From 899117c3197fe6c60f065580a3974d5e5fb46834 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Thu, 7 Sep 2023 20:22:31 -0700 Subject: [PATCH 1/5] Add test --- .../declarationEmitBindingPatternsUnused.js | 37 +++++++++++++++++++ ...clarationEmitBindingPatternsUnused.symbols | 32 ++++++++++++++++ ...declarationEmitBindingPatternsUnused.types | 32 ++++++++++++++++ .../declarationEmitBindingPatternsUnused.ts | 15 ++++++++ 4 files changed, 116 insertions(+) create mode 100644 tests/baselines/reference/declarationEmitBindingPatternsUnused.js create mode 100644 tests/baselines/reference/declarationEmitBindingPatternsUnused.symbols create mode 100644 tests/baselines/reference/declarationEmitBindingPatternsUnused.types create mode 100644 tests/cases/compiler/declarationEmitBindingPatternsUnused.ts diff --git a/tests/baselines/reference/declarationEmitBindingPatternsUnused.js b/tests/baselines/reference/declarationEmitBindingPatternsUnused.js new file mode 100644 index 0000000000000..d28277252b0c5 --- /dev/null +++ b/tests/baselines/reference/declarationEmitBindingPatternsUnused.js @@ -0,0 +1,37 @@ +//// [tests/cases/compiler/declarationEmitBindingPatternsUnused.ts] //// + +//// [declarationEmitBindingPatternsUnused.ts] +function shouldNotKeep({ name: alias }: { name: string }) { + +} + +function shouldNotKeepButIsKept({ name: alias }: { name: string }) { + return alias; +} + +function shouldKeep({ name: alias }: { name: string }): typeof alias { + return alias; +} + + +//// [declarationEmitBindingPatternsUnused.js] +function shouldNotKeep({ name: alias }) { +} +function shouldNotKeepButIsKept({ name: alias }) { + return alias; +} +function shouldKeep({ name: alias }) { + return alias; +} + + +//// [declarationEmitBindingPatternsUnused.d.ts] +declare function shouldNotKeep({ name }: { + name: string; +}): void; +declare function shouldNotKeepButIsKept({ name: alias }: { + name: string; +}): string; +declare function shouldKeep({ name: alias }: { + name: string; +}): typeof alias; diff --git a/tests/baselines/reference/declarationEmitBindingPatternsUnused.symbols b/tests/baselines/reference/declarationEmitBindingPatternsUnused.symbols new file mode 100644 index 0000000000000..843e4e39c03ac --- /dev/null +++ b/tests/baselines/reference/declarationEmitBindingPatternsUnused.symbols @@ -0,0 +1,32 @@ +//// [tests/cases/compiler/declarationEmitBindingPatternsUnused.ts] //// + +=== declarationEmitBindingPatternsUnused.ts === +function shouldNotKeep({ name: alias }: { name: string }) { +>shouldNotKeep : Symbol(shouldNotKeep, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 41)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 0, 24)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 41)) + +} + +function shouldNotKeepButIsKept({ name: alias }: { name: string }) { +>shouldNotKeepButIsKept : Symbol(shouldNotKeepButIsKept, Decl(declarationEmitBindingPatternsUnused.ts, 2, 1)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 4, 50)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 4, 33)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 4, 50)) + + return alias; +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 4, 33)) +} + +function shouldKeep({ name: alias }: { name: string }): typeof alias { +>shouldKeep : Symbol(shouldKeep, Decl(declarationEmitBindingPatternsUnused.ts, 6, 1)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 8, 38)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 8, 21)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 8, 38)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 8, 21)) + + return alias; +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 8, 21)) +} + diff --git a/tests/baselines/reference/declarationEmitBindingPatternsUnused.types b/tests/baselines/reference/declarationEmitBindingPatternsUnused.types new file mode 100644 index 0000000000000..e3cd43f5ec503 --- /dev/null +++ b/tests/baselines/reference/declarationEmitBindingPatternsUnused.types @@ -0,0 +1,32 @@ +//// [tests/cases/compiler/declarationEmitBindingPatternsUnused.ts] //// + +=== declarationEmitBindingPatternsUnused.ts === +function shouldNotKeep({ name: alias }: { name: string }) { +>shouldNotKeep : ({ name: alias }: { name: string;}) => void +>name : any +>alias : string +>name : string + +} + +function shouldNotKeepButIsKept({ name: alias }: { name: string }) { +>shouldNotKeepButIsKept : ({ name: alias }: { name: string;}) => string +>name : any +>alias : string +>name : string + + return alias; +>alias : string +} + +function shouldKeep({ name: alias }: { name: string }): typeof alias { +>shouldKeep : ({ name: alias }: { name: string;}) => typeof alias +>name : any +>alias : string +>name : string +>alias : string + + return alias; +>alias : string +} + diff --git a/tests/cases/compiler/declarationEmitBindingPatternsUnused.ts b/tests/cases/compiler/declarationEmitBindingPatternsUnused.ts new file mode 100644 index 0000000000000..f73d04dcee5b2 --- /dev/null +++ b/tests/cases/compiler/declarationEmitBindingPatternsUnused.ts @@ -0,0 +1,15 @@ +// @declaration: true +// @target: esnext +// @skipLibCheck: false + +function shouldNotKeep({ name: alias }: { name: string }) { + +} + +function shouldNotKeepButIsKept({ name: alias }: { name: string }) { + return alias; +} + +function shouldKeep({ name: alias }: { name: string }): typeof alias { + return alias; +} From 0055c91288512e2c0fd288fae3b2fdaa51c859aa Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Thu, 7 Sep 2023 20:59:13 -0700 Subject: [PATCH 2/5] Bring back renamings in emitted d.ts files --- src/compiler/transformers/declarations.ts | 18 ++--------- .../declarationEmitBindingPatternsUnused.js | 2 +- .../declarationEmitKeywordDestructuring.js | 6 ++-- .../reference/destructuringInFunctionType.js | 2 +- .../paramterDestrcuturingDeclaration.js | 4 +-- ...amingDestructuredPropertyInFunctionType.js | 30 +++++++++---------- 6 files changed, 25 insertions(+), 37 deletions(-) diff --git a/src/compiler/transformers/declarations.ts b/src/compiler/transformers/declarations.ts index aa8ab4f9fbee0..c51804e0e9ec0 100644 --- a/src/compiler/transformers/declarations.ts +++ b/src/compiler/transformers/declarations.ts @@ -116,8 +116,6 @@ import { isFunctionDeclaration, isFunctionLike, isGlobalScopeAugmentation, - isIdentifier, - isIdentifierANonContextualKeyword, isIdentifierText, isImportDeclaration, isImportEqualsDeclaration, @@ -684,7 +682,7 @@ export function transformDeclarations(context: TransformationContext) { return ret; } - function filterBindingPatternInitializersAndRenamings(name: BindingName) { + function filterBindingPatternInitializers(name: BindingName) { if (name.kind === SyntaxKind.Identifier) { return name; } @@ -705,21 +703,11 @@ 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 - return factory.updateBindingElement( - elem, - elem.dotDotDotToken, - /*propertyName*/ undefined, - elem.propertyName, - shouldPrintWithInitializer(elem) ? elem.initializer : undefined, - ); - } return factory.updateBindingElement( elem, elem.dotDotDotToken, elem.propertyName, - filterBindingPatternInitializersAndRenamings(elem.name), + filterBindingPatternInitializers(elem.name), shouldPrintWithInitializer(elem) ? elem.initializer : undefined, ); } @@ -735,7 +723,7 @@ export function transformDeclarations(context: TransformationContext) { p, maskModifiers(factory, p, modifierMask), p.dotDotDotToken, - filterBindingPatternInitializersAndRenamings(p.name), + filterBindingPatternInitializers(p.name), resolver.isOptionalParameter(p) ? (p.questionToken || factory.createToken(SyntaxKind.QuestionToken)) : undefined, ensureType(p, type || p.type, /*ignorePrivate*/ true), // Ignore private param props, since this type is going straight back into a param ensureNoInitializer(p), diff --git a/tests/baselines/reference/declarationEmitBindingPatternsUnused.js b/tests/baselines/reference/declarationEmitBindingPatternsUnused.js index d28277252b0c5..0b81a1435cdb7 100644 --- a/tests/baselines/reference/declarationEmitBindingPatternsUnused.js +++ b/tests/baselines/reference/declarationEmitBindingPatternsUnused.js @@ -26,7 +26,7 @@ function shouldKeep({ name: alias }) { //// [declarationEmitBindingPatternsUnused.d.ts] -declare function shouldNotKeep({ name }: { +declare function shouldNotKeep({ name: alias }: { name: string; }): void; declare function shouldNotKeepButIsKept({ name: alias }: { diff --git a/tests/baselines/reference/declarationEmitKeywordDestructuring.js b/tests/baselines/reference/declarationEmitKeywordDestructuring.js index 2f52ebbf5309d..f039acc5c0134 100644 --- a/tests/baselines/reference/declarationEmitKeywordDestructuring.js +++ b/tests/baselines/reference/declarationEmitKeywordDestructuring.js @@ -88,21 +88,21 @@ declare function f2({ function: _function, ...rest }: P): { await: boolean; one: boolean; }; -declare function f3({ abstract, ...rest }: P): { +declare function f3({ abstract: _abstract, ...rest }: P): { enum: boolean; function: boolean; async: boolean; await: boolean; one: boolean; }; -declare function f4({ async, ...rest }: P): { +declare function f4({ async: _async, ...rest }: P): { enum: boolean; function: boolean; abstract: boolean; await: boolean; one: boolean; }; -declare function f5({ await, ...rest }: P): { +declare function f5({ await: _await, ...rest }: P): { enum: boolean; function: boolean; abstract: boolean; diff --git a/tests/baselines/reference/destructuringInFunctionType.js b/tests/baselines/reference/destructuringInFunctionType.js index e03a8fc5c4e93..bd444d850f382 100644 --- a/tests/baselines/reference/destructuringInFunctionType.js +++ b/tests/baselines/reference/destructuringInFunctionType.js @@ -54,7 +54,7 @@ type T3 = ([{ }, { b: a; }]); -type F3 = ([{ a }, { b }]: [{ +type F3 = ([{ a: b }, { b: a }]: [{ a: any; }, { b: any; diff --git a/tests/baselines/reference/paramterDestrcuturingDeclaration.js b/tests/baselines/reference/paramterDestrcuturingDeclaration.js index 69b176dc50d35..86d8e41a90358 100644 --- a/tests/baselines/reference/paramterDestrcuturingDeclaration.js +++ b/tests/baselines/reference/paramterDestrcuturingDeclaration.js @@ -12,10 +12,10 @@ interface C { //// [paramterDestrcuturingDeclaration.d.ts] interface C { - ({ p }: { + ({ p: name }: { p: any; }): any; - new ({ p }: { + new ({ p: boolean }: { p: any; }): any; } diff --git a/tests/baselines/reference/renamingDestructuredPropertyInFunctionType.js b/tests/baselines/reference/renamingDestructuredPropertyInFunctionType.js index f3595a69e4846..af19e36e72147 100644 --- a/tests/baselines/reference/renamingDestructuredPropertyInFunctionType.js +++ b/tests/baselines/reference/renamingDestructuredPropertyInFunctionType.js @@ -101,14 +101,14 @@ type O = { c: number; }; type F1 = (arg: number) => any; -type F2 = ({ a }: O) => any; -type F3 = ({ a, b, c }: O) => any; -type F4 = ({ a }: O) => any; -type F5 = ({ a, b, c }: O) => any; +type F2 = ({ a: string }: O) => any; +type F3 = ({ a: string, b, c }: O) => any; +type F4 = ({ a: string }: O) => any; +type F5 = ({ a: string, b, c }: O) => any; type F6 = ({ a: string }: { a: any; }) => typeof string; -type F7 = ({ a, b: number }: { +type F7 = ({ a: string, b: number }: { a: any; b: any; }) => typeof number; @@ -118,14 +118,14 @@ type F8 = ({ a, b: number }: { }) => typeof number; type F9 = ([a, b, c]: [any, any, any]) => void; type G1 = new (arg: number) => any; -type G2 = new ({ a }: O) => any; -type G3 = new ({ a, b, c }: O) => any; -type G4 = new ({ a }: O) => any; -type G5 = new ({ a, b, c }: O) => any; +type G2 = new ({ a: string }: O) => any; +type G3 = new ({ a: string, b, c }: O) => any; +type G4 = new ({ a: string }: O) => any; +type G5 = new ({ a: string, b, c }: O) => any; type G6 = new ({ a: string }: { a: any; }) => typeof string; -type G7 = new ({ a, b: number }: { +type G7 = new ({ a: string, b: number }: { a: any; b: any; }) => typeof number; @@ -156,19 +156,19 @@ type G13 = new ({ [2]: string }: { }) => void; interface I { method1(arg: number): any; - method2({ a }: { + method2({ a: string }: { a: any; }): any; (arg: number): any; - ({ a }: { + ({ a: string }: { a: any; }): any; new (arg: number): any; - new ({ a }: { + new ({ a: string }: { a: any; }): any; } -declare function f1({ a }: O): void; +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; @@ -179,7 +179,7 @@ declare const obj1: { declare const obj2: { method({ a: string }: O): string; }; -declare function f6({ a }: O): void; +declare function f6({ a: string }: O): void; declare const f7: ({ a: string, b, c }: O) => void; declare const f8: ({ "a": string }: O) => void; declare function f9({ 2: string }: { From aad96926a10a8eee22ae6019f5c4b050ef17746d Mon Sep 17 00:00:00 2001 From: Titian Cernicova-Dragomir Date: Fri, 8 Sep 2023 15:49:51 +0100 Subject: [PATCH 3/5] Only keep binding element aliases if they are used in the signature. --- src/compiler/checker.ts | 6 +- src/compiler/transformers/declarations.ts | 141 ++++++- src/compiler/types.ts | 1 + ...rationEmitBindingPatternsUnused.errors.txt | 128 ++++++ .../declarationEmitBindingPatternsUnused.js | 233 ++++++++++- ...clarationEmitBindingPatternsUnused.symbols | 372 +++++++++++++++++- ...declarationEmitBindingPatternsUnused.types | 321 ++++++++++++++- .../declarationEmitKeywordDestructuring.js | 6 +- .../reference/destructuringInFunctionType.js | 2 +- .../paramterDestrcuturingDeclaration.js | 4 +- ...amingDestructuredPropertyInFunctionType.js | 30 +- .../declarationEmitBindingPatternsUnused.ts | 102 ++++- 12 files changed, 1262 insertions(+), 84 deletions(-) create mode 100644 tests/baselines/reference/declarationEmitBindingPatternsUnused.errors.txt diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 6f4c2dd1d9094..4364cd56504c8 100644 --- a/src/compiler/checker.ts +++ b/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 diff --git a/src/compiler/transformers/declarations.ts b/src/compiler/transformers/declarations.ts index c51804e0e9ec0..0eb4ca577e46e 100644 --- a/src/compiler/transformers/declarations.ts +++ b/src/compiler/transformers/declarations.ts @@ -48,6 +48,7 @@ import { factory, FileReference, filter, + findAncestor, flatMap, flatten, forEach, @@ -116,6 +117,8 @@ import { isFunctionDeclaration, isFunctionLike, isGlobalScopeAugmentation, + isIdentifier, + isIdentifierANonContextualKeyword, isIdentifierText, isImportDeclaration, isImportEqualsDeclaration, @@ -131,6 +134,7 @@ import { isModuleDeclaration, isNightly, isOmittedExpression, + isParameter, isPrivateIdentifier, isPropertyAccessExpression, isPropertySignature, @@ -184,6 +188,7 @@ import { pathContainsNodeModules, pathIsRelative, PropertyDeclaration, + PropertyName, PropertySignature, pushIfUnique, removeAllComments, @@ -296,6 +301,7 @@ export function transformDeclarations(context: TransformationContext) { let lateStatementReplacementMap: Map>; let suppressNewDiagnosticContexts: boolean; let exportedModulesFromDeclarationEmit: Symbol[] | undefined; + const usedBindingElementAliases = new Map>(); const { factory } = context; const host = context.getEmitHost(); @@ -350,7 +356,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; } @@ -360,6 +366,17 @@ export function transformDeclarations(context: TransformationContext) { } } } + if (symbolAccessibilityResult.bindingElementToMakeVisible) { + const bindingElement = symbolAccessibilityResult.bindingElementToMakeVisible; + const parameter = findAncestor(bindingElement, isParameter); + Debug.assert(parameter !== undefined); + const parentId = getOriginalNodeId(parameter.parent); + let aliases = usedBindingElementAliases.get(parentId); + if (!aliases) { + usedBindingElementAliases.set(parentId, aliases = new Map()); + } + aliases.set(getOriginalNodeId(bindingElement), bindingElement.name); + } // TODO: Do all these accessibility checks inside/after the first pass in the checker when declarations are enabled, if possible } @@ -703,6 +720,18 @@ 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) && !isIdentifierANonContextualKeyword(elem.propertyName)) { + // Remove rename. We will add it back if it used. + return factory.updateBindingElement( + elem, + elem.dotDotDotToken, + /*propertyName*/ undefined, + elem.propertyName, + shouldPrintWithInitializer(elem) ? elem.initializer : undefined, + ); + } + return factory.updateBindingElement( elem, elem.dotDotDotToken, @@ -713,6 +742,69 @@ export function transformDeclarations(context: TransformationContext) { } } + function ensureBindingAliasesInParameterList(original: Node, updater: (...p: T) => N, parametersIndex: P, args: T & Record>) { + const params = args[parametersIndex]; + const nodeId = getOriginalNodeId(original); + const aliases = usedBindingElementAliases.get(nodeId); + if (aliases) { + usedBindingElementAliases.delete(nodeId); + const newParams = map(params, addUsedBindingPatternsToParameter); + const updatableArgs: Record> = args; + updatableArgs[parametersIndex] = factory.createNodeArray(newParams, params.hasTrailingComma); + } + const finalArgs: T = args; + return updater(...finalArgs); + + 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(elem: T): T; + function visitBindingElement(elem: ArrayBindingElement): ArrayBindingElement { + if (elem.kind === SyntaxKind.OmittedExpression) { + return elem; + } + const usedAlias = aliases!.get(getOriginalNodeId(elem)); + if (usedAlias) { + 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; if (!suppressNewDiagnosticContexts) { @@ -1168,26 +1260,26 @@ 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, factory.updateConstructSignature, 2, [ 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( + const ctor = ensureBindingAliasesInParameterList(input, factory.createConstructorDeclaration, 1, [ /*modifiers*/ ensureModifiers(input), updateParamsList(input, input.parameters, ModifierFlags.None), /*body*/ undefined, - ); + ]); return cleanup(ctor); } case SyntaxKind.MethodDeclaration: { if (isPrivateIdentifier(input.name)) { return cleanup(/*returnValue*/ undefined); } - const sig = factory.createMethodDeclaration( + const sig = ensureBindingAliasesInParameterList(input, factory.createMethodDeclaration, 5, [ ensureModifiers(input), /*asteriskToken*/ undefined, input.name, @@ -1196,7 +1288,7 @@ export function transformDeclarations(context: TransformationContext) { updateParamsList(input, input.parameters), ensureType(input, input.type), /*body*/ undefined, - ); + ]); return cleanup(sig); } case SyntaxKind.GetAccessor: { @@ -1204,26 +1296,26 @@ export function transformDeclarations(context: TransformationContext) { return cleanup(/*returnValue*/ undefined); } const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input)); - return cleanup(factory.updateGetAccessorDeclaration( + return cleanup(ensureBindingAliasesInParameterList(input, factory.updateGetAccessorDeclaration, 3, [ 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, factory.updateSetAccessorDeclaration, 3, [ input, ensureModifiers(input), input.name, updateAccessorParamsList(input, hasEffectiveModifier(input, ModifierFlags.Private)), /*body*/ undefined, - )); + ])); } case SyntaxKind.PropertyDeclaration: if (isPrivateIdentifier(input.name)) { @@ -1252,7 +1344,7 @@ export function transformDeclarations(context: TransformationContext) { if (isPrivateIdentifier(input.name)) { return cleanup(/*returnValue*/ undefined); } - return cleanup(factory.updateMethodSignature( + return cleanup(ensureBindingAliasesInParameterList(input, factory.updateMethodSignature, 5, [ input, ensureModifiers(input), input.name, @@ -1260,15 +1352,15 @@ export function transformDeclarations(context: TransformationContext) { ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), ensureType(input, input.type), - )); + ])); } case SyntaxKind.CallSignature: { - return cleanup(factory.updateCallSignature( + return cleanup(ensureBindingAliasesInParameterList(input, factory.updateCallSignature, 2, [ input, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), ensureType(input, input.type), - )); + ])); } case SyntaxKind.IndexSignature: { return cleanup(factory.updateIndexSignature( @@ -1309,10 +1401,21 @@ 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, 2, [ + 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, 3, [ + 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); @@ -1509,7 +1612,7 @@ 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, factory.updateFunctionDeclaration, 5, [ input, ensureModifiers(input), /*asteriskToken*/ undefined, @@ -1518,7 +1621,7 @@ export function transformDeclarations(context: TransformationContext) { updateParamsList(input, input.parameters), ensureType(input, input.type), /*body*/ undefined, - )); + ])); if (clean && resolver.isExpandoFunctionDeclaration(input) && shouldEmitFunctionProperties(input)) { const props = resolver.getPropertiesOfContainerFunction(input); // Use parseNodeFactory so it is usable as an enclosing declaration diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 342cfc59be965..43d57474059f1 100644 --- a/src/compiler/types.ts +++ b/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 diff --git a/tests/baselines/reference/declarationEmitBindingPatternsUnused.errors.txt b/tests/baselines/reference/declarationEmitBindingPatternsUnused.errors.txt new file mode 100644 index 0000000000000..80c68b8fadc28 --- /dev/null +++ b/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 { + 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; + 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 index 0b81a1435cdb7..c21cfb9284ca0 100644 --- a/tests/baselines/reference/declarationEmitBindingPatternsUnused.js +++ b/tests/baselines/reference/declarationEmitBindingPatternsUnused.js @@ -1,37 +1,244 @@ //// [tests/cases/compiler/declarationEmitBindingPatternsUnused.ts] //// //// [declarationEmitBindingPatternsUnused.ts] -function shouldNotKeep({ name: alias }: { name: string }) { +type Named = { name: string } +function notReferenced({ name: alias }: Named) { } +function notReferencedNestedAlias({ p: { name: alias } }: { p: Named }) { +} +function notReferencedArrayAlias([a, b, { name: alias }]: Named[]) { +} + -function shouldNotKeepButIsKept({ name: alias }: { name: string }) { + +function referencedInCode({ name: alias }: Named) { return alias; } -function shouldKeep({ name: alias }: { name: string }): typeof 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 { + 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; + mParameter({ name: alias }: Named, p: typeof alias); +} //// [declarationEmitBindingPatternsUnused.js] -function shouldNotKeep({ name: alias }) { +function notReferenced({ name: alias }) { +} +function notReferencedNestedAlias({ p: { name: alias } }) { } -function shouldNotKeepButIsKept({ name: alias }) { +function notReferencedArrayAlias([a, b, { name: alias }]) { +} +function referencedInCode({ name: alias }) { + return alias; +} +function referencedInSignarture({ name: alias }) { return alias; } -function shouldKeep({ name: alias }) { +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] -declare function shouldNotKeep({ name: alias }: { +type Named = { name: string; +}; +declare function notReferenced({ name }: Named): void; +declare function notReferencedNestedAlias({ p: { name } }: { + p: Named; }): void; -declare function shouldNotKeepButIsKept({ name: alias }: { - name: string; -}): string; -declare function shouldKeep({ name: alias }: { - name: string; +declare function notReferencedArrayAlias([a, b, { name }]: Named[]): void; +declare function referencedInCode({ name }: Named): string; +declare function referencedInSignarture({ name: alias }: Named): 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; + 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; + mParameter({ name: alias }: Named, p: typeof alias): any; +} diff --git a/tests/baselines/reference/declarationEmitBindingPatternsUnused.symbols b/tests/baselines/reference/declarationEmitBindingPatternsUnused.symbols index 843e4e39c03ac..c295c7e51f0fb 100644 --- a/tests/baselines/reference/declarationEmitBindingPatternsUnused.symbols +++ b/tests/baselines/reference/declarationEmitBindingPatternsUnused.symbols @@ -1,32 +1,368 @@ //// [tests/cases/compiler/declarationEmitBindingPatternsUnused.ts] //// === declarationEmitBindingPatternsUnused.ts === -function shouldNotKeep({ name: alias }: { name: string }) { ->shouldNotKeep : Symbol(shouldNotKeep, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) ->name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 41)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 0, 24)) ->name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 41)) +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 shouldNotKeepButIsKept({ name: alias }: { name: string }) { ->shouldNotKeepButIsKept : Symbol(shouldNotKeepButIsKept, Decl(declarationEmitBindingPatternsUnused.ts, 2, 1)) ->name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 4, 50)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 4, 33)) ->name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 4, 50)) + +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, 4, 33)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 11, 27)) } -function shouldKeep({ name: alias }: { name: string }): typeof alias { ->shouldKeep : Symbol(shouldKeep, Decl(declarationEmitBindingPatternsUnused.ts, 6, 1)) ->name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 8, 38)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 8, 21)) ->name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 8, 38)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 8, 21)) +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, 8, 21)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 15, 33)) +} + +function referencedInInferredType({ name: alias }: Named) { +>referencedInInferredType : Symbol(referencedInInferredType, Decl(declarationEmitBindingPatternsUnused.ts, 17, 1)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 19, 35)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) + + type Named2 = { name: typeof alias } +>Named2 : Symbol(Named2, Decl(declarationEmitBindingPatternsUnused.ts, 19, 59)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 20, 19)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 19, 35)) + + return null! as Named2 +>Named2 : Symbol(Named2, Decl(declarationEmitBindingPatternsUnused.ts, 19, 59)) +} + +function referencedInNestedFunction({ name: alias }: Named) { +>referencedInNestedFunction : Symbol(referencedInNestedFunction, Decl(declarationEmitBindingPatternsUnused.ts, 22, 1)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 24, 37)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) + + return function(p: typeof alias) { +>p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 25, 20)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 24, 37)) + + } +} + +function referencedNestedAlias({ p: { name: alias } }: { p: Named }): typeof alias { +>referencedNestedAlias : Symbol(referencedNestedAlias, Decl(declarationEmitBindingPatternsUnused.ts, 28, 1)) +>p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 30, 56)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 30, 37)) +>p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 30, 56)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 30, 37)) + + return alias; +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 30, 37)) +} + +function referencedArrayAlias([a, b, { name: alias }]: Named[]): typeof alias { +>referencedArrayAlias : Symbol(referencedArrayAlias, Decl(declarationEmitBindingPatternsUnused.ts, 32, 1)) +>a : Symbol(a, Decl(declarationEmitBindingPatternsUnused.ts, 34, 31)) +>b : Symbol(b, Decl(declarationEmitBindingPatternsUnused.ts, 34, 33)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 34, 38)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 34, 38)) + + return alias; +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 34, 38)) } + +class NotReferencedClass { +>NotReferencedClass : Symbol(NotReferencedClass, Decl(declarationEmitBindingPatternsUnused.ts, 36, 1)) + + constructor({ name: alias }: Named) { +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 40, 14)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) + } + set x({ name: alias }: Named) { +>x : Symbol(NotReferencedClass.x, Decl(declarationEmitBindingPatternsUnused.ts, 41, 2)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 42, 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, 42, 8)) + } + m({ name: alias }: Named) { +>m : Symbol(NotReferencedClass.m, Decl(declarationEmitBindingPatternsUnused.ts, 44, 5)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 45, 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, 45, 4)) + } +} + +class ReferencedInCodeClas { +>ReferencedInCodeClas : Symbol(ReferencedInCodeClas, Decl(declarationEmitBindingPatternsUnused.ts, 48, 1)) + + constructor({ name: alias }: Named) { +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 51, 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, 51, 14)) + } + set x({ name: alias }: Named) { +>x : Symbol(ReferencedInCodeClas.x, Decl(declarationEmitBindingPatternsUnused.ts, 53, 2)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 54, 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, 54, 8)) + } + m({ name: alias }: Named) { +>m : Symbol(ReferencedInCodeClas.m, Decl(declarationEmitBindingPatternsUnused.ts, 56, 5)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 57, 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, 57, 4)) + } +} + +class ReferencedInSignartureClass { +>ReferencedInSignartureClass : Symbol(ReferencedInSignartureClass, Decl(declarationEmitBindingPatternsUnused.ts, 60, 1)) + + constructor({ name: alias }: Named, p: typeof alias) { +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 63, 14)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) +>p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 63, 36)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 63, 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, 63, 14)) + } + set x({ name: alias }: Named & { o: typeof alias }) { +>x : Symbol(ReferencedInSignartureClass.x, Decl(declarationEmitBindingPatternsUnused.ts, 65, 2)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 66, 8)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) +>o : Symbol(o, Decl(declarationEmitBindingPatternsUnused.ts, 66, 33)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 66, 8)) + + } + mReturnType({ name: alias }: Named): typeof alias { +>mReturnType : Symbol(ReferencedInSignartureClass.mReturnType, Decl(declarationEmitBindingPatternsUnused.ts, 68, 5)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 69, 14)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 69, 14)) + + return null! + } + mRerturnTypeNested({ name: alias }: Named): NonNullable { +>mRerturnTypeNested : Symbol(ReferencedInSignartureClass.mRerturnTypeNested, Decl(declarationEmitBindingPatternsUnused.ts, 71, 5)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 72, 21)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) +>NonNullable : Symbol(NonNullable, Decl(lib.es5.d.ts, --, --)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 72, 21)) + + return null! + } + mParameter({ name: alias }: Named, p: typeof alias) { +>mParameter : Symbol(ReferencedInSignartureClass.mParameter, Decl(declarationEmitBindingPatternsUnused.ts, 74, 5)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 75, 16)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) +>p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 75, 38)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 75, 16)) + + return null! + } +} + +let notReferencedFnType: ({ name: alias }: Named) => void; +>notReferencedFnType : Symbol(notReferencedFnType, Decl(declarationEmitBindingPatternsUnused.ts, 80, 3)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 80, 27)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) + +let referencedInSignartureReturnTypeFnType: ({ name: alias }: Named) => typeof alias; +>referencedInSignartureReturnTypeFnType : Symbol(referencedInSignartureReturnTypeFnType, Decl(declarationEmitBindingPatternsUnused.ts, 81, 3)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 81, 46)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 81, 46)) + +let referencedInSignartureParamTypeFnType: ({ name: alias }: Named, p: typeof alias) => void; +>referencedInSignartureParamTypeFnType : Symbol(referencedInSignartureParamTypeFnType, Decl(declarationEmitBindingPatternsUnused.ts, 82, 3)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 82, 45)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) +>p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 82, 67)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 82, 45)) + +let notReferencedCtorType: new ({ name: alias }: Named) => void; +>notReferencedCtorType : Symbol(notReferencedCtorType, Decl(declarationEmitBindingPatternsUnused.ts, 84, 3)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 84, 33)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) + +let referencedInSignartureReturnTypeCtorType: new ({ name: alias }: Named) => typeof alias; +>referencedInSignartureReturnTypeCtorType : Symbol(referencedInSignartureReturnTypeCtorType, Decl(declarationEmitBindingPatternsUnused.ts, 85, 3)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 85, 52)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 85, 52)) + +let referencedInSignartureParamTypeCtorType: new ({ name: alias }: Named, p: typeof alias) => void; +>referencedInSignartureParamTypeCtorType : Symbol(referencedInSignartureParamTypeCtorType, Decl(declarationEmitBindingPatternsUnused.ts, 86, 3)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 86, 52)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) +>p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 86, 74)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 86, 52)) + + +interface NotReferencedInterface { +>NotReferencedInterface : Symbol(NotReferencedInterface, Decl(declarationEmitBindingPatternsUnused.ts, 86, 100)) + + ({ name: alias }: Named): void +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 90, 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, 91, 7)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) + + set x({ name: alias }: Named); +>x : Symbol(NotReferencedInterface.x, Decl(declarationEmitBindingPatternsUnused.ts, 91, 35)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 92, 8)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) + + m({ name: alias }: Named); +>m : Symbol(NotReferencedInterface.m, Decl(declarationEmitBindingPatternsUnused.ts, 92, 31)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 93, 4)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) +} + +interface ReferencedInSignartureInterface { +>ReferencedInSignartureInterface : Symbol(ReferencedInSignartureInterface, Decl(declarationEmitBindingPatternsUnused.ts, 94, 1)) + + ({ name: alias }: Named, p: typeof alias): void +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 97, 3)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) +>p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 97, 25)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 97, 3)) + + ({ name: alias }: Named): typeof alias +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 98, 3)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 98, 3)) + + new ({ name: alias }: Named, p: typeof alias): void +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 100, 7)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) +>p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 100, 29)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 100, 7)) + + new ({ name: alias }: Named): typeof alias +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 101, 7)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 101, 7)) + + set x({ name: alias }: Named & { o: typeof alias }) +>x : Symbol(ReferencedInSignartureInterface.x, Decl(declarationEmitBindingPatternsUnused.ts, 101, 43)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 102, 8)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) +>o : Symbol(o, Decl(declarationEmitBindingPatternsUnused.ts, 102, 33)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 102, 8)) + + mReturnType({ name: alias }: Named): typeof alias; +>mReturnType : Symbol(ReferencedInSignartureInterface.mReturnType, Decl(declarationEmitBindingPatternsUnused.ts, 102, 52)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 103, 14)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 103, 14)) + + mRerturnTypeNested({ name: alias }: Named): NonNullable; +>mRerturnTypeNested : Symbol(ReferencedInSignartureInterface.mRerturnTypeNested, Decl(declarationEmitBindingPatternsUnused.ts, 103, 51)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 104, 21)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) +>NonNullable : Symbol(NonNullable, Decl(lib.es5.d.ts, --, --)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 104, 21)) + + mParameter({ name: alias }: Named, p: typeof alias); +>mParameter : Symbol(ReferencedInSignartureInterface.mParameter, Decl(declarationEmitBindingPatternsUnused.ts, 104, 71)) +>name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 105, 16)) +>Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) +>p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 105, 38)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 105, 16)) +} diff --git a/tests/baselines/reference/declarationEmitBindingPatternsUnused.types b/tests/baselines/reference/declarationEmitBindingPatternsUnused.types index e3cd43f5ec503..22ebcb827799c 100644 --- a/tests/baselines/reference/declarationEmitBindingPatternsUnused.types +++ b/tests/baselines/reference/declarationEmitBindingPatternsUnused.types @@ -1,32 +1,335 @@ //// [tests/cases/compiler/declarationEmitBindingPatternsUnused.ts] //// === declarationEmitBindingPatternsUnused.ts === -function shouldNotKeep({ name: alias }: { name: string }) { ->shouldNotKeep : ({ name: alias }: { name: string;}) => void +type Named = { name: string } +>Named : { name: string; } +>name : string + +function notReferenced({ name: alias }: Named) { +>notReferenced : ({ name: alias }: Named) => void >name : any >alias : string ->name : 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 shouldNotKeepButIsKept({ name: alias }: { name: string }) { ->shouldNotKeepButIsKept : ({ name: alias }: { name: string;}) => string +function referencedInCode({ name: alias }: Named) { +>referencedInCode : ({ name: alias }: Named) => string >name : any >alias : string ->name : string return alias; >alias : string } -function shouldKeep({ name: alias }: { name: string }): typeof alias { ->shouldKeep : ({ name: alias }: { name: string;}) => typeof alias +function referencedInSignarture({ name: alias }: Named): typeof alias { +>referencedInSignarture : ({ name: alias }: Named) => typeof alias >name : any >alias : string ->name : string >alias : string return alias; >alias : string } +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 { +>mRerturnTypeNested : ({ name: alias }: Named) => NonNullable +>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; +>mRerturnTypeNested : ({ name: alias }: Named) => NonNullable +>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/baselines/reference/declarationEmitKeywordDestructuring.js b/tests/baselines/reference/declarationEmitKeywordDestructuring.js index f039acc5c0134..2f52ebbf5309d 100644 --- a/tests/baselines/reference/declarationEmitKeywordDestructuring.js +++ b/tests/baselines/reference/declarationEmitKeywordDestructuring.js @@ -88,21 +88,21 @@ declare function f2({ function: _function, ...rest }: P): { await: boolean; one: boolean; }; -declare function f3({ abstract: _abstract, ...rest }: P): { +declare function f3({ abstract, ...rest }: P): { enum: boolean; function: boolean; async: boolean; await: boolean; one: boolean; }; -declare function f4({ async: _async, ...rest }: P): { +declare function f4({ async, ...rest }: P): { enum: boolean; function: boolean; abstract: boolean; await: boolean; one: boolean; }; -declare function f5({ await: _await, ...rest }: P): { +declare function f5({ await, ...rest }: P): { enum: boolean; function: boolean; abstract: boolean; diff --git a/tests/baselines/reference/destructuringInFunctionType.js b/tests/baselines/reference/destructuringInFunctionType.js index bd444d850f382..e03a8fc5c4e93 100644 --- a/tests/baselines/reference/destructuringInFunctionType.js +++ b/tests/baselines/reference/destructuringInFunctionType.js @@ -54,7 +54,7 @@ type T3 = ([{ }, { b: a; }]); -type F3 = ([{ a: b }, { b: a }]: [{ +type F3 = ([{ a }, { b }]: [{ a: any; }, { b: any; diff --git a/tests/baselines/reference/paramterDestrcuturingDeclaration.js b/tests/baselines/reference/paramterDestrcuturingDeclaration.js index 86d8e41a90358..69b176dc50d35 100644 --- a/tests/baselines/reference/paramterDestrcuturingDeclaration.js +++ b/tests/baselines/reference/paramterDestrcuturingDeclaration.js @@ -12,10 +12,10 @@ interface C { //// [paramterDestrcuturingDeclaration.d.ts] interface C { - ({ p: name }: { + ({ p }: { p: any; }): any; - new ({ p: boolean }: { + new ({ p }: { p: any; }): any; } diff --git a/tests/baselines/reference/renamingDestructuredPropertyInFunctionType.js b/tests/baselines/reference/renamingDestructuredPropertyInFunctionType.js index af19e36e72147..f3595a69e4846 100644 --- a/tests/baselines/reference/renamingDestructuredPropertyInFunctionType.js +++ b/tests/baselines/reference/renamingDestructuredPropertyInFunctionType.js @@ -101,14 +101,14 @@ type O = { c: number; }; type F1 = (arg: number) => any; -type F2 = ({ a: string }: O) => any; -type F3 = ({ a: string, b, c }: O) => any; -type F4 = ({ a: string }: O) => any; -type F5 = ({ a: string, b, c }: O) => any; +type F2 = ({ a }: O) => any; +type F3 = ({ a, b, c }: O) => any; +type F4 = ({ a }: O) => any; +type F5 = ({ a, b, c }: O) => any; type F6 = ({ a: string }: { a: any; }) => typeof string; -type F7 = ({ a: string, b: number }: { +type F7 = ({ a, b: number }: { a: any; b: any; }) => typeof number; @@ -118,14 +118,14 @@ type F8 = ({ a, b: number }: { }) => typeof number; type F9 = ([a, b, c]: [any, any, any]) => void; type G1 = new (arg: number) => any; -type G2 = new ({ a: string }: O) => any; -type G3 = new ({ a: string, b, c }: O) => any; -type G4 = new ({ a: string }: O) => any; -type G5 = new ({ a: string, b, c }: O) => any; +type G2 = new ({ a }: O) => any; +type G3 = new ({ a, b, c }: O) => any; +type G4 = new ({ a }: O) => any; +type G5 = new ({ a, b, c }: O) => any; type G6 = new ({ a: string }: { a: any; }) => typeof string; -type G7 = new ({ a: string, b: number }: { +type G7 = new ({ a, b: number }: { a: any; b: any; }) => typeof number; @@ -156,19 +156,19 @@ type G13 = new ({ [2]: string }: { }) => void; interface I { method1(arg: number): any; - method2({ a: string }: { + method2({ a }: { a: any; }): any; (arg: number): any; - ({ a: string }: { + ({ a }: { a: any; }): any; new (arg: number): any; - new ({ a: string }: { + new ({ a }: { a: any; }): any; } -declare function f1({ a: string }: O): void; +declare function f1({ a }: 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; @@ -179,7 +179,7 @@ declare const obj1: { declare const obj2: { method({ a: string }: O): string; }; -declare function f6({ a: string }: O): void; +declare function f6({ a }: O): void; declare const f7: ({ a: string, b, c }: O) => void; declare const f8: ({ "a": string }: O) => void; declare function f9({ 2: string }: { diff --git a/tests/cases/compiler/declarationEmitBindingPatternsUnused.ts b/tests/cases/compiler/declarationEmitBindingPatternsUnused.ts index f73d04dcee5b2..291b57de0943d 100644 --- a/tests/cases/compiler/declarationEmitBindingPatternsUnused.ts +++ b/tests/cases/compiler/declarationEmitBindingPatternsUnused.ts @@ -2,14 +2,110 @@ // @target: esnext // @skipLibCheck: false -function shouldNotKeep({ name: alias }: { name: string }) { +type Named = { name: string } +function notReferenced({ name: alias }: Named) { } +function notReferencedNestedAlias({ p: { name: alias } }: { p: Named }) { +} +function notReferencedArrayAlias([a, b, { name: alias }]: Named[]) { +} + + -function shouldNotKeepButIsKept({ name: alias }: { name: string }) { +function referencedInCode({ name: alias }: Named) { return alias; } -function shouldKeep({ name: alias }: { name: string }): typeof 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 { + 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; + mParameter({ name: alias }: Named, p: typeof alias); +} \ No newline at end of file From 44a6dd9340672dd344c1cf68519cb6a39f6ddb89 Mon Sep 17 00:00:00 2001 From: Titian Cernicova-Dragomir Date: Fri, 8 Sep 2023 17:40:45 +0100 Subject: [PATCH 4/5] Fixed code review issues --- src/compiler/transformers/declarations.ts | 305 ++++++++++++++++------ 1 file changed, 219 insertions(+), 86 deletions(-) diff --git a/src/compiler/transformers/declarations.ts b/src/compiler/transformers/declarations.ts index 0eb4ca577e46e..050f56b1cdf52 100644 --- a/src/compiler/transformers/declarations.ts +++ b/src/compiler/transformers/declarations.ts @@ -53,6 +53,7 @@ import { flatten, forEach, FunctionDeclaration, + FunctionExpression, FunctionTypeNode, GeneratedIdentifierFlags, GetAccessorDeclaration, @@ -67,6 +68,7 @@ import { getLeadingCommentRangesOfNode, getLineAndCharacterOfPosition, getNameOfDeclaration, + getOriginalNode, getOriginalNodeId, getOutputPathsFor, getParseTreeNode, @@ -157,6 +159,7 @@ import { isVarAwaitUsing, isVariableDeclaration, isVarUsing, + JSDocFunctionType, last, LateBoundDeclaration, LateVisibilityPaintedStatement, @@ -301,7 +304,7 @@ export function transformDeclarations(context: TransformationContext) { let lateStatementReplacementMap: Map>; let suppressNewDiagnosticContexts: boolean; let exportedModulesFromDeclarationEmit: Symbol[] | undefined; - const usedBindingElementAliases = new Map>(); + const usedBindingElementAliases = new Map>(); const { factory } = context; const host = context.getEmitHost(); @@ -370,12 +373,12 @@ export function transformDeclarations(context: TransformationContext) { const bindingElement = symbolAccessibilityResult.bindingElementToMakeVisible; const parameter = findAncestor(bindingElement, isParameter); Debug.assert(parameter !== undefined); - const parentId = getOriginalNodeId(parameter.parent); - let aliases = usedBindingElementAliases.get(parentId); + const parent = getOriginalNode(parameter.parent); + let aliases = usedBindingElementAliases.get(parent); if (!aliases) { - usedBindingElementAliases.set(parentId, aliases = new Map()); + usedBindingElementAliases.set(parent, aliases = new Map()); } - aliases.set(getOriginalNodeId(bindingElement), bindingElement.name); + 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 @@ -699,7 +702,7 @@ export function transformDeclarations(context: TransformationContext) { return ret; } - function filterBindingPatternInitializers(name: BindingName) { + function filterBindingPatternInitializersAndRenamings(name: BindingName) { if (name.kind === SyntaxKind.Identifier) { return name; } @@ -736,24 +739,124 @@ export function transformDeclarations(context: TransformationContext) { elem, elem.dotDotDotToken, elem.propertyName, - filterBindingPatternInitializers(elem.name), + filterBindingPatternInitializersAndRenamings(elem.name), shouldPrintWithInitializer(elem) ? elem.initializer : undefined, ); } } + type SignatureDeclarationWithUsableBindingAliases = Exclude; + function ensureBindingAliasesInParameterList(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, + ); - function ensureBindingAliasesInParameterList(original: Node, updater: (...p: T) => N, parametersIndex: P, args: T & Record>) { - const params = args[parametersIndex]; - const nodeId = getOriginalNodeId(original); - const aliases = usedBindingElementAliases.get(nodeId); - if (aliases) { - usedBindingElementAliases.delete(nodeId); - const newParams = map(params, addUsedBindingPatternsToParameter); - const updatableArgs: Record> = args; - updatableArgs[parametersIndex] = factory.createNodeArray(newParams, params.hasTrailingComma); + 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); } - const finalArgs: T = args; - return updater(...finalArgs); function addUsedBindingPatternsToParameter(p: ParameterDeclaration): ParameterDeclaration { return factory.updateParameterDeclaration( @@ -784,7 +887,7 @@ export function transformDeclarations(context: TransformationContext) { if (elem.kind === SyntaxKind.OmittedExpression) { return elem; } - const usedAlias = aliases!.get(getOriginalNodeId(elem)); + const usedAlias = aliases!.get(getOriginalNode(elem)); if (usedAlias) { return factory.updateBindingElement( elem, @@ -815,7 +918,7 @@ export function transformDeclarations(context: TransformationContext) { p, maskModifiers(factory, p, modifierMask), p.dotDotDotToken, - filterBindingPatternInitializers(p.name), + filterBindingPatternInitializersAndRenamings(p.name), resolver.isOptionalParameter(p) ? (p.questionToken || factory.createToken(SyntaxKind.QuestionToken)) : undefined, ensureType(p, type || p.type, /*ignorePrivate*/ true), // Ignore private param props, since this type is going straight back into a param ensureNoInitializer(p), @@ -1260,35 +1363,44 @@ export function transformDeclarations(context: TransformationContext) { return cleanup(factory.updateTypeReferenceNode(node, node.typeName, node.typeArguments)); } case SyntaxKind.ConstructSignature: - return cleanup(ensureBindingAliasesInParameterList(input, factory.updateConstructSignature, 2, [ + 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 = ensureBindingAliasesInParameterList(input, factory.createConstructorDeclaration, 1, [ - /*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); } case SyntaxKind.MethodDeclaration: { if (isPrivateIdentifier(input.name)) { return cleanup(/*returnValue*/ undefined); } - const sig = ensureBindingAliasesInParameterList(input, factory.createMethodDeclaration, 5, [ - 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); } case SyntaxKind.GetAccessor: { @@ -1296,26 +1408,32 @@ export function transformDeclarations(context: TransformationContext) { return cleanup(/*returnValue*/ undefined); } const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input)); - return cleanup(ensureBindingAliasesInParameterList(input, factory.updateGetAccessorDeclaration, 3, [ + 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(ensureBindingAliasesInParameterList(input, factory.updateSetAccessorDeclaration, 3, [ + 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: if (isPrivateIdentifier(input.name)) { @@ -1344,23 +1462,29 @@ export function transformDeclarations(context: TransformationContext) { if (isPrivateIdentifier(input.name)) { return cleanup(/*returnValue*/ undefined); } - return cleanup(ensureBindingAliasesInParameterList(input, factory.updateMethodSignature, 5, [ + 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(ensureBindingAliasesInParameterList(input, factory.updateCallSignature, 2, [ + 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: { return cleanup(factory.updateIndexSignature( @@ -1401,21 +1525,27 @@ export function transformDeclarations(context: TransformationContext) { return cleanup(factory.updateConditionalTypeNode(input, checkType, extendsType, trueType, falseType)); } case SyntaxKind.FunctionType: { - return cleanup(ensureBindingAliasesInParameterList(input, factory.updateFunctionTypeNode, 2, [ + return cleanup(ensureBindingAliasesInParameterList( input, - visitNodes(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration), - updateParamsList(input, input.parameters), - Debug.checkDefined(visitNode(input.type, visitDeclarationSubtree, isTypeNode)), - ])); + factory.updateFunctionTypeNode( + input, + visitNodes(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration), + updateParamsList(input, input.parameters), + Debug.checkDefined(visitNode(input.type, visitDeclarationSubtree, isTypeNode)), + ), + )); } case SyntaxKind.ConstructorType: { - return cleanup(ensureBindingAliasesInParameterList(input, factory.updateConstructorTypeNode, 3, [ + return cleanup(ensureBindingAliasesInParameterList( input, - ensureModifiers(input), - visitNodes(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration), - updateParamsList(input, input.parameters), - Debug.checkDefined(visitNode(input.type, visitDeclarationSubtree, isTypeNode)), - ])); + 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); @@ -1612,16 +1742,19 @@ export function transformDeclarations(context: TransformationContext) { } case SyntaxKind.FunctionDeclaration: { // Generators lose their generator-ness, excepting their return type - const clean = cleanup(ensureBindingAliasesInParameterList(input, factory.updateFunctionDeclaration, 5, [ + 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); // Use parseNodeFactory so it is usable as an enclosing declaration From c737bce45e04020f3e09b185320db30a8608bd13 Mon Sep 17 00:00:00 2001 From: Titian Cernicova-Dragomir Date: Thu, 14 Sep 2023 15:13:51 +0100 Subject: [PATCH 5/5] Do not add alias back if it was never removed (such as in the case of keyword properties) --- src/compiler/transformers/declarations.ts | 4 +- ...rationEmitBindingPatternsUnused.errors.txt | 16 +- .../declarationEmitBindingPatternsUnused.js | 10 + ...clarationEmitBindingPatternsUnused.symbols | 226 +++++++++--------- ...declarationEmitBindingPatternsUnused.types | 11 + .../declarationEmitBindingPatternsUnused.ts | 4 + 6 files changed, 156 insertions(+), 115 deletions(-) diff --git a/src/compiler/transformers/declarations.ts b/src/compiler/transformers/declarations.ts index 050f56b1cdf52..2d96b6985beb6 100644 --- a/src/compiler/transformers/declarations.ts +++ b/src/compiler/transformers/declarations.ts @@ -888,7 +888,9 @@ export function transformDeclarations(context: TransformationContext) { return elem; } const usedAlias = aliases!.get(getOriginalNode(elem)); - if (usedAlias) { + // 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, diff --git a/tests/baselines/reference/declarationEmitBindingPatternsUnused.errors.txt b/tests/baselines/reference/declarationEmitBindingPatternsUnused.errors.txt index 80c68b8fadc28..84bfe180d0084 100644 --- a/tests/baselines/reference/declarationEmitBindingPatternsUnused.errors.txt +++ b/tests/baselines/reference/declarationEmitBindingPatternsUnused.errors.txt @@ -1,9 +1,9 @@ -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(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) ==== @@ -26,6 +26,10 @@ declarationEmitBindingPatternsUnused.ts(94,12): error TS2842: 'alias' is an unus 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 diff --git a/tests/baselines/reference/declarationEmitBindingPatternsUnused.js b/tests/baselines/reference/declarationEmitBindingPatternsUnused.js index c21cfb9284ca0..79c2ea8520b8b 100644 --- a/tests/baselines/reference/declarationEmitBindingPatternsUnused.js +++ b/tests/baselines/reference/declarationEmitBindingPatternsUnused.js @@ -20,6 +20,10 @@ 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 @@ -122,6 +126,9 @@ function referencedInCode({ name: alias }) { function referencedInSignarture({ name: alias }) { return alias; } +function referencedInSignartureKeyword({ function: alias }) { + return null; +} function referencedInInferredType({ name: alias }) { return null; } @@ -191,6 +198,9 @@ declare function notReferencedNestedAlias({ p: { name } }: { 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; }; diff --git a/tests/baselines/reference/declarationEmitBindingPatternsUnused.symbols b/tests/baselines/reference/declarationEmitBindingPatternsUnused.symbols index c295c7e51f0fb..809cf5683cd21 100644 --- a/tests/baselines/reference/declarationEmitBindingPatternsUnused.symbols +++ b/tests/baselines/reference/declarationEmitBindingPatternsUnused.symbols @@ -52,317 +52,327 @@ function referencedInSignarture({ name: alias }: Named): typeof 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, 17, 1)) +>referencedInInferredType : Symbol(referencedInInferredType, Decl(declarationEmitBindingPatternsUnused.ts, 21, 1)) >name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 19, 35)) +>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, 19, 59)) ->name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 20, 19)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 19, 35)) +>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, 19, 59)) +>Named2 : Symbol(Named2, Decl(declarationEmitBindingPatternsUnused.ts, 23, 59)) } function referencedInNestedFunction({ name: alias }: Named) { ->referencedInNestedFunction : Symbol(referencedInNestedFunction, Decl(declarationEmitBindingPatternsUnused.ts, 22, 1)) +>referencedInNestedFunction : Symbol(referencedInNestedFunction, Decl(declarationEmitBindingPatternsUnused.ts, 26, 1)) >name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 24, 37)) +>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, 25, 20)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 24, 37)) +>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, 28, 1)) ->p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 30, 56)) +>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, 30, 37)) ->p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 30, 56)) +>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, 30, 37)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 34, 37)) return alias; ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 30, 37)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 34, 37)) } function referencedArrayAlias([a, b, { name: alias }]: Named[]): typeof alias { ->referencedArrayAlias : Symbol(referencedArrayAlias, Decl(declarationEmitBindingPatternsUnused.ts, 32, 1)) ->a : Symbol(a, Decl(declarationEmitBindingPatternsUnused.ts, 34, 31)) ->b : Symbol(b, Decl(declarationEmitBindingPatternsUnused.ts, 34, 33)) +>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, 34, 38)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 38, 38)) >Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 34, 38)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 38, 38)) return alias; ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 34, 38)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 38, 38)) } class NotReferencedClass { ->NotReferencedClass : Symbol(NotReferencedClass, Decl(declarationEmitBindingPatternsUnused.ts, 36, 1)) +>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, 40, 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, 41, 2)) +>x : Symbol(NotReferencedClass.x, Decl(declarationEmitBindingPatternsUnused.ts, 45, 2)) >name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 42, 8)) +>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, 42, 8)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 46, 8)) } m({ name: alias }: Named) { ->m : Symbol(NotReferencedClass.m, Decl(declarationEmitBindingPatternsUnused.ts, 44, 5)) +>m : Symbol(NotReferencedClass.m, Decl(declarationEmitBindingPatternsUnused.ts, 48, 5)) >name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 45, 4)) +>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, 45, 4)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 49, 4)) } } class ReferencedInCodeClas { ->ReferencedInCodeClas : Symbol(ReferencedInCodeClas, Decl(declarationEmitBindingPatternsUnused.ts, 48, 1)) +>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, 51, 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, 51, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 55, 14)) } set x({ name: alias }: Named) { ->x : Symbol(ReferencedInCodeClas.x, Decl(declarationEmitBindingPatternsUnused.ts, 53, 2)) +>x : Symbol(ReferencedInCodeClas.x, Decl(declarationEmitBindingPatternsUnused.ts, 57, 2)) >name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 54, 8)) +>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, 54, 8)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 58, 8)) } m({ name: alias }: Named) { ->m : Symbol(ReferencedInCodeClas.m, Decl(declarationEmitBindingPatternsUnused.ts, 56, 5)) +>m : Symbol(ReferencedInCodeClas.m, Decl(declarationEmitBindingPatternsUnused.ts, 60, 5)) >name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 57, 4)) +>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, 57, 4)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 61, 4)) } } class ReferencedInSignartureClass { ->ReferencedInSignartureClass : Symbol(ReferencedInSignartureClass, Decl(declarationEmitBindingPatternsUnused.ts, 60, 1)) +>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, 63, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 67, 14)) >Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) ->p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 63, 36)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 63, 14)) +>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, 63, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 67, 14)) } set x({ name: alias }: Named & { o: typeof alias }) { ->x : Symbol(ReferencedInSignartureClass.x, Decl(declarationEmitBindingPatternsUnused.ts, 65, 2)) +>x : Symbol(ReferencedInSignartureClass.x, Decl(declarationEmitBindingPatternsUnused.ts, 69, 2)) >name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 66, 8)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 70, 8)) >Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) ->o : Symbol(o, Decl(declarationEmitBindingPatternsUnused.ts, 66, 33)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 66, 8)) +>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, 68, 5)) +>mReturnType : Symbol(ReferencedInSignartureClass.mReturnType, Decl(declarationEmitBindingPatternsUnused.ts, 72, 5)) >name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 69, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 73, 14)) >Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 69, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 73, 14)) return null! } mRerturnTypeNested({ name: alias }: Named): NonNullable { ->mRerturnTypeNested : Symbol(ReferencedInSignartureClass.mRerturnTypeNested, Decl(declarationEmitBindingPatternsUnused.ts, 71, 5)) +>mRerturnTypeNested : Symbol(ReferencedInSignartureClass.mRerturnTypeNested, Decl(declarationEmitBindingPatternsUnused.ts, 75, 5)) >name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 72, 21)) +>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, 72, 21)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 76, 21)) return null! } mParameter({ name: alias }: Named, p: typeof alias) { ->mParameter : Symbol(ReferencedInSignartureClass.mParameter, Decl(declarationEmitBindingPatternsUnused.ts, 74, 5)) +>mParameter : Symbol(ReferencedInSignartureClass.mParameter, Decl(declarationEmitBindingPatternsUnused.ts, 78, 5)) >name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 75, 16)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 79, 16)) >Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) ->p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 75, 38)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 75, 16)) +>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, 80, 3)) +>notReferencedFnType : Symbol(notReferencedFnType, Decl(declarationEmitBindingPatternsUnused.ts, 84, 3)) >name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 80, 27)) +>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, 81, 3)) +>referencedInSignartureReturnTypeFnType : Symbol(referencedInSignartureReturnTypeFnType, Decl(declarationEmitBindingPatternsUnused.ts, 85, 3)) >name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 81, 46)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 85, 46)) >Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 81, 46)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 85, 46)) let referencedInSignartureParamTypeFnType: ({ name: alias }: Named, p: typeof alias) => void; ->referencedInSignartureParamTypeFnType : Symbol(referencedInSignartureParamTypeFnType, Decl(declarationEmitBindingPatternsUnused.ts, 82, 3)) +>referencedInSignartureParamTypeFnType : Symbol(referencedInSignartureParamTypeFnType, Decl(declarationEmitBindingPatternsUnused.ts, 86, 3)) >name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 82, 45)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 86, 45)) >Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) ->p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 82, 67)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 82, 45)) +>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, 84, 3)) +>notReferencedCtorType : Symbol(notReferencedCtorType, Decl(declarationEmitBindingPatternsUnused.ts, 88, 3)) >name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 84, 33)) +>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, 85, 3)) +>referencedInSignartureReturnTypeCtorType : Symbol(referencedInSignartureReturnTypeCtorType, Decl(declarationEmitBindingPatternsUnused.ts, 89, 3)) >name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 85, 52)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 89, 52)) >Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 85, 52)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 89, 52)) let referencedInSignartureParamTypeCtorType: new ({ name: alias }: Named, p: typeof alias) => void; ->referencedInSignartureParamTypeCtorType : Symbol(referencedInSignartureParamTypeCtorType, Decl(declarationEmitBindingPatternsUnused.ts, 86, 3)) +>referencedInSignartureParamTypeCtorType : Symbol(referencedInSignartureParamTypeCtorType, Decl(declarationEmitBindingPatternsUnused.ts, 90, 3)) >name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 86, 52)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 90, 52)) >Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) ->p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 86, 74)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 86, 52)) +>p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 90, 74)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 90, 52)) interface NotReferencedInterface { ->NotReferencedInterface : Symbol(NotReferencedInterface, Decl(declarationEmitBindingPatternsUnused.ts, 86, 100)) +>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, 90, 3)) +>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, 91, 7)) +>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, 91, 35)) +>x : Symbol(NotReferencedInterface.x, Decl(declarationEmitBindingPatternsUnused.ts, 95, 35)) >name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 92, 8)) +>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, 92, 31)) +>m : Symbol(NotReferencedInterface.m, Decl(declarationEmitBindingPatternsUnused.ts, 96, 31)) >name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 93, 4)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 97, 4)) >Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) } interface ReferencedInSignartureInterface { ->ReferencedInSignartureInterface : Symbol(ReferencedInSignartureInterface, Decl(declarationEmitBindingPatternsUnused.ts, 94, 1)) +>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, 97, 3)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 101, 3)) >Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) ->p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 97, 25)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 97, 3)) +>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, 98, 3)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 102, 3)) >Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 98, 3)) +>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, 100, 7)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 104, 7)) >Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) ->p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 100, 29)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 100, 7)) +>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, 101, 7)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 105, 7)) >Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 101, 7)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 105, 7)) set x({ name: alias }: Named & { o: typeof alias }) ->x : Symbol(ReferencedInSignartureInterface.x, Decl(declarationEmitBindingPatternsUnused.ts, 101, 43)) +>x : Symbol(ReferencedInSignartureInterface.x, Decl(declarationEmitBindingPatternsUnused.ts, 105, 43)) >name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 102, 8)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 106, 8)) >Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) ->o : Symbol(o, Decl(declarationEmitBindingPatternsUnused.ts, 102, 33)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 102, 8)) +>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, 102, 52)) +>mReturnType : Symbol(ReferencedInSignartureInterface.mReturnType, Decl(declarationEmitBindingPatternsUnused.ts, 106, 52)) >name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 103, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 107, 14)) >Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 103, 14)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 107, 14)) mRerturnTypeNested({ name: alias }: Named): NonNullable; ->mRerturnTypeNested : Symbol(ReferencedInSignartureInterface.mRerturnTypeNested, Decl(declarationEmitBindingPatternsUnused.ts, 103, 51)) +>mRerturnTypeNested : Symbol(ReferencedInSignartureInterface.mRerturnTypeNested, Decl(declarationEmitBindingPatternsUnused.ts, 107, 51)) >name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 104, 21)) +>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, 104, 21)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 108, 21)) mParameter({ name: alias }: Named, p: typeof alias); ->mParameter : Symbol(ReferencedInSignartureInterface.mParameter, Decl(declarationEmitBindingPatternsUnused.ts, 104, 71)) +>mParameter : Symbol(ReferencedInSignartureInterface.mParameter, Decl(declarationEmitBindingPatternsUnused.ts, 108, 71)) >name : Symbol(name, Decl(declarationEmitBindingPatternsUnused.ts, 0, 14)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 105, 16)) +>alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 109, 16)) >Named : Symbol(Named, Decl(declarationEmitBindingPatternsUnused.ts, 0, 0)) ->p : Symbol(p, Decl(declarationEmitBindingPatternsUnused.ts, 105, 38)) ->alias : Symbol(alias, Decl(declarationEmitBindingPatternsUnused.ts, 105, 16)) +>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 index 22ebcb827799c..32771df655b98 100644 --- a/tests/baselines/reference/declarationEmitBindingPatternsUnused.types +++ b/tests/baselines/reference/declarationEmitBindingPatternsUnused.types @@ -47,6 +47,17 @@ function referencedInSignarture({ name: alias }: Named): typeof 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 diff --git a/tests/cases/compiler/declarationEmitBindingPatternsUnused.ts b/tests/cases/compiler/declarationEmitBindingPatternsUnused.ts index 291b57de0943d..285292e8d4819 100644 --- a/tests/cases/compiler/declarationEmitBindingPatternsUnused.ts +++ b/tests/cases/compiler/declarationEmitBindingPatternsUnused.ts @@ -21,6 +21,10 @@ 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