@tishlang/tish-format 1.0.12 → 1.0.13

package/crates/tish_eval/src/value.rs

@@ -0,0 +1,318 @@
+//! Runtime values for the Tish interpreter.
+//!
+//! This module defines the interpreter's `Value` type, which includes variants
+//! like `Function`, `Native`, and `Serve` that hold AST or interpreter-specific
+//! data. The compiled runtime uses `tishlang_core::Value` instead, which has a
+//! different shape (no AST-carrying variants). The split is intentional.
+
+use std::cell::RefCell;
+use std::rc::Rc;
+use std::sync::Arc;
+
+use ahash::AHashMap;
+use tishlang_ast::{FunParam, Statement};
+use tishlang_core::NativeFn as CoreNativeFn;
+use tishlang_core::TishSymbol;
+
+/// Property map for interpreter object string keys (uses `eval::Value`, not `tishlang_core::Value`).
+pub type PropMap = AHashMap<Arc<str>, Value>;
+
+/// Interpreter object: string keys plus optional symbol-keyed properties.
+#[derive(Clone, Debug, Default)]
+pub struct EvalObjectData {
+    pub strings: PropMap,
+    pub symbols: Option<AHashMap<u64, Value>>,
+}
+
+impl EvalObjectData {
+    pub fn from_strings(strings: PropMap) -> Self {
+        Self {
+            strings,
+            symbols: None,
+        }
+    }
+}
+
+pub fn eval_object_get(obj: &Value, key: &Value) -> Option<Value> {
+    let Value::Object(od) = obj else {
+        return None;
+    };
+    let b = od.borrow();
+    match key {
+        Value::Symbol(s) => b.symbols.as_ref()?.get(&s.id).cloned(),
+        Value::Number(n) => {
+            let k: Arc<str> = n.to_string().into();
+            b.strings.get(&k).cloned()
+        }
+        Value::String(k) => b.strings.get(k.as_ref()).cloned(),
+        _ => None,
+    }
+}
+
+pub fn eval_object_set(obj: &Value, key: &Value, val: Value) -> Result<(), String> {
+    let Value::Object(od) = obj else {
+        return Err("Cannot set property on non-object".to_string());
+    };
+    let mut b = od.borrow_mut();
+    match key {
+        Value::Symbol(s) => {
+            if b.symbols.is_none() {
+                b.symbols = Some(AHashMap::default());
+            }
+            b.symbols.as_mut().unwrap().insert(s.id, val);
+            Ok(())
+        }
+        Value::Number(n) => {
+            b.strings.insert(n.to_string().into(), val);
+            Ok(())
+        }
+        Value::String(k) => {
+            b.strings.insert(Arc::clone(k), val);
+            Ok(())
+        }
+        _ => Err("Object key must be string, number, or symbol".to_string()),
+    }
+}
+
+pub fn eval_object_has(obj: &Value, key: &Value) -> bool {
+    let Value::Object(od) = obj else {
+        return false;
+    };
+    let b = od.borrow();
+    match key {
+        Value::Symbol(s) => b.symbols.as_ref().is_some_and(|m| m.contains_key(&s.id)),
+        Value::Number(n) => {
+            let k: Arc<str> = n.to_string().into();
+            b.strings.contains_key(&k)
+        }
+        Value::String(k) => b.strings.contains_key(k.as_ref()),
+        _ => false,
+    }
+}
+use tishlang_core::TishOpaque;
+#[cfg(feature = "http")]
+use tishlang_core::TishPromise;
+
+#[cfg(feature = "http")]
+pub use crate::promise::PromiseResolver;
+#[cfg(feature = "regex")]
+pub use crate::regex::TishRegExp;
+
+/// Native function type - takes args, returns Result<Value, String>
+pub type NativeFn = fn(&[Value]) -> Result<Value, String>;
+
+#[derive(Clone)]
+pub enum Value {
+    Number(f64),
+    String(Arc<str>),
+    Bool(bool),
+    Null,
+    Array(Rc<RefCell<Vec<Value>>>),
+    Object(Rc<RefCell<EvalObjectData>>),
+    Symbol(Arc<TishSymbol>),
+    /// User-defined function with AST body
+    Function {
+        formals: Arc<[FunParam]>,
+        rest_param: Option<Arc<str>>,
+        body: Arc<Statement>,
+    },
+    /// Native/builtin function
+    Native(NativeFn),
+    /// HTTP serve function (needs special handling for callbacks)
+    #[cfg(feature = "http")]
+    Serve,
+    #[cfg(feature = "regex")]
+    RegExp(Rc<RefCell<TishRegExp>>),
+    /// Promise (ECMA-262 §27.2). Requires http feature for tokio.
+    #[cfg(feature = "http")]
+    Promise(crate::promise::PromiseRef),
+    /// Internal: resolve/reject functions passed to executor. Not user-facing.
+    #[cfg(feature = "http")]
+    PromiseResolver(PromiseResolver),
+    /// Promise constructor: Promise(executor). Requires special call handling.
+    #[cfg(feature = "http")]
+    PromiseConstructor,
+    /// Bound promise method: promise.then/catch/finally - captures the promise for the call.
+    #[cfg(feature = "http")]
+    BoundPromiseMethod(crate::promise::PromiseRef, std::sync::Arc<str>),
+    /// Timer builtins: setTimeout, setInterval. Need evaluator for callback.
+    #[cfg(feature = "timers")]
+    TimerBuiltin(std::sync::Arc<str>),
+    /// Native `tishlang_core` Promise (fetch / reader.read / response.text).
+    #[cfg(feature = "http")]
+    CorePromise(Arc<dyn TishPromise>),
+    /// `tishlang_core::Value::Function` (native callbacks, `new` constructors, fetch/ws when enabled).
+    CoreFn(CoreNativeFn),
+    /// Opaque handle to a native Rust type (e.g. Polars DataFrame).
+    Opaque(Arc<dyn TishOpaque>),
+    /// Bound method on an opaque value (opaque, method_name). Callable.
+    OpaqueMethod(Arc<dyn TishOpaque>, Arc<str>),
+}
+
+impl std::fmt::Debug for Value {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Value::Number(n) => write!(f, "Number({})", n),
+            Value::String(s) => write!(f, "String({:?})", s.as_ref()),
+            Value::Bool(b) => write!(f, "Bool({})", b),
+            Value::Null => write!(f, "Null"),
+            Value::Array(arr) => write!(f, "Array({:?})", arr.borrow()),
+            Value::Object(obj) => write!(f, "Object({:?})", obj.borrow()),
+            Value::Function { .. } => write!(f, "Function"),
+            Value::Native(_) => write!(f, "Native"),
+            #[cfg(feature = "http")]
+            Value::Serve => write!(f, "Serve"),
+            #[cfg(feature = "regex")]
+            Value::RegExp(re) => write!(
+                f,
+                "RegExp(/{}/{})",
+                re.borrow().source,
+                re.borrow().flags_string()
+            ),
+            #[cfg(feature = "http")]
+            Value::Promise(_) => write!(f, "Promise"),
+            #[cfg(feature = "http")]
+            Value::PromiseResolver(_) => write!(f, "[PromiseResolver]"),
+            #[cfg(feature = "http")]
+            Value::PromiseConstructor => write!(f, "[Function: Promise]"),
+            #[cfg(feature = "http")]
+            Value::BoundPromiseMethod(_, _) => write!(f, "[Function]"),
+            #[cfg(feature = "timers")]
+            Value::TimerBuiltin(_) => write!(f, "[Function]"),
+            #[cfg(feature = "http")]
+            Value::CorePromise(_) => write!(f, "Promise"),
+            Value::CoreFn(_) => write!(f, "CoreFn"),
+            Value::Opaque(o) => write!(f, "{}(opaque)", o.type_name()),
+            Value::OpaqueMethod(_, _) => write!(f, "[Function]"),
+            Value::Symbol(s) => write!(f, "Symbol({})", s.id),
+        }
+    }
+}
+
+impl std::fmt::Display for Value {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Value::Number(n) => {
+                if n.is_nan() {
+                    write!(f, "NaN")
+                } else if *n == f64::INFINITY {
+                    write!(f, "Infinity")
+                } else if *n == f64::NEG_INFINITY {
+                    write!(f, "-Infinity")
+                } else {
+                    write!(f, "{}", n)
+                }
+            }
+            Value::String(s) => write!(f, "{}", s),
+            Value::Bool(b) => write!(f, "{}", b),
+            Value::Null => write!(f, "null"),
+            Value::Array(arr) => {
+                let inner: Vec<String> = arr.borrow().iter().map(|v| v.to_string()).collect();
+                write!(f, "[{}]", inner.join(", "))
+            }
+            Value::Object(obj) => {
+                let inner: Vec<String> = obj
+                    .borrow()
+                    .strings
+                    .iter()
+                    .map(|(k, v)| format!("{}: {}", k.as_ref(), v))
+                    .collect();
+                write!(f, "{{{}}}", inner.join(", "))
+            }
+            Value::Symbol(s) => {
+                if let Some(d) = &s.description {
+                    write!(f, "Symbol({})", d)
+                } else {
+                    write!(f, "Symbol()")
+                }
+            }
+            Value::Function { .. } => write!(f, "[Function]"),
+            Value::Native(_) => write!(f, "[NativeFunction]"),
+            #[cfg(feature = "http")]
+            Value::Serve => write!(f, "[NativeFunction: serve]"),
+            #[cfg(feature = "regex")]
+            Value::RegExp(re) => {
+                let re = re.borrow();
+                write!(f, "/{}/{}", re.source, re.flags_string())
+            }
+            #[cfg(feature = "http")]
+            Value::Promise(_) => write!(f, "[Promise]"),
+            #[cfg(feature = "http")]
+            Value::PromiseResolver(_) => write!(f, "[Function]"),
+            #[cfg(feature = "http")]
+            Value::PromiseConstructor => write!(f, "function Promise() {{ [native code] }}"),
+            #[cfg(feature = "http")]
+            Value::BoundPromiseMethod(_, _) => write!(f, "[Function]"),
+            #[cfg(feature = "timers")]
+            Value::TimerBuiltin(_) => write!(f, "[Function]"),
+            #[cfg(feature = "http")]
+            Value::CorePromise(_) => write!(f, "[Promise]"),
+            Value::CoreFn(_) => write!(f, "[Function]"),
+            Value::Opaque(o) => write!(f, "[object {}]", o.type_name()),
+            Value::OpaqueMethod(_, _) => write!(f, "[Function]"),
+        }
+    }
+}
+
+impl Value {
+    pub fn is_truthy(&self) -> bool {
+        match self {
+            Value::Null => false,
+            Value::Bool(b) => *b,
+            Value::Number(n) => *n != 0.0 && !n.is_nan(),
+            Value::String(s) => !s.is_empty(),
+            _ => true,
+        }
+    }
+
+    pub fn strict_eq(&self, other: &Value) -> bool {
+        match (self, other) {
+            (Value::Number(a), Value::Number(b)) => {
+                if a.is_nan() || b.is_nan() {
+                    false
+                } else {
+                    a == b
+                }
+            }
+            (Value::String(a), Value::String(b)) => a == b,
+            (Value::Bool(a), Value::Bool(b)) => a == b,
+            (Value::Null, Value::Null) => true,
+            (Value::Array(a), Value::Array(b)) => Rc::ptr_eq(a, b),
+            (Value::Object(a), Value::Object(b)) => Rc::ptr_eq(a, b),
+            (Value::Symbol(a), Value::Symbol(b)) => Arc::ptr_eq(a, b),
+            (Value::Opaque(a), Value::Opaque(b)) => Arc::ptr_eq(a, b),
+            (Value::OpaqueMethod(a, ak), Value::OpaqueMethod(b, bk)) => {
+                Arc::ptr_eq(a, b) && ak == bk
+            }
+            _ => false,
+        }
+    }
+
+    /// Create a new array Value from a Vec.
+    pub fn array(items: Vec<Value>) -> Self {
+        Value::Array(Rc::new(RefCell::new(items)))
+    }
+
+    /// Create a new object Value from a property map.
+    pub fn object(map: PropMap) -> Self {
+        Value::Object(Rc::new(RefCell::new(EvalObjectData::from_strings(map))))
+    }
+
+    /// Create an empty array Value.
+    pub fn empty_array() -> Self {
+        Value::Array(Rc::new(RefCell::new(Vec::new())))
+    }
+
+    /// Create an empty object Value.
+    pub fn empty_object() -> Self {
+        Value::Object(Rc::new(RefCell::new(EvalObjectData::default())))
+    }
+
+    /// Extract the number value, if this is a Number.
+    pub fn as_number(&self) -> Option<f64> {
+        match self {
+            Value::Number(n) => Some(*n),
+            _ => None,
+        }
+    }
+}

