Introduce CodeBuffer as StringBuffer replacement in compiler.

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,
                            FunctionElement other)
       : super.from(name, other, other.enclosingElement);
 
   isInstanceMember() => true;
 }
 
 /**
  * Generates the code for all used classes in the program. Static fields (even
  * in classes) are ignored, since they can be treated as non-class elements.
  *
  * The code for the containing (used) methods must exist in the [:universe:].
  */
 class CodeEmitterTask extends CompilerTask {
   bool needsInheritFunction = false;
   bool needsDefineClass = false;
   bool needsClosureClass = false;
   final Namer namer;
   NativeEmitter nativeEmitter;
-  StringBuffer boundClosureBuffer;
-  StringBuffer mainBuffer;
+  CodeBuffer boundClosureBuffer;
+  CodeBuffer mainBuffer;
   /** Shorter access to [isolatePropertiesName]. Both here in the code, as
       well as in the generated code. */
   String isolateProperties;
   String classesCollector;
   final Map<int, String> boundClosureCache;
 
   final bool generateSourceMap;
   final SourceMapBuilder sourceMapBuilder;
 
   CodeEmitterTask(Compiler compiler, [bool generateSourceMap = false])
       : namer = compiler.namer,
-        boundClosureBuffer = new StringBuffer(),
-        mainBuffer = new StringBuffer(),
+        boundClosureBuffer = new CodeBuffer(),
+        mainBuffer = new CodeBuffer(),
         boundClosureCache = new Map<int, String>(),
         generateSourceMap = generateSourceMap,
         sourceMapBuilder = new SourceMapBuilder(),
         super(compiler) {
     nativeEmitter = new NativeEmitter(this);
   }
 
   String get name() => 'CodeEmitter';
 
   String get defineClassName()
@@ skipping 172 matching lines @@
   }
   str += "}\\n";
   var newIsolate = new Function(str);
   newIsolate.prototype = isolatePrototype;
   isolatePrototype.constructor = newIsolate;
   newIsolate.${namer.ISOLATE_PROPERTIES} = isolateProperties;
   return newIsolate;
 }""";
   }
 
-  void addDefineClassAndFinishClassFunctionsIfNecessary(StringBuffer buffer) {
+  void addDefineClassAndFinishClassFunctionsIfNecessary(CodeBuffer buffer) {
     if (needsDefineClass) {
       String isolate = namer.ISOLATE;
       buffer.add("$defineClassName = $defineClassFunction;\n");
       buffer.add("$pendingClassesName = {};\n");
       buffer.add("$finishClassesName = $finishClassesFunction;\n");
     }
   }
 
-  void emitFinishIsolateConstructor(StringBuffer buffer) {
+  void emitFinishIsolateConstructor(CodeBuffer buffer) {
     String name = finishIsolateConstructorName;
     String value = finishIsolateConstructorFunction;
     buffer.add("$name = $value;\n");
   }
 
-  void emitFinishIsolateConstructorInvocation(StringBuffer buffer) {
+  void emitFinishIsolateConstructorInvocation(CodeBuffer buffer) {
     String isolate = namer.ISOLATE;
     buffer.add("$isolate = $finishIsolateConstructorName($isolate);\n");
   }
 
   void addParameterStub(FunctionElement member,
                         Selector selector,
                         DefineMemberFunction defineInstanceMember) {
     FunctionSignature parameters = member.computeSignature(compiler);
     int positionalArgumentCount = selector.positionalArgumentCount;
     if (positionalArgumentCount == parameters.parameterCount) {
       assert(selector.namedArgumentCount == 0);
       return;
     }
     ConstantHandler handler = compiler.constantHandler;
     List<SourceString> names = selector.getOrderedNamedArguments();
 
     String invocationName =
         namer.instanceMethodInvocationName(member.getLibrary(), member.name,
                                            selector);
-    StringBuffer buffer = new StringBuffer();
+    CodeBuffer buffer = new CodeBuffer();
     buffer.add('function(');
 
     // The parameters that this stub takes.
     List<String> parametersBuffer = new List<String>(selector.argumentCount);
     // The arguments that will be passed to the real method.
     List<String> argumentsBuffer = new List<String>(parameters.parameterCount);
 
     // We fill the lists depending on the selector. For example,
     // take method foo:
     //    foo(a, b, [c, d]);
@@ skipping 46 matching lines @@
         } else {
           Constant value = handler.initialVariableValues[element];
           if (value == null) {
             argumentsBuffer[count] = NullConstant.JsNull;
           } else {
             if (!value.isNull()) {
               // If the value is the null constant, we should not pass it
               // down to the native method.
               indexOfLastOptionalArgumentInParameters = count;
             }
-            StringBuffer argumentBuffer = new StringBuffer();
+            CodeBuffer argumentBuffer = new CodeBuffer();
             handler.writeConstant(argumentBuffer, value);
             argumentsBuffer[count] = argumentBuffer.toString();
           }
         }
       }
       count++;
     });
     String parametersString = Strings.join(parametersBuffer, ",");
     buffer.add('$parametersString) {\n');
 
     if (member.isNative()) {
       nativeEmitter.generateParameterStub(
           member, invocationName, parametersString, argumentsBuffer,
           indexOfLastOptionalArgumentInParameters, buffer);
     } else {
       String arguments = Strings.join(argumentsBuffer, ",");
       buffer.add('  return this.${namer.getName(member)}($arguments)');
     }
     buffer.add('\n}');
-    defineInstanceMember(invocationName, buffer.toString());
+    defineInstanceMember(invocationName, buffer);
   }
 
   void addParameterStubs(FunctionElement member,
                          DefineMemberFunction defineInstanceMember) {
     Set<Selector> selectors = compiler.codegenWorld.invokedNames[member.name];
     if (selectors == null) return;
     for (Selector selector in selectors) {
       if (!selector.applies(member, compiler)) continue;
       addParameterStub(member, selector, defineInstanceMember);
     }
@@ skipping 20 matching lines @@
   void addInstanceMember(Element member,
                          DefineMemberFunction defineInstanceMember) {
     // 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;
-      CodeBlock codeBlock = compiler.codegenWorld.generatedCode[member];
-      if (codeBlock == null) return;
-      defineInstanceMember(namer.getName(member),
-                           codeBlock.code,
-                           codeBlock.sourceMappings);
-      codeBlock = compiler.codegenWorld.generatedBailoutCode[member];
-      if (codeBlock !== null) {
-        defineInstanceMember(compiler.namer.getBailoutName(member),
-                             codeBlock.code,
-                             codeBlock.sourceMappings);
+      CodeBuffer codeBuffer = compiler.codegenWorld.generatedCode[member];
+      if (codeBuffer == null) return;
+      defineInstanceMember(namer.getName(member), codeBuffer);
+      codeBuffer = compiler.codegenWorld.generatedBailoutCode[member];
+      if (codeBuffer !== null) {
+        defineInstanceMember(compiler.namer.getBailoutName(member), codeBuffer);
       }
       FunctionElement function = member;
       FunctionSignature parameters = function.computeSignature(compiler);
       if (!parameters.optionalParameters.isEmpty()) {
         addParameterStubs(member, defineInstanceMember);
       }
     } else if (member.kind === ElementKind.FIELD) {
       SourceString name = member.name;
       ClassElement cls = member.getEnclosingClass();
       if (cls.lookupSuperMember(name) !== null) {
         String fieldName = namer.instanceFieldName(cls, name);
+        CodeBuffer getterBuffer = new CodeBuffer();
+        getterBuffer.add('function() {\n  return this.$fieldName;\n }');
         defineInstanceMember(namer.getterName(cls.getLibrary(), name),
-                             'function() {\n  return this.$fieldName;\n }');
+                             getterBuffer);
+        CodeBuffer setterBuffer = new CodeBuffer();
+        setterBuffer.add('function(x) {\n  this.$fieldName = x;\n }');
         defineInstanceMember(namer.setterName(cls.getLibrary(), name),
-                             'function(x) {\n  this.$fieldName = x;\n }');
+                             setterBuffer);
       }
     } else {
       compiler.internalError('unexpected kind: "${member.kind}"',
                              element: member);
     }
     emitExtraAccessors(member, defineInstanceMember);
   }
 
-  Set<Element> emitClassFields(ClassElement classElement, StringBuffer buffer) {
+  Set<Element> emitClassFields(ClassElement classElement, CodeBuffer buffer) {
     // If the class is never instantiated we still need to set it up for
     // inheritance purposes, but we can simplify its JavaScript constructor.
     bool isInstantiated =
         compiler.codegenWorld.instantiatedClasses.contains(classElement);
 
     bool isFirstField = true;
     void addField(ClassElement enclosingClass, Element member) {
       assert(!member.isNative());
       // See if we can dynamically create getters and setters.
       // We can only generate getters and setters for [classElement] since
@@ skipping 36 matching lines @@
     // generate the field getter/setter dynamically. Since this is only
     // allowed on fields that are in [classElement] we don't need to visit
     // superclasses for non-instantiated classes.
     classElement.forEachInstanceField(
         addField,
         includeBackendMembers: true,
         includeSuperMembers: isInstantiated && !classElement.isNative());
   }
 
   void emitInstanceMembers(ClassElement classElement,
-                           StringBuffer buffer,
+                           CodeBuffer buffer,
                            bool needsLeadingComma) {
     bool needsComma = needsLeadingComma;
-    void defineInstanceMember(String name,
-                              String value,
-                              [List<SourceMappingEntry> sourceMappings]) {
+    void defineInstanceMember(String name, CodeBuffer memberBuffer) {
       if (needsComma) buffer.add(',');
       needsComma = true;
       buffer.add('\n');
       buffer.add(' $name: ');
-      sourceMapBuilder.addCodeBlock(sourceMappings, buffer.length);
-      buffer.add('$value');
+      addMappings(memberBuffer, buffer.length);
+      buffer.add(memberBuffer);
     }
 
     classElement.forEachMember(includeBackendMembers: true,
                                f: (ClassElement enclosing, Element member) {
       if (member.isInstanceMember()) {
         addInstanceMember(member, defineInstanceMember);
       }
     });
 
     generateTypeTests(classElement, (Element other) {
+      String code;
       if (nativeEmitter.requiresNativeIsCheck(other)) {
-        defineInstanceMember(namer.operatorIs(other),
-                             'function() { return true; }');
+        code = 'function() { return true; }';
       } else {
-        defineInstanceMember(namer.operatorIs(other), 'true');
+        code = 'true';
       }
+      CodeBuffer buffer = new CodeBuffer();
+      buffer.add(code);
+      defineInstanceMember(namer.operatorIs(other), buffer);
     });
 
     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(defineInstanceMember);
     }
   }
 
-  void generateClass(ClassElement classElement, StringBuffer buffer) {
+  void generateClass(ClassElement classElement, CodeBuffer 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;
     }
 
@@ skipping 33 matching lines @@
       Element element = interfaceType.element;
       if (!alreadyGenerated.contains(element) &&
           compiler.codegenWorld.isChecks.contains(element)) {
         alreadyGenerated.add(element);
         generateTypeTest(element);
       }
       generateInterfacesIsTests(element, generateTypeTest, alreadyGenerated);
     }
   }
 
-  void emitClasses(StringBuffer buffer) {
+  void emitClasses(CodeBuffer buffer) {
     Set<ClassElement> instantiatedClasses =
         compiler.codegenWorld.instantiatedClasses;
     Set<ClassElement> neededClasses =
         new Set<ClassElement>.from(instantiatedClasses);
     for (ClassElement element in instantiatedClasses) {
       for (ClassElement superclass = element.superclass;
            superclass !== null;
            superclass = superclass.superclass) {
         if (neededClasses.contains(superclass)) break;
         neededClasses.add(superclass);
@@ skipping 12 matching lines @@
     }
 
     // The closure class could have become necessary because of the generation
     // of stubs.
     ClassElement closureClass = compiler.closureClass;
     if (needsClosureClass && !instantiatedClasses.contains(closureClass)) {
       generateClass(closureClass, buffer);
     }
   }
 
-  void emitFinishClassesInvocationIfNecessary(StringBuffer buffer) {
+  void emitFinishClassesInvocationIfNecessary(CodeBuffer buffer) {
     if (needsDefineClass) {
       buffer.add("$finishClassesName($classesCollector);\n");
       // Reset the map.
       buffer.add("$classesCollector = {};\n");
     }
   }
 
-  void emitStaticFunctionsWithNamer(StringBuffer buffer,
-                                    Map<Element, CodeBlock> generatedCode,
+  void emitStaticFunctionsWithNamer(CodeBuffer buffer,
+                                    Map<Element, CodeBuffer> generatedCode,
                                     String functionNamer(Element element)) {
-    generatedCode.forEach((Element element, CodeBlock codeBlock) {
+    generatedCode.forEach((Element element, CodeBuffer functionBuffer) {
       if (!element.isInstanceMember()) {
         String functionName = functionNamer(element);
         buffer.add('$isolateProperties.$functionName = ');
-        sourceMapBuilder.addCodeBlock(codeBlock.sourceMappings, buffer.length);
-        buffer.add('${codeBlock.code};\n\n');
+        addMappings(functionBuffer, buffer.length);
+        buffer.add(functionBuffer);
+        buffer.add(';\n\n');
       }
     });
   }
 
-  void emitStaticFunctions(StringBuffer buffer) {
+  void emitStaticFunctions(CodeBuffer buffer) {
     emitStaticFunctionsWithNamer(buffer,
                                  compiler.codegenWorld.generatedCode,
                                  namer.getName);
     emitStaticFunctionsWithNamer(buffer,
                                  compiler.codegenWorld.generatedBailoutCode,
                                  namer.getBailoutName);
   }
 
-  void emitStaticFunctionGetters(StringBuffer buffer) {
+  void emitStaticFunctionGetters(CodeBuffer buffer) {
     Set<FunctionElement> functionsNeedingGetter =
         compiler.codegenWorld.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.getName(element);
       int parameterCount = element.parameterCount(compiler);
       String invocationName =
           namer.instanceMethodName(element.getLibrary(), callElement.name,
                                    parameterCount);
       String fieldAccess = '$isolateProperties.$staticName';
       buffer.add("$fieldAccess.$invocationName = $fieldAccess;\n");
-      addParameterStubs(callElement, (
-          String name, String value,
-          [List<SourceMappingEntry> sourceMappings]) {
+      addParameterStubs(callElement, (String name, CodeBuffer value) {
         buffer.add('$fieldAccess.$name = $value;\n');
       });
       // If a static function is used as a closure we need to add its name
       // in case it is used in spawnFunction.
       String fieldName = namer.STATIC_CLOSURE_NAME_NAME;
       buffer.add('$fieldAccess.$fieldName = "$staticName";\n');
     }
   }
 
   void emitDynamicFunctionGetter(FunctionElement member,
@@ skipping 51 matching lines @@
                                    callElement.name, parameterCount);
       List<String> arguments = new List<String>(parameterCount);
       for (int i = 0; i < parameterCount; i++) {
         arguments[i] = "p$i";
       }
       String joinedArgs = Strings.join(arguments, ", ");
       boundClosureBuffer.add(
           "$invocationName: function($joinedArgs) {");
       boundClosureBuffer.add(" return this.self[this.target]($joinedArgs);");
       boundClosureBuffer.add(" }");
-      addParameterStubs(callElement, (
-          String stubName, String memberValue,
-          [List<SourceMappingEntry> sourceMappings]) {
+      addParameterStubs(callElement, (String stubName, CodeBuffer memberValue) {
         boundClosureBuffer.add(',\n $stubName: $memberValue');
       });
       boundClosureBuffer.add("\n});\n");
 
       closureClass = namer.isolateAccess(closureClassElement);
 
       // Cache it.
       if (!hasOptionalParameters) {
         boundClosureCache[parameterCount] = closureClass;
       }
     }
 
     // And finally the getter.
     String getterName = namer.getterName(member.getLibrary(), member.name);
     String targetName = namer.instanceMethodName(member.getLibrary(),
                                                  member.name, parameterCount);
-    defineInstanceMember(
-        getterName,
+    CodeBuffer getterBuffer = new CodeBuffer();
+    getterBuffer.add(
         "function() { return new $closureClass(this, '$targetName'); }");
+    defineInstanceMember(getterName, getterBuffer);
   }
 
   void emitCallStubForGetter(Element member,
                              Set<Selector> selectors,
                              DefineMemberFunction defineInstanceMember) {
     String getter;
     if (member.kind == ElementKind.GETTER) {
       getter = "this.${namer.getterName(member.getLibrary(), member.name)}()";
     } else {
       String name = namer.instanceFieldName(member.getEnclosingClass(),
                                             member.name);
       getter = "this.$name";
     }
     for (Selector selector in selectors) {
       if (selector.applies(member, compiler)) {
         String invocationName =
             namer.instanceMethodInvocationName(member.getLibrary(), member.name,
                                                selector);
         SourceString callName = namer.CLOSURE_INVOCATION_NAME;
         String closureCallName =
             namer.instanceMethodInvocationName(member.getLibrary(), callName,
                                                selector);
         List<String> arguments = <String>[];
         for (int i = 0; i < selector.argumentCount; i++) {
           arguments.add("arg$i");
         }
         String joined = Strings.join(arguments, ", ");
-        defineInstanceMember(
-            invocationName,
+        CodeBuffer getterBuffer = new CodeBuffer();
+        getterBuffer.add(
             "function($joined) { return $getter.$closureCallName($joined); }");
+        defineInstanceMember(invocationName, getterBuffer);
       }
     }
   }
 
-  void emitStaticNonFinalFieldInitializations(StringBuffer buffer) {
+  void emitStaticNonFinalFieldInitializations(CodeBuffer buffer) {
     ConstantHandler handler = compiler.constantHandler;
     List<VariableElement> staticNonFinalFields =
         handler.getStaticNonFinalFieldsForEmission();
     for (Element element in staticNonFinalFields) {
       buffer.add('$isolateProperties.${namer.getName(element)} = ');
       compiler.withCurrentElement(element, () {
           handler.writeJsCodeForVariable(buffer, element);
         });
       buffer.add(';\n');
     }
   }
 
-  void emitCompileTimeConstants(StringBuffer buffer) {
+  void emitCompileTimeConstants(CodeBuffer buffer) {
     ConstantHandler handler = compiler.constantHandler;
     List<Constant> constants = handler.getConstantsForEmission();
     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(buffer);
       }
       buffer.add('$isolateProperties.$name = ');
       handler.writeJsCode(buffer, constant);
       buffer.add(';\n');
     }
   }
 
-  void emitMakeConstantList(StringBuffer buffer) {
+  void emitMakeConstantList(CodeBuffer buffer) {
     buffer.add(namer.ISOLATE);
     buffer.add(@'''.makeConstantList = function(list) {
   list.immutable$list = true;
   list.fixed$length = true;
   return list;
 };
 ''');
   }
 
   void emitExtraAccessors(Element member,
@@ skipping 15 matching lines @@
     if (compiler.codegenWorld.instantiatedClasses.isEmpty()) return;
 
     ClassElement objectClass =
         compiler.coreLibrary.find(const SourceString('Object'));
     String runtimeObjectPrototype =
         '${namer.isolateAccess(objectClass)}.prototype';
     String noSuchMethodName =
         namer.instanceMethodName(null, Compiler.NO_SUCH_METHOD, 2);
     Collection<LibraryElement> libraries = compiler.libraries.getValues();
 
-    String generateMethod(String methodName, Selector selector) {
-      StringBuffer buffer = new StringBuffer();
+    CodeBuffer generateMethod(String methodName, Selector selector) {
+      CodeBuffer buffer = new CodeBuffer();
       buffer.add('function');
-      StringBuffer args = new StringBuffer();
+      CodeBuffer args = new CodeBuffer();
       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("      : $runtimeObjectPrototype.$noSuchMethodName.call(");
       buffer.add("this, '$methodName', [$args])\n");
       buffer.add('}');
-      return buffer.toString();
+      return buffer;
     }
 
     compiler.codegenWorld.invokedNames.forEach((SourceString methodName,
                                             Set<Selector> selectors) {
       if (objectClass.lookupLocalMember(methodName) === null
           && methodName != Elements.OPERATOR_EQUALS) {
         for (Selector selector in selectors) {
           if (methodName.isPrivate()) {
             for (LibraryElement lib in libraries) {
               String jsName =
                 namer.instanceMethodInvocationName(lib, methodName, selector);
-              String method =
+              CodeBuffer method =
                   generateMethod(methodName.slowToString(), selector);
               defineInstanceMember(jsName, method);
             }
           } else {
             String jsName =
               namer.instanceMethodInvocationName(null, methodName, selector);
-            String method = generateMethod(methodName.slowToString(), selector);
+            CodeBuffer method = generateMethod(methodName.slowToString(),
+                                               selector);
             defineInstanceMember(jsName, method);
           }
         }
       }
     });
 
     compiler.codegenWorld.invokedGetters.forEach((SourceString getterName,
                                               Set<Selector> selectors) {
       if (getterName.isPrivate()) {
         for (LibraryElement lib in libraries) {
           String jsName = namer.getterName(lib, getterName);
-          String method = generateMethod('get ${getterName.slowToString()}',
-                                         Selector.GETTER);
+          CodeBuffer method = generateMethod('get ${getterName.slowToString()}',
+                                             Selector.GETTER);
           defineInstanceMember(jsName, method);
         }
       } else {
         String jsName = namer.getterName(null, getterName);
-        String method = generateMethod('get ${getterName.slowToString()}',
-                                       Selector.GETTER);
+        CodeBuffer method = generateMethod('get ${getterName.slowToString()}',
+                                           Selector.GETTER);
         defineInstanceMember(jsName, method);
       }
     });
 
     compiler.codegenWorld.invokedSetters.forEach((SourceString setterName,
                                               Set<Selector> selectors) {
       if (setterName.isPrivate()) {
         for (LibraryElement lib in libraries) {
           String jsName = namer.setterName(lib, setterName);
-          String method = generateMethod('set ${setterName.slowToString()}',
-                                         Selector.SETTER);
+          CodeBuffer method = generateMethod('set ${setterName.slowToString()}',
+                                             Selector.SETTER);
           defineInstanceMember(jsName, method);
         }
       } else {
         String jsName = namer.setterName(null, setterName);
-        String method = generateMethod('set ${setterName.slowToString()}',
-                                       Selector.SETTER);
+        CodeBuffer method = generateMethod('set ${setterName.slowToString()}',
+                                           Selector.SETTER);
         defineInstanceMember(jsName, method);
       }
     });
   }
 
-  String buildIsolateSetup(StringBuffer buffer,
+  String buildIsolateSetup(CodeBuffer buffer,
                            Element appMain,
                            Element isolateMain) {
     String mainAccess = "${namer.isolateAccess(appMain)}";
     String currentIsolate = "${namer.CURRENT_ISOLATE}";
     String mainEnsureGetter = '';
     // Since we pass the closurized version of the main method to
     // the isolate method, we must make sure that it exists.
     if (!compiler.codegenWorld.staticFunctionsNeedingGetter.contains(appMain)) {
       String invocationName =
           "${namer.closureInvocationName(Selector.INVOCATION_0)}";
@@ skipping 17 matching lines @@
 }
 function \$setGlobals(context) {
   $currentIsolate = context.isolateStatics;
   \$globalThis = $currentIsolate;
 }
 $mainEnsureGetter
 """);
   return "${namer.isolateAccess(isolateMain)}($mainAccess)";
   }
 
-  emitMain(StringBuffer buffer) {
+  emitMain(CodeBuffer buffer) {
     if (compiler.isMockCompilation) return;
     Element main = compiler.mainApp.find(Compiler.MAIN);
     String mainCall = null;
     if (compiler.isolateLibrary != null) {
       Element isolateMain =
         compiler.isolateLibrary.find(Compiler.START_ROOT_ISOLATE);
       mainCall = buildIsolateSetup(buffer, main, isolateMain);
     } else {
       mainCall = '${namer.isolateAccess(main)}()';
     }
@@ skipping 61 matching lines @@
         String sourceMap = sourceMapBuilder.build(compiledFile);
         // TODO(podivilov): We should find a better way to return source maps to
         // compiler. Using diagnostic handler for that purpose is a temporary
         // hack.
         compiler.reportDiagnostic(
             null, sourceMap, new api.Diagnostic(-1, 'source map'));
       }
     });
     return compiler.assembledCode;
   }
+
+  void addMappings(CodeBuffer buffer, int bufferOffset) {
+    buffer.forEachSourceLocation((Element element, Token token, int offset) {
+      SourceFile sourceFile = element.getCompilationUnit().script.file;
+      String sourceName = null;
+      if (token.kind === IDENTIFIER_TOKEN) {
+        sourceName = token.slowToString();
+      }
+      int totalOffset = bufferOffset + offset;
+      sourceMapBuilder.addMapping(
+          sourceFile, token.charOffset, sourceName, totalOffset);
+    });
+  }
 }
 
-typedef void DefineMemberFunction(String invocationName,
-                                  String definition,
-                                  [List<SourceMappingEntry> sourceMappings]);
+typedef void DefineMemberFunction(String invocationName, CodeBuffer definition);