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

pkg/compiler/lib/src/js_emitter/old_emitter/container_builder.dart

 // Copyright (c) 2013, 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 dart2js.js_emitter;
 
 /// This class should morph into something that makes it easy to build
 /// JavaScript representations of libraries, class-sides, and instance-sides.
 /// Initially, it is just a placeholder for code that is moved from
 /// [CodeEmitterTask].
 class ContainerBuilder extends CodeEmitterHelper {
 
   void addMemberMethod(DartMethod method, ClassBuilder builder) {
     MethodElement member = method.element;
-    String name = method.name;
+    jsAst.Name name = method.name;
     FunctionSignature parameters = member.functionSignature;
     jsAst.Expression code = method.code;
     bool needsStubs = method.parameterStubs.isNotEmpty;
     bool canBeApplied = method.canBeApplied;
     bool canBeReflected = method.canBeReflected;
     bool canTearOff = method.needsTearOff;
-    String tearOffName = method.tearOffName;
+    jsAst.Name tearOffName = method.tearOffName;
     bool isClosure = method is InstanceMethod && method.isClosure;
-    String superAlias = method is InstanceMethod ? method.aliasName : null;
+    jsAst.Name superAlias = method is InstanceMethod ? method.aliasName : null;
     bool hasSuperAlias = superAlias != null;
     jsAst.Expression memberTypeExpression = method.functionType;
 
     bool needStructuredInfo =
         canTearOff || canBeReflected || canBeApplied || hasSuperAlias;
 
     emitter.interceptorEmitter.recordMangledNameOfMemberMethod(member, name);
 
     if (!needStructuredInfo) {
       compiler.dumpInfoTask.registerElementAst(member,
@@ skipping 35 matching lines @@
     // P.   Unmangled name (if reflectable).
     // P+1. First metadata (if reflectable).
     // ...
     // TODO(ahe): Consider one of the parameter counts can be replaced by the
     // length property of the JavaScript function object.
 
     List<jsAst.Expression> expressions = <jsAst.Expression>[];
 
     // Create the optional aliasing entry if this method is called via super.
     if (hasSuperAlias) {
-      expressions.add(new jsAst.LiteralString('"${superAlias}"'));
+      expressions.add(js.quoteName(superAlias));
     }
 
     expressions.add(code);
 
     bool onlyNeedsSuperAlias =
         !(canTearOff || canBeReflected || canBeApplied || needsStubs);
 
     if (onlyNeedsSuperAlias) {
       jsAst.ArrayInitializer arrayInit =
             new jsAst.ArrayInitializer(expressions);
           compiler.dumpInfoTask.registerElementAst(member,
               builder.addProperty(name, arrayInit));
       return;
     }
 
-    String callSelectorString = 'null';
-    if (method.callName != null) {
-      callSelectorString = '"${method.callName}"';
+    jsAst.LiteralString callSelectorString;
+    if (method.callName == null) {
+      callSelectorString = new jsAst.LiteralString('null');
+    } else {
+      callSelectorString = js.quoteName(method.callName);
     }
 
     // On [requiredParameterCount], the lower bit is set if this method can be
     // called reflectively.
     int requiredParameterCount = parameters.requiredParameterCount << 1;
     if (member.isAccessor) requiredParameterCount++;
 
     int optionalParameterCount = parameters.optionalParameterCount << 1;
     if (parameters.optionalParametersAreNamed) optionalParameterCount++;
 
     // TODO(sra): Don't use LiteralString for non-strings.

[floitsch, 2015/06/22 17:43:44]

does this comment still apply?

[herhut, 2015/06/23 13:26:31]

It did but to get rid of the TODO I have now replaced the LiteralString by a
LiteralNull.

-    List tearOffInfo = [new jsAst.LiteralString(callSelectorString)];
+    List tearOffInfo = [callSelectorString];
 
     for (ParameterStubMethod stub in method.parameterStubs) {
-      String invocationName = stub.name;
+      jsAst.Name invocationName = stub.name;
       emitter.interceptorEmitter
           .recordMangledNameOfMemberMethod(member, invocationName);
 
       expressions.add(stub.code);
       if (member.isInstanceMember) {
-        expressions.add(js.string(invocationName));
+        expressions.add(js.quoteName(invocationName));
       }
-      String callName = stub.callName;
-      String callSelectorString = (callName == null) ? 'null' : '"$callName"';
-      tearOffInfo.add(new jsAst.LiteralString(callSelectorString));
+      jsAst.Name callName = stub.callName;
+      jsAst.Literal callSelectorString =
+          (callName == null) ? new jsAst.LiteralNull() : js.quoteName(callName);
+      tearOffInfo.add(callSelectorString);
     }
 
     expressions
         ..addAll(tearOffInfo)
         ..add((tearOffName == null || member.isAccessor)
-              ? js("null") : js.string(tearOffName))
+              ? js("null") : js.quoteName(tearOffName))
         ..add(js.number(requiredParameterCount))
         ..add(js.number(optionalParameterCount))
         ..add(memberTypeExpression == null ? js("null") : memberTypeExpression)
         ..addAll(task.metadataCollector.reifyDefaultArguments(member));
 
     if (canBeReflected || canBeApplied) {
       parameters.forEachParameter((Element parameter) {
         expressions.add(task.metadataCollector.reifyName(parameter.name));
         if (backend.mustRetainMetadata) {
           Iterable<jsAst.Expression> metadataIndices =
@@ skipping 30 matching lines @@
     jsAst.ArrayInitializer arrayInit =
       new jsAst.ArrayInitializer(expressions.toList());
     compiler.dumpInfoTask.registerElementAst(member,
         builder.addProperty(name, arrayInit));
   }
 
   void addMemberField(Field field, ClassBuilder builder) {
     // For now, do nothing.
   }
 }