Reduce size by emitting $.foo instead of Isolate.prototype.foo.

lib/compiler/implementation/emitter.dart

 // Copyright (c) 2012, 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.
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
 class ClosureInvocationElement extends FunctionElement {
   ClosureInvocationElement(SourceString name,
@@ skipping 32 matching lines @@
       : namer = compiler.namer,
         nativeEmitter = new NativeEmitter(compiler),
         generatedClasses = new Set<ClassElement>(),
         mainBuffer = new StringBuffer(),
         super(compiler);
 
   String get name() => 'CodeEmitter';
 
   String get inheritsName() => '${namer.ISOLATE}.\$inherits';
 
-  String get objectClassName() {
-    ClassElement objectClass =
-        compiler.coreLibrary.find(const SourceString('Object'));
-    return namer.isolatePropertyAccess(objectClass);
-  }
-
   void addInheritFunctionIfNecessary() {
     if (addedInheritFunction) return;
     addedInheritFunction = true;
     mainBuffer.add('$inheritsName = ');
     mainBuffer.add(INHERIT_FUNCTION);
     mainBuffer.add(';\n');
   }
 
   void addParameterStub(FunctionElement member,
                         String attachTo(String invocationName),
@@ skipping 109 matching lines @@
     FunctionParameters parameters = member.computeParameters(compiler);
     for (Selector selector in selectors) {
       if (!selector.applies(parameters)) continue;
       addParameterStub(member, attachTo, buffer, selector, isNative);
     }
   }
 
   void addInstanceMember(Element member,
                          String attachTo(String name),
                          StringBuffer buffer,
+                         String isolatePrototype,
                          [bool isNative = false]) {
     // TODO(floitsch): we don't need to deal with members of
     // uninstantiated classes, that have been overwritten by subclasses.
 
     if (member.kind === ElementKind.FUNCTION
         || member.kind === ElementKind.GENERATIVE_CONSTRUCTOR_BODY
         || member.kind === ElementKind.GETTER
         || member.kind === ElementKind.SETTER) {
       if (member.modifiers !== null && member.modifiers.isAbstract()) return;
       String codeBlock = compiler.universe.generatedCode[member];
@@ skipping 24 matching lines @@
         String getterName = namer.getterName(member.getLibrary(), member.name);
         String name =
             isNative ? member.name.slowToString() : namer.getName(member);
         buffer.add('${attachTo(getterName)} = function(){\n');
         buffer.add('  return this.$name;\n};\n');
       }
     } else {
       compiler.internalError('unexpected kind: "${member.kind}"',
                              element: member);
     }
-    emitExtraAccessors(member, attachTo, buffer);
+    emitExtraAccessors(member, attachTo, buffer, isolatePrototype);
   }
 
   bool generateFieldInits(ClassElement classElement,
                           StringBuffer argumentsBuffer,
                           StringBuffer bodyBuffer) {
     bool isFirst = true;
     void generateFieldInit(ClassElement enclosingClass, Element member) {
       // TODO(floitsch): make sure there are no name clashes.
       String className = namer.getName(enclosingClass);
       if (!isFirst) argumentsBuffer.add(', ');
       isFirst = false;
       String memberName = namer.instanceFieldName(member.getLibrary(),
                                                   member.name);
       argumentsBuffer.add('${className}_$memberName');
       bodyBuffer.add('  this.$memberName = ${className}_$memberName;\n');
     }
 
     classElement.forEachInstanceField(generateFieldInit,
                                       includeBackendMembers: true,
                                       includeSuperMembers: true);
   }
 
-  void emitInherits(ClassElement cls, StringBuffer buffer) {
+  void emitInherits(ClassElement cls,
+                    StringBuffer buffer,
+                    String isolatePrototype) {
     ClassElement superclass = cls.superclass;
     if (superclass !== null) {
       addInheritFunctionIfNecessary();
-      String className = namer.isolatePropertyAccess(cls);
-      String superName = namer.isolatePropertyAccess(superclass);
-      buffer.add('${inheritsName}($className, $superName);\n');
+      String className = namer.getName(cls);
+      String superName = namer.getName(superclass);
+      buffer.add('${inheritsName}($isolatePrototype.$className, ');
+      buffer.add('$isolatePrototype.$superName);\n');
     }
   }
 
-  void ensureGenerated(ClassElement classElement, StringBuffer buffer) {
+  void ensureGenerated(ClassElement classElement,
+                       StringBuffer buffer,
+                       String isolatePrototype) {
     if (classElement == null) return;
     if (generatedClasses.contains(classElement)) return;
     generatedClasses.add(classElement);
-    generateClass(classElement, buffer);
+    generateClass(classElement, buffer, isolatePrototype);
   }
 
-  void generateClass(ClassElement classElement, StringBuffer buffer) {
-    ensureGenerated(classElement.superclass, buffer);
+  void generateClass(ClassElement classElement,
+                     StringBuffer buffer,
+                     String isolatePrototype) {
+    ensureGenerated(classElement.superclass, buffer, isolatePrototype);
 
     if (classElement.isNative()) {
       nativeEmitter.generateNativeClass(classElement);
       return;
     } else {
       // TODO(ngeoffray): Instead of switching between buffer, we
       // should create code sections, and decide where to emit them at
       // the end.
       buffer = mainBuffer;
     }
 
-    String className = namer.isolatePropertyAccess(classElement);
+    String className = '${isolatePrototype}.${namer.getName(classElement)}';
     String constructorName = namer.safeName(classElement.name.slowToString());
     buffer.add('$className = function $constructorName(');
     StringBuffer bodyBuffer = new StringBuffer();
     // If the class is never instantiated we still need to set it up for
     // inheritance purposes, but we can leave its JavaScript constructor empty.
     if (compiler.universe.instantiatedClasses.contains(classElement)) {
       generateFieldInits(classElement, buffer, bodyBuffer);
     }
     buffer.add(') {\n');
     buffer.add(bodyBuffer);
     buffer.add('};\n');
 
-    emitInherits(classElement, buffer);
+    emitInherits(classElement, buffer, isolatePrototype);
 
     String attachTo(String name) => '$className.prototype.$name';
     
     classElement.forEachMember(includeBackendMembers: true,
                                f: (ClassElement enclosing, Element member) {
       if (member.isInstanceMember()) {
-        addInstanceMember(member, attachTo, buffer);
+        addInstanceMember(member, attachTo, buffer, isolatePrototype);
       }
     });
 
     generateTypeTests(classElement, (Element other) {
       buffer.add('${attachTo(namer.operatorIs(other))} = ');
       if (nativeEmitter.requiresNativeIsCheck(other)) {
         buffer.add('function() { return true; }');
       } else {
         buffer.add('true');
       }
       buffer.add(';\n');
     });
 
     if (classElement === compiler.objectClass && compiler.enabledNoSuchMethod) {
       // Emit the noSuchMethods on the Object prototype now, so that
       // the code in the dynamicMethod can find them. Note that the
       // code in dynamicMethod is invoked before analyzing the full JS
       // script.
-      emitNoSuchMethodCalls(buffer);
+      emitNoSuchMethodCalls(buffer, isolatePrototype);
     }
   }
 
   void generateTypeTests(ClassElement cls,
                          void generateTypeTest(ClassElement element)) {
     if (compiler.universe.isChecks.contains(cls)) {
       generateTypeTest(cls);
     }
     generateInterfacesIsTests(cls, generateTypeTest, new Set<Element>());
   }
 
   void generateInterfacesIsTests(ClassElement cls,
                                  void generateTypeTest(ClassElement element),
                                  Set<Element> alreadyGenerated) {
     for (Type interfaceType in cls.interfaces) {
       Element element = interfaceType.element;
       if (!alreadyGenerated.contains(element) &&
           compiler.universe.isChecks.contains(element)) {
         alreadyGenerated.add(element);
         generateTypeTest(element);
       }
       generateInterfacesIsTests(element, generateTypeTest, alreadyGenerated);
     }
   }
 
-  void emitClasses(StringBuffer buffer) {
+  void emitClasses(StringBuffer buffer, String isolatePrototype) {
     for (ClassElement element in compiler.universe.instantiatedClasses) {
-      ensureGenerated(element, buffer);
+      ensureGenerated(element, buffer, isolatePrototype);
     }
   }
 
   void emitStaticFunctionsWithNamer(StringBuffer buffer,
+                                    String isolatePrototype,
                                     Map<Element, String> generatedCode,
                                     String functionNamer(Element element)) {
     generatedCode.forEach((Element element, String codeBlock) {
       if (!element.isInstanceMember()) {
-        buffer.add('${functionNamer(element)} = ');
+        buffer.add(isolatePrototype);
+        buffer.add('.${functionNamer(element)} = ');
         buffer.add(codeBlock);
         buffer.add(';\n\n');
       }
     });
   }
 
-  void emitStaticFunctions(StringBuffer buffer) {
+  void emitStaticFunctions(StringBuffer buffer, String isolatePrototype) {
     emitStaticFunctionsWithNamer(buffer,
+                                 isolatePrototype,
                                  compiler.universe.generatedCode,
-                                 namer.isolatePropertyAccess);
+                                 namer.getName);
     emitStaticFunctionsWithNamer(buffer,
+                                 isolatePrototype,
                                  compiler.universe.generatedBailoutCode,
-                                 namer.isolateBailoutPropertyAccess);
+                                 namer.getBailoutName);
   }
 
-  void emitStaticFunctionGetters(StringBuffer buffer) {
+  void emitStaticFunctionGetters(StringBuffer buffer, String isolatePrototype) {
     Set<FunctionElement> functionsNeedingGetter =
         compiler.universe.staticFunctionsNeedingGetter;
     for (FunctionElement element in functionsNeedingGetter) {
       // The static function does not have the correct name. Since
       // [addParameterStubs] use the name to create its stubs we simply
       // create a fake element with the correct name.
       // Note: the callElement will not have any enclosingElement.
       FunctionElement callElement =
           new ClosureInvocationElement(Namer.CLOSURE_INVOCATION_NAME, element);
-      String staticName = namer.isolatePropertyAccess(element);
+      String staticName = namer.getName(element);
       int parameterCount = element.parameterCount(compiler);
       String invocationName =
           namer.instanceMethodName(element.getLibrary(), callElement.name,
                                    parameterCount);
-      buffer.add("$staticName.$invocationName = $staticName;\n");
-      addParameterStubs(callElement, (name) => '$staticName.$name', buffer);
+      buffer.add(isolatePrototype);
+      buffer.add(".$staticName.$invocationName = ");
+      buffer.add(isolatePrototype);
+      buffer.add(".$staticName;\n");
+      addParameterStubs(callElement,
+                        (name) => '$isolatePrototype.$staticName.$name',
+                        buffer);
     }
   }
 
   void emitDynamicFunctionGetter(StringBuffer buffer,
+                                 String isolatePrototype,
                                  String attachTo(String invocationName),
                                  FunctionElement member) {
     // For every method that has the same name as a property-get we create a
     // getter that returns a bound closure. Say we have a class 'A' with method
     // 'foo' and somewhere in the code there is a dynamic property get of
     // 'foo'. Then we generate the following code (in pseudo Dart):
     //
     // class A {
     //    foo(x, y, z) { ... } // Original function.
     //    get foo() { return new BoundClosure499(this); }
     // }
     // class BoundClosure499 extends Closure {
     //   var self;
     //   BoundClosure499(this.self);
     //   $call3(x, y, z) { return self.foo(x, y, z); }
     // }
 
     // TODO(floitsch): share the closure classes with other classes
     // if they share methods with the same signature.
 
     // The closure class.
     SourceString name = const SourceString("BoundClosure");
     ClassElement closureClassElement =
         new ClosureClassElement(compiler, member.getCompilationUnit());
-    String isolateAccess = namer.isolatePropertyAccess(closureClassElement);
-    ensureGenerated(closureClassElement.superclass, buffer);
+    String mangledName = namer.getName(closureClassElement);
+    ensureGenerated(closureClassElement.superclass, buffer, isolatePrototype);
 
     // Define the constructor with a name so that Object.toString can
     // find the class name of the closure class.
-    buffer.add("$isolateAccess = function $name(self) ");
+    buffer.add(isolatePrototype);

[Lasse Reichstein Nielsen, 2012/04/12 09:45:32]

We should add an "<<" operator to StringBuffer :)

[floitsch, 2012/04/12 11:26:56]

hehe.

+    buffer.add(".$mangledName = function $name(self) ");
     buffer.add("{ this.self = self; };\n");
-    emitInherits(closureClassElement, buffer);
+    emitInherits(closureClassElement, buffer, isolatePrototype);
 
-    String prototype = "$isolateAccess.prototype";
+    String prototype = "$isolatePrototype.$mangledName.prototype";
 
     // Now add the methods on the closure class. The instance method does not
     // have the correct name. Since [addParameterStubs] use the name to create
     // its stubs we simply create a fake element with the correct name.
     // Note: the callElement will not have any enclosingElement.
     FunctionElement callElement =
         new ClosureInvocationElement(Namer.CLOSURE_INVOCATION_NAME, member);
 
     int parameterCount = member.parameterCount(compiler);
     String invocationName =
         namer.instanceMethodName(member.getLibrary(),
                                  callElement.name, parameterCount);
     String targetName = namer.instanceMethodName(member.getLibrary(),
                                                  member.name, parameterCount);
     List<String> arguments = new List<String>(parameterCount);
     for (int i = 0; i < parameterCount; i++) {
       arguments[i] = "arg$i";
     }
     String joinedArgs = Strings.join(arguments, ", ");
     buffer.add("$prototype.$invocationName = function($joinedArgs) {\n");
     buffer.add("  return this.self.$targetName($joinedArgs);\n");
     buffer.add("};\n");
     addParameterStubs(callElement,
-                      (invocationName) => '$prototype.$invocationName',
+                      (stubName) => '$prototype.$stubName',
                       buffer);
 
     // And finally the getter.
     String getterName = namer.getterName(member.getLibrary(), member.name);
     String closureClass = namer.isolateAccess(closureClassElement);
     buffer.add("${attachTo(getterName)} = function() {\n");
     buffer.add("  return new $closureClass(this);\n");
     buffer.add("};\n");
   }
 
@@ skipping 40 matching lines @@
     if (!staticNonFinalFields.isEmpty()) buffer.add('\n');
     for (Element element in staticNonFinalFields) {
       buffer.add('  this.${namer.getName(element)} = ');
       compiler.withCurrentElement(element, () {
           handler.writeJsCodeForVariable(buffer, element);
         });
       buffer.add(';\n');
     }
   }
 
-  void emitCompileTimeConstants(StringBuffer buffer) {
+  void emitCompileTimeConstants(StringBuffer buffer, String isolatePrototype) {
     ConstantHandler handler = compiler.constantHandler;
     List<Constant> constants = handler.getConstantsForEmission();
-    String prototype = "${namer.ISOLATE}.prototype";
     bool addedMakeConstantList = false;
     for (Constant constant in constants) {
       if (!addedMakeConstantList && constant.isList()) {
         addedMakeConstantList = true;
-        emitMakeConstantList(prototype, buffer);
+        emitMakeConstantList(buffer, isolatePrototype);
       }
       String name = handler.getNameForConstant(constant);
-      buffer.add('$prototype.$name = ');
+      buffer.add('$isolatePrototype.$name = ');
       handler.writeJsCode(buffer, constant);
       buffer.add(';\n');
     }
   }
 
-  void emitMakeConstantList(String prototype, StringBuffer buffer) {
-    buffer.add(prototype);
+  void emitMakeConstantList(StringBuffer buffer, String isolatePrototype) {
+    buffer.add(isolatePrototype);
     buffer.add(@'''.makeConstantList = function(list) {
   list.immutable$list = true;
   list.fixed$length = true;
   return list;
 };
 ''');
   }
 
-  void emitStaticFinalFieldInitializations(StringBuffer buffer) {
+  void emitStaticFinalFieldInitializations(StringBuffer buffer,
+                                           String isolatePrototype) {
     ConstantHandler handler = compiler.constantHandler;
     List<VariableElement> staticFinalFields =
         handler.getStaticFinalFieldsForEmission();
     for (VariableElement element in staticFinalFields) {
-      buffer.add('${namer.isolatePropertyAccess(element)} = ');
+      buffer.add(isolatePrototype);
+      buffer.add('.${namer.getName(element)} = ');
       compiler.withCurrentElement(element, () {
           handler.writeJsCodeForVariable(buffer, element);
         });
       buffer.add(';\n');
     }
   }
 
   void emitExtraAccessors(Element member,
                           String attachTo(String name),
-                          StringBuffer buffer) {
+                          StringBuffer buffer,
+                          String isolatePrototype) {
     if (member.kind == ElementKind.GETTER || member.kind == ElementKind.FIELD) {
       Set<Selector> selectors = compiler.universe.invokedNames[member.name];
       if (selectors !== null && !selectors.isEmpty()) {
         compiler.emitter.emitCallStubForGetter(
             buffer, attachTo, member, selectors);
       }
     } else if (member.kind == ElementKind.FUNCTION) {
       if (compiler.universe.invokedGetters.contains(member.name)) {
         compiler.emitter.emitDynamicFunctionGetter(
-            buffer, attachTo, member);
+            buffer, isolatePrototype, attachTo, member);
       }
     }
   }
 
-  void emitNoSuchMethodCalls(StringBuffer buffer) {
+  void emitNoSuchMethodCalls(StringBuffer buffer, String isolatePrototype) {

[Lasse Reichstein Nielsen, 2012/04/12 09:45:32]

Instead of passing isolatePrototype everywhere, could you make it a mutable
field on the emitter object? It seems it only needs to change its name once, and
not have different values interchangably.

[floitsch, 2012/04/12 11:26:56]

Done.

     // Do not generate no such method calls if there is no class.
     if (compiler.universe.instantiatedClasses.isEmpty()) return;
 
     ClassElement objectClass =
         compiler.coreLibrary.find(const SourceString('Object'));
-    String className = namer.isolatePropertyAccess(objectClass);
-    String prototype = '$className.prototype';
+    String className = namer.getName(objectClass);
+    String prototype = '$isolatePrototype.$className.prototype';
+    String runtimeObjectPrototype =
+        '${namer.isolateAccess(objectClass)}.prototype';
     String noSuchMethodName =
         namer.instanceMethodName(null, Compiler.NO_SUCH_METHOD, 2);
     Collection<LibraryElement> libraries =
         compiler.universe.libraries.getValues();
 
     void generateMethod(String methodName, String jsName, Selector selector) {
       buffer.add('$prototype.$jsName = function');
       StringBuffer args = new StringBuffer();
       for (int i = 0; i < selector.argumentCount; i++) {
         if (i != 0) args.add(', ');
         args.add('arg$i');
       }
       // We need to check if the object has a noSuchMethod. If not, it
       // means the object is a native object, and we can just call our
       // generic noSuchMethod. Note that when calling this method, the
       // 'this' object is not a Dart object.
       buffer.add(' ($args) {\n');
       buffer.add('  return this.$noSuchMethodName\n');
       buffer.add("      ? this.$noSuchMethodName('$methodName', [$args])\n");
-      buffer.add("      : $objectClassName.prototype.$noSuchMethodName.call(");
+      buffer.add("      : $runtimeObjectPrototype.$noSuchMethodName.call(");
       buffer.add("this, '$methodName', [$args])\n");
       buffer.add('}\n');
     }
 
     compiler.universe.invokedNames.forEach((SourceString methodName,
                                             Set<Selector> selectors) {
       if (objectClass.lookupLocalMember(methodName) === null
           && methodName != Namer.OPERATOR_EQUALS) {
         for (Selector selector in selectors) {
           if (methodName.isPrivate()) {
@@ skipping 95 matching lines @@
 } else {
   ${mainCall};
 }
 """);
   }
 
   String assembleProgram() {
     measure(() {
       mainBuffer.add('function ${namer.ISOLATE}() {');
       emitStaticNonFinalFieldInitializations(mainBuffer);
-      mainBuffer.add('}\n\n');
-      emitClasses(mainBuffer);
-      emitStaticFunctions(mainBuffer);
-      emitStaticFunctionGetters(mainBuffer);
-      emitCompileTimeConstants(mainBuffer);
-      emitStaticFinalFieldInitializations(mainBuffer);
-      nativeEmitter.emitDynamicDispatchMetadata();
+      mainBuffer.add('};\n\n');
+      // Shorten the code by using [namer.CURRENT_ISOLATE] as temporary.
+      String isolatePrototype = namer.CURRENT_ISOLATE;
+      mainBuffer.add('var $isolatePrototype = ${namer.ISOLATE}.prototype;\n');
+      emitClasses(mainBuffer, isolatePrototype);
+      emitStaticFunctions(mainBuffer, isolatePrototype);
+      emitStaticFunctionGetters(mainBuffer, isolatePrototype);
+      emitCompileTimeConstants(mainBuffer, isolatePrototype);
+      emitStaticFinalFieldInitializations(mainBuffer, isolatePrototype);
+
       mainBuffer.add(
           'var ${namer.CURRENT_ISOLATE} = new ${namer.ISOLATE}();\n');
+      nativeEmitter.emitDynamicDispatchMetadata();
       nativeEmitter.assembleCode(mainBuffer);
       emitMain(mainBuffer);
       compiler.assembledCode = mainBuffer.toString();
     });
     return compiler.assembledCode;
   }
 }