Collect the types used in is-checks in the resolver phase.

lib/compiler/implementation/resolver.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.
 
 interface TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(TypeAnnotation annotation);
   bool isParameterChecked(Element element);
 }
@@ skipping 934 matching lines @@
     }
     return arguments.toLink();
   }
 }
 
 class ResolverVisitor extends CommonResolverVisitor<Element> {
   final TreeElementMapping mapping;
   final Element enclosingElement;
   final TypeResolver typeResolver;
   bool inInstanceContext;
+  bool inCheckContext;
   Scope scope;
   ClassElement currentClass;
   bool typeRequired = false;
   StatementScope statementScope;
   int allowedCategory = ElementCategory.VARIABLE | ElementCategory.FUNCTION;
 
   ResolverVisitor(Compiler compiler, Element element)
     : this.mapping  = new TreeElementMapping(),
       this.enclosingElement = element,
       // When the element is a field, we are actually resolving its
       // initial value, which should not have access to instance
       // fields.
       inInstanceContext = (element.isInstanceMember() && !element.isField())
           || element.isGenerativeConstructor(),
-      this.currentClass = element.isMember() ?
-                              element.getEnclosingClass() :
-                              null,
+      this.currentClass = element.isMember() ? element.getEnclosingClass()
+                                             : null,
       this.statementScope = new StatementScope(),
       typeResolver = new TypeResolver(compiler),
       scope = element.buildEnclosingScope(),
+      inCheckContext = compiler.enableTypeAssertions,
       super(compiler) {
   }
 
   Enqueuer get world => compiler.enqueuer.resolution;
 
   Element lookup(Node node, SourceString name) {
     Element result = scope.lookup(name);
     if (!inInstanceContext && result != null && result.isInstanceMember()) {
       error(node, MessageKind.NO_INSTANCE_AVAILABLE, [node]);
     }
     return result;
   }
 
   // Create, or reuse an already created, statement element for a statement.
   TargetElement getOrCreateTargetElement(Node statement) {
     TargetElement element = mapping[statement];
     if (element === null) {
       element = new TargetElement(statement,
                                      statementScope.nestingLevel,
                                      enclosingElement);
       mapping[statement] = element;
     }
     return element;
   }
 
+  doInCheckContext(action()) {
+    bool wasInCheckContext = inCheckContext;
+    inCheckContext = true;
+    var result = action();
+    inCheckContext = wasInCheckContext;
+    return result;
+  }
+
   inStaticContext(action()) {
     bool wasInstanceContext = inInstanceContext;
     inInstanceContext = false;
     var result = action();
     inInstanceContext = wasInstanceContext;
     return result;
   }
 
   visitInStaticContext(Node node) {
     inStaticContext(() => visit(node));
@@ skipping 20 matching lines @@
           // TODO(ahe): Improve error message. Need UX input.
           error(node, MessageKind.GENERIC, ["is not an expression $element"]);
         }
       }
       return useElement(node, element);
     }
   }
 
   Element visitTypeAnnotation(TypeAnnotation node) {
     DartType type = resolveTypeAnnotation(node);
-    if (type !== null) return type.element;
+    if (type !== null) {
+      if (inCheckContext) {
+        compiler.enqueuer.resolution.registerIsCheck(type);
+      }
+      return type.element;
+    }
     return null;
   }
 
   Element defineElement(Node node, Element element,
                         [bool doAddToScope = true]) {
     compiler.ensure(element !== null);
     mapping[node] = element;
     if (doAddToScope) {
       Element existing = scope.add(element);
       if (existing != element) {
@@ skipping 289 matching lines @@
         // TODO(karlklose): make this a runtime error.
         error(node.selector, MessageKind.CANNOT_RESOLVE_GETTER);
       }
     }
 
     bool resolvedArguments = false;
     if (node.isOperator) {
       String operatorString = node.selector.asOperator().source.stringValue;
       if (operatorString === 'is' || operatorString === 'as') {
         assert(node.arguments.tail.isEmpty());
-        resolveTypeTest(node.arguments.head);
+        DartType type = resolveTypeTest(node.arguments.head);
+        if (type != null) {
+          compiler.enqueuer.resolution.registerIsCheck(type);
+        }
         resolvedArguments = true;
       } else if (operatorString === '?') {
         Element parameter = mapping[node.receiver];
         if (parameter === null || parameter.kind !== ElementKind.PARAMETER) {
           error(node.receiver, MessageKind.PARAMETER_NAME_EXPECTED);
         } else {
           mapping.checkedParameters.add(parameter);
         }
       }
     }
@@ skipping 240 matching lines @@
   DartType resolveTypeRequired(TypeAnnotation node) {
     bool old = typeRequired;
     typeRequired = true;
     DartType result = resolveTypeAnnotation(node);
     typeRequired = old;
     return result;
   }
 
   DartType resolveTypeAnnotation(TypeAnnotation node) {
     Function report = typeRequired ? error : warning;
-    return typeResolver.resolveTypeAnnotation(node, inScope: scope,
-                                              onFailure: report,
-                                              whenResolved: useType);
+    DartType type = typeResolver.resolveTypeAnnotation(node, inScope: scope,
+                                                       onFailure: report,
+                                                       whenResolved: useType);
+    if (compiler.enableTypeAssertions && type != null) {

[ngeoffray, 2012/09/05 12:50:40]

use inCheckContext

[karlklose, 2012/09/06 11:04:02]

Done.

+      compiler.enqueuer.resolution.registerIsCheck(type);
+    }
+    return type;
   }
 
   visitModifiers(Modifiers node) {
     // TODO(ngeoffray): Implement this.
     unimplemented(node, 'modifiers');
   }
 
   visitLiteralList(LiteralList node) {
     NodeList arguments = node.typeArguments;
     if (arguments !== null) {
@@ skipping 254 matching lines @@
           error(modifier, MessageKind.PARAMETER_WITH_MODIFIER_IN_CATCH);
         }
         TypeAnnotation type = declaration.type;
         if (type !== null) {
           error(type, MessageKind.PARAMETER_WITH_TYPE_IN_CATCH);
         }
       }
     }
 
     Scope blockScope = new BlockScope(scope);
-    visitIn(node.type, blockScope);
+    doInCheckContext(() => visitIn(node.type, blockScope)); 
     visitIn(node.formals, blockScope);
     visitIn(node.block, blockScope);
   }
 
   visitTypedef(Typedef node) {
     unimplemented(node, 'typedef');
   }
 }
 
 class TypeDefinitionVisitor extends CommonResolverVisitor<DartType> {
@@ skipping 767 matching lines @@
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) {
     return library.find(name);
   }
 
   Element add(Element newElement) {
     throw "Cannot add an element in the top scope";
   }
   String toString() => '$element';
 }