From 70f413ccd284055724ee81e2577aab175ccc7764 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Fri, 13 Nov 2026 22:45:42 -0800 Subject: [PATCH 1/9] Stop building invalid type syntax for hover and code fixes The node builder and the missing-type-annotation code fix could build type nodes containing syntax that is not valid in those positions: expressions in place of types, property-access expressions as typeof names, type parameter declarations in type argument lists, and type arguments in type parameter lists. These trees reach API consumers and every caller that expects valid syntax, so the printer accepted property accesses as entity names, and instantiation expressions were classified as type nodes to let them through. Most of this came from notation that hover shows but that is not valid type syntax: f.C for a class local to a generic function, outer type parameters with their constraints and defaults in names such as C.prototype, and instantiated arguments in place of a signature's type parameters, as in (value: string). Build valid syntax instead, and record the hover notation as emit-context metadata that the printer substitutes. An instantiated signature still declares its remaining type parameters, but those declarations are not printed, so they do not count toward the truncation length. Hover formatting uses a builder local to the operation so that its display metadata is not retained by the checker's cached builder. --- packages/typescript/src/ast/is.ts | 1 - packages/typescript/test/async/api.test.ts | 36 +++- packages/typescript/test/sync/api.test.ts | 36 +++- tsc/internal/ast/precedence.go | 5 +- tsc/internal/ast/utilities.go | 1 - tsc/internal/checker/checker_test.go | 28 ++++ tsc/internal/checker/nodebuilder.go | 11 ++ tsc/internal/checker/nodebuilderimpl.go | 155 +++++++++++------- tsc/internal/checker/printer.go | 8 +- ...nnotationOnExports34-object-spread_test.go | 27 +++ .../codeactions_fixmissingtypeannotation.go | 2 +- tsc/internal/printer/emitcontext.go | 38 +++++ tsc/internal/printer/factory.go | 11 ++ tsc/internal/printer/printer.go | 64 +++++--- 14 files changed, 325 insertions(+), 98 deletions(-) diff --git a/packages/typescript/src/ast/is.ts b/packages/typescript/src/ast/is.ts index f69661af7a03f..5e1eee55bd7cc 100644 --- a/packages/typescript/src/ast/is.ts +++ b/packages/typescript/src/ast/is.ts @@ -100,7 +100,6 @@ function isTypeNodeKind(kind: SyntaxKind): boolean { || kind === SyntaxKind.UndefinedKeyword || kind === SyntaxKind.NeverKeyword || kind === SyntaxKind.IntrinsicKeyword - || kind === SyntaxKind.ExpressionWithTypeArguments || kind === SyntaxKind.JSDocAllType || kind === SyntaxKind.JSDocNullableType || kind === SyntaxKind.JSDocNonNullableType diff --git a/packages/typescript/test/async/api.test.ts b/packages/typescript/test/async/api.test.ts index 3f303868a73cc..728ca258f96e7 100644 --- a/packages/typescript/test/async/api.test.ts +++ b/packages/typescript/test/async/api.test.ts @@ -13,6 +13,7 @@ import { isClassDeclaration, isExpressionStatement, isFunctionDeclaration, + isFunctionTypeNode, isIdentifier, isImportDeclaration, isInterfaceDeclaration, @@ -49,6 +50,7 @@ import { import { cloneNode, createArrayTypeNode, + createExpressionWithTypeArguments, createFunctionTypeNode, createIdentifier, createKeywordTypeNode, @@ -93,6 +95,7 @@ import { ModuleKind, ModuleResolutionKind, type ModuleResolver, + NodeBuilderFlags, type NumberLiteralType, ObjectFlags, type Program, @@ -8979,7 +8982,6 @@ export const obj = { m: 1, s: "hi", b: true }; SyntaxKind.ObjectKeyword, SyntaxKind.SymbolKeyword, SyntaxKind.IntrinsicKeyword, - SyntaxKind.ExpressionWithTypeArguments, SyntaxKind.JSDocAllType, SyntaxKind.JSDocNullableType, SyntaxKind.JSDocNonNullableType, @@ -8992,6 +8994,38 @@ export const obj = { m: 1, s: "hi", b: true }; for (const kind of kinds) { assert.ok(isTypeNode({ kind } as any), `isTypeNode should accept ${SyntaxKind[kind]}`); } + assert.ok(!isTypeNode(createExpressionWithTypeArguments(createIdentifier("f"), [createKeywordTypeNode(SyntaxKind.StringKeyword)]))); + }); + + test("node builder results keep hover-only notation out of the syntax tree", async () => { + const source = `function f(x: T) { + class C { value = x; other!: U; } + return new C(); +} +const local = f("hello"); +class N { method(value: U): U { return value; } } +const method = new N().method;`; + await using api = spawnAPI({ "/tsconfig.json": "{}", "/main.ts": source }); + const snapshot = await api.createSnapshot({ openProjects: ["/tsconfig.json"] }); + const { checker } = snapshot.getConfiguredProject("/tsconfig.json")!; + const typeOf = async (name: string) => checker.getTypeOfSymbol((await checker.getSymbolAtPosition("/main.ts", source.indexOf(`const ${name}`) + 6))!); + const assertTypeSyntax = (node: Node | undefined) => { + assert.ok(node); + (function visit(child: Node): Node { + assert.ok(child.kind !== SyntaxKind.ExpressionWithTypeArguments && child.kind !== SyntaxKind.PropertyAccessExpression, SyntaxKind[child.kind]); + return visitEachChild(child, visit); + })(node); + }; + + // f.C is only meaningful as display text. + assertTypeSyntax(await checker.typeToTypeNode(await typeOf("local"), undefined, NodeBuilderFlags.UseInstantiationExpressions)); + + // An instantiated signature still declares its remaining type parameters. + const [signature] = await (await typeOf("method")).getCallSignatures(); + const declaration = await checker.signatureToSignatureDeclaration(signature, SyntaxKind.FunctionType, undefined, NodeBuilderFlags.WriteTypeArgumentsOfSignature); + assert.ok(declaration && isFunctionTypeNode(declaration)); + assert.strictEqual(declaration.typeParameters?.[0].kind, SyntaxKind.TypeParameter); + assert.strictEqual(declaration.typeParameters[0].constraint?.kind, SyntaxKind.StringKeyword); }); test("typeToString", async () => { diff --git a/packages/typescript/test/sync/api.test.ts b/packages/typescript/test/sync/api.test.ts index c57ca53e905bc..39c6c0dbacf08 100644 --- a/packages/typescript/test/sync/api.test.ts +++ b/packages/typescript/test/sync/api.test.ts @@ -21,6 +21,7 @@ import { isClassDeclaration, isExpressionStatement, isFunctionDeclaration, + isFunctionTypeNode, isIdentifier, isImportDeclaration, isInterfaceDeclaration, @@ -57,6 +58,7 @@ import { import { cloneNode, createArrayTypeNode, + createExpressionWithTypeArguments, createFunctionTypeNode, createIdentifier, createKeywordTypeNode, @@ -115,6 +117,7 @@ import { ModuleKind, ModuleResolutionKind, type ModuleResolver, + NodeBuilderFlags, type NumberLiteralType, ObjectFlags, type Program, @@ -8737,7 +8740,6 @@ export const obj = { m: 1, s: "hi", b: true }; SyntaxKind.ObjectKeyword, SyntaxKind.SymbolKeyword, SyntaxKind.IntrinsicKeyword, - SyntaxKind.ExpressionWithTypeArguments, SyntaxKind.JSDocAllType, SyntaxKind.JSDocNullableType, SyntaxKind.JSDocNonNullableType, @@ -8750,6 +8752,38 @@ export const obj = { m: 1, s: "hi", b: true }; for (const kind of kinds) { assert.ok(isTypeNode({ kind } as any), `isTypeNode should accept ${SyntaxKind[kind]}`); } + assert.ok(!isTypeNode(createExpressionWithTypeArguments(createIdentifier("f"), [createKeywordTypeNode(SyntaxKind.StringKeyword)]))); + }); + + test("node builder results keep hover-only notation out of the syntax tree", () => { + const source = `function f(x: T) { + class C { value = x; other!: U; } + return new C(); +} +const local = f("hello"); +class N { method(value: U): U { return value; } } +const method = new N().method;`; + using api = spawnAPI({ "/tsconfig.json": "{}", "/main.ts": source }); + const snapshot = api.createSnapshot({ openProjects: ["/tsconfig.json"] }); + const { checker } = snapshot.getConfiguredProject("/tsconfig.json")!; + const typeOf = (name: string) => checker.getTypeOfSymbol((checker.getSymbolAtPosition("/main.ts", source.indexOf(`const ${name}`) + 6))!); + const assertTypeSyntax = (node: Node | undefined) => { + assert.ok(node); + (function visit(child: Node): Node { + assert.ok(child.kind !== SyntaxKind.ExpressionWithTypeArguments && child.kind !== SyntaxKind.PropertyAccessExpression, SyntaxKind[child.kind]); + return visitEachChild(child, visit); + })(node); + }; + + // f.C is only meaningful as display text. + assertTypeSyntax(checker.typeToTypeNode(typeOf("local"), undefined, NodeBuilderFlags.UseInstantiationExpressions)); + + // An instantiated signature still declares its remaining type parameters. + const [signature] = (typeOf("method")).getCallSignatures(); + const declaration = checker.signatureToSignatureDeclaration(signature, SyntaxKind.FunctionType, undefined, NodeBuilderFlags.WriteTypeArgumentsOfSignature); + assert.ok(declaration && isFunctionTypeNode(declaration)); + assert.strictEqual(declaration.typeParameters?.[0].kind, SyntaxKind.TypeParameter); + assert.strictEqual(declaration.typeParameters[0].constraint?.kind, SyntaxKind.StringKeyword); }); test("typeToString", () => { diff --git a/tsc/internal/ast/precedence.go b/tsc/internal/ast/precedence.go index bfaaa679b63af..1288c86d1bc61 100644 --- a/tsc/internal/ast/precedence.go +++ b/tsc/internal/ast/precedence.go @@ -706,10 +706,7 @@ func GetTypeNodePrecedence(n *TypeNode) TypePrecedence { KindMappedType, KindNamedTupleMember, KindTemplateLiteralType, - KindImportType, - // These occur in pseudo-types like `f.C`, where `f` is a generic function and `C` is a local type - KindPropertyAccessExpression, - KindExpressionWithTypeArguments: + KindImportType: return TypePrecedenceNonArray default: panic(fmt.Sprintf("unhandled TypeNode: %v", n.Kind)) diff --git a/tsc/internal/ast/utilities.go b/tsc/internal/ast/utilities.go index f178903372dc2..c5be1b79fb6da 100644 --- a/tsc/internal/ast/utilities.go +++ b/tsc/internal/ast/utilities.go @@ -786,7 +786,6 @@ func IsTypeNodeKind(kind Kind) bool { KindUndefinedKeyword, KindNeverKeyword, KindIntrinsicKeyword, - KindExpressionWithTypeArguments, KindJSDocAllType, KindJSDocNullableType, KindJSDocNonNullableType, diff --git a/tsc/internal/checker/checker_test.go b/tsc/internal/checker/checker_test.go index f5b766607c5f7..82ec3576c4f92 100644 --- a/tsc/internal/checker/checker_test.go +++ b/tsc/internal/checker/checker_test.go @@ -11,6 +11,8 @@ import ( "github.com/microsoft/TypeScript/tsc/internal/checker" "github.com/microsoft/TypeScript/tsc/internal/compiler" "github.com/microsoft/TypeScript/tsc/internal/core" + "github.com/microsoft/TypeScript/tsc/internal/nodebuilder" + "github.com/microsoft/TypeScript/tsc/internal/printer" "github.com/microsoft/TypeScript/tsc/internal/repo" "github.com/microsoft/TypeScript/tsc/internal/tsoptions" "github.com/microsoft/TypeScript/tsc/internal/tspath" @@ -63,6 +65,32 @@ foo.bar;` } } +func TestQualifiedNameTypeParametersAreDisplayOnly(t *testing.T) { + t.Parallel() + fs := bundled.WrapFS(vfstest.FromMap(map[string]string{ + "/main.ts": `class C {} C.prototype;`, + }, tspath.CaseSensitive)) + p, err := compiler.NewProgram(t.Context(), compiler.ProgramOptions{ + Config: tsoptions.NewParsedCommandLine(&core.CompilerOptions{}, []tspath.RootedFilePath{"/main.ts"}, nil, "/", fs.CaseSensitivity()), + Host: compiler.NewCompilerHost(fs, bundled.LibPath(), nil, nil, nil), + }) + assert.NilError(t, err) + p.BindSourceFiles() + c, done := p.GetTypeChecker(t.Context()) + defer done() + file := p.GetSourceFile("/main.ts") + access := file.Statements.Nodes[1].Expression() + emitContext := printer.NewEmitContext() + builder := checker.NewNodeBuilderEx(c, emitContext, nil) + expression := builder.SymbolToExpression(c.GetSymbolAtLocation(access), ast.SymbolFlagsValue, access, nodebuilder.FlagsWriteTypeParametersInQualifiedName, nodebuilder.InternalFlagsNone, nil) + + // The declaration's modifiers, constraint and default are display text, not a type argument. + argument := expression.Expression().AsExpressionWithTypeArguments().TypeArguments.Nodes[0] + assert.Assert(t, ast.IsTypeNode(argument), argument.Kind) + text := printer.NewPrinter(printer.PrinterOptions{}, printer.PrintHandlers{}, emitContext).Emit(expression, file) + assert.Equal(t, text, `C.prototype`) +} + func TestGetTypeAtLocationOfTypeOnlyImportClause(t *testing.T) { t.Parallel() diff --git a/tsc/internal/checker/nodebuilder.go b/tsc/internal/checker/nodebuilder.go index a4fb793b334bf..793d39daea1b9 100644 --- a/tsc/internal/checker/nodebuilder.go +++ b/tsc/internal/checker/nodebuilder.go @@ -296,6 +296,17 @@ func (c *Checker) getNodeBuilder() (*NodeBuilder, func()) { return c.typeToStringNodebuilder, releaseNodes } +// getNodeBuilderForTypeFormat uses a builder local to the operation for +// hover-only display formatting, so the display metadata it records is not +// retained by the cached builder. +func (c *Checker) getNodeBuilderForTypeFormat(flags TypeFormatFlags) (*NodeBuilder, func()) { + if flags&(TypeFormatFlagsWriteTypeArgumentsOfSignature|TypeFormatFlagsUseInstantiationExpressions) == 0 { + return c.getNodeBuilder() + } + builder := c.getNodeBuilderEx(nil) + return builder, builder.EmitContext().Factory.ReleaseArenas +} + func (c *Checker) getNodeBuilderEx(idToSymbol map[*ast.IdentifierNode]*ast.Symbol) *NodeBuilder { b := NewNodeBuilderEx(c, printer.NewEmitContext(), idToSymbol) return b diff --git a/tsc/internal/checker/nodebuilderimpl.go b/tsc/internal/checker/nodebuilderimpl.go index 2d2d01e83affa..4e502a2dbfc37 100644 --- a/tsc/internal/checker/nodebuilderimpl.go +++ b/tsc/internal/checker/nodebuilderimpl.go @@ -272,12 +272,6 @@ func (b *NodeBuilderImpl) checkTypeExpandability(t *Type) { } func (b *NodeBuilderImpl) appendReferenceToType(root *ast.TypeNode, ref *ast.TypeNode) *ast.TypeNode { - if !ast.IsImportTypeNode(root) && (ast.IsExpressionWithTypeArguments(root) || ast.IsExpressionWithTypeArguments(ref)) { - // Type arguments precede the last name of root or ref, so the - // reference is an expression with type arguments rather than a - // qualified name. - return b.appendReferenceToExpression(b.referenceToExpression(root), b.referenceToExpression(ref)) - } if ast.IsImportTypeNode(root) { // first shift type arguments @@ -310,29 +304,37 @@ func (b *NodeBuilderImpl) appendReferenceToType(root *ast.TypeNode, ref *ast.Typ return b.f.UpdateImportTypeNode(imprt, imprt.IsTypeOf, imprt.Argument, imprt.Attributes, qualifier, ref.TypeArgumentList()) } else if ast.IsTypeReferenceNode(root) { typeRef := root.AsTypeReferenceNode() - if b.ctx.flags&nodebuilder.FlagsUseInstantiationExpressions != 0 && typeRef.TypeArguments != nil && len(typeRef.TypeArguments.Nodes) != 0 { - expr := b.createExpressionWithTypeArguments(b.createAccessExpression(typeRef.TypeName), typeRef.TypeArguments) - for _, id := range getAccessStack(ref) { - expr = b.f.NewPropertyAccessExpression(expr, nil, id, ast.NodeFlagsNone) - } - return expr - } var typeName *ast.Node = typeRef.TypeName for _, id := range getAccessStack(ref) { typeName = b.f.NewQualifiedName(typeName, id) } - return b.f.UpdateTypeReferenceNode(root.AsTypeReferenceNode(), typeName, ref.TypeArgumentList()) - } - expr := b.createAccessExpression(root) - for _, id := range getAccessStack(ref) { - expr = b.f.NewPropertyAccessExpression(expr, nil, id, ast.NodeFlagsNone) - } - return expr + result := b.f.UpdateTypeReferenceNode(root.AsTypeReferenceNode(), typeName, ref.TypeArgumentList()) + rootDisplay := b.e.DisplayNode(root) + refDisplay := b.e.DisplayNode(ref) + if rootDisplay != nil && ast.IsExpressionWithTypeArguments(rootDisplay) || + refDisplay != nil && ast.IsExpressionWithTypeArguments(refDisplay) { + display := b.appendReferenceToExpression(b.referenceToExpression(root), b.referenceToExpression(ref)) + b.e.SetDisplayNode(result, display) + } else if rootDisplay != nil || + b.ctx.flags&nodebuilder.FlagsUseInstantiationExpressions != 0 && typeRef.TypeArguments != nil && len(typeRef.TypeArguments.Nodes) != 0 { + // The display omits the inner reference's type arguments, which + // the type reference itself still has. + displayRef := b.createAccessExpression(ref.AsTypeReferenceNode().TypeName) + display := b.appendReferenceToExpression(b.referenceToExpression(root), displayRef) + b.e.SetDisplayNode(result, display) + } + return result + } + debug.FailBadSyntaxKind(root) + return nil } // referenceToExpression returns a type reference, or a reference that is // already an expression, as an expression. func (b *NodeBuilderImpl) referenceToExpression(ref *ast.Node) *ast.Expression { + if display := b.e.DisplayNode(ref); display != nil { + return b.f.DeepCloneNode(display) + } if ast.IsTypeReferenceNode(ref) { return b.createExpressionWithTypeArguments(b.createAccessExpression(ref.AsTypeReferenceNode().TypeName), ref.TypeArgumentList()) } @@ -761,17 +763,16 @@ func (b *NodeBuilderImpl) symbolToTypeNode(symbol *ast.Symbol, mask ast.SymbolFl if ast.IsIndexedAccessTypeNode(entityName) { return entityName // Indexed accesses can never be `typeof` } - if ast.IsEntityName(entityName) { - if isTypeOf { - return b.f.NewTypeQueryNode(entityName, nil) - } - return b.f.NewTypeReferenceNode(entityName, typeArguments) + debug.Assert(ast.IsEntityName(entityName)) + if isTypeOf { + return b.f.NewTypeQueryNode(entityName, typeArguments) } - if isTypeOf && ast.IsExpressionWithTypeArguments(entityName) { - expr := entityName.AsExpressionWithTypeArguments() - return b.f.NewTypeQueryNode(b.f.DeepCloneNode(expr.Expression), expr.TypeArguments) + result := b.f.NewTypeReferenceNode(entityName, typeArguments) + if b.ctx.flags&nodebuilder.FlagsUseInstantiationExpressions != 0 && ast.IsQualifiedName(entityName) && + (b.e.DisplayNode(entityName) != nil || typeArguments != nil && len(typeArguments.Nodes) != 0) { + b.e.SetDisplayNode(result, b.createExpressionWithTypeArguments(b.createAccessExpression(entityName), typeArguments)) } - return entityName + return result } func getTopmostIndexedAccessType(node *ast.IndexedAccessTypeNode) *ast.IndexedAccessTypeNode { @@ -869,10 +870,16 @@ func (b *NodeBuilderImpl) createAccessFromSymbolChain(chain []*ast.Symbol, index if index > stopper { lhs := b.createAccessFromSymbolChain(chain, index-1, stopper, overrideTypeArguments) - if b.ctx.flags&nodebuilder.FlagsUseInstantiationExpressions == 0 || ast.IsEntityName(lhs) && (typeParameterNodes == nil || len(typeParameterNodes.Nodes) == 0) { - return b.f.NewQualifiedName(lhs, identifier) + name := b.f.NewQualifiedName(lhs, identifier) + if b.ctx.flags&nodebuilder.FlagsUseInstantiationExpressions != 0 && + (b.e.DisplayNode(lhs) != nil || index < len(chain)-1 && typeParameterNodes != nil && len(typeParameterNodes.Nodes) != 0) { + expr := b.f.NewPropertyAccessExpression(b.createAccessExpression(lhs), nil, identifier, ast.NodeFlagsNone) + if index < len(chain)-1 { + expr = b.createExpressionWithTypeArguments(expr, typeParameterNodes) + } + b.e.SetDisplayNode(name, expr) } - return b.createExpressionWithTypeArguments(b.f.NewPropertyAccessExpression(b.createAccessExpression(lhs), nil, identifier, ast.NodeFlagsNone), typeParameterNodes) + return name } return identifier } @@ -1065,7 +1072,7 @@ func (b *NodeBuilderImpl) getTypeParametersOfClassOrInterface(symbol *ast.Symbol return result } -func (b *NodeBuilderImpl) lookupTypeParameterNodes(chain []*ast.Symbol, index int) *ast.TypeParameterList { +func (b *NodeBuilderImpl) lookupTypeParameterNodes(chain []*ast.Symbol, index int) *ast.TypeList { debug.Assert(chain != nil && 0 <= index && index < len(chain)) symbol := chain[index] symbolId := ast.GetSymbolId(symbol) @@ -1078,7 +1085,7 @@ func (b *NodeBuilderImpl) lookupTypeParameterNodes(chain []*ast.Symbol, index in if typeArgumentNodes := b.lookupInstantiatedTypeArgumentNodes(chain, index); typeArgumentNodes != nil { return typeArgumentNodes } else { - typeParameterNodes := b.typeParametersToTypeParameterDeclarations(symbol) + typeParameterNodes := b.typeParametersToTypeArgumentNodes(symbol) if len(typeParameterNodes) > 0 { return b.f.NewNodeList(typeParameterNodes) } @@ -1742,20 +1749,27 @@ func (b *NodeBuilderImpl) symbolToTypeParameterDeclarations(symbol *ast.Symbol) } func (b *NodeBuilderImpl) typeParametersToTypeParameterDeclarations(symbol *ast.Symbol) []*ast.Node { + if parameters := b.getTypeParametersOfSymbol(symbol); len(parameters) > 0 { + return core.Map(parameters, b.typeParameterToDeclaration) + } + return nil +} + +func (b *NodeBuilderImpl) typeParametersToTypeArgumentNodes(symbol *ast.Symbol) []*ast.TypeNode { + return core.Map(b.getTypeParametersOfSymbol(symbol), func(parameter *Type) *ast.TypeNode { + declaration := b.typeParameterToDeclaration(parameter) + reference := b.f.NewTypeReferenceNode(declaration.Name(), nil) + b.e.SetDisplayNode(reference, declaration) + return reference + }) +} + +func (b *NodeBuilderImpl) getTypeParametersOfSymbol(symbol *ast.Symbol) []*Type { targetSymbol := b.ch.getTargetSymbol(symbol) if targetSymbol.Flags()&(ast.SymbolFlagsClass|ast.SymbolFlagsInterface|ast.SymbolFlagsAlias) != 0 { - var results []*ast.Node - params := b.ch.getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) - for _, param := range params { - results = append(results, b.typeParameterToDeclaration(param)) - } - return results + return b.ch.getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) } else if targetSymbol.Flags()&ast.SymbolFlagsFunction != 0 { - var results []*ast.Node - for _, param := range b.ch.getTypeParametersFromDeclaration(symbol.ValueDeclaration()) { - results = append(results, b.typeParameterToDeclaration(param)) - } - return results + return b.ch.getTypeParametersFromDeclaration(symbol.ValueDeclaration()) } return nil } @@ -1911,6 +1925,7 @@ type SignatureToSignatureDeclarationOptions struct { func (b *NodeBuilderImpl) signatureToSignatureDeclarationHelper(signature *Signature, kind ast.Kind, options *SignatureToSignatureDeclarationOptions) *ast.Node { var typeParameters []*ast.Node + var typeArguments []*ast.Node expandedParams, cleanup := b.enterSignatureScope(signature) b.ctx.approximateLength += 3 @@ -1918,13 +1933,20 @@ func (b *NodeBuilderImpl) signatureToSignatureDeclarationHelper(signature *Signa if b.ctx.flags&nodebuilder.FlagsWriteTypeArgumentsOfSignature != 0 && signature.target != nil && signature.mapper != nil && len(signature.target.TypeParameters()) != 0 { for _, parameter := range signature.target.TypeParameters() { - typeParameters = append(typeParameters, b.typeToTypeNode(b.ch.instantiateType(parameter, signature.mapper))) - } - } else { - for _, parameter := range signature.TypeParameters() { - typeParameters = append(typeParameters, b.typeParameterToDeclaration(parameter)) + typeArguments = append(typeArguments, b.typeToTypeNode(b.ch.instantiateType(parameter, signature.mapper))) } } + displayLength, displayTruncating := b.ctx.approximateLength, b.ctx.truncating + canIncreaseExpansionDepth, expansionTruncated := b.ctx.canIncreaseExpansionDepth, b.ctx.expansionTruncated + for _, parameter := range signature.TypeParameters() { + typeParameters = append(typeParameters, b.typeParameterToDeclaration(parameter)) + } + if len(typeArguments) != 0 { + // The display arguments are printed instead of these declarations, + // so the declarations do not count toward the truncation length. + b.ctx.approximateLength, b.ctx.truncating = displayLength, displayTruncating + b.ctx.canIncreaseExpansionDepth, b.ctx.expansionTruncated = canIncreaseExpansionDepth, expansionTruncated + } restoreFlags := b.saveRestoreFlags() b.ctx.flags &^= nodebuilder.FlagsSuppressAnyReturnType @@ -2020,10 +2042,10 @@ func (b *NodeBuilderImpl) signatureToSignatureDeclarationHelper(signature *Signa panic("Unhandled kind in signatureToSignatureDeclarationHelper") } - // !!! TODO: Smuggle type arguments of signatures out for quickinfo - // if typeArguments != nil { - // node.TypeArguments = b.f.NewNodeList(typeArguments) - // } + // Instantiated arguments are display metadata, not type parameter declarations. + if len(typeArguments) != 0 { + b.e.SetDisplayTypeArguments(node, b.f.NewNodeList(typeArguments)) + } cleanup() return node @@ -3752,11 +3774,26 @@ func (b *NodeBuilderImpl) newIdentifier(text string, symbol *ast.Symbol) *ast.No return id } +// cloneIdentifier copies an identifier along with its symbol, which +// classified output uses to color the name. +func (b *NodeBuilderImpl) cloneIdentifier(node *ast.IdentifierNode) *ast.IdentifierNode { + clone := b.f.DeepCloneNode(node) + if symbol, ok := b.idToSymbol[node]; ok { + b.idToSymbol[clone] = symbol + } + return clone +} + func (b *NodeBuilderImpl) createAccessExpression(node *ast.Node) *ast.Expression { + if display := b.e.DisplayNode(node); display != nil { + return b.f.DeepCloneNode(display) + } switch { case ast.IsQualifiedName(node): - return b.f.NewPropertyAccessExpression(b.createAccessExpression(node.AsQualifiedName().Left), nil /*questionDotToken*/, b.f.DeepCloneNode(node.AsQualifiedName().Right), ast.NodeFlagsNone) - case ast.IsIdentifier(node), ast.IsPropertyAccessExpression(node), ast.IsExpressionWithTypeArguments(node): + return b.f.NewPropertyAccessExpression(b.createAccessExpression(node.AsQualifiedName().Left), nil /*questionDotToken*/, b.cloneIdentifier(node.AsQualifiedName().Right), ast.NodeFlagsNone) + case ast.IsIdentifier(node): + return b.cloneIdentifier(node) + case ast.IsPropertyAccessExpression(node), ast.IsExpressionWithTypeArguments(node): return b.f.DeepCloneNode(node) default: panic("unexpected access node kind: " + node.Kind.String()) @@ -3770,7 +3807,7 @@ func (b *NodeBuilderImpl) createExpressionWithTypeArguments(expr *ast.Expression return b.f.NewExpressionWithTypeArguments(expr, typeArguments) } -func (b *NodeBuilderImpl) lookupInstantiatedTypeArgumentNodes(chain []*ast.Symbol, index int) *ast.TypeParameterList { +func (b *NodeBuilderImpl) lookupInstantiatedTypeArgumentNodes(chain []*ast.Symbol, index int) *ast.TypeList { if b.shouldWriteTypeParametersInQualifiedName(chain, index) { symbol := chain[index] nextSymbol := chain[index+1] @@ -3797,7 +3834,7 @@ func (b *NodeBuilderImpl) lookupInstantiatedTypeArgumentNodes(chain []*ast.Symbo return nil } -func (b *NodeBuilderImpl) lookupExpressionChainTypeArgumentNodes(chain []*ast.Symbol, index int) *ast.TypeParameterList { +func (b *NodeBuilderImpl) lookupExpressionChainTypeArgumentNodes(chain []*ast.Symbol, index int) *ast.TypeList { if b.shouldWriteTypeParametersInQualifiedName(chain, index) { symbol := chain[index] symbolId := ast.GetSymbolId(symbol) @@ -3809,7 +3846,7 @@ func (b *NodeBuilderImpl) lookupExpressionChainTypeArgumentNodes(chain []*ast.Sy if typeArgumentNodes := b.lookupInstantiatedTypeArgumentNodes(chain, index); typeArgumentNodes != nil { return typeArgumentNodes } - typeParameterNodes := b.typeParametersToTypeParameterDeclarations(symbol) + typeParameterNodes := b.typeParametersToTypeArgumentNodes(symbol) if len(typeParameterNodes) > 0 { return b.f.NewNodeList(typeParameterNodes) } diff --git a/tsc/internal/checker/printer.go b/tsc/internal/checker/printer.go index b84c967883d88..bec03b954b1a1 100644 --- a/tsc/internal/checker/printer.go +++ b/tsc/internal/checker/printer.go @@ -73,7 +73,7 @@ func (c *Checker) typeToStringEx(t *Type, enclosingDeclaration *ast.Node, flags if noTruncation { combinedFlags = combinedFlags | nodebuilder.FlagsNoTruncation } - nodeBuilder, release := c.getNodeBuilder() + nodeBuilder, release := c.getNodeBuilderForTypeFormat(flags) defer release() oldVerbosity := nodeBuilder.verbosity nodeBuilder.verbosity = vc @@ -201,7 +201,7 @@ func (c *Checker) signatureToStringEx(signature *Signature, enclosingDeclaration } } - nodeBuilder, release := c.getNodeBuilder() + nodeBuilder, release := c.getNodeBuilderForTypeFormat(flags) defer release() oldVerbosity := nodeBuilder.verbosity nodeBuilder.verbosity = vc @@ -233,7 +233,7 @@ func (c *Checker) typePredicateToString(typePredicate *TypePredicate) string { func (c *Checker) typePredicateToStringEx(typePredicate *TypePredicate, enclosingDeclaration *ast.Node, flags TypeFormatFlags) string { writer, putWriter := printer.GetSingleLineStringWriter() defer putWriter() - nodeBuilder, release := c.getNodeBuilder() + nodeBuilder, release := c.getNodeBuilderForTypeFormat(flags) defer release() combinedFlags := toNodeBuilderFlags(flags) | nodebuilder.FlagsIgnoreErrors | nodebuilder.FlagsWriteTypeParametersInQualifiedName predicate := nodeBuilder.TypePredicateToTypePredicateNode(typePredicate, enclosingDeclaration, combinedFlags, nodebuilder.InternalFlagsNone, nil) // TODO: GH#18217 @@ -291,6 +291,8 @@ func (c *Checker) TypeToTypeNode(t *Type, enclosingDeclaration *ast.Node, flags } func (c *Checker) SignatureToSignatureDeclaration(signature *Signature, kind ast.Kind, enclosingDeclaration *ast.Node, flags nodebuilder.Flags) *ast.Node { + // API callers receive only valid syntax, so skip recording display arguments. + flags &^= nodebuilder.FlagsWriteTypeArgumentsOfSignature nodeBuilder, release := c.getNodeBuilder() defer release() return nodeBuilder.SignatureToSignatureDeclaration(signature, kind, enclosingDeclaration, flags, nodebuilder.InternalFlagsNone, nil) diff --git a/tsc/internal/fourslash/tests/codeFixMissingTypeAnnotationOnExports34-object-spread_test.go b/tsc/internal/fourslash/tests/codeFixMissingTypeAnnotationOnExports34-object-spread_test.go index c264dbb96c43c..d68bc39e305a3 100644 --- a/tsc/internal/fourslash/tests/codeFixMissingTypeAnnotationOnExports34-object-spread_test.go +++ b/tsc/internal/fourslash/tests/codeFixMissingTypeAnnotationOnExports34-object-spread_test.go @@ -74,3 +74,30 @@ export const All: typeof All_Part1_1 & typeof Start & typeof All_Part3 & typeof Index: 1, }) } + +func TestCodeFixMissingTypeAnnotationOnQualifiedObjectSpread(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @isolatedDeclarations: true +// @declaration: true +// @Filename: /code.ts +declare namespace N { + namespace Nested { + const values: { x: number }; + } +} +export const all = { ...N.Nested.values };` + f, done := fourslash.NewFourslash(t, nil /*capabilities*/, content) + defer done() + f.VerifyCodeFix(t, fourslash.VerifyCodeFixOptions{ + Description: "Add annotation of type 'typeof N.Nested.values'", + NewFileContent: `declare namespace N { + namespace Nested { + const values: { x: number }; + } +} +export const all: typeof N.Nested.values = { + ...N.Nested.values +};`, + }) +} diff --git a/tsc/internal/ls/codeactions_fixmissingtypeannotation.go b/tsc/internal/ls/codeactions_fixmissingtypeannotation.go index 783f2207f78aa..7318ce1830bf9 100644 --- a/tsc/internal/ls/codeactions_fixmissingtypeannotation.go +++ b/tsc/internal/ls/codeactions_fixmissingtypeannotation.go @@ -935,7 +935,7 @@ func (f *isolatedDeclarationsFixer) getExtraFlags(node *ast.Node, t *checker.Typ // createTypeOfFromEntityNameExpression creates a `typeof X` type query node. func (f *isolatedDeclarationsFixer) createTypeOfFromEntityNameExpression(node *ast.Node) *ast.TypeNode { return f.changeTracker.NodeFactory.NewTypeQueryNode( - f.changeTracker.NodeFactory.DeepCloneNode(node), nil, + printer.CreateEntityNameFromExpression(f.changeTracker.NodeFactory, node), nil, ) } diff --git a/tsc/internal/printer/emitcontext.go b/tsc/internal/printer/emitcontext.go index 7953212bd40e7..5791a04afbc5b 100644 --- a/tsc/internal/printer/emitcontext.go +++ b/tsc/internal/printer/emitcontext.go @@ -534,6 +534,7 @@ type emitNode struct { leadingComments []SynthesizedComment trailingComments []SynthesizedComment typeNode *ast.TypeNode + display *display snippetElement *SnippetElement } @@ -546,12 +547,49 @@ func (e *emitNode) copyFrom(source *emitNode) { e.tokenSourceMapRanges = maps.Clone(source.tokenSourceMapRanges) e.helpers = slices.Clone(source.helpers) e.externalHelpersModuleName = source.externalHelpersModuleName + e.display = source.display if source.snippetElement != nil { snippetElement := *source.snippetElement e.snippetElement = &snippetElement } } +// display holds notation that the printer substitutes when showing a +// synthesized node to a user. The syntax tree itself keeps canonical children, +// so declarations and API consumers never observe display-only syntax. +// Entries are replaced rather than mutated because clones share them. +type display struct { + node *ast.Node + typeArguments *ast.TypeArgumentList +} + +// DisplayNode returns the node printed in place of node, such as the +// instantiation expression f.C for a type reference or a constrained +// type parameter for a type argument. +func (c *EmitContext) DisplayNode(node *ast.Node) *ast.Node { + if emitNode := c.emitNodes.TryGet(node); emitNode != nil && emitNode.display != nil { + return emitNode.display.node + } + return nil +} + +func (c *EmitContext) SetDisplayNode(node *ast.Node, displayNode *ast.Node) { + c.emitNodes.Get(node).display = &display{node: displayNode} +} + +// DisplayTypeArguments returns the instantiated type arguments printed in +// place of a signature's type parameters. +func (c *EmitContext) DisplayTypeArguments(node *ast.Node) *ast.TypeArgumentList { + if emitNode := c.emitNodes.TryGet(node); emitNode != nil && emitNode.display != nil { + return emitNode.display.typeArguments + } + return nil +} + +func (c *EmitContext) SetDisplayTypeArguments(node *ast.Node, typeArguments *ast.TypeArgumentList) { + c.emitNodes.Get(node).display = &display{typeArguments: typeArguments} +} + func (c *EmitContext) EmitFlags(node *ast.Node) EmitFlags { if emitNode := c.emitNodes.TryGet(node); emitNode != nil { return emitNode.emitFlags diff --git a/tsc/internal/printer/factory.go b/tsc/internal/printer/factory.go index dbc9242abe400..596cad98c612f 100644 --- a/tsc/internal/printer/factory.go +++ b/tsc/internal/printer/factory.go @@ -281,6 +281,17 @@ func (f *NodeFactory) InlineExpressions(expressions []*ast.Expression) *ast.Expr // Utilities // +func CreateEntityNameFromExpression(f *ast.NodeFactory, node *ast.Expression) *ast.EntityName { + if ast.IsIdentifier(node) { + return f.DeepCloneNode(node) + } + debug.Assert(ast.IsPropertyAccessExpression(node) && ast.IsIdentifier(node.Name())) + return f.NewQualifiedName( + CreateEntityNameFromExpression(f, node.Expression()), + f.DeepCloneNode(node.Name()), + ) +} + func (f *NodeFactory) CreateExpressionFromEntityName(node *ast.Node) *ast.Expression { if ast.IsQualifiedName(node) { left := f.CreateExpressionFromEntityName(node.AsQualifiedName().Left) diff --git a/tsc/internal/printer/printer.go b/tsc/internal/printer/printer.go index a4cb6e3591cba..1f6d8324152c8 100644 --- a/tsc/internal/printer/printer.go +++ b/tsc/internal/printer/printer.go @@ -1223,16 +1223,30 @@ func (p *Printer) emitComputedPropertyName(node *ast.ComputedPropertyName) { p.exitNode(node.AsNode(), state) } +// emitDisplayNode prints the display-only substitute for a synthesized node, +// if one exists, and reports whether it did. +func (p *Printer) emitDisplayNode(node *ast.Node) bool { + display := p.emitContext.DisplayNode(node) + switch { + case display == nil: + return false + case ast.IsTypeParameterDeclaration(display): + p.emitTypeParameter(display.AsTypeParameterDeclaration()) + default: + p.emitExpression(display, ast.OperatorPrecedenceDisallowComma) + } + return true +} + func (p *Printer) emitEntityName(node *ast.EntityName) { + if p.emitDisplayNode(node) { + return + } switch node.Kind { case ast.KindIdentifier: p.emitIdentifierReference(node.AsIdentifier()) case ast.KindQualifiedName: p.emitQualifiedName(node.AsQualifiedName()) - case ast.KindPropertyAccessExpression: - // TypeQuery nodes may have PropertyAccessExpression as exprName (e.g. typeof foo.x). - // TS's emitter handles this via generic emit(); we dispatch to expression emitter here. - p.emitExpression(node, ast.OperatorPrecedenceDisallowComma) default: panic(fmt.Sprintf("unexpected EntityName: %v", node.Kind)) } @@ -1461,8 +1475,6 @@ func (p *Printer) emitTypeParameter(node *ast.TypeParameterDeclaration) { } func (p *Printer) emitTypeParameterDeclarationNode(node *ast.TypeParameterDeclarationNode) { - // NOTE: QuickInfo uses TypeFormatFlagsWriteTypeArgumentsOfSignature to instruct the NodeBuilder to store type arguments - // (i.e. type nodes) instead of type parameter declarations in the type parameter list. if ast.IsTypeParameterDeclaration(node) { p.emitTypeParameter(node.AsTypeParameterDeclaration()) } else { @@ -1521,6 +1533,14 @@ func (p *Printer) emitTypeParameters(parentNode *ast.Node, nodes *ast.TypeParame p.emitList((*Printer).emitTypeParameterDeclarationNode, parentNode, nodes, LFTypeParameters|core.IfElse(ast.IsArrowFunction(parentNode) /*p.shouldAllowTrailingComma(parentNode, nodes)*/, LFAllowTrailingComma, LFNone)) // TODO: preserve trailing comma after Strada migration } +func (p *Printer) emitSignatureTypeArgumentsOrParameters(node *ast.Node) { + if arguments := p.emitContext.DisplayTypeArguments(node); arguments != nil { + p.emitTypeArguments(node, arguments) + } else { + p.emitTypeParameters(node, node.FunctionLikeData().TypeParameters) + } +} + func (p *Printer) emitTypeAnnotation(node *ast.TypeNode) { if node == nil { return @@ -1586,12 +1606,7 @@ func (p *Printer) emitParametersForIndexSignature(parentNode *ast.Node, paramete func (p *Printer) emitSignature(node *ast.Node) { n := node.FunctionLikeData() - // !!! In old emitter, quickinfo used type arguments in place of type parameters on instantiated signatures - ////if n.TypeArguments != nil { - //// p.emitTypeArguments(node, n.TypeArguments) - ////} else { - p.emitTypeParameters(node, n.TypeParameters) - ////} + p.emitSignatureTypeArgumentsOrParameters(node) p.emitParameters(node, n.Parameters) p.emitTypeAnnotation(n.Type) @@ -1898,7 +1913,9 @@ func (p *Printer) emitTypePredicate(node *ast.TypePredicateNode) { } func (p *Printer) emitTypeArgument(node *ast.TypeNode) { - p.emitTypeNodeOutsideExtends(node) + if !p.emitDisplayNode(node) { + p.emitTypeNodeOutsideExtends(node) + } } func (p *Printer) emitTypeArguments(parentNode *ast.Node, nodes *ast.TypeArgumentList) { @@ -1910,8 +1927,10 @@ func (p *Printer) emitTypeArguments(parentNode *ast.Node, nodes *ast.TypeArgumen func (p *Printer) emitTypeReference(node *ast.TypeReferenceNode) { state := p.enterNode(node.AsNode()) - p.emitEntityName(node.TypeName) - p.emitTypeArguments(node.AsNode(), node.TypeArguments) + if !p.emitDisplayNode(node.AsNode()) { + p.emitEntityName(node.TypeName) + p.emitTypeArguments(node.AsNode(), node.TypeArguments) + } p.exitNode(node.AsNode(), state) } @@ -1939,8 +1958,7 @@ func (p *Printer) emitFunctionType(node *ast.FunctionTypeNode) { indented := p.shouldEmitIndented(node.AsNode()) p.increaseIndentIf(indented) p.pushNameGenerationScope(node.AsNode()) - // !!! in the old emitter, quickinfo uses type arguments in place of type parameters for instantiated signatures - p.emitTypeParameters(node.AsNode(), node.TypeParameters) + p.emitSignatureTypeArgumentsOrParameters(node.AsNode()) p.emitParameters(node.AsNode(), node.Parameters) p.writeSpace() p.emitReturnType(node.Type) @@ -1957,8 +1975,7 @@ func (p *Printer) emitConstructorType(node *ast.ConstructorTypeNode) { indented := p.shouldEmitIndented(node.AsNode()) p.increaseIndentIf(indented) p.pushNameGenerationScope(node.AsNode()) - // !!! in the old emitter, quickinfo uses type arguments in place of type parameters for instantiated signatures - p.emitTypeParameters(node.AsNode(), node.TypeParameters) + p.emitSignatureTypeArgumentsOrParameters(node.AsNode()) p.emitParameters(node.AsNode(), node.Parameters) p.writeSpace() p.emitReturnType(node.Type) @@ -2367,13 +2384,6 @@ func (p *Printer) emitTypeNode(node *ast.TypeNode, precedence ast.TypePrecedence case ast.KindImportType: p.emitImportTypeNode(node.AsImportTypeNode()) - case ast.KindPropertyAccessExpression: - // Occurs in pseudo-types such as `f.C`, where `f` is a generic function and `C` is a local type - p.emitPropertyAccessExpression(node.AsPropertyAccessExpression()) - case ast.KindExpressionWithTypeArguments: - // !!! Should this actually be considered a type? - p.emitExpressionWithTypeArguments(node.AsExpressionWithTypeArguments()) - case ast.KindJSDocAllType: p.emitJSDocAllType(node) case ast.KindJSDocNonNullableType: @@ -2691,7 +2701,7 @@ func (p *Printer) emitArrowFunction(node *ast.ArrowFunction) { indented := p.shouldEmitIndented(node.AsNode()) p.increaseIndentIf(indented) p.pushNameGenerationScope(node.AsNode()) - p.emitTypeParameters(node.AsNode(), node.TypeParameters) + p.emitSignatureTypeArgumentsOrParameters(node.AsNode()) p.emitParametersForArrow(node.AsNode(), node.Parameters) p.emitTypeAnnotation(node.Type) p.writeSpace() From f3725178f8c3e56b6f2611bd579eaac59ec67adc Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sat, 14 Nov 2026 08:10:10 -0800 Subject: [PATCH 2/9] Keep symbols on copied hover display names Classified hover colors each name by looking up the symbol recorded for its identifier. Display notation such as foo.X.m.(Anonymous function).Y is assembled from copies of earlier display expressions, and those copies had no recorded symbols, so most of the names printed as plain text. Copy the symbols along with every identifier in a copied display expression. --- tsc/internal/checker/nodebuilderimpl.go | 37 +++++++++++++++++-------- 1 file changed, 25 insertions(+), 12 deletions(-) diff --git a/tsc/internal/checker/nodebuilderimpl.go b/tsc/internal/checker/nodebuilderimpl.go index 4e502a2dbfc37..0be1b012a30bf 100644 --- a/tsc/internal/checker/nodebuilderimpl.go +++ b/tsc/internal/checker/nodebuilderimpl.go @@ -333,7 +333,7 @@ func (b *NodeBuilderImpl) appendReferenceToType(root *ast.TypeNode, ref *ast.Typ // already an expression, as an expression. func (b *NodeBuilderImpl) referenceToExpression(ref *ast.Node) *ast.Expression { if display := b.e.DisplayNode(ref); display != nil { - return b.f.DeepCloneNode(display) + return b.cloneWithSymbols(display) } if ast.IsTypeReferenceNode(ref) { return b.createExpressionWithTypeArguments(b.createAccessExpression(ref.AsTypeReferenceNode().TypeName), ref.TypeArgumentList()) @@ -3774,27 +3774,40 @@ func (b *NodeBuilderImpl) newIdentifier(text string, symbol *ast.Symbol) *ast.No return id } -// cloneIdentifier copies an identifier along with its symbol, which -// classified output uses to color the name. -func (b *NodeBuilderImpl) cloneIdentifier(node *ast.IdentifierNode) *ast.IdentifierNode { +// cloneWithSymbols deep-clones node and gives each cloned identifier the +// symbol of its original, which classified output uses to color names. +func (b *NodeBuilderImpl) cloneWithSymbols(node *ast.Node) *ast.Node { clone := b.f.DeepCloneNode(node) - if symbol, ok := b.idToSymbol[node]; ok { + b.copyIdentifierSymbols(node, clone) + return clone +} + +func (b *NodeBuilderImpl) copyIdentifierSymbols(original *ast.Node, clone *ast.Node) { + if symbol, ok := b.idToSymbol[original]; ok { b.idToSymbol[clone] = symbol } - return clone + var originals []*ast.Node + original.ForEachChild(func(child *ast.Node) bool { + originals = append(originals, child) + return false + }) + i := 0 + clone.ForEachChild(func(child *ast.Node) bool { + b.copyIdentifierSymbols(originals[i], child) + i++ + return false + }) } func (b *NodeBuilderImpl) createAccessExpression(node *ast.Node) *ast.Expression { if display := b.e.DisplayNode(node); display != nil { - return b.f.DeepCloneNode(display) + return b.cloneWithSymbols(display) } switch { case ast.IsQualifiedName(node): - return b.f.NewPropertyAccessExpression(b.createAccessExpression(node.AsQualifiedName().Left), nil /*questionDotToken*/, b.cloneIdentifier(node.AsQualifiedName().Right), ast.NodeFlagsNone) - case ast.IsIdentifier(node): - return b.cloneIdentifier(node) - case ast.IsPropertyAccessExpression(node), ast.IsExpressionWithTypeArguments(node): - return b.f.DeepCloneNode(node) + return b.f.NewPropertyAccessExpression(b.createAccessExpression(node.AsQualifiedName().Left), nil /*questionDotToken*/, b.cloneWithSymbols(node.AsQualifiedName().Right), ast.NodeFlagsNone) + case ast.IsIdentifier(node), ast.IsPropertyAccessExpression(node), ast.IsExpressionWithTypeArguments(node): + return b.cloneWithSymbols(node) default: panic("unexpected access node kind: " + node.Kind.String()) } From 31b928a759bc6e707e0446d2ea040734377a0c7a Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sat, 14 Nov 2026 08:28:14 -0800 Subject: [PATCH 3/9] Clarify hover display comments --- packages/typescript/test/async/api.test.ts | 2 +- packages/typescript/test/sync/api.test.ts | 2 +- tsc/internal/checker/checker_test.go | 2 +- tsc/internal/checker/nodebuilderimpl.go | 6 +++--- tsc/internal/checker/printer.go | 2 +- 5 files changed, 7 insertions(+), 7 deletions(-) diff --git a/packages/typescript/test/async/api.test.ts b/packages/typescript/test/async/api.test.ts index 728ca258f96e7..1acd160281a5c 100644 --- a/packages/typescript/test/async/api.test.ts +++ b/packages/typescript/test/async/api.test.ts @@ -9020,7 +9020,7 @@ const method = new N().method;`; // f.C is only meaningful as display text. assertTypeSyntax(await checker.typeToTypeNode(await typeOf("local"), undefined, NodeBuilderFlags.UseInstantiationExpressions)); - // An instantiated signature still declares its remaining type parameters. + // An instantiated signature declares its remaining type parameters. const [signature] = await (await typeOf("method")).getCallSignatures(); const declaration = await checker.signatureToSignatureDeclaration(signature, SyntaxKind.FunctionType, undefined, NodeBuilderFlags.WriteTypeArgumentsOfSignature); assert.ok(declaration && isFunctionTypeNode(declaration)); diff --git a/packages/typescript/test/sync/api.test.ts b/packages/typescript/test/sync/api.test.ts index 39c6c0dbacf08..1a8ec9d693308 100644 --- a/packages/typescript/test/sync/api.test.ts +++ b/packages/typescript/test/sync/api.test.ts @@ -8778,7 +8778,7 @@ const method = new N().method;`; // f.C is only meaningful as display text. assertTypeSyntax(checker.typeToTypeNode(typeOf("local"), undefined, NodeBuilderFlags.UseInstantiationExpressions)); - // An instantiated signature still declares its remaining type parameters. + // An instantiated signature declares its remaining type parameters. const [signature] = (typeOf("method")).getCallSignatures(); const declaration = checker.signatureToSignatureDeclaration(signature, SyntaxKind.FunctionType, undefined, NodeBuilderFlags.WriteTypeArgumentsOfSignature); assert.ok(declaration && isFunctionTypeNode(declaration)); diff --git a/tsc/internal/checker/checker_test.go b/tsc/internal/checker/checker_test.go index 82ec3576c4f92..b301a98a7abad 100644 --- a/tsc/internal/checker/checker_test.go +++ b/tsc/internal/checker/checker_test.go @@ -84,7 +84,7 @@ func TestQualifiedNameTypeParametersAreDisplayOnly(t *testing.T) { builder := checker.NewNodeBuilderEx(c, emitContext, nil) expression := builder.SymbolToExpression(c.GetSymbolAtLocation(access), ast.SymbolFlagsValue, access, nodebuilder.FlagsWriteTypeParametersInQualifiedName, nodebuilder.InternalFlagsNone, nil) - // The declaration's modifiers, constraint and default are display text, not a type argument. + // The type argument references T; its modifiers, constraint and default appear only in the printed text. argument := expression.Expression().AsExpressionWithTypeArguments().TypeArguments.Nodes[0] assert.Assert(t, ast.IsTypeNode(argument), argument.Kind) text := printer.NewPrinter(printer.PrinterOptions{}, printer.PrintHandlers{}, emitContext).Emit(expression, file) diff --git a/tsc/internal/checker/nodebuilderimpl.go b/tsc/internal/checker/nodebuilderimpl.go index 0be1b012a30bf..834569fc2db52 100644 --- a/tsc/internal/checker/nodebuilderimpl.go +++ b/tsc/internal/checker/nodebuilderimpl.go @@ -317,8 +317,8 @@ func (b *NodeBuilderImpl) appendReferenceToType(root *ast.TypeNode, ref *ast.Typ b.e.SetDisplayNode(result, display) } else if rootDisplay != nil || b.ctx.flags&nodebuilder.FlagsUseInstantiationExpressions != 0 && typeRef.TypeArguments != nil && len(typeRef.TypeArguments.Nodes) != 0 { - // The display omits the inner reference's type arguments, which - // the type reference itself still has. + // The display omits the inner reference's type arguments; the + // type reference keeps them. displayRef := b.createAccessExpression(ref.AsTypeReferenceNode().TypeName) display := b.appendReferenceToExpression(b.referenceToExpression(root), displayRef) b.e.SetDisplayNode(result, display) @@ -2042,7 +2042,7 @@ func (b *NodeBuilderImpl) signatureToSignatureDeclarationHelper(signature *Signa panic("Unhandled kind in signatureToSignatureDeclarationHelper") } - // Instantiated arguments are display metadata, not type parameter declarations. + // The printer shows the instantiated arguments in place of the type parameters. if len(typeArguments) != 0 { b.e.SetDisplayTypeArguments(node, b.f.NewNodeList(typeArguments)) } diff --git a/tsc/internal/checker/printer.go b/tsc/internal/checker/printer.go index bec03b954b1a1..af0f61246a4ac 100644 --- a/tsc/internal/checker/printer.go +++ b/tsc/internal/checker/printer.go @@ -291,7 +291,7 @@ func (c *Checker) TypeToTypeNode(t *Type, enclosingDeclaration *ast.Node, flags } func (c *Checker) SignatureToSignatureDeclaration(signature *Signature, kind ast.Kind, enclosingDeclaration *ast.Node, flags nodebuilder.Flags) *ast.Node { - // API callers receive only valid syntax, so skip recording display arguments. + // Only hover prints display arguments, so API callers do not need them. flags &^= nodebuilder.FlagsWriteTypeArgumentsOfSignature nodeBuilder, release := c.getNodeBuilder() defer release() From 5d6ca4ddb2b7ba722735040f7dba60b56330c493 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sat, 14 Nov 2026 08:34:20 -0800 Subject: [PATCH 4/9] Test hover display through quick info Constrained and defaulted outer type parameters, as in D.prototype, appear only in hover text, so check that text directly. The removed API and checker tests checked internal tree structure, and the hover baselines already cover it. --- packages/typescript/test/async/api.test.ts | 35 ------------------- packages/typescript/test/sync/api.test.ts | 35 ------------------- tsc/internal/checker/checker_test.go | 28 --------------- tsc/internal/checker/nodebuilder.go | 6 ++-- tsc/internal/checker/nodebuilderimpl.go | 4 +-- ...quickInfoForGenericPrototypeMember_test.go | 5 ++- tsc/internal/printer/emitcontext.go | 8 ++--- 7 files changed, 13 insertions(+), 108 deletions(-) diff --git a/packages/typescript/test/async/api.test.ts b/packages/typescript/test/async/api.test.ts index 1acd160281a5c..a4b82446f1fd4 100644 --- a/packages/typescript/test/async/api.test.ts +++ b/packages/typescript/test/async/api.test.ts @@ -13,7 +13,6 @@ import { isClassDeclaration, isExpressionStatement, isFunctionDeclaration, - isFunctionTypeNode, isIdentifier, isImportDeclaration, isInterfaceDeclaration, @@ -50,7 +49,6 @@ import { import { cloneNode, createArrayTypeNode, - createExpressionWithTypeArguments, createFunctionTypeNode, createIdentifier, createKeywordTypeNode, @@ -95,7 +93,6 @@ import { ModuleKind, ModuleResolutionKind, type ModuleResolver, - NodeBuilderFlags, type NumberLiteralType, ObjectFlags, type Program, @@ -8994,38 +8991,6 @@ export const obj = { m: 1, s: "hi", b: true }; for (const kind of kinds) { assert.ok(isTypeNode({ kind } as any), `isTypeNode should accept ${SyntaxKind[kind]}`); } - assert.ok(!isTypeNode(createExpressionWithTypeArguments(createIdentifier("f"), [createKeywordTypeNode(SyntaxKind.StringKeyword)]))); - }); - - test("node builder results keep hover-only notation out of the syntax tree", async () => { - const source = `function f(x: T) { - class C { value = x; other!: U; } - return new C(); -} -const local = f("hello"); -class N { method(value: U): U { return value; } } -const method = new N().method;`; - await using api = spawnAPI({ "/tsconfig.json": "{}", "/main.ts": source }); - const snapshot = await api.createSnapshot({ openProjects: ["/tsconfig.json"] }); - const { checker } = snapshot.getConfiguredProject("/tsconfig.json")!; - const typeOf = async (name: string) => checker.getTypeOfSymbol((await checker.getSymbolAtPosition("/main.ts", source.indexOf(`const ${name}`) + 6))!); - const assertTypeSyntax = (node: Node | undefined) => { - assert.ok(node); - (function visit(child: Node): Node { - assert.ok(child.kind !== SyntaxKind.ExpressionWithTypeArguments && child.kind !== SyntaxKind.PropertyAccessExpression, SyntaxKind[child.kind]); - return visitEachChild(child, visit); - })(node); - }; - - // f.C is only meaningful as display text. - assertTypeSyntax(await checker.typeToTypeNode(await typeOf("local"), undefined, NodeBuilderFlags.UseInstantiationExpressions)); - - // An instantiated signature declares its remaining type parameters. - const [signature] = await (await typeOf("method")).getCallSignatures(); - const declaration = await checker.signatureToSignatureDeclaration(signature, SyntaxKind.FunctionType, undefined, NodeBuilderFlags.WriteTypeArgumentsOfSignature); - assert.ok(declaration && isFunctionTypeNode(declaration)); - assert.strictEqual(declaration.typeParameters?.[0].kind, SyntaxKind.TypeParameter); - assert.strictEqual(declaration.typeParameters[0].constraint?.kind, SyntaxKind.StringKeyword); }); test("typeToString", async () => { diff --git a/packages/typescript/test/sync/api.test.ts b/packages/typescript/test/sync/api.test.ts index 1a8ec9d693308..3b5b5306c2f24 100644 --- a/packages/typescript/test/sync/api.test.ts +++ b/packages/typescript/test/sync/api.test.ts @@ -21,7 +21,6 @@ import { isClassDeclaration, isExpressionStatement, isFunctionDeclaration, - isFunctionTypeNode, isIdentifier, isImportDeclaration, isInterfaceDeclaration, @@ -58,7 +57,6 @@ import { import { cloneNode, createArrayTypeNode, - createExpressionWithTypeArguments, createFunctionTypeNode, createIdentifier, createKeywordTypeNode, @@ -117,7 +115,6 @@ import { ModuleKind, ModuleResolutionKind, type ModuleResolver, - NodeBuilderFlags, type NumberLiteralType, ObjectFlags, type Program, @@ -8752,38 +8749,6 @@ export const obj = { m: 1, s: "hi", b: true }; for (const kind of kinds) { assert.ok(isTypeNode({ kind } as any), `isTypeNode should accept ${SyntaxKind[kind]}`); } - assert.ok(!isTypeNode(createExpressionWithTypeArguments(createIdentifier("f"), [createKeywordTypeNode(SyntaxKind.StringKeyword)]))); - }); - - test("node builder results keep hover-only notation out of the syntax tree", () => { - const source = `function f(x: T) { - class C { value = x; other!: U; } - return new C(); -} -const local = f("hello"); -class N { method(value: U): U { return value; } } -const method = new N().method;`; - using api = spawnAPI({ "/tsconfig.json": "{}", "/main.ts": source }); - const snapshot = api.createSnapshot({ openProjects: ["/tsconfig.json"] }); - const { checker } = snapshot.getConfiguredProject("/tsconfig.json")!; - const typeOf = (name: string) => checker.getTypeOfSymbol((checker.getSymbolAtPosition("/main.ts", source.indexOf(`const ${name}`) + 6))!); - const assertTypeSyntax = (node: Node | undefined) => { - assert.ok(node); - (function visit(child: Node): Node { - assert.ok(child.kind !== SyntaxKind.ExpressionWithTypeArguments && child.kind !== SyntaxKind.PropertyAccessExpression, SyntaxKind[child.kind]); - return visitEachChild(child, visit); - })(node); - }; - - // f.C is only meaningful as display text. - assertTypeSyntax(checker.typeToTypeNode(typeOf("local"), undefined, NodeBuilderFlags.UseInstantiationExpressions)); - - // An instantiated signature declares its remaining type parameters. - const [signature] = (typeOf("method")).getCallSignatures(); - const declaration = checker.signatureToSignatureDeclaration(signature, SyntaxKind.FunctionType, undefined, NodeBuilderFlags.WriteTypeArgumentsOfSignature); - assert.ok(declaration && isFunctionTypeNode(declaration)); - assert.strictEqual(declaration.typeParameters?.[0].kind, SyntaxKind.TypeParameter); - assert.strictEqual(declaration.typeParameters[0].constraint?.kind, SyntaxKind.StringKeyword); }); test("typeToString", () => { diff --git a/tsc/internal/checker/checker_test.go b/tsc/internal/checker/checker_test.go index b301a98a7abad..f5b766607c5f7 100644 --- a/tsc/internal/checker/checker_test.go +++ b/tsc/internal/checker/checker_test.go @@ -11,8 +11,6 @@ import ( "github.com/microsoft/TypeScript/tsc/internal/checker" "github.com/microsoft/TypeScript/tsc/internal/compiler" "github.com/microsoft/TypeScript/tsc/internal/core" - "github.com/microsoft/TypeScript/tsc/internal/nodebuilder" - "github.com/microsoft/TypeScript/tsc/internal/printer" "github.com/microsoft/TypeScript/tsc/internal/repo" "github.com/microsoft/TypeScript/tsc/internal/tsoptions" "github.com/microsoft/TypeScript/tsc/internal/tspath" @@ -65,32 +63,6 @@ foo.bar;` } } -func TestQualifiedNameTypeParametersAreDisplayOnly(t *testing.T) { - t.Parallel() - fs := bundled.WrapFS(vfstest.FromMap(map[string]string{ - "/main.ts": `class C {} C.prototype;`, - }, tspath.CaseSensitive)) - p, err := compiler.NewProgram(t.Context(), compiler.ProgramOptions{ - Config: tsoptions.NewParsedCommandLine(&core.CompilerOptions{}, []tspath.RootedFilePath{"/main.ts"}, nil, "/", fs.CaseSensitivity()), - Host: compiler.NewCompilerHost(fs, bundled.LibPath(), nil, nil, nil), - }) - assert.NilError(t, err) - p.BindSourceFiles() - c, done := p.GetTypeChecker(t.Context()) - defer done() - file := p.GetSourceFile("/main.ts") - access := file.Statements.Nodes[1].Expression() - emitContext := printer.NewEmitContext() - builder := checker.NewNodeBuilderEx(c, emitContext, nil) - expression := builder.SymbolToExpression(c.GetSymbolAtLocation(access), ast.SymbolFlagsValue, access, nodebuilder.FlagsWriteTypeParametersInQualifiedName, nodebuilder.InternalFlagsNone, nil) - - // The type argument references T; its modifiers, constraint and default appear only in the printed text. - argument := expression.Expression().AsExpressionWithTypeArguments().TypeArguments.Nodes[0] - assert.Assert(t, ast.IsTypeNode(argument), argument.Kind) - text := printer.NewPrinter(printer.PrinterOptions{}, printer.PrintHandlers{}, emitContext).Emit(expression, file) - assert.Equal(t, text, `C.prototype`) -} - func TestGetTypeAtLocationOfTypeOnlyImportClause(t *testing.T) { t.Parallel() diff --git a/tsc/internal/checker/nodebuilder.go b/tsc/internal/checker/nodebuilder.go index 793d39daea1b9..9abe43818ba3b 100644 --- a/tsc/internal/checker/nodebuilder.go +++ b/tsc/internal/checker/nodebuilder.go @@ -296,9 +296,9 @@ func (c *Checker) getNodeBuilder() (*NodeBuilder, func()) { return c.typeToStringNodebuilder, releaseNodes } -// getNodeBuilderForTypeFormat uses a builder local to the operation for -// hover-only display formatting, so the display metadata it records is not -// retained by the cached builder. +// getNodeBuilderForTypeFormat gives hover-only display formatting a builder +// local to the operation, so the cached builder does not retain its display +// metadata. func (c *Checker) getNodeBuilderForTypeFormat(flags TypeFormatFlags) (*NodeBuilder, func()) { if flags&(TypeFormatFlagsWriteTypeArgumentsOfSignature|TypeFormatFlagsUseInstantiationExpressions) == 0 { return c.getNodeBuilder() diff --git a/tsc/internal/checker/nodebuilderimpl.go b/tsc/internal/checker/nodebuilderimpl.go index 834569fc2db52..e61ac181ddbdc 100644 --- a/tsc/internal/checker/nodebuilderimpl.go +++ b/tsc/internal/checker/nodebuilderimpl.go @@ -3774,8 +3774,8 @@ func (b *NodeBuilderImpl) newIdentifier(text string, symbol *ast.Symbol) *ast.No return id } -// cloneWithSymbols deep-clones node and gives each cloned identifier the -// symbol of its original, which classified output uses to color names. +// cloneWithSymbols deep-clones node and copies each identifier's symbol to its +// clone. Classified output colors names by symbol. func (b *NodeBuilderImpl) cloneWithSymbols(node *ast.Node) *ast.Node { clone := b.f.DeepCloneNode(node) b.copyIdentifierSymbols(node, clone) diff --git a/tsc/internal/fourslash/tests/quickInfoForGenericPrototypeMember_test.go b/tsc/internal/fourslash/tests/quickInfoForGenericPrototypeMember_test.go index 12425114ea53b..80425c02a5f58 100644 --- a/tsc/internal/fourslash/tests/quickInfoForGenericPrototypeMember_test.go +++ b/tsc/internal/fourslash/tests/quickInfoForGenericPrototypeMember_test.go @@ -14,9 +14,12 @@ func TestQuickInfoForGenericPrototypeMember(t *testing.T) { foo(x: T) { } } var x = new /*1*/C(); -var y = C.proto/*2*/type;` +var y = C.proto/*2*/type; +class D {} +D.proto/*3*/type;` f, done := fourslash.NewFourslash(t, nil /*capabilities*/, content) defer done() f.VerifyQuickInfoAt(t, "1", "constructor C(): C", "") f.VerifyQuickInfoAt(t, "2", "(property) C.prototype: C", "") + f.VerifyQuickInfoAt(t, "3", `(property) D.prototype: D`, "") } diff --git a/tsc/internal/printer/emitcontext.go b/tsc/internal/printer/emitcontext.go index 5791a04afbc5b..0ee4815243c5d 100644 --- a/tsc/internal/printer/emitcontext.go +++ b/tsc/internal/printer/emitcontext.go @@ -554,10 +554,10 @@ func (e *emitNode) copyFrom(source *emitNode) { } } -// display holds notation that the printer substitutes when showing a -// synthesized node to a user. The syntax tree itself keeps canonical children, -// so declarations and API consumers never observe display-only syntax. -// Entries are replaced rather than mutated because clones share them. +// display records how the printer shows a synthesized node to a user. The +// syntax tree keeps canonical children, so declarations and API consumers +// never see display-only syntax. Clones share entries, so each setter stores +// a new entry. type display struct { node *ast.Node typeArguments *ast.TypeArgumentList From a72a1686e901fc02c5237db62d50fdb23056b762 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sat, 14 Nov 2026 09:07:25 -0800 Subject: [PATCH 5/9] Simplify hover display construction Display expressions are synthesized and only printed, so they can share nodes with each other and with the type tree. Sharing keeps each identifier's recorded symbol for classified hover without copying. Instantiated signatures used for display print their arguments in place of the type parameters, so build the arguments alone for them. Hover is the only consumer; the checker's public entry points clear the hover-only flags. The printer prints a display type parameter through its type reference, so type argument lists need no separate hook. --- tsc/internal/checker/nodebuilderimpl.go | 73 ++++++------------------- tsc/internal/checker/printer.go | 10 +++- tsc/internal/printer/printer.go | 14 ++--- 3 files changed, 28 insertions(+), 69 deletions(-) diff --git a/tsc/internal/checker/nodebuilderimpl.go b/tsc/internal/checker/nodebuilderimpl.go index e61ac181ddbdc..ff7eee0070ae8 100644 --- a/tsc/internal/checker/nodebuilderimpl.go +++ b/tsc/internal/checker/nodebuilderimpl.go @@ -313,14 +313,14 @@ func (b *NodeBuilderImpl) appendReferenceToType(root *ast.TypeNode, ref *ast.Typ refDisplay := b.e.DisplayNode(ref) if rootDisplay != nil && ast.IsExpressionWithTypeArguments(rootDisplay) || refDisplay != nil && ast.IsExpressionWithTypeArguments(refDisplay) { - display := b.appendReferenceToExpression(b.referenceToExpression(root), b.referenceToExpression(ref)) + display := b.appendReferenceToExpression(b.referenceToExpression(typeRef), b.referenceToExpression(ref.AsTypeReferenceNode())) b.e.SetDisplayNode(result, display) } else if rootDisplay != nil || b.ctx.flags&nodebuilder.FlagsUseInstantiationExpressions != 0 && typeRef.TypeArguments != nil && len(typeRef.TypeArguments.Nodes) != 0 { // The display omits the inner reference's type arguments; the // type reference keeps them. displayRef := b.createAccessExpression(ref.AsTypeReferenceNode().TypeName) - display := b.appendReferenceToExpression(b.referenceToExpression(root), displayRef) + display := b.appendReferenceToExpression(b.referenceToExpression(typeRef), displayRef) b.e.SetDisplayNode(result, display) } return result @@ -329,16 +329,12 @@ func (b *NodeBuilderImpl) appendReferenceToType(root *ast.TypeNode, ref *ast.Typ return nil } -// referenceToExpression returns a type reference, or a reference that is -// already an expression, as an expression. -func (b *NodeBuilderImpl) referenceToExpression(ref *ast.Node) *ast.Expression { - if display := b.e.DisplayNode(ref); display != nil { - return b.cloneWithSymbols(display) +// referenceToExpression returns a type reference as an expression. +func (b *NodeBuilderImpl) referenceToExpression(ref *ast.TypeReferenceNode) *ast.Expression { + if display := b.e.DisplayNode(ref.AsNode()); display != nil { + return display } - if ast.IsTypeReferenceNode(ref) { - return b.createExpressionWithTypeArguments(b.createAccessExpression(ref.AsTypeReferenceNode().TypeName), ref.TypeArgumentList()) - } - return b.createAccessExpression(ref) + return b.createExpressionWithTypeArguments(b.createAccessExpression(ref.TypeName), ref.TypeArguments) } // appendReferenceToExpression returns ref, a reference expression, as a @@ -1935,17 +1931,10 @@ func (b *NodeBuilderImpl) signatureToSignatureDeclarationHelper(signature *Signa for _, parameter := range signature.target.TypeParameters() { typeArguments = append(typeArguments, b.typeToTypeNode(b.ch.instantiateType(parameter, signature.mapper))) } - } - displayLength, displayTruncating := b.ctx.approximateLength, b.ctx.truncating - canIncreaseExpansionDepth, expansionTruncated := b.ctx.canIncreaseExpansionDepth, b.ctx.expansionTruncated - for _, parameter := range signature.TypeParameters() { - typeParameters = append(typeParameters, b.typeParameterToDeclaration(parameter)) - } - if len(typeArguments) != 0 { - // The display arguments are printed instead of these declarations, - // so the declarations do not count toward the truncation length. - b.ctx.approximateLength, b.ctx.truncating = displayLength, displayTruncating - b.ctx.canIncreaseExpansionDepth, b.ctx.expansionTruncated = canIncreaseExpansionDepth, expansionTruncated + } else { + for _, parameter := range signature.TypeParameters() { + typeParameters = append(typeParameters, b.typeParameterToDeclaration(parameter)) + } } restoreFlags := b.saveRestoreFlags() @@ -3774,43 +3763,15 @@ func (b *NodeBuilderImpl) newIdentifier(text string, symbol *ast.Symbol) *ast.No return id } -// cloneWithSymbols deep-clones node and copies each identifier's symbol to its -// clone. Classified output colors names by symbol. -func (b *NodeBuilderImpl) cloneWithSymbols(node *ast.Node) *ast.Node { - clone := b.f.DeepCloneNode(node) - b.copyIdentifierSymbols(node, clone) - return clone -} - -func (b *NodeBuilderImpl) copyIdentifierSymbols(original *ast.Node, clone *ast.Node) { - if symbol, ok := b.idToSymbol[original]; ok { - b.idToSymbol[clone] = symbol - } - var originals []*ast.Node - original.ForEachChild(func(child *ast.Node) bool { - originals = append(originals, child) - return false - }) - i := 0 - clone.ForEachChild(func(child *ast.Node) bool { - b.copyIdentifierSymbols(originals[i], child) - i++ - return false - }) -} - -func (b *NodeBuilderImpl) createAccessExpression(node *ast.Node) *ast.Expression { +func (b *NodeBuilderImpl) createAccessExpression(node *ast.EntityName) *ast.Expression { if display := b.e.DisplayNode(node); display != nil { - return b.cloneWithSymbols(display) + return display } - switch { - case ast.IsQualifiedName(node): - return b.f.NewPropertyAccessExpression(b.createAccessExpression(node.AsQualifiedName().Left), nil /*questionDotToken*/, b.cloneWithSymbols(node.AsQualifiedName().Right), ast.NodeFlagsNone) - case ast.IsIdentifier(node), ast.IsPropertyAccessExpression(node), ast.IsExpressionWithTypeArguments(node): - return b.cloneWithSymbols(node) - default: - panic("unexpected access node kind: " + node.Kind.String()) + if ast.IsQualifiedName(node) { + return b.f.NewPropertyAccessExpression(b.createAccessExpression(node.AsQualifiedName().Left), nil /*questionDotToken*/, node.AsQualifiedName().Right, ast.NodeFlagsNone) } + debug.Assert(ast.IsIdentifier(node)) + return node } func (b *NodeBuilderImpl) createExpressionWithTypeArguments(expr *ast.Expression, typeArguments *ast.NodeList) *ast.Expression { diff --git a/tsc/internal/checker/printer.go b/tsc/internal/checker/printer.go index af0f61246a4ac..ae1a27d3d77bb 100644 --- a/tsc/internal/checker/printer.go +++ b/tsc/internal/checker/printer.go @@ -233,7 +233,7 @@ func (c *Checker) typePredicateToString(typePredicate *TypePredicate) string { func (c *Checker) typePredicateToStringEx(typePredicate *TypePredicate, enclosingDeclaration *ast.Node, flags TypeFormatFlags) string { writer, putWriter := printer.GetSingleLineStringWriter() defer putWriter() - nodeBuilder, release := c.getNodeBuilderForTypeFormat(flags) + nodeBuilder, release := c.getNodeBuilder() defer release() combinedFlags := toNodeBuilderFlags(flags) | nodebuilder.FlagsIgnoreErrors | nodebuilder.FlagsWriteTypeParametersInQualifiedName predicate := nodeBuilder.TypePredicateToTypePredicateNode(typePredicate, enclosingDeclaration, combinedFlags, nodebuilder.InternalFlagsNone, nil) // TODO: GH#18217 @@ -285,14 +285,18 @@ func (c *Checker) formatUnionTypes(types []*Type, expandingEnum bool) []*Type { return result } +// hoverOnlyNodeBuilderFlags only affect printed hover text, which API callers +// do not receive. +const hoverOnlyNodeBuilderFlags = nodebuilder.FlagsWriteTypeArgumentsOfSignature | nodebuilder.FlagsUseInstantiationExpressions + func (c *Checker) TypeToTypeNode(t *Type, enclosingDeclaration *ast.Node, flags nodebuilder.Flags, idToSymbol map[*ast.IdentifierNode]*ast.Symbol) *ast.TypeNode { + flags &^= hoverOnlyNodeBuilderFlags nodeBuilder := c.getNodeBuilderEx(idToSymbol) return nodeBuilder.TypeToTypeNode(t, enclosingDeclaration, flags, nodebuilder.InternalFlagsNone, nil) } func (c *Checker) SignatureToSignatureDeclaration(signature *Signature, kind ast.Kind, enclosingDeclaration *ast.Node, flags nodebuilder.Flags) *ast.Node { - // Only hover prints display arguments, so API callers do not need them. - flags &^= nodebuilder.FlagsWriteTypeArgumentsOfSignature + flags &^= hoverOnlyNodeBuilderFlags nodeBuilder, release := c.getNodeBuilder() defer release() return nodeBuilder.SignatureToSignatureDeclaration(signature, kind, enclosingDeclaration, flags, nodebuilder.InternalFlagsNone, nil) diff --git a/tsc/internal/printer/printer.go b/tsc/internal/printer/printer.go index 1f6d8324152c8..85f7eb36a05a7 100644 --- a/tsc/internal/printer/printer.go +++ b/tsc/internal/printer/printer.go @@ -1475,11 +1475,7 @@ func (p *Printer) emitTypeParameter(node *ast.TypeParameterDeclaration) { } func (p *Printer) emitTypeParameterDeclarationNode(node *ast.TypeParameterDeclarationNode) { - if ast.IsTypeParameterDeclaration(node) { - p.emitTypeParameter(node.AsTypeParameterDeclaration()) - } else { - p.emitTypeArgument(node) - } + p.emitTypeParameter(node.AsTypeParameterDeclaration()) } func (p *Printer) emitParameterName(node *ast.BindingName) { @@ -1913,16 +1909,14 @@ func (p *Printer) emitTypePredicate(node *ast.TypePredicateNode) { } func (p *Printer) emitTypeArgument(node *ast.TypeNode) { - if !p.emitDisplayNode(node) { - p.emitTypeNodeOutsideExtends(node) - } + p.emitTypeNodeOutsideExtends(node) } func (p *Printer) emitTypeArguments(parentNode *ast.Node, nodes *ast.TypeArgumentList) { if nodes == nil { return } - p.emitList((*Printer).emitTypeParameterDeclarationNode, parentNode, nodes, LFTypeArguments /*|core.IfElse(p.shouldAllowTrailingComma(parentNode, nodes), LFAllowTrailingComma, LFNone)*/) // TODO: preserve trailing comma after Strada migration + p.emitList((*Printer).emitTypeArgument, parentNode, nodes, LFTypeArguments /*|core.IfElse(p.shouldAllowTrailingComma(parentNode, nodes), LFAllowTrailingComma, LFNone)*/) // TODO: preserve trailing comma after Strada migration } func (p *Printer) emitTypeReference(node *ast.TypeReferenceNode) { @@ -2701,7 +2695,7 @@ func (p *Printer) emitArrowFunction(node *ast.ArrowFunction) { indented := p.shouldEmitIndented(node.AsNode()) p.increaseIndentIf(indented) p.pushNameGenerationScope(node.AsNode()) - p.emitSignatureTypeArgumentsOrParameters(node.AsNode()) + p.emitTypeParameters(node.AsNode(), node.TypeParameters) p.emitParametersForArrow(node.AsNode(), node.Parameters) p.emitTypeAnnotation(node.Type) p.writeSpace() From 97d4e73b1836c3a6d6ccfb87b72f729123fd754e Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sat, 14 Nov 2026 09:13:34 -0800 Subject: [PATCH 6/9] Remove code made redundant by valid type syntax isTypeNode rejects instantiation expressions, so inlay hints no longer need to exclude them separately. symbolToTypeParameterDeclarations is the only caller of its helper, so it takes the helper's body. --- tsc/internal/checker/nodebuilderimpl.go | 4 ---- tsc/internal/ls/inlay_hints.go | 2 +- 2 files changed, 1 insertion(+), 5 deletions(-) diff --git a/tsc/internal/checker/nodebuilderimpl.go b/tsc/internal/checker/nodebuilderimpl.go index ff7eee0070ae8..7e14b4ddaee3c 100644 --- a/tsc/internal/checker/nodebuilderimpl.go +++ b/tsc/internal/checker/nodebuilderimpl.go @@ -1741,10 +1741,6 @@ func (b *NodeBuilderImpl) typeParameterToDeclaration(parameter *Type) *ast.Node } func (b *NodeBuilderImpl) symbolToTypeParameterDeclarations(symbol *ast.Symbol) []*ast.Node { - return b.typeParametersToTypeParameterDeclarations(symbol) -} - -func (b *NodeBuilderImpl) typeParametersToTypeParameterDeclarations(symbol *ast.Symbol) []*ast.Node { if parameters := b.getTypeParametersOfSymbol(symbol); len(parameters) > 0 { return core.Map(parameters, b.typeParameterToDeclaration) } diff --git a/tsc/internal/ls/inlay_hints.go b/tsc/internal/ls/inlay_hints.go index c4d4cebf39717..6cee0e7511740 100644 --- a/tsc/internal/ls/inlay_hints.go +++ b/tsc/internal/ls/inlay_hints.go @@ -86,7 +86,7 @@ func (s *inlayHintState) visit(node *ast.Node) bool { return false } - if ast.IsTypeNode(node) && !ast.IsExpressionWithTypeArguments(node) { + if ast.IsTypeNode(node) { return false } From d292de9b216b702a157f02ec5b84401437dfcc0c Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sat, 14 Nov 2026 18:06:48 -0800 Subject: [PATCH 7/9] Keep display entries only for one formatting operation The checker reuses one node builder for type, symbol and signature formatting. Display entries recorded on its emit context stayed for the checker's lifetime, so repeated hovers kept adding to it. Store display entries in their own table and clear it when the outermost operation releases the builder. Serialized types that use display notation are not cached, because a cached copy would outlive those entries. Every formatting path can then share the builder. --- tsc/internal/checker/nodebuilder.go | 15 +++-------- tsc/internal/checker/nodebuilderimpl.go | 31 ++++++++++++++++----- tsc/internal/checker/printer.go | 4 +-- tsc/internal/printer/emitcontext.go | 36 +++++++++++++++---------- 4 files changed, 52 insertions(+), 34 deletions(-) diff --git a/tsc/internal/checker/nodebuilder.go b/tsc/internal/checker/nodebuilder.go index 9abe43818ba3b..1ae7677660ac0 100644 --- a/tsc/internal/checker/nodebuilder.go +++ b/tsc/internal/checker/nodebuilder.go @@ -288,6 +288,10 @@ func NewNodeBuilderEx(ch *Checker, e *printer.EmitContext, idToSymbol map[*ast.I func (c *Checker) getNodeBuilder() (*NodeBuilder, func()) { releaseNodes := func() { c.typeToStringNodebuilder.EmitContext().Factory.ReleaseArenas() // Allow any allocated nodes to be freed if they're no longer in a cache + if c.typeToStringNodebuilder.impl.ctx == nil { + // Only the outermost operation clears; nested ones finish while it is still building. + c.typeToStringNodebuilder.EmitContext().ClearDisplay() + } } if c.typeToStringNodebuilder != nil { return c.typeToStringNodebuilder, releaseNodes @@ -296,17 +300,6 @@ func (c *Checker) getNodeBuilder() (*NodeBuilder, func()) { return c.typeToStringNodebuilder, releaseNodes } -// getNodeBuilderForTypeFormat gives hover-only display formatting a builder -// local to the operation, so the cached builder does not retain its display -// metadata. -func (c *Checker) getNodeBuilderForTypeFormat(flags TypeFormatFlags) (*NodeBuilder, func()) { - if flags&(TypeFormatFlagsWriteTypeArgumentsOfSignature|TypeFormatFlagsUseInstantiationExpressions) == 0 { - return c.getNodeBuilder() - } - builder := c.getNodeBuilderEx(nil) - return builder, builder.EmitContext().Factory.ReleaseArenas -} - func (c *Checker) getNodeBuilderEx(idToSymbol map[*ast.IdentifierNode]*ast.Symbol) *NodeBuilder { b := NewNodeBuilderEx(c, printer.NewEmitContext(), idToSymbol) return b diff --git a/tsc/internal/checker/nodebuilderimpl.go b/tsc/internal/checker/nodebuilderimpl.go index 7e14b4ddaee3c..05e41d122f6e7 100644 --- a/tsc/internal/checker/nodebuilderimpl.go +++ b/tsc/internal/checker/nodebuilderimpl.go @@ -64,6 +64,7 @@ type moduleSpecifierResult struct { type NodeBuilderContext struct { host Host + usedDisplay bool // Results containing display notation are not cached tracker nodebuilder.SymbolTracker approximateLength int maxTruncationLength int @@ -314,14 +315,14 @@ func (b *NodeBuilderImpl) appendReferenceToType(root *ast.TypeNode, ref *ast.Typ if rootDisplay != nil && ast.IsExpressionWithTypeArguments(rootDisplay) || refDisplay != nil && ast.IsExpressionWithTypeArguments(refDisplay) { display := b.appendReferenceToExpression(b.referenceToExpression(typeRef), b.referenceToExpression(ref.AsTypeReferenceNode())) - b.e.SetDisplayNode(result, display) + b.setDisplayNode(result, display) } else if rootDisplay != nil || b.ctx.flags&nodebuilder.FlagsUseInstantiationExpressions != 0 && typeRef.TypeArguments != nil && len(typeRef.TypeArguments.Nodes) != 0 { // The display omits the inner reference's type arguments; the // type reference keeps them. displayRef := b.createAccessExpression(ref.AsTypeReferenceNode().TypeName) display := b.appendReferenceToExpression(b.referenceToExpression(typeRef), displayRef) - b.e.SetDisplayNode(result, display) + b.setDisplayNode(result, display) } return result } @@ -766,7 +767,7 @@ func (b *NodeBuilderImpl) symbolToTypeNode(symbol *ast.Symbol, mask ast.SymbolFl result := b.f.NewTypeReferenceNode(entityName, typeArguments) if b.ctx.flags&nodebuilder.FlagsUseInstantiationExpressions != 0 && ast.IsQualifiedName(entityName) && (b.e.DisplayNode(entityName) != nil || typeArguments != nil && len(typeArguments.Nodes) != 0) { - b.e.SetDisplayNode(result, b.createExpressionWithTypeArguments(b.createAccessExpression(entityName), typeArguments)) + b.setDisplayNode(result, b.createExpressionWithTypeArguments(b.createAccessExpression(entityName), typeArguments)) } return result } @@ -873,7 +874,7 @@ func (b *NodeBuilderImpl) createAccessFromSymbolChain(chain []*ast.Symbol, index if index < len(chain)-1 { expr = b.createExpressionWithTypeArguments(expr, typeParameterNodes) } - b.e.SetDisplayNode(name, expr) + b.setDisplayNode(name, expr) } return name } @@ -1751,7 +1752,7 @@ func (b *NodeBuilderImpl) typeParametersToTypeArgumentNodes(symbol *ast.Symbol) return core.Map(b.getTypeParametersOfSymbol(symbol), func(parameter *Type) *ast.TypeNode { declaration := b.typeParameterToDeclaration(parameter) reference := b.f.NewTypeReferenceNode(declaration.Name(), nil) - b.e.SetDisplayNode(reference, declaration) + b.setDisplayNode(reference, declaration) return reference }) } @@ -2029,7 +2030,7 @@ func (b *NodeBuilderImpl) signatureToSignatureDeclarationHelper(signature *Signa // The printer shows the instantiated arguments in place of the type parameters. if len(typeArguments) != 0 { - b.e.SetDisplayTypeArguments(node, b.f.NewNodeList(typeArguments)) + b.setDisplayTypeArguments(node, b.f.NewNodeList(typeArguments)) } cleanup() @@ -3370,9 +3371,15 @@ func (b *NodeBuilderImpl) visitAndTransformType(t *Type, transform func(b *NodeB prevTrackedSymbols := b.ctx.trackedSymbols b.ctx.trackedSymbols = nil startLength := b.ctx.approximateLength + usedDisplay := b.ctx.usedDisplay + b.ctx.usedDisplay = false result := transform(b, t) addedLength := b.ctx.approximateLength - startLength - if canUseCache && !b.ctx.reportedDiagnostic && !b.ctx.encounteredError { + // Display entries are cleared after each operation, so a cached copy of + // this result could not print them. + resultUsedDisplay := b.ctx.usedDisplay + b.ctx.usedDisplay = usedDisplay || resultUsedDisplay + if canUseCache && !resultUsedDisplay && !b.ctx.reportedDiagnostic && !b.ctx.encounteredError { links := b.links.Get(b.ctx.enclosingDeclaration) if links.serializedTypes == nil { links.serializedTypes = make(map[CompositeTypeCacheIdentity]*SerializedTypeEntry) @@ -3759,6 +3766,16 @@ func (b *NodeBuilderImpl) newIdentifier(text string, symbol *ast.Symbol) *ast.No return id } +func (b *NodeBuilderImpl) setDisplayNode(node *ast.Node, display *ast.Node) { + b.e.SetDisplayNode(node, display) + b.ctx.usedDisplay = true +} + +func (b *NodeBuilderImpl) setDisplayTypeArguments(node *ast.Node, typeArguments *ast.TypeArgumentList) { + b.e.SetDisplayTypeArguments(node, typeArguments) + b.ctx.usedDisplay = true +} + func (b *NodeBuilderImpl) createAccessExpression(node *ast.EntityName) *ast.Expression { if display := b.e.DisplayNode(node); display != nil { return display diff --git a/tsc/internal/checker/printer.go b/tsc/internal/checker/printer.go index ae1a27d3d77bb..460a6eb020d99 100644 --- a/tsc/internal/checker/printer.go +++ b/tsc/internal/checker/printer.go @@ -73,7 +73,7 @@ func (c *Checker) typeToStringEx(t *Type, enclosingDeclaration *ast.Node, flags if noTruncation { combinedFlags = combinedFlags | nodebuilder.FlagsNoTruncation } - nodeBuilder, release := c.getNodeBuilderForTypeFormat(flags) + nodeBuilder, release := c.getNodeBuilder() defer release() oldVerbosity := nodeBuilder.verbosity nodeBuilder.verbosity = vc @@ -201,7 +201,7 @@ func (c *Checker) signatureToStringEx(signature *Signature, enclosingDeclaration } } - nodeBuilder, release := c.getNodeBuilderForTypeFormat(flags) + nodeBuilder, release := c.getNodeBuilder() defer release() oldVerbosity := nodeBuilder.verbosity nodeBuilder.verbosity = vc diff --git a/tsc/internal/printer/emitcontext.go b/tsc/internal/printer/emitcontext.go index 0ee4815243c5d..fe2bc9be7b6fa 100644 --- a/tsc/internal/printer/emitcontext.go +++ b/tsc/internal/printer/emitcontext.go @@ -19,6 +19,7 @@ type EmitContext struct { textSource map[*ast.StringLiteralNode]*ast.Node original map[*ast.Node]*ast.Node emitNodes core.LinkStore[*ast.Node, emitNode] + display map[*ast.Node]display assignedName map[*ast.Node]*ast.Expression classThis map[*ast.Node]*ast.IdentifierNode varScopeStack core.Stack[*varScope] @@ -445,6 +446,9 @@ func (c *EmitContext) SetOriginalEx(node *ast.Node, original *ast.Node, allowOve if emitNode := c.emitNodes.TryGet(original); emitNode != nil { c.emitNodes.Get(node).copyFrom(emitNode) } + if d, ok := c.display[original]; ok { + c.display[node] = d + } } else if !allowOverwrite && existing != original { panic("Original node already set.") } else if allowOverwrite { @@ -534,7 +538,6 @@ type emitNode struct { leadingComments []SynthesizedComment trailingComments []SynthesizedComment typeNode *ast.TypeNode - display *display snippetElement *SnippetElement } @@ -547,7 +550,6 @@ func (e *emitNode) copyFrom(source *emitNode) { e.tokenSourceMapRanges = maps.Clone(source.tokenSourceMapRanges) e.helpers = slices.Clone(source.helpers) e.externalHelpersModuleName = source.externalHelpersModuleName - e.display = source.display if source.snippetElement != nil { snippetElement := *source.snippetElement e.snippetElement = &snippetElement @@ -556,8 +558,7 @@ func (e *emitNode) copyFrom(source *emitNode) { // display records how the printer shows a synthesized node to a user. The // syntax tree keeps canonical children, so declarations and API consumers -// never see display-only syntax. Clones share entries, so each setter stores -// a new entry. +// never see display-only syntax. type display struct { node *ast.Node typeArguments *ast.TypeArgumentList @@ -567,27 +568,34 @@ type display struct { // instantiation expression f.C for a type reference or a constrained // type parameter for a type argument. func (c *EmitContext) DisplayNode(node *ast.Node) *ast.Node { - if emitNode := c.emitNodes.TryGet(node); emitNode != nil && emitNode.display != nil { - return emitNode.display.node - } - return nil + return c.display[node].node } func (c *EmitContext) SetDisplayNode(node *ast.Node, displayNode *ast.Node) { - c.emitNodes.Get(node).display = &display{node: displayNode} + c.setDisplay(node, display{node: displayNode}) } // DisplayTypeArguments returns the instantiated type arguments printed in // place of a signature's type parameters. func (c *EmitContext) DisplayTypeArguments(node *ast.Node) *ast.TypeArgumentList { - if emitNode := c.emitNodes.TryGet(node); emitNode != nil && emitNode.display != nil { - return emitNode.display.typeArguments - } - return nil + return c.display[node].typeArguments } func (c *EmitContext) SetDisplayTypeArguments(node *ast.Node, typeArguments *ast.TypeArgumentList) { - c.emitNodes.Get(node).display = &display{typeArguments: typeArguments} + c.setDisplay(node, display{typeArguments: typeArguments}) +} + +func (c *EmitContext) setDisplay(node *ast.Node, d display) { + if c.display == nil { + c.display = make(map[*ast.Node]display) + } + c.display[node] = d +} + +// ClearDisplay removes all display entries, so they are not retained once +// their nodes have been printed. +func (c *EmitContext) ClearDisplay() { + clear(c.display) } func (c *EmitContext) EmitFlags(node *ast.Node) EmitFlags { From 4ba910be9267ae53c788176ab6a3cfe6207128e5 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sun, 15 Nov 2026 13:57:28 -0800 Subject: [PATCH 8/9] Carry hover type arguments on identifiers Qualified names such as f.C and D.prototype need type arguments on a name that is not the last one. The display was built as a substitute expression for the whole name, which took several helpers and dropped a reference's own type arguments, so hover showed (Anonymous function).Y instead of (Anonymous function).Y. Record those type arguments with the identifier they follow, outside the syntax tree, and print them after it, the same table that holds a signature's instantiated arguments. Qualified names and type references keep their ordinary shape, and the expression-building helpers are gone. --- tsc/internal/checker/nodebuilder.go | 2 +- tsc/internal/checker/nodebuilderimpl.go | 151 ++++++------------ tsc/internal/printer/emitcontext.go | 53 ++---- tsc/internal/printer/printer.go | 44 ++--- ...foLocalTypeInGenericFunctionCrash.baseline | 4 +- 5 files changed, 87 insertions(+), 167 deletions(-) diff --git a/tsc/internal/checker/nodebuilder.go b/tsc/internal/checker/nodebuilder.go index 1ae7677660ac0..424b0e06f12b1 100644 --- a/tsc/internal/checker/nodebuilder.go +++ b/tsc/internal/checker/nodebuilder.go @@ -290,7 +290,7 @@ func (c *Checker) getNodeBuilder() (*NodeBuilder, func()) { c.typeToStringNodebuilder.EmitContext().Factory.ReleaseArenas() // Allow any allocated nodes to be freed if they're no longer in a cache if c.typeToStringNodebuilder.impl.ctx == nil { // Only the outermost operation clears; nested ones finish while it is still building. - c.typeToStringNodebuilder.EmitContext().ClearDisplay() + c.typeToStringNodebuilder.EmitContext().ClearDisplayTypeArguments() } } if c.typeToStringNodebuilder != nil { diff --git a/tsc/internal/checker/nodebuilderimpl.go b/tsc/internal/checker/nodebuilderimpl.go index 05e41d122f6e7..20c3967f45872 100644 --- a/tsc/internal/checker/nodebuilderimpl.go +++ b/tsc/internal/checker/nodebuilderimpl.go @@ -64,7 +64,7 @@ type moduleSpecifierResult struct { type NodeBuilderContext struct { host Host - usedDisplay bool // Results containing display notation are not cached + usedDisplay bool // Results with display type arguments are not cached tracker nodebuilder.SymbolTracker approximateLength int maxTruncationLength int @@ -306,51 +306,25 @@ func (b *NodeBuilderImpl) appendReferenceToType(root *ast.TypeNode, ref *ast.Typ } else if ast.IsTypeReferenceNode(root) { typeRef := root.AsTypeReferenceNode() var typeName *ast.Node = typeRef.TypeName + if b.ctx.flags&nodebuilder.FlagsUseInstantiationExpressions != 0 && typeRef.TypeArguments != nil && len(typeRef.TypeArguments.Nodes) != 0 { + // The root's type arguments belong to its last name, ahead of the + // appended names. + b.setDisplayTypeArguments(getLastIdentifier(typeName), typeRef.TypeArguments) + } for _, id := range getAccessStack(ref) { typeName = b.f.NewQualifiedName(typeName, id) } - result := b.f.UpdateTypeReferenceNode(root.AsTypeReferenceNode(), typeName, ref.TypeArgumentList()) - rootDisplay := b.e.DisplayNode(root) - refDisplay := b.e.DisplayNode(ref) - if rootDisplay != nil && ast.IsExpressionWithTypeArguments(rootDisplay) || - refDisplay != nil && ast.IsExpressionWithTypeArguments(refDisplay) { - display := b.appendReferenceToExpression(b.referenceToExpression(typeRef), b.referenceToExpression(ref.AsTypeReferenceNode())) - b.setDisplayNode(result, display) - } else if rootDisplay != nil || - b.ctx.flags&nodebuilder.FlagsUseInstantiationExpressions != 0 && typeRef.TypeArguments != nil && len(typeRef.TypeArguments.Nodes) != 0 { - // The display omits the inner reference's type arguments; the - // type reference keeps them. - displayRef := b.createAccessExpression(ref.AsTypeReferenceNode().TypeName) - display := b.appendReferenceToExpression(b.referenceToExpression(typeRef), displayRef) - b.setDisplayNode(result, display) - } - return result + return b.f.UpdateTypeReferenceNode(typeRef, typeName, ref.TypeArgumentList()) } debug.FailBadSyntaxKind(root) return nil } -// referenceToExpression returns a type reference as an expression. -func (b *NodeBuilderImpl) referenceToExpression(ref *ast.TypeReferenceNode) *ast.Expression { - if display := b.e.DisplayNode(ref.AsNode()); display != nil { - return display - } - return b.createExpressionWithTypeArguments(b.createAccessExpression(ref.TypeName), ref.TypeArguments) -} - -// appendReferenceToExpression returns ref, a reference expression, as a -// reference to a member of root. -func (b *NodeBuilderImpl) appendReferenceToExpression(root *ast.Expression, ref *ast.Expression) *ast.Expression { - switch { - case ast.IsIdentifier(ref): - return b.f.NewPropertyAccessExpression(root, nil /*questionDotToken*/, ref, ast.NodeFlagsNone) - case ast.IsPropertyAccessExpression(ref): - return b.f.NewPropertyAccessExpression(b.appendReferenceToExpression(root, ref.Expression()), nil /*questionDotToken*/, ref.Name(), ast.NodeFlagsNone) - case ast.IsExpressionWithTypeArguments(ref): - return b.f.NewExpressionWithTypeArguments(b.appendReferenceToExpression(root, ref.Expression()), ref.AsExpressionWithTypeArguments().TypeArguments) - default: - panic("unexpected reference kind: " + ref.Kind.String()) +func getLastIdentifier(name *ast.EntityName) *ast.IdentifierNode { + if ast.IsQualifiedName(name) { + return name.AsQualifiedName().Right } + return name } func getAccessStack(ref *ast.Node) []*ast.Node { @@ -764,12 +738,7 @@ func (b *NodeBuilderImpl) symbolToTypeNode(symbol *ast.Symbol, mask ast.SymbolFl if isTypeOf { return b.f.NewTypeQueryNode(entityName, typeArguments) } - result := b.f.NewTypeReferenceNode(entityName, typeArguments) - if b.ctx.flags&nodebuilder.FlagsUseInstantiationExpressions != 0 && ast.IsQualifiedName(entityName) && - (b.e.DisplayNode(entityName) != nil || typeArguments != nil && len(typeArguments.Nodes) != 0) { - b.setDisplayNode(result, b.createExpressionWithTypeArguments(b.createAccessExpression(entityName), typeArguments)) - } - return result + return b.f.NewTypeReferenceNode(entityName, typeArguments) } func getTopmostIndexedAccessType(node *ast.IndexedAccessTypeNode) *ast.IndexedAccessTypeNode { @@ -857,7 +826,7 @@ func (b *NodeBuilderImpl) createAccessFromSymbolChain(chain []*ast.Symbol, index ) } return b.f.NewIndexedAccessTypeNode( - b.f.NewTypeReferenceNode(lhs, typeParameterNodes), + b.f.NewTypeReferenceNode(lhs, b.referenceTypeArguments(lhs, typeParameterNodes)), b.f.NewLiteralTypeNode(b.newStringLiteral(symbolName)), ) } @@ -867,16 +836,10 @@ func (b *NodeBuilderImpl) createAccessFromSymbolChain(chain []*ast.Symbol, index if index > stopper { lhs := b.createAccessFromSymbolChain(chain, index-1, stopper, overrideTypeArguments) - name := b.f.NewQualifiedName(lhs, identifier) - if b.ctx.flags&nodebuilder.FlagsUseInstantiationExpressions != 0 && - (b.e.DisplayNode(lhs) != nil || index < len(chain)-1 && typeParameterNodes != nil && len(typeParameterNodes.Nodes) != 0) { - expr := b.f.NewPropertyAccessExpression(b.createAccessExpression(lhs), nil, identifier, ast.NodeFlagsNone) - if index < len(chain)-1 { - expr = b.createExpressionWithTypeArguments(expr, typeParameterNodes) - } - b.setDisplayNode(name, expr) + if b.ctx.flags&nodebuilder.FlagsUseInstantiationExpressions != 0 && index < len(chain)-1 && typeParameterNodes != nil && len(typeParameterNodes.Nodes) != 0 { + b.setDisplayTypeArguments(identifier, typeParameterNodes) } - return name + return b.f.NewQualifiedName(lhs, identifier) } return identifier } @@ -913,12 +876,13 @@ func (b *NodeBuilderImpl) createExpressionFromSymbolChain(chain []*ast.Symbol, i identifier := b.newIdentifier(symbolName, symbol) b.e.AddEmitFlags(identifier, printer.EFNoAsciiEscaping) b.ctx.approximateLength += 1 + len(symbolName) + b.setDisplayTypeArgumentsIfAny(identifier, typeParameterNodes) if index > 0 { result := b.f.NewPropertyAccessExpression(b.createExpressionFromSymbolChain(chain, index-1), nil, identifier, ast.NodeFlagsNone) b.e.AddEmitFlags(result, printer.EFNoIndentation) - return b.createExpressionWithTypeArguments(result, typeParameterNodes) + return result } - return b.createExpressionWithTypeArguments(identifier, typeParameterNodes) + return identifier } if startsWithSquareBracket(symbolName) { @@ -940,9 +904,10 @@ func (b *NodeBuilderImpl) createExpressionFromSymbolChain(chain []*ast.Symbol, i b.ctx.approximateLength += len(symbolName) expression = b.newIdentifier(symbolName, symbol) b.e.AddEmitFlags(expression, printer.EFNoAsciiEscaping) + b.setDisplayTypeArgumentsIfAny(expression, typeParameterNodes) } b.ctx.approximateLength += 2 // [] - return b.createExpressionWithTypeArguments(b.f.NewElementAccessExpression(b.createExpressionFromSymbolChain(chain, index-1), nil, expression, ast.NodeFlagsNone), typeParameterNodes) + return b.f.NewElementAccessExpression(b.createExpressionFromSymbolChain(chain, index-1), nil, expression, ast.NodeFlagsNone) } func canUsePropertyAccess(name string) bool { @@ -1069,7 +1034,7 @@ func (b *NodeBuilderImpl) getTypeParametersOfClassOrInterface(symbol *ast.Symbol return result } -func (b *NodeBuilderImpl) lookupTypeParameterNodes(chain []*ast.Symbol, index int) *ast.TypeList { +func (b *NodeBuilderImpl) lookupTypeParameterNodes(chain []*ast.Symbol, index int) *ast.TypeParameterList { debug.Assert(chain != nil && 0 <= index && index < len(chain)) symbol := chain[index] symbolId := ast.GetSymbolId(symbol) @@ -1082,7 +1047,7 @@ func (b *NodeBuilderImpl) lookupTypeParameterNodes(chain []*ast.Symbol, index in if typeArgumentNodes := b.lookupInstantiatedTypeArgumentNodes(chain, index); typeArgumentNodes != nil { return typeArgumentNodes } else { - typeParameterNodes := b.typeParametersToTypeArgumentNodes(symbol) + typeParameterNodes := b.typeParametersToTypeParameterDeclarations(symbol) if len(typeParameterNodes) > 0 { return b.f.NewNodeList(typeParameterNodes) } @@ -1742,27 +1707,24 @@ func (b *NodeBuilderImpl) typeParameterToDeclaration(parameter *Type) *ast.Node } func (b *NodeBuilderImpl) symbolToTypeParameterDeclarations(symbol *ast.Symbol) []*ast.Node { - if parameters := b.getTypeParametersOfSymbol(symbol); len(parameters) > 0 { - return core.Map(parameters, b.typeParameterToDeclaration) - } - return nil -} - -func (b *NodeBuilderImpl) typeParametersToTypeArgumentNodes(symbol *ast.Symbol) []*ast.TypeNode { - return core.Map(b.getTypeParametersOfSymbol(symbol), func(parameter *Type) *ast.TypeNode { - declaration := b.typeParameterToDeclaration(parameter) - reference := b.f.NewTypeReferenceNode(declaration.Name(), nil) - b.setDisplayNode(reference, declaration) - return reference - }) + return b.typeParametersToTypeParameterDeclarations(symbol) } -func (b *NodeBuilderImpl) getTypeParametersOfSymbol(symbol *ast.Symbol) []*Type { +func (b *NodeBuilderImpl) typeParametersToTypeParameterDeclarations(symbol *ast.Symbol) []*ast.Node { targetSymbol := b.ch.getTargetSymbol(symbol) if targetSymbol.Flags()&(ast.SymbolFlagsClass|ast.SymbolFlagsInterface|ast.SymbolFlagsAlias) != 0 { - return b.ch.getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) + var results []*ast.Node + params := b.ch.getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) + for _, param := range params { + results = append(results, b.typeParameterToDeclaration(param)) + } + return results } else if targetSymbol.Flags()&ast.SymbolFlagsFunction != 0 { - return b.ch.getTypeParametersFromDeclaration(symbol.ValueDeclaration()) + var results []*ast.Node + for _, param := range b.ch.getTypeParametersFromDeclaration(symbol.ValueDeclaration()) { + results = append(results, b.typeParameterToDeclaration(param)) + } + return results } return nil } @@ -2028,8 +1990,8 @@ func (b *NodeBuilderImpl) signatureToSignatureDeclarationHelper(signature *Signa panic("Unhandled kind in signatureToSignatureDeclarationHelper") } - // The printer shows the instantiated arguments in place of the type parameters. if len(typeArguments) != 0 { + // The printer shows these in place of the type parameters. b.setDisplayTypeArguments(node, b.f.NewNodeList(typeArguments)) } @@ -3375,8 +3337,8 @@ func (b *NodeBuilderImpl) visitAndTransformType(t *Type, transform func(b *NodeB b.ctx.usedDisplay = false result := transform(b, t) addedLength := b.ctx.approximateLength - startLength - // Display entries are cleared after each operation, so a cached copy of - // this result could not print them. + // Display type arguments are cleared after each operation, so a cached + // copy of this result could not print them. resultUsedDisplay := b.ctx.usedDisplay b.ctx.usedDisplay = usedDisplay || resultUsedDisplay if canUseCache && !resultUsedDisplay && !b.ctx.reportedDiagnostic && !b.ctx.encounteredError { @@ -3766,35 +3728,28 @@ func (b *NodeBuilderImpl) newIdentifier(text string, symbol *ast.Symbol) *ast.No return id } -func (b *NodeBuilderImpl) setDisplayNode(node *ast.Node, display *ast.Node) { - b.e.SetDisplayNode(node, display) - b.ctx.usedDisplay = true -} - -func (b *NodeBuilderImpl) setDisplayTypeArguments(node *ast.Node, typeArguments *ast.TypeArgumentList) { +func (b *NodeBuilderImpl) setDisplayTypeArguments(node *ast.Node, typeArguments *ast.NodeList) { b.e.SetDisplayTypeArguments(node, typeArguments) b.ctx.usedDisplay = true } -func (b *NodeBuilderImpl) createAccessExpression(node *ast.EntityName) *ast.Expression { - if display := b.e.DisplayNode(node); display != nil { - return display +func (b *NodeBuilderImpl) setDisplayTypeArgumentsIfAny(node *ast.Node, typeArguments *ast.NodeList) { + if typeArguments != nil && len(typeArguments.Nodes) != 0 { + b.setDisplayTypeArguments(node, typeArguments) } - if ast.IsQualifiedName(node) { - return b.f.NewPropertyAccessExpression(b.createAccessExpression(node.AsQualifiedName().Left), nil /*questionDotToken*/, node.AsQualifiedName().Right, ast.NodeFlagsNone) - } - debug.Assert(ast.IsIdentifier(node)) - return node } -func (b *NodeBuilderImpl) createExpressionWithTypeArguments(expr *ast.Expression, typeArguments *ast.NodeList) *ast.Expression { - if typeArguments == nil || len(typeArguments.Nodes) == 0 { - return expr +// referenceTypeArguments returns the type arguments of a reference to name. A +// list with type parameter declarations is shown with name, outside the tree. +func (b *NodeBuilderImpl) referenceTypeArguments(name *ast.EntityName, typeArguments *ast.NodeList) *ast.NodeList { + if typeArguments == nil || !core.Some(typeArguments.Nodes, ast.IsTypeParameterDeclaration) { + return typeArguments } - return b.f.NewExpressionWithTypeArguments(expr, typeArguments) + b.setDisplayTypeArguments(getLastIdentifier(name), typeArguments) + return nil } -func (b *NodeBuilderImpl) lookupInstantiatedTypeArgumentNodes(chain []*ast.Symbol, index int) *ast.TypeList { +func (b *NodeBuilderImpl) lookupInstantiatedTypeArgumentNodes(chain []*ast.Symbol, index int) *ast.TypeParameterList { if b.shouldWriteTypeParametersInQualifiedName(chain, index) { symbol := chain[index] nextSymbol := chain[index+1] @@ -3821,7 +3776,7 @@ func (b *NodeBuilderImpl) lookupInstantiatedTypeArgumentNodes(chain []*ast.Symbo return nil } -func (b *NodeBuilderImpl) lookupExpressionChainTypeArgumentNodes(chain []*ast.Symbol, index int) *ast.TypeList { +func (b *NodeBuilderImpl) lookupExpressionChainTypeArgumentNodes(chain []*ast.Symbol, index int) *ast.TypeParameterList { if b.shouldWriteTypeParametersInQualifiedName(chain, index) { symbol := chain[index] symbolId := ast.GetSymbolId(symbol) @@ -3833,7 +3788,7 @@ func (b *NodeBuilderImpl) lookupExpressionChainTypeArgumentNodes(chain []*ast.Sy if typeArgumentNodes := b.lookupInstantiatedTypeArgumentNodes(chain, index); typeArgumentNodes != nil { return typeArgumentNodes } - typeParameterNodes := b.typeParametersToTypeArgumentNodes(symbol) + typeParameterNodes := b.typeParametersToTypeParameterDeclarations(symbol) if len(typeParameterNodes) > 0 { return b.f.NewNodeList(typeParameterNodes) } diff --git a/tsc/internal/printer/emitcontext.go b/tsc/internal/printer/emitcontext.go index fe2bc9be7b6fa..6dd90196afe5e 100644 --- a/tsc/internal/printer/emitcontext.go +++ b/tsc/internal/printer/emitcontext.go @@ -19,7 +19,7 @@ type EmitContext struct { textSource map[*ast.StringLiteralNode]*ast.Node original map[*ast.Node]*ast.Node emitNodes core.LinkStore[*ast.Node, emitNode] - display map[*ast.Node]display + display map[*ast.Node]*ast.NodeList assignedName map[*ast.Node]*ast.Expression classThis map[*ast.Node]*ast.IdentifierNode varScopeStack core.Stack[*varScope] @@ -446,8 +446,8 @@ func (c *EmitContext) SetOriginalEx(node *ast.Node, original *ast.Node, allowOve if emitNode := c.emitNodes.TryGet(original); emitNode != nil { c.emitNodes.Get(node).copyFrom(emitNode) } - if d, ok := c.display[original]; ok { - c.display[node] = d + if typeArguments, ok := c.display[original]; ok { + c.display[node] = typeArguments } } else if !allowOverwrite && existing != original { panic("Original node already set.") @@ -556,45 +556,26 @@ func (e *emitNode) copyFrom(source *emitNode) { } } -// display records how the printer shows a synthesized node to a user. The -// syntax tree keeps canonical children, so declarations and API consumers -// never see display-only syntax. -type display struct { - node *ast.Node - typeArguments *ast.TypeArgumentList +// DisplayTypeArguments returns type arguments shown with node: after an +// identifier in a qualified name, as in C.x, or in place of a +// signature's type parameters, as in (value: string). They may include +// type parameter declarations, as in C.prototype. +// The syntax tree keeps only valid children, so declarations and API +// consumers never see these. +func (c *EmitContext) DisplayTypeArguments(node *ast.Node) *ast.NodeList { + return c.display[node] } -// DisplayNode returns the node printed in place of node, such as the -// instantiation expression f.C for a type reference or a constrained -// type parameter for a type argument. -func (c *EmitContext) DisplayNode(node *ast.Node) *ast.Node { - return c.display[node].node -} - -func (c *EmitContext) SetDisplayNode(node *ast.Node, displayNode *ast.Node) { - c.setDisplay(node, display{node: displayNode}) -} - -// DisplayTypeArguments returns the instantiated type arguments printed in -// place of a signature's type parameters. -func (c *EmitContext) DisplayTypeArguments(node *ast.Node) *ast.TypeArgumentList { - return c.display[node].typeArguments -} - -func (c *EmitContext) SetDisplayTypeArguments(node *ast.Node, typeArguments *ast.TypeArgumentList) { - c.setDisplay(node, display{typeArguments: typeArguments}) -} - -func (c *EmitContext) setDisplay(node *ast.Node, d display) { +func (c *EmitContext) SetDisplayTypeArguments(node *ast.Node, typeArguments *ast.NodeList) { if c.display == nil { - c.display = make(map[*ast.Node]display) + c.display = make(map[*ast.Node]*ast.NodeList) } - c.display[node] = d + c.display[node] = typeArguments } -// ClearDisplay removes all display entries, so they are not retained once -// their nodes have been printed. -func (c *EmitContext) ClearDisplay() { +// ClearDisplayTypeArguments removes all display type arguments, so they are +// not retained once their nodes have been printed. +func (c *EmitContext) ClearDisplayTypeArguments() { clear(c.display) } diff --git a/tsc/internal/printer/printer.go b/tsc/internal/printer/printer.go index 85f7eb36a05a7..00836c697c402 100644 --- a/tsc/internal/printer/printer.go +++ b/tsc/internal/printer/printer.go @@ -1120,13 +1120,12 @@ func (p *Printer) emitIdentifierText(node *ast.Identifier) { debug.Assert(f == nil || p.currentSourceFile == nil || f.FileName() == p.currentSourceFile.FileName()) text := p.getTextOfNode(node.AsNode(), false /*includeTrivia*/) - if p.IdToSymbol != nil { - if symbol, ok := p.IdToSymbol[node.AsNode()]; ok { - p.writeSymbol(text, symbol) - return - } + if symbol, ok := p.IdToSymbol[node.AsNode()]; ok { + p.writeSymbol(text, symbol) + } else { + p.write(text) } - p.write(text) + p.emitTypeArguments(node.AsNode(), p.emitContext.DisplayTypeArguments(node.AsNode())) } func (p *Printer) emitIdentifierName(node *ast.Identifier) { @@ -1223,25 +1222,7 @@ func (p *Printer) emitComputedPropertyName(node *ast.ComputedPropertyName) { p.exitNode(node.AsNode(), state) } -// emitDisplayNode prints the display-only substitute for a synthesized node, -// if one exists, and reports whether it did. -func (p *Printer) emitDisplayNode(node *ast.Node) bool { - display := p.emitContext.DisplayNode(node) - switch { - case display == nil: - return false - case ast.IsTypeParameterDeclaration(display): - p.emitTypeParameter(display.AsTypeParameterDeclaration()) - default: - p.emitExpression(display, ast.OperatorPrecedenceDisallowComma) - } - return true -} - func (p *Printer) emitEntityName(node *ast.EntityName) { - if p.emitDisplayNode(node) { - return - } switch node.Kind { case ast.KindIdentifier: p.emitIdentifierReference(node.AsIdentifier()) @@ -1475,7 +1456,12 @@ func (p *Printer) emitTypeParameter(node *ast.TypeParameterDeclaration) { } func (p *Printer) emitTypeParameterDeclarationNode(node *ast.TypeParameterDeclarationNode) { - p.emitTypeParameter(node.AsTypeParameterDeclaration()) + // Display type arguments can include type parameter declarations. + if ast.IsTypeParameterDeclaration(node) { + p.emitTypeParameter(node.AsTypeParameterDeclaration()) + } else { + p.emitTypeArgument(node) + } } func (p *Printer) emitParameterName(node *ast.BindingName) { @@ -1916,15 +1902,13 @@ func (p *Printer) emitTypeArguments(parentNode *ast.Node, nodes *ast.TypeArgumen if nodes == nil { return } - p.emitList((*Printer).emitTypeArgument, parentNode, nodes, LFTypeArguments /*|core.IfElse(p.shouldAllowTrailingComma(parentNode, nodes), LFAllowTrailingComma, LFNone)*/) // TODO: preserve trailing comma after Strada migration + p.emitList((*Printer).emitTypeParameterDeclarationNode, parentNode, nodes, LFTypeArguments /*|core.IfElse(p.shouldAllowTrailingComma(parentNode, nodes), LFAllowTrailingComma, LFNone)*/) // TODO: preserve trailing comma after Strada migration } func (p *Printer) emitTypeReference(node *ast.TypeReferenceNode) { state := p.enterNode(node.AsNode()) - if !p.emitDisplayNode(node.AsNode()) { - p.emitEntityName(node.TypeName) - p.emitTypeArguments(node.AsNode(), node.TypeArguments) - } + p.emitEntityName(node.TypeName) + p.emitTypeArguments(node.AsNode(), node.TypeArguments) p.exitNode(node.AsNode(), state) } diff --git a/tsc/testdata/baselines/reference/fourslash/quickInfo/quickInfoLocalTypeInGenericFunctionCrash.baseline b/tsc/testdata/baselines/reference/fourslash/quickInfo/quickInfoLocalTypeInGenericFunctionCrash.baseline index 7f2af9703e124..c58e54a30b708 100644 --- a/tsc/testdata/baselines/reference/fourslash/quickInfo/quickInfoLocalTypeInGenericFunctionCrash.baseline +++ b/tsc/testdata/baselines/reference/fourslash/quickInfo/quickInfoLocalTypeInGenericFunctionCrash.baseline @@ -20,7 +20,7 @@ // ^ // | ---------------------------------------------------------------------- // | ```typescript -// | (method) X.m(): (Anonymous function).Y +// | (method) X.m(): (Anonymous function).Y // | ``` // | // | ---------------------------------------------------------------------- @@ -140,7 +140,7 @@ "item": { "contents": { "kind": "markdown", - "value": "```typescript\n(method) X.m(): (Anonymous function).Y\n```\n" + "value": "```typescript\n(method) X.m(): (Anonymous function).Y\n```\n" }, "range": { "start": { From e382fd2d4e580b50ef140a6a7f7ee5b55886fb9c Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sun, 15 Nov 2026 14:25:51 -0800 Subject: [PATCH 9/9] Match printer and lookup signatures to the nodes they handle Type argument lists were printed through the type parameter printer so that display type arguments could include declarations, and type lists were annotated as type parameter lists. Print display type arguments through their own path, so each printer handles only the kind of node its signature names, and annotate the type lists with the kinds they hold. --- tsc/internal/checker/nodebuilderimpl.go | 6 ++--- tsc/internal/printer/printer.go | 30 +++++++++++++++++-------- 2 files changed, 24 insertions(+), 12 deletions(-) diff --git a/tsc/internal/checker/nodebuilderimpl.go b/tsc/internal/checker/nodebuilderimpl.go index 20c3967f45872..c60a65d8c43aa 100644 --- a/tsc/internal/checker/nodebuilderimpl.go +++ b/tsc/internal/checker/nodebuilderimpl.go @@ -1034,7 +1034,7 @@ func (b *NodeBuilderImpl) getTypeParametersOfClassOrInterface(symbol *ast.Symbol return result } -func (b *NodeBuilderImpl) lookupTypeParameterNodes(chain []*ast.Symbol, index int) *ast.TypeParameterList { +func (b *NodeBuilderImpl) lookupTypeParameterNodes(chain []*ast.Symbol, index int) *ast.NodeList { debug.Assert(chain != nil && 0 <= index && index < len(chain)) symbol := chain[index] symbolId := ast.GetSymbolId(symbol) @@ -3749,7 +3749,7 @@ func (b *NodeBuilderImpl) referenceTypeArguments(name *ast.EntityName, typeArgum return nil } -func (b *NodeBuilderImpl) lookupInstantiatedTypeArgumentNodes(chain []*ast.Symbol, index int) *ast.TypeParameterList { +func (b *NodeBuilderImpl) lookupInstantiatedTypeArgumentNodes(chain []*ast.Symbol, index int) *ast.TypeArgumentList { if b.shouldWriteTypeParametersInQualifiedName(chain, index) { symbol := chain[index] nextSymbol := chain[index+1] @@ -3776,7 +3776,7 @@ func (b *NodeBuilderImpl) lookupInstantiatedTypeArgumentNodes(chain []*ast.Symbo return nil } -func (b *NodeBuilderImpl) lookupExpressionChainTypeArgumentNodes(chain []*ast.Symbol, index int) *ast.TypeParameterList { +func (b *NodeBuilderImpl) lookupExpressionChainTypeArgumentNodes(chain []*ast.Symbol, index int) *ast.NodeList { if b.shouldWriteTypeParametersInQualifiedName(chain, index) { symbol := chain[index] symbolId := ast.GetSymbolId(symbol) diff --git a/tsc/internal/printer/printer.go b/tsc/internal/printer/printer.go index 00836c697c402..2844774f441a8 100644 --- a/tsc/internal/printer/printer.go +++ b/tsc/internal/printer/printer.go @@ -1125,7 +1125,7 @@ func (p *Printer) emitIdentifierText(node *ast.Identifier) { } else { p.write(text) } - p.emitTypeArguments(node.AsNode(), p.emitContext.DisplayTypeArguments(node.AsNode())) + p.emitDisplayTypeArguments(node.AsNode(), p.emitContext.DisplayTypeArguments(node.AsNode())) } func (p *Printer) emitIdentifierName(node *ast.Identifier) { @@ -1456,12 +1456,7 @@ func (p *Printer) emitTypeParameter(node *ast.TypeParameterDeclaration) { } func (p *Printer) emitTypeParameterDeclarationNode(node *ast.TypeParameterDeclarationNode) { - // Display type arguments can include type parameter declarations. - if ast.IsTypeParameterDeclaration(node) { - p.emitTypeParameter(node.AsTypeParameterDeclaration()) - } else { - p.emitTypeArgument(node) - } + p.emitTypeParameter(node.AsTypeParameterDeclaration()) } func (p *Printer) emitParameterName(node *ast.BindingName) { @@ -1517,7 +1512,7 @@ func (p *Printer) emitTypeParameters(parentNode *ast.Node, nodes *ast.TypeParame func (p *Printer) emitSignatureTypeArgumentsOrParameters(node *ast.Node) { if arguments := p.emitContext.DisplayTypeArguments(node); arguments != nil { - p.emitTypeArguments(node, arguments) + p.emitDisplayTypeArguments(node, arguments) } else { p.emitTypeParameters(node, node.FunctionLikeData().TypeParameters) } @@ -1902,7 +1897,24 @@ func (p *Printer) emitTypeArguments(parentNode *ast.Node, nodes *ast.TypeArgumen if nodes == nil { return } - p.emitList((*Printer).emitTypeParameterDeclarationNode, parentNode, nodes, LFTypeArguments /*|core.IfElse(p.shouldAllowTrailingComma(parentNode, nodes), LFAllowTrailingComma, LFNone)*/) // TODO: preserve trailing comma after Strada migration + p.emitList((*Printer).emitTypeArgument, parentNode, nodes, LFTypeArguments /*|core.IfElse(p.shouldAllowTrailingComma(parentNode, nodes), LFAllowTrailingComma, LFNone)*/) // TODO: preserve trailing comma after Strada migration +} + +// emitDisplayTypeArguments prints type arguments recorded for display. They can +// include type parameter declarations. +func (p *Printer) emitDisplayTypeArguments(parentNode *ast.Node, nodes *ast.NodeList) { + if nodes == nil { + return + } + p.emitList((*Printer).emitDisplayTypeArgument, parentNode, nodes, LFTypeArguments) +} + +func (p *Printer) emitDisplayTypeArgument(node *ast.Node) { + if ast.IsTypeParameterDeclaration(node) { + p.emitTypeParameter(node.AsTypeParameterDeclaration()) + } else { + p.emitTypeArgument(node) + } } func (p *Printer) emitTypeReference(node *ast.TypeReferenceNode) {