Further reduce use of Element in codegen.

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 '../dart_types.dart';
 import '../elements/elements.dart';
 import '../elements/entities.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.
 ///
 /// This can for instance be used to constrain this dynamic call to `foo` to
 /// 'receivers of the exact instance `Bar`':
 ///
 ///     class Bar {
 ///        void foo() {}
@@ skipping 1062 matching lines @@
   ClosedWorld get closedWorldCache {
     assert(isClosed);
     return _closedWorldCache;
   }
 }
 
 /// World builder specific to codegen.
 ///
 /// This adds additional access to liveness of selectors and elements.
 abstract class CodegenWorldBuilder implements WorldBuilder {
+  /// Calls [f] with every instance field, together with its declarer, in an
+  /// instance of [cls].
+  void forEachInstanceField(

[Siggi Cherem (dart-lang), 2017/01/03 17:39:37]

I like the move of this out of the entities.

Couple questions:
 * Does this API include all fields or just fields that are in use (not
tree-shaken)? I'm guessing it's the former, but either way, it might be good to
add a sentence in the dartdoc to be explicit. If we are only including used
fields, consider renaming this to forEachUsedInstanceField (similar to how all
the forEachInvoked* methods below).

 * should we add this API to some other interface too (like
WorldBuilder/ClosedWorld)? It might be too early to tell, but from a quick
glance it seems we use element.forEachInstanceField in a few other places
(constants, creating inference graph, ssa builder). I'm OK crossing that bridge
when we get there and not on this CL, up to you.

[Johnni Winther, 2017/01/04 10:39:49]

Currently all, in time it should be at the world builders discretion. We should
at some point in time (again) be able to tree-shake fields (based on resolution
closed world knowledge) and the caller of this function shouldn't know or care.
I expect it to be in WorldBuilder/ClosedWorld and be used elsewhere, but
currently I'm just growing the interfaces slowly by what is needed by the
refactored use cases.

+      ClassEntity cls, void f(ClassEntity declarer, FieldEntity field));
+
   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.
   bool hasInvokedSetter(Element member, ClosedWorld world);
 
   bool hasInvokedGetter(Element member, ClosedWorld world);
 
   Map<Selector, SelectorConstraints> invocationsByName(String name);
 
   Map<Selector, SelectorConstraints> getterInvocationsByName(String name);
 
   Map<Selector, SelectorConstraints> setterInvocationsByName(String name);
 
   Iterable<FunctionElement> get staticFunctionsNeedingGetter;
   Iterable<FunctionElement> get methodsNeedingSuperGetter;
 
   /// The set of all referenced static fields.
   ///
   /// Invariant: Elements are declaration elements.
   Iterable<FieldElement> get allReferencedStaticFields;
+
+  CallStructure getCallStructureFor(FunctionEntity entity);
 }
 
 class CodegenWorldBuilderImpl implements CodegenWorldBuilder {
   final Backend _backend;
 
   /// The set of all directly instantiated classes, that is, classes with a
   /// generative constructor that has been called directly and not only through
   /// a super-call.
   ///
   /// Invariant: Elements are declaration elements.
@@ skipping 52 matching lines @@
   /// closurized.
   final Map<String, Set<_MemberUsage>> _instanceFunctionsByName =
       <String, Set<_MemberUsage>>{};
 
   final Set<DartType> isChecks = new Set<DartType>();
 
   final SelectorConstraintsStrategy selectorConstraintsStrategy;
 
   CodegenWorldBuilderImpl(this._backend, this.selectorConstraintsStrategy);
 
+  /// 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);
+  }
+
+  CallStructure getCallStructureFor(MethodElement element) {
+    return new CallStructure.unnamed(element.parameters.length);
+  }
+
   // TODO(johnniwinther): Remove this hack:
   ClosedWorld get _world =>
       _backend.compiler.resolverWorld.closedWorldForTesting;
 
   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.
@@ skipping 724 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());
 }