resolver

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

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

type ConflictResolver interface {
	// Name is the canonical name for the resolver
	Name() string
	// RegisterFlags configures the flags.  RegisterFlags is called for all
	// resolvers whether they are enabled or not.
	RegisterFlags(fs *flag.FlagSet, cmd string, c *config.Config)
	// CheckFlags asserts that the flags are correct.  CheckFlags is only called
	// if the resolver is enabled.
	CheckFlags(fs *flag.FlagSet, c *config.Config) error
	// ResolveConflict takes the context rule and imports, and the target symbol
	// with conflicts to resolve.
	ResolveConflict(universe Universe, r *rule.Rule, imports ImportMap, imp *Import, symbol *Symbol) (*Symbol, bool)
}

type ConflictResolverRegistry interface {
	// GetConflictResolver returns the named resolver.  If not known `(nil,
	// false)` is returned.
	GetConflictResolver(name string) (ConflictResolver, bool)

	// PutConflictResolver adds the given known rule to the registry.  It is an
	// error to attempt duplicate registration of the same rule twice.
	// Implementations should use the google.golang.org/grpc/status.Errorf for
	// error types.
	PutConflictResolver(name string, r ConflictResolver) error
}

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

type Import struct {
	// Kind is the import type
	Kind sppb.ImportKind
	// Imp is the name of the import
	Imp string
	// File is the source file (when this is a direct import).
	Source *sppb.File
	// Src is the name of the parent import (when this is an implicit import)
	Src string
	// Symbol is the resolved symbol of the import, or nil if not resolved.
	Symbol *Symbol
	// Error is assiged if there is a resolution error.
	Error error
}

type ImportMap map[string]*Import

type KnownRuleRegistry interface {
	// GetKnownRule does a lookup of the given label and returns the
	// known rule.  If not known `(nil, false)` is returned.
	GetKnownRule(from label.Label) (*rule.Rule, bool)

	// PutKnownRule adds the given known rule to the registry.  It is an
	// error to attempt duplicate registration of the same rule twice.
	// Implementations should use the google.golang.org/grpc/status.Errorf for
	// error types.
	PutKnownRule(from label.Label, r *rule.Rule) error
}

type LabelNameRewriteSpec struct {
	// Src is the label name pattern to match
	Src string
	// Dst is the label name pattern to rewrite
	Dst string
}

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

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

type PredefinedLabelConflictResolver struct {
}

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

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

type Scope interface {
	fmt.Stringer

	// GetScope returns a scope for th symbol under the given prefix.
	GetScope(name string) (Scope, bool)

	// GetSymbol does a lookup of the given import symbol and returns the
	// known import.  If not known `(nil, false)` is returned.
	GetSymbol(name string) (*Symbol, bool)

	// GetSymbols does a lookup of the given prefix and returns the
	// symbols.
	GetSymbols(prefix string) []*Symbol

	// PutSymbol adds the given known import to the registry.  It is an
	// error to attempt duplicate registration of the same import twice.
	PutSymbol(known *Symbol) error
}

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

type Symbol struct {
	// Type is the kind of symbol this is.
	Type sppb.ImportType
	// Name is the fully-qualified import name.
	Name string
	// Label is the bazel label where the symbol is provided from.
	Label label.Label
	// Provider is the name of the provider that supplied the symbol.
	Provider string
	// Conflicts is a list of symbols provided by another provider or label.
	Conflicts []*Symbol
	// Requires is a list of other symbols that are required by this one.
	Requires []*Symbol
}

type SymbolMap map[string]*Symbol

type SymbolProvider interface {
	// Providers have canonical names
	Name() string
	// RegisterFlags configures the flags.  RegisterFlags is called for all
	// providers whether they are enabled or not.
	RegisterFlags(fs *flag.FlagSet, cmd string, c *config.Config)
	// CheckFlags asserts that the flags are correct and provides a scope to
	// provide symbols to.  CheckFlags is only called if the provider is
	// enabled.
	CheckFlags(fs *flag.FlagSet, c *config.Config, scope Scope) error
	// OnResolve is a lifecycle hook that gets called when the resolve phase has
	// started.
	OnResolve() error
	// OnEnd is a lifecycle hook that gets called when the resolve phase has
	// ended.
	OnEnd() error
	// Providers typically manage a particular sub-space of labels.  For
	// example, the maven resolver may return true for labels like
	// "@maven//:junit_junit". The rule Index can be used to consult what type
	// of label from is, based on the rule characteristics.
	CanProvide(dep label.Label, knownRule func(from label.Label) (*rule.Rule, bool)) bool
}

type SymbolProviderRegistry interface {
	// SymbolProviders returns a list of all known providers.
	SymbolProviders() []SymbolProvider

	// AddSymbolProvider adds the given known import provider to the
	// registry.  It is an error to add the same namedprovider twice.
	AddSymbolProvider(provider SymbolProvider) error
}

type SymbolResolver interface {
	// ResolveSymbol takes the given config, gazelle rule index, and an
	// import to resolve.
	ResolveSymbol(c *config.Config, ix *resolve.RuleIndex, from label.Label, lang string, sym string) (*Symbol, bool)
}

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

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

type Universe interface {
	SymbolProviderRegistry
	KnownRuleRegistry
	ConflictResolverRegistry
	Scope
	SymbolResolver
}