metadata: simplify summary accessors

Author: luoliwoshang

internal/metadata/format.go

@@ -9,10 +9,6 @@ import (
 
 // FormatMeta writes a stable human-readable representation for tests.
 func FormatMeta(w io.Writer, pm *PackageMeta) {
-	if pm == nil {
-		return
-	}
-
 	sym := func(s Symbol) string {
 		if int(s) < len(pm.stringTable) {
 			return pm.stringTable[s]

internal/metadata/global_summary.go

@@ -125,37 +125,37 @@ func (g *GlobalSummary) ConcreteTypes() []Symbol {
 
 // OrdinaryEdges returns direct ordinary references from sym.
 func (g *GlobalSummary) OrdinaryEdges(sym Symbol) []Symbol {
-	return cloneSymbols(g.ordinaryEdges[sym])
+	return g.ordinaryEdges[sym]
 }
 
 // TypeChildren returns child type symbols for typ.
 func (g *GlobalSummary) TypeChildren(typ Symbol) []Symbol {
-	return cloneSymbols(g.typeChildren[typ])
+	return g.typeChildren[typ]
 }
 
 // InterfaceMethods returns the method set for iface.
 func (g *GlobalSummary) InterfaceMethods(iface Symbol) []MethodSig {
-	return cloneMethodSigs(g.interfaceInfo[iface])
+	return g.interfaceInfo[iface]
 }
 
 // UseIface returns concrete types that enter interface semantics from fn.
 func (g *GlobalSummary) UseIface(fn Symbol) []Symbol {
-	return cloneSymbols(g.useIface[fn])
+	return g.useIface[fn]
 }
 
 // UseIfaceMethod returns interface method demands emitted by fn.
 func (g *GlobalSummary) UseIfaceMethod(fn Symbol) []IfaceMethodDemand {
-	return cloneIfaceMethodDemands(g.useIfaceMethod[fn])
+	return g.useIfaceMethod[fn]
 }
 
 // MethodSlots returns ABI method slots for typ.
 func (g *GlobalSummary) MethodSlots(typ Symbol) []MethodSlot {
-	return cloneMethodSlots(g.methodInfo[typ])
+	return g.methodInfo[typ]
 }
 
 // UseNamedMethod returns constant MethodByName names emitted by fn.
 func (g *GlobalSummary) UseNamedMethod(fn Symbol) []Name {
-	return cloneNames(g.useNamedMethod[fn])
+	return g.useNamedMethod[fn]
 }
 
 // HasReflectMethod reports whether fn triggers conservative reflection handling.
@@ -230,7 +230,7 @@ func (b *globalSummaryBuilder) addMethodSlots(typ Symbol, slots []MethodSlot) er
 		}
 		return fmt.Errorf("conflicting MethodInfo for %s", b.summary.SymbolName(typ))
 	}
-	b.summary.methodInfo[typ] = cloneMethodSlots(slots)
+	b.summary.methodInfo[typ] = slots
 	return nil
 }
 

internal/metadata/global_summary_test.go

@@ -77,6 +77,63 @@ func TestGlobalSummaryMergesLocalIDsByText(t *testing.T) {
 	}
 }
 
+func TestGlobalSummaryNameLookupsReturnEmptyStringForOutOfRangeIDs(t *testing.T) {
+	summary, err := NewGlobalSummary([]*PackageMeta{buildGlobalDuplicateFactsPackage()})
+	if err != nil {
+		t.Fatalf("NewGlobalSummary: %v", err)
+	}
+
+	if got := summary.SymbolName(Symbol(len(summary.stringTable))); got != "" {
+		t.Fatalf("SymbolName(out-of-range) = %q, want empty string", got)
+	}
+	if got := summary.Name(Name(len(summary.stringTable))); got != "" {
+		t.Fatalf("Name(out-of-range) = %q, want empty string", got)
+	}
+}
+
+func TestGlobalSummaryDeduplicatesMergedFacts(t *testing.T) {
+	pkgA := buildGlobalDuplicateFactsPackage()
+	pkgB := buildGlobalDuplicateFactsPackage()
+
+	summary, err := NewGlobalSummary([]*PackageMeta{pkgA, pkgB})
+	if err != nil {
+		t.Fatalf("NewGlobalSummary: %v", err)
+	}
+
+	main := mustLookupSymbol(t, summary, "pkg.main")
+	use := mustLookupSymbol(t, summary, "pkg.use")
+	typ := mustLookupSymbol(t, summary, "_llgo_pkg.T")
+	iface := mustLookupSymbol(t, summary, "_llgo_iface$I")
+	funcType := mustLookupSymbol(t, summary, "_llgo_func$M")
+	ifn := mustLookupSymbol(t, summary, "pkg.(*T).M")
+	tfn := mustLookupSymbol(t, summary, "pkg.T.M")
+	methodNames := summary.UseNamedMethod(use)
+	if len(methodNames) != 1 {
+		t.Fatalf("UseNamedMethod len = %d (%#v), want 1", len(methodNames), methodNames)
+	}
+	wantSig := MethodSig{Name: methodNames[0], MType: funcType}
+
+	if got := summary.OrdinaryEdges(main); !reflect.DeepEqual(got, []Symbol{use}) {
+		t.Fatalf("OrdinaryEdges(pkg.main) = %#v, want %#v", got, []Symbol{use})
+	}
+	if got := summary.TypeChildren(typ); !reflect.DeepEqual(got, []Symbol{funcType}) {
+		t.Fatalf("TypeChildren(_llgo_pkg.T) = %#v, want %#v", got, []Symbol{funcType})
+	}
+	if got := summary.InterfaceMethods(iface); !reflect.DeepEqual(got, []MethodSig{wantSig}) {
+		t.Fatalf("InterfaceMethods(_llgo_iface$I) = %#v, want %#v", got, []MethodSig{wantSig})
+	}
+	if got := summary.UseIface(main); !reflect.DeepEqual(got, []Symbol{typ}) {
+		t.Fatalf("UseIface(pkg.main) = %#v, want %#v", got, []Symbol{typ})
+	}
+	wantDemand := IfaceMethodDemand{Target: iface, Sig: wantSig}
+	if got := summary.UseIfaceMethod(use); !reflect.DeepEqual(got, []IfaceMethodDemand{wantDemand}) {
+		t.Fatalf("UseIfaceMethod(pkg.use) = %#v, want %#v", got, []IfaceMethodDemand{wantDemand})
+	}
+	if got := summary.MethodSlots(typ); !reflect.DeepEqual(got, []MethodSlot{{Sig: wantSig, IFn: ifn, TFn: tfn}}) {
+		t.Fatalf("MethodSlots(_llgo_pkg.T) = %#v", got)
+	}
+}
+
 func TestGlobalSummaryRejectsConflictingMethodSlots(t *testing.T) {
 	pkgA, _ := buildGlobalSummaryPkgB()
 
@@ -99,6 +156,28 @@ func TestGlobalSummaryRejectsConflictingMethodSlots(t *testing.T) {
 	}
 }
 
+func buildGlobalDuplicateFactsPackage() *PackageMeta {
+	b := NewBuilder()
+	main := b.Symbol("pkg.main")
+	use := b.Symbol("pkg.use")
+	typ := b.Symbol("_llgo_pkg.T")
+	iface := b.Symbol("_llgo_iface$I")
+	methodName := b.Name("M")
+	funcType := b.Symbol("_llgo_func$M")
+	ifn := b.Symbol("pkg.(*T).M")
+	tfn := b.Symbol("pkg.T.M")
+	sig := MethodSig{Name: methodName, MType: funcType}
+
+	b.AddEdge(main, use)
+	b.AddTypeChild(typ, funcType)
+	b.AddIfaceEntry(iface, []MethodSig{sig})
+	b.AddUseIface(main, []Symbol{typ})
+	b.AddUseIfaceMethod(use, []IfaceMethodDemand{{Target: iface, Sig: sig}})
+	b.AddUseNamedMethod(use, []Name{methodName})
+	b.AddMethodInfo(typ, []MethodSlot{{Sig: sig, IFn: ifn, TFn: tfn}})
+	return b.Build()
+}
+
 type globalSummaryRefs struct {
 	intType Symbol
 }

internal/metadata/meta.go

@@ -56,126 +56,74 @@ func NewPackageMeta(stringTable []string) *PackageMeta {
 	}
 }
 
