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

pkg/compiler/lib/src/js_emitter/old_emitter/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.
 
 part of dart2js.js_emitter;
 
 
 class OldEmitter implements Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
@@ skipping 25 matching lines @@
 
   // The full code that is written to each hunk part-file.
   Map<OutputUnit, CodeOutput> outputBuffers = new Map<OutputUnit, CodeOutput>();
 
   String classesCollector;
   Set<ClassElement> get neededClasses => task.neededClasses;
   Map<OutputUnit, List<ClassElement>> get outputClassLists
       => task.outputClassLists;
   Map<OutputUnit, List<ConstantValue>> get outputConstantLists
       => task.outputConstantLists;
-  final Map<String, String> mangledFieldNames = <String, String>{};
-  final Map<String, String> mangledGlobalFieldNames = <String, String>{};
-  final Set<String> recordedMangledNames = new Set<String>();
+  final Map<jsAst.Name, String> mangledFieldNames =
+      new HashMap<jsAst.Name, String>();
+  final Map<jsAst.Name, String> mangledGlobalFieldNames =
+      new HashMap<jsAst.Name, String>();
+  final Set<jsAst.Name> recordedMangledNames = new Set<jsAst.Name>();
 
   List<TypedefElement> get typedefsNeededForReflection =>
       task.typedefsNeededForReflection;
 
   JavaScriptBackend get backend => compiler.backend;
   TypeVariableHandler get typeVariableHandler => backend.typeVariableHandler;
 
   String get _ => space;
   String get space => compiler.enableMinification ? "" : " ";
   String get n => compiler.enableMinification ? "" : "\n";
