Ensure supertypes are loaded safely.

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 430 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(

[Lasse Reichstein Nielsen, 2012/08/13 13:34:48]

Make initialize a copy constructor instead.

[ahe, 2012/08/13 15:14:01]

I don't think I can do that. I got to keep the same instance around, for
example, to deal with a self-reference.

+        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 411 matching lines @@
       TypeVariableType variableType = new TypeVariableType(variableElement);
       variableElement.type = variableType;
       arguments.addLast(variableType);
     }
     return arguments.toLink();
   }
 }
 
 class ClassElement extends ContainerElement
     implements TypeDeclarationElement {
+  static final int STATE_NOT_STARTED = 0;
+  static final int STATE_STARTED = 1;
+  static final int STATE_DONE = 2;
+
   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;
+  Link<Type> interfaces;
+
+  int _supertypeLoadState = STATE_NOT_STARTED;
+  int get supertypeLoadState() => _supertypeLoadState;
+  void set supertypeLoadState(int state) {
+    assert(state == _supertypeLoadState + 1);

[Lasse Reichstein Nielsen, 2012/08/13 13:34:48]

Also assert that it's not larger than STATE_DONE.

[ahe, 2012/08/13 15:14:01]

Done.

+    _supertypeLoadState = state;
+  }
+
+  int _resolutionState = STATE_NOT_STARTED;
+  int get resolutionState() => _resolutionState;
+  void set resolutionState(int state) {
+    assert(state == _resolutionState + 1);
+    _resolutionState = state;
+  }
+
   // 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 (resolutionState == STATE_NOT_STARTED) {
+      compiler.resolver.resolveClass(this);
+    }
     return this;
   }
 
   Element lookupLocalMember(SourceString memberName) {
     return localMembers[memberName];
   }
 
   Element lookupSuperMember(SourceString memberName) {
     bool isPrivate = memberName.isPrivate();
     for (ClassElement s = superclass; s != null; s = s.superclass) {
@@ skipping 66 matching lines @@
     }
     return result;
   }
 
   /**
    * Returns the super class, if any.
    *
    * The returned element may not be resolved yet.
    */
   ClassElement get superclass() {
-    assert(isResolved);
+    assert(supertypeLoadState == STATE_DONE);
     return supertype === null ? null : supertype.element;
   }
 
   /**
    * Runs through all members of this class.
    *
    * The enclosing class is passed to the callback. This is useful when
    * [includeSuperMembers] is [:true:].
    */
   void forEachMember([void f(ClassElement enclosingClass, Element member),
@@ skipping 254 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()}";
 }