@ctxo/lang-go 0.7.1 → 0.8.0

package/tools/ctxo-go-analyzer/internal/reach/reach.go

@@ -0,0 +1,332 @@
+// Package reach builds an SSA program, computes a Class Hierarchy Analysis
+// (CHA) callgraph, and returns the set of function/method symbols reachable
+// from a set of roots (main.main + init if binary; all exported API if
+// library).
+//
+// A reflect-safe post-pass grafts back methods on types that appear as
+// arguments to reflect.TypeOf / reflect.ValueOf / reflect.New or
+// json.Marshal/Unmarshal — the most common source of false-positive dead
+// code in Go codebases.
+//
+// Design note: ADR-013 originally specified RTA, but RTA panics on generic
+// code (golang/go issue). CHA is conservative (over-approximates reachability
+// through interface dispatch) which is preferable for dead-code detection —
+// it reduces false positives at the cost of slightly less precise liveness.
+// Analysis runs with a deadline per ADR-013 §4 Q3.
+package reach
+
+import (
+	"go/ast"
+	"go/token"
+	"go/types"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"golang.org/x/tools/go/callgraph"
+	"golang.org/x/tools/go/callgraph/cha"
+	"golang.org/x/tools/go/packages"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/ssa/ssautil"
+
+	"github.com/alperhankendi/ctxo/tools/ctxo-go-analyzer/internal/symbols"
+)
+
+// Result is the reachability snapshot. Reachable holds symbol IDs that are
+// transitively callable from the chosen roots. HasMain distinguishes binary
+// mode (precise) from library mode (approximated via exported API).
+type Result struct {
+	Reachable map[string]bool
+	HasMain   bool
+	Timeout   bool
+	Elapsed   time.Duration
+}
+
+// Analyze runs SSA + RTA against the loaded package set. deadline bounds the
+// RTA phase specifically (SSA build is always completed — it is cheap).
+func Analyze(rootDir string, pkgs []*packages.Package, deadline time.Duration) *Result {
+	start := time.Now()
+
+	prog, _ := ssautil.AllPackages(pkgs, ssa.BuilderMode(0))
+	prog.Build()
+
+	pkgByTypes := make(map[*types.Package]*packages.Package)
+	packages.Visit(pkgs, nil, func(p *packages.Package) {
+		if p.Types != nil {
+			pkgByTypes[p.Types] = p
+		}
+	})
+
+	roots, hasMain := collectRoots(prog, pkgs, rootDir)
+
+	result := &Result{Reachable: map[string]bool{}, HasMain: hasMain}
+
+	if len(roots) > 0 {
+		done := make(chan *callgraph.Graph, 1)
+		go func() {
+			// cha.CallGraph is synchronous and not cancellable — on timeout the
+			// goroutine leaks but the process exits shortly after.
+			done <- cha.CallGraph(prog)
+		}()
+
+		select {
+		case cg := <-done:
+			for fn := range reachableFromGraph(cg, roots) {
+				if id, ok := ssaFuncSymbolID(fn, rootDir); ok {
+					result.Reachable[id] = true
+				}
+			}
+		case <-time.After(deadline):
+			result.Timeout = true
+		}
+	}
+
+	applyReflectSafe(pkgs, pkgByTypes, rootDir, result.Reachable)
+
+	result.Elapsed = time.Since(start)
+	return result
+}
+
+// reachableFromGraph performs a BFS over the callgraph starting from the
+// provided root functions and returns the set of reachable *ssa.Function.
+func reachableFromGraph(cg *callgraph.Graph, roots []*ssa.Function) map[*ssa.Function]struct{} {
+	seen := make(map[*ssa.Function]struct{})
+	queue := make([]*ssa.Function, 0, len(roots))
+	for _, r := range roots {
+		if r != nil {
+			queue = append(queue, r)
+		}
+	}
+	for len(queue) > 0 {
+		fn := queue[0]
+		queue = queue[1:]
+		if _, ok := seen[fn]; ok {
+			continue
+		}
+		seen[fn] = struct{}{}
+		node := cg.Nodes[fn]
+		if node == nil {
+			continue
+		}
+		for _, edge := range node.Out {
+			if edge.Callee != nil && edge.Callee.Func != nil {
+				queue = append(queue, edge.Callee.Func)
+			}
+		}
+	}
+	return seen
+}
+
+// collectRoots returns the CHA entry set. Binary packages contribute their
+// main + init; when no main exists anywhere, every exported function/method
+// in the module becomes a root (library approximation).
+func collectRoots(prog *ssa.Program, pkgs []*packages.Package, rootDir string) ([]*ssa.Function, bool) {
+	var mains []*ssa.Function
+	var inits []*ssa.Function
+	packages.Visit(pkgs, nil, func(p *packages.Package) {
+		sp := prog.Package(p.Types)
+		if sp == nil {
+			return
+		}
+		if p.Name == "main" {
+			if main := sp.Func("main"); main != nil {
+				mains = append(mains, main)
+			}
+		}
+		if init := sp.Func("init"); init != nil {
+			inits = append(inits, init)
+		}
+	})
+
+	if len(mains) > 0 {
+		return append(mains, inits...), true
+	}
+
+	// Library mode — treat every module-local exported function/method as a root.
+	var roots []*ssa.Function
+	roots = append(roots, inits...)
+	packages.Visit(pkgs, nil, func(p *packages.Package) {
+		if !inModule(p, rootDir) {
+			return
+		}
+		sp := prog.Package(p.Types)
+		if sp == nil {
+			return
+		}
+		for _, member := range sp.Members {
+			switch m := member.(type) {
+			case *ssa.Function:
+				if isExported(m.Name()) {
+					roots = append(roots, m)
+				}
+			case *ssa.Type:
+				// Methods on a named type live on the method set, not the member map.
+				mset := prog.MethodSets.MethodSet(m.Type())
+				for i := 0; i < mset.Len(); i++ {
+					fn := prog.MethodValue(mset.At(i))
+					if fn != nil && isExported(fn.Name()) {
+						roots = append(roots, fn)
+					}
+				}
+				// Also pointer receiver methods.
+				ptrSet := prog.MethodSets.MethodSet(types.NewPointer(m.Type()))
+				for i := 0; i < ptrSet.Len(); i++ {
+					fn := prog.MethodValue(ptrSet.At(i))
+					if fn != nil && isExported(fn.Name()) {
+						roots = append(roots, fn)
+					}
+				}
+			}
+		}
+	})
+	return roots, false
+}
+
+// applyReflectSafe grafts method symbols of reflect-accessed types back into
+// the reachable set. Scope is conservative: reflect.TypeOf, reflect.ValueOf,
+// reflect.New, and json.Unmarshal / json.NewDecoder arguments.
+func applyReflectSafe(pkgs []*packages.Package, pkgByTypes map[*types.Package]*packages.Package, rootDir string, reachable map[string]bool) {
+	safe := make(map[*types.Named]struct{})
+	for _, p := range pkgs {
+		if p.TypesInfo == nil {
+			continue
+		}
+		for _, f := range p.Syntax {
+			ast.Inspect(f, func(n ast.Node) bool {
+				call, ok := n.(*ast.CallExpr)
+				if !ok {
+					return true
+				}
+				if !isReflectOrJSONCall(call, p.TypesInfo) {
+					return true
+				}
+				if len(call.Args) == 0 {
+					return true
+				}
+				t := p.TypesInfo.TypeOf(call.Args[0])
+				if t == nil {
+					return true
+				}
+				if ptr, ok := t.(*types.Pointer); ok {
+					t = ptr.Elem()
+				}
+				if named, ok := t.(*types.Named); ok {
+					safe[named] = struct{}{}
+				}
+				return true
+			})
+		}
+	}
+
+	for named := range safe {
+		addMethodsToReachable(named, pkgByTypes, rootDir, reachable)
+	}
+}
+
+func isReflectOrJSONCall(call *ast.CallExpr, info *types.Info) bool {
+	sel, ok := call.Fun.(*ast.SelectorExpr)
+	if !ok {
+		return false
+	}
+	x, ok := sel.X.(*ast.Ident)
+	if !ok {
+		return false
+	}
+	obj := info.Uses[x]
+	pn, ok := obj.(*types.PkgName)
+	if !ok {
+		return false
+	}
+	path := pn.Imported().Path()
+	switch path {
+	case "reflect":
+		switch sel.Sel.Name {
+		case "TypeOf", "ValueOf", "New":
+			return true
+		}
+	case "encoding/json":
+		switch sel.Sel.Name {
+		case "Unmarshal", "NewDecoder", "Marshal", "NewEncoder":
+			return true
+		}
+	}
+	return false
+}
+
+func addMethodsToReachable(n *types.Named, pkgByTypes map[*types.Package]*packages.Package, rootDir string, reachable map[string]bool) {
+	pkg := pkgByTypes[n.Obj().Pkg()]
+	if pkg == nil || pkg.Fset == nil {
+		return
+	}
+	for i := 0; i < n.NumMethods(); i++ {
+		m := n.Method(i)
+		rel := relFile(pkg.Fset, m.Pos(), rootDir)
+		if rel == "" {
+			continue
+		}
+		name := n.Obj().Name() + "." + m.Name()
+		reachable[symbols.SymbolID(rel, name, "method")] = true
+	}
+}
+
+// ssaFuncSymbolID maps an *ssa.Function back to the Ctxo symbol id format
+// used by the symbols/edges passes. Anonymous closures and synthetic
+// wrappers are filtered by their missing source position.
+func ssaFuncSymbolID(fn *ssa.Function, rootDir string) (string, bool) {
+	if fn == nil || fn.Pos() == token.NoPos || fn.Prog == nil {
+		return "", false
+	}
+	file := fn.Prog.Fset.File(fn.Pos())
+	if file == nil {
+		return "", false
+	}
+	rel, err := filepath.Rel(rootDir, file.Name())
+	if err != nil || strings.HasPrefix(rel, "..") {
+		return "", false
+	}
+	rel = filepath.ToSlash(rel)
+
+	name := fn.Name()
+	kind := "function"
+	if fn.Signature != nil && fn.Signature.Recv() != nil {
+		if recv := receiverName(fn.Signature.Recv().Type()); recv != "" {
+			name = recv + "." + fn.Name()
+			kind = "method"
+		}
+	}
+	return symbols.SymbolID(rel, name, kind), true
+}
+
+func receiverName(t types.Type) string {
+	if p, ok := t.(*types.Pointer); ok {
+		t = p.Elem()
+	}
+	if n, ok := t.(*types.Named); ok {
+		return n.Obj().Name()
+	}
+	return ""
+}
+
+func inModule(p *packages.Package, rootDir string) bool {
+	if len(p.GoFiles) == 0 {
+		return false
+	}
+	rel, err := filepath.Rel(rootDir, p.GoFiles[0])
+	return err == nil && !strings.HasPrefix(rel, "..")
+}
+
+func isExported(name string) bool {
+	return name != "" && name[0] >= 'A' && name[0] <= 'Z'
+}
+
+func relFile(fset *token.FileSet, pos token.Pos, rootDir string) string {
+	p := fset.Position(pos)
+	if !p.IsValid() {
+		return ""
+	}
+	rel, err := filepath.Rel(rootDir, p.Filename)
+	if err != nil || strings.HasPrefix(rel, "..") {
+		return ""
+	}
+	return filepath.ToSlash(rel)
+}

