Generate readable source map baselines for -b --out scenario

src/harness/sourceMapRecorder.ts

@@ -15,10 +15,10 @@ namespace Harness.SourceMapRecorder {
             error?: string;
         }
 
-        export function initializeSourceMapDecoding(sourceMapData: ts.SourceMapEmitResult) {
+        export function initializeSourceMapDecoding(sourceMap: ts.RawSourceMap) {
             decodingIndex = 0;
-            sourceMapMappings = sourceMapData.sourceMap.mappings;
-            mappings = ts.decodeMappings(sourceMapData.sourceMap.mappings);
+            sourceMapMappings = sourceMap.mappings;
+            mappings = ts.decodeMappings(sourceMap.mappings);
         }
 
         export function decodeNextEncodedSourceMapSpan(): DecodedMapping {
@@ -53,10 +53,10 @@ namespace Harness.SourceMapRecorder {
         let nextJsLineToWrite: number;
         let spanMarkerContinues: boolean;
 
-        export function initializeSourceMapSpanWriter(sourceMapRecordWriter: Compiler.WriterAggregator, sourceMapData: ts.SourceMapEmitResult, currentJsFile: documents.TextDocument) {
+        export function initializeSourceMapSpanWriter(sourceMapRecordWriter: Compiler.WriterAggregator, sourceMap: ts.RawSourceMap, currentJsFile: documents.TextDocument) {
             sourceMapRecorder = sourceMapRecordWriter;
-            sourceMapSources = sourceMapData.sourceMap.sources;
-            sourceMapNames = sourceMapData.sourceMap.names;
+            sourceMapSources = sourceMap.sources;
+            sourceMapNames = sourceMap.names;
 
             jsFile = currentJsFile;
             jsLineMap = jsFile.lineStarts;
@@ -66,14 +66,14 @@ namespace Harness.SourceMapRecorder {
             nextJsLineToWrite = 0;
             spanMarkerContinues = false;
 
-            SourceMapDecoder.initializeSourceMapDecoding(sourceMapData);
+            SourceMapDecoder.initializeSourceMapDecoding(sourceMap);
             sourceMapRecorder.WriteLine("===================================================================");
-            sourceMapRecorder.WriteLine("JsFile: " + sourceMapData.sourceMap.file);
+            sourceMapRecorder.WriteLine("JsFile: " + sourceMap.file);
             sourceMapRecorder.WriteLine("mapUrl: " + ts.tryGetSourceMappingURL(ts.getLineInfo(jsFile.text, jsLineMap)));
-            sourceMapRecorder.WriteLine("sourceRoot: " + sourceMapData.sourceMap.sourceRoot);
-            sourceMapRecorder.WriteLine("sources: " + sourceMapData.sourceMap.sources);
-            if (sourceMapData.sourceMap.sourcesContent) {
-                sourceMapRecorder.WriteLine("sourcesContent: " + JSON.stringify(sourceMapData.sourceMap.sourcesContent));
+            sourceMapRecorder.WriteLine("sourceRoot: " + sourceMap.sourceRoot);
+            sourceMapRecorder.WriteLine("sources: " + sourceMap.sources);
+            if (sourceMap.sourcesContent) {
+                sourceMapRecorder.WriteLine("sourcesContent: " + JSON.stringify(sourceMap.sourcesContent));
             }
             sourceMapRecorder.WriteLine("===================================================================");
         }
@@ -299,7 +299,7 @@ namespace Harness.SourceMapRecorder {
                 }
             }
 
-            SourceMapSpanWriter.initializeSourceMapSpanWriter(sourceMapRecorder, sourceMapData, currentFile);
+            SourceMapSpanWriter.initializeSourceMapSpanWriter(sourceMapRecorder, sourceMapData.sourceMap, currentFile);
             const mapper = ts.decodeMappings(sourceMapData.sourceMap.mappings);
             for (let { value: decodedSourceMapping, done } = mapper.next(); !done; { value: decodedSourceMapping, done } = mapper.next()) {
                 const currentSourceFile = ts.isSourceMapping(decodedSourceMapping)
@@ -320,4 +320,46 @@ namespace Harness.SourceMapRecorder {
         sourceMapRecorder.Close();
         return sourceMapRecorder.lines.join("\r\n");
     }
+
+    export function getSourceMapRecordWithVFS(fs: vfs.FileSystem, sourceMapFile: string) {
+        const sourceMapRecorder = new Compiler.WriterAggregator();
+        let prevSourceFile: documents.TextDocument | undefined;
+        const files = ts.createMap<documents.TextDocument>();
+        const sourceMap = ts.tryParseRawSourceMap(fs.readFileSync(sourceMapFile, "utf8"));
+        if (sourceMap) {
+            const mapDirectory = ts.getDirectoryPath(sourceMapFile);
+            const sourceRoot = sourceMap.sourceRoot ? ts.getNormalizedAbsolutePath(sourceMap.sourceRoot, mapDirectory) : mapDirectory;
+            const generatedAbsoluteFilePath = ts.getNormalizedAbsolutePath(sourceMap.file, mapDirectory);
+            const sourceFileAbsolutePaths = sourceMap.sources.map(source => ts.getNormalizedAbsolutePath(source, sourceRoot));
+            const currentFile = getFile(generatedAbsoluteFilePath);
+
+            SourceMapSpanWriter.initializeSourceMapSpanWriter(sourceMapRecorder, sourceMap, currentFile);
+            const mapper = ts.decodeMappings(sourceMap.mappings);
+            for (let { value: decodedSourceMapping, done } = mapper.next(); !done; { value: decodedSourceMapping, done } = mapper.next()) {
+                const currentSourceFile = ts.isSourceMapping(decodedSourceMapping)
+                    ? getFile(sourceFileAbsolutePaths[decodedSourceMapping.sourceIndex])
+                    : undefined;
+                if (currentSourceFile !== prevSourceFile) {
+                    if (currentSourceFile) {
+                        SourceMapSpanWriter.recordNewSourceFileSpan(decodedSourceMapping, currentSourceFile.text);
+                    }
+                    prevSourceFile = currentSourceFile;
+                }
+                else {
+                    SourceMapSpanWriter.recordSourceMapSpan(decodedSourceMapping);
+                }
+            }
+            SourceMapSpanWriter.close(); // If the last spans werent emitted, emit them
+        }
+        sourceMapRecorder.Close();
+        return sourceMapRecorder.lines.join("\r\n");
+
+        function getFile(path: string) {
+            const existing = files.get(path);
+            if (existing) return existing;
+            const value = new documents.TextDocument(path, fs.readFileSync(path, "utf8"));
+            files.set(path, value);
+            return value;
+        }
+    }
 }

src/testRunner/unittests/tsbuild.ts

@@ -493,6 +493,18 @@ export const b = new A();`);
                     fs = undefined;
                 });
                 it(`Generates files matching the baseline`, () => {
+                    for (const mapFile of [
+                        "/src/first/bin/first-output.js.map",
+                        "/src/first/bin/first-output.d.ts.map",
+                        "/src/2/second-output.js.map",
+                        "/src/2/second-output.d.ts.map",
+                        "/src/third/thirdjs/output/third-output.js.map",
+                        "/src/third/thirdjs/output/third-output.d.ts.map"
+                    ]) {
+                        const text = Harness.SourceMapRecorder.getSourceMapRecordWithVFS(fs!, mapFile);
+                        fs!.writeFileSync(`${mapFile}.baseline.txt`, text);
+                    }
+
                     const patch = fs!.diff();
                     // tslint:disable-next-line:no-null-keyword
                     Harness.Baseline.runBaseline(`outFile-${scenario.split(" ").join("-")}.js`, patch ? vfs.formatPatch(patch) : null);