binop except assign and conditionals (#141)

Author: 0xGeorgii

CHANGELOG.md

@@ -24,6 +24,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - Execution functions use target's release optimization so proofs cover actual deployed code
   - `OptLevel` is currently metadata only; optimization passes planned for future
 - Add validation guards in `codegen()`: reject proof mode with non-Wasm32 targets, reject Soroban with non-det operations ([#97])
+- Add binary and unary expression lowering to WebAssembly codegen ([#140])
+  - All arithmetic operators (`+`, `-`, `*`, `/`, `%`) for i32 and i64, signed and unsigned variants
+  - All comparison operators (`==`, `!=`, `<`, `<=`, `>`, `>=`) with correct sign-sensitive dispatch
+  - All logical operators (`&&`, `||`) lowered as bitwise `i32.and`/`i32.or` (bool operands guaranteed by type-checker)
+  - All bitwise operators (`&`, `|`, `^`) and shift operators (`<<`, `>>`) for i32 and i64
+  - Unary negation (`-x`) via `0 - x` idiom (no native WASM integer negate instruction)
+  - Logical not (`!x`) via `i32.eqz`
+  - Bitwise not (`~x`) via `x ^ -1` idiom (works for both i32 and i64)
+  - Parenthesized expressions lowered transparently (no extra instructions emitted)
+  - Variable definition initializers now accept any value-producing expression (not just literals/identifiers/uzumaki)
+  - `Pow` operator (`**`) deferred — no native WASM instruction
 - Add function parameter lowering and function call support to WebAssembly codegen ([#136])
   - Function parameters mapped to WASM local indices `0..n`; body locals start at `n`
   - Pre-scan builds `func_name_to_idx` map for forward reference support
@@ -317,3 +328,4 @@ Initial tagged release.
 [#134]: https://github.com/Inferara/inference/pull/135
 [#136]: https://github.com/Inferara/inference/pull/136
 [#138]: https://github.com/Inferara/inference/pull/138
+[#140]: https://github.com/Inferara/inference/pull/140

core/ast/docs/nodes.md

@@ -585,14 +585,14 @@ pub struct BinaryExpression {
 **Operators:**
 ```rust
 pub enum OperatorKind {
-    Pow,      // **
+    Pow,      // **  — parsed but NOT yet lowered in WASM codegen (todo!)
     Add,      // +
     Sub,      // -
     Mul,      // *
-    Div,      // /  (Added in issue #86)
+    Div,      // /
     Mod,      // %
-    And,      // &&
-    Or,       // ||
+    And,      // &&  — lowers to i32.and (no short-circuit)
+    Or,       // ||  — lowers to i32.or  (no short-circuit)
     Eq,       // ==
     Ne,       // !=
     Lt,       // <
@@ -602,19 +602,31 @@ pub enum OperatorKind {
     BitAnd,   // &
     BitOr,    // |
     BitXor,   // ^
-    BitNot,   // ~
+    BitNot,   // design inconsistency — never produced for BinaryExpression;
+              // the ~ token is always a PrefixUnaryExpression (UnaryOperatorKind::BitNot)
     Shl,      // <<
     Shr,      // >>
 }
 ```
 
+**Codegen notes:**
+
+- `Pow` (`**`) is not yet implemented in the WASM backend. Attempting to lower a
+  binary expression with this operator will panic with a `todo!()`.
+- `BitNot` should not appear in any `BinaryExpression` node. The `~` token is
+  always parsed as a prefix unary expression and stored as
+  `UnaryOperatorKind::BitNot`. The `OperatorKind::BitNot` variant is a design
+  inconsistency that will be removed in a future cleanup.
+- `And` and `Or` lower to WebAssembly `i32.and`/`i32.or` bitwise instructions.
+  Both operands are always evaluated — there is no short-circuit evaluation.
+
 **Example source:**
 ```inference
 x + y
 a * b + c
-a / b              // Division operator (issue #86)
+a / b
 flag && (count > 0)
-x % 2 == 0         // Modulo
+x % 2 == 0
 ```
 
 ### PrefixUnaryExpression
@@ -630,19 +642,22 @@ pub struct PrefixUnaryExpression {
 }
 
 pub enum UnaryOperatorKind {
-    Not,     // !  - Logical negation
-    Neg,     // -  - Numeric negation (Added in issue #86)
-    BitNot,  // ~  - Bitwise NOT (Added in issue #86)
+    Not,     // !  - Logical negation   — lowers to i32.eqz
+    Neg,     // -  - Numeric negation   — lowers to (0 - expr) using i32.sub or i64.sub
+    BitNot,  // ~  - Bitwise NOT        — lowers to (expr ^ -1) using i32.xor or i64.xor
 }
 ```
 
+Note: `~` always produces a `PrefixUnaryExpression` with `UnaryOperatorKind::BitNot`.
+It is never stored as `OperatorKind::BitNot` in a `BinaryExpression`.
+
 **Example source:**
 ```inference
 !flag              // Logical NOT
 !(x > 0)
--x                 // Numeric negation (issue #86)
+-x                 // Numeric negation
 -42
-~mask              // Bitwise NOT (issue #86)
+~mask              // Bitwise NOT
 ~0xFF
 ```
 

core/ast/src/arena.rs

@@ -20,6 +20,12 @@ pub struct Arena {
 }
 
 impl Arena {
+    /// Returns all `SourceFile` nodes in the arena, sorted by node ID.
+    ///
+    /// In a single-file compilation the result contains exactly one element.
+    /// In multi-file compilation (via `ParserContext`) it contains one entry per
+    /// parsed file. Node ID order matches the order in which files were added to
+    /// the builder.
     #[must_use]
     pub fn source_files(&self) -> Vec<Rc<SourceFile>> {
         self.list_nodes_cmp(|node| {
@@ -31,6 +37,11 @@ impl Arena {
         })
         .collect()
     }
+
+    /// Returns all `FunctionDefinition` nodes in the arena, sorted by node ID.
+    ///
+    /// This includes both free functions and struct methods. Node ID order
+    /// matches source order within each file.
     #[must_use]
     pub fn functions(&self) -> Vec<Rc<FunctionDefinition>> {
         self.list_nodes_cmp(|node| {
@@ -68,6 +79,10 @@ impl Arena {
         }
     }
 
+    /// Returns a clone of the node with the given ID, or `None` if not present.
+    ///
+    /// This is an O(1) hash map lookup. Cloning an `AstNode` is cheap because
+    /// the heavy node data is behind `Rc`.
     #[must_use]
     pub fn find_node(&self, id: u32) -> Option<AstNode> {
         self.nodes.get(&id).cloned()
@@ -153,6 +168,11 @@ impl Arena {
         }
     }
 
+    /// Returns all descendants of the node with the given ID that satisfy `comparator`.
+    ///
+    /// Performs a depth-first traversal starting from `id`, collecting every
+    /// node (including the root itself) for which `comparator` returns `true`.
+    /// Returns an empty `Vec` if the starting node does not exist.
     pub fn get_children_cmp<F>(&self, id: u32, comparator: F) -> Vec<AstNode>
     where
         F: Fn(&AstNode) -> bool,
@@ -178,6 +198,7 @@ impl Arena {
         result
     }
 
+    /// Returns all `TypeDefinition` nodes in the arena, sorted by node ID.
     #[must_use]
     pub fn list_type_definitions(&self) -> Vec<Rc<TypeDefinition>> {
         self.list_nodes_cmp(|node| {
@@ -190,6 +211,19 @@ impl Arena {
         .collect()
     }
 
+    /// Returns all nodes that satisfy `fn_predicate`, sorted by node ID.
+    ///
+    /// Unlike `get_children_cmp`, this scans the entire arena (not just a
+    /// subtree) and always returns results in ascending node ID order. Use this
+    /// for global queries such as "find all binary expressions".
+    ///
+    /// # Example
+    ///
+    /// ```ignore
+    /// let binary_exprs = arena.filter_nodes(|node| {
+    ///     matches!(node, AstNode::Expression(Expression::Binary(_)))
+    /// });
+    /// ```
     pub fn filter_nodes<T: Fn(&AstNode) -> bool>(&self, fn_predicate: T) -> Vec<AstNode> {
         let mut entries: Vec<_> = self.nodes.iter().collect();
         entries.sort_unstable_by_key(|(id, _)| *id);

core/cli/README.md

@@ -182,7 +182,7 @@ infc example.inf --codegen -v
 ```
 Parsed: example.inf
 Analyzed: example.inf
-WASM generated
+Codegen complete
 V generated at: out/example.v
 ```
 

core/cli/src/main.rs

@@ -27,7 +27,7 @@
 //!
 //! 3. **Codegen** (`--codegen`) – Emits WebAssembly binary
 //!    - Generates WebAssembly binary from typed AST
-//!    - Supports non-deterministic instructions (uzumaki, forall, exists)
+//!    - Supports non-deterministic instructions (uzumaki, forall, exists, assume, unique)
 //!    - Optionally translates to Rocq (.v) format for formal verification
 //!
 //! ## Phase Execution

core/type-checker/src/lib.rs

@@ -133,6 +133,10 @@ impl Default for TypeCheckerBuilder<TypeCheckerInitState> {
 }
 
 impl TypeCheckerBuilder<TypeCheckerInitState> {
+    /// Create a new builder in the initial (untyped) state.
+    ///
+    /// Prefer [`TypeCheckerBuilder::build_typed_context`] for the common case
+    /// where you have an arena ready to check immediately.
     #[must_use]
     pub fn new() -> Self {
         TypeCheckerBuilder {

core/type-checker/src/type_info.rs

@@ -179,20 +179,50 @@ impl std::str::FromStr for NumberType {
     }
 }
 
+/// Discriminates the semantic category of a [`TypeInfo`] value.
+///
+/// Variants mirror the type system of the Inference language.
+/// See the module-level documentation for the full hierarchy.
 #[derive(Debug, Eq, PartialEq, Clone, Hash)]
 pub enum TypeInfoKind {
+    /// The unit type `unit` — the implicit return type of void functions.
     Unit,
+    /// The boolean type `bool`.
     Bool,
+    /// The string type `string` (UTF-8, partial support).
     String,
+    /// A numeric integer type (signed or unsigned, 8–64 bit).
     Number(NumberType),
+    /// A user-defined type referenced by name that has not yet been resolved
+    /// to a struct or enum entry in the symbol table.
+    ///
+    /// After type registration this should have been replaced by
+    /// [`Struct`](TypeInfoKind::Struct) or [`Enum`](TypeInfoKind::Enum).
     Custom(String),
+    /// A fixed-size array: element type and element count.
     Array(Box<TypeInfo>, u32),
+    /// An unresolved generic type parameter (e.g. `T` in `fn foo<T>(x: T) -> T`).
+    ///
+    /// Replaced by a concrete type after type-parameter substitution.
     Generic(String),
+    /// A two-segment qualified type name (`module::Type`) from the source.
     QualifiedName(String),
+    /// A single-segment qualified type reference carrying an alias prefix.
     Qualified(String),
+    /// A function type. The inner string takes one of three forms depending on
+    /// how the function was referenced:
+    ///
+    /// - `"FunctionName"` — a free function referenced by name (from `function_definition.name()`)
+    /// - `"ReceiverType::MethodName"` — a method or type-member access expression
+    /// - `"Function<N, ReturnType>"` — a function-type literal from a `Type::Function` node
+    ///
+    /// Used to annotate function-name expressions in the `TypedContext`.
     Function(String),
+    /// A resolved struct type, carrying the struct's canonical name.
     Struct(String),
+    /// A resolved enum type, carrying the enum's canonical name.
     Enum(String),
+    /// A spec (specification) type, carrying the spec's canonical name.
     Spec(String),
 }
 
@@ -267,11 +297,19 @@ impl TypeInfoKind {
     }
 }
 
+/// The semantic type of a value expression after type checking.
+///
+/// Produced by [`TypeInfo::new`] from AST [`Type`] nodes and stored in
+/// [`TypedContext`](crate::typed_context::TypedContext) keyed by AST node ID.
 #[derive(Debug, Eq, PartialEq, Clone, Hash)]
 pub struct TypeInfo {
+    /// The concrete type category (e.g. `Number(I32)`, `Struct("Point")`).
     pub kind: TypeInfoKind,
+    /// Names of any unresolved generic type parameters carried by this type
+    /// (e.g. `["T"]` for a value whose type is a generic parameter `T`).
+    ///
+    /// After all type parameters have been substituted this will be empty.
     pub type_params: Vec<String>,
-    // (Field type information could be added here if needed for struct field checking.)
 }
 
 impl Default for TypeInfo {
@@ -299,6 +337,10 @@ impl Display for TypeInfo {
 }
 
 impl TypeInfo {
+    /// Construct a `bool` `TypeInfo` value.
+    ///
+    /// Shorthand for the common case of representing a boolean result,
+    /// for example when checking conditions or logical operator results.
     #[must_use]
     pub fn boolean() -> Self {
         Self {
@@ -315,6 +357,10 @@ impl TypeInfo {
         }
     }
 
+    /// Convert an AST [`Type`] to its semantic `TypeInfo` representation.
+    ///
+    /// Equivalent to `TypeInfo::new_with_type_params(ty, &[])` — use this
+    /// when there are no in-scope generic type parameters to consider.
     #[must_use]
     pub fn new(ty: &Type) -> Self {
         Self::new_with_type_params(ty, &[])

core/type-checker/src/typed_context.rs

@@ -91,6 +91,16 @@ use inference_ast::{
 };
 use rustc_hash::FxHashMap;
 
+/// Central store produced by type checking.
+///
+/// `TypedContext` combines the original parsed [`Arena`] with a map from
+/// AST node IDs to their inferred [`TypeInfo`] values and the populated
+/// [`SymbolTable`].  It is the primary output of
+/// [`TypeCheckerBuilder::build_typed_context`](crate::TypeCheckerBuilder::build_typed_context)
+/// and the primary input to subsequent compiler phases such as WASM code generation.
+///
+/// See the module-level documentation for details on which expressions receive
+/// type information and which are structural.
 #[derive(Default)]
 pub struct TypedContext {
     pub(crate) symbol_table: SymbolTable,
@@ -372,10 +382,18 @@ impl TypedContext {
     }
 }
 
-/// Information about an expression missing its type after type checking.
+/// Describes a value expression that has no [`TypeInfo`] entry after type checking.
+///
+/// A non-empty list returned by
+/// [`TypedContext::find_untyped_expressions`] indicates a bug in the type
+/// checker: every value expression should be annotated by the time inference
+/// completes.
 #[derive(Debug)]
 pub struct MissingExpressionType {
+    /// AST node ID of the untyped expression.
     pub id: u32,
+    /// Human-readable name of the expression variant (e.g. `"Binary"`, `"FunctionCall"`).
     pub kind: String,
+    /// Source location of the expression, for diagnostic output.
     pub location: Location,
 }