Add SSA instructions for reified type information

pkg/compiler/lib/src/ssa/builder.dart

 // 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.
 
 import 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 2309 matching lines @@
       // if there are field initializers.
       add(new HFieldGet(null, newObject, backend.dynamicType,
           isAssignable: false));
       for (int i = 0; i < fields.length; i++) {
         add(new HFieldSet(fields[i], newObject, constructorArguments[i]));
       }
     }
     removeInlinedInstantiation(type);
     // Create the runtime type information, if needed.
     if (backend.classNeedsRti(classElement)) {
-      // Read the values of the type arguments and create a list to set on the
-      // newly create object.  We can identify the case where the new list
-      // would be of the form:
+      // Read the values of the type arguments and create a HTypeInfoExpression
+      // to set on the newly create object.  We can identify the case where the
+      // expression would be of the form:
+      //
       //  [getTypeArgumentByIndex(this, 0), .., getTypeArgumentByIndex(this, k)]
+      //
       // and k is the number of type arguments of this.  If this is the case,
       // we can simply copy the list from this.
 
       // These locals are modified by [isIndexedTypeArgumentGet].
       HThis source; // The source of the type arguments.
       bool allIndexed = true;
       int expectedIndex = 0;
       ClassElement contextClass; // The class of `this`.
       int remainingTypeVariables; // The number of 'remaining type variables'
       // of `this`.
 
       /// Helper to identify instructions that read a type variable without
-      /// substitution (that is, directly use the index). These instructions
-      /// are of the form:
-      ///   HInvokeStatic(getTypeArgumentByIndex, this, index)
+      /// substitution (that is, directly use the index). These are
+      /// HTypeInfoReadVariable instructions that require no substitution.
       ///
       /// Return `true` if [instruction] is of that form and the index is the
       /// next index in the sequence (held in [expectedIndex]).
+
+      /// TODO: Move this to a simplifier optimization of HTypeInfoExpression.
       bool isIndexedTypeArgumentGet(HInstruction instruction) {
-        if (instruction is! HInvokeStatic) return false;
-        HInvokeStatic invoke = instruction;
-        if (invoke.element != helpers.getTypeArgumentByIndex) {
-          return false;
+        if (instruction is HTypeInfoReadVariable) {
+          HInstruction newSource = instruction.inputs[0];
+          if (newSource is! HThis) {
+            return false;
+          }
+          if (source == null) {
+            // This is the first match. Extract the context class for the type
+            // variables and get the list of type variables to keep track of how
+            // many arguments we need to process.
+            source = newSource;
+            contextClass = source.sourceElement.enclosingClass;
+            if (needsSubstitutionForTypeVariableAccess(contextClass)) {
+              return false;
+            }
+            remainingTypeVariables = contextClass.typeVariables.length;
+          } else {
+            assert(source == newSource);
+          }
+          // If there are no more type variables, then there are more type
+          // arguments for the new object than the source has, and it can't be
+          // a copy.  Otherwise remove one argument.
+          if (remainingTypeVariables == 0) return false;
+          remainingTypeVariables--;
+          // Check that the index is the one we expect.
+          int index = instruction.variable.element.index;
+          return index == expectedIndex++;
         }
-        HConstant index = invoke.inputs[1];
-        HInstruction newSource = invoke.inputs[0];
-        if (newSource is! HThis) {
-          return false;
-        }
-        if (source == null) {
-          // This is the first match. Extract the context class for the type
-          // variables and get the list of type variables to keep track of how
-          // many arguments we need to process.
-          source = newSource;
-          contextClass = source.sourceElement.enclosingClass;
-          remainingTypeVariables = contextClass.typeVariables.length;
-        } else {
-          assert(source == newSource);
-        }
-        // If there are no more type variables, then there are more type
-        // arguments for the new object than the source has, and it can't be
-        // a copy.  Otherwise remove one argument.
-        if (remainingTypeVariables == 0) return false;
-        remainingTypeVariables--;
-        // Check that the index is the one we expect.
-        IntConstantValue constant = index.constant;
-        return constant.primitiveValue == expectedIndex++;
+        return false;
       }
 
       List<HInstruction> typeArguments = <HInstruction>[];
       classElement.typeVariables.forEach((TypeVariableType typeVariable) {
         HInstruction argument = localsHandler
             .readLocal(localsHandler.getTypeVariableAsLocal(typeVariable));
         if (allIndexed && !isIndexedTypeArgumentGet(argument)) {
           allIndexed = false;
         }
         typeArguments.add(argument);
       });
 
       if (source != null && allIndexed && remainingTypeVariables == 0) {
-        copyRuntimeTypeInfo(source, newObject);
+        HInstruction typeInfo =
+            new HTypeInfoReadRaw(source, backend.dynamicType);
+        add(typeInfo);
+        newObject = callSetRuntimeTypeInfo(typeInfo, newObject);
       } else {
-        newObject =
-            callSetRuntimeTypeInfo(classElement, typeArguments, newObject);
+        HInstruction typeInfo = new HTypeInfoExpression(
+            TypeInfoExpressionKind.INSTANCE,
+            classElement.thisType,
+            typeArguments,
+            backend.dynamicType);
+        add(typeInfo);
+        newObject = callSetRuntimeTypeInfo(typeInfo, newObject);
       }
     }
 
     // Generate calls to the constructor bodies.
     HInstruction interceptor = null;
     for (int index = constructorResolvedAsts.length - 1; index >= 0; index--) {
       ResolvedAst constructorResolvedAst = constructorResolvedAsts[index];
       ConstructorBodyElement body = getConstructorBody(constructorResolvedAst);
       if (body == null) continue;
 
@@ skipping 2295 matching lines @@
   bool needsSubstitutionForTypeVariableAccess(ClassElement cls) {
     ClassWorld classWorld = compiler.world;
     if (classWorld.isUsedAsMixin(cls)) return true;
 
     return compiler.world.anyStrictSubclassOf(cls, (ClassElement subclass) {
       return !rti.isTrivialSubstitution(subclass, cls);
     });
   }
 
   /**
-   * Generate code to extract the type arguments from the object, substitute
-   * them as an instance of the type we are testing against (if necessary), and
-   * extract the type argument by the index of the variable in the list of type
-   * variables for that class.
+   * Generate code to extract the type argument from the object.
    */
-  HInstruction readTypeVariable(ClassElement cls, TypeVariableElement variable,
+  HInstruction readTypeVariable(TypeVariableType variable,
       {SourceInformation sourceInformation}) {
     assert(sourceElement.isInstanceMember);
-
+    assert(variable is! MethodTypeVariableType);
     HInstruction target = localsHandler.readThis();
-    HConstant index = graph.addConstantInt(variable.index, compiler);
-
-    if (needsSubstitutionForTypeVariableAccess(cls)) {
-      // TODO(ahe): Creating a string here is unfortunate. It is slow (due to
-      // string concatenation in the implementation), and may prevent
-      // segmentation of '$'.
-      js.Name substitutionName = backend.namer.runtimeTypeName(cls);
-      HInstruction substitutionNameInstr =
-          graph.addConstantStringFromName(substitutionName, compiler);
-      pushInvokeStatic(null, helpers.getRuntimeTypeArgument,
-          [target, substitutionNameInstr, index],
-          typeMask: backend.dynamicType, sourceInformation: sourceInformation);
-    } else {
-      pushInvokeStatic(null, helpers.getTypeArgumentByIndex, [target, index],
-          typeMask: backend.dynamicType, sourceInformation: sourceInformation);
-    }
+    push(new HTypeInfoReadVariable(variable, target, backend.dynamicType)
+      ..sourceInformation = sourceInformation);
     return pop();
   }
 
   // TODO(karlklose): this is needed to avoid a bug where the resolved type is
   // not stored on a type annotation in the closure translator. Remove when
   // fixed.
   bool hasDirectLocal(Local local) {
     return !localsHandler.isAccessedDirectly(local) ||
         localsHandler.directLocals[local] != null;
   }
 
   /**
    * Helper to create an instruction that gets the value of a type variable.
    */
   HInstruction addTypeVariableReference(TypeVariableType type,
       {SourceInformation sourceInformation}) {
     assert(assertTypeInContext(type));
+    if (type is MethodTypeVariableType) {
+      return graph.addConstantNull(compiler);
+    }
     Element member = sourceElement;
     bool isClosure = member.enclosingElement.isClosure;
     if (isClosure) {
       ClosureClassElement closureClass = member.enclosingElement;
       member = closureClass.methodElement;
       member = member.outermostEnclosingMemberOrTopLevel;
     }
     bool isInConstructorContext =
         member.isConstructor || member.isGenerativeConstructorBody;
     Local typeVariableLocal = localsHandler.getTypeVariableAsLocal(type);
     if (isClosure) {
       if (member.isFactoryConstructor ||
           (isInConstructorContext && hasDirectLocal(typeVariableLocal))) {
         // The type variable is used from a closure in a factory constructor.
         // The value of the type argument is stored as a local on the closure
         // itself.
         return localsHandler.readLocal(typeVariableLocal,
             sourceInformation: sourceInformation);
       } else if (member.isFunction ||
           member.isGetter ||
           member.isSetter ||
           isInConstructorContext) {
         // The type variable is stored on the "enclosing object" and needs to be
         // accessed using the this-reference in the closure.
-        return readTypeVariable(member.enclosingClass, type.element,
-            sourceInformation: sourceInformation);
+        return readTypeVariable(type, sourceInformation: sourceInformation);
       } else {
         assert(member.isField);
         // The type variable is stored in a parameter of the method.
         return localsHandler.readLocal(typeVariableLocal);
       }
     } else if (isInConstructorContext ||
         // When [member] is a field, we can be either
         // generating a checked setter or inlining its
         // initializer in a constructor. An initializer is
         // never built standalone, so in that case [target] is not
         // the [member] itself.
         (member.isField && member != target)) {
       // The type variable is stored in a parameter of the method.
       return localsHandler.readLocal(typeVariableLocal,
           sourceInformation: sourceInformation);
     } else if (member.isInstanceMember) {
       // The type variable is stored on the object.
-      return readTypeVariable(member.enclosingClass, type.element,
-          sourceInformation: sourceInformation);
+      return readTypeVariable(type, sourceInformation: sourceInformation);
     } else {
       reporter.internalError(
           type.element, 'Unexpected type variable in static context.');
       return null;
     }
   }
 
   HInstruction analyzeTypeArgument(DartType argument,
       {SourceInformation sourceInformation}) {
     assert(assertTypeInContext(argument));
     if (argument.treatAsDynamic) {
       // Represent [dynamic] as [null].
       return graph.addConstantNull(compiler);
     }
 
     if (argument.isTypeVariable) {
       return addTypeVariableReference(argument,
           sourceInformation: sourceInformation);
     }
 
     List<HInstruction> inputs = <HInstruction>[];
-
-    js.Expression template =
-        rtiEncoder.getTypeRepresentationWithPlaceholders(argument, (variable) {
-      inputs.add(addTypeVariableReference(variable));
+    argument.forEachTypeVariable((variable) {
+      if (variable is! MethodTypeVariableType) {
+        inputs.add(analyzeTypeArgument(variable));
+      }
     });
-
-    js.Template code = new js.Template(null, template);
-    HInstruction result = new HForeignCode(code, backend.stringType, inputs,
-        nativeBehavior: native.NativeBehavior.PURE);
+    HInstruction result = new HTypeInfoExpression(
+        TypeInfoExpressionKind.COMPLETE, argument, inputs, backend.dynamicType)
+      ..sourceInformation = sourceInformation;
     add(result);
     return result;
   }
 
   HInstruction handleListConstructor(
       InterfaceType type, ast.Node currentNode, HInstruction newObject) {
     if (!backend.classNeedsRti(type.element) || type.treatAsRaw) {
       return newObject;
     }
     List<HInstruction> inputs = <HInstruction>[];
     type = localsHandler.substInContext(type);
     type.typeArguments.forEach((DartType argument) {
       inputs.add(analyzeTypeArgument(argument));
     });
     // TODO(15489): Register at codegen.
     registry?.registerInstantiation(type);
-    return callSetRuntimeTypeInfo(type.element, inputs, newObject);
+    return callSetRuntimeTypeInfoWithTypeArguments(
+        type.element, inputs, newObject);
   }
 
-  void copyRuntimeTypeInfo(HInstruction source, HInstruction target) {
-    Element copyHelper = helpers.copyTypeArguments;
-    pushInvokeStatic(null, copyHelper, [source, target],
-        sourceInformation: target.sourceInformation);
-    pop();
-  }
-
-  HInstruction callSetRuntimeTypeInfo(ClassElement element,
+  HInstruction callSetRuntimeTypeInfoWithTypeArguments(ClassElement element,
       List<HInstruction> rtiInputs, HInstruction newObject) {
-    if (!backend.classNeedsRti(element) || element.typeVariables.isEmpty) {
+    if (!backend.classNeedsRti(element)) {
       return newObject;
     }
 
-    HInstruction typeInfo = buildLiteralList(rtiInputs);
+    HInstruction typeInfo = new HTypeInfoExpression(
+        TypeInfoExpressionKind.INSTANCE,
+        element.thisType,
+        rtiInputs,
+        backend.dynamicType);
     add(typeInfo);
+    return callSetRuntimeTypeInfo(typeInfo, newObject);
+  }
 
+  HInstruction callSetRuntimeTypeInfo(
+      HInstruction typeInfo, HInstruction newObject) {
     // Set the runtime type information on the object.
     Element typeInfoSetterElement = helpers.setRuntimeTypeInfo;
     pushInvokeStatic(
         null, typeInfoSetterElement, <HInstruction>[newObject, typeInfo],
         typeMask: backend.dynamicType,
         sourceInformation: newObject.sourceInformation);
 
     // The new object will now be referenced through the
     // `setRuntimeTypeInfo` call. We therefore set the type of that
     // instruction to be of the object's type.
     assert(invariant(CURRENT_ELEMENT_SPANNABLE,
         stack.last is HInvokeStatic || stack.last == newObject,
         message: "Unexpected `stack.last`: Found ${stack.last}, "
             "expected ${newObject} or an HInvokeStatic. "
-            "State: element=$element, rtiInputs=$rtiInputs, stack=$stack."));
+            "State: typeInfo=$typeInfo, stack=$stack."));
     stack.last.instructionType = newObject.instructionType;
     return pop();
   }
 
   void handleNewSend(ast.NewExpression node) {
     ast.Send send = node.send;
     generateIsDeferredLoadedCheckOfSend(send);
 
     bool isFixedList = false;
     bool isFixedListConstructorCall =
@@ skipping 205 matching lines @@
         pop();
         stack.add(checked);
       }
     }
   }
 
   void potentiallyAddTypeArguments(
       List<HInstruction> inputs, ClassElement cls, InterfaceType expectedType,
       {SourceInformation sourceInformation}) {
     if (!backend.classNeedsRti(cls)) return;
-    assert(expectedType.typeArguments.isEmpty ||
-        cls.typeVariables.length == expectedType.typeArguments.length);
+    assert(cls.typeVariables.length == expectedType.typeArguments.length);
     expectedType.typeArguments.forEach((DartType argument) {
       inputs.add(
           analyzeTypeArgument(argument, sourceInformation: sourceInformation));
     });
   }
 
   /// In checked mode checks the [type] of [node] to be well-bounded. The method
   /// returns [:true:] if an error can be statically determined.
   bool checkTypeVariableBounds(ast.NewExpression node, InterfaceType type) {
     if (!compiler.options.enableTypeAssertions) return false;
@@ skipping 1689 matching lines @@
     InterfaceType type = localsHandler.substInContext(elements.getType(node));
     if (!backend.classNeedsRti(type.element) || type.treatAsRaw) {
       return object;
     }
     List<HInstruction> arguments = <HInstruction>[];
     for (DartType argument in type.typeArguments) {
       arguments.add(analyzeTypeArgument(argument));
     }
     // TODO(15489): Register at codegen.
     registry?.registerInstantiation(type);
-    return callSetRuntimeTypeInfo(type.element, arguments, object);
+    return callSetRuntimeTypeInfoWithTypeArguments(
+        type.element, arguments, object);
   }
 
   visitLiteralList(ast.LiteralList node) {
     HInstruction instruction;
 
     if (node.isConst) {
       instruction = addConstant(node);
     } else {
       List<HInstruction> inputs = <HInstruction>[];
       for (Link<ast.Node> link = node.elements.nodes;
@@ skipping 1831 matching lines @@
   const _LoopTypeVisitor();
   int visitNode(ast.Node node) => HLoopBlockInformation.NOT_A_LOOP;
   int visitWhile(ast.While node) => HLoopBlockInformation.WHILE_LOOP;
   int visitFor(ast.For node) => HLoopBlockInformation.FOR_LOOP;
   int visitDoWhile(ast.DoWhile node) => HLoopBlockInformation.DO_WHILE_LOOP;
   int visitAsyncForIn(ast.AsyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSyncForIn(ast.SyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSwitchStatement(ast.SwitchStatement node) =>
       HLoopBlockInformation.SWITCH_CONTINUE_LOOP;
 }