Add empty mapping entries for the ranges of generated JavaScript that don't map to any Dart source …

lib/compiler/implementation/js_backend/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 26 matching lines @@
   NativeEmitter nativeEmitter;
   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 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
       => '${namer.ISOLATE}.\$defineClass';
   String get finishClassesName
       => '${namer.ISOLATE}.\$finishClasses';
@@ skipping 519 matching lines @@
 
   void emitInstanceMembers(ClassElement classElement,
                            CodeBuffer buffer,
                            bool needsLeadingComma) {
     bool needsComma = needsLeadingComma;
     void defineInstanceMember(String name, CodeBuffer memberBuffer) {
       if (needsComma) buffer.add(',');
       needsComma = true;
       buffer.add('\n');
       buffer.add(' $name: ');
-      addMappings(memberBuffer, buffer.length);
       buffer.add(memberBuffer);
     }
 
     classElement.forEachMember(includeBackendMembers: true,
                                f: (ClassElement enclosing, Element member) {
       if (member.isInstanceMember()) {
         addInstanceMember(member, defineInstanceMember);
       }
     });
 
@@ skipping 136 matching lines @@
       buffer.add("$classesCollector = {};\n");
     }
   }
 
   void emitStaticFunctionWithNamer(CodeBuffer buffer,
                                    Element element,
                                    CodeBuffer functionBuffer,
                                    String functionNamer(Element element)) {
     String functionName = functionNamer(element);
     buffer.add('$isolateProperties.$functionName = ');
-    addMappings(functionBuffer, buffer.length);
     buffer.add(functionBuffer);
     buffer.add(';\n\n');
   }
   void emitStaticFunctionsWithNamer(CodeBuffer buffer,
                                     Map<Element, CodeBuffer> generatedCode,
                                     String functionNamer(Element element)) {
     generatedCode.forEach((Element element, CodeBuffer functionBuffer) {
       if (!element.isInstanceMember() && !element.isField()) {
         emitStaticFunctionWithNamer(
             buffer, element, functionBuffer,functionNamer);
@@ skipping 186 matching lines @@
         // closure that constructs the initial value.
         buffer.add("$lazyInitializerName(");
         buffer.add(isolateProperties);
         buffer.add(", '");
         buffer.add(element.name.slowToString());
         buffer.add("', '");
         buffer.add(namer.getName(element));
         buffer.add("', '");
         buffer.add(namer.getLazyInitializerName(element));
         buffer.add("', ");
-        addMappings(code, buffer.length);
         buffer.add(code);
         buffer.add(");\n");
       }
     }
   }
 
   void emitCompileTimeConstants(CodeBuffer buffer) {
     ConstantHandler handler = compiler.constantHandler;
     List<Constant> constants = handler.getConstantsForEmission();
     bool addedMakeConstantList = false;
@@ skipping 301 matching lines @@
       mainBuffer.add('function init() {\n');
       mainBuffer.add('$isolateProperties = {};\n');
       addDefineClassAndFinishClassFunctionsIfNecessary(mainBuffer);
       addLazyInitializerFunctionIfNecessary(mainBuffer);
       emitFinishIsolateConstructor(mainBuffer);
       mainBuffer.add('}\n');
       compiler.assembledCode = mainBuffer.toString();
 
       if (generateSourceMap) {
         SourceFile compiledFile = new SourceFile(null, compiler.assembledCode);
-        String sourceMap = sourceMapBuilder.build(compiledFile);
+        String sourceMap = buildSourceMap(mainBuffer, 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) {
+  String buildSourceMap(CodeBuffer buffer, SourceFile compiledFile) {
+    SourceMapBuilder sourceMapBuilder = new SourceMapBuilder();
     buffer.forEachSourceLocation((Element element, Token token, int offset) {
+      if (element == null) {
+        sourceMapBuilder.addMapping(null, null, null, offset);
+        return;
+      }
       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);
+          sourceFile, token.charOffset, sourceName, offset);
     });
+    return sourceMapBuilder.build(compiledFile);
   }
 }
 
 typedef void DefineMemberFunction(String invocationName, CodeBuffer definition);