Reduce use of elements/resolution_types in enqueuer.

pkg/compiler/lib/src/universe/codegen_world_builder.dart

 // Copyright (c) 2017, 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 world_builder;
 
 /// World builder specific to codegen.
 ///
 /// This adds additional access to liveness of selectors and elements.
 abstract class CodegenWorldBuilder implements WorldBuilder {
@@ skipping 51 matching lines @@
   /// Invariant: Elements are declaration elements.
   // TODO(johnniwinther): [_directlyInstantiatedClasses] and
   // [_instantiatedTypes] sets should be merged.
   final Set<ClassElement> _directlyInstantiatedClasses =
       new Set<ClassElement>();
 
   /// The set of all directly instantiated types, that is, the types of the
   /// directly instantiated classes.
   ///
   /// See [_directlyInstantiatedClasses].
-  final Set<ResolutionDartType> _instantiatedTypes =
-      new Set<ResolutionDartType>();
+  final Set<InterfaceType> _instantiatedTypes = new Set<InterfaceType>();
 
   /// Classes implemented by directly instantiated classes.
   final Set<ClassElement> _implementedClasses = new Set<ClassElement>();
 
   /// The set of all referenced static fields.
   ///
   /// Invariant: Elements are declaration elements.
   final Set<FieldElement> allReferencedStaticFields = new Set<FieldElement>();
 
   /**
@@ skipping 77 matching lines @@
   // TODO(johnniwinther): Improve semantic precision.
   Iterable<ClassElement> get directlyInstantiatedClasses {
     return _directlyInstantiatedClasses;
   }
 
   /// All directly instantiated types, that is, the types of the directly
   /// instantiated classes.
   ///
   /// See [directlyInstantiatedClasses].
   // TODO(johnniwinther): Improve semantic precision.
-  Iterable<ResolutionDartType> get instantiatedTypes => _instantiatedTypes;
+  Iterable<InterfaceType> get instantiatedTypes => _instantiatedTypes;
 
   /// Register [type] as (directly) instantiated.
   ///
   /// If [byMirrors] is `true`, the instantiation is through mirrors.
   // TODO(johnniwinther): Fully enforce the separation between exact, through
   // subclass and through subtype instantiated types/classes.
   // TODO(johnniwinther): Support unknown type arguments for generic types.
   void registerTypeInstantiation(
       ResolutionInterfaceType type, ClassUsedCallback classUsed,
       {bool byMirrors: false}) {
@@ skipping 136 matching lines @@
   void forEachInvokedGetter(
       f(String name, Map<Selector, SelectorConstraints> selectors)) {
     _invokedGetters.forEach(f);
   }
 
   void forEachInvokedSetter(
       f(String name, Map<Selector, SelectorConstraints> selectors)) {
     _invokedSetters.forEach(f);
   }
 
-  ResolutionDartType registerIsCheck(ResolutionDartType type) {
+  void registerIsCheck(ResolutionDartType type) {
     type = type.unaliased;
     // Even in checked mode, type annotations for return type and argument
     // types do not imply type checks, so there should never be a check
     // against the type variable of a typedef.
+    assert(!type.isTypeVariable || !type.element.enclosingElement.isTypedef);
     isChecks.add(type);
-    return type;
   }
 
   void _registerStaticUse(StaticUse staticUse) {
     Element element = staticUse.element;
     if (Elements.isStaticOrTopLevel(element) && element.isField) {
       allReferencedStaticFields.add(element);
     }
     switch (staticUse.kind) {
       case StaticUseKind.STATIC_TEAR_OFF:
         staticFunctionsNeedingGetter.add(element);
@@ skipping 144 matching lines @@
         return true;
       }
       return false;
     }
 
     while (cls != null && processClass(cls)) {
       cls = cls.superclass;
     }
   }
 }