VOID Language roadmap

Generic operators are coherent.
Now unify conversions.

The iterator-lifetime and generic-operator phase is finished, including preservation of generic constraint provenance through iterator lowering. Completed phases stay collapsible while conversion semantics becomes the active compiler architecture block.

Current phase

Conversion Semantics & Generic Conversion Integration

Current

This phase consolidates VOID's older conversion paths into one semantic conversion engine, then extends that same model through nullable lifting, target-typed sites, static-interface conversion contracts, constrained generics, iterators, closures, and GC. Semantic analysis remains authoritative; code generation consumes the selected conversion instead of rediscovering it.

Next

Standard conversion classification completion

Define one semantic vocabulary for identity, numeric, nullable, enum, reference/interface, null, and existing pointer/unsafe conversions.

Planned

User-defined conversion resolution completion

Complete applicability, implicit/explicit rules, ambiguity, accessibility, and surrounding standard conversions for concrete conversion operators, with semantic analysis choosing the binding.

Planned

Lifted nullable conversion completion

Integrate user-defined conversions with nullable value types, including null propagation, legal explicit extraction, ambiguity, and diagnostics through existing nullable machinery.

Planned

Conversion-site integration

Drive assignments, locals, fields, properties, parameters, returns, constructors, arrays, initializers, params, conditionals, switch expressions, and other target-typed contexts through the same conversion engine.

Planned

Static interface conversion contracts

Allow signature-only implicit/explicit conversion requirements on static interfaces, with specialization, inheritance, implementation validation, conflicts, and diagnostics.

Planned

Constrained generic implicit conversion dispatch

Authorize generic implicit conversions only when an applicable interface constraint requires them, then resolve the concrete conversion through monomorphization.

Planned

Constrained generic explicit conversion dispatch

Apply the same rule to explicit casts so specialized concrete conversions cannot make an unconstrained generic cast retroactively legal.

Planned

Generic conversion provenance & inference integration

Preserve conversion-contract provenance through generic methods/types, specialization, locals, fields, properties, overload resolution, inference, and target-typed transformed expressions.

Planned

Iterator, closure & GC conversion integration

Carry generic conversion provenance through iterator fields and closure captures, then stress conversions across yield, GC, managed results, exceptions, finally, and disposal.

Planned

Conversion semantics & generic conversion integration

Close the block across standard/user conversions, nullable lifting, static-interface contracts, constrained generics, operators, closures, iterators, exceptions, deterministic cleanup, GC, and library compilation.

Completed foundations

Completed phases, without the wall of text.

Each completed phase keeps its full public history, but starts collapsed. Open only the section you want to inspect; the active phase above remains expanded.

Completed

Language & runtime foundation

  • Classes, structs, inheritance, and interfaces
  • Generics and generic collections
  • foreach, enumerators, and yield
  • Delegates, lambdas, closures, and events
  • Garbage collection across managed language features
  • Attributes and focused runtime discovery
Completed

Native & unsafe foundation

  • Pointers and pointer arithmetic
  • ABI-safe native structures
  • Native ref/out/in, bindings, aliases, libraries, and callbacks
  • sizeof, memory copy/clear, and stackalloc
  • Controlled end-to-end C integration
Completed

Core language ergonomics

  • Enums and switch
  • const/readonly, casts, is/as
  • Null operators, optional/default parameters, and params
  • default(T), typeof, type metadata, and conversions
Completed

Language completion & initialization

  • Nullable value types and lifted nullable operators
  • Null-conditional indexing and named arguments
  • Target-typed default
  • Instance field and auto-property initializers
  • Object, array, and collection initializers
  • Static fields/properties and deterministic static initialization
  • Generic static initialization and managed static GC roots
  • Cross-feature integration/stabilization
Completed

Tooling & developer experience

  • Source spans, ranged diagnostics, and voidc check
  • Semantic query sessions and native debug/source mapping
  • Compiler-side LSP lifecycle and live diagnostics
  • Hover, signature help, and semantic completion
  • Go-to-definition, references, document/workspace symbols
  • Multi-file unsaved-state integration and broken-source recovery
Completed

Object model & language completion II

  • Base-constructor chaining and same-type constructor delegation
  • Interface inheritance and struct interface implementation
  • Virtual, abstract, and override property dispatch
  • Static events, interface events, and event initializers
  • Struct delegate targets, by-reference delegate parameters, and structural delegate equality
  • Target-typed conditional expressions across class, struct/interface, delegate, nullable, conversion, and generic cases
  • Multi-file object-model integration and stabilization
Completed

Value types, closures & control flow

  • Nested value structs with recursive managed-reference tracing
  • Readonly structs, readonly instance methods/accessors, and in calls
  • Jagged arrays and real rectangular multidimensional arrays
  • Nested/per-iteration closures plus ref/out/in capture and struct this
  • Iterator state across foreach, switch, nested control flow, and base-member access
  • Pointer properties/constructors within existing unsafe boundaries
  • Compound indexer and vector-swizzle assignment with single evaluation
  • Cross-feature check/build/run/publish integration with forced GC
Completed

