fix(encoding/json): honor json tags on anonymous struct Unmarshal targets

[mck]

Part of #142 (item 5).

Stacked on #145 (fix/json-unmarshal-typed-containers): this branch is #145's branch plus its own commits, because this fix extends the __goType-spelling parser (goTypeDescriptor) and the type-driven decoder (decodeValueForType) that #145 introduces, rather than duplicating them in an independent branch. GitHub doesn't let a cross-fork PR target another fork branch directly, so this is opened against master and shows #145's diff too until #145 merges (after which it auto-shrinks to just the new commits). Please review/merge #145 first, then review only this branch's own two commits (visible individually under the Commits tab): 37040341 (the item-5 fix) and 38181bf7 (three follow-up fixes from review, described below).

Unmarshal only knew how to populate a target carrying struct-field runtime metadata (a registered, named struct type). An anonymous (inline, unnamed) struct target carries no such metadata, so it fell through to the untyped interface{} decode, which replaces the plain-object struct value with this override's Map representation entirely, dropping every field.

var loose struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}
json.Unmarshal([]byte(`{"name":"Ada","age":30}`), &loose)
// loose.Name and loose.Age read back "" and 0: every field empty

An anonymous struct target still carries its Go type spelling (including field names, types, and json tags) via __goType, e.g. *struct{Name string "json:\"name\""; Age int "json:\"age\""}. The fix parses it into the same fieldMetadata shape a registered struct's fields use (parseAnonymousStructFields, splitting on the tag's Go-quoted string literal so a ; inside a tag can't split a field early), then decodes each field through the existing per-field path (assignDecodedFieldValue/assignAnonymousStructFields), so tags, nested slices/maps, and RawMessage fields are all included for free. Wired into both assignDecodedValue (a top-level anonymous-struct var) and decodeValueForType (an anonymous struct used as a map/slice element type, e.g. map[string]struct{...}).

Review also found three related gaps, fixed in the follow-up commit 38181bf7. A top-level pointer-to-struct var (var p *pkg.T) fell through to the untyped decode instead of the same unmarked-pointee Pointer handling used elsewhere; assignDecodedValue's type-driven dispatch now also matches Pointer TypeInfo. assignAnonymousStructFields ignored opts.disallowUnknownFields, unlike named-struct decode; it now enforces it the same way. And a by-value named-struct field inside an anonymous struct had no pre-existing instance for the generic decode path to populate into (anonymous structs start with unset fields, unlike registered structs' pre-initialized zero-value instances); it is now constructed directly when the field's type resolves to a real, ctor-bearing struct type.

Tests extend gs/encoding/json/index.test.ts with five cases: a top-level anonymous struct target, one used as a map value type, a top-level pointer-to-struct var, disallowUnknownFields on an anonymous target, and a by-value named-struct field inside an anonymous struct. Each fails on the commit before its fix and passes with it.

Verify:

bun run vitest run gs/encoding/json/index.test.ts

29 passed. Full suite: bun run typecheck clean, bun run test:js 1282 passed / 4 skipped / 0 failed, go test ./... all packages green, bun run lint:js clean.

Found while transpiling and running a real ~100k-LOC Go interpreter/parser package through goscript.

[Copilot]

Pull request overview

This PR extends the gs/encoding/json Unmarshal implementation to honor json:"..." tags on anonymous (inline) struct targets by parsing the target’s __goType spelling into field metadata, and then decoding through the existing per-field/type-driven machinery. It also adds tests covering anonymous struct targets and anonymous structs as map element types.

Changes:

• Add parsing for inline struct{...} type spellings (including tags) and decode anonymous struct targets/element types using parsed field metadata.
• Extend type-driven decoding utilities (resolveTypeInfo, decodeValueForType, decodeInterfaceValue) and wire them into Unmarshal assignment paths.
• Add vitest coverage for anonymous struct decoding and related nested container decoding scenarios.

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 3 comments.

File	Description
gs/encoding/json/index.ts	Adds anonymous-struct type-spelling parsing and integrates it into Unmarshal’s type-driven decode/assignment paths.
gs/encoding/json/index.test.ts	Adds tests for anonymous struct Unmarshal targets and anonymous struct map element decoding.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[mck]

Good catch, fixed in 38181bf: assignDecodedValue's type-driven dispatch now also matches Pointer TypeInfo, reusing decodeValueForType's existing unmarked Pointer handling. Added a test with a top-level var p *pkg.T style target verifying it matches *Property, not Property.

[mck]

