Use more entities in program_builder, collector and registry

pkg/compiler/lib/src/js_emitter/program_builder/program_builder.dart

 // Copyright (c) 2014, 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.js_emitter.program_builder;
 
 import '../../closure.dart' show ClosureTask, ClosureFieldElement;
 import '../../common.dart';
 import '../../common/names.dart' show Names, Selectors;
 import '../../constants/values.dart'
     show ConstantValue, InterceptorConstantValue;
-import '../../common_elements.dart' show CommonElements;
+import '../../common_elements.dart' show CommonElements, ElementEnvironment;
 import '../../deferred_load.dart' show DeferredLoadTask, OutputUnit;
 import '../../elements/elements.dart'
     show
         ClassElement,
         Element,
         Elements,
         FieldElement,
         FunctionElement,
         FunctionSignature,
         GetterElement,
@@ skipping 35 matching lines @@
         ClassStubGenerator,
         CodeEmitterTask,
         computeMixinClass,
         Emitter,
         InterceptorStubGenerator,
         MainCallStubGenerator,
         ParameterStubGenerator,
         RuntimeTypeGenerator,
         TypeTestProperties;
 import '../model.dart';
+import '../sorter.dart';
 
 part 'collector.dart';
 part 'field_visitor.dart';
 part 'registry.dart';
 
 /// Builds a self-contained representation of the program that can then be
 /// emitted more easily by the individual emitters.
 class ProgramBuilder {
   final CompilerOptions _options;
+  final ElementEnvironment _elementEnvironment;
   final CommonElements _commonElements;
   final DartTypes _types;
   final DeferredLoadTask _deferredLoadTask;
   final ClosureTask _closureToClassMapper;
   final CodegenWorldBuilder _worldBuilder;
   final NativeCodegenEnqueuer _nativeCodegenEnqueuer;
   final BackendUsage _backendUsage;
   final JavaScriptConstantCompiler _constantHandler;
   final NativeData _nativeData;
   final RuntimeTypesNeed _rtiNeed;
@@ skipping 21 matching lines @@
   final Registry _registry;
 
   final FunctionEntity _mainFunction;
   final bool _isMockCompilation;
 
   /// True if the program should store function types in the metadata.
   bool _storeFunctionTypesInMetadata = false;
 
   ProgramBuilder(
       this._options,
+      this._elementEnvironment,
       this._commonElements,
       this._types,
       this._deferredLoadTask,
       this._closureToClassMapper,
       this._worldBuilder,
       this._nativeCodegenEnqueuer,
       this._backendUsage,
       this._constantHandler,
       this._nativeData,
       this._rtiNeed,
       this._mirrorsData,
       this._interceptorData,
       this._superMemberData,
       this._rtiChecks,
       this._rtiEncoder,
       this._rtiSubstitutions,
       this._jsInteropAnalysis,
       this._oneShotInterceptorData,
       this._customElementsCodegenAnalysis,
       this._generatedCode,
       this._namer,
       this._task,
       this._closedWorld,
-      Set<ClassElement> rtiNeededClasses,
+      Set<ClassEntity> rtiNeededClasses,
       this._mainFunction,
       {bool isMockCompilation})
       : this._isMockCompilation = isMockCompilation,
         this.collector = new Collector(
             _options,
             _commonElements,
             _deferredLoadTask,
             _worldBuilder,
             _namer,
             _task.emitter,
             _constantHandler,
             _nativeData,
             _interceptorData,
             _oneShotInterceptorData,
             _mirrorsData,
             _closedWorld,
             rtiNeededClasses,
-            _generatedCode),
-        this._registry = new Registry(_deferredLoadTask);
+            _generatedCode,
+            _task.sorter),
+        this._registry = new Registry(_deferredLoadTask, _task.sorter);
 
-  /// Mapping from [ClassElement] to constructed [Class]. We need this to
+  /// Mapping from [ClassEntity] to constructed [Class]. We need this to
   /// update the superclass in the [Class].
