# 0101 — postfix `!` chained with `.field` miscompiles

**RESOLVED.** A postfix optional force-unwrap chained directly with a member
access — `opt!.field` — read garbage instead of the field, while the
bind-first form (`v := opt!; v.field`) was correct. Sibling chains shared the
bug: `opt!.method()` failed to resolve the method at all (`error: unresolved
'<method>'`), and `opt!.a.b` / `opt![i]` were affected the same way.

**Symptom** — observed vs expected:

```sx
#import "modules/std.sx";
S :: struct { id: string; n: i64; }
mk :: () -> ?S { return S.{ id = "hello", n = 42 }; }
main :: () {
    print("chained: {}\n", mk()!.id);   // observed: garbage (e.g. 8362783136)
    v := mk()!; print("bind: {}\n", v.id);  // observed: "hello"  (correct)
}
```

Expected: `mk()!.id` prints `hello` (same as the bind-first form).

**Root cause** (`src/ir/expr_typer.zig`, `ExprTyper.inferType`): the AST-level
type-inference switch had **no `.force_unwrap` arm**, so `mk()!` typed as
`.unresolved` (the `else` fallback). `lowerForceUnwrap` lowers the unwrap to a
correctly-typed value, so the *bind* form works — `v := mk()!` stores that
typed Ref into a slot and `v.field` reads it back. But the *chained* form never
materializes a slot: `lowerFieldAccess` re-derives the receiver type via
`inferExprType(fa.object)` (= `inferExprType(mk()!)`), got `.unresolved`, and
the struct-field lookup on `.unresolved` failed — `mk()!.id` was typed
`.unresolved`/`i64` and its value emitted as `undef` (the print monomorphized
`pack_i64` with `i64 undef`, surfacing as a stale stack address). The method
chain failed for the same reason: receiver typing returned `.unresolved`, so
method resolution found nothing.

**Fix** (`src/ir/expr_typer.zig:92`): add a `.force_unwrap` arm to
`ExprTyper.inferType` that resolves the operand's optional child type (mirrors
`lowerForceUnwrap`'s `resolveOptionalInner`):

```zig
.force_unwrap => |fu| blk: {
    const opt_ty = self.l.inferExprType(fu.operand);
    if (!opt_ty.isBuiltin()) {
        const info = self.l.module.types.get(opt_ty);
        if (info == .optional) break :blk info.optional.child;
    }
    break :blk .unresolved;
},
```

This is the single root cause for every chained form — field, nested field,
method call, and index all route their receiver type through `inferExprType`.
One arm fixes all of them.

**Reproduction** (standalone, std-only):

```sx
#import "modules/std.sx";
Inner :: struct { tag: string; k: i64; }
S :: struct {
    id: string; n: i64; inner: Inner;
    greet :: (self: *S) -> string { return self.id; }
}
mk :: () -> ?S { return S.{ id = "hello", n = 42, inner = Inner.{ tag = "deep", k = 7 } }; }
main :: () {
    print("{}\n", mk()!.id);          // pre-fix: garbage; post-fix: hello
    print("{}\n", mk()!.n);           // pre-fix: garbage; post-fix: 42
    print("{}\n", mk()!.greet());     // pre-fix: error unresolved 'greet'; post-fix: hello
    print("{}\n", mk()!.inner.tag);   // post-fix: deep
}
```

**Regression**: `examples/0905-optionals-unwrap-field-chain.sx` exercises
`opt!.field` (string + int field, chained vs bind-first), `opt!.method()`
(pointer + value receiver), nested `opt!.a.b`, and `opt![i]`. Garbage / compile
error on pre-fix code; all correct after.