Ensure interfaces are loaded.

dart/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 207 matching lines @@
     if (annotation === null) return compiler.types.dynamicType;
     ResolverVisitor visitor = new ResolverVisitor(compiler, element);
     Type result = visitor.resolveTypeAnnotation(annotation);
     if (result === null) {
       // TODO(karklose): warning.
       return compiler.types.dynamicType;
     }
     return result;
   }
 
+  void loadSupertypes(ClassElement cls, Node from) {
+    compiler.withCurrentElement(cls, () => measure(() {
+      if (cls.supertypesAreLoaded) return;
+      if (cls.isLoadingSupertypes) {
+        compiler.reportMessage(
+          compiler.spanFromNode(from),
+          MessageKind.CYCLIC_CLASS_HIERARCHY.error([cls.name]),
+          api.Diagnostic.ERROR);
+        cls.allSupertypes = const EmptyLink<Type>().prepend(
+            compiler.objectClass.computeType(compiler));
+        return;
+      }
+      cls.isLoadingSupertypes = true;
+      compiler.withCurrentElement(cls, () {
+        // TODO(ahe): Cache the node in cls.
+        cls.parseNode(compiler).accept(new ClassSupertypeResolver(compiler,
+                                                                  cls));
+      });
+      cls.isLoadingSupertypes = false;
+      cls.supertypesAreLoaded = true;
+      toResolve.add(cls);
+    }));
+  }
+
+  /**
+   * Do not call this method directly. Instead use
+   * [:element.ensureResolved(compiler):].
+   */
   void resolveClass(ClassElement element) {
-    if (element.isResolved || element.isBeingResolved) return;
-    element.isBeingResolved = true;
-    measure(() {
+    compiler.withCurrentElement(element, () => measure(() {
+      assert(element.isBeingResolved && !element.isResolved);
+      loadSupertypes(element, null);
       ClassNode tree = element.parseNode(compiler);
+
       ClassResolverVisitor visitor =
         new ClassResolverVisitor(compiler, element);
       visitor.visit(tree);
       element.isBeingResolved = false;
       element.isResolved = true;
 
       while (!toResolve.isEmpty()) {
         ClassElement classElement = toResolve.removeFirst();
         classElement.ensureResolved(compiler);
       }
 
       checkMembers(element);
-    });
+    }));
   }
 
   checkMembers(ClassElement cls) {
     if (cls === compiler.objectClass) return;
     cls.forEachMember((holder, member) {
       checkAbstractField(member);
       checkValidOverride(member, cls.lookupSuperMember(member.name));
     });
   }
 
@@ skipping 25 matching lines @@
         compiler.spanFromElement(errorneousElement),
         errorMessage.error([contextElement.name,
                             contextElement.getEnclosingClass().name]),
         api.Diagnostic.ERROR);
     compiler.reportMessage(
         compiler.spanFromElement(contextElement),
         contextMessage.error(),
         api.Diagnostic.INFO);
   }
 
-
   void checkValidOverride(Element member, Element superMember) {
     if (superMember === null) return;
     if (member.modifiers.isStatic()) {
       reportErrorWithContext(
           member, MessageKind.NO_STATIC_OVERRIDE,
           superMember, MessageKind.NO_STATIC_OVERRIDE_CONT);
     } else {
       FunctionElement superFunction = superMember.asFunctionElement();
       FunctionElement function = member.asFunctionElement();
       if (superFunction === null || superFunction.isAccessor()) {
@@ skipping 460 matching lines @@
     if (element === null) {
       onFailure(node, MessageKind.CANNOT_RESOLVE_TYPE, [node.typeName]);
     } else if (!element.impliesType()) {
       onFailure(node, MessageKind.NOT_A_TYPE, [node.typeName]);
     } else {
       if (element === compiler.types.voidType.element ||
           element === compiler.types.dynamicType.element) {
         type = element.computeType(compiler);
       } else if (element.isClass()) {
         ClassElement cls = element;
-        if (!cls.isResolved) compiler.resolveClass(cls);
+        cls.ensureResolved(compiler);
         Link<Type> arguments =
             resolveTypeArguments(node, cls.typeVariables, scope,
                                  onFailure, whenResolved);
         if (cls.typeVariables.isEmpty() && arguments.isEmpty()) {
           // Use the canonical type if it has no type parameters.
           type = cls.computeType(compiler);
         } else {
           type = new InterfaceType(cls, arguments);
         }
       } else if (element.isTypedef()) {
@@ skipping 1118 matching lines @@
        type.element === compiler.boolClass ||
        type.element === compiler.numClass ||
        type.element === compiler.intClass ||
        type.element === compiler.doubleClass ||
        type.element === compiler.stringClass ||
        type.element === compiler.nullClass ||
        type.element === compiler.functionClass);
   }
 }
 
+class ClassSupertypeResolver extends CommonResolverVisitor {
+  Scope context;
+  ClassElement classElement;
+
+  ClassSupertypeResolver(Compiler compiler, ClassElement cls)
+    : context = new TopScope(cls.getLibrary()),
+      this.classElement = cls,
+      super(compiler);
+
+  void visitClassNode(ClassNode node) {
+    if (node.superclass === null) {
+      // TODO(ahe): Handle this.
+    } else {
+      node.superclass.accept(this);
+    }
+    if (node.interfaces === null) {
+      // TODO(ahe): Can this happen?
+    } else {
+      node.interfaces.accept(this);
+    }
+  }
+
+  void visitTypeAnnotation(TypeAnnotation node) {
+    node.typeName.accept(this);
+  }
+
+  void visitIdentifier(Identifier node) {
+    Element element = context.lookup(node.source);
+    if (element === null) {
+      error(node, MessageKind.CANNOT_RESOLVE_TYPE, [node]);
+    } else if (!element.impliesType()) {
+      error(node, MessageKind.NOT_A_TYPE, [node]);
+    } else {
+      if (element.isClass()) {
+        compiler.resolver.loadSupertypes(element, node);
+      } else {
+        compiler.reportMessage(
+          compiler.spanFromNode(node),
+          MessageKind.TYPE_NAME_EXPECTED.error([]),
+          api.Diagnostic.ERROR);
+      }
+    }
+  }
+
+  void visitNodeList(NodeList node) {
+    for (Link<Node> link = node.nodes; !link.isEmpty(); link = link.tail) {
+      visit(link.head);
+    }
+  }
+
+  void visitSend(Send node) {
+    Identifier prefix = node.receiver.asIdentifier();
+    if (prefix === null) {
+      error(node.receiver, MessageKind.NOT_A_PREFIX, [node.receiver]);
+      return;
+    }
+    Element element = context.lookup(prefix.source);
+    if (element === null || element.kind !== ElementKind.PREFIX) {
+      error(node.receiver, MessageKind.NOT_A_PREFIX, [node.receiver]);
+      return;
+    }
+    PrefixElement prefixElement = element;
+    Identifier selector = node.selector.asIdentifier();
+    var e = prefixElement.lookupLocalMember(selector.source);
+    if (e === null || !e.impliesType()) {
+      error(node.selector, MessageKind.CANNOT_RESOLVE_TYPE, [node.selector]);
+      return;
+    }
+    compiler.resolver.loadSupertypes(e, node);
+  }
+}
+
 class VariableDefinitionsVisitor extends CommonResolverVisitor<SourceString> {
   VariableDefinitions definitions;
   ResolverVisitor resolver;
   ElementKind kind;
   VariableListElement variables;
 
   VariableDefinitionsVisitor(Compiler compiler,
                              this.definitions, this.resolver, this.kind)
     : super(compiler)
   {
@@ skipping 382 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';
 }