init: convert ArgParse/MachoCache/PdbCache to compound-literal macros

These three were the only non-I/O inits still doing function-shaped
construction. Their bodies were trivial -- field assigns plus a
nested VecInit -- so they fit the same compound-literal pattern the
rest of the codebase uses (StrInit / VecInit / MapInit / HttpRequestInit).

`ArgParseInit` keeps the `(name, about[, alloc])` shape and now
expands to `((ArgParse){.alloc = ALLOCATOR_OF(...), .name = ...,
.about = ..., .specs = VecInit_1(...)})`. The macro parameters are
renamed `prog_name` / `prog_about` so they don't shadow the
`.name` / `.about` field designators when the preprocessor substitutes
the args inside the compound literal -- a portability requirement,
not a stylistic one. The NULL-`name` runtime guard is dropped:
`ALLOCATOR_OF` already enforces a typed allocator at compile time
and callers pass string literals for `name`.

`MachoCacheInit` / `PdbCacheInit` shift from
`bool fn(T *out, Allocator *)` to return-by-value compound literal.
The two Backtrace callsites are rewritten to gate on `alloc` first
(`bool ok = alloc != NULL; T c = ok ? Init(alloc) : (T){0};`) and
the test callers drop the `&out` argument. The bool return was
already effectively redundant: the only failure path was a NULL
out-pointer that never occurred in any caller.

Linux 104/104 + Mac 99/99 green.

Author: brightprogrammer

Include/Misra/Std/ArgParse.h

@@ -137,23 +137,28 @@ extern "C" {
     } ArgParse;
 
     ///
-    /// Create a parser. Registers `-h` / `--help` automatically. The
-    /// `name` and `about` pointers are borrowed -- they must outlive
-    /// the parser (string literals are the typical case).
+    /// Create a parser. The `name` and `about` pointers are borrowed --
+    /// they must outlive the parser (string literals are the typical
+    /// case). The `-h` / `--help` flag is registered lazily on the
+    /// first `ArgParseRun` / `ArgParseHelp` call.
     ///
     /// Two call shapes, like `StrInit` / `VecInitT`:
     ///   `ArgParseInit(name, about)`        -- uses the surrounding
     ///                                          `Scope`'s allocator.
     ///   `ArgParseInit(name, about, alloc)` -- explicit allocator.
     ///
-    /// SUCCESS: Returns an initialized parser.
-    /// FAILURE: Aborts via `LOG_FATAL` on allocator OOM.
-    ///
-    ArgParse arg_parse_init(Zstr name, Zstr about, Allocator *alloc);
-
-#define ArgParseInit(...)                      MISRA_OVERLOAD(ArgParseInit, __VA_ARGS__)
-#define ArgParseInit_2(name, about)            arg_parse_init((name), (about), MisraScope)
-#define ArgParseInit_3(name, about, alloc_ptr) arg_parse_init((name), (about), ALLOCATOR_OF(alloc_ptr))
+    /// SUCCESS: Yields an initialized parser. The `specs` Vec is empty;
+    ///          add specs with `ArgParseAddPositional` / etc.
+    /// FAILURE: Cannot fail at construction; first allocator OOM
+    ///          surfaces from later spec-Vec growth.
+    ///
+#define ArgParseInit(...)                     MISRA_OVERLOAD(ArgParseInit, __VA_ARGS__)
+#define ArgParseInit_2(prog_name, prog_about) ArgParseInit_3((prog_name), (prog_about), MisraScope)
+#define ArgParseInit_3(prog_name, prog_about, alloc_ptr)                                                               \
+    ((ArgParse) {.alloc = ALLOCATOR_OF(alloc_ptr),                                                                     \
+                 .name  = (prog_name),                                                                                 \
+                 .about = (prog_about),                                                                                \
+                 .specs = VecInit_1(alloc_ptr)})
 
     ///
     /// Release the spec Vec. Safe on a fully-initialised parser; not

Include/Misra/Sys/MachoCache.h

@@ -48,19 +48,21 @@ typedef struct MachoCache {
 } MachoCache;
 
 ///
-/// Initialise an empty Mach-O symbol cache.
+/// Initialise an empty Mach-O symbol cache. The allocator argument
+/// is optional inside a `Scope` block (defaults to `MisraScope`) and
+/// backs both the entries Vec and every Mach-O / DWARF table the
+/// cache grows lazily.
 ///
