Stub implementation of patch invariants for the patch refactoring.

lib/compiler/implementation/universe/universe.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.
 
 #library('universe');
 
 #import('../closure.dart');
 #import('../elements/elements.dart');
 #import('../leg.dart');
 #import('../scanner/scannerlib.dart');
 // For RuntimeTypeInformation. TODO(ngeoffray): remove this dependency.
 #import('../ssa/ssa.dart');
 #import('../tree/tree.dart');
 #import('../util/util.dart');
 
 #source('function_set.dart');
 #source('partial_type_tree.dart');
 #source('selector_map.dart');
 
 class Universe {
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: Key elements are declaration elements.
+   */
   Map<Element, CodeBuffer> generatedCode;
+
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: Key elements are declaration elements.
+   */
   Map<Element, CodeBuffer> generatedBailoutCode;
+
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: Elements are declaration elements.
+   */
   final Set<ClassElement> instantiatedClasses;
+
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: Elements are declaration elements.
+   */
   final Set<FunctionElement> staticFunctionsNeedingGetter;
   final Map<SourceString, Set<Selector>> invokedNames;
   final Map<SourceString, Set<Selector>> invokedGetters;
   final Map<SourceString, Set<Selector>> invokedSetters;
   final Map<SourceString, Set<Selector>> fieldGetters;
   final Map<SourceString, Set<Selector>> fieldSetters;
   final Set<DartType> isChecks;
   final RuntimeTypeInformation rti;
 
   Universe() : generatedCode = new Map<Element, CodeBuffer>(),
                generatedBailoutCode = new Map<Element, CodeBuffer>(),
                instantiatedClasses = new Set<ClassElement>(),
                staticFunctionsNeedingGetter = new Set<FunctionElement>(),
                invokedNames = new Map<SourceString, Set<Selector>>(),
                invokedGetters = new Map<SourceString, Set<Selector>>(),
                invokedSetters = new Map<SourceString, Set<Selector>>(),
                fieldGetters = new Map<SourceString, Set<Selector>>(),
                fieldSetters = new Map<SourceString, Set<Selector>>(),
                isChecks = new Set<DartType>(),
                rti = new RuntimeTypeInformation();
 
   void addGeneratedCode(WorkItem work, CodeBuffer codeBuffer) {
+    assert(invariant(work.element, work.element.isDeclaration));
     generatedCode[work.element] = codeBuffer;
   }
 
   void addBailoutCode(WorkItem work, CodeBuffer codeBuffer) {
+    assert(invariant(work.element, work.element.isDeclaration));
     generatedBailoutCode[work.element] = codeBuffer;
   }
 
   bool hasMatchingSelector(Set<Selector> selectors,
                            Element member,
                            Compiler compiler) {
     if (selectors === null) return false;
     for (Selector selector in selectors) {
       if (selector.applies(member, compiler)) return true;
     }
@@ skipping 218 matching lines @@
   }
 
   // TODO(5074): Remove this method once we don't accept the
   // deprecated parameter specification.
   bool addOptionalArgumentsToListDEPRECATED(Link<Node> arguments,
                                             List list,
                                             FunctionElement element,
                                             compileArgument(Node argument),
                                             compileConstant(Element element),
                                             Compiler compiler) {
+    assert(invariant(element, element.isImplementation));
     // If there are named arguments, provide them in the order
     // expected by the called function, which is the source order.
     FunctionSignature parameters = element.computeSignature(compiler);
 
     // Visit positional arguments and add them to the list.
     for (int i = parameters.requiredParameterCount;
          i < positionalArgumentCount;
          arguments = arguments.tail, i++) {
       list.add(compileArgument(arguments.head));
     }
@@ skipping 27 matching lines @@
       } else {
         list.add(compileConstant(parameter));
       }
     }
   }
 
 
   /**
    * Returns [:true:] if the selector and the [element] match; [:false:]
    * otherwise.
+   *
+   * Invariant: [element] must be the implementation element.
    */
   bool addArgumentsToList(Link<Node> arguments,
                           List list,
                           FunctionElement element,
                           compileArgument(Node argument),
                           compileConstant(Element element),
                           Compiler compiler) {
+    assert(invariant(element, element.isImplementation));
     if (!this.applies(element, compiler)) return false;
 
     FunctionSignature parameters = element.computeSignature(compiler);
     parameters.forEachRequiredParameter((element) {
       list.add(compileArgument(arguments.head));
       arguments = arguments.tail;
     });
 
     if (!parameters.optionalParametersAreNamed) {
       // TODO(5074): Remove this check once we don't accept the
@@ skipping 144 matching lines @@
 
     if (!self.isInterface() && self.isSubclassOf(other)) {
       // Resolve an invocation of [element.name] on [self]. If it
       // is found, this selector is a candidate.
       return hasElementIn(self, element) && appliesUntyped(element, compiler);
     }
 
     return false;
   }
 }