Re-apply issue 11308169: GVN getInterceptor and use the interceptor constant when the type is known.

sdk/lib/_internal/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.
 
 part of js_backend;
 
 typedef void Recompile(Element element);
 
 class ReturnInfo {
   HType returnType;
@@ skipping 83 matching lines @@
       result.types[i] = types[node.inputs[i + 1]];
     }
     return result;
   }
 
   factory HTypeList.fromDynamicInvocation(HInvokeDynamic node,
                                           Selector selector,
                                           HTypeMap types) {
     HTypeList result;
     int argumentsCount = node.inputs.length - 1;
+    int startInvokeIndex = HInvoke.ARGUMENTS_OFFSET;
+
+    if (node.isInterceptorCall) {
+      argumentsCount--;
+      startInvokeIndex++;
+    }
+
     if (selector.namedArgumentCount > 0) {
       result =
           new HTypeList.withNamedArguments(
               argumentsCount, selector.namedArguments);
     } else {
       result = new HTypeList(argumentsCount);
     }
+
     for (int i = 0; i < result.types.length; i++) {
-      result.types[i] = types[node.inputs[i + 1]];
+      result.types[i] = types[node.inputs[i + startInvokeIndex]];
     }
     return result;
   }
 
   static const HTypeList ALL_UNKNOWN = const HTypeList.withAllUnknown();
 
   bool get allUnknown => types == null;
   bool get hasNamedArguments => namedArguments != null;
   int get length => types.length;
   HType operator[](int index) => types[index];
@@ skipping 12 matching lines @@
         result.types.setRange(0, i, this.types);
       }
       if (result != this) {
         result.types[i] = newType;
       }
       if (result[i] != HType.UNKNOWN) onlyUnknown = false;
     }
     return onlyUnknown ? HTypeList.ALL_UNKNOWN : result;
   }
 
