It's alive!

pkg/compiler/lib/src/js_emitter/full_emitter/emitter.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.full_emitter;
 
 import 'dart:collection' show HashMap;
 import 'dart:convert';
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
 import 'package:js_runtime/shared/embedded_names.dart'
     show JsBuiltin, JsGetName;
 
 import '../../../compiler_new.dart';
 import '../../common.dart';
 import '../../compiler.dart' show Compiler;
 import '../../constants/values.dart';
 import '../../common_elements.dart' show CommonElements;
 import '../../elements/resolution_types.dart' show ResolutionDartType;
 import '../../deferred_load.dart' show OutputUnit;
 import '../../elements/elements.dart'
     show
         ClassElement,
         Element,
         Elements,
         FieldElement,
-        FunctionElement,
         FunctionSignature,
         LibraryElement,
         MethodElement,
         TypedefElement;
 import '../../elements/entities.dart';
 import '../../hash/sha1.dart' show Hasher;
 import '../../io/code_output.dart';
 import '../../io/location_provider.dart' show LocationCollector;
 import '../../io/source_map_builder.dart' show SourceMapBuilder;
 import '../../js/js.dart' as jsAst;
@@ skipping 123 matching lines @@
 
   /**
    * Accumulate properties for classes and libraries, describing their
    * static/top-level members.
    * Later, these members are emitted when the class or library is emitted.
    *
    * See [getElementDescriptor].
    */
   // TODO(ahe): Generate statics with their class, and store only libraries in
   // this map.