package/crates/tish_eval/src/value_convert.rs

@@ -0,0 +1,111 @@
+//! Conversion between tishlang_eval::Value and tishlang_core::Value for opaque method calls.
+
+use std::cell::RefCell;
+use std::rc::Rc;
+use std::sync::Arc;
+
+#[cfg(feature = "regex")]
+use tishlang_core::TishRegExp;
+use ahash::AHashMap;
+use tishlang_core::{ObjectData, ObjectMap, Value as CoreValue, VmRef};
+
+use crate::value::{EvalObjectData, PropMap, Value};
+
+/// Convert interpreter Value to core Value. Fails for interpreter-only variants.
+pub fn eval_to_core(v: &Value) -> Result<CoreValue, String> {
+    match v {
+        Value::Number(n) => Ok(CoreValue::Number(*n)),
+        Value::String(s) => Ok(CoreValue::String(Arc::clone(s))),
+        Value::Bool(b) => Ok(CoreValue::Bool(*b)),
+        Value::Null => Ok(CoreValue::Null),
+        Value::Array(arr) => {
+            let mut out = Vec::new();
+            for item in arr.borrow().iter() {
+                out.push(eval_to_core(item)?);
+            }
+            Ok(CoreValue::Array(VmRef::new(out)))
+        }
+        Value::Object(map) => {
+            let b = map.borrow();
+            let mut strings = ObjectMap::default();
+            for (k, v) in b.strings.iter() {
+                strings.insert(Arc::clone(k), eval_to_core(v)?);
+            }
+            let symbols = if let Some(ss) = &b.symbols {
+                let mut sm = AHashMap::default();
+                for (id, v) in ss.iter() {
+                    sm.insert(*id, eval_to_core(v)?);
+                }
+                Some(sm)
+            } else {
+                None
+            };
+            Ok(CoreValue::Object(VmRef::new(ObjectData { strings, symbols })))
+        }
+        Value::Symbol(s) => Ok(CoreValue::Symbol(Arc::clone(s))),
+        Value::Opaque(o) => Ok(CoreValue::Opaque(Arc::clone(o))),
+        _ => Err(format!(
+            "Cannot pass {:?} to native function (unsupported type)",
+            std::mem::discriminant(v)
+        )),
+    }
+}
+
+/// Convert core Value to interpreter Value.
+pub fn core_to_eval(v: CoreValue) -> Value {
+    match v {
+        CoreValue::Number(n) => Value::Number(n),
+        CoreValue::String(s) => Value::String(s),
+        CoreValue::Bool(b) => Value::Bool(b),
+        CoreValue::Null => Value::Null,
+        CoreValue::Array(arr) => {
+            let mut out = Vec::new();
+            for item in arr.borrow().iter() {
+                out.push(core_to_eval(item.clone()));
+            }
+            Value::Array(Rc::new(RefCell::new(out)))
+        }
+        CoreValue::Object(map) => {
+            let b = map.borrow();
+            let mut out = PropMap::default();
+            for (k, v) in b.strings.iter() {
+                out.insert(Arc::clone(k), core_to_eval(v.clone()));
+            }
+            let mut eod = EvalObjectData::from_strings(out);
+            if let Some(ss) = &b.symbols {
+                let mut es = AHashMap::default();
+                for (id, v) in ss.iter() {
+                    es.insert(*id, core_to_eval(v.clone()));
+                }
+                eod.symbols = Some(es);
+            }
+            Value::Object(Rc::new(RefCell::new(eod)))
+        }
+        CoreValue::Symbol(s) => Value::Symbol(Arc::clone(&s)),
+        CoreValue::Opaque(o) => Value::Opaque(o),
+        #[cfg(feature = "http")]
+        CoreValue::Promise(p) => Value::CorePromise(Arc::clone(&p)),
+        #[cfg(not(feature = "http"))]
+        CoreValue::Promise(_) => Value::Null,
+        // `CoreNativeFn` is feature-gated (Rc vs Arc), so use Clone::clone
+        // which works for either.
+        CoreValue::Function(f) => Value::CoreFn(f.clone()),
+        // tishlang_core gets regex from http or regex features; handle RegExp when it exists
+        #[cfg(any(feature = "http", feature = "regex"))]
+        CoreValue::RegExp(re) => {
+            #[cfg(feature = "regex")]
+            {
+                // Core uses `VmRef<TishRegExp>` (potentially `Arc<Mutex>`),
+                // interpreter uses `Rc<RefCell<TishRegExp>>`. Clone the
+                // inner state across so the two storage shapes can coexist.
+                let inner: TishRegExp = re.borrow().clone();
+                Value::RegExp(Rc::new(RefCell::new(inner)))
+            }
+            #[cfg(not(feature = "regex"))]
+            {
+                let _ = re;
+                Value::Null
+            }
+        }
+    }
+}

