Stub implementation of patch invariants for the 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);
 }
 
 class TreeElementMapping implements TreeElements {
+  final Element currentElement;
   final Map<Node, Element> map;
   final Map<Node, Selector> selectors;
   final Map<TypeAnnotation, DartType> types;
   final Set<Element> checkedParameters;
 
-  TreeElementMapping()
+  TreeElementMapping([Element this.currentElement])
       : map = new LinkedHashMap<Node, Element>(),
         selectors = new LinkedHashMap<Node, Selector>(),
         types = new LinkedHashMap<TypeAnnotation, DartType>(),
         checkedParameters = new Set<Element>();
 
-  operator []=(Node node, Element element) => map[node] = element;
+  operator []=(Node node, Element element) {
+    assert(invariant(node, () {
+      if (node is FunctionExpression && node.modifiers != null) {
+        return !node.modifiers.isExternal();
+      }
+      return true;
+    }));
+    assert(invariant(node, () {
+      if (!element.isErroneous() && currentElement != null && element.isPatch) {
+        return currentElement.getImplementationLibrary().isPatch;
+      }
+      return true;
+    }));
+
+    map[node] = element;
+  }
   operator [](Node node) => map[node];
   void remove(Node node) { map.remove(node); }
 
   void setType(TypeAnnotation annotation, DartType type) {
     types[annotation] = type;
   }
 
   DartType getType(TypeAnnotation annotation) => types[annotation];
 
   void setSelector(Node node, Selector selector) {
@@ skipping 69 matching lines @@
       if (seen.contains(redirection)) {
         resolver.visitor.error(node, MessageKind.REDIRECTING_CONSTRUCTOR_CYCLE);
         return;
       }
       seen.add(redirection);
       redirection = resolveConstructorRedirection(redirection);
     }
   }
 
   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) {
@@ skipping 842 matching lines @@
   bool inInstanceContext;
   bool inCheckContext;
   Scope scope;
   ClassElement currentClass;
   ExpressionStatement currentExpressionStatement;
   bool typeRequired = false;
   StatementScope statementScope;
   int allowedCategory = ElementCategory.VARIABLE | ElementCategory.FUNCTION;
 
   ResolverVisitor(Compiler compiler, Element element)
-    : this.mapping  = new TreeElementMapping(),
+    : this.mapping  = new TreeElementMapping(element),
       this.enclosingElement = element,
       // When the element is a field, we are actually resolving its
       // initial value, which should not have access to instance
       // fields.
       inInstanceContext = (element.isInstanceMember() && !element.isField())
           || element.isGenerativeConstructor(),
       this.currentClass = element.isMember() ? element.getEnclosingClass()
                                              : null,
       this.statementScope = new StatementScope(),
       typeResolver = new TypeResolver(compiler),
@@ skipping 550 matching lines @@
       if (selector.isGetter()) {
         world.registerDynamicGetter(selector.name, selector);
       } else if (selector.isSetter()) {
         world.registerDynamicSetter(selector.name, selector);
       } else {
         world.registerDynamicInvocation(selector.name, selector);
       }
     } else if (Elements.isStaticOrTopLevel(target)) {
       // TODO(kasperl): It seems like we're not supposed to register
       // the use of classes. Wouldn't it be simpler if we just did?
-      if (!target.isClass()) world.registerStaticUse(target);
+      if (!target.isClass()) {
+        // [target] might be the implementation element and only declaration
+        // elements may be registered.
+        world.registerStaticUse(target.declaration);
+      }
     }
 
     var interceptor =
         new Interceptors(compiler).getStaticInterceptorBySelector(selector);
     if (interceptor !== null) {
       world.registerStaticUse(interceptor);
     }
   }
 
   visitLiteralInt(LiteralInt node) {
@@ skipping 56 matching lines @@
     resolveSelector(node.send);
     resolveArguments(node.send.argumentsNode);
     useElement(node.send, constructor);
     if (Elements.isUnresolved(constructor)) return constructor;
     // TODO(karlklose): handle optional arguments.
     if (node.send.argumentCount() != constructor.parameterCount(compiler)) {
       // TODO(ngeoffray): resolution error with wrong number of
       // parameters. We cannot do this rigth now because of the
       // List constructor.
     }
-    world.registerStaticUse(constructor);
+    // [constructor] might be the implementation element and only declaration
+    // elements may be registered.
+    world.registerStaticUse(constructor.declaration);
     compiler.withCurrentElement(constructor, () {
       FunctionExpression tree = constructor.parseNode(compiler);
       compiler.resolver.resolveConstructorImplementation(constructor, tree);
     });
-    world.registerStaticUse(constructor.defaultImplementation);
+    // [constructor.defaultImplementation] might be the implementation element
+    // and only declaration elements may be registered.
+    world.registerStaticUse(constructor.defaultImplementation.declaration);
     ClassElement cls = constructor.defaultImplementation.getEnclosingClass();
-    world.registerInstantiatedClass(cls);
+    // [cls] might be the implementation element and only declaration elements
+    // may be registered.
+    world.registerInstantiatedClass(cls.declaration);
     cls.forEachInstanceField(
         includeBackendMembers: false,
         includeSuperMembers: true,
         f: (ClassElement enclosingClass, Element member) {
           world.addToWorkList(member);
         });
     return null;
   }
 
   /**
@@ skipping 1063 matching lines @@
   abstract Element localLookup(SourceString name);
 }
 
 class VariableScope extends Scope {
   VariableScope(parent, element) : super(parent, element);
 
   Element add(Element newElement) {
     throw "Cannot add element to VariableScope";
   }
 
-  Element lookup(SourceString name) => parent.lookup(name);
+  Element localLookup(SourceString name) => null;
 
   String toString() => '$element > $parent';
 }
 
 /**
  * [TypeDeclarationScope] defines the outer scope of a type declaration in
  * which the declared type variables and the entities in the enclosing scope are
  * available but where declared and inherited members are not available. This
  * scope is only used for class/interface declarations during resolution of the
  * class hierarchy. In all other cases [ClassScope] is used.
@@ skipping 99 matching lines @@
 
   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';
 }