Reduce use of elements/resolution_types in enqueuer.

pkg/compiler/lib/src/universe/resolution_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;
 
 abstract class ResolutionWorldBuilder implements WorldBuilder, OpenWorld {
   /// Set of all local functions in the program. Used by the mirror tracking
   /// system to find all live closure instances.
   Iterable<LocalFunctionElement> get localFunctions;
@@ skipping 376 matching lines @@
       }
     });
     return classes;
   }
 
   /// All directly instantiated types, that is, the types of the directly
   /// instantiated classes.
   ///
   /// See [directlyInstantiatedClasses].
   // TODO(johnniwinther): Improve semantic precision.
-  Iterable<ResolutionDartType> get instantiatedTypes {
+  Iterable<InterfaceType> get instantiatedTypes {
     Set<ResolutionInterfaceType> types = new Set<ResolutionInterfaceType>();
     getInstantiationMap().forEach((_, InstantiationInfo info) {
       if (info.instantiationMap != null) {
         for (Set<Instance> instances in info.instantiationMap.values) {
           for (Instance instance in instances) {
             types.add(instance.type);
           }
         }
       }
     });
@@ skipping 185 matching lines @@
     ReceiverConstraint mask = dynamicUse.mask;
     Map<Selector, SelectorConstraints> selectors = selectorMap.putIfAbsent(
         name, () => new Maplet<Selector, SelectorConstraints>());
     UniverseSelectorConstraints constraints =
         selectors.putIfAbsent(selector, () {
       return selectorConstraintsStrategy.createSelectorConstraints(selector);
     });
     return constraints.addReceiverConstraint(mask);
   }
 
-  ResolutionDartType registerIsCheck(ResolutionDartType type) {
+  void registerIsCheck(ResolutionDartType type) {
     type.computeUnaliased(_resolution);
     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, MemberUsedCallback memberUsed) {
     Element element = staticUse.element;
     assert(invariant(element, element.isDeclaration,
         message: "Element ${element} is not the declaration."));
     _StaticMemberUsage usage = _staticMemberUsage.putIfAbsent(element, () {
       if ((element.isStatic || element.isTopLevel) && element.isFunction) {
         return new _StaticFunctionUsage(element);
       } else {
@@ skipping 325 matching lines @@
   @override
   bool isMemberUsed(MemberEntity member) {
     if (member.isInstanceMember) {
       _MemberUsage usage = _instanceMemberUsage[member];
       if (usage != null && usage.hasUse) return true;
     }
     _StaticMemberUsage usage = _staticMemberUsage[member];
     return usage != null && usage.hasUse;
   }
 }