[dart2js] new-rti: signatures for tear-offs with dependent types

rakudrama · commit-bot@chromium.org · commit f7a300fc69e2 · 2019-08-08T23:08:42.000Z
Change-Id: I0fd4e1b081500fe9a44897b1489cdd2b6680f409 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/112440 Reviewed-by: Mayank Patke <fishythefish@google.com> Commit-Queue: Stephen Adams <sra@google.com>
diff --git a/pkg/compiler/lib/src/js_emitter/program_builder/program_builder.dart b/pkg/compiler/lib/src/js_emitter/program_builder/program_builder.dart
@@ -31,6 +31,8 @@ import '../../js_backend/runtime_types.dart'
 import '../../js_backend/runtime_types_new.dart' show RecipeEncoder;
 import '../../js_backend/runtime_types_resolution.dart' show RuntimeTypesNeed;
 import '../../js_model/elements.dart' show JGeneratorBody, JSignatureMethod;
+import '../../js_model/type_recipe.dart'
+    show FullTypeEnvironmentStructure, TypeExpressionRecipe;
 import '../../native/enqueue.dart' show NativeCodegenEnqueuer;
 import '../../options.dart';
 import '../../universe/codegen_world_builder.dart';
@@ -926,7 +928,8 @@ class ProgramBuilder {
     js.Expression functionType;
     if (canTearOff) {
       OutputUnit outputUnit = _outputUnitData.outputUnitForMember(element);
-      functionType = _generateFunctionType(memberType, outputUnit);
+      functionType =
+          _generateFunctionType(element.enclosingClass, memberType, outputUnit);
     }
 
     FunctionEntity method = element;
@@ -955,12 +958,22 @@ class ProgramBuilder {
         applyIndex: applyIndex);
   }
 
