Keep results a cycle yield computes from scratch

When a query enters a cycle somewhere other than its program-order
entry, the cycle yields to its first member and recomputes it with the
resolutions below hidden. Two things made that recomputation differ
from computing the member first:

- The reverse mapping stacks, contextual types and inference contexts
  of the hidden resolutions stayed visible, so the recomputation saw
  contexts that a computation from scratch never has. A yield now hides
  them along with the resolutions and restores them when it ends.

- Results were kept as cycle participants only by comparing the
  outermost cycle head in progress against the resolution. A cycle
  headed below the yield, which the yield cannot observe, caused the
  yield root and the hidden re-entries of itself to be discarded, so
  the member was computed again and genuinely re-entered itself.

Each type resolution now tracks the lowest cycle head it observed, and
a result is kept when what it observed was entered from scratch: by
the outer resolution of itself, by the yield it is the root of, or by
the outermost measurement of variances.

(seen in circularScopeThunkReverseMapped)

Author: jakebailey

tsc/internal/checker/checker.go

@@ -708,6 +708,7 @@ type Checker struct {
 	circularityMark                             int                 // Length of discard log when the cycle in progress was detected
 	innerCycles                                 []innerCycle        // Cycles detected inside the one in progress; see extendCircularity
 	flowDepthFailures                           map[FlowLoopKey]int // Largest depth budget known to be too small for a flow walk from a node; see getTypeAtFlowNode
+	observedHead                                int32               // 1 + index in resolutions of the lowest head of a cycle observed by the innermost type resolution in progress, or 0
 	cycleParticipants                           []TypeResolution    // Computations that observed a cycle in progress
 	effectsMarkDepth                            int                 // 1 + resolution index of the innermost effects mark that may be discarded, or 0
 	varianceStack                               []VarianceStackEntry
@@ -20335,9 +20336,20 @@ type cycleYield struct {
 	savedResolutionStart int
 	savedVisibleStart    int
 	savedDepths          [3]depthLimit
+	savedReverseMapped   reverseMappedState
+	savedContextual      []ContextualInfo
+	savedInference       []InferenceContextInfo
+	floor                int
 	shadowed             []shadowedResolving
 }
 
+type reverseMappedState struct {
+	sourceStack    []*Type
+	targetStack    []*Type
+	expandingFlags ExpandingFlags
+	start          int32
+}
+
 type shadowedResolving struct {
 	key   memoKey
 	index int32
@@ -20521,7 +20533,15 @@ func (c *Checker) beginCycleYield(target TypeSystemEntity, propertyName TypeSyst
 		savedResolutionStart: c.resolutionStart,
 		savedVisibleStart:    c.visibleStart,
 		savedDepths:          [3]depthLimit{c.serializationLevel, c.inlineLevel, c.conditionalConstraintDepth},
+		savedReverseMapped:   reverseMappedState{c.reverseMappedSourceStack, c.reverseMappedTargetStack, c.reverseExpandingFlags, c.reverseMappedStart},
+		savedContextual:      c.contextualInfos,
+		savedInference:       c.inferenceContextInfos,
+		floor:                floor,
 	})
+	// The contexts the hidden resolutions entered are hidden too, so that the
+	// recomputation is from scratch.
+	c.reverseMappedSourceStack, c.reverseMappedTargetStack, c.reverseExpandingFlags, c.reverseMappedStart = nil, nil, 0, 0
+	c.contextualInfos, c.inferenceContextInfos = nil, nil
 	c.resolutionStart = n
 	c.visibleStart = n
 	c.serializationLevel, c.inlineLevel, c.conditionalConstraintDepth = depthLimit{}, depthLimit{}, depthLimit{}
@@ -20532,6 +20552,9 @@ func (c *Checker) endCycleYield() {
 	c.resolutionStart = y.savedResolutionStart
 	c.visibleStart = y.savedVisibleStart
 	c.serializationLevel, c.inlineLevel, c.conditionalConstraintDepth = y.savedDepths[0], y.savedDepths[1], y.savedDepths[2]
+	r := y.savedReverseMapped
+	c.reverseMappedSourceStack, c.reverseMappedTargetStack, c.reverseExpandingFlags, c.reverseMappedStart = r.sourceStack, r.targetStack, r.expandingFlags, r.start
+	c.contextualInfos, c.inferenceContextInfos = y.savedContextual, y.savedInference
 	for _, sh := range y.shadowed {
 		c.resolving.set(sh.key, sh.index)
 	}
@@ -20797,6 +20820,42 @@ func (c *Checker) markTypeResolutionCircular(start int) {
 	c.markCircular(start)
 }
 
+// keepsResultInCycle reports whether the type resolution at index n, which
+// observed the cycles whose lowest head is observed (see Checker.observedHead),
+// computes what it computes first from scratch although a cycle is in
+// progress, so that its result is kept as a participant of the cycle:
+//   - The resolution re-entered a hidden resolution of itself, which a
+//     computation from scratch of the outer one always does, and what it
+//     observed in progress was all entered by the outer one, so its result is
+//     what the outer one computes first from scratch.
+//   - The resolution is the one a cycle yield computes again from scratch,
+//     with everything below it hidden, and it observed nothing hidden.
+//   - The resolution is inside the outermost measurement of variances, which
+//     hides what is below it and is measured from the canonical entry of its
+//     circularity, so what it computes is the same whatever led to it, and it
+//     only observed its incomplete variances. Computing it first from scratch
+//     reaches the measurement and computes it again inside, the same way.
+func (c *Checker) keepsResultInCycle(n int, f *resolution, observed int32) bool {
+	r := &f.typeResolution
+	if r.outerSelf != 0 && observed != 0 && observed >= r.outerSelf && int(observed) <= n {
+		return true
+	}
+	if len(c.cycleYields) != 0 {
+		y := &c.cycleYields[len(c.cycleYields)-1]
+		if n >= y.floor && int(f.prevTypeResolution) <= y.floor && (observed == 0 || int(observed) > y.floor) {
+			return true
+		}
+	}
+	return c.observedOnlyOutermostMeasurement(n)
+}
+
+func minObservedHead(a int32, b int32) int32 {
+	if a == 0 || b != 0 && b < a {
+		return b
+	}
+	return a
+}
+
 // observedOnlyOutermostMeasurement reports whether the cycle in progress is
 // the one headed by the outermost measurement of variances, which the
 // resolution at index n is inside, and no other.
@@ -20855,21 +20914,9 @@ func (c *Checker) popTypeResolution() bool {
 	debug.Assert(c.typeResolutionTop == n+1, "resolutions left above a type resolution")
 	f := &c.resolutions[n]
 	result := f.typeResolution.result
-	if r := &f.typeResolution; r.outerSelf != 0 && result && c.circularityStart != 0 && c.circularityStart <= n && c.circularityStart >= int(r.outerSelf) && !r.participant {
-		// The resolution re-entered a hidden resolution of itself, which a
-		// computation from scratch of the outer one always does, and what it
-		// observed in progress was all entered by the outer one, so its result
-		// is what the outer one computes first from scratch: the outer one
-		// keeps it, as must the cycle.
-		r.participant = true
-		c.cycleParticipants = append(c.cycleParticipants, *r)
-	} else if r := &f.typeResolution; result && !r.participant && c.observedOnlyOutermostMeasurement(n) {
-		// The outermost measurement of variances hides what is below it and
-		// is measured from the canonical entry of its circularity, so what
-		// it computes is the same whatever led to it. This resolution only
-		// observed its incomplete variances, so its result is what it
-		// computes first from scratch too, which reaches the measurement and
-		// computes it again inside, as main keeps the first result set.
+	observed := c.observedHead
+	c.observedHead = minObservedHead(f.prevObservedHead, observed)
+	if r := &f.typeResolution; result && !r.participant && c.circularityStart != 0 && c.keepsResultInCycle(n, f, observed) {
 		r.participant = true
 		c.cycleParticipants = append(c.cycleParticipants, *r)
 	}
@@ -20901,6 +20948,8 @@ func (c *Checker) beginTypeResolution(target TypeSystemEntity, propertyName Type
 	f.prevMemo = int32(c.memoTop)
 	f.isTypeResolution = true
 	f.prevTypeResolution = int32(c.typeResolutionTop)
+	f.prevObservedHead = c.observedHead
+	c.observedHead = 0
 	f.typeResolution.target = target
 	f.typeResolution.propertyName = propertyName
 	f.typeResolution.result = true

tsc/internal/checker/memo.go

@@ -1984,6 +1984,7 @@ func (c *Checker) discardCycle(mark int, retain bool) {
 // is incomplete is discarded when it finishes, as for the outermost, rather
 // than read by the rest of the outer cycle.
 func (c *Checker) extendCircularity(head int) {
+	c.observedHead = minObservedHead(c.observedHead, int32(head))
 	if c.checking && c.memoTop != 0 {
 		c.recordFromCheck()
 	}

tsc/internal/checker/resolutions.go

@@ -51,6 +51,7 @@ type resolution struct {
 	typeResolution     TypeResolution
 	isTypeResolution   bool
 	prevTypeResolution int32 // Checker.typeResolutionTop on entry
+	prevObservedHead   int32 // Checker.observedHead on entry
 	// Checker.searchableTop on entry, for a type resolution other than that
 	// of a current node.
 	prevSearchable int32

tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).errors.txt

@@ -82,7 +82,11 @@ export const $ = scope({
 
     b: () => $.type("a").pipe(function (n) { return n === 0; }),
 >b : Symbol(b, Decl(circularScopeThunkReverseMapped.ts, 12, 62))
+>$.type("a").pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19))
+>$.type : Symbol(Scope.type, Decl(circularScopeThunkReverseMapped.ts, 2, 22))
 >$ : Symbol($, Decl(circularScopeThunkReverseMapped.ts, 11, 12))
+>type : Symbol(Scope.type, Decl(circularScopeThunkReverseMapped.ts, 2, 22))
+>pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19))
 >n : Symbol(n, Decl(circularScopeThunkReverseMapped.ts, 13, 40))
 >n : Symbol(n, Decl(circularScopeThunkReverseMapped.ts, 13, 40))
 
@@ -105,7 +109,11 @@ export const $2 = scope({
 
     b: () => $2.type("a").pipe((n: number) => n === 0),
 >b : Symbol(b, Decl(circularScopeThunkReverseMapped.ts, 18, 62))
+>$2.type("a").pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19))
+>$2.type : Symbol(Scope.type, Decl(circularScopeThunkReverseMapped.ts, 2, 22))
 >$2 : Symbol($2, Decl(circularScopeThunkReverseMapped.ts, 17, 12))
+>type : Symbol(Scope.type, Decl(circularScopeThunkReverseMapped.ts, 2, 22))
+>pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19))
 >n : Symbol(n, Decl(circularScopeThunkReverseMapped.ts, 19, 32))
 >n : Symbol(n, Decl(circularScopeThunkReverseMapped.ts, 19, 32))
 

tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).symbols

@@ -27,10 +27,10 @@ declare function type<T>(x: T): Type<T>;
 >x : T
 
 export const $ = scope({
->$ : any
->scope({    a: type("string").pipe(function (s) { return s.length; }),    b: () => $.type("a").pipe(function (n) { return n === 0; }),}) : Scope<{ readonly a: Type<number>; readonly b: () => any; }>
+>$ : Scope<{ a: Type<number>; b: () => Type<boolean>; }>
+>scope({    a: type("string").pipe(function (s) { return s.length; }),    b: () => $.type("a").pipe(function (n) { return n === 0; }),}) : Scope<{ readonly a: Type<number>; readonly b: () => Type<boolean>; }>
 >scope : <const def>(def: Validate<def>) => Scope<def>
->{    a: type("string").pipe(function (s) { return s.length; }),    b: () => $.type("a").pipe(function (n) { return n === 0; }),} : { a: Type<number>; b: () => any; }
+>{    a: type("string").pipe(function (s) { return s.length; }),    b: () => $.type("a").pipe(function (n) { return n === 0; }),} : { a: Type<number>; b: () => Type<boolean>; }
 
     a: type("string").pipe(function (s) { return s.length; }),
 >a : Type<number>
@@ -47,30 +47,30 @@ export const $ = scope({
 >length : number
 
     b: () => $.type("a").pipe(function (n) { return n === 0; }),
->b : () => any
->() => $.type("a").pipe(function (n) { return n === 0; }) : () => any
->$.type("a").pipe(function (n) { return n === 0; }) : any
->$.type("a").pipe : any
->$.type("a") : any
->$.type : any
->$ : any
->type : any
+>b : () => Type<boolean>
+>() => $.type("a").pipe(function (n) { return n === 0; }) : () => Type<boolean>
+>$.type("a").pipe(function (n) { return n === 0; }) : Type<boolean>
+>$.type("a").pipe : <U>(f: (x: number) => U) => Type<U>
+>$.type("a") : Type<number>
+>$.type : <k_1 extends "a" | "b">(k: k_1) => Resolve<{ a: Type<number>; b: () => Type<boolean>; }[k_1]>
+>$ : Scope<{ a: Type<number>; b: () => Type<boolean>; }>
+>type : <k_1 extends "a" | "b">(k: k_1) => Resolve<{ a: Type<number>; b: () => Type<boolean>; }[k_1]>
 >"a" : "a"
->pipe : any
->function (n) { return n === 0; } : (n: any) => boolean
->n : any
+>pipe : <U>(f: (x: number) => U) => Type<U>
+>function (n) { return n === 0; } : (n: number) => n is 0
+>n : number
 >n === 0 : boolean
->n : any
+>n : number
 >0 : 0
 
 });
 
 // Entered from the function in the first property when queried in reverse
 export const $2 = scope({
->$2 : any
->scope({    a: type("string").pipe(function (s) { return s.length; }),    b: () => $2.type("a").pipe((n: number) => n === 0),}) : Scope<{ readonly a: Type<number>; readonly b: () => any; }>
+>$2 : Scope<{ a: Type<number>; b: () => Type<boolean>; }>
+>scope({    a: type("string").pipe(function (s) { return s.length; }),    b: () => $2.type("a").pipe((n: number) => n === 0),}) : Scope<{ readonly a: Type<number>; readonly b: () => Type<boolean>; }>
 >scope : <const def>(def: Validate<def>) => Scope<def>
->{    a: type("string").pipe(function (s) { return s.length; }),    b: () => $2.type("a").pipe((n: number) => n === 0),} : { a: Type<number>; b: () => any; }
+>{    a: type("string").pipe(function (s) { return s.length; }),    b: () => $2.type("a").pipe((n: number) => n === 0),} : { a: Type<number>; b: () => Type<boolean>; }
 
     a: type("string").pipe(function (s) { return s.length; }),
 >a : Type<number>
@@ -87,16 +87,16 @@ export const $2 = scope({
 >length : number
 
     b: () => $2.type("a").pipe((n: number) => n === 0),
->b : () => any
->() => $2.type("a").pipe((n: number) => n === 0) : () => any
->$2.type("a").pipe((n: number) => n === 0) : any
->$2.type("a").pipe : any
->$2.type("a") : any
->$2.type : any
->$2 : any
->type : any
+>b : () => Type<boolean>
+>() => $2.type("a").pipe((n: number) => n === 0) : () => Type<boolean>
+>$2.type("a").pipe((n: number) => n === 0) : Type<boolean>
+>$2.type("a").pipe : <U>(f: (x: number) => U) => Type<U>
+>$2.type("a") : Type<number>
+>$2.type : <k_1 extends "a" | "b">(k: k_1) => Resolve<{ a: Type<number>; b: () => Type<boolean>; }[k_1]>
+>$2 : Scope<{ a: Type<number>; b: () => Type<boolean>; }>
+>type : <k_1 extends "a" | "b">(k: k_1) => Resolve<{ a: Type<number>; b: () => Type<boolean>; }[k_1]>
 >"a" : "a"
->pipe : any
+>pipe : <U>(f: (x: number) => U) => Type<U>
 >(n: number) => n === 0 : (n: number) => n is 0
 >n : number
 >n === 0 : boolean