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 {
+  /// Invariant: Key elements are declaration elements.
   Map<Element, CodeBuffer> generatedCode;
+  /// Invariant: Key elements are declaration elements.
   Map<Element, CodeBuffer> generatedBailoutCode;
+  /// Invariant: Elements are declaration elements.
   final Set<ClassElement> instantiatedClasses;
+  /// 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;
   // TODO(karlklose): move this data to RuntimeTypeInformation.
+  // Invariant: Elements are declarations.
   Set<Element> checkedClasses;
   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();
 
   // TODO(karlklose): add the set of instantiatedtypes as second argument.
   void computeRequiredTypes(Set<DartType> isChecks) {
     assert(checkedClasses == null);
     checkedClasses = new Set<Element>();
     isChecks.forEach((DartType t) => checkedClasses.add(t.element));
   }
 
   void addGeneratedCode(WorkItem work, CodeBuffer codeBuffer) {
+    assert(work.element.isDeclaration);
     generatedCode[work.element] = codeBuffer;
   }
 
   void addBailoutCode(WorkItem work, CodeBuffer codeBuffer) {
+    assert(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 217 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(element.isImplementation);

[ngeoffray, 2012/09/17 12:46:24]

No sure you need this restriction.

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

The only call-site enforces the invariant so I'll keep it here.

     // 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(element.isImplementation);

[ngeoffray, 2012/09/17 12:46:24]

ditto

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

The call-sites enforces the invariant so I'll keep it here.

     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) {
       if (!Compiler.REJECT_NAMED_ARGUMENT_AS_POSITIONAL) {
@@ skipping 142 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;
   }
 }