depsurface

type Bloated struct {
	Interface string
	// Methods counts what interfacebloat counts: every method written out and
	// every embedded interface.
	Methods     int
	Limit       int
	LimitSource string
	// Suppressed: narrow-deps wrote a reasoned //nolint:interfacebloat above
	// the type, because the project's lint runs interfacebloat.
	Suppressed bool
}

type Downcast struct {
	Field  string
	File   string
	Line   int
	Target string
}

type EnvRead struct {
	File string
	Line int
	// Call is the function read through ("os.Getenv").
	Call string
}

type Field struct {
	Name string
	File string // project-relative
	Line int
	// Type is the field's type as the consumer would write it.
	Type string
	// Interface is true for an interface-typed field; Methods are its
	// exported methods, sorted.
	Interface bool
	Methods   []string
	// Foreign is true for a named interface declared in another package
	// (the consumer did not declare what it needs).
	Foreign bool
	// Used are the methods the package needs through the field: those it
	// calls, plus every method of each Role.
	Used map[string]bool
	// Roles are the interfaces the field's value is passed on as: a
	// parameter, a struct field (assigned or in a literal) or a conversion
	// whose declared type is an interface with methods. Whatever the
	// receiver does with the value, it does through that interface, so its
	// method set — as the receiver declares it — bounds what the receiver
	// needs, and is in Used.
	Roles []Role
	// Escapes is true when the value also leaves through something that
	// bounds nothing — `any`, a concrete type, a return value, a channel, a
	// map or slice element — so even Used is not the whole story.
	// EscapeAt is where it first does ("file:line").
	Escapes  bool
	EscapeAt string
	// Downcast is true when the package type-asserts the field to a
	// concrete type (Package.Downcasts says where).
	Downcast bool
	// Container names the container the field holds ("" for none).
	Container string
	// RootConfig is true for a field holding the project's root config
	// (pkg/config.Config) rather than the component's own block.
	RootConfig bool
	// contains filtered or unexported fields
}

type NarrowResult struct {
	Dir string
	// File is the project-relative file the interfaces were written to:
	// the package's contract.go, or deps.go.
	File     string
	Narrowed []Narrowed
	Skipped  []Skipped
	// Bloated are the declared interfaces wider than the project's
	// interfacebloat limit.
	Bloated []Bloated
}

type Narrowed struct {
	Field, From, To string
	// Methods are every method the new interface holds; Embeds are the
	// interfaces it embeds for the ones the package passes the value on as.
	Methods []string
	Embeds  []string
}

type Package struct {
	// Dir is the package directory, project-relative and slash-separated.
	Dir string
	// Path is the import path.
	Path string
	// DepsFile is the project-relative file declaring Deps.
	DepsFile string
	Fields   []Field
	// Downcasts are type assertions from a Deps field to a concrete type.
	Downcasts []Downcast
	// EnvReads are the package's own reads of the process environment
	// (os.Getenv, os.LookupEnv, os.Environ) in non-test files: configuration
	// the composition never handed it, and a root's config reach cannot see.
	EnvReads []EnvRead
	// contains filtered or unexported fields
}

type Role struct {
	// Type is the interface as the consumer would write it
	// ("threads.Repository"); for an interface literal or a type
	// parameter's constraint, its methods in braces.
	Type string
	// Methods are its exported methods, sorted.
	Methods []string
	// Embeddable is true when the consumer can name the interface (a named
	// interface it may refer to), so a narrowed interface can embed it.
	Embeddable bool
	// contains filtered or unexported fields
}

type Skipped struct {
	Field, Type, Reason string
}