-  js.Expression _generateFunctionType(
+  js.Expression _generateFunctionType(ClassEntity /*?*/ enclosingClass,
       FunctionType type, OutputUnit outputUnit) {
     if (type.containsTypeVariables) {
-      js.Expression thisAccess = js.js(r'this.$receiver');
-      return _rtiEncoder.getSignatureEncoding(
-          _namer, _task.emitter, type, thisAccess);
+      if (_options.experimentNewRti) {
+        // TODO(sra): The recipe might reference class type variables. Collect
+        // these for the type metadata.
+        return _rtiRecipeEncoder.encodeRecipe(
+            _task.emitter,
+            FullTypeEnvironmentStructure(
+                classType: _elementEnvironment.getThisType(enclosingClass)),
+            TypeExpressionRecipe(type));
+      } else {
+        js.Expression thisAccess = js.js(r'this.$receiver');
+        return _rtiEncoder.getSignatureEncoding(
+            _namer, _task.emitter, type, thisAccess);
+      }
     } else {
       return _task.metadataCollector.reifyType(type, outputUnit);
     }
@@ -1180,7 +1193,7 @@ class ProgramBuilder {
     DartType type = _elementEnvironment.getFunctionType(element);
     if (needsTearOff) {
       OutputUnit outputUnit = _outputUnitData.outputUnitForMember(element);
-      functionType = _generateFunctionType(type, outputUnit);
+      functionType = _generateFunctionType(null, type, outputUnit);
     }
 
     FunctionEntity method = element;
diff --git a/sdk/lib/_internal/js_runtime/lib/js_helper.dart b/sdk/lib/_internal/js_runtime/lib/js_helper.dart
@@ -60,7 +60,11 @@ import 'dart:_js_names'
         unmangleAllIdentifiersIfPreservedAnyways;
 
 import 'dart:_rti' as newRti
-    show createRuntimeType, getRuntimeType, getTypeFromTypesTable;
+    show
+        createRuntimeType,
+        evalInInstance,
+        getRuntimeType,
+        getTypeFromTypesTable;
 
 part 'annotations.dart';
 part 'constant_map.dart';
@@ -2039,8 +2043,12 @@ abstract class Closure implements Function {
       // The functions are called here to model the calls from JS forms below.
       // The types in the JS forms in the arguments are propagated in type
       // inference.
-      BoundClosure.receiverOf(JS('BoundClosure', '0'));
-      BoundClosure.selfOf(JS('BoundClosure', '0'));
+      var aBoundClosure = JS('BoundClosure', '0');
+      var aString = JS('String', '0');
+      BoundClosure.receiverOf(aBoundClosure);
+      BoundClosure.selfOf(aBoundClosure);
+      BoundClosure.evalRecipeIntercepted(aBoundClosure, aString);
+      BoundClosure.evalRecipe(aBoundClosure, aString);
       getType(JS('int', '0'));
     });
     // TODO(ahe): All the place below using \$ should be rewritten to go
@@ -2119,7 +2127,41 @@ abstract class Closure implements Function {
           propertyName);
     }
 
-    var signatureFunction;
+    var signatureFunction = JS_GET_FLAG('USE_NEW_RTI')
+        ? _computeSignatureFunctionNewRti(functionType, isStatic, isIntercepted)
+        : _computeSignatureFunctionLegacy(
+            functionType, isStatic, isIntercepted);
+
+    JS('', '#[#] = #', prototype, JS_GET_NAME(JsGetName.SIGNATURE_NAME),
+        signatureFunction);
+    var applyTrampoline = trampoline;
+    JS('', '#[#] = #', prototype, callName, trampoline);
+    for (int i = 1; i < functions.length; i++) {
+      var stub = functions[i];
+      var stubCallName = JS('String|Null', '#[#]', stub,
+          JS_GET_NAME(JsGetName.CALL_NAME_PROPERTY));
+      if (stubCallName != null) {
+        stub = isStatic ? stub : forwardCallTo(receiver, stub, isIntercepted);
+        JS('', '#[#] = #', prototype, stubCallName, stub);
+      }
+      if (i == applyTrampolineIndex) {
+        applyTrampoline = stub;
+        JS('', '#.\$reflectionInfo = #', applyTrampoline, reflectionInfo);
+      }
+    }
+
+    JS('', '#[#] = #', prototype, JS_GET_NAME(JsGetName.CALL_CATCH_ALL),
+        applyTrampoline);
+    String reqArgProperty = JS_GET_NAME(JsGetName.REQUIRED_PARAMETER_PROPERTY);
+    String defValProperty = JS_GET_NAME(JsGetName.DEFAULT_VALUES_PROPERTY);
+    JS('', '#.# = #.#', prototype, reqArgProperty, function, reqArgProperty);
+    JS('', '#.# = #.#', prototype, defValProperty, function, defValProperty);
+
+    return constructor;
+  }
+
+  static _computeSignatureFunctionLegacy(
+      Object functionType, bool isStatic, bool isIntercepted) {
     if (JS('bool', 'typeof # == "number"', functionType)) {
       // We cannot call [getType] here, since the types-metadata might not be
       // set yet. This is, because fromTearOff might be called for constants
@@ -2128,23 +2170,22 @@ abstract class Closure implements Function {
       // Note that we cannot just textually inline the call
       // `getType(functionType)` since we cannot guarantee that the (then)
       // captured variable `functionType` isn't reused.
-      signatureFunction = JS(
+      return JS(
           '',
           '''(function(getType, t) {
                     return function(){ return getType(t); };
                 })(#, #)''',
-          JS_GET_FLAG('USE_NEW_RTI')
-              ? RAW_DART_FUNCTION_REF(newRti.getTypeFromTypesTable)
-              : RAW_DART_FUNCTION_REF(getType),
+          RAW_DART_FUNCTION_REF(getType),
           functionType);
-    } else if (JS('bool', 'typeof # == "function"', functionType)) {
+    }
+    if (JS('bool', 'typeof # == "function"', functionType)) {
       if (isStatic) {
-        signatureFunction = functionType;
+        return functionType;
       } else {
         var getReceiver = isIntercepted
             ? RAW_DART_FUNCTION_REF(BoundClosure.receiverOf)
             : RAW_DART_FUNCTION_REF(BoundClosure.selfOf);
-        signatureFunction = JS(
+        return JS(
             '',
             'function(f,r){'
                 'return function(){'
@@ -2154,36 +2195,46 @@ abstract class Closure implements Function {
             functionType,
             getReceiver);
       }
-    } else {
-      throw 'Error in reflectionInfo.';
     }
+    throw 'Error in functionType of tearoff';
+  }
 
-    JS('', '#[#] = #', prototype, JS_GET_NAME(JsGetName.SIGNATURE_NAME),
-        signatureFunction);
-    var applyTrampoline = trampoline;
-    JS('', '#[#] = #', prototype, callName, trampoline);
-    for (int i = 1; i < functions.length; i++) {
-      var stub = functions[i];
-      var stubCallName = JS('String|Null', '#[#]', stub,
-          JS_GET_NAME(JsGetName.CALL_NAME_PROPERTY));
-      if (stubCallName != null) {
-        stub = isStatic ? stub : forwardCallTo(receiver, stub, isIntercepted);
-        JS('', '#[#] = #', prototype, stubCallName, stub);
-      }
-      if (i == applyTrampolineIndex) {
-        applyTrampoline = stub;
-        JS('', '#.\$reflectionInfo = #', applyTrampoline, reflectionInfo);
+  static _computeSignatureFunctionNewRti(
+      Object functionType, bool isStatic, bool isIntercepted) {
+    if (JS('bool', 'typeof # == "number"', functionType)) {
+      // Index into types table.
+      //
+      // We cannot call [getTypeFromTypesTable] here, since the types-metadata
+      // might not be set yet. This is, because fromTearOff might be called for
+      // constants when the program isn't completely set up yet. We also want to
+      // avoid creating lots of types at startup.
+      return JS(
+          '',
+          '''(function(getType, t) {
+                 return function(){ return getType(t); };
+             })(#, #)''',
+          RAW_DART_FUNCTION_REF(newRti.getTypeFromTypesTable),
+          functionType);
+    }
+    if (JS('bool', 'typeof # == "string"', functionType)) {
+      // A recipe to evaluate against the instance type.
+      if (isStatic) {
+        throw 'TODO: Recipe for static tearoff.';
       }
+      var typeEvalMethod = isIntercepted
+          ? RAW_DART_FUNCTION_REF(BoundClosure.evalRecipeIntercepted)
+          : RAW_DART_FUNCTION_REF(BoundClosure.evalRecipe);
+      return JS(
+          '',
+          '    function(recipe, evalOnReceiver) {'
+              '  return function() {'
+              '    return evalOnReceiver(this, recipe);'
+              '  };'
+              '}(#,#)',
+          functionType,
+          typeEvalMethod);
     }
-
-    JS('', '#[#] = #', prototype, JS_GET_NAME(JsGetName.CALL_CATCH_ALL),
-        applyTrampoline);
-    String reqArgProperty = JS_GET_NAME(JsGetName.REQUIRED_PARAMETER_PROPERTY);
-    String defValProperty = JS_GET_NAME(JsGetName.DEFAULT_VALUES_PROPERTY);
-    JS('', '#.# = #.#', prototype, reqArgProperty, function, reqArgProperty);
-    JS('', '#.# = #.#', prototype, defValProperty, function, defValProperty);
-
-    return constructor;
+    throw 'Error in functionType of tearoff';
   }
 
   static cspForwardCall(
@@ -2531,6 +2582,14 @@ class BoundClosure extends TearOffClosure {
         "${Primitives.objectToHumanReadableString(receiver)}";
   }
 
+  static evalRecipe(BoundClosure closure, String recipe) {
+    return newRti.evalInInstance(closure._self, recipe);
+  }
+
+  static evalRecipeIntercepted(BoundClosure closure, String recipe) {
+    return newRti.evalInInstance(closure._receiver, recipe);
+  }
+
   @pragma('dart2js:noInline')
   static selfOf(BoundClosure closure) => closure._self;
 
diff --git a/sdk/lib/_internal/js_runtime/lib/rti.dart b/sdk/lib/_internal/js_runtime/lib/rti.dart
@@ -341,6 +341,11 @@ Rti findType(String recipe) {
   return _Universe.eval(_theUniverse(), recipe);
 }
 
+/// Evaluate a type recipe in the environment of an instance.
+Rti evalInInstance(instance, String recipe) {
+  return _rtiEval(instanceType(instance), recipe);
+}
+
 /// Returns the Rti type of [object]. Closures have both an interface type
 /// (Closures implement `Function`) and a structural function type. Uses
 /// [testRti] to choose the appropriate type.