-  final Map<ClassElement, Class> _classes = <ClassElement, Class>{};
+  final Map<ClassEntity, Class> _classes = <ClassEntity, Class>{};
 
   /// Mapping from [OutputUnit] to constructed [Fragment]. We need this to
   /// generate the deferredLoadingMap (to know which hunks to load).
   final Map<OutputUnit, Fragment> _outputs = <OutputUnit, Fragment>{};
 
   /// Mapping from [ConstantValue] to constructed [Constant]. We need this to
   /// update field-initializers to point to the ConstantModel.
   final Map<ConstantValue, Constant> _constants = <ConstantValue, Constant>{};
 
   /// Mapping from names to strings.
   ///
   /// This mapping is used to support `const Symbol` expressions.
   ///
   /// This map is filled when building classes.
   final Map<js.Name, String> _symbolsMap = <js.Name, String>{};
 
   Set<Class> _unneededNativeClasses;
 
   Program buildProgram({bool storeFunctionTypesInMetadata: false}) {
     collector.collect();
 
     this._storeFunctionTypesInMetadata = storeFunctionTypesInMetadata;
     // Note: In rare cases (mostly tests) output units can be empty. This
     // happens when the deferred code is dead-code eliminated but we still need
     // to check that the library has been loaded.
     _deferredLoadTask.allOutputUnits.forEach(_registry.registerOutputUnit);
-    collector.outputClassLists.forEach(_registry.registerElements);
-    collector.outputStaticLists.forEach(_registry.registerElements);
+    collector.outputClassLists.forEach(_registry.registerClasses);
+    collector.outputStaticLists.forEach(_registry.registerMembers);
     collector.outputConstantLists.forEach(_registerConstants);
-    collector.outputStaticNonFinalFieldLists
-        .forEach(_registry.registerElements);
+    collector.outputStaticNonFinalFieldLists.forEach(_registry.registerMembers);
 
     // We always add the current isolate holder.
     _registerStaticStateHolder();
 
     // We need to run the native-preparation before we build the output. The
     // preparation code, in turn needs the classes to be set up.
     // We thus build the classes before building their containers.
     collector.outputClassLists
-        .forEach((OutputUnit _, List<ClassElement> classes) {
+        .forEach((OutputUnit _, List<ClassEntity> classes) {
       classes.forEach(_buildClass);
     });
 
     // Resolve the superclass references after we've processed all the classes.
-    _classes.forEach((ClassElement element, Class c) {
-      if (element.superclass != null) {
-        c.setSuperclass(_classes[element.superclass]);
-        assert(invariant(element, c.superclass != null,
+    _classes.forEach((ClassEntity cls, Class c) {
+      ClassEntity superclass = _elementEnvironment.getSuperClass(cls);
+      if (superclass != null) {
+        c.setSuperclass(_classes[superclass]);
+        assert(invariant(cls, c.superclass != null,
             message: "No Class for has been created for superclass "
-                "${element.superclass} of $c."));
+                "${superclass} of $c."));
       }
       if (c is MixinApplication) {
-        c.setMixinClass(_classes[computeMixinClass(element)]);
+        c.setMixinClass(_classes[computeMixinClass(cls)]);
         assert(c.mixinClass != null);
       }
     });
 
     List<Class> nativeClasses = collector.nativeClassesAndSubclasses
-        .map((ClassElement classElement) => _classes[classElement])
+        .map((ClassEntity classElement) => _classes[classElement])
         .toList();
 
-    Set<ClassElement> interceptorClassesNeededByConstants =
+    Set<ClassEntity> interceptorClassesNeededByConstants =
         collector.computeInterceptorsReferencedFromConstants();
-    Set<ClassElement> classesModifiedByEmitRTISupport =
+    Set<ClassEntity> classesModifiedByEmitRTISupport =
         _task.typeTestRegistry.computeClassesModifiedByEmitRuntimeTypeSupport();
 
     _unneededNativeClasses = _task.nativeEmitter.prepareNativeClasses(
         nativeClasses,
         interceptorClassesNeededByConstants,
         classesModifiedByEmitRTISupport);
 
     _addJsInteropStubs(_registry.mainLibrariesMap);
 
     MainFragment mainFragment = _buildMainFragment(_registry.mainLibrariesMap);
@@ skipping 98 matching lines @@
   List<Constant> _buildConstants(LibrariesMap librariesMap) {
     List<ConstantValue> constantValues =
         collector.outputConstantLists[librariesMap.outputUnit];
     if (constantValues == null) return const <Constant>[];
     return constantValues
         .map((ConstantValue value) => _constants[value])
         .toList(growable: false);
   }
 
   List<StaticField> _buildStaticNonFinalFields(LibrariesMap librariesMap) {
-    List<VariableElement> staticNonFinalFields =
+    List<FieldEntity> staticNonFinalFields =
         collector.outputStaticNonFinalFieldLists[librariesMap.outputUnit];
     if (staticNonFinalFields == null) return const <StaticField>[];
 
     return staticNonFinalFields.map(_buildStaticField).toList(growable: false);
   }
 
   StaticField _buildStaticField(FieldElement element) {
     ConstantValue initialValue =
         _constantHandler.getConstantValue(element.constant);
     // TODO(zarah): The holder should not be registered during building of
@@ skipping 41 matching lines @@
     // building a static field. (Note that the static-state holder was
     // already registered earlier, and that we just call the register to get
     // the holder-instance.
     return new StaticField(
         element, name, _registerStaticStateHolder(), code, isFinal, isLazy);
   }
 
   List<Library> _buildLibraries(LibrariesMap librariesMap) {
     List<Library> libraries = new List<Library>(librariesMap.length);
     int count = 0;
-    librariesMap.forEach((LibraryElement library, List<Element> elements) {
-      libraries[count++] = _buildLibrary(library, elements);
+    librariesMap.forEach((LibraryEntity library, List<ClassEntity> classes,
+        List<MemberEntity> members) {
+      libraries[count++] = _buildLibrary(library, classes, members);
     });
     return libraries;
   }
 
   void _addJsInteropStubs(LibrariesMap librariesMap) {
     if (_classes.containsKey(_commonElements.objectClass)) {
       var toStringInvocation = _namer.invocationName(Selectors.toString_);
       // TODO(jacobr): register toString as used so that it is always accessible
       // from JavaScript.
       _classes[_commonElements.objectClass].callStubs.add(_buildStubMethod(
           new StringBackedName("toString"),
           js.js('function() { return this.#(this) }', toStringInvocation)));
     }
 
     // We add all members from classes marked with isJsInterop to the base
     // Interceptor class with implementations that directly call the
     // corresponding JavaScript member. We do not attempt to bind this when
     // tearing off JavaScript methods as we cannot distinguish between calling
     // a regular getter that returns a JavaScript function and tearing off
     // a method in the case where there exist multiple JavaScript classes
     // that conflict on whether the member is a getter or a method.
     var interceptorClass = _classes[_commonElements.jsJavaScriptObjectClass];
     var stubNames = new Set<String>();
-    librariesMap.forEach((LibraryElement library, List<Element> elements) {
-      for (Element e in elements) {
-        if (e is ClassElement && _nativeData.isJsInteropClass(e)) {
+    librariesMap
+        .forEach((LibraryEntity library, List<ClassEntity> classElements, _) {
+      for (ClassElement e in classElements) {
+        if (_nativeData.isJsInteropClass(e)) {
           e.declaration.forEachMember((_, Element member) {
             var jsName = _nativeData.computeUnescapedJSInteropName(member.name);
             if (!member.isInstanceMember) return;
             if (member.isGetter || member.isField || member.isFunction) {
               var selectors =
                   _worldBuilder.getterInvocationsByName(member.name);
               if (selectors != null && !selectors.isEmpty) {
                 for (var selector in selectors.keys) {
                   var stubName = _namer.invocationName(selector);
                   if (stubNames.add(stubName.key)) {
@@ skipping 96 matching lines @@
               }
             }
           });
         }
       }
     });
   }
 
   // Note that a library-element may have multiple [Library]s, if it is split
   // into multiple output units.
-  Library _buildLibrary(LibraryElement library, List<Element> elements) {
+  Library _buildLibrary(LibraryElement library, List<ClassEntity> classElements,
+      List<MemberEntity> memberElements) {
     String uri = library.canonicalUri.toString();
 
-    List<StaticMethod> statics = elements
-        .where((e) => e is FunctionElement)
+    List<StaticMethod> statics = memberElements
+        .where((e) => e is MethodElement)
         .map(_buildStaticMethod)
         .toList();
 
     if (library == _commonElements.interceptorsLibrary) {
       statics.addAll(_generateGetInterceptorMethods());
       statics.addAll(_generateOneShotInterceptors());
     }
 
-    List<Class> classes = elements
-        .where((e) => e is ClassElement)
+    List<Class> classes = classElements
         .map((ClassElement classElement) => _classes[classElement])
         .where((Class cls) =>
             !cls.isNative || !_unneededNativeClasses.contains(cls))
         .toList(growable: false);
 
     bool visitStatics = true;
     List<Field> staticFieldsForReflection =
         _buildFields(library, visitStatics: visitStatics);
 
     return new Library(
@@ skipping 518 matching lines @@
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     }
   }
 
   Holder _registerStaticStateHolder() {
     return _registry.registerHolder(_namer.staticStateHolder,
         isStaticStateHolder: true);
   }
 }