Method getEffectsSignature

internal/checker/flow.go:2026–2067

(node *ast.Node)

}

func (c *Checker) getEffectsSignature(node *ast.Node) *Signature {
	links := c.signatureLinks.Get(node)
	signature := links.effectsSignature
	if signature == nil {
		// A call expression parented by an expression statement is a potential assertion. Other call
		// expressions are potential type predicate function calls. In order to avoid triggering
		// circularities in control flow analysis, we use getTypeOfDottedName when resolving the call
		// target expression of an assertion.
		var funcType *Type
		if ast.IsBinaryExpression(node) {
			rightType := c.checkNonNullExpression(node.AsBinaryExpression().Right)
			funcType = c.getSymbolHasInstanceMethodOfObjectType(rightType)
		} else if ast.IsExpressionStatement(node.Parent) {
			funcType = c.getTypeOfDottedName(node.Expression(), nil /*diagnostic*/)
		} else if node.Expression().Kind != ast.KindSuperKeyword {
			if ast.IsOptionalChain(node) {
				funcType = c.checkNonNullType(c.getOptionalExpressionType(c.checkExpression(node.Expression()), node.Expression()), node.Expression())
			} else {
				funcType = c.checkNonNullExpression(node.Expression())
			}
		}
		var apparentType *Type
		if funcType != nil {
			apparentType = c.getApparentType(funcType)
		}
		signatures := c.getSignaturesOfType(core.OrElse(apparentType, c.unknownType), SignatureKindCall)
		switch {
		case len(signatures) == 1 && len(signatures[0].typeParameters) == 0:
			signature = signatures[0]
		case core.Some(signatures, c.hasTypePredicateOrNeverReturnType):
			signature = c.getResolvedSignature(node, nil, CheckModeNormal)
		}
		if !(signature != nil && c.hasTypePredicateOrNeverReturnType(signature)) {
			signature = c.unknownSignature
		}
		links.effectsSignature = signature
	}
	if signature == c.unknownSignature {
		return nil
	}
	return signature
}

/**
 * Get the type of the `[Symbol.hasInstance]` method of an object type.