typresolve

package
v0.14.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 3, 2026 License: MIT Imports: 5 Imported by: 0

Documentation

Overview

Package typresolve provides shared infrastructure for in-process language-specific type resolution. It includes type representation, a type registry, scope chains, and the Resolver interface that per-language resolvers implement.

This package replaces external LSP servers for type resolution, running inside the same process as tree-sitter extraction and sharing the parsed AST directly.

Package typresolve defines the Resolver interface for per-language in-process type resolution and the ResolverEnricher orchestrator that dispatches resolution concurrently across files. Language-specific resolvers (Go, Python, TypeScript, etc.) implement the Resolver interface; the enricher groups files by language, initializes each resolver's workspace, and fans out file resolution with bounded concurrency.

Index

Constants

View Source 
const ProvenanceResolverResolved = "resolver_resolved"

ProvenanceResolverResolved is the provenance string for edges produced by in-process type resolution, distinct from "lsp_resolved" edges produced by the external LSP enricher.

View Source 
const ResolverConfidence = 0.9

ResolverConfidence is the default confidence for resolver-produced edges.

Variables

This section is empty.

Functions

func RouteEnrichment 

func RouteEnrichment(ctx context.Context, store types.GraphStore,
	workspaceRoot string, repoHash types.Hash,
	resolverEnricher *ResolverEnricher,
	lspEnricher LspEnricher,
	fileResults []FileResult) error

RouteEnrichment dispatches file results to either the in-process resolver or the external LSP enricher based on which languages have registered resolvers. Languages with a resolver go through resolverEnricher.Run; languages without one fall back to lspEnricher.Run (if non-nil).

Resolver errors do not prevent the LSP fallback from running. The first error encountered (resolver or LSP) is returned.

func TypesEqual 

func TypesEqual(a, b *Type) bool

TypesEqual performs structural equality comparison of two types. Two types are equal if their kinds match and all structural members match recursively. Both nil returns true; one nil returns false.

Types

type ChanDir 

type ChanDir int

ChanDir represents the direction of a channel type. 

const (
	ChanBidi ChanDir = iota // chan T
	ChanSend                // chan<- T
	ChanRecv                // <-chan T
)

type Field 

type Field struct {
	Name string
	Type *Type
}

Field represents a struct field.

type FileResult 

type FileResult struct {
	Path       string
	FileHash   types.Hash
	Content    []byte
	ParsedTree types.ParsedTree
	Edges      []types.Edge
	Language   string
}

FileResult wraps extraction output for a single file, used as input to the ResolverEnricher.

type LanguageStats 

type LanguageStats struct {
	Language    string
	FileCount   int
	UseResolver bool
}

LanguageStats reports the routing decision for a single language.

func RouteStats 

func RouteStats(resolverEnricher *ResolverEnricher, fileResults []FileResult) []LanguageStats

RouteStats returns per-language routing decisions without executing. Useful for logging and testing.

type LspEnricher 

type LspEnricher interface {
	Run(ctx context.Context, repoHash types.Hash) error
}

LspEnricher is the interface the existing enrichment.Enricher satisfies. Defined here rather than importing internal/enrichment to avoid circular dependencies. The enricher's Run method has the signature: 

Run(ctx context.Context, repoHash types.Hash) error

type Method 

type Method struct {
	Name      string
	Signature *Type // KindFunc
}

Method represents an interface method.

type Param 

type Param struct {
	Name string
	Type *Type
}

Param represents a function parameter.

type RegisteredFunc 

type RegisteredFunc struct {
	QualifiedName string
	ReceiverType  string // empty for free functions
	ShortName     string
	Signature     *Type    // KindFunc
	TypeParams    []string // generic type param names
	MinParams     int      // -1 = unknown
}

RegisteredFunc represents a function or method registered in the type registry. For methods, ReceiverType holds the qualified name of the receiver type.

type RegisteredType 

type RegisteredType struct {
	QualifiedName string
	ShortName     string
	Fields        []Field
	MethodNames   []string // parallel with MethodQNs
	MethodQNs     []string // parallel with MethodNames
	EmbeddedTypes []string
	AliasOf       string // empty if not alias
	TypeParams    []string
	IsInterface   bool
}

