Revert "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 160 matching lines @@
     worldImpact.staticUses.forEach(registerStaticUse);
     worldImpact.typeUses.forEach(registerTypeUse);
     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: isNative,
+          isNative: compiler.backend.isNative(cls),
           byMirrors: mirrorUsage,
           onImplemented: (ClassElement cls) {
         compiler.backend.registerImplementedClass(
                     cls, this, compiler.globalDependencies);
       });
-      // TODO(johnniwinther): Share this reasoning with [Universe].
-      if (!cls.isAbstract || isNative || mirrorUsage) {
-        processInstantiatedClass(cls);
-      }
+      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);
       }
 
-      ClassElement superclass = cls;
-      while (superclass != null) {
-        processClass(superclass);
-        superclass = superclass.superclass;
+      while (cls != null) {
+        processClass(cls);
+        cls = cls.superclass;
       }
     });
   }
 
   void registerDynamicUse(DynamicUse dynamicUse) {
     task.measure(() {
       if (universe.registerDynamicUse(dynamicUse)) {
         handleUnseenSelector(dynamicUse);
       }
     });
@@ skipping 679 matching lines @@
   @override
   void processStaticUse(Enqueuer enqueuer, StaticUse staticUse) {
     enqueuer.registerStaticUseInternal(staticUse);
   }
 
   @override
   void processDynamicUse(Enqueuer enqueuer, DynamicUse dynamicUse) {
     enqueuer.handleUnseenSelectorInternal(dynamicUse);
   }
 }