Reimplement input sourcemap merging.

packages/babel-cli/test/fixtures/babel/filename-sourcemap --out-file --source-maps inline/out-files/script2.js

@@ -4,4 +4,4 @@ var foo = function foo() {
   return 4;
 };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm9yaWdpbmFsLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsVUFBVSxlO1MsQUFBTTtBQUFDIiwiZmlsZSI6InNjcmlwdDIuanMiLCJzb3VyY2VzQ29udGVudCI6WyJ2YXIgZm9vID0gKCkgPT4gNDsiXX0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm9yaWdpbmFsLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsSUFBQSxNQUFVLFNBQVYsR0FBVSxHO1NBQU0sQztBQUFDLENBQWpCIiwiZmlsZSI6InNjcmlwdDIuanMiLCJzb3VyY2VzQ29udGVudCI6WyJ2YXIgZm9vID0gKCkgPT4gNDsiXX0=

packages/babel-core/src/transformation/file/merge-map.js

@@ -7,49 +7,313 @@ export default function mergeSourceMap(
   inputMap: SourceMap,
   map: SourceMap,
 ): SourceMap {
-  const inputMapConsumer = new sourceMap.SourceMapConsumer(inputMap);
+  const input = buildMappingData(inputMap);
-  const outputMapConsumer = new sourceMap.SourceMapConsumer(map);
+  const output = buildMappingData(map);
 
-  const mergedGenerator = new sourceMap.SourceMapGenerator({
+  // Babel-generated maps always map to a single input filename.
-    file: inputMapConsumer.file,
+  if (output.sources.length !== 1) {
-    sourceRoot: inputMapConsumer.sourceRoot,
+    throw new Error("Assertion failure - expected a single output file");
-  });
+  }
+  const defaultSource = output.sources[0];
 
-  // This assumes the output map always has a single source, since Babel always compiles a
+  const mergedGenerator = new sourceMap.SourceMapGenerator();
-  // single source file to a single output file.
+  for (const { source } of input.sources) {
-  const source = outputMapConsumer.sources[0];
+    if (typeof source.content === "string") {
+      mergedGenerator.setSourceContent(source.path, source.content);
+    }
+  }
 
-  inputMapConsumer.eachMapping(function(mapping) {
+  const insertedMappings = new Map();
-    const generatedPosition = outputMapConsumer.generatedPositionFor({
+
-      line: mapping.generatedLine,
+  // Process each generated range in the input map, e.g. each range over the
-      column: mapping.generatedColumn,
+  // code that Babel was originally given.
-      source: source,
+  eachInputGeneratedRange(input, (generated, original, source) => {
-    });
+    // Then pick out each range over Babel's _output_ that corresponds with
-    if (generatedPosition.line != null && generatedPosition.column != null) {
+    // the given range on the code given to Babel.
-      const generated = {
+    eachOverlappingGeneratedOutputRange(defaultSource, generated, item => {
-        line: generatedPosition.line,
+      // It's possible that multiple input ranges will overlap the same
-        column: generatedPosition.column,
+      // generated range. Since sourcemap don't traditionally represent
-      };
+      // generated locations with multiple original locations, we explicitly
+      // skip generated locations once we've seen them the first time.
+      const key = makeMappingKey(item);
+      if (insertedMappings.has(key)) return;
+      insertedMappings.set(key, item);
 
       mergedGenerator.addMapping({
-        source: mapping.source,
+        source: source.path,
-
+        original: {
-        original:
+          line: original.line,
-          mapping.source == null
+          column: original.columnStart,
-            ? null
-            : {
-                line: mapping.originalLine,
-                column: mapping.originalColumn,
         },
+        generated: {
+          line: item.line,
+          column: item.columnStart,
+        },
+        name: original.name,
+      });
+    });
+  });
 
-        generated,
+  // Since mappings are manipulated using single locations, but are interpreted
+  // as ranges, the insertions above may not actually have their ending
+  // locations mapped yet. Here be go through each one and ensure that it has
+  // a well-defined ending location, if one wasn't already created by the start
+  // of a different range.
+  for (const item of insertedMappings.values()) {
+    if (item.columnEnd === Infinity) {
+      continue;
+    }
 
-        name: mapping.name,
+    const clearItem = {
+      line: item.line,
+      columnStart: item.columnEnd,
+    };
+
+    const key = makeMappingKey(clearItem);
+    if (insertedMappings.has(key)) {
+      continue;
+    }
+
+    // Insert mappings with no original position to terminate any mappings
+    // that were found above, so that they don't expand beyond their correct
+    // range.
+    mergedGenerator.addMapping({
+      generated: {
+        line: clearItem.line,
+        column: clearItem.columnStart,
+      },
     });
   }
+
+  const result = mergedGenerator.toJSON();
+  // addMapping expects a relative path, and setSourceContent expects an
+  // absolute path. To avoid this whole confusion, we leave the root out
+  // entirely, and add it at the end here.
+  if (typeof input.sourceRoot === "string") {
+    result.sourceRoot = input.sourceRoot;
+  }
+  return result;
+}
+
+function makeMappingKey(item: { line: number, columnStart: number }) {
+  return JSON.stringify([item.line, item.columnStart]);
+}
+
+function eachOverlappingGeneratedOutputRange(
+  outputFile: ResolvedFileMappings,
+  inputGeneratedRange: ResolvedGeneratedRange,
+  callback: ResolvedGeneratedRange => mixed,
+) {
+  // Find the Babel-generated mappings that overlap with this range in the
+  // input sourcemap. Generated locations within the input sourcemap
+  // correspond with the original locations in the map Babel generates.
+  const overlappingOriginal = filterApplicableOriginalRanges(
+    outputFile,
+    inputGeneratedRange,
+  );
+
+  for (const { generated } of overlappingOriginal) {
+    for (const item of generated) {
+      callback(item);
+    }
+  }
+}
+
+function filterApplicableOriginalRanges(
+  { mappings }: ResolvedFileMappings,
+  { line, columnStart, columnEnd }: ResolvedGeneratedRange,
+): OriginalMappings {
+  // The mapping array is sorted by original location, so we can
+  // binary-search it for the overlapping ranges.
+  return filterSortedArray(mappings, ({ original: outOriginal }) => {
+    if (line > outOriginal.line) return -1;
+    if (line < outOriginal.line) return 1;
+
+    if (columnStart >= outOriginal.columnEnd) return -1;
+    if (columnEnd <= outOriginal.columnStart) return 1;
+
+    return 0;
+  });
+}
+
+function eachInputGeneratedRange(
+  map: ResolvedMappings,
+  callback: (
+    ResolvedGeneratedRange,
+    ResolvedOriginalRange,
+    ResolvedSource,
+  ) => mixed,
+) {
+  for (const { source, mappings } of map.sources) {
+    for (const { original, generated } of mappings) {
+      for (const item of generated) {
+        callback(item, original, source);
+      }
+    }
+  }
+}
+
+type ResolvedMappings = {|
+  file: ?string,
+  sourceRoot: ?string,
+  sources: Array<ResolvedFileMappings>,
+|};
+type ResolvedFileMappings = {|
+  source: ResolvedSource,
+  mappings: OriginalMappings,
+|};
+type OriginalMappings = Array<{|
+  original: ResolvedOriginalRange,
+  generated: Array<ResolvedGeneratedRange>,
+|}>;
+type ResolvedSource = {|
+  path: string,
+  content: string | null,
+|};
+type ResolvedOriginalRange = {|
+  line: number,
+  columnStart: number,
+  columnEnd: number,
+  name: string | null,
+|};
+type ResolvedGeneratedRange = {|
+  line: number,
+  columnStart: number,
+  columnEnd: number,
+|};
+
+function buildMappingData(map: SourceMap): ResolvedMappings {
+  const consumer = new sourceMap.SourceMapConsumer({
+    ...map,
+
+    // This is a bit hack. .addMapping expects source values to be relative,
+    // but eachMapping returns mappings with absolute paths. To avoid that
+    // incompatibility, we leave the sourceRoot out here and add it to the
+    // final map at the end instead.
+    sourceRoot: null,
   });
 
-  const mergedMap = mergedGenerator.toJSON();
+  const sources = new Map();
-  inputMap.mappings = mergedMap.mappings;
+  const mappings = new Map();
-  return inputMap;
+
+  let last = null;
+
+  consumer.computeColumnSpans();
+
+  consumer.eachMapping(
+    m => {
+      if (m.originalLine === null) return;
+
+      let source = sources.get(m.source);
+      if (!source) {
+        source = {
+          path: m.source,
+          content: consumer.sourceContentFor(m.source, true),
+        };
+        sources.set(m.source, source);
+      }
+
+      let sourceData = mappings.get(source);
+      if (!sourceData) {
+        sourceData = {
+          source,
+          mappings: [],
+        };
+        mappings.set(source, sourceData);
+      }
+
+      const obj = {
+        line: m.originalLine,
+        columnStart: m.originalColumn,
+        columnEnd: Infinity,
+        name: m.name,
+      };
+
+      if (
+        last &&
+        last.source === source &&
+        last.mapping.line === m.originalLine
+      ) {
+        last.mapping.columnEnd = m.originalColumn;
+      }
+
+      last = {
+        source,
+        mapping: obj,
+      };
+
+      sourceData.mappings.push({
+        original: obj,
+        generated: consumer
+          .allGeneratedPositionsFor({
+            source: m.source,
+            line: m.originalLine,
+            column: m.originalColumn,
+          })
+          .map(item => ({
+            line: item.line,
+            columnStart: item.column,
+            // source-map's lastColumn is inclusive, not exclusive, so we need
+            // to add 1 to it.
+            columnEnd: item.lastColumn + 1,
+          })),
+      });
+    },
+    null,
+    sourceMap.SourceMapConsumer.ORIGINAL_ORDER,
+  );
+
+  return {
+    file: map.file,
+    sourceRoot: map.sourceRoot,
+    sources: Array.from(mappings.values()),
+  };
+}
+
+function findInsertionLocation<T>(
+  array: Array<T>,
+  callback: T => number,
+): number {
+  let left = 0;
+  let right = array.length;
+  while (left < right) {
+    const mid = Math.floor((left + right) / 2);
+    const item = array[mid];
+
+    const result = callback(item);
+    if (result === 0) {
+      left = mid;
+      break;
+    }
+    if (result >= 0) {
+      right = mid;
+    } else {
+      left = mid + 1;
+    }
+  }
+
+  // Ensure the value is the start of any set of matches.
+  let i = left;
+  if (i < array.length) {
+    while (i > 0 && callback(array[i]) >= 0) {
+      i--;
+    }
+    return i + 1;
+  }
+
+  return i;
+}
+
+function filterSortedArray<T>(
+  array: Array<T>,
+  callback: T => number,
+): Array<T> {
+  const start = findInsertionLocation(array, callback);
+
+  const results = [];
+  for (let i = start; i < array.length && callback(array[i]) === 0; i++) {
+    results.push(array[i]);
+  }
+
+  return results;
 }

packages/babel-core/test/fixtures/transformation/source-maps/input-source-map-complex/source-map.json

@@ -4,7 +4,7 @@
     "HelloWorld.vue"
   ],
   "names": [],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsFA;;QAEA;;SACA;;WAEA,AACA;AAFA;AAGA;;AANA",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAsFA;AACA,QAAA,YADA;;AAEA,SAAA;AACA,WAAA;AACA,WAAA;AADA,KAAA;AAGA;;AANA,C",
   "sourceRoot": "src/components",
   "sourcesContent": [
     "<template>\n  <div class=\"hello\">\n    <h1>{{ msg }}</h1>\n    <h2>Essential Links</h2>\n    <ul>\n      <li>\n        <a\n          href=\"https://vuejs.org\"\n          target=\"_blank\"\n        >\n          Core Docs\n        </a>\n      </li>\n      <li>\n        <a\n          href=\"https://forum.vuejs.org\"\n          target=\"_blank\"\n        >\n          Forum\n        </a>\n      </li>\n      <li>\n        <a\n          href=\"https://chat.vuejs.org\"\n          target=\"_blank\"\n        >\n          Community Chat\n        </a>\n      </li>\n      <li>\n        <a\n          href=\"https://twitter.com/vuejs\"\n          target=\"_blank\"\n        >\n          Twitter\n        </a>\n      </li>\n      <br>\n      <li>\n        <a\n          href=\"http://vuejs-templates.github.io/webpack/\"\n          target=\"_blank\"\n        >\n          Docs for This Template\n        </a>\n      </li>\n    </ul>\n    <h2>Ecosystem</h2>\n    <ul>\n      <li>\n        <a\n          href=\"http://router.vuejs.org/\"\n          target=\"_blank\"\n        >\n          vue-router\n        </a>\n      </li>\n      <li>\n        <a\n          href=\"http://vuex.vuejs.org/\"\n          target=\"_blank\"\n        >\n          vuex\n        </a>\n      </li>\n      <li>\n        <a\n          href=\"http://vue-loader.vuejs.org/\"\n          target=\"_blank\"\n        >\n          vue-loader\n        </a>\n      </li>\n      <li>\n        <a\n          href=\"https://github.com/vuejs/awesome-vue\"\n          target=\"_blank\"\n        >\n          awesome-vue\n        </a>\n      </li>\n    </ul>\n  </div>\n</template>\n\n<script>\nexport default {\n  name: 'HelloWorld',\n  data () {\n    return {\n      msg: 'Welcome to Your Vue.js App'\n    }\n  }\n}\n</script>\n\n<!-- Add \"scoped\" attribute to limit CSS to this component only -->\n<style scoped>\nh1, h2 {\n  font-weight: normal;\n}\nul {\n  list-style-type: none;\n  padding: 0;\n}\nli {\n  display: inline-block;\n  margin: 0 10px;\n}\na {\n  color: #42b983;\n}\n</style>\n"

packages/babel-core/test/fixtures/transformation/source-maps/input-source-map-complex/source-mappings.json

@@ -1,37 +1,27 @@
 [
   {
     "generated": {
-      "line": 91,
+      "line": 92,
-      "column": 0
+      "column": 15
     },
     "original": {
       "line": 87,
       "column": 0
     }
   },
-  {
-    "generated": {
-      "line": 92,
-      "column": 0
-    },
-    "original": {
-      "line": null,
-      "column": null
-    }
-  },
   {
     "generated": {
       "line": 93,
       "column": 0
     },
     "original": {
-      "line": null,
+      "line": 88,
-      "column": null
+      "column": 0
     }
   },
   {
     "generated": {
-      "line": 93,
+      "line": 95,
       "column": 9
     },
     "original": {
@@ -41,18 +31,8 @@
   },
   {
     "generated": {
-      "line": 94,
+      "line": 96,
-      "column": 9
+      "column": 0
-    },
-    "original": {
-      "line": null,
-      "column": null
-    }
-  },
-  {
-    "generated": {
-      "line": 95,
-      "column": 9
     },
     "original": {
       "line": 90,
@@ -61,21 +41,31 @@
   },
   {
     "generated": {
-      "line": 96,
+      "line": 97,
       "column": 0
     },
     "original": {
-      "line": null,
+      "line": 91,
-      "column": null
+      "column": 0
     }
   },
   {
     "generated": {
-      "line": 97,
+      "line": 98,
-      "column": 12
+      "column": 0
     },
     "original": {
-      "line": 92,
+      "line": 90,
+      "column": 0
+    }
+  },
+  {
+    "generated": {
+      "line": 99,
+      "column": 0
+    },
+    "original": {
+      "line": 93,
       "column": 0
     }
   }

packages/babel-core/test/fixtures/transformation/source-maps/input-source-map/source-map.json

@@ -1,11 +1,7 @@
 {
-  "version": 3,
+  "mappings": "AAAA,IAAA,MAAU,Y;SAAM,C;AAAC,CAAjB",
-  "mappings": "AAAA,UAAU,Y;SAAM,A;AAAC",
   "names": [],
-  "sources": [
+  "sources": ["original.js"],
-    "original.js"
+  "sourcesContent": ["var foo = () => 4;"],
-  ],
+  "version": 3
-  "sourcesContent": [
-    "var foo = () => 4;"
-  ]
 }