Merge branch 'main' into rewrite-extensions

Author: andrewbranch

.dprint.jsonc

@@ -53,7 +53,7 @@
     // Note: if adding new languages, make sure settings.template.json is updated too.
     // Also, if updating typescript, update the one in package.json.
     "plugins": [
-        "https://plugins.dprint.dev/typescript-0.91.7.wasm",
+        "https://plugins.dprint.dev/typescript-0.91.8.wasm",
         "https://plugins.dprint.dev/json-0.19.3.wasm",
         "https://plugins.dprint.dev/g-plane/pretty_yaml-v0.5.0.wasm"
     ]

package-lock.json

@@ -40,9 +40,9 @@
     ],
     "devDependencies": {
         "@dprint/formatter": "^0.4.1",
-        "@dprint/typescript": "0.91.7",
+        "@dprint/typescript": "0.91.8",
         "@esfx/canceltoken": "^1.0.0",
-        "@eslint/js": "^9.9.1",
+        "@eslint/js": "^9.10.0",
         "@octokit/rest": "^21.0.2",
         "@types/chai": "^4.3.19",
         "@types/diff": "^5.2.2",
@@ -52,9 +52,9 @@
         "@types/node": "latest",
         "@types/source-map-support": "^0.5.10",
         "@types/which": "^3.0.4",
-        "@typescript-eslint/rule-tester": "^8.3.0",
-        "@typescript-eslint/type-utils": "^8.3.0",
-        "@typescript-eslint/utils": "^8.3.0",
+        "@typescript-eslint/rule-tester": "^8.5.0",
+        "@typescript-eslint/type-utils": "^8.5.0",
+        "@typescript-eslint/utils": "^8.5.0",
         "azure-devops-node-api": "^14.0.2",
         "c8": "^10.1.2",
         "chai": "^4.5.0",
@@ -63,26 +63,25 @@
         "diff": "^5.2.0",
         "dprint": "^0.47.2",
         "esbuild": "^0.23.1",
-        "eslint": "^9.9.1",
+        "eslint": "^9.10.0",
         "eslint-formatter-autolinkable-stylish": "^1.4.0",
         "eslint-plugin-regexp": "^2.6.0",
-        "fast-xml-parser": "^4.4.1",
+        "fast-xml-parser": "^4.5.0",
         "glob": "^10.4.5",
         "globals": "^15.9.0",
         "hereby": "^1.9.0",
         "jsonc-parser": "^3.3.1",
-        "knip": "^5.27.5",
+        "knip": "^5.30.1",
         "minimist": "^1.2.8",
         "mocha": "^10.7.3",
         "mocha-fivemat-progress-reporter": "^0.1.0",
         "monocart-coverage-reports": "^2.10.3",
         "ms": "^2.1.3",
-        "node-fetch": "^3.3.2",
-        "playwright": "^1.46.1",
+        "playwright": "^1.47.0",
         "source-map-support": "^0.5.21",
         "tslib": "^2.7.0",
-        "typescript": "^5.5.4",
-        "typescript-eslint": "^8.3.0",
+        "typescript": "^5.6.2",
+        "typescript-eslint": "^8.5.0",
         "which": "^3.0.1"
     },
     "overrides": {

package.json

@@ -1,7 +1,6 @@
 import { Octokit } from "@octokit/rest";
 import assert from "assert";
 import ado from "azure-devops-node-api";
-import fetch from "node-fetch";
 
 /**
  * @param {string} name

scripts/post-vsts-artifact-comment.mjs

@@ -241,7 +241,7 @@ export function createImportAdder(sourceFile: SourceFile | FutureSourceFile, pro
 interface AddToExistingState {
     readonly importClauseOrBindingPattern: ImportClause | ObjectBindingPattern;
     defaultImport: Import | undefined;
-    readonly namedImports: Map<string, AddAsTypeOnly>;
+    readonly namedImports: Map<string, { addAsTypeOnly: AddAsTypeOnly; propertyName?: string | undefined; }>;
 }
 
 function createImportAdderWorker(sourceFile: SourceFile | FutureSourceFile, program: Program, useAutoImportProvider: boolean, preferences: UserPreferences, host: LanguageServiceHost, cancellationToken: CancellationToken | undefined): ImportAdder {
@@ -290,15 +290,28 @@ function createImportAdderWorker(sourceFile: SourceFile | FutureSourceFile, prog
         let fix = getImportFixForSymbol(sourceFile, exportInfo, program, /*position*/ undefined, !!isValidTypeOnlyUseSite, useRequire, host, preferences);
         if (fix) {
             const localName = tryCast(referenceImport?.name, isIdentifier)?.text ?? symbolName;
+            let addAsTypeOnly: AddAsTypeOnly | undefined;
+            let propertyName: string | undefined;
             if (
                 referenceImport
                 && isTypeOnlyImportDeclaration(referenceImport)
                 && (fix.kind === ImportFixKind.AddNew || fix.kind === ImportFixKind.AddToExisting)
                 && fix.addAsTypeOnly === AddAsTypeOnly.Allowed
             ) {
                 // Copy the type-only status from the reference import
-                fix = { ...fix, addAsTypeOnly: AddAsTypeOnly.Required };
+                addAsTypeOnly = AddAsTypeOnly.Required;
             }
+
+            if (exportedSymbol.name !== localName) {
+                // checks if the symbol was aliased at the referenced import
+                propertyName = exportedSymbol.name;
+            }
+
+            fix = {
+                ...fix,
+                ...(addAsTypeOnly === undefined ? {} : { addAsTypeOnly }),
+                ...(propertyName === undefined ? {} : { propertyName }),
+            };
             addImport({ fix, symbolName: localName ?? symbolName, errorIdentifierText: undefined });
         }
     }
