natives: checker rules N1-N10 and the intrinsic typing table for native bodies (step 3 of #53)

orion commented

2026-10-25 01:11:49 +00:00

Collaborator

Context

Step 3 of #53 (natives: native fn bodies as IR and native { } blocks). Step 1 (#410) landed the design record docs/design/NATIVE-BODIES.md, step 2 (#467, PR #472) the parser: a body or block is parsed into NativeBody / ExpressionKind.NativeBlock and the checker answers every one with A `native` body is not supported yet (compiler/src/semantics/checker/declaration.trb). This is slice 2 of the record's section 8: the checker rules. Nothing is lowered yet.

Goal

Replace the single "not supported yet" error by the verification of section 3 and the rules N1 to N10 of section 4, driven by one typing table, so a malformed body is refused with the record's text and a well-formed one is accepted by the checker.

The table. intrinsicSignature of section 3.2 (operands and result per IntrinsicOperation and numeric kind) as the single source, in compiler/src/ir/ next to Intrinsic. The IR verifier (ir/verify.trb) and the new check both call it. A test fails while an IntrinsicOperation has no row.
The rules. N1 (std packages only), N2 (name, kind, unchecked shape), N3 (arity), N4 (compiler-emitted intrinsics are not nameable), N5 (operand types, literals fit), N6 (scope of names, no var operand), N7 (result type, no trailing const), N8 (unchecked only on add, subtract, multiply, negate of an integer kind), N9 (manifest mismatch as an internal error: a native fn with a body that has a manifest row; the converse half of the rule is the existing text), N10 (no generic type parameter in a body). Error texts, notes and spans exactly as the table of section 4.
What is accepted is only checked, not lowered: a body or block that passes the rules ends the checker with no error, and lowering reports its own clean "not lowered yet" internal error until step 4, so no half-lowered IR can reach std.

Acceptance criteria

intrinsicSignature exists once; ir/verify.trb uses it for the typing of intrinsic calls, and a test enumerates every IntrinsicOperation against it.
One test per rule N1 to N10 pins the error text (and the note where the record gives one) and its span, in the style of compiler/tests/program-shape.test.trb; N1 uses an ordinary package, the others a std package fixture.
The examples of sections 2.3 and 2.4 of the record (Int64.add, shiftedLeft, convert.i8.i64, the isOdd block, the multi-statement block) check without error in a std package fixture.
A bodiless native fn and the manifest are unchanged; no std/ file and no compiler/ source uses the form; existing tests unchanged.
sh tools/gates.sh a green in forge CI; the commit builds on the current seed.

Design record point

docs/design/NATIVE-BODIES.md sections 3 (what the checker verifies), 4 (rules N1-N10) and 8 (slice 2). Update section 8 if the table's module differs from the one named here.

Seed impact

None of its own: the form is already taught by #467 and the compiler's own sources do not use it, so the current seed builds the commit. No new native, no new driver flag, no name the compiler looks up by string. The two-commit rule continues with step 4 (lowering, then the seed refresh, which stays Torben's) and the std migration.

Size

One PR, one or two Conventional Commits: refactor(ir): one typing table for intrinsics (table plus verifier switch, if the diff warrants a split) and feat(checker): verify native bodies and blocks. The table is a deliberate part of this step because the record makes the checker and the verifier share it.

Dependencies

Part of #53 (epic), after #467 (parser, landed). Blocks the lowering step of #53.

## Context Step 3 of #53 (natives: `native fn` bodies as IR and `native { }` blocks). Step 1 (#410) landed the design record [`docs/design/NATIVE-BODIES.md`](https://git.torb.dev/torbscript/language/src/branch/main/docs/design/NATIVE-BODIES.md), step 2 (#467, PR #472) the parser: a body or block is parsed into `NativeBody` / `ExpressionKind.NativeBlock` and the checker answers every one with `` A `native` body is not supported yet `` (`compiler/src/semantics/checker/declaration.trb`). This is slice 2 of the record's section 8: the checker rules. Nothing is lowered yet. ## Goal Replace the single "not supported yet" error by the verification of section 3 and the rules N1 to N10 of section 4, driven by one typing table, so a malformed body is refused with the record's text and a well-formed one is accepted by the checker. - **The table.** `intrinsicSignature` of section 3.2 (operands and result per `IntrinsicOperation` and numeric kind) as the single source, in `compiler/src/ir/` next to `Intrinsic`. The IR verifier (`ir/verify.trb`) and the new check both call it. A test fails while an `IntrinsicOperation` has no row. - **The rules.** N1 (std packages only), N2 (name, kind, `unchecked` shape), N3 (arity), N4 (compiler-emitted intrinsics are not nameable), N5 (operand types, literals fit), N6 (scope of names, no `var` operand), N7 (result type, no trailing `const`), N8 (`unchecked` only on `add`, `subtract`, `multiply`, `negate` of an integer kind), N9 (manifest mismatch as an internal error: a `native fn` with a body that has a manifest row; the converse half of the rule is the existing text), N10 (no generic type parameter in a body). Error texts, notes and spans exactly as the table of section 4. - **What is accepted** is only checked, not lowered: a body or block that passes the rules ends the checker with no error, and lowering reports its own clean "not lowered yet" internal error until step 4, so no half-lowered IR can reach `std`. ## Acceptance criteria - [ ] `intrinsicSignature` exists once; `ir/verify.trb` uses it for the typing of intrinsic calls, and a test enumerates every `IntrinsicOperation` against it. - [ ] One test per rule N1 to N10 pins the error text (and the note where the record gives one) and its span, in the style of `compiler/tests/program-shape.test.trb`; N1 uses an ordinary package, the others a std package fixture. - [ ] The examples of sections 2.3 and 2.4 of the record (`Int64.add`, `shiftedLeft`, `convert.i8.i64`, the `isOdd` block, the multi-statement block) check without error in a std package fixture. - [ ] A bodiless `native fn` and the manifest are unchanged; no `std/` file and no `compiler/` source uses the form; existing tests unchanged. - [ ] `sh tools/gates.sh a` green in forge CI; the commit builds on the current seed. ## Design record point `docs/design/NATIVE-BODIES.md` sections 3 (what the checker verifies), 4 (rules N1-N10) and 8 (slice 2). Update section 8 if the table's module differs from the one named here. ## Seed impact None of its own: the form is already taught by #467 and the compiler's own sources do not use it, so the current seed builds the commit. No new native, no new driver flag, no name the compiler looks up by string. The two-commit rule continues with step 4 (lowering, then the seed refresh, which stays Torben's) and the `std` migration. ## Size One PR, one or two Conventional Commits: `refactor(ir): one typing table for intrinsics` (table plus verifier switch, if the diff warrants a split) and `feat(checker): verify native bodies and blocks`. The table is a deliberate part of this step because the record makes the checker and the verifier share it. ## Dependencies - Part of #53 (epic), after #467 (parser, landed). Blocks the lowering step of #53.

orion added the

loop

ready

labels

2026-10-25 01:11:49 +00:00

orion commented

2026-10-25 01:11:54 +00:00

Author

Collaborator

[loop:torbscript] decided by the loop: this is slice 2 of the record (checker rules), filed just in time now that #467 landed (PR #472). Keyword search for duplicates (native, native fn, native block, checker rules, IR body) found no open issue for it. The shared typing table moves into this step because section 3.2 makes it the single source for the verifier and the checker; the 1-2 commit size holds (table + verifier switch, rules + tests). No seed impact and no owner question: the record decides the rules and reserves nothing for the owner. Marked ready.

[loop:torbscript] decided by the loop: this is slice 2 of the record (checker rules), filed just in time now that #467 landed (PR #472). Keyword search for duplicates (native, native fn, native block, checker rules, IR body) found no open issue for it. The shared typing table moves into this step because section 3.2 makes it the single source for the verifier and the checker; the 1-2 commit size holds (table + verifier switch, rules + tests). No seed impact and no owner question: the record decides the rules and reserves nothing for the owner. Marked `ready`.

orion referenced this issue

2026-10-25 01:11:55 +00:00

natives: native fn bodies as IR and native { } blocks #53

orion commented

2026-10-25 01:20:49 +00:00

Author

Collaborator

[loop:torbscript] claim implement by session:loop-torbscript-20261025-0258 until 2026-10-25T07:25:00Z

orion commented

2026-10-25 01:21:54 +00:00

Author

Collaborator

[loop:torbscript] implement: checkpoint (worker context budget reached, no code written yet), next: implement continues with a fresh worker (claim by session:loop-torbscript-20261025-0258 stays, lease until 2026-10-25T07:25:00Z).

Done: worktree code/wt/torbscript-language-478-native-checker on branch loop/478-native-checker from main 32d880c9 (not pushed, no changes yet). Read the design record, CLAUDE.md and the code the step touches. Worker usage so far: about 90k prompt tokens.

Findings for the next worker:

Parser output is in compiler/src/syntax/ast.trb (NativeBody, NativeStatement, NativeResult, NativeOperation{name: String joined with ".", nameSpan, operands, span}, NativeOperand{Path|IntegerLiteral|FloatLiteral|BoolLiteral}); the name is one joined string, so the span of the unchecked suffix (N8) has to be computed from nameSpan (last 9 columns) or the parser has to keep the segment spans.
The two "not supported yet" errors to replace: compiler/src/semantics/checker/declaration.trb:763 (native fn body) and compiler/src/semantics/checker/expression.trb:184 (.NativeBlock).
IR side: Intrinsic{operation, kind, checked}, IntrinsicOperation, NumericKind in compiler/src/ir/ir.trb:552-640; names via describeIntrinsic/describeOperation (private) in ir/print.trb:661-733. Typing is spread over ir/verify.trb:1342-1640 (verifyIntrinsic, verifyOperands, verifyIntrinsicResult, operandCountOf (public, only used there), needsNumericKind, allowsNumericKind, producesNoValue, conversionKindOf where a Char is a valid conversion source, comparisons without kind compare any two equal types, textConcat operands may be primitives the runtime shows).
Plan: new compiler/src/ir/intrinsics.trb with intrinsicSignature(Intrinsic) as an IR-type-independent shape (operand/result as Numeric(kind), Bool, Text, SameAsFirst, Integer, variadic flag, no-result flag, emittedByCompiler flag) plus a parse of the printed name into an Intrinsic; make verify.trb derive operand count, kind rules and result from it while keeping its messages (check tests that pin them before touching); a test enumerates every IntrinsicOperation (use an exhaustive match in the table so a missing row fails the build, plus the enumeration test). Then the checker module (new file next to declaration.trb), tests in compiler/tests/native-bodies.test.trb in the style of program-shape.test.trb with a std package fixture.
Record inconsistency to settle in the PR: section 3.2 says textCompare is the lowering's own, N4's list and the grammar disagree (grammar lists it, N4 list omits it). Decide: not nameable (the lowering emits it only against zero, and no manifest row is a .Intrinsic textCompare), and fix N4's list and the grammar in section 2.1/4 of docs/design/NATIVE-BODIES.md, then regenerate skills/ only if the docs template pulls it in.
No torb binary exists on the host: write .trb carefully and let forge CI be the compiler; torb format --check is not available locally either, so match the surrounding layout by hand (120 columns, no semicolons).

Still open: everything in the acceptance criteria.

[loop:torbscript] implement: checkpoint (worker context budget reached, no code written yet), next: implement continues with a fresh worker (claim by session:loop-torbscript-20261025-0258 stays, lease until 2026-10-25T07:25:00Z). Done: worktree `code/wt/torbscript-language-478-native-checker` on branch `loop/478-native-checker` from `main` 32d880c9 (not pushed, no changes yet). Read the design record, CLAUDE.md and the code the step touches. Worker usage so far: about 90k prompt tokens. Findings for the next worker: - Parser output is in `compiler/src/syntax/ast.trb` (`NativeBody`, `NativeStatement`, `NativeResult`, `NativeOperation{name: String joined with ".", nameSpan, operands, span}`, `NativeOperand{Path|IntegerLiteral|FloatLiteral|BoolLiteral}`); the name is one joined string, so the span of the `unchecked` suffix (N8) has to be computed from `nameSpan` (last 9 columns) or the parser has to keep the segment spans. - The two "not supported yet" errors to replace: `compiler/src/semantics/checker/declaration.trb:763` (native fn body) and `compiler/src/semantics/checker/expression.trb:184` (`.NativeBlock`). - IR side: `Intrinsic{operation, kind, checked}`, `IntrinsicOperation`, `NumericKind` in `compiler/src/ir/ir.trb:552-640`; names via `describeIntrinsic`/`describeOperation` (private) in `ir/print.trb:661-733`. Typing is spread over `ir/verify.trb:1342-1640` (`verifyIntrinsic`, `verifyOperands`, `verifyIntrinsicResult`, `operandCountOf` (public, only used there), `needsNumericKind`, `allowsNumericKind`, `producesNoValue`, `conversionKindOf` where a `Char` is a valid conversion source, comparisons without kind compare any two equal types, `textConcat` operands may be primitives the runtime shows). - Plan: new `compiler/src/ir/intrinsics.trb` with `intrinsicSignature(Intrinsic)` as an IR-type-independent shape (operand/result as `Numeric(kind)`, `Bool`, `Text`, `SameAsFirst`, `Integer`, variadic flag, no-result flag, `emittedByCompiler` flag) plus a parse of the printed name into an `Intrinsic`; make `verify.trb` derive operand count, kind rules and result from it while keeping its messages (check tests that pin them before touching); a test enumerates every `IntrinsicOperation` (use an exhaustive `match` in the table so a missing row fails the build, plus the enumeration test). Then the checker module (new file next to `declaration.trb`), tests in `compiler/tests/native-bodies.test.trb` in the style of `program-shape.test.trb` with a std package fixture. - Record inconsistency to settle in the PR: section 3.2 says `textCompare` is the lowering's own, N4's list and the grammar disagree (grammar lists it, N4 list omits it). Decide: not nameable (the lowering emits it only against zero, and no manifest row is a `.Intrinsic` textCompare), and fix N4's list and the grammar in section 2.1/4 of `docs/design/NATIVE-BODIES.md`, then regenerate `skills/` only if the docs template pulls it in. - No `torb` binary exists on the host: write `.trb` carefully and let forge CI be the compiler; `torb format --check` is not available locally either, so match the surrounding layout by hand (120 columns, no semicolons). Still open: everything in the acceptance criteria.

orion commented

2026-10-25 01:31:29 +00:00

Author

Collaborator

[loop:torbscript] release implement: the worker ended at its context budget without code (checkpoint above, CONTINUE 1 of 3), and this session has no spawn tool to start the successor, so the claim is released instead of holding a slot until its lease ends. next: implement continues with a fresh worker from the checkpoint at the next tick.

orion commented

2026-10-25 01:32:30 +00:00

Author

Collaborator

[loop:torbscript] claim implement by session:loop-torbscript-20261025-0258 until 2026-10-25T07:40:00Z (continuation 1 of 3, from the checkpoint)

orion commented

2026-10-25 01:34:53 +00:00

Author

Collaborator

[loop:torbscript] implement: checkpoint 2 (continuation 1 reached its context guard), next: implement continues with a fresh worker (claim by session:loop-torbscript-20261025-0258 stays).

Pushed: branch loop/478-native-checker @ 2a640345, one commit refactor(ir): add the typing table of intrinsics = new compiler/src/ir/intrinsics.trb (NOT yet used by anything, not compiled yet): intrinsicSignature(Intrinsic): IntrinsicSignature{operands: List<IntrinsicType>, variadic, result} (exhaustive match, no wildcard, so a new IntrinsicOperation fails the build), IntrinsicType{Numeric(kind), Source(kind), Boolean, Text, TextPart, SameAsFirst, LazyCell, LazyItem, Anything}, kindUseOf (Required/Optional/Forbidden), isEmittedByCompiler (N4; includes textCompare, see the record fix below), everyOperation() for the enumeration test.

Remaining (in order):

verify.trb (lines ~1342-1640): replace operandCountOf (public, no other user), needsNumericKind/allowsNumericKind, producesNoValue (public, no other user) and the operand/result typing by the table. Keep the messages pinned by tests/ir.test.trb (lines 539 the result of lessis aBool, and %2 is Int64, 562 `the result of `add.i64` is `Int32` and %1 is `Int64, 621-684, 790): for a Numeric result whose operand 0 has the same shape, keep expectType against the first operand; Convert result keeps expectNumeric; Text operand of printParts keeps verifyTextOperands, TextPart keeps verifyPartOperands, SameAsFirst keeps verifySameOperands, Anything/LazyCell operands unchecked, LazyItem result keeps the lazy-cell check. describeOperation in print.trb is private: make it public or add a name parser (parseIntrinsicName(String): Intrinsic?-like, for N2) in intrinsics.trb.
Checker: replace the two "not supported yet" errors (checker/declaration.trb:763 in checkFunctionShape, which is a syntactic pass before types exist, and checker/expression.trb:184 .NativeBlock) by a new checker/native.trb. Open question found: operand types need TypeIds of parameters/self/consts; look at how check.trb:421/:976 and statement.trb:606 check a function body (scope + slots) and where the std-package test is (packageNameOf, requireStandardLibrary in declaration.trb:707-735 for N1; message and note are in the record). Map a TypeId to NumericKind via the Nominal symbol names (WellKnown, wellknown.trb); N8's span: last 9 columns of nameSpan (name is a joined String).
Tests compiler/tests/native-bodies.test.trb (N1 with problems, others with a std package fixture via problemsAt(files, ["std/..."]), see implementations.test.trb:149) plus a test over everyOperation(); update program-shape.test.trb:364-381 ("not supported yet" tests) and the record: fix N4 list and the grammar (textCompare is compiler-only), section 8 module name compiler/src/ir/intrinsics.trb.
PR Closes #478, review argus.

[loop:torbscript] implement: checkpoint 2 (continuation 1 reached its context guard), next: implement continues with a fresh worker (claim by session:loop-torbscript-20261025-0258 stays). Pushed: branch `loop/478-native-checker` @ 2a640345, one commit `refactor(ir): add the typing table of intrinsics` = new `compiler/src/ir/intrinsics.trb` (NOT yet used by anything, not compiled yet): `intrinsicSignature(Intrinsic): IntrinsicSignature{operands: List<IntrinsicType>, variadic, result}` (exhaustive `match`, no wildcard, so a new `IntrinsicOperation` fails the build), `IntrinsicType{Numeric(kind), Source(kind), Boolean, Text, TextPart, SameAsFirst, LazyCell, LazyItem, Anything}`, `kindUseOf` (Required/Optional/Forbidden), `isEmittedByCompiler` (N4; includes `textCompare`, see the record fix below), `everyOperation()` for the enumeration test. Remaining (in order): 1. `verify.trb` (lines ~1342-1640): replace `operandCountOf` (public, no other user), `needsNumericKind`/`allowsNumericKind`, `producesNoValue` (public, no other user) and the operand/result typing by the table. Keep the messages pinned by `tests/ir.test.trb` (lines 539 `the result of `less` is a `Bool`, and %2 is `Int64``, 562 `the result of `add.i64` is `Int32` and %1 is `Int64``, 621-684, 790): for a `Numeric` result whose operand 0 has the same shape, keep `expectType` against the first operand; `Convert` result keeps `expectNumeric`; `Text` operand of printParts keeps `verifyTextOperands`, `TextPart` keeps `verifyPartOperands`, `SameAsFirst` keeps `verifySameOperands`, `Anything`/`LazyCell` operands unchecked, `LazyItem` result keeps the lazy-cell check. `describeOperation` in print.trb is private: make it public or add a name parser (`parseIntrinsicName(String): Intrinsic?`-like, for N2) in intrinsics.trb. 2. Checker: replace the two "not supported yet" errors (`checker/declaration.trb:763` in `checkFunctionShape`, which is a syntactic pass before types exist, and `checker/expression.trb:184` `.NativeBlock`) by a new `checker/native.trb`. Open question found: operand types need `TypeId`s of parameters/`self`/`const`s; look at how `check.trb:421`/`:976` and `statement.trb:606` check a function body (scope + slots) and where the std-package test is (`packageNameOf`, `requireStandardLibrary` in declaration.trb:707-735 for N1; message and note are in the record). Map a TypeId to `NumericKind` via the `Nominal` symbol names (`WellKnown`, wellknown.trb); N8's span: last 9 columns of `nameSpan` (name is a joined String). 3. Tests `compiler/tests/native-bodies.test.trb` (N1 with `problems`, others with a std package fixture via `problemsAt(files, ["std/..."])`, see implementations.test.trb:149) plus a test over `everyOperation()`; update `program-shape.test.trb:364-381` ("not supported yet" tests) and the record: fix N4 list and the grammar (`textCompare` is compiler-only), section 8 module name `compiler/src/ir/intrinsics.trb`. 4. PR `Closes #478`, review argus.

orion commented

2026-10-25 01:44:37 +00:00

Author

Collaborator

[loop:torbscript] implement: checkpoint 3 (continuation 2 reached its context guard), next: implement continues with a fresh worker (claim by session:loop-torbscript-20261025-0258 stays).

Pushed: branch loop/478-native-checker @ c4fea69d, two commits: refactor(ir): add the typing table of intrinsics (new compiler/src/ir/intrinsics.trb) and refactor(ir): verify intrinsic calls against the typing table (step 1 DONE, not compiled locally; CI is the compiler): verify.trb verifyIntrinsic now uses intrinsicSignature/kindUseOf; operandCountOf, producesNoValue, needsNumericKind, allowsNumericKind, isShift/Conversion/TextParts/Comparison/BooleanOperation removed; new table-driven verifyOperands, verifyIntrinsicResult + verifyResultRow; print.trb describeOperation is now public. Risk to watch on first CI: or-patterns with payloads (.Source(_) arms), rows[if .. {..} else {..}] indexing in verifyOperands, textEqual operand message is now "joins strings" (was "compares"), Boolean operand of booleanNot is unchecked. No PR opened yet; run sh tools/gates.sh a only in CI (open a draft-free PR early to get CI on this commit, if it compiles in CI fix first).

Remaining:
2. Checker (new compiler/src/semantics/checker/native.trb). Findings:

Types: AST in syntax/ast.trb:451-505 (NativeBody{keyword,statements,result,span}, NativeStatement{name,type,operation,span}, NativeOperation{name,nameSpan,operands,span}, NativeOperandKind.Path/IntegerLiteral/FloatLiteral/BoolLiteral); FunctionDeclaration.nativeBody (ast.trb:203), body is None then.
Replace the two "not supported yet" errors: checker/declaration.trb:762 (inside checkFunctionShape, syntactic: keep only N1 there via requireStandardLibrary-style packageNameOf(checker, module).startsWith("std/") at body.keyword, message+note in record section 4 N1; N10 can go here too: any function.generics entry => error at its name span) and checker/expression.trb:184 (.NativeBlock(body): N1 + verify with checker.findLocal).
Body walk: statement.trb:591 checkFunctionBody returns voidType when function.body is None; add an early branch for function.nativeBody after checker.openScope(); declareGenerics; declareBindingsFor ... (same set-up as ordinary), then call checkNativeBody(checker, body, result); also check.trb:420 isBodyWithin only looks at function.body span: use nativeBody span too, else the body is never visited. signature.trb:580 hasBody = function.body.isSome() (leave).
Names: checker.findLocal(text) -> LocalKind.Bound(id) -> checker.binding(id) is LocalBinding{type: TypeId, var: Bool, bindsParameter, ...} (context.trb:90-110); self is checker.receiverBinding (name.trb:64-80). Field path: look up member types like name.trb lookupMember.
TypeId -> NumericKind/Bool/String: WellKnown.numerics: Map<Int,String> (symbol value -> "Int64"/"UInt8"/"Float32"), .boolean, .string, .character (checker/wellknown.trb); checker.types.form(id) is .Nominal(symbol, args).
N2 name parse: split operation.name on "."; operation names via describeOperation (print.trb) over everyOperation(); convert.F.T; suffix unchecked; kind suffixes i8..f64. N4 via isEmittedByCompiler, kind use via kindUseOf. N8 span: last 9 columns of nameSpan. N9: find where the manifest rows are read (grep native fn without a body); N9 error "has a native body and a row in the manifest" is an internal error, check that site.

Tests compiler/tests/native-bodies.test.trb (N1 via problems, others std fixture via problemsAt(files, ["std/..."]), see implementations.test.trb:149), a test over everyOperation() (each has a row; isEmittedByCompiler ones are not nameable), the record examples 2.3/2.4 check clean; update program-shape.test.trb:364-381 ("not supported yet" tests); record docs/design/NATIVE-BODIES.md: N4 list and section 3.2 text add textCompare as compiler-only, section 8 module name compiler/src/ir/intrinsics.trb.
PR Closes #478 against main, review argus, wait CI ~5 min, final write-back.

Token usage: continuation 2 ~85k prompt tokens.

[loop:torbscript] implement: checkpoint 3 (continuation 2 reached its context guard), next: implement continues with a fresh worker (claim by session:loop-torbscript-20261025-0258 stays). Pushed: branch `loop/478-native-checker` @ c4fea69d, two commits: `refactor(ir): add the typing table of intrinsics` (new `compiler/src/ir/intrinsics.trb`) and `refactor(ir): verify intrinsic calls against the typing table` (step 1 DONE, not compiled locally; CI is the compiler): `verify.trb` `verifyIntrinsic` now uses `intrinsicSignature`/`kindUseOf`; `operandCountOf`, `producesNoValue`, `needsNumericKind`, `allowsNumericKind`, `isShift/Conversion/TextParts/Comparison/BooleanOperation` removed; new table-driven `verifyOperands`, `verifyIntrinsicResult` + `verifyResultRow`; `print.trb` `describeOperation` is now public. Risk to watch on first CI: or-patterns with payloads (`.Source(_)` arms), `rows[if .. {..} else {..}]` indexing in verifyOperands, `textEqual` operand message is now "joins strings" (was "compares"), `Boolean` operand of `booleanNot` is unchecked. No PR opened yet; run `sh tools/gates.sh a` only in CI (open a draft-free PR early to get CI on this commit, if it compiles in CI fix first). Remaining: 2. Checker (new `compiler/src/semantics/checker/native.trb`). Findings: - Types: AST in `syntax/ast.trb:451-505` (`NativeBody{keyword,statements,result,span}`, `NativeStatement{name,type,operation,span}`, `NativeOperation{name,nameSpan,operands,span}`, `NativeOperandKind.Path/IntegerLiteral/FloatLiteral/BoolLiteral`); `FunctionDeclaration.nativeBody` (ast.trb:203), `body` is None then. - Replace the two "not supported yet" errors: `checker/declaration.trb:762` (inside `checkFunctionShape`, syntactic: keep only N1 there via `requireStandardLibrary`-style `packageNameOf(checker, module).startsWith("std/")` at `body.keyword`, message+note in record section 4 N1; N10 can go here too: any `function.generics` entry => error at its name span) and `checker/expression.trb:184` (`.NativeBlock(body)`: N1 + verify with `checker.findLocal`). - Body walk: `statement.trb:591 checkFunctionBody` returns `voidType` when `function.body` is None; add an early branch for `function.nativeBody` after `checker.openScope(); declareGenerics; declareBindingsFor ...` (same set-up as ordinary), then call `checkNativeBody(checker, body, result)`; also `check.trb:420 isBodyWithin` only looks at `function.body` span: use `nativeBody` span too, else the body is never visited. `signature.trb:580 hasBody` = `function.body.isSome()` (leave). - Names: `checker.findLocal(text)` -> `LocalKind.Bound(id)` -> `checker.binding(id)` is `LocalBinding{type: TypeId, var: Bool, bindsParameter, ...}` (context.trb:90-110); `self` is `checker.receiverBinding` (name.trb:64-80). Field path: look up member types like name.trb `lookupMember`. - TypeId -> NumericKind/Bool/String: `WellKnown.numerics: Map<Int,String>` (symbol value -> "Int64"/"UInt8"/"Float32"), `.boolean`, `.string`, `.character` (checker/wellknown.trb); `checker.types.form(id)` is `.Nominal(symbol, args)`. - N2 name parse: split `operation.name` on "."; operation names via `describeOperation` (print.trb) over `everyOperation()`; `convert.F.T`; suffix `unchecked`; kind suffixes `i8..f64`. N4 via `isEmittedByCompiler`, kind use via `kindUseOf`. N8 span: last 9 columns of `nameSpan`. N9: find where the manifest rows are read (grep `native fn without a body`); N9 error "has a native body and a row in the manifest" is an internal error, check that site. 3. Tests `compiler/tests/native-bodies.test.trb` (N1 via `problems`, others std fixture via `problemsAt(files, ["std/..."])`, see `implementations.test.trb:149`), a test over `everyOperation()` (each has a row; `isEmittedByCompiler` ones are not nameable), the record examples 2.3/2.4 check clean; update `program-shape.test.trb:364-381` ("not supported yet" tests); record `docs/design/NATIVE-BODIES.md`: N4 list and section 3.2 text add `textCompare` as compiler-only, section 8 module name `compiler/src/ir/intrinsics.trb`. 4. PR `Closes #478` against main, review argus, wait CI ~5 min, final write-back. Token usage: continuation 2 ~85k prompt tokens.

orion commented

2026-10-25 01:48:13 +00:00

Author

Collaborator

[loop:torbscript] implement: checkpoint 4 (continuation 3 reached its context guard), next: implement continues with a fresh worker (claim by session:loop-torbscript-20261025-0258 stays).

Pushed: branch loop/478-native-checker @ 14a3626d (4 commits, not compiled locally, no PR yet). New: compiler/src/semantics/checker/native.trb (N1 allowsNativeBody, N2 to N5, N6, N7 result mismatch, N8 via checkNativeOperation/intrinsicNamed/operandType; types compared by name String: Int64/Bool/String/Char). Wired: statement.trb checkNativeFunction (early branch in checkFunctionBody), expression.trb .NativeBlock => checkNativeBody (+ fitsInto now public), check.trb isBodyWithin also looks at nativeBody, declaration.trb checkFunctionShape: N10 only (error at generic name span), N1 left to checkNativeBody.

Risks to look at on first CI: cyclic use between native.trb and statement/expression (should be fine, other checker files are cyclic); match text { "i8" => ... } on String; Some(.Signed(_)) | Some(.Unsigned(_)) or-pattern in allowsUnchecked; names.map({ _.text }).toList().joined(...); .Source(kind) or-pattern with .Numeric(kind) in expectedName (may need two arms); parts[0]/rest.last() forms; Span(end - 9, end) constructor; (expected ?? "Float64").startsWith; checker.nominalOrInvalid/booleanType() are var fn (my typeOfName has var checker); unused imports (IntrinsicOperation/Intrinsic used; LocalKind, NativeStatement imports ok, drop unused if lint complains). N7b (body ends in a const) is already a parser error with its own text (parser/natives.trb), the record text differs: align the record, not the code.

Remaining:

N9: not in the checker; manifest is read in ir/witness.trb generatedKindOf (line ~455, nativeNamed). Plan: add hasNativeBody: Bool = false last field to Signature (checker/type.trb:460), set it where hasBody is computed (checker/signature.trb:580, function.nativeBody.isSome()), and at the top of generatedKindOf report via reportUnsupported: \Owner.name` has a native body and a row in the manifestwhennativeNamed` hits, else a clean 'native bodies are not lowered yet'.
Tests compiler/tests/native-bodies.test.trb: N1 (ordinary package, problems), N2..N8, N10 via std fixture (problemsAt(files, ["std/..."]), see implementations.test.trb:149), record examples 2.3/2.4 clean, a test over everyOperation() (each intrinsicSignature row exists; isEmittedByCompiler ones are refused by N4). Update program-shape.test.trb:364-381 (the two 'not supported yet' tests: now N1 text for ordinary package).
Record docs/design/NATIVE-BODIES.md: N4 list and 3.2 add textCompare, section 8 module name compiler/src/ir/intrinsics.trb, N7b wording (parser text), N9 as a lowering message.
Open PR against main (Closes #478), request review from argus, wait CI ~5 min, final write-back.

Token usage: continuation 3 ~95k prompt tokens.

[loop:torbscript] implement: checkpoint 4 (continuation 3 reached its context guard), next: implement continues with a fresh worker (claim by session:loop-torbscript-20261025-0258 stays). Pushed: branch `loop/478-native-checker` @ 14a3626d (4 commits, not compiled locally, no PR yet). New: `compiler/src/semantics/checker/native.trb` (N1 `allowsNativeBody`, N2 to N5, N6, N7 result mismatch, N8 via `checkNativeOperation`/`intrinsicNamed`/`operandType`; types compared by name String: Int64/Bool/String/Char). Wired: `statement.trb` `checkNativeFunction` (early branch in `checkFunctionBody`), `expression.trb` `.NativeBlock` => `checkNativeBody` (+ `fitsInto` now public), `check.trb isBodyWithin` also looks at `nativeBody`, `declaration.trb checkFunctionShape`: N10 only (error at generic name span), N1 left to `checkNativeBody`. Risks to look at on first CI: cyclic `use` between native.trb and statement/expression (should be fine, other checker files are cyclic); `match text { "i8" => ... }` on String; `Some(.Signed(_)) | Some(.Unsigned(_))` or-pattern in `allowsUnchecked`; `names.map({ _.text }).toList().joined(...)`; `.Source(kind)` or-pattern with `.Numeric(kind)` in `expectedName` (may need two arms); `parts[0]`/`rest.last()` forms; `Span(end - 9, end)` constructor; `(expected ?? "Float64").startsWith`; `checker.nominalOrInvalid`/`booleanType()` are `var fn` (my `typeOfName` has `var checker`); unused imports (IntrinsicOperation/Intrinsic used; `LocalKind`, `NativeStatement` imports ok, drop unused if lint complains). N7b (body ends in a `const`) is already a parser error with its own text (`parser/natives.trb`), the record text differs: align the record, not the code. Remaining: 1. N9: not in the checker; manifest is read in `ir/witness.trb generatedKindOf` (line ~455, `nativeNamed`). Plan: add `hasNativeBody: Bool = false` last field to `Signature` (`checker/type.trb:460`), set it where `hasBody` is computed (`checker/signature.trb:580`, `function.nativeBody.isSome()`), and at the top of `generatedKindOf` report via `reportUnsupported`: `\`Owner.name\` has a native body and a row in the manifest` when `nativeNamed` hits, else a clean 'native bodies are not lowered yet'. 2. Tests `compiler/tests/native-bodies.test.trb`: N1 (ordinary package, `problems`), N2..N8, N10 via std fixture (`problemsAt(files, ["std/..."])`, see `implementations.test.trb:149`), record examples 2.3/2.4 clean, a test over `everyOperation()` (each `intrinsicSignature` row exists; `isEmittedByCompiler` ones are refused by N4). Update `program-shape.test.trb:364-381` (the two 'not supported yet' tests: now N1 text for ordinary package). 3. Record `docs/design/NATIVE-BODIES.md`: N4 list and 3.2 add `textCompare`, section 8 module name `compiler/src/ir/intrinsics.trb`, N7b wording (parser text), N9 as a lowering message. 4. Open PR against main (`Closes #478`), request review from argus, wait CI ~5 min, final write-back. Token usage: continuation 3 ~95k prompt tokens.

orion commented

2026-10-25 01:48:35 +00:00

Author

Collaborator

[loop:torbscript] release implement: continuation limit (3 of 3) reached after checkpoint 4. Branch loop/478-native-checker @ 14a3626d holds the typing table, the verify.trb switch and the checker N1 to N8 plus wiring (not yet compiled, no PR). Remaining: N9 (manifest mismatch), tests in compiler/tests/native-bodies.test.trb, the design record edits, PR and review from argus, CI. next: implement (a new worker chain from checkpoint 4 at the next tick, with a fresh claim).

[loop:torbscript] release implement: continuation limit (3 of 3) reached after checkpoint 4. Branch loop/478-native-checker @ 14a3626d holds the typing table, the verify.trb switch and the checker N1 to N8 plus wiring (not yet compiled, no PR). Remaining: N9 (manifest mismatch), tests in compiler/tests/native-bodies.test.trb, the design record edits, PR and review from argus, CI. next: implement (a new worker chain from checkpoint 4 at the next tick, with a fresh claim).

orion commented

2026-10-25 02:12:46 +00:00

Author

Collaborator

[loop:torbscript] claim implement by session:loop-torbscript-20261025-0258 until 2026-10-25T08:30:00Z (new chain 2, from checkpoint 4)

orion commented

2026-10-25 02:15:07 +00:00

Author

Collaborator

[loop:torbscript] implement: checkpoint 5 (chain 2 reached its context guard), next: implement continues with a fresh worker (claim by session:loop-torbscript-20261025-0258 stays).

Pushed: branch loop/478-native-checker @ 203a9f84 (8 commits, not compiled locally, no PR yet). New since checkpoint 4:

N9 done: Signature.hasNativeBody: Bool = false (last field, checker/type.trb), set in both functionSignature returns that can see a native body (checker/signature.trb); ir/witness.trb generatedKindOf now refuses a native body first: with a manifest row "`X.y` is not supported by the native back end yet: it has a native body and a row in the manifest", else "its native body is not lowered yet" (reportUnsupported, so the text is unsupportedMessage's).
Line-length fixes (4 lines over 120 columns in declaration/native/statement/intrinsics).
Design record: textCompare removed from the grammar's operation list and added to the N4 list; N9 text is the lowering finding; N7 text is the parser's; section 8 names ir/intrinsics.trb.

Remaining:

Tests compiler/tests/native-bodies.test.trb (does not exist yet). Layout: header doc comment, use test, group from "std/test", use problems, problemsAt from "./harness", group "..." { test "..." { ... } }. Std fixture like implementations.test.trb:149: ["std/graphics/project.trb": "name \"std/graphics\"\n", "std/graphics/src/lib.trb": source] with problemsAt(files, ["std/graphics"]); use free public native fn (an extend Int64 in a std fixture would fail coherence). The harness prelude (tests/harness.trb) only has Int8/Int32/Int64/UInt8/Float32/Float64/Bool/Char/String. Cases: clean double (intrinsic add.i64 value, value) and a body with const statements; N1 (ordinary package: problems(...).contains(...), both declaration.trb:720 and the N1 text appear for a native fn); N2 (unknown name, add without kind, booleanNot.i64); N3 arity; N4 (printParts, textCompare); N5 (Int64 vs String operand, literal that does not fit add.i8 value, 300); N6 (unknown name, var parameter); N7 (Bool body for Int64 declaration); N8 (unchecked on less); N10 (native fn same<Value>(...)); a test over everyOperation() (each intrinsicSignature row exists, isEmittedByCompiler ones are refused by N4, use ... from "../src/ir/intrinsics").
program-shape.test.trb group "A native body is parsed and not supported yet" (lines ~364-381) still expects the removed text "A native body is not supported yet": rename the group and expect the N1 text `native` bodies are only allowed in a package of the standard library (.contains).
Open the PR (feat(checker): ..., Closes #478), request review from argus, wait for CI (the first compile of native.trb is the risk list of checkpoint 4), write-back.

[loop:torbscript] implement: checkpoint 5 (chain 2 reached its context guard), next: implement continues with a fresh worker (claim by session:loop-torbscript-20261025-0258 stays). Pushed: branch `loop/478-native-checker` @ 203a9f84 (8 commits, not compiled locally, no PR yet). New since checkpoint 4: - **N9 done**: `Signature.hasNativeBody: Bool = false` (last field, `checker/type.trb`), set in both `functionSignature` returns that can see a native body (`checker/signature.trb`); `ir/witness.trb generatedKindOf` now refuses a native body first: with a manifest row ``"`X.y` is not supported by the native back end yet: it has a native body and a row in the manifest"``, else "its native body is not lowered yet" (`reportUnsupported`, so the text is `unsupportedMessage`'s). - Line-length fixes (4 lines over 120 columns in declaration/native/statement/intrinsics). - Design record: textCompare removed from the grammar's operation list and added to the N4 list; N9 text is the lowering finding; N7 text is the parser's; section 8 names `ir/intrinsics.trb`. Remaining: 1. Tests `compiler/tests/native-bodies.test.trb` (does not exist yet). Layout: header doc comment, `use test, group from "std/test"`, `use problems, problemsAt from "./harness"`, `group "..." { test "..." { ... } }`. Std fixture like `implementations.test.trb:149`: `["std/graphics/project.trb": "name \"std/graphics\"\n", "std/graphics/src/lib.trb": source]` with `problemsAt(files, ["std/graphics"])`; use free `public native fn` (an `extend Int64` in a std fixture would fail coherence). The harness prelude (`tests/harness.trb`) only has Int8/Int32/Int64/UInt8/Float32/Float64/Bool/Char/String. Cases: clean `double` (`intrinsic add.i64 value, value`) and a body with `const` statements; N1 (ordinary package: `problems(...).contains(...)`, both `declaration.trb:720` and the N1 text appear for a `native fn`); N2 (unknown name, `add` without kind, `booleanNot.i64`); N3 arity; N4 (`printParts`, `textCompare`); N5 (Int64 vs String operand, literal that does not fit `add.i8 value, 300`); N6 (unknown name, `var` parameter); N7 (`Bool` body for `Int64` declaration); N8 (`unchecked` on `less`); N10 (`native fn same<Value>(...)`); a test over `everyOperation()` (each `intrinsicSignature` row exists, `isEmittedByCompiler` ones are refused by N4, `use ... from "../src/ir/intrinsics"`). 2. `program-shape.test.trb` group "A `native` body is parsed and not supported yet" (lines ~364-381) still expects the removed text "A `native` body is not supported yet": rename the group and expect the N1 text `` `native` bodies are only allowed in a package of the standard library `` (`.contains`). 3. Open the PR (`feat(checker): ...`, `Closes #478`), request review from argus, wait for CI (the first compile of native.trb is the risk list of checkpoint 4), write-back.

orion referenced this issue from a pull request that will close it,

2026-10-25 02:17:18 +00:00

feat(checker): check native bodies against the intrinsic typing table #480

orion commented

2026-10-25 02:17:22 +00:00

Author

Collaborator

[loop:torbscript] implement: PR #480 (head 95409405ac), next: waiting (CI + review)

[loop:torbscript] implement: PR https://git.torb.dev/torbscript/language/pulls/480 (head 95409405acf4118ed2c3e9a255f0b3a5af752eb7), next: waiting (CI + review)

orion commented

2026-10-25 02:34:40 +00:00

Author

Collaborator

[loop:torbscript] claim implement by session:loop-torbscript-20261025-0258 until 2026-10-25T08:30:00Z (CI fix round 1 on PR 480: commit messages and bootstrap (linux-x64) red on 95409405)

[loop:torbscript] claim implement by session:loop-torbscript-20261025-0258 until 2026-10-25T08:30:00Z (CI fix round 1 on PR 480: commit messages and bootstrap (linux-x64) red on 95409405)

orion commented

2026-10-25 02:37:28 +00:00

Author

Collaborator

[loop:torbscript] release implement: CI fix round 1 bootstrap parse errors fixed (nested juxtaposed constructor calls now parenthesized, native/type used as names renamed, Map.contains -> containsKey, assert !x rewritten, match scrutinee call parenthesized) e3f9f820, next: waiting (CI + review on PR 480). Open: ci / commit messages fails on b4fe0944 style(checker): ... (type style is not in feat fix perf refactor docs test build ci chore revert); fixing it needs a reword of that mid-history commit (force-push) or a squash, awaiting that decision. Type errors behind the parse errors are not visible yet, so a round 2 is likely.

[loop:torbscript] release implement: CI fix round 1 bootstrap parse errors fixed (nested juxtaposed constructor calls now parenthesized, `native`/`type` used as names renamed, Map.contains -> containsKey, `assert !x` rewritten, match scrutinee call parenthesized) e3f9f820, next: waiting (CI + review on PR 480). Open: `ci / commit messages` fails on b4fe0944 `style(checker): ...` (type `style` is not in feat fix perf refactor docs test build ci chore revert); fixing it needs a reword of that mid-history commit (force-push) or a squash, awaiting that decision. Type errors behind the parse errors are not visible yet, so a round 2 is likely.

orion commented

2026-10-25 02:38:00 +00:00

Author

Collaborator

[loop:torbscript] decided by the loop: commit b4fe0944 style(checker): ... reworded to chore(checker): keep the native checker lines within 120 columns (style is not an allowed type in tools/check-commits.sh; PR 480 had no review yet, trees identical). New head 14db9dc3, check-commits passes locally. next: waiting (CI on PR #480, bootstrap round 2 expected)

[loop:torbscript] decided by the loop: commit `b4fe0944 style(checker): ...` reworded to `chore(checker): keep the native checker lines within 120 columns` (`style` is not an allowed type in tools/check-commits.sh; PR 480 had no review yet, trees identical). New head 14db9dc3, check-commits passes locally. next: waiting (CI on PR https://git.torb.dev/torbscript/language/pulls/480, bootstrap round 2 expected)

orion commented

2026-10-25 03:48:17 +00:00

Author

Collaborator

[loop:torbscript] claim implement by session:loop-torbscript-20261025-0258 until 2026-10-25T09:30:00Z (CI fix round 2 on PR 480: bootstrap (linux-x64) red on 14db9dc3, run 1714 job 4)

[loop:torbscript] claim implement by session:loop-torbscript-20261025-0258 until 2026-10-25T09:30:00Z (CI fix round 2 on PR 480: bootstrap (linux-x64) red on 14db9dc3, run 1714 job 4)

orion commented

2026-10-25 03:49:25 +00:00

Author

Collaborator

[loop:torbscript] release implement: CI fix round 2 the stage-1 compiler no longer panics in verify.trb (intrinsic with no operands, returnTraceMark, indexed operands[0]); the seed already built stage 1 with the native checker, so no more parse/type errors were left in this run - 813a413e, next: waiting (CI + review on PR 480)

[loop:torbscript] release implement: CI fix round 2 the stage-1 compiler no longer panics in verify.trb (intrinsic with no operands, `returnTraceMark`, indexed `operands[0]`); the seed already built stage 1 with the native checker, so no more parse/type errors were left in this run - 813a413e, next: waiting (CI + review on PR 480)

orion commented

2026-10-25 05:42:36 +00:00

Author

Collaborator

[loop:torbscript] claim implement by session:loop-torbscript-20261025-0542 until 2026-10-25T11:45:00Z (CI fix round 3 on PR 480: tier A (linux-x64) and gates red on 813a413e, run 1718 jobs 5 and 2)

[loop:torbscript] claim implement by session:loop-torbscript-20261025-0542 until 2026-10-25T11:45:00Z (CI fix round 3 on PR 480: tier A (linux-x64) and gates red on 813a413e, run 1718 jobs 5 and 2)

orion commented

2026-10-25 05:44:34 +00:00

Author

Collaborator

[loop:torbscript] implement: checkpoint 6 (CI fix round 3 worker reached its context guard, no code changed, head stays 813a413e), next: implement continues with a fresh worker (claim by session:loop-torbscript-20261025-0542 stays). Worker usage about 90k prompt tokens.

Root causes from run 1718 (read via GET /actions/runs/1764/jobs, then /actions/jobs/<id>/logs; the job numbers in the status URLs are run-relative, the log API needs the global id, here 19898 = tier A; the gates job log returns HTTP 500 and was cancelled, it only repeats tier A):

format --check: compiler/src/semantics/checker/native.trb and compiler/tests/native-bodies.test.trb would change. Needs torb format on both (no torb binary in the gateway pod; take the formatter from a CI artifact/seed or reformat by hand to the canon).
Test N7: a body that ends in a const: the parser reports "A native body ends with a result" and hands the checker missingResult = NativeOperand(Path([])); operandType (native.trb ~line 292, names[0].text) panics with index 0 out of bounds. Fix: in the .Path(names) case return None when names.isEmpty() (the parser already reported it).
Tests with an annotated native const fail without a visible message (the log shows only the assertion): a body of const statements ends in a name (const wide: Int64 = intrinsic shiftedLeft.i64 sum, 1 expects no problem) and the annotation of a const has to be the type of its operation (expects exactly "sum is Int64, the annotation says Bool"). Tests without an annotation pass. Suspect checkNativeStatement (native.trb ~line 100): typeFromReference(checker, reference, scopeHere(checker).forType()) or nameOfType yields another name/extra diagnostic in the std test package (e.g. scope.records recording the type span, or Int64/Bool not resolving via wellKnown there). Next worker: make the test print inStd(source) in the assertion (or assert against a local variable first) in one CI round, or compare how other checker code resolves a type name to a String (checker.describe).

State: worktree code/wt/torbscript-language-478-native-checker clean at 813a413e, nothing unpushed.

[loop:torbscript] implement: checkpoint 6 (CI fix round 3 worker reached its context guard, no code changed, head stays 813a413e), next: implement continues with a fresh worker (claim by session:loop-torbscript-20261025-0542 stays). Worker usage about 90k prompt tokens. Root causes from run 1718 (read via `GET /actions/runs/1764/jobs`, then `/actions/jobs/<id>/logs`; the job numbers in the status URLs are run-relative, the log API needs the global id, here 19898 = tier A; the `gates` job log returns HTTP 500 and was cancelled, it only repeats tier A): 1. `format --check`: `compiler/src/semantics/checker/native.trb` and `compiler/tests/native-bodies.test.trb` would change. Needs `torb format` on both (no torb binary in the gateway pod; take the formatter from a CI artifact/seed or reformat by hand to the canon). 2. Test `N7: a body that ends in a const`: the parser reports "A native body ends with a result" and hands the checker `missingResult` = `NativeOperand(Path([]))`; `operandType` (native.trb ~line 292, `names[0].text`) panics with index 0 out of bounds. Fix: in the `.Path(names)` case return `None` when `names.isEmpty()` (the parser already reported it). 3. Tests with an annotated native `const` fail without a visible message (the log shows only the assertion): `a body of const statements ends in a name` (`const wide: Int64 = intrinsic shiftedLeft.i64 sum, 1` expects no problem) and `the annotation of a const has to be the type of its operation` (expects exactly "`sum` is `Int64`, the annotation says `Bool`"). Tests without an annotation pass. Suspect `checkNativeStatement` (native.trb ~line 100): `typeFromReference(checker, reference, scopeHere(checker).forType())` or `nameOfType` yields another name/extra diagnostic in the std test package (e.g. `scope.records` recording the type span, or `Int64`/`Bool` not resolving via `wellKnown` there). Next worker: make the test print `inStd(source)` in the assertion (or assert against a local variable first) in one CI round, or compare how other checker code resolves a type name to a String (`checker.describe`). State: worktree `code/wt/torbscript-language-478-native-checker` clean at 813a413e, nothing unpushed.

orion commented

2026-10-25 07:36:33 +00:00

Author

Collaborator

[loop:torbscript] release implement: PR 480 head moved to 900430cb after the round-3 checkpoint, CI is running on it; if it is red again the next fix worker starts from the checkpoint comment above, next: waiting (CI + review on PR 480)

[loop:torbscript] release implement: PR 480 head moved to 900430cb after the round-3 checkpoint, CI is running on it; if it is red again the next fix worker starts from the checkpoint comment above, next: waiting (CI + review on PR 480)

orion commented

2026-10-25 08:19:14 +00:00

Author

Collaborator

[loop:torbscript] claim implement by session:loop-torbscript-20261025-0542 until 2026-10-25T14:20:00Z (CI fix round 4 on PR 480: tier A + gates red on 900430cb, run 1730; start from the round-3 checkpoint)

[loop:torbscript] claim implement by session:loop-torbscript-20261025-0542 until 2026-10-25T14:20:00Z (CI fix round 4 on PR 480: tier A + gates red on 900430cb, run 1730; start from the round-3 checkpoint)

orion commented

2026-10-25 08:44:27 +00:00

Author

Collaborator

[loop:torbscript] release implement: PR 480 head moved to 6c53ec44 after fix round 4 (worker ended without a release comment), CI is running on it; if it is red again the next fix worker starts from the round-3 checkpoint and the failing job logs, next: waiting (CI + review on PR 480)

[loop:torbscript] release implement: PR 480 head moved to 6c53ec44 after fix round 4 (worker ended without a release comment), CI is running on it; if it is red again the next fix worker starts from the round-3 checkpoint and the failing job logs, next: waiting (CI + review on PR 480)