indexer

type EmitOptions struct {
	// If true, emit nodes for standard library packages when they are first
	// encountered. This is helpful if you want to index a package in isolation
	// where data for the standard library are not available.
	EmitStandardLibs bool

	// If true, emit code facts containing MarkedSource messages.
	EmitMarkedSource bool

	// If true, emit linkages specified by metadata rules.
	EmitLinkages bool

	// If true, emit childof edges for an anchor's semantic scope.
	EmitAnchorScopes bool

	// If true, use the enclosing file for top-level callsite scopes.
	UseFileAsTopLevelScope bool

	// If set, use this as the base URL for links to godoc.  The import path is
	// appended to the path of this URL to obtain the target URL to link to.
	DocBase *url.URL

	// If true, the doc/uri fact is only emitted for go std library packages.
	OnlyEmitDocURIsForStandardLibs bool

	// If enabled, all VNames emitted by the indexer are assigned the
	// compilation unit's corpus.
	UseCompilationCorpusForAll bool

	// If set, all stdlib nodes are assigned this corpus. This takes precedence
	// over UseCompilationCorpusForAll for stdlib nodes.
	OverrideStdlibCorpus string

	// EmitRefCallOverIdentifier determines whether ref/call anchors are emitted
	// over function identifiers (or the legacy behavior of over the entire
	// callsite).
	EmitRefCallOverIdentifier bool

	// FlagConstructors is a set of known flag constructor functions.
	FlagConstructors *gopb.FlagConstructors

	// Verbose determines whether verbose logging is enabled.
	Verbose bool
}

type Fetcher interface {
	Fetch(path, digest string) ([]byte, error)
}

type PackageInfo struct {
	Name         string                        // The (short) name of the package
	ImportPath   string                        // The nominal import path of the package
	Package      *types.Package                // The package for this compilation
	Dependencies map[string]*types.Package     // Packages imported from dependencies
	VName        *spb.VName                    // The base vname for this package
	PackageVName map[*types.Package]*spb.VName // Resolved package to vname
	FileSet      *token.FileSet                // Location info for the source files
	Files        []*ast.File                   // The parsed ASTs of the source files
	SourceText   map[*ast.File]string          // The text of the source files
	Rules        map[*ast.File]metadata.Rules  // Mapping metadata for each source file
	Vendored     map[string]string             // Mapping from package to its vendor path

	Info   *types.Info // If non-nil, contains type-checker results
	Errors []error     // All errors reported by the type checker
	// contains filtered or unexported fields
}

type ResolveOptions struct {
	// Passes a value whose non-nil map fields will be filled in by the type
	// checker during resolution. The value will also be copied to the Info
	// field of the PackageInfo returned by Resolve.
	Info *types.Info

	// If set, this function is called for each required input to check whether
	// it contains metadata rules.
	//
	// Valid return are:
	//    rs, nil    -- a valid ruleset
	//    nil, nil   -- no ruleset found
	//    _, err     -- an error attempting to load a ruleset
	//
	CheckRules func(ri *apb.CompilationUnit_FileInput, f Fetcher) (*Ruleset, error)
}

type Ruleset struct {
	Path  string         // the file path this rule set applies to
	Rules metadata.Rules // the rules that apply to the path
}

type Sink func(context.Context, *spb.Entry) error