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()

internal/astnav/tokens.go

@@ -602,3 +602,13 @@ func getNodeVisitor(
 		},
 	})
 }
+
+// !!!
+func HasQuestionToken(node *ast.Node) bool {
+	switch node.Kind {
+	case ast.KindParameter, ast.KindMethodDeclaration, ast.KindMethodSignature, ast.KindShorthandPropertyAssignment,
+		ast.KindPropertyAssignment, ast.KindPropertyDeclaration, ast.KindPropertySignature:
+		return node.AsParameterDeclaration().QuestionToken != nil
+	}
+	return false
+}

internal/checker/flow.go

@@ -276,7 +276,7 @@ func (c *Checker) isEmptyArrayAssignment(node *ast.Node) bool {
 func (c *Checker) getTypeAtFlowCall(f *FlowState, flow *ast.FlowNode) FlowType {
 	signature := c.getEffectsSignature(flow.Node)
 	if signature != nil {
-		predicate := c.getTypePredicateOfSignature(signature)
+		predicate := c.GetTypePredicateOfSignature(signature)
 		if predicate != nil && (predicate.kind == TypePredicateKindAssertsThis || predicate.kind == TypePredicateKindAssertsIdentifier) {
 			flowType := c.getTypeAtFlowNode(f, flow.Antecedent)
 			t := c.finalizeEvolvingArrayType(flowType.t)
@@ -294,7 +294,7 @@ func (c *Checker) getTypeAtFlowCall(f *FlowState, flow *ast.FlowNode) FlowType {
 			}
 			return c.newFlowType(narrowedType, flowType.incomplete)
 		}
-		if c.getReturnTypeOfSignature(signature).flags&TypeFlagsNever != 0 {
+		if c.GetReturnTypeOfSignature(signature).flags&TypeFlagsNever != 0 {
 			return FlowType{t: c.unreachableNeverType}
 		}
 	}
@@ -435,7 +435,7 @@ func (c *Checker) narrowTypeByCallExpression(f *FlowState, t *Type, callExpressi
 		if assumeTrue || !isCallChain(callExpression) {
 			signature := c.getEffectsSignature(callExpression)
 			if signature != nil {
-				predicate = c.getTypePredicateOfSignature(signature)
+				predicate = c.GetTypePredicateOfSignature(signature)
 			}
 		}
 		if predicate != nil && (predicate.kind == TypePredicateKindThis || predicate.kind == TypePredicateKindIdentifier) {
@@ -801,7 +801,7 @@ func (c *Checker) narrowTypeByInstanceof(f *FlowState, t *Type, expr *ast.Binary
 	// participate in `instanceof`, as per Step 2 of https://tc39.es/ecma262/#sec-instanceofoperator.
 	var predicate *TypePredicate
 	if signature := c.getEffectsSignature(expr.AsNode()); signature != nil {
-		predicate = c.getTypePredicateOfSignature(signature)
+		predicate = c.GetTypePredicateOfSignature(signature)
 	}
 	if predicate != nil && predicate.kind == TypePredicateKindIdentifier && predicate.parameterIndex == 0 {
 		return c.getNarrowedType(t, predicate.t, assumeTrue, true /*checkDerived*/)
@@ -940,10 +940,10 @@ func (c *Checker) getInstanceType(constructorType *Type) *Type {
 	if prototypePropertyType != nil && !IsTypeAny(prototypePropertyType) {
 		return prototypePropertyType
 	}
-	constructSignatures := c.getSignaturesOfType(constructorType, SignatureKindConstruct)
+	constructSignatures := c.GetSignaturesOfType(constructorType, SignatureKindConstruct)
 	if len(constructSignatures) != 0 {
 		return c.getUnionType(core.Map(constructSignatures, func(signature *Signature) *Type {
-			return c.getReturnTypeOfSignature(c.getErasedSignature(signature))
+			return c.GetReturnTypeOfSignature(c.getErasedSignature(signature))
 		}))
 	}
 	// We use the empty object type to indicate we don't know the type of objects created by
@@ -2035,7 +2035,7 @@ func (c *Checker) getEffectsSignature(node *ast.Node) *Signature {
 		if funcType != nil {
 			apparentType = c.getApparentType(funcType)
 		}
-		signatures := c.getSignaturesOfType(core.OrElse(apparentType, c.unknownType), SignatureKindCall)
+		signatures := c.GetSignaturesOfType(core.OrElse(apparentType, c.unknownType), SignatureKindCall)
 		switch {
 		case len(signatures) == 1 && signatures[0].typeParameters == nil:
 			signature = signatures[0]
@@ -2062,7 +2062,7 @@ func (c *Checker) getSymbolHasInstanceMethodOfObjectType(t *Type) *Type {
 		hasInstanceProperty := c.getPropertyOfType(t, hasInstancePropertyName)
 		if hasInstanceProperty != nil {
 			hasInstancePropertyType := c.getTypeOfSymbol(hasInstanceProperty)
-			if hasInstancePropertyType != nil && len(c.getSignaturesOfType(hasInstancePropertyType, SignatureKindCall)) != 0 {
+			if hasInstancePropertyType != nil && len(c.GetSignaturesOfType(hasInstancePropertyType, SignatureKindCall)) != 0 {
 				return hasInstancePropertyType
 			}
 		}
@@ -2161,7 +2161,7 @@ func (c *Checker) isDeclarationWithExplicitTypeAnnotation(node *ast.Node) bool {
 }
 
 func (c *Checker) hasTypePredicateOrNeverReturnType(sig *Signature) bool {
-	return c.getTypePredicateOfSignature(sig) != nil || sig.declaration != nil && core.OrElse(c.getReturnTypeFromAnnotation(sig.declaration), c.unknownType).flags&TypeFlagsNever != 0
+	return c.GetTypePredicateOfSignature(sig) != nil || sig.declaration != nil && core.OrElse(c.getReturnTypeFromAnnotation(sig.declaration), c.unknownType).flags&TypeFlagsNever != 0
 }
 
 func (c *Checker) getExplicitThisType(node *ast.Node) *Type {
@@ -2486,14 +2486,14 @@ func (c *Checker) isReachableFlowNodeWorker(f *FlowState, flow *ast.FlowNode, no
 		case flags&ast.FlowFlagsCall != 0:
 			signature := c.getEffectsSignature(flow.Node)
 			if signature != nil {
-				predicate := c.getTypePredicateOfSignature(signature)
+				predicate := c.GetTypePredicateOfSignature(signature)
 				if predicate != nil && predicate.kind == TypePredicateKindAssertsIdentifier && predicate.t == nil {
 					predicateArgument := flow.Node.Arguments()[predicate.parameterIndex]
 					if predicateArgument != nil && c.isFalseExpression(predicateArgument) {
 						return false
 					}
 				}
-				if c.getReturnTypeOfSignature(signature).flags&TypeFlagsNever != 0 {
+				if c.GetReturnTypeOfSignature(signature).flags&TypeFlagsNever != 0 {
 					return false
 				}
 			}

internal/checker/inference.go

@@ -652,22 +652,22 @@ func (c *Checker) inferFromObjectTypes(n *InferenceState, source *Type, target *
 		return
 	}
 	if c.isArrayOrTupleType(source) {
-		if isTupleType(target) {
+		if IsTupleType(target) {
 			sourceArity := c.getTypeReferenceArity(source)
 			targetArity := c.getTypeReferenceArity(target)
 			elementTypes := c.getTypeArguments(target)
 			elementInfos := target.TargetTupleType().elementInfos
 			// When source and target are tuple types with the same structure (fixed, variadic, and rest are matched
 			// to the same kind in each position), simply infer between the element types.
-			if isTupleType(source) && c.isTupleTypeStructureMatching(source, target) {
+			if IsTupleType(source) && c.isTupleTypeStructureMatching(source, target) {
 				for i := range targetArity {
 					c.inferFromTypes(n, c.getTypeArguments(source)[i], elementTypes[i])
 				}
 				return
 			}
 			startLength := 0
 			endLength := 0
-			if isTupleType(source) {
+			if IsTupleType(source) {
 				startLength = min(source.TargetTupleType().fixedLength, target.TargetTupleType().fixedLength)
 				if target.TargetTupleType().combinedFlags&ElementFlagsVariable != 0 {
 					endLength = min(getEndElementCount(source.TargetTupleType(), ElementFlagsFixed), getEndElementCount(target.TargetTupleType(), ElementFlagsFixed))
@@ -677,7 +677,7 @@ func (c *Checker) inferFromObjectTypes(n *InferenceState, source *Type, target *
 			for i := range startLength {
 				c.inferFromTypes(n, c.getTypeArguments(source)[i], elementTypes[i])
 			}
-			if !isTupleType(source) || sourceArity-startLength-endLength == 1 && source.TargetTupleType().elementInfos[startLength].flags&ElementFlagsRest != 0 {
+			if !IsTupleType(source) || sourceArity-startLength-endLength == 1 && source.TargetTupleType().elementInfos[startLength].flags&ElementFlagsRest != 0 {
 				// Single rest element remains in source, infer from that to every element in target
 				restType := c.getTypeArguments(source)[startLength]
 				for i := startLength; i < targetArity-endLength; i++ {
@@ -703,7 +703,7 @@ func (c *Checker) inferFromObjectTypes(n *InferenceState, source *Type, target *
 						// if T is constrained by a fixed-size tuple we might be able to use its arity to infer T
 						if info := getInferenceInfoForType(n, elementTypes[startLength]); info != nil {
 							constraint := c.getBaseConstraintOfType(info.typeParameter)
-							if constraint != nil && isTupleType(constraint) && constraint.TargetTupleType().combinedFlags&ElementFlagsVariable == 0 {
+							if constraint != nil && IsTupleType(constraint) && constraint.TargetTupleType().combinedFlags&ElementFlagsVariable == 0 {
 								impliedArity := constraint.TargetTupleType().fixedLength
 								c.inferFromTypes(n, c.sliceTupleType(source, startLength, sourceArity-(startLength+impliedArity)), elementTypes[startLength])
 								c.inferFromTypes(n, c.getElementTypeOfSliceOfTupleType(source, startLength+impliedArity, endLength, false, false), elementTypes[startLength+1])
@@ -714,7 +714,7 @@ func (c *Checker) inferFromObjectTypes(n *InferenceState, source *Type, target *
 						// if T is constrained by a fixed-size tuple we might be able to use its arity to infer T
 						if info := getInferenceInfoForType(n, elementTypes[startLength+1]); info != nil {
 							constraint := c.getBaseConstraintOfType(info.typeParameter)
-							if constraint != nil && isTupleType(constraint) && constraint.TargetTupleType().combinedFlags&ElementFlagsVariable == 0 {
+							if constraint != nil && IsTupleType(constraint) && constraint.TargetTupleType().combinedFlags&ElementFlagsVariable == 0 {
 								impliedArity := constraint.TargetTupleType().fixedLength
 								endIndex := sourceArity - getEndElementCount(target.TargetTupleType(), ElementFlagsFixed)
 								startIndex := endIndex - impliedArity
@@ -766,12 +766,12 @@ func (c *Checker) inferFromProperties(n *InferenceState, source *Type, target *T
 }
 
 func (c *Checker) inferFromSignatures(n *InferenceState, source *Type, target *Type, kind SignatureKind) {
-	sourceSignatures := c.getSignaturesOfType(source, kind)
+	sourceSignatures := c.GetSignaturesOfType(source, kind)
 	sourceLen := len(sourceSignatures)
 	if sourceLen > 0 {
 		// We match source and target signatures from the bottom up, and if the source has fewer signatures
 		// than the target, we infer from the first source signature to the excess target signatures.
-		targetSignatures := c.getSignaturesOfType(target, kind)
+		targetSignatures := c.GetSignaturesOfType(target, kind)
 		targetLen := len(targetSignatures)
 		for i := range targetLen {
 			sourceIndex := max(sourceLen-targetLen+i, 0)
@@ -824,17 +824,17 @@ func (c *Checker) applyToParameterTypes(source *Signature, target *Signature, ca
 }
 
 func (c *Checker) applyToReturnTypes(source *Signature, target *Signature, callback func(s *Type, t *Type)) {
-	targetTypePredicate := c.getTypePredicateOfSignature(target)
+	targetTypePredicate := c.GetTypePredicateOfSignature(target)
 	if targetTypePredicate != nil {
-		sourceTypePredicate := c.getTypePredicateOfSignature(source)
+		sourceTypePredicate := c.GetTypePredicateOfSignature(source)
 		if sourceTypePredicate != nil && c.typePredicateKindsMatch(sourceTypePredicate, targetTypePredicate) && sourceTypePredicate.t != nil && targetTypePredicate.t != nil {
 			callback(sourceTypePredicate.t, targetTypePredicate.t)
 			return
 		}
 	}
-	targetReturnType := c.getReturnTypeOfSignature(target)
+	targetReturnType := c.GetReturnTypeOfSignature(target)
 	if c.couldContainTypeVariables(targetReturnType) {
-		callback(c.getReturnTypeOfSignature(source), targetReturnType)
+		callback(c.GetReturnTypeOfSignature(source), targetReturnType)
 	}
 }
 
@@ -956,7 +956,7 @@ func (c *Checker) createReverseMappedType(source *Type, target *Type, constraint
 		}
 		return c.createArrayTypeEx(elementType, c.isReadonlyArrayType(source))
 	}
-	if isTupleType(source) {
+	if IsTupleType(source) {
 		elementTypes := core.Map(c.getElementTypes(source), func(t *Type) *Type {
 			return c.inferReverseMappedType(t, target, constraint)
 		})
@@ -990,7 +990,7 @@ func (c *Checker) createReverseMappedType(source *Type, target *Type, constraint
 func (c *Checker) isPartiallyInferableType(t *Type) bool {
 	return t.objectFlags&ObjectFlagsNonInferrableType == 0 || isObjectLiteralType(t) && core.Some(c.getPropertiesOfType(t), func(prop *ast.Symbol) bool {
 		return c.isPartiallyInferableType(c.getTypeOfSymbol(prop))
-	}) || isTupleType(t) && core.Some(c.getElementTypes(t), c.isPartiallyInferableType)
+	}) || IsTupleType(t) && core.Some(c.getElementTypes(t), c.isPartiallyInferableType)
 }
 
 func (c *Checker) inferReverseMappedType(source *Type, target *Type, constraint *Type) *Type {
@@ -1115,7 +1115,7 @@ func (c *Checker) replaceIndexedAccess(instantiable *Type, t *Type, replacement
 func (c *Checker) typesDefinitelyUnrelated(source *Type, target *Type) bool {
 	// Two tuple types with incompatible arities are definitely unrelated.
 	// Two object types that each have a property that is unmatched in the other are definitely unrelated.
-	if isTupleType(source) && isTupleType(target) {
+	if IsTupleType(source) && IsTupleType(target) {
 		return tupleTypesDefinitelyUnrelated(source, target)
 	}
 	return c.getUnmatchedProperty(source, target, false /*requireOptionalProperties*/, true /*matchDiscriminantProperties*/) != nil &&
@@ -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)
@@ -1415,11 +1415,11 @@ func (c *Checker) isTypeParameterAtTopLevel(t *Type, tp *Type, depth int) bool {
 }
 
 func (c *Checker) isTypeParameterAtTopLevelInReturnType(signature *Signature, typeParameter *Type) bool {
-	typePredicate := c.getTypePredicateOfSignature(signature)
+	typePredicate := c.GetTypePredicateOfSignature(signature)
 	if typePredicate != nil {
 		return typePredicate.t != nil && c.isTypeParameterAtTopLevel(typePredicate.t, typeParameter, 0)
 	}
-	return c.isTypeParameterAtTopLevel(c.getReturnTypeOfSignature(signature), typeParameter, 0)
+	return c.isTypeParameterAtTopLevel(c.GetReturnTypeOfSignature(signature), typeParameter, 0)
 }
 
 func (c *Checker) getTypeFromInference(inference *InferenceInfo) *Type {
@@ -1523,7 +1523,7 @@ func (c *Checker) isSkipDirectInferenceNode(node *ast.Node) bool {
 
 // Returns `true` if `type` has the shape `[T[0]]` where `T` is `typeParameter`
 func (c *Checker) isTupleOfSelf(tp *Type, t *Type) bool {
-	return isTupleType(t) && c.getTupleElementType(t, 0) == c.getIndexedAccessType(tp, c.getNumberLiteralType(0)) && c.getTypeOfPropertyOfType(t, "1") == nil
+	return IsTupleType(t) && c.getTupleElementType(t, 0) == c.getIndexedAccessType(tp, c.getNumberLiteralType(0)) && c.getTypeOfPropertyOfType(t, "1") == nil
 }
 
 func newInferenceInfo(typeParameter *Type) *InferenceInfo {