2026.04.24.1

  • Gleam now emits a pub type GVal declaration containing only the constructors actually needed for the data, rather than always emitting all eight variants. Scalar-only inputs (e.g. GInt(42)) now produce a one-constructor type, bringing Gleam in line with Elm and Haskell.

  • lint-lua in .github/workflows/lint.yml now runs each Lua fixture end-to-end via lua, catching runtime errors (calls to undefined functions, missing module imports, failed assertions) that the existing luac -p parse-only step let through, mirroring lint-bash / lint-javascript / lint-perl etc.

  • literalize_call(..., wrap_in_file=True) now injects a no-op stub for the target_function into the wrapped file, so the generated source compiles against strict checkers on its own. Callers that supply a call_transform are still responsible for providing a definition for the wrapper function the transform introduces.

  • Added literalize_call support for Bash. A new CommandCallStyle tagged-union member renders calls as target arg1 arg2 with space-separated arguments and no surrounding parentheses; with a call_transform like lambda c: f"emit({c})" the inner call is wrapped in $(...) command substitution (emit "$(target arg1 arg2)"). Bash’s format_call_stub emits name() { :; } function stubs that accept any arguments so generated files parse with bash -n and run under bash. A new CallArgNotSupportedError is raised at literalize time when a list, dict, or set is passed as a Bash call argument: Bash has no inline compound-literal syntax in command invocations, so silently emitting cmd (1 2 3) (which parses as a nested (...) child-process group) would leave users with a broken script; callers must declare the collection as a variable and pass a $ref marker instead.

  • literalize_call gains a ref_case keyword argument that converts {"$ref": "name"} identifiers to the target language’s idiomatic case at render time via pyhumps. Pass IdentifierCase.SNAKE, CAMEL, PASCAL, UPPER_SNAKE, or KEBAB to drive one YAML source through multiple languages without re-authoring the ref names (e.g. the same user_obj ref renders as user_obj for Python, userObj for JavaScript, UserObj for Go). Each language exposes the subset it understands via its identifier_cases tuple; passing an unsupported case raises UnsupportedIdentifierCaseError. When ref_case=None (the default) ref names are emitted verbatim, preserving existing behavior.

  • Mojo now supports an opt-in HeterogeneousStrategies.VARIANT that wraps mixed scalars in an auto-generated comptime Value = Variant[...] over only the Mojo types actually present in the data, with a from std.utils.variant import Variant preamble line. Each wrapped scalar renders as Value(...) (with an explicit String(...) or Float64(...) cast when needed to select the intended Variant alternative, and NoneType() for nulls), so heterogeneous dicts and lists become homogeneous in the Variant type. The alias name is configurable via Mojo.heterogeneous_value_variant_name (default "Value"). The default ERROR strategy still raises on heterogeneous input.

  • C generated output now routes positive integers above LLONG_MAX (e.g. 2**63) through a new unsigned long long union field instead of narrowing them into the signed long long field. The CVal union gains a u member alongside i, and a new uint_field constructor argument lets users rename it. clang-tidy’s bugprone-narrowing-conversions and cppcoreguidelines-narrowing-conversions checks, previously suppressed in .clang-tidy because the union-initializer literal silently truncated those values, are now enforced for both C and Cpp output.

  • Cpp generated output now wraps the INFINITY and NAN <cmath> macros in static_cast<double> (with the negation applied outside the cast for -INFINITY) so that brace-init of std::vector<double> does not trip clang-tidy’s narrowing-conversions check on the implicit float-to-double conversion.

  • Erlang now supports literalize_call. Calls use positional argument syntax (f(A, B)); dotted targets like app.client.fetch are emitted as quoted-atom function names ('app.client.fetch'(...)) since Erlang atoms do not allow unquoted dots. Call stubs are emitted as module-level function definitions placed between -export and x(), and x() separates call statements with , terminated by ..

  • Added literalize_call support for Gleam: Gleam.format_call_preamble_stub emits module-level pub fn declarations with fresh type variables per parameter and a panic body, and Gleam.format_call_target flattens dotted targets (e.g. app.client.fetch) to underscored identifiers (app_client_fetch) because Gleam identifiers cannot contain .. Gleam.CallStyles.POSITIONAL renders calls as func(arg1, arg2).

  • ObjectiveC call stubs now emit k-prefixed, title-cased root names for the static const struct globals that back dotted call targets, so a user-written throttler.check(...) is rendered as kThrottler.check(...) (and app.client.fetch to kApp.client.fetch). clang-tidy’s google-objc-global-variable-declaration check, previously suppressed in .clang-tidy because the bare root names did not conform, is now enforced.