error unions, output folder path

Author: ngmachado

src/formal_verifier.zig

@@ -14,6 +14,9 @@ pub const FormalVerificationError = error{
     InvalidQuantifier,
     UnboundedLoop,
     ComplexityTooHigh,
+    ErrorUnionVerificationFailed,
+    ErrorPropagationIncomplete,
+    TryWithoutErrorUnion,
 };
 
 /// SMT solver backend types
@@ -267,6 +270,7 @@ pub const FormalVerifier = struct {
     theory_db: MathTheoryDB,
     symbolic_executor: SymbolicExecutor,
     proof_cache: ProofCache,
+    error_union_verifier: ErrorUnionVerifier,
     verification_config: VerificationConfig,
 
     pub const VerificationConfig = struct {
@@ -498,8 +502,8 @@ pub const FormalVerifier = struct {
                     .Mapping => MathDomain.Function,
                     .DoubleMap => MathDomain.Function,
                     .Identifier => MathDomain.Integer, // Default for custom types
-                    .ErrorUnion => MathDomain.Integer, // Error unions are treated as integers
-                    .Result => MathDomain.Integer, // Result types are treated as integers
+                    .ErrorUnion => MathDomain.Algebraic, // Error unions use algebraic data types
+                    .Result => MathDomain.Algebraic, // Result types use algebraic data types
                 };
             }
             return MathDomain.Integer;
@@ -510,13 +514,78 @@ pub const FormalVerifier = struct {
         }
     };
 
+    /// Error union verification methods
+    pub const ErrorUnionVerifier = struct {
+        allocator: Allocator,
+
+        pub fn init(allocator: Allocator) ErrorUnionVerifier {
+            return ErrorUnionVerifier{
+                .allocator = allocator,
+            };
+        }
+
+        pub fn deinit(self: *ErrorUnionVerifier) void {
+            _ = self;
+        }
+
+        /// Verify that all error paths are handled in try-catch blocks
+        pub fn verifyErrorPropagation(self: *ErrorUnionVerifier, try_block: *ast.TryBlockNode) FormalVerificationError!bool {
+            _ = self;
+            // TODO: Implement error propagation verification
+            // - Check that all possible error conditions are handled
+            // - Verify that error variables are properly typed
+            // - Ensure no error paths are missed
+
+            if (try_block.catch_block == null) {
+                return FormalVerificationError.ErrorPropagationIncomplete;
+            }
+
+            return true;
+        }
+
+        /// Verify that try expressions are only used with error union types
+        pub fn verifyTryExpression(self: *ErrorUnionVerifier, try_expr: *ast.TryExpr) FormalVerificationError!bool {
+            _ = self;
+            _ = try_expr;
+            // TODO: Implement try expression verification
+            // - Check that the expression being tried returns an error union
+            // - Verify that error propagation is correct
+            // - Ensure proper error handling context
+
+            return true;
+        }
+
+        /// Generate SMT constraints for error union types
+        pub fn generateErrorUnionConstraints(self: *ErrorUnionVerifier, error_union_type: *ast.ErrorUnionType, variable_name: []const u8) FormalVerificationError![]const u8 {
+            _ = error_union_type;
+
+            // Generate SMT-LIB constraints for error union
+            const constraint = try std.fmt.allocPrint(self.allocator, "(assert (or (= (tag {s}) success) (= (tag {s}) error)))", .{ variable_name, variable_name });
+
+            return constraint;
+        }
+
+        /// Verify error union invariants
+        pub fn verifyErrorUnionInvariants(self: *ErrorUnionVerifier, function: *ast.FunctionNode) FormalVerificationError!bool {
+            _ = self;
+            _ = function;
+            // TODO: Implement error union invariant verification
+            // - Check that error union functions properly handle all error cases
+            // - Verify that success cases don't leak errors
+            // - Ensure error union consistency across function calls
+
+            return true;
+        }
+    };
+
     pub fn init(allocator: Allocator) FormalVerifier {
         return FormalVerifier{
             .allocator = allocator,
             .smt_solver = SMTSolverType.Internal,
             .theory_db = MathTheoryDB.init(allocator),
             .symbolic_executor = SymbolicExecutor.init(allocator),
             .proof_cache = ProofCache.init(allocator),
+            .error_union_verifier = ErrorUnionVerifier.init(allocator),
             .verification_config = VerificationConfig{},
         };
     }
