Type parameters are renamed in declarations

[dragomirtitian]

🔎 Search Terms

type parameters declaration rename

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ

⏯ Playground Link

https://www.typescriptlang.org/play?ts=5.2.2#code/MYGwhgzhAECC0G9oF8CwAoAbmATtARtALzQA8sANAHwAUAHgFxwCUxV0dQA

💻 Code

class A { }
var b = <A,>(x: A) => x

🙁 Actual behavior

Declaration file type for b is declare var b: <A_1>(x: A_1) => A_1;

🙂 Expected behavior

Declaration file type for b should be declare var b: <A>(x: A) => A; as written in source code. There is no reason to rename the type parameter

Additional information about the issue

No response

[jakebailey]

My understanding (from skimming + the last time I touched this) is that the determination for "should I rename the type parameter" is just "does something exist in scope in type space with the same name", so interface A also does this. But, that doesn't explain why this doesn't apply to functions:

class A { }
var a = <A,>(x: A) => x
function a2<A,>(x: A) { return x }

interface B { }
var b = <B,>(x: B) => x
function b2<B,>(x: B) { return x }

declare class A {
}
declare var a: <A_1>(x: A_1) => A_1;
declare function a2<A>(x: A): A;
interface B {
}
declare var b: <B_1>(x: B_1) => B_1;
declare function b2<B>(x: B): B;

I will note that you still need to be able to write:

class A { }
var a = <A,>(x: A) => new A()
function a2<A,>(x: A) { return new A() }

declare class A {
}
declare var a: <A_1>(x: A_1) => A;
declare function a2<A>(x: A): globalThis.A;

Exporting them nets:

export declare class A {
}
export declare var a: <A_1>(x: A_1) => A;
export declare function a2<A>(x: A): import("./input").A;

[jakebailey]

I looked into this, and the reason the function declaration and the variable differ is because declaration emit walks declaration nodes directly (fixing up the AST there), whereas on the variable, all it has is the type and so it hands it off directly to typeToTypeNode. The former is able to walk the declaration's type parameters first and decides to use them as-is (which then causes the return to have to be redone), whereas the latter goes through signatureToSignatureDeclarationHelper which sees the outer A and decides to rename (letting the return type remain as-is instead).