Support general handling of type variables by substituting types into the current context.

sdk/lib/_internal/compiler/implementation/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.
 
 part of ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to implement [TypedElement.type] because our
  * optimizers may look at its declared type.
@@ skipping 97 matching lines @@
    * [directLocals] is iterated, so it is "insertion ordered" to make the
    * iteration order a function only of insertions and not a function of
    * e.g. Element hash codes.  I'd prefer to use a SortedMap but some elements
    * don't have source locations for [Elements.compareByPosition].
    */
   Map<Element, HInstruction> directLocals;
   Map<Element, Element> redirectionMapping;
   SsaBuilder builder;
   ClosureClassMap closureData;
 
-  LocalsHandler(this.builder)
-      : directLocals = new Map<Element, HInstruction>(),
-        redirectionMapping = new Map<Element, Element>();
+  /// The class that defines the current type environment or null if no type
+  /// variables are in scope.
+  final ClassElement contextClass;
+
+  LocalsHandler(this.builder, this.contextClass)
+      : redirectionMapping = new Map<Element, Element>(),
+        directLocals = new Map<Element, HInstruction>();
+
+  /// Substituted type variables occurring in [type] into the context of
+  /// [contextClass].
+  DartType substInContext(DartType type) {
+    if (contextClass != null) {
+      ClassElement typeContext = Types.getClassContext(type);
+      if (typeContext != null) {
+        type = type.substByContext(
+            contextClass.asInstanceOf(typeContext));
+      }
+    }
+    return type;
+  }
 
   get typesTask => builder.compiler.typesTask;
 
   /**
    * Creates a new [LocalsHandler] based on [other]. We only need to
    * copy the [directLocals], since the other fields can be shared
    * throughout the AST visit.
    */
   LocalsHandler.from(LocalsHandler other)
       : directLocals = new Map<Element, HInstruction>.from(other.directLocals),
         redirectionMapping = other.redirectionMapping,
