@ctxo/lang-go 0.7.1 → 0.8.0

package/tools/ctxo-go-analyzer/internal/extends/extends_test.go

@@ -0,0 +1,141 @@
+package extends
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/alperhankendi/ctxo/tools/ctxo-go-analyzer/internal/load"
+)
+
+func TestStructEmbedding(t *testing.T) {
+	dir := writeFixture(t, map[string]string{
+		"go.mod": "module fixture\n\ngo 1.22\n",
+		"a.go": `package fixture
+
+type Base struct {
+	ID string
+}
+
+// Child embeds Base (value embedding).
+type Child struct {
+	Base
+	Extra int
+}
+
+// Pointer embedding.
+type PointerChild struct {
+	*Base
+}
+
+// Named field — NOT embedded.
+type NotChild struct {
+	B Base
+}
+`,
+	})
+
+	edges := extractAll(t, dir)
+
+	want := []string{
+		"a.go::Child::class -> a.go::Base::class (extends)",
+		"a.go::PointerChild::class -> a.go::Base::class (extends)",
+	}
+	for _, w := range want {
+		if !edges[w] {
+			t.Errorf("missing: %s\n  got: %v", w, edges)
+		}
+	}
+	if edges["a.go::NotChild::class -> a.go::Base::class (extends)"] {
+		t.Error("named field must not be treated as embedding")
+	}
+}
+
+func TestInterfaceEmbedding(t *testing.T) {
+	dir := writeFixture(t, map[string]string{
+		"go.mod": "module fixture\n\ngo 1.22\n",
+		"a.go": `package fixture
+
+type Reader interface { Read() }
+type Writer interface { Write() }
+
+type ReadWriter interface {
+	Reader
+	Writer
+}
+`,
+	})
+
+	edges := extractAll(t, dir)
+
+	want := []string{
+		"a.go::ReadWriter::interface -> a.go::Reader::interface (extends)",
+		"a.go::ReadWriter::interface -> a.go::Writer::interface (extends)",
+	}
+	for _, w := range want {
+		if !edges[w] {
+			t.Errorf("missing: %s\n  got: %v", w, edges)
+		}
+	}
+}
+
+func TestSkipStdlibEmbedding(t *testing.T) {
+	dir := writeFixture(t, map[string]string{
+		"go.mod": "module fixture\n\ngo 1.22\n",
+		"a.go": `package fixture
+
+import "sync"
+
+type Guarded struct {
+	sync.Mutex
+}
+`,
+	})
+	edges := extractAll(t, dir)
+	for key := range edges {
+		if contains(key, "sync.") || contains(key, "Mutex") {
+			t.Errorf("stdlib embedding leaked: %s", key)
+		}
+	}
+}
+
+// ── helpers ──
+
+func extractAll(t *testing.T, dir string) map[string]bool {
+	t.Helper()
+	res := load.Packages(dir)
+	if res.FatalError != nil {
+		t.Fatal(res.FatalError)
+	}
+	out := map[string]bool{}
+	for _, list := range Extract(dir, res.Packages) {
+		for _, e := range list {
+			out[e.From+" -> "+e.To+" ("+e.Kind+")"] = true
+		}
+	}
+	return out
+}
+
+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
+}
+
+func contains(s, sub string) bool {
+	for i := 0; i+len(sub) <= len(s); i++ {
+		if s[i:i+len(sub)] == sub {
+			return true
+		}
+	}
+	return false
+}

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

@@ -0,0 +1,115 @@
+// Package implements derives interface-satisfaction edges by pairing every
+// concrete named type in the module against every module-local interface and
+// consulting go/types. Go's structural typing means this is the only way to
+// recover `implements` relations — there is no `implements` keyword to walk.
+package implements
+
+import (
+	"go/token"
+	"go/types"
+	"path/filepath"
+	"strings"
+
+	"golang.org/x/tools/go/packages"
+
+	"github.com/alperhankendi/ctxo/tools/ctxo-go-analyzer/internal/emit"
+	"github.com/alperhankendi/ctxo/tools/ctxo-go-analyzer/internal/symbols"
+)
+
+// Extract returns `implements` edges grouped by the source file of the
+// concrete type. Both sides of each edge are guaranteed to live inside the
+// module root — external interfaces and stdlib types are skipped.
+func Extract(rootDir string, pkgs []*packages.Package) map[string][]emit.Edge {
+	type typed struct {
+		named *types.Named
+		file  string
+	}
+
+	var concretes []typed
+	var ifaces []typed
+
+	packages.Visit(pkgs, nil, func(p *packages.Package) {
+		if p.Types == nil || p.Fset == nil {
+			return
+		}
+		scope := p.Types.Scope()
+		for _, name := range scope.Names() {
+			if name == "_" {
+				continue
+			}
+			obj := scope.Lookup(name)
+			tn, ok := obj.(*types.TypeName)
+			if !ok {
+				continue
+			}
+			named, ok := tn.Type().(*types.Named)
+			if !ok {
+				continue
+			}
+			// Generic types are bucketed once, without instantiation — consistent
+			// with the ADR-013 §4 generics decision.
+			if named.TypeParams() != nil && named.TypeParams().Len() > 0 {
+				continue
+			}
+			rel := relFile(p.Fset, obj.Pos(), rootDir)
+			if rel == "" {
+				continue
+			}
+			entry := typed{named: named, file: rel}
+			if _, isIface := named.Underlying().(*types.Interface); isIface {
+				ifaces = append(ifaces, entry)
+			} else {
+				concretes = append(concretes, entry)
+			}
+		}
+	})
+
+	out := map[string][]emit.Edge{}
+	for _, iface := range ifaces {
+		iUnder := iface.named.Underlying().(*types.Interface)
+		if iUnder.NumMethods() == 0 {
+			// Empty interfaces (any, comparable-without-methods) are satisfied by
+			// every type — skipping keeps the graph useful.
+			continue
+		}
+		ifaceID := symbols.SymbolID(iface.file, iface.named.Obj().Name(), "interface")
+
+		for _, c := range concretes {
+			concreteID := symbols.SymbolID(c.file, c.named.Obj().Name(), kindOf(c.named))
+			if concreteID == ifaceID {
+				continue
+			}
+			if types.Implements(c.named, iUnder) || types.Implements(types.NewPointer(c.named), iUnder) {
+				out[c.file] = append(out[c.file], emit.Edge{
+					From: concreteID,
+					To:   ifaceID,
+					Kind: "implements",
+				})
+			}
+		}
+	}
+	return out
+}
+
+func kindOf(n *types.Named) string {
+	switch n.Underlying().(type) {
+	case *types.Struct:
+		return "class"
+	case *types.Interface:
+		return "interface"
+	default:
+		return "type"
+	}
+}
+
+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/implements/implements_test.go

@@ -0,0 +1,141 @@
+package implements
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/alperhankendi/ctxo/tools/ctxo-go-analyzer/internal/load"
+)
+
+func TestExtractSatisfiesInterface(t *testing.T) {
+	dir := writeFixture(t, map[string]string{
+		"go.mod": "module fixture\n\ngo 1.22\n",
+		"types.go": `package fixture
+
+type Greeter interface {
+	Greet() string
+}
+
+// Value-receiver implementation.
+type Hello struct{}
+func (h Hello) Greet() string { return "hello" }
+
+// Pointer-receiver implementation.
+type Ciao struct{}
+func (c *Ciao) Greet() string { return "ciao" }
+
+// Non-implementer — missing Greet.
+type Silent struct{}
+
+// Empty interface — edges to it must NOT be emitted.
+type Any interface{}
+
+// Interface-to-interface — should not produce implements edge.
+type LoudGreeter interface {
+	Greeter
+	Shout()
+}
+`,
+	})
+
+	res := load.Packages(dir)
+	if res.FatalError != nil {
+		t.Fatal(res.FatalError)
+	}
+
+	out := Extract(dir, res.Packages)
+
+	edges := map[string]bool{}
+	for _, list := range out {
+		for _, e := range list {
+			edges[e.From+" -> "+e.To+" ("+e.Kind+")"] = true
+		}
+	}
+
+	mustHave := []string{
+		"types.go::Hello::class -> types.go::Greeter::interface (implements)",
+		"types.go::Ciao::class -> types.go::Greeter::interface (implements)",
+	}
+	for _, want := range mustHave {
+		if !edges[want] {
+			t.Errorf("missing edge: %s\n  got: %v", want, edges)
+		}
+	}
+
+	mustNotHave := []string{
+		"types.go::Silent::class -> types.go::Greeter::interface (implements)",
+	}
+	for _, bad := range mustNotHave {
+		if edges[bad] {
+			t.Errorf("unexpected edge: %s", bad)
+		}
+	}
+
+	for key := range edges {
+		if containsSubstring(key, "Any::interface") {
+			t.Errorf("empty-interface edge leaked: %s", key)
+		}
+	}
+}
+
+func TestNonStructNamedType(t *testing.T) {
+	dir := writeFixture(t, map[string]string{
+		"go.mod": "module fixture\n\ngo 1.22\n",
+		"a.go": `package fixture
+
+type Stringer interface { String() string }
+
+// Non-struct named type — underlying is string, but it has methods.
+type ID string
+
+func (i ID) String() string { return string(i) }
+`,
+	})
+
+	res := load.Packages(dir)
+	if res.FatalError != nil {
+		t.Fatal(res.FatalError)
+	}
+	out := Extract(dir, res.Packages)
+
+	got := false
+	for _, list := range out {
+		for _, e := range list {
+			if e.From == "a.go::ID::type" && e.To == "a.go::Stringer::interface" && e.Kind == "implements" {
+				got = true
+			}
+		}
+	}
+	if !got {
+		t.Errorf("expected non-struct type ID to implement Stringer; got %v", out)
+	}
+}
+
+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
+}
+
+func containsSubstring(s, sub string) bool {
+	return len(sub) == 0 || (len(s) >= len(sub) && indexOf(s, sub) >= 0)
+}
+
+func indexOf(s, sub string) int {
+	for i := 0; i+len(sub) <= len(s); i++ {
+		if s[i:i+len(sub)] == sub {
+			return i
+		}
+	}
+	return -1
+}

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