-// StringTable returns a copy of the package-local string table.
-func (pm *PackageMeta) StringTable() []string {
-	if pm == nil {
-		return nil
-	}
-	return append([]string(nil), pm.stringTable...)
-}
-
 // SymbolName returns the string referenced by a Symbol.
 func (pm *PackageMeta) SymbolName(sym Symbol) string {
-	if pm == nil || int(sym) >= len(pm.stringTable) {
+	if int(sym) >= len(pm.stringTable) {
 		return ""
 	}
 	return pm.stringTable[sym]
 }
 
 // Name returns the string referenced by a Name.
 func (pm *PackageMeta) Name(ref Name) string {
-	if pm == nil || int(ref) >= len(pm.stringTable) {
+	if int(ref) >= len(pm.stringTable) {
 		return ""
 	}
 	return pm.stringTable[ref]
 }
 
 // ForEachOrdinaryEdge visits each ordinary reachability edge group.
 func (pm *PackageMeta) ForEachOrdinaryEdge(fn func(src Symbol, dsts []Symbol)) {
-	if pm == nil {
-		return
-	}
 	for src, dsts := range pm.ordinaryEdges {
-		fn(src, cloneSymbols(dsts))
+		fn(src, dsts)
 	}
 }
 
 // ForEachTypeChild visits each type-child edge group.
 func (pm *PackageMeta) ForEachTypeChild(fn func(parent Symbol, children []Symbol)) {
-	if pm == nil {
-		return
-	}
 	for parent, children := range pm.typeChildren {
-		fn(parent, cloneSymbols(children))
+		fn(parent, children)
 	}
 }
 
 // ForEachInterface visits each interface method set.
 func (pm *PackageMeta) ForEachInterface(fn func(iface Symbol, methods []MethodSig)) {
-	if pm == nil {
-		return
-	}
 	for iface, methods := range pm.interfaceInfo {
-		fn(iface, cloneMethodSigs(methods))
+		fn(iface, methods)
 	}
 }
 
 // ForEachUseIface visits each function's concrete types used as interfaces.
 func (pm *PackageMeta) ForEachUseIface(fn func(owner Symbol, types []Symbol)) {
-	if pm == nil {
-		return
-	}
 	for owner, types := range pm.useIface {
-		fn(owner, cloneSymbols(types))
+		fn(owner, types)
 	}
 }
 
 // ForEachUseIfaceMethod visits each function's interface method demands.
 func (pm *PackageMeta) ForEachUseIfaceMethod(fn func(owner Symbol, demands []IfaceMethodDemand)) {
-	if pm == nil {
-		return
-	}
 	for owner, demands := range pm.useIfaceMethod {
-		fn(owner, cloneIfaceMethodDemands(demands))
+		fn(owner, demands)
 	}
 }
 
 // ForEachMethodInfo visits each concrete type's method slots.
 func (pm *PackageMeta) ForEachMethodInfo(fn func(typ Symbol, slots []MethodSlot)) {
-	if pm == nil {
-		return
-	}
 	for typ, slots := range pm.methodInfo {
-		fn(typ, cloneMethodSlots(slots))
+		fn(typ, slots)
 	}
 }
 
 // ForEachUseNamedMethod visits each function's constant MethodByName names.
 func (pm *PackageMeta) ForEachUseNamedMethod(fn func(owner Symbol, names []Name)) {
-	if pm == nil {
-		return
-	}
 	for owner, names := range pm.useNamedMethod {
-		fn(owner, cloneNames(names))
+		fn(owner, names)
 	}
 }
 
 // ForEachReflectMethod visits each function that needs conservative reflection handling.
 func (pm *PackageMeta) ForEachReflectMethod(fn func(owner Symbol)) {
-	if pm == nil {
-		return
-	}
 	for owner := range pm.reflectMethod {
 		fn(owner)
 	}
 }
-
-func cloneSymbols(in []Symbol) []Symbol {
-	return append([]Symbol(nil), in...)
-}
-
-func cloneNames(in []Name) []Name {
-	return append([]Name(nil), in...)
-}
-
-func cloneMethodSigs(in []MethodSig) []MethodSig {
-	return append([]MethodSig(nil), in...)
-}
-
-func cloneIfaceMethodDemands(in []IfaceMethodDemand) []IfaceMethodDemand {
-	return append([]IfaceMethodDemand(nil), in...)
-}
-
-func cloneMethodSlots(in []MethodSlot) []MethodSlot {
-	return append([]MethodSlot(nil), in...)
-}

internal/metadata/metadata_test.go

@@ -41,6 +41,17 @@ func TestBuilderSeparatesSymbolAndNameReferences(t *testing.T) {
 	}
 }
 
+func TestPackageMetaNameLookupsReturnEmptyStringForOutOfRangeIDs(t *testing.T) {
+	pm := NewPackageMeta([]string{"main"})
+
+	if got := pm.SymbolName(Symbol(1)); got != "" {
+		t.Fatalf("SymbolName(out-of-range) = %q, want empty string", got)
+	}
+	if got := pm.Name(Name(1)); got != "" {
+		t.Fatalf("Name(out-of-range) = %q, want empty string", got)
+	}
+}
+
 func TestBuilderDeduplicatesFacts(t *testing.T) {
 	b := NewBuilder()
 	main := b.Symbol("main")
@@ -175,6 +186,26 @@ github.com/goplus/llgo/cl/_testmeta/interface_anonymous.use
 	}
 }
 
+func TestFormatMetaPrintsUnknownSymbolAndNameReferences(t *testing.T) {
+	pm := NewPackageMeta([]string{"owner"})
+	pm.useIface[Symbol(0)] = []Symbol{Symbol(2)}
+	pm.useNamedMethod[Symbol(0)] = []Name{Name(3)}
+
+	got := MetaString(pm)
+	want := `[UseIface]
+owner:
+    ?2
+
+[UseNamedMethod]
+owner:
+    ?3
+
+`
+	if got != want {
+		t.Fatalf("MetaString mismatch\ngot:\n%s\nwant:\n%s", got, want)
+	}
+}
+
 func assertSymbolGroup(t *testing.T, group string, pm *PackageMeta, visit func(func(Symbol, []Symbol)), key Symbol, want []Symbol) {
 	t.Helper()