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

pkg/compiler/lib/src/js_emitter/old_emitter/class_emitter.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;
 
 class ClassEmitter extends CodeEmitterHelper {
 
   ClassStubGenerator get _stubGenerator =>
       new ClassStubGenerator(compiler, namer, backend);
 
   /**
    * Documentation wanted -- johnniwinther
    */
   void emitClass(Class cls, ClassBuilder enclosingBuilder, Fragment fragment) {
     ClassElement classElement = cls.element;
 
     assert(invariant(classElement, classElement.isDeclaration));
 
     emitter.needsClassSupport = true;
 
     ClassElement superclass = classElement.superclass;
-    String superName = "";
+    jsAst.Name superName;
     if (superclass != null) {
       superName = namer.className(superclass);
     }
 
     if (cls.isMixinApplication) {
       MixinApplication mixinApplication = cls;
-      String mixinName = mixinApplication.mixinClass.name;
-      superName = '$superName+$mixinName';
+      jsAst.Name mixinName = mixinApplication.mixinClass.name;
+      superName =
+          new CompoundName([superName, Namer.literalPlus, mixinName]);
       emitter.needsMixinSupport = true;
     }
 
-    ClassBuilder builder = new ClassBuilder(classElement, namer);
+    ClassBuilder builder = new ClassBuilder.forClass(classElement, namer);
     builder.superName = superName;
     emitConstructorsForCSP(cls);
     emitFields(cls, builder);
     emitCheckedClassSetters(cls, builder);
     emitClassGettersSettersForCSP(cls, builder);
     emitInstanceMembers(cls, builder);
     emitStubs(cls.callStubs, builder);
     emitStubs(cls.typeVariableReaderStubs, builder);
     emitRuntimeTypeInformation(cls, builder);
     emitNativeInfo(cls, builder);
 
     if (classElement == backend.closureClass) {
       // We add a special getter here to allow for tearing off a closure from
       // itself.
       jsAst.Fun function = js('function() { return this; }');
-      String name = namer.getterForMember(Selector.CALL_NAME);
+      jsAst.Name name = namer.getterForMember(Selector.CALL_NAME);
       builder.addProperty(name, function);
     }
 
     emitClassBuilderWithReflectionData(cls, builder, enclosingBuilder,
         fragment);
   }
   /**
   * Emits the precompiled constructor when in CSP mode.
   */
   void emitConstructorsForCSP(Class cls) {
     List<String> fieldNames = <String>[];
 
     if (!compiler.useContentSecurityPolicy) return;
 
     if (!cls.onlyForRti && !cls.isNative) {
       fieldNames = cls.fields.map((Field field) => field.name).toList();
     }
 
     ClassElement classElement = cls.element;
 
     jsAst.Expression constructorAst =
         _stubGenerator.generateClassConstructor(classElement, fieldNames);
 
-    String constructorName = namer.className(classElement);
+    jsAst.Name constructorName = namer.className(classElement);
     OutputUnit outputUnit =
         compiler.deferredLoadTask.outputUnitForElement(classElement);
     emitter.assemblePrecompiledConstructor(
         outputUnit, constructorName, constructorAst, fieldNames);
   }
 
   /// Returns `true` if fields added.
   bool emitFields(FieldContainer container,
                   ClassBuilder builder,
                   { bool classIsNative: false,
@@ skipping 12 matching lines @@
       assert(emitStatics);
       fields = container.staticFieldsForReflection;
     }
 
     var fieldMetadata = [];
     bool hasMetadata = false;
     bool fieldsAdded = false;
 
     for (Field field in fields) {
       FieldElement fieldElement = field.element;
-      String name = field.name;
-      String accessorName = field.accessorName;
+      jsAst.Name name = field.name;
+      jsAst.Name accessorName = field.accessorName;
       bool needsGetter = field.needsGetter;
       bool needsSetter = field.needsUncheckedSetter;
 
         // Ignore needsCheckedSetter - that is handled below.
       bool needsAccessor = (needsGetter || needsSetter);
       // We need to output the fields for non-native classes so we can auto-
       // generate the constructor.  For native classes there are no
       // constructors, so we don't need the fields unless we are generating
       // accessors at runtime.
       bool needsFieldsForConstructor = !emitStatics && !classIsNative;
       if (needsFieldsForConstructor || needsAccessor) {
         var metadata =
             task.metadataCollector.buildMetadataFunction(fieldElement);
         if (metadata != null) {
           hasMetadata = true;
         } else {
           metadata = new jsAst.LiteralNull();
         }
         fieldMetadata.add(metadata);
         recordMangledField(fieldElement, accessorName,
             namer.privateName(fieldElement.memberName));
         List<jsAst.Literal> fieldNameParts = <jsAst.Literal>[];
         if (!needsAccessor) {
           // Emit field for constructor generation.
           assert(!classIsNative);
-          fieldNameParts.add(js.stringPart(name));
+          fieldNameParts.add(name);
         } else {
           // Emit (possibly renaming) field name so we can add accessors at
           // runtime.
           if (name != accessorName) {
-            fieldNameParts.add(js.stringPart(accessorName));
+            fieldNameParts.add(accessorName);
             fieldNameParts.add(js.stringPart(':'));
           }
-          fieldNameParts.add(js.stringPart(name));
+          fieldNameParts.add(name);
           if (field.needsInterceptedGetter) {
             emitter.interceptorEmitter.interceptorInvocationNames.add(
                 namer.getterForElement(fieldElement));
           }
           // TODO(16168): The setter creator only looks at the getter-name.
           // Even though the setter could avoid the interceptor convention we
           // currently still need to add the additional argument.
           if (field.needsInterceptedGetter || field.needsInterceptedSetter) {
             emitter.interceptorEmitter.interceptorInvocationNames.add(
                 namer.setterForElement(fieldElement));
@@ skipping 114 matching lines @@
       builder.functionType = cls.functionTypeIndex;
     }
 
     for (Method method in cls.isChecks) {
       builder.addProperty(method.name, method.code);
     }
   }
 
   void emitNativeInfo(Class cls, ClassBuilder builder) {
     if (cls.nativeInfo != null) {
-      builder.addProperty(namer.nativeSpecProperty, js.string(cls.nativeInfo));
+      builder.addPropertyByName(namer.nativeSpecProperty, cls.nativeInfo);
     }
   }
 
   void emitClassBuilderWithReflectionData(Class cls,
                                           ClassBuilder classBuilder,
                                           ClassBuilder enclosingBuilder,
                                           Fragment fragment) {
     ClassElement classElement = cls.element;
-    String className = cls.name;
+    jsAst.Name className = cls.name;
 
     var metadata = task.metadataCollector.buildMetadataFunction(classElement);
     if (metadata != null) {
-      classBuilder.addProperty("@", metadata);
+      classBuilder.addPropertyByName("@", metadata);
     }
 
     if (backend.isAccessibleByReflection(classElement)) {
       List<DartType> typeVars = classElement.typeVariables;
       Iterable typeVariableProperties = emitter.typeVariableHandler
           .typeVariablesOf(classElement);
 
       ClassElement superclass = classElement.superclass;
       bool hasSuper = superclass != null;
       if ((!typeVariableProperties.isEmpty && !hasSuper) ||
           (hasSuper && !equalElements(superclass.typeVariables, typeVars))) {
-        classBuilder.addProperty('<>',
+        classBuilder.addPropertyByName('<>',
             new jsAst.ArrayInitializer(typeVariableProperties.toList()));
       }
     }
 
     List<jsAst.Property> statics = new List<jsAst.Property>();
-    ClassBuilder staticsBuilder = new ClassBuilder(classElement, namer);
+    ClassBuilder staticsBuilder =
+        new ClassBuilder.forStatics(classElement, namer);
     if (emitFields(cls, staticsBuilder, emitStatics: true)) {
       jsAst.ObjectInitializer initializer =
         staticsBuilder.toObjectInitializer();
       compiler.dumpInfoTask.registerElementAst(classElement,
         initializer);
       jsAst.Node property = initializer.properties.single;
       compiler.dumpInfoTask.registerElementAst(classElement, property);
       statics.add(property);
     }
 
     // TODO(herhut): Do not grab statics out of the properties.
     ClassBuilder classProperties =
         emitter.elementDescriptors[fragment].remove(classElement);
     if (classProperties != null) {
       statics.addAll(classProperties.properties);
     }
 
     if (!statics.isEmpty) {
-      classBuilder.addProperty('static', new jsAst.ObjectInitializer(statics));
+      classBuilder.addPropertyByName('static', new jsAst.ObjectInitializer(statics));

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

long line.

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

Thanks!

     }
 
     // TODO(ahe): This method (generateClass) should return a jsAst.Expression.
     jsAst.ObjectInitializer propertyValue =
         classBuilder.toObjectInitializer();
     compiler.dumpInfoTask.registerElementAst(classBuilder.element, propertyValue);
     enclosingBuilder.addProperty(className, propertyValue);
 
     String reflectionName = emitter.getReflectionName(classElement, className);
     if (reflectionName != null) {
       if (!backend.isAccessibleByReflection(classElement)) {
-        enclosingBuilder.addProperty("+$reflectionName", js.number(0));
+        // TODO(herhut): Fix use of reflection name here.
+        enclosingBuilder.addPropertyByName("+$reflectionName", js.number(0));
       } else {
         List<jsAst.Expression> types = <jsAst.Expression>[];
         if (classElement.supertype != null) {
           types.add(task.metadataCollector.reifyType(classElement.supertype));
         }
         for (DartType interface in classElement.interfaces) {
           types.add(task.metadataCollector.reifyType(interface));
         }
-        enclosingBuilder.addProperty("+$reflectionName",
+        // TODO(herhut): Fix use of reflection name here.
+        enclosingBuilder.addPropertyByName("+$reflectionName",
             new jsAst.ArrayInitializer(types));
       }
     }
   }
 
   /**
    * Invokes [f] for each of the fields of [element].
    *
    * [element] must be a [ClassElement] or a [LibraryElement].
    *
@@ skipping 43 matching lines @@
       bool needsGetter = false;
       bool needsSetter = false;
       if (isLibrary || isMixinNativeField || holder == element) {
         needsGetter = fieldNeedsGetter(field);
         needsSetter = fieldNeedsSetter(field);
       }
 
       if ((isInstantiated && !holder.isNative)
           || needsGetter
           || needsSetter) {
-        String accessorName = namer.fieldAccessorName(field);
-        String fieldName = namer.fieldPropertyName(field);
+        jsAst.Name accessorName = namer.fieldAccessorName(field);
+        jsAst.Name fieldName = namer.fieldPropertyName(field);
         bool needsCheckedSetter = false;
         if (compiler.enableTypeAssertions
             && needsSetter
             && !canAvoidGeneratedCheckedSetter(field)) {
           needsCheckedSetter = true;
           needsSetter = false;
         }
         // Getters and setters with suffixes will be generated dynamically.
         f(field, fieldName, accessorName, needsGetter, needsSetter,
           needsCheckedSetter);
@@ skipping 18 matching lines @@
       // If a class is not instantiated then we add the field just so we can
       // generate the field getter/setter dynamically. Since this is only
       // allowed on fields that are in [element] we don't need to visit
       // superclasses for non-instantiated classes.
       cls.implementation.forEachInstanceField(
           visitField, includeSuperAndInjectedMembers: isInstantiated);
     }
   }
 
   void recordMangledField(Element member,
-                          String accessorName,
+                          jsAst.Name accessorName,
                           String memberName) {
     if (!backend.shouldRetainGetter(member)) return;
     String previousName;
     if (member.isInstanceMember) {
       previousName = emitter.mangledFieldNames.putIfAbsent(
-          '${namer.getterPrefix}$accessorName',
+          namer.deriveGetterName(accessorName),
           () => memberName);
     } else {
       previousName = emitter.mangledGlobalFieldNames.putIfAbsent(
           accessorName,
           () => memberName);
     }
     assert(invariant(member, previousName == memberName,
                      message: '$previousName != ${memberName}'));
   }
 
@@ skipping 24 matching lines @@
   }
 
   bool canAvoidGeneratedCheckedSetter(VariableElement member) {
     // We never generate accessors for top-level/static fields.
     if (!member.isInstanceMember) return true;
     DartType type = member.type;
     return type.treatAsDynamic || (type.element == compiler.objectClass);
   }
 
   void generateCheckedSetter(Element member,
-                             String fieldName,
-                             String accessorName,
+                             jsAst.Name fieldName,
+                             jsAst.Name accessorName,
                              ClassBuilder builder) {
     jsAst.Expression code = backend.generatedCode[member];
     assert(code != null);
-    String setterName = namer.deriveSetterName(accessorName);
+    jsAst.Name setterName = namer.deriveSetterName(accessorName);
     compiler.dumpInfoTask.registerElementAst(member,
         builder.addProperty(setterName, code));
     generateReflectionDataForFieldGetterOrSetter(
         member, setterName, builder, isGetter: false);
   }
 
-  void emitGetterForCSP(Element member, String fieldName, String accessorName,
+  void emitGetterForCSP(Element member, jsAst.Name fieldName,
+                        jsAst.Name accessorName,
                         ClassBuilder builder) {
     jsAst.Expression function =
         _stubGenerator.generateGetter(member, fieldName);
 
-    String getterName = namer.deriveGetterName(accessorName);
+    jsAst.Name getterName = namer.deriveGetterName(accessorName);
     ClassElement cls = member.enclosingClass;
-    String className = namer.className(cls);
+    jsAst.Name className = namer.className(cls);
     OutputUnit outputUnit =
         compiler.deferredLoadTask.outputUnitForElement(member);
     emitter.cspPrecompiledFunctionFor(outputUnit).add(
         js('#.prototype.# = #', [className, getterName, function]));
     if (backend.isAccessibleByReflection(member)) {
       emitter.cspPrecompiledFunctionFor(outputUnit).add(
           js('#.prototype.#.${namer.reflectableField} = 1',
               [className, getterName]));
     }
   }
 
-  void emitSetterForCSP(Element member, String fieldName, String accessorName,
+  void emitSetterForCSP(Element member, jsAst.Name fieldName,
+                        jsAst.Name accessorName,
                         ClassBuilder builder) {
     jsAst.Expression function =
         _stubGenerator.generateSetter(member, fieldName);
 
-    String setterName = namer.deriveSetterName(accessorName);
+    jsAst.Name setterName = namer.deriveSetterName(accessorName);
     ClassElement cls = member.enclosingClass;
-    String className = namer.className(cls);
+    jsAst.Name className = namer.className(cls);
     OutputUnit outputUnit =
         compiler.deferredLoadTask.outputUnitForElement(member);
     emitter.cspPrecompiledFunctionFor(outputUnit).add(
         js('#.prototype.# = #', [className, setterName, function]));
     if (backend.isAccessibleByReflection(member)) {
       emitter.cspPrecompiledFunctionFor(outputUnit).add(
           js('#.prototype.#.${namer.reflectableField} = 1',
               [className, setterName]));
     }
   }
 
   void generateReflectionDataForFieldGetterOrSetter(Element member,
-                                                    String name,
+                                                    jsAst.Name name,
                                                     ClassBuilder builder,
                                                     {bool isGetter}) {
     Selector selector = isGetter
         ? new Selector.getter(member.name, member.library)
         : new Selector.setter(member.name, member.library);
     String reflectionName = emitter.getReflectionName(selector, name);
     if (reflectionName != null) {
       var reflectable =
           js(backend.isAccessibleByReflection(member) ? '1' : '0');
-      builder.addProperty('+$reflectionName', reflectable);
+      builder.addPropertyByName('+$reflectionName', reflectable);
     }
   }
 }