RegisteredType represents a type registered in the type registry. MethodNames and MethodQNs are parallel arrays: MethodNames[i] is the short name and MethodQNs[i] is the qualified name of the same method.

type Registry 

type Registry struct {
	// contains filtered or unexported fields
}

Registry provides hash-indexed lookup tables for functions and types by qualified name. It supports fallback chaining for two-level lookup (e.g. local workspace registry falling back to a stdlib registry).

Registry is NOT thread-safe for writes. Build it single-threaded during InitWorkspace, then use it read-only for concurrent ResolveFile calls.

func NewRegistry 

func NewRegistry() *Registry

NewRegistry creates an empty registry with initialized maps.

func (*Registry) AddFunc 

func (r *Registry) AddFunc(f RegisteredFunc)

AddFunc registers a function by its qualified name. If the function has a ReceiverType, it is also indexed under "ReceiverType.ShortName" in the methods map for method lookup.

func (*Registry) AddType 

func (r *Registry) AddType(t RegisteredType)

AddType registers a type by its qualified name.

func (*Registry) FuncCount 

func (r *Registry) FuncCount() int

FuncCount returns the number of functions registered locally (not including fallback).

func (*Registry) IterFuncsByShortName 

func (r *Registry) IterFuncsByShortName(shortName string, fn func(*RegisteredFunc) bool)

IterFuncsByShortName calls fn for every registered function whose ShortName matches shortName. Searches this registry and all fallbacks. Used as a last-resort resolution strategy when qualified-name lookup fails.

func (*Registry) LookupFunc 

func (r *Registry) LookupFunc(qualifiedName string) *RegisteredFunc

LookupFunc looks up a function by qualified name. Returns nil if not found in this registry or any fallback.

func (*Registry) LookupMethod 

func (r *Registry) LookupMethod(receiverQN, methodName string) *RegisteredFunc

LookupMethod looks up a method by receiver qualified name and method name. The key is "receiverQN.methodName". Returns nil if not found.

func (*Registry) LookupSymbol 

func (r *Registry) LookupSymbol(packageQN, name string) *RegisteredFunc

LookupSymbol looks up a function by constructing "packageQN.name" and searching the funcs map. Returns nil if not found.

func (*Registry) LookupType 

func (r *Registry) LookupType(qualifiedName string) *RegisteredType

LookupType looks up a type by qualified name. Returns nil if not found in this registry or any fallback.

func (*Registry) ResolveAlias 

func (r *Registry) ResolveAlias(typeQN string) *RegisteredType

ResolveAlias follows the AliasOf chain on types up to 16 levels deep. Returns the concrete (non-alias) type at the end of the chain, or nil if the type is not found or the chain exceeds 16 levels (cycle detection).

func (*Registry) SetFallback 

func (r *Registry) SetFallback(parent *Registry)

SetFallback sets the fallback (parent) registry for chained lookups. When a lookup misses in this registry, it falls through to the fallback.

func (*Registry) TypeCount 

func (r *Registry) TypeCount() int

TypeCount returns the number of types registered locally (not including fallback).

type ResolveFileOpts 

type ResolveFileOpts struct {
	FilePath   string
	FileHash   types.Hash
	Content    []byte
	ParsedTree types.ParsedTree
	Edges      []types.Edge
}

ResolveFileOpts contains all inputs for resolving a single file.

type Resolver 

type Resolver interface {
	// Language returns the language identifier (e.g. "go", "python").
	Language() string

	// InitWorkspace builds the cross-file type registry from all extracted
	// definitions. Called once before any ResolveFile calls. The registry
	// must be read-only after this returns.
	InitWorkspace(ctx context.Context, defs []ResolverDef) error

	// ResolveFile resolves type references in a single file. Thread-safe;
	// called concurrently across files. Returns edges with provenance
	// ProvenanceResolverResolved and confidence ResolverConfidence.
	ResolveFile(ctx context.Context, opts ResolveFileOpts) ([]types.Edge, error)
}

