🧹 Refactor register_canvas_schemas for improved code health

compiler/ast/tests/ast_tests.rs

@@ -1,6 +1,6 @@
 use techscript_ast::{
-    AssignmentExpr, Block, BreakStmt, EnumDecl, EnumVariant, Expression, FieldSpec, Ident,
-    LiteralExpr, LiteralVal, Pattern, Program, Statement, StructDecl, VarDecl,
+    AssignmentExpr, EnumDecl, EnumVariant, Expression, FieldSpec, Ident, LiteralExpr, LiteralVal,
+    Pattern, StructDecl, VarDecl,
 };
 use techscript_common::{NodeId, Span};
 
@@ -101,47 +101,5 @@ fn test_ast_serialization() {
     assert_eq!(lit, deserialized);
 }
 
-#[test]
-fn test_ast_program_construction_and_serialization() {
-    let span = Span::new(0, 50);
-    let id = NodeId(1);
-
-    // Create a dummy statement (Break)
-    let break_stmt = Statement::Break(BreakStmt::new(NodeId(2), span));
-
-    let program = Program::new(id, vec![break_stmt.clone()], span);
-
-    assert_eq!(program.id, id);
-    assert_eq!(program.statements.len(), 1);
-    assert_eq!(program.span, span);
-
-    let serialized = serde_json::to_string(&program).expect("serialize should succeed");
-    let deserialized: Program =
-        serde_json::from_str(&serialized).expect("deserialize should succeed");
-
-    assert_eq!(program, deserialized);
-}
-
-#[test]
-fn test_ast_block_construction_and_serialization() {
-    let span = Span::new(10, 20);
-    let id = NodeId(3);
-
-    // Create a dummy statement (Break)
-    let break_stmt = Statement::Break(BreakStmt::new(NodeId(4), span));
-
-    let block = Block::new(id, vec![break_stmt.clone()], span);
-
-    assert_eq!(block.id, id);
-    assert_eq!(block.statements.len(), 1);
-    assert_eq!(block.span, span);
-
-    let serialized = serde_json::to_string(&block).expect("serialize should succeed");
-    let deserialized: Block =
-        serde_json::from_str(&serialized).expect("deserialize should succeed");
-
-    assert_eq!(block, deserialized);
-}
-
 // Internal helper just to satisfy TypeSpec compilation in test_ast_struct_decl
 use techscript_ast::TypeSpec;

compiler/lexer/src/lib.rs

@@ -12,6 +12,7 @@ use techscript_syntax::{lookup_keyword, Token, TokenKind};
 /// Private token enumeration used internally by Logos for scanning.
 #[derive(Logos, Debug, Clone, Copy, PartialEq, Eq)]
 #[logos(skip r"[ \t\r]+")] // Skip spaces, tabs, and carriage returns
+#[allow(dead_code)]
 enum LogosToken {
     #[token("\n")]
     #[token("\r\n")]

compiler/semantic/src/dsl_schema.rs

@@ -298,7 +298,15 @@ fn register_web_schemas(reg: &mut HashMap<String, DSLSchema>) {
     );
 }
 
