Method getTypeAtFlowBranchLabel

internal/checker/flow.go:1232–1288

(f *FlowState, flow *ast.FlowNode, antecedents *ast.FlowList)

}

func (c *Checker) getTypeAtFlowBranchLabel(f *FlowState, flow *ast.FlowNode, antecedents *ast.FlowList) FlowType {
	antecedentStart := len(c.antecedentTypes)
	subtypeReduction := false
	seenIncomplete := false
	var bypassFlow *ast.FlowNode
	for list := antecedents; list != nil; list = list.Next {
		antecedent := list.Flow
		if bypassFlow == nil && antecedent.Flags&ast.FlowFlagsSwitchClause != 0 && antecedent.Node.AsFlowSwitchClauseData().IsEmpty() {
			// The antecedent is the bypass branch of a potentially exhaustive switch statement.
			bypassFlow = antecedent
			continue
		}
		flowType := c.getTypeAtFlowNode(f, antecedent)
		// If the type at a particular antecedent path is the declared type and the
		// reference is known to always be assigned (i.e. when declared and initial types
		// are the same), there is no reason to process more antecedents since the only
		// possible outcome is subtypes that will be removed in the final union type anyway.
		if flowType.t == f.declaredType && f.declaredType == f.initialType {
			c.antecedentTypes = c.antecedentTypes[:antecedentStart]
			return FlowType{t: flowType.t}
		}
		if !slices.Contains(c.antecedentTypes[antecedentStart:], flowType.t) {
			c.antecedentTypes = append(c.antecedentTypes, flowType.t)
		}
		// If an antecedent type is not a subset of the declared type, we need to perform
		// subtype reduction. This happens when a "foreign" type is injected into the control
		// flow using the instanceof operator or a user defined type predicate.
		if !c.isTypeSubsetOf(flowType.t, f.initialType) {
			subtypeReduction = true
		}
		if flowType.incomplete {
			seenIncomplete = true
		}
	}
	if bypassFlow != nil {
		flowType := c.getTypeAtFlowNode(f, bypassFlow)
		// If the bypass flow contributes a type we haven't seen yet and the switch statement
		// isn't exhaustive, process the bypass flow type. Since exhaustiveness checks increase
		// the risk of circularities, we only want to perform them when they make a difference.
		if flowType.t.flags&TypeFlagsNever == 0 && !slices.Contains(c.antecedentTypes[antecedentStart:], flowType.t) && !c.isExhaustiveSwitchStatement(bypassFlow.Node.AsFlowSwitchClauseData().SwitchStatement) {
			if flowType.t == f.declaredType && f.declaredType == f.initialType {
				c.antecedentTypes = c.antecedentTypes[:antecedentStart]
				return FlowType{t: flowType.t}
			}
			c.antecedentTypes = append(c.antecedentTypes, flowType.t)
			if !c.isTypeSubsetOf(flowType.t, f.initialType) {
				subtypeReduction = true
			}
			if flowType.incomplete {
				seenIncomplete = true
			}
		}
	}
	result := c.newFlowType(c.getUnionOrEvolvingArrayType(f, c.antecedentTypes[antecedentStart:], core.IfElse(subtypeReduction, UnionReductionSubtype, UnionReductionLiteral)), seenIncomplete)
	c.antecedentTypes = c.antecedentTypes[:antecedentStart]
	return result
}