Use entities in native_emitter.dart

pkg/compiler/lib/src/universe/world_builder.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 universe;
 
 import 'dart:collection';
 
 import '../cache_strategy.dart';
 import '../common.dart';
 import '../common/backend_api.dart' show Backend;
 import '../common/names.dart' show Identifiers;
 import '../common/resolution.dart' show Resolution;
 import '../compiler.dart' show Compiler;
 import '../core_types.dart';
-import '../elements/resolution_types.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
+import '../elements/resolution_types.dart';
+import '../elements/types.dart';
 import '../universe/class_set.dart';
 import '../universe/function_set.dart' show FunctionSetBuilder;
 import '../util/enumset.dart';
 import '../util/util.dart';
 import '../world.dart' show World, ClosedWorld, ClosedWorldImpl, OpenWorld;
 import 'call_structure.dart' show CallStructure;
 import 'selector.dart' show Selector;
 import 'use.dart' show DynamicUse, DynamicUseKind, StaticUse, StaticUseKind;
 
 /// The known constraint on receiver for a dynamic call site.
@@ skipping 1077 matching lines @@
 abstract class CodegenWorldBuilder implements WorldBuilder {
   /// Opens this world builder using [closedWorld] as the known superset of
   /// possible runtime entities.
   void open(ClosedWorld closedWorld);
 
   /// Calls [f] with every instance field, together with its declarer, in an
   /// instance of [cls].
   void forEachInstanceField(
       ClassEntity cls, void f(ClassEntity declarer, FieldEntity field));
 
+  /// Calls [f] for each parameter of [function] providing the type and name of
+  /// the parameter.
+  void forEachParameter(
+      FunctionEntity function, void f(DartType type, String name));
+
   void forEachInvokedName(
       f(String name, Map<Selector, SelectorConstraints> selectors));
 
   void forEachInvokedGetter(
       f(String name, Map<Selector, SelectorConstraints> selectors));
 
   void forEachInvokedSetter(
       f(String name, Map<Selector, SelectorConstraints> selectors));
 
   /// Returns `true` if [member] is invoked as a setter.
@@ skipping 101 matching lines @@
   }
 
   /// Calls [f] with every instance field, together with its declarer, in an
   /// instance of [cls].
   void forEachInstanceField(
       ClassElement cls, void f(ClassEntity declarer, FieldEntity field)) {
     cls.implementation
         .forEachInstanceField(f, includeSuperAndInjectedMembers: true);
   }
 
+  @override
+  void forEachParameter(
+      MethodElement function, void f(DartType type, String name)) {
+    FunctionSignature parameters = function.functionSignature;
+    parameters.forEachParameter((ParameterElement parameter) {
+      f(parameter.type, parameter.name);
+    });
+  }
+
   Iterable<ClassElement> get processedClasses => _processedClasses.keys
       .where((cls) => _processedClasses[cls].isInstantiated);
 
   /// All directly instantiated classes, that is, classes with a generative
   /// constructor that has been called directly and not only through a
   /// super-call.
   // TODO(johnniwinther): Improve semantic precision.
   Iterable<ClassElement> get directlyInstantiatedClasses {
     return _directlyInstantiatedClasses;
   }
@@ skipping 720 matching lines @@
   @override
   EnumSet<MemberUse> get _originalUse => MemberUses.ALL_STATIC;
 }
 
 void removeFromSet(Map<String, Set<_MemberUsage>> map, Element element) {
   Set<_MemberUsage> set = map[element.name];
   if (set == null) return;
   set.removeAll(
       set.where((_MemberUsage usage) => usage.entity == element).toList());
 }