Merge branch 'master' into watchImprovements

Author: sheetalkamat

src/compiler/checker.ts

@@ -3098,7 +3098,7 @@
         "category": "Message",
         "code": 6132
     },
-    "'{0}' is declared but never used.": {
+    "'{0}' is declared but its value is never read.": {
         "category": "Error",
         "code": 6133
     },
@@ -3118,7 +3118,7 @@
         "category": "Error",
         "code": 6137
     },
-    "Property '{0}' is declared but never used.": {
+    "Property '{0}' is declared but its value is never read.": {
         "category": "Error",
         "code": 6138
     },

src/compiler/diagnosticMessages.json

@@ -21,9 +21,6 @@ namespace ts {
         const compilerOptions = context.getCompilerOptions();
         const languageVersion = getEmitScriptTarget(compilerOptions);
 
-        // These variables contain state that changes as we descend into the tree.
-        let currentSourceFile: SourceFile;
-
         /**
          * Keeps track of whether expression substitution has been enabled for specific edge cases.
          * They are persisted between each SourceFile transformation and should not be reset.
@@ -51,12 +48,8 @@ namespace ts {
                 return node;
             }
 
-            currentSourceFile = node;
-
             const visited = visitEachChild(node, visitor, context);
             addEmitHelpers(visited, context.readEmitHelpers());
-
-            currentSourceFile = undefined;
             return visited;
         }
 

src/compiler/transformers/es2017.ts

@@ -244,7 +244,6 @@ namespace ts {
         const previousOnSubstituteNode = context.onSubstituteNode;
         context.onSubstituteNode = onSubstituteNode;
 
-        let currentSourceFile: SourceFile;
         let renamedCatchVariables: Map<boolean>;
         let renamedCatchVariableDeclarations: Identifier[];
 
@@ -300,12 +299,9 @@ namespace ts {
                 return node;
             }
 
-            currentSourceFile = node;
 
             const visited = visitEachChild(node, visitor, context);
             addEmitHelpers(visited, context.readEmitHelpers());
-
-            currentSourceFile = undefined;
             return visited;
         }
 

src/compiler/transformers/generators.ts

@@ -503,13 +503,11 @@ namespace ts {
             case SyntaxKind.ArrowFunction:
                 return true;
             default:
-                staticAssertNever(node);
+                assertTypeIsNever(node);
                 return false;
         }
     }
 
-    function staticAssertNever(_: never): void {}
-
     // Gets the nearest enclosing block scope container that has the provided node
     // as a descendant, that is not the provided node.
     export function getEnclosingBlockScopeContainer(node: Node): Node {
@@ -3505,6 +3503,46 @@ namespace ts {
         return symbol.exportSymbol ? symbol.exportSymbol.flags | symbol.flags : symbol.flags;
     }
 
+    export function isWriteOnlyAccess(node: Node) {
+        return accessKind(node) === AccessKind.Write;
+    }
+
+    export function isWriteAccess(node: Node) {
+        return accessKind(node) !== AccessKind.Read;
+    }
+
+    const enum AccessKind {
+        /** Only reads from a variable. */
+        Read,
+        /** Only writes to a variable without using the result. E.g.: `x++;`. */
+        Write,
+        /** Writes to a variable and uses the result as an expression. E.g.: `f(x++);`. */
+        ReadWrite
+    }
+    function accessKind(node: Node): AccessKind {
+        const { parent } = node;
+        if (!parent) return AccessKind.Read;
+
+        switch (parent.kind) {
+            case SyntaxKind.PostfixUnaryExpression:
+            case SyntaxKind.PrefixUnaryExpression:
+                const { operator } = parent as PrefixUnaryExpression | PostfixUnaryExpression;
+                return operator === SyntaxKind.PlusPlusToken || operator === SyntaxKind.MinusMinusToken ? writeOrReadWrite() : AccessKind.Read;
+            case SyntaxKind.BinaryExpression:
+                const { left, operatorToken } = parent as BinaryExpression;
+                return left === node && isAssignmentOperator(operatorToken.kind) ? writeOrReadWrite() : AccessKind.Read;
+            case SyntaxKind.PropertyAccessExpression:
+                return (parent as PropertyAccessExpression).name !== node ? AccessKind.Read : accessKind(parent);
+            default:
+                return AccessKind.Read;
+        }
+
+        function writeOrReadWrite(): AccessKind {
+            // If grandparent is not an ExpressionStatement, this is used as an expression in addition to having a side effect.
+            return parent.parent && parent.parent.kind === SyntaxKind.ExpressionStatement ? AccessKind.Write : AccessKind.ReadWrite;
+        }
+    }
+
     export function compareDataObjects(dst: any, src: any): boolean {
         if (!dst || !src || Object.keys(dst).length !== Object.keys(src).length) {
             return false;

src/compiler/utilities.ts

@@ -239,8 +239,7 @@ namespace ts {
         let program: Program;
         let needsReload: boolean;                                           // true if the config file changed and needs to reload it from the disk
         let missingFilesMap: Map<FileWatcher>;                              // Map of file watchers for the missing files
-        let configFileWatcher: FileWatcher;                                 // watcher for the config file
-        let watchedWildcardDirectories: Map<WildcardDirectoryWatcher>;     // map of watchers for the wild card directories in the config file
+        let watchedWildcardDirectories: Map<WildcardDirectoryWatcher>;      // map of watchers for the wild card directories in the config file
         let timerToUpdateProgram: any;                                      // timer callback to recompile the program
 
         const sourceFilesCache = createMap<HostFileInfo | string>();        // Cache that stores the source file and version info
@@ -259,7 +258,7 @@ namespace ts {
 
         const partialSystem = configFileName ? createCachedPartialSystem(system) : system;
         if (configFileName) {
-            configFileWatcher = watchFile(system, configFileName, scheduleProgramReload, writeLog);
+            watchFile(system, configFileName, scheduleProgramReload, writeLog);
         }
 
         const getCurrentDirectory = memoize(() => partialSystem.getCurrentDirectory());

src/compiler/watchedProgram.ts

@@ -11,19 +11,13 @@ const enum CompilerTestType {
 class CompilerBaselineRunner extends RunnerBase {
     private basePath = "tests/cases";
     private testSuiteName: TestRunnerKind;
-    private errors: boolean;
     private emit: boolean;
-    private decl: boolean;
-    private output: boolean;
 
     public options: string;
 
     constructor(public testType: CompilerTestType) {
         super();
-        this.errors = true;
         this.emit = true;
-        this.decl = true;
-        this.output = true;
         if (testType === CompilerTestType.Conformance) {
             this.testSuiteName = "conformance";
         }
@@ -214,26 +208,14 @@ class CompilerBaselineRunner extends RunnerBase {
 
     private parseOptions() {
         if (this.options && this.options.length > 0) {
-            this.errors = false;
             this.emit = false;
-            this.decl = false;
-            this.output = false;
 
             const opts = this.options.split(",");
             for (let i = 0; i < opts.length; i++) {
                 switch (opts[i]) {
-                    case "error":
-                        this.errors = true;
-                        break;
                     case "emit":
                         this.emit = true;
                         break;
-                    case "decl":
-                        this.decl = true;
-                        break;
-                    case "output":
-                        this.output = true;
-                        break;
                     default:
                         throw new Error("unsupported flag");
                 }

src/harness/compilerRunner.ts

@@ -2758,11 +2758,11 @@ namespace FourSlash {
             }
         }
 
-        private getSelection() {
-            return ({
+        private getSelection(): ts.TextRange {
+            return {
                 pos: this.currentCaretPosition,
                 end: this.selectionEnd === -1 ? this.currentCaretPosition : this.selectionEnd
-            });
+            };
         }
 
         public verifyRefactorAvailable(negative: boolean, name: string, actionName?: string) {
@@ -2803,7 +2803,7 @@ namespace FourSlash {
             }
         }
 
-        public applyRefactor({ refactorName, actionName, actionDescription }: FourSlashInterface.ApplyRefactorOptions) {
+        public applyRefactor({ refactorName, actionName, actionDescription, newContent: newContentWithRenameMarker }: FourSlashInterface.ApplyRefactorOptions) {
             const range = this.getSelection();
             const refactors = this.languageService.getApplicableRefactors(this.activeFile.fileName, range);
             const refactor = refactors.find(r => r.name === refactorName);
@@ -2823,6 +2823,35 @@ namespace FourSlash {
             for (const edit of editInfo.edits) {
                 this.applyEdits(edit.fileName, edit.textChanges, /*isFormattingEdit*/ false);
             }
+
+            const { renamePosition, newContent } = parseNewContent();
+
+            this.verifyCurrentFileContent(newContent);
+
+            if (renamePosition === undefined) {
+                if (editInfo.renameLocation !== undefined) {
+                    this.raiseError(`Did not expect a rename location, got ${editInfo.renameLocation}`);
+                }
+            }
+            else {
+                // TODO: test editInfo.renameFilename value
+                assert.isDefined(editInfo.renameFilename);
+                if (renamePosition !== editInfo.renameLocation) {
+                    this.raiseError(`Expected rename position of ${renamePosition}, but got ${editInfo.renameLocation}`);
+                }
+            }
+
+            function parseNewContent(): { renamePosition: number | undefined, newContent: string } {
+                const renamePosition = newContentWithRenameMarker.indexOf("/*RENAME*/");
+                if (renamePosition === -1) {
+                    return { renamePosition: undefined, newContent: newContentWithRenameMarker };
+                }
+                else {
+                    const newContent = newContentWithRenameMarker.slice(0, renamePosition) + newContentWithRenameMarker.slice(renamePosition + "/*RENAME*/".length);
+                    return { renamePosition, newContent };
+                }
+            }
+
         }
 
         public verifyFileAfterApplyingRefactorAtMarker(
@@ -4319,6 +4348,7 @@ namespace FourSlashInterface {
         refactorName: string;
         actionName: string;
         actionDescription: string;
+        newContent: string;
     }
 
     export interface CompletionsAtOptions {

src/harness/fourslash.ts

@@ -216,8 +216,8 @@ if (taskConfigsFolder) {
 
     for (let i = 0; i < workerCount; i++) {
         const config = workerConfigs[i];
-        // use last worker to run unit tests
-        config.runUnitTests = i === workerCount - 1;
+        // use last worker to run unit tests if we're not just running a single specific runner
+        config.runUnitTests = runners.length !== 1 && i === workerCount - 1;
         Harness.IO.writeFile(ts.combinePaths(taskConfigsFolder, `task-config${i}.json`), JSON.stringify(workerConfigs[i]));
     }
 }

src/harness/runner.ts

@@ -263,7 +263,7 @@ class RWCRunner extends RunnerBase {
      */
     public initializeTests(): void {
         // Read in and evaluate the test list
-        const testList = this.enumerateTestFiles();
+        const testList = this.tests && this.tests.length ? this.tests : this.enumerateTestFiles();
         for (let i = 0; i < testList.length; i++) {
             this.runTest(testList[i]);
         }