Resolver is the contract that per-language in-process type resolvers implement. Language() identifies the resolver; InitWorkspace builds a cross-file type registry from extracted definitions (called once, after which the registry is read-only); ResolveFile resolves a single file and is safe for concurrent use.

type ResolverDef 

type ResolverDef struct {
	QualifiedName string
	Kind          string // "function", "type", "method", etc.
	Signature     string
	FilePath      string
	PackagePath   string
}

ResolverDef contains definition metadata collected from extraction, used to build the per-language type registry in InitWorkspace.

type ResolverEnricher 

type ResolverEnricher struct {
	// contains filtered or unexported fields
}

ResolverEnricher orchestrates per-language type resolution. It groups files by language, initializes each registered resolver, and resolves files concurrently using bounded concurrency with a single DB-writer goroutine.

func NewResolverEnricher 

func NewResolverEnricher(store types.GraphStore, concurrency int) *ResolverEnricher

NewResolverEnricher creates a ResolverEnricher backed by the given store. If concurrency is 0 or negative, it defaults to 8.

func (*ResolverEnricher) HasResolver 

func (re *ResolverEnricher) HasResolver(language string) bool

HasResolver reports whether a resolver is registered for the given language.

func (*ResolverEnricher) Register 

func (re *ResolverEnricher) Register(r Resolver)

Register adds a language-specific resolver. Subsequent calls with the same Language() value overwrite the previous registration.

func (*ResolverEnricher) Run 

func (re *ResolverEnricher) Run(ctx context.Context, repoHash types.Hash, fileResults []FileResult) error

Run executes type resolution for all file results. It groups files by language, then for each language with a registered resolver:

  1. Collects ResolverDef entries from the file results
  2. Calls InitWorkspace with the collected definitions
  3. Resolves files concurrently via a channel semaphore
  4. Writes edges through a single writer goroutine calling store.PutEdge

Errors in individual files or languages are logged but do not abort the entire run.

type Scope 

type Scope struct {
	// contains filtered or unexported fields
}

Scope is a linked-list scope chain for variable-to-type bindings during AST walk. Each scope level holds its own bindings map and a pointer to the enclosing (parent) scope. Scope is NOT thread-safe; it is used within a single ResolveFile call (one goroutine per file).

This is the Go equivalent of CBMScope from codebase-memory's scope.c, simplified to use map[string]*Type per level instead of arena-allocated linked chunks.

func NewScope 

func NewScope(parent *Scope) *Scope

NewScope creates a new scope level. Pass nil for the root scope.

func (*Scope) Bind 

func (s *Scope) Bind(name string, typ *Type)

Bind binds a variable name to a type in the current scope. If the name already exists in the current scope, it is overwritten.

func (*Scope) Lookup 

func (s *Scope) Lookup(name string) *Type

Lookup walks up the scope chain looking for name. Returns the first match found. Returns nil if the name is not bound in any enclosing scope.

func (*Scope) Parent 

func (s *Scope) Parent() *Scope

Parent returns the parent scope, or nil for the root scope.

type Type 

type Type struct {
	Kind       TypeKind
	Name       string      // qualified name for Named/Builtin/TypeParam/Alias
	Elem       *Type       // element for Pointer/Slice/Array/Channel/Optional/Reference
	Key        *Type       // key for Map
	Value      *Type       // value for Map
	Params     []Param     // parameters for Func
	Returns    []*Type     // return types for Func
	Fields     []Field     // fields for Struct
	Methods    []Method    // methods for Interface
	Elements   []*Type     // elements for Tuple
	TypeParams []TypeParam // generic type parameters
	Underlying *Type       // underlying type for Alias
	ChanDir    ChanDir     // direction for Channel
}

Type is the core type representation struct with kind discrimination. Different fields are populated based on Kind, analogous to the tagged union approach in the C reference implementation (CBMType).

func Alias 

func Alias(name string, underlying *Type) *Type

Alias returns a new alias type with the given name and underlying type.

func Array 

func Array(elem *Type) *Type

Array returns a new array type with the given element type.

func Builtin 

func Builtin(name string) *Type

