[lesomnus]

For lesomnus/payday's sandbox, which a browser downloads: 24 MB of its 63 MB was the linker keeping methods nothing calls, and this was why.

What was wrong

• A descriptor listed its type's methods as it was made. goType, which every field.Uuid, field.Json, field.Other and .GoType goes through, called methods, which is reflect.Type.Method(i) for each method -- for codegen, which reads RType.Methods to know what a GoType implements.
• A running program makes descriptors too. A generated client whose schema has a default, a validator or a value scanner calls the schema's Fields at init (runtime.go), so it builds every field of that schema.
• The linker cannot prune methods in such a program. A function that calls reflect.Type.Method, or MethodByName with a name the compiler cannot see, is marked for it (<ReflectMethod> in -dumpdep). In a program that can reach one, it has to assume any exported method of any type converted to an interface may be called by name, so it keeps all of them, in every package, used or not. Nothing fails.
• RType.Implements was a second one. Its name and signature are reflect.Type's own Implements, which a program calls through the interface (encoding/json does), and the linker keeps a method of that name and type on every type converted to an interface. An RType is one, behind each field's builder, and the method's loop is the same call by index. Taking out the listing alone left the binary as big: the linker reached this next.

The chain the linker took, in payday's app:

go:main.inittasks
…/internal/ent..inittask
…/internal/ent.init.0                       (runtime.go)
…/internal/ent/schema.Access.Fields
github.com/protobuf-orm/ent/schema/field.Json
github.com/protobuf-orm/ent/schema/field.(*Descriptor).goType
github.com/protobuf-orm/ent/schema/field.methods <ReflectMethod>

Every payday app has paid it since payday's Audit gave its domain column a default (protoc-gen-orm-ent#8 turned a declared default into .Default(v), and payday took it in payday#87): that put the schema into every app's runtime.go, including apps with no default of their own.

What changed

• The loader lists the methods. RType.LoadMethods does what methods did, and entc/load's NewField calls it on every field before the schema is encoded. A descriptor records the type alone, and Methods is nil until it is loaded.
• RType.Implements is implements, unexported. It asks reflect of a type a descriptor holds, and the recorded methods of one decoded from a loaded schema, which is what entc has. TypeInfo's ValueScanner, Validator, Valuer and Stringer call it as before.
• The enum builder's Stringer check asks reflect of the type itself. It went through TypeInfo.Stringer, which reaches the loop; it would also have answered from methods that are no longer recorded at that point.
• UPSTREAM.md gets a Behaviour row: an upstream change that lists methods in goType again, or checks a descriptor through TypeInfo's predicates, undoes this.

What is generated does not change. The generate gate regenerates every example and integration schema, including the snapshots that carry RType.Methods (entc/integration/privacy/ent/internal/schema.go and others), and nothing moves. So an app regenerates nothing; it takes the fix by taking the module.

Nothing in the protobuf-orm org calls RType.Implements (protoc-gen-orm-ent, payday, roster and rove searched).

Tests

• TestMakingFieldsLetsTheLinkerPruneMethods builds schema/field/testdata/linked, which makes a schema's fields as runtime.go does -- a uuid with a default, JSON, Other, a GoType with a value scanner, an enum GoType, a defaulted uint32 -- and asks reflect.Type.Implements through the interface. It reads the linker's dump (-dumpdep). No marked function may be reached, and a failure names the chain.
  • With each of the three put back, it fails: the listing in goType, an exported Implements, the enum check through TypeInfo.Stringer. Each names its own chain.
  • The same program built with -tags load, which does what the loader does, must be marked at (*RType).LoadMethods. So a dump that could not show the mark would not pass.
• TestRType_Implements asks a descriptor's RType before it is loaded (reflect), and after it is loaded and decoded through JSON (the recorded methods). A type with no methods loads as an empty set, as the snapshots have it ({}).
• Run here, with green results:
  • go test -race ./... in cmd, dialect, schema, entc/load, entc/gen and examples.
  • dialect/sql/schema/integration on SQLite.
  • The generate gate.
  • .github/lint.sh over every tracked file.
  • entc/integration with -race -count=2 on all six engines of compose.test.yaml, on this branch and on master. MySQL 8.0 ran on its own once it accepted connections: 8.0.46 took minutes to start here.

CI has not run

GitHub has created no workflow run on this repository since 2026-10-21. These all made no run:

• this PR's push
• opening the PR
• closing and reopening it
• the same commit pushed to a second branch (deleted since)
• a re-push under a new SHA (reverted to 4d86cf3, which go.mod: protobuf-orm/ent 2248bed -- a sandbox keeps only the methods it calls, and a test links it to say so lesomnus/payday#170 pins)

The workflow is active. Actions is enabled for the repository and allows every action. githubstatus.com shows no incident. lesomnus/payday's runs started as usual over the same hours. The checks above are what the lint, unit, generate and integration jobs run, run by hand.

Measured

GOOS=js GOARCH=wasm go build -tags grpcnotrace ./wasm, with this branch replaced in:

	before	after
payday's app (internal/apptest, payday 1b4425d)	62,994,032 B	39,013,503 B

With runtime.go's init deleted outright it is 38,628,342 B, so what is left of the schema at init is 0.4 MB.

What follows

A payday PR that takes this commit, with a test that links payday's sandbox and refuses any marked function in it. Apps get it from payday's go.mod.

🤖 Generated with Claude Code

https://claude.ai/code/session_01KxtnpRW533bdErnW8QPhsk