Genericize static analysis of variadic arguments.

Author: jmalloc

config/staticconfig/internal/ssax/value.go

@@ -12,41 +12,46 @@ import (
 //
 // If v cannot be resolved to a single value, it returns an empty optional.
 func StaticValue(v ssa.Value) optional.Optional[ssa.Value] {
-	switch v := v.(type) {
-	case *ssa.Const:
-		return optional.Some[ssa.Value](v)
-
-	case ssa.Instruction:
-		values := staticValuesFromInstruction(v)
-		if len(values) > 1 {
-			panic("did not expect multiple values")
-		}
+	values := staticValues(v)
+	if len(values) > 1 {
+		panic("did not expect multiple values")
+	}
 
-		if len(values) == 1 {
-			return values[0]
-		}
+	if len(values) == 1 {
+		return values[0]
 	}
 
-	// TODO(jmalloc): This implementation is incomplete.
 	return optional.None[ssa.Value]()
 }
 
-// staticValuesFromInstruction returns the static value(s) that result from
-// evaluating the given instruction.
+// staticValues returns the static value(s) that result from evaluating the
+// given node.
 //
 // If an individual value within the expression cannot be resolved to a singular
-// static value, it is represented as a nil value in the returned slice.
+// static value, it is represented as an empty optional in the returned slice.
 //
 // It returns an empty slice if the expression itself cannot be resolved.
-func staticValuesFromInstruction(inst ssa.Instruction) []optional.Optional[ssa.Value] {
-	switch inst := inst.(type) {
+func staticValues(v ssa.Value) []optional.Optional[ssa.Value] {
+	switch v := v.(type) {
+	case *ssa.Const:
+		return optional.Slice[ssa.Value](v)
+
 	case *ssa.Call:
-		return staticValuesFromCall(inst.Common())
+		return staticValuesFromCall(v.Common())
 
 	case *ssa.Extract:
-		if expr, ok := inst.Tuple.(ssa.Instruction); ok {
-			values := staticValuesFromInstruction(expr)
-			return values[inst.Index : inst.Index+1]
+		values := staticValues(v.Tuple)
+		if len(values) <= v.Index {
+			return nil
+		}
+		return values[v.Index : v.Index+1]
+
+	case *ssa.MakeInterface:
+		return staticValues(v.X)
+
+	case *ssa.UnOp:
+		if v.Op == token.MUL { // pointer de-reference
+			return staticValues(v.X)
 		}
 	}
 
@@ -58,13 +63,11 @@ func staticValuesFromInstruction(inst ssa.Instruction) []optional.Optional[ssa.V
 // a call to a function.
 //
 // If an individual value within the expression cannot be resolved to a singular
-// static value, it is represented as a nil value in the returned slice.
+// static value, it is represented as an empty value in the returned slice.
 //
 // It returns an empty slice if the function itself cannot be resolved. For
 // example, if it is a dynamic call to an interface method.
-func staticValuesFromCall(
-	call *ssa.CallCommon,
-) []optional.Optional[ssa.Value] {
+func staticValuesFromCall(call *ssa.CallCommon) []optional.Optional[ssa.Value] {
 	// TODO: we could use StaticValue or some variant thereof to resolve the
 	// callee in more cases.
 	fn := call.StaticCallee()

config/staticconfig/route.go

@@ -14,14 +14,11 @@ func analyzeRoutes[
 ](
 	ctx *configurerCallContext[T, H, B],
 ) {
-	for r := range resolveVariadic(ctx.Builder, ctx.Instruction) {
-		ctx.Builder.Route(func(b *configbuilder.RouteBuilder) {
-			if ctx.IsSpeculative {
-				b.Speculative() // TODO: is this correct?
-			}
-			analyzeRoute(ctx.context, b, r)
-		})
-	}
+	analyzeVariadicArguments(
+		ctx,
+		ctx.Builder.Route,
+		analyzeRoute,
+	)
 }
 
 func analyzeRoute(

config/staticconfig/varargs.go

@@ -1,85 +1,92 @@
 package staticconfig
 
 import (
-	"go/token"
-	"iter"
-
 	"github.com/dogmatiq/enginekit/config"
 	"github.com/dogmatiq/enginekit/config/internal/configbuilder"
 	"github.com/dogmatiq/enginekit/config/staticconfig/internal/ssax"
 	"golang.org/x/tools/go/ssa"
 )
 
-func findAllocation(v ssa.Value) (*ssa.Alloc, bool) {
-	switch v := v.(type) {
-	case *ssa.Alloc:
-		return v, true
-
-	case *ssa.Slice:
-		return findAllocation(v.X)
-
-	case *ssa.UnOp:
-		if v.Op == token.MUL { // pointer de-reference
-			return findAllocation(v.X)
-		}
-		return nil, false
-
-	default:
-		return nil, false
-	}
-}
-
-func isIndexOfArray(
-	array *ssa.Alloc,
-	v ssa.Value,
-) (int, bool) {
-	switch v := v.(type) {
-	case *ssa.IndexAddr:
-		if v.X != array {
-			return 0, false
-		}
-		return ssax.AsInt(v.Index).TryGet()
-	}
-	return 0, false
-}
-
-func resolveVariadic[
+func analyzeVariadicArguments[
 	T config.Entity,
 	E any,
 	B configbuilder.EntityBuilder[T, E],
+	TChild config.Component,
+	BChild configbuilder.ComponentBuilder[TChild],
 ](
-	b B,
-	inst ssa.CallInstruction,
-) iter.Seq[ssa.Value] {
-	return func(yield func(ssa.Value) bool) {
-		call := inst.Common()
+	ctx *configurerCallContext[T, E, B],
+	child func(func(BChild)),
+	analyze func(*context, BChild, ssa.Value),
+) {
+	// The variadic slice parameter is always the last argument.
+	varargs := ctx.Args[len(ctx.Args)-1]
 
-		variadics := call.Args[len(call.Args)-1]
-		if ssax.IsZeroValue(variadics) {
-			return
-		}
+	if ssax.IsZeroValue(varargs) {
+		return
+	}
+
+	array, ok := findSliceArrayAllocation(varargs)
+	if !ok {
+		ctx.Builder.Partial()
+		return
+	}
 
-		array, ok := findAllocation(variadics)
-		if !ok {
-			b.Partial()
-			return
+	buildersByIndex := map[int][]BChild{}
+
+	for block := range ssax.WalkBlock(array.Block()) {
+		// If there's no path from this block to the call instruction, we can
+		// safely ignore it, even if it modifies the underlying array.
+		if !ssax.PathExists(block, ctx.Instruction.Block()) {
+			continue
 		}
 
-		for b := range ssax.WalkBlock(array.Block()) {
-			if !ssax.PathExists(b, inst.Block()) {
-				continue
-			}
+		for inst := range ssax.InstructionsBefore(block, ctx.Instruction) {
+			switch inst := inst.(type) {
+			case *ssa.Store:
+				if addr, ok := inst.Addr.(*ssa.IndexAddr); ok && addr.X == array {
+					child(func(b BChild) {
+						if index, ok := ssax.AsInt(addr.Index).TryGet(); ok {
+							// If there are multiple writes to the same index,
+							// we mark them all as speculative.
+							//
+							// TODO: Could we handle this more intelligently by
+							// using the value of the store instruction closest
+							// to the call instruction?
+							conflicting := buildersByIndex[index]
+							if len(conflicting) == 1 {
+								conflicting[0].Speculative()
+							}
+							if len(conflicting) != 0 {
+								b.Speculative()
+							}
+							buildersByIndex[index] = append(conflicting, b)
+						} else {
+							// If we can't resolve the index we assume the child
+							// is speculative because we can't tell if it is
+							// ever overwritten with a different value.
+							b.Speculative()
+						}
 
-			for inst := range ssax.InstructionsBefore(b, inst) {
-				switch inst := inst.(type) {
-				case *ssa.Store:
-					if _, ok := isIndexOfArray(array, inst.Addr); ok {
-						if !yield(inst.Val) {
-							return
+						if ctx.IsSpeculative {
+							b.Speculative()
 						}
-					}
+
+						analyze(ctx.context, b, inst.Val)
+					})
 				}
 			}
 		}
 	}
 }
+
+// findSliceArrayAllocation returns the underlying array allocation of a slice.
+func findSliceArrayAllocation(v ssa.Value) (*ssa.Alloc, bool) {
+	switch v := v.(type) {
+	case *ssa.Alloc:
+		return v, true
+	case *ssa.Slice:
+		return findSliceArrayAllocation(v.X)
+	default:
+		return nil, false
+	}
+}

optional/container.go

@@ -32,3 +32,12 @@ func Key[K comparable, V any, M ~map[K]V](m M, k K) Optional[V] {
 	}
 	return None[V]()
 }
+
+// Slice returns a slice of Optional[T] values.
+func Slice[T any](elems ...T) []Optional[T] {
+	slice := make([]Optional[T], len(elems))
+	for i, elem := range elems {
+		slice[i] = Some(elem)
+	}
+	return slice
+}