Refactor interproc facts domain

compiler/ast/expr.go

@@ -89,6 +89,17 @@ type FuncCallExpr struct {
 	AdjustRet bool       // Whether return count should be adjusted
 }
 
+// CanProduceMultipleValues reports whether expr can expand to multiple Lua values
+// when it appears in the final slot of an expression list.
+func CanProduceMultipleValues(expr Expr) bool {
+	switch expr.(type) {
+	case *FuncCallExpr, *Comma3Expr:
+		return true
+	default:
+		return false
+	}
+}
+
 // LogicalOpExpr represents a logical operator (and, or).
 type LogicalOpExpr struct {
 	ExprBase

compiler/bind/fieldpath.go

@@ -90,3 +90,19 @@ func displayFieldPathKey(path string) string {
 
 	return path
 }
+
+// DirectFieldNameFromKey returns the field name for a one-segment string-like
+// field key. Numeric indexes and nested paths do not describe direct prototype
+// fields and are rejected.
+func DirectFieldNameFromKey(path string) (string, bool) {
+	segs := pathkey.ParseSuffix(path)
+	if len(segs) != 1 {
+		return "", false
+	}
+	switch segs[0].Kind {
+	case constraint.SegmentField, constraint.SegmentIndexString:
+		return segs[0].Name, segs[0].Name != ""
+	default:
+		return "", false
+	}
+}

compiler/bind/table.go

@@ -97,6 +97,12 @@ type fieldPathKey struct {
 	path string
 }
 
+// FieldSymbolRef identifies a direct field symbol rooted at a base symbol.
+type FieldSymbolRef struct {
+	Name   string
+	Symbol cfg.SymbolID
+}
+
 // NewBindingTable creates an empty binding table with all maps initialized.
 func NewBindingTable() *BindingTable {
 	return NewBindingTableWithHint(0, 0)
@@ -409,6 +415,38 @@ func (t *BindingTable) FieldSymbol(baseSym cfg.SymbolID, path string) (cfg.Symbo
 	return sym, ok
 }
 
+// DirectFieldSymbols returns direct field symbols rooted at baseSym.
+//
+// Only one-segment string-like fields are returned; nested paths and numeric
+// indexes are intentionally excluded because they are not fields on the base
+// prototype itself.
+func (t *BindingTable) DirectFieldSymbols(baseSym cfg.SymbolID) []FieldSymbolRef {
+	if t == nil || baseSym == 0 || len(t.fieldSymbols) == 0 {
+		return nil
+	}
+	out := make([]FieldSymbolRef, 0)
+	for key, sym := range t.fieldSymbols {
+		if key.base != baseSym || sym == 0 {
+			continue
+		}
+		name, ok := DirectFieldNameFromKey(key.path)
+		if !ok {
+			continue
+		}
+		out = append(out, FieldSymbolRef{Name: name, Symbol: sym})
+	}
+	if len(out) == 0 {
+		return nil
+	}
+	sort.Slice(out, func(i, j int) bool {
+		if out[i].Name == out[j].Name {
+			return out[i].Symbol < out[j].Symbol
+		}
+		return out[i].Name < out[j].Name
+	})
+	return out
+}
+
 // GetOrCreateFuncLitSymbol returns or creates a symbol for an anonymous function.
 //
 // Anonymous functions (function literals) need symbols for type assignment

compiler/bind/table_test.go

@@ -524,6 +524,51 @@ func TestBindingTable_FieldSymbol_NormalizesLegacyBracketStringKey(t *testing.T)
 	}
 }
 
