Revert "Reapply "Implement new model for class members." and "Implement new model for interface mem…

sdk/lib/_internal/compiler/implementation/resolution/members.dart

Index: sdk/lib/_internal/compiler/implementation/resolution/members.dart
diff --git a/sdk/lib/_internal/compiler/implementation/resolution/members.dart b/sdk/lib/_internal/compiler/implementation/resolution/members.dart
index 3f03c4edecebf9a8694f1008537b8fb896b078fd..152863d7fd380726887b4eef417ecb56e5ea0ff6 100644
--- a/sdk/lib/_internal/compiler/implementation/resolution/members.dart
+++ b/sdk/lib/_internal/compiler/implementation/resolution/members.dart
@@ -675,14 +675,12 @@ class ResolverTask extends CompilerTask {
         compiler.reportError(from, MessageKind.CYCLIC_CLASS_HIERARCHY,
                                  {'className': cls.name});
         cls.supertypeLoadState = STATE_DONE;
-        cls.hasIncompleteHierarchy = true;
         cls.allSupertypesAndSelf =
             compiler.objectClass.allSupertypesAndSelf.extendClass(
                 cls.computeType(compiler));
         cls.supertype = cls.allSupertypes.head;
         assert(invariant(from, cls.supertype != null,
             message: 'Missing supertype on cyclic class $cls.'));
-        cls.interfaces = const Link<DartType>();
         return;
       }
       cls.supertypeLoadState = STATE_STARTED;
