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 20 matching lines @@
     child.prototype = new tmp();
     child.prototype.constructor = child;
   }
 }''';
 
   bool addedInheritFunction = false;
   final Namer namer;
   final NativeEmitter nativeEmitter;
   Set<ClassElement> generatedClasses;
   StringBuffer mainBuffer;
+  String isolatePrototype;
 
   CodeEmitterTask(Compiler compiler)
       : 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 180 matching lines @@
 
     classElement.forEachInstanceField(generateFieldInit,
                                       includeBackendMembers: true,
                                       includeSuperMembers: true);
   }
 
   void emitInherits(ClassElement cls, StringBuffer buffer) {
     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) {
     if (classElement == null) return;
     if (generatedClasses.contains(classElement)) return;
     generatedClasses.add(classElement);
     generateClass(classElement, buffer);
   }
 
   void generateClass(ClassElement classElement, StringBuffer buffer) {
     ensureGenerated(classElement.superclass, buffer);
 
     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);
@@ skipping 55 matching lines @@
     for (ClassElement element in compiler.universe.instantiatedClasses) {
       ensureGenerated(element, buffer);
     }
   }
 
   void emitStaticFunctionsWithNamer(StringBuffer buffer,
                                     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) {
     emitStaticFunctionsWithNamer(buffer,
                                  compiler.universe.generatedCode,
-                                 namer.isolatePropertyAccess);
+                                 namer.getName);
     emitStaticFunctionsWithNamer(buffer,
                                  compiler.universe.generatedBailoutCode,
-                                 namer.isolateBailoutPropertyAccess);
+                                 namer.getBailoutName);
   }
 
   void emitStaticFunctionGetters(StringBuffer buffer) {
     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 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);
+    String mangledName = namer.getName(closureClassElement);
     ensureGenerated(closureClassElement.superclass, buffer);
 
     // 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);
+    buffer.add(".$mangledName = function $name(self) ");
     buffer.add("{ this.self = self; };\n");
     emitInherits(closureClassElement, buffer);
 
-    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 43 matching lines @@
       compiler.withCurrentElement(element, () {
           handler.writeJsCodeForVariable(buffer, element);
         });
       buffer.add(';\n');
     }
   }
 
   void emitCompileTimeConstants(StringBuffer buffer) {
     ConstantHandler handler = compiler.constantHandler;
     List<Constant> constants = handler.getConstantsForEmission();
-    String prototype = "${namer.ISOLATE}.prototype";
     bool addedMakeConstantList = false;
     for (Constant constant in constants) {
       String name = handler.getNameForConstant(constant);
       // The name is null when the constant is already a JS constant.
       // TODO(floitsch): every constant should be registered, so that we can
       // share the ones that take up too much space (like some strings).
       if (name === null) continue;
       if (!addedMakeConstantList && constant.isList()) {
         addedMakeConstantList = true;
-        emitMakeConstantList(prototype, buffer);
+        emitMakeConstantList(buffer);
       }
-      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) {
+    buffer.add(isolatePrototype);
     buffer.add(@'''.makeConstantList = function(list) {
   list.immutable$list = true;
   list.fixed$length = true;
   return list;
 };
 ''');
   }
 
   void emitStaticFinalFieldInitializations(StringBuffer buffer) {
     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) {
     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);
+        compiler.emitter.emitDynamicFunctionGetter(buffer, attachTo, member);
       }
     }
   }
 
   void emitNoSuchMethodCalls(StringBuffer buffer) {
     // 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 96 matching lines @@
   ${mainCall};
 }
 """);
   }
 
   String assembleProgram() {
     measure(() {
       mainBuffer.add('function ${namer.ISOLATE}() {');
       emitStaticNonFinalFieldInitializations(mainBuffer);
       mainBuffer.add('}\n\n');
+      // Shorten the code by using [namer.CURRENT_ISOLATE] as temporary.
+      isolatePrototype = namer.CURRENT_ISOLATE;
+      mainBuffer.add('var $isolatePrototype = ${namer.ISOLATE}.prototype;\n');
       emitClasses(mainBuffer);
       emitStaticFunctions(mainBuffer);
       emitStaticFunctionGetters(mainBuffer);
       emitCompileTimeConstants(mainBuffer);
       emitStaticFinalFieldInitializations(mainBuffer);
-      nativeEmitter.emitDynamicDispatchMetadata();
+
+      isolatePrototype = '${namer.ISOLATE}.prototype;\n';
       mainBuffer.add(
           'var ${namer.CURRENT_ISOLATE} = new ${namer.ISOLATE}();\n');
+      nativeEmitter.emitDynamicDispatchMetadata();
       nativeEmitter.assembleCode(mainBuffer);
       emitMain(mainBuffer);
       compiler.assembledCode = mainBuffer.toString();
     });
     return compiler.assembledCode;
   }
 }