Declaration maps and transparent goto definition using them

src/compiler/commandLineParser.ts

@@ -194,6 +194,13 @@ namespace ts {
             category: Diagnostics.Basic_Options,
             description: Diagnostics.Generates_corresponding_d_ts_file,
         },
+        {
+            name: "declarationMaps",
+            type: "boolean",
+            showInSimplifiedHelpView: true,
+            category: Diagnostics.Basic_Options,
+            description: Diagnostics.Generates_a_sourcemap_for_each_corresponding_d_ts_file,
+        },
         {
             name: "emitDeclarationOnly",
             type: "boolean",

src/compiler/core.ts

@@ -2066,6 +2066,10 @@ namespace ts {
         return moduleResolution;
     }
 
+    export function getAreDeclarationMapsEnabled(options: CompilerOptions) {
+        return !!(options.declaration && options.declarationMaps);
+    }
+
     export function getAllowSyntheticDefaultImports(compilerOptions: CompilerOptions) {
         const moduleKind = getEmitModuleKind(compilerOptions);
         return compilerOptions.allowSyntheticDefaultImports !== undefined

src/compiler/diagnosticMessages.json

@@ -2768,6 +2768,10 @@
         "code": 5068
     },
 
+    "Generates a sourcemap for each corresponding '.d.ts' file.": {
+        "category": "Message",
+        "code": 6000
+    },
     "Concatenate and emit output to single file.": {
         "category": "Message",
         "code": 6001

src/compiler/emitter.ts

@@ -49,15 +49,17 @@ namespace ts {
             const jsFilePath = options.outFile || options.out;
             const sourceMapFilePath = getSourceMapFilePath(jsFilePath, options);
             const declarationFilePath = (forceDtsPaths || options.declaration) ? removeFileExtension(jsFilePath) + Extension.Dts : undefined;
-            return { jsFilePath, sourceMapFilePath, declarationFilePath };
+            const declarationMapPath = getAreDeclarationMapsEnabled(options) ? declarationFilePath + ".map" : undefined;
+            return { jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath };
         }
         else {
             const jsFilePath = getOwnEmitOutputFilePath(sourceFile, host, getOutputExtension(sourceFile, options));
             const sourceMapFilePath = getSourceMapFilePath(jsFilePath, options);
             // For legacy reasons (ie, we have baselines capturing the behavior), js files don't report a .d.ts output path - this would only matter if `declaration` and `allowJs` were both on, which is currently an error
             const isJs = isSourceFileJavaScript(sourceFile);
             const declarationFilePath = ((forceDtsPaths || options.declaration) && !isJs) ? getDeclarationEmitOutputFilePath(sourceFile, host) : undefined;
-            return { jsFilePath, sourceMapFilePath, declarationFilePath };
+            const declarationMapPath = getAreDeclarationMapsEnabled(options) ? declarationFilePath + ".map" : undefined;
+            return { jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath };
         }
     }
 
@@ -83,12 +85,19 @@ namespace ts {
         return Extension.Js;
     }
 
+    const enum SourceMapEmitKind {
+        None,
+        File,
+        Inline,
+        DeclarationFile
+    }
+
     /*@internal*/
     // targetSourceFile is when users only want one file in entire project to be emitted. This is used in compileOnSave feature
     export function emitFiles(resolver: EmitResolver, host: EmitHost, targetSourceFile: SourceFile, emitOnlyDtsFiles?: boolean, transformers?: TransformerFactory<SourceFile>[]): EmitResult {
         const compilerOptions = host.getCompilerOptions();
         const moduleKind = getEmitModuleKind(compilerOptions);
-        const sourceMapDataList: SourceMapData[] = compilerOptions.sourceMap || compilerOptions.inlineSourceMap ? [] : undefined;
+        const sourceMapDataList: SourceMapData[] = (compilerOptions.sourceMap || compilerOptions.inlineSourceMap || getAreDeclarationMapsEnabled(compilerOptions)) ? [] : undefined;
         const emittedFilesList: string[] = compilerOptions.listEmittedFiles ? [] : undefined;
         const emitterDiagnostics = createDiagnosticCollection();
         const newLine = host.getNewLine();
@@ -113,9 +122,9 @@ namespace ts {
             sourceMaps: sourceMapDataList
         };
 
-        function emitSourceFileOrBundle({ jsFilePath, sourceMapFilePath, declarationFilePath }: EmitFileNames, sourceFileOrBundle: SourceFile | Bundle) {
+        function emitSourceFileOrBundle({ jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath }: EmitFileNames, sourceFileOrBundle: SourceFile | Bundle) {
             emitJsFileOrBundle(sourceFileOrBundle, jsFilePath, sourceMapFilePath);
-            emitDeclarationFileOrBundle(sourceFileOrBundle, declarationFilePath);
+            emitDeclarationFileOrBundle(sourceFileOrBundle, declarationFilePath, declarationMapPath);
 
             if (!emitSkipped && emittedFilesList) {
                 if (!emitOnlyDtsFiles) {
@@ -162,13 +171,14 @@ namespace ts {
                 onSetSourceFile: setSourceFile,
             });
 
-            printSourceFileOrBundle(jsFilePath, sourceMapFilePath, isSourceFile(sourceFileOrBundle) ? transform.transformed[0] : createBundle(transform.transformed), printer);
+            const sourcemapKind = compilerOptions.inlineSourceMap ? SourceMapEmitKind.Inline : compilerOptions.sourceMap ? SourceMapEmitKind.File : SourceMapEmitKind.None;
+            printSourceFileOrBundle(jsFilePath, sourceMapFilePath, isSourceFile(sourceFileOrBundle) ? transform.transformed[0] : createBundle(transform.transformed), printer, sourcemapKind);
 
             // Clean up emit nodes on parse tree
             transform.dispose();
         }
 
-        function emitDeclarationFileOrBundle(sourceFileOrBundle: SourceFile | Bundle, declarationFilePath: string | undefined) {
+        function emitDeclarationFileOrBundle(sourceFileOrBundle: SourceFile | Bundle, declarationFilePath: string | undefined, declarationMapPath: string | undefined) {
             if (!(declarationFilePath && !isInJavaScriptFile(sourceFileOrBundle))) {
                 return;
             }
@@ -186,25 +196,34 @@ namespace ts {
                 // resolver hooks
                 hasGlobalName: resolver.hasGlobalName,
 
+                // sourcemap hooks
+                onEmitSourceMapOfNode: sourceMap.emitNodeWithSourceMap,
+                onEmitSourceMapOfToken: sourceMap.emitTokenWithSourceMap,
+                onEmitSourceMapOfPosition: sourceMap.emitPos,
+                onSetSourceFile: setSourceFile,
+
                 // transform hooks
                 onEmitNode: declarationTransform.emitNodeWithNotification,
                 substituteNode: declarationTransform.substituteNode,
             });
             const declBlocked = (!!declarationTransform.diagnostics && !!declarationTransform.diagnostics.length) || !!host.isEmitBlocked(declarationFilePath) || !!compilerOptions.noEmit;
             emitSkipped = emitSkipped || declBlocked;
             if (!declBlocked || emitOnlyDtsFiles) {
-                const previousState = sourceMap.setState(/*disabled*/ true);
-                printSourceFileOrBundle(declarationFilePath, /*sourceMapFilePath*/ undefined, declarationTransform.transformed[0], declarationPrinter, /*shouldSkipSourcemap*/ true);
-                sourceMap.setState(previousState);
+                printSourceFileOrBundle(declarationFilePath, declarationMapPath, declarationTransform.transformed[0], declarationPrinter, getAreDeclarationMapsEnabled(compilerOptions) ? SourceMapEmitKind.DeclarationFile : SourceMapEmitKind.None);
             }
             declarationTransform.dispose();
         }
 
-        function printSourceFileOrBundle(jsFilePath: string, sourceMapFilePath: string, sourceFileOrBundle: SourceFile | Bundle, printer: Printer, shouldSkipSourcemap = false) {
+        function printSourceFileOrBundle(jsFilePath: string, sourceMapFilePath: string | undefined, sourceFileOrBundle: SourceFile | Bundle, printer: Printer, sourcemapKind: SourceMapEmitKind) {
             const bundle = sourceFileOrBundle.kind === SyntaxKind.Bundle ? sourceFileOrBundle : undefined;
             const sourceFile = sourceFileOrBundle.kind === SyntaxKind.SourceFile ? sourceFileOrBundle : undefined;
             const sourceFiles = bundle ? bundle.sourceFiles : [sourceFile];
-            sourceMap.initialize(jsFilePath, sourceMapFilePath, sourceFileOrBundle);
+            if (sourcemapKind !== SourceMapEmitKind.None) {
+                sourceMap.initialize(jsFilePath, sourceMapFilePath, sourceFileOrBundle);
+            }
+            else {
+                sourceMap.setState(/*disabled*/ true);
+            }
 
             if (bundle) {
                 bundledHelpers = createMap<boolean>();
@@ -219,25 +238,31 @@ namespace ts {
             writer.writeLine();
 
             const sourceMappingURL = sourceMap.getSourceMappingURL();
-            if (!shouldSkipSourcemap && sourceMappingURL) {
+            if (sourceMappingURL) {
                 writer.write(`//# ${"sourceMappingURL"}=${sourceMappingURL}`); // Sometimes tools can sometimes see this line as a source mapping url comment
             }
 
             // Write the source map
-            if (!shouldSkipSourcemap && compilerOptions.sourceMap && !compilerOptions.inlineSourceMap) {
+            if (sourceMapFilePath && (sourcemapKind === SourceMapEmitKind.File || sourcemapKind === SourceMapEmitKind.DeclarationFile)) {
                 writeFile(host, emitterDiagnostics, sourceMapFilePath, sourceMap.getText(), /*writeByteOrderMark*/ false, sourceFiles);
             }
 
             // Record source map data for the test harness.
-            if (!shouldSkipSourcemap && sourceMapDataList) {
+            if (sourcemapKind !== SourceMapEmitKind.None) {
                 sourceMapDataList.push(sourceMap.getSourceMapData());
             }
 
             // Write the output file
             writeFile(host, emitterDiagnostics, jsFilePath, writer.getText(), compilerOptions.emitBOM, sourceFiles);
 
             // Reset state
-            sourceMap.reset();
+
+            if (sourcemapKind !== SourceMapEmitKind.None) {
+                sourceMap.reset();
+            }
+            else {
+                sourceMap.setState(/*disabled*/ false);
+            }
             writer.clear();
 
             currentSourceFile = undefined;

src/compiler/program.ts

@@ -2122,7 +2122,7 @@ namespace ts {
                 createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "out", "outFile");
             }
 
-            if (options.mapRoot && !options.sourceMap) {
+            if (options.mapRoot && !(options.sourceMap || options.declarationMaps)) {
                 // Error to specify --mapRoot without --sourcemap
                 createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "mapRoot", "sourceMap");
             }
@@ -2136,6 +2136,12 @@ namespace ts {
                 }
             }
 
+            if (options.declarationMaps) {
+                if (!options.declaration) {
+                    createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "declarationMaps", "declaration");
+                }
+            }
+
             if (options.lib && options.noLib) {
                 createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "lib", "noLib");
             }

src/compiler/scanner.ts

@@ -330,7 +330,7 @@ namespace ts {
         return result;
     }
 
-    export function getPositionOfLineAndCharacter(sourceFile: SourceFile, line: number, character: number): number {
+    export function getPositionOfLineAndCharacter(sourceFile: SourceFileLike, line: number, character: number): number {
         return computePositionOfLineAndCharacter(getLineStarts(sourceFile), line, character, sourceFile.text);
     }
 

src/compiler/types.ts

@@ -4085,6 +4085,7 @@ namespace ts {
         /** configFile is set as non enumerable property so as to avoid checking of json source files */
         /* @internal */ readonly configFile?: JsonSourceFile;
         declaration?: boolean;
+        declarationMaps?: boolean;
         emitDeclarationOnly?: boolean;
         declarationDir?: string;
         /* @internal */ diagnostics?: boolean;

src/compiler/utilities.ts

@@ -2807,7 +2807,8 @@ namespace ts {
     export interface EmitFileNames {
         jsFilePath: string;
         sourceMapFilePath: string;
-        declarationFilePath: string;
+        declarationFilePath: string | undefined;
+        declarationMapPath: string | undefined;
     }
 
     /**

src/harness/compilerRunner.ts

@@ -148,7 +148,7 @@ class CompilerBaselineRunner extends RunnerBase {
 
             // Source maps?
             it("Correct sourcemap content for " + fileName, () => {
-                if (options.sourceMap || options.inlineSourceMap) {
+                if (options.sourceMap || options.inlineSourceMap || options.declarationMaps) {
                     Harness.Baseline.runBaseline(justName.replace(/\.tsx?$/, ".sourcemap.txt"), () => {
                         const record = result.getSourceMapRecord();
                         if ((options.noEmitOnError && result.errors.length !== 0) || record === undefined) {

src/harness/harness.ts

@@ -1632,14 +1632,15 @@ namespace Harness {
         }
 
         export function doSourcemapBaseline(baselinePath: string, options: ts.CompilerOptions, result: CompilerResult, harnessSettings: TestCaseParser.CompilerSettings) {
+            const declMaps = ts.getAreDeclarationMapsEnabled(options);
             if (options.inlineSourceMap) {
-                if (result.sourceMaps.length > 0) {
+                if (result.sourceMaps.length > 0 && !declMaps) {
                     throw new Error("No sourcemap files should be generated if inlineSourceMaps was set.");
                 }
                 return;
             }
-            else if (options.sourceMap) {
-                if (result.sourceMaps.length !== result.files.length) {
+            else if (options.sourceMap || declMaps) {
+                if (result.sourceMaps.length !== (result.files.length * (declMaps && options.sourceMap ? 2 : 1))) {
                     throw new Error("Number of sourcemap files should be same as js files.");
                 }
 
@@ -1806,6 +1807,10 @@ namespace Harness {
             return ts.endsWith(fileName, ".js.map") || ts.endsWith(fileName, ".jsx.map");
         }
 
+        export function isDTSMap(fileName: string) {
+            return ts.endsWith(fileName, ".d.ts.map");
+        }
+
         /** Contains the code and errors of a compilation and some helper methods to check its status. */
         export class CompilerResult {
             public files: GeneratedFile[] = [];
@@ -1826,7 +1831,7 @@ namespace Harness {
                         // .js file, add to files
                         this.files.push(emittedFile);
                     }
-                    else if (isJSMap(emittedFile.fileName)) {
+                    else if (isJSMap(emittedFile.fileName) || isDTSMap(emittedFile.fileName)) {
                         this.sourceMaps.push(emittedFile);
                     }
                     else {
@@ -1839,7 +1844,7 @@ namespace Harness {
 
             public getSourceMapRecord() {
                 if (this.sourceMapData && this.sourceMapData.length > 0) {
-                    return SourceMapRecorder.getSourceMapRecord(this.sourceMapData, this.program, this.files);
+                    return SourceMapRecorder.getSourceMapRecord(this.sourceMapData, this.program, this.files, this.declFilesCode);
                 }
             }
         }

src/harness/sourceMapRecorder.ts

@@ -434,14 +434,31 @@ namespace Harness.SourceMapRecorder {
         }
     }
 
-    export function getSourceMapRecord(sourceMapDataList: ts.SourceMapData[], program: ts.Program, jsFiles: Compiler.GeneratedFile[]) {
+    export function getSourceMapRecord(sourceMapDataList: ts.SourceMapData[], program: ts.Program, jsFiles: Compiler.GeneratedFile[], declarationFiles: Compiler.GeneratedFile[]) {
         const sourceMapRecorder = new Compiler.WriterAggregator();
 
         for (let i = 0; i < sourceMapDataList.length; i++) {
             const sourceMapData = sourceMapDataList[i];
             let prevSourceFile: ts.SourceFile;
+            let currentFile: Compiler.GeneratedFile;
+            if (ts.endsWith(sourceMapData.sourceMapFile, ts.Extension.Dts)) {
+                if (sourceMapDataList.length > jsFiles.length) {
+                    currentFile = declarationFiles[Math.floor(i / 2)]; // When both kinds of source map are present, they alternate js/dts
+                }
+                else {
+                    currentFile = declarationFiles[i];
+                }
+            }
+            else {
+                if (sourceMapDataList.length > jsFiles.length) {
+                    currentFile = jsFiles[Math.floor(i / 2)];
+                }
+                else {
+                    currentFile = jsFiles[i];
+                }
+            }
 
-            SourceMapSpanWriter.initializeSourceMapSpanWriter(sourceMapRecorder, sourceMapData, jsFiles[i]);
+            SourceMapSpanWriter.initializeSourceMapSpanWriter(sourceMapRecorder, sourceMapData, currentFile);
             for (const decodedSourceMapping of sourceMapData.sourceMapDecodedMappings) {
                 const currentSourceFile = program.getSourceFile(sourceMapData.inputSourceFileNames[decodedSourceMapping.sourceIndex]);
                 if (currentSourceFile !== prevSourceFile) {