@ctxo/lang-go 0.7.1 → 0.8.0

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

@@ -0,0 +1,159 @@
+package symbols
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/alperhankendi/ctxo/tools/ctxo-go-analyzer/internal/load"
+)
+
+func TestExtract(t *testing.T) {
+	dir := writeFixture(t, map[string]string{
+		"go.mod": "module fixture\n\ngo 1.22\n",
+		"a.go": `package fixture
+
+// Top-level function (exported)
+func Hello() string { return "hi" }
+
+// Unexported function — should still surface (no exported-only filter)
+func helper() {}
+
+// Variables and constants
+var Counter = 0
+const Tag = "release"
+
+// Blank identifier — must be skipped
+var _ = "ignore"
+`,
+		"types.go": `package fixture
+
+type User struct {
+	Name string
+}
+
+type Greeter interface {
+	Greet() string
+}
+
+type ID = string
+
+// Method with pointer receiver
+func (u *User) Greet() string { return "hi " + u.Name }
+
+// Method with value receiver
+func (u User) ID() string { return u.Name }
+`,
+	})
+
+	res := load.Packages(dir)
+	if res.FatalError != nil {
+		t.Fatalf("Packages: %v", res.FatalError)
+	}
+	if len(res.Packages) == 0 {
+		t.Fatal("no packages loaded")
+	}
+
+	all := map[string]string{} // name -> kind
+	files := map[string]bool{}
+	for _, pkg := range res.Packages {
+		for _, fs := range Extract(pkg, dir) {
+			files[fs.RelPath] = true
+			for _, s := range fs.Symbols {
+				all[s.Name] = s.Kind
+				if s.StartLine == 0 {
+					t.Errorf("symbol %s missing StartLine", s.Name)
+				}
+				if s.StartOffset == nil || s.EndOffset == nil {
+					t.Errorf("symbol %s missing offsets", s.Name)
+				}
+				wantID := SymbolID(fs.RelPath, s.Name, s.Kind)
+				if s.SymbolID != wantID {
+					t.Errorf("symbol %s id=%q want %q", s.Name, s.SymbolID, wantID)
+				}
+			}
+		}
+	}
+
+	expected := map[string]string{
+		"Hello":   "function",
+		"helper":  "function",
+		"Counter": "variable",
+		"Tag":     "variable",
+		"User":    "class",
+		"Greeter": "interface",
+		"ID":      "type",
+		// Methods qualified with receiver
+		"User.Greet": "method",
+		"User.ID":    "method",
+	}
+	for name, kind := range expected {
+		got, ok := all[name]
+		if !ok {
+			t.Errorf("missing symbol %s", name)
+			continue
+		}
+		if got != kind {
+			t.Errorf("symbol %s kind=%s want %s", name, got, kind)
+		}
+	}
+
+	if _, ok := all["_"]; ok {
+		t.Error("blank identifier should be skipped")
+	}
+
+	for f := range files {
+		if !strings.HasSuffix(f, ".go") {
+			t.Errorf("relative path not normalized: %s", f)
+		}
+		if strings.Contains(f, "\\") {
+			t.Errorf("relative path uses backslash: %s", f)
+		}
+	}
+}
+
+func TestReceiverTypeName(t *testing.T) {
+	dir := writeFixture(t, map[string]string{
+		"go.mod": "module fixture\n\ngo 1.22\n",
+		"a.go": `package fixture
+
+type Box[T any] struct{ v T }
+
+func (b *Box[T]) Get() T { return b.v }
+`,
+	})
+	res := load.Packages(dir)
+	if res.FatalError != nil {
+		t.Fatal(res.FatalError)
+	}
+
+	found := false
+	for _, pkg := range res.Packages {
+		for _, fs := range Extract(pkg, dir) {
+			for _, s := range fs.Symbols {
+				if s.Name == "Box.Get" && s.Kind == "method" {
+					found = true
+				}
+			}
+		}
+	}
+	if !found {
+		t.Error("expected method Box.Get with generic receiver")
+	}
+}
+
+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/main.go

