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

pkg/compiler/lib/src/js_emitter/new_emitter/model_emitter.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.new_js_emitter.model_emitter;
 
 import '../../constants/values.dart' show ConstantValue, FunctionConstantValue;
 import '../../dart2jslib.dart' show Compiler;
 import '../../elements/elements.dart' show ClassElement, FunctionElement;
 import '../../js/js.dart' as js;
@@ skipping 75 matching lines @@
   static const String deferredInitializersGlobal =
       r"$__dart_deferred_initializers__";
 
   static const String deferredExtension = "part.js";
 
   static const String typeNameProperty = r"builtin$cls";
 
   ModelEmitter(Compiler compiler, Namer namer, this.nativeEmitter)
       : this.compiler = compiler,
         this.namer = namer {
-    // TODO(floitsch): remove hard-coded name.
-    // TODO(floitsch): there is no harm in caching the template.
-    js.Template makeConstantListTemplate =
-        js.js.uncachedExpressionTemplate('makeConstList(#)');
 
     this.constantEmitter = new ConstantEmitter(
         compiler, namer, this.generateConstantReference,
-        makeConstantListTemplate);
+        constantListGenerator);
+  }
+
+  js.Expression constantListGenerator(js.Expression array) {
+    // TODO(floitsch): remove hard-coded name.
+    return js.js('makeConstList(#)', [array]);
   }
 
   js.Expression generateEmbeddedGlobalAccess(String global) {
     return js.js(generateEmbeddedGlobalAccessString(global));
   }
 
   String generateEmbeddedGlobalAccessString(String global) {
     // TODO(floitsch): don't use 'init' as global embedder storage.
     return 'init.$global';
   }
