Reapply "Implement new model for class members." and "Implement new model for interface members."

sdk/lib/_internal/compiler/implementation/resolution/members.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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Setlet<Node> get superUses;
 
@@ skipping 657 matching lines @@
    * Warning: do not call this method directly. It should only be
    * called by [resolveClass] and [ClassSupertypeResolver].
    */
   void loadSupertypes(BaseClassElementX cls, Spannable from) {
     compiler.withCurrentElement(cls, () => measure(() {
       if (cls.supertypeLoadState == STATE_DONE) return;
       if (cls.supertypeLoadState == STATE_STARTED) {
         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;
       compiler.withCurrentElement(cls, () {
         // TODO(ahe): Cache the node in cls.
         cls.parseNode(compiler).accept(
             new ClassSupertypeResolver(compiler, cls));
         if (cls.supertypeLoadState != STATE_DONE) {
           cls.supertypeLoadState = STATE_DONE;
         }
       });
     }));
   }
 
   // TODO(johnniwinther): Remove this queue when resolution has been split into
   // syntax and semantic resolution.
-  ClassElement currentlyResolvedClass;
+  TypeDeclarationElement currentlyResolvedTypeDeclaration;
   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'.
+  _resolveTypeDeclaration(TypeDeclarationElement element,
+                          resolveTypeDeclaration()) {
+    TypeDeclarationElement previousResolvedTypeDeclaration =
+        currentlyResolvedTypeDeclaration;
+    currentlyResolvedTypeDeclaration = element;
+    var result = 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;
+    return result;
+  }
 
   /**
    * Resolve the class [element].
    *
    * Before calling this method, [element] was constructed by the
    * scanner and most fields are null or empty. This method fills in
    * these fields and also ensure that the supertypes of [element] are
    * resolved.
    *
    * Warning: Do not call this method directly. Instead use
    * [:element.ensureResolved(compiler):].
    */
   void resolveClass(ClassElement element) {
-    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;
+    _resolveTypeDeclaration(element, () {
+      // TODO(johnniwinther): Store the mapping in the resolution enqueuer.
+      TreeElementMapping mapping = new TreeElementMapping(element);
+      resolveClassInternal(element, mapping);
+    });
   }
 
   void _ensureClassWillBeResolved(ClassElement element) {
-    if (currentlyResolvedClass == null) {
+    if (currentlyResolvedTypeDeclaration == null) {
       element.ensureResolved(compiler);
     } else {
       pendingClassesToBeResolved.add(element);
     }
   }
 
   void resolveClassInternal(BaseClassElementX element,
                             TreeElementMapping mapping) {
     if (!element.isPatch) {
       compiler.withCurrentElement(element, () => measure(() {
         assert(element.resolutionState == STATE_NOT_STARTED);
         element.resolutionState = STATE_STARTED;
         Node tree = element.parseNode(compiler);
         loadSupertypes(element, tree);
 
         ClassResolverVisitor visitor =
             new ClassResolverVisitor(compiler, element, mapping);
         visitor.visit(tree);
         element.resolutionState = STATE_DONE;
         compiler.onClassResolved(element);
+        pendingClassesToBePostProcessed.add(element);
       }));
       if (element.isPatched) {
         // Ensure handling patch after origin.
         element.patch.ensureResolved(compiler);
       }
     } else { // Handle patch classes:
       element.resolutionState = STATE_STARTED;
       // Ensure handling origin before patch.
       element.origin.ensureResolved(compiler);
       // Ensure that the type is computed.
       element.computeType(compiler);
       // Copy class hiearchy from origin.
       element.supertype = element.origin.supertype;
       element.interfaces = element.origin.interfaces;
       element.allSupertypesAndSelf = element.origin.allSupertypesAndSelf;
       // Stepwise assignment to ensure invariant.
       element.supertypeLoadState = STATE_STARTED;
       element.supertypeLoadState = STATE_DONE;
       element.resolutionState = STATE_DONE;
       // 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) {
         element.isProxy = true;
       }
     }
 
     // Force resolution of metadata on non-instance members since they may be
     // inspected by the backend while emitting. Metadata on instance members is
     // handled as a result of processing instantiated class members in the
     // enqueuer.
     // TODO(ahe): Avoid this eager resolution.
     element.forEachMember((_, Element member) {
       if (!member.isInstanceMember()) {
         compiler.withCurrentElement(member, () {
           for (MetadataAnnotation metadata in member.metadata) {
             metadata.ensureResolved(compiler);
           }
         });
       }
     });
+
+    MembersCreator.computeClassMembers(compiler, element);
   }
 
   void checkClass(ClassElement element) {
     if (element.isMixinApplication) {
       checkMixinApplication(element);
     } else {
       checkClassMembers(element);
     }
   }
 
@@ skipping 183 matching lines @@
   void checkUserDefinableOperator(Element member) {
     FunctionElement function = member.asFunctionElement();
     if (function == null) return;
     String value = member.name;
     if (value == null) return;
     if (!(isUserDefinableOperator(value) || identical(value, 'unary-'))) return;
 
     bool isMinus = false;
     int requiredParameterCount;
     MessageKind messageKind;
-    FunctionSignature signature = function.computeSignature(compiler);
     if (identical(value, 'unary-')) {
       isMinus = true;
       messageKind = MessageKind.MINUS_OPERATOR_BAD_ARITY;
       requiredParameterCount = 0;
     } else if (isMinusOperator(value)) {
       isMinus = true;
       messageKind = MessageKind.MINUS_OPERATOR_BAD_ARITY;
       requiredParameterCount = 1;
     } else if (isUnaryOperator(value)) {
       messageKind = MessageKind.UNARY_OPERATOR_BAD_ARITY;
@@ skipping 81 matching lines @@
 
   reportErrorWithContext(Element errorneousElement,
                          MessageKind errorMessage,
                          Element contextElement,
                          MessageKind contextMessage) {
     compiler.reportError(
         errorneousElement,
         errorMessage,
         {'memberName': contextElement.name,
          'className': contextElement.getEnclosingClass().name});
-    compiler.reportMessage(
-        compiler.spanFromElement(contextElement),
-        contextMessage.error(),
-        Diagnostic.INFO);
+    compiler.reportInfo(contextElement, contextMessage);
   }
 
   void checkValidOverride(Element member, Element superMember) {
     if (superMember == null) return;
     if (member.modifiers.isStatic()) {
       reportErrorWithContext(
           member, MessageKind.NO_STATIC_OVERRIDE,
           superMember, MessageKind.NO_STATIC_OVERRIDE_CONT);
     } else {
       FunctionElement superFunction = superMember.asFunctionElement();
@@ skipping 47 matching lines @@
   }
 
   FunctionSignature resolveFunctionExpression(Element element,
                                               FunctionExpression node) {
     return measure(() => SignatureResolver.analyze(
       compiler, node.parameters, node.returnType, element));
   }
 
   TreeElements resolveTypedef(TypedefElementX element) {
     if (element.isResolved) return element.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 _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;
+          return mapping;
+        });
       });
     });
   }
 
   FunctionType computeFunctionType(Element element,
                                    FunctionSignature signature) {
     var parameterTypes = new LinkBuilder<DartType>();
     for (Element parameter in signature.requiredParameters) {
        parameterTypes.addLast(parameter.computeType(compiler));
     }
@@ skipping 2665 matching lines @@
           compiler.internalError(
               "Cannot resolve default superclass for $element",
               node: node);
         } else {
           superElement.ensureResolved(compiler);
         }
         element.supertype = superElement.computeType(compiler);
       }
     }
 
