Add ssax package.

config/staticconfig/configurer.go

@@ -6,6 +6,7 @@ import (
 
 	"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"
 )
 
@@ -74,8 +75,8 @@ func emitConfigurerCallsInFunc(
 		return true
 	}
 
-	for block := range walkReachable(fn.Blocks[0]) {
-		for _, inst := range block.Instrs {
+	for b := range ssax.WalkDown(fn.Blocks[0]) {
+		for _, inst := range b.Instrs {
 			if !emitConfigurerCallsInInstruction(ctx, inst, yield) {
 				return false
 			}
@@ -108,7 +109,7 @@ func emitConfigurerCallsInCallInstruction(
 	if com.IsInvoke() && ctx.IsConfigurer(com.Value) {
 		// We've found a direct call to a method on the configurer.
 		var f config.Fidelity
-		if isConditional(call.Block()) {
+		if !ssax.IsUnconditional(call.Block()) {
 			f |= config.Speculative
 		}
 

config/staticconfig/handler.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/dogmatiq/enginekit/config"
 	"github.com/dogmatiq/enginekit/config/internal/configbuilder"
+	"github.com/dogmatiq/enginekit/config/staticconfig/internal/ssax"
 	"github.com/dogmatiq/enginekit/internal/typename"
 	"golang.org/x/tools/go/ssa"
 )

config/staticconfig/identity.go

@@ -1,10 +1,9 @@
 package staticconfig
 
 import (
-	"go/constant"
-
 	"github.com/dogmatiq/enginekit/config"
 	"github.com/dogmatiq/enginekit/config/internal/configbuilder"
+	"github.com/dogmatiq/enginekit/config/staticconfig/internal/ssax"
 )
 
 func analyzeIdentityCall(
@@ -14,14 +13,14 @@ func analyzeIdentityCall(
 	b.Identity(func(b *configbuilder.IdentityBuilder) {
 		b.UpdateFidelity(call.Fidelity)
 
-		if name := staticValue(call.Args[0]); name != nil {
-			b.SetName(constant.StringVal(name))
+		if name, ok := ssax.AsString(call.Args[0]).TryGet(); ok {
+			b.SetName(name)
 		} else {
 			b.UpdateFidelity(config.Incomplete)
 		}
 
-		if key := staticValue(call.Args[1]); key != nil {
-			b.SetKey(constant.StringVal(key))
+		if key, ok := ssax.AsString(call.Args[1]).TryGet(); ok {
+			b.SetKey(key)
 		} else {
 			b.UpdateFidelity(config.Incomplete)
 		}

config/staticconfig/internal/ssax/block.go

@@ -0,0 +1,37 @@
+package ssax
+
+import (
+	"iter"
+
+	"github.com/dogmatiq/enginekit/optional"
+	"golang.org/x/tools/go/ssa"
+)
+
+// Terminator returns the final "transfer of control" instruction in the given
+// block.
+//
+// If the block does not contain any instructions (as is the case for external
+// functions), or the terminator instruction is not of type T, ok is false.
+//
+// The instruction is always [ssa.If], [ssa.Jump], [ssa.Return], or [ssa.Panic].
+func Terminator[T ssa.Instruction](b *ssa.BasicBlock) optional.Optional[T] {
+	return optional.As[T](optional.Last(b.Instrs))
+}
+
+// InstructionsBefore yields all instructions in the block that precede the
+// given instruction.
+//
+// It yields all instructions if inst is not in b.
+func InstructionsBefore(b *ssa.BasicBlock, inst ssa.Instruction) iter.Seq[ssa.Instruction] {
+	return func(yield func(ssa.Instruction) bool) {
+		for _, x := range b.Instrs {
+			if x == inst {
+				return
+			}
+
+			if !yield(x) {
+				return
+			}
+		}
+	}
+}

config/staticconfig/internal/ssax/const.go

@@ -0,0 +1,63 @@
+package ssax
+
+import (
+	"go/constant"
+	"math"
+
+	"github.com/dogmatiq/enginekit/optional"
+	"golang.org/x/tools/go/ssa"
+)
+
+// Const returns the singlar constant value of v if possible.
+func Const(v ssa.Value) optional.Optional[constant.Value] {
+	return optional.TryTransform(
+		StaticValue(v),
+		func(v ssa.Value) (constant.Value, bool) {
+			if c, ok := v.(*ssa.Const); ok {
+				return c.Value, true
+			}
+			return nil, false
+		},
+	)
+}
+
+// AsString returns the singular constant string value of v if possible.
+func AsString(v ssa.Value) optional.Optional[string] {
+	return constAs(constant.StringVal, v)
+}
+
+// AsBool returns the singular constant boolean value of v if possible.
+func AsBool(v ssa.Value) optional.Optional[bool] {
+	return constAs(constant.BoolVal, v)
+}
+
+// AsInt returns the singular constant integer value of v if possible.
+func AsInt(v ssa.Value) optional.Optional[int] {
+	return optional.TryTransform(
+		Const(v),
+		func(c constant.Value) (_ int, ok bool) {
+			i, ok := constant.Int64Val(c)
+			return int(i), ok && i >= math.MinInt && i <= math.MaxInt
+		},
+	)
+}
+
+// constAsX returns the constant value of v, converted to type T by fn.
+func constAs[T any](
+	fn func(constant.Value) T,
+	v ssa.Value,
+) optional.Optional[T] {
+	return optional.TryTransform(
+		Const(v),
+		func(c constant.Value) (_ T, ok bool) {
+			defer func() {
+				if recover() != nil {
+					// ignore panics about type conversion
+					ok = false
+				}
+			}()
+
+			return fn(c), true
+		},
+	)
+}

config/staticconfig/internal/ssax/doc.go

@@ -0,0 +1,2 @@
+// Package ssax contains general SSA-related utilities.
+package ssax