Patch refactoring.

lib/compiler/implementation/resolver.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.
 
 abstract class TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(TypeAnnotation annotation);
   bool isParameterChecked(Element element);
 }
@@ skipping 11 matching lines @@
         types = new LinkedHashMap<TypeAnnotation, DartType>(),
         checkedParameters = new Set<Element>();
 
   operator []=(Node node, Element element) {
     assert(invariant(node, () {
       if (node is FunctionExpression) {
         return !node.modifiers.isExternal();
       }
       return true;
     }));
+    // TODO(johnniwinther): Simplify this invariant to use only declarations in
+    // [TreeElements].
     assert(invariant(node, () {
       if (!element.isErroneous() && currentElement != null && element.isPatch) {
         return currentElement.getImplementationLibrary().isPatch;
       }
       return true;
     }));
 
     map[node] = element;
   }
   operator [](Node node) => map[node];
@@ skipping 45 matching lines @@
 
   SourceString getConstructorName(Send node) {
     if (node.receiver !== null) {
       return node.selector.asIdentifier().source;
     } else {
       return const SourceString('');
     }
   }
 
   FunctionElement resolveConstructorRedirection(FunctionElement constructor) {
+    if (constructor.isPatched) {
+      checkMatchingPatchSignatures(constructor, constructor.patch);
+      constructor = constructor.patch;
+    }
     FunctionExpression node = constructor.parseNode(compiler);
+
     // A synthetic constructor does not have a node.
     if (node === null) return null;
     if (node.initializers === null) return null;
     Link<Node> initializers = node.initializers.nodes;
     if (!initializers.isEmpty() &&
         Initializers.isConstructorRedirect(initializers.head)) {
       final ClassElement classElement = constructor.getEnclosingClass();
       final SourceString constructorName =
           getConstructorName(initializers.head);
       final SourceString className = classElement.name;
@@ skipping 11 matching lines @@
     while (redirection !== null) {
       if (seen.contains(redirection)) {
         resolver.visitor.error(node, MessageKind.REDIRECTING_CONSTRUCTOR_CYCLE);
         return;
       }
       seen.add(redirection);
       redirection = resolveConstructorRedirection(redirection);
     }
   }
 
+  void checkMatchingPatchSignatures(FunctionElement origin,
+                                    FunctionElement patch) {
+    // TODO(johnniwinther): Stub. Implementation in a later CL.
+  }
+
   TreeElements resolveMethodElement(FunctionElement element) {
     assert(invariant(element, element.isDeclaration));
     return compiler.withCurrentElement(element, () {
       bool isConstructor = element.kind === ElementKind.GENERATIVE_CONSTRUCTOR;
       TreeElements elements =
           compiler.enqueuer.resolution.getCachedElements(element);
       if (elements !== null) {
         assert(isConstructor);
         return elements;
       }
-      FunctionExpression tree = element.parseNode(compiler);
-      if (isConstructor) {
-        if (tree.returnType !== null) {
-          error(tree, MessageKind.CONSTRUCTOR_WITH_RETURN_TYPE);
+      if (element.isPatched) {
+        checkMatchingPatchSignatures(element, element.patch);
+        element = element.patch;
+      }
+      return compiler.withCurrentElement(element, () {
+        FunctionExpression tree = element.parseNode(compiler);
+        if (isConstructor) {
+          if (tree.returnType !== null) {
+            error(tree, MessageKind.CONSTRUCTOR_WITH_RETURN_TYPE);
+          }
+          resolveConstructorImplementation(element, tree);
         }
-        resolveConstructorImplementation(element, tree);
-      }
-      ResolverVisitor visitor = new ResolverVisitor(compiler, element);
-      visitor.useElement(tree, element);
-      visitor.setupFunction(tree, element);
+        ResolverVisitor visitor = new ResolverVisitor(compiler, element);
+        visitor.useElement(tree, element);
+        visitor.setupFunction(tree, element);
 
-      if (isConstructor) {
-        // Even if there is no initializer list we still have to do the
-        // resolution in case there is an implicit super constructor call.
-        InitializerResolver resolver = new InitializerResolver(visitor);
-        FunctionElement redirection =
-            resolver.resolveInitializers(element, tree);
-        if (redirection !== null) {
-          resolveRedirectingConstructor(resolver, tree, element, redirection);
+        if (isConstructor) {
+          // Even if there is no initializer list we still have to do the
+          // resolution in case there is an implicit super constructor call.
+          InitializerResolver resolver = new InitializerResolver(visitor);
+          FunctionElement redirection =
+              resolver.resolveInitializers(element, tree);
+          if (redirection !== null) {
+            resolveRedirectingConstructor(resolver, tree, element, redirection);
+          }
+        } else if (tree.initializers != null) {
+          error(tree, MessageKind.FUNCTION_WITH_INITIALIZER);
         }
-      } else if (tree.initializers != null) {
-        error(tree, MessageKind.FUNCTION_WITH_INITIALIZER);
-      }
-      visitBody(visitor, tree.body);
+        visitBody(visitor, tree.body);
 
-      return visitor.mapping;
+        return visitor.mapping;
+      });
     });
   }
 
   void visitBody(ResolverVisitor visitor, Statement body) {
     visitor.visit(body);
   }
 
   void resolveConstructorImplementation(FunctionElement constructor,
                                         FunctionExpression node) {
     if (constructor.defaultImplementation !== constructor) return;
@@ skipping 110 matching lines @@
    *
    * 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) {
-    compiler.withCurrentElement(element, () => measure(() {
-      assert(element.resolutionState == STATE_NOT_STARTED);
+    if (!element.isPatch) {
+      compiler.withCurrentElement(element, () => measure(() {
+        assert(element.resolutionState == STATE_NOT_STARTED);
+        element.resolutionState = STATE_STARTED;
+        ClassNode tree = element.parseNode(compiler);
+        loadSupertypes(element, tree);
+
+        ClassResolverVisitor visitor =
+            new ClassResolverVisitor(compiler, element);
+        visitor.visit(tree);
+        element.resolutionState = STATE_DONE;
+      }));
+      if (element.isPatched) {
+        // Ensure handling patch after origin.
+        element.patch.ensureResolved(compiler);
+      }
+    } else { // Handle patch classes:
       element.resolutionState = STATE_STARTED;
-      ClassNode tree = element.parseNode(compiler);
-      loadSupertypes(element, tree);
-
-      ClassResolverVisitor visitor =
-        new ClassResolverVisitor(compiler, element);
-      visitor.visit(tree);
+      // 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.defaultClass = element.origin.defaultClass;
+      element.interfaces = element.origin.interfaces;
+      element.allSupertypes = element.origin.allSupertypes;
+      // 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 checkMembers(ClassElement cls) {
-    if (cls === compiler.objectClass) return;
+    assert(invariant(cls, cls.isDeclaration));
+    if (cls.isObject(compiler)) return;
+    // TODO(johnniwinther): Should this be done on the implementation element as
+    // well?
     cls.forEachMember((holder, member) {
       // Perform various checks as side effect of "computing" the type.
       member.computeType(compiler);
 
       // Check modifiers.
       if (member.isFunction() && member.modifiers.isFinal()) {
         compiler.reportMessage(
           compiler.spanFromElement(member),
           MessageKind.ILLEGAL_FINAL_METHOD_MODIFIER.error(),
           api.Diagnostic.ERROR);
@@ skipping 207 matching lines @@
     initialized[name] = init;
   }
 
   void resolveFieldInitializer(FunctionElement constructor, SendSet init) {
     // init is of the form [this.]field = value.
     final Node selector = init.selector;
     final SourceString name = selector.asIdentifier().source;
     // Lookup target field.
     Element target;
     if (isFieldInitializer(init)) {
-      final ClassElement classElement = constructor.getEnclosingClass();
-      target = classElement.lookupLocalMember(name);
+      Scope localScope = constructor.getEnclosingClass().buildLocalScope();
+      target = localScope.lookup(name);
       if (target === null) {
         error(selector, MessageKind.CANNOT_RESOLVE, [name]);
       } else if (target.kind != ElementKind.FIELD) {
         error(selector, MessageKind.NOT_A_FIELD, [name]);
       } else if (!target.isInstanceMember()) {
         error(selector, MessageKind.INIT_STATIC_FIELD, [name]);
       }
     } else {
       error(init, MessageKind.INVALID_RECEIVER_IN_INITIALIZER);
     }
@@ skipping 770 matching lines @@
       }
       if (!inInstanceContext) {
         error(node.receiver, MessageKind.NO_INSTANCE_AVAILABLE, [name]);
         return null;
       }
       if (currentClass.supertype === null) {
         // This is just to guard against internal errors, so no need
         // for a real error message.
         error(node.receiver, MessageKind.GENERIC, ["Object has no superclass"]);
       }
+      // TODO(johnniwinther): Ensure correct behavior if currentClass is a
+      // patch.
       target = currentClass.lookupSuperMember(name);
       // [target] may be null which means invoking noSuchMethod on
       // super.
     } else if (Elements.isUnresolved(resolvedReceiver)) {
       return null;
     } else if (resolvedReceiver.kind === ElementKind.CLASS) {
       ClassElement receiverClass = resolvedReceiver;
-      target = receiverClass.ensureResolved(compiler).lookupLocalMember(name);
+      receiverClass.ensureResolved(compiler);
+      target = receiverClass.buildLocalScope().lookup(name);
       if (target === null) {
+        // TODO(johnniwinther): With the simplified [TreeElements] invariant,
+        // try to resolve ghost elements if [currentClass] is in the patch
+        // library of [receiverClass].
+
         // TODO(karlklose): this should be reported by the caller of
         // [resolveSend] to select better warning messages for getters and
         // setters.
         return warnAndCreateErroneousElement(node, name,
                                              MessageKind.METHOD_NOT_FOUND,
                                              [receiverClass.name, name]);
       } else if (target.isInstanceMember()) {
         error(node, MessageKind.MEMBER_NOT_STATIC, [receiverClass.name, name]);
       }
     } else if (resolvedReceiver.kind === ElementKind.PREFIX) {
@@ skipping 323 matching lines @@
       FunctionExpression tree = constructor.parseNode(compiler);
       compiler.resolver.resolveConstructorImplementation(constructor, tree);
     });
     // [constructor.defaultImplementation] might be the implementation element
     // and only declaration elements may be registered.
     world.registerStaticUse(constructor.defaultImplementation.declaration);
     ClassElement cls = constructor.defaultImplementation.getEnclosingClass();
     // [cls] might be the implementation element and only declaration elements
     // may be registered.
     world.registerInstantiatedClass(cls.declaration);
-    cls.forEachInstanceField(
+    // [cls] might be the declaration element and we want to include injected
+    // members.
+    cls.implementation.forEachInstanceField(
         includeBackendMembers: false,
         includeSuperMembers: true,
         f: (ClassElement enclosingClass, Element member) {
           world.addToWorkList(member);
         });
     return null;
   }
 
   /**
    * Try to resolve the constructor that is referred to by [node].
@@ skipping 631 matching lines @@
        type.element === compiler.nullClass ||
        type.element === compiler.functionClass);
   }
 }
 
 class ClassSupertypeResolver extends CommonResolverVisitor {
   Scope context;
   ClassElement classElement;
 
   ClassSupertypeResolver(Compiler compiler, ClassElement cls)
-    : context = new TopScope(cls.getLibrary()),
+    : context = cls.buildEnclosingScope(),
       this.classElement = cls,
       super(compiler);
 
   void loadSupertype(ClassElement element, Node from) {
     compiler.resolver.loadSupertypes(element, from);
     element.ensureResolved(compiler);
   }
 
   void visitClassNode(ClassNode node) {
     if (node.superclass === null) {
@@ skipping 452 matching lines @@
       TypeVariableType typeVariable = typeVariableLink.head;
       if (typeVariable.name == name) {
         return typeVariable.element;
       }
       typeVariableLink = typeVariableLink.tail;
     }
     return null;
   }
 
   String toString() =>
-      '$element${element.typeVariables} > $parent';
+      'TypeDeclarationScope($element)';
 }
 
 class MethodScope extends Scope {
   final Map<SourceString, Element> elements;
 
   MethodScope(Scope parent, Element element)
       : super(parent, element),
         this.elements = new Map<SourceString, Element>() {
     assert(parent !== null);
   }
 
   Element localLookup(SourceString name) => elements[name];
 
   Element add(Element newElement) {
     if (elements.containsKey(newElement.name)) {
       return elements[newElement.name];
     }
     elements[newElement.name] = newElement;
     return newElement;
   }
 
-  String toString() => '$element${elements.getKeys()} > $parent';
+  String toString() => '$element${elements.getKeys()}';
 }
 
 class BlockScope extends MethodScope {
   BlockScope(Scope parent) : super(parent, parent.element);
 
-  String toString() => 'block${elements.getKeys()} > $parent';
+  String toString() => 'block${elements.getKeys()}';
 }
 
 /**
  * [ClassScope] defines the inner scope of a class/interface declaration in
  * which declared members, declared type variables, entities in the enclosing
  * scope and inherited members are available, in the given order.
  */
 class ClassScope extends TypeDeclarationScope {
   bool inStaticContext = false;
 
   ClassScope(Scope parentScope, ClassElement element)
-      : super(parentScope, element);
+      : super(parentScope, element)  {
+    assert(parent !== null);
+  }
 
   Element localLookup(SourceString name) {
     ClassElement cls = element;
     Element result = cls.lookupLocalMember(name);
     if (result !== null) return result;
     if (!inStaticContext) {
       // If not in a static context, we can lookup in the
       // TypeDeclaration scope, which contains the type variables of
       // the class.
-      return super.localLookup(name);
+      result = super.localLookup(name);
     }
-    return null;
+    return result;
   }
 
   Element lookup(SourceString name) {
-    Element result = super.lookup(name);
+    Element result = localLookup(name);
+    if (result !== null) return result;
+    result = parent.lookup(name);
     if (result !== null) return result;
     ClassElement cls = element;
     return cls.lookupSuperMember(name);
   }
 
   Element add(Element newElement) {
     throw "Cannot add an element in a class scope";
   }
 
-  String toString() => '$element > $parent';
+  String toString() => 'ClassScope($element)';
+}
+
+// TODO(johnniwinther): Refactor scopes to avoid class explosion.
+class PatchClassScope extends TypeDeclarationScope {
+  bool inStaticContext = false;
+  ClassElement get origin => element;
+  final ClassElement patch;
+
+  PatchClassScope(Scope parentScope,
+                  ClassElement origin, ClassElement this.patch)
+      : super(parentScope, origin) {
+    assert(parent !== null);
+  }
+
+  Element localLookup(SourceString name) {
+    Element result = patch.lookupLocalMember(name);
+    if (result !== null) return result;
+    result = origin.lookupLocalMember(name);
+    if (result !== null) return result;
+    if (!inStaticContext) {
+      // If not in a static context, we can lookup in the
+      // TypeDeclaration scope, which contains the type variables of
+      // the class.
+      result = super.localLookup(name);
+      if (result !== null) return result;
+    }
+    result = parent.lookup(name);
+    if (result !== null) return result;
+    return result;
+  }
+
+  Element lookup(SourceString name) {
+    Element result = localLookup(name);
+    if (result !== null) return result;
+    // TODO(johnniwinther): Should we support patch lookup on supertypes?
+    return origin.lookupSuperMember(name);
+  }
+
+  Element add(Element newElement) {
+    throw "Cannot add an element in a class scope";
+  }
+
+  String toString() => 'PatchClassScope($origin,$patch)';
+}
+
+class LocalClassScope extends Scope {
+  LocalClassScope(ClassElement element)
+      : super(null, element);
+
+  Element lookup(SourceString name) => localLookup(name);
+
+  Element localLookup(SourceString name) {
+    ClassElement cls = element;
+    return cls.lookupLocalMember(name);
+  }
+
+  Element add(Element newElement) {
+    throw "Cannot add an element in a class scope";
+  }
+
+  String toString() => 'LocalClassScope($element)';
+}
+
+class LocalPatchClassScope extends Scope {
+  ClassElement get origin => element;
+  final ClassElement patch;
+
+  LocalPatchClassScope(ClassElement origin, ClassElement this.patch)
+      : super(null, origin);
+
+  Element lookup(SourceString name) => localLookup(name);
+
+  Element localLookup(SourceString name) {
+    Element result = patch.lookupLocalMember(name);
+    if (result !== null) return result;
+    return origin.lookupLocalMember(name);
+  }
+
+
+  Element add(Element newElement) {
+    throw "Cannot add an element in a class scope";
+  }
+
+  String toString() => 'LocalPatchClassScope($origin,$patch)';
 }
 
 class TopScope extends Scope {
   LibraryElement get library => element;
 
   TopScope(LibraryElement library) : super(null, library);
 
   Element localLookup(SourceString name) => library.find(name);
   Element lookup(SourceString name) => localLookup(name);
   Element lexicalLookup(SourceString name) => localLookup(name);
 
   Element add(Element newElement) {
     throw "Cannot add an element in the top scope";
   }
-  String toString() => '$element';
+  String toString() => 'LibraryScope($element)';
 }
+
+class PatchLibraryScope extends Scope {
+  LibraryElement get origin => element;
+  final LibraryElement patch;
+
+  PatchLibraryScope(LibraryElement origin, LibraryElement this.patch)
+      : super(null, origin);
+
+  Element localLookup(SourceString name) {
+    Element result = patch.find(name);
+    if (result !== null) {
+      return result;
+    }
+    result = origin.find(name);
+    if (result !== null) {
+      return result;
+    }
+    return result;
+  }
+  Element lookup(SourceString name) => localLookup(name);
+  Element lexicalLookup(SourceString name) => localLookup(name);
+
+  Element add(Element newElement) {
+    throw "Cannot add an element in a patch library scope";
+  }
+  String toString() => 'PatchLibraryScope($origin,$patch)';
+}