open-context-engine 0.1.0

package/src/retrieval/languages/files.py

@@ -0,0 +1,90 @@
+"""Shared file eligibility for discovery and explicitly supplied snapshots."""
+import hashlib
+import os
+from pathlib import Path, PurePosixPath
+import re
+import subprocess
+
+MAX_BYTES = 1024 * 1024
+SKIP_DIRS = frozenset({'.git', '.hg', '.svn', 'node_modules', 'vendor', '.venv', 'venv',
+                       '__pycache__', 'dist', 'build', 'target', '.next', '.cache',
+                       '.pilot-state', 'runs'})
+SKIP_SUFFIXES = ('.min.js', '.min.css', '.map', '.pyc', '.pyo', '.so', '.dylib', '.dll',
+                 '.exe', '.o', '.a', '.class', '.jar', '.wasm', '.zip', '.gz', '.tar',
+                 '.png', '.jpg', '.jpeg', '.gif', '.webp', '.ico', '.pdf', '.woff', '.woff2',
+                 '.mp3', '.mp4', '.sqlite', '.db', '.pem', '.key')
+LOCKFILES = frozenset({'package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', 'poetry.lock',
+                       'uv.lock', 'Cargo.lock', 'go.sum'})
+GENERATED = re.compile(r'(?im)^\s*(?://|#|/\*|\*)\s*(?:code generated\b[^\n]*do not edit|'
+                       r'(?:this file (?:is|was) |@)?(?:auto[- ]?)?generated\b[^\n]*do not edit)')
+
+
+def path_exclusion(name):
+    path = PurePosixPath(name)
+    if set(path.parts[:-1]) & SKIP_DIRS:
+        return 'dependency-or-build-directory'
+    if path.name in LOCKFILES or name.lower().endswith(SKIP_SUFFIXES):
+        return 'generated-or-non-source-name'
+    if path.name == '.env' or (path.name.startswith('.env.') and path.name not in {'.env.example', '.env.sample'}):
+        return 'local-environment'
+    return None
+
+
+def read_text(path):
+    """Return decoded source or an explicit skip reason; never replace bad bytes."""
+    if path.stat().st_size > MAX_BYTES:
+        return None, None, 'file-too-large'
+    raw = path.read_bytes()
+    if len(raw) > MAX_BYTES:
+        return None, None, 'file-too-large'
+    if any(byte < 32 and byte not in (9, 10, 12, 13) for byte in raw):
+        return raw, None, 'binary-content'
+    try:
+        text = raw.decode('utf-8-sig')
+    except UnicodeDecodeError:
+        return raw, None, 'non-utf8'
+    if GENERATED.search(text[:2048]):
+        return raw, None, 'generated-header'
+    return raw, text, None
+
+
+def discover_snapshot(root):
+    """Use Git's ignore rules when available, otherwise a bounded directory walk."""
+    root = Path(root).resolve()
+    if not root.is_dir():
+        raise ValueError('Source root must be a directory')
+    git = subprocess.run(['git', '-C', str(root), 'rev-parse', '--is-inside-work-tree'],
+                         capture_output=True, text=True)
+    excluded, files = [], []
+    if git.returncode == 0 and git.stdout.strip() == 'true':
+        result = subprocess.run(['git', '-C', str(root), 'ls-files', '-c', '-o',
+                                 '--exclude-standard', '-z'], capture_output=True, check=True)
+        names = sorted(set(os.fsdecode(name) for name in result.stdout.split(b'\0') if name))
+        discovery = 'git-tracked-and-unignored'
+    else:
+        names = []
+        for directory, dirs, entries in os.walk(root, followlinks=False):
+            for name in sorted(dirs):
+                path = Path(directory)/name
+                if name in SKIP_DIRS or path.is_symlink():
+                    excluded.append({'path': path.relative_to(root).as_posix()+'/',
+                                     'reason': 'symlink' if path.is_symlink() else 'dependency-or-build-directory'})
+            dirs[:] = [name for name in dirs if name not in SKIP_DIRS and not (Path(directory)/name).is_symlink()]
+            names.extend((Path(directory)/name).relative_to(root).as_posix() for name in entries)
+        names.sort()
+        discovery = 'directory-walk'
+    for name in names:
+        path = root/name
+        reason = path_exclusion(name)
+        if path.is_symlink() or not path.resolve().is_relative_to(root):
+            reason = 'symlink'
+        elif not path.is_file():
+            reason = 'not-a-regular-file'
+        if not reason:
+            raw, _, reason = read_text(path)
+        if reason:
+            excluded.append({'path': name, 'reason': reason})
+        else:
+            files.append({'path': name, 'bytes': len(raw), 'sha256': hashlib.sha256(raw).hexdigest()})
+    return {'schemaVersion': 1, 'scope': 'eligible UTF-8 text; structural adapters where available',
+            'discovery': discovery, 'files': files, 'excluded': sorted(excluded, key=lambda item: item['path'])}