Good catch, fixed in 38181bf: assignAnonymousStructFields now checks decoded keys against the field list's json names when disallowUnknownFields is set, same as assignStructFields does for named structs.

[mck]

Good catch, fixed in 38181bf: assignAnonymousStructFields now constructs a by-value named-struct field directly via decodeValueForType whenever the field's type resolves to a real, ctor-bearing struct type, instead of falling through to the generic path that expects a pre-existing instance.

[paralin]

Requesting changes: nested anonymous struct fields still fall through to the generic interface decoder.

At gs/encoding/json/index.ts:1515, assignAnonymousStructFields only special-cases ctor-backed named struct fields before calling assignDecodedFieldValue. For a field like:

struct {
    Inner struct {
        Name string `json:"name"`
    } `json:"inner"`
}

parseAnonymousStructFields stores Inner’s type as another anonymous-struct descriptor, not a registered TypeInfo. resolveTypeInfo(field.type) returns null, so the field falls through and is decoded as a generic interface object: a Map keyed by the JSON tag (name) instead of the anonymous struct representation keyed by Go field name (Name). Nested DisallowUnknownFields is skipped for the same reason. A *struct{...} anonymous field has the same failure mode.

Focused repros on this head:

expected { Name: "Ada" }
received Map { "name" => "Ada" }

Fix direction: before the generic assignDecodedFieldValue fallback, route anonymous field descriptors through decodeValueForType(fieldValue, field.type, opts). For pointer descriptors, let decodeValueForType handle *struct{...} as well; its pointer branch can recurse into the anonymous descriptor and preserve the parsed json tags.

[mck]

Fixed in dea5a9e. A field whose own type is itself an inline struct{...} (or *struct{...}) had its type stored as another anonymous-struct descriptor by parseAnonymousStructFields, so resolveTypeInfo(field.type) returned null and it fell through to the generic assignDecodedFieldValue path, decoding as an interface{} Map keyed by the JSON tag with nested DisallowUnknownFields skipped. assignAnonymousStructFields now routes anonymous field descriptors (struct{...} directly, or *struct{...} via a new isAnonymousStructType helper) through decodeValueForType before that fallback, which recurses into assignAnonymousStructFields (the pointer case falls through its Pointer branch to the same anonymous decode for a non-struct-typeinfo pointee), so the parsed json tags and disallowUnknownFields are honored. Added three regression tests (nested struct{...} field, nested *struct{...} field, nested disallowUnknownFields) that fail on the parent commit and pass here.

Verify: bun run typecheck && vitest run gs/encoding/json/index.test.ts

[mck]

Rebased this branch onto the latest #145 (c18d36a, paralin's fix so a non-nil *T implementing UnmarshalJSON decodes through the hook, both when pre-populated and when freshly allocated). The two changes coexist cleanly: the custom UnmarshalJSON hook check runs first in both assignDecodedFieldValue and decodeValueForType's Pointer branch, and everything that isn't a custom unmarshaler still falls through to the anonymous-struct and type-driven handling added here. Ran the full JS suite, the json package tests specifically (34 passing, covering both PRs' regressions), typecheck, lint, and go test ./... — all green. Since this was rebased on #145's tip, #145 should merge first, then this.

[Copilot]

Pull request overview

Copilot reviewed 2 out of 2 changed files in this pull request and generated 2 comments.

[paralin]

Requesting changes: anonymous struct parsing currently treats unexported fields as JSON fields.

At gs/encoding/json/index.ts:1394, parseAnonymousStructFields pushes every named field into fieldMetadata:

const name = spec.slice(0, space)
fields.push({
  key: name,
  name,
  type: goTypeDescriptor(spec.slice(space + 1).trim()),
  ...(tag !== undefined ? { tag } : {}),
})

Go's encoding/json ignores unexported fields even when they have a json:"..." tag. Current code populates lowercase fields and also includes them in the DisallowUnknownFields known-name set, so strict mode accepts keys Go would reject.

Focused repros on current head:

expected { name: "keep", Age: 30 }
received { name: "Ada", Age: 30 }

and strict mode:

expected json: unknown field "name"
received undefined

Fix direction: parseAnonymousStructFields should skip unexported named fields before adding them to fieldMetadata. Then ordinary decode leaves lowercase fields untouched, and DisallowUnknownFields rejects JSON keys that only match unexported fields.

I also re-ran the existing focused JSON test and typecheck on the current head:

bun run vitest run gs/encoding/json/index.test.ts
# 34 passed

bun run typecheck
# passed

[Copilot]

Pull request overview

Copilot reviewed 2 out of 2 changed files in this pull request and generated no new comments.