Merge branch 'master' into esau-squash

# Conflicts:
#	tests/baselines/reference/api/typescript.d.ts

Author: RyanCavanaugh

src/compiler/binder.ts

@@ -2305,18 +2305,22 @@ namespace ts {
         }
 
         function setCommonJsModuleIndicator(node: Node) {
+            if (file.externalModuleIndicator) {
+                return false;
+            }
             if (!file.commonJsModuleIndicator) {
                 file.commonJsModuleIndicator = node;
-                if (!file.externalModuleIndicator) {
-                    bindSourceFileAsExternalModule();
-                }
+                bindSourceFileAsExternalModule();
             }
+            return true;
         }
 
         function bindExportsPropertyAssignment(node: BinaryExpression) {
             // When we create a property via 'exports.foo = bar', the 'exports.foo' property access
             // expression is the declaration
-            setCommonJsModuleIndicator(node);
+            if (!setCommonJsModuleIndicator(node)) {
+                return;
+            }
             const lhs = node.left as PropertyAccessEntityNameExpression;
             const symbol = forEachIdentifierInEntityName(lhs.expression, /*parent*/ undefined, (id, symbol) => {
                 if (symbol) {
@@ -2337,15 +2341,15 @@ namespace ts {
             // is still pointing to 'module.exports'.
             // We do not want to consider this as 'export=' since a module can have only one of these.
             // Similarly we do not want to treat 'module.exports = exports' as an 'export='.
+            if (!setCommonJsModuleIndicator(node)) {
+                return;
+            }
             const assignedExpression = getRightMostAssignedExpression(node.right);
             if (isEmptyObjectLiteral(assignedExpression) || container === file && isExportsOrModuleExportsOrAlias(file, assignedExpression)) {
-                // Mark it as a module in case there are no other exports in the file
-                setCommonJsModuleIndicator(node);
                 return;
             }
 
             // 'module.exports = expr' assignment
-            setCommonJsModuleIndicator(node);
             const flags = exportAssignmentIsAlias(node)
                 ? SymbolFlags.Alias // An export= with an EntityNameExpression or a ClassExpression exports all meanings of that identifier or class
                 : SymbolFlags.Property | SymbolFlags.ExportValue | SymbolFlags.ValueModule;

src/compiler/factory.ts

@@ -2587,18 +2587,41 @@ namespace ts {
         return node;
     }
 
-    export function createUnparsedSourceFile(text: string, map?: string): UnparsedSource {
+    export function createUnparsedSourceFile(text: string): UnparsedSource;
+    export function createUnparsedSourceFile(text: string, mapPath: string | undefined, map: string | undefined): UnparsedSource;
+    export function createUnparsedSourceFile(text: string, mapPath?: string, map?: string): UnparsedSource {
         const node = <UnparsedSource>createNode(SyntaxKind.UnparsedSource);
         node.text = text;
+        node.sourceMapPath = mapPath;
         node.sourceMapText = map;
         return node;
     }
-
-    export function createInputFiles(javascript: string, declaration: string, javascriptMapText?: string, declarationMapText?: string): InputFiles {
+    export function createInputFiles(
+        javascript: string,
+        declaration: string
+    ): InputFiles;
+    export function createInputFiles(
+        javascript: string,
+        declaration: string,
+        javascriptMapPath: string | undefined,
+        javascriptMapText: string | undefined,
+        declarationMapPath: string | undefined,
+        declarationMapText: string | undefined
+    ): InputFiles;
+    export function createInputFiles(
+        javascript: string,
+        declaration: string,
+        javascriptMapPath?: string,
+        javascriptMapText?: string,
+        declarationMapPath?: string,
+        declarationMapText?: string
+    ): InputFiles {
         const node = <InputFiles>createNode(SyntaxKind.InputFiles);
         node.javascriptText = javascript;
+        node.javascriptMapPath = javascriptMapPath;
         node.javascriptMapText = javascriptMapText;
         node.declarationText = declaration;
+        node.declarationMapPath = declarationMapPath;
         node.declarationMapText = declarationMapText;
         return node;
     }

src/compiler/moduleSpecifiers.ts

@@ -133,15 +133,16 @@ namespace ts.moduleSpecifiers {
         return firstDefined(imports, ({ text }) => pathIsRelative(text) ? fileExtensionIs(text, Extension.Js) : undefined) || false;
     }
 
-    function discoverProbableSymlinks(files: ReadonlyArray<SourceFile>) {
+    function discoverProbableSymlinks(files: ReadonlyArray<SourceFile>, getCanonicalFileName: (file: string) => string, host: ModuleSpecifierResolutionHost) {
         const symlinks = mapDefined(files, sf =>
             sf.resolvedModules && firstDefinedIterator(sf.resolvedModules.values(), res =>
                 res && res.originalPath && res.resolvedFileName !== res.originalPath ? [res.resolvedFileName, res.originalPath] : undefined));
         const result = createMap<string>();
         if (symlinks) {
+            const currentDirectory = host.getCurrentDirectory ? host.getCurrentDirectory() : "";
             for (const [resolvedPath, originalPath] of symlinks) {
-                const resolvedParts = getPathComponents(resolvedPath);
-                const originalParts = getPathComponents(originalPath);
+                const resolvedParts = getPathComponents(toPath(resolvedPath, currentDirectory, getCanonicalFileName));
+                const originalParts = getPathComponents(toPath(originalPath, currentDirectory, getCanonicalFileName));
                 while (resolvedParts[resolvedParts.length - 1] === originalParts[originalParts.length - 1]) {
                     resolvedParts.pop();
                     originalParts.pop();
@@ -153,12 +154,13 @@ namespace ts.moduleSpecifiers {
     }
 
     function getAllModulePathsUsingIndirectSymlinks(files: ReadonlyArray<SourceFile>, target: string, getCanonicalFileName: (file: string) => string, host: ModuleSpecifierResolutionHost) {
-        const links = discoverProbableSymlinks(files);
+        const links = discoverProbableSymlinks(files, getCanonicalFileName, host);
         const paths = arrayFrom(links.keys());
         let options: string[] | undefined;
+        const compareStrings = (!host.useCaseSensitiveFileNames || host.useCaseSensitiveFileNames()) ? compareStringsCaseSensitive : compareStringsCaseInsensitive;
         for (const path of paths) {
             const resolved = links.get(path)!;
-            if (startsWith(target, resolved + "/")) {
+            if (compareStrings(target.slice(0, resolved.length + 1), resolved + "/") === Comparison.EqualTo) {
                 const relative = getRelativePathFromDirectory(resolved, target, getCanonicalFileName);
                 const option = resolvePath(path, relative);
                 if (!host.fileExists || host.fileExists(option)) {
@@ -167,12 +169,11 @@ namespace ts.moduleSpecifiers {
                 }
             }
         }
-        const resolvedtarget = host.getCurrentDirectory ? resolvePath(host.getCurrentDirectory(), target) : target;
         if (options) {
-            options.push(resolvedtarget); // Since these are speculative, we also include the original resolved name as a possibility
+            options.push(target); // Since these are speculative, we also include the original resolved name as a possibility
             return options;
         }
-        return [resolvedtarget];
+        return [target];
     }
 
     /**
@@ -183,7 +184,7 @@ namespace ts.moduleSpecifiers {
         const symlinks = mapDefined(files, sf =>
             sf.resolvedModules && firstDefinedIterator(sf.resolvedModules.values(), res =>
                 res && res.resolvedFileName === fileName ? res.originalPath : undefined));
-        return symlinks.length === 0 ? getAllModulePathsUsingIndirectSymlinks(files, fileName, getCanonicalFileName, host) : symlinks;
+        return symlinks.length === 0 ? getAllModulePathsUsingIndirectSymlinks(files, getNormalizedAbsolutePath(fileName, host.getCurrentDirectory ? host.getCurrentDirectory() : ""), getCanonicalFileName, host) : symlinks;
     }
 
     function getRelativePathNParents(relativePath: string): number {

src/compiler/program.ts

@@ -1240,10 +1240,12 @@ namespace ts {
 
                     const dtsFilename = changeExtension(resolvedRefOpts.options.outFile, ".d.ts");
                     const js = host.readFile(resolvedRefOpts.options.outFile) || `/* Input file ${resolvedRefOpts.options.outFile} was missing */\r\n`;
-                    const jsMap = host.readFile(resolvedRefOpts.options.outFile + ".map"); // TODO: try to read sourceMappingUrl comment from the js file
+                    const jsMapPath = resolvedRefOpts.options.outFile + ".map"; // TODO: try to read sourceMappingUrl comment from the file
+                    const jsMap = host.readFile(jsMapPath);
                     const dts = host.readFile(dtsFilename) || `/* Input file ${dtsFilename} was missing */\r\n`;
-                    const dtsMap = host.readFile(dtsFilename + ".map");
-                    const node = createInputFiles(js, dts, jsMap, dtsMap);
+                    const dtsMapPath = dtsFilename + ".map";
+                    const dtsMap = host.readFile(dtsMapPath);
+                    const node = createInputFiles(js, dts, jsMap && jsMapPath, jsMap, dtsMap && dtsMapPath, dtsMap);
                     nodes.push(node);
                 }
             }

src/compiler/sourcemap.ts

@@ -99,10 +99,6 @@ namespace ts {
         let sourceMapDataList: SourceMapData[] | undefined;
         let disabled: boolean = !(compilerOptions.sourceMap || compilerOptions.inlineSourceMap);
 
-        let completedSections: SourceMapSectionDefinition[];
-        let sectionStartLine: number;
-        let sectionStartColumn: number;
-
         return {
             initialize,
             reset,
@@ -150,9 +146,6 @@ namespace ts {
             lastEncodedNameIndex = 0;
 
             // Initialize source map data
-            completedSections = [];
-            sectionStartLine = 1;
-            sectionStartColumn = 1;
             sourceMapData = {
                 sourceMapFilePath,
                 jsSourceMappingURL: !compilerOptions.inlineSourceMap ? getBaseFileName(normalizeSlashes(sourceMapFilePath)) : undefined!, // TODO: GH#18217
@@ -221,9 +214,6 @@ namespace ts {
             lastEncodedNameIndex = undefined;
             sourceMapData = undefined!;
             sourceMapDataList = undefined!;
-            completedSections = undefined!;
-            sectionStartLine = undefined!;
-            sectionStartColumn = undefined!;
         }
 
         interface SourceMapSection {
@@ -233,7 +223,7 @@ namespace ts {
             sources: string[];
             names?: string[];
             mappings: string;
-            sourcesContent?: string[];
+            sourcesContent?: (string | null)[];
             sections?: undefined;
         }
 
@@ -261,26 +251,6 @@ namespace ts {
             };
         }
 
-        function resetSectionalData(): void {
-            sourceMapData.sourceMapSources = [];
-            sourceMapData.sourceMapNames = [];
-            sourceMapData.sourceMapMappings = "";
-            sourceMapData.sourceMapSourcesContent = compilerOptions.inlineSources ? [] : undefined;
-        }
-
-        function generateMap(): SourceMap {
-            if (completedSections.length) {
-                captureSectionalSpanIfNeeded(/*reset*/ false);
-                return {
-                    version: 3,
-                    file: sourceMapData.sourceMapFile,
-                    sections: completedSections
-                };
-            }
-            else {
-                return captureSection();
-            }
-        }
 
         // Encoding for sourcemap span
         function encodeLastRecordedSourceMapSpan() {
@@ -350,8 +320,8 @@ namespace ts {
             sourceLinePos.line++;
             sourceLinePos.character++;
 
-            const emittedLine = writer.getLine() - sectionStartLine + 1;
-            const emittedColumn = emittedLine === 0 ? (writer.getColumn() - sectionStartColumn + 1) : writer.getColumn();
+            const emittedLine = writer.getLine();
+            const emittedColumn = writer.getColumn();
 
             // If this location wasn't recorded or the location in source is going backwards, record the span
             if (!lastRecordedSourceMapSpan ||
@@ -386,13 +356,8 @@ namespace ts {
             }
         }
 
-        function captureSectionalSpanIfNeeded(reset: boolean) {
-            if (lastRecordedSourceMapSpan && lastRecordedSourceMapSpan === lastEncodedSourceMapSpan) { // If we've recorded some spans, save them
-                completedSections.push({ offset: { line: sectionStartLine - 1, column: sectionStartColumn - 1 }, map: captureSection() });
-                if (reset) {
-                    resetSectionalData();
-                }
-            }
+        function isPossiblySourceMap(x: {}): x is SourceMapSection {
+            return typeof x === "object" && !!(x as any).mappings && typeof (x as any).mappings === "string" && !!(x as any).sources;
         }
 
         /**
@@ -409,7 +374,6 @@ namespace ts {
 
             if (node) {
                 if (isUnparsedSource(node) && node.sourceMapText !== undefined) {
-                    captureSectionalSpanIfNeeded(/*reset*/ true);
                     const text = node.sourceMapText;
                     let parsed: {} | undefined;
                     try {
@@ -418,24 +382,41 @@ namespace ts {
                     catch {
                         // empty
                     }
-                    const offset = { line: writer.getLine() - 1, column: writer.getColumn() - 1 };
-                    completedSections.push(parsed
-                        ? {
-                            offset,
-                            map: parsed as SourceMap
-                        }
-                        : {
-                            offset,
-                            // This is just passes the buck on sourcemaps we don't really understand, instead of issuing an error (which would be difficult this late)
-                            url: `data:application/json;charset=utf-8;base64,${base64encode(sys, text)}`
-                        }
-                    );
-                    const emitResult = emitCallback(hint, node);
-                    sectionStartLine = writer.getLine();
-                    sectionStartColumn = writer.getColumn();
-                    lastRecordedSourceMapSpan = undefined!;
-                    lastEncodedSourceMapSpan = defaultLastEncodedSourceMapSpan;
-                    return emitResult;
+                    if (!parsed || !isPossiblySourceMap(parsed)) {
+                        return emitCallback(hint, node);
+                    }
+                    const offsetLine = writer.getLine();
+                    const firstLineColumnOffset = writer.getColumn();
+                    // First, decode the old component sourcemap
+                    const originalMap = parsed;
+                    sourcemaps.calculateDecodedMappings(originalMap, (raw): void => {
+                        // Apply offsets to each position and fixup source entries
+                        const rawPath = originalMap.sources[raw.sourceIndex];
+                        const relativePath = originalMap.sourceRoot ? combinePaths(originalMap.sourceRoot, rawPath) : rawPath;
+                        const combinedPath = combinePaths(getDirectoryPath(node.sourceMapPath!), relativePath);
+                        const sourcesDirectoryPath = compilerOptions.sourceRoot ? host.getCommonSourceDirectory() : sourceMapDir;
+                        const resolvedPath = getRelativePathToDirectoryOrUrl(
+                            sourcesDirectoryPath,
+                            combinedPath,
+                            host.getCurrentDirectory(),
+                            host.getCanonicalFileName,
+                            /*isAbsolutePathAnUrl*/ true
+                        );
+                        const absolutePath = toPath(resolvedPath, sourcesDirectoryPath, host.getCanonicalFileName);
+                        // tslint:disable-next-line:no-null-keyword
+                        setupSourceEntry(absolutePath, originalMap.sourcesContent ? originalMap.sourcesContent[raw.sourceIndex] : null); // TODO: Lookup content for inlining?
+                        const newIndex = sourceMapData.sourceMapSources.indexOf(resolvedPath);
+                        // Then reencode all the updated spans into the overall map
+                        encodeLastRecordedSourceMapSpan();
+                        lastRecordedSourceMapSpan = {
+                            ...raw,
+                            emittedLine: raw.emittedLine + offsetLine - 1,
+                            emittedColumn: raw.emittedLine === 0 ? (raw.emittedColumn + firstLineColumnOffset - 1) : raw.emittedColumn,
+                            sourceIndex: newIndex,
+                        };
+                    });
+                    // And actually emit the text these sourcemaps are for
+                    return emitCallback(hint, node);
                 }
                 const emitNode = node.emitNode;
                 const emitFlags = emitNode && emitNode.flags || EmitFlags.None;
@@ -529,13 +510,17 @@ namespace ts {
                 return;
             }
 
+            setupSourceEntry(sourceFile.fileName, sourceFile.text);
+        }
+
+        function setupSourceEntry(fileName: string, content: string | null) {
             // Add the file to tsFilePaths
             // If sourceroot option: Use the relative path corresponding to the common directory path
             // otherwise source locations relative to map file location
             const sourcesDirectoryPath = compilerOptions.sourceRoot ? host.getCommonSourceDirectory() : sourceMapDir;
 
             const source = getRelativePathToDirectoryOrUrl(sourcesDirectoryPath,
-                currentSource.fileName,
+                fileName,
                 host.getCurrentDirectory(),
                 host.getCanonicalFileName,
                 /*isAbsolutePathAnUrl*/ true);
@@ -546,10 +531,10 @@ namespace ts {
                 sourceMapData.sourceMapSources.push(source);
 
                 // The one that can be used from program to get the actual source file
-                sourceMapData.inputSourceFileNames.push(currentSource.fileName);
+                sourceMapData.inputSourceFileNames.push(fileName);
 
                 if (compilerOptions.inlineSources) {
-                    sourceMapData.sourceMapSourcesContent!.push(currentSource.text);
+                    sourceMapData.sourceMapSourcesContent!.push(content);
                 }
             }
         }
@@ -564,7 +549,7 @@ namespace ts {
 
             encodeLastRecordedSourceMapSpan();
 
-            return JSON.stringify(generateMap());
+            return JSON.stringify(captureSection());
         }
 
         /**