Merge branch 'main' into feat/esnext-float16

Author: petamoriken

src/compiler/checker.ts

@@ -3458,10 +3458,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     if (containerKind === SyntaxKind.InterfaceDeclaration && heritageKind === SyntaxKind.ExtendsKeyword) {
                         error(errorLocation, Diagnostics.An_interface_cannot_extend_a_primitive_type_like_0_It_can_only_extend_other_named_object_types, unescapeLeadingUnderscores(name));
                     }
-                    else if (containerKind === SyntaxKind.ClassDeclaration && heritageKind === SyntaxKind.ExtendsKeyword) {
+                    else if (isClassLike(grandparent.parent) && heritageKind === SyntaxKind.ExtendsKeyword) {
                         error(errorLocation, Diagnostics.A_class_cannot_extend_a_primitive_type_like_0_Classes_can_only_extend_constructable_values, unescapeLeadingUnderscores(name));
                     }
-                    else if (containerKind === SyntaxKind.ClassDeclaration && heritageKind === SyntaxKind.ImplementsKeyword) {
+                    else if (isClassLike(grandparent.parent) && heritageKind === SyntaxKind.ImplementsKeyword) {
                         error(errorLocation, Diagnostics.A_class_cannot_implement_a_primitive_type_like_0_It_can_only_implement_other_named_object_types, unescapeLeadingUnderscores(name));
                     }
                 }
@@ -6193,8 +6193,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             enterNewScope(context, node) {
                 if (isFunctionLike(node) || isJSDocSignature(node)) {
                     const signature = getSignatureFromDeclaration(node);
-                    const expandedParams = getExpandedParameters(signature, /*skipUnionExpanding*/ true)[0];
-                    return enterNewScope(context as NodeBuilderContext, node, expandedParams, signature.typeParameters);
+                    return enterNewScope(context as NodeBuilderContext, node, signature.parameters, signature.typeParameters);
                 }
                 else {
                     const typeParameters = isConditionalTypeNode(node) ? getInferTypeParameters(node) :

src/compiler/expressionToTypeNode.ts

@@ -969,14 +969,16 @@ export function createSyntacticTypeNodeBuilder(
         return failed;
     }
     function typeFromFunctionLikeExpression(fnNode: FunctionExpression | ArrowFunction, context: SyntacticTypeNodeBuilderContext) {
-        // Disable any inference fallback since we won't actually use the resulting type and we don't want to generate errors
-        const oldNoInferenceFallback = context.noInferenceFallback;
-        context.noInferenceFallback = true;
-        createReturnFromSignature(fnNode, /*symbol*/ undefined, context);
-        reuseTypeParameters(fnNode.typeParameters, context);
-        fnNode.parameters.map(p => ensureParameter(p, context));
-        context.noInferenceFallback = oldNoInferenceFallback;
-        return notImplemented;
+        const returnType = createReturnFromSignature(fnNode, /*symbol*/ undefined, context);
+        const typeParameters = reuseTypeParameters(fnNode.typeParameters, context);
+        const parameters = fnNode.parameters.map(p => ensureParameter(p, context));
+        return syntacticResult(
+            factory.createFunctionTypeNode(
+                typeParameters,
+                parameters,
+                returnType,
+            ),
+        );
     }
     function canGetTypeFromArrayLiteral(arrayLiteral: ArrayLiteralExpression, context: SyntacticTypeNodeBuilderContext, isConstContext: boolean) {
         if (!isConstContext) {

src/harness/client.ts

@@ -801,7 +801,6 @@ export class SessionClient implements LanguageService {
     }
 
     mapCode: typeof notImplemented = notImplemented;
-    getImports: typeof notImplemented = notImplemented;
 
     private createFileLocationOrRangeRequestArgs(positionOrRange: number | TextRange, fileName: string): protocol.FileLocationOrRangeRequestArgs {
         return typeof positionOrRange === "number"

src/harness/fourslashImpl.ts

@@ -4652,28 +4652,6 @@ ${changes.join("\n// ---\n")}
 ${after}`;
         this.baseline("mapCode", baseline, ".mapCode.ts");
     }
-
-    public verifyGetImports(fileName: string, expectedImports: string[]): void {
-        const actualImports = this.languageService.getImports(fileName);
-        if (actualImports.length !== expectedImports.length) {
-            throw new Error(`Expected ${expectedImports.length} imports for ${fileName}, got ${actualImports.length}
-    Expected:
-${expectedImports}
-    Actual:
-${actualImports}
-`);
-        }
-        for (let i = 0; i < expectedImports.length; i++) {
-            if (actualImports[i] !== expectedImports[i]) {
-                throw new Error(`Expected at ${fileName} index ${i}: ${expectedImports[i]}, got ${actualImports[i]}
-    Expected:
-${expectedImports}
-    Actual:
-${actualImports}
-`);
-            }
-        }
-    }
 }
 
 function updateTextRangeForTextChanges({ pos, end }: ts.TextRange, textChanges: readonly ts.TextChange[]): ts.TextRange {

src/harness/fourslashInterfaceImpl.ts

@@ -257,10 +257,6 @@ export class VerifyNegatable {
     public baselineMapCode(ranges: FourSlash.Range[][], changes: string[] = []): void {
         this.state.baselineMapCode(ranges, changes);
     }
-
-    public getImports(fileName: string, imports: string[]): void {
-        return this.state.verifyGetImports(fileName, imports);
-    }
 }
 
 export interface CompletionsResult {
@@ -2051,8 +2047,3 @@ export interface RenameOptions {
     readonly providePrefixAndSuffixTextForRename?: boolean;
     readonly quotePreference?: "auto" | "double" | "single";
 }
-
-export interface VerifyGetImportsOptions {
-    fileName: string;
-    imports: string[];
-}

src/server/protocol.ts

@@ -202,6 +202,7 @@ export const enum CommandTypes {
     ProvideInlayHints = "provideInlayHints",
     WatchChange = "watchChange",
     MapCode = "mapCode",
+    /** @internal */
     CopilotRelated = "copilotRelated",
 }
 
@@ -2417,18 +2418,6 @@ export interface MapCodeResponse extends Response {
     body: readonly FileCodeEdits[];
 }
 
-export interface CopilotRelatedRequest extends FileRequest {
-    command: CommandTypes.CopilotRelated;
-    arguments: FileRequestArgs;
-}
-
-export interface CopilotRelatedItems {
-    relatedFiles: readonly string[];
-}
-
-export interface CopilotRelatedResponse extends Response {
-    body: CopilotRelatedItems;
-}
 /**
  * Synchronous request for semantic diagnostics of one file.
  */

src/server/session.ts

@@ -2052,11 +2052,9 @@ export class Session<TMessage = string> implements EventSender {
         return this.mapTextChangesToCodeEdits(changes);
     }
 
-    private getCopilotRelatedInfo(args: protocol.FileRequestArgs): protocol.CopilotRelatedItems {
-        const { file, project } = this.getFileAndProject(args);
-
+    private getCopilotRelatedInfo(): { relatedFiles: never[]; } {
         return {
-            relatedFiles: project.getLanguageService().getImports(file),
+            relatedFiles: [],
         };
     }
 
@@ -3802,8 +3800,8 @@ export class Session<TMessage = string> implements EventSender {
         [protocol.CommandTypes.MapCode]: (request: protocol.MapCodeRequest) => {
             return this.requiredResponse(this.mapCode(request.arguments));
         },
-        [protocol.CommandTypes.CopilotRelated]: (request: protocol.CopilotRelatedRequest) => {
-            return this.requiredResponse(this.getCopilotRelatedInfo(request.arguments));
+        [protocol.CommandTypes.CopilotRelated]: () => {
+            return this.requiredResponse(this.getCopilotRelatedInfo());
         },
     }));
 

src/services/codefixes/helpers.ts

@@ -606,12 +606,10 @@ export function typeToAutoImportableTypeNode(checker: TypeChecker, importAdder:
 
 /** @internal */
 export function typeNodeToAutoImportableTypeNode(typeNode: TypeNode, importAdder: ImportAdder, scriptTarget: ScriptTarget): TypeNode | undefined {
-    if (typeNode && isImportTypeNode(typeNode)) {
-        const importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget);
-        if (importableReference) {
-            importSymbols(importAdder, importableReference.symbols);
-            typeNode = importableReference.typeNode;
-        }
+    const importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget);
+    if (importableReference) {
+        importSymbols(importAdder, importableReference.symbols);
+        typeNode = importableReference.typeNode;
     }
 
     // Ensure nodes are fresh so they can have different positions when going through formatting.

src/services/refactors/moveToFile.ts

@@ -26,6 +26,7 @@ import {
     emptyArray,
     EnumDeclaration,
     escapeLeadingUnderscores,
+    every,
     ExportDeclaration,
     ExportKind,
     Expression,
@@ -885,24 +886,23 @@ export function getUsageInfo(oldFile: SourceFile, toMove: readonly Statement[],
     const unusedImportsFromOldFile = new Set<Symbol>();
     for (const statement of toMove) {
         forEachReference(statement, checker, enclosingRange, (symbol, isValidTypeOnlyUseSite) => {
-            if (!symbol.declarations || isGlobalType(checker, symbol)) {
+            if (!symbol.declarations) {
                 return;
             }
             if (existingTargetLocals.has(skipAlias(symbol, checker))) {
                 unusedImportsFromOldFile.add(symbol);
                 return;
             }
-            for (const decl of symbol.declarations) {
-                if (isInImport(decl)) {
-                    const prevIsTypeOnly = oldImportsNeededByTargetFile.get(symbol);
-                    oldImportsNeededByTargetFile.set(symbol, [
-                        prevIsTypeOnly === undefined ? isValidTypeOnlyUseSite : prevIsTypeOnly && isValidTypeOnlyUseSite,
-                        tryCast(decl, (d): d is codefix.ImportOrRequireAliasDeclaration => isImportSpecifier(d) || isImportClause(d) || isNamespaceImport(d) || isImportEqualsDeclaration(d) || isBindingElement(d) || isVariableDeclaration(d)),
-                    ]);
-                }
-                else if (isTopLevelDeclaration(decl) && sourceFileOfTopLevelDeclaration(decl) === oldFile && !movedSymbols.has(symbol)) {
-                    targetFileImportsFromOldFile.set(symbol, isValidTypeOnlyUseSite);
-                }
+            const importedDeclaration = find(symbol.declarations, isInImport);
+            if (importedDeclaration) {
+                const prevIsTypeOnly = oldImportsNeededByTargetFile.get(symbol);
+                oldImportsNeededByTargetFile.set(symbol, [
+                    prevIsTypeOnly === undefined ? isValidTypeOnlyUseSite : prevIsTypeOnly && isValidTypeOnlyUseSite,
+                    tryCast(importedDeclaration, (d): d is codefix.ImportOrRequireAliasDeclaration => isImportSpecifier(d) || isImportClause(d) || isNamespaceImport(d) || isImportEqualsDeclaration(d) || isBindingElement(d) || isVariableDeclaration(d)),
+                ]);
+            }
+            else if (!movedSymbols.has(symbol) && every(symbol.declarations, decl => isTopLevelDeclaration(decl) && sourceFileOfTopLevelDeclaration(decl) === oldFile)) {
+                targetFileImportsFromOldFile.set(symbol, isValidTypeOnlyUseSite);
             }
         });
     }
@@ -946,10 +946,6 @@ export function getUsageInfo(oldFile: SourceFile, toMove: readonly Statement[],
     }
 }
 
-function isGlobalType(checker: TypeChecker, symbol: Symbol) {
-    return !!checker.resolveName(symbol.name, /*location*/ undefined, SymbolFlags.Type, /*excludeGlobals*/ false);
-}
-
 function makeUniqueFilename(proposedFilename: string, extension: string, inDirectory: string, host: LanguageServiceHost): string {
     let newFilename = proposedFilename;
     for (let i = 1;; i++) {

src/services/services.ts

@@ -2,7 +2,6 @@ import {
     __String,
     ApplicableRefactorInfo,
     ApplyCodeActionCommandResult,
-    arrayFrom,
     AssignmentDeclarationKind,
     BaseType,
     BinaryExpression,
@@ -234,7 +233,6 @@ import {
     Node,
     NodeArray,
     NodeFlags,
-    nodeIsSynthesized,
     noop,
     normalizePath,
     normalizeSpans,
@@ -1604,7 +1602,6 @@ const invalidOperationsInPartialSemanticMode: readonly (keyof LanguageService)[]
     "provideInlayHints",
     "getSupportedCodeFixes",
     "getPasteEdits",
-    "getImports",
 ];
 
 const invalidOperationsInSyntacticMode: readonly (keyof LanguageService)[] = [
@@ -3381,18 +3378,6 @@ export function createLanguageService(
         );
     }
 
-    function getImports(fileName: string): readonly string[] {
-        synchronizeHostData();
-        const file = getValidSourceFile(fileName);
-        let imports: Set<string> | undefined;
-        for (const specifier of file.imports) {
-            if (nodeIsSynthesized(specifier)) continue;
-            const name = program.getResolvedModuleFromModuleSpecifier(specifier, file)?.resolvedModule?.resolvedFileName;
-            if (name) (imports ??= new Set()).add(name);
-        }
-        return imports ? arrayFrom(imports) : emptyArray;
-    }
-
     const ls: LanguageService = {
         dispose,
         cleanupSemanticCache,
@@ -3467,7 +3452,6 @@ export function createLanguageService(
         preparePasteEditsForFile,
         getPasteEdits,
         mapCode,
-        getImports,
     };
 
     switch (languageServiceMode) {