fix(47561): use parameter name from enclosing declaration

Author: a-tarasyuk

src/compiler/checker.ts

@@ -6393,7 +6393,8 @@ namespace ts {
                         includePrivateSymbol?.(sym);
                     }
                     if (isIdentifier(node)) {
-                        const name = sym.flags & SymbolFlags.TypeParameter ? typeParameterToName(getDeclaredTypeOfSymbol(sym), context) : factory.cloneNode(node);
+                        const type = getDeclaredTypeOfSymbol(sym);
+                        const name = sym.flags & SymbolFlags.TypeParameter && !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration) ? typeParameterToName(type, context) : factory.cloneNode(node);
                         name.symbol = sym; // for quickinfo, which uses identifier symbol information
                         return { introducesError, node: setEmitFlags(setOriginalNode(name, node), EmitFlags.NoAsciiEscaping) };
                     }

tests/baselines/reference/typeParametersAvailableInNestedScope3.js

@@ -0,0 +1,55 @@
+//// [typeParametersAvailableInNestedScope3.ts]
+function foo<T>(v: T) {
+    function a<T>(a: T) {
+        return a;
+    }
+    function b(): T {
+        return v;
+    }
+
+    function c<T>(v: T) {
+        function a<T>(a: T) {
+            return a;
+        }
+        function b(): T {
+            return v;
+        }
+
+        return { a, b };
+    }
+
+    return { a, b, c };
+}
+
+
+
+//// [typeParametersAvailableInNestedScope3.js]
+function foo(v) {
+    function a(a) {
+        return a;
+    }
+    function b() {
+        return v;
+    }
+    function c(v) {
+        function a(a) {
+            return a;
+        }
+        function b() {
+            return v;
+        }
+        return { a: a, b: b };
+    }
+    return { a: a, b: b, c: c };
+}
+
+
+//// [typeParametersAvailableInNestedScope3.d.ts]
+declare function foo<T>(v: T): {
+    a: <T_1>(a: T_1) => T_1;
+    b: () => T;
+    c: <T_2>(v: T_2) => {
+        a: <T_3>(a: T_3) => T_3;
+        b: () => T_2;
+    };
+};

tests/baselines/reference/typeParametersAvailableInNestedScope3.symbols