@@ -0,0 +1,183 @@
+// ctxo-go-analyzer is the full-tier Go analysis binary bundled inside the
+// @ctxo/lang-go npm package. It loads a module via golang.org/x/tools/go/packages,
+// walks ASTs with full type info, and emits JSONL describing symbols, edges,
+// and reachability on stdout.
+//
+// The TypeScript composite adapter in packages/lang-go/src/analyzer/ spawns
+// this binary in batch mode per index run.
+package main
+
+import (
+	"flag"
+	"fmt"
+	"go/ast"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"time"
+
+	"golang.org/x/tools/go/packages"
+
+	"github.com/alperhankendi/ctxo/tools/ctxo-go-analyzer/internal/edges"
+	"github.com/alperhankendi/ctxo/tools/ctxo-go-analyzer/internal/emit"
+	"github.com/alperhankendi/ctxo/tools/ctxo-go-analyzer/internal/extends"
+	"github.com/alperhankendi/ctxo/tools/ctxo-go-analyzer/internal/implements"
+	"github.com/alperhankendi/ctxo/tools/ctxo-go-analyzer/internal/load"
+	"github.com/alperhankendi/ctxo/tools/ctxo-go-analyzer/internal/reach"
+	"github.com/alperhankendi/ctxo/tools/ctxo-go-analyzer/internal/symbols"
+)
+
+const reachDeadline = 60 * time.Second
+
+const version = "0.8.0-alpha.0"
+
+func main() {
+	root := flag.String("root", "", "module root to analyze (required)")
+	showVersion := flag.Bool("version", false, "print version and exit")
+	flag.Parse()
+
+	if *showVersion {
+		fmt.Println(version)
+		return
+	}
+
+	if *root == "" {
+		fmt.Fprintln(os.Stderr, "ctxo-go-analyzer: --root is required")
+		os.Exit(2)
+	}
+
+	if err := run(*root, os.Stdout); err != nil {
+		fmt.Fprintln(os.Stderr, "ctxo-go-analyzer:", err)
+		os.Exit(1)
+	}
+}
+
+type fileAggregate struct {
+	symbols []emit.Symbol
+	edges   []emit.Edge
+}
+
+func run(root string, stdout *os.File) error {
+	w := emit.NewWriter(stdout)
+	start := time.Now()
+
+	if err := w.Progress(fmt.Sprintf("analyzer v%s loading %s", version, root)); err != nil {
+		return err
+	}
+
+	res := load.PackagesWithFallback(root)
+	if res.FatalError != nil {
+		_ = w.Progress(fmt.Sprintf("module load returned a fatal error (degrading): %v", res.FatalError))
+	}
+	if res.FallbackUsed {
+		_ = w.Progress(fmt.Sprintf("root pattern failed; per-subdir fallback recovered %d packages", len(res.Packages)))
+	}
+	if len(res.Errors) > 0 {
+		_ = w.Progress(fmt.Sprintf("load reported %d package-level errors (continuing)", len(res.Errors)))
+	}
+
+	byFile := make(map[string]*fileAggregate)
+	get := func(rel string) *fileAggregate {
+		if agg, ok := byFile[rel]; ok {
+			return agg
+		}
+		agg := &fileAggregate{}
+		byFile[rel] = agg
+		return agg
+	}
+
+	for _, pkg := range res.Packages {
+		for _, fs := range symbols.Extract(pkg, root) {
+			get(fs.RelPath).symbols = append(get(fs.RelPath).symbols, fs.Symbols...)
+		}
+	}
+
+	ext := edges.NewExtractor(root, res.Packages)
+	for _, pkg := range res.Packages {
+		for _, file := range pkg.Syntax {
+			rel := relativeFile(pkg, file, root)
+			if rel == "" {
+				continue
+			}
+			get(rel).edges = append(get(rel).edges, ext.Extract(pkg, file)...)
+		}
+	}
+
+	for rel, implEdges := range implements.Extract(root, res.Packages) {
+		get(rel).edges = append(get(rel).edges, implEdges...)
+	}
+
+	for rel, extEdges := range extends.Extract(root, res.Packages) {
+		get(rel).edges = append(get(rel).edges, extEdges...)
+	}
+
+	paths := make([]string, 0, len(byFile))
+	for p := range byFile {
+		paths = append(paths, p)
+	}
+	sort.Strings(paths)
+	for _, p := range paths {
+		agg := byFile[p]
+		if err := w.File(emit.FileRecord{
+			File:    p,
+			Symbols: agg.symbols,
+			Edges:   agg.edges,
+		}); err != nil {
+			return err
+		}
+	}
+
+	reachRes := reach.Analyze(root, res.Packages, reachDeadline)
+	deadIDs := collectDead(byFile, reachRes.Reachable)
+	if err := w.Dead(emit.Dead{
+		SymbolIDs: deadIDs,
+		HasMain:   reachRes.HasMain,
+		Timeout:   reachRes.Timeout,
+	}); err != nil {
+		return err
+	}
+	if reachRes.Timeout {
+		_ = w.Progress("reachability analysis exceeded deadline; dead-code precision degraded")
+	}
+
+	return w.Summary(emit.Summary{
+		TotalFiles: len(paths),
+		Elapsed:    time.Since(start).String(),
+	})
+}
+
+// collectDead walks every function/method symbol across the module and
+// returns the subset not present in the reachable set. Non-callable kinds
+// (type/variable/class/interface) are excluded — CHA gives us liveness for
+// callable symbols only.
+func collectDead(byFile map[string]*fileAggregate, reachable map[string]bool) []string {
+	var dead []string
+	for _, agg := range byFile {
+		for _, s := range agg.symbols {
+			if s.Kind != "function" && s.Kind != "method" {
+				continue
+			}
+			if !reachable[s.SymbolID] {
+				dead = append(dead, s.SymbolID)
+			}
+		}
+	}
+	sort.Strings(dead)
+	return dead
+}
+
+func relativeFile(pkg *packages.Package, file *ast.File, root string) string {
+	if pkg.Fset == nil {
+		return ""
+	}
+	tf := pkg.Fset.File(file.Pos())
+	if tf == nil {
+		return ""
+	}
+	rel, err := filepath.Rel(root, tf.Name())
+	if err != nil || strings.HasPrefix(rel, "..") {
+		return ""
+	}
+	return filepath.ToSlash(rel)
+}