Move types out of the HInstructions.

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.
 
 class InvocationInfo {
   int parameterCount = -1;
   List<HType> providedTypes;
   List<Element> compiledFunctions;
 
-  InvocationInfo(HInvoke node)
+  InvocationInfo(HInvoke node, HTypeMap types)
       : compiledFunctions = new List<Element>() {
     assert(node != null);
     // Gather the type information provided. If the types contains no useful
     // information there is no need to actually store them.
     bool allUnknown = true;
     for (int i = 1; i < node.inputs.length; i++) {
-      if (node.inputs[i].propagatedType != HType.UNKNOWN) {
+      if (types[node.inputs[i]] != HType.UNKNOWN) {
         allUnknown = false;
         break;
       }
     }
     if (!allUnknown) {
       providedTypes = new List<HType>(node.inputs.length - 1);
       for (int i = 0; i < providedTypes.length; i++) {
-        providedTypes[i] = node.inputs[i + 1].propagatedType;
+        providedTypes[i] = types[node.inputs[i + 1]];
       }
       parameterCount = providedTypes.length;
     }
   }
 
   InvocationInfo.unknownTypes();
 
-  void update(HInvoke node, var recompile) {
+  void update(HInvoke node, HTypeMap types, var recompile) {
     // If we don't know anything useful about the types adding more
     // information will not help.
     if (!hasTypeInformation) return;
 
     // Update the type information with the provided types.
     bool typesChanged = false;
     bool allUnknown = true;
     for (int i = 0; i < providedTypes.length; i++) {
-      HType newType = providedTypes[i].union(node.inputs[i + 1].propagatedType);
+      HType newType = providedTypes[i].union(types[node.inputs[i + 1]]);
       if (newType != providedTypes[i]) {
         typesChanged = true;
         providedTypes[i] = newType;
       }
       if (providedTypes[i] != HType.UNKNOWN) allUnknown = false;
     }
     // If the provided types change we need to recompile all functions which
     // have been compiled under the now invalidated assumptions.
     if (typesChanged && compiledFunctions.length != 0) {
       if (recompile != null) {
         compiledFunctions.forEach(recompile);
       }
       compiledFunctions.clear();
     }
     // If all information is lost no need to keep it around.
     if (allUnknown) clearTypeInformation();
   }
 
   addCompiledFunction(FunctionElement function) =>
       compiledFunctions.add(function);
 
   void clearTypeInformation() => providedTypes = null;
   bool get hasTypeInformation() => providedTypes != null;
 
 }
 
+class JavaScriptItemCompilationContext extends ItemCompilationContext {
+  final HTypeMap types;
+
+  JavaScriptItemCompilationContext() : types = new HTypeMap();
+}
+
 class JavaScriptBackend extends Backend {
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
   SsaCodeGeneratorTask generator;
   CodeEmitterTask emitter;
   final Map<Element, Map<Element, HType>> fieldInitializers;
   final Map<Element, Map<Element, HType>> fieldConstructorSetters;
   final Map<Element, Map<Element, HType>> fieldSettersType;
 
   final Map<Element, InvocationInfo> staticInvocationInfo;
@@ skipping 12 matching lines @@
         fieldSettersType = new Map<Element, Map<Element, HType>>(),
         invocationInfo = new Map<SourceString, Map<Selector, InvocationInfo>>(),
         staticInvocationInfo = new Map<Element, InvocationInfo>(),
         invalidateAfterCodegen = new List<Element>(),
         super(compiler) {
     builder = new SsaBuilderTask(this);
     optimizer = new SsaOptimizerTask(this);
     generator = new SsaCodeGeneratorTask(this);
   }
 
+  JavaScriptItemCompilationContext createItemCompilationContext() {
+    return new JavaScriptItemCompilationContext();
+  }
+
   void enqueueHelpers(Enqueuer world) {
     enqueueAllTopLevelFunctions(compiler.jsHelperLibrary, world);
     enqueueAllTopLevelFunctions(compiler.interceptorsLibrary, world);
     for (var helper in [const SourceString('Closure'),
                         const SourceString('ConstantMap'),
                         const SourceString('ConstantProtoMap')]) {
       var e = compiler.findHelper(helper);
       if (e !== null) world.registerInstantiatedClass(e);
     }
   }
@@ skipping 121 matching lines @@
     }
     Map<Element, HType> fields = fieldSettersType[enclosingClass];
     if (!fields.containsKey(field)) return HType.CONFLICTING;
     return fields[field];
   }
 
   /**
    *  Register a dynamic invocation and collect the provided types for the
    *  named selector.
    */
-  void registerDynamicInvocation(HInvokeDynamicMethod node, Selector selector) {
+  void registerDynamicInvocation(HInvokeDynamicMethod node,
+                                 Selector selector,
+                                 HTypeMap types) {
     Map<Selector, InvocationInfo> invocationInfos =
         invocationInfo.putIfAbsent(node.name,
                                    () => new Map<Selector, InvocationInfo>());
     InvocationInfo info = invocationInfos[selector];
     if (info != null) {
       void recompile(Element element) {
         if (compiler.phase == Compiler.PHASE_COMPILING) {
           invalidateAfterCodegen.add(element);
         }
       }
 
-      info.update(node, recompile);
+      info.update(node, types, recompile);
     } else {
-      invocationInfos[selector] = new InvocationInfo(node);
+      invocationInfos[selector] = new InvocationInfo(node, types);
     }
   }
 
   /**
    *  Register a static invocation and collect the provided types for the
    *  named selector.
    */
-  void registerStaticInvocation(HInvokeStatic node) {
+  void registerStaticInvocation(HInvokeStatic node, HTypeMap types) {
     InvocationInfo info = staticInvocationInfo[node.element];
     if (info != null) {
       recompile(Element element) {
         if (compiler.phase == Compiler.PHASE_COMPILING) {
           invalidateAfterCodegen.add(element);
         }
       }
-      info.update(node, recompile);
+      info.update(node, types, recompile);
     } else {
-      staticInvocationInfo[node.element] = new InvocationInfo(node);
+      staticInvocationInfo[node.element] = new InvocationInfo(node, types);
     }
   }
 
   /**
    *  Register that a static is used for something else than a call target.
    */
   void registerNonCallStaticUse(HStatic node) {
     // When a static is used for anything else than a call target we cannot
     // infer anything about its parameter types.
     InvocationInfo info = staticInvocationInfo[node.element];
@@ skipping 49 matching lines @@
         FunctionSignature signature = element.computeSignature(compiler);
         if (signature.parameterCount == found.parameterCount) {
           found.addCompiledFunction(element);
           return found.providedTypes;
         }
       }
       return null;
     }
   }
 }