Use entities in runtime_types

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;
 
@@ skipping 12 matching lines @@
 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';
 
 part 'field_naming_mixin.dart';
 part 'frequency_namer.dart';
 part 'minify_namer.dart';
 part 'namer_names.dart';
 
 /**
  * Assigns JavaScript identifiers to Dart variables, class-names and members.
  *
  * Names are generated through three stages:
@@ skipping 701 matching lines @@
         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.
-      String libraryName = _proposeNameForGlobal(library);
+      String libraryName = _proposeNameForLibrary(library);
       return "_$libraryName\$$text";
     }
   }
 
   String _proposeNameForConstructorBody(ConstructorBodyElement method) {
     String name = Elements.reconstructConstructorNameSourceString(method);
     // We include the method suffix on constructor bodies. It has no purpose,
     // but this way it produces the same names as previous versions of the
     // Namer class did.
     List<String> suffix = callSuffixForSignature(method.functionSignature);
@@ skipping 497 matching lines @@
       return '${className}_${Elements.reconstructConstructorName(element)}';
     }
     if (Elements.isStaticOrTopLevel(element)) {
       if (element.isClassMember) {
         ClassElement enclosingClass = element.enclosingClass;
         return '${enclosingClass.name}_${element.name}';
       }
       return element.name.replaceAll('+', '_');
     }
     if (element.isLibrary) {
-      return _proposeNameForLibrary(element);
+      LibraryElement library = element;
+      return _proposeNameForLibrary(library);
     }
     return element.name;
   }
 
   /**
    * Returns a proposed name for the given [LibraryElement].
    * The returned id is guaranteed to be a valid JavaScript identifier.
    */
   // TODO(sra): Pre-process libraries to assign [libraryLongNames] in a way that
   // is independent of the order of calls to namer.
-  String _proposeNameForLibrary(LibraryElement library) {
+  String _proposeNameForLibrary(LibraryEntity library) {
     String name = libraryLongNames[library];
     if (name != null) return name;
     // Use the 'file' name, e.g. "package:expect/expect.dart" -> "expect"
     name = library.canonicalUri.path;
     name = name.substring(name.lastIndexOf('/') + 1);
     if (name.contains('.')) {
       // Drop file extension.
       name = name.substring(0, name.lastIndexOf('.'));
     }
     // The filename based name can contain all kinds of nasty characters. Make
@@ skipping 213 matching lines @@
     assert(Elements.isStaticOrTopLevelField(element));
     jsAst.Name name = _disambiguateGlobal(element);
     // These are not real dart getters, so do not use GetterName;
     return deriveLazyInitializerName(name);
   }
 
   jsAst.Name staticClosureName(Element element) {
     assert(Elements.isStaticOrTopLevelFunction(element));
     String enclosing =
         element.enclosingClass == null ? "" : element.enclosingClass.name;
-    String library = _proposeNameForGlobal(element.library);
+    String library = _proposeNameForLibrary(element.library);
     return _disambiguateInternalGlobal(
         "${library}_${enclosing}_${element.name}\$closure");
   }
 
   // This name is used as part of the name of a TypeConstant
-  String uniqueNameForTypeConstantElement(Element element) {
+  String uniqueNameForTypeConstantElement(
+      LibraryEntity library, Entity element) {
     // TODO(sra): If we replace the period with an identifier character,
     // TypeConstants will have better names in unminified code.
-    String library = _proposeNameForGlobal(element.library);
-    return "${library}.${element.name}";
+    String libraryName = _proposeNameForLibrary(library);
+    return "${libraryName}.${element.name}";
   }
 
   String globalObjectForConstant(ConstantValue constant) => 'C';
 
   String get operatorIsPrefix => r'$is';
 
   String get operatorAsPrefix => r'$as';
 
   String get operatorSignature => r'$signature';
 
@@ skipping 648 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);
   }
 }