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..a4b82446f1fd4 100644 --- a/packages/typescript/test/async/api.test.ts +++ b/packages/typescript/test/async/api.test.ts @@ -8979,7 +8979,6 @@ export const obj = { m: 1, s: "hi", b: true }; SyntaxKind.ObjectKeyword, SyntaxKind.SymbolKeyword, SyntaxKind.IntrinsicKeyword, - SyntaxKind.ExpressionWithTypeArguments, SyntaxKind.JSDocAllType, SyntaxKind.JSDocNullableType, SyntaxKind.JSDocNonNullableType, diff --git a/packages/typescript/test/sync/api.test.ts b/packages/typescript/test/sync/api.test.ts index c57ca53e905bc..3b5b5306c2f24 100644 --- a/packages/typescript/test/sync/api.test.ts +++ b/packages/typescript/test/sync/api.test.ts @@ -8737,7 +8737,6 @@ export const obj = { m: 1, s: "hi", b: true }; SyntaxKind.ObjectKeyword, SyntaxKind.SymbolKeyword, SyntaxKind.IntrinsicKeyword, - SyntaxKind.ExpressionWithTypeArguments, SyntaxKind.JSDocAllType, SyntaxKind.JSDocNullableType, SyntaxKind.JSDocNonNullableType, 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/nodebuilder.go b/tsc/internal/checker/nodebuilder.go index a4fb793b334bf..424b0e06f12b1 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().ClearDisplayTypeArguments() + } } if c.typeToStringNodebuilder != nil { return c.typeToStringNodebuilder, releaseNodes diff --git a/tsc/internal/checker/nodebuilderimpl.go b/tsc/internal/checker/nodebuilderimpl.go index 2d2d01e83affa..c60a65d8c43aa 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 with display type arguments are not cached tracker nodebuilder.SymbolTracker approximateLength int maxTruncationLength int @@ -272,12 +273,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,48 +305,26 @@ 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() + var typeName *ast.Node = typeRef.TypeName 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 + // The root's type arguments belong to its last name, ahead of the + // appended names. + b.setDisplayTypeArguments(getLastIdentifier(typeName), typeRef.TypeArguments) } - 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 b.f.UpdateTypeReferenceNode(typeRef, typeName, ref.TypeArgumentList()) } - return expr -} - -// 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 ast.IsTypeReferenceNode(ref) { - return b.createExpressionWithTypeArguments(b.createAccessExpression(ref.AsTypeReferenceNode().TypeName), ref.TypeArgumentList()) - } - return b.createAccessExpression(ref) + debug.FailBadSyntaxKind(root) + return nil } -// 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 { @@ -761,17 +734,11 @@ 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) - } - if isTypeOf && ast.IsExpressionWithTypeArguments(entityName) { - expr := entityName.AsExpressionWithTypeArguments() - return b.f.NewTypeQueryNode(b.f.DeepCloneNode(expr.Expression), expr.TypeArguments) + debug.Assert(ast.IsEntityName(entityName)) + if isTypeOf { + return b.f.NewTypeQueryNode(entityName, typeArguments) } - return entityName + return b.f.NewTypeReferenceNode(entityName, typeArguments) } func getTopmostIndexedAccessType(node *ast.IndexedAccessTypeNode) *ast.IndexedAccessTypeNode { @@ -859,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)), ) } @@ -869,10 +836,10 @@ 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) + if b.ctx.flags&nodebuilder.FlagsUseInstantiationExpressions != 0 && index < len(chain)-1 && typeParameterNodes != nil && len(typeParameterNodes.Nodes) != 0 { + b.setDisplayTypeArguments(identifier, typeParameterNodes) } - return b.createExpressionWithTypeArguments(b.f.NewPropertyAccessExpression(b.createAccessExpression(lhs), nil, identifier, ast.NodeFlagsNone), typeParameterNodes) + return b.f.NewQualifiedName(lhs, identifier) } return identifier } @@ -909,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) { @@ -936,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 { @@ -1065,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) @@ -1911,6 +1880,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,7 +1888,7 @@ 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))) + typeArguments = append(typeArguments, b.typeToTypeNode(b.ch.instantiateType(parameter, signature.mapper))) } } else { for _, parameter := range signature.TypeParameters() { @@ -2020,10 +1990,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) - // } + if len(typeArguments) != 0 { + // The printer shows these in place of the type parameters. + b.setDisplayTypeArguments(node, b.f.NewNodeList(typeArguments)) + } cleanup() return node @@ -3363,9 +3333,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 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 { links := b.links.Get(b.ctx.enclosingDeclaration) if links.serializedTypes == nil { links.serializedTypes = make(map[CompositeTypeCacheIdentity]*SerializedTypeEntry) @@ -3752,25 +3728,28 @@ func (b *NodeBuilderImpl) newIdentifier(text string, symbol *ast.Symbol) *ast.No return id } -func (b *NodeBuilderImpl) createAccessExpression(node *ast.Node) *ast.Expression { - 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.DeepCloneNode(node) - default: - panic("unexpected access node kind: " + node.Kind.String()) +func (b *NodeBuilderImpl) setDisplayTypeArguments(node *ast.Node, typeArguments *ast.NodeList) { + b.e.SetDisplayTypeArguments(node, typeArguments) + b.ctx.usedDisplay = true +} + +func (b *NodeBuilderImpl) setDisplayTypeArgumentsIfAny(node *ast.Node, typeArguments *ast.NodeList) { + if typeArguments != nil && len(typeArguments.Nodes) != 0 { + b.setDisplayTypeArguments(node, typeArguments) } } -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.TypeParameterList { +func (b *NodeBuilderImpl) lookupInstantiatedTypeArgumentNodes(chain []*ast.Symbol, index int) *ast.TypeArgumentList { if b.shouldWriteTypeParametersInQualifiedName(chain, index) { symbol := chain[index] nextSymbol := chain[index+1] @@ -3797,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/checker/printer.go b/tsc/internal/checker/printer.go index b84c967883d88..460a6eb020d99 100644 --- a/tsc/internal/checker/printer.go +++ b/tsc/internal/checker/printer.go @@ -285,12 +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 { + flags &^= hoverOnlyNodeBuilderFlags 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/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/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/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 } diff --git a/tsc/internal/printer/emitcontext.go b/tsc/internal/printer/emitcontext.go index 7953212bd40e7..6dd90196afe5e 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]*ast.NodeList 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 typeArguments, ok := c.display[original]; ok { + c.display[node] = typeArguments + } } else if !allowOverwrite && existing != original { panic("Original node already set.") } else if allowOverwrite { @@ -552,6 +556,29 @@ func (e *emitNode) copyFrom(source *emitNode) { } } +// 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] +} + +func (c *EmitContext) SetDisplayTypeArguments(node *ast.Node, typeArguments *ast.NodeList) { + if c.display == nil { + c.display = make(map[*ast.Node]*ast.NodeList) + } + c.display[node] = typeArguments +} + +// ClearDisplayTypeArguments removes all display type arguments, so they are +// not retained once their nodes have been printed. +func (c *EmitContext) ClearDisplayTypeArguments() { + clear(c.display) +} + 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..2844774f441a8 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.emitDisplayTypeArguments(node.AsNode(), p.emitContext.DisplayTypeArguments(node.AsNode())) } func (p *Printer) emitIdentifierName(node *ast.Identifier) { @@ -1229,10 +1228,6 @@ func (p *Printer) emitEntityName(node *ast.EntityName) { 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,13 +1456,7 @@ 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 { - p.emitTypeArgument(node) - } + p.emitTypeParameter(node.AsTypeParameterDeclaration()) } func (p *Printer) emitParameterName(node *ast.BindingName) { @@ -1521,6 +1510,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.emitDisplayTypeArguments(node, arguments) + } else { + p.emitTypeParameters(node, node.FunctionLikeData().TypeParameters) + } +} + func (p *Printer) emitTypeAnnotation(node *ast.TypeNode) { if node == nil { return @@ -1586,12 +1583,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) @@ -1905,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) { @@ -1939,8 +1948,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 +1965,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 +2374,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: 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": {