Support Kernel Instantiation node in VMs constant evaluator

Fixes #32268.

Bug: 32268
Change-Id: I7d2ebc28d19aca623460cd1dacc86b64893810ac
Reviewed-on: https://dart-review.googlesource.com/42949
Commit-Queue: Jens Johansen <[email protected]>
Reviewed-by: Lasse R.H. Nielsen <[email protected]>
Reviewed-by: Vyacheslav Egorov <[email protected]>

Author: jensjoha

runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc

@@ -2777,6 +2777,9 @@ Instance& StreamingConstantEvaluator::EvaluateExpression(intptr_t offset,
       case kLet:
         EvaluateLet();
         break;
+      case kInstantiation:
+        EvaluatePartialTearoffInstantiation();
+        break;
       case kBigIntLiteral:
         EvaluateBigIntLiteral();
         break;
@@ -3394,6 +3397,41 @@ void StreamingConstantEvaluator::EvaluateLet() {
   EvaluateExpression(builder_->ReaderOffset(), false);  // read body
 }
 
+void StreamingConstantEvaluator::EvaluatePartialTearoffInstantiation() {
+  // This method call wasn't cached, so receiver et al. isn't cached either.
+  const Instance& receiver =
+      EvaluateExpression(builder_->ReaderOffset(), false);  // read receiver.
+  if (!receiver.IsClosure()) {
+    H.ReportError(script_, TokenPosition::kNoSource, "Expected closure.");
+  }
+  const Closure& old_closure = Closure::Cast(receiver);
+
+  // read type arguments.
+  intptr_t num_type_args = builder_->ReadListLength();
+  const TypeArguments* type_args = &T.BuildTypeArguments(num_type_args);
+  // Even if all dynamic types are passed in, we need to put a vector in here to
+  // distinguish this partially applied tearoff from a normal tearoff. This is
+  // necessary because the tearoff wrapper (BuildGraphOfImplicitClosureFunction)
+  // needs to throw NSM if type arguments are passed to a partially applied
+  // tearoff.
+  if (type_args->IsNull()) {
+    type_args =
+        &TypeArguments::ZoneHandle(Z, TypeArguments::New(num_type_args));
+    for (intptr_t i = 0; i < num_type_args; ++i) {
+      type_args->SetTypeAt(i, Type::ZoneHandle(Z, Type::DynamicType()));
+    }
+  }
+
+  // Create new closure with the type arguments inserted, and other things
+  // copied over.
+  Closure& new_closure = Closure::Handle(
+      Z, Closure::New(TypeArguments::Handle(
+                          Z, old_closure.instantiator_type_arguments()),
+                      *type_args, Function::Handle(Z, old_closure.function()),
+                      Context::Handle(Z, old_closure.context()), Heap::kOld));
+  result_ = H.Canonicalize(new_closure);
+}
+
 void StreamingConstantEvaluator::EvaluateBigIntLiteral() {
   const String& value =
       H.DartString(builder_->ReadStringReference());  // read string reference.

runtime/vm/compiler/frontend/kernel_binary_flowgraph.h

@@ -872,6 +872,7 @@ class StreamingConstantEvaluator {
   void EvaluateListLiteralInternal();
   void EvaluateMapLiteralInternal();
   void EvaluateLet();
+  void EvaluatePartialTearoffInstantiation();
   void EvaluateBigIntLiteral();
   void EvaluateStringLiteral();
   void EvaluateIntLiteral(uint8_t payload);

tests/language_2/language_2_dart2js.status

@@ -980,6 +980,13 @@ mixin_type_parameter_inference_test/12: CompileTimeError
 mixin_type_parameter_inference_test/13: CompileTimeError
 mixin_type_parameter_inference_test/16: CompileTimeError
 mixin_type_parameter_inference_test/none: CompileTimeError
+partial_tearoff_instantiation_test/02: CompileTimeError
+partial_tearoff_instantiation_test/04: CompileTimeError
+partial_tearoff_instantiation_test/05: Pass # for the wrong reason.
+partial_tearoff_instantiation_test/06: Pass # for the wrong reason.
+partial_tearoff_instantiation_test/07: Pass # for the wrong reason.
+partial_tearoff_instantiation_test/08: Pass # for the wrong reason.
+partial_tearoff_instantiation_test/none: CompileTimeError
 
 [ $compiler == dart2js && $dart2js_with_kernel && $fast_startup && $strong ]
 assertion_initializer_const_error2_test/none: CompileTimeError
@@ -3566,6 +3573,14 @@ override_inheritance_no_such_method_test/12: MissingCompileTimeError
 override_inheritance_no_such_method_test/13: MissingCompileTimeError
 override_method_with_field_test/02: MissingCompileTimeError
 part2_test/01: MissingCompileTimeError
+partial_tearoff_instantiation_test/01: MissingCompileTimeError
+partial_tearoff_instantiation_test/02: MissingRuntimeError
+partial_tearoff_instantiation_test/03: MissingCompileTimeError
+partial_tearoff_instantiation_test/04: MissingRuntimeError
+partial_tearoff_instantiation_test/05: MissingCompileTimeError
+partial_tearoff_instantiation_test/06: MissingCompileTimeError
+partial_tearoff_instantiation_test/07: MissingCompileTimeError
+partial_tearoff_instantiation_test/08: MissingCompileTimeError
 positional_parameters_type_test/01: MissingCompileTimeError
 positional_parameters_type_test/02: MissingCompileTimeError
 prefix16_test/00: MissingCompileTimeError

tests/language_2/language_2_kernel.status

@@ -215,6 +215,10 @@ override_inheritance_no_such_method_test/09: MissingCompileTimeError
 override_inheritance_no_such_method_test/10: MissingCompileTimeError
 override_inheritance_no_such_method_test/12: MissingCompileTimeError
 override_inheritance_no_such_method_test/13: MissingCompileTimeError
+partial_tearoff_instantiation_test/05: MissingCompileTimeError
+partial_tearoff_instantiation_test/06: MissingCompileTimeError
+partial_tearoff_instantiation_test/07: MissingCompileTimeError
+partial_tearoff_instantiation_test/08: MissingCompileTimeError
 redirecting_factory_default_values_test/01: MissingCompileTimeError # Fasta bug: Default values are not allowed on redirecting factory constructors.
 redirecting_factory_default_values_test/02: MissingCompileTimeError # Fasta bug: Default values are not allowed on redirecting factory constructors.
 regress_22976_test/*: CompileTimeError # Issue 31935

tests/language_2/language_2_vm.status

@@ -1341,4 +1341,4 @@ invalid_type_argument_count_test/01: MissingCompileTimeError # Error only in str
 invalid_type_argument_count_test/02: MissingCompileTimeError # Error only in strong mode
 invalid_type_argument_count_test/03: MissingCompileTimeError # Error only in strong mode
 invalid_type_argument_count_test/04: MissingCompileTimeError # Error only in strong mode
-
+partial_tearoff_instantiation_test/none: CompiletimeError

tests/language_2/partial_tearoff_instantiation_test.dart

@@ -0,0 +1,116 @@
+// 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.
+
+import "package:expect/expect.dart";
+
+typedef F1 = void Function<T>(T);
+typedef void F2<T>(T v);
+
+dynamic defaultFLatest;
+
+void defaultF<T>(T v) {
+  defaultFLatest = v;
+}
+
+class X1 {
+  final F1 f;
+  const X1({this.f: defaultF});
+}
+
+class X2 {
+  final F2 f;
+  const X2({this.f: defaultF});
+}
+
+class Y1 {
+  F1 f;
+}
+
+class Y2 {
+  F2 f;
+}
+
+dynamic foo() {
+  if (defaultFLatest == -1) return -1;
+  return "not -1";
+}
+
+void main() {
+  {
+    var x = const X1();
+
+    // OK with implicit dynamic type argument.
+    x.f("hello1");
+    Expect.equals("hello1", defaultFLatest);
+
+    // OK with explicit dynamic type argument.
+    x.f<dynamic>("hello2");
+    Expect.equals("hello2", defaultFLatest);
+
+    // OK with correctly given argument type.
+    x.f<String>("hello3");
+    Expect.equals("hello3", defaultFLatest);
+
+    // OK with correctly given argument type.
+    x.f<int>(42);
+    Expect.equals(42, defaultFLatest);
+
+    // Not OK with incorrectly given argument type.
+    x.f<int>("hello"); //# 01: compile-time error
+
+    // Not OK with incorrectly given argument type.
+    x.f<int>(foo()); //# 02: runtime error
+
+    var y = new Y1();
+    y.f = defaultF;
+
+    // OK with implicit dynamic type argument.
+    y.f("hello4");
+    Expect.equals("hello4", defaultFLatest);
+
+    // OK with explicit dynamic type argument.
+    y.f<dynamic>("hello5");
+    Expect.equals("hello5", defaultFLatest);
+
+    // OK with correctly given argument type.
+    y.f<String>("hello6");
+    Expect.equals("hello6", defaultFLatest);
+
+    // OK with correctly given argument type.
+    y.f<int>(43);
+    Expect.equals(43, defaultFLatest);
+
+    // Not OK with incorrectly given argument type.
+    y.f<int>("hello"); //# 03: compile-time error
+
+    // Not OK with incorrectly given argument type.
+    y.f<int>(foo()); //# 04: runtime error
+  }
+  {
+    var x = const X2();
+
+    // OK with no type arguments.
+    x.f("hello1");
+    Expect.equals("hello1", defaultFLatest);
+
+    // Not OK with a type argument.
+    x.f<dynamic>("hello2"); //# 05: compile-time error
+
+    // Not OK with a type argument.
+    x.f<String>("hello3"); //# 06: compile-time error
+
+    var y = new Y2();
+    y.f = defaultF;
+
+    // OK with no type argument.
+    y.f("hello4");
+    Expect.equals("hello4", defaultFLatest);
+
+    // Not OK with a type argument.
+    y.f<dynamic>("hello5"); //# 07: compile-time error
+
+    // Not OK with a type argument.
+    y.f<String>("hello6"); //# 08: compile-time error
+  }
+}