Infer types of catpured variables and use the types in the SSA builder.

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 override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 219 matching lines @@
       // [readLocal] uses the [boxElement] to find its box. By replacing it
       // behind its back we can still get to the old values.
       updateLocal(boxElement, oldBox);
       HInstruction oldValue = readLocal(boxedVariable);
       updateLocal(boxElement, newBox);
       updateLocal(boxedVariable, oldValue);
     }
     updateLocal(boxElement, newBox);
   }
 
-  HType cachedTypeOfThis;
-
-  HType getTypeOfThis() {
-    HType result = cachedTypeOfThis;
-    if (result == null) {
-      Element element = closureData.thisElement;
-      ClassElement cls = element.enclosingElement.getEnclosingClass();
-      Compiler compiler = builder.compiler;
-      // Use the raw type because we don't have the type context for the
-      // type parameters.
-      DartType type = cls.rawType;
-      if (compiler.world.isUsedAsMixin(cls)) {
-        // If the enclosing class is used as a mixin, [:this:] can be
-        // of the class that mixins the enclosing class. These two
-        // classes do not have a subclass relationship, so, for
-        // simplicity, we mark the type as an interface type.
-        result = new HType.nonNullSubtype(type, compiler);
-      } else {
-        result = new HType.nonNullSubclass(type, compiler);
-      }
-      cachedTypeOfThis = result;
-    }
-    return result;
-  }
-
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [function] must be an implementation element.
    */
   void startFunction(Element element, Expression node) {
     assert(invariant(node, element.isImplementation));
     Compiler compiler = builder.compiler;
     closureData = compiler.closureToClassMapper.computeClosureToClassMapping(
             element, node, builder.elements);
 
     if (element is FunctionElement) {
       FunctionElement functionElement = element;
       FunctionSignature params = functionElement.computeSignature(compiler);
       params.orderedForEachParameter((Element parameterElement) {
         if (element.isGenerativeConstructorBody()) {
           ClosureScope scopeData = closureData.capturingScopes[node];
           if (scopeData != null
               && scopeData.capturedVariableMapping.containsKey(
                   parameterElement)) {
             // The parameter will be a field in the box passed as the
             // last parameter. So no need to have it.
             return;
           }
         }
         HInstruction parameter = builder.addParameter(parameterElement);
         builder.parameters[parameterElement] = parameter;
         directLocals[parameterElement] = parameter;
         parameter.instructionType =
-            new HType.inferredForElement(parameterElement, compiler);
+            new HType.inferredTypeForElement(parameterElement, compiler);
       });
     }
 
     enterScope(node, element);
 
     // If the freeVariableMapping is not empty, then this function was a
     // nested closure that captures variables. Redirect the captured
     // variables to fields in the closure.
     closureData.freeVariableMapping.forEach((Element from, Element to) {
       redirectElement(from, to);
     });
     if (closureData.isClosure()) {
       // Inside closure redirect references to itself to [:this:].
       HThis thisInstruction = new HThis(closureData.thisElement);
       builder.graph.thisInstruction = thisInstruction;
       builder.graph.entry.addAtEntry(thisInstruction);
       updateLocal(closureData.closureElement, thisInstruction);
     } else if (element.isInstanceMember()
                || element.isGenerativeConstructor()) {
       // Once closures have been mapped to classes their instance members might
       // not have any thisElement if the closure was created inside a static
       // context.
       HThis thisInstruction = new HThis(
-          closureData.thisElement, getTypeOfThis());
+          closureData.thisElement, builder.getTypeOfThis());
       builder.graph.thisInstruction = thisInstruction;
       builder.graph.entry.addAtEntry(thisInstruction);
       directLocals[closureData.thisElement] = thisInstruction;
     }
 
     // If this method is an intercepted method, add the extra
     // parameter to it, that is the actual receiver for intercepted
     // classes, or the same as [:this:] for non-intercepted classes.
     ClassElement cls = element.getEnclosingClass();
     if (builder.backend.isInterceptedMethod(element)) {
@@ skipping 79 matching lines @@
     if (isAccessedDirectly(element)) {
       if (directLocals[element] == null) {
         builder.compiler.internalError("Cannot find value $element",
                                        element: element);
       }
       return directLocals[element];
     } else if (isStoredInClosureField(element)) {
       Element redirect = redirectionMapping[element];
       HInstruction receiver = readLocal(closureData.closureElement);
       HInstruction fieldGet = new HFieldGet(redirect, receiver);
+      fieldGet.instructionType = builder.getTypeOfCapturedVariable(element);
       builder.add(fieldGet);
       return fieldGet;
     } else if (isBoxed(element)) {
       Element redirect = redirectionMapping[element];
       // In the function that declares the captured variable the box is
       // accessed as direct local. Inside the nested closure the box is
       // accessed through a closure-field.
       // Calling [readLocal] makes sure we generate the correct code to get
       // the box.
       assert(redirect.enclosingElement.isVariable());
       HInstruction box = readLocal(redirect.enclosingElement);
       HInstruction lookup = new HFieldGet(redirect, box);
+      lookup.instructionType = builder.getTypeOfCapturedVariable(element);
       builder.add(lookup);
       return lookup;
     } else {
       assert(isUsedInTry(element));
       HLocalValue local = getLocal(element);
       HInstruction variable = new HLocalGet(element, local);
       builder.add(variable);
       return variable;
     }
   }
 
   HInstruction readThis() {
     HInstruction res = readLocal(closureData.thisElement);
     if (res.instructionType == null) {
-      res.instructionType = getTypeOfThis();
+      res.instructionType = builder.getTypeOfThis();
     }
     return res;
   }
 
   HLocalValue getLocal(Element element) {
     // If the element is a parameter, we already have a
     // HParameterValue for it. We cannot create another one because
     // it could then have another name than the real parameter. And
     // the other one would not know it is just a copy of the real
     // parameter.
@@ skipping 424 matching lines @@
 
   Constant compileVariable(VariableElement element) {
     return compiler.constantHandler.compileVariable(element);
   }
 
   bool isLazilyInitialized(VariableElement element) {
     Constant initialValue = compileVariable(element);
     return initialValue == null;
   }
 
+  HType cachedTypeOfThis;
+
+  HType getTypeOfThis() {
+    HType result = cachedTypeOfThis;
+    if (result == null) {
+      Element element = localsHandler.closureData.thisElement;
+      ClassElement cls = element.enclosingElement.getEnclosingClass();
+      // Use the raw type because we don't have the type context for the
+      // type parameters.
+      DartType type = cls.rawType;
+      if (compiler.world.isUsedAsMixin(cls)) {
+        // If the enclosing class is used as a mixin, [:this:] can be
+        // of the class that mixins the enclosing class. These two
+        // classes do not have a subclass relationship, so, for
+        // simplicity, we mark the type as an interface type.
+        result = new HType.nonNullSubtype(type, compiler);
+      } else {
+        result = new HType.nonNullSubclass(type, compiler);
+      }
+      cachedTypeOfThis = result;
+    }
+    return result;
+  }
+
+  Map<Element, HType> cachedTypesOfCapturedVariables =
+      new Map<Element, HType>();
+
+  HType getTypeOfCapturedVariable(Element element) {
+    return cachedTypesOfCapturedVariables.putIfAbsent(element, () {
+      return new HType.inferredTypeForElement(element, compiler);
+    });
+  }
+
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [functionElement] must be an implementation element.
    */
   HGraph buildMethod(FunctionElement functionElement) {
     assert(invariant(functionElement, functionElement.isImplementation));
     FunctionExpression function = functionElement.parseNode(compiler);
     assert(function != null);
     assert(!function.modifiers.isExternal());
@@ skipping 1899 matching lines @@
   }
 
   visitDynamicSend(Send node, {bool inline: true}) {
     Selector selector = elements.getSelector(node);
 
     // TODO(kasperl): It would be much better to try to get the
     // guaranteed type of the receiver after we've evaluated it, but
     // because of the way inlining currently works that is hard to do
     // with re-evaluating the receiver.
     if (isThisSend(node)) {
-      HType receiverType = localsHandler.getTypeOfThis();
+      HType receiverType = getTypeOfThis();
       selector = receiverType.refine(selector, compiler);
     }
 
     Element element = compiler.world.locateSingleElement(selector);
     bool isClosureCall = false;
     if (inline && element != null) {
       if (tryInlineMethod(element, selector, node.arguments, node)) {
         if (element.isGetter()) {
           // If the element is a getter, we are doing a closure call
           // on what this getter returns.
@@ skipping 551 matching lines @@
         generateWrongArgumentCountError(node, element, node.arguments);
         return;
       }
 
       if (isIdenticalFunction) {
         pushWithPosition(new HIdentity(inputs[1], inputs[2]), node);
         return;
       }
 
       HInvokeStatic instruction = new HInvokeStatic(inputs, HType.UNKNOWN);
-      HType returnType = new HType.inferredForElement(element, compiler);
+      HType returnType =
+          new HType.inferredReturnTypeForElement(element, compiler);
       if (returnType.isUnknown()) {
         // TODO(ngeoffray): Only do this if knowing the return type is
         // useful.
         returnType =
             builder.backend.optimisticReturnTypesWithRecompilationOnTypeChange(
                 currentElement, element);
       }
       if (returnType != null) instruction.instructionType = returnType;
       pushWithPosition(instruction, node);
     } else {
@@ skipping 1644 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }