Merge remote-tracking branch 'origin/main' into feat/trait-system-improvements

# Conflicts:
#	docs/pages/specs/syntax/types/function.md

Author: brockelmore

Cargo.toml

@@ -4,7 +4,7 @@ resolver = "2"
 
 [workspace.package]
 description = "Edge Language Compiler Workspace"
-version = "0.1.17"
+version = "0.1.18"
 edition = "2021"
 rust-version = "1.85"
 license = "MIT"

README.md

@@ -84,6 +84,10 @@ edgec check examples/counter.edge
 # Print the contract ABI as JSON
 edgec --emit abi examples/counter.edge
 # [{"type":"function","name":"increment","inputs":[],"outputs":[],"stateMutability":"view"}, ...]
+
+# Standard JSON I/O (for tool integration — reads from stdin, writes to stdout)
+echo '{"language":"Edge","sources":{"counter.edge":{"content":"..."}}}' | edgec standard-json
+# {"sources":{"counter.edge":{"id":0}},"contracts":{"counter.edge":{"Counter":{"abi":[...],"evm":{"bytecode":{"object":"604d..."},...}}}}}
 ```
 
 ### Example: counter contract

bin/edgec/src/cli.rs

@@ -58,6 +58,9 @@ pub enum Commands {
     Lsp,
     /// Parse a file and print AST
     Parse(FileArgs),
+    /// Compile using standard JSON I/O (reads stdin, writes stdout)
+    #[command(name = "standard-json")]
+    StandardJson,
 }
 
 /// Arguments for file-based subcommands
@@ -75,6 +78,7 @@ impl Cli {
             Some(Commands::Lex(args)) => Self::lex(args, self.std_path),
             Some(Commands::Lsp) => Self::lsp(),
             Some(Commands::Parse(args)) => Self::parse(args, self.std_path),
+            Some(Commands::StandardJson) => Self::standard_json(),
             None => {
                 if let Some(file) = self.file {
                     Self::compile(
@@ -258,4 +262,26 @@ impl Cli {
 
         Ok(())
     }
+
+    fn standard_json() -> Result<()> {
+        use std::io::Read;
+        let mut input_str = String::new();
+        std::io::stdin().read_to_string(&mut input_str)?;
+        let output =
+            match serde_json::from_str::<edge_driver::standard_json::StandardJsonInput>(&input_str)
+            {
+                Ok(input) => edge_driver::standard_json::compile_standard_json(input),
+                Err(e) => edge_driver::standard_json::StandardJsonOutput {
+                    errors: vec![edge_driver::standard_json::OutputError {
+                        kind: "Error".into(),
+                        severity: "error".into(),
+                        message: format!("invalid standard JSON input: {e}"),
+                        formatted_message: format!("invalid standard JSON input: {e}"),
+                    }],
+                    ..Default::default()
+                },
+            };
+        println!("{}", serde_json::to_string_pretty(&output)?);
+        Ok(())
+    }
 }

crates/driver/Cargo.toml

@@ -22,6 +22,8 @@ thiserror = { workspace = true }
 tracing = { workspace = true }
 indexmap = { workspace = true }
 tiny-keccak = { workspace = true }
+serde = { workspace = true, features = ["derive"] }
+serde_json = { workspace = true }
 
 [dev-dependencies]
 edge-parser = { workspace = true }

crates/driver/README.md

@@ -1,6 +1,6 @@
 # edge-driver
 
-Compiler driver that orchestrates the full Edge compilation pipeline. Reads source files and runs each phase in sequence: lex, parse, type-check, lower to IR, and emit EVM bytecode.
+Compiler driver that orchestrates the full Edge compilation pipeline. Reads source files and runs each phase in sequence: lex, parse, type-check, lower to IR, and emit EVM bytecode. The `standard_json` module provides a Solidity-compatible standard JSON I/O interface so that build tools like Foundry can drive `edgec` with a single JSON blob on stdin.
 
 ## Pipeline Position
 
@@ -25,6 +25,9 @@ source -> lexer -> parser -> AST -> typeck -> IR -> codegen -> driver -> bytecod
 - **`CompilerConfig`** -- Input file path, output path, emit kind, optimization level, verbose flag
 - **`EmitKind`** -- What the compiler should produce: `Tokens`, `Ast`, `Abi`, or `Bytecode`
 - **`Session`** -- Per-compilation state: config, source text, and accumulated diagnostics
+- **`StandardJsonInput`** -- Deserialized standard JSON request (sources, settings)
+- **`StandardJsonOutput`** -- Serialized standard JSON response (contracts, errors)
+- **`compile_standard_json`** -- Compiles all sources from a `StandardJsonInput` and returns a `StandardJsonOutput`
 
 ## Usage
 
@@ -45,6 +48,17 @@ if let Some(abi) = &output.abi {
 }
 ```
 
+The `compile_standard_json` function accepts a `StandardJsonInput` and returns a `StandardJsonOutput` containing ABI and bytecode for every contract in the input. Errors are reported inside the output rather than as Rust-level failures.
+
+```rust,no_run
+use edge_driver::standard_json::{compile_standard_json, StandardJsonInput};
+
+let json_str = r#"{"language":"Edge","sources":{"counter.edge":{"content":"..."}}}"#;
+let input: StandardJsonInput = serde_json::from_str(json_str).unwrap();
+let output = compile_standard_json(input);
+println!("{}", serde_json::to_string_pretty(&output).unwrap());
+```
+
 ## Integration
 
 - **Input**: `.edge` source file on disk

crates/driver/src/compiler.rs

@@ -157,20 +157,24 @@ impl Compiler {
             CompileError::TypeCheckErrors
         })?;
 
-        // ABI extraction — return early if that's all the user requested
+        // ABI extraction — always compute so downstream consumers (e.g. standard-json)
+        // can access the ABI alongside bytecode.
+        let abi: Vec<edge_typeck::AbiEntry> = checked
+            .contracts
+            .iter()
+            .flat_map(|c| edge_typeck::extract_abi(c, &checked.events))
+            .collect();
+
+        // Return early if ABI is all the user requested
         if emit == EmitKind::Abi {
-            let mut all_entries = Vec::new();
-            for contract in &checked.contracts {
-                all_entries.extend(edge_typeck::extract_abi(contract, &checked.events));
-            }
             return Ok(CompileOutput {
                 tokens: None,
                 ast: None,
                 ir: None,
                 bytecode: None,
                 bytecodes: None,
                 asm: None,
-                abi: Some(all_entries),
+                abi: Some(abi),
             });
         }
 
@@ -307,7 +311,7 @@ impl Compiler {
             bytecode: last_bytecode,
             bytecodes: Some(all_bytecodes),
             asm: None,
-            abi: None,
+            abi: Some(abi),
         })
     }
 
@@ -622,4 +626,9 @@ impl Compiler {
     pub const fn session(&self) -> &Session {
         &self.session
     }
+
+    /// Get a mutable reference to the session
+    pub const fn session_mut(&mut self) -> &mut Session {
+        &mut self.session
+    }
 }

crates/driver/src/lib.rs

@@ -5,6 +5,7 @@
 pub mod compiler;
 pub mod config;
 pub mod session;
+pub mod standard_json;
 
 /// Embedded standard library sources, generated by build.rs.
 /// Maps module key (e.g. `"tokens/erc20"`) to `.edge` source text.