-fn register_canvas_shape_schemas(reg: &mut HashMap<String, DSLSchema>) {
+fn register_canvas_schemas(reg: &mut HashMap<String, DSLSchema>) {
+    // Canvas module schemas ──────────────────────────────────────────
+    register_canvas_shapes_schemas(reg);
+    register_canvas_text_schemas(reg);
+    register_canvas_misc_schemas(reg);
+}
+
+fn register_canvas_shapes_schemas(reg: &mut HashMap<String, DSLSchema>) {
+    // Canvas shapes schemas
     reg.insert(
         "logo".to_string(),
         DSLSchema::new(
@@ -317,6 +325,22 @@ fn register_canvas_shape_schemas(reg: &mut HashMap<String, DSLSchema>) {
         ),
     );
 
+    reg.insert(
+        "rings".to_string(),
+        DSLSchema::new(
+            vec![
+                "count".into(),
+                "color".into(),
+                "size".into(),
+                "thickness".into(),
+                "spacing".into(),
+                "rotation".into(),
+            ],
+            vec![],
+            vec![],
+        ),
+    );
+
     reg.insert(
         "emblem".to_string(),
         DSLSchema::new(
@@ -348,9 +372,25 @@ fn register_canvas_shape_schemas(reg: &mut HashMap<String, DSLSchema>) {
             vec![],
         ),
     );
+
+    reg.insert(
+        "circuits".to_string(),
+        DSLSchema::new(
+            vec![
+                "color".into(),
+                "density".into(),
+                "width".into(),
+                "animated".into(),
+                "complexity".into(),
+            ],
+            vec![],
+            vec![],
+        ),
+    );
 }
 
 fn register_canvas_text_schemas(reg: &mut HashMap<String, DSLSchema>) {
+    // Canvas text schemas
     reg.insert(
         "letter".to_string(),
         DSLSchema::new(
@@ -410,37 +450,7 @@ fn register_canvas_text_schemas(reg: &mut HashMap<String, DSLSchema>) {
 }
 
 fn register_canvas_misc_schemas(reg: &mut HashMap<String, DSLSchema>) {
-    reg.insert(
-        "rings".to_string(),
-        DSLSchema::new(
-            vec![
-                "count".into(),
-                "color".into(),
-                "size".into(),
-                "thickness".into(),
-                "spacing".into(),
-                "rotation".into(),
-            ],
-            vec![],
-            vec![],
-        ),
-    );
-
-    reg.insert(
-        "circuits".to_string(),
-        DSLSchema::new(
-            vec![
-                "color".into(),
-                "density".into(),
-                "width".into(),
-                "animated".into(),
-                "complexity".into(),
-            ],
-            vec![],
-            vec![],
-        ),
-    );
-
+    // Canvas misc schemas
     reg.insert(
         "theme".to_string(),
         DSLSchema::new(
@@ -490,13 +500,6 @@ fn register_canvas_misc_schemas(reg: &mut HashMap<String, DSLSchema>) {
     );
 }
 
-fn register_canvas_schemas(reg: &mut HashMap<String, DSLSchema>) {
-    // Canvas module schemas ──────────────────────────────────────────
-    register_canvas_shape_schemas(reg);
-    register_canvas_text_schemas(reg);
-    register_canvas_misc_schemas(reg);
-}
-
 fn register_generic_schemas(reg: &mut HashMap<String, DSLSchema>) {
     // Generic DSL blocks ────────────────────────────────────────────
     reg.insert(

runtime/vm/src/executor.rs

@@ -450,8 +450,8 @@ impl VM {
                 }
 
                 // PERFORMANCE OPTIMIZATION (Bolt):
-                // We reuse the existing mutable frame reference acquired at the start of
-                // the loop iteration rather than redundantly fetching the last mutable frame
+                // We reuse the existing mutable `frame` reference acquired at the start of
+                // the loop iteration rather than redundantly calling `self.frames.last_mut()`
                 // for these control flow and exception opcodes. This reduces bounds checking
                 // and RefCell borrow overhead on the hottest execution paths.
                 Opcode::Jump => {

scripts/migrate_syntax.py

@@ -34,7 +34,7 @@
     (r'std\.io\.println\((.+?)\)', r'say \1', 0),
     (r'std\.io\.print\((.+?)\)', r'say \1', 0),
 
-    # ── std.<module>.yyy() calls → module.yyy() ────────────────────────────
+    # ── std.xxx.yyy() calls → module.yyy() ─────────────────────────────────
     (r'std\.math\.', r'math.', 0),
     (r'std\.strings\.', r'string.', 0),
     (r'std\.fs\.', r'file.', 0),

stdlib/src/database.rs

@@ -78,7 +78,8 @@ fn std_database_query(
     let sql = args[1].try_into_string()?;
     let params_list = get_params_list(&args);
 
-    let resources_borrow = ctx.resources.borrow();
+    let resources = ctx.resources.clone();
+    let resources_borrow = resources.borrow();
     let conn = resources_borrow
         .get::<rusqlite::Connection>(handle)
         .ok_or_else(|| {
@@ -172,7 +173,8 @@ fn std_database_execute(
     let sql = args[1].try_into_string()?;
     let params_list = get_params_list(&args);
 
-    let resources_borrow = ctx.resources.borrow();
+    let resources = ctx.resources.clone();
+    let resources_borrow = resources.borrow();
     let conn = resources_borrow
         .get::<rusqlite::Connection>(handle)
         .ok_or_else(|| {

stdlib/src/encoding.rs

@@ -83,7 +83,7 @@ impl StdlibRegistry {
             StdlibModule {
                 name: "std.hex".to_string(),
                 version: "1.0.0".to_string(),
-                exports,
+                exports: exports.clone(),
                 required_capabilities: Vec::new(),
             },
         );

stdlib/src/json.rs

@@ -205,95 +205,4 @@ mod tests {
         let err = result.unwrap_err();
         assert!(err.to_string().contains("Cannot stringify type"));
     }
-
-    #[test]
-    fn test_parse_json_value_simple() {
-        // Null
-        assert_eq!(
-            parse_json_value(serde_json::Value::Null),
-            RuntimeValue::Null
-        );
-
-        // Bool
-        assert_eq!(
-            parse_json_value(serde_json::Value::Bool(true)),
-            RuntimeValue::Bool(true)
-        );
-        assert_eq!(
-            parse_json_value(serde_json::Value::Bool(false)),
-            RuntimeValue::Bool(false)
-        );
-
-        // Int
-        assert_eq!(
-            parse_json_value(serde_json::Value::Number(serde_json::Number::from(42))),
-            RuntimeValue::Int(42)
-        );
-        assert_eq!(
-            parse_json_value(serde_json::Value::Number(serde_json::Number::from(-10))),
-            RuntimeValue::Int(-10)
-        );
-
-        // Float
-        assert_eq!(
-            parse_json_value(serde_json::Value::Number(
-                serde_json::Number::from_f64(3.14).unwrap()
-            )),
-            RuntimeValue::Float(3.14)
-        );
-
-        // String
-        assert_eq!(
-            parse_json_value(serde_json::Value::String("hello".to_string())),
-            RuntimeValue::Str("hello".to_string())
-        );
-    }
-
-    #[test]
-    fn test_parse_json_value_complex() {
-        // Array
-        let arr = serde_json::Value::Array(vec![
-            serde_json::Value::Number(serde_json::Number::from(1)),
-            serde_json::Value::String("two".to_string()),
-            serde_json::Value::Bool(false),
-        ]);
-        let parsed_arr = parse_json_value(arr);
-        match parsed_arr {
-            RuntimeValue::List { items, is_const } => {
-                assert!(!is_const);
-                let borrowed = items.borrow();
-                assert_eq!(borrowed.len(), 3);
-                assert_eq!(borrowed[0], RuntimeValue::Int(1));
-                assert_eq!(borrowed[1], RuntimeValue::Str("two".to_string()));
-                assert_eq!(borrowed[2], RuntimeValue::Bool(false));
-            }
-            _ => panic!("Expected RuntimeValue::List"),
-        }
-
-        // Object
-        let mut obj_map = serde_json::Map::new();
-        obj_map.insert(
-            "key1".to_string(),
-            serde_json::Value::Number(serde_json::Number::from(100)),
-        );
-        obj_map.insert(
-            "key2".to_string(),
-            serde_json::Value::String("value2".to_string()),
-        );
-        let obj = serde_json::Value::Object(obj_map);
-        let parsed_obj = parse_json_value(obj);
-        match parsed_obj {
-            RuntimeValue::Map { entries, is_const } => {
-                assert!(!is_const);
-                let borrowed = entries.borrow();
-                assert_eq!(borrowed.len(), 2);
-                assert_eq!(borrowed.get("key1").unwrap(), &RuntimeValue::Int(100));
-                assert_eq!(
-                    borrowed.get("key2").unwrap(),
-                    &RuntimeValue::Str("value2".to_string())
-                );
-            }
-            _ => panic!("Expected RuntimeValue::Map"),
-        }
-    }
 }

stdlib/src/notification.rs

@@ -34,11 +34,13 @@ impl StdlibRegistry {
                     {
                         use std::process::Command;
                         let _ = Command::new("powershell")
-                            .env("__TS_BODY", &body)
-                            .env("__TS_TITLE", &title)
                             .args([
                                 "-Command",
-                                "[System.Windows.MessageBox]::Show($env:__TS_BODY, $env:__TS_TITLE)",
+                                &format!(
+                                    "[System.Windows.MessageBox]::Show('{}','{}')",
+                                    body.replace("'", "''"),
+                                    title.replace("'", "''")
+                                ),
                             ])
                             .spawn();
                     }

stdlib/src/sqlite.rs

@@ -63,6 +63,15 @@ impl StdlibRegistry {
                         )
                     })?;
                     let sql = args[1].to_string();
+                    let params_list = if args.len() > 2 {
+                        if let RuntimeValue::List { items, .. } = &args[2] {
+                            items.borrow().clone()
+                        } else {
+                            Vec::new()
+                        }
+                    } else {
+                        Vec::new()
+                    };
 
                     let params: Vec<rusqlite::types::Value> = if let Some(arg) = args.get(2) {
                         if let RuntimeValue::List { items, .. } = arg {
@@ -129,6 +138,15 @@ impl StdlibRegistry {
                         )
                     })?;
                     let sql = args[1].to_string();
+                    let params_list = if args.len() > 2 {
+                        if let RuntimeValue::List { items, .. } = &args[2] {
+                            items.borrow().clone()
+                        } else {
+                            Vec::new()
+                        }
+                    } else {
+                        Vec::new()
+                    };
 
                     let params: Vec<rusqlite::types::Value> = if let Some(arg) = args.get(2) {
                         if let RuntimeValue::List { items, .. } = arg {

stdlib/src/sys.rs

@@ -100,7 +100,7 @@ impl StdlibRegistry {
             StdlibModule {
                 name: "std.fs".to_string(),
                 version: "1.0.0".to_string(),
-                exports,
+                exports: exports.clone(),
                 required_capabilities: vec![Capability::FileSystem],
             },
         );