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);
   Type getType(TypeAnnotation annotation);
 }
 
@@ skipping 927 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) {
     Type 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 285 matching lines @@
         && target.kind == ElementKind.ABSTRACT_FIELD) {
       AbstractFieldElement field = target;
       target = field.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);
+        Type type = resolveTypeTest(node.arguments.head);
+        if (type != null) {
+          compiler.enqueuer.resolution.registerIsCheck(type);
+        }
         resolvedArguments = true;
       }
     }
 
     if (!resolvedArguments) {
       resolveArguments(node.argumentsNode);
     }
 
     // If the selector is null, it means that we will not be generating
     // code for this as a send.
@@ skipping 238 matching lines @@
   Type resolveTypeRequired(TypeAnnotation node) {
     bool old = typeRequired;
     typeRequired = true;
     Type result = resolveTypeAnnotation(node);
     typeRequired = old;
     return result;
   }
 
   Type resolveTypeAnnotation(TypeAnnotation node) {
     Function report = typeRequired ? error : warning;
-    return typeResolver.resolveTypeAnnotation(node, inScope: scope,
-                                              onFailure: report,
-                                              whenResolved: useType);
+    Type type = typeResolver.resolveTypeAnnotation(node, inScope: scope,
+                                                   onFailure: report,
+                                                   whenResolved: useType);
+    if (compiler.enableTypeAssertions) {
+      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 230 matching lines @@
   visitCatchBlock(CatchBlock node) {
     Scope blockScope = new BlockScope(scope);
     if (node.formals.isEmpty()) {
       error(node, MessageKind.EMPTY_CATCH_DECLARATION);
     } else if (!node.formals.nodes.tail.isEmpty()
                && !node.formals.nodes.tail.tail.isEmpty()) {
       for (Node extra in node.formals.nodes.tail.tail) {
         error(extra, MessageKind.EXTRA_CATCH_DECLARATION);
       }
     }
-    visitIn(node.type, blockScope);
-    visitIn(node.formals, blockScope);
+    if (node.type != null) {
+      doInCheckContext(() => visitIn(node.type, blockScope));
+      visitIn(node.formals, blockScope);
+    } else {
+      // The type annotation for the exception type is on the first formal.
+      doInCheckContext(() => visitIn(node.formals.nodes.head, blockScope));
+      if (!node.formals.nodes.tail.isEmpty()) {
+        visitIn(node.formals.nodes.tail.head, blockScope);
+      }
+    }
     visitIn(node.block, blockScope);
   }
 
   visitTypedef(Typedef node) {
     unimplemented(node, 'typedef');
   }
 }
 
 class TypeDefinitionVisitor extends CommonResolverVisitor<Type> {
   Scope scope;
@@ skipping 765 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';
 }