-  final Map<Fragment, Map<Element, ClassBuilder>> elementDescriptors =
-      new Map<Fragment, Map<Element, ClassBuilder>>();
+  final Map<Fragment, Map<LibraryEntity, ClassBuilder>> libraryDescriptors =
+      new Map<Fragment, Map<LibraryEntity, ClassBuilder>>();
+
+  final Map<Fragment, Map<ClassEntity, ClassBuilder>> classDescriptors =
+      new Map<Fragment, Map<ClassEntity, ClassBuilder>>();
 
   final bool generateSourceMap;
 
   Emitter(this.compiler, this.namer, this._closedWorld, this.generateSourceMap,
       this.task, this._sorter)
       : classEmitter = new ClassEmitter(_closedWorld),
         interceptorEmitter = new InterceptorEmitter(_closedWorld),
         nsmEmitter = new NsmEmitter(_closedWorld) {
     constantEmitter = new ConstantEmitter(
         compiler.options,
@@ skipping 286 matching lines @@
         elementOrSelector.isFunction ||
         elementOrSelector.isConstructor) {
       int positionalParameterCount;
       String namedArguments = '';
       bool isConstructor = false;
       if (elementOrSelector is Selector) {
         CallStructure callStructure = elementOrSelector.callStructure;
         positionalParameterCount = callStructure.positionalArgumentCount;
         namedArguments = namedParametersAsReflectionNames(callStructure);
       } else {
-        FunctionElement function = elementOrSelector;
+        MethodElement function = elementOrSelector;
         if (function.isConstructor) {
           isConstructor = true;
           name = Elements.reconstructConstructorName(function);
         }
         FunctionSignature signature = function.functionSignature;
         positionalParameterCount = signature.requiredParameterCount;
         if (signature.optionalParametersAreNamed) {
           var names = [];
           for (Element e in signature.optionalParameters) {
             names.add(e.name);
@@ skipping 67 matching lines @@
     reporter.withCurrentElement(classElement, () {
       classEmitter.emitClass(cls, enclosingBuilder, fragment);
     });
   }
 
   void assembleStaticFunctions(
       Iterable<Method> staticFunctions, Fragment fragment) {
     if (staticFunctions == null) return;
 
     for (Method method in staticFunctions) {
-      MethodElement element = method.element;
+      FunctionEntity element = method.element;
       // We need to filter out null-elements for the interceptors.
       // TODO(floitsch): use the precomputed interceptors here.
       if (element == null) continue;
       ClassBuilder builder = new ClassBuilder.forStatics(element, namer);
       containerBuilder.addMemberMethod(method, builder);
       getStaticMethodDescriptor(element, fragment)
           .properties
           .addAll(builder.properties);
     }
   }
@@ skipping 425 matching lines @@
         } catch(_) {}
 
         return false;
       })();
     ''');
 
     return supportsDirectProtoAccess;
   }
 
   jsAst.Expression generateLibraryDescriptor(
-      LibraryElement library, Fragment fragment) {
+      LibraryEntity library, Fragment fragment) {
     var uri = "";
     if (!compiler.options.enableMinification ||
         backend.mirrorsData.mustPreserveUris) {
       uri = library.canonicalUri;
       if (uri.scheme == 'file' && compiler.options.outputUri != null) {
         uri =
             relativize(compiler.options.outputUri, library.canonicalUri, false);
       }
     }
 
     String libraryName = (!compiler.options.enableMinification ||
             backend.mirrorsData.mustRetainLibraryNames)
-        ? library.libraryName
+        // TODO(johnniwinther): Support library names for entities.
+        ? library is LibraryElement ? library.libraryName : library.name
         : "";
 
     jsAst.Fun metadata =
         task.metadataCollector.buildLibraryMetadataFunction(library);
 
-    ClassBuilder descriptor = elementDescriptors[fragment][library];
+    ClassBuilder descriptor = libraryDescriptors[fragment][library];
 
     jsAst.ObjectInitializer initializer;
     if (descriptor == null) {
       // Nothing of the library was emitted.
       // TODO(floitsch): this should not happen. We currently have an example
       // with language/prefix6_negative_test.dart where we have an instance
       // method without its corresponding class.
       initializer = new jsAst.ObjectInitializer([]);
     } else {
       initializer = descriptor.toObjectInitializer();
@@ skipping 213 matching lines @@
       }
       jsAst.Expression mangledGlobalNamesAccess =
           generateEmbeddedGlobalAccess(embeddedNames.MANGLED_GLOBAL_NAMES);
       jsAst.ObjectInitializer map = new jsAst.ObjectInitializer(properties);
       parts.add(js.statement('# = #', [mangledGlobalNamesAccess, map]));
     }
 
     return new jsAst.Block(parts);
   }
 
-  void checkEverythingEmitted(Iterable<Element> elements) {
-    List<Element> pendingStatics =
-        Elements.sortedByPosition(elements.where((e) => !e.isLibrary));
+  void checkEverythingEmitted(
+      Map<ClassEntity, ClassBuilder> pendingClassBuilders) {
+    if (pendingClassBuilders == null) return;
+    List<ClassEntity> pendingClasses =
+        _sorter.sortClasses(pendingClassBuilders.keys);
 
-    pendingStatics.forEach((element) => reporter.reportInfo(
+    pendingClasses.forEach((ClassEntity element) => reporter.reportInfo(
         element, MessageKind.GENERIC, {'text': 'Pending statics.'}));
 
-    if (pendingStatics != null && !pendingStatics.isEmpty) {
+    if (pendingClasses != null && !pendingClasses.isEmpty) {
       reporter.internalError(
-          pendingStatics.first, 'Pending statics (see above).');
+          pendingClasses.first, 'Pending statics (see above).');
     }
   }
 
   void assembleLibrary(Library library, Fragment fragment) {
-    LibraryElement libraryElement = library.element;
+    LibraryEntity libraryElement = library.element;
 
     assembleStaticFunctions(library.statics, fragment);
 
     ClassBuilder libraryBuilder =
         getLibraryDescriptor(libraryElement, fragment);
     for (Class cls in library.classes) {
       assembleClass(cls, libraryBuilder, fragment);
     }
 
     classEmitter.emitFields(library, libraryBuilder, emitStatics: true);
@@ skipping 27 matching lines @@
 
     List<jsAst.Statement> statements = <jsAst.Statement>[];
 
     statements..add(buildGeneratedBy())..add(js.comment(HOOKS_API_USAGE));
 
     if (isProgramSplit) {
       statements.add(buildDeferredHeader());
     }
 
     // Collect the AST for the descriptors.
-    Map<Element, ClassBuilder> descriptors = elementDescriptors[mainFragment];
-    if (descriptors == null) descriptors = const {};
+    Map<LibraryEntity, ClassBuilder> descriptors =
+        libraryDescriptors[mainFragment] ?? const {};
 
-    checkEverythingEmitted(descriptors.keys);
+    checkEverythingEmitted(classDescriptors[mainFragment]);
 
     Iterable<LibraryEntity> libraries = outputLibraryLists[mainOutputUnit];
-    if (libraries == null) libraries = <LibraryElement>[];
+    if (libraries == null) libraries = <LibraryEntity>[];
 
     List<jsAst.Expression> parts = <jsAst.Expression>[];
     for (LibraryEntity library in _sorter.sortLibraries(libraries)) {
       parts.add(generateLibraryDescriptor(library, mainFragment));
       descriptors.remove(library);
     }
 
     if (descriptors.isNotEmpty) {
-      List<Element> remainingLibraries =
-          descriptors.keys.where((Element e) => e is LibraryElement).toList();
+      List<LibraryEntity> remainingLibraries = descriptors.keys.toList();
 
       // The remaining descriptors are only accessible through reflection.
       // The program builder does not collect libraries that only
       // contain typedefs that are used for reflection.
-      for (LibraryElement element in remainingLibraries) {
-        assert(element is LibraryElement);
-        if (element is LibraryElement) {
-          parts.add(generateLibraryDescriptor(element, mainFragment));
-          descriptors.remove(element);
-        }
+      for (LibraryEntity element in remainingLibraries) {
+        parts.add(generateLibraryDescriptor(element, mainFragment));
+        descriptors.remove(element);
       }
     }
     jsAst.ArrayInitializer descriptorsAst = new jsAst.ArrayInitializer(parts);
 
     // Using a named function here produces easier to read stack traces in
     // Chrome/V8.
     statements.add(js.statement(
         """
     (function() {
        // No renaming in the top-level function to save the locals for the
@@ skipping 176 matching lines @@
   }
 
   Map<OutputUnit, jsAst.Expression> buildDescriptorsForOutputUnits(
       Program program) {
     Map<OutputUnit, jsAst.Expression> outputs =
         new Map<OutputUnit, jsAst.Expression>();
 
     for (Fragment fragment in program.deferredFragments) {
       OutputUnit outputUnit = fragment.outputUnit;
 
-      Map<Element, ClassBuilder> descriptors = elementDescriptors[fragment];
+      Map<LibraryEntity, ClassBuilder> descriptors =
+          libraryDescriptors[fragment];
 
       if (descriptors != null && descriptors.isNotEmpty) {
         Iterable<LibraryEntity> libraries = outputLibraryLists[outputUnit];
-        if (libraries == null) libraries = [];
+        if (libraries == null) libraries = <LibraryEntity>[];
 
         // TODO(johnniwinther): Avoid creating [CodeBuffer]s.
         List<jsAst.Expression> parts = <jsAst.Expression>[];
         for (LibraryEntity library in _sorter.sortLibraries(libraries)) {
           parts.add(generateLibraryDescriptor(library, fragment));
           descriptors.remove(library);
         }
 
         outputs[outputUnit] = new jsAst.ArrayInitializer(parts);
       }
@@ skipping 56 matching lines @@
 
     if (_closedWorld.backendUsage.requiresPreamble &&
         !backend.htmlLibraryIsLoaded) {
       reporter.reportHintMessage(NO_LOCATION_SPANNABLE, MessageKind.PREAMBLE);
     }
     // Return the total program size.
     return outputBuffers.values.fold(0, (a, b) => a + b.length);
   }
 
   ClassBuilder getStaticMethodDescriptor(
-      MethodElement element, Fragment fragment) {
-    Element owner = element.library;
+      FunctionEntity element, Fragment fragment) {
     if (!_nativeData.isNativeMember(element)) {
       // For static (not top level) elements, record their code in a buffer
       // specific to the class. For now, not supported for native classes and
       // native elements.
-      ClassElement cls = element.enclosingClass;
+      ClassEntity cls = element.enclosingClass;
       if (compiler.codegenWorldBuilder.directlyInstantiatedClasses
               .contains(cls) &&
           !_nativeData.isNativeClass(cls) &&
-          compiler.deferredLoadTask.outputUnitForElement(element) ==
-              compiler.deferredLoadTask.outputUnitForElement(cls)) {
-        owner = cls;
+          compiler.deferredLoadTask.outputUnitForMember(element) ==
+              compiler.deferredLoadTask.outputUnitForClass(cls)) {
+        return classDescriptors
+            .putIfAbsent(fragment, () => new Map<ClassEntity, ClassBuilder>())
+            .putIfAbsent(cls, () {
+          return new ClassBuilder.forClass(cls, namer);
+        });
       }
     }
-    return _getElementDescriptor(element, owner, fragment);
+    return _getLibraryDescriptor(element, element.library, fragment);
   }
 
-  ClassBuilder getLibraryDescriptor(LibraryElement element, Fragment fragment) {
-    return _getElementDescriptor(element, element, fragment);
+  ClassBuilder getLibraryDescriptor(LibraryEntity element, Fragment fragment) {
+    return _getLibraryDescriptor(element, element, fragment);
   }
 
-  ClassBuilder _getElementDescriptor(
-      Element element, Element owner, Fragment fragment) {
+  ClassBuilder _getLibraryDescriptor(
+      Entity element, LibraryEntity owner, Fragment fragment) {
     if (owner == null) {
       reporter.internalError(element, 'Owner is null.');
     }
-    return elementDescriptors
-        .putIfAbsent(fragment, () => new Map<Element, ClassBuilder>())
+    return libraryDescriptors
+        .putIfAbsent(fragment, () => new Map<LibraryEntity, ClassBuilder>())
         .putIfAbsent(owner, () {
-      return new ClassBuilder(owner, namer, owner.isClass);
+      return new ClassBuilder.forLibrary(owner, namer);
     });
   }
 
   /// Emits support-code for deferred loading into [output].
   jsAst.Statement buildDeferredBoilerPlate(
       Map<OutputUnit, _DeferredOutputUnitHash> deferredLoadHashes) {
     List<jsAst.Statement> parts = <jsAst.Statement>[];
 
     parts.add(js.statement(
         '''
@@ skipping 238 matching lines @@
     // data.
     mapping["_comment"] = "This mapping shows which compiled `.js` files are "
         "needed for a given deferred library import.";
     mapping.addAll(compiler.deferredLoadTask.computeDeferredMap());
     compiler.outputProvider(
         compiler.options.deferredMapUri.path, '', OutputType.info)
       ..add(const JsonEncoder.withIndent("  ").convert(mapping))
       ..close();
   }
 }