Refactor: streamline evalWire function for clarity

Refactor the evalWire function to enhance readability and maintainability by clearly organizing steps for AST reading, evaluation, environment creation, transformation, and cleanup. Ensure proper resource management and error handling throughout the function.

include/shards/shards.h

@@ -1071,6 +1071,7 @@ struct SHLEvalEnv;
 typedef struct SHLAst(__cdecl *SHReadProc)(struct SHStringWithLen name, struct SHStringWithLen code,
                                            struct SHStringWithLen basePath, const struct SHStringWithLen *includeDirs,
                                            uint32_t numIncludeDirs);
+typedef struct SHLAst(__cdecl *SHLoadAstProc)(const uint8_t *bytes, uint32_t size);
 typedef struct SHLEvalEnv *(__cdecl *SHCreateEvalEnv)(struct SHStringWithLen namespace_);
 typedef void(__cdecl *SHFreeEvalEnv)(struct SHLEvalEnv *env);
 typedef struct SHLError *(__cdecl *SHEvalProc)(struct SHLEvalEnv *env, const struct SHVar *ast);
@@ -1210,6 +1211,7 @@ typedef struct _SHCore {
 
   // Language parsing and evaluation
   SHReadProc read;
+  SHLoadAstProc loadAst;
   SHCreateEvalEnv createEvalEnv;
   SHFreeEvalEnv freeEvalEnv;
   SHEvalProc eval;

include/shards/shards.swift

@@ -1357,6 +1357,41 @@ class Shards {
         let wireController = WireController(native: wire.wire.pointee!)
         return wireController
     }
+
+    static func evalWire(_ name: String, _ ast: [UInt8]) -> WireController? {
+        // Create SHStringWithLen instances
+        let nameStr = SwiftSWL(name)
+
+        // Read the AST
+        var ast = ast.withUnsafeBufferPointer { buffer in
+            G.Core.pointee.loadAst(buffer.baseAddress!, UInt32(buffer.count))
+        }
+        guard ast.error == nil else {
+            return nil
+        }
+
+        // Create evaluation environment
+        let emptyStr = SHStringWithLen.fromStatic("")
+        let env = G.Core.pointee.createEvalEnv(emptyStr)
+
+        // Evaluate the AST
+        let error = G.Core.pointee.eval(env, &ast.ast) // consumes ast
+        guard error == nil else {
+            G.Core.pointee.freeEvalEnv(env)
+            return nil
+        }
+
+        // Transform environment into a wire
+        var wire = G.Core.pointee.transformEnv(env, nameStr.asSHStringWithLen()) // consumes env
+        guard wire.error == nil else {
+            G.Core.pointee.freeWire(&wire)
+            return nil
+        }
+
+        // Create WireController from the resulting wire
+        let wireController = WireController(native: wire.wire.pointee!)
+        return wireController
+    }
 }
 
 #if canImport(UIKit)

shards/core/runtime.cpp

@@ -2570,6 +2570,7 @@ SHCore sh_current_interface{};
 extern "C" {
 SHLAst shards_read(SHStringWithLen name, SHStringWithLen code, SHStringWithLen base_path, const SHStringWithLen *include_dirs,
                    uint32_t num_include_dirs);
+SHLAst shards_load_ast(const uint8_t *bytes, uint32_t size);
 SHLEvalEnv *shards_create_env(SHStringWithLen namespace_);
 void shards_free_env(SHLEvalEnv *env);
 SHLError *shards_eval_env(SHLEvalEnv *env, const SHVar *ast);
@@ -3095,6 +3096,8 @@ SHCore *__cdecl shardsInterface(uint32_t abi_version) {
   result->read = [](SHStringWithLen name, SHStringWithLen code, SHStringWithLen basePath, const SHStringWithLen *includeDirs,
                     uint32_t numIncludeDirs) { return shards_read(name, code, basePath, includeDirs, numIncludeDirs); };
 
+  result->loadAst = [](const uint8_t *bytes, uint32_t size) { return shards_load_ast(bytes, size); };
+
   result->createEvalEnv = [](SHStringWithLen namespace_) { return shards_create_env(namespace_); };
 
   result->freeEvalEnv = [](SHLEvalEnv *env) { shards_free_env(env); };

shards/langffi/src/lib.rs

@@ -87,7 +87,7 @@ pub extern "C" fn shards_read(
 }
 
 #[no_mangle]
-pub extern "C" fn shards_load_ast(bytes: *mut u8, size: u32) -> SHLAst {
+pub extern "C" fn shards_load_ast(bytes: *const u8, size: u32) -> SHLAst {
   let bytes = unsafe { from_raw_parts_allow_null(bytes, size as usize) };
   let decoded_bin: Result<Program, _> = flexbuffers::from_slice(bytes);
   match decoded_bin {