First shot at source maps generation in dart2js.

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 16 matching lines @@
   final Namer namer;
   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;
 
-  CodeEmitterTask(Compiler compiler)
+  final bool generateSourceMap;
+  final List<SourceMappingEntry> sourceMappings;
+
+  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>(),
         super(compiler) {
     nativeEmitter = new NativeEmitter(this);
   }
 
   String get name() => 'CodeEmitter';
 
   String get defineClassName()
       => '${namer.ISOLATE}.\$defineClass';
   String get finishClassesName()
       => '${namer.ISOLATE}.\$finishClasses';
@@ skipping 557 matching lines @@
       buffer.add("$classesCollector = {};\n");
     }
   }
 
   void emitStaticFunctionsWithNamer(StringBuffer buffer,
                                     Map<Element, String> generatedCode,
                                     String functionNamer(Element element)) {
     generatedCode.forEach((Element element, String codeBlock) {
       if (!element.isInstanceMember()) {
         String functionName = functionNamer(element);
-        buffer.add('$isolateProperties.$functionName = $codeBlock;\n\n');
+        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);
+        }
       }
     });
   }
 
   void emitStaticFunctions(StringBuffer buffer) {
     emitStaticFunctionsWithNamer(buffer,
                                  compiler.codegenWorld.generatedCode,
                                  namer.getName);
     emitStaticFunctionsWithNamer(buffer,
                                  compiler.codegenWorld.generatedBailoutCode,
@@ skipping 395 matching lines @@
         'var ${namer.CURRENT_ISOLATE} = new ${namer.ISOLATE}();\n');
 
       nativeEmitter.assembleCode(mainBuffer);
       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);
+        // 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));
+  }
 }