Only keep binding element aliases if they are used in the signature.

src/compiler/checker.ts

@@ -6121,12 +6121,16 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
 
     function hasVisibleDeclarations(symbol: Symbol, shouldComputeAliasToMakeVisible: boolean): SymbolVisibilityResult | undefined {
         let aliasesToMakeVisible: LateVisibilityPaintedStatement[] | undefined;
+        let bindingElementToMakeVisible: BindingElement | undefined;
         if (!every(filter(symbol.declarations, d => d.kind !== SyntaxKind.Identifier), getIsDeclarationVisible)) {
             return undefined;
         }
-        return { accessibility: SymbolAccessibility.Accessible, aliasesToMakeVisible };
+        return { accessibility: SymbolAccessibility.Accessible, aliasesToMakeVisible, bindingElementToMakeVisible };
 
         function getIsDeclarationVisible(declaration: Declaration) {
+            if (isBindingElement(declaration) && findAncestor(declaration, isParameter)) {
+                bindingElementToMakeVisible = declaration;
+            }
             if (!isDeclarationVisible(declaration)) {
                 // Mark the unexported alias as visible if its parent is visible
                 // because these kind of aliases can be used to name types in declaration file

src/compiler/types.ts

@@ -5517,6 +5517,7 @@ export type LateVisibilityPaintedStatement =
 /** @internal */
 export interface SymbolVisibilityResult {
     accessibility: SymbolAccessibility;
+    bindingElementToMakeVisible?: BindingElement;
     aliasesToMakeVisible?: LateVisibilityPaintedStatement[]; // aliases that need to have this symbol visible
     errorSymbolName?: string; // Optional symbol name that results in error
     errorNode?: Node; // optional node that results in error

tests/baselines/reference/declarationEmitBindingPatternsUnused.errors.txt

@@ -0,0 +1,128 @@
+declarationEmitBindingPatternsUnused.ts(81,35): error TS2842: 'alias' is an unused renaming of 'name'. Did you intend to use it as a type annotation?
+declarationEmitBindingPatternsUnused.ts(85,41): error TS2842: 'alias' is an unused renaming of 'name'. Did you intend to use it as a type annotation?
+declarationEmitBindingPatternsUnused.ts(91,11): error TS2842: 'alias' is an unused renaming of 'name'. Did you intend to use it as a type annotation?
+declarationEmitBindingPatternsUnused.ts(92,15): error TS2842: 'alias' is an unused renaming of 'name'. Did you intend to use it as a type annotation?
+declarationEmitBindingPatternsUnused.ts(93,16): error TS2842: 'alias' is an unused renaming of 'name'. Did you intend to use it as a type annotation?
+declarationEmitBindingPatternsUnused.ts(94,12): error TS2842: 'alias' is an unused renaming of 'name'. Did you intend to use it as a type annotation?
+
+
+==== declarationEmitBindingPatternsUnused.ts (6 errors) ====
+    type Named = { name: string }
+    function notReferenced({ name: alias }: Named) {
+
+    }
+    function notReferencedNestedAlias({ p: { name: alias } }: { p: Named }) {
+    }
+    function notReferencedArrayAlias([a, b, { name: alias }]: Named[]) {
+    }
+
+
+
+    function referencedInCode({ name: alias }: Named) {
+        return alias;
+    }
+
+    function referencedInSignarture({ name: alias }: Named): typeof alias {
+        return alias;
+    }
+
+    function referencedInInferredType({ name: alias }: Named) {
+        type Named2 = { name: typeof alias }
+        return null! as Named2
+    }
+
+    function referencedInNestedFunction({ name: alias }: Named) {
+        return function(p: typeof alias) {
+
+        }
+    }
+
+    function referencedNestedAlias({ p: { name: alias } }: { p: Named }): typeof alias {
+    	return alias;
+    }
+
+    function referencedArrayAlias([a, b, { name: alias }]: Named[]): typeof alias {
+    	return alias;
+    }
+
+
+    class NotReferencedClass {
+    	constructor({ name: alias }: Named) {
+    	}
+    	set x({ name: alias }: Named) {
+            console.log(alias);
+        }
+    	m({ name: alias }: Named) {
+            console.log(alias);
+        }
+    }
+
+    class ReferencedInCodeClas {
+    	constructor({ name: alias }: Named) {
+    		console.log(alias);
+    	}
+    	set x({ name: alias }: Named) {
+            console.log(alias);
+        }
+    	m({ name: alias }: Named) {
+            console.log(alias);
+        }
+    }
+
+    class ReferencedInSignartureClass {
+    	constructor({ name: alias }: Named, p: typeof alias) {
+    		console.log(alias);
+    	}
+    	set x({ name: alias }: Named & { o: typeof alias }) {
+
+        }
+    	mReturnType({ name: alias }: Named): typeof alias {
+            return null!
+        }
+    	mRerturnTypeNested({ name: alias }: Named): NonNullable<typeof alias> {
+            return null!
+        }
+        mParameter({ name: alias }: Named, p: typeof alias) {
+            return null!
+        }
+    }
+
+    let notReferencedFnType: ({ name: alias }: Named) => void;
+                                      ~~~~~
+!!! error TS2842: 'alias' is an unused renaming of 'name'. Did you intend to use it as a type annotation?
+    let referencedInSignartureReturnTypeFnType: ({ name: alias }: Named) => typeof alias;
+    let referencedInSignartureParamTypeFnType: ({ name: alias }: Named, p: typeof alias) => void;
+
+    let notReferencedCtorType: new ({ name: alias }: Named) => void;
+                                            ~~~~~
+!!! error TS2842: 'alias' is an unused renaming of 'name'. Did you intend to use it as a type annotation?
+    let referencedInSignartureReturnTypeCtorType: new ({ name: alias }: Named) => typeof alias;
+    let referencedInSignartureParamTypeCtorType: new  ({ name: alias }: Named, p: typeof alias) => void;
+
+
+    interface NotReferencedInterface {
+    	({ name: alias }: Named): void
+    	         ~~~~~
+!!! error TS2842: 'alias' is an unused renaming of 'name'. Did you intend to use it as a type annotation?
+    	new ({ name: alias }: Named): void
+    	             ~~~~~
+!!! error TS2842: 'alias' is an unused renaming of 'name'. Did you intend to use it as a type annotation?
+    	set x({ name: alias }: Named);
+    	              ~~~~~
+!!! error TS2842: 'alias' is an unused renaming of 'name'. Did you intend to use it as a type annotation?
+    	m({ name: alias }: Named);
+    	          ~~~~~
+!!! error TS2842: 'alias' is an unused renaming of 'name'. Did you intend to use it as a type annotation?
+    }
+
+    interface ReferencedInSignartureInterface {
+    	({ name: alias }: Named, p: typeof alias): void
+    	({ name: alias }: Named): typeof alias
+
+    	new ({ name: alias }: Named, p: typeof alias): void
+    	new ({ name: alias }: Named): typeof alias
+    	set x({ name: alias }: Named & { o: typeof alias })
+    	mReturnType({ name: alias }: Named): typeof alias;
+    	mRerturnTypeNested({ name: alias }: Named): NonNullable<typeof alias>;
+        mParameter({ name: alias }: Named, p: typeof alias);
+    }