Fix resolution of type parameters in static context, and the use of type parameters in closures.

lib/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("leg.dart");
 #import("scanner/scannerlib.dart");
 #import("tree/tree.dart");
@@ skipping 161 matching lines @@
   // List of encountered closures.
   List<FunctionExpression> closures;
 
   // The variables that have been declared in the current scope.
   List<Element> scopeVariables;
 
   // Keep track of the mutated variables so that we don't need to box
   // non-mutated variables.
   Set<Element> mutatedVariables;
 
+  FunctionElement outermostFunctionElement;
   FunctionElement currentFunctionElement;
+
   // The closureData of the currentFunctionElement.
   ClosureClassMap closureData;
 
   bool insideClosure = false;
 
   ClosureTranslator(this.compiler, this.elements, this.closureMappingCache)
       : capturedVariableMapping = new Map<Element, Element>(),
         closures = <FunctionExpression>[],
         mutatedVariables = new Set<Element>();
 
@@ skipping 50 matching lines @@
         Element fieldElement = new ClosureFieldElement(name, closureElement);
         closureElement.backendMembers =
             closureElement.backendMembers.prepend(fieldElement);
         data.capturedFieldMapping[fieldElement] = capturedElement;
         freeVariableMapping[capturedElement] = fieldElement;
       }
     }
   }
 
   void useLocal(Element element) {
-    // TODO(floitsch): replace this with a general solution.
-    Element functionElement = currentFunctionElement;
-    if (functionElement.kind === ElementKind.GENERATIVE_CONSTRUCTOR_BODY) {
-      ConstructorBodyElement body = functionElement;
-      functionElement = body.constructor;
-    }
     // If the element is not declared in the current function and the element
     // is not the closure itself we need to mark the element as free variable.
-    if (element.enclosingElement != functionElement &&
-        element != functionElement) {
+    // Note that the check on [insideClosure] is not just an
+    // optimization: factories have type parameters as function
+    // parameters, and type parameters are declared in the class, not
+    // the factory.
+    if (insideClosure &&
+        element.enclosingElement != currentFunctionElement &&
+        element != currentFunctionElement) {
       assert(closureData.freeVariableMapping[element] == null ||
              closureData.freeVariableMapping[element] == element);
       closureData.freeVariableMapping[element] = element;
     } else if (inTryStatement) {
       // Don't mark the this-element. This would complicate things in the
       // builder.
       if (element != closureData.thisElement) {
         // TODO(ngeoffray): only do this if the variable is mutated.
         closureData.usedVariablesInTry.add(element);
       }
@@ skipping 66 matching lines @@
 
   visitSendSet(SendSet node) {
     Element element = elements[node];
     if (Elements.isLocal(element)) {
       mutatedVariables.add(element);
     }
     super.visitSendSet(node);
   }
 
   visitNewExpression(NewExpression node) {
+    TypeAnnotation annotation = node.send.getTypeAnnotation();
+    DartType type = elements.getType(annotation);
+
     bool hasTypeVariable(DartType type) {
       if (type is TypeVariableType) {
         return true;
       } else if (type is InterfaceType) {
         InterfaceType ifcType = type;
         for (DartType argument in ifcType.arguments) {
           if (hasTypeVariable(argument)) {
             return true;
           }
         }
       }
       return false;
     }
-    TypeAnnotation annotation = node.send.getTypeAnnotation();
-    DartType type = elements.getType(annotation);
-    if (hasTypeVariable(type)) {
-      // Factories do not use [this] to get the type variables.
-      if (closureData.thisElement !== null) {
-        useLocal(closureData.thisElement);
+
+    void analyzeTypeVariables(DartType type) {
+      if (type is TypeVariableType) {
+        useLocal(type.element);
+      } else if (type is InterfaceType) {
+        InterfaceType ifcType = type;
+        for (DartType argument in ifcType.arguments) {
+          analyzeTypeVariables(argument);
+        }
       }
     }
+
+    if (outermostFunctionElement.isInstanceMember() 
+        || outermostFunctionElement.isGenerativeConstructor()) {
+      if (hasTypeVariable(type)) useLocal(closureData.thisElement);
+    } else if (outermostFunctionElement.isFactoryConstructor()) {
+      analyzeTypeVariables(type);
+    }
+
     node.visitChildren(this);
   }
 
   // If variables that are declared in the [node] scope are captured and need
   // to be boxed create a box-element and update the [capturingScopes] in the
   // current [closureData].
   // The boxed variables are updated in the [capturedVariableMapping].
   void attachCapturedScopeVariables(Node node) {
     Element box = null;
     Map<Element, Element> scopeMapping = new Map<Element, Element>();
@@ skipping 77 matching lines @@
         const EmptyLink<Element>().prepend(callElement);
     // The nested function's 'this' is the same as the one for the outer
     // function. It could be [null] if we are inside a static method.
     Element thisElement = closureData.thisElement;
     return new ClosureClassMap(element, globalizedElement,
                                callElement, thisElement);
   }
 
   visitFunctionExpression(FunctionExpression node) {
     Element element = elements[node];
-    if (element.kind === ElementKind.PARAMETER) {
+    if (element.isParameter()) {
       // TODO(ahe): This is a hack. This method should *not* call
       // visitChildren.
       return node.name.accept(this);
     }
-    bool isClosure = (closureData !== null);
-
-    if (isClosure) closures.add(node);
 
     bool oldInsideClosure = insideClosure;
     FunctionElement oldFunctionElement = currentFunctionElement;
     ClosureClassMap oldClosureData = closureData;
 
-    insideClosure = isClosure;
-    currentFunctionElement = elements[node];
+    insideClosure = outermostFunctionElement != null;
+    currentFunctionElement = element;
     if (insideClosure) {
+      closures.add(node);
       closureData = globalizeClosure(node, element);
     } else {
+      outermostFunctionElement = element;
       Element thisElement = null;
-      // TODO(floitsch): we should not need to look for generative constructors.
-      // At the moment we store only one ClosureData for both the factory and
-      // the body.
-      if (element.isInstanceMember() ||
-          element.kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
-        // TODO(floitsch): currently all variables are considered to be
-        // declared in the GENERATIVE_CONSTRUCTOR. Including the 'this'.
-        Element thisEnclosingElement = element;
-        if (element.kind === ElementKind.GENERATIVE_CONSTRUCTOR_BODY) {
-          ConstructorBodyElement body = element;
-          thisEnclosingElement = body.constructor;
-        }
-        thisElement = new ThisElement(thisEnclosingElement);
+      if (element.isInstanceMember() || element.isGenerativeConstructor()) {
+        thisElement = new ThisElement(element);
       }
       closureData = new ClosureClassMap(null, null, null, thisElement);
     }
     closureMappingCache[node] = closureData;
 
     inNewScope(node, () {
       // We have to declare the implicit 'this' parameter.
       if (!insideClosure && closureData.thisElement !== null) {
         declareLocal(closureData.thisElement);
       }
       // If we are inside a named closure we have to declare ourselve. For
       // simplicity we declare the local even if the closure does not have a
       // name.
       // It will simply not be used.
       if (insideClosure) {
         declareLocal(element);
       }
+      
+      if (currentFunctionElement.isFactoryConstructor()) {
+        // Declare the type parameters in the scope. Generative
+        // constructors just use 'this'.
+        ClassElement cls = currentFunctionElement.enclosingElement;
+        cls.typeVariables.forEach((TypeVariableType typeVariable) {
+          declareLocal(typeVariable.element);
+        });
+      }
 
       // TODO(ahe): This is problematic. The backend should not repeat
       // the work of the resolver. It is the resolver's job to create
       // parameters, etc. Other phases should only visit statements.
       // TODO(floitsch): we avoid visiting the initializers on purpose so that
       // we get an error-message later in the builder.
       if (node.parameters !== null) node.parameters.accept(this);
       if (node.body !== null) node.body.accept(this);
     });
 
@@ skipping 26 matching lines @@
   }
 
   visitTryStatement(TryStatement node) {
     // TODO(ngeoffray): implement finer grain state.
     bool oldInTryStatement = inTryStatement;
     inTryStatement = true;
     node.visitChildren(this);
     inTryStatement = oldInTryStatement;
   }
 }