Signature help implementation

internal/ast/utilities.go

@@ -334,6 +334,18 @@ func IsStringOrNumericLiteralLike(node *Node) bool {
 	return IsStringLiteralLike(node) || IsNumericLiteral(node)
 }
 
+func IsStringTextContainingNode(node *Node) bool {
+	return node.Kind == KindStringLiteral || IsTemplateLiteralKind(node.Kind)
+}
+
+func IsTemplateLiteralKind(kind Kind) bool {
+	return KindFirstTemplateToken <= kind && kind <= KindLastTemplateToken
+}
+
+func IsTemplateLiteralToken(node *Node) bool {
+	return IsTemplateLiteralKind(node.Kind)
+}
+
 func IsSignedNumericLiteral(node *Node) bool {
 	if node.Kind == KindPrefixUnaryExpression {
 		node := node.AsPrefixUnaryExpression()
@@ -2952,3 +2964,13 @@ func GetPropertyNameForPropertyNameNode(name *Node) string {
 	}
 	panic("Unhandled case in getPropertyNameForPropertyNameNode")
 }
+
+// !!!
+func HasQuestionToken(node *Node) bool {
+	switch node.Kind {
+	case KindParameter, KindMethodDeclaration, KindMethodSignature, KindShorthandPropertyAssignment,
+		KindPropertyAssignment, KindPropertyDeclaration, KindPropertySignature:
+		return node.AsParameterDeclaration().QuestionToken != nil
+	}
+	return false
+}

internal/checker/checker.go

@@ -25962,16 +25962,23 @@ func (c *Checker) markPropertyAsReferenced(prop *ast.Symbol, nodeForCheckWriteOn
 	c.symbolReferenceLinks.Get(target).referenceKinds |= ast.SymbolFlagsAll
 }
 
-func (c *Checker) GetExpandedParameters(signature *Signature /* !!! skipUnionExpanding */) []*ast.Symbol {
+func (c *Checker) getExpandedParameters(signature *Signature, skipUnionExpanding *bool) [][]*ast.Symbol {
 	if signatureHasRestParameter(signature) {
 		restIndex := len(signature.parameters) - 1
 		restSymbol := signature.parameters[restIndex]
 		restType := c.getTypeOfSymbol(restSymbol)
 		if isTupleType(restType) {
-			return c.expandSignatureParametersWithTupleMembers(signature, restType.AsTypeReference(), restIndex, restSymbol)
+			return [][]*ast.Symbol{c.expandSignatureParametersWithTupleMembers(signature, restType.AsTypeReference(), restIndex, restSymbol)}
+		} else if skipUnionExpanding != nil && !*skipUnionExpanding && restType.flags&TypeFlagsUnion != 0 && core.Every(restType.AsUnionType().Types(), isTupleType) {
+			result := [][]*ast.Symbol{}
+			for _, t := range restType.AsUnionType().Types() {
+				result = append(result, c.expandSignatureParametersWithTupleMembers(signature, t.AsTypeReference(), restIndex, restSymbol))
+			}
+			return result
 		}
+
 	}
-	return signature.parameters
+	return [][]*ast.Symbol{signature.parameters}
 }
 
 func (c *Checker) expandSignatureParametersWithTupleMembers(signature *Signature, restType *TypeReference, restIndex int, restSymbol *ast.Symbol) []*ast.Symbol {
@@ -29422,7 +29429,7 @@ func (c *Checker) GetSymbolAtLocation(node *ast.Node) *ast.Symbol {
 // be used only by the language service and external tools. The semantics of the function are deliberately "fuzzy"
 // and aim to just return *some* symbol for the node. To obtain the symbol associated with a node for type checking
 // purposes, use appropriate function for the context, e.g. `getResolvedSymbol` for an expression identifier,
-// `getSymbolOfDeclaration` for a declaration, etc.
+// `GetSymbolOfDeclaration` for a declaration, etc.
 func (c *Checker) getSymbolAtLocation(node *ast.Node, ignoreErrors bool) *ast.Symbol {
 	if ast.IsSourceFile(node) {
 		if ast.IsExternalOrCommonJSModule(node.AsSourceFile()) {
@@ -29761,7 +29768,7 @@ func (c *Checker) getTypeOfNode(node *ast.Node) *Type {
 	}
 
 	if isTypeDeclaration(node) {
-		// In this case, we call getSymbolOfDeclaration instead of getSymbolAtLocation because it is a declaration
+		// In this case, we call GetSymbolOfDeclaration instead of getSymbolAtLocation because it is a declaration
 		symbol := c.getSymbolOfDeclaration(node)
 		return c.getDeclaredTypeOfSymbol(symbol)
 	}
@@ -29783,7 +29790,7 @@ func (c *Checker) getTypeOfNode(node *ast.Node) *Type {
 	}
 
 	if ast.IsDeclaration(node) {
-		// In this case, we call getSymbolOfDeclaration instead of getSymbolLAtocation because it is a declaration
+		// In this case, we call GetSymbolOfDeclaration instead of getSymbolLAtocation because it is a declaration
 		symbol := c.getSymbolOfDeclaration(node)
 		if symbol != nil {
 			return c.getTypeOfSymbol(symbol)

internal/checker/exports.go

@@ -52,3 +52,59 @@ func GetDeclarationModifierFlagsFromSymbol(s *ast.Symbol) ast.ModifierFlags {
 func (c *Checker) WasCanceled() bool {
 	return c.wasCanceled
 }
+
+func (c *Checker) GetSignaturesOfType(t *Type, kind SignatureKind) []*Signature {
+	return c.getSignaturesOfType(t, kind)
+}
+
+func (c *Checker) GetTypePredicateOfSignature(sig *Signature) *TypePredicate {
+	return c.getTypePredicateOfSignature(sig)
+}
+
+func IsTupleType(t *Type) bool {
+	return isTupleType(t)
+}
+
+func (c *Checker) GetReturnTypeOfSignature(sig *Signature) *Type {
+	return c.getReturnTypeOfSignature(sig)
+}
+
+func IsCallOrNewExpression(node *ast.Node) bool {
+	return isCallOrNewExpression(node)
+}
+
+func GetInvokedExpression(node *ast.Node) *ast.Node {
+	return getInvokedExpression(node)
+}
+
+func IsJsxOpeningLikeElement(node *ast.Node) bool {
+	return isJsxOpeningLikeElement(node)
+}
+
+func (c *Checker) HasEffectiveRestParameter(signature *Signature) bool {
+	return c.hasEffectiveRestParameter(signature)
+}
+
+func CanHaveSymbol(node *ast.Node) bool {
+	return canHaveSymbol(node)
+}
+
+func (c *Checker) GetLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol *ast.Symbol) []*Type {
+	return c.getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol)
+}
+
+func (c *Checker) GetContextualTypeForObjectLiteralElement(element *ast.Node, contextFlags ContextFlags) *Type {
+	return c.getContextualTypeForObjectLiteralElement(element, contextFlags)
+}
+
+func (c *Checker) TypePredicateToString(t *TypePredicate) string {
+	return c.typePredicateToString(t)
+}
+
+func (c *Checker) GetExpandedParameters(signature *Signature, skipUnionExpanding *bool) [][]*ast.Symbol {
+	return c.getExpandedParameters(signature, skipUnionExpanding)
+}
+
+func IndexOfNode(nodes []*ast.Node, node *ast.Node) int {
+	return indexOfNode(nodes, node)
+}

internal/checker/inference.go

@@ -1235,7 +1235,7 @@ func (c *Checker) inferFromIntraExpressionSites(n *InferenceContext) {
 		if ast.IsMethodDeclaration(site.node) {
 			contextualType = c.getContextualTypeForObjectLiteralMethod(site.node, ContextFlagsNoConstraints)
 		} else {
-			contextualType = c.getContextualType(site.node, ContextFlagsNoConstraints)
+			contextualType = c.GetContextualType(site.node, ContextFlagsNoConstraints)
 		}
 		if contextualType != nil {
 			c.inferTypes(n.inferences, site.t, contextualType, InferencePriorityNone, false)

internal/checker/printer.go

@@ -585,7 +585,8 @@ func (p *Printer) printSignature(sig *Signature, returnSeparator string) {
 		p.printType(p.c.getTypeOfSymbol(sig.thisParameter))
 		tail = true
 	}
-	expandedParameters := p.c.GetExpandedParameters(sig)
+	skipUnionExpanding := true
+	expandedParameters := p.c.getExpandedParameters(sig, &skipUnionExpanding)[0]
 	// If the expanded parameter list had a variadic in a non-trailing position, don't expand it
 	parameters := core.IfElse(core.Some(expandedParameters, func(s *ast.Symbol) bool {
 		return s != expandedParameters[len(expandedParameters)-1] && s.CheckFlags&ast.CheckFlagsRestParameter != 0

internal/checker/services.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/microsoft/typescript-go/internal/ast"
 	"github.com/microsoft/typescript-go/internal/core"
+	"github.com/microsoft/typescript-go/internal/printer"
 )
 
 func (c *Checker) GetSymbolsInScope(location *ast.Node, meaning ast.SymbolFlags) []*ast.Symbol {
@@ -481,3 +482,50 @@ func (c *Checker) GetJsxIntrinsicTagNamesAt(location *ast.Node) []*ast.Symbol {
 func (c *Checker) GetContextualTypeForJsxAttribute(attribute *ast.JsxAttributeLike) *Type {
 	return c.getContextualTypeForJsxAttribute(attribute, ContextFlagsNone)
 }
+
+func (c *Checker) runWithoutResolvedSignatureCaching(node *ast.Node, fn func() *Signature) *Signature {
+	ancestorNode := ast.FindAncestor(node, func(n *ast.Node) bool {
+		return ast.IsCallLikeOrFunctionLikeExpression(n)
+	})
+	if ancestorNode != nil {
+		cachedResolvedSignatures := make(map[*SignatureLinks]*Signature)
+		cachedTypes := make(map[*ValueSymbolLinks]*Type)
+		for ancestorNode != nil {
+			signatureLinks := c.signatureLinks.Get(ancestorNode)
+			cachedResolvedSignatures[signatureLinks] = signatureLinks.resolvedSignature
+			signatureLinks.resolvedSignature = nil
+			if ast.IsFunctionExpressionOrArrowFunction(ancestorNode) {
+				symbolLinks := c.valueSymbolLinks.Get(c.getSymbolOfDeclaration(ancestorNode))
+				resolvedType := symbolLinks.resolvedType
+				cachedTypes[symbolLinks] = resolvedType
+				symbolLinks.resolvedType = nil
+			}
+			ancestorNode = ast.FindAncestor(ancestorNode.Parent, ast.IsCallLikeOrFunctionLikeExpression)
+		}
+		result := fn()
+		for signatureLinks, resolvedSignature := range cachedResolvedSignatures {
+			signatureLinks.resolvedSignature = resolvedSignature
+		}
+		for symbolLinks, resolvedType := range cachedTypes {
+			symbolLinks.resolvedType = resolvedType
+		}
+		return result
+	}
+	return fn()
+}
+
+func (c *Checker) getResolvedSignatureWorker(node *ast.Node, candidatesOutArray *[]*Signature, checkMode CheckMode, argumentCount int) *Signature {
+	parsedNode := printer.NewEmitContext().ParseNode(node)
+	c.apparentArgumentCount = &argumentCount
+	var res *Signature = nil
+	if parsedNode != nil {
+		res = c.getResolvedSignature(parsedNode, candidatesOutArray, checkMode)
+	}
+	return res
+}
+
+func (c *Checker) GetResolvedSignatureForSignatureHelp(node *ast.Node, candidatesOutArray *[]*Signature, argumentCount int) *Signature {
+	return c.runWithoutResolvedSignatureCaching(node, func() *Signature {
+		return c.getResolvedSignatureWorker(node, candidatesOutArray, CheckModeIsForSignatureHelp, argumentCount)
+	})
+}

internal/checker/types.go

@@ -546,6 +546,10 @@ func (t *Type) Flags() TypeFlags {
 	return t.flags
 }
 
+func (t *Type) ObjectFlags() ObjectFlags {
+	return t.objectFlags
+}
+
 // Casts for concrete struct types
 
 func (t *Type) AsIntrinsicType() *IntrinsicType             { return t.data.(*IntrinsicType) }
@@ -886,6 +890,8 @@ type TupleElementInfo struct {
 	labeledDeclaration *ast.Node // NamedTupleMember | ParameterDeclaration | nil
 }
 
+func (t *TupleElementInfo) TupleElementFlags() ElementFlags { return t.flags }
+
 type TupleType struct {
 	InterfaceType
 	elementInfos  []TupleElementInfo
@@ -895,6 +901,15 @@ type TupleType struct {
 	readonly      bool
 }
 
+func (t *TupleType) FixedLength() int { return t.fixedLength }
+func (t *TupleType) ElementFlags() []ElementFlags {
+	elementFlags := make([]ElementFlags, len(t.elementInfos))
+	for i, info := range t.elementInfos {
+		elementFlags[i] = info.flags
+	}
+	return elementFlags
+}
+
 // SingleSignatureType
 
 type SingleSignatureType struct {
@@ -1094,6 +1109,38 @@ type Signature struct {
 	composite                *CompositeSignature
 }
 
+func (s *Signature) TypeParameters() []*Type {
+	if len(s.typeParameters) == 0 {
+		return nil
+	}
+	return s.typeParameters
+}
+
+func (s *Signature) Declaration() *ast.Node {
+	return s.declaration
+}
+
+func (s *Signature) Parameters() []*ast.Symbol {
+	if len(s.parameters) == 0 {
+		return nil
+	}
+	return s.parameters
+}
+
+func (s *Signature) Target() *Signature {
+	if s.target == nil {
+		return nil
+	}
+	return s.target
+}
+
+func (s *Signature) ThisParameter() *ast.Symbol {
+	if s.thisParameter == nil {
+		return nil
+	}
+	return s.thisParameter
+}
+
 type CompositeSignature struct {
 	isUnion    bool         // True for union, false for intersection
 	signatures []*Signature // Individual signatures