microsoft · Jun 1, 2018 · May 21, 2018 · May 22, 2018 · May 22, 2018 · May 23, 2018
diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
@@ -929,7 +929,8 @@ namespace ts {
         }
     }
 
-    function getOptionFromName(optionName: string, allowShort = false): CommandLineOption | undefined {
+    /** @internal */
+    export function getOptionFromName(optionName: string, allowShort = false): CommandLineOption | undefined {
         optionName = optionName.toLowerCase();
         const { optionNameMap, shortOptionNames } = getOptionNameMap();
         // Try to translate short option names to their full equivalents.

diff --git a/src/compiler/core.ts b/src/compiler/core.ts
@@ -2588,6 +2588,22 @@ namespace ts {
         return startsWith(str, prefix) ? str.substr(prefix.length) : str;
     }
 
+    export function tryRemovePrefix(str: string, prefix: string): string | undefined {
+        return startsWith(str, prefix) ? str.substring(prefix.length) : undefined;
+    }
+
+    export function tryRemoveDirectoryPrefix(path: string, dirPath: string): string | undefined {
+        const a = tryRemovePrefix(path, dirPath);
+        if (a === undefined) return undefined;
+        switch (a.charCodeAt(0)) {
+            case CharacterCodes.slash:
+            case CharacterCodes.backslash:
+                return a.slice(1);
+            default:
+                return undefined;
+        }
+    }
+
     export function endsWith(str: string, suffix: string): boolean {
         const expectedPos = str.length - suffix.length;
         return expectedPos >= 0 && str.indexOf(suffix, expectedPos) === expectedPos;
@@ -2597,6 +2613,10 @@ namespace ts {
         return endsWith(str, suffix) ? str.slice(0, str.length - suffix.length) : str;
     }
 
+    export function tryRemoveSuffix(str: string, suffix: string): string | undefined {
+        return endsWith(str, suffix) ? str.slice(0, str.length - suffix.length) : undefined;
+    }
+
     export function stringContains(str: string, substring: string): boolean {
         return str.indexOf(substring) !== -1;
     }
@@ -2797,6 +2817,7 @@ namespace ts {
         basePaths: ReadonlyArray<string>;
     }
 
+    /** @param path directory of the tsconfig.json */
     export function getFileMatcherPatterns(path: string, excludes: ReadonlyArray<string> | undefined, includes: ReadonlyArray<string> | undefined, useCaseSensitiveFileNames: boolean, currentDirectory: string): FileMatcherPatterns {
         path = normalizePath(path);
         currentDirectory = normalizePath(currentDirectory);
@@ -2811,16 +2832,20 @@ namespace ts {
         };
     }
 
+    export function getRegexFromPattern(pattern: string, useCaseSensitiveFileNames: boolean): RegExp {
+        return new RegExp(pattern, useCaseSensitiveFileNames ? "" : "i");
+    }
+
+    /** @param path directory of the tsconfig.json */
     export function matchFiles(path: string, extensions: ReadonlyArray<string> | undefined, excludes: ReadonlyArray<string> | undefined, includes: ReadonlyArray<string> | undefined, useCaseSensitiveFileNames: boolean, currentDirectory: string, depth: number | undefined, getFileSystemEntries: (path: string) => FileSystemEntries): string[] {
         path = normalizePath(path);
         currentDirectory = normalizePath(currentDirectory);
 
         const patterns = getFileMatcherPatterns(path, excludes, includes, useCaseSensitiveFileNames, currentDirectory);
 
-        const regexFlag = useCaseSensitiveFileNames ? "" : "i";
-        const includeFileRegexes = patterns.includeFilePatterns && patterns.includeFilePatterns.map(pattern => new RegExp(pattern, regexFlag));
-        const includeDirectoryRegex = patterns.includeDirectoryPattern && new RegExp(patterns.includeDirectoryPattern, regexFlag);
-        const excludeRegex = patterns.excludePattern && new RegExp(patterns.excludePattern, regexFlag);
+        const includeFileRegexes = patterns.includeFilePatterns && patterns.includeFilePatterns.map(pattern => getRegexFromPattern(pattern, useCaseSensitiveFileNames));
+        const includeDirectoryRegex = patterns.includeDirectoryPattern && getRegexFromPattern(patterns.includeDirectoryPattern, useCaseSensitiveFileNames);
+        const excludeRegex = patterns.excludePattern && getRegexFromPattern(patterns.excludePattern, useCaseSensitiveFileNames);
 
         // Associate an array of results with each include regex. This keeps results in order of the "include" order.
         // If there are no "includes", then just put everything in results[0].

diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
@@ -1087,7 +1087,7 @@ namespace ts {
     }
 
     export function getPropertyAssignment(objectLiteral: ObjectLiteralExpression, key: string, key2?: string): ReadonlyArray<PropertyAssignment> {
-        return filter(objectLiteral.properties, (property): property is PropertyAssignment => {
+        return objectLiteral.properties.filter((property): property is PropertyAssignment => {
             if (property.kind === SyntaxKind.PropertyAssignment) {
                 const propName = getTextOfPropertyName(property.name);
                 return key === propName || (!!key2 && key2 === propName);
@@ -1104,12 +1104,15 @@ namespace ts {
     }
 
     export function getTsConfigPropArrayElementValue(tsConfigSourceFile: TsConfigSourceFile | undefined, propKey: string, elementValue: string): StringLiteral | undefined {
+        return firstDefined(getTsConfigPropArray(tsConfigSourceFile, propKey), property =>
+            isArrayLiteralExpression(property.initializer) ?
+                find(property.initializer.elements, (element): element is StringLiteral => isStringLiteral(element) && element.text === elementValue) :
+                undefined);
+    }
+
+    export function getTsConfigPropArray(tsConfigSourceFile: TsConfigSourceFile | undefined, propKey: string): ReadonlyArray<PropertyAssignment> {
         const jsonObjectLiteral = getTsConfigObjectLiteralExpression(tsConfigSourceFile);
-        return jsonObjectLiteral &&
-            firstDefined(getPropertyAssignment(jsonObjectLiteral, propKey), property =>
-                isArrayLiteralExpression(property.initializer) ?
-                    find(property.initializer.elements, (element): element is StringLiteral => isStringLiteral(element) && element.text === elementValue) :
-                    undefined);
+        return jsonObjectLiteral ? getPropertyAssignment(jsonObjectLiteral, propKey) : emptyArray;
     }
 
     export function getContainingFunction(node: Node): SignatureDeclaration | undefined {

diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts
@@ -3131,8 +3131,12 @@ Actual: ${stringify(fullActual)}`);
             assert(action.name === "Move to a new file" && action.description === "Move to a new file");
 
             const editInfo = this.languageService.getEditsForRefactor(this.activeFile.fileName, this.formatCodeSettings, range, refactor.name, action.name, options.preferences || ts.defaultPreferences)!;
-            for (const edit of editInfo.edits) {
-                const newContent = options.newFileContents[edit.fileName];
+            this.testNewFileContents(editInfo.edits, options.newFileContents);
+        }
+
+        private testNewFileContents(edits: ReadonlyArray<ts.FileTextChanges>, newFileContents: { [fileName: string]: string }): void {
+            for (const edit of edits) {
+                const newContent = newFileContents[edit.fileName];
                 if (newContent === undefined) {
                     this.raiseError(`There was an edit in ${edit.fileName} but new content was not specified.`);
                 }
@@ -3149,8 +3153,8 @@ Actual: ${stringify(fullActual)}`);
                 }
             }
 
-            for (const fileName in options.newFileContents) {
-                assert(editInfo.edits.some(e => e.fileName === fileName));
+            for (const fileName in newFileContents) {
+                assert(edits.some(e => e.fileName === fileName));
             }
         }
 
@@ -3360,12 +3364,8 @@ Actual: ${stringify(fullActual)}`);
         }
 
         public getEditsForFileRename(options: FourSlashInterface.GetEditsForFileRenameOptions): void {
-            const changes = this.languageService.getEditsForFileRename(options.oldPath, options.newPath, this.formatCodeSettings);
-            this.applyChanges(changes);
-            for (const fileName in options.newFileContents) {
-                this.openFile(fileName);
-                this.verifyCurrentFileContent(options.newFileContents[fileName]);
-            }
+            const changes = this.languageService.getEditsForFileRename(options.oldPath, options.newPath, this.formatCodeSettings, ts.defaultPreferences);
+            this.testNewFileContents(changes, options.newFileContents);
         }
 
         private getApplicableRefactors(positionOrRange: number | ts.TextRange, preferences = ts.defaultPreferences): ReadonlyArray<ts.ApplicableRefactorInfo> {

diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts
@@ -8403,15 +8403,23 @@ new C();`
                 path: "/user.ts",
                 content: 'import { x } from "./old";',
             };
+            const newTs: File = {
+                path: "/new.ts",
+                content: "export const x = 0;",
+            };
+            const tsconfig: File = {
+                path: "/tsconfig.json",
+                content: "{}",
+            };
 
-            const host = createServerHost([userTs]);
+            const host = createServerHost([userTs, newTs, tsconfig]);
             const projectService = createProjectService(host);
             projectService.openClientFile(userTs.path);
-            const project = first(projectService.inferredProjects);
+            const project = projectService.configuredProjects.get(tsconfig.path)!;
 
             Debug.assert(!!project.resolveModuleNames);
 
-            const edits = project.getLanguageService().getEditsForFileRename("/old.ts", "/new.ts", testFormatOptions);
+            const edits = project.getLanguageService().getEditsForFileRename("/old.ts", "/new.ts", testFormatOptions, defaultPreferences);
             assert.deepEqual<ReadonlyArray<FileTextChanges>>(edits, [{
                 fileName: "/user.ts",
                 textChanges: [{

diff --git a/src/server/session.ts b/src/server/session.ts
@@ -1695,7 +1695,7 @@ namespace ts.server {
 
         private getEditsForFileRename(args: protocol.GetEditsForFileRenameRequestArgs, simplifiedResult: boolean): ReadonlyArray<protocol.FileCodeEdits> | ReadonlyArray<FileTextChanges> {
             const { file, project } = this.getFileAndProject(args);
-            const changes = project.getLanguageService().getEditsForFileRename(args.oldFilePath, args.newFilePath, this.getFormatOptions(file));
+            const changes = project.getLanguageService().getEditsForFileRename(args.oldFilePath, args.newFilePath, this.getFormatOptions(file), this.getPreferences(file));
             return simplifiedResult ? this.mapTextChangesToCodeEdits(project, changes) : changes;
         }