Use entities in impact transformers.

pkg/compiler/lib/src/common/codegen.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.common.codegen;
 
 import '../common.dart';
-import '../elements/resolution_types.dart'
-    show ResolutionDartType, ResolutionInterfaceType;
 import '../elements/elements.dart'
     show
+        AsyncMarker,
         ClassElement,
-        Element,
-        FunctionElement,
         LocalFunctionElement,
         MemberElement,
         ResolvedAst;
 import '../elements/entities.dart';
+import '../elements/types.dart' show DartType, InterfaceType;
 import '../js_backend/backend.dart' show JavaScriptBackend;
 import '../universe/use.dart' show ConstantUse, DynamicUse, StaticUse, TypeUse;
 import '../universe/world_impact.dart'
     show WorldImpact, WorldImpactBuilderImpl, WorldImpactVisitor;
+import '../util/enumset.dart';
 import '../util/util.dart' show Pair, Setlet;
 import 'work.dart' show WorkItem;
 
 class CodegenImpact extends WorldImpact {
   const CodegenImpact();
 
-  Iterable<Pair<ResolutionDartType, ResolutionDartType>>
-      get typeVariableBoundsSubtypeChecks {
-    return const <Pair<ResolutionDartType, ResolutionDartType>>[];
+  Iterable<Pair<DartType, DartType>> get typeVariableBoundsSubtypeChecks {
+    return const <Pair<DartType, DartType>>[];
   }
 
   Iterable<String> get constSymbols => const <String>[];
 
   Iterable<Set<ClassEntity>> get specializedGetInterceptors {
     return const <Set<ClassEntity>>[];
   }
 
   bool get usesInterceptor => false;
 
-  Iterable<Element> get asyncMarkers => const <FunctionElement>[];
+  Iterable<AsyncMarker> get asyncMarkers => <AsyncMarker>[];
 }
 
 class _CodegenImpact extends WorldImpactBuilderImpl implements CodegenImpact {
-  Setlet<Pair<ResolutionDartType, ResolutionDartType>>
-      _typeVariableBoundsSubtypeChecks;
+  Setlet<Pair<DartType, DartType>> _typeVariableBoundsSubtypeChecks;
   Setlet<String> _constSymbols;
   List<Set<ClassEntity>> _specializedGetInterceptors;
   bool _usesInterceptor = false;
-  Setlet<FunctionElement> _asyncMarkers;
+  EnumSet<AsyncMarker> _asyncMarkers;
 
   _CodegenImpact();
 
   void apply(WorldImpactVisitor visitor) {
     staticUses.forEach(visitor.visitStaticUse);
     dynamicUses.forEach(visitor.visitDynamicUse);
     typeUses.forEach(visitor.visitTypeUse);
   }
 
   void registerTypeVariableBoundsSubtypeCheck(
-      ResolutionDartType subtype, ResolutionDartType supertype) {
+      DartType subtype, DartType supertype) {
     if (_typeVariableBoundsSubtypeChecks == null) {
-      _typeVariableBoundsSubtypeChecks =
-          new Setlet<Pair<ResolutionDartType, ResolutionDartType>>();
+      _typeVariableBoundsSubtypeChecks = new Setlet<Pair<DartType, DartType>>();
     }
-    _typeVariableBoundsSubtypeChecks.add(
-        new Pair<ResolutionDartType, ResolutionDartType>(subtype, supertype));
+    _typeVariableBoundsSubtypeChecks
+        .add(new Pair<DartType, DartType>(subtype, supertype));
   }
 
-  Iterable<Pair<ResolutionDartType, ResolutionDartType>>
-      get typeVariableBoundsSubtypeChecks {
+  Iterable<Pair<DartType, DartType>> get typeVariableBoundsSubtypeChecks {
     return _typeVariableBoundsSubtypeChecks != null
         ? _typeVariableBoundsSubtypeChecks
-        : const <Pair<ResolutionDartType, ResolutionDartType>>[];
+        : const <Pair<DartType, DartType>>[];
   }
 
   void registerConstSymbol(String name) {
     if (_constSymbols == null) {
       _constSymbols = new Setlet<String>();
     }
     _constSymbols.add(name);
   }
 
   Iterable<String> get constSymbols {
@@ skipping 12 matching lines @@
         ? _specializedGetInterceptors
         : const <Set<ClassEntity>>[];
   }
 
   void registerUseInterceptor() {
     _usesInterceptor = true;
   }
 
   bool get usesInterceptor => _usesInterceptor;
 
-  void registerAsyncMarker(FunctionElement element) {
+  void registerAsyncMarker(AsyncMarker asyncMarker) {
     if (_asyncMarkers == null) {
-      _asyncMarkers = new Setlet<FunctionElement>();
+      _asyncMarkers = new EnumSet<AsyncMarker>();
     }
-    _asyncMarkers.add(element);
+    _asyncMarkers.add(asyncMarker);
   }
 
-  Iterable<Element> get asyncMarkers {
-    return _asyncMarkers != null ? _asyncMarkers : const <FunctionElement>[];
+  Iterable<AsyncMarker> get asyncMarkers {
+    return _asyncMarkers != null
+        ? _asyncMarkers.iterable(AsyncMarker.values)
+        : const <AsyncMarker>[];
   }
 }
 
 // TODO(johnniwinther): Split this class into interface and implementation.
 // TODO(johnniwinther): Move this implementation to the JS backend.
 class CodegenRegistry {
   final MemberElement currentElement;
   final _CodegenImpact worldImpact;
 
   CodegenRegistry(MemberElement currentElement)
@@ skipping 19 matching lines @@
 
   void registerTypeUse(TypeUse typeUse) {
     worldImpact.registerTypeUse(typeUse);
   }
 
   void registerConstantUse(ConstantUse constantUse) {
     worldImpact.registerConstantUse(constantUse);
   }
 
   void registerTypeVariableBoundsSubtypeCheck(
-      ResolutionDartType subtype, ResolutionDartType supertype) {
+      DartType subtype, DartType supertype) {
     worldImpact.registerTypeVariableBoundsSubtypeCheck(subtype, supertype);
   }
 
   void registerInstantiatedClosure(LocalFunctionElement element) {
     worldImpact.registerStaticUse(new StaticUse.closure(element));
   }
 
   void registerConstSymbol(String name) {
     worldImpact.registerConstSymbol(name);
   }
 
   void registerSpecializedGetInterceptor(Set<ClassEntity> classes) {
     worldImpact.registerSpecializedGetInterceptor(classes);
   }
 
   void registerUseInterceptor() {
     worldImpact.registerUseInterceptor();
   }
 
-  void registerInstantiation(ResolutionInterfaceType type) {
+  void registerInstantiation(InterfaceType type) {
     registerTypeUse(new TypeUse.instantiation(type));
   }
 
-  void registerAsyncMarker(FunctionElement element) {
-    worldImpact.registerAsyncMarker(element);
+  void registerAsyncMarker(AsyncMarker asyncMarker) {
+    worldImpact.registerAsyncMarker(asyncMarker);
   }
 }
 
 /// [WorkItem] used exclusively by the [CodegenEnqueuer].
 class CodegenWorkItem extends WorkItem {
   CodegenRegistry registry;
   final ResolvedAst resolvedAst;
   final JavaScriptBackend backend;
 
   factory CodegenWorkItem(JavaScriptBackend backend, MemberElement element) {
@@ skipping 12 matching lines @@
 
   MemberElement get element => resolvedAst.element;
 
   WorldImpact run() {
     registry = new CodegenRegistry(element);
     return backend.codegen(this);
   }
 
   String toString() => 'CodegenWorkItem(${resolvedAst.element})';
 }