Adds tests for syntactic support for generic methods.

eernstg · eernstg · commit 4dd22a87bb43 · 2016-03-11T10:27:37.000+01:00
This CL adds tests for syntactic support for declaration of type parameters on methods and named functions, and for passing actual type parameters in invocations. The status files declare all the tests to be `CompiletimeError`s (there is no support for `// AnalyzerOptions=`, so no `--options=..` can be passed to `dartanalyzer`, even though it does succeed with `--options=tests/language/X.options` where `X` is the name of the test). BUG= R=brianwilkerson@google.com, leafp@google.com, regis@google.com Review URL: https://codereview.chromium.org/1779173003 .
diff --git a/tests/language/generic_functions_test.dart b/tests/language/generic_functions_test.dart
@@ -0,0 +1,106 @@
+// Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import "package:expect/expect.dart";
+
+// Dart test verifying that the parser can handle type parameterization of
+// function declarations and function invocations. Variant of code from
+// DEP #22, adjusted to use generic top level functions.
+
+class BinaryTreeNode<K extends Comparable<K>, V> {
+  final K _key;
+  final V _value;
+  final BinaryTreeNode<K, V> _left;
+  final BinaryTreeNode<K, V> _right;
+
+  BinaryTreeNode(this._key, this._value,
+      {BinaryTreeNode<K, V> left: null, BinaryTreeNode<K, V> right: null}) :
+        _left = left, _right = right;
+
+  BinaryTreeNode<K, V> insert(K key, V value) {
+    int c = key.compareTo(_key);
+    if (c == 0) return this;
+    var _insert = (BinaryTreeNode<K, V> t, K key, V value) =>
+        insertOpt<K, V>(t, key, value);
+    BinaryTreeNode<K, V> left = _left;
+    BinaryTreeNode<K, V> right = _right;
+    if (c < 0) {
+      left = _insert(_left, key, value);
+    } else {
+      right = _insert(_right, key, value);
+    }
+    return new BinaryTreeNode<K, V>(_key, _value, left: left, right: right);
+  }
+
+  BinaryTreeNode<K, U> map<U>(U f(V x)){
+    var _map = (BinaryTreeNode<K, V> t, U f(V x)) => mapOpt<K, V, U>(t, f);
+    return new BinaryTreeNode<K, U>(
+        _key,
+        f(_value),
+        left: _map(_left, f),
+        right: _map(_right, f));
+  }
+
+  S foldPre<S>(S init, S f(V t, S s)) {
+    var _fold = (BinaryTreeNode<K, V> t, S s, S f(V t, S s)) =>
+        foldPreOpt<K, V, S>(t, s, f);
+    S s = init;
+    s = f(_value, s);
+    s = _fold(_left, s, f);
+    s = _fold(_right, s, f);
+    return s;
+  }
+}
+
+// Use fresh type variables.
+BinaryTreeNode<K2, V2> insertOpt<K2 extends Comparable<K2>, V2>(
+    BinaryTreeNode<K2, V2> t, K2 key, V2 value) {
+  return (t == null) ? new BinaryTreeNode(key, value) : t.insert(key, value);
+}
+
+// Reuse type variables [K], [V] to test shadowing.
+BinaryTreeNode<K, U> mapOpt<K extends Comparable<K>, V, U>(
+    BinaryTreeNode<K, V> t, U f(V x)) {
+  return (t == null) ? null : t.map<U>(f);
+}
+
+// Use fresh [K2], shadowing [V].
+S foldPreOpt<K2 extends Comparable<K2>, V, S>(
+    BinaryTreeNode<K2, V> t, S init, S f(V t, S s)) {
+  return (t == null) ? init : t.foldPre<S>(init, f);
+}
+
+class BinaryTree<K extends Comparable<K>, V> {
+  final BinaryTreeNode<K, V> _root;
+
+  BinaryTree._internal(this._root);
+  BinaryTree.empty() : this._internal(null);
+
+  BinaryTree<K, V> insert(K key, V value) {
+    BinaryTreeNode<K, V> root = insertOpt<K, V>(_root, key, value);
+    return new BinaryTree<K, V>._internal(root);
+  }
+
+  BinaryTree<K, U> map<U>(U f(V x)) {
+    BinaryTreeNode<K, U> root = mapOpt<K, V, U>(_root, f);
+    return new BinaryTree<K, U>._internal(root);
+  }
+
+  S foldPre<S>(S init, S f(V t, S s)) {
+    return foldPreOpt<K, V, S>(_root, init, f);
+  }
+}
+
+main() {
+  BinaryTree<num, String> sT = new BinaryTree<num, String>.empty();
+
+  sT = sT.insert(0, "");
+  sT = sT.insert(1, " ");
+  sT = sT.insert(2, "  ");
+  sT = sT.insert(3, "   ");
+
+  BinaryTree<num, num> iT = sT.map<num>((String s) => s.length);
+
+  Expect.equals(iT.foldPre<num>(0, (int i, num s) => i + s), 6);
+}
diff --git a/tests/language/generic_functions_test.options b/tests/language/generic_functions_test.options
@@ -0,0 +1,3 @@
+analyzer:
+  language:
+    enableGenericMethods: true
diff --git a/tests/language/generic_methods_test.dart b/tests/language/generic_methods_test.dart
@@ -0,0 +1,107 @@
+// Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import "package:expect/expect.dart";
+
+// Dart test verifying that the parser can handle type parameterization of
+// method declarations and method invocations. Slightly adjusted version of
+// code from DEP #22.
+
+class BinaryTreeNode<K extends Comparable<K>, V> {
+  final K _key;
+  final V _value;
+  final BinaryTreeNode<K, V> _left;
+  final BinaryTreeNode<K, V> _right;
+
+  BinaryTreeNode(this._key, this._value,
+      {BinaryTreeNode<K, V> left: null, BinaryTreeNode<K, V> right: null}) :
+          _left = left, _right = right;
+
+  // Use fresh type variables.
+  static BinaryTreeNode<K2, V2> insertOpt<K2 extends Comparable<K2>, V2>(
+      BinaryTreeNode<K2, V2> t, K2 key, V2 value) {
+    return (t == null) ? new BinaryTreeNode(key, value) : t.insert(key, value);
+  }
+
+  BinaryTreeNode<K, V> insert(K key, V value) {
+    int c = key.compareTo(_key);
+    if (c == 0) return this;
+    var _insert = (BinaryTreeNode<K, V> node, K key, V value) =>
+        insertOpt<K, V>(node, key, value);
+    BinaryTreeNode<K, V> left = _left;
+    BinaryTreeNode<K, V> right = _right;
+    if (c < 0) {
+      left = _insert(_left, key, value);
+    } else {
+      right = _insert(_right, key, value);
+    }
+    return new BinaryTreeNode<K, V>(_key, _value, left: left, right: right);
+  }
+
+  // Reuse type variables [K], [V] to test shadowing.
+  static BinaryTreeNode<K, U> mapOpt<K extends Comparable<K>, V, U>
+      (BinaryTreeNode<K, V> t, U f(V x)) {
+    return (t == null) ? null : t.map<U>(f);
+  }
+
+  BinaryTreeNode<K, U> map<U>(U f(V x)){
+    var _map = (BinaryTreeNode<K, V> t, U f(V x)) => mapOpt<K, V, U>(t, f);
+    return new BinaryTreeNode<K, U>(
+        _key,
+        f(_value),
+        left: _map(_left, f),
+        right: _map(_right, f));
+  }
+
+  // Use fresh [K2], shadowing [V].
+  static S foldPreOpt<K2 extends Comparable<K2>, V, S>(
+      BinaryTreeNode<K2, V> t, S init, S f(V t, S s)) {
+    return (t == null) ? init : t.foldPre<S>(init, f);
+  }
+
+  S foldPre<S>(S init, S f(V t, S s)) {
+    var _fold = (BinaryTreeNode<K, V> t, S s, S f(V t, S s)) =>
+        foldPreOpt<K, V, S>(t, s, f);
+    S s = init;
+    s = f(_value, s);
+    s = _fold(_left, s, f);
+    s = _fold(_right, s, f);
+    return s;
+  }
+}
+
+class BinaryTree<K extends Comparable<K>, V> {
+  final BinaryTreeNode<K, V> _root;
+
+  BinaryTree._internal(this._root);
+  BinaryTree.empty() : this._internal(null);
+
+  BinaryTree<K, V> insert(K key, V value) {
+    BinaryTreeNode<K, V> root =
+        BinaryTreeNode.insertOpt<K, V>(_root, key, value);
+    return new BinaryTree<K, V>._internal(root);
+  }
+
+  BinaryTree<K, U> map<U>(U f(V x)) {
+    BinaryTreeNode<K, U> root = BinaryTreeNode.mapOpt<K, V, U>(_root, f);
+    return new BinaryTree<K, U>._internal(root);
+  }
+
+  S foldPre<S>(S init, S f(V t, S s)) {
+    return BinaryTreeNode.foldPreOpt<K, V, S>(_root, init, f);
+  }
+}
+
+main() {
+  BinaryTree<num, String> sT = new BinaryTree<num, String>.empty();
+
+  sT = sT.insert(0, "");
+  sT = sT.insert(1, " ");
+  sT = sT.insert(2, "  ");
+  sT = sT.insert(3, "   ");
+
+  BinaryTree<num, num> iT = sT.map<num>((String s) => s.length);
+
+  Expect.equals(iT.foldPre<num>(0, (int i, num s) => i + s), 6);
+}
diff --git a/tests/language/generic_methods_test.options b/tests/language/generic_methods_test.options
@@ -0,0 +1,3 @@
+analyzer:
+  language:
+    enableGenericMethods: true
diff --git a/tests/language/generic_sends_test.dart b/tests/language/generic_sends_test.dart
@@ -0,0 +1,24 @@
+// Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// Dart test verifying that the parser can handle certain cases where
+// grammar ambiguity is resolved in favor of generic sends, not
+// relational expressions.
+
+f(arg1, [arg2]) => null;
+g<X, Y>(arg) => null;
+
+main() {
+  // Generic invocations.
+  f(g<int, String>(3));
+  f(g<int, List<String>>(3));
+  f(g<int, String>(3), 4);
+  f(g<int, List<String>>(3), 4);
+
+  // Relational expressions.
+  int a = 0, b = 1, c = 2, d = 3;
+  f(a < b, c > 3);
+  f(a < b, c >> 3);
+  f(a < b, c < d >> 3);
+}
diff --git a/tests/language/generic_sends_test.options b/tests/language/generic_sends_test.options
@@ -0,0 +1,3 @@
+analyzer:
+  language:
+    enableGenericMethods: true
diff --git a/tests/language/language.status b/tests/language/language.status
@@ -45,6 +45,11 @@ async_star_regression_2238_test: CompileTimeError, RuntimeError # drt only runti
 async_star_cancel_while_paused_test: RuntimeError
 async_star_await_pauses_test: Skip # Times out. Issue 23996
 