package/src/retrieval/languages/go.py

@@ -0,0 +1,154 @@
+"""Go AST bridge with a content-addressed, local-only helper build."""
+from collections import defaultdict
+from functools import lru_cache
+import hashlib
+import json
+import os
+import re
+from pathlib import Path
+import shutil
+import subprocess
+import tempfile
+
+from .schema import physical_lines
+
+
+@lru_cache(maxsize=8)
+def toolchain(binary):
+    result = subprocess.run([binary, 'version'], capture_output=True, text=True, check=True, timeout=10)
+    return result.stdout.strip()
+
+
+def compiler():
+    binary = os.environ.get('OCE_GO_BINARY') or os.environ.get('REPONERVE_GO_BINARY') or shutil.which('go')
+    if not binary:
+        raise RuntimeError('Go indexing requires Go 1.22+ on PATH or OCE_GO_BINARY')
+    return binary, toolchain(binary)
+
+
+def settings(options=None, sources=()):
+    options = {} if options is None else options
+    if not isinstance(options, dict) or set(options)-{'mode', 'modulePath', 'goos', 'goarch'}:
+        raise ValueError('Go options support mode, modulePath, goos and goarch')
+    result = {'mode': 'syntax', 'modulePath': 'snapshot', 'goos': 'linux', 'goarch': 'amd64', **options}
+    if result['mode'] not in {'syntax', 'types'} or result['goos'] not in {'linux', 'darwin', 'windows', 'freebsd'} or result['goarch'] not in {'amd64', 'arm64', '386', 'arm'}:
+        raise ValueError('Unsupported Go analysis mode or build target')
+    if 'modulePath' not in options:
+        for source in sources:
+            if source.path == 'go.mod':
+                match = re.search(r'(?m)^module\s+("[^"\n]+"|[^\s/]+(?:/[^\s]+)*)', source.text)
+                if match:
+                    result['modulePath'] = match[1].strip('"')
+    if not isinstance(result['modulePath'], str) or not re.fullmatch(r'[A-Za-z0-9_.~/-]+', result['modulePath']) or '..' in result['modulePath'].split('/') or result['modulePath'].startswith('/'):
+        raise ValueError('Invalid Go modulePath')
+    return result
+
+
+def parse(sources, options):
+    binary, version = compiler()
+    source = Path(__file__).with_name('go_ast.go')
+    semantic = source.with_name('go_types.go')
+    identity = hashlib.sha256(source.read_bytes()+semantic.read_bytes()+version.encode()).hexdigest()
+    cache = Path(tempfile.gettempdir())/f'reponerve-go-adapter-{getattr(os, "getuid", lambda: 0)()}'
+    cache.mkdir(mode=0o700, exist_ok=True)
+    if cache.is_symlink() or (os.name == 'posix' and
+            (cache.stat().st_uid != os.getuid() or cache.stat().st_mode & 0o077)):
+        raise RuntimeError('Go parser cache must be private to the current user')
+    executable = cache/identity
+    if executable.is_symlink():
+        raise RuntimeError('Invalid Go parser cache entry')
+    if not executable.exists():
+        with tempfile.TemporaryDirectory(dir=cache) as directory:
+            target = Path(directory)/'parser'
+            env = {**os.environ, 'GOENV': 'off', 'GOWORK': 'off', 'GOTOOLCHAIN': 'local',
+                   'GOPROXY': 'off', 'GO111MODULE': 'off', 'CGO_ENABLED': '0', 'GOFLAGS': '',
+                   'GOCACHE': str(cache/'build')}
+            built = subprocess.run([binary, 'build', '-o', str(target), str(source), str(semantic)],
+                                   env=env, capture_output=True, text=True, timeout=120)
+            if built.returncode:
+                raise RuntimeError('Go parser build failed: '+built.stderr[:2000])
+            os.replace(target, executable)
+    result = subprocess.run([str(executable)], input=json.dumps({'options': options, 'files': [
+        {'path': source.path, 'text': source.text} for source in sources]}),
+        text=True, capture_output=True, timeout=120)
+    if result.returncode:
+        raise ValueError('Go adapter failed: '+result.stderr.strip()[:2000])
+    return json.loads(result.stdout)
+
+
+def extract(sources, max_lines=65, options=None):
+    options = settings(options)
+    parsed = parse(sources, options)
+    units, records, targets = [], {}, defaultdict(list)
+    source_by_path = {source.path: source for source in sources}
+    for file in parsed['files']:
+        path = file['path']
+        lines = physical_lines(source_by_path[path].text)
+        module = str(Path(path).parent)+'::'+file['package']
+        root = {'name': '', 'kind': 'module', 'start': 1, 'end': len(lines), 'decl': 0}
+        owners = [root]*len(lines)
+        for entry in file['entries']:
+            for i in range(entry['start']-1, entry['end']):
+                owners[i] = entry
+        line_units = {}
+        start = 1
+        while start <= len(lines):
+            owner = owners[start-1]
+            end = start
+            while end < len(lines) and owners[end] is owner:
+                end += 1
+            while start <= end:
+                stop = min(end, start+max_lines-1)
+                if stop < end:
+                    boundaries = [b for b in file['boundaries']
+                                  if start+max(1, max_lines//2) <= b <= stop+1 and b > start]
+                    if boundaries:
+                        stop = max(boundaries)-1
+                value = '\n'.join(lines[start-1:stop])
+                if value.strip():
+                    uid = len(units)
+                    symbol = f"{path}::{owner['name']}@{owner['decl']}"
+                    unit = {'id': uid, 'language': 'go', 'path': path, 'module': module,
+                            'name': owner['name'], 'symbol': symbol, 'kind': owner['kind'],
+                            'scope': module, 'owner': None, 'start': start, 'end': stop,
+                            'text': value, 'relations': [], 'edges': [], 'calls': [], 'unresolved': []}
+                    units.append(unit)
+                    targets[(path, owner['decl'])].append(uid)
+                    for i in range(start, stop+1):
+                        line_units[i] = uid
+                start = stop+1
+        records[path] = line_units
+        if line_units:
+            units[next(iter(line_units.values()))]['goAnalysis'] = {
+                **options, 'selectedForTypes': file['semantic'], 'diagnostics': file['diagnostics']}
+    def add(uid, others, kind, resolution):
+        for target in others:
+            if uid != target:
+                units[uid]['relations'].append({'target': target, 'kind': kind,
+                    'confidence': 1 if kind == 'same_symbol' else .9, 'resolution': resolution})
+    for (path, decl), ids in targets.items():
+        if decl:
+            for uid in ids:
+                add(uid, ids, 'same_symbol', 'syntax')
+    for file in parsed['files']:
+        for reference in file['references']:
+            uid = records[file['path']].get(reference['line'])
+            if uid is not None:
+                add(uid, targets.get((reference['targetPath'], reference['targetLine']), []),
+                    'references_type', reference['resolution'])
+        for call in file['calls']:
+            uid = records[file['path']].get(call['line'])
+            if uid is None:
+                continue
+            units[uid]['calls'].append(call['text'])
+            ids = targets.get((call.get('targetPath'), call.get('targetLine')), [])
+            if ids:
+                add(uid, ids, 'calls', call['resolution'])
+            else:
+                units[uid]['unresolved'].append({'kind': 'calls', 'text': call['text'],
+                    'line': call['line'], 'reason': 'dynamic, external or not statically bound in snapshot'})
+    for unit in units:
+        unit['relations'] = sorted({(r['target'], r['kind']): r for r in unit['relations']}.values(),
+                                   key=lambda r: (r['target'], r['kind']))
+        unit['edges'] = sorted({r['target'] for r in unit['relations']})
+    return units

package/src/retrieval/languages/go_ast.go

@@ -0,0 +1,204 @@
+// Read only supplied source strings. Never load modules, run source or emit code.
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path"
+	"runtime"
+	"sort"
+	"strings"
+)
+
+type Source struct {
+	Path string `json:"path"`
+	Text string `json:"text"`
+}
+type Input struct {
+	Files   []Source `json:"files"`
+	Options Settings `json:"options"`
+}
+type Settings struct {
+	Mode       string `json:"mode"`
+	ModulePath string `json:"modulePath"`
+	GOOS       string `json:"goos"`
+	GOARCH     string `json:"goarch"`
+}
+type Entry struct {
+	Name  string `json:"name"`
+	Kind  string `json:"kind"`
+	Start int    `json:"start"`
+	End   int    `json:"end"`
+	Decl  int    `json:"decl"`
+}
+type Call struct {
+	Line       int    `json:"line"`
+	Text       string `json:"text"`
+	Path       string `json:"targetPath,omitempty"`
+	Decl       int    `json:"targetLine,omitempty"`
+	Resolution string `json:"resolution,omitempty"`
+}
+type File struct {
+	Path        string   `json:"path"`
+	Package     string   `json:"package"`
+	Entries     []Entry  `json:"entries"`
+	Boundaries  []int    `json:"boundaries"`
+	Calls       []Call   `json:"calls"`
+	References  []Call   `json:"references"`
+	Diagnostics []string `json:"diagnostics"`
+	Semantic    bool     `json:"semantic"`
+}
+type Target struct {
+	path string
+	line int
+}
+
+func main() {
+	if err := run(); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
+func run() error {
+	var input Input
+	if err := json.NewDecoder(os.Stdin).Decode(&input); err != nil {
+		return err
+	}
+	fset := token.NewFileSet()
+	trees := map[string]*ast.File{}
+	texts := map[string]string{}
+	objects := map[*ast.Object]Target{}
+	functions := map[string][]Target{}
+	line := func(p token.Pos) int { return fset.PositionFor(p, false).Line }
+	for _, src := range input.Files {
+		text := strings.ReplaceAll(strings.ReplaceAll(src.Text, "\r\n", "\n"), "\r", "\n")
+		tree, err := parser.ParseFile(fset, src.Path, text, parser.ParseComments|parser.AllErrors)
+		if err != nil {
+			return err
+		}
+		trees[src.Path] = tree
+		texts[src.Path] = text
+		for _, decl := range tree.Decls {
+			if fn, ok := decl.(*ast.FuncDecl); ok && fn.Recv == nil {
+				t := Target{src.Path, line(fn.Pos())}
+				if fn.Name.Obj != nil {
+					objects[fn.Name.Obj] = t
+				}
+				key := path.Dir(src.Path) + "::" + tree.Name.Name + "::" + fn.Name.Name
+				functions[key] = append(functions[key], t)
+			}
+		}
+	}
+	var typed TypeEvidence
+	if input.Options.Mode == "types" {
+		typed = resolveTypes(fset, trees, texts, input.Options.ModulePath, input.Options.GOOS, input.Options.GOARCH)
+	}
+	files := []File{}
+	for _, src := range input.Files {
+		tree := trees[src.Path]
+		out := File{Path: src.Path, Package: tree.Name.Name, Entries: []Entry{}, Boundaries: []int{}, Calls: []Call{}, References: []Call{}, Diagnostics: []string{}}
+		if input.Options.Mode == "types" {
+			out.Semantic = typed.Selected[src.Path]
+			out.Diagnostics = append(out.Diagnostics, typed.Diagnostics[src.Path]...)
+		}
+		add := func(node ast.Node, name, kind string, doc *ast.CommentGroup) {
+			start := line(node.Pos())
+			if doc != nil {
+				start = line(doc.Pos())
+			}
+			out.Entries = append(out.Entries, Entry{name, kind, start, line(node.End() - 1), line(node.Pos())})
+		}
+		for _, decl := range tree.Decls {
+			switch d := decl.(type) {
+			case *ast.FuncDecl:
+				name, kind := d.Name.Name, "function"
+				if d.Recv != nil && len(d.Recv.List) > 0 {
+					receiver := d.Recv.List[0].Type
+					if pointer, ok := receiver.(*ast.StarExpr); ok {
+						receiver = pointer.X
+					}
+					if indexed, ok := receiver.(*ast.IndexExpr); ok {
+						receiver = indexed.X
+					}
+					if indexed, ok := receiver.(*ast.IndexListExpr); ok {
+						receiver = indexed.X
+					}
+					if id, ok := receiver.(*ast.Ident); ok {
+						name = id.Name + "." + name
+					}
+					kind = "method"
+				}
+				add(d, name, kind, d.Doc)
+			case *ast.GenDecl:
+				for _, spec := range d.Specs {
+					if t, ok := spec.(*ast.TypeSpec); ok {
+						add(t, t.Name.Name, "type", t.Doc)
+					}
+				}
+			}
+		}
+		ast.Inspect(tree, func(node ast.Node) bool {
+			if node == nil {
+				return true
+			}
+			if _, ok := node.(ast.Stmt); ok {
+				out.Boundaries = append(out.Boundaries, line(node.Pos()))
+			}
+			if call, ok := node.(*ast.CallExpr); ok {
+				expression := call.Fun
+				if generic, ok := expression.(*ast.IndexExpr); ok {
+					expression = generic.X
+				}
+				if generic, ok := expression.(*ast.IndexListExpr); ok {
+					expression = generic.X
+				}
+				start, end := fset.PositionFor(expression.Pos(), false).Offset, fset.PositionFor(expression.End(), false).Offset
+				text := texts[src.Path][start:end]
+				if len(text) > 200 {
+					text = text[:200]
+				}
+				c := Call{Line: line(call.Pos()), Text: text}
+				if id, ok := expression.(*ast.Ident); ok {
+					var target Target
+					if id.Obj != nil {
+						target = objects[id.Obj]
+					} else {
+						candidates := functions[path.Dir(src.Path)+"::"+tree.Name.Name+"::"+id.Name]
+						if len(candidates) == 1 {
+							target = candidates[0]
+						}
+					}
+					if target.path != "" {
+						c.Path = target.path
+						c.Decl = target.line
+						c.Resolution = "syntax-binding"
+					}
+				}
+				if input.Options.Mode == "types" {
+					c.Path = ""
+					c.Decl = 0
+					c.Resolution = ""
+					if target, ok := typed.Calls[call.Pos()]; ok {
+						c.Path = target.path
+						c.Decl = target.line
+						c.Resolution = "compiler-symbol"
+					}
+				}
+				out.Calls = append(out.Calls, c)
+			}
+			if input.Options.Mode == "types" {
+				if target, ok := typed.References[node.Pos()]; ok {
+					out.References = append(out.References, Call{Line: line(node.Pos()), Path: target.path, Decl: target.line, Resolution: "compiler-symbol"})
+				}
+			}
+			return true
+		})
+		sort.Ints(out.Boundaries)
+		files = append(files, out)
+	}
+	return json.NewEncoder(os.Stdout).Encode(map[string]any{"compilerVersion": runtime.Version(), "files": files})
+}

package/src/retrieval/languages/go_types.go

@@ -0,0 +1,169 @@
+// Snapshot-only type checking. Missing dependencies remain unresolved; no loader,
+// shell command, module download, package initializer or analyzed code is run.
+package main
+
+import (
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/token"
+	"go/types"
+	"io"
+	"path"
+	"sort"
+	"strings"
+)
+
+type TypeEvidence struct {
+	Calls       map[token.Pos]Target
+	References  map[token.Pos]Target
+	Diagnostics map[string][]string
+	Selected    map[string]bool
+}
+type snapshotImporter struct {
+	fset     *token.FileSet
+	files    map[string][]*ast.File
+	packages map[string]*types.Package
+	visiting map[string]bool
+	info     *types.Info
+	errors   map[string][]string
+	sizes    types.Sizes
+	blocked  map[string]bool
+}
+
+func (s *snapshotImporter) Import(name string) (*types.Package, error) {
+	if p := s.packages[name]; p != nil {
+		return p, nil
+	}
+	files := s.files[name]
+	if len(files) == 0 {
+		return nil, fmt.Errorf("dependency outside source snapshot: %s", name)
+	}
+	if s.visiting[name] {
+		return nil, fmt.Errorf("snapshot import cycle: %s", name)
+	}
+	s.visiting[name] = true
+	conf := types.Config{Importer: s, DisableUnusedImportCheck: true, Sizes: s.sizes, Error: func(err error) {
+		if typed, ok := err.(types.Error); ok {
+			pos := s.fset.PositionFor(typed.Pos, false)
+			if strings.Contains(typed.Msg, "redeclared") || strings.Contains(typed.Msg, "already declared") {
+				s.blocked[name] = true
+			}
+			if len(s.errors[pos.Filename]) < 20 {
+				s.errors[pos.Filename] = append(s.errors[pos.Filename], fmt.Sprintf("%d: %s", pos.Line, typed.Msg))
+			}
+		}
+	}}
+	pkg, err := conf.Check(name, s.fset, files, s.info)
+	delete(s.visiting, name)
+	// go/types returns a partial package on ordinary type errors. Only concrete
+	// declarations with positions in this snapshot can become relations later.
+	if pkg != nil {
+		s.packages[name] = pkg
+		return pkg, nil
+	}
+	return nil, err
+}
+
+func resolveTypes(fset *token.FileSet, trees map[string]*ast.File, texts map[string]string,
+	modulePath, goos, goarch string) TypeEvidence {
+	evidence := TypeEvidence{Calls: map[token.Pos]Target{}, References: map[token.Pos]Target{},
+		Diagnostics: map[string][]string{}, Selected: map[string]bool{}}
+	context := build.Default
+	context.GOOS = goos
+	context.GOARCH = goarch
+	context.CgoEnabled = false
+	context.OpenFile = func(name string) (io.ReadCloser, error) {
+		if text, ok := texts[path.Clean(name)]; ok {
+			return io.NopCloser(strings.NewReader(text)), nil
+		}
+		return nil, fmt.Errorf("source outside snapshot: %s", name)
+	}
+	info := &types.Info{Uses: map[*ast.Ident]types.Object{}, Defs: map[*ast.Ident]types.Object{}, Selections: map[*ast.SelectorExpr]*types.Selection{}}
+	loader := &snapshotImporter{fset: fset, files: map[string][]*ast.File{}, packages: map[string]*types.Package{}, visiting: map[string]bool{}, info: info, errors: evidence.Diagnostics, sizes: types.SizesFor("gc", goarch), blocked: map[string]bool{}}
+	functions, definitions := map[token.Pos]Target{}, map[token.Pos]Target{}
+	names := make([]string, 0, len(trees))
+	for name := range trees {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	for _, name := range names {
+		tree := trees[name]
+		// All files remain in the structural index. Semantic links use one explicit
+		// build target and exclude external test packages and test-only declarations.
+		match, err := context.MatchFile(path.Dir(name), path.Base(name))
+		if err != nil {
+			evidence.Diagnostics[name] = append(evidence.Diagnostics[name], err.Error())
+			continue
+		}
+		if !match || strings.HasSuffix(name, "_test.go") {
+			continue
+		}
+		evidence.Selected[name] = true
+		packagePath := path.Join(modulePath, path.Dir(name))
+		loader.files[packagePath] = append(loader.files[packagePath], tree)
+		for _, decl := range tree.Decls {
+			switch d := decl.(type) {
+			case *ast.FuncDecl:
+				if d.Body != nil {
+					functions[d.Name.Pos()] = Target{name, fset.PositionFor(d.Pos(), false).Line}
+				}
+			case *ast.GenDecl:
+				for _, spec := range d.Specs {
+					if t, ok := spec.(*ast.TypeSpec); ok {
+						definitions[t.Name.Pos()] = Target{name, fset.PositionFor(t.Pos(), false).Line}
+					}
+				}
+			}
+		}
+	}
+	packageNames := make([]string, 0, len(loader.files))
+	for name := range loader.files {
+		packageNames = append(packageNames, name)
+	}
+	sort.Strings(packageNames)
+	for _, name := range packageNames {
+		_, _ = loader.Import(name)
+	}
+	for _, name := range names {
+		if !evidence.Selected[name] || loader.blocked[path.Join(modulePath, path.Dir(name))] {
+			continue
+		}
+		ast.Inspect(trees[name], func(node ast.Node) bool {
+			if call, ok := node.(*ast.CallExpr); ok {
+				expression := call.Fun
+				if indexed, ok := expression.(*ast.IndexExpr); ok {
+					expression = indexed.X
+				}
+				if indexed, ok := expression.(*ast.IndexListExpr); ok {
+					expression = indexed.X
+				}
+				var object types.Object
+				switch x := expression.(type) {
+				case *ast.Ident:
+					object = info.Uses[x]
+				case *ast.SelectorExpr:
+					if selection := info.Selections[x]; selection != nil {
+						object = selection.Obj()
+					} else {
+						object = info.Uses[x.Sel]
+					}
+				}
+				if fn, ok := object.(*types.Func); ok {
+					if target, found := functions[fn.Pos()]; found && !loader.blocked[path.Join(modulePath, path.Dir(target.path))] {
+						evidence.Calls[call.Pos()] = target
+					}
+				}
+			}
+			if id, ok := node.(*ast.Ident); ok {
+				if object, ok := info.Uses[id].(*types.TypeName); ok {
+					if target, found := definitions[object.Pos()]; found && !loader.blocked[path.Join(modulePath, path.Dir(target.path))] {
+						evidence.References[id.Pos()] = target
+					}
+				}
+			}
+			return true
+		})
+	}
+	return evidence
+}