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 465 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);
 
   TypedefElement cloneTo(Element enclosing, DiagnosticListener listener) {
     TypedefElement result = new TypedefElement(name, enclosing);
@@ skipping 474 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>();
-
-  LinkedHashMap<SourceString, TypeVariableElement> typeParameters;
+  Link<Type> interfaces;
   SourceString nativeName;
 
-  bool isResolved = false;
-  bool isBeingResolved = false;
+  int _supertypeLoadState = STATE_NOT_STARTED;
+  int get supertypeLoadState() => _supertypeLoadState;
+  void set supertypeLoadState(int state) {
+    assert(state == _supertypeLoadState + 1);
+    assert(state <= STATE_DONE);
+    _supertypeLoadState = state;
+  }

[Lasse Reichstein Nielsen, 2012/08/14 08:40:36]

I'd prefer putting getters/setters after the constructor, so constructors are
the first code in the class.

[ahe, 2012/08/14 11:10:42]

Agreed. In addition, I don't like Dart's privacy. I feel I have cleaned it up in
https://chromiumcodereview.appspot.com/10823311/.

+
+  int _resolutionState = STATE_NOT_STARTED;
+  int get resolutionState() => _resolutionState;
+  void set resolutionState(int state) {
+    assert(state == _resolutionState + 1);
+    assert(state <= STATE_DONE);
+    _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(SourceString name, Element enclosing, this.id)
     : localMembers = new Map<SourceString, Element>(),
       constructors = new Map<SourceString, Element>(),
       super(name, ElementKind.CLASS, enclosing);
@@ skipping 17 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 63 matching lines @@
     return false;
   }
 
   bool isInterface() => false;
   bool isNative() => nativeName != null;
   int hashCode() => id;
 
   Scope buildScope() =>
       new ClassScope(enclosingElement.buildScope(), this);
 
-  void cloneMembersTo(Element target, DiagnosticListener listener) {
-    target.type = type;
-    target.supertype = supertype;
-    target.defaultClass = defaultClass;
-    target.interfaces = interfaces;
-    if (typeParameters !== null) {
-      target.typeParameters =
-          new LinkedHashMap<SourceString, TypeVariableElement>();
-      typeParameters.forEach((SourceString name, TypeVariableElement type) {
-        target.typeParameters[name] = type.cloneTo(target, listener);
-      });
-    }
-    target.nativeName = nativeName;
-    target.isResolved = isResolved;
-    target.isBeingResolved = isBeingResolved;
-    target.allSupertypes = allSupertypes;
-    if (!backendMembers.isEmpty()) {
-      listener.cancel("Cloning backend-modified class.", element: this);
-    }
-
-    Link<Element> elementList = this.members;
-    while (!elementList.isEmpty()) {
-      target.addMember(elementList.head.cloneTo(target, listener), listener);
-      elementList = elementList.tail;
-    }
-  }
-
   ClassElement cloneTo(Element enclosing, DiagnosticListener listener) {
-    // TODO(lrn): Is copying id acceptable?
-    ClassElement result = new ClassElement(name, enclosing, id);
-    cloneMembersTo(result, listener);
-    return result;
+    listener.internalErrorOnElement(this, 'unsupported operation');
   }
 }
 
 class Elements {
   static bool isLocal(Element element) {
     return ((element !== null)
             && !element.isInstanceMember()
             && !isStaticOrTopLevelField(element)
             && !isStaticOrTopLevelFunction(element)
             && (element.kind === ElementKind.VARIABLE ||
@@ skipping 177 matching lines @@
   Node parseNode(compiler) => cachedNode;
 
   String toString() => "${enclosingElement.toString()}.${name.slowToString()}";
 
   TypeVariableElement cloneTo(Element enclosing, DiagnosticListener listener) {
     TypeVariableElement result =
         new TypeVariableElement(name, enclosing, node, type, bound);
     return result;
   }
 }