+# Experimental feature: Syntactic support for generic methods.
+generic_methods_test: CompiletimeError # Issue 25869
+generic_functions_test: CompiletimeError # Issue 25869
+generic_sends_test: CompiletimeError # Issue 25869
+
 [ ($compiler == none || $compiler == precompiler || $compiler == dart2app) && ($runtime == vm || $runtime == dart_precompiled || $runtime == dart_product) ]
 
 class_keyword_test/02: MissingCompileTimeError # Issue 13627
diff --git a/tests/language/language_analyzer2.status b/tests/language/language_analyzer2.status
@@ -520,3 +520,8 @@ accessor_conflict_import_test: StaticWarning # Issue 25624
 
 for_in3_test: StaticWarning, OK # Test should have warning by design.
 for_in_side_effects_test: StaticWarning, OK # Test uses custom class that does not implement Iterable in for-in.
+
+# Experimental feature: Syntactic support for generic methods.
+generic_functions_test: CompileTimeError # Issue 25868
+generic_methods_test: CompileTimeError # Issue 25868
+generic_sends_test: CompileTimeError # Issue 25868
diff --git a/tests/language/language_dart2js.status b/tests/language/language_dart2js.status
@@ -36,6 +36,11 @@ accessor_conflict_import_prefixed2_test: RuntimeError # Issue 25626
 accessor_conflict_import_prefixed_test: RuntimeError # Issue 25626
 accessor_conflict_import_test: RuntimeError # Issue 25626
 
+# Experimental feature: Syntactic support for generic methods.
+generic_functions_test: CompileTimeError # Issue 25835
+generic_methods_test: CompileTimeError # Issue 25835
+generic_sends_test: CompileTimeError # Issue 25835
+
 [ $compiler == dart2js && $runtime == jsshell ]
 await_for_test: Skip # Jsshell does not provide periodic timers, Issue 7728
 async_star_test: RuntimeError # Jsshell does not provide non-zero timers, Issue 7728

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+analyzer:`
	`2`	`+ language:`
	`3`	`+ enableGenericMethods: true`