@@ -525,6 +594,7 @@ pub const FormalVerifier = struct {
         self.theory_db.deinit();
         self.symbolic_executor.deinit();
         self.proof_cache.deinit();
+        self.error_union_verifier.deinit();
     }
 
     /// Verify a complex formal condition

src/main.zig

@@ -29,62 +29,58 @@ pub fn main() !void {
         return;
     }
 
-    const command = args[1];
-
-    if (std.mem.eql(u8, command, "lex")) {
-        if (args.len < 3) {
-            try printUsage();
-            return;
-        }
-        try runLexer(allocator, args[2]);
-    } else if (std.mem.eql(u8, command, "parse")) {
-        if (args.len < 3) {
-            try printUsage();
-            return;
-        }
-        try runParser(allocator, args[2]);
-    } else if (std.mem.eql(u8, command, "analyze")) {
-        if (args.len < 3) {
-            try printUsage();
-            return;
-        }
-        try runSemanticAnalysis(allocator, args[2]);
-    } else if (std.mem.eql(u8, command, "ir")) {
-        if (args.len < 3) {
-            try printUsage();
-            return;
-        }
-        try runIRGeneration(allocator, args[2]);
-    } else if (std.mem.eql(u8, command, "compile")) {
-        if (args.len < 3) {
-            try printUsage();
-            return;
-        }
-        try runFullCompilation(allocator, args[2]);
-    } else if (std.mem.eql(u8, command, "ast")) {
-        if (args.len < 3) {
-            try printUsage();
-            return;
-        }
-        try runASTGeneration(allocator, args[2]);
-    } else if (std.mem.eql(u8, command, "hir")) {
-        if (args.len < 3) {
-            try printUsage();
-            return;
-        }
-        try runHIRGeneration(allocator, args[2]);
-    } else if (std.mem.eql(u8, command, "yul")) {
-        if (args.len < 3) {
-            try printUsage();
-            return;
-        }
-        try runYulGeneration(allocator, args[2]);
-    } else if (std.mem.eql(u8, command, "bytecode")) {
-        if (args.len < 3) {
+    // Parse arguments to find output directory option
+    var output_dir: ?[]const u8 = null;
+    var command: ?[]const u8 = null;
+    var input_file: ?[]const u8 = null;
+    var i: usize = 1;
+
+    while (i < args.len) {
+        if (std.mem.eql(u8, args[i], "-o") or std.mem.eql(u8, args[i], "--output-dir")) {
+            if (i + 1 >= args.len) {
+                try printUsage();
+                return;
+            }
+            output_dir = args[i + 1];
+            i += 2;
+        } else if (command == null) {
+            command = args[i];
+            i += 1;
+        } else if (input_file == null) {
+            input_file = args[i];
+            i += 1;
+        } else {
             try printUsage();
             return;
         }
-        try runBytecodeGeneration(allocator, args[2]);
+    }
+
+    if (command == null or input_file == null) {
+        try printUsage();
+        return;
+    }
+
+    const cmd = command.?;
+    const file_path = input_file.?;
+
+    if (std.mem.eql(u8, cmd, "lex")) {
+        try runLexer(allocator, file_path);
+    } else if (std.mem.eql(u8, cmd, "parse")) {
+        try runParser(allocator, file_path);
+    } else if (std.mem.eql(u8, cmd, "analyze")) {
+        try runSemanticAnalysis(allocator, file_path);
+    } else if (std.mem.eql(u8, cmd, "ir")) {
+        try runIRGeneration(allocator, file_path);
+    } else if (std.mem.eql(u8, cmd, "compile")) {
+        try runFullCompilation(allocator, file_path);
+    } else if (std.mem.eql(u8, cmd, "ast")) {
+        try runASTGeneration(allocator, file_path, output_dir);
+    } else if (std.mem.eql(u8, cmd, "hir")) {
+        try runHIRGeneration(allocator, file_path, output_dir);
+    } else if (std.mem.eql(u8, cmd, "yul")) {
+        try runYulGeneration(allocator, file_path, output_dir);
+    } else if (std.mem.eql(u8, cmd, "bytecode")) {
+        try runBytecodeGeneration(allocator, file_path, output_dir);
     } else {
         try printUsage();
     }
@@ -93,7 +89,9 @@ pub fn main() !void {
 fn printUsage() !void {
     const stdout = std.io.getStdOut().writer();
     try stdout.print("Ora DSL Compiler v0.1\n", .{});
-    try stdout.print("Usage: ora <command> <file>\n", .{});
+    try stdout.print("Usage: ora [options] <command> <file>\n", .{});
+    try stdout.print("\nOptions:\n", .{});
+    try stdout.print("  -o, --output-dir <dir>  - Specify output directory for generated files\n", .{});
     try stdout.print("\nCommands:\n", .{});
     try stdout.print("  lex <file>     - Tokenize a .ora file\n", .{});
     try stdout.print("  parse <file>   - Parse a .ora file to AST\n", .{});
@@ -104,6 +102,8 @@ fn printUsage() !void {
     try stdout.print("  hir <file>     - Generate HIR and save to JSON file\n", .{});
     try stdout.print("  yul <file>     - Generate Yul code from HIR\n", .{});
     try stdout.print("  bytecode <file> - Generate EVM bytecode from HIR\n", .{});
+    try stdout.print("\nExample:\n", .{});
+    try stdout.print("  ora -o build ast example.ora\n", .{});
 }
 
 /// Run lexer on file and display tokens
@@ -517,7 +517,7 @@ fn printAstSummary(writer: anytype, node: *lib.AstNode, indent: u32) !void {
 }
 
 /// Generate AST and save to JSON file
-fn runASTGeneration(allocator: std.mem.Allocator, file_path: []const u8) !void {
+fn runASTGeneration(allocator: std.mem.Allocator, file_path: []const u8, output_dir: ?[]const u8) !void {
     const stdout = std.io.getStdOut().writer();
 
     // Read source file
@@ -550,7 +550,21 @@ fn runASTGeneration(allocator: std.mem.Allocator, file_path: []const u8) !void {
     try stdout.print("Generated {} AST nodes\n", .{ast_nodes.len});
 
     // Generate output filename
-    const output_file = try std.mem.concat(allocator, u8, &[_][]const u8{ std.fs.path.stem(file_path), ".ast.json" });
+    const output_file = if (output_dir) |dir| blk: {
+        // Create output directory if it doesn't exist
+        std.fs.cwd().makeDir(dir) catch |err| switch (err) {
+            error.PathAlreadyExists => {},
+            else => return err,
+        };
+
+        const basename = std.fs.path.stem(file_path);
+        const filename = try std.mem.concat(allocator, u8, &[_][]const u8{ basename, ".ast.json" });
+        defer allocator.free(filename);
+        break :blk try std.fs.path.join(allocator, &[_][]const u8{ dir, filename });
+    } else blk: {
+        const basename = std.fs.path.stem(file_path);
+        break :blk try std.mem.concat(allocator, u8, &[_][]const u8{ basename, ".ast.json" });
+    };
     defer allocator.free(output_file);
 
     // Save AST to JSON file
@@ -570,7 +584,7 @@ fn runASTGeneration(allocator: std.mem.Allocator, file_path: []const u8) !void {
 }
 
 /// Generate HIR and save to JSON file
-fn runHIRGeneration(allocator: std.mem.Allocator, file_path: []const u8) !void {
+fn runHIRGeneration(allocator: std.mem.Allocator, file_path: []const u8, output_dir: ?[]const u8) !void {
     const stdout = std.io.getStdOut().writer();
 
     // Read source file
@@ -627,7 +641,21 @@ fn runHIRGeneration(allocator: std.mem.Allocator, file_path: []const u8) !void {
     try stdout.print("  {} contracts converted to HIR\n", .{hir_program.contracts.len});
 
     // Generate output filename
-    const output_file = try std.mem.concat(allocator, u8, &[_][]const u8{ std.fs.path.stem(file_path), ".hir.json" });
+    const output_file = if (output_dir) |dir| blk: {
+        // Create output directory if it doesn't exist
+        std.fs.cwd().makeDir(dir) catch |err| switch (err) {
+            error.PathAlreadyExists => {},
+            else => return err,
+        };
+
+        const basename = std.fs.path.stem(file_path);
+        const filename = try std.mem.concat(allocator, u8, &[_][]const u8{ basename, ".hir.json" });
+        defer allocator.free(filename);
+        break :blk try std.fs.path.join(allocator, &[_][]const u8{ dir, filename });
+    } else blk: {
+        const basename = std.fs.path.stem(file_path);
+        break :blk try std.mem.concat(allocator, u8, &[_][]const u8{ basename, ".hir.json" });
+    };
     defer allocator.free(output_file);
 
     // Save HIR to JSON file
@@ -647,7 +675,7 @@ fn runHIRGeneration(allocator: std.mem.Allocator, file_path: []const u8) !void {
 }
 
 /// Generate Yul code from HIR
-fn runYulGeneration(allocator: std.mem.Allocator, file_path: []const u8) !void {
+fn runYulGeneration(allocator: std.mem.Allocator, file_path: []const u8, output_dir: ?[]const u8) !void {
     const stdout = std.io.getStdOut().writer();
 
     // Read source file
@@ -703,7 +731,21 @@ fn runYulGeneration(allocator: std.mem.Allocator, file_path: []const u8) !void {
     try stdout.print("{s}\n", .{yul_code});
 
     // Save to file
-    const output_file = try std.mem.concat(allocator, u8, &[_][]const u8{ std.fs.path.stem(file_path), ".yul" });
+    const output_file = if (output_dir) |dir| blk: {
+        // Create output directory if it doesn't exist
+        std.fs.cwd().makeDir(dir) catch |err| switch (err) {
+            error.PathAlreadyExists => {},
+            else => return err,
+        };
+
+        const basename = std.fs.path.stem(file_path);
+        const filename = try std.mem.concat(allocator, u8, &[_][]const u8{ basename, ".yul" });
+        defer allocator.free(filename);
+        break :blk try std.fs.path.join(allocator, &[_][]const u8{ dir, filename });
+    } else blk: {
+        const basename = std.fs.path.stem(file_path);
+        break :blk try std.mem.concat(allocator, u8, &[_][]const u8{ basename, ".yul" });
+    };
     defer allocator.free(output_file);
 
     const file = std.fs.cwd().createFile(output_file, .{}) catch |err| {
@@ -717,7 +759,7 @@ fn runYulGeneration(allocator: std.mem.Allocator, file_path: []const u8) !void {
 }
 
 /// Generate EVM bytecode from HIR
-fn runBytecodeGeneration(allocator: std.mem.Allocator, file_path: []const u8) !void {
+fn runBytecodeGeneration(allocator: std.mem.Allocator, file_path: []const u8, output_dir: ?[]const u8) !void {
     const stdout = std.io.getStdOut().writer();
 
     // Read source file
@@ -781,7 +823,21 @@ fn runBytecodeGeneration(allocator: std.mem.Allocator, file_path: []const u8) !v
             try stdout.print("Bytecode: {s}\n", .{bytecode});
 
             // Save to file
-            const output_file = try std.mem.concat(allocator, u8, &[_][]const u8{ std.fs.path.stem(file_path), ".bin" });
+            const output_file = if (output_dir) |dir| blk: {
+                // Create output directory if it doesn't exist
+                std.fs.cwd().makeDir(dir) catch |err| switch (err) {
+                    error.PathAlreadyExists => {},
+                    else => return err,
+                };
+
+                const basename = std.fs.path.stem(file_path);
+                const filename = try std.mem.concat(allocator, u8, &[_][]const u8{ basename, ".bin" });
+                defer allocator.free(filename);
+                break :blk try std.fs.path.join(allocator, &[_][]const u8{ dir, filename });
+            } else blk: {
+                const basename = std.fs.path.stem(file_path);
+                break :blk try std.mem.concat(allocator, u8, &[_][]const u8{ basename, ".bin" });
+            };
             defer allocator.free(output_file);
 
             const file = std.fs.cwd().createFile(output_file, .{}) catch |err| {