Merge branch 'master' into qualified-name-param-tag-error

Author: Gabriela Britto

completionAtDottedNamespace.ts

@@ -0,0 +1,5 @@
+/// <reference path='fourslash.ts'/>
+
+////namespace wwer./**/w
+
+verify.completions({ marker: "", exact: [], isNewIdentifierLocation: true });

scripts/build/baselineAccept.js

@@ -12,7 +12,7 @@ function baselineAccept(subfolder = "") {
 }
 
 function baselineCopy(subfolder = "") {
-    return gulp.src([`${localBaseline}${subfolder ? `${subfolder}/` : ``}**`, `!${localBaseline}${subfolder}/**/*.delete`], { base: localBaseline, read: false })
+    return gulp.src([`${localBaseline}${subfolder ? `${subfolder}/` : ``}**`, `!${localBaseline}${subfolder}/**/*.delete`], { base: localBaseline })
         .pipe(gulp.dest(refBaseline));
 }
 
@@ -21,4 +21,4 @@ function baselineDelete(subfolder = "") {
         .pipe(rm())
         .pipe(rename({ extname: "" }))
         .pipe(rm(refBaseline));
-}
+}

src/compiler/checker.ts

@@ -1776,7 +1776,7 @@
         "category": "Error",
         "code": 2496
     },
