encoding/json + builtin/type.ts: correctness bugs

[mck]

Follow-up to #141 (three gs/builtin/slice.ts perf fixes, already opened).

While transpiling and running a real ~100k-LOC Go package (interpreter + parser + lexer + types + resolver for a design-tokens expression language) through goscript, we found a handful of additional bugs — mostly in the bundled encoding/json runtime, plus one more builtin/type.ts correctness bug. These are currently vendored locally as a --gs-path override (for encoding/json) and a post-generation text patch (for builtin/type.ts), rather than proposed as PRs yet, to keep review units small. Filing this as a pointer in case there's interest — happy to open individual PRs for any/all of these on request.

Summary of what we found (all root-caused with minimal standalone repros, transpiled and run under Bun):

1. encoding/json omitempty not honored on marshal. Struct fields tagged ,omitempty were emitted unconditionally even when holding a Go zero value (zero number, empty string, false, empty slice/map, nil pointer/interface).

2. encoding/json marshal leaks the boxed interface{} wrapper. A value carrying goscript's boxed-any wrapper (__goValue) serialized as {"__goValue": ...} instead of the underlying primitive/map/slice.

3. encoding/json unmarshal doesn't type-drive Map/Slice struct fields. Only direct []Struct fields decoded into real struct instances; map[string]Struct / map[string][]Struct fields (and further nesting) left plain JS objects/arrays in place, so generated struct-field-accessor getters returned undefined.

4. encoding/json unmarshal doesn't recurse into array elements inside interface{}-typed values. An interface{}-typed array of objects (e.g. Go []any holding map[string]any elements) left element objects as raw plain JS objects instead of the Map representation used elsewhere, breaking Go-side case map[string]any: type switches that call .entries().

5. encoding/json unmarshal ignores json:"..." tags on anonymous (inline, unnamed) struct types. Anonymous struct targets carry no _fields/registered type metadata, so they fell through to the untyped interface{} decode path, which replaces the plain-object struct value with a Map — every field then read back empty.

6. encoding/json RawMessage not handled as a map/slice element type, and no Pointer-to-struct branch in the type-driven decoder (map/slice element and field types like map[string]*Property leaked plain objects with undefined Go field reads).

7. builtin/type.ts structural type matching misclassifies a plain JS Array as map[string]any. matchesMapType and typeAssert's inline map check accept any non-null object; Object.entries() of an array yields string indices that pass key/elem sampling. A Go type switch listing case map[string]any: before case []any: then captures arrays in the map branch, and ranging over the "map" produces numeric keys instead of the correct slice semantics — corrupting []any values into {0: ..., 1: ...}-shaped maps.

Each of these was found because our workload exercises real nested JSON documents (design-token specs) through encoding/json-based Unmarshal/Marshal and Go-side type switches on interface{} — not synthetic. Happy to share minimal repros or open PRs for any of these if useful; didn't want to dump 7 unrelated changes into one giant PR.

🤖 Filed with Claude Code

[mck]

Opened as four small PRs:

• fix(builtin/type): a plain array never matches a map type #143 - item 7 (builtin/type: array vs map)
• fix(encoding/json): honor omitempty and unwrap boxed interface{} on marshal #144 - items 1+2 (encoding/json marshal: omitempty, boxed interface{})
• fix(encoding/json): type-drive Unmarshal into Map/Slice/Pointer containers #145 - items 3+4+6 (encoding/json unmarshal: typed Map/Slice/Pointer decode)
• fix(encoding/json): honor json tags on anonymous struct Unmarshal targets #146 - item 5 (encoding/json unmarshal: anonymous struct json tags), stacked on fix(encoding/json): type-drive Unmarshal into Map/Slice/Pointer containers #145

Each has tests that fail before and pass after its fix, plus a Verify section with the exact command to run just that PR's tests. #146 depends on #145 (noted in its body); the other three are independent.

[paralin]

Merged #143 and #145

#144 and #146 have changes requested

[paralin]

Merged the reviewed JSON runtime PRs through to master in c3933e59b4db361036c050c229e4d7580bb26204.

Included PRs:

• fix(encoding/json): honor omitempty and unwrap boxed interface{} on marshal #144: marshal omitempty plus boxed interface value handling.
• fix(encoding/json): type-drive Unmarshal into Map/Slice/Pointer containers #145: typed Unmarshal for Map/Slice/Pointer containers; already merged to dev and included in the final master state.
• fix(encoding/json): honor json tags on anonymous struct Unmarshal targets #146: anonymous struct json tag decoding.

The final commit also includes the follow-up review fixes made after the PR reviews:

• omitempty now checks pointer/interface nilness before VarRef unwrapping, so non-nil pointers/interfaces are emitted even when their pointed or dynamic value is zero/nil.
• Anonymous struct parsing skips unexported fields even with json tags, and strict decode rejects keys that only match those skipped fields.

Verified locally:

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

origin/dev and origin/master both point at c3933e59b4db361036c050c229e4d7580bb26204.

[paralin]

Checked current master/dev at c3933e5 against the full #142 thread and linked PRs #143-#146. All issues seem fixed!

Status by reported item:

1. encoding/json marshal omitempty: fixed, including zero string/int/slice/map/[]byte, zero bigint, nil pointer/interface, and the reviewed non-nil pointer/interface cases.
2. Boxed interface{} marshal: fixed via the runtime boxed-value predicate, so real named-value boxes unwrap while ordinary objects with a __goValue key still marshal as objects.
3. Type-driven Unmarshal for map/slice struct fields: fixed for nested containers such as map[string][]Struct.
4. interface{} array/object recursion: fixed; object elements inside interface-typed arrays decode to the runtime Map representation.
5. Anonymous struct tags: fixed for top-level, map element, nested anonymous struct, pointer-to-anonymous-struct, strict unknown-field handling, and unexported-field skipping.
6. RawMessage and pointer container decode: fixed for map/slice element RawMessage, pointer-to-struct fields/elements/top-level targets, pointer-vs-value marking, and UnmarshalJSON hooks on nil and non-nil pointer fields.
7. builtin/type.ts array-vs-map matching: fixed for Array and Uint8Array, including empty values and type-switch ordering.

Local verification on the current checkout:

bun run vitest run gs/encoding/json/index.test.ts gs/builtin/type.test.ts
# 2 files passed, 48 tests passed

bun run typecheck
# passed

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

No blockers found. Closing this as completed. Thanks again @mck for the detailed repros and the well-scoped PRs.