@@ skipping 27 matching lines @@
 
   final bool generateSourceMap;
 
   OldEmitter(Compiler compiler, Namer namer, this.generateSourceMap, this.task)
       : this.compiler = compiler,
         this.namer = namer,
         cachedEmittedConstants = compiler.cacheStrategy.newSet(),
         cachedClassBuilders = compiler.cacheStrategy.newMap(),
         cachedElements = compiler.cacheStrategy.newSet() {
     constantEmitter = new ConstantEmitter(
-        compiler, namer, this.constantReference, makeConstantListTemplate);
+        compiler, namer, this.constantReference, constantListGenerator);
     containerBuilder.emitter = this;
     classEmitter.emitter = this;
     nsmEmitter.emitter = this;
     interceptorEmitter.emitter = this;
   }
 
   List<jsAst.Node> cspPrecompiledFunctionFor(OutputUnit outputUnit) {
     return _cspPrecompiledFunctions.putIfAbsent(
         outputUnit,
         () => new List<jsAst.Node>());
@@ skipping 38 matching lines @@
     if (a.isInterceptor != b.isInterceptor) {
       return a.isInterceptor ? -1 : 1;
     }
 
     // Sorting by the long name clusters constants with the same constructor
     // which compresses a tiny bit better.
     int r = namer.constantLongName(a).compareTo(namer.constantLongName(b));
     if (r != 0) return r;
     // Resolve collisions in the long name by using the constant name (i.e. JS
     // name) which is unique.
-    return namer.constantName(a).compareTo(namer.constantName(b));
+    // TODO(herhut): Find a better way to resolve collisions.
+    return namer.constantName(a).hashCode.compareTo(
+        namer.constantName(b).hashCode);
   }
 
   @override
   jsAst.Expression constantReference(ConstantValue value) {
     if (value.isFunction) {
       FunctionConstantValue functionConstant = value;
       return isolateStaticClosureAccess(functionConstant.element);
     }
 
     // We are only interested in the "isInlined" part, but it does not hurt to
@@ skipping 14 matching lines @@
   String get finishIsolateConstructorName
       => '${namer.isolateName}.\$finishIsolateConstructor';
   String get isolatePropertiesName
       => '${namer.isolateName}.${namer.isolatePropertiesName}';
   String get lazyInitializerProperty
       => r'$lazy';
   String get lazyInitializerName
       => '${namer.isolateName}.${lazyInitializerProperty}';
   String get initName => 'init';
 
-  String get makeConstListProperty => namer.internalGlobal('makeConstantList');
+  jsAst.Name get makeConstListProperty
+      => namer.internalGlobal('makeConstantList');
 
   /// The name of the property that contains all field names.
   ///
   /// This property is added to constructors when isolate support is enabled.
   static const String FIELD_NAMES_PROPERTY_NAME = r"$__fields__";
 
   /// For deferred loading we communicate the initializers via this global var.
   final String deferredInitializers = r"$dart_deferred_initializers$";
 
   /// Contains the global state that is needed to initialize and load a
   /// deferred library.
-  String get globalsHolder => namer.internalGlobal("globalsHolder");
+  jsAst.Name get globalsHolder => namer.internalGlobal("globalsHolder");
 
   @override
   jsAst.Expression generateEmbeddedGlobalAccess(String global) {
     return js(generateEmbeddedGlobalAccessString(global));
   }
 
   String generateEmbeddedGlobalAccessString(String global) {
     // TODO(floitsch): don't use 'init' as global embedder storage.
     return '$initName.$global';
   }
 
   jsAst.PropertyAccess globalPropertyAccess(Element element) {
-    String name = namer.globalPropertyName(element);
-    jsAst.PropertyAccess pa = new jsAst.PropertyAccess.field(
+    jsAst.Name name = namer.globalPropertyName(element);
+    jsAst.PropertyAccess pa = new jsAst.PropertyAccess(
         new jsAst.VariableUse(namer.globalObjectFor(element)),
         name);
     return pa;
   }
 
   @override
   jsAst.Expression isolateLazyInitializerAccess(FieldElement element) {
      return jsAst.js('#.#', [namer.globalObjectFor(element),
                              namer.lazyInitializerName(element)]);
    }
@@ skipping 59 matching lines @@
         return backend.rti.representationGenerator
             .templateForCreateFunctionType;
 
       case JsBuiltin.isSubtype:
         // TODO(floitsch): move this closer to where is-check properties are
         // built.
         String isPrefix = namer.operatorIsPrefix;
         return jsAst.js.expressionTemplateFor(
             "('$isPrefix' + #) in #.prototype");
 
-      case JsBuiltin.isFunctionTypeRti:
-        String functionClassName =
-            backend.namer.runtimeTypeName(compiler.functionClass);
-        return jsAst.js.expressionTemplateFor(
-            '#.$typeNameProperty === "$functionClassName"');
-
-      case JsBuiltin.isDartObjectTypeRti:
-        String objectClassName =
-            backend.namer.runtimeTypeName(compiler.objectClass);
-        return jsAst.js.expressionTemplateFor(
-            '#.$typeNameProperty === "$objectClassName"');
-
-      case JsBuiltin.isNullTypeRti:
-        String nullClassName =
-            backend.namer.runtimeTypeName(compiler.nullClass);
-        return jsAst.js.expressionTemplateFor(
-            '#.$typeNameProperty === "$nullClassName"');
+      case JsBuiltin.isGivenTypeRti:
+        return jsAst.js.expressionTemplateFor('#.$typeNameProperty === #');
 
       case JsBuiltin.getMetadata:
         String metadataAccess =
             generateEmbeddedGlobalAccessString(embeddedNames.METADATA);
         return jsAst.js.expressionTemplateFor("$metadataAccess[#]");
 
       case JsBuiltin.getType:
         String typesAccess =
             generateEmbeddedGlobalAccessString(embeddedNames.TYPES);
         return jsAst.js.expressionTemplateFor("$typesAccess[#]");
@@ skipping 41 matching lines @@
   /// The reflection name of a getter 'foo' is 'foo'.
   /// The reflection name of a setter 'foo' is 'foo='.
   /// The reflection name of a method 'foo' is 'foo:N:M:O', where N is the
   /// number of required arguments, M is the number of optional arguments, and
   /// O is the named arguments.
   /// The reflection name of a constructor is similar to a regular method but
   /// starts with 'new '.
   /// The reflection name of class 'C' is 'C'.
   /// An anonymous mixin application has no reflection name.
   /// This is used by js_mirrors.dart.
-  String getReflectionName(elementOrSelector, String mangledName) {
+  String getReflectionName(elementOrSelector, jsAst.Name mangledName) {
     String name = elementOrSelector.name;
     if (backend.shouldRetainName(name) ||
         elementOrSelector is Element &&
         // Make sure to retain names of unnamed constructors, and
         // for common native types.
         ((name == '' &&
           backend.isAccessibleByReflection(elementOrSelector)) ||
          _isNativeTypeNeedingReflectionName(elementOrSelector))) {
 
       // TODO(ahe): Enable the next line when I can tell the difference between
       // an instance method and a global.  They may have the same mangled name.
       // if (recordedMangledNames.contains(mangledName)) return null;
       recordedMangledNames.add(mangledName);
       return getReflectionNameInternal(elementOrSelector, mangledName);
     }
     return null;
   }
 
-  String getReflectionNameInternal(elementOrSelector, String mangledName) {
+  String getReflectionNameInternal(elementOrSelector,
+                                   jsAst.Name mangledName) {
     String name = namer.privateName(elementOrSelector.memberName);
     if (elementOrSelector.isGetter) return name;
     if (elementOrSelector.isSetter) {
-      if (!mangledName.startsWith(namer.setterPrefix)) return '$name=';
-      String base = mangledName.substring(namer.setterPrefix.length);
-      String getter = '${namer.getterPrefix}$base';
+      if (mangledName is! SetterName) return '$name=';
+      SetterName setterName = mangledName;
+      jsAst.Name base = setterName.base;
+      jsAst.Name getter = namer.deriveGetterName(base);
       mangledFieldNames.putIfAbsent(getter, () => name);
       assert(mangledFieldNames[getter] == name);
       recordedMangledNames.add(getter);
       // TODO(karlklose,ahe): we do not actually need to store information
       // about the name of this setter in the output, but it is needed for
       // marking the function as invokable by reflection.
       return '$name=';
     }
     if (elementOrSelector is Element && elementOrSelector.isClosure) {
       // Closures are synthesized and their name might conflict with existing
       // globals. Assign an illegal name, and make sure they don't clash
       // with each other.
-      return " $mangledName";
+      return " $name";
     }
     if (elementOrSelector is Selector
         || elementOrSelector.isFunction
         || elementOrSelector.isConstructor) {
       int positionalParameterCount;
       String namedArguments = '';
       bool isConstructor = false;
       if (elementOrSelector is Selector) {
         CallStructure callStructure = elementOrSelector.callStructure;
         positionalParameterCount = callStructure.positionalArgumentCount;
@@ skipping 71 matching lines @@
     }
   }
 
   void assembleClass(Class cls, ClassBuilder enclosingBuilder,
                      Fragment fragment) {
     ClassElement classElement = cls.element;
     compiler.withCurrentElement(classElement, () {
       if (compiler.hasIncrementalSupport) {
         ClassBuilder cachedBuilder =
             cachedClassBuilders.putIfAbsent(classElement, () {
-              ClassBuilder builder = new ClassBuilder(classElement, namer);
+              ClassBuilder builder =
+                  new ClassBuilder.forClass(classElement, namer);
               classEmitter.emitClass(cls, builder, fragment);
               return builder;
             });
         invariant(classElement, cachedBuilder.fields.isEmpty);
         invariant(classElement, cachedBuilder.superName == null);
         invariant(classElement, cachedBuilder.functionType == null);
         invariant(classElement, cachedBuilder.fieldMetadata == null);
         enclosingBuilder.properties.addAll(cachedBuilder.properties);
       } else {
         classEmitter.emitClass(cls, enclosingBuilder, fragment);
       }
     });
   }
 
   void assembleStaticFunctions(Iterable<Method> staticFunctions,
                                Fragment fragment) {
     if (staticFunctions == null) return;
 
     for (Method method in staticFunctions) {
       Element element = method.element;
       // We need to filter out null-elements for the interceptors.
       // TODO(floitsch): use the precomputed interceptors here.
       if (element == null) continue;
-      ClassBuilder builder = new ClassBuilder(element, namer);
+      ClassBuilder builder = new ClassBuilder.forStatics(element, namer);
       containerBuilder.addMemberMethod(method, builder);
       getElementDescriptor(element, fragment).properties
           .addAll(builder.properties);
     }
   }
 
   jsAst.Statement buildStaticNonFinalFieldInitializations(
       OutputUnit outputUnit) {
     jsAst.Statement buildInitialization(Element element,
                                        jsAst.Expression initialValue) {
@@ skipping 79 matching lines @@
 
   List<jsAst.Expression> buildLaziesInfo(List<VariableElement> lazies) {
     List<jsAst.Expression> laziesInfo = <jsAst.Expression>[];
     for (VariableElement element in Elements.sortedByPosition(lazies)) {
       jsAst.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) continue;
       if (compiler.enableMinification) {
-        laziesInfo.addAll([js.string(namer.globalPropertyName(element)),
-                           js.string(namer.lazyInitializerName(element)),
+        laziesInfo.addAll([js.quoteName(namer.globalPropertyName(element)),
+                           js.quoteName(namer.lazyInitializerName(element)),
                            code]);
       } else {
-        laziesInfo.addAll([js.string(namer.globalPropertyName(element)),
-                           js.string(namer.lazyInitializerName(element)),
+        laziesInfo.addAll([js.quoteName(namer.globalPropertyName(element)),
+                           js.quoteName(namer.lazyInitializerName(element)),
                            code,
                            js.string(element.name)]);
       }
     }
     return laziesInfo;
   }
 
   jsAst.Expression buildLazilyInitializedStaticField(
       VariableElement element, {String isolateProperties}) {
     jsAst.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;
     // The code only computes the initial value. We build the lazy-check
     // here:
     //   lazyInitializer(fieldName, getterName, initial, name, prototype);
     // The name is used for error reporting. The 'initial' must be a
     // closure that constructs the initial value.
     if (isolateProperties != null) {
       // This is currently only used in incremental compilation to patch
       // in new lazy values.
       return js('#(#,#,#,#,#)',
           [js(lazyInitializerName),
-           js.string(namer.globalPropertyName(element)),
-           js.string(namer.lazyInitializerName(element)),
+           js.quoteName(namer.globalPropertyName(element)),
+           js.quoteName(namer.lazyInitializerName(element)),
            code,
            js.string(element.name),
            isolateProperties]);
     }
 
     if (compiler.enableMinification) {
       return js('#(#,#,#)',
           [js(lazyInitializerName),
-           js.string(namer.globalPropertyName(element)),
-           js.string(namer.lazyInitializerName(element)),
+           js.quoteName(namer.globalPropertyName(element)),
+           js.quoteName(namer.lazyInitializerName(element)),
            code]);
     } else {
       return js('#(#,#,#,#)',
           [js(lazyInitializerName),
-           js.string(namer.globalPropertyName(element)),
-           js.string(namer.lazyInitializerName(element)),
+           js.quoteName(namer.globalPropertyName(element)),
+           js.quoteName(namer.lazyInitializerName(element)),
            code,
            js.string(element.name)]);
     }
   }
 
   jsAst.Statement buildMetadata(Program program, OutputUnit outputUnit) {
     List<jsAst.Statement> parts = <jsAst.Statement>[];
 
     jsAst.Expression types = program.metadataTypesForOutputUnit(outputUnit);
 
@@ skipping 27 matching lines @@
         if (cachedEmittedConstants.contains(constantValue)) continue;
         cachedEmittedConstants.add(constantValue);
       }
       parts.add(buildConstantInitializer(constantValue));
     }
 
     return new jsAst.Block(parts);
   }
 
   jsAst.Statement buildConstantInitializer(ConstantValue constant) {
-    String name = namer.constantName(constant);
+    jsAst.Name name = namer.constantName(constant);
     return js.statement('#.# = #',
                         [namer.globalObjectForConstant(constant), name,
                          constantInitializerExpression(constant)]);
   }
 
-  jsAst.Template get makeConstantListTemplate {
+  jsAst.Expression constantListGenerator(jsAst.Expression array) {
     // TODO(floitsch): there is no harm in caching the template.
-    return jsAst.js.uncachedExpressionTemplate(
-        '${namer.isolateName}.$makeConstListProperty(#)');
+    return js('${namer.isolateName}.#(#)', [makeConstListProperty, array]);
   }
 
   jsAst.Statement buildMakeConstantList() {
     if (task.outputContainsConstantList) {
       return js.statement(r'''
           // Functions are stored in the hidden class and not as properties in
           // the object. We never actually look at the value, but only want
           // to know if the property exists.
           #.# = function (list) {
             list.immutable$list = Array;
@@ skipping 274 matching lines @@
          ..add(js('#', namer.globalObjectFor(library)))
          ..add(initializer);
     if (library == compiler.mainApp) {
       parts.add(js.number(1));
     }
 
     return new jsAst.ArrayInitializer(parts);
   }
 
   void assemblePrecompiledConstructor(OutputUnit outputUnit,
-                                      String constructorName,
+                                      jsAst.Name constructorName,
                                       jsAst.Expression constructorAst,
                                       List<String> fields) {
     cspPrecompiledFunctionFor(outputUnit).add(
-        new jsAst.FunctionDeclaration(
-            new jsAst.VariableDeclaration(constructorName), constructorAst));
+        new jsAst.FunctionDeclaration(constructorName, constructorAst));
 
     String fieldNamesProperty = FIELD_NAMES_PROPERTY_NAME;
     bool hasIsolateSupport = compiler.hasIsolateSupport;
     jsAst.Node fieldNamesArray =
         hasIsolateSupport ? js.stringArray(fields) : new jsAst.LiteralNull();
 
     cspPrecompiledFunctionFor(outputUnit).add(js.statement(r'''
         {
           #constructorName.#typeNameProperty = #constructorNameString;
           // IE does not have a name property.
           if (!("name" in #constructorName))
               #constructorName.name = #constructorNameString;
           $desc = $collectedClasses$.#constructorName[1];
           #constructorName.prototype = $desc;
           ''' /* next string is not a raw string */ '''
           if (#hasIsolateSupport) {
             #constructorName.$fieldNamesProperty = #fieldNamesArray;
           }
         }''',
         {"constructorName": constructorName,
          "typeNameProperty": typeNameProperty,
-         "constructorNameString": js.string(constructorName),
+         "constructorNameString": js.quoteName(constructorName),
          "hasIsolateSupport": hasIsolateSupport,
          "fieldNamesArray": fieldNamesArray}));
 
     cspPrecompiledConstructorNamesFor(outputUnit).add(js('#', constructorName));
   }
 
   void assembleTypedefs(Program program) {
     Fragment mainFragment = program.mainFragment;
     OutputUnit mainOutputUnit = mainFragment.outputUnit;
 
     // Emit all required typedef declarations into the main output unit.
     // TODO(karlklose): unify required classes and typedefs to declarations
     // and have builders for each kind.
     for (TypedefElement typedef in typedefsNeededForReflection) {
       LibraryElement library = typedef.library;
       // TODO(karlklose): add a TypedefBuilder and move this code there.
       DartType type = typedef.alias;
       // TODO(zarah): reify type variables once reflection on type arguments of
       // typedefs is supported.
       jsAst.Expression typeIndex =
           task.metadataCollector.reifyType(type, ignoreTypeVariables: true);
-      ClassBuilder builder = new ClassBuilder(typedef, namer);
-      builder.addProperty(embeddedNames.TYPEDEF_TYPE_PROPERTY_NAME, typeIndex);
-      builder.addProperty(embeddedNames.TYPEDEF_PREDICATE_PROPERTY_NAME,
-                          js.boolean(true));
+      ClassBuilder builder = new ClassBuilder.forStatics(typedef, namer);
+      builder.addPropertyByName(embeddedNames.TYPEDEF_TYPE_PROPERTY_NAME,
+                                typeIndex);
+      builder.addPropertyByName(embeddedNames.TYPEDEF_PREDICATE_PROPERTY_NAME,
+                                js.boolean(true));
 
       // We can be pretty sure that the objectClass is initialized, since
       // typedefs are only emitted with reflection, which requires lots of
       // classes.
       assert(compiler.objectClass != null);
       builder.superName = namer.className(compiler.objectClass);
       jsAst.Node declaration = builder.toObjectInitializer();
-      String mangledName = namer.globalPropertyName(typedef);
+      jsAst.Name mangledName = namer.globalPropertyName(typedef);
       String reflectionName = getReflectionName(typedef, mangledName);
       getElementDescriptor(library, mainFragment)
           ..addProperty(mangledName, declaration)
-          ..addProperty("+$reflectionName", js.string(''));
+          ..addPropertyByName("+$reflectionName", js.string(''));
       // Also emit a trivial constructor for CSP mode.
-      String constructorName = mangledName;
+      jsAst.Name constructorName = mangledName;
       jsAst.Expression constructorAst = js('function() {}');
       List<String> fieldNames = [];
       assemblePrecompiledConstructor(mainOutputUnit,
                                      constructorName,
                                      constructorAst,
                                      fieldNames);
     }
   }
 
   jsAst.Statement buildGlobalObjectSetup(bool isProgramSplit) {
@@ skipping 79 matching lines @@
       }
     }
 
     return new jsAst.Block(parts);
   }
 
   jsAst.Statement buildMangledNames() {
     List<jsAst.Statement> parts = <jsAst.Statement>[];
 
     if (!mangledFieldNames.isEmpty) {
-      var keys = mangledFieldNames.keys.toList();
-      keys.sort();
+      List<jsAst.Name> keys = mangledFieldNames.keys.toList()..sort();
       var properties = [];
-      for (String key in keys) {
-        var value = js.string('${mangledFieldNames[key]}');
-        properties.add(new jsAst.Property(js.string(key), value));
+      for (jsAst.Name key in keys) {
+        var value = js.string(mangledFieldNames[key]);
+        properties.add(new jsAst.Property(key, value));
       }
 
       jsAst.Expression mangledNamesAccess =
           generateEmbeddedGlobalAccess(embeddedNames.MANGLED_NAMES);
       var map = new jsAst.ObjectInitializer(properties);
       parts.add(js.statement('# = #', [mangledNamesAccess, map]));
     }
 
     if (!mangledGlobalFieldNames.isEmpty) {
-      var keys = mangledGlobalFieldNames.keys.toList();
-      keys.sort();
-      var properties = [];
-      for (String key in keys) {
-        var value = js.string('${mangledGlobalFieldNames[key]}');
-        properties.add(new jsAst.Property(js.string(key), value));
+      List<jsAst.Name> keys = mangledGlobalFieldNames.keys.toList()
+          ..sort();
+      List<jsAst.Property> properties = <jsAst.Property>[];
+      for (jsAst.Name key in keys) {
+        jsAst.Literal value = js.string(mangledGlobalFieldNames[key]);
+        properties.add(new jsAst.Property(js.quoteName(key), value));
       }
       jsAst.Expression mangledGlobalNamesAccess =
           generateEmbeddedGlobalAccess(embeddedNames.MANGLED_GLOBAL_NAMES);
-      var map = new jsAst.ObjectInitializer(properties);
+      jsAst.ObjectInitializer map = new jsAst.ObjectInitializer(properties);
       parts.add(js.statement('# = #', [mangledGlobalNamesAccess, map]));
     }
 
     return new jsAst.Block(parts);
   }
 
   void checkEverythingEmitted(Iterable<Element> elements) {
     List<Element> pendingStatics;
     if (!compiler.hasIncrementalSupport) {
       pendingStatics =
@@ skipping 482 matching lines @@
       return '''
 
 //# sourceMappingURL=$sourceMapFileName
 ''';
     }
     return '';
   }
 
   ClassBuilder getElementDescriptor(Element element, Fragment fragment) {
     Element owner = element.library;
+    bool isClass = false;
     if (!element.isLibrary && !element.isTopLevel && !element.isNative) {
       // For static (not top level) elements, record their code in a buffer
       // specific to the class. For now, not supported for native classes and
       // native elements.
       ClassElement cls =
           element.enclosingClassOrCompilationUnit.declaration;
       if (compiler.codegenWorld.directlyInstantiatedClasses.contains(cls) &&
           !cls.isNative &&
           compiler.deferredLoadTask.outputUnitForElement(element) ==
               compiler.deferredLoadTask.outputUnitForElement(cls)) {
         owner = cls;
       }
     }
     if (owner == null) {
       compiler.internalError(element, 'Owner is null.');
     }
     return elementDescriptors
         .putIfAbsent(fragment, () => new Map<Element, ClassBuilder>())
-        .putIfAbsent(owner, () => new ClassBuilder(owner, namer));
+        .putIfAbsent(owner, () {
+          return new ClassBuilder(owner, namer, owner.isClass);
+        });
   }
 
   /// Emits support-code for deferred loading into [output].
   jsAst.Statement buildDeferredBoilerPlate(
       Map<OutputUnit, _DeferredOutputUnitHash> deferredLoadHashes) {
     List<jsAst.Statement> parts = <jsAst.Statement>[];
 
     parts.add(js.statement('''
         {
           // Function for checking if a hunk is loaded given its hash.
           #isHunkLoaded = function(hunkHash) {
             return !!$deferredInitializers[hunkHash];
           };
           #deferredInitialized = new Object(null);
           // Function for checking if a hunk is initialized given its hash.
           #isHunkInitialized = function(hunkHash) {
             return #deferredInitialized[hunkHash];
           };
           // Function for initializing a loaded hunk, given its hash.
           #initializeLoadedHunk = function(hunkHash) {
             $deferredInitializers[hunkHash](
-            $globalsHolder, ${namer.currentIsolate});
+            #globalsHolder, ${namer.currentIsolate});
             #deferredInitialized[hunkHash] = true;
           };
         }
-        ''', {"isHunkLoaded": generateEmbeddedGlobalAccess(
+        ''', {"globalsHolder": globalsHolder,
+              "isHunkLoaded": generateEmbeddedGlobalAccess(
                   embeddedNames.IS_HUNK_LOADED),
               "isHunkInitialized": generateEmbeddedGlobalAccess(
                   embeddedNames.IS_HUNK_INITIALIZED),
               "initializeLoadedHunk": generateEmbeddedGlobalAccess(
                   embeddedNames.INITIALIZE_LOADED_HUNK),
               "deferredInitialized": generateEmbeddedGlobalAccess(
                   embeddedNames.DEFERRED_INITIALIZED)}));
 
     // Write a javascript mapping from Deferred import load ids (derrived
     // from the import prefix.) to a list of lists of uris of hunks to load,
@@ skipping 52 matching lines @@
     for (Fragment fragment in program.deferredFragments) {
       OutputUnit outputUnit = fragment.outputUnit;
       jsAst.Expression libraryDescriptor = deferredAsts[outputUnit];
       List<jsAst.Statement> body = <jsAst.Statement>[];
 
       // No renaming in the top-level function to save the locals for the
       // nested context where they will be used more.
       body.add(js.comment("/* ::norenaming:: "));
 
       for (String globalObject in Namer.reservedGlobalObjectNames) {
-        body.add(js.statement('var #object = ${globalsHolder}.#object;',
-                              {'object': globalObject}));
+        body.add(js.statement('var #object = #globalsHolder.#object;',
+                              {'globalsHolder': globalsHolder,
+                               'object': globalObject}));
       }
-      body..add(js.statement('var init = ${globalsHolder}.init;'))
+      body..add(js.statement('var init = #globalsHolder.init;',
+                             {'globalsHolder': globalsHolder}))
           ..add(js.statement('var $setupProgramName = '
-                             '$globalsHolder.$setupProgramName;'))
+                             '#globalsHolder.$setupProgramName;',
+                             {'globalsHolder': globalsHolder}))
           ..add(js.statement('var ${namer.isolateName} = '
-                             '${globalsHolder}.${namer.isolateName};'));
+                             '#globalsHolder.${namer.isolateName};',
+                             {'globalsHolder': globalsHolder}));
       String typesAccess =
           generateEmbeddedGlobalAccessString(embeddedNames.TYPES);
       if (libraryDescriptor != null) {
         // The argument to reflectionDataParser is assigned to a temporary
         // 'dart' so that 'dart.' will appear as the prefix to dart methods
         // in stack traces and profile entries.
         body.add(js.statement('var dart = #', libraryDescriptor));
 
         if (compiler.useContentSecurityPolicy) {
           body.add(buildCspPrecompiledFunctionFor(outputUnit));
@@ skipping 12 matching lines @@
 
       body.add(buildCompileTimeConstants(fragment.constants,
                                          isMainFragment: false));
       body.add(buildStaticNonFinalFieldInitializations(outputUnit));
 
       List<jsAst.Statement> statements = <jsAst.Statement>[];
 
       statements
           ..add(buildGeneratedBy())
           ..add(js.statement('${deferredInitializers}.current = '
-                             """function (${globalsHolder}) {
+                             """function (#) {
                                   #
                                 }
-                             """, [body]));
+                             """, [globalsHolder, body]));
 
       result[outputUnit] = new jsAst.Program(statements);
     }
 
     return result;
   }
 
   /// Returns a map from OutputUnit to a hash of its content. The hash uniquely
   /// identifies the code of the output-unit. It does not include
   /// boilerplate JS code, like the sourcemap directives or the hash
@@ skipping 111 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }