Associate partial source map with each code block in Universe.generatedCode.

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 17 matching lines @@
   NativeEmitter nativeEmitter;
   StringBuffer boundClosureBuffer;
   StringBuffer 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 List<SourceMappingEntry> sourceMappings;
+  final SourceMapBuilder sourceMapBuilder;
 
   CodeEmitterTask(Compiler compiler, [bool generateSourceMap = false])
       : namer = compiler.namer,
         boundClosureBuffer = new StringBuffer(),
         mainBuffer = new StringBuffer(),
         boundClosureCache = new Map<int, String>(),
         generateSourceMap = generateSourceMap,
-        sourceMappings = new List<SourceMappingEntry>(),
+        sourceMapBuilder = new SourceMapBuilder(),
         super(compiler) {
     nativeEmitter = new NativeEmitter(this);
   }
 
   String get name() => 'CodeEmitter';
 
   String get defineClassName()
       => '${namer.ISOLATE}.\$defineClass';
   String get finishClassesName()
       => '${namer.ISOLATE}.\$finishClasses';
@@ skipping 191 matching lines @@
     buffer.add("$name = $value;\n");
   }
 
   void emitFinishIsolateConstructorInvocation(StringBuffer buffer) {
     String isolate = namer.ISOLATE;
     buffer.add("$isolate = $finishIsolateConstructorName($isolate);\n");
   }
 
   void addParameterStub(FunctionElement member,
                         Selector selector,
-                        void defineInstanceMember(String invocationName,
-                                                  String definition)) {
+                        DefineInstanceMember 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 =
@@ skipping 83 matching lines @@
           indexOfLastOptionalArgumentInParameters, buffer);
     } else {
       String arguments = Strings.join(argumentsBuffer, ",");
       buffer.add('  return this.${namer.getName(member)}($arguments)');
     }
     buffer.add('\n}');
     defineInstanceMember(invocationName, buffer.toString());
   }
 
   void addParameterStubs(FunctionElement member,
-                         void defineInstanceMember(String invocationName,
-                                                   String definition)) {
+                         DefineInstanceMember 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);
     }
   }
 
   bool instanceFieldNeedsGetter(Element member) {
     assert(member.kind === ElementKind.FIELD);
     return compiler.codegenWorld.hasInvokedGetter(member, compiler);
   }
 
   bool instanceFieldNeedsSetter(Element member) {
     assert(member.kind === ElementKind.FIELD);
     return (member.modifiers === null || !member.modifiers.isFinal())
         && compiler.codegenWorld.hasInvokedSetter(member, compiler);
   }
 
   String compiledFieldName(Element member) {
     assert(member.kind === ElementKind.FIELD);
     return member.isNative()
         ? member.name.slowToString()
         : namer.getName(member);
   }
 
   void addInstanceMember(Element member,
-                         void defineInstanceMember(String invocationName,
-                                                   String definition)) {
+                         DefineInstanceMember 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;
-      String codeBlock = compiler.codegenWorld.generatedCode[member];
+      CodeBlock codeBlock = compiler.codegenWorld.generatedCode[member];
       if (codeBlock == null) return;
-      defineInstanceMember(namer.getName(member), codeBlock);
+      defineInstanceMember(namer.getName(member),
+                           codeBlock.code,
+                           codeBlock.sourceMappings);
       codeBlock = compiler.codegenWorld.generatedBailoutCode[member];
       if (codeBlock !== null) {
-        defineInstanceMember(compiler.namer.getBailoutName(member), codeBlock);
+        defineInstanceMember(compiler.namer.getBailoutName(member),
+                             codeBlock.code,
+                             codeBlock.sourceMappings);
       }
       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) {
@@ skipping 63 matching lines @@
     classElement.forEachInstanceField(
         addField,
         includeBackendMembers: true,
         includeSuperMembers: isInstantiated && !classElement.isNative());
   }
 
   void emitInstanceMembers(ClassElement classElement,
                            StringBuffer buffer,
                            bool needsLeadingComma) {
     bool needsComma = needsLeadingComma;
-    void defineInstanceMember(String name, String value) {
+    void defineInstanceMember(String name,
+                              String value,
+                              [List<SourceMappingEntry> sourceMappings]) {
       if (needsComma) buffer.add(',');
       needsComma = true;
       buffer.add('\n');
-      buffer.add(' $name: $value');
+      buffer.add(' $name: ');
+      sourceMapBuilder.addCodeBlock(sourceMappings, buffer.length);
+      buffer.add('$value');
     }
 
     classElement.forEachMember(includeBackendMembers: true,
                                f: (ClassElement enclosing, Element member) {
       if (member.isInstanceMember()) {
         addInstanceMember(member, defineInstanceMember);
       }
     });
 
     generateTypeTests(classElement, (Element other) {
@@ skipping 103 matching lines @@
 
   void emitFinishClassesInvocationIfNecessary(StringBuffer buffer) {
     if (needsDefineClass) {
       buffer.add("$finishClassesName($classesCollector);\n");
       // Reset the map.
       buffer.add("$classesCollector = {};\n");
     }
   }
 
   void emitStaticFunctionsWithNamer(StringBuffer buffer,
-                                    Map<Element, String> generatedCode,
+                                    Map<Element, CodeBlock> generatedCode,
                                     String functionNamer(Element element)) {
-    generatedCode.forEach((Element element, String codeBlock) {
+    generatedCode.forEach((Element element, CodeBlock codeBlock) {
       if (!element.isInstanceMember()) {
         String functionName = functionNamer(element);
         buffer.add('$isolateProperties.$functionName = ');
-        int beginPosition = buffer.length;
-        buffer.add(codeBlock);
-        int endPosition = buffer.length;
-        buffer.add(';\n\n');
-        if (generateSourceMap) {
-          addSourceMapping(element, beginPosition, endPosition);
-        }
+        sourceMapBuilder.addCodeBlock(codeBlock.sourceMappings, buffer.length);
+        buffer.add('${codeBlock.code};\n\n');
       }
     });
   }
 
   void emitStaticFunctions(StringBuffer buffer) {
     emitStaticFunctionsWithNamer(buffer,
                                  compiler.codegenWorld.generatedCode,
                                  namer.getName);
     emitStaticFunctionsWithNamer(buffer,
                                  compiler.codegenWorld.generatedBailoutCode,
@@ skipping 10 matching lines @@
       // 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) {
+      addParameterStubs(callElement, (
+          String name, String value,
+          [List<SourceMappingEntry> sourceMappings]) {
         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,
-                                 defineInstanceMember(String invocationName,
-                                                      String definition)) {
+                                 DefineInstanceMember defineInstanceMember) {
     // 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/JavaScript):
     //
     // class A {
     //    foo(x, y, z) { ... } // Original function.
     //    get foo() { return new BoundClosure499(this, "foo"); }
     // }
     // class BoundClosure499 extends Closure {
@@ skipping 64 matching lines @@
     String getterName = namer.getterName(member.getLibrary(), member.name);
     String targetName = namer.instanceMethodName(member.getLibrary(),
                                                  member.name, parameterCount);
     defineInstanceMember(
         getterName,
         "function() { return new $closureClass(this, '$targetName'); }");
   }
 
   void emitCallStubForGetter(Element member,
                              Set<Selector> selectors,
-                             void defineInstanceMember(String invocationName,
-                                                       String definition)) {
+                             DefineInstanceMember 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)) {
@@ skipping 53 matching lines @@
     buffer.add(namer.ISOLATE);
     buffer.add(@'''.makeConstantList = function(list) {
   list.immutable$list = true;
   list.fixed$length = true;
   return list;
 };
 ''');
   }
 
   void emitExtraAccessors(Element member,
-                          void defineInstanceMember(String invocationName,
-                                                    String definition)) {
+                          DefineInstanceMember defineInstanceMember) {
     if (member.kind == ElementKind.GETTER || member.kind == ElementKind.FIELD) {
       Set<Selector> selectors = compiler.codegenWorld.invokedNames[member.name];
       if (selectors !== null && !selectors.isEmpty()) {
         emitCallStubForGetter(member, selectors, defineInstanceMember);
       }
     } else if (member.kind == ElementKind.FUNCTION) {
       if (compiler.codegenWorld.hasInvokedGetter(member, compiler)) {
         emitDynamicFunctionGetter(member, defineInstanceMember);
       }
     }
   }
 
-  void emitNoSuchMethodCalls(void defineInstanceMember(String invocationName,
-                                                       String definition)) {
+  void emitNoSuchMethodCalls(DefineInstanceMember defineInstanceMember) {
     // Do not generate no such method calls if there is no class.
     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();
@@ skipping 180 matching lines @@
       emitMain(mainBuffer);
       mainBuffer.add('function init() {\n');
       mainBuffer.add('  $isolateProperties = {};\n');
       addDefineClassAndFinishClassFunctionsIfNecessary(mainBuffer);
       emitFinishIsolateConstructor(mainBuffer);
       mainBuffer.add('}\n');
       compiler.assembledCode = mainBuffer.toString();
 
       if (generateSourceMap) {
         SourceFile compiledFile = new SourceFile(null, compiler.assembledCode);
-        String sourceMap = new SourceMapBuilder().build(sourceMappings,
-                                                        compiledFile);
+        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 addSourceMapping(FunctionElement element,
-                        int beginPosition,
-                        int endPosition) {
-    SourceFile sourceFile = element.getCompilationUnit().script.file;
-    FunctionExpression expression = element.cachedNode;
-    sourceMappings.add(new SourceMappingEntry(
-        sourceFile, expression.getBeginToken().charOffset, beginPosition));
-    sourceMappings.add(new SourceMappingEntry(
-        sourceFile, expression.getEndToken().charOffset, endPosition));
-  }
-}
+typedef void DefineInstanceMember(String invocationName,

[floitsch, 2012/07/02 15:18:32]

DefineInstanceMemberFunction ?
imho it reads strange otherwise.

[podivilov, 2012/07/03 13:08:49]

Done.

+                                  String definition,
+                                  [List<SourceMappingEntry> sourceMappings]);