fix(encoding/json): type-drive Unmarshal into Map/Slice/Pointer containers

[mck]

Part of #142 (items 3, 4 and 6).

Touches the same file as #144 but a different area (Unmarshal's decode path vs Marshal's encode path). gs/encoding/json/index.ts itself merges cleanly between the two branches; only the shared test file (index.test.ts) has a textual conflict, since both PRs happen to insert new test fixture classes right after the existing FieldAlias class, so whichever merges second needs a trivial resolution there (keep both class blocks). No logic overlap. #146 (item 5, anonymous struct json tags) is stacked directly on this branch, since it extends the same goTypeDescriptor/decodeValueForType this PR introduces, so please merge this one first.

Unmarshal only recognized a struct field/target as needing special handling when its runtime value was already an instance of the right shape (an existing struct instance, a Uint8Array, etc). Everything else fell through to a generic "objects become Maps" decode with no awareness of the field's declared Go element type. Three related gaps, all fixed by the same missing piece: decoding needs to walk the field/element's TypeInfo, not just the JSON shape it happens to see.

Gap 1: map[string]Struct and map[string][]Struct fields (and further nesting) left plain JS objects/arrays in place instead of real struct instances, so generated struct-field accessors read back undefined.

type Ref struct{ Name string `json:"name"` }
type Container struct {
    Contexts map[string][]Ref `json:"contexts"`
}
json.Unmarshal([]byte(`{"contexts":{"a":[{"name":"x"}]}}`), &c)
// c.Contexts["a"][0].Name read back "": plain object, not a Ref

Gap 2: an interface{}-typed array of objects left its element objects as raw plain JS objects instead of this override's Map representation, so a case map[string]any: type switch on an element panicked calling Map-only methods like .entries().

var v any
json.Unmarshal([]byte(`[{"x":1},{"y":2}]`), &v)
// v.([]any)[0] was a plain object, not the Map every other
// interface{}-typed object value decodes to

Gap 3: json.RawMessage wasn't recognized as a map/slice element type (only as a direct field type), and there was no Pointer branch in the type-driven path at all, so pointer elements and fields (map[string]*Property, Items *ItemsSpec) leaked plain objects with undefined Go field reads.

The fix is a recursive decodeValueForType(decoded, typeInfo, opts) that decodes a raw JSON value per its Go TypeInfo: Struct constructs a real instance via the registered ctor, Slice/Map recurse per elemType, Pointer decodes as its pointee, json.RawMessage captures the raw fragment as bytes, and anything else (including interface{}) falls back to a new decodeInterfaceValue, which replaces objectToMap and additionally recurses into array elements, fixing gap 2 for both nested and top-level arrays. It is wired in at both call sites: assignDecodedFieldValue (struct fields) and assignDecodedValue's new top-level branch, which resolves a var's own type via the __goType spelling the runtime boxes onto Unmarshal's any target, needed for e.g. var m map[string]json.RawMessage where there is no struct field to hang type info off of.

A pointer-to-struct pointee is constructed directly in the Pointer branch (not by recursing into the Struct branch, which always marks its result via $.markAsStructValue): the runtime's pointer type matching (matchesPointerType in gs/builtin/type.ts) requires struct pointees to stay unmarked, so both assignDecodedFieldValue's field routing and decodeValueForType's own Pointer branch share this construction path. goTypeDescriptor also preserves a nested pointer element type (e.g. the *test.Property in map[string]*test.Property) instead of stripping every leading * while parsing; only the outermost address-of star (the Unmarshal target's own &var) is stripped, by unmarshalTargetGoType, before this function ever runs.

Tests extend gs/encoding/json/index.test.ts with one case per gap: map[string][]Struct field, interface{} array-of-objects, pointer-to-struct map value and field, RawMessage as both a map and slice element, and two cases verifying decoded pointer values match *Struct (not Struct by value) via the public $.is() API. All new tests fail on master (or the prior commit, for the pointer-marking cases) and pass with this fix, verified by temporarily reverting just the source change and confirming they fail with the errors described above.

Verify:

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

24 passed. Full suite: bun run typecheck clean, bun run test:js 1277 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 improves the gs/encoding/json override’s Unmarshal decode path by decoding JSON values according to Go TypeInfo (including nested map/slice element types), instead of relying purely on the runtime JSON shape. It targets correctness for nested map[string]T / []T containers, pointer-to-struct elements/fields, interface{} arrays-of-objects, and json.RawMessage as an element type.