Language edge & project completion

  • Static interface property contracts with class/struct implementations and inherited/diamond validation
  • Static interface event contracts without interface-owned storage
  • Plain constructor return; with chaining/initializer and definite-assignment correctness
  • Typed rectangular array initializers with inferred shape, conversions, row-major storage, and GC safety
  • Normal iterator local inference, definite assignment, shadowing, and managed state across yield
  • General instance-method receivers across temporaries, properties, indexers, arrays, conditionals, virtual/interface dispatch, and GC
  • Explicit generic calls through static, instance, inherited, virtual, interface, specialized, and temporary receivers
  • Native callback ref/out/in parameters through the existing C ABI
  • Real "output": "library" static archives, [Export] symbols, reachability, static initialization, and VOID/C consumers
  • Cross-feature library/consumer integration through check/build/run/publish and native linking
Completed

Language surface completion II

  • Unsafe delegates with pointer returns/parameters, nested pointers, void*, and ref/out/in pointer forms
  • Pointer-bearing properties across unsafe classes/interfaces/value types with static, virtual, override, and interface dispatch
  • Full do/while control flow across normal code, generics, lambdas, iterators, break/continue, and GC roots
  • Expression-bodied methods, constructors, operators/conversions, void members, and property setters
  • Custom event add/remove accessors across instance/static/interface/virtual forms
  • Null-conditional indexing across one-dimensional, jagged, and rectangular arrays with single-evaluation and short-circuit semantics
  • Explicit-size rectangular initializers with compile-time dimension/shape validation
  • Implicit new[,]-style rectangular initializer inference
  • Generic where constraints across class/struct/base/interface/multiple-interface/new() forms
  • Cross-feature surface integration and stabilization through the normal toolchain
Completed

Exceptions & Runtime Control Flow
  • Managed Exception hierarchy, messages, derived exceptions, and throw expression;
  • Typed and catch-all handlers, catch variables, and derived-to-base handler ordering
  • Cross-call propagation with GC/root restoration during unwinding
  • finally on normal and exceptional completion
  • return, break, and continue through one or more finally regions
  • Nested handlers, bare throw; rethrow, and exceptions raised from catch/finally
  • Iterator exception/finally integration across suspension and resume
  • Delegate, multicast-event, and managed-target exception propagation
  • Native/library boundary rules and ABI diagnostics
  • Integration hardening including static-initializer failure recovery, GC-root checkpoint restoration, and retry-safe initialization
Completed

Deterministic lifetime & advanced abstractions

  • IDisposable foundation and deterministic compiler-generated iterator disposal
  • Non-array foreach disposal on normal completion, early exit, and exceptions
  • using (...) statements and scope-bound using declarations
  • Reverse-order disposal across structured exits and existing finally regions
  • Generic method type inference through the existing overload resolver/monomorphizer
  • Extension methods with ordinary instance-member precedence
  • Static interface method contracts without interface-owned runtime storage
  • Constrained static interface calls specialized to concrete static methods
  • Default interface method bodies with concrete precedence and ambiguity diagnostics
  • Cross-feature lifetime/abstraction integration with exceptions, iterators, GC, and native boundaries
Completed

Pattern matching & control-flow expressions

  • Declaration/type patterns with flow-aware pattern locals and definite assignment
  • Constant and null patterns through the shared pattern matcher
  • Relational patterns using existing numeric/comparison semantics
  • Logical and, or, and not composition with binding/flow rules
  • Property patterns across classes, structs, interfaces, inheritance, and nullable/reference values
  • Recursive nested patterns with short-circuiting, GC-safe temporaries, and single evaluation
  • Pattern-aware switch statements while preserving existing constant/integral/enum behavior
  • when guards, deterministic first-match ordering, and focused invalid/unreachable diagnostics
  • Switch expressions with target/result type unification, managed/value results, and nullable handling
  • Cross-feature integration with generics, interfaces/default methods, exceptions, iterators, GC, and value/nullability semantics
Completed

Iterator lifetime completion & generic operator foundations

  • Declaration-pattern locals promoted through the existing iterator capture model when they survive yield
  • Switch-case, switch-expression-arm, recursive-pattern, and when-guard locals preserved across suspension with exact scoping
  • Captured managed pattern values proven GC-safe through suspension, resume, disposal, exceptions, finally, and teardown
  • Cumulative iterator state-machine audit across ordinary/pattern locals, foreach, using/disposal, exceptions, generics, and switch forms
  • Stable user-facing diagnostics without historical internal milestone labels
  • User-defined unary operator completion through normal overload/type resolution
  • User-defined binary arithmetic/comparison/equality and compound paths through shared conversion/overload machinery
  • Static interface operator contracts with implementation, inheritance, conflict, accessibility, and generic validation
  • Constrained generic operator dispatch specialized to ordinary concrete operator calls
  • Iterator lowering preserves generic-origin/constraint provenance so constrained operators remain valid after yield

What changed

Operator semantics are integrated. Conversion semantics are next.

The completed phase proved that pattern-local iterator lifetime, GC cleanup, user-defined operators, static-interface operator contracts, and constrained generic dispatch can share the existing compiler architecture. The final integration exposed a real lowering defect: promoted generic iterator fields lost their original constraint provenance. That metadata is now preserved, and the next block applies the same semantic-authority principle to VOID's conversion system.