Stub implementation of patch invariants for the patch refactoring.

lib/compiler/implementation/enqueue.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.
 
 class EnqueueTask extends CompilerTask {
   final Enqueuer codegen;
   final Enqueuer resolution;
 
   String get name => 'Enqueue';
 
   EnqueueTask(Compiler compiler)
-    : codegen = new Enqueuer(compiler,
+    : codegen = new Enqueuer('codegen enqueuer', compiler,
                              compiler.backend.createItemCompilationContext),
-      resolution = new Enqueuer(compiler,
+      resolution = new Enqueuer('resolution enqueuer', compiler,
                                 compiler.backend.createItemCompilationContext),
       super(compiler) {
     codegen.task = this;
     resolution.task = this;
   }
 }
 
 class RecompilationQueue {
   final Function itemCompilationContextCreator;
   final Queue<WorkItem> queue;
@@ skipping 17 matching lines @@
 
   WorkItem next() {
     WorkItem item = queue.removeLast();
     queueElements.remove(item.element);
     processed++;
     return item;
   }
 }
 
 class Enqueuer {
+  final String name;
   final Compiler compiler; // TODO(ahe): Remove this dependency.
   final Function itemCompilationContextCreator;
   final Map<String, Link<Element>> instanceMembersByName;
   final Set<ClassElement> seenClasses;
   final Universe universe;
   final Queue<WorkItem> queue;
+
+  /**
+   * Map from declaration elements to the [TreeElements] object holding the
+   * resolution mapping for the element implementation.
+   *
+   * Invariant: Key elements are declaration elements.
+   */
   final Map<Element, TreeElements> resolvedElements;
   final RecompilationQueue recompilationCandidates;
 
   bool queueIsClosed = false;
   EnqueueTask task;
 
-  Enqueuer(this.compiler,
+  Enqueuer(this.name, this.compiler,
            ItemCompilationContext itemCompilationContextCreator())
     : this.itemCompilationContextCreator = itemCompilationContextCreator,
       instanceMembersByName = new Map<String, Link<Element>>(),
       seenClasses = new Set<ClassElement>(),
       universe = new Universe(),
       queue = new Queue<WorkItem>(),
       resolvedElements = new Map<Element, TreeElements>(),
       recompilationCandidates =
           new RecompilationQueue(itemCompilationContextCreator);
 
   bool get isResolutionQueue => compiler.enqueuer.resolution === this;
 
   TreeElements getCachedElements(Element element) {
     // TODO(ngeoffray): Get rid of this check.
     if (element.enclosingElement.isClosure()) {
       closureMapping.ClosureClassElement cls = element.enclosingElement;
       element = cls.methodElement;
     }
     Element owner = element.getOutermostEnclosingMemberOrTopLevel();
-    return compiler.enqueuer.resolution.resolvedElements[owner];
+    return compiler.enqueuer.resolution.resolvedElements[owner.declaration];
   }
 
-  String lookupCode(Element element) =>
-      universe.generatedCode[element].toString();
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: [element] must be a declaration element.
+   */
+  String lookupCode(Element element) {
+    assert(invariant(element, element.isDeclaration));
+    return universe.generatedCode[element].toString();
+  }
 
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: [element] must be a declaration element.
+   */
   void addToWorkList(Element element, [TreeElements elements]) {
+    assert(invariant(element, element.isDeclaration));
     if (element.isForeign()) return;
     if (compiler.phase == Compiler.PHASE_RECOMPILING) return;
     if (queueIsClosed) {
       if (isResolutionQueue && getCachedElements(element) !== null) return;
       compiler.internalErrorOnElement(element, "Work list is closed.");
     }
     if (!isResolutionQueue &&
         element.kind === ElementKind.GENERATIVE_CONSTRUCTOR) {
       registerInstantiatedClass(element.getEnclosingClass());
     }
@@ skipping 13 matching lines @@
 
     // Enable isolate support if we start using something from the
     // isolate library.
     LibraryElement library = element.getLibrary();
     if (!compiler.hasIsolateSupport()
         && library.uri.toString() == 'dart:isolate') {
       compiler.enableIsolateSupport(library);
     }
   }
 
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: [element] must be an declaration element.
+   */
   void eagerRecompile(Element element) {
+    assert(invariant(element, element.isDeclaration));
     universe.generatedCode.remove(element);
     universe.generatedBailoutCode.remove(element);
     addToWorkList(element);
   }
 
   void registerRecompilationCandidate(Element element,
                                       [TreeElements elements]) {
     if (queueIsClosed) {
-      compiler.internalErrorOnElement(element, "Work list is closed.");
+      compiler.internalErrorOnElement(element, "$name work list is closed.");
     }
     recompilationCandidates.add(element, elements);
   }
 
   void registerInstantiatedClass(ClassElement cls) {
     if (cls.isInterface()) {
       compiler.internalErrorOnElement(
           // Use the current element, as this is where cls is referenced from.
           compiler.currentElement,
           'Expected a class, but $cls is an interface.');
@@ skipping 13 matching lines @@
         }
       }
     });
     return true;
   }
 
   void processInstantiatedClass(ClassElement cls) {
     cls.localMembers.forEach(processInstantiatedClassMember);
   }
 
+  /**
+   * Documentation wanted -- johnniwinther
+   */
   void processInstantiatedClassMember(Element member) {
+    assert(invariant(member, member.isDeclaration));
     if (universe.generatedCode.containsKey(member)) return;
     if (resolvedElements[member] !== null) return;
     if (!member.isInstanceMember()) return;
     if (member.isField()) return;
 
     String memberName = member.name.slowToString();
     Link<Element> members = instanceMembersByName.putIfAbsent(
         memberName, () => const EmptyLink<Element>());
     instanceMembersByName[memberName] = members.prepend(member);
 
@@ skipping 115 matching lines @@
   void handleUnseenSelector(SourceString methodName, Selector selector) {
     processInstanceMembers(methodName, (Element member) {
       if (selector.applies(member, compiler)) {
         addToWorkList(member);
         return true;
       }
       return false;
     });
   }
 
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: [element] must be a declaration element.
+   */
   void registerStaticUse(Element element) {
-    if (element !== null) addToWorkList(element);
+    if (element == null) return;
+    assert(invariant(element, element.isDeclaration));
+    addToWorkList(element);
   }
 
   void registerGetOfStaticFunction(FunctionElement element) {
     registerStaticUse(element);
     universe.staticFunctionsNeedingGetter.add(element);
   }
 
   void registerDynamicInvocation(SourceString methodName, Selector selector) {
     assert(selector !== null);
     registerInvocation(methodName, selector);
@@ skipping 35 matching lines @@
 
   void registerIsCheck(DartType type) {
     universe.isChecks.add(type);
   }
 
   void forEach(f(WorkItem work)) {
     while (!queue.isEmpty()) {
       f(queue.removeLast()); // TODO(kasperl): Why isn't this removeFirst?
     }
   }
+
+  String toString() => 'Enqueuer($name)';
 }