Normalize type masks to use the least upper instantiated subclass/type.

pkg/compiler/lib/src/enqueue.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.
 
 library dart2js.enqueue;
 
 import 'dart:collection' show
     Queue;
 
 import 'common.dart';
@@ skipping 164 matching lines @@
     }
     worldImpact.onCatchTypes.forEach(registerIsCheck);
     worldImpact.closures.forEach(registerClosure);
   }
 
   void registerInstantiatedType(InterfaceType type,
                                 {bool mirrorUsage: false}) {
     task.measure(() {
       ClassElement cls = type.element;
       cls.ensureResolved(resolution);
+      bool isNative = compiler.backend.isNative(cls);
       universe.registerTypeInstantiation(
           type,
-          isNative: compiler.backend.isNative(cls),
+          isNative: isNative,
           byMirrors: mirrorUsage,
           onImplemented: (ClassElement cls) {
         compiler.backend.registerImplementedClass(
                     cls, this, compiler.globalDependencies);
       });
-      processInstantiatedClass(cls);
+      if (!cls.isAbstract || isNative || mirrorUsage) {

[Johnni Winther, 2015/11/03 13:20:02]

Make a variable and use for universe.register...

[Johnni Winther, 2015/11/06 13:43:23]

Done.

+        processInstantiatedClass(cls);
+      }
     });
   }
 
   bool checkNoEnqueuedInvokedInstanceMethods() {
     return filter.checkNoEnqueuedInvokedInstanceMethods(this);
   }
 
   void processInstantiatedClassMembers(ClassElement cls) {
     strategy.processInstantiatedClass(this, cls);
   }
@@ skipping 128 matching lines @@
         if (isResolutionQueue && !superclass.isSynthesized) {
           compiler.resolver.checkClass(superclass);
         }
         // We only tell the backend once that [superclass] was instantiated, so
         // any additional dependencies must be treated as global
         // dependencies.
         compiler.backend.registerInstantiatedClass(
             superclass, this, compiler.globalDependencies);
       }
 
-      while (cls != null) {
-        processClass(cls);
-        cls = cls.superclass;
+      ClassElement superclass = cls;
+      while (superclass != null) {
+        processClass(superclass);
+        superclass = superclass.superclass;
       }
     });
   }
 
   void registerDynamicUse(DynamicUse dynamicUse) {
     task.measure(() {
       if (universe.registerDynamicUse(dynamicUse)) {
         handleUnseenSelector(dynamicUse);
       }
     });
@@ skipping 657 matching lines @@
   @override
   void processStaticUse(Enqueuer enqueuer, StaticUse staticUse) {
     enqueuer.registerStaticUseInternal(staticUse);
   }
 
   @override
   void processDynamicUse(Enqueuer enqueuer, DynamicUse dynamicUse) {
     enqueuer.handleUnseenSelectorInternal(dynamicUse);
   }
 }