Fix braino with return types, and make sure the compiler knows we might call noSuchMethod with a JS…

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;
   List<Element> compiledFunctions;
 
   ReturnInfo(HType this.returnType)
       : compiledFunctions = new List<Element>();
 
   ReturnInfo.unknownType()
-      : this.returnType = null,
+      : this.returnType = HType.UNKNOWN,
         compiledFunctions = new List<Element>();
 
   void update(HType type, Recompile recompile, Compiler compiler) {
     HType newType =
         returnType != null ? returnType.union(type, compiler) : type;
     if (newType != returnType) {
       if (returnType == null && identical(newType, HType.UNKNOWN)) {
         // If the first actual piece of information is not providing any type
         // information there is no need to recompile callers.
         compiledFunctions.clear();
@@ skipping 93 matching lines @@
     }
     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];
+  void operator[]=(int index, HType type) { types[index] = type; }
 
   HTypeList union(HTypeList other, Compiler compiler) {
     if (allUnknown) return this;
     if (other.allUnknown) return other;
     if (length != other.length) return HTypeList.ALL_UNKNOWN;
     bool onlyUnknown = true;
     HTypeList result = this;
     for (int i = 0; i < length; i++) {
       HType newType = this[i].union(other[i], compiler);
       if (result == this && newType != this[i]) {
@@ skipping 334 matching lines @@
     // 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(HInvokeDynamic node,
-                                 Selector selector,
-                                 HTypeMap types) {
+  void registerDynamicInvocation(HTypeList providedTypes, Selector selector) {
     if (selector.isClosureCall()) {
       // We cannot use the current framework to do optimizations based
       // on the 'call' selector because we are also generating closure
       // calls during the emitter phase, which at this point, does not
       // track parameter types, nor invalidates optimized methods.
       return;
     }
-    HTypeList providedTypes =
-        new HTypeList.fromDynamicInvocation(node, selector, types);
     if (!selectorTypeMap.containsKey(selector)) {
       selectorTypeMap[selector] = providedTypes;
     } else {
       HTypeList oldTypes = selectorTypeMap[selector];
       updateTypes(oldTypes, providedTypes, selector, selectorTypeMap);
     }
 
     // If we're not compiling, we don't have to do anything.
     if (compiler.phase != Compiler.PHASE_COMPILING) return;
 
@@ skipping 129 matching lines @@
   ClassElement jsBoolClass;
   ClassElement objectInterceptorClass;
   Element jsArrayLength;
   Element jsStringLength;
   Element jsArrayRemoveLast;
   Element jsArrayAdd;
   Element jsStringSplit;
   Element jsStringConcat;
   Element getInterceptorMethod;
   Element fixedLengthListConstructor;
-  bool _interceptorsAreInitialized = false;
+  bool seenAnyClass = 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 179 matching lines @@
         return keys;
       });
       return namer.isolateAccess(getInterceptorMethod);
     } else {
       String name = namer.getSpecializedName(getInterceptorMethod, classes);
       specializedGetInterceptors[name] = classes;
       return '${namer.CURRENT_ISOLATE}.$name';
     }
   }
 
+  void initializeNoSuchMethod() {
+    // In case the emitter generates noSuchMethod calls, we need to
+    // make sure all [noSuchMethod] methods know they might take a
+    // [JsInvocationMirror] as parameter.
+    HTypeList types = new HTypeList(1);
+    types[0] = new HType.fromBoundedType(
+        compiler.jsInvocationMirrorClass.computeType(compiler),
+        compiler,
+        false);
+    argumentTypes.registerDynamicInvocation(types, new Selector.noSuchMethod());
+  }
+
   void registerInstantiatedClass(ClassElement cls, Enqueuer enqueuer) {
+    if (!seenAnyClass) {
+      initializeInterceptorElements();
+      initializeNoSuchMethod();
+      seenAnyClass = true;
+    }
     ClassElement result = null;
-    if (!_interceptorsAreInitialized) {
-      initializeInterceptorElements();
-      _interceptorsAreInitialized = true;
-    }
     if (cls == compiler.stringClass) {
       addInterceptors(jsStringClass, enqueuer);
     } else if (cls == compiler.listClass) {
       addInterceptors(jsArrayClass, enqueuer);
       // The backend will try to optimize array access and use the
       // `ioore` and `iae` helpers directly.
       enqueuer.registerStaticUse(
           compiler.findHelper(const SourceString('ioore')));
       enqueuer.registerStaticUse(
           compiler.findHelper(const SourceString('iae')));
@@ skipping 95 matching lines @@
     }
   }
 
   /**
    *  Register a dynamic invocation and collect the provided types for the
    *  named selector.
    */
   void registerDynamicInvocation(HInvokeDynamic node,
                                  Selector selector,
                                  HTypeMap types) {
-    argumentTypes.registerDynamicInvocation(node, selector, types);
+    HTypeList providedTypes =
+        new HTypeList.fromDynamicInvocation(node, selector, types);
+    argumentTypes.registerDynamicInvocation(providedTypes, selector);
   }
 
   /**
    *  Register a static invocation and collect the provided types for the
    *  named selector.
    */
   void registerStaticInvocation(HInvokeStatic node, HTypeMap types) {
     argumentTypes.registerStaticInvocation(node, types);
   }
 
@@ skipping 164 matching lines @@
     print("Inferred return types:");
     print("----------------------");
     dumpReturnTypes();
     print("");
     print("Inferred field types:");
     print("------------------------");
     fieldTypes.dump();
     print("");
   }
 }