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

pkg/compiler/lib/src/js_emitter/program_builder.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.program_builder;
 
 import 'js_emitter.dart' show computeMixinClass;
 import 'model.dart';
 
 import '../common.dart';
@@ skipping 196 matching lines @@
         .toList(growable: false);
   }
 
   StaticField _buildStaticField(Element element) {
     JavaScriptConstantCompiler handler = backend.constants;
     ConstantValue initialValue = handler.getInitialValueFor(element);
     // TODO(zarah): The holder should not be registered during building of
     // a static field.
     _registry.registerHolder(namer.globalObjectForConstant(initialValue));
     js.Expression code = _task.emitter.constantReference(initialValue);
-    String name = namer.globalPropertyName(element);
+    js.Name name = namer.globalPropertyName(element);
     bool isFinal = false;
     bool isLazy = false;
 
     // TODO(floitsch): we shouldn't update the registry in the middle of
     // building a static field. (Note that the $ holder is already registered
     // earlier).
     return new StaticField(element,
                            name, _registry.registerHolder(r'$'), code,
                            isFinal, isLazy);
   }
@@ skipping 15 matching lines @@
         .toList(growable: false);
   }
 
   StaticField _buildLazyField(Element element) {
     js.Expression code = backend.generatedCode[element];
     // The code is null if we ended up not needing the lazily
     // initialized field after all because of constant folding
     // before code generation.
     if (code == null) return null;
 
-    String name = namer.globalPropertyName(element);
+    js.Name name = namer.globalPropertyName(element);
     bool isFinal = element.isFinal;
     bool isLazy = true;
     // TODO(floitsch): we shouldn't update the registry in the middle of
     // building a static field. (Note that the $ holder is already registered
     // earlier).
     return new StaticField(element,
                            name, _registry.registerHolder(r'$'), code,
                            isFinal, isLazy);
   }
 