@@ -0,0 +1,59 @@
+=== tests/cases/conformance/types/typeParameters/typeParameterLists/typeParametersAvailableInNestedScope3.ts ===
+function foo<T>(v: T) {
+>foo : Symbol(foo, Decl(typeParametersAvailableInNestedScope3.ts, 0, 0))
+>T : Symbol(T, Decl(typeParametersAvailableInNestedScope3.ts, 0, 13))
+>v : Symbol(v, Decl(typeParametersAvailableInNestedScope3.ts, 0, 16))
+>T : Symbol(T, Decl(typeParametersAvailableInNestedScope3.ts, 0, 13))
+
+    function a<T>(a: T) {
+>a : Symbol(a, Decl(typeParametersAvailableInNestedScope3.ts, 0, 23))
+>T : Symbol(T, Decl(typeParametersAvailableInNestedScope3.ts, 1, 15))
+>a : Symbol(a, Decl(typeParametersAvailableInNestedScope3.ts, 1, 18))
+>T : Symbol(T, Decl(typeParametersAvailableInNestedScope3.ts, 1, 15))
+
+        return a;
+>a : Symbol(a, Decl(typeParametersAvailableInNestedScope3.ts, 1, 18))
+    }
+    function b(): T {
+>b : Symbol(b, Decl(typeParametersAvailableInNestedScope3.ts, 3, 5))
+>T : Symbol(T, Decl(typeParametersAvailableInNestedScope3.ts, 0, 13))
+
+        return v;
+>v : Symbol(v, Decl(typeParametersAvailableInNestedScope3.ts, 0, 16))
+    }
+
+    function c<T>(v: T) {
+>c : Symbol(c, Decl(typeParametersAvailableInNestedScope3.ts, 6, 5))
+>T : Symbol(T, Decl(typeParametersAvailableInNestedScope3.ts, 8, 15))
+>v : Symbol(v, Decl(typeParametersAvailableInNestedScope3.ts, 8, 18))
+>T : Symbol(T, Decl(typeParametersAvailableInNestedScope3.ts, 8, 15))
+
+        function a<T>(a: T) {
+>a : Symbol(a, Decl(typeParametersAvailableInNestedScope3.ts, 8, 25))
+>T : Symbol(T, Decl(typeParametersAvailableInNestedScope3.ts, 9, 19))
+>a : Symbol(a, Decl(typeParametersAvailableInNestedScope3.ts, 9, 22))
+>T : Symbol(T, Decl(typeParametersAvailableInNestedScope3.ts, 9, 19))
+
+            return a;
+>a : Symbol(a, Decl(typeParametersAvailableInNestedScope3.ts, 9, 22))
+        }
+        function b(): T {
+>b : Symbol(b, Decl(typeParametersAvailableInNestedScope3.ts, 11, 9))
+>T : Symbol(T, Decl(typeParametersAvailableInNestedScope3.ts, 8, 15))
+
+            return v;
+>v : Symbol(v, Decl(typeParametersAvailableInNestedScope3.ts, 8, 18))
+        }
+
+        return { a, b };
+>a : Symbol(a, Decl(typeParametersAvailableInNestedScope3.ts, 16, 16))
+>b : Symbol(b, Decl(typeParametersAvailableInNestedScope3.ts, 16, 19))
+    }
+
+    return { a, b, c };
+>a : Symbol(a, Decl(typeParametersAvailableInNestedScope3.ts, 19, 12))
+>b : Symbol(b, Decl(typeParametersAvailableInNestedScope3.ts, 19, 15))
+>c : Symbol(c, Decl(typeParametersAvailableInNestedScope3.ts, 19, 18))
+}
+
+

tests/baselines/reference/typeParametersAvailableInNestedScope3.types

@@ -0,0 +1,51 @@
+=== tests/cases/conformance/types/typeParameters/typeParameterLists/typeParametersAvailableInNestedScope3.ts ===
+function foo<T>(v: T) {
+>foo : <T>(v: T) => { a: <T>(a: T) => T; b: () => T; c: <T>(v: T) => { a: <T>(a: T) => T; b: () => T; }; }
+>v : T
+
+    function a<T>(a: T) {
+>a : <T>(a: T) => T
+>a : T
+
+        return a;
+>a : T
+    }
+    function b(): T {
+>b : () => T
+
+        return v;
+>v : T
+    }
+
+    function c<T>(v: T) {
+>c : <T>(v: T) => { a: <T>(a: T) => T; b: () => T; }
+>v : T
+
+        function a<T>(a: T) {
+>a : <T>(a: T) => T
+>a : T
+
+            return a;
+>a : T
+        }
+        function b(): T {
+>b : () => T
+
+            return v;
+>v : T
+        }
+
+        return { a, b };
+>{ a, b } : { a: <T>(a: T) => T; b: () => T; }
+>a : <T>(a: T) => T
+>b : () => T
+    }
+
+    return { a, b, c };
+>{ a, b, c } : { a: <T>(a: T) => T; b: () => T; c: <T>(v: T) => { a: <T>(a: T) => T; b: () => T; }; }
+>a : <T>(a: T) => T
+>b : () => T
+>c : <T>(v: T) => { a: <T>(a: T) => T; b: () => T; }
+}
+
+

tests/cases/conformance/types/typeParameters/typeParameterLists/typeParametersAvailableInNestedScope3.ts

@@ -0,0 +1,14 @@
+// @declaration: true
+
+function foo<T>(v: T) {
+    function a<T>(a: T) { return a; }
+    function b(): T { return v; }
+
+    function c<T>(v: T) {
+        function a<T>(a: T) { return a; }
+        function b(): T { return v; }
+        return { a, b };
+    }
+
+    return { a, b, c };
+}