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 11 matching lines @@
 /**
  * A string to identify the revision or build.
  *
  * This ID is displayed if the compiler crashes and in verbose mode, and is
  * an aid in reproducing bug reports.
  *
  * The actual string is rewritten during the SDK build process.
  */
 const String BUILD_ID = 'build number could not be determined';
 
-
 /**
  * Contains backend-specific data that is used throughout the compilation of
  * one work item.
  */
 class ItemCompilationContext {
 }
 
 class WorkItem {
   final ItemCompilationContext compilationContext;
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: [element] must be a declaration element.
+   */
   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(invariant(element, 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 543 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(invariant(element, 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(invariant(element, 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 217 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)';
 }
+
+/**
+ * Throws an [InvariantException] if [condition] is [:false:]. [condition] must
+ * be either a [:bool:] or a no-arg function returning a [:bool:].
+ *
+ * Use this method to provide better information for assertion by calling
+ * [invariant] as the argument to an [:assert:] statement:
+ *
+ *     assert(invariant(position, isValid));
+ *
+ * [spannable] must be non-null and will be used to provide positional
+ * information in the generated error message.
+ */
+bool invariant(Spannable spannable, var condition, {String message: null}) {
+  // TODO(johnniwinther): Use [spannable] and [message] to provide better
+  // information on assertion errors.
+  if (condition is Function){
+    condition = condition();
+  }
+  return spannable != null && condition;
+}