-    assert(element.interfaces == null);
-    element.interfaces = resolveInterfaces(node.interfaces, node.superclass);
+    if (element.interfaces == null) {
+      element.interfaces = resolveInterfaces(node.interfaces, node.superclass);
+    } else {
+      assert(invariant(element, element.hasIncompleteHierarchy));
+    }
     calculateAllSupertypes(element);
 
     if (!element.hasConstructor) {
       Element superMember =
           element.superclass.localLookup('');
       if (superMember == null || !superMember.isGenerativeConstructor()) {
         DualKind kind = MessageKind.CANNOT_FIND_CONSTRUCTOR;
         Map arguments = {'constructorName': ''};
         // TODO(ahe): Why is this a compile-time error? Or if it is an error,
         // why do we bother to registerThrowNoSuchMethod below?
@@ skipping 53 matching lines @@
   }
 
   DartType applyMixin(DartType supertype, DartType mixinType, Node node) {
     String superName = supertype.name;
     String mixinName = mixinType.name;
     MixinApplicationElementX mixinApplication = new MixinApplicationElementX(
         "${superName}+${mixinName}",
         element.getCompilationUnit(),
         compiler.getNextFreeClassId(),
         node,
-        Modifiers.EMPTY);  // TODO(kasperl): Should this be abstract?
+        new Modifiers.withFlags(new NodeList.empty(), Modifiers.FLAG_ABSTRACT));
     // Create synthetic type variables for the mixin application.
     LinkBuilder<DartType> typeVariablesBuilder = new LinkBuilder<DartType>();
     element.typeVariables.forEach((TypeVariableType type) {
       TypeVariableElementX typeVariableElement = new TypeVariableElementX(
           type.name, mixinApplication, type.element.parseNode(compiler));
       TypeVariableType typeVariable = new TypeVariableType(typeVariableElement);
       typeVariablesBuilder.addLast(typeVariable);
     });
     Link<DartType> typeVariables = typeVariablesBuilder.toLink();
     // Setup bounds on the synthetic type variables.
@@ skipping 51 matching lines @@
     NamedMixinApplication namedMixinApplication =
         node.asNamedMixinApplication();
     Link<DartType> interfaces = (namedMixinApplication != null)
         ? resolveInterfaces(namedMixinApplication.interfaces,
                             namedMixinApplication.superclass)
         : const Link<DartType>();
 
     // 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.
-
-    interfaces = interfaces.prepend(mixinType);
-    assert(mixinApplication.interfaces == null);
-    mixinApplication.interfaces = interfaces;
+    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));
+    }
 
     ClassElement superclass = supertype.element;
     if (mixinType.kind != TypeKind.INTERFACE) {
+      mixinApplication.hasIncompleteHierarchy = true;
       mixinApplication.allSupertypesAndSelf = superclass.allSupertypesAndSelf;
       return;
     }
 
     assert(mixinApplication.mixinType == null);
     mixinApplication.mixinType = resolveMixinFor(mixinApplication, mixinType);
 
     // Create forwarding constructors for constructor defined in the superclass
     // because they are now hidden by the mixin application.
     superclass.forEachLocalMember((Element member) {
@@ skipping 747 matching lines @@
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }