@tishlang/tish 1.6.0 → 1.7.0

package/crates/tish_compile/src/infer.rs

@@ -22,7 +22,9 @@ pub struct InferCtx {
 
 impl InferCtx {
     pub fn new() -> Self {
-        Self { scopes: vec![HashMap::new()] }
+        Self {
+            scopes: vec![HashMap::new()],
+        }
     }
 
     fn push_scope(&mut self) {
@@ -75,17 +77,16 @@ pub fn infer_expr_type(expr: &Expr, ctx: &InferCtx) -> Option<TypeAnnotation> {
             Literal::Null => None,
         },
         Expr::Ident { name, .. } => ctx.lookup(name.as_ref()).cloned(),
-        Expr::Binary { left, op, right, .. } => {
+        Expr::Binary {
+            left, op, right, ..
+        } => {
             let lt = infer_expr_type(left, ctx)?;
             let rt = infer_expr_type(right, ctx)?;
             if is_number(&lt) && is_number(&rt) {
                 match op {
-                    BinOp::Add
-                    | BinOp::Sub
-                    | BinOp::Mul
-                    | BinOp::Div
-                    | BinOp::Mod
-                    | BinOp::Pow => Some(number_ann()),
+                    BinOp::Add | BinOp::Sub | BinOp::Mul | BinOp::Div | BinOp::Mod | BinOp::Pow => {
+                        Some(number_ann())
+                    }
                     BinOp::Lt
                     | BinOp::Le
                     | BinOp::Gt
@@ -103,7 +104,11 @@ pub fn infer_expr_type(expr: &Expr, ctx: &InferCtx) -> Option<TypeAnnotation> {
             match op {
                 UnaryOp::Neg | UnaryOp::Pos => {
                     let t = infer_expr_type(operand, ctx)?;
-                    if is_number(&t) { Some(number_ann()) } else { None }
+                    if is_number(&t) {
+                        Some(number_ann())
+                    } else {
+                        None
+                    }
                 }
                 UnaryOp::Not => Some(bool_ann()),
                 _ => None,
@@ -117,7 +122,9 @@ pub fn infer_expr_type(expr: &Expr, ctx: &InferCtx) -> Option<TypeAnnotation> {
 /// type annotations filled in on `VarDecl` nodes.
 pub fn infer_program(program: &Program) -> Program {
     let mut ctx = InferCtx::new();
-    Program { statements: infer_statements(&program.statements, &mut ctx) }
+    Program {
+        statements: infer_statements(&program.statements, &mut ctx),
+    }
 }
 
 fn infer_statements(stmts: &[Statement], ctx: &mut InferCtx) -> Vec<Statement> {
@@ -126,7 +133,13 @@ fn infer_statements(stmts: &[Statement], ctx: &mut InferCtx) -> Vec<Statement> {
 
 fn infer_statement(stmt: &Statement, ctx: &mut InferCtx) -> Statement {
     match stmt {
-        Statement::VarDecl { name, mutable, type_ann, init, span } => {
+        Statement::VarDecl {
+            name,
+            mutable,
+            type_ann,
+            init,
+            span,
+        } => {
             // Already annotated — propagate into ctx but don't change the node.
             if let Some(ann) = type_ann {
                 ctx.define(name.as_ref(), ann.clone());
@@ -149,9 +162,18 @@ fn infer_statement(stmt: &Statement, ctx: &mut InferCtx) -> Statement {
             ctx.push_scope();
             let stmts = infer_statements(statements, ctx);
             ctx.pop_scope();
-            Statement::Block { statements: stmts, span: *span }
+            Statement::Block {
+                statements: stmts,
+                span: *span,
+            }
         }
-        Statement::For { init, cond, update, body, span } => {
+        Statement::For {
+            init,
+            cond,
+            update,
+            body,
+            span,
+        } => {
             // Scope for loop variable
             ctx.push_scope();
             let new_init = init.as_ref().map(|i| Box::new(infer_statement(i, ctx)));
@@ -165,7 +187,12 @@ fn infer_statement(stmt: &Statement, ctx: &mut InferCtx) -> Statement {
                 span: *span,
             }
         }
-        Statement::ForOf { name, iterable, body, span } => {
+        Statement::ForOf {
+            name,
+            iterable,
+            body,
+            span,
+        } => {
             ctx.push_scope();
             let new_body = Box::new(infer_statement(body, ctx));
             ctx.pop_scope();
@@ -180,17 +207,32 @@ fn infer_statement(stmt: &Statement, ctx: &mut InferCtx) -> Statement {
             ctx.push_scope();
             let new_body = Box::new(infer_statement(body, ctx));
             ctx.pop_scope();
-            Statement::While { cond: cond.clone(), body: new_body, span: *span }
+            Statement::While {
+                cond: cond.clone(),
+                body: new_body,
+                span: *span,
+            }
         }
         Statement::DoWhile { body, cond, span } => {
             ctx.push_scope();
             let new_body = Box::new(infer_statement(body, ctx));
             ctx.pop_scope();
-            Statement::DoWhile { body: new_body, cond: cond.clone(), span: *span }
+            Statement::DoWhile {
+                body: new_body,
+                cond: cond.clone(),
+                span: *span,
+            }
         }
-        Statement::If { cond, then_branch, else_branch, span } => {
+        Statement::If {
+            cond,
+            then_branch,
+            else_branch,
+            span,
+        } => {
             let new_then = Box::new(infer_statement(then_branch, ctx));
-            let new_else = else_branch.as_ref().map(|e| Box::new(infer_statement(e, ctx)));
+            let new_else = else_branch
+                .as_ref()
+                .map(|e| Box::new(infer_statement(e, ctx)));
             Statement::If {
                 cond: cond.clone(),
                 then_branch: new_then,
@@ -198,7 +240,15 @@ fn infer_statement(stmt: &Statement, ctx: &mut InferCtx) -> Statement {
                 span: *span,
             }
         }
-        Statement::FunDecl { async_, name, params, rest_param, return_type, body, span } => {
+        Statement::FunDecl {
+            async_,
+            name,
+            params,
+            rest_param,
+            return_type,
+            body,
+            span,
+        } => {
             ctx.push_scope();
             for p in params {
                 if let FunParam::Simple(tp) = p {

package/crates/tish_compile/src/lib.rs

@@ -7,11 +7,11 @@ mod infer;
 mod resolve;
 mod types;
 
+pub use codegen::CompileError;
 pub use codegen::{
     compile, compile_project, compile_project_full, compile_with_features,
     compile_with_native_modules, compile_with_project_root,
 };
-pub use codegen::CompileError;
 pub use resolve::{
     cargo_export_fn_name, compute_native_build_artifacts, detect_cycles, export_name_to_rust_ident,
     extract_native_import_features, format_rust_dependencies_toml, generate_native_wrapper_rs,
@@ -44,7 +44,10 @@ fn sum(...args: number[]): number {
         // total should be declared as f64
         assert!(rust.contains("let mut total: f64"), "expected total: f64");
         // The return value of run() should convert total back to Value
-        assert!(rust.contains("Value::Number(total)"), "expected Value::Number(total) wrapping");
+        assert!(
+            rust.contains("Value::Number(total)"),
+            "expected Value::Number(total) wrapping"
+        );
     }
 
     #[test]
@@ -60,7 +63,10 @@ for (let i = 0; i < 5; i = i + 1) {
         let program = parse(src).unwrap();
         let rust = compile(&program).unwrap();
         // outerVar and x are f64 (inferred) — Copy assignment, no .clone() needed.
-        assert!(rust.contains("let mut outerVar: f64"), "expected outerVar: f64");
+        assert!(
+            rust.contains("let mut outerVar: f64"),
+            "expected outerVar: f64"
+        );
         assert!(rust.contains("let mut x: f64"), "expected x: f64");
     }
 
@@ -105,13 +111,17 @@ fn factory() {
         // This test verifies the full benchmark_granular project compiles and that outerVar
         // is emitted as the inferred f64 type rather than requiring a Value clone.
         let manifest = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-        let bench = manifest.join("../../tests/core/benchmark_granular.tish").canonicalize().unwrap();
+        let bench = manifest
+            .join("../../tests/core/benchmark_granular.tish")
+            .canonicalize()
+            .unwrap();
         // Use same default features as tish CLI (http, fs, process, regex)
         let features = ["http", "fs", "process", "regex"]
             .into_iter()
             .map(String::from)
             .collect::<Vec<_>>();
-        let (rust, _, _, _) = compile_project_full(&bench, bench.parent(), &features, true).unwrap();
+        let (rust, _, _, _) =
+            compile_project_full(&bench, bench.parent(), &features, true).unwrap();
         // outerVar = 42 is inferred as f64; f64 is Copy so no .clone() is emitted.
         assert!(
             rust.contains("let mut outerVar: f64"),

package/crates/tish_compile/src/resolve.rs

@@ -73,7 +73,10 @@ pub fn is_builtin_native_spec(spec: &str) -> bool {
 /// Resolve all native imports in a merged program via package.json lookup.
 /// Built-in modules (tish:fs, tish:http, tish:process) are skipped - they use tishlang_runtime directly.
 /// Handles both lowered `NativeModuleLoad` (merged modules) and raw `import { … } from 'tish:…'`.
-pub fn resolve_native_modules(program: &Program, project_root: &Path) -> Result<Vec<ResolvedNativeModule>, String> {
+pub fn resolve_native_modules(
+    program: &Program,
+    project_root: &Path,
+) -> Result<Vec<ResolvedNativeModule>, String> {
     let root_canon = project_root
         .canonicalize()
         .map_err(|e| format!("Cannot canonicalize project root: {}", e))?;
@@ -131,12 +134,17 @@ pub fn cargo_export_fn_name(spec: &str) -> String {
     out
 }
 
-fn resolve_cargo_native_module(spec: &str, project_root: &Path) -> Result<ResolvedNativeModule, String> {
+fn resolve_cargo_native_module(
+    spec: &str,
+    project_root: &Path,
+) -> Result<ResolvedNativeModule, String> {
     let tail = spec
         .strip_prefix("cargo:")
         .ok_or_else(|| format!("Invalid cargo native spec: {}", spec))?;
     if tail.is_empty() {
-        return Err("cargo: import needs a dependency name, e.g. import { x } from 'cargo:serde_json'".into());
+        return Err(
+            "cargo: import needs a dependency name, e.g. import { x } from 'cargo:my_crate'".into(),
+        );
     }
     let dep_key = tail.to_string();
     let tish = read_project_tish_config(project_root);
@@ -179,14 +187,26 @@ fn resolve_native_module(spec: &str, project_root: &Path) -> Result<ResolvedNati
     let pkg_json = pkg_dir.join("package.json");
     let content = std::fs::read_to_string(&pkg_json)
         .map_err(|e| format!("Cannot read {}: {}", pkg_json.display(), e))?;
-    let json: serde_json::Value =
-        serde_json::from_str(&content).map_err(|e| format!("Invalid JSON in {}: {}", pkg_json.display(), e))?;
+    let json: serde_json::Value = serde_json::from_str(&content)
+        .map_err(|e| format!("Invalid JSON in {}: {}", pkg_json.display(), e))?;
     let tish = json
         .get("tish")
         .and_then(|v| v.as_object())
-        .ok_or_else(|| format!("Package {} has no \"tish\" config in package.json", package_name))?;
-    if !tish.get("module").and_then(|v| v.as_bool()).unwrap_or(false) {
-        return Err(format!("Package {} is not a Tish native module (tish.module must be true)", package_name));
+        .ok_or_else(|| {
+            format!(
+                "Package {} has no \"tish\" config in package.json",
+                package_name
+            )
+        })?;
+    if !tish
+        .get("module")
+        .and_then(|v| v.as_bool())
+        .unwrap_or(false)
+    {
+        return Err(format!(
+            "Package {} is not a Tish native module (tish.module must be true)",
+            package_name
+        ));
     }
     let raw_crate = tish
         .get("crate")
@@ -219,7 +239,9 @@ pub fn read_project_tish_config(project_root: &Path) -> serde_json::Value {
     let Ok(json) = serde_json::from_str::<serde_json::Value>(&content) else {
         return serde_json::json!({});
     };
-    json.get("tish").cloned().unwrap_or_else(|| serde_json::json!({}))
+    json.get("tish")
+        .cloned()
+        .unwrap_or_else(|| serde_json::json!({}))
 }
 
 fn resolve_cargo_path_for_toml(project_root: &Path, raw: &str) -> String {
@@ -233,7 +255,10 @@ fn resolve_cargo_path_for_toml(project_root: &Path, raw: &str) -> String {
     resolved.display().to_string().replace('\\', "/")
 }
 
-fn json_to_cargo_inline_value(v: &serde_json::Value, project_root: &Path) -> Result<String, String> {
+fn json_to_cargo_inline_value(
+    v: &serde_json::Value,
+    project_root: &Path,
+) -> Result<String, String> {
     match v {
         serde_json::Value::String(s) => Ok(format!("{:?}", s.as_str())),
         serde_json::Value::Bool(b) => Ok(b.to_string()),
@@ -264,7 +289,10 @@ fn json_to_cargo_inline_value(v: &serde_json::Value, project_root: &Path) -> Res
 
 /// Serialize `tish.rustDependencies` from project `package.json` into Cargo.toml `[dependencies]` lines.
 /// Relative `path = "…"` entries in inline tables are resolved against `project_root` so the temp build crate can find them.
-pub fn format_rust_dependencies_toml(tish: &serde_json::Value, project_root: &Path) -> Result<String, String> {
+pub fn format_rust_dependencies_toml(
+    tish: &serde_json::Value,
+    project_root: &Path,
+) -> Result<String, String> {
     let Some(obj) = tish.get("rustDependencies").and_then(|v| v.as_object()) else {
         return Ok(String::new());
     };
@@ -313,7 +341,10 @@ pub fn infer_native_module_exports(program: &Program) -> HashMap<String, HashSet
     for stmt in &program.statements {
         match stmt {
             Statement::VarDecl {
-                init: Some(Expr::NativeModuleLoad { spec, export_name, .. }),
+                init:
+                    Some(Expr::NativeModuleLoad {
+                        spec, export_name, ..
+                    }),
                 ..
             } => {
                 let s = spec.as_ref();
@@ -324,8 +355,11 @@ pub fn infer_native_module_exports(program: &Program) -> HashMap<String, HashSet
                     .or_default()
                     .insert(export_name.to_string());
             }
-            Statement::Import { specifiers, from, .. } if is_native_import(from.as_ref()) => {
-                let spec = normalize_builtin_spec(from.as_ref()).unwrap_or_else(|| from.to_string());
+            Statement::Import {
+                specifiers, from, ..
+            } if is_native_import(from.as_ref()) => {
+                let spec =
+                    normalize_builtin_spec(from.as_ref()).unwrap_or_else(|| from.to_string());
                 if is_builtin_native_spec(&spec) {
                     continue;
                 }
@@ -358,7 +392,11 @@ pub fn generate_native_wrapper_rs(
     );
     let mut any = false;
     for m in modules {
-        let Some(NativeModuleInit::Generated { shim_crate, export_fn }) = init_by_spec.get(&m.spec) else {
+        let Some(NativeModuleInit::Generated {
+            shim_crate,
+            export_fn,
+        }) = init_by_spec.get(&m.spec)
+        else {
             continue;
         };
         let Some(names) = inferred.get(&m.spec) else {
@@ -405,9 +443,16 @@ pub fn compute_native_build_artifacts(
     let mut native_init: HashMap<String, NativeModuleInit> = HashMap::new();
     for m in native_modules {
         let use_gen = if is_cargo_native_spec(&m.spec) {
-            inferred.get(&m.spec).map(|s| !s.is_empty()).unwrap_or(false)
+            inferred
+                .get(&m.spec)
+                .map(|s| !s.is_empty())
+                .unwrap_or(false)
         } else {
-            gen_tish && inferred.get(&m.spec).map(|s| !s.is_empty()).unwrap_or(false)
+            gen_tish
+                && inferred
+                    .get(&m.spec)
+                    .map(|s| !s.is_empty())
+                    .unwrap_or(false)
         };
         let init = if use_gen {
             NativeModuleInit::Generated {
@@ -538,13 +583,18 @@ pub fn resolve_project(
     entry_path: &Path,
     project_root: Option<&Path>,
 ) -> Result<Vec<ResolvedModule>, String> {
-    let project_root = project_root.unwrap_or_else(|| entry_path.parent().unwrap_or(Path::new(".")));
+    let project_root =
+        project_root.unwrap_or_else(|| entry_path.parent().unwrap_or(Path::new(".")));
     let entry_canon = entry_path
         .canonicalize()
         .map_err(|e| format!("Cannot canonicalize entry {}: {}", entry_path.display(), e))?;
-    let root_canon = project_root
-        .canonicalize()
-        .map_err(|e| format!("Cannot canonicalize project root {}: {}", project_root.display(), e))?;
+    let root_canon = project_root.canonicalize().map_err(|e| {
+        format!(
+            "Cannot canonicalize project root {}: {}",
+            project_root.display(),
+            e
+        )
+    })?;
 
     let mut visited = HashSet::new();
     let mut path_to_module: HashMap<PathBuf, Program> = HashMap::new();
@@ -574,21 +624,23 @@ pub fn resolve_project_from_stdin(
     source: &str,
     project_root: &Path,
 ) -> Result<Vec<ResolvedModule>, String> {
-    let root_canon = project_root
-        .canonicalize()
-        .map_err(|e| format!("Cannot canonicalize project root {}: {}", project_root.display(), e))?;
+    let root_canon = project_root.canonicalize().map_err(|e| {
+        format!(
+            "Cannot canonicalize project root {}: {}",
+            project_root.display(),
+            e
+        )
+    })?;
 
     let stdin_path = root_canon.join("<stdin>");
-    let program = tishlang_parser::parse(source)
-        .map_err(|e| format!("Parse error (stdin): {}", e))?;
+    let program =
+        tishlang_parser::parse(source).map_err(|e| format!("Parse error (stdin): {}", e))?;
 
     let mut visited = HashSet::new();
     let mut path_to_module: HashMap<PathBuf, Program> = HashMap::new();
     let mut load_order: Vec<PathBuf> = Vec::new();
 
-    let from_dir = stdin_path
-        .parent()
-        .unwrap_or_else(|| Path::new("."));
+    let from_dir = stdin_path.parent().unwrap_or_else(|| Path::new("."));
 
     for stmt in &program.statements {
         if let Statement::Import { from, .. } = stmt {
@@ -787,7 +839,10 @@ pub fn detect_cycles(modules: &[ResolvedModule]) -> Result<(), String> {
                 .iter()
                 .map(|&i| modules[i].path.display().to_string())
                 .collect();
-            return Err(format!("Circular import detected: {}", path_names.join(" -> ")));
+            return Err(format!(
+                "Circular import detected: {}",
+                path_names.join(" -> ")
+            ));
         }
     }
     Ok(())
@@ -817,14 +872,8 @@ fn has_cycle_from(
                     stack.push(dep_idx);
                     let dep = &modules[dep_idx];
                     let dep_dir = dep.path.parent().unwrap_or(Path::new("."));
-                    if has_cycle_from(
-                        dep_dir,
-                        &dep.program,
-                        path_to_idx,
-                        modules,
-                        stack,
-                        visiting,
-                    )? {
+                    if has_cycle_from(dep_dir, &dep.program, path_to_idx, modules, stack, visiting)?
+                    {
                         return Ok(true);
                     }
                     stack.pop();
@@ -874,12 +923,15 @@ pub fn merge_modules(modules: Vec<ResolvedModule>) -> Result<Program, String> {
         let dir = module.path.parent().unwrap_or(Path::new("."));
         for stmt in &module.program.statements {
             match stmt {
-                Statement::Import { specifiers, from, span } => {
+                Statement::Import {
+                    specifiers,
+                    from,
+                    span,
+                } => {
                     if is_native_import(from.as_ref()) {
                         // Normalize fs/http/process -> tish:fs etc. for Node compatibility
-                        let canonical_spec =
-                            normalize_builtin_spec(from.as_ref())
-                                .unwrap_or_else(|| from.to_string());
+                        let canonical_spec = normalize_builtin_spec(from.as_ref())
+                            .unwrap_or_else(|| from.to_string());
                         // Emit VarDecl with NativeModuleLoad for each specifier
                         for spec in specifiers {
                             match spec {
@@ -918,9 +970,7 @@ pub fn merge_modules(modules: Vec<ResolvedModule>) -> Result<Program, String> {
                         continue;
                     }
                     let dep_path = resolve_import_path(from.as_ref(), dir, Path::new("."))?;
-                    let dep_path = dep_path
-                        .canonicalize()
-                        .unwrap_or(dep_path);
+                    let dep_path = dep_path.canonicalize().unwrap_or(dep_path);
                     let dep_idx = *path_to_idx
                         .get(&dep_path)
                         .ok_or_else(|| format!("Resolved import '{}' not in module list", from))?;
@@ -961,18 +1011,13 @@ pub fn merge_modules(modules: Vec<ResolvedModule>) -> Result<Program, String> {
                                     name: ns.clone(),
                                     mutable: false,
                                     type_ann: None,
-                                    init: Some(Expr::Object {
-                                        props,
-                                        span: *span,
-                                    }),
+                                    init: Some(Expr::Object { props, span: *span }),
                                     span: *span,
                                 });
                             }
                             ImportSpecifier::Default(bind) => {
-                                let source = dep_exports
-                                    .get("default")
-                                    .cloned()
-                                    .ok_or_else(|| {
+                                let source =
+                                    dep_exports.get("default").cloned().ok_or_else(|| {
                                         format!("Module '{}' has no default export", from)
                                     })?;
                                 statements.push(Statement::VarDecl {
@@ -989,21 +1034,19 @@ pub fn merge_modules(modules: Vec<ResolvedModule>) -> Result<Program, String> {
                         }
                     }
                 }
-                Statement::Export { declaration, .. } => {
-                    match declaration.as_ref() {
-                        ExportDeclaration::Named(s) => statements.push(*s.clone()),
-                        ExportDeclaration::Default(e) => {
-                            let default_name = format!("__default_{}", idx);
-                            statements.push(Statement::VarDecl {
-                                name: Arc::from(default_name),
-                                mutable: false,
-                                type_ann: None,
-                                init: Some((*e).clone()),
-                                span: e.span(),
-                            });
-                        }
+                Statement::Export { declaration, .. } => match declaration.as_ref() {
+                    ExportDeclaration::Named(s) => statements.push(*s.clone()),
+                    ExportDeclaration::Default(e) => {
+                        let default_name = format!("__default_{}", idx);
+                        statements.push(Statement::VarDecl {
+                            name: Arc::from(default_name),
+                            mutable: false,
+                            type_ann: None,
+                            init: Some((*e).clone()),
+                            span: e.span(),
+                        });
                     }
-                }
+                },
                 _ => statements.push(stmt.clone()),
             }
         }
@@ -1051,8 +1094,8 @@ mod cargo_spec_tests {
     #[test]
     fn cargo_export_fn_name_sanitizes() {
         assert_eq!(
-            cargo_export_fn_name("cargo:serde_json"),
-            "cargo_native_serde_json_object"
+            cargo_export_fn_name("cargo:tish_serde_json"),
+            "cargo_native_tish_serde_json_object"
         );
         assert_eq!(
             cargo_export_fn_name("cargo:my-crate"),

package/crates/tish_compile/src/types.rs

@@ -45,9 +45,7 @@ impl RustType {
                 "any" => RustType::Value,
                 _ => RustType::Value, // Unknown types fall back to Value
             },
-            TypeAnnotation::Array(elem) => {
-                RustType::Vec(Box::new(Self::from_annotation(elem)))
-            }
+            TypeAnnotation::Array(elem) => RustType::Vec(Box::new(Self::from_annotation(elem))),
             TypeAnnotation::Object(fields) => {
                 let typed_fields: Vec<_> = fields
                     .iter()
@@ -66,13 +64,13 @@ impl RustType {
             TypeAnnotation::Union(types) => {
                 // Check for T | null pattern -> Option<T>
                 if types.len() == 2 {
-                    let has_null = types.iter().any(|t| {
-                        matches!(t, TypeAnnotation::Simple(s) if s.as_ref() == "null")
-                    });
+                    let has_null = types
+                        .iter()
+                        .any(|t| matches!(t, TypeAnnotation::Simple(s) if s.as_ref() == "null"));
                     if has_null {
-                        let non_null = types.iter().find(|t| {
-                            !matches!(t, TypeAnnotation::Simple(s) if s.as_ref() == "null")
-                        });
+                        let non_null = types.iter().find(
+                            |t| !matches!(t, TypeAnnotation::Simple(s) if s.as_ref() == "null"),
+                        );
                         if let Some(inner) = non_null {
                             return RustType::Option(Box::new(Self::from_annotation(inner)));
                         }
@@ -271,9 +269,7 @@ impl TypeContext {
 
     /// Check if a variable is typed (has a non-Value type).
     pub fn is_typed(&self, name: &str) -> bool {
-        self.lookup(name)
-            .map(|ty| ty.is_native())
-            .unwrap_or(false)
+        self.lookup(name).map(|ty| ty.is_native()).unwrap_or(false)
     }
 
     /// Get the type of a variable, defaulting to Value if not found.
@@ -329,12 +325,12 @@ mod tests {
         ctx.define("x", RustType::F64);
         assert_eq!(ctx.get_type("x"), RustType::F64);
         assert!(ctx.is_typed("x"));
-        
+
         ctx.push_scope();
         ctx.define("y", RustType::String);
         assert_eq!(ctx.get_type("y"), RustType::String);
         assert_eq!(ctx.get_type("x"), RustType::F64); // Can still see outer scope
-        
+
         ctx.pop_scope();
         assert_eq!(ctx.get_type("y"), RustType::Value); // y no longer visible
     }