Migrate language_2/call to NNBD.

Change-Id: I3356296e72dfa07b0ac994da0ce96f766b182e80
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/137722
Commit-Queue: Bob Nystrom <[email protected]>
Auto-Submit: Bob Nystrom <[email protected]>
Reviewed-by: Leaf Petersen <[email protected]>

Author: munificent

tests/language/call/argument_inference_test.dart

@@ -0,0 +1,14 @@
+// Copyright (c) 2013, 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";
+
+class A {
+  call(a) => a is num;
+}
+
+main() {
+  Expect.isTrue(new A().call(42));
+  Expect.isFalse(new A()('foo'));
+}

tests/language/call/call_test.dart

@@ -0,0 +1,43 @@
+// Copyright (c) 2012, 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.
+// VMOptions=--optimization_counter_threshold=10 --no-background_compilation
+
+import "package:expect/expect.dart";
+
+main() {
+  bar(a) {
+    return a is String;
+  }
+
+  for (var i = 0; i < 20; i++) {
+    Expect.isFalse(bar(1));
+    Expect.isTrue(bar.call('foo'));
+  }
+
+  opt_arg([a = "a"]) => a is String;
+
+  for (var i = 0; i < 20; i++) {
+    Expect.isFalse(opt_arg(1));
+    Expect.isFalse(opt_arg.call(1));
+    Expect.isTrue(opt_arg());
+    Expect.isTrue(opt_arg.call());
+    Expect.isTrue(opt_arg("b"));
+    Expect.isTrue(opt_arg.call("b"));
+  }
+
+  named_arg({x: 11, y: 22}) => "$x$y";
+
+  for (var i = 0; i < 20; i++) {
+    Expect.equals("1122", named_arg());
+    Expect.equals("1122", named_arg.call());
+    Expect.equals("4455", named_arg(y: 55, x: 44));
+    Expect.equals("4455", named_arg.call(y: 55, x: 44));
+    Expect.equals("4455", named_arg(x: 44, y: 55));
+    Expect.equals("4455", named_arg.call(x: 44, y: 55));
+  }
+
+  Expect.throwsNoSuchMethodError(() => (bar as dynamic).call());
+  Expect.throwsNoSuchMethodError(() => (opt_arg as dynamic).call(x: "p"));
+  Expect.throwsNoSuchMethodError(() => (named_arg as dynamic).call("p", "q"));
+}

tests/language/call/closurization_test.dart

@@ -0,0 +1,54 @@
+// Copyright (c) 2014, 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.
+// VMOptions=--optimization_counter_threshold=10 --no-background_compilation
+
+import "package:expect/expect.dart";
+
+main() {
+  bar(a) {
+    return a is String;
+  }
+
+  var bar_tearOff = bar.call;
+
+  for (var i = 0; i < 20; i++) {
+    Expect.isFalse(bar_tearOff(1));
+    Expect.isTrue(bar_tearOff.call('foo'));
+    Expect.isFalse(bar_tearOff.call(1));
+    Expect.isTrue(bar_tearOff('foo'));
+  }
+
+  opt_arg([a = "a"]) => a is String;
+  var opt_arg_tearOff = opt_arg.call;
+
+  for (var i = 0; i < 20; i++) {
+    Expect.isFalse(opt_arg_tearOff(1));
+    Expect.isFalse(opt_arg_tearOff.call(1));
+    Expect.isTrue(opt_arg_tearOff());
+    Expect.isTrue(opt_arg_tearOff.call());
+    Expect.isTrue(opt_arg_tearOff("b"));
+    Expect.isTrue(opt_arg_tearOff.call("b"));
+  }
+
+  named_arg({x: 11, y: 22}) => "$x$y";
+  var named_arg_tearOff = named_arg.call;
+
+  for (var i = 0; i < 20; i++) {
+    Expect.equals("1122", named_arg_tearOff());
+    Expect.equals("1122", named_arg_tearOff.call());
+    Expect.equals("4455", named_arg_tearOff(y: 55, x: 44));
+    Expect.equals("4455", named_arg_tearOff.call(y: 55, x: 44));
+    Expect.equals("4455", named_arg_tearOff(x: 44, y: 55));
+    Expect.equals("4455", named_arg_tearOff.call(x: 44, y: 55));
+  }
+
+  // In order to test runtime behavior of calling with invalid arguments,
+  // we cast to dynamic to make the type system forget about the actual types.
+  dynamic bar_tearOff_d = bar_tearOff;
+  dynamic opt_arg_tearOff_d = opt_arg_tearOff;
+  dynamic named_arg_tearOff_d = named_arg_tearOff;
+  Expect.throws(() => bar_tearOff_d.call());
+  Expect.throwsNoSuchMethodError(() => opt_arg_tearOff_d.call(x: "p"));
+  Expect.throwsNoSuchMethodError(() => named_arg_tearOff_d.call("p", "q"));
+}

tests/language/call/constructor_on_unresolvable_class_runtime_test.dart

@@ -0,0 +1,18 @@
+// TODO(multitest): This was automatically migrated from a multitest and may
+// contain strange or dead code.
+
+// Copyright (c) 2012, 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.
+
+// Check that calling a constructor of a class that cannot be resolved causes
+// compile error.
+
+import "package:expect/expect.dart";
+import 'dart:math';
+
+main() {
+
+
+
+}

tests/language/call/constructor_on_unresolvable_class_test.dart