-/// out[out]   : Cache to initialise.
-/// alloc[in]  : Allocator used for the entries vector and for
-///              every Mach-O / DWARF table the cache grows lazily.
+/// SUCCESS : Yields a `MachoCache` whose `entries` Vec is empty and
+///           ready for use.
+/// FAILURE : Cannot fail at construction; first allocator OOM
+///           surfaces from later `entries` growth.
 ///
-/// SUCCESS : Returns true. `out` is a usable empty cache.
-/// FAILURE : Returns false on allocator OOM. `out` is left zeroed.
+/// TAGS: Sys, MachO, Cache, Init, Lifecycle
 ///
-bool macho_cache_init(MachoCache *out, Allocator *alloc);
-#define MachoCacheInit(...)          MISRA_OVERLOAD(MachoCacheInit, __VA_ARGS__)
-#define MachoCacheInit_1(out)        macho_cache_init((out), MisraScope)
-#define MachoCacheInit_2(out, alloc) macho_cache_init((out), ALLOCATOR_OF(alloc))
+#define MachoCacheInit(...)         MISRA_OVERLOAD(MachoCacheInit, __VA_ARGS__)
+#define MachoCacheInit_0()          MachoCacheInit_1(MisraScope)
+#define MachoCacheInit_1(alloc_ptr) ((MachoCache) {.allocator = ALLOCATOR_OF(alloc_ptr), .entries = VecInit_1(alloc_ptr)})
 
 ///
 /// Release every cached Mach-O / DWARF table and the entries vector.

Include/Misra/Sys/PdbCache.h

@@ -47,15 +47,19 @@ typedef struct PdbCache {
 } PdbCache;
 
 ///
-/// Initialize an empty cache.
+/// Initialize an empty cache. The allocator argument is optional
+/// inside a `Scope` block (defaults to `MisraScope`).
 ///
-/// SUCCESS : Returns true; `out` is zeroed and ready for `Resolve`.
-/// FAILURE : Returns false on NULL arg.
+/// SUCCESS : Yields a `PdbCache` whose `entries` Vec is empty and
+///           ready for `Resolve`.
+/// FAILURE : Cannot fail at construction; first allocator OOM
+///           surfaces from later `entries` growth.
 ///
-bool pdb_cache_init(PdbCache *out, Allocator *alloc);
-#define PdbCacheInit(...)          MISRA_OVERLOAD(PdbCacheInit, __VA_ARGS__)
-#define PdbCacheInit_1(out)        pdb_cache_init((out), MisraScope)
-#define PdbCacheInit_2(out, alloc) pdb_cache_init((out), ALLOCATOR_OF(alloc))
+/// TAGS: Sys, PDB, Cache, Init, Lifecycle
+///
+#define PdbCacheInit(...)        MISRA_OVERLOAD(PdbCacheInit, __VA_ARGS__)
+#define PdbCacheInit_0()         PdbCacheInit_1(MisraScope)
+#define PdbCacheInit_1(alloc_ptr) ((PdbCache) {.allocator = ALLOCATOR_OF(alloc_ptr), .entries = VecInit_1(alloc_ptr)})
 
 ///
 /// Tear down the cache, releasing every cached `Pe` and `Pdb`.

Source/Misra/Std/ArgParse.c

