Skip to content
1 change: 0 additions & 1 deletion packages/typescript/src/ast/is.ts
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
1 change: 0 additions & 1 deletion packages/typescript/test/async/api.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -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,
Expand Down
1 change: 0 additions & 1 deletion packages/typescript/test/sync/api.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -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,
Expand Down
5 changes: 1 addition & 4 deletions tsc/internal/ast/precedence.go
Original file line number Diff line number Diff line change
Expand Up @@ -706,10 +706,7 @@ func GetTypeNodePrecedence(n *TypeNode) TypePrecedence {
KindMappedType,
KindNamedTupleMember,
KindTemplateLiteralType,
KindImportType,
// These occur in pseudo-types like `f<T>.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))
Expand Down
1 change: 0 additions & 1 deletion tsc/internal/ast/utilities.go
Original file line number Diff line number Diff line change
Expand Up @@ -786,7 +786,6 @@ func IsTypeNodeKind(kind Kind) bool {
KindUndefinedKeyword,
KindNeverKeyword,
KindIntrinsicKeyword,
KindExpressionWithTypeArguments,
KindJSDocAllType,
KindJSDocNullableType,
KindJSDocNonNullableType,
Expand Down
4 changes: 4 additions & 0 deletions tsc/internal/checker/nodebuilder.go
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
133 changes: 56 additions & 77 deletions tsc/internal/checker/nodebuilderimpl.go
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down Expand Up @@ -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

Expand Down Expand Up @@ -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 {
Expand Down Expand Up @@ -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 {
Expand Down Expand Up @@ -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)),
)
}
Expand All @@ -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
}
Expand Down Expand Up @@ -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) {
Expand All @@ -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 {
Expand Down Expand Up @@ -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)
Expand Down Expand Up @@ -1911,14 +1880,15 @@ 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
// Usually a signature contributes a few more characters than this, but 3 is the minimum

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() {
Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -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)
Expand Down Expand Up @@ -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]
Expand All @@ -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)
Expand Down
6 changes: 6 additions & 0 deletions tsc/internal/checker/printer.go
Original file line number Diff line number Diff line change
Expand Up @@ -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)
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -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
};`,
})
}
Original file line number Diff line number Diff line change
Expand Up @@ -14,9 +14,12 @@ func TestQuickInfoForGenericPrototypeMember(t *testing.T) {
foo(x: T) { }
}
var x = new /*1*/C<any>();
var y = C.proto/*2*/type;`
var y = C.proto/*2*/type;
class D<out T extends string = "a"> {}
D.proto/*3*/type;`
f, done := fourslash.NewFourslash(t, nil /*capabilities*/, content)
defer done()
f.VerifyQuickInfoAt(t, "1", "constructor C<any>(): C<any>", "")
f.VerifyQuickInfoAt(t, "2", "(property) C<T>.prototype: C<any>", "")
f.VerifyQuickInfoAt(t, "3", `(property) D<out T extends string = "a">.prototype: D<any>`, "")
}
2 changes: 1 addition & 1 deletion tsc/internal/ls/codeactions_fixmissingtypeannotation.go
Original file line number Diff line number Diff line change
Expand Up @@ -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,
)
}

Expand Down
2 changes: 1 addition & 1 deletion tsc/internal/ls/inlay_hints.go
Original file line number Diff line number Diff line change
Expand Up @@ -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
}

Expand Down
Loading
Loading