Stub implementation of patch invariants for the patch refactoring.

lib/compiler/implementation/compiler.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.
 
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
 const bool REPORT_EXCESS_RESOLUTION = false;
@@ skipping 21 matching lines @@
 
 /**
  * Contains backend-specific data that is used throughout the compilation of
  * one work item.
  */
 class ItemCompilationContext {
 }
 
 class WorkItem {
   final ItemCompilationContext compilationContext;
+  /**
+   * Invariant: [element] must be the declaration element.

[ahe, 2012/09/18 11:25:54]

This is not a documentation comment.

[Johnni Winther, 2012/09/20 08:12:23]

Done.

+   */
   final Element element;
   TreeElements resolutionTree;
   bool allowSpeculativeOptimization = true;
   List<HTypeGuard> guards = const <HTypeGuard>[];
 
-  WorkItem(this.element, this.resolutionTree, this.compilationContext);
+  WorkItem(this.element, this.resolutionTree, this.compilationContext) {
+    assert(element.isDeclaration);
+  }
 
   bool isAnalyzed() => resolutionTree !== null;
 
   void run(Compiler compiler, Enqueuer world) {
     CodeBuffer codeBuffer = world.universe.generatedCode[element];
     if (codeBuffer !== null) return;
     resolutionTree = compiler.analyze(this, world);
     compiler.codegen(this, world);
   }
 }
@@ skipping 544 matching lines @@
       print("Inferred return types:");
       print("----------------------");
       backend.dumpReturnTypes();
     }
   }
 
   void processRecompilationQueue(Enqueuer world) {
     assert(phase == PHASE_RECOMPILING);
     while (!world.recompilationCandidates.isEmpty()) {
       WorkItem work = world.recompilationCandidates.next();
-      CodeBuffer oldCode = world.universe.generatedCode[work.element];
-      world.universe.generatedCode.remove(work.element);
-      world.universe.generatedBailoutCode.remove(work.element);
-      withCurrentElement(work.element, () => work.run(this, world));
-      CodeBuffer newCode = world.universe.generatedCode[work.element];
+      Element element = work.element;
+      CodeBuffer oldCode = world.universe.generatedCode[element];
+      world.universe.generatedCode.remove(element);
+      world.universe.generatedBailoutCode.remove(element);
+      withCurrentElement(element, () => work.run(this, world));
+      CodeBuffer newCode = world.universe.generatedCode[element];
       if (REPORT_PASS2_OPTIMIZATIONS && newCode != oldCode) {
         log("Pass 2 optimization:");
         log("Before:\n$oldCode");
         log("After:\n$newCode");
       }
     }
   }
 
   /**
    * Perform various checks of the queues. This includes checking that
@@ skipping 37 matching lines @@
     log('Excess resolution work: ${resolved.length}.');
     if (!REPORT_EXCESS_RESOLUTION) return;
     for (Element e in resolved) {
       SourceSpan span = spanFromElement(e);
       reportDiagnostic(span, 'Warning: $e resolved but not compiled.',
                        api.Diagnostic.WARNING);
     }
   }
 
   TreeElements analyzeElement(Element element) {
+    assert(element.isDeclaration);
     TreeElements elements = enqueuer.resolution.getCachedElements(element);
     if (elements !== null) return elements;
     final int allowed = ElementCategory.VARIABLE | ElementCategory.FUNCTION
                         | ElementCategory.FACTORY;
     ElementKind kind = element.kind;
     if (!element.isAccessor() &&
         ((kind === ElementKind.ABSTRACT_FIELD) ||
          (kind.category & allowed) == 0)) {
       return null;
     }
@@ skipping 23 matching lines @@
       }
     }
     Element element = work.element;
     TreeElements result = world.getCachedElements(element);
     if (result !== null) return result;
     if (world !== enqueuer.resolution) {
       internalErrorOnElement(element,
                              'Internal error: unresolved element: $element.');
     }
     result = analyzeElement(element);
+    assert(element.isDeclaration);
     enqueuer.resolution.resolvedElements[element] = result;
     return result;
   }
 
   void codegen(WorkItem work, Enqueuer world) {
     if (world !== enqueuer.codegen) return null;
     if (progress.elapsedInMs() > 500) {
       // TODO(ahe): Add structured diagnostics to the compiler API and
       // use it to separate this from the --verbose option.
       if (phase == PHASE_COMPILING) {
@@ skipping 211 matching lines @@
     final endOffset = end.charOffset + end.slowCharCount;
 
     // [begin] and [end] might be the same for the same empty token. This
     // happens for instance when scanning '$$'.
     assert(endOffset >= beginOffset);
     return f(beginOffset, endOffset);
   }
 
   String toString() => 'SourceSpan($uri, $begin, $end)';
 }