dart2js cps: More interceptor optimizations and fixes.

pkg/compiler/lib/src/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;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
@@ skipping 997 matching lines @@
         });
 
     if (elements == null) return false;
     if (elements.isEmpty) return false;
     return elements.any((element) {
       return selector.applies(element, compiler.world) &&
              (mask == null || mask.canHit(element, selector, compiler.world));
     });
   }
 
+  /// True if the given class is an internal class used for type inference
+  /// and never exists at runtime.
+  bool isCompileTimeOnlyClass(ClassElement class_) {
+  return class_ == jsPositiveIntClass ||

[sra1, 2015/10/28 02:31:52]

indent

[asgerf, 2015/10/28 10:06:31]

Done.

+      class_ == jsUInt32Class ||
+      class_ == jsUInt31Class ||
+      class_ == jsFixedArrayClass ||
+      class_ == jsUnmodifiableArrayClass ||
+      class_ == jsMutableArrayClass ||
+      class_ == jsExtendableArrayClass;
+  }
+
+  /// Maps compile-time classes to their runtime class.  The runtime class is
+  /// always a superclass or the class itself.
+  ClassElement getRuntimeClass(ClassElement class_) {
+    if (class_.isSubclassOf(jsIntClass)) return jsIntClass;
+    if (class_.isSubclassOf(jsArrayClass)) return jsArrayClass;
+    return class_;
+  }
+
   final Map<String, Set<ClassElement>> interceptedClassesCache =
       new Map<String, Set<ClassElement>>();
 
   /**
    * Returns a set of interceptor classes that contain a member named
    * [name]. Returns [:null:] if there is no class.
    */
   Set<ClassElement> getInterceptedClassesOn(String name) {
     Set<Element> intercepted = interceptedElements[name];
     if (intercepted == null) return null;
     return interceptedClassesCache.putIfAbsent(name, () {
       // Populate the cache by running through all the elements and
       // determine if the given selector applies to them.
       Set<ClassElement> result = new Set<ClassElement>();
       for (Element element in intercepted) {
         ClassElement classElement = element.enclosingClass;
+        if (isCompileTimeOnlyClass(classElement)) continue;
         if (isNativeOrExtendsNative(classElement)
             || interceptedClasses.contains(classElement)) {
           result.add(classElement);
         }
         if (classesMixedIntoInterceptedClasses.contains(classElement)) {
           Set<ClassElement> nativeSubclasses =
               nativeSubclassesOfMixin(classElement);
           if (nativeSubclasses != null) result.addAll(nativeSubclasses);
         }
       }
@@ skipping 2169 matching lines @@
   }
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final ConstantValue constant;
   final Element annotatedElement;
 
   const Dependency(this.constant, this.annotatedElement);
 }
-