Compile and run Hello World!

pkg/compiler/lib/src/js_backend/namer.dart

 // Copyright (c) 2011, 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 js_backend.namer;
 
 import 'dart:collection' show HashMap;
 
 import 'package:js_runtime/shared/embedded_names.dart' show JsGetName;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Selectors;
 import '../constants/values.dart';
 import '../common_elements.dart' show CommonElements;
 import '../diagnostics/invariant.dart' show DEBUG_MODE;
-import '../elements/elements.dart';
+import '../elements/elements.dart'
+    show
+        ClassElement,
+        ConstructorBodyElement,
+        Element,
+        Elements,
+        FieldElement,
+        FormalElement,
+        FunctionElement,
+        FunctionSignature,
+        MemberElement,
+        TypeDeclarationElement,
+        MixinApplicationElement,
+        TypedefElement;
 import '../elements/entities.dart';
 import '../elements/entity_utils.dart' as utils;
 import '../elements/jumps.dart';
 import '../elements/names.dart';
 import '../elements/resolution_types.dart';
 import '../elements/types.dart';
 import '../js/js.dart' as jsAst;
-import '../tree/tree.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart' show Selector, SelectorKind;
 import '../universe/world_builder.dart' show CodegenWorldBuilder;
 import 'package:front_end/src/fasta/scanner/characters.dart';
 import '../util/util.dart';
 import '../world.dart' show ClosedWorld;
 import 'backend.dart';
 import 'constant_system_javascript.dart';
 import 'native_data.dart';
 import 'runtime_types.dart';
@@ skipping 499 matching lines @@
 
   /// Used to disambiguate names for constants in [constantName].
   final NamingScope constantScope = new NamingScope();
 
   /// Used to store scopes for instances of [PrivatelyNamedJsEntity]
   final Map<Entity, NamingScope> _privateNamingScopes =
       new Map<Entity, NamingScope>();
 
   final Map<String, int> popularNameCounters = <String, int>{};
 
-  final Map<LibraryElement, String> libraryLongNames =
-      new HashMap<LibraryElement, String>();
+  final Map<LibraryEntity, String> libraryLongNames =
+      new HashMap<LibraryEntity, String>();
 
   final Map<ConstantValue, jsAst.Name> constantNames =
       new HashMap<ConstantValue, jsAst.Name>();
   final Map<ConstantValue, String> constantLongNames =
       <ConstantValue, String>{};
   ConstantCanonicalHasher _constantHasher;
 
   /// Maps private names to a library that may use that name without prefixing
   /// itself. Used for building proposed names.
-  final Map<String, LibraryElement> shortPrivateNameOwners =
-      <String, LibraryElement>{};
+  final Map<String, LibraryEntity> shortPrivateNameOwners =
+      <String, LibraryEntity>{};
 
   final Map<String, String> suggestedGlobalNames = <String, String>{};
   final Map<String, String> suggestedInstanceNames = <String, String>{};
 
   /// Used to store unique keys for library names. Keys are not used as names,
   /// nor are they visible in the output. The only serve as an internal
   /// key into maps.
-  final Map<LibraryElement, String> _libraryKeys =
-      new HashMap<LibraryElement, String>();
+  final Map<LibraryEntity, String> _libraryKeys =
+      new HashMap<LibraryEntity, String>();
 
   Namer(this._closedWorld, this._codegenWorldBuilder) {
     _literalAsyncPrefix = new StringBackedName(asyncPrefix);
     _literalGetterPrefix = new StringBackedName(getterPrefix);
     _literalSetterPrefix = new StringBackedName(setterPrefix);
     _literalLazyGetterPrefix = new StringBackedName(lazyGetterPrefix);
   }
 
   CommonElements get _commonElements => _closedWorld.commonElements;
 
@@ skipping 12 matching lines @@
   String get closureInvocationSelectorName => Identifiers.call;
   bool get shouldMinify => false;
 
   NamingScope _getPrivateScopeFor(PrivatelyNamedJSEntity entity) {
     return _privateNamingScopes.putIfAbsent(
         entity.rootOfScope, () => new NamingScope());
   }
 
   /// Returns the string that is to be used as the result of a call to
   /// [JS_GET_NAME] at [node] with argument [name].
