Rework const context handling to defer psuedotype selection until checker data is ready, reducing literal expression diffs

Author: weswigham

internal/checker/nodebuilderimpl.go

@@ -2018,13 +2018,13 @@ func (b *nodeBuilderImpl) serializeTypeForDeclaration(declaration *ast.Declarati
 	// !!! expandable hover support
 	if tryReuse && declaration != nil && (ast.IsAccessor(declaration) || (ast.HasInferredType(declaration) && !ast.NodeIsSynthesized(declaration) && (t.ObjectFlags()&ObjectFlagsRequiresWidening) == 0)) {
 		remove := b.addSymbolTypeToContext(symbol, t)
+		var pt *psuedochecker.PsuedoType
 		if ast.IsAccessor(declaration) {
-			pt := b.pc.GetTypeOfAccessor(declaration)
-			result = b.psuedoTypeToNode(pt)
+			pt = b.pc.GetTypeOfAccessor(declaration)
 		} else {
-			pt := b.pc.GetTypeOfDeclaration(declaration)
-			result = b.psuedoTypeToNode(pt)
+			pt = b.pc.GetTypeOfDeclaration(declaration)
 		}
+		result = b.psuedoTypeToNode(pt)
 		remove()
 	}
 	if result == nil {

internal/checker/psuedotypenodebuilder.go

@@ -23,6 +23,23 @@ func (b *nodeBuilderImpl) psuedoTypeToNode(t *psuedochecker.PsuedoType) *ast.Nod
 		node := t.Data.(*psuedochecker.PsuedoTypeNoResult).Declaration
 		b.ctx.tracker.ReportInferenceFallback(node)
 		return b.serializeTypeForDeclaration(node, nil, nil, false)
+	case psuedochecker.PsuedoTypeKindMaybeConstLocation:
+		d := t.Data.(*psuedochecker.PsuedoTypeMaybeConstLocation)
+		// see checkExpressionWithContextualType for general literal widening rules which need to be emulated here, plus
+		// checkTemplateLiteralExpression for template literal widening rules if the psuedochecker ever supports literalized templates
+		isInConstContext := b.ch.isConstContext(d.Node)
+		if !isInConstContext {
+			contextualType := b.ch.getContextualType(d.Node, ContextFlagsNone)
+			t := b.psuedoTypeToType(d.ConstType)
+			if t != nil && b.ch.isLiteralOfContextualType(t, b.ch.instantiateContextualType(contextualType, d.Node, ContextFlagsNone)) {
+				isInConstContext = true
+			}
+		}
+		if isInConstContext {
+			return b.psuedoTypeToNode(d.ConstType)
+		} else {
+			return b.psuedoTypeToNode(d.RegularType)
+		}
 	case psuedochecker.PsuedoTypeKindUnion:
 		var res []*ast.Node
 		var hasElidedType bool
@@ -206,3 +223,72 @@ func (b *nodeBuilderImpl) psuedoParameterToNode(p *psuedochecker.PsuedoParameter
 		nil,
 	)
 }
+
+func (b *nodeBuilderImpl) psuedoTypeToType(t *psuedochecker.PsuedoType) *Type {
+	// !!! TODO: only literal types currently mapped because this is only used to determine if literal contextual typing need apply to the psuedotype
+	// If this is used more broadly, the implementation needs to be filled out more to handle the structural psuedotypes - signatures, objects, tuples, etc
+	debug.Assert(t != nil, "Attempted to realize nil psuedotype")
+	switch t.Kind {
+	case psuedochecker.PsuedoTypeKindDirect:
+		return b.ch.getTypeFromTypeNode(t.Data.(*psuedochecker.PsuedoTypeDirect).TypeNode)
+	case psuedochecker.PsuedoTypeKindInferred:
+		node := t.Data.(*psuedochecker.PsuedoTypeInferred).Expression
+		ty := b.ch.getTypeOfExpression(node)
+		return ty
+	case psuedochecker.PsuedoTypeKindNoResult:
+		return nil // TODO: extract type selection logic from `serializeTypeForDeclaration`, not needed for current usecases but needed if completeness becomes required
+	case psuedochecker.PsuedoTypeKindMaybeConstLocation:
+		d := t.Data.(*psuedochecker.PsuedoTypeMaybeConstLocation)
+		return b.psuedoTypeToType(d.ConstType) // !!! TODO: not needed for const-checking usecases, but proper context switching behavior required if completeness is required
+	case psuedochecker.PsuedoTypeKindUnion:
+		var res []*Type
+		var hasElidedType bool
+		members := t.Data.(*psuedochecker.PsuedoTypeUnion).Types
+		for _, m := range members {
+			if !b.ch.strictNullChecks {
+				if m.Kind == psuedochecker.PsuedoTypeKindUndefined || m.Kind == psuedochecker.PsuedoTypeKindNull {
+					hasElidedType = true
+					continue
+				}
+			}
+			t := b.psuedoTypeToType(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.newUnionType(ObjectFlagsNone, res)
+	case psuedochecker.PsuedoTypeKindUndefined:
+		return b.ch.undefinedWideningType
+	case psuedochecker.PsuedoTypeKindNull:
+		return b.ch.nullWideningType
+	case psuedochecker.PsuedoTypeKindAny:
+		return b.ch.anyType
+	case psuedochecker.PsuedoTypeKindString:
+		return b.ch.stringType
+	case psuedochecker.PsuedoTypeKindNumber:
+		return b.ch.numberType
+	case psuedochecker.PsuedoTypeKindBigInt:
+		return b.ch.bigintType
+	case psuedochecker.PsuedoTypeKindBoolean:
+		return b.ch.booleanType
+	case psuedochecker.PsuedoTypeKindFalse:
+		return b.ch.falseType
+	case psuedochecker.PsuedoTypeKindTrue:
+		return b.ch.trueType
+	case psuedochecker.PsuedoTypeKindStringLiteral, psuedochecker.PsuedoTypeKindNumericLiteral, psuedochecker.PsuedoTypeKindBigIntLiteral:
+		source := t.Data.(*psuedochecker.PsuedoTypeLiteral).Node
+		return b.ch.getTypeOfExpression(source) // big shortcut, uses cached expression types where possible
+	default:
+		return nil
+	}
+}

internal/psuedochecker/lookup.go

@@ -267,40 +267,20 @@ func (ch *PsuedoChecker) typeFromExpression(node *ast.Node) *PsuedoType {
 	case ast.KindClassExpression:
 		return NewPsuedoTypeInferred(node) // No possible annotation/directly mappable syntax
 	case ast.KindTemplateExpression:
-		if ch.isInConstContext(node) {
-			return NewPsuedoTypeInferred(node) // templateLitWithHoles as const, not supported
-		}
-		return PsuedoTypeString
+		// templateLitWithHoles as const, not supported
+		return NewPsuedoTypeMaybeConstLocation(node, NewPsuedoTypeInferred(node), PsuedoTypeString)
 	case ast.KindNumericLiteral:
-		if ch.isInConstContext(node) {
-			return NewPsuedoTypeNumericLiteral(node)
-		}
-		return PsuedoTypeNumber
+		return NewPsuedoTypeMaybeConstLocation(node, NewPsuedoTypeNumericLiteral(node), PsuedoTypeNumber)
 	case ast.KindNoSubstitutionTemplateLiteral:
-		if ch.isInConstContext(node) {
-			return NewPsuedoTypeStringLiteral(node)
-		}
-		return PsuedoTypeString
+		return NewPsuedoTypeMaybeConstLocation(node, NewPsuedoTypeStringLiteral(node), PsuedoTypeString)
 	case ast.KindStringLiteral:
-		if ch.isInConstContext(node) {
-			return NewPsuedoTypeStringLiteral(node)
-		}
-		return PsuedoTypeString
+		return NewPsuedoTypeMaybeConstLocation(node, NewPsuedoTypeStringLiteral(node), PsuedoTypeString)
 	case ast.KindBigIntLiteral:
-		if ch.isInConstContext(node) {
-			return NewPsuedoTypeBigIntLiteral(node)
-		}
-		return PsuedoTypeBigInt
+		return NewPsuedoTypeMaybeConstLocation(node, NewPsuedoTypeBigIntLiteral(node), PsuedoTypeBigInt)
 	case ast.KindTrueKeyword:
-		if ch.isInConstContext(node) {
-			return PsuedoTypeTrue
-		}
-		return PsuedoTypeBoolean
+		return NewPsuedoTypeMaybeConstLocation(node, PsuedoTypeTrue, PsuedoTypeBoolean)
 	case ast.KindFalseKeyword:
-		if ch.isInConstContext(node) {
-			return PsuedoTypeFalse
-		}
-		return PsuedoTypeBoolean
+		return NewPsuedoTypeMaybeConstLocation(node, PsuedoTypeFalse, PsuedoTypeBoolean)
 	}
 	return NewPsuedoTypeInferred(node)
 }
@@ -462,16 +442,10 @@ func (ch *PsuedoChecker) isInConstContext(node *ast.Node) bool {
 func (ch *PsuedoChecker) typeFromPrimitiveLiteralPrefix(node *ast.PrefixUnaryExpression) *PsuedoType {
 	inner := node.Operand
 	if inner.Kind == ast.KindBigIntLiteral {
-		if ch.isInConstContext(node.AsNode()) {
-			return NewPsuedoTypeBigIntLiteral(node.AsNode())
-		}
-		return PsuedoTypeBigInt
+		return NewPsuedoTypeMaybeConstLocation(node.AsNode(), NewPsuedoTypeBigIntLiteral(node.AsNode()), PsuedoTypeBigInt)
 	}
 	if inner.Kind == ast.KindNumericLiteral {
-		if ch.isInConstContext(node.AsNode()) {
-			return NewPsuedoTypeNumericLiteral(node.AsNode())
-		}
-		return PsuedoTypeNumber
+		return NewPsuedoTypeMaybeConstLocation(node.AsNode(), NewPsuedoTypeNumericLiteral(node.AsNode()), PsuedoTypeNumber)
 	}
 	debug.FailBadSyntaxKind(inner)
 	return nil

internal/psuedochecker/type.go

@@ -22,6 +22,7 @@ const (
 	PsuedoTypeKindDirect PsuedoTypeKind = iota
 	PsuedoTypeKindInferred
 	PsuedoTypeKindNoResult
+	PsuedoTypeKindMaybeConstLocation
 	PsuedoTypeKindUnion
 	PsuedoTypeKindUndefined
 	PsuedoTypeKindNull
@@ -112,6 +113,27 @@ func NewPsuedoTypeNoResult(decl *ast.Node) *PsuedoType {
 	return NewPsuedoType(PsuedoTypeKindNoResult, &PsuedoTypeNoResult{Declaration: decl})
 }
 
+// PsuedoTypeMaybeConstLocation encodes the const/regular types of a location so the builder
+// can later select the appropriate psuedotype based on the location's context. This is used
+// to ensure accuracy in nested expressions without exposing type-based functionality to the psuedochecker.
+// A nodebuilder that doesn't do contextual typing would need to, as policy, reject these types if they
+// are in a contextually typed position! (Otherwise they could pick one, but either type could be wrong, depending on context!)
+// At the top-level, which is generally what ID is concerned with, nothing is contextually typed, so these cases don't generally
+// cause problems. Once you get into reused nodes in nested expressions, however, this becomes important.
+// In strada, checker `isConstContext` functionality exposed to the psuedochecker + type comparison sanity checking
+// on nested results masks the need for this abstraction, but with it present it clearly highlights a shortcoming
+// of the ID infernce model and how "standalone" it can(n't) truly be without substantial restrictions on expression inference.
+type PsuedoTypeMaybeConstLocation struct {
+	PsuedoTypeBase
+	Node        *ast.Node
+	ConstType   *PsuedoType
+	RegularType *PsuedoType
+}
+
+func NewPsuedoTypeMaybeConstLocation(loc *ast.Node, ct *PsuedoType, reg *PsuedoType) *PsuedoType {
+	return NewPsuedoType(PsuedoTypeKindMaybeConstLocation, &PsuedoTypeMaybeConstLocation{Node: loc, ConstType: ct, RegularType: reg})
+}
+
 // PsuedoTypeUnion is a collection of psudotypes joined into a union
 type PsuedoTypeUnion struct {
 	PsuedoTypeBase