Enable full type-checks in checked mode.

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 372 matching lines @@
         // TODO(ngeoffray): only do this if the variable is mutated.
         closureData.usedVariablesInTry.add(element);
       }
     }
   }
 
   void declareLocal(Element element) {
     scopeVariables.add(element);
   }
 
+  void registerNeedsThis() {
+    if (closureData.thisElement != null) {
+      useLocal(closureData.thisElement);
+    }
+  }
+
   visit(Node node) => node.accept(this);
 
   visitNode(Node node) => node.visitChildren(this);
 
   visitVariableDefinitions(VariableDefinitions node) {
+    if (node.type != null) {
+      visit(node.type);
+    }
     for (Link<Node> link = node.definitions.nodes;
          !link.isEmpty;
          link = link.tail) {
       Node definition = link.head;
       Element element = elements[definition];
       assert(element != null);
       declareLocal(element);
       // We still need to visit the right-hand sides of the init-assignments.
       // For SendSets don't visit the left again. Otherwise it would be marked
       // as mutated.
       if (definition is Send) {
         Send assignment = definition;
         Node arguments = assignment.argumentsNode;
         if (arguments != null) {
           visit(arguments);
         }
       } else {
         visit(definition);
       }
     }
   }
 
+  visitTypeAnnotation(TypeAnnotation node) {
+    if (compiler.enableTypeAssertions && currentElement.isInstanceMember()) {
+      DartType type = elements.getType(node);
+      // In checked mode, using a type variable in a type annotation may lead
+      // to a runtime type check that needs to access the type argument and
+      // therefore the closure needs a this-element.
+      // TODO(karlklose,johnniwinther): if the type is null, the annotation is
+      // from a parameter which has been analyzed before the method has been
+      // resolved and the result has been thrown away.
+      if (type != null && type.containsTypeVariables) {
+        registerNeedsThis();
+      }
+    }
+    node.visitChildren(this);
+  }
+
   visitIdentifier(Identifier node) {
     if (node.isThis()) {
-      useLocal(closureData.thisElement);
+      registerNeedsThis();
     } else {
       Element element = elements[node];
       if (element != null && element.kind == ElementKind.TYPE_VARIABLE) {
-        useLocal(closureData.thisElement);
+        registerNeedsThis();
       }
     }
     node.visitChildren(this);
   }
 
   visitSend(Send node) {
     Element element = elements[node];
     if (Elements.isLocal(element)) {
       useLocal(element);
     } else if (node.receiver == null &&
                Elements.isInstanceSend(node, elements)) {
-      useLocal(closureData.thisElement);
+      registerNeedsThis();
     } else if (node.isSuperCall) {
-      useLocal(closureData.thisElement);
+      registerNeedsThis();
     } else if (node.isParameterCheck) {
       Element parameter = elements[node.receiver];
       FunctionElement enclosing = parameter.enclosingElement;
       FunctionExpression function = enclosing.parseNode(compiler);
       ClosureClassMap cached = closureMappingCache[function];
       if (!cached.parametersWithSentinel.containsKey(parameter)) {
         SourceString parameterName = parameter.name;
         String name = '${parameterName.slowToString()}_check';
         Element newElement = new CheckVariableElement(new SourceString(name),
                                                       parameter,
                                                       enclosing);
         useLocal(newElement);
         cached.parametersWithSentinel[parameter] = newElement;
       }
     }
     node.visitChildren(this);
   }
 
   visitSendSet(SendSet node) {
     Element element = elements[node];
     if (Elements.isLocal(element)) {
       mutatedVariables.add(element);
     }
+    if (Elements.isLocal(element) &&
+        element.computeType(compiler).containsTypeVariables) {
+      registerNeedsThis();
+    }
     super.visitSendSet(node);
   }
 
   visitNewExpression(NewExpression node) {
     DartType type = elements.getType(node);
 
     bool hasTypeVariable(DartType type) {
       if (type is TypeVariableType) {
         return true;
       } else if (type is InterfaceType) {
@@ skipping 16 matching lines @@
           analyzeTypeVariables(argument);
         }
       }
     }
 
     if (outermostElement.isMember() &&
         compiler.backend.needsRti(outermostElement.getEnclosingClass())) {
       if (outermostElement.isConstructor() || outermostElement.isField()) {
         analyzeTypeVariables(type);
       } else if (outermostElement.isInstanceMember()) {
-        if (hasTypeVariable(type)) useLocal(closureData.thisElement);
+        if (hasTypeVariable(type)) {
+          registerNeedsThis();
+        }
       }
     }
 
     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].
@@ skipping 151 matching lines @@
       if (currentElement.isFactoryConstructor() &&
           compiler.backend.needsRti(currentElement.enclosingElement)) {
         // Declare the type parameters in the scope. Generative
         // constructors just use 'this'.
         ClassElement cls = currentElement.enclosingElement;
         cls.typeVariables.forEach((TypeVariableType typeVariable) {
           declareLocal(typeVariable.element);
         });
       }
 
+      // Compute the function type and check for type variables in return or
+      // parameter types.
+      if (element.computeType(compiler).containsTypeVariables) {
+        registerNeedsThis();
+      }
+
       visitChildren();
     });
 
 
     ClosureClassMap savedClosureData = closureData;
     bool savedInsideClosure = insideClosure;
 
     // Restore old values.
     insideClosure = oldInsideClosure;
     closureData = oldClosureData;
@@ skipping 37 matching lines @@
   }
 
   visitTryStatement(TryStatement node) {
     // TODO(ngeoffray): implement finer grain state.
     bool oldInTryStatement = inTryStatement;
     inTryStatement = true;
     node.visitChildren(this);
     inTryStatement = oldInTryStatement;
   }
 }