@tishlang/tish 1.6.0 → 1.8.0

package/crates/tish_ast/src/ast.rs

@@ -30,11 +30,11 @@ pub enum TypeAnnotation {
 #[derive(Debug, Clone, PartialEq)]
 pub struct TypedParam {
     pub name: Arc<str>,
+    pub name_span: Span,
     pub type_ann: Option<TypeAnnotation>,
     pub default: Option<Expr>,
 }
 
-
 /// Single formal parameter: simple identifier or destructuring pattern.
 #[derive(Debug, Clone, PartialEq)]
 pub enum FunParam {
@@ -46,7 +46,6 @@ pub enum FunParam {
     },
 }
 
-
 impl FunParam {
     /// Variable names introduced by this formal parameter.
     pub fn bound_names(&self) -> Vec<Arc<str>> {
@@ -66,11 +65,11 @@ impl FunParam {
                 for el in elements {
                     if let Some(el) = el {
                         match el {
-                            DestructElement::Ident(n) => out.push(Arc::clone(n)),
+                            DestructElement::Ident(n, _) => out.push(Arc::clone(n)),
                             DestructElement::Pattern(p) => {
                                 Self::collect_pattern_binding_names(p, out);
                             }
-                            DestructElement::Rest(n) => out.push(Arc::clone(n)),
+                            DestructElement::Rest(n, _) => out.push(Arc::clone(n)),
                         }
                     }
                 }
@@ -78,11 +77,11 @@ impl FunParam {
             DestructPattern::Object(props) => {
                 for prop in props {
                     match &prop.value {
-                        DestructElement::Ident(n) => out.push(Arc::clone(n)),
+                        DestructElement::Ident(n, _) => out.push(Arc::clone(n)),
                         DestructElement::Pattern(p) => {
                             Self::collect_pattern_binding_names(p, out);
                         }
-                        DestructElement::Rest(n) => out.push(Arc::clone(n)),
+                        DestructElement::Rest(n, _) => out.push(Arc::clone(n)),
                     }
                 }
             }
@@ -103,11 +102,11 @@ pub enum DestructPattern {
 #[derive(Debug, Clone, PartialEq)]
 pub enum DestructElement {
     /// Simple binding: a
-    Ident(Arc<str>),
+    Ident(Arc<str>, Span),
     /// Nested pattern: [a, b] or { x, y }
     Pattern(Box<DestructPattern>),
     /// Rest element: ...rest
-    Rest(Arc<str>),
+    Rest(Arc<str>, Span),
 }
 
 /// Property in object destructuring pattern
@@ -123,11 +122,22 @@ pub struct DestructProp {
 #[derive(Debug, Clone, PartialEq)]
 pub enum ImportSpecifier {
     /// Named: { foo } or { foo as bar }
-    Named { name: Arc<str>, alias: Option<Arc<str>> },
+    Named {
+        name: Arc<str>,
+        name_span: Span,
+        alias: Option<Arc<str>>,
+        alias_span: Option<Span>,
+    },
     /// Namespace: * as M
-    Namespace(Arc<str>),
+    Namespace {
+        name: Arc<str>,
+        name_span: Span,
+    },
     /// Default: import X from "..."
-    Default(Arc<str>),
+    Default {
+        name: Arc<str>,
+        name_span: Span,
+    },
 }
 
 /// Export declaration: named (const/let/fn) or default
@@ -152,6 +162,7 @@ pub enum Statement {
     },
     VarDecl {
         name: Arc<str>,
+        name_span: Span,
         mutable: bool, // true for `let`, false for `const`
         type_ann: Option<TypeAnnotation>,
         init: Option<Expr>,
@@ -188,6 +199,7 @@ pub enum Statement {
     },
     ForOf {
         name: Arc<str>,
+        name_span: Span,
         iterable: Expr,
         body: Box<Statement>,
         span: Span,
@@ -205,6 +217,7 @@ pub enum Statement {
     FunDecl {
         async_: bool,
         name: Arc<str>,
+        name_span: Span,
         params: Vec<FunParam>,
         rest_param: Option<TypedParam>,
         return_type: Option<TypeAnnotation>,
@@ -229,6 +242,7 @@ pub enum Statement {
     Try {
         body: Box<Statement>,
         catch_param: Option<Arc<str>>,
+        catch_param_span: Option<Span>,
         catch_body: Option<Box<Statement>>,
         finally_body: Option<Box<Statement>>,
         span: Span,
@@ -242,6 +256,31 @@ pub enum Statement {
         declaration: Box<ExportDeclaration>,
         span: Span,
     },
+    /// `type Name = Type` (erased at runtime; for checker / declaration files).
+    TypeAlias {
+        name: Arc<str>,
+        name_span: Span,
+        ty: TypeAnnotation,
+        span: Span,
+    },
+    /// `declare let name: T` or `declare const name: T`
+    DeclareVar {
+        name: Arc<str>,
+        name_span: Span,
+        type_ann: Option<TypeAnnotation>,
+        const_: bool,
+        span: Span,
+    },
+    /// `declare [async] function name(...): R` (no body).
+    DeclareFun {
+        async_: bool,
+        name: Arc<str>,
+        name_span: Span,
+        params: Vec<FunParam>,
+        rest_param: Option<TypedParam>,
+        return_type: Option<TypeAnnotation>,
+        span: Span,
+    },
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -366,8 +405,8 @@ pub enum Expr {
     },
     /// Template literal: `text ${expr} text`
     TemplateLiteral {
-        quasis: Vec<Arc<str>>,    // Static string parts (n+1 for n expressions)
-        exprs: Vec<Expr>,          // Interpolated expressions (n)
+        quasis: Vec<Arc<str>>, // Static string parts (n+1 for n expressions)
+        exprs: Vec<Expr>,      // Interpolated expressions (n)
         span: Span,
     },
     /// Await expression: await operand
@@ -399,10 +438,7 @@ pub enum Expr {
 #[derive(Debug, Clone, PartialEq)]
 pub enum JsxProp {
     /// name="value" or name={expr} or name (boolean shorthand)
-    Attr {
-        name: Arc<str>,
-        value: JsxAttrValue,
-    },
+    Attr { name: Arc<str>, value: JsxAttrValue },
     /// {...expr}
     Spread(Expr),
 }
@@ -493,11 +529,11 @@ pub enum CallArg {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum CompoundOp {
-    Add,  // +=
-    Sub,  // -=
-    Mul,  // *=
-    Div,  // /=
-    Mod,  // %=
+    Add, // +=
+    Sub, // -=
+    Mul, // *=
+    Div, // /=
+    Mod, // %=
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -552,6 +588,39 @@ pub enum UnaryOp {
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum MemberProp {
-    Name(Arc<str>),
+    /// Property name in `obj.prop` / `obj?.prop` (span covers **prop** only).
+    Name {
+        name: Arc<str>,
+        span: Span,
+    },
     Expr(Box<Expr>), // for computed property
 }
+
+impl Statement {
+    /// Source span covering this statement (including nested bodies where applicable).
+    pub fn span(&self) -> Span {
+        match self {
+            Statement::Block { span, .. }
+            | Statement::VarDecl { span, .. }
+            | Statement::VarDeclDestructure { span, .. }
+            | Statement::ExprStmt { span, .. }
+            | Statement::If { span, .. }
+            | Statement::While { span, .. }
+            | Statement::For { span, .. }
+            | Statement::ForOf { span, .. }
+            | Statement::Return { span, .. }
+            | Statement::Break { span, .. }
+            | Statement::Continue { span, .. }
+            | Statement::FunDecl { span, .. }
+            | Statement::Switch { span, .. }
+            | Statement::DoWhile { span, .. }
+            | Statement::Throw { span, .. }
+            | Statement::Try { span, .. }
+            |             Statement::Import { span, .. }
+            | Statement::Export { span, .. }
+            | Statement::TypeAlias { span, .. }
+            | Statement::DeclareVar { span, .. }
+            | Statement::DeclareFun { span, .. } => *span,
+        }
+    }
+}

package/crates/tish_build_utils/Cargo.toml

@@ -5,3 +5,7 @@ edition = "2021"
 description = "Shared build utilities for Tish (workspace discovery, path resolution)"
 license-file = { workspace = true }
 repository = { workspace = true }
+
+[dependencies]
+# Bundled `protoc` for nested `cargo build` (Lance / prost-build) when none is on PATH.
+protoc-bin-vendored = "3"

package/crates/tish_build_utils/src/lib.rs

@@ -137,6 +137,39 @@ fn tish_root_from_project_cargo_files(mut start: PathBuf) -> Option<PathBuf> {
 /// Returns the directory containing the workspace Cargo.toml (with [workspace]).
 /// Used when building native binaries, WASM, or locating runtime crates.
 pub fn find_workspace_root() -> Result<PathBuf, String> {
+    // Strategy 0: explicit checkout (e.g. tish-hub `npm run dev` / native build from a JS-only tree)
+    if let Ok(root) = std::env::var("TISHLANG_WORKSPACE") {
+        let trimmed = root.trim();
+        if !trimmed.is_empty() {
+            let p = PathBuf::from(trimmed);
+            if p.is_dir() && is_tish_workspace_root(&p) {
+                return p.canonicalize().map_err(|e| {
+                    format!(
+                        "TISHLANG_WORKSPACE is set but not a usable directory: {}",
+                        e
+                    )
+                });
+            }
+            // Non-empty but invalid: fall through (sibling `tish/` discovery may still apply).
+        }
+    }
+
+    // Strategy 0b: monorepo layout `…/<parent>/tish-hub` (cwd) next to `…/<parent>/tish` (language repo).
+    // Works without `TISHLANG_WORKSPACE` so older `tish` binaries still find the compiler tree.
+    if let Ok(mut dir) = std::env::current_dir() {
+        for _ in 0..24 {
+            let candidate = dir.join("tish");
+            if is_tish_workspace_root(&candidate) {
+                return candidate.canonicalize().map_err(|e| {
+                    format!("Cannot canonicalize Tish workspace {}: {}", candidate.display(), e)
+                });
+            }
+            if !dir.pop() {
+                break;
+            }
+        }
+    }
+
     // Strategy 1: CARGO_MANIFEST_DIR (works during cargo build/run from workspace)
     if let Ok(manifest_dir) = std::env::var("CARGO_MANIFEST_DIR") {
         let path = PathBuf::from(&manifest_dir);
@@ -158,7 +191,9 @@ pub fn find_workspace_root() -> Result<PathBuf, String> {
         if let Some(mut current) = exe.parent() {
             for _ in 0..15 {
                 let crates_dir = current.join("crates");
-                if crates_dir.join("tish_runtime").exists() || crates_dir.join("tish_cranelift_runtime").exists() {
+                if crates_dir.join("tish_runtime").exists()
+                    || crates_dir.join("tish_cranelift_runtime").exists()
+                {
                     return Ok(current.to_path_buf());
                 }
                 if let Some(p) = current.parent() {
@@ -177,6 +212,19 @@ pub fn find_workspace_root() -> Result<PathBuf, String> {
         }
     }
 
+    // Strategy 3b: `node_modules/@tishlang/tish` from cwd or any ancestor (package.json-only apps)
+    if let Ok(mut dir) = std::env::current_dir() {
+        for _ in 0..32 {
+            let npm_pkg = dir.join("node_modules").join("@tishlang").join("tish");
+            if is_tish_workspace_root(&npm_pkg) {
+                return Ok(npm_pkg);
+            }
+            if !dir.pop() {
+                break;
+            }
+        }
+    }
+
     // Strategy 4: Walk from current working directory
     if let Ok(mut current) = std::env::current_dir() {
         for _ in 0..15 {
@@ -276,33 +324,112 @@ pub fn find_crate_path(crate_name: &str) -> Result<PathBuf, String> {
 
 /// Create a temp build directory with src subdir.
 pub fn create_build_dir(prefix: &str, out_name: &str) -> Result<PathBuf, String> {
-    let build_dir = std::env::temp_dir().join(prefix).join(format!("{}_{}", out_name, std::process::id()));
+    let build_dir =
+        std::env::temp_dir()
+            .join(prefix)
+            .join(format!("{}_{}", out_name, std::process::id()));
     fs::create_dir_all(&build_dir).map_err(|e| format!("Cannot create build dir: {}", e))?;
-    fs::create_dir_all(build_dir.join("src")).map_err(|e| format!("Cannot create src dir: {}", e))?;
+    fs::create_dir_all(build_dir.join("src"))
+        .map_err(|e| format!("Cannot create src dir: {}", e))?;
     Ok(build_dir)
 }
 
+/// `PROTOC` for prost-build in transitive crates (e.g. lance-encoding) during nested `cargo build`.
+/// Respects an existing `PROTOC`, then `protoc` on `PATH`, then `protoc-bin-vendored`.
+fn protoc_for_nested_cargo() -> Option<PathBuf> {
+    // Empty or non-file PROTOC must not short-circuit: prost-build treats "" like a missing binary.
+    if let Some(v) = std::env::var_os("PROTOC") {
+        if !v.is_empty() {
+            let p = PathBuf::from(&v);
+            if p.is_file() {
+                return None;
+            }
+        }
+    }
+    // Prefer vendored protoc over PATH: a broken or non-executable `protoc` on PATH still passes `is_file()`.
+    if let Ok(p) = protoc_bin_vendored::protoc_bin_path() {
+        return Some(p);
+    }
+    let ext = if cfg!(windows) { ".exe" } else { "" };
+    let name = format!("protoc{}", ext);
+    if let Some(paths) = std::env::var_os("PATH") {
+        for dir in std::env::split_paths(&paths) {
+            let candidate = dir.join(&name);
+            if candidate.is_file() {
+                return Some(candidate);
+            }
+        }
+    }
+    None
+}
+
 /// Run cargo build in the given directory.
 /// If target_dir is Some, use that for --target-dir (e.g. workspace target for caching).
 pub fn run_cargo_build(build_dir: &Path, target_dir: Option<&Path>) -> Result<(), String> {
-    let target_dir = target_dir.map(|p| p.to_path_buf()).unwrap_or_else(|| build_dir.join("target"));
-    let output = Command::new("cargo")
-        .args(["build", "--release", "--target-dir"])
+    let target_dir = target_dir
+        .map(|p| p.to_path_buf())
+        .unwrap_or_else(|| build_dir.join("target"));
+    // Default to target-cpu=native so the emitted binary uses every SIMD / ISA
+    // extension the build host supports. Callers can override by pre-setting
+    // RUSTFLAGS in the environment.
+    let existing_rustflags = std::env::var("RUSTFLAGS").unwrap_or_default();
+    let merged_rustflags = if existing_rustflags.is_empty() {
+        "-C target-cpu=native".to_string()
+    } else if existing_rustflags.contains("target-cpu") {
+        existing_rustflags
+    } else {
+        format!("{} -C target-cpu=native", existing_rustflags)
+    };
+    // Nested `cargo build` (e.g. `tish build --native-backend rust`) inherits the parent
+    // environment. CI often sets `RUSTC_WRAPPER=sccache`; wrapping this inner compile too can
+    // cause flaky or failed builds (LTO / temp-crate paths). Use plain rustc here; the main
+    // workspace build still benefits from the wrapper.
+    let mut cmd = Command::new("cargo");
+    cmd.args(["build", "--release", "--target-dir"])
         .arg(&target_dir)
         .current_dir(build_dir)
         .env_remove("CARGO_TARGET_DIR")
+        .env_remove("RUSTC_WRAPPER")
+        .env_remove("RUSTC_WORKSPACE_WRAPPER")
+        .env_remove("CARGO_BUILD_RUSTC_WRAPPER")
         .env("CARGO_TERM_PROGRESS", "always")
+        .env("RUSTFLAGS", &merged_rustflags);
+    if let Some(protoc) = protoc_for_nested_cargo() {
+        cmd.env("PROTOC", protoc);
+    }
+    let output = cmd
         .output()
         .map_err(|e| format!("Failed to run cargo: {}", e))?;
 
     if !output.status.success() {
         let stderr = String::from_utf8_lossy(&output.stderr);
         let stdout = String::from_utf8_lossy(&output.stdout);
-        return Err(format!("Compilation failed.\nstdout:\n{}\nstderr:\n{}", stdout, stderr));
+        return Err(format!(
+            "Compilation failed.\nstdout:\n{}\nstderr:\n{}",
+            stdout, stderr
+        ));
     }
     Ok(())
 }
 
+#[cfg(test)]
+mod protoc_tests {
+    use super::*;
+
+    #[test]
+    fn protoc_for_nested_cargo_without_env_uses_vendored_or_path() {
+        let _lock = std::sync::Mutex::new(());
+        let _guard = _lock.lock().unwrap();
+        std::env::remove_var("PROTOC");
+        let p = protoc_for_nested_cargo().expect("expected vendored or PATH protoc");
+        assert!(
+            p.exists(),
+            "resolved protoc should exist: {}",
+            p.display()
+        );
+    }
+}
+
 /// Find the built binary in target/release.
 pub fn find_release_binary(binary_dir: &Path, bin_name: &str) -> Result<PathBuf, String> {
     let binary_no_ext = binary_dir.join(bin_name);
@@ -351,7 +478,8 @@ pub fn copy_binary_to_output(binary: &Path, output_path: &Path) -> Result<(), St
     if let Some(parent) = output_path.parent() {
         fs::create_dir_all(parent).map_err(|e| format!("Cannot create output dir: {}", e))?;
     }
-    fs::copy(binary, output_path).map_err(|e| format!("Cannot copy to {}: {}", output_path.display(), e))?;
+    fs::copy(binary, output_path)
+        .map_err(|e| format!("Cannot copy to {}: {}", output_path.display(), e))?;
     Ok(())
 }
 

package/crates/tish_builtins/Cargo.toml

@@ -8,9 +8,13 @@ description = "Shared builtin implementations for Tish (array, string, object, m
 license-file = { workspace = true }
 repository = { workspace = true }
 [dependencies]
-rand = "0.10.0"
+rand = "0.10.1"
 tishlang_core = { path = "../tish_core", version = ">=0.1" }
 
 [features]
 default = []
 regex = ["tishlang_core/regex"]
+# Propagate the `send-values` feature from `tishlang_core` so that closures
+# handed to us via `NativeFn` pick up the `Send + Sync` bound automatically
+# when multi-threaded `Value`s are enabled upstream.
+send-values = ["tishlang_core/send-values"]

package/crates/tish_builtins/src/array.rs

@@ -1,13 +1,14 @@
 //! Array builtin methods.
 
+use crate::helpers::normalize_index;
+use tishlang_core::VmRef;
 use std::cell::RefCell;
 use std::rc::Rc;
 use tishlang_core::Value;
-use crate::helpers::normalize_index;
 
 /// Create a new array Value from a Vec of Values.
 pub fn from_vec(v: Vec<Value>) -> Value {
-    Value::Array(Rc::new(RefCell::new(v)))
+    Value::Array(VmRef::new(v))
 }
 
 /// Get the length of an array.
@@ -110,7 +111,7 @@ pub fn join(arr: &Value, sep: &Value) -> Value {
 pub fn reverse(arr: &Value) -> Value {
     if let Value::Array(arr) = arr {
         arr.borrow_mut().reverse();
-        Value::Array(Rc::clone(arr))
+        Value::Array(arr.clone())
     } else {
         Value::Null
     }
@@ -122,7 +123,7 @@ pub fn shuffle(arr: &Value) -> Value {
         let mut v = arr.borrow().clone();
         use rand::seq::SliceRandom;
         v.shuffle(&mut rand::rng());
-        Value::Array(Rc::new(RefCell::new(v)))
+        Value::Array(VmRef::new(v))
     } else {
         Value::Null
     }
@@ -141,7 +142,7 @@ pub fn splice(arr: &Value, start: &Value, delete_count: Option<&Value>, items: &
         let removed: Vec<Value> = arr_mut
             .splice(start_idx..start_idx + actual_delete, items.iter().cloned())
             .collect();
-        Value::Array(Rc::new(RefCell::new(removed)))
+        Value::Array(VmRef::new(removed))
     } else {
         Value::Null
     }
@@ -153,8 +154,12 @@ pub fn slice(arr: &Value, start: &Value, end: &Value) -> Value {
         let len = arr_borrow.len() as i64;
         let start_idx = normalize_index(start, len, 0);
         let end_idx = normalize_index(end, len, len as usize);
-        let sliced = if start_idx < end_idx { arr_borrow[start_idx..end_idx].to_vec() } else { vec![] };
-        Value::Array(Rc::new(RefCell::new(sliced)))
+        let sliced = if start_idx < end_idx {
+            arr_borrow[start_idx..end_idx].to_vec()
+        } else {
+            vec![]
+        };
+        Value::Array(VmRef::new(sliced))
     } else {
         Value::Null
     }
@@ -170,7 +175,7 @@ pub fn concat(arr: &Value, args: &[Value]) -> Value {
                 result.push(v.clone());
             }
         }
-        Value::Array(Rc::new(RefCell::new(result)))
+        Value::Array(VmRef::new(result))
     } else {
         Value::Null
     }
@@ -188,7 +193,7 @@ pub fn flat(arr: &Value, depth: &Value) -> Value {
             result.push(v.clone());
         }
     }
-    
+
     if let Value::Array(arr) = arr {
         let d = match depth {
             Value::Number(n) => *n as i32,
@@ -196,7 +201,7 @@ pub fn flat(arr: &Value, depth: &Value) -> Value {
         };
         let mut result = Vec::new();
         flatten(&arr.borrow(), d, &mut result);
-        Value::Array(Rc::new(RefCell::new(result)))
+        Value::Array(VmRef::new(result))
     } else {
         Value::Null
     }
@@ -208,10 +213,12 @@ pub fn flat(arr: &Value, depth: &Value) -> Value {
 pub fn map(arr: &Value, callback: &Value) -> Value {
     if let (Value::Array(arr), Value::Function(cb)) = (arr, callback) {
         let arr_borrow = arr.borrow();
-        let result: Vec<Value> = arr_borrow.iter().enumerate().map(|(i, v)| {
-            cb(&[v.clone(), Value::Number(i as f64)])
-        }).collect();
-        Value::Array(Rc::new(RefCell::new(result)))
+        let result: Vec<Value> = arr_borrow
+            .iter()
+            .enumerate()
+            .map(|(i, v)| cb(&[v.clone(), Value::Number(i as f64)]))
+            .collect();
+        Value::Array(VmRef::new(result))
     } else {
         Value::Null
     }
@@ -220,11 +227,19 @@ pub fn map(arr: &Value, callback: &Value) -> Value {
 pub fn filter(arr: &Value, callback: &Value) -> Value {
     if let (Value::Array(arr), Value::Function(cb)) = (arr, callback) {
         let arr_borrow = arr.borrow();
-        let result: Vec<Value> = arr_borrow.iter().enumerate().filter_map(|(i, v)| {
-            let keep = cb(&[v.clone(), Value::Number(i as f64)]);
-            if keep.is_truthy() { Some(v.clone()) } else { None }
-        }).collect();
-        Value::Array(Rc::new(RefCell::new(result)))
+        let result: Vec<Value> = arr_borrow
+            .iter()
+            .enumerate()
+            .filter_map(|(i, v)| {
+                let keep = cb(&[v.clone(), Value::Number(i as f64)]);
+                if keep.is_truthy() {
+                    Some(v.clone())
+                } else {
+                    None
+                }
+            })
+            .collect();
+        Value::Array(VmRef::new(result))
     } else {
         Value::Null
     }
@@ -234,9 +249,7 @@ pub fn reduce(arr: &Value, callback: &Value, initial: &Value) -> Value {
     if let (Value::Array(arr), Value::Function(cb)) = (arr, callback) {
         let arr_borrow = arr.borrow();
         let len = arr_borrow.len();
-        let (start_idx, mut acc) = if matches!(initial, Value::Null)
-            && !arr_borrow.is_empty()
-        {
+        let (start_idx, mut acc) = if matches!(initial, Value::Null) && !arr_borrow.is_empty() {
             // No initial value: use first element as acc, start from index 1
             (1, arr_borrow[0].clone())
         } else {
@@ -328,24 +341,28 @@ pub fn flat_map(arr: &Value, callback: &Value) -> Value {
                 result.push(mapped);
             }
         }
-        Value::Array(Rc::new(RefCell::new(result)))
+        Value::Array(VmRef::new(result))
     } else {
         Value::Null
     }
 }
 
 fn sort_by_impl<F>(arr: &Value, cmp: F) -> Value
-where F: FnMut(&Value, &Value) -> std::cmp::Ordering {
+where
+    F: FnMut(&Value, &Value) -> std::cmp::Ordering,
+{
     if let Value::Array(arr) = arr {
         arr.borrow_mut().sort_by(cmp);
-        Value::Array(Rc::clone(arr))
+        Value::Array(arr.clone())
     } else {
         Value::Null
     }
 }
 
 pub fn sort_default(arr: &Value) -> Value {
-    sort_by_impl(arr, |a, b| a.to_display_string().cmp(&b.to_display_string()))
+    sort_by_impl(arr, |a, b| {
+        a.to_display_string().cmp(&b.to_display_string())
+    })
 }
 
 pub fn sort_with_comparator(arr: &Value, comparator: &Value) -> Value {
@@ -355,7 +372,7 @@ pub fn sort_with_comparator(arr: &Value, comparator: &Value) -> Value {
         let mut indices: Vec<usize> = (0..len).collect();
         let mut elements: Vec<Value> = std::mem::take(&mut *arr_mut);
         let mut args_buf: [Value; 2] = [Value::Null, Value::Null];
-        
+
         indices.sort_by(|&a, &b| {
             args_buf[0] = elements[a].clone();
             args_buf[1] = elements[b].clone();
@@ -365,10 +382,13 @@ pub fn sort_with_comparator(arr: &Value, comparator: &Value) -> Value {
                 _ => std::cmp::Ordering::Equal,
             }
         });
-        
-        *arr_mut = indices.into_iter().map(|i| std::mem::replace(&mut elements[i], Value::Null)).collect();
+
+        *arr_mut = indices
+            .into_iter()
+            .map(|i| std::mem::replace(&mut elements[i], Value::Null))
+            .collect();
         drop(arr_mut);
-        Value::Array(Rc::clone(arr))
+        Value::Array(arr.clone())
     } else {
         Value::Null
     }
@@ -380,7 +400,11 @@ fn num_cmp(a: &Value, b: &Value, asc: bool) -> std::cmp::Ordering {
         _ => (f64::NAN, f64::NAN),
     };
     let cmp = na.partial_cmp(&nb).unwrap_or(std::cmp::Ordering::Equal);
-    if asc { cmp } else { cmp.reverse() }
+    if asc {
+        cmp
+    } else {
+        cmp.reverse()
+    }
 }
 
 pub fn sort_numeric_asc(arr: &Value) -> Value {
@@ -398,13 +422,21 @@ pub fn sort_by_property_numeric(arr: &Value, prop: &str, asc: bool) -> Value {
         let na = get_prop_number(a, &prop_arc);
         let nb = get_prop_number(b, &prop_arc);
         let cmp = na.partial_cmp(&nb).unwrap_or(std::cmp::Ordering::Equal);
-        if asc { cmp } else { cmp.reverse() }
+        if asc {
+            cmp
+        } else {
+            cmp.reverse()
+        }
     })
 }
 
 fn get_prop_number(v: &Value, prop: &std::sync::Arc<str>) -> f64 {
     match v {
-        Value::Object(o) => o.borrow().get(prop.as_ref()).map(|v| v.as_number().unwrap_or(f64::NAN)).unwrap_or(f64::NAN),
+        Value::Object(o) => o
+            .borrow()
+            .get(prop.as_ref())
+            .map(|v| v.as_number().unwrap_or(f64::NAN))
+            .unwrap_or(f64::NAN),
         _ => f64::NAN,
     }
 }