package/crates/tish_fmt/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "tishlang_fmt"
+version = "0.1.0"
+edition = "2021"
+description = "Opinionated formatter for Tish source (parse → pretty-print)"
+license-file = { workspace = true }
+repository = { workspace = true }
+
+[[bin]]
+name = "tish-fmt"
+path = "src/bin/tish-fmt.rs"
+
+[dependencies]
+clap = { version = "4.6.0", features = ["derive"] }
+tishlang_ast = { path = "../tish_ast", version = ">=0.1" }
+tishlang_parser = { path = "../tish_parser", version = ">=0.1" }

package/crates/tish_fmt/src/bin/tish-fmt.rs

@@ -0,0 +1,41 @@
+//! Standalone formatter — not part of the `tish` compiler CLI.
+
+use std::fs;
+
+use clap::Parser;
+
+#[derive(Parser)]
+#[command(name = "tish-fmt")]
+#[command(about = "Format Tish source (pretty-print via AST)")]
+struct Cli {
+    #[arg(required = true)]
+    file: String,
+    #[arg(long)]
+    check: bool,
+}
+
+fn main() {
+    let cli = Cli::parse();
+    if let Err(e) = run(&cli.file, cli.check) {
+        eprintln!("{}", e);
+        std::process::exit(1);
+    }
+}
+
+fn run(path: &str, check: bool) -> Result<(), String> {
+    let source = fs::read_to_string(path).map_err(|e| format!("Cannot read {}: {}", path, e))?;
+    let formatted = tishlang_fmt::format_source(&source)?;
+    if check {
+        if formatted != source {
+            return Err(format!(
+                "Format check failed: {} needs formatting (run `tish-fmt {}`)",
+                path, path
+            ));
+        }
+        println!("{}: OK", path);
+        return Ok(());
+    }
+    fs::write(path, formatted).map_err(|e| format!("Cannot write {}: {}", path, e))?;
+    println!("Formatted: {}", path);
+    Ok(())
+}