# Changelog ## 1.0.0-rc.19 - 2026-10-26 ### Added - What std's methods return is known wherever the receiver's own type parameters decide it: `name.as_ref()` on an `&Option` is an `Option<&String>`, and `list.first()` an `Option<&T>` of its items. `Type.substitute/2` binds a type's parameters. - A list literal whose items share a type is a list of that type. ### Fixed - `Enum.at` on a pipeline stage is the iterator's `nth`, collecting no list. - A filter over copied tuples matches each by reference, as `|&(set, field)|`. - `Enum.count`, `length`, and `byte_size` stay `usize` where one is expected. - A function a `defrustmacro` defines can name the module's own types in its spec, as a `defrust` can. - A fallible call used as the receiver of a method its result lacks, as `decoder.read_bool().encode(env)`, propagates its error first. - A loop over a slice, or a list behind a reference, reads each item by reference, so passing one on where a reference is expected borrows it once. ## 1.0.0-rc.18 - 2026-10-26 ### Added - A pipeline of `Enum` stages runs as one Rust iterator chain: `list |> Enum.map(f) |> Enum.find(p)` is `.map(f).find(p)`, with no list collected between them, and `Enum.count/1` on a stage counts as it goes. - `mix rustq.std` also derives what std's methods on strings, characters, lists, maps, sets, and options return where the receiver's type parameters do not matter, so `name.len()` is a `usize` and `name.trim()` a `&str`. - A comprehension's type is the list, map, or set it collects its body's values into, and a block of expressions lowers wherever an expression does. ### Changed - Whether a value may be taken is decided for each use of it: a pass over the body records what is still in use after every variable occurrence, as Elixir scopes it, so a list used again later in the same expression, as `{Map.put(scores, name, 1), scores}`, is copied. A parameter is `mut` where the lowered Rust changes it in place. - `Map.new`, `MapSet.new`, `Enum.into` into an empty collection, `group_by`, `uniq`, and generators over `Enum.with_index` are rewritten into other Rusty-Elixir before lowering, by `RustQ.Meta.Desugar`. - Pattern, comprehension, path, and mutability lowering are their own modules beside `RustQ.Meta.Lower`. - Each Elixir module's lowering implements `RustQ.Meta.Lower.Stdlib.Lowering`, whose `use` imports the helpers they share, and a call goes to the lowering named after its module. Lowering builds Rust with `RustQ.Rust.AST.Builder`, whose `expr/1` now accepts every RustQ AST node. ## 1.0.0-rc.17 - 2026-10-25 ### Added - A module's `defrustmod` mappings come with it under the alias naming it, and `defrustmod __MODULE__, as: [...]` maps the module itself, so a library maps the Rust modules its generated code defines once for every module using it. - `MapSet` lowers on `HashSet`s, `MapSet.t(item)` is a `HashSet`, and `Map` lowers on `HashMap`s as well as structs: `get`, `fetch!`, `has_key?`, `put`, `delete`, `merge`, `update/4`, `keys`, `values`, `to_list`, and `new`, and `MapSet.new`, `put`, `delete`, `member?`, `union`, `difference`, `intersection`, `subset?`, `disjoint?`, `size`, and `to_list`. Updates take the collection only at its last use. - `Enum.into`, `group_by`, `with_index`, `find_index`, `find_value`, `reduce_while`, `sort_by`, `max_by`, `min_by`, `max`, `min` (with an empty fallback), `uniq`, `uniq_by`, `dedup`, `split_with`, `at`, `slice`, `take_while`, `drop_while`, `zip_with`, `chunk_every`, `join`, and `map_join`. A comprehension over `Enum.with_index(list)` enumerates the list in place, and `into: HashMap.new()` or `MapSet.new()` collects into that collection where no type is expected. - Rebinding a list, map, or set to its update, as `scores = Map.put(scores, name, 1)` or `layers = Enum.sort_by(layers, ...)`, changes it in place: `scores.insert(name, 1);`. - A comprehension generator over one value, as `{:some, id} <- [record_id(record)]`, matches the value beside the item instead of iterating a list made for it. ### Changed - `Enum` functions take an owned list only at its last use. A list used afterwards, by the call's closure, or by a value built from it is borrowed, so code using the list again compiles. Questions such as `any?` and `all?` always borrow, items kept from a borrowed list are cloned, and numbers and atoms are copied out. - A new value such as `HashSet.new()` passed where a reference is expected is borrowed. - A list reached through a reference, as `binding.superseded` for a borrowed `binding`, is never taken: `Enum` borrows it and a comprehension copies its items, as a comprehension also does for an owned list still in use. - `Enum.filter/2`, `reject/2`, `find`, and `count/2` lower to Rust's `filter` and `find`, as clippy prefers to `filter_map` returning the item; a number or atom item is matched as `|&value|`. `Enum` iterates slices with `iter()`. `RustQ.Rust.AST.PatRef` renders `&pattern`. ## 1.0.0-rc.16 - 2026-10-25 ### Added - A RustQ module provides the `.rs` file named as its own file is in `templates/` beside it, such as `templates/runtime.rs` for `runtime.ex`: Rust it emits as it is, like a runtime a library ships. Its functions, methods, and types join the module's exports, each type as an Elixir type, and `__rustq_items__/0` and `__rustq_source__/0` emit it. `use RustQ.Meta, provides: [...]` names other files, relative to the module's file. A library no longer needs to publish where its Rust files are. - A RustQ module named through `alias` in a spec, a type, or a `defrust` body is imported as `callable_modules` imports one, and calling its Rust function as `Module.function(...)` lowers to the function's call. Other aliases remain Rust paths. ## 1.0.0-rc.15 - 2026-10-24 ### Added - `match?(pattern, value)` lowers to a `match` answering whether the value matches, so `defrust` bodies need not spell it as a `case` returning `true` and `false`. ## 1.0.0-rc.14 - 2026-10-23 ### Added - `RustQ.Meta.AST.macro_call!/3` takes RustQ AST for `:expr` and `:ty` captures and renders it, so a generator need not write Rust source strings for them. ### Changed - `use RustQ.Meta, rust_sources: ...` evaluates its paths when the module compiles, so they can come from a module attribute or a function, such as one returning the path of a Rust source a library ships. Relative paths are still relative to the working directory, which a library loaded from another project cannot rely on. - `defrustmacro` repetition rows separate their captures with commas, in the pattern and in the calls `RustQ.Meta.AST.macro_call!/3` builds, for every row. RustQ used to lay out a few row shapes, written for kiwi_codec, with `=>` and `:`, and fall back to spaces otherwise, which `expr` captures cannot be followed by. - `RustQ.Rustler.Term`'s struct helpers no longer name rustler's raw term type, which rustler 0.39 changed from `rustler::wrapper::NIF_TERM` to `rustler::sys::ErlNifTerm`. `cached_struct_keys` caches `Atom`s, `default_struct_values` returns `Vec`, and `make_struct_from_nif_term_arrays` is `make_struct_from_arrays`, taking atom keys and term values. The same Rust builds on rustler 0.37 to 0.39. - `RustQ.Native` crates depend on rustler 0.39 by default, and `mix rustq.templates.check` and the suite's generated-Rust check build against it. ### Removed - `RustQ.Rustler.Nif.raw_term_builders/1`. Its helpers called `rustler::wrapper`, which rustler 0.39 removed; `RustQ.Rustler.Term.builders/1` builds the same maps and structs from terms. ### Fixed - `assign!(index(values, i), call())` propagates a fallible call with `?` when the element type is known, as a `let` with a known type does, and makes an owned `values` argument `mut`. The Rust assigned the `Result` and changed an immutable argument. - A `defrust` inside an item `defrustmacro` keeps its plain arguments plain. Every argument used to be written as a macro variable, `$offset`, which the body then referred to as `offset`. - Calling a function a `defrustmacro` names with an `:ident` capture calls `$inner(...)` rather than a function literally named `inner`. ## 1.0.0-rc.13 - 2026-10-23 ### Added - A type declared twice in a module is a `:duplicate_type` diagnostic naming both lines. RustQ reads types before Elixir rejects the duplicate, and used to follow the later declaration silently; types read from source with `RustQ.Spec` were never checked at all. - `RustQ.Spec.declarations/1` takes declarations' lines from `quote location: :keep` as well as from parsed source. ### Changed - A typespec RustQ has no Rust type for, such as `pid()`, `keyword()`, `map()`, a bare `nil`, or a literal `1` or `1..10`, is an `:unsupported_type` diagnostic suggesting a `RustQ.Type` spelling. It used to become a Rust type named after it, which never compiled. `any()` is `Term`, as `term()` is. - `byte()` is `u8`, `non_neg_integer()` and `pos_integer()` are `u64`, and `char()` is `u32`, since it includes surrogate code points Rust's `char` cannot hold. `pos_integer()` admits zero, and rustler's `u8` decoder truncates out-of-range integers rather than rejecting them. - Which words are Rust keywords, written as raw identifiers, comes from syn rather than a list kept in RustQ, in the native and the text renderer alike. ### Fixed - A function returning `R.nif_result(t)` returns a plain value as `Ok(value)`, as the NIF returns that value in Elixir. Its Rust returned the bare value, which did not compile; a plain value returned where an `R.result` is expected is now a diagnostic asking for `{:ok, value}`. - A tail `decode_as!` in such a function is its `decode`, without the `?` that made it not compile. - `:ok` returned where an atom is expected is the atom, and `Ok(())` for any result carrying nothing; it used to be `()` wherever the type was not `NifResult<()>`. - `{:some, value}` and `:none` where an option is expected are `Some(value)` and `None`, as patterns read them; `{:some, 12.0}` used to be a tuple. - A function returning a variable typed as a 3-tuple returned the variable's Elixir AST as a tuple of atoms. - `true` and `false` render as raw identifiers wherever a name goes, and `macro_rules!` names and grouped `use` names are escaped as other names are. - Rendering a node on its own escapes keywords in variables, fields, methods, closure arguments, patterns, and atom names, as rendering it inside an item does. - A name Rust cannot use as an identifier, such as a field named `self`, is a diagnostic carrying syn's message. It used to render invalid Rust, fail with "argument error", or crash the native renderer. - Rendered Rust is checked to parse before it is returned. - `RustQ.Rust.AST.Builder.expr(true)` builds the literal, not a variable named `true`. - A `RustQ.Native` crate using `%{key => value}` or `HashMap.t` in a NIF compiles; it imports `HashMap`. - A public `R.enum` type crosses the NIF boundary as Elixir writes it, as `{:circle, 1.0}` or `:empty`, through `rustler::NifTaggedEnum`. It had no codec, so a NIF taking or returning one did not compile. - A `defnif` whose spec returns `binary()` returns an Elixir binary. Its bytes are a `Vec` in Rust, which rustler sends as a list, so the NIF now wraps a `*_rustq_binary_impl` function and copies its bytes into a new binary. A `binary()` nested in an argument or result still crosses as a list of bytes. - `gen`, which the 2024 edition reserves, renders as a raw identifier. - A path segment named `try`, or a variable named `break`, `continue`, `return`, or `yield`, renders raw. It used to render as the keyword, which parses but does not name the variable. ## 1.0.0-rc.12 - 2026-10-22 ### Added - Lower comprehensions with several generators, filters, and patterns that can fail to match. As a value, a comprehension becomes an iterator pipeline that collects into the expected type, so `into:` works by the target type; run for its effects, it becomes nested `for` loops with `if let` and `if`. - Lower `&fun/1` captures in any expression, not only inside `Enum` calls, and `&(&1 + 1)` shorthand to a closure, including as an `Enum` mapper. - Lower `container[key]` to Rust indexing, borrowing the key for a map, also through a reference to one. - A spec's `%{key => value}` with one key type is a `HashMap`, as `HashMap.t(key, value)` is. - Match constants such as `Kind.PLAIN` in patterns, resolved through the module's Rust module aliases, and `true` or `false` in `with` clauses. - Add `R.ref/2` and `R.mut_ref/2` for references with a named lifetime, as in `R.ref(Record.t(), R.lifetime(:a))`, which a function returning a reference borrowed from one of several reference arguments needs. - Add `R.hashable(type)` for a declared struct or enum that also derives `PartialEq`, `Eq`, and `Hash`, so it can key a map or set. - Build and match `R.enum` values with tagged tuples, as in Elixir: `{:float, value}` is `Literal::Float(value)` and `:missing` is `Literal::Missing` wherever the enum is expected or matched, including through a reference and inside a type that refers to itself. - Generate Rust-only types from `@typep`: the struct, enum, or alias without the term decoder a `@type` gets, so it may hold values without a term codec. - Lower `%{value | field: new}` on a struct to Rust's struct update syntax, `Struct { field: new, ..value }`, including on the items a comprehension or `Enum` function's closure is given; a struct a closure captures is cloned. - Closures that a comprehension or `Enum.map`, `flat_map`, `each`, `reduce`, `any?`, or `all?` gives a typed list's items know their type. - A later generator over a list from outside the comprehension copies its items, so `for x <- xs, y <- ys` compiles without cloning `ys` by hand. - Add `R.slice(type, R.lifetime(:a))` for a slice with a named lifetime. - An atom where an atom-union type such as `:small | :large` is expected names the enum variant, as patterns already did, including fields of a `struct_literal` whose struct the module declares. - A module may use the types its `callable_modules` declare, written remotely as `Other.tree()` since Elixir checks local types; they keep their single Rust declaration in the module that declares them. - `RustQ.Syn` describes traits, as `RustQ.Syn.Trait` with their associated types and methods, and `RustQ.Syn.Index.traits/1` lists them. Impls carry their type parameters' trait bounds and the associated types they define; methods carry their attributes and type parameters' bounds. Impls also carry their trait's structured path as `trait_ast`, and `negative` marks `impl !Trait`. `RustQ.Syn.parse(source, unstable: true)` reads source that uses unstable syntax which does not change an item's signature, as the Rust standard library does. ### Changed - Which std methods mutate their receiver, return an iterator or an option, belong to `Option` and `Result`, or belong to std collections is derived from the Rust standard library's source rather than listed by hand, so lowering knows every stable method, such as `push_back`, `retain_mut`, or `nth`. - A callable's arguments are `RustQ.Binding.Callable.Arg` structs rather than bare maps with the same keys. - Piping into a function the module can call passes the value as its first argument, as in Elixir. It used to call a method of that name on the value. - An Elixir predicate such as `live?` names the Rust function `live`; a module defining both is rejected. - Document every module and function that was hidden from the API reference. Lowering, code generation, native build, and tooling internals are grouped as such, and the user-facing groups list only user-facing modules. - Stub modules `RustQ.Rustler.Nif` generates carry a moduledoc, so checked-in generated stubs need regenerating. - The API reference leaves out the tools in `dev/` for working on RustQ itself, which the package does not ship. ### Fixed - Elements of a tuple pattern are full patterns, so `{{:some, Kind.PLAIN}, _}` matches the constant inside the option. - A pipe into a name the module does not define lowers as that method call, with the same argument types and borrows; a `let` bound to a `collect()` states what it collects into, a `Vec` unless known. - A binding used through option methods such as `is_some` keeps its option type, a vector's items are not taken for its success type, and methods every collection has, such as `is_empty`, no longer type a binding as whichever source type also defines them. `clone` of a borrowed struct and `to_vec` are typed. - `ok(value)` lowers the value as the expected success type, so `ok(:ok)` is `Ok(())`; tuple literals are typed when their elements are, so atom and constant patterns match inside them. - Mark `mut` a tuple-destructured binding that changes, and an owned argument changed through a field or borrowed with `mut_ref`. A field named like a changing method, such as `layer.swap`, does not mark its struct `mut`. - Pushing a call that fails as the function does onto a vector of unknown items propagates it; collecting where a slice is expected collects into a vector and borrows it; an option or result binding nothing downstream unwraps keeps its type. - Write the Rust Clippy expects: a comprehension over `values.iter()` does not call `into_iter()` again, one that clones each item is `cloned()`, `into_iter()` on a borrowed collection is `iter()`, and a statement `case` whose other branch does nothing is an `if let`. - A closure `Option::map` or `and_then` takes lowers its body as the expected option's value, so tagged tuples and atoms inside it name variants; an option a closure maps, items collected, or an iterator's `next` is not wrapped in a second `Some`. `or`, `or_else`, `as_slice` are typed. - Patterns in `with`, inside `{:some, _}`, and on slices take the type of what they match, and a list pattern on a value of unknown type is a slice pattern. - Inference reads a struct literal's fields as the types the struct declares, ignores uses after a pattern binds the same name again, and a comprehension ignores item variables its body does not use. - A failed native render names atoms matched inside patterns no type resolved. - A borrowed number, boolean, or tuple of them passed where the value is expected is copied out with `*`, and arithmetic on borrowed numbers is typed as a number; `ref(value)` is typed as a reference, and `try_fold` in an option-returning position is not wrapped in `Some`. - A comprehension whose collection type is known lowers its body as the item type, so tagged tuples and atoms in it name variants, and `extend` on a vector takes items of its type. - A `with` run for its effects whose `else` does nothing lowers to nested `if let`s, with `true <- condition` as an `if`; variables a slice pattern binds are typed as references to its elements. - Keep the grouping of nested operators: `a and (b or c)` rendered as `a && b || c`, and `not (a or b)` as `!a || b`. Operands are parenthesized by Rust's precedence. - A `cond` run for its effects lowers to `if` statements, and a comprehension bound in a statement states what it collects into, a `Vec` unless known. - An explicitly borrowed argument is not borrowed again, and a method that changes its receiver marks it `mut` wherever it is called. - Render words Rust reserves for future use, such as `override` and `yield`, as raw identifiers, including function and closure arguments and local calls. - Compare two options or results without propagating either side, never propagate literals, and type arithmetic on a propagated option as its value, so `some(value + 1)` no longer wraps the sum in a second `?`. - Parenthesize a `?` applied to a compound expression; it used to bind only to the last operand. - Mark a variable `mut` when a statement-level method chain starting with a method that changes it, such as `map.entry(key).or_default().push(value)`, uses it, and a closure argument its body changes, such as a fold accumulator. An empty map or set bound with a known type states it, as Rust cannot infer its value type through `entry(key).or_default()`. - Lower a `with` whose `else` is a lone catch-all to that fallback arm, rather than a single-arm match on the unmatched value, and a borrowed list literal to a borrowed array rather than a vector built for the borrow. - Patterns of unknown type drop the old types of the names they rebind, and a `with` clause takes the type of a plain variable it matches, so a rebound value is no longer propagated as the option it came from. - A `with` without `else` passes an unmatched `{:error, _}` or `nil` on as the function's own `Err` or `None`, as Elixir returns the unmatched value. - Never propagate with `?` in a function or closure returning a plain value such as a vector; the value stays wrapped there. - Type `get` on maps and on borrowed vectors, `and_then`, `copied`, `cloned`, and methods reached through a pipe, so an option they return is no longer wrapped in a second `Some`. - A function returning nothing runs its last expression as a statement, so a trailing `if` or `for` no longer becomes a value such as a collected vector. - `ref([])` where a slice is expected borrows an empty array. - A type that refers to itself, such as a tree whose children are trees, names its Rust type in its own fields. - Mark an owned argument `mut` for any method that changes it in place, such as `retain` or `sort`, not only `push` and `insert`. ## 1.0.0-rc.11 - 2026-09-30 ### Added - Describe enum variant payloads in `RustQ.Syn.Enum.variant_shapes`, a list of `RustQ.Syn.Variant` structs with the variant name, its kind (`:unit`, `:tuple`, or `:named`), its fields, and its doc comments. `variants` still lists variant names. - Report `lifetimes` and `type_parameters` for `RustQ.Syn.Struct` and `RustQ.Syn.Enum`, matching the existing function and method metadata. - Add `RustQ.Rustler.Term.encoders_from_source/3` and `encoder_atoms_from_source/3`, which build `Term` encoder functions and their atom declarations for structs and enums read from Rust source. They support types owned by another crate and without `serde`. Any reachable type that is not indexed, a wrapper, a scalar, or mapped as external fails generation with a list of the unmapped types, as does a variant tag that would replace a payload field with the same key. Per-type policy covers excluded fields, key and variant renames, `with:` helpers, and `transparent: true` structs. - Add `RustQ.Syn.Index.structs/1`, `struct/2`, and `struct!/2`. - Add `RustQ.Rust.AST.PatternBuilder.tuple/1`. ### Fixed - Render Rust keywords used as field names, struct literal and struct pattern fields, and macro item arguments as raw identifiers (`r#type`). Field access such as `value.type` previously failed to render. - Type a literal atom such as `:if_node` in a typespec as `Atom`, like a union of atoms. It was emitted as a Rust type named after the atom, which does not compile. ## 1.0.0-rc.10 - 2026-09-28 ### Fixed - Resolve local type alias references regardless of declaration order. An alias referenced inside a list, tuple, or map value from an alias that sorts before it, such as `[plugin()]` in `lint_input`, was emitted as the raw Elixir name (`Vec`) instead of its Rust type (`Vec`). - Stop passing `fast_path:` to JSONCodec, which json_codec 0.3 deprecates, so RustQ compiles without warnings on json_codec 0.1 through 0.3. ## 1.0.0-rc.9 - 2026-09-06 ### Added - Support named fields and attributes on Rust enum variants, and attributes on match arms, enabling feature-gated event declarations and dispatch. - Add explicit move captures with `move(fn ... end)`, tuple-pattern closure parameters, and structural closure arguments with optional Rust types. - Add `R.impl` for native callable types using ordinary Elixir function signatures, with `:fn`, `:fn_mut`, and `:fn_once` kinds, additional traits, and explicit lifetime bounds. - Preserve foreign callable-trait parameter and return types, and specialize supported generic method arguments from known receiver and argument types. - Expand supported source-defined Rust type aliases for receiver inference, including generic aliases and grouped imports. Resolve known standard-library shared pointers, mutex lock results, and guard receivers without guessing from unrelated method names. ### Fixed - Render matching struct-field bindings in shorthand form for Clippy-clean generated patterns while preserving explicit renamed bindings. - Reject enum variants that mix tuple and named fields. - Preserve reference and unary-expression precedence in method receivers. - Infer borrows for dereferenced values and supported `String` and `Vec` clone results, including expressions derived from typed callback parameters. - Keep closure parameter types scoped to the callback instead of inheriting shadowed outer-variable types. - Omit redundant unit returns, use struct-expression field shorthand, and simplify supported ignored-error result matches for Clippy-clean output. - Avoid unnecessary mutable bindings for local references while preserving explicit mutation requirements. - Respect generic-parameter shadowing during alias expansion, refresh aliases after source edits, and diagnose conflicting generic substitutions. - Reject unsupported lifetime-alias expansion and inconsistent specialization of opaque foreign trait bounds rather than silently changing their meaning. Defer unsupported nested or ambiguous alias diagnostics until expansion requests them. ## 1.0.0-rc.8 - 2026-09-06 ### Added - Add `@cfg` for conditional Rust helper, method, and NIF implementations with shared signatures and separate clause groups. - Support nested attribute metadata, including `not`, `all`, and `any` predicates, with typed path, name/value, and list representations. - Select conditional functions with `RustQ.Meta.AST.function!/3` and a `:cfg` option. ### Changed - Reject ambiguous function selectors instead of choosing the first conditional implementation. - Diagnose stacked or dangling conditions, duplicate conditions, mixed unconditional/conditional definitions, and inconsistent NIF scheduling policies. ### Fixed - Preserve authored receiver names and lexical shadowing in `defrustimpl` methods through a local binding to the Rust receiver. - Gate generated NIF result codecs and implementation helpers consistently with their conditional entrypoints while retaining one Elixir export. ## 1.0.0-rc.7 - 2026-09-06 ### Changed - Reject integer operands for `/` with an actionable diagnostic; use explicit floating-point conversion when floating-point division is intended. - Validate generated Cargo dependency names, options, and duplicates, and serialize manifests with a TOML encoder for correct string escaping. ### Fixed - Load generated native libraries correctly on macOS. - Preserve native result types through NIF boundary encoding, recursive calls, composed calls, closures, and named captures; diagnose generated-name conflicts. - Preserve expected result types in `cond` branches and typed `Enum.map` closures. - Resolve local type aliases in decoding expressions and external struct constructor paths consistently with their remote typespecs. - Infer the decoded value type for return-position `.decode()` and optional return types for checked integer arithmetic methods. - Preserve argument evaluation and infer result propagation for shape queries. - Refresh callable metadata after provider recompilation and source changes, including same-size edits with unchanged timestamps. - Render nested conditionals as `else if` where appropriate for Clippy-clean output. ### Security - Update maintainer HTTP dependencies to versions without the reported security advisories and remove unused dependency lock entries. ## v1.0.0-rc.6 - 2026-07-27 - Infer mutable owned Rust arguments from mutating collection method calls and render them directly as `mut` parameters, including metadata-backed mutable receivers and supported `Vec` and set/map insertion methods. ## v1.0.0-rc.5 - 2026-07-27 - Add focused `RustQ.Meta.AST` selectors for generated Rust items, type items, enums, structs, and inherent or trait implementation blocks. ## v1.0.0-rc.4 - 2026-07-27 - Add `defrustimpl` for generating inherent and trait Rust implementation methods directly from typed Rusty-Elixir, including `&self` and `&mut self` receiver inference and implementation visibility, attributes, and lifetimes. ## v1.0.0-rc.3 - 2026-07-17 - Generate optional Rustler term filters with typed `Option::filter` calls for compatibility with Rust 1.97 Clippy. - Highlight fenced Rust examples in generated HexDocs. ## v1.0.0-rc.2 - 2026-07-16 - Add composable `RustQ.Test.rust_source!/1,2` and `nif_exported?/3` helpers that preserve ordinary ExUnit assertions and diffs; reorganize the suite around focused source values, parameterized schema/corpus cases, compiled support fixtures, and ExUnit-managed temporary directories. - Decode precise-capturing `impl Trait + use<'a>` bounds without relying on pre-existing runtime atoms, as exercised by current `skia-safe` metadata. - Funnel compiled `defrust` AST access and internal rendering through the documented `RustQ.Meta.AST` and `RustQ.Rust` boundaries. - Preserve inferred tuple types as structural `RustQ.Rust.AST.TypeTuple` nodes instead of raw rendered type strings. - Preserve imported Rust reference lifetimes and fixed-array lengths, lowering them through structural `TypeRef`, `TypeArray`, and `TypePath` nodes. - Add structural bare-function types with bound lifetimes, unsafe and ABI qualifiers, named input metadata, variadics, and return types. - Preserve ordered Rust path generic arguments and `impl Trait` bounds in Syn metadata, and lower complete bound lists through structural `TypeImplTrait`. - Document `defnif` normal, dirty CPU, and dirty IO scheduler policy and the preferred `@nif schedule: :dirty_cpu | :dirty_io` spelling. - Replace the README reference manual with a focused project overview and move template, AST, splice, metadata, and validation details into a generation guide. - Lower supported remote calls in Elixir pipelines and carry expected collection types through materialized Enum stages, preserving eager semantics while avoiding ambiguous Rust `collect()` inference. ## v1.0.0-rc.1 - 2026-07-16 - Define the RustQ 1.x compatibility contract and ship the policy with the package, HexDocs, and agent skill. - Add `RustQ.Native`, public `defnif`, private `defrustp`, generated Cargo crates, native loading, Cargo dependency metadata, and dirty-scheduler normalization for zero-handwritten-bridge-Rust NIFs. - Derive directional Rustler boundaries for scalars, strings, binaries, tuples, lists, options, tagged results, typed maps, Elixir structs and exceptions, structural unions, unit enums, and explicitly declared resources. - Expand Rusty-Elixir lowering with multiple clauses, recursion, list/map/struct patterns, guards, comprehensions, and structural slice-pattern AST support; normalize semantics-preserving Kernel, Enum, List, typed Map, String, Tuple, and Range calls through focused hidden lowerers with call-specific typing. - Add external/precompiled-crate native preparation through `use RustQ.Native, build: false, load: false`, with public `RustQ.Native.items/1` and implicit `nif_env/0` injection that preserves BEAM arity. - Add packaged `RustQ.Test` ExUnit assertions for focused `defrust` source, `defnif` exports/attributes, and generated Rust validity. - Expose all compiled `defrust` function AST nodes through the documented `RustQ.Meta.AST.functions/1` generator boundary. - Validate documented public APIs, package contents, checked generation, and a formatted, Clippy-clean zero-Rust native crate through structured external consumer fixtures containing no checked-in Rust or Cargo files. ## v0.11.1 - 2026-07-14 - Lower named `Enum.map/2` function captures and multi-statement closure bodies, and dogfood them for generated native AST collection decoders. - Generate Rustler term decoders structurally, including cached struct keys, and add an AST-backed unsafe block for isolated low-level Rustler operations. ## v0.11.0 - 2026-07-13 - Require structural Rust type nodes at the native rendering boundary, normalize builder type inputs, and add structural tuple types. - Support multiple lifetimes on Rust struct AST nodes, hide the internal AST renderer, and remove duplicate simple-item builder delegates. - Validate atom-backed Rust identifiers and avoid callable metadata cache locks during parallel compilation. ## v0.10.0 - 2026-07-10 - Make `RustQ.Rust.AST` the canonical generated-Rust representation, including source-derived NIF wrappers with multiple lifetimes, and remove the duplicate legacy Rust builder model. - Reorganize Rustler generation into focused `Nif`, `Term`, `Atom`, `Opts`, `Resource`, and `Schema` APIs with concise wrapper, function-metadata, stub, and encoder naming. - Simplify generator manifests, template rendering, metadata selection, and file-spec APIs; hide implementation modules and document the public API by responsibility. ## v0.9.11 - 2026-07-10 - Discover Rustler atom references through a configurable Rust module name, including references nested in macro token trees. ## v0.9.10 - 2026-07-10 - Preserve explicit nested `Option` constructors and infer `Option::map(Some)` without adding extra wrappers or propagation. - Add a source-generated optional-string map decoder and emit zero-arity Elixir NIF stubs without parentheses. ## v0.9.9 - 2026-07-10 - Preserve nested wrapper tuple binding types and lexical pre-shadow types so downstream inference does not add propagation to infallible values. ## v0.9.8 - 2026-07-10 - Select map-backed Rust struct items from Rusty-Elixir `@type` metadata with configurable derives, attributes, struct visibility, and field visibility. ## v0.9.7 - 2026-07-10 - Add structural schema field and shorthand-field splices for projection-driven Rust struct declarations and literals. ## v0.9.6 - 2026-07-10 - Generate one Elixir NIF stub module from mixed Rust source metadata and RustQ AST functions, including automatic Rustler `Env` exclusion. ## v0.9.5 - 2026-07-10 - Preserve no-parentheses function-pointer field access in expected-type positions instead of lowering fields named `decode` as generic Rustler method calls. ## v0.9.4 - 2026-07-10 - Add AST-backed Rustler term encoders with nested, conditional, optional, collection, adapter, helper, and fallback field projections. - Add source-derived Rustler NIF wrappers and Elixir fallback stubs so one manifest and the handwritten Rust implementation signatures determine both sides of the boundary. - Discover atom references inside Rust macro token trees and document stable, structural Rustler generation workflows. - Add optional Rustler map decoders and improve option/method result inference. ## v0.9.3 - 2026-07-06 - Infer `Option` author input for expected `Option<&T>` adapter arguments, including fallible `NifResult>` values passed to `impl Into>` Rust methods. - Preserve owned option locals while emitting `.as_ref()` at the eventual call site to avoid borrowing from temporaries. ## v0.9.2 - 2026-07-06 - Improve Rusty-Elixir propagation and borrow inference for fallible option cases, `some(...)`, `unwrap_or`, `decode_as!`, `map_get`, fallible reference access, list/slice arguments, loop bindings, and method arguments. - Improve callable metadata lookup for qualified method receivers and add corpus coverage for `impl Into>` argument propagation. - Refresh README, guide, skill, and module docs around inference-first authoring with less explicit `unwrap!`, `ref`, and `mut_ref` boilerplate. ## v0.9.1 - 2026-07-06 - Improve expected-input inference for callable arguments, including fallible `case` scrutinees, associated calls, and slice/`Vec` borrow adaptation. - Add corpus coverage for semantic `defrustmacro` item calls and recent propagation/borrow inference regressions. ## v0.9.0 - 2026-07-06 This release is a large Rusty-Elixir self-hosting and downstream dogfooding release. It expands structural Rust generation, improves type-driven lowering, and fixes a major compile-time performance regression exposed by Skia dogfood. ### Added - Add Rust type item generation from `@type` aliases, including type aliases, structs, enums, and Rust-only support records that do not force generated Rustler term decoders. - Add `R.enum(...)` for explicit Rust enum type items and fix zero-arity type alias resolution for bare `@type name :: ...` declarations. - Add structural `macro_rules!` AST support and native validation/rendering for macro variables, captures, repetitions, and macro repeat expressions. - Add AST walking utilities for RustQ AST traversal and mutation analysis. - Add golden corpus tooling for Rusty-Elixir lowering, with coverage reporting by category. - Add semantic `enum_variant(Type, :variant, ...)` lowering for constructing Rust enum variants from Rusty-Elixir without token macros. - Add semantic item-producing `defrustmacro` calls and macro item call support. - Add `defrustmacro` support for compact `skip_fields` and sparse struct field descriptor row patterns. - Add idiomatic Clippy lint paths for Rust-facing attributes, such as `@allow Clippy.redundant_field_names` rendering to `#[allow(clippy::redundant_field_names)]`. - Add dev-only RustQ Reach smell checks and dogfood them in strict mode for raw Rust escapes, low-level Rusty-Elixir control flow, trivial `defrust` wrappers, and blockless `defrustmod` aliases. ### Changed - Extend `defrustmacro` with identifier/literal captures, item-generating inner `defrust` bodies, multiple generated item bodies, and `repeat ... do` macro-template repetitions. - Lower calls to known `defrustmacro` helpers as generated Rust macro invocations, and support remote Rust macro calls such as `Debug.trace!(value)`. - Replace ad hoc macro metavariable spacing cleanup with structural macro repeat expression rendering. - Remove the process dictionary from Rusty-Elixir lowering; lowering state is now threaded explicitly through expression, call-argument, alias, array, control-flow, return, and expected-expression lowering. - Make context-aware expression lowering the primary lowering path. - Expand type-driven checking for expected expression positions, including returns, call arguments, struct fields, `case` arms, `if` branches, `with`/`for reduce` bodies, closures, field access, statics, array literals, and option `some(...)` wrappers. - Infer downstream types through value uses such as comparisons, `binary_search_by_key`, receiver method calls, mutable `Vec::push`, option case bindings, option adapters, package free functions, and `Self`-based impl callables. - Import free functions from configured Cargo packages in addition to impl methods. - Resolve `Self` types in impl callable metadata to the concrete impl target. - Keep `__rustq_callables__/0` exports limited to local RustQ callables instead of embedding all external/package callables into every module. External callables are still available during compilation through cached source/package resolution. - Document item-generating `defrustmacro` patterns for compact generated Rust that keeps implementation logic in Rusty-Elixir. - Document when to use ordinary Elixir `defmacro` for authoring-layer reuse versus `defrustmacro` for intentionally reducing generated Rust size. ### Fixed - Parse Rust bare function pointer types structurally through `syn` metadata instead of regexing rendered Rust type strings. - Mark function pointer types as non-decodable where Rustler decoding cannot be derived safely. - Auto-borrow binary-search keys, array literals expected as slices, call arguments, option `some(...)` inners, option adapter inners, external statics, and several downstream value-use patterns. - Avoid applying `?` to `Option` values in `Result`/`NifResult` contexts where Rust does not support that propagation boundary. - Infer external static types and generated static types for auto-borrowing. - Preserve explicit `R.raw(...)` as an escape hatch while using structured `syn` metadata where available. - Fix zero-cost package metadata reuse after Skia dogfood: generated checks that previously ballooned to roughly 75–80 seconds now avoid duplicating thousands of external callables into every module. ## v0.8.3 - 2026-06-28 - Infer propagation for source-backed receiver method calls when the receiver type is known. - Index Rust source callables by normalized receiver target names. - Strengthen metadata guidance for avoiding `unwrap!` when Rust source metadata can be configured. ## v0.8.2 - 2026-06-26 - Add the RustQ agent skill to the Hex package and documentation. - Add guidance for authoring RustQ generators with `defrust`, AST builders, metadata, inference, and explicit escape boundaries. - Document expression-oriented Rusty-Elixir style and recursion/reducer patterns. ## v0.8.1 - 2026-06-25 - Add Rustler fixed struct term helpers for cached keys, default values, and raw `NIF_TERM` map construction. - Use `Atom::from_str` for generated cached atom helpers. - Add missing Rust integer marker types to `RustQ.Type`. ## v0.8.0 - 2026-06-25 - Add semantic control-flow lowering for expression-oriented Rusty-Elixir. - Support macro-generated `case` clauses in `defrust` lowering. ## v0.7.0 - 2026-06-25 - Add `ok_or!(option_expr, error_expr)` as the Rusty-Elixir idiom for explicit `Option` to `Result` propagation boundaries. - Extend type-driven propagation inference with nested Rust module function metadata, downstream receiver-method let inference, `as_slice()` adapters, source-backed `From for B` compatibility for `impl Into`, and associated-type metadata such as `impl IntoIterator`. - Add source-backed callable metadata from Rust source files, Cargo packages, and callable modules. - Dogfood native RustQ AST generation in Rustler atom dispatch, tagged enum, macro item, and native codegen helper paths. - Add structured diagnostics for RustQ configuration, source loading, lowering, and native rendering failures. ## v0.6.0 - 2026-06-19 - Reframe Rusty Elixir as the high-level `defrust` authoring surface. - Add external Rust type specs through ordinary remote types such as `GeneratedOpts.OvalOpts.t(RustQ.Type.lifetime(:a))`. - Add ordinary Elixir macro expansion before `defrust` lowering so reusable Rusty-Elixir body fragments can use `defmacro`, `quote`, and `unquote`. - Lower plural alias calls such as `Atoms.fill()` to snake-case Rust module calls such as `atoms::fill()`. - Demote `RustQ.Meta.quoted` and `RustQ.Type.path` to low-level escape hatches instead of the normal authoring style. - Add small AST reuse bridges for RustQ-owned codegen helpers: `RustQ.Rust.ast_item/1`, `RustQ.Rust.ast_items/1`, and the internal `RustQ.Meta.item(module, name)` / `items(module, names)` / `ast!(module, name)` helpers. - Add Rust AST support for receiver arguments and lifetime-bearing impl blocks, including Rustler shapes such as `impl<'a> rustler::Decoder<'a> for Type` and `fn encode<'a>(&self, env: rustler::Env<'a>) -> rustler::Term<'a>`. - Dogfood Rustler helper generation through `defrust` and RustQ AST builders: term helpers, opts helpers, term builders, cached atoms, atom decoders, tagged enum decoders/encoders, resources, and term decoder shells no longer rely on hand-written helper templates. Explicit raw `NIF_TERM` builders remain the unsafe escape hatch. ## v0.5.1 - 2026-06-15 - Add generic Rust expression builders: - `Rust.call_expr/3` - `Rust.some/1` - `Rust.none/0` - `Rust.tuple/1` - `Rust.cast/2` - `Rust.question/1` - `Rust.ref_expr/2` ## v0.5.0 - 2026-06-15 - Add template includes. - Add composable RustQ splice groups. - Use plain keyword splices for composition. - Add structured include diagnostics. - Add rustfmt option. - Add generic Rust body/control-flow builders: - `Rust.block/1` - `Rust.let_/2` - `Rust.let_mut/2` - `Rust.assign/2` - `Rust.call_stmt/3` - `Rust.return_if/2` - `Rust.if_/3` - `Rust.if_let/4` - `Rust.match_/2` - Document macro token placeholder limitation. ## v0.4.0 - 2026-06-06 - Add generic Rustler builders for atom decoders, atom dispatch functions, and keyword/options helper functions. ## v0.3.0 - 2026-06-06 - Remove the generic Rustler schema field group DSL. Prefer explicit fields in RustQ schemas or project-specific macros for domain shorthand. ## v0.2.2 - 2026-06-03 - Add `RustQ.Rustler.resource_handle/2` for generating a Rustler resource plus a decoder for Elixir-facing resource handle structs/maps. - Add Rustler schema field groups for reusable field sets with `use_fields/1`. - Let Rustler schema nodes override generated Rust type names and Elixir module names with `rust:` and `module:`. ## v0.2.1 - 2026-06-03 - Add `RustQ.Rustler.nif_export/2` and `nif_exports/1` for generating exported Rustler NIF functions that delegate to handwritten implementation functions. ## v0.2.0 - 2026-06-02 - Replace the separate `__expr_`, `__type_`, and `__splice_` placeholder prefixes with one visually distinct `__rq_` placeholder prefix. - Templates now use forms like `__rq_Name`, `__rq_value!()`, `__rq_fields: (),`, and `__rq_items!();`. ## v0.1.2 - 2026-06-02 - Let Rustler schema field types reference schema nodes and tagged enums by schema name, so examples can use `Content` instead of generated Rust names like `ExContent`. ## v0.1.1 - 2026-06-02 - Keep the packaged NIF crate out of parent Cargo workspaces when RustQ is used inside workspace-based projects. ## v0.1.0 - 2026-06-02 Initial release. - Parse, validate, render, bind, and splice Rust templates from Elixir. - `~R` sigil for inline Rust templates. - Rust fragment builders for functions, structs, enums, impls, fields, constants, uses, modules, and type aliases. - Rustler helper generators for atoms, NIFs, resources, option decoders, term helpers, term decoders, NIF structs, tagged enums, cached atoms, safe term builders, and explicit raw `NIF_TERM` builders. - `rustq.exs` manifest DSL plus `mix rustq.gen` for generated file syncing and stale checks. - Rustler schema DSL for generating Rust NIF structs and tagged enums from Elixir schema definitions.