mirror of
https://github.com/hanzoai/tsgo.git
synced 2026-10-30 19:37:15 +00:00
766 lines
29 KiB
Go
766 lines
29 KiB
Go
package checker
|
|
|
|
import (
|
|
"github.com/microsoft/typescript-go/internal/ast"
|
|
"github.com/microsoft/typescript-go/internal/debug"
|
|
"github.com/microsoft/typescript-go/internal/nodebuilder"
|
|
"github.com/microsoft/typescript-go/internal/printer"
|
|
"github.com/microsoft/typescript-go/internal/pseudochecker"
|
|
)
|
|
|
|
// pseudoTypeToNodeWithCheckerFallback is like pseudoTypeToNode but when the top-level pseudo type
|
|
// is PseudoTypeInferred, it reports any error nodes and then serializes from the checker's type.
|
|
// This avoids incorrect type output when PseudoTypeInferred would derive the type from the
|
|
// original declaration expression in an instantiated context.
|
|
func (b *NodeBuilderImpl) pseudoTypeToNodeWithCheckerFallback(t *pseudochecker.PseudoType, checkerType *Type) *ast.Node {
|
|
if t.Kind == pseudochecker.PseudoTypeKindInferred {
|
|
if !b.ctx.suppressReportInferenceFallback {
|
|
if errorNodes := t.AsPseudoTypeInferred().ErrorNodes; len(errorNodes) > 0 {
|
|
for _, n := range errorNodes {
|
|
b.ctx.tracker.ReportInferenceFallback(n)
|
|
}
|
|
} else {
|
|
b.ctx.tracker.ReportInferenceFallback(t.AsPseudoTypeInferred().Expression)
|
|
}
|
|
}
|
|
oldSuppress := b.ctx.suppressReportInferenceFallback
|
|
b.ctx.suppressReportInferenceFallback = true
|
|
result := b.typeToTypeNode(checkerType)
|
|
b.ctx.suppressReportInferenceFallback = oldSuppress
|
|
return result
|
|
} else if t.Kind == pseudochecker.PseudoTypeKindDirect {
|
|
existing := t.AsPseudoTypeDirect().TypeNode
|
|
if !b.canReuseExistingJSTypeNode(existing, checkerType) {
|
|
if !b.ctx.suppressReportInferenceFallback {
|
|
b.ctx.tracker.ReportInferenceFallback(existing)
|
|
}
|
|
oldSuppress := b.ctx.suppressReportInferenceFallback
|
|
b.ctx.suppressReportInferenceFallback = true
|
|
result := b.typeToTypeNode(checkerType)
|
|
b.ctx.suppressReportInferenceFallback = oldSuppress
|
|
return result
|
|
}
|
|
}
|
|
return b.pseudoTypeToNode(t)
|
|
}
|
|
|
|
// Maps a pseudochecker's pseudotypes into ast nodes and reports any inference fallback errors the pseudotype structure implies
|
|
func (b *NodeBuilderImpl) pseudoTypeToNode(t *pseudochecker.PseudoType) *ast.Node {
|
|
debug.Assert(t != nil, "Attempted to serialize nil pseudotype")
|
|
switch t.Kind {
|
|
case pseudochecker.PseudoTypeKindDirect:
|
|
return b.reuseTypeNode(t.AsPseudoTypeDirect().TypeNode)
|
|
case pseudochecker.PseudoTypeKindInferred:
|
|
inferred := t.AsPseudoTypeInferred()
|
|
node := inferred.Expression
|
|
if errorNodes := inferred.ErrorNodes; len(errorNodes) > 0 {
|
|
for _, n := range errorNodes {
|
|
b.ctx.tracker.ReportInferenceFallback(n)
|
|
}
|
|
} else if ast.IsEntityNameExpression(node) && ast.IsDeclaration(node.Parent) {
|
|
b.ctx.tracker.ReportInferenceFallback(node.Parent)
|
|
} else {
|
|
b.ctx.tracker.ReportInferenceFallback(node)
|
|
}
|
|
if inferred.IsSignatureReturn {
|
|
return b.serializeReturnTypeForSignature(b.ch.getSignatureFromDeclaration(node), false)
|
|
}
|
|
// use symbol type from parent declaration to automatically handle expression type widening without duplicating logic
|
|
if ast.IsReturnStatement(node.Parent) {
|
|
enclosing := ast.GetContainingFunction(node)
|
|
if ast.IsAccessor(enclosing) {
|
|
return b.serializeTypeForDeclaration(enclosing, nil, nil, false)
|
|
}
|
|
return b.serializeReturnTypeForSignature(b.ch.getSignatureFromDeclaration(enclosing), false)
|
|
}
|
|
if ast.IsArrowFunction(node.Parent) && node.Parent.AsArrowFunction().Body == node {
|
|
return b.serializeReturnTypeForSignature(b.ch.getSignatureFromDeclaration(node.Parent), false)
|
|
}
|
|
if ast.IsDeclaration(node.Parent) {
|
|
return b.serializeTypeForDeclaration(node.Parent, nil, nil, false)
|
|
}
|
|
// This might be effectively unreachable. If it's not, it may need more widening rules to mirror checker behavior for whatever expressions are serialized here
|
|
ty := b.ch.getTypeOfExpression(node)
|
|
return b.typeToTypeNode(ty)
|
|
case pseudochecker.PseudoTypeKindNoResult:
|
|
node := t.AsPseudoTypeNoResult().Declaration
|
|
b.ctx.tracker.ReportInferenceFallback(node)
|
|
if ast.IsFunctionLike(node) && !ast.IsAccessor(node) {
|
|
return b.serializeReturnTypeForSignature(b.ch.getSignatureFromDeclaration(node), false)
|
|
}
|
|
return b.serializeTypeForDeclaration(node, nil, nil, false)
|
|
case pseudochecker.PseudoTypeKindMaybeConstLocation:
|
|
d := t.AsPseudoTypeMaybeConstLocation()
|
|
// see checkExpressionWithContextualType for general literal widening rules which need to be emulated here, plus
|
|
// checkTemplateLiteralExpression for template literal widening rules if the pseudochecker ever supports literalized templates
|
|
isInConstContext := b.ch.isConstContext(d.Node)
|
|
if !isInConstContext && pseudochecker.IsInConstContext(d.Node) {
|
|
// Only consult the contextual type if the pseudochecker's syntactic check also puts us in a const context.
|
|
// getContextualType returns post-inference results at node-printing time which may not have existed
|
|
// during initial checking (e.g. when the contextual type depends on inference), causing incorrect
|
|
// literal type preservation.
|
|
contextualType := b.ch.getContextualType(d.Node, ContextFlagsNone)
|
|
t := b.pseudoTypeToType(d.ConstType)
|
|
if t != nil && b.ch.isLiteralOfContextualType(t, b.ch.instantiateContextualType(contextualType, d.Node, ContextFlagsNone)) {
|
|
isInConstContext = true
|
|
}
|
|
}
|
|
if isInConstContext {
|
|
return b.pseudoTypeToNode(d.ConstType)
|
|
} else {
|
|
return b.pseudoTypeToNode(d.RegularType)
|
|
}
|
|
case pseudochecker.PseudoTypeKindUnion:
|
|
var res []*ast.Node
|
|
var hasElidedType bool
|
|
var hasUndefined bool
|
|
members := t.AsPseudoTypeUnion().Types
|
|
var appendTypeNode func(node *ast.Node)
|
|
appendTypeNode = func(node *ast.Node) {
|
|
if ast.IsUnionTypeNode(node) {
|
|
for _, node := range node.AsUnionTypeNode().Types.Nodes {
|
|
appendTypeNode(node)
|
|
}
|
|
return
|
|
}
|
|
if node.Kind == ast.KindUndefinedKeyword {
|
|
if hasUndefined {
|
|
return
|
|
}
|
|
hasUndefined = true
|
|
}
|
|
res = append(res, node)
|
|
}
|
|
for _, m := range members {
|
|
if !b.ch.strictNullChecks {
|
|
if m.Kind == pseudochecker.PseudoTypeKindUndefined || m.Kind == pseudochecker.PseudoTypeKindNull {
|
|
hasElidedType = true
|
|
continue
|
|
}
|
|
}
|
|
appendTypeNode(b.pseudoTypeToNode(m))
|
|
}
|
|
if len(res) == 1 {
|
|
return res[0]
|
|
}
|
|
if len(res) == 0 {
|
|
if hasElidedType {
|
|
return b.f.NewKeywordTypeNode(ast.KindAnyKeyword)
|
|
}
|
|
return b.f.NewKeywordTypeNode(ast.KindNeverKeyword)
|
|
}
|
|
return b.f.NewUnionTypeNode(b.f.NewNodeList(res))
|
|
case pseudochecker.PseudoTypeKindUndefined:
|
|
if !b.ch.strictNullChecks {
|
|
return b.f.NewKeywordTypeNode(ast.KindAnyKeyword)
|
|
}
|
|
return b.f.NewKeywordTypeNode(ast.KindUndefinedKeyword)
|
|
case pseudochecker.PseudoTypeKindNull:
|
|
if !b.ch.strictNullChecks {
|
|
return b.f.NewKeywordTypeNode(ast.KindAnyKeyword)
|
|
}
|
|
return b.f.NewLiteralTypeNode(b.f.NewKeywordExpression(ast.KindNullKeyword))
|
|
case pseudochecker.PseudoTypeKindAny:
|
|
return b.f.NewKeywordTypeNode(ast.KindAnyKeyword)
|
|
case pseudochecker.PseudoTypeKindString:
|
|
return b.f.NewKeywordTypeNode(ast.KindStringKeyword)
|
|
case pseudochecker.PseudoTypeKindNumber:
|
|
return b.f.NewKeywordTypeNode(ast.KindNumberKeyword)
|
|
case pseudochecker.PseudoTypeKindBigInt:
|
|
return b.f.NewKeywordTypeNode(ast.KindBigIntKeyword)
|
|
case pseudochecker.PseudoTypeKindBoolean:
|
|
return b.f.NewKeywordTypeNode(ast.KindBooleanKeyword)
|
|
case pseudochecker.PseudoTypeKindFalse:
|
|
return b.f.NewLiteralTypeNode(b.f.NewKeywordExpression(ast.KindFalseKeyword))
|
|
case pseudochecker.PseudoTypeKindTrue:
|
|
return b.f.NewLiteralTypeNode(b.f.NewKeywordExpression(ast.KindTrueKeyword))
|
|
case pseudochecker.PseudoTypeKindSingleCallSignature:
|
|
d := t.AsPseudoTypeSingleCallSignature()
|
|
signature := b.ch.getSignatureFromDeclaration(d.Signature)
|
|
expandedParams := b.ch.getExpandedParameters(signature, true /*skipUnionExpanding*/)[0]
|
|
cleanup := b.enterNewScope(d.Signature, expandedParams, signature.typeParameters, signature.parameters, signature.mapper)
|
|
defer cleanup()
|
|
var typeParams *ast.NodeList
|
|
if len(d.TypeParameters) > 0 {
|
|
res := make([]*ast.Node, 0, len(d.TypeParameters))
|
|
for _, tp := range d.TypeParameters {
|
|
res = append(res, b.reuseNode(tp.AsNode()))
|
|
}
|
|
typeParams = b.f.NewNodeList(res)
|
|
}
|
|
params := b.pseudoParametersToNodeList(d.Parameters)
|
|
returnType := b.pseudoTypeToNode(d.ReturnType)
|
|
return b.f.NewFunctionTypeNode(typeParams, params, returnType)
|
|
case pseudochecker.PseudoTypeKindTuple:
|
|
var res []*ast.Node
|
|
elements := t.AsPseudoTypeTuple().Elements
|
|
for _, e := range elements {
|
|
res = append(res, b.pseudoTypeToNode(e))
|
|
}
|
|
// pseudo-tuples are implicitly `readonly` since they originate from `as const` contexts
|
|
// but strada *sometimes* fails to add the `readonly` modifier to the generated node.
|
|
result := b.f.NewTupleTypeNode(b.f.NewNodeList(res))
|
|
b.e.AddEmitFlags(result, printer.EFSingleLine)
|
|
return b.f.NewTypeOperatorNode(ast.KindReadonlyKeyword, result)
|
|
case pseudochecker.PseudoTypeKindObjectLiteral:
|
|
elements := t.AsPseudoTypeObjectLiteral().Elements
|
|
if len(elements) == 0 {
|
|
result := b.f.NewTypeLiteralNode(b.f.NewNodeList(nil))
|
|
b.e.AddEmitFlags(result, printer.EFSingleLine)
|
|
return result
|
|
}
|
|
// NOTE: using the checker's `isConstContext` instead of the pseudochecker's `isInConstContext`
|
|
// results in different results here. The checker one is more "correct" but means we'll mark
|
|
// objects in parameter positions contextually typed by const type parameters as readonly -
|
|
// something a true syntactic ID emitter couldn't possibly know (since the signature could
|
|
// be from across files). This can't *really* happen in any cases ID doesn't already error on, though.
|
|
// Just something to keep in mind if the ID checker keeps growing.
|
|
isConst := b.ch.isConstContext(elements[0].Name.Parent.Parent)
|
|
newElements := make([]*ast.Node, 0, len(elements))
|
|
|
|
// Member types are serialized within an object type literal, so set the
|
|
// corresponding flag to mirror createTypeNodeFromObjectType. This ensures
|
|
// inaccessible `this` references inside the members are reported (TS2527).
|
|
restoreObjectLiteralFlags := b.saveRestoreFlags()
|
|
b.ctx.flags |= nodebuilder.FlagsInObjectTypeLiteral
|
|
|
|
for _, e := range elements {
|
|
var modifiers *ast.ModifierList
|
|
if isConst || (e.Kind == pseudochecker.PseudoObjectElementKindPropertyAssignment && e.AsPseudoPropertyAssignment().Readonly) {
|
|
modifiers = b.f.NewModifierList([]*ast.Node{b.f.NewModifier(ast.KindReadonlyKeyword)})
|
|
}
|
|
var cleanup func()
|
|
if e.Kind != pseudochecker.PseudoObjectElementKindPropertyAssignment {
|
|
signature := b.ch.getSignatureFromDeclaration(e.Signature())
|
|
expandedParams := b.ch.getExpandedParameters(signature, true /*skipUnionExpanding*/)[0]
|
|
cleanup = b.enterNewScope(e.Signature(), expandedParams, signature.typeParameters, signature.parameters, signature.mapper)
|
|
}
|
|
var newProp *ast.Node
|
|
switch e.Kind {
|
|
case pseudochecker.PseudoObjectElementKindMethod:
|
|
d := e.AsPseudoObjectMethod()
|
|
var typeParams *ast.NodeList
|
|
if len(d.TypeParameters) > 0 {
|
|
res := make([]*ast.Node, 0, len(d.TypeParameters))
|
|
for _, tp := range d.TypeParameters {
|
|
res = append(res, b.reuseNode(tp.AsNode()))
|
|
}
|
|
typeParams = b.f.NewNodeList(res)
|
|
}
|
|
if isConst {
|
|
newProp = b.f.NewPropertySignatureDeclaration(
|
|
modifiers,
|
|
b.reuseName(e.Name, false /*isMethod*/),
|
|
nil,
|
|
b.f.NewFunctionTypeNode(
|
|
typeParams,
|
|
b.pseudoParametersToNodeList(d.Parameters),
|
|
b.pseudoTypeToNode(d.ReturnType),
|
|
),
|
|
nil,
|
|
)
|
|
break
|
|
}
|
|
newProp = b.f.NewMethodSignatureDeclaration(
|
|
modifiers,
|
|
b.reuseName(e.Name, true /*isMethod*/),
|
|
nil,
|
|
typeParams,
|
|
b.pseudoParametersToNodeList(d.Parameters),
|
|
b.pseudoTypeToNode(d.ReturnType),
|
|
)
|
|
case pseudochecker.PseudoObjectElementKindPropertyAssignment:
|
|
d := e.AsPseudoPropertyAssignment()
|
|
newProp = b.f.NewPropertySignatureDeclaration(
|
|
modifiers,
|
|
b.reuseName(e.Name, false /*isMethod*/),
|
|
nil,
|
|
b.pseudoTypeToNode(d.Type),
|
|
nil,
|
|
)
|
|
case pseudochecker.PseudoObjectElementKindSetAccessor:
|
|
d := e.AsPseudoSetAccessor()
|
|
newProp = b.f.NewSetAccessorDeclaration(
|
|
nil,
|
|
b.reuseName(e.Name, false /*isMethod*/),
|
|
nil,
|
|
b.f.NewNodeList([]*ast.Node{b.pseudoParameterToNode(d.Parameter)}),
|
|
nil,
|
|
nil,
|
|
nil,
|
|
)
|
|
case pseudochecker.PseudoObjectElementKindGetAccessor:
|
|
d := e.AsPseudoGetAccessor()
|
|
newProp = b.f.NewGetAccessorDeclaration(
|
|
nil,
|
|
b.reuseName(e.Name, false /*isMethod*/),
|
|
nil,
|
|
nil,
|
|
b.pseudoTypeToNode(d.Type),
|
|
nil,
|
|
nil,
|
|
)
|
|
}
|
|
if b.ctx.enclosingFile == ast.GetSourceFileOfNode(e.Name) {
|
|
b.e.SetCommentRange(newProp, e.Name.Parent.Loc)
|
|
}
|
|
newElements = append(newElements, newProp)
|
|
if cleanup != nil {
|
|
cleanup()
|
|
}
|
|
}
|
|
restoreObjectLiteralFlags()
|
|
result := b.f.NewTypeLiteralNode(b.f.NewNodeList(newElements))
|
|
if b.ctx.flags&nodebuilder.FlagsMultilineObjectLiterals == 0 {
|
|
b.e.AddEmitFlags(result, printer.EFSingleLine)
|
|
}
|
|
return result
|
|
case pseudochecker.PseudoTypeKindStringLiteral, pseudochecker.PseudoTypeKindNumericLiteral, pseudochecker.PseudoTypeKindBigIntLiteral:
|
|
source := t.AsPseudoTypeLiteral().Node
|
|
return b.f.NewLiteralTypeNode(b.reuseNode(source))
|
|
default:
|
|
debug.AssertNever(t.Kind, "Unhandled pseudotype kind in pseudotype node construction")
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func (b *NodeBuilderImpl) pseudoParametersToNodeList(params []*pseudochecker.PseudoParameter) *ast.NodeList {
|
|
res := make([]*ast.Node, 0, len(params))
|
|
for _, p := range params {
|
|
res = append(res, b.pseudoParameterToNode(p))
|
|
}
|
|
return b.f.NewNodeList(res)
|
|
}
|
|
|
|
func (b *NodeBuilderImpl) pseudoParameterToNode(p *pseudochecker.PseudoParameter) *ast.Node {
|
|
var dotDotDot *ast.Node
|
|
var questionMark *ast.Node
|
|
if p.Rest {
|
|
dotDotDot = b.f.NewToken(ast.KindDotDotDotToken)
|
|
}
|
|
if p.Optional {
|
|
questionMark = b.f.NewToken(ast.KindQuestionToken)
|
|
}
|
|
parameter := b.f.NewParameterDeclaration(
|
|
nil,
|
|
dotDotDot,
|
|
// matches strada behavior of always reserializing param names from scratch
|
|
b.parameterToParameterDeclarationName(p.Name.Parent.Symbol(), p.Name.Parent),
|
|
questionMark,
|
|
b.pseudoTypeToNode(p.Type),
|
|
nil,
|
|
)
|
|
if original := p.Name.Parent; ast.IsParameterDeclaration(original) {
|
|
b.setCommentRange(parameter, original)
|
|
}
|
|
return parameter
|
|
}
|
|
|
|
// see `typeNodeIsEquivalentToType` in strada, but applied more broadly here, so is setup to handle more equivalences - strada only used it via
|
|
// the `canReuseTypeNodeAnnotation` host hook and not the `canReuseTypeNode` hook, which meant locations using the later were reliant on
|
|
// over-invalidation by the ID inference engine to not emit incorrect types.
|
|
func (b *NodeBuilderImpl) pseudoTypeEquivalentToType(t *pseudochecker.PseudoType, type_ *Type, isOptionalAnnotated bool, reportErrors bool) bool {
|
|
// if type_ resolves to an error, we charitably assume equality, since we might be in a single-file checking mode
|
|
if type_ != nil && b.ch.isErrorType(type_) {
|
|
return true
|
|
}
|
|
// If we can easily operate on just types, we should
|
|
typeFromPseudo := b.pseudoTypeToType(t) // note: cannot convert complex types like objects, which must be validated separately
|
|
if typeFromPseudo == type_ {
|
|
return true
|
|
}
|
|
undefinedStripped := type_
|
|
if isOptionalAnnotated {
|
|
undefinedStripped = b.ch.getTypeWithFacts(type_, TypeFactsNEUndefined)
|
|
}
|
|
if typeFromPseudo != nil && type_ != nil {
|
|
if isOptionalAnnotated {
|
|
if undefinedStripped == typeFromPseudo {
|
|
return true
|
|
}
|
|
if typeFromPseudo.flags&TypeFlagsUnion != 0 && undefinedStripped.flags&TypeFlagsUnion != 0 {
|
|
// does union comparison in general, since the unions may not be `==` identical due to aliasing and the like
|
|
if b.ch.compareTypesIdentical(typeFromPseudo, undefinedStripped) == TernaryTrue {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
// handles freshness mismatches (e.g., fresh true vs regular true in as const)
|
|
if b.ch.getRegularTypeOfLiteralType(typeFromPseudo) == b.ch.getRegularTypeOfLiteralType(type_) {
|
|
return true
|
|
}
|
|
if typeFromPseudo.flags&TypeFlagsUnion != 0 && type_.flags&TypeFlagsUnion != 0 {
|
|
// handles union comparison in general, since unions may not be `==` identical due to aliasing
|
|
if b.ch.compareTypesIdentical(typeFromPseudo, type_) == TernaryTrue {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
// otherwise, fallback to actual pseudo/type cross-comparisons
|
|
switch t.Kind {
|
|
case pseudochecker.PseudoTypeKindInferred:
|
|
// PseudoTypeInferred with error nodes identifies specific problematic children.
|
|
// Report fine-grained errors on them, then return false so the parent falls back
|
|
// to checker-based serialization (avoiding issues like reusing raw JSON string
|
|
// literal property names from the pseudochecker's AST).
|
|
if errorNodes := t.AsPseudoTypeInferred().ErrorNodes; len(errorNodes) > 0 {
|
|
if reportErrors {
|
|
for _, n := range errorNodes {
|
|
b.ctx.tracker.ReportInferenceFallback(n)
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
if reportErrors {
|
|
b.ctx.tracker.ReportInferenceFallback(t.AsPseudoTypeInferred().Expression)
|
|
}
|
|
return false
|
|
case pseudochecker.PseudoTypeKindObjectLiteral:
|
|
pt := t.AsPseudoTypeObjectLiteral()
|
|
if type_ == nil {
|
|
return false
|
|
}
|
|
targetProps := b.ch.getPropertiesOfType(undefinedStripped)
|
|
// Count total declarations across all target prop symbols to handle getter/setter pairs,
|
|
// which are two elements in pt.Elements but only one symbol in targetProps.
|
|
targetDeclCount := 0
|
|
for _, prop := range targetProps {
|
|
targetDeclCount += len(prop.Declarations)
|
|
}
|
|
if len(pt.Elements) != targetDeclCount {
|
|
return false
|
|
}
|
|
for _, e := range pt.Elements {
|
|
var targetProp *ast.Symbol
|
|
elemSymbol := e.Name.Parent.Symbol()
|
|
if elemSymbol != nil {
|
|
targetProp = b.ch.getPropertyOfType(undefinedStripped, elemSymbol.Name)
|
|
}
|
|
if targetProp == nil {
|
|
// Name lookup failed or returned no result; search target properties
|
|
// for one whose declaration name node matches the one we have
|
|
for _, prop := range targetProps {
|
|
if prop.ValueDeclaration != nil && prop.ValueDeclaration.Name() == e.Name {
|
|
targetProp = prop
|
|
break
|
|
}
|
|
}
|
|
if targetProp == nil {
|
|
if reportErrors {
|
|
b.ctx.tracker.ReportInferenceFallback(e.Name.Parent)
|
|
}
|
|
return false
|
|
}
|
|
}
|
|
targetIsOptional := targetProp.Flags&ast.SymbolFlagsOptional != 0
|
|
if e.Optional != targetIsOptional {
|
|
if reportErrors {
|
|
b.ctx.tracker.ReportInferenceFallback(e.Name.Parent)
|
|
}
|
|
return false
|
|
}
|
|
propType := b.ch.getTypeOfSymbol(targetProp)
|
|
propType = b.ch.removeMissingType(propType, targetIsOptional)
|
|
switch e.Kind {
|
|
case pseudochecker.PseudoObjectElementKindPropertyAssignment:
|
|
d := e.AsPseudoPropertyAssignment()
|
|
if !b.pseudoTypeEquivalentToType(d.Type, propType, e.Optional, false) {
|
|
if reportErrors {
|
|
if d.Type.Kind == pseudochecker.PseudoTypeKindInferred && len(d.Type.AsPseudoTypeInferred().ErrorNodes) > 0 {
|
|
// Re-report the fine-grained error nodes; the recursive call used reportErrors=false
|
|
for _, n := range d.Type.AsPseudoTypeInferred().ErrorNodes {
|
|
b.ctx.tracker.ReportInferenceFallback(n)
|
|
}
|
|
} else if !isStructuralPseudoType(d.Type) {
|
|
b.ctx.tracker.ReportInferenceFallback(e.Name.Parent)
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
case pseudochecker.PseudoObjectElementKindMethod:
|
|
d := e.AsPseudoObjectMethod()
|
|
targetSig := b.ch.getSingleCallSignature(propType)
|
|
if targetSig == nil {
|
|
// Target property type doesn't have a single call signature; can't validate
|
|
continue
|
|
}
|
|
paramEq := b.pseudoParametersEquivalentToParameters(d.Parameters, targetSig, reportErrors, e.Name.Parent)
|
|
if !paramEq {
|
|
return false
|
|
}
|
|
targetPredicate := b.ch.getTypePredicateOfSignature(targetSig)
|
|
if targetPredicate != nil {
|
|
if !b.pseudoReturnTypeMatchesPredicate(d.ReturnType, targetPredicate) {
|
|
if reportErrors {
|
|
b.ctx.tracker.ReportInferenceFallback(e.Name.Parent)
|
|
}
|
|
return false
|
|
}
|
|
} else if !b.pseudoTypeEquivalentToType(d.ReturnType, b.ch.getReturnTypeOfSignature(targetSig), false, false) {
|
|
if reportErrors {
|
|
b.ctx.tracker.ReportInferenceFallback(e.Name.Parent)
|
|
}
|
|
return false
|
|
}
|
|
case pseudochecker.PseudoObjectElementKindGetAccessor:
|
|
d := e.AsPseudoGetAccessor()
|
|
if !b.pseudoTypeEquivalentToType(d.Type, propType, false, false) {
|
|
if reportErrors {
|
|
b.ctx.tracker.ReportInferenceFallback(e.Name.Parent)
|
|
}
|
|
return false
|
|
}
|
|
case pseudochecker.PseudoObjectElementKindSetAccessor:
|
|
d := e.AsPseudoSetAccessor()
|
|
writeType := b.ch.getWriteTypeOfSymbol(targetProp)
|
|
if !b.pseudoTypeEquivalentToType(d.Parameter.Type, writeType, false, false) {
|
|
if reportErrors {
|
|
b.ctx.tracker.ReportInferenceFallback(e.Name.Parent)
|
|
}
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
return true
|
|
case pseudochecker.PseudoTypeKindTuple:
|
|
pt := t.AsPseudoTypeTuple()
|
|
if undefinedStripped == nil || !isTupleType(undefinedStripped) {
|
|
return false
|
|
}
|
|
tupleTarget := undefinedStripped.TargetTupleType()
|
|
// Pseudo-tuples come from `as const` array literals, so they only ever have required elements.
|
|
// If the target tuple has optional, rest, or variadic elements, the structures can't match.
|
|
if tupleTarget.combinedFlags&ElementFlagsNonRequired != 0 {
|
|
return false
|
|
}
|
|
elementTypes := b.ch.getTypeArguments(undefinedStripped)
|
|
if len(pt.Elements) != len(elementTypes) {
|
|
return false
|
|
}
|
|
for i, elem := range pt.Elements {
|
|
if !b.pseudoTypeEquivalentToType(elem, elementTypes[i], false, reportErrors) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
case pseudochecker.PseudoTypeKindSingleCallSignature:
|
|
targetSig := b.ch.getSingleCallSignature(undefinedStripped)
|
|
if targetSig == nil {
|
|
return false
|
|
}
|
|
pt := t.AsPseudoTypeSingleCallSignature()
|
|
if len(targetSig.typeParameters) != len(pt.TypeParameters) {
|
|
if reportErrors {
|
|
b.ctx.tracker.ReportInferenceFallback(pt.Signature)
|
|
}
|
|
return false
|
|
}
|
|
paramEq := b.pseudoParametersEquivalentToParameters(pt.Parameters, targetSig, reportErrors, pt.Signature)
|
|
if !paramEq {
|
|
return false
|
|
}
|
|
targetPredicate := b.ch.getTypePredicateOfSignature(targetSig)
|
|
if targetPredicate != nil {
|
|
if !b.pseudoReturnTypeMatchesPredicate(pt.ReturnType, targetPredicate) {
|
|
if reportErrors {
|
|
b.ctx.tracker.ReportInferenceFallback(pt.Signature)
|
|
}
|
|
return false
|
|
}
|
|
} else if !b.pseudoTypeEquivalentToType(pt.ReturnType, b.ch.getReturnTypeOfSignature(targetSig), false, reportErrors) {
|
|
// error reported within the return type
|
|
return false
|
|
}
|
|
return true
|
|
case pseudochecker.PseudoTypeKindNoResult:
|
|
if reportErrors {
|
|
b.ctx.tracker.ReportInferenceFallback(t.AsPseudoTypeNoResult().Declaration)
|
|
}
|
|
return false
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func (b *NodeBuilderImpl) pseudoParametersEquivalentToParameters(params []*pseudochecker.PseudoParameter, targetSig *Signature, reportErrors bool, nonParamErrorLocation *ast.Node) bool {
|
|
if targetSig.thisParameter != nil && len(params) == 0 {
|
|
if reportErrors {
|
|
b.ctx.tracker.ReportInferenceFallback(nonParamErrorLocation) // missing `this` param
|
|
}
|
|
return false
|
|
} else if targetSig.thisParameter != nil && ast.IsThisIdentifier(params[0].Name) {
|
|
targetParam := targetSig.thisParameter
|
|
paramType := b.ch.getTypeOfParameter(targetParam)
|
|
if !b.pseudoTypeEquivalentToType(params[0].Type, paramType, params[0].Optional, false) {
|
|
if reportErrors {
|
|
b.ctx.tracker.ReportInferenceFallback(params[0].Name.Parent)
|
|
}
|
|
return false
|
|
}
|
|
params = params[1:]
|
|
} else if targetSig.thisParameter != nil {
|
|
if reportErrors {
|
|
b.ctx.tracker.ReportInferenceFallback(nonParamErrorLocation)
|
|
}
|
|
return false
|
|
}
|
|
if len(targetSig.parameters) != len(params) {
|
|
if reportErrors {
|
|
b.ctx.tracker.ReportInferenceFallback(nonParamErrorLocation)
|
|
}
|
|
return false // TODO: spread tuple params may mess with this check
|
|
}
|
|
for i, p := range params {
|
|
targetParam := targetSig.parameters[i]
|
|
if p.Optional != b.ch.isOptionalParameter(targetParam.ValueDeclaration) {
|
|
if reportErrors {
|
|
b.ctx.tracker.ReportInferenceFallback(p.Name.Parent)
|
|
}
|
|
return false
|
|
}
|
|
paramType := b.ch.getTypeOfParameter(targetParam)
|
|
if !b.pseudoTypeEquivalentToType(p.Type, paramType, p.Optional, false) {
|
|
if reportErrors {
|
|
b.ctx.tracker.ReportInferenceFallback(p.Name.Parent)
|
|
}
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func isStructuralPseudoType(t *pseudochecker.PseudoType) bool {
|
|
switch t.Kind {
|
|
case pseudochecker.PseudoTypeKindObjectLiteral, pseudochecker.PseudoTypeKindTuple, pseudochecker.PseudoTypeKindSingleCallSignature:
|
|
return true
|
|
case pseudochecker.PseudoTypeKindMaybeConstLocation:
|
|
d := t.AsPseudoTypeMaybeConstLocation()
|
|
return isStructuralPseudoType(d.ConstType) || isStructuralPseudoType(d.RegularType)
|
|
}
|
|
return false
|
|
}
|
|
|
|
// pseudoReturnTypeMatchesPredicate checks if a pseudo return type (which should be a Direct type
|
|
// wrapping a TypePredicate) matches the given type predicate from the checker.
|
|
func (b *NodeBuilderImpl) pseudoReturnTypeMatchesPredicate(rt *pseudochecker.PseudoType, predicate *TypePredicate) bool {
|
|
if rt.Kind != pseudochecker.PseudoTypeKindDirect {
|
|
return false
|
|
}
|
|
node := rt.AsPseudoTypeDirect().TypeNode
|
|
if !ast.IsTypePredicateNode(node) {
|
|
return false
|
|
}
|
|
tp := node.AsTypePredicateNode()
|
|
// Check asserts modifier matches
|
|
isAsserts := tp.AssertsModifier != nil
|
|
predicateIsAsserts := predicate.kind == TypePredicateKindAssertsThis || predicate.kind == TypePredicateKindAssertsIdentifier
|
|
if isAsserts != predicateIsAsserts {
|
|
return false
|
|
}
|
|
// Check this vs identifier matches
|
|
isThis := ast.IsThisTypeNode(tp.ParameterName)
|
|
predicateIsThis := predicate.kind == TypePredicateKindThis || predicate.kind == TypePredicateKindAssertsThis
|
|
if isThis != predicateIsThis {
|
|
return false
|
|
}
|
|
// For identifier predicates, check parameter name matches
|
|
if !isThis {
|
|
if tp.ParameterName.Text() != predicate.parameterName {
|
|
return false
|
|
}
|
|
}
|
|
// Check the narrowed type, if any
|
|
if predicate.t != nil {
|
|
if tp.Type == nil {
|
|
return false
|
|
}
|
|
predicateTypeFromNode := b.ch.getTypeFromTypeNode(tp.Type)
|
|
if predicateTypeFromNode != predicate.t {
|
|
if b.ch.compareTypesIdentical(predicateTypeFromNode, predicate.t) != TernaryTrue {
|
|
return false
|
|
}
|
|
}
|
|
} else if tp.Type != nil {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (b *NodeBuilderImpl) pseudoTypeToType(t *pseudochecker.PseudoType) *Type {
|
|
// !!! TODO: only literal types currently mapped because this is only used to determine if literal contextual typing need apply to the pseudotype
|
|
// If this is used more broadly, the implementation needs to be filled out more to handle the structural pseudotypes - signatures, objects, tuples, etc
|
|
debug.Assert(t != nil, "Attempted to realize nil pseudotype")
|
|
switch t.Kind {
|
|
case pseudochecker.PseudoTypeKindDirect:
|
|
return b.ch.getTypeFromTypeNode(t.AsPseudoTypeDirect().TypeNode)
|
|
case pseudochecker.PseudoTypeKindInferred:
|
|
node := t.AsPseudoTypeInferred().Expression
|
|
if t.AsPseudoTypeInferred().IsSignatureReturn {
|
|
return b.ch.getReturnTypeOfSignature(b.ch.getSignatureFromDeclaration(node))
|
|
}
|
|
ty := b.ch.getWidenedType(b.ch.getRegularTypeOfExpression(node))
|
|
return ty
|
|
case pseudochecker.PseudoTypeKindNoResult:
|
|
return nil // TODO: extract type selection logic from `serializeTypeForDeclaration`, not needed for current usecases but needed if completeness becomes required
|
|
case pseudochecker.PseudoTypeKindMaybeConstLocation:
|
|
d := t.AsPseudoTypeMaybeConstLocation()
|
|
if b.ch.isConstContext(d.Node) {
|
|
return b.pseudoTypeToType(d.ConstType)
|
|
}
|
|
return b.pseudoTypeToType(d.RegularType)
|
|
case pseudochecker.PseudoTypeKindUnion:
|
|
var res []*Type
|
|
var hasElidedType bool
|
|
members := t.AsPseudoTypeUnion().Types
|
|
for _, m := range members {
|
|
if !b.ch.strictNullChecks {
|
|
if m.Kind == pseudochecker.PseudoTypeKindUndefined || m.Kind == pseudochecker.PseudoTypeKindNull {
|
|
hasElidedType = true
|
|
continue
|
|
}
|
|
}
|
|
t := b.pseudoTypeToType(m)
|
|
if t == nil {
|
|
return nil // propagate failure
|
|
}
|
|
res = append(res, t)
|
|
}
|
|
if len(res) == 1 {
|
|
return res[0]
|
|
}
|
|
if len(res) == 0 {
|
|
if hasElidedType {
|
|
return b.ch.anyType
|
|
}
|
|
return b.ch.neverType
|
|
}
|
|
return b.ch.getUnionType(res)
|
|
case pseudochecker.PseudoTypeKindUndefined:
|
|
return b.ch.undefinedWideningType
|
|
case pseudochecker.PseudoTypeKindNull:
|
|
return b.ch.nullWideningType
|
|
case pseudochecker.PseudoTypeKindAny:
|
|
return b.ch.anyType
|
|
case pseudochecker.PseudoTypeKindString:
|
|
return b.ch.stringType
|
|
case pseudochecker.PseudoTypeKindNumber:
|
|
return b.ch.numberType
|
|
case pseudochecker.PseudoTypeKindBigInt:
|
|
return b.ch.bigintType
|
|
case pseudochecker.PseudoTypeKindBoolean:
|
|
return b.ch.booleanType
|
|
case pseudochecker.PseudoTypeKindFalse:
|
|
return b.ch.falseType
|
|
case pseudochecker.PseudoTypeKindTrue:
|
|
return b.ch.trueType
|
|
case pseudochecker.PseudoTypeKindStringLiteral, pseudochecker.PseudoTypeKindNumericLiteral, pseudochecker.PseudoTypeKindBigIntLiteral:
|
|
source := t.AsPseudoTypeLiteral().Node
|
|
return b.ch.getRegularTypeOfExpression(source) // big shortcut, uses cached expression types where possible
|
|
case pseudochecker.PseudoTypeKindObjectLiteral, pseudochecker.PseudoTypeKindSingleCallSignature, pseudochecker.PseudoTypeKindTuple:
|
|
return nil // no simple mapping to a type, since these are structural types
|
|
default:
|
|
debug.Fail("Unhandled pseudochecker.PseudoTypeKind in pseudoTypeToType")
|
|
return nil
|
|
}
|
|
}
|