+        contextClass = other.contextClass,
         builder = other.builder,
         closureData = other.closureData;
 
   /**
    * Redirects accesses from element [from] to element [to]. The [to] element
    * must be a boxed variable or a variable that is stored in a closure-field.
    */
   void redirectElement(Element from, Element to) {
     assert(redirectionMapping[from] == null);
     redirectionMapping[from] = to;
@@ skipping 820 matching lines @@
   List<HInstruction> stack = <HInstruction>[];
 
   SsaBuilder(JavaScriptBackend backend,
              CodegenWorkItem work,
              this.nativeEmitter)
     : this.backend = backend,
       this.constantSystem = backend.constantSystem,
       this.work = work,
       this.rti = backend.rti,
       super(work.resolutionTree, backend.compiler) {
-    localsHandler = new LocalsHandler(this);
+    localsHandler = new LocalsHandler(this, work.element.contextClass);
     sourceElementStack.add(work.element);
   }
 
   Element get sourceElement => sourceElementStack.last;
 
   HBasicBlock addNewBlock() {
     HBasicBlock block = graph.addNewBlock();
     // If adding a new block during building of an expression, it is due to
     // conditional expressions or short-circuit logical operators.
     return block;
@@ skipping 534 matching lines @@
    * This method sets up the local state of the builder for inlining [function].
    * The arguments of the function are inserted into the [localsHandler].
    *
    * When inlining a function, [:return:] statements are not emitted as
    * [HReturn] instructions. Instead, the value of a synthetic element is
    * updated in the [localsHandler]. This function creates such an element and
    * stores it in the [returnElement] field.
    */
   void setupStateForInlining(FunctionElement function,
                              List<HInstruction> compiledArguments) {
-    localsHandler = new LocalsHandler(this);
+    localsHandler = new LocalsHandler(this, function.contextClass);
     localsHandler.closureData =
         compiler.closureToClassMapper.computeClosureToClassMapping(
             function, function.parseNode(compiler), elements);
     // TODO(kasperl): Bad smell. We shouldn't be constructing elements here.
     returnElement = new VariableElementX.synthetic("result",
         ElementKind.VARIABLE, function);
     localsHandler.updateLocal(returnElement,
         graph.addConstantNull(compiler));
 
     inTryStatement = false; // TODO(lry): why? Document.
@@ skipping 73 matching lines @@
   }
 
   /**
    * In checked mode, generate type tests for the parameters of the inlined
    * function.
    */
   void potentiallyCheckInlinedParameterTypes(FunctionElement function) {
     if (!compiler.enableTypeAssertions) return;
 
     FunctionSignature signature = function.functionSignature;
-
-    InterfaceType contextType;
-    if (function.isSynthesized && function.isGenerativeConstructor()) {
-      // Synthesized constructors reuse the parameters from the
-      // [targetConstructor]. In face of generic types, the type variables
-      // occurring in the parameter types must be substituted by the type
-      // arguments of the enclosing class.
-      FunctionElement target = function;
-      while (target.targetConstructor != null) {
-        target = target.targetConstructor;
-      }
-      if (target != function) {
-        ClassElement functionClass = function.getEnclosingClass();
-        ClassElement targetClass = target.getEnclosingClass();
-        contextType = functionClass.thisType.asInstanceOf(targetClass);
-      }
-    }
-
     signature.orderedForEachParameter((ParameterElement parameter) {
       HInstruction argument = localsHandler.readLocal(parameter);
-      DartType parameterType = parameter.type;
-      if (contextType != null) {
-        parameterType = parameterType.substByContext(contextType);
-      }
-      potentiallyCheckType(argument, parameterType);
+      potentiallyCheckType(argument, parameter.type);
     });
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [constructors] must contain only implementation elements.
    */
   void inlineSuperOrRedirect(FunctionElement callee,
                              List<HInstruction> compiledArguments,
                              List<FunctionElement> constructors,
                              Map<Element, HInstruction> fieldValues,
                              FunctionElement caller) {
     callee = callee.implementation;
     compiler.withCurrentElement(callee, () {
       constructors.add(callee);
       ClassElement enclosingClass = callee.getEnclosingClass();
       if (backend.classNeedsRti(enclosingClass)) {
         // If [enclosingClass] needs RTI, we have to give a value to its
         // type parameters.
         ClassElement currentClass = caller.getEnclosingClass();
         // For a super constructor call, the type is the supertype of
         // [currentClass]. For a redirecting constructor, the type is
         // the current type. [InterfaceType.asInstanceOf] takes care
         // of both.
         InterfaceType type = currentClass.thisType.asInstanceOf(enclosingClass);
+        type = localsHandler.substInContext(type);
         Link<DartType> typeVariables = enclosingClass.typeVariables;
         type.typeArguments.forEach((DartType argument) {
           localsHandler.updateLocal(
               typeVariables.head.element,
               analyzeTypeArgument(argument));
           typeVariables = typeVariables.tail;
         });
         // If the supertype is a raw type, we need to set to null the
         // type variables.
         assert(typeVariables.isEmpty
@@ skipping 247 matching lines @@
 
     classElement.forEachInstanceField(
         (ClassElement enclosingClass, VariableElement member) {
           HInstruction value = fieldValues[member];
           if (value == null) {
             // Uninitialized native fields are pre-initialized by the native
             // implementation.
             assert(isNativeUpgradeFactory);
           } else {
             fields.add(member);
-            DartType type = member.type;
-            if (enclosingClass.isMixinApplication) {
-              // TODO(johnniwinther): Add a member-like abstraction for fields
-              // that normalizes this.
-              type = type.substByContext(
-                  enclosingClass.thisType.asInstanceOf(
-                      member.enclosingElement));
-            }
+            DartType type = localsHandler.substInContext(member.type);
             constructorArguments.add(potentiallyCheckType(value, type));
           }
         },
         includeSuperAndInjectedMembers: true);
 
     InterfaceType type = classElement.thisType;
     TypeMask ssaType = new TypeMask.nonNullExact(classElement.declaration);
     List<DartType> instantiatedTypes;
     addInlinedInstantiation(type);
     if (!currentInlinedInstantiations.isEmpty) {
@@ skipping 122 matching lines @@
         if (!localsHandler.isBoxed(parameter)) {
           bodyCallInputs.add(localsHandler.readLocal(parameter));
         }
       });
 
       ClassElement currentClass = constructor.getEnclosingClass();
       if (backend.classNeedsRti(currentClass)) {
         // If [currentClass] needs RTI, we add the type variables as
         // parameters of the generative constructor body.
         currentClass.typeVariables.forEach((DartType argument) {
+          // TODO(johnniwinther): Substitute [argument] with
+          // `localsHandler.substInContext(argument)`.
           bodyCallInputs.add(localsHandler.readLocal(argument.element));
         });
       }
 
       // If there are locals that escape (ie mutated in closures), we
       // pass the box to the constructor.
       ClosureScope scopeData = parameterClosureData.capturingScopes[node];
       if (scopeData != null) {
         bodyCallInputs.add(localsHandler.readLocal(scopeData.boxElement));
       }
@@ skipping 72 matching lines @@
         localsHandler.directLocals[parameterElement] = newParameter;
       });
 
       returnType = signature.type.returnType;
     } else {
       // Otherwise it is a lazy initializer which does not have parameters.
       assert(element is VariableElement);
     }
   }
 
+  /// Check that [type] is valid in the context of `localsHandler.contextClass`.
+  /// This should only be called in assertions.
+  bool assertTypeInContext(DartType type, [Spannable spannable]) {
+    return invariant(spannable == null ? CURRENT_ELEMENT_SPANNABLE : spannable,
+        () {
+          ClassElement contextClass = Types.getClassContext(type);
+          return contextClass == null ||
+                 contextClass == localsHandler.contextClass;
+        },
+        message: "Type '$type' is not valid context of "
+                 "${localsHandler.contextClass}.");
+  }
+
+  /// Build a [HTypeConversion] for convertion [original] to type [type].
+  ///
+  /// Invariant: [type] must be valid in the context.
+  /// See [LocalsHandler.substInContext].
   HInstruction buildTypeConversion(HInstruction original,
                                    DartType type,
                                    int kind) {
     if (type == null) return original;
-    type = type.unalias(compiler);
+    assert(assertTypeInContext(type, original));
     if (type.kind == TypeKind.INTERFACE && !type.treatAsRaw) {
       TypeMask subtype = new TypeMask.subtype(type.element);
       HInstruction representations = buildTypeArgumentRepresentations(type);
       add(representations);
       return new HTypeConversion.withTypeRepresentation(type, kind, subtype,
           original, representations);
     } else if (type.kind == TypeKind.TYPE_VARIABLE) {
       TypeMask subtype = original.instructionType;
       HInstruction typeVariable = addTypeVariableReference(type);
       return new HTypeConversion.withTypeRepresentation(type, kind, subtype,
@@ skipping 10 matching lines @@
 
       return new HTypeConversion(type, kind, original.instructionType, pop());
     } else {
       return original.convertType(compiler, type, kind);
     }
   }
 
   HInstruction potentiallyCheckType(HInstruction original, DartType type,
       { int kind: HTypeConversion.CHECKED_MODE_CHECK }) {
     if (!compiler.enableTypeAssertions) return original;
+    type = localsHandler.substInContext(type);
     HInstruction other = buildTypeConversion(original, type, kind);
     if (other != original) add(other);
     compiler.enqueuer.codegen.registerIsCheck(type, work.resolutionTree);
     return other;
   }
 
   void assertIsSubtype(ast.Node node, DartType subtype, DartType supertype,
                        String message) {
-    HInstruction subtypeInstruction = analyzeTypeArgument(subtype);
-    HInstruction supertypeInstruction = analyzeTypeArgument(supertype);
+    HInstruction subtypeInstruction =
+        analyzeTypeArgument(localsHandler.substInContext(subtype));
+    HInstruction supertypeInstruction =
+        analyzeTypeArgument(localsHandler.substInContext(supertype));
     HInstruction messageInstruction =
         graph.addConstantString(new ast.DartString.literal(message), compiler);
     Element element = backend.getAssertIsSubtype();
     var inputs = <HInstruction>[subtypeInstruction, supertypeInstruction,
                                 messageInstruction];
     HInstruction assertIsSubtype = new HInvokeStatic(
         element, inputs, subtypeInstruction.instructionType);
     compiler.backend.registerTypeVariableBoundsSubtypeCheck(subtype, supertype);
     add(assertIsSubtype);
   }
@@ skipping 917 matching lines @@
       visitIsSend(node);
     } else if ("as" == op.source) {
       visit(node.receiver);
       HInstruction expression = pop();
       DartType type = elements.getType(node.typeAnnotationFromIsCheckOrCast);
       if (type.kind == TypeKind.MALFORMED_TYPE) {
         ErroneousElement element = type.element;
         generateTypeError(node, element.message);
       } else {
         HInstruction converted = buildTypeConversion(
-            expression, type, HTypeConversion.CAST_TYPE_CHECK);
+            expression,
+            localsHandler.substInContext(type),
+            HTypeConversion.CAST_TYPE_CHECK);
         if (converted != expression) add(converted);
         stack.add(converted);
       }
     } else {
       visit(node.receiver);
       visit(node.argumentsNode);
       var right = pop();
       var left = pop();
       visitBinary(left, op, right, elements.getSelector(node), node);
     }
   }
 
   void visitIsSend(ast.Send node) {
     visit(node.receiver);
     HInstruction expression = pop();
     bool isNot = node.isIsNotCheck;
     DartType type = elements.getType(node.typeAnnotationFromIsCheckOrCast);
-    type = type.unalias(compiler);
     HInstruction instruction = buildIsNode(node, type, expression);
     if (isNot) {
       add(instruction);
       instruction = new HNot(instruction, backend.boolType);
     }
     push(instruction);
   }
 
-  HInstruction buildIsNode(ast.Node node, DartType type, HInstruction expression) {
-    type = type.unalias(compiler);
+  HInstruction buildIsNode(ast.Node node,
+                           DartType type,
+                           HInstruction expression) {
+    type = localsHandler.substInContext(type).unalias(compiler);
     if (type.kind == TypeKind.FUNCTION) {
       List arguments = [buildFunctionType(type), expression];
       pushInvokeDynamic(
           node, new Selector.call('_isTest', compiler.jsHelperLibrary, 1),
           arguments);
       return new HIs.compound(type, expression, pop(), backend.boolType);
     } else if (type.kind == TypeKind.TYPE_VARIABLE) {
       HInstruction runtimeType = addTypeVariableReference(type);
       Element helper = backend.getCheckSubtypeOfRuntimeType();
       List<HInstruction> inputs = <HInstruction>[expression, runtimeType];
@@ skipping 631 matching lines @@
   // fixed.
   bool hasDirectLocal(Element element) {
     return !localsHandler.isAccessedDirectly(element) ||
         localsHandler.directLocals[element] != null;
   }
 
   /**
    * Helper to create an instruction that gets the value of a type variable.
    */
   HInstruction addTypeVariableReference(TypeVariableType type) {
+    assert(assertTypeInContext(type));
     Element member = sourceElement;
     bool isClosure = member.enclosingElement.isClosure();
     if (isClosure) {
       ClosureClassElement closureClass = member.enclosingElement;
       member = closureClass.methodElement;
       member = member.getOutermostEnclosingMemberOrTopLevel();
     }
     bool isInConstructorContext = member.isConstructor() ||
         member.isGenerativeConstructorBody();
     if (isClosure) {
@@ skipping 31 matching lines @@
     } else {
       // TODO(ngeoffray): Match the VM behavior and throw an
       // exception at runtime.
       compiler.internalError(type.element,
           'Unimplemented unresolved type variable.');
       return null;
     }
   }
 
   HInstruction analyzeTypeArgument(DartType argument) {
+    assert(assertTypeInContext(argument));
     if (argument.treatAsDynamic) {
       // Represent [dynamic] as [null].
       return graph.addConstantNull(compiler);
     }
 
     if (argument.kind == TypeKind.TYPE_VARIABLE) {
       return addTypeVariableReference(argument);
     }
 
     List<HInstruction> inputs = <HInstruction>[];
 
     String template = rti.getTypeRepresentationWithHashes(argument, (variable) {
       inputs.add(addTypeVariableReference(variable));
     });
 
     js.Template code = js.js.uncachedExpressionTemplate(template);
     HInstruction result = createForeign(code, backend.stringType, inputs);
     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.
     compiler.enqueuer.codegen.registerInstantiatedType(type, elements);
     return callSetRuntimeTypeInfo(type.element, inputs, newObject);
   }
 
   void copyRuntimeTypeInfo(HInstruction source, HInstruction target) {
     Element copyHelper = backend.getCopyTypeArguments();
@@ skipping 88 matching lines @@
       assert(invariant(send, constructor != null,
                        message: 'Constructor Symbol.validated is missing'));
       selector = compiler.symbolValidatedConstructorSelector;
       assert(invariant(send, selector != null,
                        message: 'Constructor Symbol.validated is missing'));
     }
 
     bool isRedirected = functionElement.isRedirectingFactory;
     InterfaceType type = elements.getType(node);
     InterfaceType expectedType = functionElement.computeTargetType(type);
+    expectedType = localsHandler.substInContext(expectedType);
 
     if (checkTypeVariableBounds(node, type)) return;
 
     var inputs = <HInstruction>[];
     if (constructor.isGenerativeConstructor() &&
         Elements.isNativeOrExtendsNative(constructor.getEnclosingClass())) {
       // Native class generative constructors take a pre-constructed object.
       inputs.add(graph.addConstantNull(compiler));
     }
     // TODO(5347): Try to avoid the need for calling [implementation] before
@@ skipping 217 matching lines @@
       // TODO(karlklose): add type representation
       if (node.isCall) {
         // The node itself is not a constant but we register the selector (the
         // identifier that refers to the class/typedef) as a constant.
         stack.add(addConstant(node.selector));
       } else {
         stack.add(addConstant(node));
       }
     } else if (element.isTypeVariable()) {
       TypeVariableElement typeVariable = element;
-      HInstruction value = addTypeVariableReference(typeVariable.type);
+      DartType type = localsHandler.substInContext(typeVariable.type);
+      HInstruction value = analyzeTypeArgument(type);
       pushInvokeStatic(node,
                        backend.getRuntimeTypeToString(),
                        [value],
                        backend.stringType);
       pushInvokeStatic(node,
                        backend.getCreateRuntimeType(),
                        [pop()]);
     } else {
       internalError('unexpected element kind $element', node: node);
     }
@@ skipping 543 matching lines @@
       }
       for (; i < targetOptionals.length; i++) {
         inputs.add(handleConstantForOptionalParameter(targetOptionals[i]));
       }
 
       ClassElement targetClass = targetConstructor.getEnclosingClass();
       if (backend.classNeedsRti(targetClass)) {
         ClassElement cls = redirectingConstructor.getEnclosingClass();
         InterfaceType targetType =
             redirectingConstructor.computeTargetType(cls.thisType);
+        targetType = localsHandler.substInContext(targetType);
         targetType.typeArguments.forEach((DartType argument) {
           inputs.add(analyzeTypeArgument(argument));
         });
       }
       pushInvokeStatic(node, targetConstructor, inputs);
       value = pop();
     } else if (node.expression == null) {
       value = graph.addConstantNull(compiler);
     } else {
       visit(node.expression);
@@ skipping 30 matching lines @@
         localsHandler.updateLocal(elements[definition], initialValue);
       } else {
         assert(definition is ast.SendSet);
         visitSendSet(definition);
         pop();  // Discard value.
       }
     }
   }
 
   HInstruction setRtiIfNeeded(HInstruction object, ast.Node node) {
-    InterfaceType type = elements.getType(node);
+    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.
     compiler.enqueuer.codegen.registerInstantiatedType(type, elements);
     return callSetRuntimeTypeInfo(type.element, arguments, object);
@@ skipping 226 matching lines @@
       inputs.add(keyValuePairs);
     }
 
     assert(constructor.isFactoryConstructor());
 
     FunctionElement functionElement = constructor;
     constructor = functionElement.redirectionTarget;
 
     InterfaceType type = elements.getType(node);
     InterfaceType expectedType = functionElement.computeTargetType(type);
+    expectedType = localsHandler.substInContext(expectedType);
 
     if (constructor.isFactoryConstructor()) {
       compiler.enqueuer.codegen.registerFactoryWithTypeArguments(elements);
     }
 
     ClassElement cls = constructor.getEnclosingClass();
 
     if (backend.classNeedsRti(cls)) {
       Link<DartType> typeVariable = cls.typeVariables;
       expectedType.typeArguments.forEach((DartType argument) {
@@ skipping 1178 matching lines @@
     DartType unaliased = type.unalias(builder.compiler);
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     ClassElement cls = builder.compiler.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls)));
   }
 }