@@ -0,0 +1,24 @@
+// Copyright (c) 2012, 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.
+
+// Check that calling a constructor of a class that cannot be resolved causes
+// compile error.
+
+import "package:expect/expect.dart";
+import 'dart:math';
+
+main() {
+  new A();
+  //  ^
+  // [analyzer] COMPILE_TIME_ERROR.UNDEFINED_CLASS
+  // [cfe] Method not found: 'A'.
+  new A.foo();
+  //  ^^^^^
+  // [analyzer] COMPILE_TIME_ERROR.UNDEFINED_CLASS
+  // [cfe] Method not found: 'A.foo'.
+  new lib.A();
+  //  ^^^^^
+  // [analyzer] COMPILE_TIME_ERROR.UNDEFINED_CLASS
+  // [cfe] Method not found: 'lib.A'.
+}

tests/language/call/function2_test.dart

@@ -0,0 +1,28 @@
+// 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";
+
+typedef Object Func(Object x);
+
+class Bar {
+  int x = 42;
+
+  Object call(Object x) {
+    return 'Bar $x';
+  }
+}
+
+Object baz(Object x) => x;
+
+var map = <String, Func>{'baz': baz, 'bar': new Bar()};
+
+Object test(String str, Object arg) {
+  return map[str]!.call(arg);
+}
+
+void main() {
+  Expect.equals(42, test('baz', 42));
+  Expect.equals('Bar 42', test('bar', 42));
+}

tests/language/call/function_apply_test.dart

@@ -0,0 +1,15 @@
+// Copyright (c) 2015, 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";
+
+class A {
+  call({a: 42}) {
+    return 499 + a;
+  }
+}
+
+main() {
+  Expect.equals(497, Function.apply(new A(), [], {#a: -2}));
+}

tests/language/call/function_test.dart

@@ -0,0 +1,49 @@
+// Copyright (c) 2015, 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";
+
+Object bar(Object x) {
+  return x;
+}
+
+Function baz = bar;
+
+dynamic dyn = bar;
+
+class Foo {
+  Object call(Object x) {
+    return 'Foo$x';
+  }
+}
+
+typedef Object FooType(Object x);
+FooType foo = bar;
+
+void main() {
+  Expect.equals(42, bar.call(42));
+  Expect.equals(42, baz.call(42));
+  Expect.equals(42, foo.call(42));
+  Expect.equals(42, dyn.call(42));
+  Expect.equals(42, bar(42));
+  Expect.equals(42, baz(42));
+  Expect.equals(42, foo(42));
+  Expect.equals(42, dyn(42));
+
+  baz = new Foo();
+  foo = new Foo();
+  dyn = new Foo();
+  Expect.equals('Foo42', baz.call(42));
+  Expect.equals('Foo42', foo.call(42));
+  Expect.equals('Foo42', dyn.call(42));
+  Expect.equals('Foo42', baz(42));
+  Expect.equals('Foo42', foo(42));
+  Expect.equals('Foo42', dyn(42));
+
+  var s = (FooType).toString();
+  var minified = s != 'FooType'; // dart2js --minify has minified names.
+  dynamic d = null;
+  Expect.throws(() => d(),
+      (e) => e is NoSuchMethodError && (minified || '$e'.contains('call')));
+}

tests/language/call/method_as_cast_test.dart

@@ -0,0 +1,35 @@
+// Copyright (c) 2018, 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 program to test arithmetic operations.
+
+import "package:expect/expect.dart";
+
+class B {}
+
+class C {
+  B call(B b) => b;
+}
+
+class D implements Function {
+  B call(B b) => b;
+}
+
+typedef B BToB(B x);
+
+typedef Object NullToObject(Null x);
+
+main() {
+  // The presence of a `.call` method does not cause class `C` to become a
+  // subtype of any function type.
+  C c = new C();
+  Expect.throwsCastError(() => c as BToB); //# 01: ok
+  Expect.throwsCastError(() => c as NullToObject); //# 02: ok
+  Expect.throwsCastError(() => c as Function); //# 03: ok
+
+  // The same goes for class `D`: `implements Function` is ignored in Dart 2.
+  D d = new D();
+  Expect.throwsCastError(() => d as BToB); //# 04: ok
+  Expect.throwsCastError(() => d as NullToObject); //# 05: ok
+  Expect.throwsCastError(() => d as Function); //# 06: ok
+}

tests/language/call/method_function_typed_value_test.dart

@@ -0,0 +1,27 @@
+// Copyright (c) 2018, 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 program to test arithmetic operations.
+
+import "package:expect/expect.dart";
+
+int f(int i) => 2 * i;
+
+typedef int IntToInt(int x);
+
+main() {
+  // It is possible to use `.call` on a function-typed value (even though it is
+  // redundant).  Similarly, it is possible to tear off `.call` on a
+  // function-typed value (but it is a no-op).
+  Expect.equals(f.call(1), 2); //# 01: ok
+  Expect.identical(f.call, f); //# 02: ok
+  IntToInt f2 = f;
+  Expect.equals(f2.call(1), 2); //# 03: ok
+  Expect.identical(f2.call, f); //# 04: ok
+  Function f3 = f;
+  Expect.equals(f3.call(1), 2); //# 05: ok
+  Expect.identical(f3.call, f); //# 06: ok
+  dynamic d = f;
+  Expect.equals(d.call(1), 2); //# 07: ok
+  Expect.identical(d.call, f); //# 08: ok
+}