dart2js: Use an abstract Name class for names in the generated JavaScript ast.

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

 // Copyright (c) 2012, 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 js_backend;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
@@ skipping 198 matching lines @@
 
   void markAsMustInline(FunctionElement element) {
     _cachedDecisions[element] = _mustInline;
   }
 }
 
 enum SyntheticConstantKind {
   DUMMY_INTERCEPTOR,
   EMPTY_VALUE,
   TYPEVARIABLE_REFERENCE,
+  NAME
 }
 
 class JavaScriptBackend extends Backend {
   static final Uri DART_JS_HELPER = new Uri(scheme: 'dart', path: '_js_helper');
   static final Uri DART_INTERCEPTORS =
       new Uri(scheme: 'dart', path: '_interceptors');
   static final Uri DART_INTERNAL =
       new Uri(scheme: 'dart', path: '_internal');
   static final Uri DART_FOREIGN_HELPER =
       new Uri(scheme: 'dart', path: '_foreign_helper');
@@ skipping 199 matching lines @@
    * Interface used to determine if an object has the JavaScript
    * indexing behavior. The interface is only visible to specific
    * libraries.
    */
   ClassElement jsIndexingBehaviorInterface;
 
   /**
    * A collection of selectors that must have a one shot interceptor
    * generated.
    */
-  final Map<String, Selector> oneShotInterceptors;
+  final Map<jsAst.Name, Selector> oneShotInterceptors;
 
   /**
    * The members of instantiated interceptor classes: maps a member name to the
    * list of members that have that name. This map is used by the codegen to
    * know whether a send must be intercepted or not.
    */
   final Map<String, Set<Element>> interceptedElements;
 
   /**
    * The members of mixin classes that are mixed into an instantiated
@@ skipping 10 matching lines @@
       new Map<String, Set<Element>>();
 
   /**
    * A map of specialized versions of the [getInterceptorMethod].
    * Since [getInterceptorMethod] is a hot method at runtime, we're
    * always specializing it based on the incoming type. The keys in
    * the map are the names of these specialized versions. Note that
    * the generic version that contains all possible type checks is
    * also stored in this map.
    */
-  final Map<String, Set<ClassElement>> specializedGetInterceptors;
+  final Map<jsAst.Name, Set<ClassElement>> specializedGetInterceptors;
 
   /**
    * Set of classes whose methods are intercepted.
    */
   final Set<ClassElement> _interceptedClasses = new Set<ClassElement>();
 
   /**
    * Set of classes used as mixins on intercepted (native and primitive)
    * classes.  Methods on these classes might also be mixed in to regular Dart
    * (unintercepted) classes.
@@ skipping 133 matching lines @@
   JavaScriptResolutionCallbacks resolutionCallbacks;
 
   PatchResolverTask patchResolverTask;
 
   bool enabledNoSuchMethod = false;
 
   JavaScriptBackend(Compiler compiler,
                     SourceInformationFactory sourceInformationFactory,
                     {bool generateSourceMap: true})
       : namer = determineNamer(compiler),
-        oneShotInterceptors = new Map<String, Selector>(),
+        oneShotInterceptors = new Map<jsAst.Name, Selector>(),
         interceptedElements = new Map<String, Set<Element>>(),
         rti = new RuntimeTypes(compiler),
-        specializedGetInterceptors = new Map<String, Set<ClassElement>>(),
+        specializedGetInterceptors = new Map<jsAst.Name, Set<ClassElement>>(),
         annotations = new Annotations(compiler),
         super(compiler) {
     emitter = new CodeEmitterTask(compiler, namer, generateSourceMap);
     typeVariableHandler = new TypeVariableHandler(compiler);
     customElementsAnalysis = new CustomElementsAnalysis(this);
     noSuchMethodRegistry = new NoSuchMethodRegistry(this);
     constantCompilerTask = new JavaScriptConstantTask(compiler);
     resolutionCallbacks = new JavaScriptResolutionCallbacks(this);
     patchResolverTask = new PatchResolverTask(compiler);
     functionCompiler = compiler.useCpsIr
@@ skipping 72 matching lines @@
   }
 
   bool isInterceptorClass(ClassElement element) {
     if (element == null) return false;
     if (Elements.isNativeOrExtendsNative(element)) return true;
     if (interceptedClasses.contains(element)) return true;
     if (classesMixedIntoInterceptedClasses.contains(element)) return true;
     return false;
   }
 
-  String registerOneShotInterceptor(Selector selector) {
+  jsAst.Name registerOneShotInterceptor(Selector selector) {
     Set<ClassElement> classes = getInterceptedClassesOn(selector.name);
-    String name = namer.nameForGetOneShotInterceptor(selector, classes);
+    jsAst.Name name = namer.nameForGetOneShotInterceptor(selector, classes);
     if (!oneShotInterceptors.containsKey(name)) {
       registerSpecializedGetInterceptor(classes);
       oneShotInterceptors[name] = selector;
     }
     return name;
   }
 
   /**
    * Record that [method] is called from a subclass via `super`.
    */
@@ skipping 185 matching lines @@
     }
     enqueueClass(enqueuer, cls, registry);
   }
 
   Set<ClassElement> get interceptedClasses {
     assert(compiler.enqueuer.resolution.queueIsClosed);
     return _interceptedClasses;
   }
 
   void registerSpecializedGetInterceptor(Set<ClassElement> classes) {
-    String name = namer.nameForGetInterceptor(classes);
+    jsAst.Name name = namer.nameForGetInterceptor(classes);
     if (classes.contains(jsInterceptorClass)) {
       // We can't use a specialized [getInterceptorMethod], so we make
       // sure we emit the one with all checks.
       specializedGetInterceptors[name] = interceptedClasses;
     } else {
       specializedGetInterceptors[name] = classes;
     }
   }
 
   void registerCompileTimeConstant(ConstantValue constant, Registry registry) {
@@ skipping 2049 matching lines @@
   }
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final ConstantValue constant;
   final Element annotatedElement;
 
   const Dependency(this.constant, this.annotatedElement);
 }