diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 9ee8fe6572848..954e84584468b 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -6184,12 +6184,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
diff --git a/src/compiler/transformers/declarations.ts b/src/compiler/transformers/declarations.ts
index 45a5df4f0b95d..7d2946d616497 100644
--- a/src/compiler/transformers/declarations.ts
+++ b/src/compiler/transformers/declarations.ts
@@ -47,10 +47,12 @@ import {
     factory,
     FileReference,
     filter,
+    findAncestor,
     flatMap,
     flatten,
     forEach,
     FunctionDeclaration,
+    FunctionExpression,
     FunctionTypeNode,
     GeneratedIdentifierFlags,
     GetAccessorDeclaration,
@@ -66,6 +68,7 @@ import {
     getLineAndCharacterOfPosition,
     getNameOfDeclaration,
     getNormalizedAbsolutePath,
+    getOriginalNode,
     getOriginalNodeId,
     getOutputPathsFor,
     getParseTreeNode,
@@ -132,6 +135,7 @@ import {
     isModifier,
     isModuleDeclaration,
     isOmittedExpression,
+    isParameter,
     isPrivateIdentifier,
     isPropertySignature,
     isSemicolonClassElement,
@@ -153,6 +157,7 @@ import {
     isVarAwaitUsing,
     isVariableDeclaration,
     isVarUsing,
+    JSDocFunctionType,
     last,
     LateBoundDeclaration,
     LateVisibilityPaintedStatement,
@@ -184,6 +189,7 @@ import {
     pathContainsNodeModules,
     pathIsRelative,
     PropertyDeclaration,
+    PropertyName,
     PropertySignature,
     pushIfUnique,
     removeAllComments,
@@ -296,6 +302,7 @@ export function transformDeclarations(context: TransformationContext) {
     let lateStatementReplacementMap: Map<NodeId, VisitResult<LateVisibilityPaintedStatement | ExportAssignment | undefined>>;
     let suppressNewDiagnosticContexts: boolean;
     let exportedModulesFromDeclarationEmit: Symbol[] | undefined;
+    const usedBindingElementAliases = new Map<Node, Map<Node, BindingName>>();
 
     const { factory } = context;
     const host = context.getEmitHost();
@@ -361,7 +368,7 @@ export function transformDeclarations(context: TransformationContext) {
     function handleSymbolAccessibilityError(symbolAccessibilityResult: SymbolAccessibilityResult) {
         if (symbolAccessibilityResult.accessibility === SymbolAccessibility.Accessible) {
             // Add aliases back onto the possible imports list if they're not there so we can try them again with updated visibility info
-            if (symbolAccessibilityResult && symbolAccessibilityResult.aliasesToMakeVisible) {
+            if (symbolAccessibilityResult.aliasesToMakeVisible) {
                 if (!lateMarkedStatements) {
                     lateMarkedStatements = symbolAccessibilityResult.aliasesToMakeVisible;
                 }
@@ -371,6 +378,17 @@ export function transformDeclarations(context: TransformationContext) {
                     }
                 }
             }
+            if (symbolAccessibilityResult.bindingElementToMakeVisible) {
+                const bindingElement = symbolAccessibilityResult.bindingElementToMakeVisible;
+                const parameter = findAncestor(bindingElement, isParameter);
+                Debug.assert(parameter !== undefined);
+                const parent = getOriginalNode(parameter.parent);
+                let aliases = usedBindingElementAliases.get(parent);
+                if (!aliases) {
+                    usedBindingElementAliases.set(parent, aliases = new Map());
+                }
+                aliases.set(getOriginalNode(bindingElement), bindingElement.name);
+            }
 
             // TODO: Do all these accessibility checks inside/after the first pass in the checker when declarations are enabled, if possible
         }
@@ -708,8 +726,9 @@ export function transformDeclarations(context: TransformationContext) {
             if (elem.propertyName && isComputedPropertyName(elem.propertyName) && isEntityNameExpression(elem.propertyName.expression)) {
                 checkEntityNameVisibility(elem.propertyName.expression, enclosingDeclaration);
             }
-            if (elem.propertyName && isIdentifier(elem.propertyName) && isIdentifier(elem.name) && !elem.symbol.isReferenced && !isIdentifierANonContextualKeyword(elem.propertyName)) {
-                // Unnecessary property renaming is forbidden in types, so remove renaming
+
+            if (elem.propertyName && isIdentifier(elem.propertyName) && isIdentifier(elem.name) && !isIdentifierANonContextualKeyword(elem.propertyName)) {
+                // Remove rename. We will add it back if it used.
                 return factory.updateBindingElement(
                     elem,
                     elem.dotDotDotToken,
@@ -718,6 +737,7 @@ export function transformDeclarations(context: TransformationContext) {
                     shouldPrintWithInitializer(elem) ? elem.initializer : undefined,
                 );
             }
+
             return factory.updateBindingElement(
                 elem,
                 elem.dotDotDotToken,
@@ -727,6 +747,171 @@ export function transformDeclarations(context: TransformationContext) {
             );
         }
     }
+    type SignatureDeclarationWithUsableBindingAliases = Exclude<SignatureDeclaration, JSDocFunctionType | FunctionExpression | IndexSignatureDeclaration>;
+    function ensureBindingAliasesInParameterList<T extends SignatureDeclarationWithUsableBindingAliases>(input: T, updatedNode: T): T;
+    function ensureBindingAliasesInParameterList(input: SignatureDeclarationWithUsableBindingAliases, updatedNode: SignatureDeclarationWithUsableBindingAliases) {
+        const original = getOriginalNode(input);
+        const params = updatedNode.parameters;
+        const aliases = usedBindingElementAliases.get(original);
+        if (!aliases) {
+            return updatedNode;
+        }
+        usedBindingElementAliases.delete(original);
+        const newParams = map(params, addUsedBindingPatternsToParameter);
+        const newParamsNodeArray = factory.createNodeArray(newParams, params.hasTrailingComma);
+        switch (updatedNode.kind) {
+            case SyntaxKind.MethodDeclaration:
+                return factory.updateMethodDeclaration(
+                    updatedNode,
+                    updatedNode.modifiers,
+                    updatedNode.asteriskToken,
+                    updatedNode.name,
+                    updatedNode.questionToken,
+                    updatedNode.typeParameters,
+                    newParamsNodeArray,
+                    updatedNode.type,
+                    updatedNode.body,
+                );
+            case SyntaxKind.Constructor:
+                return factory.updateConstructorDeclaration(
+                    updatedNode,
+                    updatedNode.modifiers,
+                    newParamsNodeArray,
+                    updatedNode.body,
+                );
+            case SyntaxKind.GetAccessor:
+                return factory.updateGetAccessorDeclaration(
+                    updatedNode,
+                    updatedNode.modifiers,
+                    updatedNode.name,
+                    newParamsNodeArray,
+                    updatedNode.type,
+                    updatedNode.body,
+                );
+            case SyntaxKind.SetAccessor:
+                return factory.updateSetAccessorDeclaration(
+                    updatedNode,
+                    updatedNode.modifiers,
+                    updatedNode.name,
+                    newParamsNodeArray,
+                    updatedNode.body,
+                );
+            case SyntaxKind.ArrowFunction:
+                return factory.updateArrowFunction(
+                    updatedNode,
+                    updatedNode.modifiers,
+                    updatedNode.typeParameters,
+                    newParamsNodeArray,
+                    updatedNode.type,
+                    updatedNode.equalsGreaterThanToken,
+                    updatedNode.body,
+                );
+            case SyntaxKind.FunctionDeclaration:
+                return factory.updateFunctionDeclaration(
+                    updatedNode,
+                    updatedNode.modifiers,
+                    updatedNode.asteriskToken,
+                    updatedNode.name,
+                    updatedNode.typeParameters,
+                    newParamsNodeArray,
+                    updatedNode.type,
+                    updatedNode.body,
+                );
+            case SyntaxKind.CallSignature:
+                return factory.updateCallSignature(
+                    updatedNode,
+                    updatedNode.typeParameters,
+                    newParamsNodeArray,
+                    updatedNode.type,
+                );
+            case SyntaxKind.MethodSignature:
+                return factory.updateMethodSignature(
+                    updatedNode,
+                    updatedNode.modifiers,
+                    updatedNode.name,
+                    updatedNode.questionToken,
+                    updatedNode.typeParameters,
+                    newParamsNodeArray,
+                    updatedNode.type,
+                );
+
+            case SyntaxKind.ConstructSignature:
+                return factory.updateConstructSignature(
+                    updatedNode,
+                    updatedNode.typeParameters,
+                    newParamsNodeArray,
+                    updatedNode.type,
+                );
+            case SyntaxKind.FunctionType:
+                return factory.updateFunctionTypeNode(
+                    updatedNode,
+                    updatedNode.typeParameters,
+                    newParamsNodeArray,
+                    updatedNode.type,
+                );
+            case SyntaxKind.ConstructorType:
+                return factory.updateConstructorTypeNode(
+                    updatedNode,
+                    updatedNode.modifiers,
+                    updatedNode.typeParameters,
+                    newParamsNodeArray,
+                    updatedNode.type,
+                );
+            default:
+                Debug.assertNever(updatedNode);
+        }
+
+        function addUsedBindingPatternsToParameter(p: ParameterDeclaration): ParameterDeclaration {
+            return factory.updateParameterDeclaration(
+                p,
+                p.modifiers,
+                p.dotDotDotToken,
+                addUsedBindingPatternAliases(p.name),
+                p.questionToken,
+                p.type,
+                p.initializer,
+            );
+        }
+        function addUsedBindingPatternAliases(name: BindingName) {
+            if (name.kind === SyntaxKind.Identifier) {
+                return name;
+            }
+            else {
+                if (name.kind === SyntaxKind.ArrayBindingPattern) {
+                    return factory.updateArrayBindingPattern(name, visitNodes(name.elements, visitBindingElement, isArrayBindingElement));
+                }
+                else {
+                    return factory.updateObjectBindingPattern(name, visitNodes(name.elements, visitBindingElement, isBindingElement));
+                }
+            }
+
+            function visitBindingElement<T extends Node>(elem: T): T;
+            function visitBindingElement(elem: ArrayBindingElement): ArrayBindingElement {
+                if (elem.kind === SyntaxKind.OmittedExpression) {
+                    return elem;
+                }
+                const usedAlias = aliases!.get(getOriginalNode(elem));
+                // If alias is used and property name was removed by filterBindingPatternInitializersAndRenamings
+                // The alias can be preserved if it is a non contextual keyword.
+                if (usedAlias && !elem.propertyName) {
+                    return factory.updateBindingElement(
+                        elem,
+                        elem.dotDotDotToken,
+                        elem.name as PropertyName,
+                        usedAlias,
+                        elem.initializer,
+                    );
+                }
+                return factory.updateBindingElement(
+                    elem,
+                    elem.dotDotDotToken,
+                    elem.propertyName,
+                    addUsedBindingPatternAliases(elem.name),
+                    elem.initializer,
+                );
+            }
+        }
+    }
 
     function ensureParameter(p: ParameterDeclaration, modifierMask?: ModifierFlags, type?: TypeNode): ParameterDeclaration {
         let oldDiag: typeof getSymbolAccessibilityDiagnostic | undefined;
@@ -1177,18 +1362,24 @@ export function transformDeclarations(context: TransformationContext) {
                     return cleanup(factory.updateTypeReferenceNode(node, node.typeName, node.typeArguments));
                 }
                 case SyntaxKind.ConstructSignature:
-                    return cleanup(factory.updateConstructSignature(
+                    return cleanup(ensureBindingAliasesInParameterList(
                         input,
-                        ensureTypeParams(input, input.typeParameters),
-                        updateParamsList(input, input.parameters),
-                        ensureType(input, input.type),
+                        factory.updateConstructSignature(
+                            input,
+                            ensureTypeParams(input, input.typeParameters),
+                            updateParamsList(input, input.parameters),
+                            ensureType(input, input.type),
+                        ),
                     ));
                 case SyntaxKind.Constructor: {
                     // A constructor declaration may not have a type annotation
-                    const ctor = factory.createConstructorDeclaration(
-                        /*modifiers*/ ensureModifiers(input),
-                        updateParamsList(input, input.parameters, ModifierFlags.None),
-                        /*body*/ undefined,
+                    const ctor = ensureBindingAliasesInParameterList(
+                        input,
+                        factory.createConstructorDeclaration(
+                            /*modifiers*/ ensureModifiers(input),
+                            updateParamsList(input, input.parameters, ModifierFlags.None),
+                            /*body*/ undefined,
+                        ),
                     );
                     return cleanup(ctor);
                 }
@@ -1196,15 +1387,18 @@ export function transformDeclarations(context: TransformationContext) {
                     if (isPrivateIdentifier(input.name)) {
                         return cleanup(/*returnValue*/ undefined);
                     }
-                    const sig = factory.createMethodDeclaration(
-                        ensureModifiers(input),
-                        /*asteriskToken*/ undefined,
-                        input.name,
-                        input.questionToken,
-                        ensureTypeParams(input, input.typeParameters),
-                        updateParamsList(input, input.parameters),
-                        ensureType(input, input.type),
-                        /*body*/ undefined,
+                    const sig = ensureBindingAliasesInParameterList(
+                        input,
+                        factory.createMethodDeclaration(
+                            ensureModifiers(input),
+                            /*asteriskToken*/ undefined,
+                            input.name,
+                            input.questionToken,
+                            ensureTypeParams(input, input.typeParameters),
+                            updateParamsList(input, input.parameters),
+                            ensureType(input, input.type),
+                            /*body*/ undefined,
+                        ),
                     );
                     return cleanup(sig);
                 }
@@ -1213,25 +1407,31 @@ export function transformDeclarations(context: TransformationContext) {
                         return cleanup(/*returnValue*/ undefined);
                     }
                     const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input));
-                    return cleanup(factory.updateGetAccessorDeclaration(
+                    return cleanup(ensureBindingAliasesInParameterList(
                         input,
-                        ensureModifiers(input),
-                        input.name,
-                        updateAccessorParamsList(input, hasEffectiveModifier(input, ModifierFlags.Private)),
-                        ensureType(input, accessorType),
-                        /*body*/ undefined,
+                        factory.updateGetAccessorDeclaration(
+                            input,
+                            ensureModifiers(input),
+                            input.name,
+                            updateAccessorParamsList(input, hasEffectiveModifier(input, ModifierFlags.Private)),
+                            ensureType(input, accessorType),
+                            /*body*/ undefined,
+                        ),
                     ));
                 }
                 case SyntaxKind.SetAccessor: {
                     if (isPrivateIdentifier(input.name)) {
                         return cleanup(/*returnValue*/ undefined);
                     }
-                    return cleanup(factory.updateSetAccessorDeclaration(
+                    return cleanup(ensureBindingAliasesInParameterList(
                         input,
-                        ensureModifiers(input),
-                        input.name,
-                        updateAccessorParamsList(input, hasEffectiveModifier(input, ModifierFlags.Private)),
-                        /*body*/ undefined,
+                        factory.updateSetAccessorDeclaration(
+                            input,
+                            ensureModifiers(input),
+                            input.name,
+                            updateAccessorParamsList(input, hasEffectiveModifier(input, ModifierFlags.Private)),
+                            /*body*/ undefined,
+                        ),
                     ));
                 }
                 case SyntaxKind.PropertyDeclaration:
@@ -1261,22 +1461,28 @@ export function transformDeclarations(context: TransformationContext) {
                     if (isPrivateIdentifier(input.name)) {
                         return cleanup(/*returnValue*/ undefined);
                     }
-                    return cleanup(factory.updateMethodSignature(
+                    return cleanup(ensureBindingAliasesInParameterList(
                         input,
-                        ensureModifiers(input),
-                        input.name,
-                        input.questionToken,
-                        ensureTypeParams(input, input.typeParameters),
-                        updateParamsList(input, input.parameters),
-                        ensureType(input, input.type),
+                        factory.updateMethodSignature(
+                            input,
+                            ensureModifiers(input),
+                            input.name,
+                            input.questionToken,
+                            ensureTypeParams(input, input.typeParameters),
+                            updateParamsList(input, input.parameters),
+                            ensureType(input, input.type),
+                        ),
                     ));
                 }
                 case SyntaxKind.CallSignature: {
-                    return cleanup(factory.updateCallSignature(
+                    return cleanup(ensureBindingAliasesInParameterList(
                         input,
-                        ensureTypeParams(input, input.typeParameters),
-                        updateParamsList(input, input.parameters),
-                        ensureType(input, input.type),
+                        factory.updateCallSignature(
+                            input,
+                            ensureTypeParams(input, input.typeParameters),
+                            updateParamsList(input, input.parameters),
+                            ensureType(input, input.type),
+                        ),
                     ));
                 }
                 case SyntaxKind.IndexSignature: {
@@ -1318,10 +1524,27 @@ export function transformDeclarations(context: TransformationContext) {
                     return cleanup(factory.updateConditionalTypeNode(input, checkType, extendsType, trueType, falseType));
                 }
                 case SyntaxKind.FunctionType: {
-                    return cleanup(factory.updateFunctionTypeNode(input, visitNodes(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration), updateParamsList(input, input.parameters), Debug.checkDefined(visitNode(input.type, visitDeclarationSubtree, isTypeNode))));
+                    return cleanup(ensureBindingAliasesInParameterList(
+                        input,
+                        factory.updateFunctionTypeNode(
+                            input,
+                            visitNodes(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration),
+                            updateParamsList(input, input.parameters),
+                            Debug.checkDefined(visitNode(input.type, visitDeclarationSubtree, isTypeNode)),
+                        ),
+                    ));
                 }
                 case SyntaxKind.ConstructorType: {
-                    return cleanup(factory.updateConstructorTypeNode(input, ensureModifiers(input), visitNodes(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration), updateParamsList(input, input.parameters), Debug.checkDefined(visitNode(input.type, visitDeclarationSubtree, isTypeNode))));
+                    return cleanup(ensureBindingAliasesInParameterList(
+                        input,
+                        factory.updateConstructorTypeNode(
+                            input,
+                            ensureModifiers(input),
+                            visitNodes(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration),
+                            updateParamsList(input, input.parameters),
+                            Debug.checkDefined(visitNode(input.type, visitDeclarationSubtree, isTypeNode)),
+                        ),
+                    ));
                 }
                 case SyntaxKind.ImportType: {
                     if (!isLiteralImportTypeNode(input)) return cleanup(input);
@@ -1528,15 +1751,18 @@ export function transformDeclarations(context: TransformationContext) {
             }
             case SyntaxKind.FunctionDeclaration: {
                 // Generators lose their generator-ness, excepting their return type
-                const clean = cleanup(factory.updateFunctionDeclaration(
+                const clean = cleanup(ensureBindingAliasesInParameterList(
                     input,
-                    ensureModifiers(input),
-                    /*asteriskToken*/ undefined,
-                    input.name,
-                    ensureTypeParams(input, input.typeParameters),
-                    updateParamsList(input, input.parameters),
-                    ensureType(input, input.type),
-                    /*body*/ undefined,
+                    factory.updateFunctionDeclaration(
+                        input,
+                        ensureModifiers(input),
+                        /*asteriskToken*/ undefined,
+                        input.name,
+                        ensureTypeParams(input, input.typeParameters),
+                        updateParamsList(input, input.parameters),
+                        ensureType(input, input.type),
+                        /*body*/ undefined,
+                    ),
                 ));
                 if (clean && resolver.isExpandoFunctionDeclaration(input) && shouldEmitFunctionProperties(input)) {
                     const props = resolver.getPropertiesOfContainerFunction(input);
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index f430e27b8539d..a9082c159a31c 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -5578,6 +5578,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
diff --git a/tests/baselines/reference/declarationEmitBindingPatternsUnused.errors.txt b/tests/baselines/reference/declarationEmitBindingPatternsUnused.errors.txt
new file mode 100644
index 0000000000000..84bfe180d0084
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitBindingPatternsUnused.errors.txt
@@ -0,0 +1,132 @@
+declarationEmitBindingPatternsUnused.ts(85,35): error TS2842: 'alias' is an unused renaming of 'name'. Did you intend to use it as a type annotation?
+declarationEmitBindingPatternsUnused.ts(89,41): error TS2842: 'alias' is an unused renaming of 'name'. Did you intend to use it as a type annotation?
+declarationEmitBindingPatternsUnused.ts(95,11): error TS2842: 'alias' is an unused renaming of 'name'. Did you intend to use it as a type annotation?
+declarationEmitBindingPatternsUnused.ts(96,15): error TS2842: 'alias' is an unused renaming of 'name'. Did you intend to use it as a type annotation?
+declarationEmitBindingPatternsUnused.ts(97,16): error TS2842: 'alias' is an unused renaming of 'name'. Did you intend to use it as a type annotation?
+declarationEmitBindingPatternsUnused.ts(98,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 referencedInSignartureKeyword({ function: alias }: { function: string }): typeof alias {
+        return null!;
+    }
+    
+    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);
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/declarationEmitBindingPatternsUnused.js b/tests/baselines/reference/declarationEmitBindingPatternsUnused.js
new file mode 100644
index 0000000000000..79c2ea8520b8b
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitBindingPatternsUnused.js
@@ -0,0 +1,254 @@
+//// [tests/cases/compiler/declarationEmitBindingPatternsUnused.ts] ////
+
+//// [declarationEmitBindingPatternsUnused.ts]
+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 referencedInSignartureKeyword({ function: alias }: { function: string }): typeof alias {
+    return null!;
+}
+
+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;
+let referencedInSignartureReturnTypeFnType: ({ name: alias }: Named) => typeof alias;
+let referencedInSignartureParamTypeFnType: ({ name: alias }: Named, p: typeof alias) => void;
+
+let notReferencedCtorType: new ({ name: alias }: Named) => void;
+let referencedInSignartureReturnTypeCtorType: new ({ name: alias }: Named) => typeof alias;
+let referencedInSignartureParamTypeCtorType: new  ({ name: alias }: Named, p: typeof alias) => void;
+
+
+interface NotReferencedInterface {
+	({ name: alias }: Named): void
+	new ({ name: alias }: Named): void
+	set x({ name: alias }: Named);
+	m({ name: alias }: Named);
+}
+
+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);
+}
+
+//// [declarationEmitBindingPatternsUnused.js]
+function notReferenced({ name: alias }) {
+}
+function notReferencedNestedAlias({ p: { name: alias } }) {
+}
+function notReferencedArrayAlias([a, b, { name: alias }]) {
+}
+function referencedInCode({ name: alias }) {
+    return alias;
+}
+function referencedInSignarture({ name: alias }) {
+    return alias;
+}
+function referencedInSignartureKeyword({ function: alias }) {
+    return null;
+}
+function referencedInInferredType({ name: alias }) {
+    return null;
+}
+function referencedInNestedFunction({ name: alias }) {
+    return function (p) {
+    };
+}
+function referencedNestedAlias({ p: { name: alias } }) {
+    return alias;
+}
+function referencedArrayAlias([a, b, { name: alias }]) {
+    return alias;
+}
+class NotReferencedClass {
+    constructor({ name: alias }) {
+    }
+    set x({ name: alias }) {
+        console.log(alias);
+    }
+    m({ name: alias }) {
+        console.log(alias);
+    }
+}
+class ReferencedInCodeClas {
+    constructor({ name: alias }) {
+        console.log(alias);
+    }
+    set x({ name: alias }) {
+        console.log(alias);
+    }
+    m({ name: alias }) {
+        console.log(alias);
+    }
+}
+class ReferencedInSignartureClass {
+    constructor({ name: alias }, p) {
+        console.log(alias);
+    }
+    set x({ name: alias }) {
+    }
+    mReturnType({ name: alias }) {
+        return null;
+    }
+    mRerturnTypeNested({ name: alias }) {
+        return null;
+    }
+    mParameter({ name: alias }, p) {
+        return null;
+    }
+}
+let notReferencedFnType;
+let referencedInSignartureReturnTypeFnType;
+let referencedInSignartureParamTypeFnType;
+let notReferencedCtorType;
+let referencedInSignartureReturnTypeCtorType;
+let referencedInSignartureParamTypeCtorType;
+
+
+//// [declarationEmitBindingPatternsUnused.d.ts]
+type Named = {
+    name: string;
+};
+declare function notReferenced({ name }: Named): void;
+declare function notReferencedNestedAlias({ p: { name } }: {
+    p: Named;
+}): void;
+declare function notReferencedArrayAlias([a, b, { name }]: Named[]): void;
+declare function referencedInCode({ name }: Named): string;
+declare function referencedInSignarture({ name: alias }: Named): typeof alias;
+declare function referencedInSignartureKeyword({ function: alias }: {
+    function: string;
+}): typeof alias;
+declare function referencedInInferredType({ name: alias }: Named): {
+    name: typeof alias;
+};
+declare function referencedInNestedFunction({ name: alias }: Named): (p: typeof alias) => void;
+declare function referencedNestedAlias({ p: { name: alias } }: {
+    p: Named;
+}): typeof alias;
+declare function referencedArrayAlias([a, b, { name: alias }]: Named[]): typeof alias;
+declare class NotReferencedClass {
+    constructor({ name }: Named);
+    set x({ name }: Named);
+    m({ name }: Named): void;
+}
+declare class ReferencedInCodeClas {
+    constructor({ name }: Named);
+    set x({ name }: Named);
+    m({ name }: Named): void;
+}
+declare class ReferencedInSignartureClass {
+    constructor({ name: alias }: Named, p: 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): any;
+}
+declare let notReferencedFnType: ({ name }: Named) => void;
+declare let referencedInSignartureReturnTypeFnType: ({ name: alias }: Named) => typeof alias;
+declare let referencedInSignartureParamTypeFnType: ({ name: alias }: Named, p: typeof alias) => void;
+declare let notReferencedCtorType: new ({ name }: Named) => void;
+declare let referencedInSignartureReturnTypeCtorType: new ({ name: alias }: Named) => typeof alias;
+declare let referencedInSignartureParamTypeCtorType: new ({ name: alias }: Named, p: typeof alias) => void;
+interface NotReferencedInterface {
+    ({ name }: Named): void;
+    new ({ name }: Named): void;
+    set x({ name }: Named);
+    m({ name }: Named): any;
+}
+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): any;
+}
diff --git a/tests/baselines/reference/declarationEmitBindingPatternsUnused.symbols b/tests/baselines/reference/declarationEmitBindingPatternsUnused.symbols
new file mode 100644
index 0000000000000..809cf5683cd21
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitBindingPatternsUnused.symbols
@@ -0,0 +1,378 @@
+//// [tests/cases/compiler/declarationEmitBindingPatternsUnused.ts] ////
+
+=== declarationEmitBindingPatternsUnused.ts ===
+type Named = { name: string }
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+
+function notReferenced({ name: alias }: Named) {
+>notReferenced : Symbol(notReferenced, Decl(declarationEmitBindingPatternsUnused.ts, 0, 29))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 1, 24))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+
+}
+function notReferencedNestedAlias({ p: { name: alias } }: { p: Named }) {
+>notReferencedNestedAlias : Symbol(notReferencedNestedAlias, Decl(declarationEmitBindingPatternsUnused.ts, 3, 1))
+>p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 4, 59))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 4, 40))
+>p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 4, 59))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+}
+function notReferencedArrayAlias([a, b, { name: alias }]: Named[]) {
+>notReferencedArrayAlias : Symbol(notReferencedArrayAlias, Decl(declarationEmitBindingPatternsUnused.ts, 5, 1))
+>a : Symbol(a, Decl(declarationEmitBindingPatternsUnused.ts, 6, 34))
+>b : Symbol(b, Decl(declarationEmitBindingPatternsUnused.ts, 6, 36))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 6, 41))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+}
+
+
+
+function referencedInCode({ name: alias }: Named) {
+>referencedInCode : Symbol(referencedInCode, Decl(declarationEmitBindingPatternsUnused.ts, 7, 1))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 11, 27))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+
+    return alias;
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 11, 27))
+}
+
+function referencedInSignarture({ name: alias }: Named): typeof alias {
+>referencedInSignarture : Symbol(referencedInSignarture, Decl(declarationEmitBindingPatternsUnused.ts, 13, 1))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 15, 33))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 15, 33))
+
+    return alias;
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 15, 33))
+}
+
+function referencedInSignartureKeyword({ function: alias }: { function: string }): typeof alias {
+>referencedInSignartureKeyword : Symbol(referencedInSignartureKeyword, Decl(declarationEmitBindingPatternsUnused.ts, 17, 1))
+>function : Symbol(function, Decl(declarationEmitBindingPatternsUnused.ts, 19, 61))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 19, 40))
+>function : Symbol(function, Decl(declarationEmitBindingPatternsUnused.ts, 19, 61))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 19, 40))
+
+    return null!;
+}
+
+function referencedInInferredType({ name: alias }: Named) {
+>referencedInInferredType : Symbol(referencedInInferredType, Decl(declarationEmitBindingPatternsUnused.ts, 21, 1))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 23, 35))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+
+    type Named2 = { name: typeof alias }
+>Named2 : Symbol(Named2, Decl(declarationEmitBindingPatternsUnused.ts, 23, 59))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 24, 19))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 23, 35))
+
+    return null! as Named2
+>Named2 : Symbol(Named2, Decl(declarationEmitBindingPatternsUnused.ts, 23, 59))
+}
+
+function referencedInNestedFunction({ name: alias }: Named) {
+>referencedInNestedFunction : Symbol(referencedInNestedFunction, Decl(declarationEmitBindingPatternsUnused.ts, 26, 1))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 28, 37))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+
+    return function(p: typeof alias) {
+>p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 29, 20))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 28, 37))
+
+    }
+}
+
+function referencedNestedAlias({ p: { name: alias } }: { p: Named }): typeof alias {
+>referencedNestedAlias : Symbol(referencedNestedAlias, Decl(declarationEmitBindingPatternsUnused.ts, 32, 1))
+>p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 34, 56))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 34, 37))
+>p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 34, 56))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 34, 37))
+
+	return alias;
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 34, 37))
+}
+
+function referencedArrayAlias([a, b, { name: alias }]: Named[]): typeof alias {
+>referencedArrayAlias : Symbol(referencedArrayAlias, Decl(declarationEmitBindingPatternsUnused.ts, 36, 1))
+>a : Symbol(a, Decl(declarationEmitBindingPatternsUnused.ts, 38, 31))
+>b : Symbol(b, Decl(declarationEmitBindingPatternsUnused.ts, 38, 33))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 38, 38))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 38, 38))
+
+	return alias;
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 38, 38))
+}
+
+
+class NotReferencedClass {
+>NotReferencedClass : Symbol(NotReferencedClass, Decl(declarationEmitBindingPatternsUnused.ts, 40, 1))
+
+	constructor({ name: alias }: Named) {
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 44, 14))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+	}
+	set x({ name: alias }: Named) {
+>x : Symbol(NotReferencedClass.x, Decl(declarationEmitBindingPatternsUnused.ts, 45, 2))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 46, 8))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+
+        console.log(alias);
+>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>console : Symbol(console, Decl(lib.dom.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 46, 8))
+    }
+	m({ name: alias }: Named) {
+>m : Symbol(NotReferencedClass.m, Decl(declarationEmitBindingPatternsUnused.ts, 48, 5))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 49, 4))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+
+        console.log(alias);
+>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>console : Symbol(console, Decl(lib.dom.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 49, 4))
+    }
+}
+
+class ReferencedInCodeClas {
+>ReferencedInCodeClas : Symbol(ReferencedInCodeClas, Decl(declarationEmitBindingPatternsUnused.ts, 52, 1))
+
+	constructor({ name: alias }: Named) {
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 55, 14))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+
+		console.log(alias);
+>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>console : Symbol(console, Decl(lib.dom.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 55, 14))
+	}
+	set x({ name: alias }: Named) {
+>x : Symbol(ReferencedInCodeClas.x, Decl(declarationEmitBindingPatternsUnused.ts, 57, 2))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 58, 8))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+
+        console.log(alias);
+>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>console : Symbol(console, Decl(lib.dom.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 58, 8))
+    }
+	m({ name: alias }: Named) {
+>m : Symbol(ReferencedInCodeClas.m, Decl(declarationEmitBindingPatternsUnused.ts, 60, 5))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 61, 4))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+
+        console.log(alias);
+>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>console : Symbol(console, Decl(lib.dom.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 61, 4))
+    }
+}
+
+class ReferencedInSignartureClass {
+>ReferencedInSignartureClass : Symbol(ReferencedInSignartureClass, Decl(declarationEmitBindingPatternsUnused.ts, 64, 1))
+
+	constructor({ name: alias }: Named, p: typeof alias) {
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 67, 14))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+>p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 67, 36))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 67, 14))
+
+		console.log(alias);
+>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>console : Symbol(console, Decl(lib.dom.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 67, 14))
+	}
+	set x({ name: alias }: Named & { o: typeof alias }) {
+>x : Symbol(ReferencedInSignartureClass.x, Decl(declarationEmitBindingPatternsUnused.ts, 69, 2))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 70, 8))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+>o : Symbol(o, Decl(declarationEmitBindingPatternsUnused.ts, 70, 33))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 70, 8))
+        
+    }
+	mReturnType({ name: alias }: Named): typeof alias {
+>mReturnType : Symbol(ReferencedInSignartureClass.mReturnType, Decl(declarationEmitBindingPatternsUnused.ts, 72, 5))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 73, 14))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 73, 14))
+
+        return null!
+    }
+	mRerturnTypeNested({ name: alias }: Named): NonNullable<typeof alias> {
+>mRerturnTypeNested : Symbol(ReferencedInSignartureClass.mRerturnTypeNested, Decl(declarationEmitBindingPatternsUnused.ts, 75, 5))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 76, 21))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+>NonNullable : Symbol(NonNullable, Decl(lib.es5.d.ts, --, --))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 76, 21))
+
+        return null!
+    }
+    mParameter({ name: alias }: Named, p: typeof alias) {
+>mParameter : Symbol(ReferencedInSignartureClass.mParameter, Decl(declarationEmitBindingPatternsUnused.ts, 78, 5))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 79, 16))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+>p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 79, 38))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 79, 16))
+
+        return null!
+    }
+}
+
+let notReferencedFnType: ({ name: alias }: Named) => void;
+>notReferencedFnType : Symbol(notReferencedFnType, Decl(declarationEmitBindingPatternsUnused.ts, 84, 3))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 84, 27))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+
+let referencedInSignartureReturnTypeFnType: ({ name: alias }: Named) => typeof alias;
+>referencedInSignartureReturnTypeFnType : Symbol(referencedInSignartureReturnTypeFnType, Decl(declarationEmitBindingPatternsUnused.ts, 85, 3))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 85, 46))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 85, 46))
+
+let referencedInSignartureParamTypeFnType: ({ name: alias }: Named, p: typeof alias) => void;
+>referencedInSignartureParamTypeFnType : Symbol(referencedInSignartureParamTypeFnType, Decl(declarationEmitBindingPatternsUnused.ts, 86, 3))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 86, 45))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+>p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 86, 67))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 86, 45))
+
+let notReferencedCtorType: new ({ name: alias }: Named) => void;
+>notReferencedCtorType : Symbol(notReferencedCtorType, Decl(declarationEmitBindingPatternsUnused.ts, 88, 3))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 88, 33))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+
+let referencedInSignartureReturnTypeCtorType: new ({ name: alias }: Named) => typeof alias;
+>referencedInSignartureReturnTypeCtorType : Symbol(referencedInSignartureReturnTypeCtorType, Decl(declarationEmitBindingPatternsUnused.ts, 89, 3))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 89, 52))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 89, 52))
+
+let referencedInSignartureParamTypeCtorType: new  ({ name: alias }: Named, p: typeof alias) => void;
+>referencedInSignartureParamTypeCtorType : Symbol(referencedInSignartureParamTypeCtorType, Decl(declarationEmitBindingPatternsUnused.ts, 90, 3))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 90, 52))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+>p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 90, 74))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 90, 52))
+
+
+interface NotReferencedInterface {
+>NotReferencedInterface : Symbol(NotReferencedInterface, Decl(declarationEmitBindingPatternsUnused.ts, 90, 100))
+
+	({ name: alias }: Named): void
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 94, 3))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+
+	new ({ name: alias }: Named): void
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 95, 7))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+
+	set x({ name: alias }: Named);
+>x : Symbol(NotReferencedInterface.x, Decl(declarationEmitBindingPatternsUnused.ts, 95, 35))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 96, 8))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+
+	m({ name: alias }: Named);
+>m : Symbol(NotReferencedInterface.m, Decl(declarationEmitBindingPatternsUnused.ts, 96, 31))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 97, 4))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+}
+
+interface ReferencedInSignartureInterface {
+>ReferencedInSignartureInterface : Symbol(ReferencedInSignartureInterface, Decl(declarationEmitBindingPatternsUnused.ts, 98, 1))
+
+	({ name: alias }: Named, p: typeof alias): void
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 101, 3))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+>p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 101, 25))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 101, 3))
+
+	({ name: alias }: Named): typeof alias
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 102, 3))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 102, 3))
+	
+	new ({ name: alias }: Named, p: typeof alias): void
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 104, 7))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+>p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 104, 29))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 104, 7))
+
+	new ({ name: alias }: Named): typeof alias
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 105, 7))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 105, 7))
+
+	set x({ name: alias }: Named & { o: typeof alias })
+>x : Symbol(ReferencedInSignartureInterface.x, Decl(declarationEmitBindingPatternsUnused.ts, 105, 43))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 106, 8))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+>o : Symbol(o, Decl(declarationEmitBindingPatternsUnused.ts, 106, 33))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 106, 8))
+
+	mReturnType({ name: alias }: Named): typeof alias;
+>mReturnType : Symbol(ReferencedInSignartureInterface.mReturnType, Decl(declarationEmitBindingPatternsUnused.ts, 106, 52))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 107, 14))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 107, 14))
+
+	mRerturnTypeNested({ name: alias }: Named): NonNullable<typeof alias>;
+>mRerturnTypeNested : Symbol(ReferencedInSignartureInterface.mRerturnTypeNested, Decl(declarationEmitBindingPatternsUnused.ts, 107, 51))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 108, 21))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+>NonNullable : Symbol(NonNullable, Decl(lib.es5.d.ts, --, --))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 108, 21))
+
+    mParameter({ name: alias }: Named, p: typeof alias);
+>mParameter : Symbol(ReferencedInSignartureInterface.mParameter, Decl(declarationEmitBindingPatternsUnused.ts, 108, 71))
+>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 109, 16))
+>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0))
+>p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 109, 38))
+>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 109, 16))
+}
diff --git a/tests/baselines/reference/declarationEmitBindingPatternsUnused.types b/tests/baselines/reference/declarationEmitBindingPatternsUnused.types
new file mode 100644
index 0000000000000..32771df655b98
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitBindingPatternsUnused.types
@@ -0,0 +1,346 @@
+//// [tests/cases/compiler/declarationEmitBindingPatternsUnused.ts] ////
+
+=== declarationEmitBindingPatternsUnused.ts ===
+type Named = { name: string }
+>Named : { name: string; }
+>name : string
+
+function notReferenced({ name: alias }: Named) {
+>notReferenced : ({ name: alias }: Named) => void
+>name : any
+>alias : string
+
+}
+function notReferencedNestedAlias({ p: { name: alias } }: { p: Named }) {
+>notReferencedNestedAlias : ({ p: { name: alias } }: {    p: Named;}) => void
+>p : any
+>name : any
+>alias : string
+>p : Named
+}
+function notReferencedArrayAlias([a, b, { name: alias }]: Named[]) {
+>notReferencedArrayAlias : ([a, b, { name: alias }]: Named[]) => void
+>a : Named
+>b : Named
+>name : any
+>alias : string
+}
+
+
+
+function referencedInCode({ name: alias }: Named) {
+>referencedInCode : ({ name: alias }: Named) => string
+>name : any
+>alias : string
+
+    return alias;
+>alias : string
+}
+
+function referencedInSignarture({ name: alias }: Named): typeof alias {
+>referencedInSignarture : ({ name: alias }: Named) => typeof alias
+>name : any
+>alias : string
+>alias : string
+
+    return alias;
+>alias : string
+}
+
+function referencedInSignartureKeyword({ function: alias }: { function: string }): typeof alias {
+>referencedInSignartureKeyword : ({ function: alias }: {    function: string;}) => typeof alias
+>function : any
+>alias : string
+>function : string
+>alias : string
+
+    return null!;
+>null! : null
+}
+
+function referencedInInferredType({ name: alias }: Named) {
+>referencedInInferredType : ({ name: alias }: Named) => { name: typeof alias; }
+>name : any
+>alias : string
+
+    type Named2 = { name: typeof alias }
+>Named2 : { name: typeof alias; }
+>name : string
+>alias : string
+
+    return null! as Named2
+>null! as Named2 : { name: string; }
+>null! : null
+}
+
+function referencedInNestedFunction({ name: alias }: Named) {
+>referencedInNestedFunction : ({ name: alias }: Named) => (p: typeof alias) => void
+>name : any
+>alias : string
+
+    return function(p: typeof alias) {
+>function(p: typeof alias) {    } : (p: typeof alias) => void
+>p : string
+>alias : string
+
+    }
+}
+
+function referencedNestedAlias({ p: { name: alias } }: { p: Named }): typeof alias {
+>referencedNestedAlias : ({ p: { name: alias } }: {    p: Named;}) => typeof alias
+>p : any
+>name : any
+>alias : string
+>p : Named
+>alias : string
+
+	return alias;
+>alias : string
+}
+
+function referencedArrayAlias([a, b, { name: alias }]: Named[]): typeof alias {
+>referencedArrayAlias : ([a, b, { name: alias }]: Named[]) => typeof alias
+>a : Named
+>b : Named
+>name : any
+>alias : string
+>alias : string
+
+	return alias;
+>alias : string
+}
+
+
+class NotReferencedClass {
+>NotReferencedClass : NotReferencedClass
+
+	constructor({ name: alias }: Named) {
+>name : any
+>alias : string
+	}
+	set x({ name: alias }: Named) {
+>x : Named
+>name : any
+>alias : string
+
+        console.log(alias);
+>console.log(alias) : void
+>console.log : (...data: any[]) => void
+>console : Console
+>log : (...data: any[]) => void
+>alias : string
+    }
+	m({ name: alias }: Named) {
+>m : ({ name: alias }: Named) => void
+>name : any
+>alias : string
+
+        console.log(alias);
+>console.log(alias) : void
+>console.log : (...data: any[]) => void
+>console : Console
+>log : (...data: any[]) => void
+>alias : string
+    }
+}
+
+class ReferencedInCodeClas {
+>ReferencedInCodeClas : ReferencedInCodeClas
+
+	constructor({ name: alias }: Named) {
+>name : any
+>alias : string
+
+		console.log(alias);
+>console.log(alias) : void
+>console.log : (...data: any[]) => void
+>console : Console
+>log : (...data: any[]) => void
+>alias : string
+	}
+	set x({ name: alias }: Named) {
+>x : Named
+>name : any
+>alias : string
+
+        console.log(alias);
+>console.log(alias) : void
+>console.log : (...data: any[]) => void
+>console : Console
+>log : (...data: any[]) => void
+>alias : string
+    }
+	m({ name: alias }: Named) {
+>m : ({ name: alias }: Named) => void
+>name : any
+>alias : string
+
+        console.log(alias);
+>console.log(alias) : void
+>console.log : (...data: any[]) => void
+>console : Console
+>log : (...data: any[]) => void
+>alias : string
+    }
+}
+
+class ReferencedInSignartureClass {
+>ReferencedInSignartureClass : ReferencedInSignartureClass
+
+	constructor({ name: alias }: Named, p: typeof alias) {
+>name : any
+>alias : string
+>p : string
+>alias : string
+
+		console.log(alias);
+>console.log(alias) : void
+>console.log : (...data: any[]) => void
+>console : Console
+>log : (...data: any[]) => void
+>alias : string
+	}
+	set x({ name: alias }: Named & { o: typeof alias }) {
+>x : Named & { o: typeof alias; }
+>name : any
+>alias : string
+>o : string
+>alias : string
+        
+    }
+	mReturnType({ name: alias }: Named): typeof alias {
+>mReturnType : ({ name: alias }: Named) => typeof alias
+>name : any
+>alias : string
+>alias : string
+
+        return null!
+>null! : null
+    }
+	mRerturnTypeNested({ name: alias }: Named): NonNullable<typeof alias> {
+>mRerturnTypeNested : ({ name: alias }: Named) => NonNullable<typeof alias>
+>name : any
+>alias : string
+>alias : string
+
+        return null!
+>null! : null
+    }
+    mParameter({ name: alias }: Named, p: typeof alias) {
+>mParameter : ({ name: alias }: Named, p: typeof alias) => any
+>name : any
+>alias : string
+>p : string
+>alias : string
+
+        return null!
+>null! : null
+    }
+}
+
+let notReferencedFnType: ({ name: alias }: Named) => void;
+>notReferencedFnType : ({ name: alias }: Named) => void
+>name : any
+>alias : string
+
+let referencedInSignartureReturnTypeFnType: ({ name: alias }: Named) => typeof alias;
+>referencedInSignartureReturnTypeFnType : ({ name: alias }: Named) => string
+>name : any
+>alias : string
+>alias : string
+
+let referencedInSignartureParamTypeFnType: ({ name: alias }: Named, p: typeof alias) => void;
+>referencedInSignartureParamTypeFnType : ({ name: alias }: Named, p: string) => void
+>name : any
+>alias : string
+>p : string
+>alias : string
+
+let notReferencedCtorType: new ({ name: alias }: Named) => void;
+>notReferencedCtorType : new ({ name: alias }: Named) => void
+>name : any
+>alias : string
+
+let referencedInSignartureReturnTypeCtorType: new ({ name: alias }: Named) => typeof alias;
+>referencedInSignartureReturnTypeCtorType : new ({ name: alias }: Named) => string
+>name : any
+>alias : string
+>alias : string
+
+let referencedInSignartureParamTypeCtorType: new  ({ name: alias }: Named, p: typeof alias) => void;
+>referencedInSignartureParamTypeCtorType : new ({ name: alias }: Named, p: string) => void
+>name : any
+>alias : string
+>p : string
+>alias : string
+
+
+interface NotReferencedInterface {
+	({ name: alias }: Named): void
+>name : any
+>alias : string
+
+	new ({ name: alias }: Named): void
+>name : any
+>alias : string
+
+	set x({ name: alias }: Named);
+>x : Named
+>name : any
+>alias : string
+
+	m({ name: alias }: Named);
+>m : ({ name: alias }: Named) => any
+>name : any
+>alias : string
+}
+
+interface ReferencedInSignartureInterface {
+	({ name: alias }: Named, p: typeof alias): void
+>name : any
+>alias : string
+>p : string
+>alias : string
+
+	({ name: alias }: Named): typeof alias
+>name : any
+>alias : string
+>alias : string
+	
+	new ({ name: alias }: Named, p: typeof alias): void
+>name : any
+>alias : string
+>p : string
+>alias : string
+
+	new ({ name: alias }: Named): typeof alias
+>name : any
+>alias : string
+>alias : string
+
+	set x({ name: alias }: Named & { o: typeof alias })
+>x : Named & { o: typeof alias; }
+>name : any
+>alias : string
+>o : string
+>alias : string
+
+	mReturnType({ name: alias }: Named): typeof alias;
+>mReturnType : ({ name: alias }: Named) => typeof alias
+>name : any
+>alias : string
+>alias : string
+
+	mRerturnTypeNested({ name: alias }: Named): NonNullable<typeof alias>;
+>mRerturnTypeNested : ({ name: alias }: Named) => NonNullable<typeof alias>
+>name : any
+>alias : string
+>alias : string
+
+    mParameter({ name: alias }: Named, p: typeof alias);
+>mParameter : ({ name: alias }: Named, p: typeof alias) => any
+>name : any
+>alias : string
+>p : string
+>alias : string
+}
diff --git a/tests/cases/compiler/declarationEmitBindingPatternsUnused.ts b/tests/cases/compiler/declarationEmitBindingPatternsUnused.ts
new file mode 100644
index 0000000000000..285292e8d4819
--- /dev/null
+++ b/tests/cases/compiler/declarationEmitBindingPatternsUnused.ts
@@ -0,0 +1,115 @@
+// @declaration: true
+// @target: esnext
+// @skipLibCheck: false
+
+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 referencedInSignartureKeyword({ function: alias }: { function: string }): typeof alias {
+    return null!;
+}
+
+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;
+let referencedInSignartureReturnTypeFnType: ({ name: alias }: Named) => typeof alias;
+let referencedInSignartureParamTypeFnType: ({ name: alias }: Named, p: typeof alias) => void;
+
+let notReferencedCtorType: new ({ name: alias }: Named) => void;
+let referencedInSignartureReturnTypeCtorType: new ({ name: alias }: Named) => typeof alias;
+let referencedInSignartureParamTypeCtorType: new  ({ name: alias }: Named, p: typeof alias) => void;
+
+
+interface NotReferencedInterface {
+	({ name: alias }: Named): void
+	new ({ name: alias }: Named): void
+	set x({ name: alias }: Named);
+	m({ name: alias }: Named);
+}
+
+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);
+}
\ No newline at end of file