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

pkg/compiler/lib/src/js_backend/codegen/glue.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 code_generator_dependencies;
 
 import '../js_backend.dart';
 import '../../dart2jslib.dart';
 import '../../js_emitter/js_emitter.dart';
 import '../../js/js.dart' as js;
@@ skipping 61 matching lines @@
   ConstructorElement get mapLiteralConstructor {
     return _backend.mapLiteralConstructor;
   }
 
   ConstructorElement get mapLiteralConstructorEmpty {
     return _backend.mapLiteralConstructorEmpty;
   }
 
   FunctionElement get identicalFunction => _compiler.identicalFunction;
 
-  String invocationName(Selector selector) {
+  js.Name invocationName(Selector selector) {
     return _namer.invocationName(selector);
   }
 
   FunctionElement get createInvocationMirrorMethod {
     return _backend.getCreateInvocationMirror();
   }
 
   void registerUseInterceptorInCodegen() {
     _backend.registerUseInterceptor(_enqueuer);
   }
@@ skipping 11 matching lines @@
   }
 
   void registerSpecializedGetInterceptor(Set<ClassElement> classes) {
     _backend.registerSpecializedGetInterceptor(classes);
   }
 
   js.Expression constructorAccess(ClassElement element) {
     return _backend.emitter.constructorAccess(element);
   }
 
-  String instanceFieldPropertyName(Element field) {
+  js.Name instanceFieldPropertyName(Element field) {
     return _namer.instanceFieldPropertyName(field);
   }
 
-  String instanceMethodName(FunctionElement element) {
+  js.Name instanceMethodName(FunctionElement element) {
     return _namer.instanceMethodName(element);
   }
 
   js.Expression prototypeAccess(ClassElement e,
                                 {bool hasBeenInstantiated: false}) {
     return _emitter.prototypeAccess(e,
         hasBeenInstantiated: hasBeenInstantiated);
   }
 
-  String getInterceptorName(Set<ClassElement> interceptedClasses) {
+  js.Name getInterceptorName(Set<ClassElement> interceptedClasses) {
     return _backend.namer.nameForGetInterceptor(interceptedClasses);
   }
 
   js.Expression getInterceptorLibrary() {
     return new js.VariableUse(
         _backend.namer.globalObjectFor(_backend.interceptorsLibrary));
   }
 
   FunctionElement getWrapExceptionHelper() {
     return _backend.getWrapExceptionHelper();
@@ skipping 41 matching lines @@
   FunctionElement getCheckSubtypeOfRuntimeType() {
     return _backend.getCheckSubtypeOfRuntimeType();
   }
 
   /// subtypeOfRuntimeTypeCast(value, runtimeType)
   FunctionElement getSubtypeOfRuntimeTypeCast() {
     return _backend.getSubtypeOfRuntimeTypeCast();
   }
 
   js.Expression getRuntimeTypeName(ClassElement cls) {
-    return js.string(_namer.runtimeTypeName(cls));
+    return js.quoteName(_namer.runtimeTypeName(cls));
   }
 
   int getTypeVariableIndex(TypeVariableType variable) {
     return RuntimeTypes.getTypeVariableIndex(variable.element);
   }
 
   bool needsSubstitutionForTypeVariableAccess(ClassElement cls) {
     ClassWorld classWorld = _compiler.world;
     if (classWorld.isUsedAsMixin(cls)) return true;
 
@@ skipping 11 matching lines @@
         (_) => arguments[variableIndex++]);
     assert(variableIndex == arguments.length);
     return representation;
   }
 
   void registerIsCheck(DartType type, Registry registry) {
     _enqueuer.registerIsCheck(type);
     _backend.registerIsCheckForCodegen(type, _enqueuer, registry);
   }
 
-  String getTypeTestTag(DartType type) {
+  js.Name getTypeTestTag(DartType type) {
     return _backend.namer.operatorIsType(type);
   }
 
-  String getTypeSubstitutionTag(ClassElement element) {
+  js.Name getTypeSubstitutionTag(ClassElement element) {
     return _backend.namer.substitutionName(element);
   }
 
   bool operatorEqHandlesNullArgument(FunctionElement element) {
     return _backend.operatorEqHandlesNullArgument(element);
   }
 
   bool hasStrictSubtype(ClassElement element) {
     return _compiler.world.hasAnyStrictSubtype(element);
   }
 }