@@ skipping 263 matching lines @@
   js.Property emitMangledGlobalNames() {
     List<js.Property> names = <js.Property>[];
 
     // We want to keep the original names for the most common core classes when
     // calling toString on them.
     List<ClassElement> nativeClassesNeedingUnmangledName =
         [compiler.intClass, compiler.doubleClass, compiler.numClass,
          compiler.stringClass, compiler.boolClass, compiler.nullClass,
          compiler.listClass];
     nativeClassesNeedingUnmangledName.forEach((element) {
-        names.add(new js.Property(js.string(namer.className(element)),
+        names.add(new js.Property(js.quoteName(namer.className(element)),
                                   js.string(element.name)));
     });
 
     return new js.Property(js.string(MANGLED_GLOBAL_NAMES),
                            new js.ObjectInitializer(names));
   }
 
   js.Statement emitDeferredInitializerGlobal(Map loadMap) {
     if (loadMap.isEmpty) return new js.Block.empty();
 
@@ skipping 174 matching lines @@
       "The array is completely empty if there is no constant at all.";
 
   js.ArrayInitializer emitConstants(List<Constant> constants) {
     List<js.Expression> data = <js.Expression>[];
     if (constants.isNotEmpty) {
       int holderIndex = constants.first.holder.index;
       data.add(js.number(holderIndex));
       data.addAll(constants.expand((Constant constant) {
         assert(constant.holder.index == holderIndex);
         js.Expression code = constantEmitter.generate(constant.value);
-        return [js.string(constant.name), unparse(compiler, code)];
+        return [js.quoteName(constant.name), unparse(compiler, code)];
       }));
     }
     return new js.ArrayInitializer(data);
   }
 
   js.Block emitStaticNonFinalFields(List<StaticField> fields) {
     Iterable<js.Statement> statements = fields.map((StaticField field) {
       return js.js.statement("#.# = #;",
                              [field.holder.name, field.name, field.code]);
     });
     return new js.Block(statements.toList());
   }
 
   js.Expression emitLazilyInitializedStatics(List<StaticField> fields) {
     Iterable fieldDescriptors = fields.expand((field) =>
-        [ js.string(field.name),
-          js.string("${namer.getterPrefix}${field.name}"),
+        [ js.quoteName(field.name),
+          js.quoteName(namer.deriveLazyInitializerName(field.name)),
           js.number(field.holder.index),
           emitLazyInitializer(field) ]);
     return new js.ArrayInitializer(fieldDescriptors.toList(growable: false));
   }
 
   js.Block emitEagerClassInitializations(List<Library> libraries) {
     js.Statement createInstantiation(Class cls) {
       return js.js.statement('new #.#()', [cls.holder.name, cls.name]);
     }
 
     List<js.Statement> instantiations =
         libraries.expand((Library library) => library.classes)
                  .where((Class cls) => cls.isEager)
                  .map(createInstantiation)
                  .toList(growable: false);
     return new js.Block(instantiations);
   }
 
   // This string should be referenced wherever JavaScript code makes assumptions
   // on the mixin format.
   static final String nativeInfoDescription =
       "A class is encoded as follows:"
       "   [name, class-code, holder-index], or "
       "   [name, class-code, native-info, holder-index].";
 
   js.Expression emitLibrary(Library library) {
     Iterable staticDescriptors = library.statics.expand(emitStaticMethod);
 
     Iterable classDescriptors = library.classes.expand((Class cls) {
-      js.LiteralString name = js.string(cls.name);
+      js.Literal name = js.quoteName(cls.name);
       js.LiteralNumber holderIndex = js.number(cls.holder.index);
       js.Expression emittedClass = emitClass(cls);
       if (cls.nativeInfo == null) {
         return [name, emittedClass, holderIndex];
       } else {
-        return [name, emittedClass, js.string(cls.nativeInfo), holderIndex];
+        return [name, emittedClass, cls.nativeInfo, holderIndex];
       }
     });
 
     js.Expression staticArray =
         new js.ArrayInitializer(staticDescriptors.toList(growable: false));
     js.Expression classArray =
         new js.ArrayInitializer(classDescriptors.toList(growable: false));
 
     return new js.ArrayInitializer([staticArray, classArray]);
   }
 
   js.Expression _generateConstructor(Class cls) {
-    List<String> fieldNames = <String>[];
+    List<js.Name> fieldNames = const <js.Name>[];
 
     // If the class is not directly instantiated we only need it for inheritance
     // or RTI. In either case we don't need its fields.
     if (cls.isDirectlyInstantiated && !cls.isNative) {
       fieldNames = cls.fields.map((Field field) => field.name).toList();
     }
-    String name = cls.name;
-    String parameters = fieldNames.join(', ');
-    String assignments = fieldNames
-        .map((String field) => "this.$field = $field;\n")
-        .join();
-    String code = 'function $name($parameters) { $assignments }';
-    js.Template template = js.js.uncachedExpressionTemplate(code);
-    return template.instantiate(const []);
+    js.Name name = cls.name;
+
+    Iterable<js.Name> assignments = fieldNames.map((js.Name field) {
+        return js.js("this.#field = #field", {"field": field});
+      });
+
+    return js.js('function #(#) { # }', [name, fieldNames, assignments]);
   }
 
   Method _generateGetter(Field field) {
     String getterTemplateFor(int flags) {
       switch (flags) {
         case 1: return "function() { return this[#]; }";
         case 2: return "function(receiver) { return receiver[#]; }";
         case 3: return "function(receiver) { return this[#]; }";
       }
       return null;
     }
 
-    js.Expression fieldName = js.string(field.name);
+    js.Expression fieldName = js.quoteName(field.name);
     js.Expression code = js.js(getterTemplateFor(field.getterFlags), fieldName);
-    String getterName = "${namer.getterPrefix}${field.accessorName}";
+    js.Name getterName = namer.deriveGetterName(field.accessorName);
     return new StubMethod(getterName, code);
   }
 
   Method _generateSetter(Field field) {
     String setterTemplateFor(int flags) {
       switch (flags) {
         case 1: return "function(val) { return this[#] = val; }";
         case 2: return "function(receiver, val) { return receiver[#] = val; }";
         case 3: return "function(receiver, val) { return this[#] = val; }";
       }
       return null;
     }
-    js.Expression fieldName = js.string(field.name);
+    js.Expression fieldName = js.quoteName(field.name);
     js.Expression code = js.js(setterTemplateFor(field.setterFlags), fieldName);
-    String setterName = "${namer.setterPrefix}${field.accessorName}";
+    js.Name setterName = namer.deriveSetterName(field.accessorName);
     return new StubMethod(setterName, code);
   }
 
   Iterable<Method> _generateGettersSetters(Class cls) {
     Iterable<Method> getters = cls.fields
         .where((Field field) => field.needsGetter)
         .map(_generateGetter);
 
     Iterable<Method> setters = cls.fields
         .where((Field field) => field.needsUncheckedSetter)
         .map(_generateSetter);
 
     return [getters, setters].expand((x) => x);
   }
 
   // This string should be referenced wherever JavaScript code makes assumptions
   // on the mixin format.
   static final String mixinFormatDescription =
       "Mixins have a reference to their mixin class at the place of the usual"
       "constructor. If they are instantiated the constructor follows the"
       "reference.";
 
   js.Expression emitClass(Class cls) {
-    List elements = [js.string(cls.superclassName),
+    List elements = [js.quoteName(cls.superclassName, allowNull: true),
                      js.number(cls.superclassHolderIndex)];
 
     if (cls.isMixinApplication) {
       MixinApplication mixin = cls;
-      elements.add(js.string(mixin.mixinClass.name));
+      elements.add(js.quoteName(mixin.mixinClass.name));
       elements.add(js.number(mixin.mixinClass.holder.index));
       if (cls.isDirectlyInstantiated) {
         elements.add(_generateConstructor(cls));
       }
     } else {
       elements.add(_generateConstructor(cls));
     }
     Iterable<Method> methods = cls.methods;
     Iterable<Method> isChecks = cls.isChecks;
     Iterable<Method> callStubs = cls.callStubs;
@@ skipping 108 matching lines @@
         properties.add(new js.Property(js.string(name),
             generateConstantReference(value)));
       });
       return new js.ObjectInitializer(properties);
     }
   }
 
   Iterable<js.Expression> emitInstanceMethod(Method method) {
 
     List<js.Expression> makeNameCodePair(Method method) {
-      return [js.string(method.name), method.code];
+      return [js.quoteName(method.name), method.code];
     }
 
     List<js.Expression> makeNameCallNameCodeTriplet(ParameterStubMethod stub) {
       js.Expression callName = stub.callName == null
           ? new js.LiteralNull()
-          : js.string(stub.callName);
-      return [js.string(stub.name), callName, stub.code];
+          : js.quoteName(stub.callName);
+      return [js.quoteName(stub.name), callName, stub.code];
     }
 
     if (method is InstanceMethod) {
       if (method.needsTearOff || method.aliasName != null) {
         /// See [parseFunctionDescriptorBoilerplate] for a full description of
         /// the format.
         // [name, [aliasName, function, callName, isIntercepted, tearOffName,
         // functionType, stub1_name, stub1_callName, stub1_code, ...]
         var data = [];
         if (method.aliasName != null) {
-          data.add(js.string(method.aliasName));
+          data.add(js.quoteName(method.aliasName));
         }
         data.add(method.code);
-        data.add(js.string(method.callName));
+        data.add(js.quoteName(method.callName, allowNull: true));
 
         if (method.needsTearOff) {
           bool isIntercepted = backend.isInterceptedMethod(method.element);
           data.add(new js.LiteralBool(isIntercepted));
-          data.add(js.string(method.tearOffName));
+          data.add(js.quoteName(method.tearOffName));
           data.add((method.functionType));
         }
 
         data.addAll(method.parameterStubs.expand(makeNameCallNameCodeTriplet));
         if (method.canBeApplied) {
           data.add(js.number(method.requiredParameterCount));
           data.add(_encodeOptionalParameterDefaultValues(method));
         }
-        return [js.string(method.name), new js.ArrayInitializer(data)];
+        return [js.quoteName(method.name), new js.ArrayInitializer(data)];
       } else {
         // TODO(floitsch): not the most efficient way...
         return ([method]..addAll(method.parameterStubs))
             .expand(makeNameCodePair);
       }
     } else {
       return makeNameCodePair(method);
     }
   }
 
   Iterable<js.Expression> emitStaticMethod(StaticMethod method) {
     js.Expression holderIndex = js.number(method.holder.index);
     List<js.Expression> output = <js.Expression>[];
 
     void _addMethod(Method method) {
       js.Expression unparsed = unparse(compiler, method.code);
-      output.add(js.string(method.name));
+      output.add(js.quoteName(method.name));
       output.add(holderIndex);
       output.add(unparsed);
     }
 
     List<js.Expression> makeNameCallNameCodeTriplet(ParameterStubMethod stub) {
       js.Expression callName = stub.callName == null
           ? new js.LiteralNull()
-          : js.string(stub.callName);
-      return [js.string(stub.name), callName, unparse(compiler, stub.code)];
+          : js.quoteName(stub.callName);
+      return [js.quoteName(stub.name), callName, unparse(compiler, stub.code)];
     }
 
     _addMethod(method);
     // TODO(floitsch): can there be anything else than a StaticDartMethod?
     if (method is StaticDartMethod) {
       if (method.needsTearOff) {
         /// The format emitted is the same as for the parser specified at
         /// [parseFunctionDescriptorBoilerplate] except for the missing
         /// field whether the method is intercepted.
         // [name, [function, callName, tearOffName, functionType,
         //     stub1_name, stub1_callName, stub1_code, ...]
         var data = [unparse(compiler, method.code)];
-        data.add(js.string(method.callName));
-        data.add(js.string(method.tearOffName));
+        data.add(js.quoteName(method.callName));
+        data.add(js.quoteName(method.tearOffName));
         data.add(method.functionType);
         data.addAll(method.parameterStubs.expand(makeNameCallNameCodeTriplet));
         if (method.canBeApplied) {
           data.add(js.number(method.requiredParameterCount));
           data.add(_encodeOptionalParameterDefaultValues(method));
         }
-        return [js.string(method.name), holderIndex,
+        return [js.quoteName(method.name), holderIndex,
                 new js.ArrayInitializer(data)];
       } else {
         method.parameterStubs.forEach(_addMethod);
       }
     }
     return output;
   }
 
   static final String setupProgramName = "setupProgram";
 
@@ skipping 333 matching lines @@
 
   var end = Date.now();
   // print('Setup: ' + (end - start) + ' ms.');
 
   #invokeMain;  // Start main.
 
 })(Date.now(), #code)
 }""";
 
 }