@@ -0,0 +1,162 @@
+// Package load wraps golang.org/x/tools/go/packages with the configuration
+// needed by ctxo-go-analyzer: full type info, ASTs, dependency closure, and
+// go.work-aware module resolution.
+package load
+
+import (
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"golang.org/x/tools/go/packages"
+)
+
+// Mode requests every field the analyzer needs from go/packages: name, files,
+// syntax trees, type-checker output, and the imported-package closure. It is
+// expensive but unavoidable for type-aware edge resolution.
+const Mode = packages.NeedName |
+	packages.NeedFiles |
+	packages.NeedCompiledGoFiles |
+	packages.NeedImports |
+	packages.NeedDeps |
+	packages.NeedTypes |
+	packages.NeedTypesInfo |
+	packages.NeedSyntax |
+	packages.NeedTypesSizes |
+	packages.NeedModule
+
+// skippedDirs are filesystem entries we never descend into during subdir
+// fallback. vendor and node_modules avoid double-loading deps; hidden
+// directories tend to be tooling state, not source.
+var skippedDirs = map[string]bool{
+	"vendor":       true,
+	".git":         true,
+	".ctxo":        true,
+	"node_modules": true,
+	"testdata":     true,
+}
+
+// LoadResult bundles the loaded package set with any non-fatal errors so the
+// caller can decide whether to surface them as warnings.
+type LoadResult struct {
+	Packages []*packages.Package
+	// Errors are package-level Errors collected from a Visit traversal.
+	// Returned for visibility — the loader does not fail the run on these.
+	Errors []packages.Error
+	// FatalError is set when packages.Load returned a top-level error (e.g.,
+	// module-graph conflict). The caller may still get partial Packages.
+	FatalError error
+	// FallbackUsed is true when the root pattern failed and per-subdir
+	// recovery was used to gather whatever packages still loaded cleanly.
+	FallbackUsed bool
+}
+
+// Packages loads "./..." rooted at dir. Patterns can override the default
+// for tests that want to scope analysis to a single sub-package.
+//
+// Failure mode: returns a LoadResult (possibly with empty Packages) and
+// sets FatalError. The caller should surface the error but continue —
+// degraded analysis beats no analysis when consumers have a flaky module.
+func Packages(dir string, patterns ...string) *LoadResult {
+	if len(patterns) == 0 {
+		patterns = []string{"./..."}
+	}
+
+	cfg := &packages.Config{
+		Mode:  Mode,
+		Dir:   dir,
+		Tests: false,
+		// GOFLAGS=-mod=mod lets `go list` automatically add missing module
+		// entries (matches what `go build` does) instead of failing with
+		// "go: updates to go.mod needed; to update it: go mod tidy".
+		// Users get analysis without being forced to run `go mod tidy` first;
+		// go.mod/go.sum may gain entries — same side effect as a normal build.
+		// `-e` keeps loading even when individual packages have type errors.
+		Env: append(os.Environ(), "GOFLAGS=-mod=mod -e"),
+	}
+
+	pkgs, err := packages.Load(cfg, patterns...)
+	res := &LoadResult{Packages: pkgs}
+	if err != nil {
+		res.FatalError = fmt.Errorf("load: %w", err)
+	}
+
+	packages.Visit(pkgs, nil, func(p *packages.Package) {
+		res.Errors = append(res.Errors, p.Errors...)
+	})
+	return res
+}
+
+// PackagesWithFallback tries to load the whole module first; if that yields
+// zero packages (typical when the module graph has a fatal conflict), it
+// walks top-level subdirectories and loads each independently. Subdirs that
+// transitively avoid the conflicting imports still produce full type info.
+func PackagesWithFallback(dir string) *LoadResult {
+	primary := Packages(dir)
+	if len(primary.Packages) > 0 {
+		return primary
+	}
+
+	subdirs := topLevelGoSubdirs(dir)
+	if len(subdirs) == 0 {
+		return primary
+	}
+
+	merged := &LoadResult{
+		FatalError:   primary.FatalError,
+		FallbackUsed: true,
+	}
+	for _, sub := range subdirs {
+		pattern := "./" + filepath.ToSlash(sub) + "/..."
+		subRes := Packages(dir, pattern)
+		if len(subRes.Packages) == 0 {
+			continue
+		}
+		merged.Packages = append(merged.Packages, subRes.Packages...)
+		merged.Errors = append(merged.Errors, subRes.Errors...)
+	}
+	return merged
+}
+
+// topLevelGoSubdirs returns immediate subdirectories of root that contain at
+// least one .go file (recursively). Skips vendor, .git, hidden dirs, etc.
+func topLevelGoSubdirs(root string) []string {
+	entries, err := os.ReadDir(root)
+	if err != nil {
+		return nil
+	}
+	var out []string
+	for _, e := range entries {
+		if !e.IsDir() {
+			continue
+		}
+		name := e.Name()
+		if skippedDirs[name] || strings.HasPrefix(name, ".") {
+			continue
+		}
+		if hasGoFile(filepath.Join(root, name)) {
+			out = append(out, name)
+		}
+	}
+	return out
+}
+
+func hasGoFile(dir string) bool {
+	found := false
+	_ = filepath.WalkDir(dir, func(_ string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return nil
+		}
+		if d.IsDir() && skippedDirs[d.Name()] {
+			return fs.SkipDir
+		}
+		if !d.IsDir() && strings.HasSuffix(d.Name(), ".go") {
+			found = true
+			return fs.SkipAll
+		}
+		return nil
+	})
+	return found
+}

