The coerce calls create IP side effects; comparison uses captured
lhs_lo/rhs_lo values. Use (void)semaCoerce() to make intent explicit.
Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>
These ty_op instructions were missing from the semaTypeOf dispatch,
needed for the float negation path added in zirNegate.
Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>
Add zirIntCast() and zirTruncate() as named entry points matching
src/Sema.zig's decomposition. Rename shared implementation to
analyzeTyOpCast(). Update dispatch and call sites.
Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>
Matches upstream Sema.zig which has zirBitNot → analyzeBitNot
two-function decomposition. Pure extraction, no behavioral change.
Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>
- Extend skip_dedup_end to full preamble items_len (not just
preamble_memoized_end) so CC sub-type entries created by
ensureCcMemoizedStateC are in the skip range
- Set preamble_cc_start AFTER CC union creation so main analysis
creates fresh CC union via skip_dedup
- Clear all 15 CC-phase builtins (not just 5) for main shard re-resolution
- Reset cc_memoized_resolved so ensureCcMemoizedStateC re-runs in main
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
- Port Sema.zig analyzeArithmetic coercion: coerce both operands to
result_ty when result is not comptime_int, creating typed intermediate
IP entries that match the Zig compiler's output.
- Fix zirTypeofLog2IntType and zirShl to use ipIntern (dedup) instead
of ipForceIntern, matching Zig's pt.intType which deduplicates via
the global pool.
- Add cc_memoized_resolved / ensureCcMemoizedStateC for the CC phase of
builtin resolution (builtins 0-14), analogous to PerThread's CC stage.
- Add preamble_skip_ptr_nav flag to defer AS/CC ptr_nav creation to
main analysis, matching Zig's sharded IP where preamble and main
shards use different nav IDs.
- Extend ct_struct_vals.fields from 4 to 8 entries and store const char*
name instead of string_bytes index, enabling zirFieldValComptime to
access TypeInfo fields by name.
- Advance num_passing from 87 to 100.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Two fixes for test 86 (inline_fn_with_plus_eq_call_inside_two_conditionals):
1. Skip duplicate func_type/func_decl in zirFunc when ensureNavValUpToDate
has already resolved the nav. Previously, ensureNavValUpToDate created
entries with ipForceIntern (no hash table) and zirFunc re-created them
with ipIntern (can't find existing), causing duplicates.
2. Defer non-generic body analysis from semaAnalyzeCall to match Zig's
ensureFuncBodyAnalysisQueued ordering. Callee body analysis is queued
and processed after the current function body completes, ensuring IP
entry ordering matches the Zig compiler's work queue semantics.
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
1. `dev == .bootstrap` does not include wasm backend, no use.
2. different optimize modes _of the compiler_ (_not_ target) _should_
not emit a different AIR. Thus if we want to `zig build test-zig0
-Doptimize=ReleaseFast`, we most often mean to compile the test
executable under this mode, but not `air_gen`, which will only emit
the AIR for comparison.
zirEnumLiteral was storing simpleStringHash(name) — a djb2 hash — as the
enum_literal IP key field. Upstream Zig stores a NullTerminatedString index
(getOrPutString). All three read sites treat the field as a string table
index and dereference it into ip->string_bytes, so the hash value caused
silent out-of-bounds reads whenever enum_literal coercion, callconv, or
signedness parsing were exercised.
Replace simpleStringHash with ipGetOrPutString, matching upstream exactly.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Use ipIntern (not ipForceIntern) for func_instance so that multiple
calls to the same generic function with the same comptime args share
one IP entry. Fixes the two-generic-calls test case where Zig produces
one func_instance but C was producing two.
Bumps num_passing from 85 to 86.
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Port IP_KEY_FUNC_INSTANCE from upstream InternPool.getFuncInstance.
When a generic non-inline function is called, create a monomorphized
func_type (runtime params only) and a func_instance entry referencing
the generic owner's func_decl. This matches the Zig compiler's IP
entry sequence for generic instantiations.
Bumps num_passing from 84 to 85.
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Refactor to match upstream Sema.zig structure where zirCall handles
callee resolution and analyzeCall handles the actual call analysis.
The new semaAnalyzeCall function takes a CalleeResolution struct that
bundles cross-module state. No functional changes.
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Generic functions (with comptime, anytype, or anytype_comptime params)
should not be compiled as standalone function bodies — they're resolved
via monomorphization when called with concrete types. Ported from
upstream: generic functions are excluded from analysis roots.
Detect comptime params by scanning the param body in the ZIR for
ZIR_INST_PARAM_COMPTIME, ZIR_INST_PARAM_ANYTYPE_COMPTIME, or
ZIR_INST_PARAM_ANYTYPE instruction tags.
Next blocker: test 84 (inline_fn_with_generic_call_inside_conditional)
has a monomorphization naming mismatch: C generates normalize__anon_503
while Zig generates normalize__anon_507. The IP index gap of 4 needs
investigation.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Fix non-inline function call to reuse the callee's existing func_decl
IP entry instead of creating a new one with func_inst as owner_nav.
Ported from upstream Sema.zig analyzeCall: func_val references the
resolved callee function, not a newly-created entry.
The callee is looked up by name in the file namespace. If the nav's
resolved_type already points to a func_decl (IP_KEY_FUNC), it's used
directly. Otherwise, the func_type from resolved_type is used to
construct and deduplicate the func_decl key.
Also fixes the coercion dedup fix from the previous commit: switched
semaCoerceIntRef from ipForceIntern to ipIntern now that skip_dedup
handles cross-shard separation.
Tests 80-83 now pass (call_inside_runtime_conditional, multi_func_call,
runtime_conditional_with_early_return, field_access_chain).
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Port compareIntsOnlyPossibleResult from upstream Sema.zig (line 32511):
when a comparison has one comptime operand, intern the other type's
min/max bounds as side effects. This matches the Zig compiler's
IP entry sequence for comparison operations.
Fix semaCoerceIntRef: switch from ipForceIntern to ipIntern for
integer type coercion. The cross-shard dedup issue is now handled
by the skip_dedup mechanism, so ipForceIntern is no longer needed.
Using ipIntern allows proper deduplication of identical coerced
values (e.g., two comparisons with `> 0` share the same int_u32(0)).
Tests 75-79 now pass (var_bitcast_and_if, shr_exact, nested_if,
conditional_bitwise_and, conditional_sub).
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Completes the file layout refactoring to match Zig's src/ structure.
Functions from src/Zcu/PerThread.zig no longer live in sema.c.
Moved to zcu_per_thread.c (~1100 lines):
- Group A (PerThread.zig orchestration): ensureFileAnalyzedC,
createFileRootStructC, scanNamespaceC, analyzeNavValC,
analyzeMemoizedStateC, ensureFullMemoizedStateC, ensureNavValUpToDate,
analyzeComptimeUnit, doImport, getBuiltinTypeC
- Group C (namespace/module helpers): createNamespace, findNavInNamespace,
findNamespaceForType, findNavForIPIndex, findFileByPathSuffix
- Group D (PerThread type/value constructors): internPtrConst, internNavPtr,
internPtrMutable, internUndef, internPtrComptimeAlloc, internPtrUav,
internPtrField, internTypedInt, internEnumTag, internFuncType,
internFuncDecl, internStrLit, coerceIntToTagType
- Also moved: BuiltinDeclEntry lookup table
sema.c now contains only src/Sema.zig functions (~11700 lines).
Supporting changes:
- sema.h: add DeclFlagsId enum, FuncZirInfo struct, CC_TAG_* defines,
and declarations for Sema functions called by PerThread
- zcu_per_thread.h: updated with all public PerThread function declarations
- build.zig: add zcu_per_thread.c to source list
Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>
Include parameter types in the func_type key for correct dedup. The
upstream Zig IP includes param types when interning function types;
C's simplified key previously used only (ret, param_count, cc) which
caused ipForceIntern to be needed (preventing dedup of identical
function signatures like fn(u32) u32 appearing in multiple exports).
Changes:
- Add param_types[8] inline array to FuncType struct
- Update ipHashKey and ipKeysEqual to include param types
- Update internFuncType to accept optional param_types array:
when provided → ipIntern (correct dedup); when NULL → ipForceIntern
- Collect param types during export function resolution and pass to
internFuncType for proper dedup
Tests 73-74 now pass (multiple_return_paths, nested_if_else_chain).
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Route ZIR_INST_SHL_SAT through zirShl (not zirArithmetic) and add
comptime RHS coercion for shl_sat: shift amount is coerced to
smallestUnsignedInt(lhs_bits) matching upstream Sema.zig line 13996.
For u32 shifts, this creates u6(1) instead of u32(1).
Attempted to switch func_type from ipForceIntern to ipIntern for
dedup of identical function signatures (test 73: multiple_return_paths).
Reverted because C's func_type key doesn't include param types, causing
false dedup for functions with same (ret, count, cc) but different
param types (regression in test 30: store_to_pointer).
Next blocker: test 73 (multiple_return_paths.zig) — needs func_type
param types in hash/equality for correct dedup.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Port shl_sat shift amount coercion from upstream Sema.zig zirShl
(line 13996). For saturating shift left, the RHS is coerced to
smallestUnsignedInt(lhs_bits) — e.g. u6 for u32 operands (needs to
represent 0-32, not just 0-31).
Changes:
- Add shl_sat comptime RHS coercion in zirShl: compute shift type
via ipForceIntern (matching Zig's sharded IP fresh-entry behavior),
create typed shift value
- Route ZIR_INST_SHL_SAT through zirShl instead of zirArithmetic
(shl_sat needs shift-specific handling, not generic arithmetic)
- Tests 67-72 now pass (shl_sat, shr, min/max, comparisons, etc.)
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Fix the IP shard simulation to work for all main analysis, not just
during ensureFullMemoizedStateC. This fixes tests 61-66 (inline fn
tests and non-inline tests that reference types from preamble builtins).
Key changes:
- Move skip_dedup activation to the end of the preamble (after
analyzeMemoizedStateC + start.zig comptime). Previously it was only
set during ensureFullMemoizedStateC, missing tests that don't
trigger full builtin resolution.
- Expand cc_keep range by 1 entry to include the CC ptr_nav that
AddressSpace resolution creates as a side effect (fixing the
1-entry excess for inline function tests).
- Remove skip_dedup clearing from ensureFullMemoizedStateC (it stays
active for the entire main analysis).
Next blocker: test 67 (shl_sat.zig) — the shift amount type (u6 for
u32 operand) is not created. C stores the shift amount as u32(1)
instead of u6(1). Need to port shift amount type coercion.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Refine the IP shard simulation for test 61 (inline_call_with_xor):
- Add comptime_int exception to skip_dedup: comptime_int entries are
shared across Zig's IP shards and should always dedup. Prevents 11
extra entries from AddressSpace values 2-12 re-creation.
- Fix dbg_inline_block func entry: reuse the callee's existing
func_decl IP index (found via nav zir_index match) instead of
creating a new func entry. Ported from upstream Sema.zig line 7788:
.func = func_val.?.toIntern().
- Fix cppcheck: const-qualify Nav pointer variables.
Gap reduced: 46 → 12 → 1 entry. The remaining 1-entry excess needs
investigation (likely a union_value or CC sub-entry mismatch).
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Eliminates all 39 mutable static globals across sema.c (37) and
intern_pool.c (2). State is now held in properly-typed structs passed
as parameters, mirroring the Zig reference implementation layout.
New files matching Zig src/ layout:
- compilation.h: CompilationConfig + Compilation (matches Compilation.zig)
- zcu.h/zcu.c: ZcuFile, ZcuNamespace, Zcu, zcuInit/zcuDeinit (matches Zcu.zig)
- zcu_per_thread.h: forward declarations for PerThread-style functions
Key changes:
- InternPool gains navs[] (dynamically allocated) + nav_count/nav_cap;
Nav functions now take InternPool* (was implicit via globals)
- Sema gains Zcu* zcu; semaInit now takes Zcu* instead of InternPool*
- All module-level state (files, namespaces, memoized state, config)
moved from static globals into Zcu struct
- zig0.c creates Compilation + Zcu before semaInit
- Test files updated to use zcuInit/zcuDeinit API
Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>
Add IP shard simulation to match upstream Zig's sharded InternPool
behavior. The Zig compiler's sharded IP keeps preamble memoized state
entries in a separate shard from main analysis entries, preventing
cross-shard deduplication. C's single-pool IP deduplicates everything,
causing a 46-entry gap when builtins 0-4 (resolved in preamble via
analyzeMemoizedStateC) are re-encountered during main analysis.
Changes:
- Add skip_dedup_start/end and cc_keep_start/end fields to InternPool
for shard-aware dedup in ipIntern
- Record preamble memoized IP range and CC sub-range during
analyzeMemoizedStateC
- In ensureFullMemoizedStateC, enable shard simulation: clear builtins
0-4 nav resolved_types and skip preamble dedup (except CC tag entries
which are in Zig's local shard)
- Resolve builtins 0-35 in a single pass (not 5-35) during main analysis
- Reorder Pass 2a to process export functions first, skip inline
functions (matching upstream declaration processing order)
- Fix inline function CC: set cc=CC_TAG_INLINE and trigger
getBuiltinTypeC(2) for CallingConvention resolution
- Fix redundant cppcheck condition in inline function handling
- Update CLAUDE.md tools section with correct dump flags
Status: test 61 (same_file_inline_call_with_bitcast_and_xor) still has
a 12-entry excess — CC tag dedup range needs further tuning. Tests 0-60
pass. No regressions.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
AddressSpace enum field values (comptime_int 0..23) go into C's single
IP hash table during memoized resolution. In the Zig compiler's sharded
IP, these entries are in a different shard and don't participate in dedup
during main analysis. CC tag values (0..12) ARE in Zig's local shard.
Use ipForceIntern for AddressSpace values >= 13 (the CC tag value count
for wasm32-wasi) to keep them out of the hash table. This prevents false
dedup where e.g. comptime_int(16) matches AddressSpace.flash1 instead of
creating a new entry.
Enables bitmask_shift_and.zig (test 54, num_passing=55).
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Fix three issues in zirFunc pre-creation to match Zig's funcCommon:
1. Resolve param types before func_type creation: iterate param_block
and call resolveZirTypeRef/resolveZirTypeInst for each param's type
body, creating IP entries (e.g. *u32) before the func_type entry.
This matches the Zig compiler's funcCommon which evaluates param
types before creating the func_type.
2. Use ipForceIntern for func_type: the C sema's func_type key only
includes param_count (not actual param types), causing incorrect
deduplication between functions with different param types but the
same count. The upstream Zig IP includes param types, so different
functions always get distinct func_types. ipForceIntern avoids the
false dedup.
3. Fix sentinel=IP_INDEX_NONE in all ptr_type creation sites: 6 sites
were using memset(0) which gives sentinel=0 instead of IP_INDEX_NONE
(UINT32_MAX), preventing deduplication with correctly-created pointer
types.
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Fix three issues to support functions with pointer parameters:
1. Fix param counting in zirFunc pre-creation: use getParamBody on the
param_block instruction instead of scanning the function body, which
doesn't start with param instructions. Matches ensureNavValUpToDate.
2. Fix return type resolution in zirFunc pre-creation: use
resolveZirTypeRef/resolveZirTypeInst (same as ensureNavValUpToDate)
to handle compound return types like *u32 that require creating IP
entries before the func_type.
3. Fix ptr_type sentinel initialization: all ptr_type IP key creation
sites must set sentinel = IP_INDEX_NONE explicitly, since memset(0)
gives sentinel=0 which differs from IP_INDEX_NONE (UINT32_MAX),
preventing deduplication with correctly-created pointer types.
Also remove redundant ptr_type + ptr_nav + name string entries from
zirFunc (upstream funcCommon doesn't create these), compensated by
increasing memoized_limit from 3 to 5 to resolve returnError (+4
entries) and StackTrace (+2 entries).
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Fix bit_shift_right/left by removing redundant shift type coercion from
zirShl (AstGen already handles it via typeof_log2_int_type +
as_shift_operand). Use ipForceIntern in zirTypeofLog2IntType and
semaCoerceIntRef to match Zig compiler's sharded IP behavior.
Improve return type resolution in ensureNavValUpToDate to handle
compound types via resolveZirTypeRef/resolveZirTypeInst.
Update CLAUDE.md: add "No workarounds" rule, remove stale status section.
num_passing: 21 -> 29
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Format all sema_tests/*.zig to canonical multi-line format using
`zig fmt`, fixing single-line function body rendering mismatches.
New passing tests: identity_function, add_two_args, add_comptime_int,
sub_two_args, xor_two_args, xor_comptime_int, bitcast_u32_to_f32,
bitcast_f32_to_u32, as_node, local_const_binding, multiple_operations,
neghf2_inline_equivalent, mul_two_args, compare_lt.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Fix single-line function body rendering: rewrite test to use multi-line
canonical format that round-trips through the C parser + Zig renderer.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Close the 64-entry IP gap by:
1. Enable s_in_main_analysis during start.zig comptime evaluation so
DECL_VAL resolves declarations lazily, creating enum_literal and
enum_tag entries matching the upstream evaluator.
2. Call analyzeMemoizedStateC with memoized_limit=3 (Signedness,
AddressSpace, CallingConvention) after module chain loading.
3. Fix CG builtin namespace collision: check has_zir in
ensureNavValUpToDate to distinguish std/builtin.zig from CG builtin.
4. Only resolve std/builtin.zig's "builtin" import (not assembly.zig).
5. Reset s_cg_builtin_ns_idx in resetModuleTracking (stale value from
previous test caused 1-entry count mismatch between first and
subsequent test runs).
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Two key fixes toward closing the IP gap for return_integer.zig:
1. Enable s_in_main_analysis during start.zig comptime evaluation so
DECL_VAL resolves declarations lazily. This creates enum_literal
and enum_tag entries from evaluating switch/if conditions in
start.zig's comptime block (matching the upstream evaluator).
2. Call analyzeMemoizedStateC with memoized_limit=3 (Signedness,
AddressSpace, CallingConvention) to create the builtin type entries
that the upstream creates through ensureMemoizedStateResolved.
3. Only resolve std/builtin.zig's "builtin" import (CG builtin), not
all imports (avoids loading builtin/assembly.zig early).
4. Fix CG builtin namespace collision in ensureNavValUpToDate.
CLI output matches reference exactly (217 entries). Test path creates
2 fewer entries due to module loading order difference between CLI and
test framework (42:u32 at IP 214 vs reference 216). num_passing stays
at 5 pending resolution of this 2-entry test-vs-CLI discrepancy.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Three fixes toward closing the 64-entry IP gap for return_integer.zig:
1. Call analyzeMemoizedStateC() after the full module chain is loaded.
This creates CallingConvention, Signedness, AddressSpace, and other
builtin type entries that the Zig compiler creates during its
analyzeMemoizedState(.main) call chain.
2. Fix ensureNavValUpToDate CG builtin namespace collision: when
std/builtin.zig and the CG builtin module share the same namespace
index, check has_zir to distinguish them. Without this, builtins
like CallingConvention (which have ZIR in std/builtin.zig) were
incorrectly routed to the CG builtin resolution path and returned
IP_INDEX_NONE.
3. Limit memoized state resolution to the first 6 direct std.builtin
declarations (Signedness through SourceLocation). Skip Type and its
21 children (indices 15-35) — the C sema's resolveTypeFullyC is too
aggressive for these complex nested types.
Gap reduced from 64 to 3 entries. Remaining gap is from module chain
entry ordering (C sema creates struct types and ptr_navs in batches,
reference interleaves them as pairs).
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
- Call ensureNavValUpToDate(start_nav) to properly resolve the start
module's nav. The DECL_VAL handler during comptime evaluation calls
doImport but doesn't update the nav's resolved_type, causing
start_file_idx to remain UINT32_MAX.
- Add analyzeMemoizedStateC forward declaration and improve CC resolution
path in zirFunc to trigger memoized state resolution for func_fancy
with CC body.
- Update CLAUDE.md with detailed IP alignment analysis using
-OReleaseSafe -fstrip to match test strip mode.
The 64-entry IP gap for return_integer.zig remains open. The entries
come from start.zig comptime evaluation which creates CallingConvention
enum type + values and other builtin type entries. Porting this requires
deeper comptime evaluation support.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Port Zig's std.hash.Wyhash to C (same secret constants, CONDOM=0 mum)
and replace ipHashCombine (boost golden ratio) with Wyhash in ipHashKey.
This aligns the C InternPool's hashing strategy with upstream Zig, which
uses Wyhash for all key hashing including NamespaceType keys.
Tests verify C and Zig Wyhash produce identical results for all standard
test vectors, streaming in various chunk sizes, autoHash equivalence for
u32/u64, and a large 8KB buffer.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Two fixes for IP entry alignment with the Zig compiler:
1. Skip call frame setup (ptr_uav, undef, ptr_comptime_alloc) when
both parameter and return types are pre-interned. The Zig compiler
doesn't create these entries for trivial comptime calls like
debug.assert(true) where everything deduplicates to existing entries.
2. Create memoized_call entries even for void-returning functions.
The Zig compiler always creates memoized_call for comptime function
calls, including void results.
3. Don't create the dbg_inline_block func IP entry in comptime context
where no AIR is emitted. This removes a spurious func entry with
ty=0 that appeared in the IP sequence.
These fixes align entries $124-$135 between C sema and Zig compiler
for return_integer.zig. Remaining gap: 66 entries starting at $136.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Document the current state: first 10 entries aligned, divergence at
memoized_call. List next steps for closing the remaining 62-entry gap.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Remove the s_in_main_analysis guard from the import decl_val handler's
ptr_type + ptr_nav creation. The Zig compiler creates these entries
whenever imports are accessed in comptime context (via
analyzeNavRefInner), regardless of analysis phase. Previously the C
sema only created them during main analysis, causing the first ~10
module-level IP entries to be in the wrong order.
This aligns the C sema's entries $124-$133 with the Zig compiler.
The remaining gap (62 entries, starting at Zig's memoized_call at
$134) requires porting memoized comptime call support.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
- Enable module_root for sema unit tests in stages_test.zig, matching
the Zig compiler which always creates std even with std_mod=null.
The first 5 tests still pass since they only use pre-interned refs.
- Add analyzeMemoizedStateC infrastructure for resolving std.builtin
BuiltinDecl entries (ExportOptions, CallingConvention, Type, etc.).
Not yet triggered — the trigger path requires matching the Zig
compiler's exact module loading order.
- Add --module-root flag to zig0 CLI for debugging IP entry comparison
between the Zig compiler and C sema.
- Fix cppcheck warning: remove redundant !fi.is_inline check (already
guarded by early return above).
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Restructure from warnings-first ("NEVER do X") to methodology-first
("port the function, not its output"). The core principle is now front
and center with a concrete 4-step method (find, read, translate, test).
Removes the 118-line "Closing the InternPool gap" section (status moved
to MEMORY.md), the anti-pattern section, and scattered duplications.
Consolidates mechanical copy rules into the methodology. 243→160 lines.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Document that pre-resolving types/declarations by name to fill the IP
gap is forbidden. This applies to builtin types, std types, module
declarations, or any other source. Every IP entry must be a side
effect of honestly porting the upstream function that produces it.
Also format return_integer.zig to canonical form.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
The parameter type resolution had a gap: 2-instruction type bodies
were only handled for ptr_type, missing decl_val+break_inline (used
when a parameter type references a module-level const like
`const U32 = @Type(...)`). Add a general fallback using
analyzeBodyInner for non-ptr_type 2-instruction bodies.
This enables reify_int.zig which uses @Type to create u32.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
