2026.04.23

  • Sibling sequences that appear as values of the same dict now widen to a common element type at each matching position, so a caller iterating the dict values tuple-style sees a consistent element type at each positional slot instead of one branch narrowed to a concrete type and another collapsed to the fallback. The widening uses the language’s fallback sequence opener when the inferred types diverge and is skipped for variant-typed languages (e.g. C++) whose fallback opener is element-specific rather than universally accepting.

  • lint-haskell in .github/workflows/lint.yml now passes -Wall -Werror to both the syntax check and the end-to-end build, so warnings such as -Wunused-matches, -Woverlapping-patterns, and -Wtype-defaults fail the job instead of being silently logged. Haskell generated output was updated to compile clean under -Wall: the Num / Fractional instances use _ for unused parameters, the catch-all negate _ clause is now omitted when Val has only numeric constructors, tuple-sequence bindings carry a (Val, Val, ...) annotation, call stubs get explicit type signatures, transform-wrapper stubs use a polymorphic argument type, main binds each call result with _ <-, and the Data.Time import set drops secondsToDiffTime when every datetime has microseconds.

  • Java declarations and reassignments whose value ends in a // line comment now place the terminating ; on the code line rather than on the comment line, where javac previously parsed it as part of the comment and rejected the program with ';' expected.

  • Mojo.skip_null_dict_values is now True so dicts containing null values render as the empty Dict[String, String]() literal (previously they emitted {"k": None, ...}, which the Mojo compiler rejects because NoneType is not a usable dict value type). Mixed-type inputs continue to raise HeterogeneousScalarCollectionError as before; this only affects dicts whose values are entirely null.

  • literalize_call now accepts {"$ref": "name"} markers at argument positions, emitting name as a bare identifier instead of formatting the value as a literal. Refs and literals can be mixed in the same call, and the marker is detected across all four input formats (JSON, JSON5, YAML, TOML). Ref dicts are excluded from data-shape validation and data-driven preamble inference so they do not drag in imports for the {str: str} shape of the marker itself.

  • lint-objectivec in .github/workflows/lint.yml now passes -Werror to both clang -fsyntax-only and the end-to-end clang compile step so warnings such as -Wimplicitly-unsigned-literal fail the job instead of being silently logged. ObjectiveC.format_integer now appends a ULL suffix to values above LLONG_MAX (matching the C fallback) and raises UnrepresentableIntegerError for values below LLONG_MIN, so emitted fixtures compile cleanly under the stricter workflow.

  • Added Nim.HeterogeneousStrategies with an OBJECT_VARIANT option that auto-generates a Nim object variant in the preamble whenever a dict, list, or sibling-list pair contains scalar values of more than one Nim type. Each heterogeneous value is wrapped at the call site as {VariantName}(kind: vkX, xVal: value); only the branches actually present in the data are emitted. The strategy switches the dict syntax from %* {key: value} to {key: value}.toTable (importing tables instead of json) so the object variants can be stored directly, and nested sequences render as @[...] at every level. The variant-type name defaults to Value and is configurable via the new heterogeneous_value_variant_name constructor argument. OBJECT_VARIANT is incompatible with DeclarationStyles.CONST because .toTable and @[] are runtime constructors; the constructor raises IncompatibleFormatsError for that combination. The default remains HeterogeneousStrategies.ERROR (unchanged behavior).

  • The heterogeneous_strategy variant case list now includes the ordered_map fixture, covering Rust TAGGED_ENUM and Dhall UNION_TYPE rendering on !!omap inputs.

  • lint-swift in .github/workflows/lint.yml now runs its swiftc -typecheck step in parallel via xargs -P, replacing the previous serial while loop so the job no longer cold-starts the compiler one fixture at a time.

  • lint-swift in .github/workflows/lint.yml now runs each Swift fixture end-to-end via swift in script mode, catching runtime errors that swiftc -typecheck alone could miss (for example, integer literals that overflow Int). So that every emitted fixture compiles, Swift.format_integer now raises UnrepresentableIntegerError for values outside the signed 64-bit range, matching the behavior of other languages without native arbitrary-precision integer support.

  • lint-groovy in .github/workflows/lint.yml now runs each Groovy fixture end-to-end, catching runtime errors (calls to undefined functions, missing module imports, failed assertions) that the existing groovyc compile-only step let through. Groovy.format_call_stub now emits a single Map _args method parameter when call_style is KEYWORD. Previously the call_keyword_args fixture tripped MissingMethodException because Groovy passes named arguments as a single LinkedHashMap that a positional parameter list rejects. POSITIONAL stubs keep the concrete parameter list unchanged.

  • lint-objectivec now executes each fixture end-to-end instead of only syntax-checking it, mirroring lint-bash / lint-javascript / lint-perl etc. To make this possible, Objective-C declarations and reassignments now box primitive scalars the same way collection entries do (id x = 42; → id x = @(42);), single-name call stubs emit a static definition so fixtures link, and ObjectiveC.supports_scalar_inline_comments is now False. Previously the trailing // comment swallowed the statement terminator. A pre-existing casing bug in the workflow’s lang_patterns (objective_c*.m instead of ObjectiveC*.m) that silently skipped every fixture is also fixed.

  • lint-elm in .github/workflows/lint.yml now runs each Elm fixture end-to-end. A new Run Elm files step compiles each fixture alongside a small Main.elm wrapper whose Platform.worker init forces Check.my_data, emits JavaScript via elm make, and executes it with Node so runtime crashes such as Debug.todo surface in CI. The scalar_int_very_negative_large fixture is skipped because the Elm 0.19.1 code generator emits --<digits> (two unary minuses) for integers at the int64 boundary, which JavaScript rejects as a prefix-decrement syntax error.

  • lint-sml in .github/workflows/lint.yml now runs each Standard ML fixture end-to-end. Because MLton never evaluates a structure’s body unless a top-level expression forces it, the new step compiles each fixture via an ML Basis file that concatenates the fixture with a small val _ = Check.my_data snippet and runs the resulting binary, catching runtime errors such as references to undefined names, missing module imports, or failed assertions.

  • Removed the K&R-style empty-prototype suppression directives from C and Objective-C call stubs. C.format_call_preamble_stub and ObjectiveC.format_call_preamble_stub now emit concrete prototypes (CVal parameters for C, id parameters for Objective-C) sized to the call’s parameter list, and an internal format_call_arg hook wraps each call argument so the call site matches the prototype. Generated C and Objective-C call code now compiles cleanly under -Wstrict-prototypes -Wdeprecated-non-prototype -Werror without suppression.

  • C++ container types now pick the narrowest integer type that holds the actual values in each collection: int when every value fits in 32 bits, otherwise long long. This mirrors the existing per-value suffix logic in Rust and fixes a case where std::variant<int, …> could not hold literals above INT_MAX. Cpp.NumericLiteralSuffixes.AUTO still emits long + L suffix for every integer.

  • Added Dhall.HeterogeneousStrategies with a UNION_TYPE option that auto-generates a Dhall union type in the preamble whenever a dict, list, or sibling-list pair contains scalar values of more than one Dhall type. Each heterogeneous value is wrapped at the call site as {UnionName}.{Variant} payload; only the variants actually present in the data are emitted. The union name defaults to Value and is configurable via the new heterogeneous_value_union_name constructor argument. The default remains HeterogeneousStrategies.ERROR (unchanged behavior).

  • Added literalize_call support for Clojure: Clojure.format_call_stub emits defn stubs with [& _args] so generated definitions accept any mix of positional and keyword arguments, and Clojure.CallStyles.PREFIX_KEYWORD renders calls as (func :name value).

  • Added literalize_call support for Objective-C: ObjectiveC.format_call_preamble_stub emits C-style forward declarations and nested struct chains with function-pointer leaves for dotted targets, and ObjectiveC.CallStyles.POSITIONAL renders calls as func(arg1, arg2).

  • Added literalize_call support for Perl: Perl.format_call_stub emits an empty sub {} declaration for each dot-separated part of the target name, so call expressions (including dotted targets, where . is Perl’s string concatenation operator) compile cleanly under perl -c.