@@ skipping 35 matching lines @@
                        staticFieldsForReflection);
   }
 
   /// HACK for Incremental Compilation.
   ///
   /// Returns a class that contains the fields of a class.
   Class buildFieldsHackForIncrementalCompilation(ClassElement element) {
     assert(_compiler.hasIncrementalSupport);
 
     List<Field> instanceFields = _buildFields(element, false);
-    String name = namer.className(element);
+    js.Name name = namer.className(element);
 
     return new Class(
         element, name, null, [], instanceFields, [], [], [], [], [], null,
         isDirectlyInstantiated: true,
         onlyForRti: false,
         isNative: element.isNative);
   }
 
   Class _buildClass(ClassElement element) {
     bool onlyForRti = _task.typeTestRegistry.rtiNeededClasses.contains(element);
@@ skipping 13 matching lines @@
       if (Elements.isNonAbstractInstanceMember(member)) {
         // TODO(herhut): Remove once _buildMethod can no longer return null.
         Method method = _buildMethod(member);
         if (method != null) methods.add(method);
       }
       if (member.isGetter || member.isField) {
         Map<Selector, TypeMaskSet> selectors =
             _compiler.codegenWorld.invocationsByName(member.name);
         if (selectors != null && !selectors.isEmpty) {
 
-          Map<String, js.Expression> callStubsForMember =
+          Map<js.Name, js.Expression> callStubsForMember =
               classStubGenerator.generateCallStubsForGetter(member, selectors);
-          callStubsForMember.forEach((String name, js.Expression code) {
+          callStubsForMember.forEach((js.Name name, js.Expression code) {
             callStubs.add(_buildStubMethod(name, code, element: member));
           });
         }
       }
     }
 
     List<StubMethod> typeVariableReaderStubs =
         runtimeTypeGenerator.generateTypeVariableReaderStubs(element);
 
     List<StubMethod> noSuchMethodStubs = <StubMethod>[];
     if (backend.enabledNoSuchMethod && element == _compiler.objectClass) {
-      Map<String, Selector> selectors =
+      Map<js.Name, Selector> selectors =
           classStubGenerator.computeSelectorsForNsmHandlers();
-      selectors.forEach((String name, Selector selector) {
+      selectors.forEach((js.Name name, Selector selector) {
         noSuchMethodStubs
             .add(classStubGenerator.generateStubForNoSuchMethod(name,
                                                                 selector));
       });
     }
 
     if (element == backend.closureClass) {
       // We add a special getter here to allow for tearing off a closure from
       // itself.
-      String name = namer.getterForMember(Selector.CALL_NAME);
+      js.Name name = namer.getterForMember(Selector.CALL_NAME);
       js.Fun function = js.js('function() { return this; }');
       callStubs.add(_buildStubMethod(name, function));
     }
 
     ClassElement implementation = element.implementation;
 
     // MixinApplications run through the members of their mixin. Here, we are
     // only interested in direct members.
     if (!onlyForRti && !element.isMixinApplication) {
       implementation.forEachMember(visitMember, includeBackendMembers: true);
     }
 
     List<Field> instanceFields =
         onlyForRti ? const <Field>[] : _buildFields(element, false);
     List<Field> staticFieldsForReflection =
         onlyForRti ? const <Field>[] : _buildFields(element, true);
 
     TypeTestProperties typeTests =
         runtimeTypeGenerator.generateIsTests(
             element,
             storeFunctionTypeInMetadata: _storeFunctionTypesInMetadata);
 
     List<StubMethod> isChecks = <StubMethod>[];
-    typeTests.properties.forEach((String name, js.Node code) {
+    typeTests.properties.forEach((js.Name name, js.Node code) {
       isChecks.add(_buildStubMethod(name, code));
     });
 
-    String name = namer.className(element);
+    js.Name name = namer.className(element);
     String holderName = namer.globalObjectFor(element);
     // TODO(floitsch): we shouldn't update the registry in the middle of
     // building a class.
     Holder holder = _registry.registerHolder(holderName);
     bool isInstantiated =
         _compiler.codegenWorld.directlyInstantiatedClasses.contains(element);
 
     Class result;
     if (element.isMixinApplication && !onlyForRti) {
       assert(!element.isNative);
@@ skipping 66 matching lines @@
       signature.forEachOptionalParameter((ParameterElement parameter) {
         ConstantValue def =
             backend.constants.getConstantValueForVariable(parameter);
         optionalParameterDefaultValues.add(def);
       });
     }
     return optionalParameterDefaultValues;
   }
 
   DartMethod _buildMethod(MethodElement element) {
-    String name = namer.methodPropertyName(element);
+    js.Name name = namer.methodPropertyName(element);
     js.Expression code = backend.generatedCode[element];
 
     // TODO(kasperl): Figure out under which conditions code is null.
     if (code == null) return null;
 
     bool canTearOff = false;
-    String tearOffName;
+    js.Name tearOffName;
     bool isClosure = false;
     bool isNotApplyTarget = !element.isFunction || element.isAccessor;
 
     bool canBeReflected = _methodCanBeReflected(element);
     bool canBeApplied = _methodCanBeApplied(element);
 
-    String aliasName = backend.isAliasedSuperMember(element)
+    js.Name aliasName = backend.isAliasedSuperMember(element)
         ? namer.aliasedSuperMemberPropertyName(element)
         : null;
 
     if (isNotApplyTarget) {
       canTearOff = false;
     } else {
       if (element.enclosingClass.isClosure) {
         canTearOff = false;
         isClosure = true;
       } else {
         // Careful with operators.
         canTearOff = universe.hasInvokedGetter(element, _compiler.world) ||
             (canBeReflected && !element.isOperator);
         assert(canTearOff ||
                !universe.methodsNeedingSuperGetter.contains(element));
         tearOffName = namer.getterForElement(element);
       }
     }
 
     if (canTearOff) {
       assert(invariant(element, !element.isGenerativeConstructor));
       assert(invariant(element, !element.isGenerativeConstructorBody));
       assert(invariant(element, !element.isConstructor));
     }
 
-    String callName = null;
+    js.Name callName = null;
     if (canTearOff) {
       Selector callSelector =
           new Selector.fromElement(element).toCallSelector();
       callName = namer.invocationName(callSelector);
     }
 
     DartType memberType;
     if (element.isGenerativeConstructorBody) {
       // TODO(herhut): Why does this need to be normalized away? We never need
       //               this information anyway as they cannot be torn off or
@@ skipping 47 matching lines @@
 
     ParameterStubGenerator generator =
         new ParameterStubGenerator(_compiler, namer, backend);
     return generator.generateParameterStubs(element, canTearOff: canTearOff);
   }
 
   /// Builds a stub method.
   ///
   /// Stub methods may have an element that can be used for code-size
   /// attribution.
-  Method _buildStubMethod(String name, js.Expression code,
+  Method _buildStubMethod(js.Name name, js.Expression code,
                           {Element element}) {
     return new StubMethod(name, code, element: element);
   }
 
   // The getInterceptor methods directly access the prototype of classes.
   // We must evaluate these classes eagerly so that the prototype is
   // accessible.
   void _markEagerInterceptorClasses() {
-    Map<String, Set<ClassElement>> specializedGetInterceptors =
+    Map<js.Name, Set<ClassElement>> specializedGetInterceptors =
         backend.specializedGetInterceptors;
     for (Set<ClassElement> classes in specializedGetInterceptors.values) {
       for (ClassElement element in classes) {
         Class cls = _classes[element];
         if (cls != null) cls.isEager = true;
       }
     }
   }
 
   Iterable<StaticStubMethod> _generateGetInterceptorMethods() {
     InterceptorStubGenerator stubGenerator =
         new InterceptorStubGenerator(_compiler, namer, backend);
 
     String holderName = namer.globalObjectFor(backend.interceptorsLibrary);
     // TODO(floitsch): we shouldn't update the registry in the middle of
     // generating the interceptor methods.
     Holder holder = _registry.registerHolder(holderName);
 
-    Map<String, Set<ClassElement>> specializedGetInterceptors =
+    Map<js.Name, Set<ClassElement>> specializedGetInterceptors =
         backend.specializedGetInterceptors;
-    List<String> names = specializedGetInterceptors.keys.toList()..sort();
-    return names.map((String name) {
+    List<js.Name> names = specializedGetInterceptors.keys.toList()..sort();
+    return names.map((js.Name name) {
       Set<ClassElement> classes = specializedGetInterceptors[name];
       js.Expression code = stubGenerator.generateGetInterceptorMethod(classes);
       return new StaticStubMethod(name, holder, code);
     });
   }
 
   List<Field> _buildFields(Element holder, bool visitStatics) {
     List<Field> fields = <Field>[];
     _task.oldEmitter.classEmitter.visitFields(
         holder, visitStatics, (VariableElement field,
-                               String name,
-                               String accessorName,
+                               js.Name name,
+                               js.Name accessorName,
                                bool needsGetter,
                                bool needsSetter,
                                bool needsCheckedSetter) {
       assert(invariant(field, field.isDeclaration));
 
       int getterFlags = 0;
       if (needsGetter) {
         if (visitStatics || !backend.fieldHasInterceptedGetter(field)) {
           getterFlags = 1;
         } else {
@@ skipping 29 matching lines @@
 
   Iterable<StaticStubMethod> _generateOneShotInterceptors() {
     InterceptorStubGenerator stubGenerator =
         new InterceptorStubGenerator(_compiler, namer, backend);
 
     String holderName = namer.globalObjectFor(backend.interceptorsLibrary);
     // TODO(floitsch): we shouldn't update the registry in the middle of
     // generating the interceptor methods.
     Holder holder = _registry.registerHolder(holderName);
 
-    List<String> names = backend.oneShotInterceptors.keys.toList()..sort();
-    return names.map((String name) {
+    List<js.Name> names = backend.oneShotInterceptors.keys.toList()..sort();
+    return names.map((js.Name name) {
       js.Expression code = stubGenerator.generateOneShotInterceptor(name);
       return new StaticStubMethod(name, holder, code);
     });
   }
 
   StaticDartMethod _buildStaticMethod(FunctionElement element) {
-    String name = namer.methodPropertyName(element);
+    js.Name name = namer.methodPropertyName(element);
     String holder = namer.globalObjectFor(element);
     js.Expression code = backend.generatedCode[element];
 
     bool isApplyTarget = !element.isConstructor && !element.isAccessor;
     bool canBeApplied = _methodCanBeApplied(element);
     bool canBeReflected = _methodCanBeReflected(element);
 
     bool needsTearOff = isApplyTarget &&
         (canBeReflected ||
             universe.staticFunctionsNeedingGetter.contains(element));
 
-    String tearOffName =
+    js.Name tearOffName =
         needsTearOff ? namer.staticClosureName(element) : null;
 
 
-    String callName = null;
+    js.Name callName = null;
     if (needsTearOff) {
       Selector callSelector =
           new Selector.fromElement(element).toCallSelector();
       callName = namer.invocationName(callSelector);
     }
     js.Expression functionType;
     DartType type = element.type;
     if (needsTearOff || canBeReflected) {
       OutputUnit outputUnit =
           _compiler.deferredLoadTask.outputUnitForElement(element);
@@ skipping 25 matching lines @@
                                 functionType: functionType);
   }
 
   void _registerConstants(OutputUnit outputUnit,
                           Iterable<ConstantValue> constantValues) {
     // `constantValues` is null if an outputUnit doesn't contain any constants.
     if (constantValues == null) return;
     for (ConstantValue constantValue in constantValues) {
       _registry.registerConstant(outputUnit, constantValue);
       assert(!_constants.containsKey(constantValue));
-      String name = namer.constantName(constantValue);
+      js.Name name = namer.constantName(constantValue);
       String constantObject = namer.globalObjectForConstant(constantValue);
       Holder holder = _registry.registerHolder(constantObject);
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     }
   }
 }