-  /**
-   * Create the union of this [HTypeList] object with the types used by
-   * the [node]. If the union results in exactly the same types the receiver
-   * is returned. Otherwise a different [HTypeList] object is returned
-   * with the type union information.
-   */
-  HTypeList unionWithInvoke(HInvoke node, HTypeMap types, Compiler compiler) {
-    // Union an all unknown list with something stays all unknown.
-    if (allUnknown) return this;
-
-    bool allUnknown = true;
-    if (length != node.inputs.length - 1) {
-      return HTypeList.ALL_UNKNOWN;
-    }
-
-    bool onlyUnknown = true;
-    HTypeList result = this;
-    for (int i = 0; i < length; i++) {
-      HType newType = this[i].union(types[node.inputs[i + 1]], compiler);
-      if (result == this && newType != this[i]) {
-        // Create a new argument types object with the matching types copied.
-        result = new HTypeList(length);
-        result.types.setRange(0, i, this.types);
-      }
-      if (result != this) {
-        result.types[i] = newType;
-      }
-      if (result[i] != HType.UNKNOWN) onlyUnknown = false;
-    }
-    return onlyUnknown ? HTypeList.ALL_UNKNOWN : result;
-  }
-
   HTypeList unionWithOptionalParameters(
       Selector selector,
       FunctionSignature signature,
       OptionalParameterTypes defaultValueTypes) {
     assert(allUnknown || selector.argumentCount == this.length);
     // Create a new HTypeList for holding types for all parameters.
     HTypeList result = new HTypeList(signature.parameterCount);
 
     // First fill in the type of the positional arguments.
     int nextTypeIndex = -1;
@@ skipping 279 matching lines @@
         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;
 
+  bool updateTypes(HTypeList oldTypes, HTypeList newTypes, var key, var map) {
+    if (oldTypes.allUnknown) return false;
+    newTypes = oldTypes.union(newTypes, backend.compiler);
+    if (identical(newTypes, oldTypes)) return false;
+    map[key] = newTypes;
+    return true;
+  }
+
   void registerStaticInvocation(HInvokeStatic node, HTypeMap types) {
     Element element = node.element;
     assert(invariant(node, element.isDeclaration));
     HTypeList oldTypes = staticTypeMap[element];
+    HTypeList newTypes = new HTypeList.fromStaticInvocation(node, types);
     if (oldTypes == null) {
-      staticTypeMap[element] = new HTypeList.fromStaticInvocation(node, types);
-    } else {
-      if (oldTypes.allUnknown) return;
-      HTypeList newTypes =
-          oldTypes.unionWithInvoke(node, types, backend.compiler);
-      if (identical(newTypes, oldTypes)) return;
       staticTypeMap[element] = newTypes;
+    } else if (updateTypes(oldTypes, newTypes, element, staticTypeMap)) {
       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;
@@ skipping 19 matching lines @@
          resolverWorld.hasInvokedGetter(element, compiler))) {
       return;
     }
 
     HTypeList providedTypes =
         new HTypeList.fromDynamicInvocation(node, selector, types);
     if (!selectorTypeMap.containsKey(selector)) {
       selectorTypeMap[selector] = providedTypes;
     } else {
       HTypeList oldTypes = selectorTypeMap[selector];
-      HTypeList newTypes =
-           oldTypes.unionWithInvoke(node, types, backend.compiler);
-      if (identical(newTypes, oldTypes)) return;
-      selectorTypeMap[selector] = newTypes;
+      updateTypes(oldTypes, providedTypes, selector, selectorTypeMap);
     }
 
     // If we're not compiling, we don't have to do anything.
     if (compiler.phase != Compiler.PHASE_COMPILING) return;
 
     // Run through all optimized functions and figure out if they need
     // to be recompiled because of this new invocation.
     optimizedFunctions.filterBySelector(selector).forEach((Element element) {
       // TODO(kasperl): Maybe check if the element is already marked for
       // recompilation? Could be pretty cheap compared to computing
@@ skipping 110 matching lines @@
   ClassElement jsNumberClass;
   ClassElement jsIntClass;
   ClassElement jsDoubleClass;
   ClassElement jsFunctionClass;
   ClassElement jsNullClass;
   ClassElement jsBoolClass;
   ClassElement objectInterceptorClass;
   Element jsArrayLength;
   Element jsStringLength;
   Element getInterceptorMethod;
+  Element arrayInterceptor;
+  Element boolInterceptor;
+  Element doubleInterceptor;
+  Element functionInterceptor;
+  Element intInterceptor;
+  Element nullInterceptor;
+  Element numberInterceptor;
+  Element stringInterceptor;
   bool _interceptorsAreInitialized = false;
 
   final Namer namer;
 
   /**
    * Interface used to determine if an object has the JavaScript
    * indexing behavior. The interface is only visible to specific
    * libraries.
    */
   ClassElement jsIndexingBehaviorInterface;
@@ skipping 110 matching lines @@
     jsFunctionClass =
         compiler.findInterceptor(const SourceString('JSFunction'));
     jsBoolClass =
         compiler.findInterceptor(const SourceString('JSBool'));
     jsArrayClass.ensureResolved(compiler);
     jsArrayLength =
         jsArrayClass.lookupLocalMember(const SourceString('length'));
     jsStringClass.ensureResolved(compiler);
     jsStringLength =
         jsStringClass.lookupLocalMember(const SourceString('length'));
+
+    arrayInterceptor =
+        compiler.findInterceptor(const SourceString('arrayInterceptor'));
+    boolInterceptor =
+        compiler.findInterceptor(const SourceString('boolInterceptor'));
+    doubleInterceptor =
+        compiler.findInterceptor(const SourceString('doubleInterceptor'));
+    functionInterceptor =
+        compiler.findInterceptor(const SourceString('functionInterceptor'));
+    intInterceptor =
+        compiler.findInterceptor(const SourceString('intInterceptor'));
+    nullInterceptor =
+        compiler.findInterceptor(const SourceString('nullInterceptor'));
+    stringInterceptor =
+        compiler.findInterceptor(const SourceString('stringInterceptor'));
+    numberInterceptor =
+        compiler.findInterceptor(const SourceString('numberInterceptor'));
   }
 
   void addInterceptors(ClassElement cls) {
     cls.ensureResolved(compiler);
     cls.forEachMember((ClassElement classElement, Element member) {
         Set<Element> set = interceptedElements.putIfAbsent(
             member.name, () => new Set<Element>());
         set.add(member);
       },
       includeSuperMembers: true);
@@ skipping 299 matching lines @@
     print("Inferred return types:");
     print("----------------------");
     dumpReturnTypes();
     print("");
     print("Inferred field types:");
     print("------------------------");
     fieldTypes.dump();
     print("");
   }
 }