analyzers

type EntityDecl struct {
	Name  string
	Group string
	File  string
	Line  int
	Pos   token.Pos
}

type EntityInfo struct {
	Name   string
	Fields []string
	// FieldsResolved is false when Fields came from a helper call rather
	// than a literal slice. The scoping rules stay quiet in that case:
	// they cannot see the columns, and guessing would mean either false
	// findings or a false all-clear.
	FieldsResolved bool

	CRUDDisabled bool
	MCP          bool
	Public       bool
	HasAccess    bool
	OwnerField   string
	MultiTenant  bool
	// AccessPermissions are the permission strings the entity's Access
	// block names. These are the permissions least likely to be exercised
	// by accident: nothing in the app calls them by name, so only a real
	// request through the CRUD layer can prove them.
	AccessPermissions []string

	File string
	Line int
	Pos  token.Pos
}

type EventSub struct {
	// Type is the event type string the handler listens for.
	Type string
	File string
	Line int
	Pos  token.Pos
}

type HookDecl struct {
	// Entity is the entity name the hook is attached to.
	Entity string
	// Type is the lifecycle point, lower-cased to match the manifest
	// ("beforecreate", "afterupdate", …).
	Type string
	File string
	Line int
	Pos  token.Pos
}

type RoleGrant struct {
	// Role is the role name granted permissions.
	Role string
	File string
	Line int
	Pos  token.Pos
}

type Route struct {
	// Method is the HTTP verb exactly as written, case included, since a
	// lowercase one is a finding rather than something to normalise away.
	Method string
	// Pattern is the full path with any resolvable group prefix applied.
	Pattern string
	// RawPattern is the literal passed at the call site, before prefixing.
	RawPattern string
	// Group is the receiver identifier, "" for a direct router call.
	Group string
	// Guarded is true when the route was registered on a group carrying
	// access or middleware, which is the framework's guarding seam.
	Guarded bool
	// Handler is the handler expression, for evidence.
	Handler string
	// Screen marks a route declared through `app.NewScreen`. Screens are
	// matched by core-ui's own router, NOT by ServeMux, and that router
	// takes `:id` parameters natively. It even rewrites `{id}` into
	// `:id`. Every rule about ServeMux pattern syntax must therefore skip
	// them, or it reports the correct spelling as a bug.
	Screen bool
	// Package is the import path of the registering package. Duplicate
	// detection is scoped by it: two example apps in one repository both
	// serving "/healthz" are not a conflict, they are two programs.
	Package string

	File string
	Line int
	Col  int
	Pos  token.Pos
}

type RouteTable struct {
	Routes   []Route
	Entities []EntityDecl
	// Registered is true when at least one registration was found,
	// distinguishing "no routes" from "this project does not register
	// routes in a way the static pass can see". Analyzers stay quiet in
	// the second case rather than reporting an empty app.
	Registered bool
}

type SheetInput struct {
	Path string
	Src  string
}

type StyleGroup struct {
	// GOOS and GOARCH are the platform the closure was computed for.
	GOOS, GOARCH string
	// MainDir is the pass-relative directory of the package main; ""
	// for the unreached group.
	MainDir string
	// Dirs are the pass-relative, slash-separated directories of the
	// program's import closure, sorted; empty for the unreached group.
	Dirs []string
	// Sheets and TokensFiles are the pass-relative sheet and tokens
	// file paths under Dirs, sorted.
	Sheets, TokensFiles []string
	// Tokens is the token map this group's sheets are judged against.
	Tokens map[string]string
	// AppTokens is every app token that parsed, in file order.
	AppTokens []ownstyle.AppTokenAt
	// ParsedTokens holds each tokens file's parse, keyed by path; a
	// file two programs reach parses identically in both.
	ParsedTokens map[string]*ownstyle.TokensFile
	// TokenFindings are this group's tokens-file checks (the call
	// `gofastr gen styles` makes), in check order.
	TokenFindings []ownstyle.FileDiagnostic
}

type StyleProgramChecks struct {
	Groups []StyleGroup

	// SheetFindings maps each input sheet path to its ownstyle.Check
	// findings across every group that reaches it — a binary only
	// carries its own tokens, so a sheet two programs share must
	// satisfy each — with identical findings collapsed to one, sorted
	// by line, column, rule, message.
	SheetFindings map[string][]ownstyle.Diagnostic

	// DuplicateNames maps each sheet whose owner name another sheet of
	// one program shares to the sorted other sheets of every such
	// program (GOFASTR1816's shape).
	DuplicateNames map[string][]string

	// RepeatedLiterals are the GOFASTR1822 occurrences, one per site
	// with every program's partners merged into the message.
	RepeatedLiterals []ownstyle.FileDiagnostic
}