Clean up state handling in ClassElement.

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('dart:uri');
 
 #import('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
@@ skipping 975 matching lines @@
    * Creates the type variables, their type and corresponding element, for the
    * type variables declared in [parameter] on [element]. The bounds of the type
    * variables are not set until [element] has been resolved.
    */
   static Link<Type> createTypeVariables(TypeDeclarationElement element,
                                         NodeList parameters) {
     if (parameters === null) return const EmptyLink<Type>();
 
     // Create types and elements for type variable.
     var arguments = new LinkBuilder<Type>();
-    for (Link<Node> link = parameters.nodes; !link.isEmpty(); link = link.tail) {
+    for (Link link = parameters.nodes; !link.isEmpty(); link = link.tail) {
       TypeVariable node = link.head;
       SourceString variableName = node.name.source;
       TypeVariableElement variableElement =
           new TypeVariableElement(variableName, element, node);
       TypeVariableType variableType = new TypeVariableType(variableElement);
       variableElement.type = variableType;
       arguments.addLast(variableType);
     }
     return arguments.toLink();
   }
 }
 
 class ClassElement extends ScopeContainerElement
     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<Type> interfaces;
   SourceString nativeName;
-
-  int _supertypeLoadState = STATE_NOT_STARTED;
-  int get supertypeLoadState() => _supertypeLoadState;
-  void set supertypeLoadState(int state) {
-    assert(state == _supertypeLoadState + 1);
-    assert(state <= STATE_DONE);
-    _supertypeLoadState = state;
-  }
-
-  int _resolutionState = STATE_NOT_STARTED;
-  int get resolutionState() => _resolutionState;
-  void set resolutionState(int state) {
-    assert(state == _resolutionState + 1);
-    assert(state <= STATE_DONE);
-    _resolutionState = state;
-  }
+  int supertypeLoadState;
+  int resolutionState;
 
   // 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;
 
   // Lazily applied patch of class members.
   ClassElement patch = null;
 
-  ClassElement(SourceString name, Element enclosing, this.id)
-    : super(name, ElementKind.CLASS, enclosing);
+  ClassElement(SourceString name, Element enclosing, this.id, int initialState)
+    : supertypeLoadState = initialState,
+      resolutionState = initialState,
+      super(name, ElementKind.CLASS, enclosing);
 
   InterfaceType computeType(compiler) {
     if (type == null) {
       ClassNode node = parseNode(compiler);
       Link<Type> parameters =
           TypeDeclarationElement.createTypeVariables(this, node.typeParameters);
       type = new InterfaceType(this, parameters);
     }
     return type;
   }
@@ skipping 451 matching lines @@
   Node parseNode(compiler) => cachedNode;
 
   String toString() => "${enclosingElement.toString()}.${name.slowToString()}";
 
   TypeVariableElement cloneTo(Element enclosing, DiagnosticListener listener) {
     TypeVariableElement result =
         new TypeVariableElement(name, enclosing, cachedNode, type, bound);
     return result;
   }
 }