@@ -461,19 +461,6 @@ void arg_register(
 /* Lifecycle + run                                                     */
 /* ------------------------------------------------------------------ */
 
-ArgParse arg_parse_init(Zstr name, Zstr about, Allocator *alloc) {
-    if (!name)
-        LOG_FATAL("ArgParseInit: name is required");
-    if (!alloc)
-        LOG_FATAL("ArgParseInit: allocator is required");
-    ArgParse p = {0};
-    p.alloc    = alloc;
-    p.name     = name;
-    p.about    = about;
-    p.specs    = VecInitT(p.specs, alloc);
-    return p;
-}
-
 void ArgParseDeinit(ArgParse *self) {
     if (!self)
         return;

Source/Misra/Sys/Backtrace.c

@@ -177,8 +177,8 @@ static void format_walk_win(Str *out, const StackFrame *frames, size count, Allo
     line.SizeOfStruct = sizeof(line);
 
 #    if FEATURE_PARSER_PDB
-    PdbCache pdb_cache;
-    bool     pdb_cache_ok = alloc && PdbCacheInit(&pdb_cache, alloc);
+    bool     pdb_cache_ok = (alloc != NULL);
+    PdbCache pdb_cache    = pdb_cache_ok ? PdbCacheInit(alloc) : (PdbCache) {0};
 #    else
     (void)alloc;
 #    endif
@@ -389,8 +389,8 @@ static bool dyld_image_for_ip(void *ip, Zstr *out_path, u64 *out_slide) {
 
 static void format_walk_mac(Str *out, const StackFrame *frames, size count, Allocator *alloc) {
 #    if FEATURE_PARSER_MACHO
-    MachoCache cache;
-    bool       cache_ok = alloc && MachoCacheInit(&cache, alloc);
+    bool       cache_ok = (alloc != NULL);
+    MachoCache cache    = cache_ok ? MachoCacheInit(alloc) : (MachoCache) {0};
 #    else
     (void)alloc;
 #    endif

Source/Misra/Sys/MachoCache.c

@@ -149,15 +149,6 @@ static bool entry_build_dwarf(MachoCacheEntry *e, Allocator *alloc) {
 // Public API
 // ---------------------------------------------------------------------------
 
-bool macho_cache_init(MachoCache *out, Allocator *alloc) {
-    if (!out || !alloc)
-        return false;
-    MemSet(out, 0, sizeof(*out));
-    out->allocator = alloc;
-    out->entries   = VecInitT(out->entries, alloc);
-    return true;
-}
-
 void MachoCacheDeinit(MachoCache *self) {
     if (!self)
         return;

Source/Misra/Sys/PdbCache.c

@@ -152,15 +152,6 @@ static PdbCacheEntry *cache_find_or_open(PdbCache *self, Zstr module_path) {
 // Public API
 // ---------------------------------------------------------------------------
 
-bool pdb_cache_init(PdbCache *out, Allocator *alloc) {
-    if (!out || !alloc)
-        return false;
-    MemSet(out, 0, sizeof(*out));
-    out->allocator = alloc;
-    out->entries   = VecInitT(out->entries, alloc);
-    return true;
-}
-
 void PdbCacheDeinit(PdbCache *self) {
     if (!self)
         return;

Tests/Std/MachoCache.c

@@ -185,8 +185,7 @@ bool test_macho_cache_resolves_via_main_symtab(void) {
         return false;
     }
 
-    MachoCache cache;
-    MachoCacheInit(&cache, base);
+    MachoCache cache = MachoCacheInit(base);
 
     // slide chosen so runtime_ip - slide = 0x100000110 (10 bytes past
     // function start)
@@ -225,8 +224,7 @@ bool test_macho_cache_falls_through_to_dsym(void) {
         return false;
     }
 
-    MachoCache cache;
-    MachoCacheInit(&cache, base);
+    MachoCache cache = MachoCacheInit(base);
 
     const u64 slide      = 0;
     const u64 runtime_ip = 0x100000208ull; // 8 bytes into dsym_only_fn
@@ -264,8 +262,7 @@ bool test_macho_cache_rejects_uuid_mismatch(void) {
     write_file(bin_path, bin_buf, bin_size);
     write_file(dsym_path, dsym_buf, dsym_size);
 
-    MachoCache cache;
-    MachoCacheInit(&cache, base);
+    MachoCache cache = MachoCacheInit(base);
 
     Zstr name = NULL;
     bool ok   = !MachoCacheResolve(&cache, bin_path, 0, 0x100000208ull, &name, NULL);

Tests/Std/PdbCache.c

@@ -285,11 +285,7 @@ bool test_pdb_cache_resolves_via_codeview(void) {
         return false;
     }
 
-    PdbCache cache;
-    if (!PdbCacheInit(&cache, base)) {
-        DefaultAllocatorDeinit(&alloc);
-        return false;
-    }
+    PdbCache cache = PdbCacheInit(base);
 
     // module_base = 0x140000000 -> RVA = (ip - base). For func at
     // RVA 0x1100, ip = module_base + 0x1100.
@@ -323,8 +319,7 @@ bool test_pdb_cache_rejects_unknown_module(void) {
     char missing[1024];
     tmp_path_join(missing, sizeof(missing), "misra_pdbcache_missing_xyz.exe");
 
-    PdbCache cache;
-    PdbCacheInit(&cache, base);
+    PdbCache cache = PdbCacheInit(base);
     Zstr name = NULL;
     bool ok   = !PdbCacheResolve(&cache, (Zstr)missing, 0, 0x1000, &name, NULL);
     PdbCacheDeinit(&cache);