-  jsAst.Name getNameForJsGetName(Node node, JsGetName name) {
+  jsAst.Name getNameForJsGetName(Spannable spannable, JsGetName name) {
     switch (name) {
       case JsGetName.GETTER_PREFIX:
         return asName(getterPrefix);
       case JsGetName.SETTER_PREFIX:
         return asName(setterPrefix);
       case JsGetName.CALL_PREFIX:
         return asName(callPrefix);
       case JsGetName.CALL_PREFIX0:
         return asName('${callPrefix}\$0');
       case JsGetName.CALL_PREFIX1:
@@ skipping 36 matching lines @@
         return asName(functionTypeReturnTypeTag);
       case JsGetName.FUNCTION_TYPE_REQUIRED_PARAMETERS_TAG:
         return asName(functionTypeRequiredParametersTag);
       case JsGetName.FUNCTION_TYPE_OPTIONAL_PARAMETERS_TAG:
         return asName(functionTypeOptionalParametersTag);
       case JsGetName.FUNCTION_TYPE_NAMED_PARAMETERS_TAG:
         return asName(functionTypeNamedParametersTag);
       case JsGetName.IS_INDEXABLE_FIELD_NAME:
         return operatorIs(_commonElements.jsIndexingBehaviorInterface);
       case JsGetName.NULL_CLASS_TYPE_NAME:
-        ClassElement nullClass = _commonElements.nullClass;
-        return runtimeTypeName(nullClass);
+        return runtimeTypeName(_commonElements.nullClass);
       case JsGetName.OBJECT_CLASS_TYPE_NAME:
-        ClassElement objectClass = _commonElements.objectClass;
-        return runtimeTypeName(objectClass);
+        return runtimeTypeName(_commonElements.objectClass);
       case JsGetName.FUNCTION_CLASS_TYPE_NAME:
-        ClassElement functionClass = _commonElements.functionClass;
-        return runtimeTypeName(functionClass);
+        return runtimeTypeName(_commonElements.functionClass);
       default:
         throw new SpannableAssertionFailure(
-            node, 'Error: Namer has no name for "$name".');
+            spannable, 'Error: Namer has no name for "$name".');
     }
   }
 
   /// Return a reference to the given [name].
   ///
   /// This is used to ensure that every use site of a name has a unique node so
   /// that we can properly attribute source information.
   jsAst.Name _newReference(jsAst.Name name) {
     return new _NameReference(name);
   }
@@ skipping 57 matching lines @@
    * where uniqueness is nice but not a strict requirement.
    *
    * The resulting name is a *proposed name* and is never minified.
    */
   String privateName(Name originalName) {
     String text = originalName.text;
 
     // Public names are easy.
     if (!originalName.isPrivate) return text;
 
-    LibraryElement library = originalName.library;
+    LibraryEntity library = originalName.library;
 
     // The first library asking for a short private name wins.
-    LibraryElement owner =
+    LibraryEntity owner =
         shortPrivateNameOwners.putIfAbsent(text, () => library);
 
     if (owner == library) {
       return text;
     } else {
       // Make sure to return a private name that starts with _ so it
       // cannot clash with any public names.
       // The name is still not guaranteed to be unique, since both the library
       // name and originalName could contain $ symbols and as the library
       // name itself might clash.
@@ skipping 271 matching lines @@
   /// globals, although the callers of must still take care not to accidentally
   /// pass in the same [name] for two different internal globals.
   jsAst.Name internalGlobal(String name) {
     assert(!name.contains(r'$'));
     return _disambiguateInternalGlobal(name);
   }
 
   /// Generates a unique key for [library].
   ///
   /// Keys are meant to be used in maps and should not be visible in the output.
-  String _generateLibraryKey(LibraryElement library) {
+  String _generateLibraryKey(LibraryEntity library) {
     return _libraryKeys.putIfAbsent(library, () {
       String keyBase = library.name;
       int counter = 0;
       String key = keyBase;
       while (_libraryKeys.values.contains(key)) {
         key = "$keyBase${counter++}";
       }
       return key;
     });
   }
@@ skipping 1189 matching lines @@
   void addSuggestion(String original, String suggestion) {
     assert(!_suggestedNames.containsKey(original));
     _suggestedNames[original] = suggestion;
   }
 
   bool hasSuggestion(String original) => _suggestedNames.containsKey(original);
   bool isSuggestion(String candidate) {
     return _suggestedNames.containsValue(candidate);
   }
 }