-    "Module '{0}' resolves to a non-module entity and cannot be imported using this construct.": {
+    "This module can only be referenced with ECMAScript imports/exports by turning on the '{0}' flag and referencing its default export.": {
         "category": "Error",
         "code": 2497
     },

src/compiler/diagnosticMessages.json

@@ -1898,6 +1898,7 @@ namespace ts {
                         case SyntaxKind.StringLiteral:
                             return createIdentifier("String");
 
+                        case SyntaxKind.PrefixUnaryExpression:
                         case SyntaxKind.NumericLiteral:
                             return createIdentifier("Number");
 

src/compiler/transformers/ts.ts

@@ -3916,7 +3916,9 @@ namespace ts {
         aliasTypeArguments?: ReadonlyArray<Type>;     // Alias type arguments (if any)
         /* @internal */ aliasTypeArgumentsContainsMarker?: boolean;   // Alias type arguments (if any)
         /* @internal */
-        wildcardInstantiation?: Type;    // Instantiation with type parameters mapped to wildcard type
+        permissiveInstantiation?: Type;  // Instantiation with type parameters mapped to wildcard type
+        /* @internal */
+        restrictiveInstantiation?: Type; // Instantiation with type parameters mapped to unconstrained form
         /* @internal */
         immediateBaseConstraint?: Type;  // Immediate base constraint cache
     }

src/compiler/types.ts

@@ -2008,7 +2008,7 @@ namespace ts.server {
             const path = toNormalizedPath(uncheckedFileName);
             const info = this.getScriptInfoForNormalizedPath(path);
             if (info) return info;
-            const configProject = this.configuredProjects.get(uncheckedFileName);
+            const configProject = this.configuredProjects.get(this.toPath(uncheckedFileName));
             return configProject && configProject.getCompilerOptions().configFile;
         }
 

src/server/editorServices.ts

@@ -104,7 +104,7 @@ namespace ts.Completions {
             getJSCompletionEntries(sourceFile, location!.pos, uniqueNames, compilerOptions.target!, entries); // TODO: GH#18217
         }
         else {
-            if ((!symbols || symbols.length === 0) && keywordFilters === KeywordCompletionFilters.None) {
+            if (!isNewIdentifierLocation && (!symbols || symbols.length === 0) && keywordFilters === KeywordCompletionFilters.None) {
                 return undefined;
             }
 

src/services/completions.ts

@@ -151,7 +151,7 @@ namespace ts {
                     const toImport = oldFromNew !== undefined
                         // If we're at the new location (file was already renamed), need to redo module resolution starting from the old location.
                         // TODO:GH#18217
-                        ? getSourceFileToImportFromResolved(resolveModuleName(importLiteral.text, oldImportFromPath, program.getCompilerOptions(), host as ModuleResolutionHost), oldToNew, host)
+                        ? getSourceFileToImportFromResolved(resolveModuleName(importLiteral.text, oldImportFromPath, program.getCompilerOptions(), host as ModuleResolutionHost), oldToNew)
                         : getSourceFileToImport(importedModuleSymbol, importLiteral, sourceFile, program, host, oldToNew);
 
                     // Need an update if the imported file moved, or the importing file moved and was using a relative path.
@@ -192,28 +192,35 @@ namespace ts {
             const resolved = host.resolveModuleNames
                 ? host.getResolvedModuleWithFailedLookupLocationsFromCache && host.getResolvedModuleWithFailedLookupLocationsFromCache(importLiteral.text, importingSourceFile.fileName)
                 : program.getResolvedModuleWithFailedLookupLocationsFromCache(importLiteral.text, importingSourceFile.fileName);
-            return getSourceFileToImportFromResolved(resolved, oldToNew, host);
+            return getSourceFileToImportFromResolved(resolved, oldToNew);
         }
     }
 
-    function getSourceFileToImportFromResolved(resolved: ResolvedModuleWithFailedLookupLocations | undefined, oldToNew: PathUpdater, host: LanguageServiceHost): ToImport | undefined {
+    function getSourceFileToImportFromResolved(resolved: ResolvedModuleWithFailedLookupLocations | undefined, oldToNew: PathUpdater): ToImport | undefined {
         // Search through all locations looking for a moved file, and only then test already existing files.
         // This is because if `a.ts` is compiled to `a.js` and `a.ts` is moved, we don't want to resolve anything to `a.js`, but to `a.ts`'s new location.
-        return tryEach(tryGetNewFile) || tryEach(tryGetOldFile);
+        if (!resolved) return undefined;
 
-        function tryEach(cb: (oldFileName: string) => ToImport | undefined): ToImport | undefined {
-            return resolved && (
-                (resolved.resolvedModule && cb(resolved.resolvedModule.resolvedFileName)) || firstDefined(resolved.failedLookupLocations, cb));
+        // First try resolved module
+        if (resolved.resolvedModule) {
+            const result = tryChange(resolved.resolvedModule.resolvedFileName);
+            if (result) return result;
         }
 
-        function tryGetNewFile(oldFileName: string): ToImport | undefined {
-            const newFileName = oldToNew(oldFileName);
-            return newFileName !== undefined && host.fileExists!(newFileName) ? { newFileName, updated: true } : undefined; // TODO: GH#18217
+        // Then failed lookups except package.json since we dont want to touch them (only included ts/js files)
+        const result = forEach(resolved.failedLookupLocations, tryChangeWithIgnoringPackageJson);
+        if (result) return result;
+
+        // If nothing changed, then result is resolved module file thats not updated
+        return resolved.resolvedModule && { newFileName: resolved.resolvedModule.resolvedFileName, updated: false };
+
+        function tryChangeWithIgnoringPackageJson(oldFileName: string) {
+            return !endsWith(oldFileName, "/package.json") ? tryChange(oldFileName) : undefined;
         }
 
-        function tryGetOldFile(oldFileName: string): ToImport | undefined {
+        function tryChange(oldFileName: string) {
             const newFileName = oldToNew(oldFileName);
-            return host.fileExists!(oldFileName) ? newFileName !== undefined ? { newFileName, updated: true } : { newFileName: oldFileName, updated: false } : undefined; // TODO: GH#18217
+            return newFileName && { newFileName, updated: true };
         }
     }
 

src/services/getEditsForFileRename.ts

@@ -116,5 +116,40 @@ namespace ts.projectSystem {
                 renameLocation: undefined,
             });
         });
+
+        it("handles canonicalization of tsconfig path", () => {
+            const aTs: File = { path: "/Foo/a.ts", content: "const x = 0;" };
+            const tsconfig: File = { path: "/Foo/tsconfig.json", content: '{ "files": ["./a.ts"] }' };
+            const session = createSession(createServerHost([aTs, tsconfig]));
+            openFilesForSession([aTs], session);
+
+            const result = executeSessionRequest<protocol.GetEditsForRefactorRequest, protocol.GetEditsForRefactorResponse>(session, protocol.CommandTypes.GetEditsForRefactor, {
+                file: aTs.path,
+                startLine: 1,
+                startOffset: 1,
+                endLine: 2,
+                endOffset: aTs.content.length,
+                refactor: "Move to a new file",
+                action: "Move to a new file",
+            });
+            assert.deepEqual<protocol.RefactorEditInfo | undefined>(result, {
+                edits: [
+                    {
+                        fileName: aTs.path,
+                        textChanges: [{ start: { line: 1, offset: 1 }, end: { line: 1, offset: aTs.content.length + 1 }, newText: "" }],
+                    },
+                    {
+                        fileName: tsconfig.path,
+                        textChanges: [{ start: { line: 1, offset: 21 }, end: { line: 1, offset: 21 }, newText: ', "./x.ts"' }],
+                    },
+                    {
+                        fileName: "/Foo/x.ts",
+                        textChanges: [{ start: { line: 0, offset: 0 }, end: { line: 0, offset: 0 }, newText: "const x = 0;\n" }],
+                    },
+                ],
+                renameFilename: undefined,
+                renameLocation: undefined,
+            });
+        });
     });
 }