2026.11.04 (2026-11-04)

Changes

  • Add JSONC as an input format, accepting line and block comments with JSON syntax. (#5088)

  • Add JSONC as an output language, preserving source comments with JSON syntax. (#5089)

  • Exclude the optional YAML C accelerator from Emscripten installations, allowing Pyodide to resolve Literalizer’s dependencies normally. (#5093)

  • Add an opt-in native record format for Roc, avoiding the generated Val union for record-shaped data. (#5094)

  • C#, Dart, Go, Kotlin, and Scala now accept skip_null_dict_values=True to omit null dictionary values while preserving the existing default behavior. (#5166)

  • Fix C++ nested list literals using incompatible element types when empty lists have populated positional cousins. (#5177)

  • Fix Java mixed integer/float collection type hints to use Number for boxed elements, preserving integer values and producing set declarations that compile. (#5191)

  • Fix C# class-field declarations to annotate tuple sequences with tuple types, including empty, single-element, and nested tuples. (#5200)

  • Fix Java and C# file wrappers for BothVariableForms with class-field modifiers by placing reassignment in an initializer or constructor.

    Pass declaration modifiers and scoped preambles to language file-wrapper hooks through FileWrapperContext. Class-member call stubs now use format_call_class_scope_stub and compositions accept extra_class_preamble. (#5201)

  • Fix PureScript native-record wrapped call stubs to accept independently typed native arguments. (#5202)

  • Render Roc dictionary keys through the semantic key formatter instead of stripping a value constructor from generated text. (#5214)

  • Track literal declarations and generated body-preamble blocks explicitly when wrapping Roc output, preserving alias usage without scanning rendered source. (#5216)

  • Java Jackson JSON declarations preserve the final modifier and reject class-field modifiers with IncompatibleFormatsError instead of silently dropping them and emitting invalid initializers. (#5224)

  • C now raises UnrepresentableInputError for native record-array reassignment instead of generating invalid C code.

    C#, D, Dart, F#, Groovy, Julia, Mojo, Nim, Odin, PHP, PowerShell, Python, Raku, SystemVerilog, and Zig now give colliding dotted-call helper types distinct names so calls such as a.foo.Foo.bar compile and pass static checks. (#5236)

  • Fix C++17 and C++20 mixed lists containing differently typed sibling maps and a scalar so their map literals match the enclosing std::variant alternatives. (#5238)

  • Fix nested collection literals to use the common integer width required by their containing map. (#5248)

  • Fix Nim, Kotlin and C# native record fields containing nested empty lists beside populated numeric siblings. (#5249)

  • Fix homogeneous C++14 RECORD fallback maps to retain their concrete value type. (#5250)

  • Give empty Swift list bindings an explicit element type. (#5251)

  • Fix bound empty, integer and floating point lists to use compatible types in their shared collection context. (#5252)

  • Reject reserved dotted call members when the target language cannot declare them. (#5253)

  • Preserve labels for underscore-prefixed Swift call parameters in generated stubs. (#5254)

  • Neutralize embedded openers in C-style block comments to prevent nesting errors and compiler warnings. (#5255)

  • Fix RECORD fallback maps containing sequence payloads to declare and render compatible value carriers. (#5256)

  • Split Python native records when their field types differ. (#5257)

  • Fix generated record names and root record rendering across bound C++ declarations. (#5258)

  • Use native record types inside Python heterogeneous field annotations. (#5259)

  • Omit unused bound value declarations from wrapped files. (#5260)

  • Omit unused JSON imports from Nim reference aliases while retaining imports required by bound value declarations. Preserve C++ reference value categories when explicit value hints differ from the bound data, including declarations with const and static modifiers. (#5261)

  • Render Nim constant maps as native tables so empty and populated siblings have compatible types. (#5262)

  • Fix C++ ordered-map variant alternatives to use their native record list types. (#5263)

  • Use GNU timeout to bound individual fixtures, retries, and multi-command round trips, with shared diagnostics that report the source, command, status, and elapsed time on failure. Bound each Kotlin fixture compiler and evaluation check with a filename and elapsed-time deadline diagnostic. Split Swift type inference for deeply nested singleton arrays into independent closure bodies, preserving the nested array type and value. (#5264)

  • Reject incompatible scalar types in nested sibling sequences under strict homogeneous strategies. (#5265)

  • Keep C# and Kotlin nested empty array literals and record fields consistent with their integer siblings. (#5266)

  • Represent nested OCaml arrays in the value carrier and reject unsupported nested Gleam tuples. (#5267)

  • Preserve post-2038 epoch integer widths in C#, V, and SystemVerilog maps. (#5268)

  • Escape DEL and C1 control characters in Ada string values and dictionary keys. (#5269)

  • Use scientific notation when a fixed float exceeds Perl or COBOL numeric token limits. (#5270)

  • Reject uppercase Roc value names and Roc/V wrapped function names that cannot compile. (#5271)

  • Use the shared C record schema for bound record declaration types. (#5272)

  • Use native record copies for V references. (#5273)

  • Wrap bound C time values in the tagged string representation. (#5274)

  • Copy Mojo bound containers when reusing them in generated declarations. (#5275)

  • Reject pre-indented Haskell files and preserve multiline call continuations when composing bound references. (#5276)

  • Rename Crystal record keyword fields consistently in declarations. (#5277)

  • Escape bidirectional formatting controls in Julia string literals. (#5278)

  • Explicitly discard SystemVerilog function call results. (#5279)

  • Initialize generated Raku call stub instances without invoking an overridden new method. (#5280)

  • Reject Ada call parameter names with leading, trailing, or repeated underscores. (#5281)

  • Give nested V arrays explicit dimensions when every leaf is empty. (#5282)

  • Reject wrapping unbound Norg values as standalone documents. (#5283)

  • Use the generated root identifier when executing Elm golden files. (#5284)

  • Keep underscore-prefixed Haskell call parameters concrete when rendering numeric arguments. (#5285)

  • Use descriptive caller-supplied reference names in C-family compiler fixtures. (#5286)

  • Omit unused Any imports when empty Python maps inherit populated sibling types. (#5287)

  • Fix ineffective C++ moves of trivial native records, including nested scalar arrays, while retaining moves for owning and externally supplied records. (#5316)

  • Preserve stale golden fixtures during ordinary verification and require explicit regeneration to remove them. (#5321)

  • Allow C++ native records to declare independent typed array fields while retaining heterogeneous array validation. (#5322)

  • Emit C++ standard-library field dependencies before composed native record declarations. (#5323)

  • Keep C++ references to known native null values bare while preserving moves for unknown references, owning JSON values, and non-null bound values with null inference hints. (#5325)

  • Golden fixture orphan checks now reject combined heterogeneous-strategy files for language versions that the renderer does not exercise. (#5329)

  • Value-initialize scalar array fields in C++ native record declarations, including nested arrays. (#5330)

  • Compare format variants across supported language versions and match orphan detection to each variant’s effective version. (#5331)

  • Infer V native-record ordered-map field types from their rendered values, including empty maps and epoch datetimes. (#5337)

  • V RECORD ordered-map fields now retain their generated record value types and reject maps containing incompatible native record types. (#5338)

  • Preserve V native record names through nested ordered-map and list field types. (#5340)

  • Simplify reference golden input preparation to retain the existing lint complexity limit after combining reference coverage. (#5342)

  • Refresh C++ native record reference golden files for the current reference-binding declarations. (#5344)

  • Collect imports from all bound values before declaring native record types. (#5345)

  • Swift native record bindings now retain their record types when their fields include null values. (#5346)

  • C, C++, and Objective-C now represent bidirectional formatting controls with escaped character arrays that preserve their string values and pass compiler checks. (#5348)

  • Allow canceled continuous integration runs to stop their completion jobs so replacement pull request checks can proceed. (#5349)

  • Resolve Kotlin native record tuple fields as Pair and Triple types. (#5350)

  • Execute generated Python assignments in multiline round-trip tests so ordered-map constructors retain their values. (#5351)

  • Preserve C++ bound values reused across literal entries or declaration and assignment forms. (#5352)

  • Match C++ reference moves and pointer qualification to native scalar binding representations. (#5353)

  • Explicitly discard unchanged transformed C++ method return values in statement calls. (#5354)

  • Terminate Java call-result bindings before trailing line comments while preserving quoted comment markers. (#5355)

  • C root references now retain their resolved native record types and copy bound values without applying literal wrappers again. (#5356)

  • Rust native record rendering now preserves the shared record schema when bound references occur alongside direct fields. (#5357)

  • Emit one coherent Gleam carrier type when reference hints differ from bound values. (#5358)

  • Narrow empty Scala arrays to the element type of populated siblings. (#5359)

  • Size SystemVerilog signed integer magnitudes explicitly at the minimum 32-bit boundary. (#5360)

  • C# class-field roots now declare bound references as typed static fields and infer root reference types from their values. Incompatible explicit reference hints raise an error. (#5361)

  • Reject reserved Scala keywords in dotted call targets. (#5362)

  • Narrow Mojo empty dictionary siblings and refuse scalar-only variants containing incompatible collection values. (#5363)

  • Preserve nested Elm block-comment openers using valid balanced comment syntax. (#5364)

  • Bind wrapped Elm multiline calls once per expression when reference declarations are present. (#5365)

  • Terminate Cpp call-result bindings before trailing line comments while preserving quoted comment markers. Infer the result binding type from the returned expression rather than its argument data. (#5366)

  • Preserve scalar variant carriers in empty Mojo list siblings. (#5377)

  • Refresh the C++14 nested null reference golden file for the current import order. (#5381)

  • Avoid extra bidirectional-control checks for ASCII C strings. (#5383)

  • Retry transient Common Lisp dependency installation failures within a bounded time budget. (#5393)

  • Infer Dart call result types independently of argument type hints. (#5398)

  • Document caller-owned argument, return-type, assignment, and constant-expression requirements for generated calls, including Dart constant constructors. (#5399)

  • Use the source numeric sign when parenthesizing Elm constructor arguments, retaining negative-zero handling across float formats. (#5405)

  • Declare C++14 scalar carriers required by heterogeneous call argument slots. (#5407)

  • Run validation workflows for pull requests targeting feature branches so stacked changes receive the normal checks. (#5415)

  • Preserve native Swift record types inside ordered-map fields and their nested collections. (#5418)

  • Infer Kotlin record fields containing boolean and floating-point primitive arrays from their element types, including nested arrays. (#5419)

  • Log Roc round-trip source generation and the exact launch command before running the compiler. (#5420)

  • Avoid timing failures in the scalar round-trip property test, matching the collection tests. (#5423)

  • Preserve native Swift record types in explicit annotations for root ordered maps and their nested collections. (#5425)

  • Replace tabs in preserved Roc comments with spaces while leaving scalar values unchanged. (#5427)

  • Align pre-indented Roc reference definitions with their type annotations in wrapped modules. (#5428)

  • TypeScript compiler consumer probes no longer introduce bindings that can shadow generated variable names. (#5429)

  • Preserve native Python record types in variable annotations, including bound references and root collections. (#5430)

  • Avoid COBOL wrapper program identifiers that collide with their nested call targets. (#5431)

  • Render R datetime years with four digits consistently across Python versions and platforms. (#5432)

  • Use the compatible ordered-map typing alias for eager annotations targeting Python 3.8 while preserving ordered-map construction. (#5438)

  • Include accepted calls with unused reserved parameter labels in golden-file discovery. (#5440)

  • Respect identifier case sensitivity when classifying reserved call parameter labels in golden-file discovery. (#5444)

  • Match public call-target keyword validation when discovering golden-file cases. (#5445)

  • Fix C++ empty sequence types beside heterogeneous tuple siblings. (#5446)

  • Preserve repeated owned Rust references by cloning values that cannot be copied. (#5447)

  • Preserve wide epoch timestamp types in nested C# arrays inside ordered-map record fields. (#5448)

  • Use golden-file binding metadata when checking Dart fixture initialization with custom root names. (#5450)

  • Render Elm singleton value lists with cons expressions so deeply nested lists format promptly with elm-format. (#5451)

  • Preserve C++ native tuple alternatives when reconciling nested empty sequence siblings. (#5452)

  • Evaluate private Dart fixture bindings through fresh public accessors in temporary library copies. (#5457)

  • Declare the wide integer carrier used by PureScript epoch datetimes. (#5459)

  • Import numeric negation for negative PureScript epoch datetimes. (#5460)

  • PureScript now renders the minimum signed 32-bit integer as an exact expression that compiles in both tagged-value and native-record output, including hexadecimal formatting. (#5461)

  • Keep known null references bare in V while preserving collection cloning for references without value metadata. (#5462)

  • Preserve rendered epoch and nested collection types when V empty maps borrow their sibling map types. (#5463)

  • Reject incompatible sibling map value types in homogeneous outer maps, including V’s default rendering strategy. (#5464)

  • Use mutable Zig bound references in generated file wrappers. (#5465)

  • Preserve root references in Zig JSON value bindings. (#5467)

  • Kotlin call-result bindings now infer their type from the call expression, including when literal type hints are set to ALWAYS. (#5468)

  • Give compatible mutable native Zig nested sequences an explicit slice type so bound-array reassignment avoids the pinned compiler’s LLVM tuple-pointer crash. (#5469)

  • Prevent Zig variable and reference bindings from shadowing generated carrier and JSON parser names, while preserving names that are available in other output modes. (#5480)

  • Preserve whole-input list arguments when inferring wrapped call parameter types. (#5481)

  • Run hosted hook checks with the prek version pinned for local development. (#5485)

  • Check the types of reference inference values and definite-null metadata during normal library use. (#5488)

  • Infer C# epoch datetime set carriers from their rendered integer widths. (#5518)

  • Clone referenced C# JSON nodes so repeated references can be attached to multiple parents. (#5519)

  • Keep C++ signed Int32 minimum expressions compatible with inferred variant alternatives. (#5520)

  • Suffix wide Rust epoch datetime literals so they compile with default type hints. (#5523)

  • Preserve JSONC and JSON5 input comments in generated literals and function calls, including nested, scalar, and empty collection inputs, using the target language’s existing comment formatting and fallback rules. (#5536)

  • Compile Java fixtures and round trips with warnings treated as errors. Generate fixed-arity call stubs so null and array arguments retain their declared parameter shape. (#5541)

  • Reject compiler warnings in C and C++ generated programs. (#5545)

  • Deny compiler warnings in Rust generated programs. (#5546)

  • Reject C#, Visual Basic and F# generated-code warnings. (#5547)

  • Reject Kotlin generated-source warnings while retaining 1.9 mode. (#5548)

  • Reject compiler warnings in Scala generated programs. (#5549)

  • Reject compiler warnings in Fortran generated programs. (#5550)

  • Make all enabled OCaml generated-code warnings fatal. (#5551)

  • Enable fatal DMD warnings in generated-code validation. (#5552)

  • Reject Ada front-end and backend warnings in generated programs. (#5553)

  • Reject compiler warnings in COBOL generated programs. (#5554)

  • Reject compiler warnings in Crystal generated programs. (#5555)

  • Reject generated-package warnings before Gleam execution. (#5556)

  • Fail Elixir fixture compilation and round trips on structured warnings. (#5557)

  • Apply Swift warnings-as-errors to round-trip programs. (#5558)

  • Reuse the Nim fixture fatal-warning list in round trips. (#5559)

  • Compile Erlang round-trip scripts with fatal warnings. (#5560)

  • Reject V compiler warnings in fixtures and round trips. (#5561)

  • Retire Kotlin 1.9 support in favor of language/API version 2.4 (Kotlin.version_formats.V2_4), validated with Kotlin 2.4.21 and fatal warnings. (#5596)

  • Retain collection type, fallback, and length decisions for sibling widening and empty-container inference. (#5597)

  • Retain literal, reference, and call assignment binding semantics without rendering declaration probes. (#5598)

  • Retain zipped-operand usage from call transforms when selecting value-dependent preambles. (#5599)

  • Retain root mapping entries when lowering wrapped TOML declarations to tables. (#5601)

  • Retain import roles and literal/call preamble compatibility through generated source assembly. (#5602)

  • Retain Python typing imports and C++ record field headers alongside type inference results. (#5603)

  • Choose Bash nested-collection escaping and declaration flags from literal and reference roles instead of rendered prefixes. (#5605)

  • Fix Swift declaration inference for record-like string contents and custom record prefixes. (#5606)

  • Retain Kotlin collection constructor types through literal and declaration rendering. (#5607)

  • Retain C pointer and array declaration shapes when rendering record fields, stubs, and bindings. (#5608)

  • Retain C++ variant, scalar-array, and aggregate initializer facts at their producers. (#5609)

  • Choose Crystal tuple and percent-string entry spacing from literal roles instead of rendered prefixes. (#5612)

  • Retry pinned Go linter installs after transient network and checksum-service failures. (#5624)

  • Infer Rust nested empty-vector element types from populated siblings and cousins. (#5638)

  • Keep nested Go map and slice types consistent when EPOCH datetimes appear beside integers. (#5639)

  • Seeded call golden fixtures require a mutable binding when their assignment introduces another declaration. (#5640)

  • Fix Mojo epoch datetime types in sets and generated call parameters. (#5641)

  • Wrapped Mojo calls now reject a bare underscore as a parameter name because Mojo reserves it in parameter declarations. (#5642)

  • Avoid redundant ownership transfers for Mojo references to known null values. (#5643)

  • Use flexible synthetic call parameters when integration fixtures feed a call result back into the same callee. (#5644)

  • Allocate distinct C cJSON helper variables across bound-reference declarations in a generated document. (#5645)

  • Use the known native record type for C wrapped-call parameters receiving bound record references. (#5646)

  • Composed call files retain binding forms and place executable assignments after Ada declarations. (#5647)

  • Call golden scaffolds validate target names in their generated declaration context. (#5648)

  • Fix C# nested dictionary and array types for epoch timestamps outside the signed 32-bit range. (#5660)

  • Fix C# native record arrays with empty sibling lists by inferring the shared record type and explicitly typing empty arrays. (#5661)

  • Haskell tuple validation now rejects tuple-valued call arguments and resolved references that cannot fit the generated Val type. (#5663)

  • Nim calls reject ragged nested arrays before returning compiler-invalid source. Use RECORD, OBJECT_VARIANT, or a JSON type to render variable-length nested collections. (#5670)

  • Nim native empty bound sequences retain their sibling-inferred element type. (#5671)

  • Reject incompatible Rust fixed-size sequence shapes through nested map boundaries before emitting source. (#5686)

  • Read synthetic call-golden seed bindings before overwriting them so strict compiler and analyzer checks accept existing-variable scaffolds. (#5687)

  • Preserve generated C++ record element types when unifying empty and populated sibling sequences, including record fields and bound references. (#5690)

  • Retain the populated sibling record type for empty V arrays in literals, record fields, and bound-reference declarations. (#5691)

  • Pool epoch-second integer widths across sequence elements, including a narrow first timestamp and nested V arrays. (#5692)

  • Preserve execution order when composing Fortran call assignments with later uses of an existing binding. (#5703)

  • Render C# RECORD arrays containing both an empty sequence and a record with an explicit object element type. (#5704)

  • Give generated Nim call stubs concrete parameter types for empty arrays so wrapped calls that bind a result compile successfully. (#5705)

  • Fix Elm wrapped JSON-valued calls placing generated function declarations before imports. (#5724)

  • Reject the SystemVerilog keyword before in variable names, call parameters, and bare or dotted call targets. (#5725)

  • Fix wrapped V dotted calls with interface-backed list arguments on the supported pinned compiler. (#5730)

  • Add a Swift array inference policy: keep automatic inference boundaries by default, or select Swift.array_inference_policies.LITERAL for direct array syntax. (#5742)

  • Fix wrapped constructor call stubs for JavaScript, TypeScript, PHP, and Groovy. (#5762)

  • Add Elm’s list_rendering_policy option. The default AUTO keeps formatter-friendly cons syntax for singleton ADT lists; LITERAL uses direct brackets. Both preserve values, types and collection layout. (#5763)

  • Fix missing Rust tagged-enum declarations for calls with separate heterogeneous list arguments. (#5767)

  • Preserve Kotlin native record types in explicitly annotated root reference aliases. (#5772)

  • Kotlin native bound empty arrays retain sibling element types; explicit hints reject unsupported mixed empty/nonempty sibling sequences consistently. (#5773)

  • Mojo VARIANT call stubs use the emitted variant element type for separately supplied heterogeneous list arguments. (#5774)

  • Escape Unicode line and paragraph separators in YAML strings and mapping keys. Raku single-quoted output uses escaped double-quoted literals for CRLF pairs so the source reader preserves both characters. (#5783)

  • Render subnormal floats with compiler-safe Swift, Ada and Nix expressions, continue long Fortran real literals, and reject non-decimal F# bigint literals. (#5785)

  • Wrapped constructor calls declare native constructor stubs in C#, Haxe, Java, Rust, Scala and Visual Basic. (#5793)

  • Bash declares its empty-string mapping-key policy as ERROR, matching the existing formatter rejection.

    PowerShell rejects null hash-table keys, including nested and ordered mappings, instead of emitting invalid source. (#5807)

  • Crystal record fields containing scalar tuples use Tuple field types under the TUPLE sequence format. (#5812)

  • Add Ruby’s opt-in date_formats.RUBY_SHORT for shorter modern Date.new literals. Historical dates retain explicit Gregorian construction. Short modern literals use Ruby’s reform-calendar arithmetic; the default RUBY format continues to preserve Python’s Gregorian arithmetic for every date. (#5860)

  • Fix Scala record output for nested lists with empty siblings so generated record values compile without incorrect map type annotations. (#5878)

  • Fix Wren map literals emitted as bare values in complete files. (#5882)

  • Escape byte order marks in Scheme string literals. (#5884)

  • Fix Java array type annotations for nested heterogeneous sequences and empty siblings. (#6199)

  • Reject incompatible sibling map-value types across Rust tuple fields instead of emitting code that fails to compile. (#6200)

  • Give heterogeneous Scala arrays an explicit common element type when inference cannot provide a usable ClassTag. (#6201)

  • Reject integers outside the signed 64-bit and unsigned 64-bit range when rendering Rust serde_json::Value, including nested values, instead of emitting code that panics at runtime. (#6449)

  • Reuse Fortran’s checked string formatter across string fragments to reduce rendering overhead, including long strings. (#6461)

  • Retain native call-result parameter types in generated Haskell and PureScript helper declarations when a bound result is passed to a follow-up call. (#6472)

  • Fix missing typing imports in eager Python RECORD field annotations, including Python 3.8 collection aliases and empty-collection defaults. (#6571)

  • Preserve seconds and microseconds in Python native datetime UTC offsets. (#6573)

  • Preserve seconds and microseconds in Ruby native datetime UTC offsets. (#6574)

  • Reject fractional UTC offsets that Go native datetime values cannot preserve. (#6575)

  • Retain declaration-only helpers when call preamble reconciliation produces no replacement. (#6581)

  • Validate integer epoch and JavaScript Date precision after applying native UTC offsets. (#6582)

  • Keep Python future imports first when composing independently rendered declarations. (#6583)

  • Retain C++ record declarations and their headers when composing calls without reference hints. (#6584)

  • Copy V datetime epoch references as integers without calling collection clone methods. (#6593)

  • Ada, Fortran and Zig can discard the result of an identity-transformed function call.

  • Add support for Python 3.15.

  • C JSON declarations preserve nested reference bindings by duplicating their cJSON nodes instead of rebuilding their resolved values.

  • C++ output includes headers for the emitted native types and reference transfer helpers, and omits headers needed only by the input structure. C++ fixture linting now rejects missing and unused direct includes.

  • C++ renders deep singleton sequences through independent vector constructors, preserving their native types and values while avoiding repeated traversal of nested initializer lists by compiler tooling.

  • C++ uses type-aware transfer for references without value hints, avoiding ineffective moves of scalar bindings.

  • C, C++, and Objective-C output no longer includes NOLINT comments.

  • COBOL validates its 63-character identifier limit and reserves BEFORE case-insensitively. Perl rejects phase-block names in dotted call targets. Wren rejects keyword member targets and bounds generated stub class names while preserving valid 64-character call targets. Visual Basic escapes keyword call members and rejects bare underscore parameters.

  • Choose literal-reference copy and move operations from actual bound values while retaining explicit reference hints for type inference.

  • Composed calls retain their executable role in Ada and Fortran files.

  • Crystal assigns existing JSON reference values directly instead of parsing their identifier names as JSON text.

  • Crystal native-record fallback maps now include populated and empty set types in their value carrier.

  • Crystal preserves empty tuples inside record fields instead of narrowing them to arrays.

  • Dart explicit type hints now use BigInt for integers outside the signed 64-bit range, matching their generated initializer.

  • Declare Elm and Nim support for call-result bindings with JSON arguments.

  • Declare Visual Basic and F# bound references in each combined-output procedure scope.

  • Dhall wraps epoch datetime call arguments as integers instead of text.

  • Empty lists beside heterogeneous scalar lists now retain the declared Dhall union type, including custom union names.

  • Empty sequences in matching fields of sibling dictionaries use the populated field’s element type. Mojo can compile a list of dictionaries containing both an empty list and a list of integers in that field. Python call stubs infer parameter types when nested empty collections need type context.

  • Enforce runtime return types when language configuration cached properties are first computed.

  • Enforce runtime type annotations on closures returned by language formatters during normal library use.

  • Enforce runtime type annotations on shared formatter closures, parsing helpers, option enums, and string metadata methods during normal library use.

  • Escape bidirectional formatting characters in Haskell JSON literals.

  • F# calls escape keyword member names consistently in call targets and generated declarations.

  • F# preserves caller indentation when placing supporting types beside wrapped reference bindings.

  • Fix C++14 nested heterogeneous sequences with positional empty rows by retaining agreed carrier types and explicitly constructing carrier values in widened sibling rows.

  • Fix F# array sequence values nested inside collections by wrapping them in the matching tagged union constructor.

  • Fix Fortran source-line wrapping for UTF-8 string literals by measuring encoded byte width and preserving character boundaries.

  • Fix PowerShell call formatting after the datetime import alias change.

  • Fix Rust nested vector type inference when one position contains only empty lists and another position supplies the element type.

  • Fix Zig native record fields containing ordered maps with mixed value types by retaining each ordered entry’s concrete type.

  • Fix explicit Java collection annotations to retain inferred native record types inside ordered maps.

  • Fix the declared type of empty Crystal record tuple fields to match their generated tuple literals.

  • Generated reference consumers retain argument metadata for null values, singleton layout counts unresolved references, and mutable Odin and Haxe declarations support complete declaration/assignment fixtures.

  • Give mutable native Zig numeric bindings explicit runtime types so declarations and later assignments compile.

  • Haskell JSON aliases and nested references retain existing JSON values through structural interpolation.

  • Haskell strings escape Unicode code points rejected by GHC. Gleam strings preserve U+FFFE and U+FFFF using UTF-8 decoding, avoiding invalid generated Erlang source.

  • Haskell tagged values construct NaN and infinities as floating-point values before wrapping them, avoiding an unimplemented division operation.

  • Include the destination binding in C JSON helper names so separately rendered declarations can be composed in one scope.

  • Include the vector header when C++ record sequences use vectors with the ARRAY sequence format.

  • Infer Java mapping key annotations from their rendered key types.

  • Infer Python and Swift dictionary key annotations from their rendered types, including mixed, null, and temporal keys.

  • Java bound references use typed static declarations when their result lives at field scope. Reference type hints retain compatible integral-to-floating widening and reject incompatible bound declaration types.

  • Java explicit type hints now retain BigInteger for integers outside the signed 64-bit range and for integer collections promoted to that representation.

  • Keep nested COBOL groups distinct when their level numbers need tighter spacing.

  • Maps inside sibling lists now share integer widths when the surrounding sequence requires one element type, keeping nested V map values compatible without changing their values.

  • Match C++ record sequence variant types to the vector literals emitted in ARRAY mode.

  • Mojo call stubs take ownership of their arguments, preserving explicit transfer semantics with Mojo 1.2.

  • Mojo copies literal references without value hints, avoiding ineffective transfers of scalar bindings.

  • Native integers exceeding the interpreter’s integer conversion limit now consistently raise ExcessiveIntegerDigitsError in JSON-backed output.

  • Nested references preserve native array and JSON value carriers in F#, OCaml, and Crystal. F# JSON nodes can be reused in multiple containers without sharing parent ownership.

  • Preserve Zig JSON reference values in nested containers and call arguments.

  • Preserve empty collections in Kotlin tuple mode and type empty F# anonymous-record fields.

  • Preserve generated record types in Crystal, D, and Zig arrays with empty siblings.

  • Preserve trailing line whitespace with Python’s RAW string format.

  • Publish native Markdown release notes and use the same notes in documentation where available.

  • Record inference now resets the previous document’s type names before checking new shapes. This prevents duplicate C++ record declarations when composing separately rendered values.

  • Replace tabs with spaces in Elm block comments so generated source compiles.

  • Require beartype>=0.23.0 for runtime type checking.

  • Retain Crystal, Nim and V record declarations when composing calls with separately rendered variables.

  • Rust calls only import static-binding helpers when they declare a new binding.

  • Rust infers alias declaration types from resolved values, unwraps lazily initialized reference values, and exercises mutable bound declarations before their values can be moved.

  • Scala call-result declarations and assignments preserve the actual function result when JSON argument formatting is selected, instead of applying literal JSON conversions based on the argument data.

  • Sequence format metadata records when length is part of the native type.

  • Sequences containing references with no value hints no longer infer element types from the reference marker. C++ retains those references’ native element types, and Go uses its unknown-element representation. Rust preserves non-consuming references whose value hints are missing, rather than assuming that their bindings implement Copy. Mojo copies reference arguments with missing value hints so owned containers remain available for reuse, while preserving native null values.

  • Terminate C call-result bindings before trailing line comments while preserving quoted comment markers.

  • Terminate CSharp call-result bindings before trailing line comments while preserving quoted comment markers. Preserve verbatim strings and nested interpolation.

  • Terminate D call-result bindings before trailing line comments while preserving quoted comment markers. Preserve backtick strings.

  • Terminate Dart call-result bindings before trailing line comments while preserving quoted comment markers. Preserve raw strings and nested interpolation.

  • Terminate Haxe call-result bindings before trailing line comments while preserving quoted comment markers. Preserve regex literals and nested interpolation.

  • Terminate ObjectiveC call-result bindings before trailing line comments while preserving quoted comment markers.

  • Terminate SystemVerilog call-result bindings before trailing line comments while preserving quoted comment markers.

  • Terminate Zig call-result bindings before trailing line comments while preserving quoted comment markers.

  • TypeScript infers reference-containing declaration types from bound values instead of reference markers.

  • Unresolved reference aliases avoid unused type imports.

  • Use jsonc-document to parse JSONC input. JSONC parser diagnostic messages and coordinates now come from the new parser.

  • Use pydantic.JsonValue throughout the JSON round-trip scripts to share their recursive payload type.

  • Use generated record types inside heterogeneous Zig tuple fields.

  • Use json5-document to parse JSON5 input. JSON5 parser error messages and coordinates now come from the new parser.

  • V uses a generic helper for unresolved reference values, cloning arrays and maps while retaining scalar and record values without invalid clone calls.

  • Wrapped call stubs infer parameter types from actual bound values when explicit reference hints disagree.

  • Wrapped calls retain helper declarations associated with their call transform. Swift preserves keyword labels on native wrappers, and Nim resolves call-result wrappers to their generated procedure.

  • Zig dotted call stubs use a receiver name that stays distinct from every declared parameter, including self and self_.

  • Zig native-record fields retain their slice representation for empty ordered maps.

  • Zig record fields preserve the anonymous empty value type of bound empty maps.