@@ -699,39 +697,8 @@ class ResolverTask extends CompilerTask {
 
   // TODO(johnniwinther): Remove this queue when resolution has been split into
   // syntax and semantic resolution.
-  TypeDeclarationElement currentlyResolvedTypeDeclaration;
+  ClassElement currentlyResolvedClass;
   Queue<ClassElement> pendingClassesToBeResolved = new Queue<ClassElement>();
-  Queue<ClassElement> pendingClassesToBePostProcessed =
-      new Queue<ClassElement>();
-
-  /// Resolve [element] using [resolveTypeDeclaration].
-  ///
-  /// This methods ensure that class declarations encountered through type
-  /// annotations during the resolution of [element] are resolved after
-  /// [element] has been resolved.
-  // TODO(johnniwinther): Encapsulate this functionality in a
-  // 'TypeDeclarationResolver'.
-  void _resolveTypeDeclaration(TypeDeclarationElement element,
-                               resolveTypeDeclaration()) {
-    TypeDeclarationElement previousResolvedTypeDeclaration =
-        currentlyResolvedTypeDeclaration;
-    currentlyResolvedTypeDeclaration = element;
-    resolveTypeDeclaration();
-    if (previousResolvedTypeDeclaration == null) {
-      do {
-        while (!pendingClassesToBeResolved.isEmpty) {
-          pendingClassesToBeResolved.removeFirst().ensureResolved(compiler);
-        }
-        while (!pendingClassesToBePostProcessed.isEmpty) {
-          _postProcessClassElement(
-              pendingClassesToBePostProcessed.removeFirst());
-        }
-      } while (!pendingClassesToBeResolved.isEmpty);
-      assert(pendingClassesToBeResolved.isEmpty);
-      assert(pendingClassesToBePostProcessed.isEmpty);
-    }
-    currentlyResolvedTypeDeclaration = previousResolvedTypeDeclaration;
-  }
 
   /**
    * Resolve the class [element].
@@ -745,15 +712,21 @@ class ResolverTask extends CompilerTask {
    * [:element.ensureResolved(compiler):].
    */
   void resolveClass(ClassElement element) {
-    _resolveTypeDeclaration(element, () {
-      // TODO(johnniwinther): Store the mapping in the resolution enqueuer.
-      TreeElementMapping mapping = new TreeElementMapping(element);
-      resolveClassInternal(element, mapping);
-    });
+    ClassElement previousResolvedClass = currentlyResolvedClass;
+    currentlyResolvedClass = element;
+    // TODO(johnniwinther): Store the mapping in the resolution enqueuer.
+    TreeElementMapping mapping = new TreeElementMapping(element);
+    resolveClassInternal(element, mapping);
+    if (previousResolvedClass == null) {
+      while (!pendingClassesToBeResolved.isEmpty) {
+        pendingClassesToBeResolved.removeFirst().ensureResolved(compiler);
+      }
+    }
+    currentlyResolvedClass = previousResolvedClass;
   }
 
   void _ensureClassWillBeResolved(ClassElement element) {
-    if (currentlyResolvedTypeDeclaration == null) {
+    if (currentlyResolvedClass == null) {
       element.ensureResolved(compiler);
     } else {
       pendingClassesToBeResolved.add(element);
@@ -774,7 +747,6 @@ class ResolverTask extends CompilerTask {
         visitor.visit(tree);
         element.resolutionState = STATE_DONE;
         compiler.onClassResolved(element);
-        pendingClassesToBePostProcessed.add(element);
       }));
       if (element.isPatched) {
         // Ensure handling patch after origin.
@@ -797,9 +769,6 @@ class ResolverTask extends CompilerTask {
       // TODO(johnniwinther): Check matching type variables and
       // empty extends/implements clauses.
     }
-  }
-
-  void _postProcessClassElement(BaseClassElementX element) {
     for (MetadataAnnotation metadata in element.metadata) {
       metadata.ensureResolved(compiler);
       if (!element.isProxy && metadata.value == compiler.proxyConstant) {
@@ -821,8 +790,6 @@ class ResolverTask extends CompilerTask {
         });
       }
     });
-
-    MembersCreator.computeClassMembers(compiler, element);
   }
 
   void checkClass(ClassElement element) {
@@ -1026,6 +993,7 @@ class ResolverTask extends CompilerTask {
     bool isMinus = false;
     int requiredParameterCount;
     MessageKind messageKind;
+    FunctionSignature signature = function.computeSignature(compiler);
     if (identical(value, 'unary-')) {
       isMinus = true;
       messageKind = MessageKind.MINUS_OPERATOR_BAD_ARITY;
@@ -1127,7 +1095,10 @@ class ResolverTask extends CompilerTask {
         errorMessage,
         {'memberName': contextElement.name,
          'className': contextElement.getEnclosingClass().name});
-    compiler.reportInfo(contextElement, contextMessage);
+    compiler.reportMessage(
+        compiler.spanFromElement(contextElement),
+        contextMessage.error(),
+        Diagnostic.INFO);
   }
 
   void checkValidOverride(Element member, Element superMember) {
@@ -1195,20 +1166,18 @@ class ResolverTask extends CompilerTask {
 
   TreeElements resolveTypedef(TypedefElementX element) {
     if (element.isResolved) return element.mapping;
-    _resolveTypeDeclaration(element, () {
-      TreeElementMapping mapping = new TreeElementMapping(element);
-      // TODO(johnniwinther): Store the mapping in the resolution enqueuer.
-      element.mapping = mapping;
-      return compiler.withCurrentElement(element, () {
-        return measure(() {
-          Typedef node =
-            compiler.parser.measure(() => element.parseNode(compiler));
-          TypedefResolverVisitor visitor =
-            new TypedefResolverVisitor(compiler, element, mapping);
-          visitor.visit(node);
-
-          return mapping;
-        });
+    TreeElementMapping mapping = new TreeElementMapping(element);
+    // TODO(johnniwinther): Store the mapping in the resolution enqueuer.
+    element.mapping = mapping;
+    return compiler.withCurrentElement(element, () {
+      return measure(() {
+        Typedef node =
+          compiler.parser.measure(() => element.parseNode(compiler));
+        TypedefResolverVisitor visitor =
+          new TypedefResolverVisitor(compiler, element, mapping);
+        visitor.visit(node);
+
+        return mapping;
       });
     });
   }
@@ -3894,11 +3863,8 @@ class ClassResolverVisitor extends TypeDefinitionVisitor {
       }
     }
 
-    if (element.interfaces == null) {
-      element.interfaces = resolveInterfaces(node.interfaces, node.superclass);
-    } else {
-      assert(invariant(element, element.hasIncompleteHierarchy));
-    }
+    assert(element.interfaces == null);
+    element.interfaces = resolveInterfaces(node.interfaces, node.superclass);
     calculateAllSupertypes(element);
 
     if (!element.hasConstructor) {
@@ -3972,7 +3938,7 @@ class ClassResolverVisitor extends TypeDefinitionVisitor {
         element.getCompilationUnit(),
         compiler.getNextFreeClassId(),
         node,
-        new Modifiers.withFlags(new NodeList.empty(), Modifiers.FLAG_ABSTRACT));
+        Modifiers.EMPTY);  // TODO(kasperl): Should this be abstract?
     // Create synthetic type variables for the mixin application.
     LinkBuilder<DartType> typeVariablesBuilder = new LinkBuilder<DartType>();
     element.typeVariables.forEach((TypeVariableType type) {
@@ -4044,20 +4010,13 @@ class ClassResolverVisitor extends TypeDefinitionVisitor {
     // The class that is the result of a mixin application implements
     // the interface of the class that was mixed in so always prepend
     // that to the interface list.
-    if (mixinApplication.interfaces == null) {
-      if (mixinType.kind == TypeKind.INTERFACE) {
-        // Avoid malformed types in the interfaces.
-        interfaces = interfaces.prepend(mixinType);
-      }
-      mixinApplication.interfaces = interfaces;
-    } else {
-      assert(invariant(mixinApplication,
-          mixinApplication.hasIncompleteHierarchy));
-    }
+
+    interfaces = interfaces.prepend(mixinType);
+    assert(mixinApplication.interfaces == null);
+    mixinApplication.interfaces = interfaces;
 
     ClassElement superclass = supertype.element;
     if (mixinType.kind != TypeKind.INTERFACE) {
-      mixinApplication.hasIncompleteHierarchy = true;
       mixinApplication.allSupertypesAndSelf = superclass.allSupertypesAndSelf;
       return;
     }