plum

# Design: field/attribute assignment target

## Problem

`Stmt::Assign` (`x = expr`) only ever binds a plain local variable — the grammar's

`assign` rule accepts `commaSep1(var_identifier)` on the left of `=`, and codegen

always treats a target as a `local.set`. There's no way to write `self.head = value`,

so any method that needs to mutate a struct field (e.g. `libs/std/list.plum`'s

`add`/`removeAt`/`set`) can't compile. This is the first of the two remaining

"Known gaps" entries in the README.

## Scope

Support `<object-expr>.<field> = <value>` as an assignment target, where

`<object-expr>` is any expression that evaluates to a class instance (including a

chain, so `self.head.value = x` falls out for free once `self.head` resolves to a

class instance). Multiple comma-separated targets (`a, b.c = 1, 2`) continue to work,

mixing plain-variable and field targets freely, since that's how the grammar already

treats the LHS list.

Out of scope (tracked separately): variadic parameters, `List`'s other `todo`

methods, index/array assignment (`self.items[i] = v`), enum-payload mutation.

## Grammar

Add a dedicated `field_target` rule instead of reusing `attribute` directly, so the

assignment LHS can't accidentally parse a method call as a target:

```js

field_target: ($) =>

  seq(

    field("object", $.primary_expression),

    ".",

    field("member", $.fn_identifier),

  ),

assign: ($) =>

  seq(

    commaSep1(choice($.var_identifier, $.field_target)),

    "=",

    commaSep1($.expression),

  ),

```

`primary_expression` already includes `$.attribute`, which recurses on its own

`object` field — so `self.head.value` parses as

`field_target(object: attribute(self, head), member: value)` with no extra grammar

work, the same way chained reads already work.

## AST

```rust

pub enum AssignTarget {

    Var(String),

    Field(Box<Expr>, String), // object, field name

}

pub struct Assign {

    pub targets: Vec<AssignTarget>,

    pub values: Vec<Expr>,

}

```

`parser.rs`'s `parse_assign` builds `AssignTarget::Var` from a `var_identifier` node

and `AssignTarget::Field` from a `field_target` node (parsing its `object` child as an

expression via the existing `parse_expression`/`unwrap_expr_node` path, and taking

`member`'s text directly).

## Checker (`plum-checker`)

In `check_stmt`'s `Stmt::Assign` arm: for `AssignTarget::Var(name)`, keep today's

behavior (infer the value's type, bind `name` in the environment). For

`AssignTarget::Field(object, field_name)`: infer the object's type, require it to be

a `PlumType::TNamed(class)`, look up `field_name` in `ctx.classes[class]`, infer the

value's type, and `unify` the two — a mismatch or unknown field is a `CheckError` with

a message following the existing `"fn '{}': assign '{}': {}"` shape (target rendered

as `"{object}.{field}"` for the message, not used for env lookup).

## Codegen (`plum-wasm-codegen`)

`Stmt::Assign` is touched in six places today: the closure free-variable walker, the

local-name collector (for allocating wasm locals), the match/scratch-local counters,

and the final emission pass. Each needs an `AssignTarget::Var`/`AssignTarget::Field`

match arm:

- **Closure walker / local collector / scratch counters**: `Var(name)` keeps current

  behavior (registers a local). `Field(object, _)` walks/visits `object` as an

  expression (so any variables *it* references are tracked) but registers no new

  local — a field target never introduces a binding.

- **Emission**: `Var(name)` keeps today's `local.set`. `Field(object, field_name)`

  mirrors the existing field-*read* codegen at `Expr::Attribute`/`AttrKind::Field`

  (`plum-wasm-codegen/src/lib.rs:2772-2796`) and the field-*init* codegen in

  class-literal construction (`:2760-2768`): resolve `object`'s `PlumType::TNamed`,

  look up the field's index/type in `ctx.classes`, `compile_expr(object)` to push the

  instance pointer, `compile_expr(value)` to push the new value, then `emit_store`

  at `field_idx * 8` with the field's `ValType`-appropriate store op — exactly the

  same offset arithmetic already used for reads, no new addressing logic.

## Testing

New `plum-wasm-codegen` tests (in `tests/codegen_tests.rs`), each a small class with a

mutable field:

- assigning a field then reading it back returns the new value

- assigning a field of one type to a mismatched-type expression is a clear checker

  error (not a codegen panic)

- a chained target (`self.head.value = x` where `head: Node`) compiles and the

  written value round-trips through a subsequent read

- a mixed multi-assign (`a, self.field = 1, 2`) compiles and both targets take effect

## README

Once this lands, update the "Known gaps" bullet about `self.head = ...` to remove the

"mutating a field or attribute isn't a supported assignment target" clause, leaving

only the cross-file import resolution gap (that one is untouched by this work) until

the follow-up variadic-params work lands.