Ensure interfaces are loaded.

dart/lib/compiler/implementation/elements/elements.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('elements');
 
 #import('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
 #import('../leg.dart');  // TODO(karlklose): we only need type.
 #import('../util/util.dart');
@@ skipping 422 matching lines @@
 
 class TypedefElement extends Element implements TypeDeclarationElement {
   Type cachedType;
   Typedef cachedNode;
 
   TypedefElement(SourceString name, Element enclosing)
       : super(name, ElementKind.TYPEDEF, enclosing);
 
   Type computeType(Compiler compiler) {
     if (cachedType !== null) return cachedType;
-    cachedType = compiler.computeFunctionType(
-        this, compiler.resolveTypedef(this));
+    cachedType = new FunctionType(null, null, this);
+    cachedType.initializeFrom(
+        compiler.computeFunctionType(this, compiler.resolveTypedef(this)));
     return cachedType;
   }
 
   Link<Type> get typeVariables() => const EmptyLink<Type>();
 
   Scope buildScope() =>
       new TypeDeclarationScope(enclosingElement.buildScope(), this);
 }
 
 class VariableElement extends Element {
@@ skipping 421 matching lines @@
   final int id;
   InterfaceType type;
   Type supertype;
   Type defaultClass;
   Link<Element> members = const EmptyLink<Element>();
   Map<SourceString, Element> localMembers;
   Map<SourceString, Element> constructors;
   Link<Type> interfaces = const EmptyLink<Type>();
   bool isResolved = false;
   bool isBeingResolved = false;
+  bool isLoadingSupertypes = false;
+  bool supertypesAreLoaded = false;

[Lasse Reichstein Nielsen, 2012/08/07 09:02:17]

Should we consider some kind of "state" type with "uninitialized",
"initializing", "initialized" states? I'm think I'm seeing this pattern a little
too often!

+
   // backendMembers are members that have been added by the backend to simplify
   // compilation. They don't have any user-side counter-part.
   Link<Element> backendMembers = const EmptyLink<Element>();
 
   Link<Type> allSupertypes;
   ClassElement patch = null;
 
   ClassElement(SourceString name, CompilationUnitElement enclosing, this.id)
     : localMembers = new Map<SourceString, Element>(),
       constructors = new Map<SourceString, Element>(),
@@ skipping 18 matching lines @@
       Link<Type> parameters =
           TypeDeclarationElement.createTypeVariables(this, node.typeParameters);
       type = new InterfaceType(this, parameters);
     }
     return type;
   }
 
   Link<Type> get typeVariables() => type.arguments;
 
   ClassElement ensureResolved(Compiler compiler) {
-    compiler.resolveClass(this);
+    if (!isResolved && !isBeingResolved) {
+      isBeingResolved = true;
+      compiler.resolver.resolveClass(this);

[Lasse Reichstein Nielsen, 2012/08/07 09:02:17]

This looks like the job for a work queue. 
Can't we just queue this instead of doing it immediately?
It seems that all this boolean-fiddling is to handle recursive dependencies, so
we must be able to handle that sometimes the resolving isn't completely done
when we return. Why not just do that all the time then?
Then we just need one bit: isResolved, and the "being resolved" is represented
by being in the queue.

+      isBeingResolved = false;
+      isResolved = true;
+    }
     return this;
   }
 
   Element lookupLocalMember(SourceString memberName) {
     return localMembers[memberName];
   }
 
   Element lookupSuperMember(SourceString memberName) {
     for (ClassElement s = superclass; s != null; s = s.superclass) {
       Element e = s.lookupLocalMember(memberName);
       if (e === null) continue;
       // Private members from a different library are not visible.
       if (memberName.isPrivate() && getLibrary() !== e.getLibrary()) continue;
       // Static members are not inherited.
       if (e.modifiers.isStatic()) continue;
       return e;
     }
+    if (isInterface()) {
+      return lookupSuperInterfaceMember(memberName, getLibrary());
+    }
     return null;
   }
 
+  Element lookupSuperInterfaceMember(SourceString memberName,
+                                     LibraryElement fromLibrary) {
+    for (Type t in interfaces) {
+      Element e = t.element.lookupLocalMember(memberName);
+      if (e === null) continue;
+      // Private members from a different library are not visible.
+      if (memberName.isPrivate() && fromLibrary !== e.getLibrary()) continue;
+      // Static members are not inherited.
+      if (e.modifiers.isStatic()) continue;
+      return e;
+    }
+  }
+
   /**
    * Find the first member in the class chain with the given
    * [memberName]. This method is NOT to be used for resolving
    * unqualified sends because it does not implement the scoping
    * rules, where library scope comes before superclass scope.
    */
   Element lookupMember(SourceString memberName) {
     Element localMember = localMembers[memberName];
     return localMember === null ? lookupSuperMember(memberName) : localMember;
   }
@@ skipping 293 matching lines @@
   TypeVariableElement(name, Element enclosing, this.cachedNode,
                       [this.type, this.bound])
     : super(name, ElementKind.TYPE_VARIABLE, enclosing);
 
   TypeVariableType computeType(compiler) => type;
 
   Node parseNode(compiler) => cachedNode;
 
   String toString() => "${enclosingElement.toString()}.${name.slowToString()}";
 }