package/tools/ctxo-go-analyzer/internal/reach/reach_test.go

@@ -0,0 +1,142 @@
+package reach
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/alperhankendi/ctxo/tools/ctxo-go-analyzer/internal/load"
+)
+
+func TestBinaryReachability(t *testing.T) {
+	dir := writeFixture(t, map[string]string{
+		"go.mod": "module fixture\n\ngo 1.22\n",
+		"main.go": `package main
+
+func used() string { return "alive" }
+func dead() string { return "never called" }
+
+func main() { _ = used() }
+`,
+	})
+
+	r := analyze(t, dir)
+	if !r.HasMain {
+		t.Fatal("expected HasMain=true for binary fixture")
+	}
+	if !r.Reachable["main.go::main::function"] {
+		t.Error("main should be reachable")
+	}
+	if !r.Reachable["main.go::used::function"] {
+		t.Error("used() should be reachable")
+	}
+	if r.Reachable["main.go::dead::function"] {
+		t.Error("dead() must not be reachable")
+	}
+}
+
+func TestLibraryMode(t *testing.T) {
+	dir := writeFixture(t, map[string]string{
+		"go.mod": "module fixture\n\ngo 1.22\n",
+		"lib.go": `package fixture
+
+func Public() int { return internal() }
+func internal() int { return 1 }
+func Orphan() int { return 2 }  // exported but with no internal callers — still reachable as library root
+func _unused() int { return 3 } // not exported, no callers
+
+type Box struct{}
+func (Box) Shake() {}     // exported method — reachable
+func (Box) hide()   {}    // unexported — not reachable unless called
+`,
+	})
+
+	r := analyze(t, dir)
+	if r.HasMain {
+		t.Fatal("expected library mode")
+	}
+	if !r.Reachable["lib.go::Public::function"] {
+		t.Error("Public must be reachable (library root)")
+	}
+	if !r.Reachable["lib.go::internal::function"] {
+		t.Error("internal must be reachable (called by Public)")
+	}
+	if !r.Reachable["lib.go::Orphan::function"] {
+		t.Error("Orphan must be reachable (library root)")
+	}
+	if !r.Reachable["lib.go::Box.Shake::method"] {
+		t.Error("Box.Shake must be reachable (exported method root)")
+	}
+}
+
+func TestReflectSafe(t *testing.T) {
+	dir := writeFixture(t, map[string]string{
+		"go.mod": "module fixture\n\ngo 1.22\n",
+		"main.go": `package main
+
+import "reflect"
+
+type Target struct{}
+func (Target) UsedViaReflect() {}  // never called, but accessed via reflect
+func (Target) AlsoReflective()  {}
+
+func main() { _ = reflect.TypeOf(Target{}) }
+`,
+	})
+	r := analyze(t, dir)
+	if !r.Reachable["main.go::Target.UsedViaReflect::method"] {
+		t.Error("reflect.TypeOf(Target{}) should mark Target methods reachable")
+	}
+	if !r.Reachable["main.go::Target.AlsoReflective::method"] {
+		t.Error("reflect-accessed types promote all methods")
+	}
+}
+
+func TestJSONUnmarshalSafe(t *testing.T) {
+	dir := writeFixture(t, map[string]string{
+		"go.mod": "module fixture\n\ngo 1.22\n",
+		"main.go": `package main
+
+import "encoding/json"
+
+type Payload struct{ Name string }
+func (Payload) String() string { return "p" }
+
+func main() {
+	var p Payload
+	_ = json.Unmarshal([]byte("{}"), &p)
+}
+`,
+	})
+	r := analyze(t, dir)
+	if !r.Reachable["main.go::Payload.String::method"] {
+		t.Error("json.Unmarshal argument type methods must be reachable")
+	}
+}
+
+// ── helpers ──
+
+func analyze(t *testing.T, dir string) *Result {
+	t.Helper()
+	res := load.Packages(dir)
+	if res.FatalError != nil {
+		t.Fatal(res.FatalError)
+	}
+	return Analyze(dir, res.Packages, 30*time.Second)
+}
+
+func writeFixture(t *testing.T, files map[string]string) string {
+	t.Helper()
+	dir := t.TempDir()
+	for name, body := range files {
+		path := filepath.Join(dir, name)
+		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return dir
+}

package/tools/ctxo-go-analyzer/internal/symbols/symbols.go

@@ -0,0 +1,172 @@
+// Package symbols walks a loaded *packages.Package and produces emit.Symbol
+// records grouped by source file. Maps Go declarations onto the kinds defined
+// by @ctxo/plugin-api: function | class | interface | method | variable | type.
+package symbols
+
+import (
+	"go/ast"
+	"go/token"
+	"path/filepath"
+	"sort"
+	"strings"
+
+	"golang.org/x/tools/go/packages"
+
+	"github.com/alperhankendi/ctxo/tools/ctxo-go-analyzer/internal/emit"
+)
+
+// FileSymbols groups extracted symbols by the source file that declared them.
+// RelPath is project-root-relative with forward-slash separators so it composes
+// cleanly with the Ctxo symbol-id format on every platform.
+type FileSymbols struct {
+	RelPath string
+	Symbols []emit.Symbol
+}
+
+// Extract walks every parsed file in the package and emits one Symbol per
+// top-level declaration. Unexported names flow through; only the blank
+// identifier "_" is skipped.
+func Extract(pkg *packages.Package, rootDir string) []FileSymbols {
+	if pkg == nil || pkg.Fset == nil {
+		return nil
+	}
+
+	byFile := make(map[string]*FileSymbols)
+	getOrCreate := func(rel string) *FileSymbols {
+		if fs, ok := byFile[rel]; ok {
+			return fs
+		}
+		fs := &FileSymbols{RelPath: rel}
+		byFile[rel] = fs
+		return fs
+	}
+
+	for _, file := range pkg.Syntax {
+		rel := relativeFile(pkg.Fset, file, rootDir)
+		if rel == "" {
+			continue
+		}
+		fs := getOrCreate(rel)
+
+		for _, decl := range file.Decls {
+			switch d := decl.(type) {
+			case *ast.FuncDecl:
+				if d.Name == nil || d.Name.Name == "_" {
+					continue
+				}
+				kind := "function"
+				name := d.Name.Name
+				if d.Recv != nil && len(d.Recv.List) > 0 {
+					recv := receiverTypeName(d.Recv.List[0].Type)
+					if recv != "" {
+						name = recv + "." + d.Name.Name
+					}
+					kind = "method"
+				}
+				fs.Symbols = append(fs.Symbols, makeSymbol(pkg.Fset, rel, name, kind, d.Pos(), d.End()))
+
+			case *ast.GenDecl:
+				switch d.Tok {
+				case token.TYPE:
+					for _, spec := range d.Specs {
+						ts, ok := spec.(*ast.TypeSpec)
+						if !ok || ts.Name == nil || ts.Name.Name == "_" {
+							continue
+						}
+						kind := typeSpecKind(ts.Type)
+						fs.Symbols = append(fs.Symbols, makeSymbol(pkg.Fset, rel, ts.Name.Name, kind, ts.Pos(), ts.End()))
+					}
+				case token.VAR, token.CONST:
+					for _, spec := range d.Specs {
+						vs, ok := spec.(*ast.ValueSpec)
+						if !ok {
+							continue
+						}
+						for _, n := range vs.Names {
+							if n.Name == "_" {
+								continue
+							}
+							fs.Symbols = append(fs.Symbols, makeSymbol(pkg.Fset, rel, n.Name, "variable", n.Pos(), n.End()))
+						}
+					}
+				}
+			}
+		}
+	}
+
+	out := make([]FileSymbols, 0, len(byFile))
+	for _, v := range byFile {
+		sort.SliceStable(v.Symbols, func(i, j int) bool {
+			return v.Symbols[i].StartLine < v.Symbols[j].StartLine
+		})
+		out = append(out, *v)
+	}
+	sort.Slice(out, func(i, j int) bool { return out[i].RelPath < out[j].RelPath })
+	return out
+}
+
+// SymbolID composes the deterministic Ctxo symbol-id format.
+func SymbolID(relFile, name, kind string) string {
+	return relFile + "::" + name + "::" + kind
+}
+
+// receiverTypeName strips pointer indirection and generic instantiation from
+// a method receiver, returning the bare type name. Returns empty when the
+// expression cannot be reduced to a single identifier.
+func receiverTypeName(expr ast.Expr) string {
+	for {
+		switch x := expr.(type) {
+		case *ast.StarExpr:
+			expr = x.X
+		case *ast.IndexExpr: // generic with one type param: List[T]
+			expr = x.X
+		case *ast.IndexListExpr: // generic with multiple type params: Map[K, V]
+			expr = x.X
+		case *ast.Ident:
+			return x.Name
+		default:
+			return ""
+		}
+	}
+}
+
+func typeSpecKind(expr ast.Expr) string {
+	switch expr.(type) {
+	case *ast.StructType:
+		return "class"
+	case *ast.InterfaceType:
+		return "interface"
+	default:
+		return "type"
+	}
+}
+
+func makeSymbol(fset *token.FileSet, rel, name, kind string, pos, end token.Pos) emit.Symbol {
+	startPos := fset.Position(pos)
+	endPos := fset.Position(end)
+	startOffset := startPos.Offset
+	endOffset := endPos.Offset
+	return emit.Symbol{
+		SymbolID:    SymbolID(rel, name, kind),
+		Name:        name,
+		Kind:        kind,
+		StartLine:   startPos.Line,
+		EndLine:     endPos.Line,
+		StartOffset: &startOffset,
+		EndOffset:   &endOffset,
+	}
+}
+
+func relativeFile(fset *token.FileSet, file *ast.File, rootDir string) string {
+	tf := fset.File(file.Pos())
+	if tf == nil {
+		return ""
+	}
+	abs := tf.Name()
+	rel, err := filepath.Rel(rootDir, abs)
+	if err != nil || strings.HasPrefix(rel, "..") {
+		// Outside the module root (likely a stdlib or external dep) — skip.
+		return ""
+	}
+	return filepath.ToSlash(rel)
+}