@@ -375,14 +388,14 @@ function createImportAdderWorker(sourceFile: SourceFile | FutureSourceFile, prog
                 importType.push(fix);
                 break;
             case ImportFixKind.AddToExisting: {
-                const { importClauseOrBindingPattern, importKind, addAsTypeOnly } = fix;
+                const { importClauseOrBindingPattern, importKind, addAsTypeOnly, propertyName } = fix;
                 let entry = addToExisting.get(importClauseOrBindingPattern);
                 if (!entry) {
                     addToExisting.set(importClauseOrBindingPattern, entry = { importClauseOrBindingPattern, defaultImport: undefined, namedImports: new Map() });
                 }
                 if (importKind === ImportKind.Named) {
-                    const prevValue = entry?.namedImports.get(symbolName);
-                    entry.namedImports.set(symbolName, reduceAddAsTypeOnlyValues(prevValue, addAsTypeOnly));
+                    const prevTypeOnly = entry?.namedImports.get(symbolName)?.addAsTypeOnly;
+                    entry.namedImports.set(symbolName, { addAsTypeOnly: reduceAddAsTypeOnlyValues(prevTypeOnly, addAsTypeOnly), propertyName });
                 }
                 else {
                     Debug.assert(entry.defaultImport === undefined || entry.defaultImport.name === symbolName, "(Add to Existing) Default import should be missing or match symbolName");
@@ -394,7 +407,7 @@ function createImportAdderWorker(sourceFile: SourceFile | FutureSourceFile, prog
                 break;
             }
             case ImportFixKind.AddNew: {
-                const { moduleSpecifier, importKind, useRequire, addAsTypeOnly } = fix;
+                const { moduleSpecifier, importKind, useRequire, addAsTypeOnly, propertyName } = fix;
                 const entry = getNewImportEntry(moduleSpecifier, importKind, useRequire, addAsTypeOnly);
                 Debug.assert(entry.useRequire === useRequire, "(Add new) Tried to add an `import` and a `require` for the same module");
 
@@ -405,12 +418,12 @@ function createImportAdderWorker(sourceFile: SourceFile | FutureSourceFile, prog
                         break;
                     case ImportKind.Named:
                         const prevValue = (entry.namedImports ||= new Map()).get(symbolName);
-                        entry.namedImports.set(symbolName, reduceAddAsTypeOnlyValues(prevValue, addAsTypeOnly));
+                        entry.namedImports.set(symbolName, [reduceAddAsTypeOnlyValues(prevValue, addAsTypeOnly), propertyName]);
                         break;
                     case ImportKind.CommonJS:
                         if (compilerOptions.verbatimModuleSyntax) {
                             const prevValue = (entry.namedImports ||= new Map()).get(symbolName);
-                            entry.namedImports.set(symbolName, reduceAddAsTypeOnlyValues(prevValue, addAsTypeOnly));
+                            entry.namedImports.set(symbolName, [reduceAddAsTypeOnlyValues(prevValue, addAsTypeOnly), propertyName]);
                         }
                         else {
                             Debug.assert(entry.namespaceLikeImport === undefined || entry.namespaceLikeImport.name === symbolName, "Namespacelike import shoudl be missing or match symbolName");
@@ -582,7 +595,7 @@ function createImportAdderWorker(sourceFile: SourceFile | FutureSourceFile, prog
                 sourceFile as SourceFile,
                 importClauseOrBindingPattern,
                 defaultImport,
-                arrayFrom(namedImports.entries(), ([name, addAsTypeOnly]) => ({ addAsTypeOnly, name })),
+                arrayFrom(namedImports.entries(), ([name, { addAsTypeOnly, propertyName }]) => ({ addAsTypeOnly, propertyName, name })),
                 importSpecifiersToRemoveWhileAdding,
                 preferences,
             );
@@ -596,7 +609,7 @@ function createImportAdderWorker(sourceFile: SourceFile | FutureSourceFile, prog
                 moduleSpecifier,
                 quotePreference,
                 defaultImport,
-                namedImports && arrayFrom(namedImports.entries(), ([name, addAsTypeOnly]) => ({ addAsTypeOnly, name })),
+                namedImports && arrayFrom(namedImports.entries(), ([name, [addAsTypeOnly, propertyName]]) => ({ addAsTypeOnly, propertyName, name })),
                 namespaceLikeImport,
                 compilerOptions,
                 preferences,
@@ -772,11 +785,13 @@ interface FixAddToExistingImport extends ImportFixBase {
     readonly importClauseOrBindingPattern: ImportClause | ObjectBindingPattern;
     readonly importKind: ImportKind.Default | ImportKind.Named;
     readonly addAsTypeOnly: AddAsTypeOnly;
+    readonly propertyName?: string;
 }
 interface FixAddNewImport extends ImportFixBase {
     readonly kind: ImportFixKind.AddNew;
     readonly importKind: ImportKind;
     readonly addAsTypeOnly: AddAsTypeOnly;
+    readonly propertyName?: string;
     readonly useRequire: boolean;
     readonly qualification?: Qualification;
 }
@@ -1794,7 +1809,7 @@ function doAddExistingFix(
                 factory.createObjectBindingPattern([
                     ...clause.elements.filter(e => !removeExistingImportSpecifiers.has(e)),
                     ...defaultImport ? [factory.createBindingElement(/*dotDotDotToken*/ undefined, /*propertyName*/ "default", defaultImport.name)] : emptyArray,
-                    ...namedImports.map(i => factory.createBindingElement(/*dotDotDotToken*/ undefined, /*propertyName*/ undefined, i.name)),
+                    ...namedImports.map(i => factory.createBindingElement(/*dotDotDotToken*/ undefined, i.propertyName, i.name)),
                 ]),
             );
             return;
@@ -1803,7 +1818,7 @@ function doAddExistingFix(
             addElementToBindingPattern(clause, defaultImport.name, "default");
         }
         for (const specifier of namedImports) {
-            addElementToBindingPattern(clause, specifier.name, /*propertyName*/ undefined);
+            addElementToBindingPattern(clause, specifier.name, specifier.propertyName);
         }
         return;
     }
@@ -1823,7 +1838,7 @@ function doAddExistingFix(
             namedImports.map(namedImport =>
                 factory.createImportSpecifier(
                     (!clause.isTypeOnly || promoteFromTypeOnly) && shouldUseTypeOnly(namedImport, preferences),
-                    /*propertyName*/ undefined,
+                    namedImport.propertyName === undefined ? undefined : factory.createIdentifier(namedImport.propertyName),
                     factory.createIdentifier(namedImport.name),
                 )
             ),
@@ -1919,11 +1934,12 @@ function getImportTypePrefix(moduleSpecifier: string, quotePreference: QuotePref
 interface Import {
     readonly name: string;
     readonly addAsTypeOnly: AddAsTypeOnly;
+    readonly propertyName?: string; // Use when needing to generate an `ImportSpecifier with a `propertyName`; the name preceding "as" keyword (undefined when "as" is absent)
 }
 
 interface ImportsCollection {
     readonly defaultImport?: Import;
-    readonly namedImports?: Map<string, AddAsTypeOnly>;
+    readonly namedImports?: Map<string, [AddAsTypeOnly, /*propertyName*/ string?]>;
     readonly namespaceLikeImport?: {
         readonly importKind: ImportKind.CommonJS | ImportKind.Namespace;
         readonly name: string;
@@ -1964,7 +1980,7 @@ function getNewImports(
                 namedImports?.map(namedImport =>
                     factory.createImportSpecifier(
                         !topLevelTypeOnly && shouldUseTypeOnly(namedImport, preferences),
-                        /*propertyName*/ undefined,
+                        namedImport.propertyName === undefined ? undefined : factory.createIdentifier(namedImport.propertyName),
                         factory.createIdentifier(namedImport.name),
                     )
                 ),
@@ -2003,7 +2019,7 @@ function getNewRequires(moduleSpecifier: string, quotePreference: QuotePreferenc
     let statements: RequireVariableStatement | readonly RequireVariableStatement[] | undefined;
     // const { default: foo, bar, etc } = require('./mod');
     if (defaultImport || namedImports?.length) {
-        const bindingElements = namedImports?.map(({ name }) => factory.createBindingElement(/*dotDotDotToken*/ undefined, /*propertyName*/ undefined, name)) || [];
+        const bindingElements = namedImports?.map(({ name, propertyName }) => factory.createBindingElement(/*dotDotDotToken*/ undefined, propertyName, name)) || [];
         if (defaultImport) {
             bindingElements.unshift(factory.createBindingElement(/*dotDotDotToken*/ undefined, "default", defaultImport.name));
         }

src/services/codefixes/importFixes.ts

@@ -2666,7 +2666,7 @@ export function getCompletionEntriesFromSymbols(
     includeSymbol = false,
 ): UniqueNameSet {
     const start = timestamp();
-    const variableOrParameterDeclaration = getVariableOrParameterDeclaration(contextToken, location);
+    const closestSymbolDeclaration = getClosestSymbolDeclaration(contextToken, location);
     const useSemicolons = probablyUsesSemicolons(sourceFile);
     const typeChecker = program.getTypeChecker();
     // Tracks unique names.
@@ -2745,26 +2745,33 @@ export function getCompletionEntriesFromSymbols(
             }
             // Filter out variables from their own initializers
             // `const a = /* no 'a' here */`
-            if (tryCast(variableOrParameterDeclaration, isVariableDeclaration) && symbol.valueDeclaration === variableOrParameterDeclaration) {
+            if (tryCast(closestSymbolDeclaration, isVariableDeclaration) && symbol.valueDeclaration === closestSymbolDeclaration) {
                 return false;
             }
 
-            // Filter out parameters from their own initializers
+            // Filter out current and latter parameters from defaults
             // `function f(a = /* no 'a' and 'b' here */, b) { }` or
-            // `function f<T = /* no 'T' here */>(a: T) { }`
+            // `function f<T = /* no 'T' and 'T2' here */>(a: T, b: T2) { }`
             const symbolDeclaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
-            if (
-                variableOrParameterDeclaration && symbolDeclaration && (
-                    (isTypeParameterDeclaration(variableOrParameterDeclaration) && isTypeParameterDeclaration(symbolDeclaration)) ||
-                    (isParameter(variableOrParameterDeclaration) && isParameter(symbolDeclaration))
-                )
-            ) {
-                const symbolDeclarationPos = symbolDeclaration.pos;
-                const parameters = isParameter(variableOrParameterDeclaration) ? variableOrParameterDeclaration.parent.parameters :
-                    isInferTypeNode(variableOrParameterDeclaration.parent) ? undefined :
-                    variableOrParameterDeclaration.parent.typeParameters;
-                if (symbolDeclarationPos >= variableOrParameterDeclaration.pos && parameters && symbolDeclarationPos < parameters.end) {
-                    return false;
+            if (closestSymbolDeclaration && symbolDeclaration) {
+                if (isParameter(closestSymbolDeclaration) && isParameter(symbolDeclaration)) {
+                    const parameters = closestSymbolDeclaration.parent.parameters;
+                    if (symbolDeclaration.pos >= closestSymbolDeclaration.pos && symbolDeclaration.pos < parameters.end) {
+                        return false;
+                    }
+                }
+                else if (isTypeParameterDeclaration(closestSymbolDeclaration) && isTypeParameterDeclaration(symbolDeclaration)) {
+                    if (closestSymbolDeclaration === symbolDeclaration && contextToken?.kind === SyntaxKind.ExtendsKeyword) {
+                        // filter out the directly self-recursive type parameters
+                        // `type A<K extends /* no 'K' here*/> = K`
+                        return false;
+                    }
+                    if (isInTypeParameterDefault(contextToken) && !isInferTypeNode(closestSymbolDeclaration.parent)) {
+                        const typeParameters = closestSymbolDeclaration.parent.typeParameters;
+                        if (typeParameters && symbolDeclaration.pos >= closestSymbolDeclaration.pos && symbolDeclaration.pos < typeParameters.end) {
+                            return false;
+                        }
+                    }
                 }
             }
 
@@ -6001,20 +6008,39 @@ function isModuleSpecifierMissingOrEmpty(specifier: ModuleReference | Expression
     return !tryCast(isExternalModuleReference(specifier) ? specifier.expression : specifier, isStringLiteralLike)?.text;
 }
 
-function getVariableOrParameterDeclaration(contextToken: Node | undefined, location: Node) {
+function getClosestSymbolDeclaration(contextToken: Node | undefined, location: Node) {
     if (!contextToken) return;
 
-    const possiblyParameterDeclaration = findAncestor(contextToken, node =>
+    let closestDeclaration = findAncestor(contextToken, node =>
         isFunctionBlock(node) || isArrowFunctionBody(node) || isBindingPattern(node)
             ? "quit"
             : ((isParameter(node) || isTypeParameterDeclaration(node)) && !isIndexSignatureDeclaration(node.parent)));
 
-    const possiblyVariableDeclaration = findAncestor(location, node =>
-        isFunctionBlock(node) || isArrowFunctionBody(node) || isBindingPattern(node)
-            ? "quit"
-            : isVariableDeclaration(node));
+    if (!closestDeclaration) {
+        closestDeclaration = findAncestor(location, node =>
+            isFunctionBlock(node) || isArrowFunctionBody(node) || isBindingPattern(node)
+                ? "quit"
+                : isVariableDeclaration(node));
+    }
+    return closestDeclaration as ParameterDeclaration | TypeParameterDeclaration | VariableDeclaration | undefined;
+}
+
+function isInTypeParameterDefault(contextToken: Node | undefined) {
+    if (!contextToken) {
+        return false;
+    }
 
-    return (possiblyParameterDeclaration || possiblyVariableDeclaration) as ParameterDeclaration | TypeParameterDeclaration | VariableDeclaration | undefined;
+    let node = contextToken;
+    let parent = contextToken.parent;
+    while (parent) {
+        if (isTypeParameterDeclaration(parent)) {
+            return parent.default === node || node.kind === SyntaxKind.EqualsToken;
+        }
+        node = parent;
+        parent = parent.parent;
+    }
+
+    return false;
 }
 
 function isArrowFunctionBody(node: Node) {