Method getTypeAtFlowArrayMutation

internal/checker/flow.go:1383–1413

(f *FlowState, flow *ast.FlowNode)

}

func (c *Checker) getTypeAtFlowArrayMutation(f *FlowState, flow *ast.FlowNode) FlowType {
	if f.declaredType == c.autoType || f.declaredType == c.autoArrayType {
		node := flow.Node
		var expr *ast.Node
		if ast.IsCallExpression(node) {
			expr = node.Expression().Expression()
		} else {
			expr = node.AsBinaryExpression().Left.Expression()
		}
		if c.isMatchingReference(f.reference, c.getReferenceCandidate(expr)) {
			flowType := c.getTypeAtFlowNode(f, flow.Antecedent)
			if flowType.t.objectFlags&ObjectFlagsEvolvingArray != 0 {
				evolvedType := flowType.t
				if ast.IsCallExpression(node) {
					for _, arg := range node.Arguments() {
						evolvedType = c.addEvolvingArrayElementType(evolvedType, arg)
					}
				} else {
					// We must get the context free expression type so as to not recur in an uncached fashion on the LHS (which causes exponential blowup in compile time)
					indexType := c.getContextFreeTypeOfExpression(node.AsBinaryExpression().Left.AsElementAccessExpression().ArgumentExpression)
					if c.isTypeAssignableToKind(indexType, TypeFlagsNumberLike) {
						evolvedType = c.addEvolvingArrayElementType(evolvedType, node.AsBinaryExpression().Right)
					}
				}
				return c.newFlowType(evolvedType, flowType.incomplete)
			}
			return flowType
		}
	}
	return FlowType{}
}

func (c *Checker) getDiscriminantPropertyAccess(f *FlowState, expr *ast.Node, computedType *Type) *ast.Node {
	// As long as the computed type is a subset of the declared type, we use the full declared type to detect