[ID-Prep] PR5 - Preserve type nodes from function like expression in declaration emit

src/compiler/checker.ts

@@ -6329,8 +6329,25 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
 
         const firstIdentifier = getFirstIdentifier(entityName);
         const symbol = resolveName(enclosingDeclaration, firstIdentifier.escapedText, meaning, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false);
-        if (symbol && symbol.flags & SymbolFlags.TypeParameter && meaning & SymbolFlags.Type) {
-            return { accessibility: SymbolAccessibility.Accessible };
+        if (symbol) {
+            if (symbol.flags & SymbolFlags.TypeParameter && meaning & SymbolFlags.Type) {
+                return { accessibility: SymbolAccessibility.Accessible };
+            }
+
+            // Parameters or binding elements from parameters are always visible in their enclosing function declarations
+            if (symbol.flags & SymbolFlags.FunctionScopedVariable && meaning & SymbolFlags.Value) {
+                let declaration: Node | undefined = symbol.valueDeclaration;
+                while (declaration) {
+                    if (declaration.kind === SyntaxKind.Parameter) break;
+                    if (declaration.kind === SyntaxKind.BindingElement) {
+                        declaration = declaration.parent.parent;
+                    }
+                    break;
+                }
+                if (declaration?.kind === SyntaxKind.Parameter) {
+                    return { accessibility: SymbolAccessibility.Accessible };
+                }
+            }
         }
         if (!symbol && isThisIdentifier(firstIdentifier) && isSymbolAccessible(getSymbolOfDeclaration(getThisContainer(firstIdentifier, /*includeArrowFunctions*/ false, /*includeClassComputedPropertyName*/ false)), firstIdentifier, meaning, /*shouldComputeAliasesToMakeVisible*/ false).accessibility === SymbolAccessibility.Accessible) {
             return { accessibility: SymbolAccessibility.Accessible };
@@ -48160,13 +48177,25 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             hasSyntacticModifier(parameter, ModifierFlags.ParameterPropertyModifier);
     }
 
-    function isExpandoFunctionDeclaration(node: Declaration): boolean {
-        const declaration = getParseTreeNode(node, isFunctionDeclaration);
+    function isExpandoFunctionDeclaration(node: FunctionDeclaration | VariableDeclaration): boolean {
+        const declaration = getParseTreeNode(node, isDeclaration);
         if (!declaration) {
             return false;
         }
-        const symbol = getSymbolOfDeclaration(declaration);
-        if (!symbol || !(symbol.flags & SymbolFlags.Function)) {
+        let symbol: Symbol;
+        if (isVariableDeclaration(declaration)) {
+            if (declaration.type || !isVarConstLike(declaration)) {
+                return false;
+            }
+            if (!(declaration.initializer && isFunctionExpressionOrArrowFunction(declaration.initializer))) {
+                return false;
+            }
+            symbol = getSymbolOfDeclaration(declaration.initializer);
+        }
+        else {
+            symbol = getSymbolOfDeclaration(declaration);
+        }
+        if (!symbol || !(symbol.flags & SymbolFlags.Function | SymbolFlags.Variable)) {
             return false;
         }
         return !!forEachEntry(getExportsOfSymbol(symbol), p => p.flags & SymbolFlags.Value && isExpandoPropertyDeclaration(p.valueDeclaration));

src/compiler/transformers/declarations.ts

@@ -6,6 +6,7 @@ import {
     append,
     ArrayBindingElement,
     arrayFrom,
+    ArrowFunction,
     AsExpression,
     BindingElement,
     BindingName,
@@ -51,6 +52,7 @@ import {
     flatten,
     forEach,
     FunctionDeclaration,
+    FunctionExpression,
     FunctionTypeNode,
     GeneratedIdentifierFlags,
     GetAccessorDeclaration,
@@ -864,6 +866,9 @@ export function transformDeclarations(context: TransformationContext) {
     }
     function typeFromExpression(node: Expression, requiresUndefined?: boolean): TypeNode | undefined {
         switch (node.kind) {
+            case SyntaxKind.ArrowFunction:
+            case SyntaxKind.FunctionExpression:
+                return typeFromFunctionLikeExpression(node as ArrowFunction | FunctionExpression);
             case SyntaxKind.TypeAssertionExpression:
             case SyntaxKind.AsExpression:
                 const asExpression = node as AsExpression | TypeAssertion;
@@ -877,7 +882,19 @@ export function transformDeclarations(context: TransformationContext) {
         }
         return undefined;
     }
+    function typeFromFunctionLikeExpression(fnNode: FunctionExpression | ArrowFunction) {
+        const oldEnclosingDeclaration = enclosingDeclaration;
+        enclosingDeclaration = fnNode;
 
+        const returnType = fnNode.type ? visitTypeNode(fnNode.type) : inferReturnTypeOfSignatureSignature(fnNode);
+        const fnTypeNode = factory.createFunctionTypeNode(
+            visitNodes(fnNode.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration),
+            fnNode.parameters.map(p => ensureParameter(p)),
+            returnType,
+        );
+        enclosingDeclaration = oldEnclosingDeclaration;
+        return fnTypeNode;
+    }
     function typeFromAccessor(node: AccessorDeclaration) {
         const accessorDeclarations = resolver.getAllAccessorDeclarations(node);
         const accessorType = getTypeAnnotationFromAllAccessorDeclarations(node, accessorDeclarations);
@@ -892,7 +909,7 @@ export function transformDeclarations(context: TransformationContext) {
             return visitNode(declaredType, visitDeclarationSubtree, isTypeNode)!;
         }
         let resultType;
-        if (node.initializer) {
+        if (node.initializer && !resolver.isExpandoFunctionDeclaration(node)) {
             resultType = typeFromExpression(node.initializer);
         }
         return resultType ?? inferVariableLikeType(node);

src/compiler/transformers/declarations/diagnostics.ts

@@ -459,6 +459,8 @@ export function createGetSymbolAccessibilityDiagnosticForNode(node: DeclarationD
                         Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1;
                 }
 
+            case SyntaxKind.ArrowFunction:
+            case SyntaxKind.FunctionExpression:
             case SyntaxKind.FunctionDeclaration:
             case SyntaxKind.FunctionType:
                 return symbolAccessibilityResult.errorModuleName ?

src/compiler/types.ts

@@ -5604,7 +5604,7 @@ export interface EmitResolver {
     collectLinkedAliases(node: Identifier, setVisibility?: boolean): Node[] | undefined;
     isImplementationOfOverload(node: SignatureDeclaration): boolean | undefined;
     requiresAddingImplicitUndefined(node: ParameterDeclaration): boolean;
-    isExpandoFunctionDeclaration(node: FunctionDeclaration): boolean;
+    isExpandoFunctionDeclaration(node: VariableDeclaration | FunctionDeclaration): boolean;
     getPropertiesOfContainerFunction(node: Declaration): Symbol[];
     createTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration | PropertyAccessExpression | ElementAccessExpression | BinaryExpression, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker, addUndefined?: boolean): TypeNode | undefined;
     createReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): TypeNode | undefined;

tests/baselines/reference/commentsFunction.js

@@ -111,9 +111,9 @@ b: number): void;
 /** fooFunc
  * comment
  */
-declare var fooFunc: (b: string) => string;
-declare var lambdaFoo: (a: number, b: number) => number;
-declare var lambddaNoVarComment: (a: number, b: number) => number;
+declare var fooFunc: (/** fooFunctionValue param */ b: string) => string;
+declare var lambdaFoo: (/**param a*/ a: number, /**param b*/ b: number) => number;
+declare var lambddaNoVarComment: (/**param a*/ a: number, /**param b*/ b: number) => number;
 declare function blah(a: string): void;
 declare function blah2(a: string): void;
 declare function blah3(a: string): void;

tests/baselines/reference/correlatedUnions.js

@@ -602,7 +602,7 @@ type SameKeys<T> = {
     };
 };
 type MappedFromOriginal = SameKeys<Original>;
-declare const getStringAndNumberFromOriginalAndMapped: <K extends keyof Original, N extends keyof Original[K]>(original: Original, mappedFromOriginal: MappedFromOriginal, key: K, nestedKey: N) => [Original[K][N], MappedFromOriginal[K][N]];
+declare const getStringAndNumberFromOriginalAndMapped: <K extends KeyOfOriginal, N extends NestedKeyOfOriginalFor<K>>(original: Original, mappedFromOriginal: MappedFromOriginal, key: K, nestedKey: N) => [Original[K][N], MappedFromOriginal[K][N]];
 interface Config {
     string: string;
     number: number;

tests/baselines/reference/declFileTypeofFunction.js

@@ -70,6 +70,6 @@ declare function b1(): typeof b1;
 declare function foo(): typeof foo;
 declare var foo1: typeof foo;
 declare var foo2: typeof foo;
-declare var foo3: () => any;
-declare var x: () => any;
+declare var foo3: () => () => any;
+declare var x: () => () => any;
 declare function foo5(x: number): (x: number) => number;

tests/baselines/reference/declarationEmitShadowingInferNotRenamed.js

@@ -13,14 +13,14 @@ export const createClient = <
     | Record<string, new (...args: any[]) => Client> // or map of classes
 >(
   clientDef: D
-): D extends new (...args: any[]) => infer C
+) => {
+  return null! as D extends new (...args: any[]) => infer C
   ? UpdatedClient<C> // return instance
   : {
       [K in keyof D]: D[K] extends new (...args: any[]) => infer C // or map of instances respectively
         ? UpdatedClient<C>
         : never
-    } => {
-  return null as any
+    }
 }
 
 //// [declarationEmitShadowingInferNotRenamed.js]
@@ -38,5 +38,5 @@ type Client = string;
 type UpdatedClient<C> = C & {
     foo: number;
 };
-export declare const createClient: <D extends Record<string, new (...args: any[]) => Client> | (new (...args: any[]) => Client)>(clientDef: D) => D extends new (...args: any[]) => infer C ? UpdatedClient<C> : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C_1 ? UpdatedClient<C_1> : never; };
+export declare const createClient: <D extends (new (...args: any[]) => Client) | Record<string, new (...args: any[]) => Client>>(clientDef: D) => D extends new (...args: any[]) => infer C ? UpdatedClient<C> : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C_1 ? UpdatedClient<C_1> : never; };
 export {};

tests/baselines/reference/declarationEmitShadowingInferNotRenamed.symbols

@@ -32,29 +32,29 @@ export const createClient = <
 >clientDef : Symbol(clientDef, Decl(declarationEmitShadowingInferNotRenamed.ts, 10, 2))
 >D : Symbol(D, Decl(declarationEmitShadowingInferNotRenamed.ts, 6, 29))
 
-): D extends new (...args: any[]) => infer C
+) => {
+  return null! as D extends new (...args: any[]) => infer C
 >D : Symbol(D, Decl(declarationEmitShadowingInferNotRenamed.ts, 6, 29))
->args : Symbol(args, Decl(declarationEmitShadowingInferNotRenamed.ts, 12, 18))
->C : Symbol(C, Decl(declarationEmitShadowingInferNotRenamed.ts, 12, 42))
+>args : Symbol(args, Decl(declarationEmitShadowingInferNotRenamed.ts, 13, 33))
+>C : Symbol(C, Decl(declarationEmitShadowingInferNotRenamed.ts, 13, 57))
 
   ? UpdatedClient<C> // return instance
 >UpdatedClient : Symbol(UpdatedClient, Decl(declarationEmitShadowingInferNotRenamed.ts, 1, 20))
->C : Symbol(C, Decl(declarationEmitShadowingInferNotRenamed.ts, 12, 42))
+>C : Symbol(C, Decl(declarationEmitShadowingInferNotRenamed.ts, 13, 57))
 
   : {
       [K in keyof D]: D[K] extends new (...args: any[]) => infer C // or map of instances respectively
->K : Symbol(K, Decl(declarationEmitShadowingInferNotRenamed.ts, 15, 7))
+>K : Symbol(K, Decl(declarationEmitShadowingInferNotRenamed.ts, 16, 7))
 >D : Symbol(D, Decl(declarationEmitShadowingInferNotRenamed.ts, 6, 29))
 >D : Symbol(D, Decl(declarationEmitShadowingInferNotRenamed.ts, 6, 29))
->K : Symbol(K, Decl(declarationEmitShadowingInferNotRenamed.ts, 15, 7))
->args : Symbol(args, Decl(declarationEmitShadowingInferNotRenamed.ts, 15, 40))
->C : Symbol(C, Decl(declarationEmitShadowingInferNotRenamed.ts, 15, 64))
+>K : Symbol(K, Decl(declarationEmitShadowingInferNotRenamed.ts, 16, 7))
+>args : Symbol(args, Decl(declarationEmitShadowingInferNotRenamed.ts, 16, 40))
+>C : Symbol(C, Decl(declarationEmitShadowingInferNotRenamed.ts, 16, 64))
 
         ? UpdatedClient<C>
 >UpdatedClient : Symbol(UpdatedClient, Decl(declarationEmitShadowingInferNotRenamed.ts, 1, 20))
->C : Symbol(C, Decl(declarationEmitShadowingInferNotRenamed.ts, 15, 64))
+>C : Symbol(C, Decl(declarationEmitShadowingInferNotRenamed.ts, 16, 64))
 
         : never
-    } => {
-  return null as any
+    }
 }

tests/baselines/reference/declarationEmitShadowingInferNotRenamed.types

@@ -12,7 +12,7 @@ type UpdatedClient<C> = C & {foo: number}
 
 export const createClient = <
 >createClient : <D extends Record<string, new (...args: any[]) => Client> | (new (...args: any[]) => Client)>(clientDef: D) => D extends new (...args: any[]) => infer C ? UpdatedClient<C> : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C_1 ? UpdatedClient<C_1> : never; }
-><  D extends    | (new (...args: any[]) => Client) // accept class    | Record<string, new (...args: any[]) => Client> // or map of classes>(  clientDef: D): D extends new (...args: any[]) => infer C  ? UpdatedClient<C> // return instance  : {      [K in keyof D]: D[K] extends new (...args: any[]) => infer C // or map of instances respectively        ? UpdatedClient<C>        : never    } => {  return null as any} : <D extends Record<string, new (...args: any[]) => Client> | (new (...args: any[]) => Client)>(clientDef: D) => D extends new (...args: any[]) => infer C ? UpdatedClient<C> : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C_1 ? UpdatedClient<C_1> : never; }
+><  D extends    | (new (...args: any[]) => Client) // accept class    | Record<string, new (...args: any[]) => Client> // or map of classes>(  clientDef: D) => {  return null! as D extends new (...args: any[]) => infer C  ? UpdatedClient<C> // return instance  : {      [K in keyof D]: D[K] extends new (...args: any[]) => infer C // or map of instances respectively        ? UpdatedClient<C>        : never    }} : <D extends Record<string, new (...args: any[]) => Client> | (new (...args: any[]) => Client)>(clientDef: D) => D extends new (...args: any[]) => infer C ? UpdatedClient<C> : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C_1 ? UpdatedClient<C_1> : never; }
 
   D extends
     | (new (...args: any[]) => Client) // accept class
@@ -25,7 +25,10 @@ export const createClient = <
   clientDef: D
 >clientDef : D
 
-): D extends new (...args: any[]) => infer C
+) => {
+  return null! as D extends new (...args: any[]) => infer C
+>null! as D extends new (...args: any[]) => infer C  ? UpdatedClient<C> // return instance  : {      [K in keyof D]: D[K] extends new (...args: any[]) => infer C // or map of instances respectively        ? UpdatedClient<C>        : never    } : D extends new (...args: any[]) => infer C ? UpdatedClient<C> : { [K in keyof D]: D[K] extends new (...args: any[]) => infer C_1 ? UpdatedClient<C_1> : never; }
+>null! : null
 >args : any[]
 
   ? UpdatedClient<C> // return instance
@@ -35,7 +38,5 @@ export const createClient = <
 
         ? UpdatedClient<C>
         : never
-    } => {
-  return null as any
->null as any : any
+    }
 }

