Function backpropAcrossTypeSwitch

assertion/function/assertiontree/backprop.go:536–586

backpropAcrossTypeSwitch handles type switches (e.g., "switch v := a.(*type)"), it is designed to be called from backpropAcrossAssignment as a finer-grained handler for special assignment cases. The main reason that this case has to be handled separately is that it introduces a "symbolic" variable t

(rootNode *RootAssertionNode, lhs *ast.Ident, rhs ast.Expr)

// without being able to compare the identity of `types.Var` instances as we usually do.
// nonnil(lhs, rhs)
func backpropAcrossTypeSwitch(rootNode *RootAssertionNode, lhs *ast.Ident, rhs ast.Expr) error {
	// First, make a copy of the children array to iterate over, as we will mutate it.
	children := slices.Clone(rootNode.Children())

	// For each variable in the assertion tree, check if it's equal to the symbolic variable
	// being instantiated by this type switch, and, if so, assign to it.
	// we (annonyingly) have to handle this as a separate case and continue after the first child
	// is found because there is no canonical instance of types.Object for symbolic type switch
	// variables
	for _, child := range children {
		if varChild, ok := child.(*varAssertionNode); ok {
			if varChild.decl.Pos() == lhs.Pos() &&
				varChild.decl.Name() == lhs.Name {
				// even though we can't do the matching through a types.Object instance, we conclude
				// that the *types.Var in the assertion nodes matches the lhs of this assignment

				liftedChild, _ := rootNode.LiftFromPath([]AssertionNode{varChild})
				if liftedChild == nil {
					// this nil check reflects programmer logic
					return errors.New("liftedChild variable is nil")
				}
				rhsPath, rhsProducers := rootNode.ParseExprAsProducer(rhs, false)
				if rhsPath != nil {
					// rhs is trackable, so move assertions as we would in the vanilla assignment case
					rootNode.LandAtPath(rhsPath, liftedChild)
					// assignment complete
				} else {
					liftedChild.SetParent(rootNode)
					switch len(rhsProducers) {
					case 0:
						// lhsVal expression will never be nil here because rhsVal will never be nil
						rootNode.triggerProductions(liftedChild, &annotation.ProduceTrigger{
							Annotation: &annotation.ProduceTriggerNever{},
							Expr:       lhs,
						})
					case 1:
						rootNode.triggerProductions(liftedChild, &annotation.ProduceTrigger{
							Annotation: rhsProducers[0].GetShallow().Annotation,
							Expr:       lhs,
						}, rhsProducers[0].GetDeepSlice()...)
					default:
						return errors.New("expression e in a e.(type) switch was multiply returning - " +
							"this should be a type error")
					}
				}
			}
		}
	}
	// no current assertion matches the type switch lhs variable here, so it's a no-op
	return nil
}

// backpropAcrossOneToOneAssignment handles normal one-to-one assignment (e.g, "var a *int = b", or
// "var a, b, c *int = d, e, f"), it is designed to be called from backpropAcrossAssignment as a