Completions fourslash tests fixes (#1228)

Author: gabritto

internal/ast/ast.go

@@ -1768,6 +1768,7 @@ type (
 	JsxOpeningLikeElement       = Node // JsxOpeningElement | JsxSelfClosingElement
 	NamedImportsOrExports       = Node // NamedImports | NamedExports
 	BreakOrContinueStatement    = Node // BreakStatement | ContinueStatement
+	CallLikeExpression          = Node // CallExpression | NewExpression | TaggedTemplateExpression | Decorator | JsxCallLike | InstanceofExpression
 )
 
 // Aliases for node singletons

internal/ast/utilities.go

@@ -2738,10 +2738,6 @@ func IsRequireCall(node *Node, requireStringLiteralLikeArgument bool) bool {
 	return !requireStringLiteralLikeArgument || IsStringLiteralLike(call.Arguments.Nodes[0])
 }
 
-func IsUnterminatedLiteral(node *Node) bool {
-	return node.LiteralLikeData().TokenFlags&TokenFlagsUnterminated != 0
-}
-
 func GetJSXImplicitImportBase(compilerOptions *core.CompilerOptions, file *SourceFile) string {
 	jsxImportSourcePragma := GetPragmaFromSourceFile(file, "jsximportsource")
 	jsxRuntimePragma := GetPragmaFromSourceFile(file, "jsxruntime")
@@ -3587,8 +3583,9 @@ func compareNodePositions(n1, n2 *Node) int {
 	return n1.Pos() - n2.Pos()
 }
 
-func IsUnterminatedNode(node *Node) bool {
-	return IsLiteralKind(node.Kind) && IsUnterminatedLiteral(node)
+func IsUnterminatedLiteral(node *Node) bool {
+	return IsLiteralKind(node.Kind) && node.LiteralLikeData().TokenFlags&TokenFlagsUnterminated != 0 ||
+		IsTemplateLiteralKind(node.Kind) && node.TemplateLiteralLikeData().TemplateFlags&TokenFlagsUnterminated != 0
 }
 
 // Gets a value indicating whether a class element is either a static or an instance property declaration with an initializer.

internal/checker/exports.go

@@ -133,3 +133,12 @@ func (c *Checker) GetExpandedParameters(signature *Signature, skipUnionExpanding
 func (c *Checker) GetResolvedSignature(node *ast.Node) *Signature {
 	return c.getResolvedSignature(node, nil, CheckModeNormal)
 }
+
+// Return the type of the given property in the given type, or nil if no such property exists
+func (c *Checker) GetTypeOfPropertyOfType(t *Type, name string) *Type {
+	return c.getTypeOfPropertyOfType(t, name)
+}
+
+func (c *Checker) GetContextualTypeForArgumentAtIndex(node *ast.Node, argIndex int) *Type {
+	return c.getContextualTypeForArgumentAtIndex(node, argIndex)
+}

internal/checker/services.go

@@ -5,6 +5,7 @@ import (
 	"slices"
 
 	"github.com/microsoft/typescript-go/internal/ast"
+	"github.com/microsoft/typescript-go/internal/collections"
 	"github.com/microsoft/typescript-go/internal/core"
 	"github.com/microsoft/typescript-go/internal/printer"
 )
@@ -168,7 +169,7 @@ func (c *Checker) GetAllPossiblePropertiesOfTypes(types []*Type) []*ast.Symbol {
 		return c.getAugmentedPropertiesOfType(unionType)
 	}
 
-	props := createSymbolTable(nil)
+	props := make(ast.SymbolTable)
 	for _, memberType := range types {
 		augmentedProps := c.getAugmentedPropertiesOfType(memberType)
 		for _, p := range augmentedProps {
@@ -231,6 +232,9 @@ func (c *Checker) getAugmentedPropertiesOfType(t *Type) []*ast.Symbol {
 		functionType = c.globalNewableFunctionType
 	}
 
+	if propsByName == nil {
+		propsByName = make(ast.SymbolTable)
+	}
 	if functionType != nil {
 		for _, p := range c.getPropertiesOfType(functionType) {
 			if _, ok := propsByName[p.Name]; !ok {
@@ -579,3 +583,39 @@ func (c *Checker) getResolvedSignatureWorker(node *ast.Node, checkMode CheckMode
 	c.apparentArgumentCount = nil
 	return res, *candidatesOutArray
 }
+
+func (c *Checker) GetCandidateSignaturesForStringLiteralCompletions(call *ast.CallLikeExpression, editingArgument *ast.Node) []*Signature {
+	candidatesSet := collections.Set[*Signature]{}
+
+	// first, get candidates when inference is blocked from the source node.
+	candidates := runWithInferenceBlockedFromSourceNode(c, editingArgument, func() []*Signature {
+		_, blockedInferenceCandidates := c.getResolvedSignatureWorker(call, CheckModeNormal, 0)
+		return blockedInferenceCandidates
+	})
+	for _, candidate := range candidates {
+		candidatesSet.Add(candidate)
+	}
+
+	// next, get candidates where the source node is considered for inference.
+	candidates = runWithoutResolvedSignatureCaching(c, editingArgument, func() []*Signature {
+		_, inferenceCandidates := c.getResolvedSignatureWorker(call, CheckModeNormal, 0)
+		return inferenceCandidates
+	})
+
+	for _, candidate := range candidates {
+		candidatesSet.Add(candidate)
+	}
+
+	return slices.Collect(maps.Keys(candidatesSet.Keys()))
+}
+
+func (c *Checker) GetTypeParameterAtPosition(s *Signature, pos int) *Type {
+	t := c.getTypeAtPosition(s, pos)
+	if t.IsIndex() && isThisTypeParameter(t.AsIndexType().target) {
+		constraint := c.getBaseConstraintOfType(t.AsIndexType().target)
+		if constraint != nil {
+			return c.getIndexType(constraint)
+		}
+	}
+	return t
+}

internal/checker/types.go

@@ -734,6 +734,10 @@ func (t *Type) IsTypeParameter() bool {
 	return t.flags&TypeFlagsTypeParameter != 0
 }
 
+func (t *Type) IsIndex() bool {
+	return t.flags&TypeFlagsIndex != 0
+}
+
 // TypeData
 
 type TypeData interface {
@@ -1181,6 +1185,14 @@ func (s *Signature) ThisParameter() *ast.Symbol {
 	return s.thisParameter
 }
 
+func (s *Signature) Parameters() []*ast.Symbol {
+	return s.parameters
+}
+
+func (s *Signature) HasRestParameter() bool {
+	return s.flags&SignatureFlagsHasRestParameter != 0
+}
+
 type CompositeSignature struct {
 	isUnion    bool         // True for union, false for intersection
 	signatures []*Signature // Individual signatures

internal/fourslash/_scripts/convertFourslash.mts

@@ -337,6 +337,9 @@ function parseExpectedCompletionItem(expr: ts.Expression): string | undefined {
                         return undefined;
                     }
                     item += `SortText: ptrTo(string(${result})), `;
+                    if (result === "ls.SortTextOptionalMember") {
+                        isOptional = true;
+                    }
                     break;
                 case "insertText":
                     if (ts.isStringLiteral(init)) {
@@ -534,7 +537,7 @@ interface GoToMarkerCmd {
 
 type Cmd = VerifyCompletionsCmd | GoToMarkerCmd;
 
-function generateVerifyCompletions({ marker, args }: VerifyCompletionsCmd): string {
+function generateVerifyCompletions({ marker, args, isNewIdentifierLocation }: VerifyCompletionsCmd): string {
     let expectedList = "nil";
     if (args) {
         const expected = [];
@@ -543,10 +546,11 @@ function generateVerifyCompletions({ marker, args }: VerifyCompletionsCmd): stri
         if (args.exact) expected.push(`Exact: ${args.exact},`);
         // !!! isIncomplete
         // !!! itemDefaults/commitCharacters from `isNewIdentifierLocation`
+        const commitCharacters = isNewIdentifierLocation ? "[]string{}" : "defaultCommitCharacters";
         expectedList = `&fourslash.VerifyCompletionsExpectedList{
     IsIncomplete: false,
     ItemDefaults: &lsproto.CompletionItemDefaults{
-        CommitCharacters: &defaultCommitCharacters,
+        CommitCharacters: &${commitCharacters},
     },
     Items: &fourslash.VerifyCompletionsExpectedItems{
         ${expected.join("\n")}