Stub implementation of patch invariants for the patch refactoring.

lib/compiler/implementation/js_backend/backend.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.
 
 typedef void Recompile(Element element);
 
 class ReturnInfo {
   HType returnType;
   List<Element> compiledFunctions;
 
@@ skipping 207 matching lines @@
     });
     return result;
   }
 
   String toString() =>
       allUnknown ? "HTypeList.ALL_UNKNOWN" : "HTypeList $types";
 }
 
 class ArgumentTypesRegistry {
   final JavaScriptBackend backend;
+
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: Keys must be declaration elements.
+   */
   final Map<Element, HTypeList> staticTypeMap;
+
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: Elements must be declaration elements.
+   */
   final Set<Element> optimizedStaticFunctions;
   final SelectorMap<HTypeList> selectorTypeMap;
   final FunctionSet optimizedFunctions;
+
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: Keys must be declaration elements.
+   */
   final Map<Element, HTypeList> optimizedTypes;
   final Map<Element, OptionalParameterTypes> optimizedDefaultValueTypes;
 
   ArgumentTypesRegistry(JavaScriptBackend backend)
       : staticTypeMap = new Map<Element, HTypeList>(),
         optimizedStaticFunctions = new Set<Element>(),
         selectorTypeMap = new SelectorMap<HTypeList>(backend.compiler),
         optimizedFunctions = new FunctionSet(backend.compiler),
         optimizedTypes = new Map<Element, HTypeList>(),
         optimizedDefaultValueTypes =
             new Map<Element, OptionalParameterTypes>(),
         this.backend = backend;
 
   Compiler get compiler => backend.compiler;
 
   void registerStaticInvocation(HInvokeStatic node, HTypeMap types) {
     Element element = node.element;
+    assert(invariant(node, element.isDeclaration));
     HTypeList oldTypes = staticTypeMap[element];
     if (oldTypes == null) {
       staticTypeMap[element] = new HTypeList.fromStaticInvocation(node, types);
     } else {
       if (oldTypes.allUnknown) return;
       HTypeList newTypes = oldTypes.unionWithInvoke(node, types);
       if (newTypes === oldTypes) return;
       staticTypeMap[element] = newTypes;
       if (optimizedStaticFunctions.contains(element)) {
         backend.scheduleForRecompilation(element);
       }
     }
   }
 
   void registerNonCallStaticUse(HStatic node) {
     // When a static is used for anything else than a call target we cannot
     // infer anything about its parameter types.
     Element element = node.element;
+    assert(invariant(node, element.isDeclaration));
     if (optimizedStaticFunctions.contains(element)) {
       backend.scheduleForRecompilation(element);
     }
     staticTypeMap[element] = HTypeList.ALL_UNKNOWN;
   }
 
   void registerDynamicInvocation(HInvokeDynamicMethod node,
                                  Selector selector,
                                  HTypeMap types) {
     // If there are any getters for this method we cannot know anything about
@@ skipping 43 matching lines @@
             break;
           }
         }
       }
       if (recompile) backend.scheduleForRecompilation(element);
     });
   }
 
   HTypeList parameterTypes(FunctionElement element,
                            OptionalParameterTypes defaultValueTypes) {
+    assert(invariant(element, element.isDeclaration));
     // Handle static functions separately.
     if (Elements.isStaticOrTopLevelFunction(element) ||
         element.kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
       HTypeList types = staticTypeMap[element];
       if (types !== null) {
         if (!optimizedStaticFunctions.contains(element)) {
           optimizedStaticFunctions.add(element);
         }
         return types;
       } else {
@@ skipping 20 matching lines @@
       assert(types.allUnknown || types.length == signature.parameterCount);
       found = (found === null) ? types : found.union(types);
       return !found.allUnknown;
     });
     return found !== null ? found : HTypeList.ALL_UNKNOWN;
   }
 
   void registerOptimization(Element element,
                             HTypeList parameterTypes,
                             OptionalParameterTypes defaultValueTypes) {
+    assert(invariant(element, element.isDeclaration));
     if (Elements.isStaticOrTopLevelFunction(element)) {
       if (parameterTypes.allUnknown) {
         optimizedStaticFunctions.remove(element);
       } else {
         optimizedStaticFunctions.add(element);
       }
     }
 
     // TODO(kasperl): What kind of non-members do we get here?
     if (!element.isMember()) return;
@@ skipping 40 matching lines @@
    * libraries.
    */
   ClassElement jsIndexingBehaviorInterface;
 
   final Map<Element, Map<Element, HType>> fieldInitializers;
   final Map<Element, Map<Element, HType>> fieldConstructorSetters;
   final Map<Element, Map<Element, HType>> fieldSettersType;
 
   final Map<Element, ReturnInfo> returnInfo;
 
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: Elements must be declaration elements.
+   */
   final List<Element> invalidateAfterCodegen;
   ArgumentTypesRegistry argumentTypes;
 
   List<CompilerTask> get tasks {
     return <CompilerTask>[builder, optimizer, generator, emitter];
   }
 
   JavaScriptBackend(Compiler compiler, bool generateSourceMap)
       : fieldInitializers = new Map<Element, Map<Element, HType>>(),
         fieldConstructorSetters = new Map<Element, Map<Element, HType>>(),
@@ skipping 165 matching lines @@
     assert(field.isMember());
     ClassElement enclosingClass = field.getEnclosingClass();
     if (!fieldSettersType.containsKey(enclosingClass)) {
       return HType.CONFLICTING;
     }
     Map<Element, HType> fields = fieldSettersType[enclosingClass];
     if (!fields.containsKey(field)) return HType.CONFLICTING;
     return fields[field];
   }
 
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: [element] must be a declaration element.
+   */
   void scheduleForRecompilation(Element element) {
+    assert(invariant(element, element.isDeclaration));
     if (compiler.phase == Compiler.PHASE_COMPILING) {
       invalidateAfterCodegen.add(element);
     }
   }
 
   /**
    *  Register a dynamic invocation and collect the provided types for the
    *  named selector.
    */
   void registerDynamicInvocation(HInvokeDynamicMethod node,
@@ skipping 15 matching lines @@
    *  target.
    */
   void registerNonCallStaticUse(HStatic node) {
     argumentTypes.registerNonCallStaticUse(node);
   }
 
   /**
    * Retrieve the types of the parameters used for calling the [element]
    * function. The types are optimistic in the sense as they are based on the
    * possible invocations of the function seen so far.
+   *
+   * Invariant: [element] must be a declaration element.
    */
   HTypeList optimisticParameterTypes(
       FunctionElement element,
       OptionalParameterTypes defaultValueTypes) {
+    assert(invariant(element, element.isDeclaration));
     if (element.parameterCount(compiler) == 0) return HTypeList.ALL_UNKNOWN;
     return argumentTypes.parameterTypes(element, defaultValueTypes);
   }
 
   /**
    * Register that the function [element] has been optimized under the
    * assumptions that the types [parameterType] will be used for calling it.
    * The passed [defaultValueTypes] holds the types of default values for
    * the optional parameters. If this assumption fail the function will be
    * scheduled for recompilation.
+   *
+   * Invariant: [element] must be a declaration element.
    */
   registerParameterTypesOptimization(
       FunctionElement element,
       HTypeList parameterTypes,
       OptionalParameterTypes defaultValueTypes) {
+    assert(invariant(element, element.isDeclaration));
     if (element.parameterCount(compiler) == 0) return;
     argumentTypes.registerOptimization(
         element, parameterTypes, defaultValueTypes);
   }
 
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: [element] must be a declaration element.
+   */
   void registerReturnType(FunctionElement element, HType returnType) {
+    assert(invariant(element, element.isDeclaration));
     ReturnInfo info = returnInfo[element];
     if (info != null) {
       info.update(returnType, scheduleForRecompilation);
     } else {
       returnInfo[element] = new ReturnInfo(returnType);
     }
   }
 
   /**
    * Retrieve the return type of the function [callee]. The type is optimistic
    * in the sense that is is based on the compilation of [callee]. If [callee]
    * is recompiled the return type might change to someting broader. For that
    * reason [caller] is registered for recompilation if this happens. If the
    * function [callee] has not yet been compiled the returned type is [null].
+   *
+   * Invariant: Both [caller] and [callee] must be declaration elements.
    */
   HType optimisticReturnTypesWithRecompilationOnTypeChange(
       Element caller, FunctionElement callee) {
+    assert(invariant(callee, callee.isDeclaration));
     returnInfo.putIfAbsent(callee, () => new ReturnInfo.unknownType());
     ReturnInfo info = returnInfo[callee];
     if (info.returnType != HType.UNKNOWN && caller != null) {
+      assert(invariant(caller, caller.isDeclaration));
       info.addCompiledFunction(caller);
     }
     return info.returnType;
   }
 
   void dumpReturnTypes() {
     returnInfo.forEach((Element element, ReturnInfo info) {
       if (info.returnType != HType.UNKNOWN) {
         print("Inferred $element has return type ${info.returnType}");
       }
@@ skipping 32 matching lines @@
             ? const SourceString('listSuperNativeTypeCheck')
             : const SourceString('listSuperTypeCheck');
       } else {
         return nativeCheck
             ? const SourceString('callTypeCheck')
             : const SourceString('propertyTypeCheck');
       }
     }
   }
 }