Changes:

• Add a recursive, type-driven decoder (decodeValueForType) and use it for struct fields and top-level map/slice targets when Go type spellings are available via __goType.
• Replace the previous object-only recursion with decodeInterfaceValue, which also recurses into arrays so objects inside []any decode into Maps consistently.
• Extend index.test.ts with new fixtures and test cases covering the reported nested map/slice, interface-array, pointer, and RawMessage 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 type-driven decoding helpers and wires them into Unmarshal’s assignment paths.
gs/encoding/json/index.test.ts	Adds regression tests for nested typed decode (map/slice), interface arrays, pointers, and RawMessage elements.

---

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

[mck]

Good catch, this was a real bug. Fixed in 1cc7a96: the field-routing path now passes the Pointer TypeInfo itself to decodeValueForType (not elemType), so it goes through the Pointer branch's now-correct unmarked construction instead of bypassing it.

[mck]

Fixed in 1cc7a96: the Pointer branch now constructs struct pointees directly instead of recursing into the Struct branch, so the result stays unmarked. Added a test verifying decoded pointer values match *Struct (not Struct) via $.is().

[mck]

Good catch, fixed in 1cc7a96: goTypeDescriptor now returns a Pointer descriptor for a leading '*' instead of stripping it, so nested pointer element types (e.g. the *test.Property in map[string]*test.Property) are preserved. Added a regression test for this exact spelling.

[paralin]

Requesting changes: the new pointer-to-struct decode path bypasses UnmarshalJSON for pointer fields.

At gs/encoding/json/index.ts:1116, assignDecodedFieldValue returns through the new pointer-to-struct branch before it can call assignDecodedValue. That skips the existing unmarshalJSONTarget(target.value) hook for a non-nil *T field whose pointee implements UnmarshalJSON. The result is field population into a fresh T instead of invoking the custom decoder that Go’s encoding/json would prioritize.

Focused repro on this head:

expected hook:{"value":"decoded"}
received decoded

Fix direction: check unmarshalJSONTarget(target.value) before the pointer-to-struct early return. For nil pointer fields where the pointee type implements UnmarshalJSON, allocate the pointee and invoke the hook on that new instance instead of directly field-populating it.

[mck]

Thanks for catching that. Fixed in c18d36a.

The pointer-to-struct branch had two spots that needed the hook check, matching your fix direction. assignDecodedFieldValue now checks unmarshalJSONTarget(target.value) before routing into the type-driven constructor: a field that already holds a non-nil pointer whose pointee implements UnmarshalJSON falls through to assignDecodedValue, which invokes the hook on that existing instance in place, the same way Go decodes into the pointee rather than allocating a replacement. decodeValueForType's Pointer branch also checks the freshly allocated pointee for UnmarshalJSON before falling back to assignStructFields, which covers the nil-field case (nothing exists to check the hook against until after allocation) and map/slice pointer-to-struct elements, which share this same branch.

Added two regression tests: a nil pointer field decoding through the hook, and a non-nil pointer field decoding into the existing pointee in place, checked via object identity so a fix that just re-hooks a fresh replacement instance would not pass it. Both fail on the parent commit and pass here, verified by temporarily reverting just the source change.

Verify: bunx vitest run gs/encoding/json/index.test.ts

RE review

[paralin]

No findings on the current head.

I re-checked the prior pointer-to-struct UnmarshalJSON issue. The current code checks the existing field value's hook before routing into the type-driven pointer constructor, and the Pointer branch checks the freshly allocated pointee before default struct population. That covers both non-nil and nil pointer field cases from the prior review.

Local focused checks on current head:

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

bun run typecheck
# passed

CI metadata also shows CodeQL, DCO, dependency review, and Tests green; browser-smoke is skipped.

[paralin]

Merged through to master in c3933e59b4db361036c050c229e4d7580bb26204.

The final dev/master commit includes the reviewed PR changes plus the follow-up review fixes:

• omitempty now decides pointer/interface emptiness from the wrapper itself before any VarRef unwrap, so non-nil pointers/interfaces are emitted even when their pointed or dynamic value is zero/nil.
• Anonymous struct decode now skips unexported fields even when they carry json tags, and DisallowUnknownFields rejects keys that only match those skipped fields.

Verified locally after applying the changes:

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

bun run typecheck
# passed

bun run test
# go test ./... passed
# vitest: 156 files, 1322 passed, 4 skipped