Builtin returns a new builtin type (int, string, bool, error, etc.).

func Channel 

func Channel(elem *Type, dir ChanDir) *Type

Channel returns a new channel type with the given element type and direction.

func Func 

func Func(params []Param, returns []*Type) *Type

Func returns a new function type with the given parameters and return types.

func Interface 

func Interface(methods []Method) *Type

Interface returns a new interface type with the given methods.

func Map 

func Map(key, value *Type) *Type

Map returns a new map type with the given key and value types.

func Named 

func Named(qualifiedName string) *Type

Named returns a new named type with the given qualified name.

func Optional 

func Optional(elem *Type) *Type

Optional returns a new optional type wrapping elem.

func Pointer 

func Pointer(elem *Type) *Type

Pointer returns a new pointer type wrapping elem.

func Ref 

func Ref(elem *Type) *Type

Ref returns a new reference type wrapping elem.

func Slice 

func Slice(elem *Type) *Type

Slice returns a new slice type with the given element type.

func Struct 

func Struct(fields []Field) *Type

Struct returns a new struct type with the given fields.

func Tuple 

func Tuple(elems []*Type) *Type

Tuple returns a new tuple type (multi-return) with the given element types.

func TypeParamType 

func TypeParamType(name string) *Type

TypeParamType returns a new generic type parameter.

func Unknown 

func Unknown() *Type

Unknown returns a new type with KindUnknown.

func (*Type) Deref 

func (t *Type) Deref() *Type

Deref removes one pointer level: returns the element type if Pointer, or the type itself otherwise.

func (*Type) GetElem 

func (t *Type) GetElem() *Type

GetElem returns the element type for Pointer, Slice, Array, Channel, Optional, and Reference kinds. Returns nil for other kinds.

func (*Type) IsInterface 

func (t *Type) IsInterface() bool

IsInterface returns true if the type has KindInterface.

func (*Type) IsPointer 

func (t *Type) IsPointer() bool

IsPointer returns true if the type has KindPointer.

func (*Type) IsUnknown 

func (t *Type) IsUnknown() bool

IsUnknown returns true if the type has KindUnknown.

type TypeKind 

type TypeKind int

TypeKind enumerates the language-agnostic type representation kinds. 

const (
	KindUnknown   TypeKind = iota
	KindNamed              // named type: "Database", "http.Request"
	KindPointer            // *T
	KindSlice              // []T
	KindMap                // map[K]V
	KindChannel            // chan T (with direction)
	KindFunc               // func(params) returns
	KindInterface          // interface{...}
	KindStruct             // struct{...}
	KindBuiltin            // int, string, bool, error, etc.
	KindTuple              // multi-return (T1, T2)
	KindTypeParam          // generic type parameter: T, K, V
	KindArray              // [N]T
	KindOptional           // *T or Option<T> language-agnostic optional
	KindReference          // &T (Rust/C++ reference)
	KindAlias              // type alias
)

func (TypeKind) String 

func (k TypeKind) String() string

String returns a human-readable name for the TypeKind.

type TypeParam 

type TypeParam struct {
	Name       string
	Constraint *Type // nil means "any"
}

TypeParam represents a generic type parameter.

Source Files

View all Source files

Directories

Path Synopsis
Package csresolve implements the C# language in-process type resolver.
 Package csresolve implements the C# language in-process type resolver.
Package goresolve implements the Go language in-process type resolver.
 Package goresolve implements the Go language in-process type resolver.
Package javaresolve implements the Java language in-process type resolver.
 Package javaresolve implements the Java language in-process type resolver.
Package pyresolve implements the Python language in-process type resolver.
 Package pyresolve implements the Python language in-process type resolver.
Package rubyresolve implements the Ruby language in-process type resolver.
 Package rubyresolve implements the Ruby language in-process type resolver.
Package rustresolve implements the Rust language in-process type resolver.
 Package rustresolve implements the Rust language in-process type resolver.
Package tsresolve implements the TypeScript/JavaScript in-process type resolver.
 Package tsresolve implements the TypeScript/JavaScript in-process type resolver.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.