Remove ObjectFlagsMembersResolving

The flag marked members whose resolution was in progress, so that the
fast path would not read members published before they were complete.
That duplicates what the resolution stack already records: the
resolution of the members is in Checker.resolving, or shadowed by a
cycle yield. The flag also let a type carry a "resolved" bit for
members that were not yet final, which is the install-then-replace
pattern Anders Hejlsberg objected to in the review of "Allow accessing
named declared members during a type's resolution".

ObjectFlagsMembersResolved now means only that the outermost
resolution of the members completed. Whether partial members are
available to a computation re-entering the resolution is recorded on
the resolution itself (membersPublished), and a re-entry finds it even
when hidden by a cycle yield. Members are marked published before their
properties are listed, since listing them may re-enter the resolution,
which then sees the members as it did before.

Types created with their members, rather than resolved, still set the
flag directly through setStructuredTypeMembers; resolvers use
setStructuredTypeData or publishStructuredTypeMembers.

Author: jakebailey

packages/typescript/enums/objectFlags.d.ts

@@ -24,7 +24,6 @@ export declare enum ObjectFlags {
     CouldContainTypeVariablesComputed = 1 << 19,
     CouldContainTypeVariables = 1 << 20,
     MembersResolved = 1 << 21,
-    MembersResolving = 1 << 30,
     ClassOrInterface = Class | Interface,
     RequiresWidening = ContainsWideningType | ContainsObjectOrArrayLiteral,
     PropagatingFlags = ContainsWideningType | ContainsObjectOrArrayLiteral | NonInferrableType,

packages/typescript/enums/objectFlags.js

@@ -24,7 +24,6 @@ export var ObjectFlags;
     ObjectFlags[ObjectFlags["CouldContainTypeVariablesComputed"] = 524288] = "CouldContainTypeVariablesComputed";
     ObjectFlags[ObjectFlags["CouldContainTypeVariables"] = 1048576] = "CouldContainTypeVariables";
     ObjectFlags[ObjectFlags["MembersResolved"] = 2097152] = "MembersResolved";
-    ObjectFlags[ObjectFlags["MembersResolving"] = 1073741824] = "MembersResolving";
     ObjectFlags[ObjectFlags["ClassOrInterface"] = 3] = "ClassOrInterface";
     ObjectFlags[ObjectFlags["RequiresWidening"] = 196608] = "RequiresWidening";
     ObjectFlags[ObjectFlags["PropagatingFlags"] = 458752] = "PropagatingFlags";

tsc/internal/api/enum_values_generated.go

@@ -20303,16 +20303,6 @@ func (c *Checker) yieldCycle(start int) bool {
 	return true
 }
 
-// observeHiddenMembers fails the cycle yield in progress if the members of t
-// are being resolved below it. Members are made available while they are
-// resolved, so the yield would see whatever part of them the hidden
-// resolution has published, rather than compute them from scratch.
-func (c *Checker) observeHiddenMembers(t *Type) {
-	if i, ok := c.resolving.get(memoKeyOf(t, memoStructuredMembers)); ok && int(i) < c.visibleStart {
-		c.markResolutionCycle(c.visibleStart)
-	}
-}
-
 // yieldCycleToMembers handles re-entering the type resolution in progress
 // at start, a cycle that would fail it, when the cycle passes through a
 // member table. Entering the cycle at the member table instead would not
@@ -21127,7 +21117,7 @@ func (c *Checker) isApplicableIndexType(source *Type, target *Type) bool {
 }
 
 func (c *Checker) resolveStructuredTypeMembers(t *Type) *StructuredType {
-	if t.objectFlags&(ObjectFlagsMembersResolved|ObjectFlagsMembersResolving) == ObjectFlagsMembersResolved && !c.observingMemos {
+	if t.objectFlags&ObjectFlagsMembersResolved != 0 && !c.observingMemos {
 		return t.asResolvedStructuredType()
 	}
 	return c.resolveStructuredTypeMembersSlow(t)
@@ -21137,12 +21127,16 @@ func (c *Checker) resolveStructuredTypeMembers(t *Type) *StructuredType {
 // past reading resolved members, out of line so that the rest inlines.
 func (c *Checker) resolveStructuredTypeMembersSlow(t *Type) *StructuredType {
 	key := memoKeyOf(t, memoStructuredMembers)
-	if t.objectFlags&(ObjectFlagsMembersResolved|ObjectFlagsMembersResolving) == ObjectFlagsMembersResolved {
+	if t.objectFlags&ObjectFlagsMembersResolved != 0 {
 		// Resolved members are only read.
 		c.observeMemo(key)
 		return t.AsStructuredType()
 	}
-	if t.objectFlags&ObjectFlagsMembersResolving != 0 {
+	published := false
+	enclosing, inProgress := c.resolvingAnyIndex(key)
+	if !inProgress {
+		enclosing = -1
+	} else {
 		// Resolving members may observe the type itself, whose members are
 		// then incomplete.
 		if c.isModuleTableType(t) {
@@ -21153,59 +21147,88 @@ func (c *Checker) resolveStructuredTypeMembersSlow(t *Type) *StructuredType {
 				c.addCycleParticipants(start)
 			}
 		}
-		if len(c.cycleYields) != 0 {
-			c.observeHiddenMembers(t)
+		if j, ok := c.resolving.get(key); ok && int(j) < c.visibleStart {
+			// The members are being resolved below the cycle yield in
+			// progress, which then sees whatever part of them that
+			// resolution has published, rather than compute them from
+			// scratch, so the yield fails.
+			c.markResolutionCycle(c.visibleStart)
 		}
+		published = c.resolutions[enclosing].membersPublished
 	}
 	c.beginMemo(key)
-	result := c.resolveStructuredTypeMembersUncached(t)
+	if !published {
+		c.resolveStructuredTypeMembersUncached(t, enclosing)
+	}
 	c.endMemo()
-	return result
+	return t.AsStructuredType()
 }
 
-func (c *Checker) resolveStructuredTypeMembersUncached(t *Type) *StructuredType {
-	if t.objectFlags&ObjectFlagsMembersResolved == 0 {
-		if t.objectFlags&ObjectFlagsMembersResolving == 0 && c.isModuleTableType(t) {
-			c.resolveModuleTableMembers(t)
-			return t.AsStructuredType()
+// resolveStructuredTypeMembersUncached resolves the members of t in the memo
+// just begun for them. Many kinds of types make members available before
+// they are complete, through publishStructuredTypeMembers, so the resolution
+// is on the stack, but never fails. The members are resolved only once the
+// outermost resolution of them completes. A nested one, which re-entering
+// the members before any are available starts, makes its result available
+// to the rest of the enclosing resolution at index enclosing, which may be
+// hidden by a cycle yield.
+func (c *Checker) resolveStructuredTypeMembersUncached(t *Type, enclosing int) {
+	outermost := enclosing < 0
+	if outermost && c.isModuleTableType(t) {
+		c.resolveModuleTableMembers(t)
+		return
+	}
+	c.beginTypeResolution(t, TypeSystemPropertyNameStructuredMembers)
+	defer func() {
+		c.popTypeResolution()
+		if outermost {
+			t.objectFlags |= ObjectFlagsMembersResolved
+		} else {
+			c.resolutions[enclosing].membersPublished = true
 		}
-		// Many kinds of types make members available before they are
-		// complete, so the resolution is on the stack, but never fails.
-		outermost := t.objectFlags&ObjectFlagsMembersResolving == 0
-		t.objectFlags |= ObjectFlagsMembersResolving
-		c.beginTypeResolution(t, TypeSystemPropertyNameStructuredMembers)
-		defer func() {
-			c.popTypeResolution()
-			if outermost {
-				t.objectFlags &^= ObjectFlagsMembersResolving
-			}
-			if c.logResults() {
-				c.logMembersDiscard(t)
-			}
-		}()
+		if c.logResults() {
+			c.logMembersDiscard(t)
+		}
+	}()
+	switch {
+	case t.flags&TypeFlagsObject != 0:
 		switch {
-		case t.flags&TypeFlagsObject != 0:
-			switch {
-			case t.objectFlags&(ObjectFlagsClassOrInterface|ObjectFlagsReference) != 0:
-				c.resolveObjectTypeMembers(t)
-			case t.objectFlags&ObjectFlagsReverseMapped != 0:
-				c.resolveReverseMappedTypeMembers(t)
-			case t.objectFlags&ObjectFlagsAnonymous != 0:
-				c.resolveAnonymousTypeMembers(t)
-			case t.objectFlags&ObjectFlagsMapped != 0:
-				c.resolveMappedTypeMembers(t)
-			default:
-				panic("Unhandled case in resolveStructuredTypeMembers")
-			}
-		case t.flags&TypeFlagsUnion != 0:
-			c.resolveUnionTypeMembers(t)
-		case t.flags&TypeFlagsIntersection != 0:
-			c.resolveIntersectionTypeMembers(t)
+		case t.objectFlags&(ObjectFlagsClassOrInterface|ObjectFlagsReference) != 0:
+			c.resolveObjectTypeMembers(t)
+		case t.objectFlags&ObjectFlagsReverseMapped != 0:
+			c.resolveReverseMappedTypeMembers(t)
+		case t.objectFlags&ObjectFlagsAnonymous != 0:
+			c.resolveAnonymousTypeMembers(t)
+		case t.objectFlags&ObjectFlagsMapped != 0:
+			c.resolveMappedTypeMembers(t)
 		default:
 			panic("Unhandled case in resolveStructuredTypeMembers")
 		}
+	case t.flags&TypeFlagsUnion != 0:
+		c.resolveUnionTypeMembers(t)
+	case t.flags&TypeFlagsIntersection != 0:
+		c.resolveIntersectionTypeMembers(t)
+	default:
+		panic("Unhandled case in resolveStructuredTypeMembers")
 	}
-	return t.AsStructuredType()
+}
+
+// markMembersPublished records that the members of t, whose resolution is
+// in progress, are available to computations re-entering it.
+func (c *Checker) markMembersPublished(t *Type) {
+	i, ok := c.resolvingAnyIndex(memoKeyOf(t, memoStructuredMembers))
+	debug.Assert(ok, "members published outside their resolution")
+	c.resolutions[i].membersPublished = true
+}
+
+// publishStructuredTypeMembers sets the members of t while they are being
+// resolved, making them available to computations re-entering the resolution
+// before it completes.
+func (c *Checker) publishStructuredTypeMembers(t *Type, members ast.SymbolTable, callSignatures []*Signature, constructSignatures []*Signature, indexInfos []*IndexInfo) {
+	// Listing the properties may re-enter the resolution, which then sees
+	// the members.
+	c.markMembersPublished(t)
+	c.setStructuredTypeData(t, members, callSignatures, constructSignatures, indexInfos)
 }
 
 // isModuleTableType reports whether t is the type of a module object, whose
@@ -21253,7 +21276,6 @@ func (c *Checker) resolveModuleTableMembers(t *Type) {
 	mark := c.markDiscard()
 	hidden := false
 	for {
-		t.objectFlags |= ObjectFlagsMembersResolving
 		c.beginTypeResolution(t, TypeSystemPropertyNameStructuredMembers)
 		c.resolveAnonymousTypeMembers(t)
 		r := c.topTypeResolution()
@@ -21268,11 +21290,13 @@ func (c *Checker) resolveModuleTableMembers(t *Type) {
 			c.discardSince(mark)
 		}
 		c.popTypeResolution()
-		t.objectFlags &^= ObjectFlagsMembersResolving
 		if canonical == nil && !restart {
 			break
 		}
 		c.clearStructuredMembers(t)
+		key := memoKeyOf(t, memoStructuredMembers)
+		i, _ := c.resolving.get(key)
+		c.resolutions[i].membersPublished = false
 		if canonical != nil {
 			c.resolveStructuredTypeMembers(canonical.(*Type))
 			continue
@@ -21281,12 +21305,12 @@ func (c *Checker) resolveModuleTableMembers(t *Type) {
 		// is resolved again as if it had been entered first: with the
 		// computations in progress below it hidden.
 		hidden = true
-		floor, _ := c.resolving.get(memoKeyOf(t, memoStructuredMembers))
-		c.beginCycleYield(t, TypeSystemPropertyNameStructuredMembers, -1, int(floor))
+		c.beginCycleYield(t, TypeSystemPropertyNameStructuredMembers, -1, int(i))
 	}
 	if hidden {
 		c.endCycleYield()
 	}
+	t.objectFlags |= ObjectFlagsMembersResolved
 	c.releaseDiscardMark(mark)
 	if c.logResults() {
 		c.logMembersDiscard(t)
@@ -21312,7 +21336,7 @@ func (c *Checker) clearStructuredMembers(t *Type) {
 //go:noinline
 func (c *Checker) logMembersDiscard(t *Type) {
 	c.discardLog = append(c.discardLog, discardEntry{nil, func() {
-		if t.objectFlags&ObjectFlagsMembersResolving != 0 {
+		if _, ok := c.resolvingAnyIndex(memoKeyOf(t, memoStructuredMembers)); ok {
 			// An enclosing resolution of the same members sets them again.
 			return
 		}
@@ -21398,7 +21422,7 @@ func (c *Checker) resolveObjectTypeMembers(t *Type) {
 			return findIndexInfo(indexInfos, info.keyType) == nil
 		}))
 	}
-	c.setStructuredTypeMembers(t, nil, callSignatures, constructSignatures, indexInfos)
+	c.setStructuredTypeData(t, nil, callSignatures, constructSignatures, indexInfos)
 	lazyState := c.lazyStateArena.New()
 	lazyState.layout = layout
 	lazyState.mapper = mapper
@@ -23101,22 +23125,22 @@ func (c *Checker) instantiateIndexInfo(info *IndexInfo, m *TypeMapper) *IndexInf
 func (c *Checker) resolveAnonymousTypeMembers(t *Type) {
 	d := t.AsObjectType()
 	if d.target != nil {
-		c.setStructuredTypeMembers(t, nil, nil, nil, nil)
+		c.publishStructuredTypeMembers(t, nil, nil, nil, nil)
 		members := c.createInstantiatedSymbolTable(c.getPropertiesOfObjectType(d.target), d.mapper)
 		callSignatures := c.instantiateSignatures(c.getSignaturesOfType(d.target, SignatureKindCall), d.mapper)
 		constructSignatures := c.instantiateSignatures(c.getSignaturesOfType(d.target, SignatureKindConstruct), d.mapper)
 		indexInfos := c.instantiateIndexInfos(c.getIndexInfosOfType(d.target), d.mapper)
-		c.setStructuredTypeMembers(t, members, callSignatures, constructSignatures, indexInfos)
+		c.publishStructuredTypeMembers(t, members, callSignatures, constructSignatures, indexInfos)
 		return
 	}
 	symbol := c.getMergedSymbol(t.symbol)
 	if symbol.Flags()&ast.SymbolFlagsTypeLiteral != 0 {
-		c.setStructuredTypeMembers(t, nil, nil, nil, nil)
+		c.publishStructuredTypeMembers(t, nil, nil, nil, nil)
 		members := c.getMembersOfSymbol(symbol)
 		callSignatures := c.getSignaturesOfSymbol(members.Get(ast.InternalSymbolNameCall))
 		constructSignatures := c.getSignaturesOfSymbol(members.Get(ast.InternalSymbolNameNew))
 		indexInfos := c.getIndexInfosOfSymbol(symbol)
-		c.setStructuredTypeMembers(t, members, callSignatures, constructSignatures, indexInfos)
+		c.publishStructuredTypeMembers(t, members, callSignatures, constructSignatures, indexInfos)
 		return
 	}
 	// Combinations of function, class, enum and module
@@ -23132,14 +23156,14 @@ func (c *Checker) resolveAnonymousTypeMembers(t *Type) {
 		members = varsOnly
 	}
 	var baseConstructorIndexInfo *IndexInfo
-	c.setStructuredTypeMembers(t, members, nil, nil, nil)
+	c.publishStructuredTypeMembers(t, members, nil, nil, nil)
 	if symbol.Flags()&ast.SymbolFlagsClass != 0 {
 		classType := c.getDeclaredTypeOfClassOrInterface(symbol)
 		baseConstructorType := c.getBaseConstructorTypeOfClass(classType)
 		if baseConstructorType.flags&(TypeFlagsObject|TypeFlagsIntersection|TypeFlagsTypeVariable) != 0 {
 			members = members.Clone()
 			c.addInheritedMembers(members, c.getPropertiesOfType(baseConstructorType))
-			c.setStructuredTypeMembers(t, members, nil, nil, nil)
+			c.publishStructuredTypeMembers(t, members, nil, nil, nil)
 		} else if baseConstructorType == c.anyType {
 			baseConstructorIndexInfo = c.anyBaseTypeIndexInfo
 		}
@@ -23351,7 +23375,7 @@ func (c *Checker) resolveMappedTypeMembers(t *Type) {
 	members := ast.NewSymbolTable()
 	var indexInfos []*IndexInfo
 	// Resolve upfront such that recursive references see an empty object type.
-	c.setStructuredTypeMembers(t, nil, nil, nil, nil)
+	c.publishStructuredTypeMembers(t, nil, nil, nil, nil)
 	// In { [P in K]: T }, we refer to P as the type parameter type, K as the constraint type,
 	// and T as the template type.
 	typeParameter := c.getTypeParameterFromMappedType(t)
@@ -23434,7 +23458,7 @@ func (c *Checker) resolveMappedTypeMembers(t *Type) {
 	} else {
 		forEachType(c.getLowerBoundOfKeyType(constraintType), addMemberForKeyType)
 	}
-	c.setStructuredTypeMembers(t, members, nil, nil, indexInfos)
+	c.publishStructuredTypeMembers(t, members, nil, nil, indexInfos)
 }
 
 func (c *Checker) getTypeOfMappedSymbol(symbol *ast.Symbol) *Type {
@@ -23521,7 +23545,7 @@ func (c *Checker) resolveUnionTypeMembers(t *Type) {
 		return c.getSignaturesOfType(t, SignatureKindConstruct)
 	}))
 	indexInfos := c.getUnionIndexInfos(t.Types())
-	c.setStructuredTypeMembers(t, nil, callSignatures, constructSignatures, indexInfos)
+	c.setStructuredTypeData(t, nil, callSignatures, constructSignatures, indexInfos)
 }
 
 func (c *Checker) getArrayMemberCallSignatures(t *Type) []*Signature {
@@ -23785,7 +23809,7 @@ func (c *Checker) resolveIntersectionTypeMembers(t *Type) {
 			indexInfos = c.appendIndexInfo(indexInfos, info, false /*union*/)
 		}
 	}
-	c.setStructuredTypeMembers(t, nil, callSignatures, constructSignatures, indexInfos)
+	c.setStructuredTypeData(t, nil, callSignatures, constructSignatures, indexInfos)
 }
 
 func (c *Checker) appendSignatures(signatures []*Signature, newSignatures []*Signature) []*Signature {
@@ -28030,8 +28054,14 @@ func (c *Checker) cloneTypeReference(source *Type) *Type {
 	return t
 }
 
+// setStructuredTypeMembers sets the members of a type being created, which
+// are then resolved.
 func (c *Checker) setStructuredTypeMembers(t *Type, members ast.SymbolTable, callSignatures []*Signature, constructSignatures []*Signature, indexInfos []*IndexInfo) {
 	t.objectFlags |= ObjectFlagsMembersResolved
+	c.setStructuredTypeData(t, members, callSignatures, constructSignatures, indexInfos)
+}
+
+func (c *Checker) setStructuredTypeData(t *Type, members ast.SymbolTable, callSignatures []*Signature, constructSignatures []*Signature, indexInfos []*IndexInfo) {
 	data := t.AsStructuredType()
 	data.members = members
 	data.properties = c.getNamedMembers(members, t.symbol)

tsc/internal/checker/checker.go

@@ -1166,7 +1166,7 @@ func (c *Checker) resolveReverseMappedTypeMembers(t *Type) {
 		}
 		members.Set(prop.Name(), inferredProp)
 	}
-	c.setStructuredTypeMembers(t, members, nil, nil, indexInfos)
+	c.setStructuredTypeData(t, members, nil, nil, indexInfos)
 }
 
 func (c *Checker) getTypeOfReverseMappedSymbol(symbol *ast.Symbol) *Type {