Use entities in runtime_types

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 20 matching lines @@
   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;
+  Iterable<FunctionEntity> get staticFunctionsNeedingGetter;
+  Iterable<FunctionEntity> get methodsNeedingSuperGetter;
 
   /// The set of all referenced static fields.
   ///
   /// Invariant: Elements are declaration elements.
-  Iterable<FieldElement> get allReferencedStaticFields;
+  Iterable<FieldEntity> get allReferencedStaticFields;
+
+  /// Set of methods in instantiated classes that are potentially closurized.
+  Iterable<FunctionEntity> get closurizedMembers;
 }
 
 class CodegenWorldBuilderImpl implements CodegenWorldBuilder {
   final NativeBasicData _nativeData;
   final ClosedWorld _world;
   final JavaScriptConstantCompiler _constants;
 
   /// 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.
@@ skipping 16 matching lines @@
   /// The set of all referenced static fields.
   ///
   /// Invariant: Elements are declaration elements.
   final Set<FieldElement> allReferencedStaticFields = new Set<FieldElement>();
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: Elements are declaration elements.
    */
-  final Set<FunctionElement> staticFunctionsNeedingGetter =
-      new Set<FunctionElement>();
-  final Set<FunctionElement> methodsNeedingSuperGetter =
-      new Set<FunctionElement>();
+  final Set<FunctionEntity> staticFunctionsNeedingGetter =
+      new Set<FunctionEntity>();
+  final Set<FunctionEntity> methodsNeedingSuperGetter =
+      new Set<FunctionEntity>();
   final Map<String, Map<Selector, SelectorConstraints>> _invokedNames =
       <String, Map<Selector, SelectorConstraints>>{};
   final Map<String, Map<Selector, SelectorConstraints>> _invokedGetters =
       <String, Map<Selector, SelectorConstraints>>{};
   final Map<String, Map<Selector, SelectorConstraints>> _invokedSetters =
       <String, Map<Selector, SelectorConstraints>>{};
 
   final Map<ClassElement, _ClassUsage> _processedClasses =
       <ClassElement, _ClassUsage>{};
 
@@ skipping 14 matching lines @@
   /// closurized.
   final Map<String, Set<_MemberUsage>> _instanceFunctionsByName =
       <String, Set<_MemberUsage>>{};
 
   final Set<ResolutionDartType> isChecks = new Set<ResolutionDartType>();
 
   final SelectorConstraintsStrategy selectorConstraintsStrategy;
 
   final Set<ConstantValue> _constantValues = new Set<ConstantValue>();
 
+  /// Set of methods in instantiated classes that are potentially closurized.
+  final Set<FunctionEntity> closurizedMembers = new Set<FunctionEntity>();
+
   CodegenWorldBuilderImpl(this._nativeData, this._world, this._constants,
       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);
   }
@@ skipping 189 matching lines @@
     isChecks.add(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);
+        MethodElement method = element;
+        staticFunctionsNeedingGetter.add(method);
         break;
       case StaticUseKind.SUPER_TEAR_OFF:
-        methodsNeedingSuperGetter.add(element);
+        MethodElement method = element;
+        methodsNeedingSuperGetter.add(method);
         break;
       case StaticUseKind.SUPER_FIELD_SET:
       case StaticUseKind.FIELD_SET:
       case StaticUseKind.GENERAL:
       case StaticUseKind.DIRECT_USE:
       case StaticUseKind.CLOSURE:
       case StaticUseKind.FIELD_GET:
       case StaticUseKind.CONSTRUCTOR_INVOKE:
       case StaticUseKind.CONST_CONSTRUCTOR_INVOKE:
       case StaticUseKind.REDIRECTION:
@@ skipping 48 matching lines @@
         useSet.addAll(usage.normalUse());
         break;
       case StaticUseKind.INLINING:
         break;
     }
     if (useSet.isNotEmpty) {
       memberUsed(usage.entity, useSet);
     }
   }
 
+  /// Registers that [element] has been closurized.
+  void registerClosurizedMember(MemberEntity element) {
+    closurizedMembers.add(element);
+  }
+
   void processClassMembers(ClassElement cls, MemberUsedCallback memberUsed) {
     cls.implementation.forEachMember((_, MemberElement member) {
       assert(invariant(member, member.isDeclaration));
       if (!member.isInstanceMember) return;
       if (member.isMalformed) return;
       _getMemberUsage(member, memberUsed);
     });
   }
 
   _MemberUsage _getMemberUsage(
@@ skipping 76 matching lines @@
 
   /// Register the constant [use] with this world builder. Returns `true` if
   /// the constant use was new to the world.
   bool registerConstantUse(ConstantUse use) {
     if (use.kind == ConstantUseKind.DIRECT) {
       _constants.addCompileTimeConstantForEmission(use.value);
     }
     return _constantValues.add(use.value);
   }
 }