+func TestBindingTable_DirectFieldSymbols(t *testing.T) {
+	table := NewBindingTable()
+	baseSym := cfg.NextSymbolID()
+	otherSym := cfg.NextSymbolID()
+
+	beta := table.GetOrCreateFieldSymbol(baseSym, "beta")
+	alpha := table.GetOrCreateFieldSymbol(baseSym, "alpha")
+	nested := table.GetOrCreateFieldSymbol(baseSym, "alpha.deep")
+	indexKey, ok := FieldPathKeyFromSegments([]constraint.Segment{
+		{Kind: constraint.SegmentIndexString, Name: "quoted-key"},
+	})
+	if !ok {
+		t.Fatal("expected canonical string-index key")
+	}
+	quoted := table.GetOrCreateFieldSymbol(baseSym, indexKey)
+	numericKey, ok := FieldPathKeyFromSegments([]constraint.Segment{
+		{Kind: constraint.SegmentIndexInt, Index: 1},
+	})
+	if !ok {
+		t.Fatal("expected canonical int-index key")
+	}
+	_ = table.GetOrCreateFieldSymbol(baseSym, numericKey)
+	_ = table.GetOrCreateFieldSymbol(otherSym, "alpha")
+
+	got := table.DirectFieldSymbols(baseSym)
+	want := []FieldSymbolRef{
+		{Name: "alpha", Symbol: alpha},
+		{Name: "beta", Symbol: beta},
+		{Name: "quoted-key", Symbol: quoted},
+	}
+	if len(got) != len(want) {
+		t.Fatalf("DirectFieldSymbols length = %d, want %d; got %#v", len(got), len(want), got)
+	}
+	for i := range want {
+		if got[i] != want[i] {
+			t.Fatalf("DirectFieldSymbols[%d] = %#v, want %#v", i, got[i], want[i])
+		}
+	}
+	for _, ref := range got {
+		if ref.Symbol == nested {
+			t.Fatal("nested field path should not be returned as a direct field")
+		}
+	}
+}
+
 func TestBindingTable_GetOrCreateFieldSymbol_InvalidPathRejected(t *testing.T) {
 	table := NewBindingTable()
 	baseSym := cfg.NextSymbolID()

compiler/cfg/analysis/dominators.go

@@ -33,6 +33,13 @@ type rpoReader interface {
 	RPOReadOnly() []basecfg.Point
 }
 
+type immediateDominatorData struct {
+	rpo         []basecfg.Point
+	rpoNum      []int
+	idomByPoint []basecfg.Point
+	hasIDom     []bool
+}
+
 func predecessorsOf(g basecfg.Graph, point basecfg.Point) []basecfg.Point {
 	if direct, ok := g.(predecessorsReader); ok {
 		return direct.PredecessorsReadOnly(point)
@@ -57,130 +64,140 @@ func rpoOf(g basecfg.Graph) []basecfg.Point {
 	return g.RPO()
 }
 
-// ComputeDominators computes immediate dominators and the dominator tree.
-// Uses the Cooper-Harvey-Kennedy algorithm with RPO iteration.
-func ComputeDominators(g basecfg.Graph) (idom map[basecfg.Point]basecfg.Point, domTree map[basecfg.Point][]basecfg.Point) {
+func computeImmediateDominatorData(g basecfg.Graph) immediateDominatorData {
 	rpo := rpoOf(g)
 	if len(rpo) == 0 {
-		return make(map[basecfg.Point]basecfg.Point), make(map[basecfg.Point][]basecfg.Point)
+		return immediateDominatorData{}
 	}
 
 	graphSize := g.Size()
-
 	if graphSize == 0 {
-		return make(map[basecfg.Point]basecfg.Point), make(map[basecfg.Point][]basecfg.Point)
+		return immediateDominatorData{}
 	}
 
-	// Build RPO number lookup for intersection and deterministic sorting.
 	rpoNum := make([]int, graphSize)
 	for i, p := range rpo {
 		if int(p) >= graphSize {
 			continue
 		}
-
 		rpoNum[p] = i
 	}
 
 	entry := g.Entry()
 	if int(entry) >= graphSize {
-		return make(map[basecfg.Point]basecfg.Point), make(map[basecfg.Point][]basecfg.Point)
+		return immediateDominatorData{}
 	}
 
 	idomByPoint := make([]basecfg.Point, graphSize)
 	hasIDom := make([]bool, graphSize)
 	idomByPoint[entry] = entry
 	hasIDom[entry] = true
 
-	// intersect finds the common dominator of two nodes
-	intersect := func(b1, b2 basecfg.Point) basecfg.Point {
-		finger1, finger2 := b1, b2
-
-		for finger1 != finger2 {
-			for rpoNum[finger1] > rpoNum[finger2] {
-				finger1 = idomByPoint[finger1]
+	intersect := func(pointA, pointB basecfg.Point) basecfg.Point {
+		fingerA, fingerB := pointA, pointB
+		for fingerA != fingerB {
+			for rpoNum[fingerA] > rpoNum[fingerB] {
+				fingerA = idomByPoint[fingerA]
 			}
-
-			for rpoNum[finger2] > rpoNum[finger1] {
-				finger2 = idomByPoint[finger2]
+			for rpoNum[fingerB] > rpoNum[fingerA] {
+				fingerB = idomByPoint[fingerB]
 			}
 		}
-
-		return finger1
+		return fingerA
 	}
 
-	// Iterate until fixed point
 	changed := true
 	for changed {
 		changed = false
-		for _, b := range rpo {
-			if b == entry {
-				continue
-			}
-
-			if int(b) >= graphSize {
+		for _, block := range rpo {
+			if block == entry || int(block) >= graphSize {
 				continue
 			}
 
-			preds := predecessorsOf(g, b)
+			preds := predecessorsOf(g, block)
 			if len(preds) == 0 {
 				continue
 			}
 
-			// Find first predecessor with defined idom
-			var newIdom basecfg.Point
-
+			var newIDom basecfg.Point
 			found := false
-
-			for _, p := range preds {
-				if int(p) >= graphSize {
+			for _, pred := range preds {
+				predIdx := int(pred)
+				if predIdx >= graphSize {
 					continue
 				}
-
-				if hasIDom[p] {
-					newIdom = p
+				if hasIDom[predIdx] {
+					newIDom = pred
 					found = true
-
 					break
 				}
 			}
-
 			if !found {
 				continue
 			}
 
-			// Intersect with other defined predecessors
-			for _, p := range preds {
-				if p == newIdom {
+			for _, pred := range preds {
+				if pred == newIDom {
 					continue
 				}
-
-				if int(p) >= graphSize {
+				predIdx := int(pred)
+				if predIdx >= graphSize {
 					continue
 				}
-
-				if hasIDom[p] {
-					newIdom = intersect(p, newIdom)
+				if hasIDom[predIdx] {
+					newIDom = intersect(pred, newIDom)
 				}
 			}
 
-			if !hasIDom[b] || idomByPoint[b] != newIdom {
-				idomByPoint[b] = newIdom
-				hasIDom[b] = true
+			blockIdx := int(block)
+			if !hasIDom[blockIdx] || idomByPoint[blockIdx] != newIDom {
+				idomByPoint[blockIdx] = newIDom
+				hasIDom[blockIdx] = true
 				changed = true
 			}
 		}
 	}
 
-	idom = make(map[basecfg.Point]basecfg.Point, len(rpo))
-	for _, point := range rpo {
-		if int(point) >= graphSize || !hasIDom[point] {
+	return immediateDominatorData{
+		rpo:         rpo,
+		rpoNum:      rpoNum,
+		idomByPoint: idomByPoint,
+		hasIDom:     hasIDom,
+	}
+}
+
+func (d immediateDominatorData) asMap() map[basecfg.Point]basecfg.Point {
+	if len(d.rpo) == 0 {
+		return make(map[basecfg.Point]basecfg.Point)
+	}
+	idom := make(map[basecfg.Point]basecfg.Point, len(d.rpo))
+	for _, point := range d.rpo {
+		idx := int(point)
+		if idx >= len(d.hasIDom) || !d.hasIDom[idx] {
 			continue
 		}
+		idom[point] = d.idomByPoint[idx]
+	}
+	return idom
+}
+
+// ComputeImmediateDominators computes only the immediate-dominator map.
+//
+// Use this when callers only need dominance predicates. It avoids building the
+// dominator tree, which is meaningful allocation in hot type-checking paths.
+func ComputeImmediateDominators(g basecfg.Graph) map[basecfg.Point]basecfg.Point {
+	return computeImmediateDominatorData(g).asMap()
+}
 
-		idom[point] = idomByPoint[point]
+// ComputeDominators computes immediate dominators and the dominator tree.
+// Uses the Cooper-Harvey-Kennedy algorithm with RPO iteration.
+func ComputeDominators(g basecfg.Graph) (idom map[basecfg.Point]basecfg.Point, domTree map[basecfg.Point][]basecfg.Point) {
+	data := computeImmediateDominatorData(g)
+	if len(data.rpo) == 0 {
+		return make(map[basecfg.Point]basecfg.Point), make(map[basecfg.Point][]basecfg.Point)
 	}
 
-	// Build dominator tree from idom
+	idom = data.asMap()
 	domTree = make(map[basecfg.Point][]basecfg.Point, len(idom))
 
 	for n, dom := range idom {
@@ -192,10 +209,10 @@ func ComputeDominators(g basecfg.Graph) (idom map[basecfg.Point]basecfg.Point, d
 	// Sort children for deterministic order.
 	for p := range domTree {
 		slices.SortFunc(domTree[p], func(a, b basecfg.Point) int {
-			if rpoNum[a] < rpoNum[b] {
+			if data.rpoNum[a] < data.rpoNum[b] {
 				return -1
 			}
-			if rpoNum[a] > rpoNum[b] {
+			if data.rpoNum[a] > data.rpoNum[b] {
 				return 1
 			}
 			return 0
@@ -599,6 +616,11 @@ func ComputePostDominators(graph basecfg.Graph) (map[basecfg.Point]basecfg.Point
 	return ComputeDominators(&reversedGraph{g: graph})
 }
 
+// ComputeImmediatePostDominators computes only the immediate post-dominator map.
+func ComputeImmediatePostDominators(graph basecfg.Graph) map[basecfg.Point]basecfg.Point {
+	return ComputeImmediateDominators(&reversedGraph{g: graph})
+}
+
 // PostDominates returns true if a post-dominates b (a is on every path from b to exit).
 func PostDominates(postIdom map[basecfg.Point]basecfg.Point, pointA, pointB basecfg.Point) bool {
 	return Dominates(postIdom, pointA, pointB)