tests/baselines/reference/functionExpressionReturningItself.js

@@ -8,4 +8,4 @@ var x = function somefn() { return somefn; };
 
 
 //// [functionExpressionReturningItself.d.ts]
-declare var x: () => any;
+declare var x: () => () => any;

tests/baselines/reference/keyofAndIndexedAccess.js

@@ -1431,7 +1431,11 @@ type DictDict<V extends string, T extends string> = {
 };
 declare function ff1<V extends string, T extends string>(dd: DictDict<V, T>, k1: V, k2: T): number;
 declare function ff2<V extends string, T extends string>(dd: DictDict<V, T>, k1: V, k2: T): number;
-declare const cf1: <T extends { [P in K]: string; } & {
+declare const cf1: <T extends {
+    [P in K]: string;
+} & {
     cool: string;
 }, K extends keyof T>(t: T, k: K) => void;
-declare const cf2: <T extends { [P in K | "cool"]: string; }, K extends keyof T>(t: T, k: K) => void;
+declare const cf2: <T extends {
+    [P in K | "cool"]: string;
+}, K extends keyof T>(t: T, k: K) => void;

tests/baselines/reference/mappedTypeGenericInstantiationPreservesInlineForm.js

@@ -15,7 +15,9 @@ export function test2<T = Record<string, never>>(schema: {
 
 
 //// [mappedTypeGenericInstantiationPreservesInlineForm.d.ts]
-export declare const test1: <T = Record<string, never>>(schema: { [K in keyof Required<T>]: T[K]; }) => void;
+export declare const test1: <T = Record<string, never>>(schema: {
+    [K in keyof Required<T>]: T[K];
+}) => void;
 export declare function test2<T = Record<string, never>>(schema: {
     [K in keyof Required<T>]: T[K];
 }): void;

tests/baselines/reference/renamingDestructuredPropertyInFunctionType.js

@@ -171,8 +171,8 @@ interface I {
 declare function f1({ a: string }: O): void;
 declare const f2: ({ a: string }: O) => void;
 declare const f3: ({ a: string, b, c }: O) => void;
-declare const f4: ({ a: string }: O) => string;
-declare const f5: ({ a: string, b, c }: O) => string;
+declare const f4: ({ a: string }: O) => typeof string;
+declare const f5: ({ a: string, b, c }: O) => typeof string;
 declare const obj1: {
     method({ a: string }: O): void;
 };