The frontend's one typed tree: the record

Archived: a record of finished work, kept as written. nanofil's archive lists the others.

Archived from campaign.md in November 2026. In October 2026 four walks of the C expression grammar each had their own idea of types; steps 3 to 5 below made them one elaborated tree that lowering, integer constants and address constants all read. The work is done and the code is the reference (c_types.pl, c_lower.pl); this page keeps the review that started it, the design, and the record of each step.

Where we stand (October 2026)

Rounds 1 and 2 are logged in factorings.md. An outside review in October 2026 found:

• Succeeding: each C typing rule now has one home in c_types.pl as a short case analysis citing its paragraph (castable/2, assignable/3, arms_type/5, composite_type/3, binary_operands/6, unary_operand/3, expression_category/3, modifiable_lvalue/2). Merging the copies closed about 15 gaps against clang, each with a test.
• Not yet shorter: round 1 was about −80 lines; round 2 was about +190 in src/.
• Still two engines: the judgment (expression_type/3) infers types but checks little; c_lower.pl raises 71 of the frontend's 78 semantic errors, and asks the judgment about subtrees again (&, ?:, null pointer constants, modifiable lvalues), which is quadratic on nested ?:.

When this review was written, four walks traversed the same C expression grammar, each with its own idea of types and categories (steps 3 to 5 below made them one tree, read three ways):

Smaller ones: scalar-type facts spread over eight tables (int_info/3, rank/2, unsigned_of/2, type_class/2, load_op/3, store_width/2, narrow_ext/2, conversion_int_type/2); C operators tabled about six times (c_parse, c_types, c_lower), with punctuators and identifier characters defined in both c_lex.pl and c_pp.pl. (The Fil-C checks, stated separately by filc_amd64.pl and interp.pl, now have an IR form: pizlonation.md.)

Completed frontend design: one typed tree

Steps 3–5 below implemented this design. Its rationale is retained here: elaborate each full expression once into a typed tree, and let every consumer fold over it: IR emission, integer constants and address constants. One description of what each C expression is, read three ways.

% X     ::= val(Type, Node) | obj(Type, Place) | fun(Type, Designator)
% Place ::= local(Name) | global(Sym) | deref(X) | at(Place, Off)
%         | literal(Lit) | complit(Type, Init)
% Node  ::= int(N) | float(Bits) | conv(Conversion, X) | bin(Op, X, X) | ...
% Conversion ::= load | decay_array | decay_function | int(From, To)
%              | int_float | float_int | ptr_int | int_ptr | bool | void
%              | null_ptr

• The category is the principal functor, so consumers dispatch in clause heads. Conversions are explicit conv/2 nodes named after C11 6.3; binary_operands/6's converted operand types are exactly the conversions to insert.
• elaborate/4 (E, Env, Loc, X) raises the C diagnostics, keeping the current message texts (tests/reject.sh matches on them) or changing reject tests deliberately.
• expression_type/3 and expression_category/3 become projections of the tree. c_lower loses decay//3, convert//3's case analysis, assign_convert//5, cond_type//4, modifiable//3, expr_type//3 and most sema_error calls; obj//3 becomes place//2 and rvalue//3 becomes value//2. The estimate is −300 to −400 lines net.
• Incremental and byte-identical: introduce a src(E) bridge node for forms not yet elaborated, which lowering handles the old way; convert one form at a time; elaborate once per full expression, never per subexpression. Keep literal symbol numbering and the order of fresh temporaries as they are today. #if elaborates with Env = pp.
• Rejected alternative: computing constants by lowering and running interp. A constant context must refuse an oversized shift count or a zero divisor, where the IR masks the count and traps. (Signed overflow is a constraint violation by C11 6.6p4, but const_eval wraps it as clang's default folding does; see ub.md.) interp is a good test oracle, not the implementation.

Frontend roadmap and implementation record

Update the status column when a step lands, with its commit.