When recording the type of a captured variable/parameter, use the closure field it maps to. Otherwi…

sdk/lib/_internal/compiler/implementation/closure.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.
 
 library closureToClassMapper;
 
 import "elements/elements.dart";
 import "dart2jslib.dart";
 import "dart_types.dart";
 import "scanner/scannerlib.dart" show Token;
@@ skipping 49 matching lines @@
       }
       return nestedClosureData;
     });
   }
 }
 
 // TODO(ahe): These classes continuously cause problems.  We need to
 // move these classes to elements/modelx.dart or see if we can find a
 // more general solution.
 class ClosureFieldElement extends ElementX {
-  ClosureFieldElement(SourceString name, ClassElement enclosing)
+  ClosureFieldElement(SourceString name,
+                      this.variableElement,
+                      ClassElement enclosing)
       : super(name, ElementKind.FIELD, enclosing);
 
   bool isInstanceMember() => true;
   bool isAssignable() => false;
   // The names of closure variables don't need renaming, since their use is very
   // simple and they have 1-character names in the minified mode.
   bool hasFixedBackendName() => true;
   String fixedBackendName() => name.slowToString();
 
-  DartType computeType(Compiler compiler) => compiler.types.dynamicType;
+  DartType computeType(Compiler compiler) {
+    return variableElement.computeType(compiler);
+  }
 
   String toString() => "ClosureFieldElement($name)";
+
+  /**
+   * The source variable this element refers to.
+   */
+  final Element variableElement;
 }
 
 // TODO(ahe): These classes continuously cause problems.  We need to
 // move these classes to elements/modelx.dart or see if we can find a
 // more general solution.
 class ClosureClassElement extends ClassElementX {
   DartType rawType;
   DartType thisType;
   /// Node that corresponds to this closure, used for source position.
   final FunctionExpression node;
@@ skipping 19 matching lines @@
 
   bool isClosure() => true;
 
   Token position() => node.getBeginToken();
 
   Node parseNode(DiagnosticListener listener) => node;
 
   /**
    * The most outer method this closure is declared into.
    */
-  Element methodElement;
+  final Element methodElement;
 }
 
 // TODO(ahe): These classes continuously cause problems.  We need to
 // move these classes to elements/modelx.dart or see if we can find a
 // more general solution.
 class BoxElement extends ElementX {
   BoxElement(SourceString name, Element enclosingElement)
       : super(name, ElementKind.VARIABLE, enclosingElement);
+
+  DartType computeType(Compiler compiler) => compiler.types.dynamicType;
+}
+
+// TODO(ngeoffray, ahe): These classes continuously cause problems.  We need to
+// move these classes to elements/modelx.dart or see if we can find a
+// more general solution.
+class BoxFieldElement extends ElementX {
+  BoxFieldElement(SourceString name,
+                  this.variableElement,
+                  BoxElement enclosingBox)
+      : super(name, ElementKind.FIELD, enclosingBox);
+
+  DartType computeType(Compiler compiler) {
+    return variableElement.computeType(compiler);
+  }
+
+  final Element variableElement;
 }
 
 // TODO(ahe): These classes continuously cause problems.  We need to
 // move these classes to elements/modelx.dart or see if we can find a
 // more general solution.
 class ThisElement extends ElementX {
   ThisElement(Element enclosing)
       : super(const SourceString('this'), ElementKind.PARAMETER, enclosing);
 
   bool isAssignable() => false;
 
+  DartType computeType(Compiler compiler) => compiler.types.dynamicType;
+
   // Since there is no declaration corresponding to 'this', use the position of
   // the enclosing method.
   Token position() => enclosingElement.position();
 }
 
 // TODO(ahe): These classes continuously cause problems.  We need to
 // move these classes to elements/modelx.dart or see if we can find a
 // more general solution.
 class CheckVariableElement extends ElementX {
   Element parameter;
   CheckVariableElement(SourceString name, this.parameter, Element enclosing)
       : super(name, ElementKind.VARIABLE, enclosing);
 
+  DartType computeType(Compiler compiler) => compiler.types.dynamicType;
+
   // Since there is no declaration for the synthetic 'check' variable, use
   // parameter.
   Token position() => parameter.position();
 }
 
 // The box-element for a scope, and the captured variables that need to be
 // stored in the box.
 class ClosureScope {
   Element boxElement;
   Map<Element, Element> capturedVariableMapping;
@@ skipping 56 matching lines @@
 
   bool isVariableCaptured(Element element) {
     freeVariableMapping.containsKey(element);
   }
 
   bool isVariableBoxed(Element element) {
     Element copy = freeVariableMapping[element];
     return copy != null && !copy.isMember();
   }
 
-  void forEachCapturedVariable(void f(Element element)) {
-    freeVariableMapping.forEach((variable, _) {
+  void forEachCapturedVariable(void f(Element local, Element field)) {
+    freeVariableMapping.forEach((variable, copy) {
       if (variable is BoxElement) return;
-      f(variable);
+      f(variable, copy);
     });
   }
 
-  void forEachBoxedVariable(void f(Element element)) {
+  void forEachBoxedVariable(void f(Element local, Element field)) {
     freeVariableMapping.forEach((variable, copy) {
       if (!isVariableBoxed(variable)) return;
-      f(variable);
+      f(variable, copy);
     });
   }
 
-  void forEachNonBoxedCapturedVariable(void f(Element element)) {
+  void forEachNonBoxedCapturedVariable(void f(Element local, Element field)) {
     freeVariableMapping.forEach((variable, copy) {
       if (variable is BoxElement) return;
       if (isVariableBoxed(variable)) return;
-      f(variable);
+      f(variable, copy);
     });
   }
 }
 
 class ClosureTranslator extends Visitor {
   final Compiler compiler;
   final TreeElements elements;
   int closureFieldCounter = 0;
   int boxedFieldCounter = 0;
   bool inTryStatement = false;
@@ skipping 77 matching lines @@
           freeVariableMapping[fromElement] = updatedElement;
           Element boxElement = updatedElement.enclosingElement;
           assert(boxElement.kind == ElementKind.VARIABLE);
           boxes.add(boxElement);
         }
       });
       ClassElement closureElement = data.closureClassElement;
       assert(closureElement != null ||
              (fieldCaptures.isEmpty && boxes.isEmpty));
       void addElement(Element element, SourceString name) {
-        Element fieldElement = new ClosureFieldElement(name, closureElement);
+        Element fieldElement = new ClosureFieldElement(
+            name, element, closureElement);
         closureElement.addMember(fieldElement, compiler);
         data.capturedFieldMapping[fieldElement] = element;
         freeVariableMapping[element] = fieldElement;
       }
       // Add the box elements first so we get the same ordering.
       // TODO(sra): What is the canonical order of multiple boxes?
       for (Element capturedElement in boxes) {
         addElement(capturedElement, capturedElement.name);
       }
       for (Element capturedElement in
@@ skipping 205 matching lines @@
           SourceString boxName =
               namer.getClosureVariableName(const SourceString('box'),
                                            closureFieldCounter++);
           box = new BoxElement(boxName, currentElement);
         }
         String elementName = element.name.slowToString();
         SourceString boxedName =
             namer.getClosureVariableName(new SourceString(elementName),
                                          boxedFieldCounter++);
         // TODO(kasperl): Should this be a FieldElement instead?
-        Element boxed = new ElementX(boxedName, ElementKind.FIELD, box);
+        Element boxed = new BoxFieldElement(boxedName, element, box);
         // No need to rename the fields of a box, so we give them a native name
         // right now.
         boxed.setFixedBackendName(boxedName.slowToString());
         scopeMapping[element] = boxed;
         capturedVariableMapping[element] = boxed;
       }
     }
     if (!scopeMapping.isEmpty) {
       ClosureScope scope = new ClosureScope(box, scopeMapping);
       closureData.capturingScopes[node] = scope;
@@ skipping 183 matching lines @@
   }
 
   visitTryStatement(TryStatement node) {
     // TODO(ngeoffray): implement finer grain state.
     bool oldInTryStatement = inTryStatement;
     inTryStatement = true;
     node.visitChildren(this);
     inTryStatement = oldInTryStatement;
   }
 }