This page tracks Moth's current implementation progress.
It is the source of truth for what the compiler currently supports, partially supports, cleanly rejects, keeps experimental, defers, or treats as outside scope. It is not a full language reference, roadmap, or test manifest.
The compiler and memory design references may describe accepted end-state architecture that has not fully landed. This matrix determines what the compiler supports today.
Use this together with tests/cases/manifest.toml when changing language features.
docs/src/docs/**.docs/roadmap/roadmap.md.docs/compiler-design-overview.md.CONTRIBUTING.md.The supported Alpha target is:
| Status | Meaning |
|---|---|
| Supported | Implemented for the Alpha surface and expected to compile, type check, lower, and run through the JS / HTML pipeline. |
| Partial | A useful subset is implemented, but some sub-surfaces are intentionally deferred, target-gated, or still being shaped before Alpha. |
| Experimental | Present in the repo, but not part of the Alpha stability promise. |
| Deferred | Planned or design-compatible, but not part of the current implemented Alpha surface. |
| Rejected | Not accepted by the compiler today and expected to fail with a structured diagnostic. |
| Outside Scope | Intentionally not planned for Moth's language design. Syntax should be rejected with structured diagnostics when encountered. |
| Coverage | Meaning |
|---|---|
| Broad | Multiple focused cases exist, including success and failure coverage. |
| Targeted | Dedicated coverage exists, but not across all important edges. |
| Thin | Coverage exists indirectly or through only a small number of cases. |
| None | No clear canonical coverage found. |
| Surface | Status | Coverage | Runtime target | Notes |
|---|---|---|---|---|
| Entry-selected module roots and implicit start | Supported | Broad entry-selected start, dependency-sort, normal-file top-level rejection, imported-root suppression, fragment-order, and API-only artifact-filtering coverage. | Frontend / HTML builder | Selected normal modules compile dormant compiler-synthesised start work. Entry assembly activates an entry-selected module's start exactly once. Imported roots expose public interfaces without activating root work. API-only roots remain importable and emit no HTML page artefact. The implicit start function is build-system-owned and not user-importable or callable. |
| Structured diagnostics | Supported | Broad import, config, project-structure, syntax, type, rule, borrow, backend-feature, and warning coverage plus targeted compiler-owned reason and primary/secondary source-remapping assertions. | Frontend | User-facing failures use typed CompilerDiagnostic payloads with stable codes and optional qualified reason keys. Integration expectations consume that identity and fixture-relative source locations without reconstructing payload taxonomy. Infrastructure and invariant failures use CompilerError. Type diagnostics are TypeId-first at semantic boundaries. |
| Variables, assignment, and scoped blocks | Supported | Broad declaration, reassignment, mutability, scope, shadowing, undefined-mutation, block-scope, and diagnostic coverage. | JS / HTML | Mutable writes require mutable places. block: creates a lexical/control-flow scope. Bare labeled scopes are rejected. |
| Control flow | Supported | Broad parser, HIR, integration, dispatcher, branch, loop, break, continue, and match lowering coverage. | JS / HTML | Branch-heavy CFG cases and loop exits remain important regression surfaces. |
| Assertions | Supported | Broad parser, diagnostics, HIR lowering, backend artifact, and integration coverage. | Frontend / HIR / JS / HTML | assert is a statement-only language intrinsic. It is always checked, unrecoverable, and accepts optional string-literal messages. assert(false) is statically terminal. |
| Functions and calls | Partial | Broad declaration, terminality, call validation, named and positional arguments, defaults, parameter passing, external calls, and return coverage. | Frontend / JS / HTML | Named calls and defaulted parameters are supported. Non-unit success-return functions are validated for all-path terminality before HIR. External and compiler-owned builtin calls remain positional-only. Return slots contain types and channels only. The compiler infers freshness and alias effects from validated bodies and calls. Source-authored return-alias syntax has been removed. User-function returns use a raw-value ABI: ordinary returns preserve allocation identity, only explicit copy creates an independent graph. The borrow checker allows rebinding a binding to a fresh value while a returned alias of the old allocation is live. |
| Default arguments and field defaults | Supported | Broad function parameter default, struct field default, named-call default skipping, constructor default skipping, and diagnostics coverage. | Frontend / JS / HTML | Function parameters and struct fields can define defaults with =. Choice payload defaults, choice default variants, and broad default semantics outside function/struct construction remain deferred. |
| Templates and style directives | Supported | Broad template parsing, directive, slot, const/runtime fragment, template control-flow, markdown inline-code, diagnostics, and JS/HTML integration coverage. | HTML / JS | Main Alpha surface. Supported shapes include const and runtime templates, slots/inserts, $children / $fresh routing, markdown/code/raw/html/css/escape directives, template Bool and option branching, template loops, runtime slot applications, import namespace member access in template heads (e.g. namespace-dot-member expressions), and const expansion guards. Full match-style template heads and full CommonMark remain outside the current surface. Templates are represented in an AST-local Template IR (TIR) during parsing, composition, folding, formatting, and HIR handoff preparation; TIR is internal, behaviour-preserving, and does not change template language semantics. Post-TIR performance follow-ups are deferred and tracked in the roadmap. |
Moth template .mtf content assets |
Partial | Targeted compiler-integrated import, synthetic content constant, markdown folding, module-root re-export, direct API, diagnostics, and integration coverage. | HTML builder / frontend | .mtf files are builder-supported source assets that synthesize one private compile-time content #String constant from an implicit $md template body. Nested templates with no explicit directive also default to $md, and any explicit nested directive overrides that default. They import extensionlessly into .moth, can be re-exported through a module root's export: block, and must fully fold. They are not entries, config files, standalone HTML files, or general source handlers. Implementation gap: the current compiler resolves implicit scope collisions through local-over-HTML precedence rather than the accepted no-shadowing collision model. Stage B of the docs language migration plan removes the overwrite path and registers both surfaces through one visible-name registry. |
Plain Markdown .md content assets |
Supported | Broad extensionless import, grouped alias, module-root re-export, parser options, raw HTML, literal links/images, collision, direct-extension, and module-root rejection coverage. | HTML builder / frontend | .md files are plain Markdown content assets that render to HTML at compile time and synthesize one private content #String constant. They do not parse Moth imports, declarations, interpolation, templates, frontmatter, metadata, or same-directory module-root scope. Links/images render literally and are not tracked assets in V1. |
| Builder-supported source file kinds | Partial | Targeted moth template and Markdown source-kind registry, extensionless resolution, unsupported-kind diagnostics, source discovery, and tokenizer/preparation coverage. | Stage 0 / frontend | Builders can declare non-.moth source file kinds that participate in source import discovery and frontend preparation. The HTML builder implements moth template .mtf and plain Markdown .md content assets. |
| Structs, records, and receiver methods | Supported | Broad parser, constructor, default, receiver, cross-file, borrow, and diagnostics coverage. | JS / HTML | Source-authored receiver methods are statically resolved and belong to the same file as their nominal receiver type. External packages do not expose receiver methods. |
| Choices | Supported | Broad declaration, constructor, import, return, assignment, match, payload, JS carrier-shape, and structural equality coverage. | JS / HTML | Unit and record-payload variants are supported. Payload fields are immutable. Payload shorthand, direct payload field access, nested payload patterns, recursive choices, choice defaults, and tagged/default declarations remain deferred or rejected. |
| Pattern matching | Partial | Broad literal, choice-match, payload-capture, relational pattern, guard, exhaustiveness, warning, and diagnostics coverage. | JS / HTML | Literal patterns, choice variants, payload extraction, relational patterns, guards, and else => arms are supported. Wildcard patterns and no-op body placeholders are rejected. Full relational overlap analysis and nested choice payload patterns remain deferred. Implementation gap: the current compiler still accepts some removed general bare-name capture forms and String relational pattern subjects. Accepted design removes general capture from full-match positions and limits relational patterns to Int, Float and Char. Stage B of the docs language migration plan removes the obsolete parser and analysis paths. |
| Collections | Supported | Broad literal, mutation, builtin method, indexing, loop, result, fixed-capacity, AST/HIR, JS helper, and diagnostics coverage. | JS / HTML | Growable {T} and fixed {N T} collections are distinct semantic types. Fixed capacities accept positive literals or bare visible #Int constants. Collection get, set, push, and remove are fallible, and length is infallible. |
| Hash maps | Partial | Broad frontend, HIR, borrow, JS, backend-validation, diagnostics, and integration coverage. | JS / HTML / backend validation for other targets | V1 supports insertion-ordered scalar-keyed maps with {K = V} types, map literals, compiler-owned map members, HIR map operations, borrow validation, and JS runtime lowering. Unsupported key families, const maps, equality, language hashsets, and non-JS lowering details remain deferred or outside scope. Implementation gap: the current compiler may apply value-shape checks that create hidden equality or map-key rules based on string construction origin. Accepted design requires uniform content equality and hashing for every runtime String. Stage B of the docs language migration plan removes the value-shape checks. |
| Results, options, multiple returns, and multi-bind | Partial | Broad option, fallible return, postfix propagation, catch, value-producing block, multi-return, multi-bind, and diagnostic coverage. | JS / HTML | Error!, postfix !, catch, value-producing blocks, and multi-bind are supported. First-class public Result values and result-pattern matching remain deferred. |
| Constants and compile-time folding | Supported | Broad top-level constant, dependency sorting, template folding, numeric folding, const-record, external constant, config, and diagnostics coverage. | Frontend | Top-level compile-time constants such as name #= value must fully fold. Same-file constant evaluation follows source order unless dependency sorting can order top-level declarations. Const records are compile-time field-access-only values. |
| Type aliases | Supported | Broad builtin, imported, collection, option, generic instance, alias-to-alias, remap, and diagnostic coverage. | Frontend | Aliases are transparent and do not create nominal identity. Fully concrete generic aliases are supported. Parameterized aliases remain deferred. |
| Arithmetic, explicit casts, and copy | Partial | Broad arithmetic, precedence, checked numeric, cast parser/AST/HIR/JS, const-folding, explicit copy, and diagnostics coverage. | JS / HTML | Runtime numeric operations lower through checked HIR operations. Explicit cast uses compiler-owned builtin cast policies and evidence. Scalar constructor-style conversions are removed. Const Error materialization, branching const catch handlers, and Wasm cast lowering remain deferred. |
| Float formatting and boundary validation | Supported | Targeted stable formatting, finite-source, external-boundary, HIR statement, JS helper, and validator coverage. | JS / HTML | Moth-owned Float formatting is used for AST folding, runtime template interpolation, and casts. External Float success returns are validated before ordinary Moth code observes them. |
| Type checking and coercion | Supported | Broad type compatibility, contextual promotion, strict expression typing, call argument, return, declaration, and diagnostics coverage. | Frontend | Strict expression typing stays separate from contextual declaration, return, parameter, template/string, and explicit-cast boundaries. |
| Traits | Partial | Broad declaration, conformance, visibility, generic-bound receiver-call, trait-name rejection, core cast trait metadata, incompatibility metadata, public API leak, and diagnostics coverage. | Frontend static semantics | Static trait declarations, explicit same-file nominal conformances, reusable evidence, trait incompatibility metadata, and generic bounds are implemented. Dynamic trait values, trait aliases/composition, associated items, inheritance, generic traits/methods, conditional/specialized conformance, default methods, and standard trait taxonomy remain deferred or outside scope. |
| Strings, coercion and IO/template boundaries | Partial | Broad quoted-escape, string-content coercion and IO/template rejection coverage, plus targeted external StringContent signature coverage. |
Frontend / JS | Quoted strings decode only \\, \", \n, \r and \t. Invalid escapes are rejected by the tokenizer. Template heads and reusable external string-content signatures accept supported string values. Console helpers such as io.line(...) use the same boundary, so complex values must be extracted or interpolated into templates before output. Implementation gap: the current compiler still accepts source String + String and compile-time string-add folding. Accepted design rejects source string concatenation with +; templates remain the canonical concatenation form. Stage B of the docs language migration plan removes the obsolete typing and folding paths. |
| Borrow validation and ownership analysis | Supported | Broad borrow, aliasing, mutable/exclusive access, branch merge, loop, short-circuit, future-use, optional-transfer, advisory drop-site, hashmap, aggregate-storage, reactivity and adversarial coverage. | HIR analysis / JS GC baseline | Borrow validation enforces shared/exclusive access while optional transfer and drop facts remain advisory. Path-dependent or imprecise transfer proof falls back to borrowing, and existing values stored in maps and collections retain shared semantics. GC remains the language baseline representation. Lifetime-region and escape validation remains deferred below. |
| Lifetime-region and escape validation | Deferred | None | Backend-neutral design | Accepted architecture exists; no implementation owner has landed. GC does not bypass the future semantic validation. |
| Declared memory groups (`group` / `into`) | Deferred | None | Frontend / HIR / lifetime analysis / all backends | Accepted end-state syntax; not current source support. Canonical semantics live under `docs/src/docs/codebase/memory-management/declared-memory-groups/`; implementation sequencing in `docs/roadmap/plans/grouped-memory-design.md`. |
| WIT value-only component integration | Deferred | None | Frontend / build / backends | Accepted closed external-boundary profile; no current import validator or runtime integration. |
| Paths and imports | Supported | Broad source import, namespace import, grouped import, binding-backed package, public-surface, module-boundary, collision and project-structure coverage. | Frontend / HTML builder | Source and module namespace records are shallow. External package namespace records support nested symbol paths such as io.input.new and io.input.Input. Direct symbol-path imports remain rejected. Cross-module and source-backed package access goes through the target root's export: public surface. |
| Binding-backed platform packages | Partial | Broad package import, external constant, external signature, provider-created JS package, runtime asset/glue, core package, prelude, and backend validation coverage. | Frontend / JS | Rust-side and provider-created binding-backed packages expose free functions, opaque types and compile-time scalar constants. Project-local and builder-owned annotated .js files can create JS-backed package surfaces. Binding-backed packages do not expose receiver methods. Unsupported reachable calls for an active backend fail before lowering. |
| HTML project builds | Supported | Broad routing, API-only artifact filtering, document shell, metadata, tracked asset, config, output cleanup, external JS glue, and page-fragment coverage. | HTML / JS | This is the release-critical project backend. Only roots with HTML artifact activity participate in page, runtime asset, tracked asset, and homepage planning. HTML-Wasm behavior is tracked under experimental surfaces. |
| Logical expressions | Supported | Broad precedence, grouping, invalid operand, not, comparison, short-circuit, and JS operator mapping coverage. | JS / HTML | Keep short-circuit behavior covered through artifact-shaped tests. |
| If statements and conditions | Supported | Broad condition validation, nested condition, Bool requirement, same-line else-if rejection, and JS lowering coverage. | JS / HTML | Conditions require Bool unless the specific syntax is an option or match-style selector. |
| Char | Supported | Broad success coverage with targeted diagnostic coverage. | JS / HTML | Additional malformed-char diagnostics are cleanup, not a core Alpha blocker. |
| Named arguments and call-site mutability | Supported | Broad function-call, constructor-call, duplicate, unknown, missing, ordering, and tilde diagnostics coverage. | JS / HTML | Fresh rvalues can satisfy mutable parameters without ~. Existing places still require explicit ~. |
| Surface | Status | Coverage | Runtime target | Notes |
|---|---|---|---|---|
| Prelude policy | Supported | Targeted prelude symbol registration, namespace-alias plumbing, and collision rejection coverage. | Frontend / JS | The builtin prelude policy registers io as a namespace alias to @core/io and leaves compiler-owned Error as a bare language symbol. There is no @core/prelude package. |
| Core IO package | Partial | Console helpers, prelude/explicit namespace imports, old callable rejection, removed public IO, input metadata/type-checking, HTML-JS input helper emission, and backend unsupported-call diagnostics. | Frontend / JS / HTML-Wasm validation | @core/io exposes io.print, io.line, io.debug, io.warn, io.error, and io.input.*. The prelude injects io as a compile-time namespace alias, not a runtime value. Deferred IO domains such as filesystem, network, timers, event queues, targeted input sources, and non-JS lowerings belong in the roadmap. |
| Core math package | Supported | Targeted direct, grouped, aliased, namespace, const, arity, type, missing-symbol, and non-imported access coverage. | JS / HTML | @core/math exposes Float math functions and scalar constants. It is explicit-import only. Non-JS support is backend-specific and tracked under experimental surfaces. Implementation gap: the current HTML-JS lowering does not enforce the checked numeric contract for non-finite results from math functions. Accepted design requires non-finite results to be rejected. Stage B or a dedicated numeric plan must add the missing boundary checks. |
| Core text package | Partial | Targeted runtime, JS helper, arity, type-error, edge-case, unsupported-builder, and Wasm-unsupported coverage. | JS / HTML | @core/text exposes string helpers such as length, emptiness, containment, prefix, and suffix checks. Receiver-method forms and non-JS lowerings remain deferred. Implementation gap: the language-level contract defines text.length as counting Unicode scalar values, consistent with Char. The current HTML-JS lowering uses JavaScript UTF-16 code-unit length. Strings containing characters outside the Basic Multilingual Plane report a higher count than the language-level value. Stage B or a dedicated plan must correct the lowering. |
| Core random package | Partial | Targeted import, JS helper, runtime smoke, arity, type-error, and Wasm-unsupported coverage. | JS / HTML | @core/random exposes random Float and inclusive random Int helpers. Seeded random and non-JS lowerings remain deferred. |
| Core time package | Partial | Targeted import, grouped alias, namespace, helper, runtime smoke, fallible parse/catch, arity/type diagnostic, old-name rejection, opaque-field rejection, and backend validation coverage. | JS / HTML | @core/time exposes opaque Duration, TimeMark, and Timestamp values plus the first JS-backed time helper slice. Calendar/time-zone APIs, timers, animation scheduling, and non-JS lowerings remain deferred. |
| Source-backed package roots | Partial | Targeted AST-backed config loading, known-key and shape enforcement, self-contained config import rejection, generic package-root discovery, collision detection and public-surface enforcement coverage. | Frontend / HTML | Source-backed packages and regular modules share module-root and visibility rules. config.moth is compiled as one self-contained source before package discovery and rejects every import before path resolution. |
| Builder-provided source-backed packages | Partial | Targeted builder source-backed package root registration and HTML Builder package coverage. | Frontend / HTML | Builders expose source-backed packages through BuilderSurface.source_packages. The HTML builder provides @html as a source-backed package. Builder and project-local prefix collisions are hard config errors. |
| Project config model | Partial | Targeted flat-config parsing, known-key validation, self-contained import rejection, and builder-section coverage. | Frontend / HTML | The current compiler supports the transitional flat config shape with parsing and validation implemented. Grouped project and builder records are accepted deferred design. #Import, @project and entry-local config: remain separately queued. Legacy package_folders remains current implementation drift. The queued Project Config and recursive schemas plan owns replacement. |
| Project-local packages | Partial | Targeted structural support-package roots, legacy config-defined package folders, import resolution, generic normal module-root, and public-surface coverage. | Frontend / HTML | Structural +*.moth support packages and the optional project-root facade define the accepted package model. The current compiler also retains legacy config-driven package_folders discovery, defaulting to lib/. The queued Project Config migration removes that compatibility path. Each support package's containing directory supplies its name. Stage 0 requires exactly one direct @*.moth or +*.moth root with a non-empty cosmetic name. The filename after @ or + has no semantic role and the root's strict export: block defines its public surface. |
| Builder runtime packages | Partial | Targeted built-in JS-backed package, runtime asset, runtime module, import-map, glue, and backend validation coverage. | HTML / JS | Builder-owned runtime packages such as @web/canvas are binding-backed packages. They share the specialised external package registry and HTML external JS asset/glue pipeline with provider-created imports. |
| Surface | Status | Coverage | Runtime target | Notes |
|---|---|---|---|---|
| Collection methods | Supported | Broad JS helper, fallible get/set/push/remove, infallible length, removed indexed-write, bounds, and mutable-receiver coverage. | JS / HTML | Collection get, set, push, remove, and length are compiler-owned members. Mutating calls require explicit mutable receiver access, and fallible members require ! or catch handling. |
| Error helper methods | Rejected | Public helper-call removal coverage. Hidden JS metadata helper coverage remains backend-internal. | Frontend / JS runtime internal | Public err.bubble(), location, trace, and @core/error helper calls are not exposed. |
| Receiver methods | Supported | Broad same-file struct/choice receiver, aligned generic receiver, imported receiver type, namespace receiver type, module-boundary exposure, nonlocal/builtin/external receiver rejection, duplicate, collision, and mutability coverage. | JS / HTML | Source-authored receiver methods travel with receiver type visibility. They are never grouped-imported, aliased, or exposed as namespace-record fields. |
| Fallible suffix handling | Supported | Broad propagation, shared then catch recovery, catch handler, template-boundary, explicit HIR branch, direct-return, call-argument, receiver-base, match-guard, and obsolete HIR propagation-expression removal coverage. | JS / HTML | Fallible calls lower through explicit success/error HIR control flow. Value-producing catch recovery uses shared value-block result locals. Collection and map fallible members use the same path. |
| Builtin Error type | Supported | Constructor, default-field, named-argument, public field, and backend-generated Error coverage. | Frontend / JS | Public fields are message and code. Hidden location/trace metadata remains backend-internal. |
| Surface | Status | Coverage | Current surface |
|---|---|---|---|
| Reactive declarations and parameters | Partial | Frontend syntax, AST/HIR metadata, borrow invalidation facts, JS lowering, HTML-JS mounting, and unsupported sink/backend diagnostics. | V1 supports $Type / $= local declarations and $T parameters as source metadata, not wrapper TypeIds. Reactive declarations are runtime-local and not importable/exportable top-level declarations. |
| Reactive template subscriptions | Partial | Template-head parsing, source validation, subscription metadata, AST/HIR propagation, reachability, borrow invalidation, JS helper lowering, HTML-JS mounting, and unsupported sink/backend diagnostics. | V1 accepts one bare reactive source identifier in template head/capture positions through $(source). Snapshot reads remain ordinary captures. Field paths, calls, computed expressions, ordinary expression use, and compile-time templates are rejected. |
| HTML-JS reactive runtime fragments | Partial | JS reactive source, scheduler, template-string runtime helper, slot mounting/rerender registration, and unsupported sink coverage. | V1 live sink support is top-level runtime HTML fragments in the HTML-JS builder. Fine-grained DOM updates, nested live regions, keyed diffing, and other UI runtime strategies are deferred. |
| Reactive follow-ups | Deferred | No accepted syntax beyond V1 source subscriptions. | Deferred surfaces include reactive-aware template control flow, field/path subscriptions, collection item subscriptions, expression dependency tracking, derived reactive values, live IO sinks, template-owned event/action/effect syntax, $bind, typed component messages, and HTML-Wasm reactive runtime support. |
| Surface | Status | Current role | Alpha rule |
|---|---|---|---|
| HTML-Wasm | Experimental | Backend experiment and integration path for future Wasm output. Ordinary entry-selected `start` execution and non-reactive runtime page fragments use the shared HTML builder slot/hydration contract. Reactive mounting remains unsupported. | Keep behind --html-wasm. Tests may pin current behavior, but Alpha support is JS / HTML. |
| Wasm backend | Experimental | Long-term backend direction with current HIR-to-Wasm-LIR lowering, runtime contracts, request validation, debug output, and binary emission work. | Do not count Wasm support as an Alpha blocker except for clean diagnostics and no-panic guarantees on covered paths. |
| Wasm payload/runtime parity | Experimental | Covered paths validate or lower selected payload, assert, generic, map, collection, numeric, cast, reactive, and external-call cases. | Backend parity progress belongs here, not repeated in every feature row. |
| Surface | Status | Coverage | Current status |
|---|---|---|---|
| Frontend Arena + Semantic Invariant Optimisation | Partial | Broad benchmark, profiling, adversarial-fixture, scope-frame, capacity-estimate, and validation coverage. | Implemented pieces include frontend token/header stats, conservative capacity estimates, AST-owned scope-frame arenas, production scope-arena seeding, external package registry clone reduction, and adversarial benchmark fixtures. Broader expression, template/render-plan, HIR, bump-allocation, and persistent-cache migrations remain deferred until profiling justifies them. |
| Surface | Status | Coverage / diagnostic direction | Notes |
|---|---|---|---|
| Trait ecosystem extensions | Deferred | Current implemented trait diagnostics are tracked in the core Traits row. | Default methods, associated items, inheritance/composition, generic traits, specialized conformance, deriving, operator traits, formatting/display coercion, hashing, ordering, iteration, serialization, downcasting/reflection, and broad standard trait taxonomy remain outside the Alpha trait slice. |
| Post-TIR template performance follow-ups | Deferred | Not part of the current Alpha surface. | Deferred items are source-span-backed template body text, a per-template parse cache, a formatter-output cache, dev-mode source-hash keyed template reuse, dependency-aware invalidation for imported consts/directives, formatter algorithm rewrites if profiling justifies them, incremental module/template compilation after module-boundary incremental builds exist, and parallel nested-template folding after a separate profiling-backed plan. |
| Async / concurrency scopes | Deferred | Reserved keyword diagnostics for async statement/declaration positions. | Future async syntax is design-only. Current async statement and declaration positions are rejected with structured diagnostics. |
| Checked scopes | Deferred | Reserved keyword diagnostics for checked statement/declaration positions. | Checked/effect semantics are not designed yet. |
| Labeled scopes | Rejected | Targeted labeled-scope diagnostic coverage. | Bare label: syntax is not supported. Use block: for ordinary scoped blocks. |
| Legacy and foreign-language syntax | Rejected | Targeted diagnostics for common TypeScript/Rust/JS-shaped mistakes. | Compatibility syntax is not planned Alpha surface. |
| Public panic/recover syntax | Rejected | Unknown-name and assert result-handling diagnostics. | There is no public panic keyword, #panic directive, recover, catch_panic, or public panic payload. Expected failures use Error! and catch. |
| Assertion extensions | Deferred | Current assert diagnostics and backend trap coverage. | Deferred surfaces include debug-only assertions, runtime/const assertion-message expressions, additional explicit stop helpers, catchable panic semantics, and richer non-JS trap payloads. |
| Choice payload field access | Deferred | Targeted direct-field-access diagnostic coverage. | Use pattern matching to extract payload fields until variant narrowing/refinement is designed. |
| Choice nested payload patterns and richer exhaustiveness | Deferred | Targeted nested-pattern deferred diagnostics. | Exhaustiveness is tag-level for now. General pattern binding renames are also deferred outside choice payload capture renames. |
| Choice defaults and tagged declarations | Deferred | Targeted diagnostics for choice defaults/default variants where present. | Variant defaults, default payload fields, and tagged/default declaration sugar remain deferred. |
| Choice recursive types | Deferred | Targeted recursive declaration deferred diagnostics. | Requires layout and indirection design. |
| `as` keyword domains | Supported | Targeted success and invalid-position diagnostics. | as is valid for type aliases, namespace/grouped import aliases, and choice payload capture renames. Other positions are rejected. |
| Module-root export/re-export syntax | Supported | Targeted authored export, grouped re-export, alias, source/external symbol, privacy, duplicate, placement, and strict-block rejection coverage. | A module root's single strict export: block exposes public authored declarations and grouped re-exports. Legacy inline export forms, bare namespace exports, wildcard exports, function alias values, and automatic method re-export through type aliases are rejected. |
| Source-backed package HIR caching | Deferred | No precompiled source-backed package cache. | Source-backed packages are compiled from source each build. Caching is deferred until the package system is stable. |
| Package manager | Deferred | No package manager, remote registries, lockfiles, or dependency resolver. | Package management, versioning, lockfiles, and remote fetching remain roadmap work. |
| External JS package expansion | Deferred | JS provider diagnostics reject unsupported public binding forms. | The HTML builder supports annotated single-file .js imports and builder-owned JS-backed packages. JS constants, classes, dependency graphs, default exports, re-exports, CommonJS, callbacks, async functions, generic external types, collection/option signatures, and multi-success returns remain deferred. |
| Namespace / wildcard imports | Partial | Source, module public surface, external package, nested external value/type traversal, and wildcard rejection coverage. | Namespace imports are compile-time records. Source and module records stay shallow. External package records can expose nested symbol paths such as io.input.new and io.input.Input. Wildcard imports remain deferred. |
| Generic type infrastructure | Supported | Broad TypeId, nominal instance, alias, constructor, import, HIR validation, trait-bound, and diagnostic coverage. | Generic structs, choices, concrete aliases, generic free functions, aligned generic receiver methods, and trait-bound validation use canonical TypeId identity before HIR. |
| Generic functions | Partial | Broad declaration, body validation, inference, instantiation, module-boundary import, diagnostics, fallible return, and non-value-use coverage. | Generic free functions infer from immediate call arguments and immediate expected result context only. They emit concrete instances before HIR and are not first-class values. |
| Trait bounds on generics | Partial | Broad declaration-site bound, visible evidence, module public-surface privacy, receiver-call, nominal generic instance, and negative diagnostic coverage. | Bounds use is. Concrete generic calls and nominal generic instances require visible reusable evidence. File-local evidence-backed dispatch remains outside scope. |
| Explicit generic call-site application | Rejected | Targeted diagnostics for of, angle, square, and typed-argument call-site forms. | Generic calls use ordinary call syntax and inference only. Use annotations at receiving sites when inference needs help. |
| Recursive generic types | Deferred | Targeted recursive generic type diagnostics. | Requires layout and indirection design. |
| Nested generic type application | Deferred | Targeted nested of diagnostics and alias workaround coverage. |
Name intermediate concrete aliases instead of writing nested inline generic applications. |
| Parameterized generic aliases | Deferred | Targeted rejection where covered. | Aliases to fully concrete generic instances are supported. Aliases with their own parameters remain deferred. |
| Generic external package functions | Deferred | External signature validation rejects unsupported generic external surfaces. | External packages currently expose concrete functions, opaque types, and constants only. |
| Type values and type-level compile-time evaluation | Outside Scope | Invalid syntax or ordinary name/type diagnostics. | Type-returning functions, runtime type IDs, type-level conditionals, and compile-time type inspection are outside the current language design. |
| General function-value surfaces | Outside Scope | Generic function value diagnostics and invalid syntax diagnostics where covered. | General closures, anonymous function values, generic function values, higher-order polymorphism, and hidden event-handler function values are outside the current language design. |
| Rich numeric redesign | Deferred | Current numeric coverage is tracked in the core arithmetic and Float rows. | Numeric check elision, explicit unchecked numeric modes, narrower numeric types, BigInt, Decimal, and broader numeric tower work remain deferred. |
This matrix should stay concise and current.
CONTRIBUTING.md.docs/roadmap/roadmap.md.docs/src/docs/**.docs/compiler-design-overview.md.