package/tools/ctxo-go-analyzer/internal/load/load_test.go

@@ -0,0 +1,96 @@
+package load
+
+import (
+	"os"
+	"path/filepath"
+	"sort"
+	"testing"
+
+	"golang.org/x/tools/go/packages"
+)
+
+func TestPackagesOnHealthyModule(t *testing.T) {
+	dir := writeFixture(t, map[string]string{
+		"go.mod": "module fixture\n\ngo 1.22\n",
+		"a.go":   "package fixture\n\nfunc Hello() string { return \"hi\" }\n",
+	})
+	res := Packages(dir)
+	if res.FatalError != nil {
+		t.Fatalf("FatalError: %v", res.FatalError)
+	}
+	if len(res.Packages) == 0 {
+		t.Fatal("expected at least one package")
+	}
+}
+
+func TestPackagesWithFallbackRecoversPartial(t *testing.T) {
+	// "broken/" imports a non-existent path so the module-wide load fails;
+	// "healthy/" is self-contained, so per-subdir loading recovers it.
+	dir := writeFixture(t, map[string]string{
+		"go.mod":             "module fixture\n\ngo 1.22\n",
+		"broken/broken.go":   "package broken\n\nimport _ \"definitely.nowhere/missing\"\n",
+		"healthy/healthy.go": "package healthy\n\nfunc Y() int { return 1 }\n",
+	})
+
+	res := PackagesWithFallback(dir)
+	if len(res.Packages) == 0 {
+		t.Fatalf("expected fallback to recover at least one package; got 0 (FatalError=%v)", res.FatalError)
+	}
+	if !pkgListContainsName(res.Packages, "healthy") {
+		t.Errorf("expected 'healthy' package recovered via fallback; got %v", pkgNames(res.Packages))
+	}
+}
+
+func TestTopLevelGoSubdirsSkipsHidden(t *testing.T) {
+	dir := writeFixture(t, map[string]string{
+		"a/file.go":     "package a",
+		".hidden/x.go":  "package x",
+		"vendor/foo.go": "package foo",
+		"b/file.go":     "package b",
+	})
+	got := topLevelGoSubdirs(dir)
+	sort.Strings(got)
+	want := []string{"a", "b"}
+	if len(got) != len(want) {
+		t.Fatalf("got %v, want %v", got, want)
+	}
+	for i := range got {
+		if got[i] != want[i] {
+			t.Fatalf("index %d: got %q want %q", i, got[i], want[i])
+		}
+	}
+}
+
+// ── helpers ──
+
+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
+}
+
+func pkgNames(pkgs []*packages.Package) []string {
+	out := make([]string, 0, len(pkgs))
+	for _, p := range pkgs {
+		out = append(out, p.Name)
+	}
+	return out
+}
+
+func pkgListContainsName(pkgs []*packages.Package, name string) bool {
+	for _, p := range pkgs {
+		if p.Name == name {
+			return true
+		}
+	}
+	return false
+}