[lesomnus]

Fixes #18.

What was wrong

A field named field generated a mutation that did not compile. Its own methods would be AddField, AddedField, ClearField and FieldCleared, which every mutation has already (ent.Mutation), and the two halves of the template disagreed about what to do about that.

• The namers renamed, and the callers did not ask them. MutationAdd and MutationAdded answer AddFieldField and AddedFieldField, but the dispatchers that take a field by its name called the field's methods by the plain name -- m.Added{{ $f.StructField }}(), m.Add{{ $f.StructField }}(v), m.Clear{{ $f.StructField }}() -- which reached the generic methods with the wrong arguments.
• Two namers never asked mutMethods. MutationClear and MutationCleared always answered Clear<F> and <F>Cleared, which redeclared the interface's.
• Three more callers spelled a name. The update builders' sqlSave and update defaults called {{ $f.StructField }}Cleared(), and an update's check of a required unique edge {{ $e.StructField }}Cleared(), though the edge's own namer renames it. An edge named edge broke there.
• mutMethods was not every method a mutation has. It was ent.Mutation's and four others (Client, Tx, Where, SetOp). It missed Predicates, WhereP, the expression methods (SetFieldExpr, FieldExpr, ExprFields, entc/gen, sqlgraph: a mutation assigns a field a SQL expression #12), and Ids: the ent package's mutation has Ids(ctx), which is upstream's IDs spelled by this fork's rule, and a field named ids got a getter Ids() that it shadowed.

What broke, generated from master: field (the five errors in the issue), fields (AddedFields), edge (ClearEdge, EdgeCleared, and the edge check), ids (AddedIds and the getter).

What changed

• MutationClear and MutationCleared ask mutMethods as the others do: ClearFieldField, and FieldFieldCleared, which puts the word where an edge's EdgeEdgeCleared puts its own.
• Every call of a field's method goes through its namer: the dispatchers AddedField, AddField and ClearField; the update builders' Clear<F>, which keeps its own name as Set<F> does, sqlSave and defaults; and the edge check uses $e.MutationCleared.
• mutMethods lists every method a generated mutation has beside ent.Mutation's.
• UPSTREAM.md has a Behaviour row. Upstream has the same code, but for Ids.

Nothing that compiled is named differently. Every method renamed is one whose old name did not compile. The generate gate regenerates every example and integration schema, and nothing moves, so an app regenerates nothing it already had.

Tests

• entc/integration/fieldnames. Item has a numeric, optional, nillable field for each of field, fields, edge, ids, where, op and type; Owner has an update default on field and a required unique edge named edge. Generated with entql, privacy, intercept, sql/upsert, sql/modifier and sql/returning. It compiles, which it did not. On every engine:
  • each field is written, read, filtered and ordered by;
  • an update adds to each, and an update of many clears each;
  • a hook adds to, clears and sets each through AddField, ClearField and SetField, by name, and reads AddedField and FieldCleared back;
  • Owner's update default is filled unless the update clears the field, and its edge moves and refuses to be cleared.
• entc/gen.
  • TestField_MutationNames names a field after every method in mutMethods, and after what is left of one without a namer's prefix or suffix (field for AddField, edge for EdgeCleared), and fails a namer that answers a method every mutation has.
  • TestMutationMethods generates a type with nothing of its own, reads the methods of its two mutations, and fails one mutMethods does not list.
  • On master's type.go they fail with MutationClear of a field named "edge" is ClearEdge and every mutation has SetFieldExpr.
• Run here, green:
  • go test -race in entc/gen and examples;
  • the generate gate;
  • .github/lint.sh over the files changed;
  • entc/integration/fieldnames on SQLite, MySQL 8.0 and 8.4, MariaDB 10.11 and 11.4, and PostgreSQL 14 and 17;
  • the whole entc/integration with -race -count=2 on all six engines. Twenty packages passed together; the root package, enttime and migrate ran into go test's ten minutes on this machine, which was loaded throughout (load average 14 to 20 on 16 cores), and passed run one at a time (-p 1 -timeout 60m). CI ran the same in about four minutes.

Found, not changed

These are of the same family. Nothing here needs them.

• An edge's own getters are spelled, not named. <Edge>Ids(), Removed<Edge>Ids() and <Edge>Id() have no namer, so an edge named added or removed gets an AddedIds() or RemovedIds() beside the interface's.
• entql gives the ent package's mutation a Filter(). It shadows the getter of a field named filter. It is not in mutMethods, since the list is not per graph: putting it there would rename that getter in every graph without entql.
• Two fields can meet each other. The ent package's mutation names the old value of name OldName(ctx), which shadows the getter of a field named old_name. A schema with both does not compile.

Stacked

#22 (#19) is on top of this branch.

🤖 Generated with Claude Code

https://claude.ai/code/session_01KxtnpRW533bdErnW8QPhsk