@tishlang/tish-format 2.36.0 → 2.37.0

package/crates/tish_compile/src/infer.rs

@@ -284,16 +284,45 @@ fn param_infer_program(program: Program) -> Program {
     // panic on / turn to NaN where JS keeps the value. Skip those fns (they stay fully boxed). Same
     // set `collect_native_fns` uses to refuse the M5 native form.
     let nonnumeric = crate::codegen::Codegen::fns_called_with_nonnumeric_arg(&program.statements);
+    // Soundness (#477): a fn referenced as a first-class VALUE — passed as a call ARGUMENT
+    // (`serve(port, handler)`), assigned, returned, or stored, i.e. any use that is NOT a direct
+    // `f(...)` call — escapes into the boxed `Value::Function` path and is later invoked via
+    // `.call(&[Value])` with arbitrary runtime Values (a `serve` handler is called with the request
+    // OBJECT). Such a fn's params CANNOT be soundly `: number`-shadowed: the escaping boxed closure
+    // unboxes arg0 as `match … Value::Number(n) => *n, _ => panic!("expected number")` and would panic
+    // on the first non-numeric call. `fns_called_with_nonnumeric_arg` only catches SYNTACTIC
+    // non-numeric call args — it can't see this value-escape — so exclude escaping fns explicitly.
+    // Over-approximation is safe: an escaping fn just stays fully boxed (correct, at worst slower).
+    let escaping = escaping_fn_names(&program.statements);
     Program {
         statements: program
             .statements
             .into_iter()
-            .map(|s| pi_stmt(s, &nonnumeric))
+            .map(|s| pi_stmt(s, &nonnumeric, &escaping))
             .collect(),
     }
 }
 
-fn pi_stmt(s: Statement, nonnumeric: &HashSet<String>) -> Statement {
+/// Names of fns referenced as a first-class VALUE anywhere in the program — any use of the name that
+/// is NOT a direct `f(...)` call (a bare-ident call argument like `serve(port, handler)`, an
+/// assignment, a return, storage in an object/array). Such a fn is reachable via the boxed
+/// `Value::Function` `.call(&[Value])` path with arbitrary runtime Values, so its params must stay
+/// boxed and are never `: number`-shadowed. Backed by the same `fn_name_uses` escape counter the
+/// inliner uses. See `param_infer_program`. (#477)
+fn escaping_fn_names(statements: &[Statement]) -> HashSet<String> {
+    let mut out = HashSet::new();
+    for s in statements {
+        if let Statement::FunDecl { name, .. } = s {
+            let (_, others) = fn_name_uses(statements, name.as_ref());
+            if others > 0 {
+                out.insert(name.to_string());
+            }
+        }
+    }
+    out
+}
+
+fn pi_stmt(s: Statement, nonnumeric: &HashSet<String>, escaping: &HashSet<String>) -> Statement {
     if let Statement::FunDecl {
         async_,
         name,
@@ -305,8 +334,10 @@ fn pi_stmt(s: Statement, nonnumeric: &HashSet<String>) -> Statement {
         span,
     } = s
     {
-        // A fn reached with a non-numeric arg somewhere: leave its params dynamic (boxed).
-        if nonnumeric.contains(name.as_ref()) {
+        // A fn reached with a non-numeric arg somewhere, OR escaping as a first-class value
+        // (#477 — a `serve` handler / stored callback invoked via the boxed path with arbitrary
+        // Values): leave its params dynamic (boxed).
+        if nonnumeric.contains(name.as_ref()) || escaping.contains(name.as_ref()) {
             return Statement::FunDecl {
                 async_,
                 name,
@@ -3680,6 +3711,12 @@ pub fn analyze_aggregate(program: &Program) -> AggregateAnalysis {
     // would otherwise emit a `match … panic!("expected number")` coercion on the String. Same set the
     // M4 `param_infer` path uses (infer.rs:273).
     let nonnumeric = crate::codegen::Codegen::fns_called_with_nonnumeric_arg(&program.statements);
+    // Soundness (#477): a fn referenced as a first-class VALUE (a `serve` handler / stored callback)
+    // is invoked via the boxed `Value::Function` path with arbitrary runtime Values, so — exactly as
+    // in `param_infer_program` — its params must NOT get an S-0 `: number` shadow either. Without this
+    // an UNUSED param (vacuously "numeric" under `pus_stmt`) would be stamped `: number` and the
+    // escaping boxed closure would `panic!("expected number")` on the request object.
+    let escaping = escaping_fn_names(&program.statements);
 
     // ---- S-0 + S-A: per top-level function, find numeric params and a return shape.
     for s in &program.statements {
@@ -3731,7 +3768,10 @@ pub fn analyze_aggregate(program: &Program) -> AggregateAnalysis {
                     }
                 }
             }
-            if !numeric_params.is_empty() && !nonnumeric.contains(name.as_ref()) {
+            if !numeric_params.is_empty()
+                && !nonnumeric.contains(name.as_ref())
+                && !escaping.contains(name.as_ref())
+            {
                 analysis.fn_numeric_params.insert(name.to_string(), numeric_params);
             }
             // S-A: a single all-f64 object-literal return shape ⇒ a struct alias.
@@ -4677,6 +4717,54 @@ mod param_infer_tests {
         let src = "fn g(x) { let r = x; return r + \"!\" }";
         assert_eq!(inferred_param(src, "g", "x"), None);
     }
+
+    /// Final annotation name (if any) for `fn <fn_name>`'s `<param>` after the FULL pipeline
+    /// (`infer_program`: M4 `param_infer` + local/struct + S-0 aggregate).
+    fn end_to_end_param_ann(src: &str, fn_name: &str, param: &str) -> Option<String> {
+        let prog = infer_program(&parse(src).unwrap());
+        for s in &prog.statements {
+            if let Statement::FunDecl { name, params, .. } = s {
+                if name.as_ref() == fn_name {
+                    for p in params {
+                        if let FunParam::Simple(tp) = p {
+                            if tp.name.as_ref() == param {
+                                return tp.type_ann.as_ref().map(|a| match a {
+                                    TypeAnnotation::Simple(s, _) => s.to_string(),
+                                    _ => "<complex>".to_string(),
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        None
+    }
+
+    #[test]
+    fn escaping_value_fn_param_stays_boxed_477() {
+        // #477: `handler` is passed as a call ARGUMENT (escapes as a first-class value, exactly like a
+        // `serve` handler). Its `req` param is UNUSED and the body is all-numeric — so BOTH the M4
+        // `param_infer` and the S-0 aggregate paths would otherwise stamp it `: number`. Because the
+        // fn is invoked via the boxed `Value::Function` path with arbitrary runtime Values, `req` MUST
+        // stay dynamic across the WHOLE pipeline (else the boxed closure panics "expected number" on
+        // the request object). Locks both promotion sites.
+        let src = "fn handler(req) { let s = 200; return s } \
+                   fn callWith(f, a) { return f(a) } \
+                   console.log(callWith(handler, { method: \"GET\" }))";
+        assert_eq!(end_to_end_param_ann(src, "handler", "req"), None);
+    }
+
+    #[test]
+    fn non_escaping_numeric_fn_keeps_native_fast_path_477() {
+        // CONTROL (no over-broad regression): a fn only ever called DIRECTLY with numbers still gets
+        // its `: number` native fast path — the #477 fix narrows promotion to escaping fns only.
+        let src = "fn square(n) { return n * n } console.log(square(7))";
+        assert_eq!(
+            end_to_end_param_ann(src, "square", "n").as_deref(),
+            Some("number")
+        );
+    }
 }
 
 #[cfg(test)]

package/crates/tish_fmt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang_fmt"
-version = "2.36.0"
+version = "2.37.0"
 edition = "2021"
 description = "Opinionated formatter for Tish source (parse → pretty-print)"
 license-file = { workspace = true }

package/crates/tish_runtime/Cargo.toml

@@ -79,7 +79,7 @@ ws = [
 tishlang_core = { path = "../tish_core", version = ">=0.1" }
 tishlang_builtins = { path = "../tish_builtins", version = ">=0.1" }
 tokio = { version = "1.50.0", features = ["rt-multi-thread", "macros", "time", "sync"], optional = true }
-reqwest = { version = "0.13.2", default-features = false, features = ["rustls", "json", "stream"], optional = true }
+reqwest = { version = "0.13.2", default-features = false, features = ["rustls", "json", "stream", "multipart"], optional = true }
 futures = { version = "0.3.32", optional = true }
 bytes = { version = "1", optional = true }
 tiny_http = { version = "0.12.0", optional = true }

package/crates/tish_runtime/src/http.rs

@@ -111,6 +111,57 @@ pub(crate) fn extract_body(options: Option<&Value>) -> Option<String> {
     })
 }
 
+/// A single `multipart/form-data` part extracted from a `fetch` options object's `multipart` array.
+pub(crate) enum MultipartPart {
+    /// A text field: `{ name, value }`.
+    Text { name: String, value: String },
+    /// A file field read from disk (binary-safe): `{ name, path, filename?, contentType? }`.
+    File {
+        name: String,
+        path: String,
+        filename: Option<String>,
+        content_type: Option<String>,
+    },
+}
+
+/// Extract the `multipart` option — an array of part descriptors — from a `fetch` options object.
+/// Each part is `{ name, value }` (text) or `{ name, path, filename?, contentType? }` (file, read as
+/// bytes so binary uploads work). Returns `None` when there is no usable `multipart` array, so callers
+/// fall back to `body`. A part missing `name`, or with neither `path` nor `value`, is skipped.
+pub(crate) fn extract_multipart(options: Option<&Value>) -> Option<Vec<MultipartPart>> {
+    let field = options.and_then(|v| match v {
+        Value::Object(obj) => obj.borrow().strings.get("multipart").cloned(),
+        _ => None,
+    })?;
+    let items = match field {
+        Value::Array(a) => a.borrow().clone(),
+        _ => return None,
+    };
+    let mut parts = Vec::with_capacity(items.len());
+    for item in items {
+        let obj = match &item {
+            Value::Object(o) => o.borrow(),
+            _ => continue,
+        };
+        let name = match obj.strings.get("name") {
+            Some(v) => v.to_display_string(),
+            None => continue,
+        };
+        let filename = obj.strings.get("filename").map(|v| v.to_display_string());
+        let content_type = obj.strings.get("contentType").map(|v| v.to_display_string());
+        if let Some(path) = obj.strings.get("path").map(|v| v.to_display_string()) {
+            parts.push(MultipartPart::File { name, path, filename, content_type });
+        } else if let Some(value) = obj.strings.get("value").map(|v| v.to_display_string()) {
+            parts.push(MultipartPart::Text { name, value });
+        }
+    }
+    if parts.is_empty() {
+        None
+    } else {
+        Some(parts)
+    }
+}
+
 pub(crate) fn build_error_response(error: &str) -> Value {
     let mut obj: ObjectMap = ObjectMap::with_capacity(2);
     obj.insert(Arc::from("error"), Value::String(error.into()));

package/crates/tish_runtime/src/http_fetch.rs

@@ -10,7 +10,10 @@ use futures::Stream;
 use futures::StreamExt;
 use tishlang_core::{NativeFn, ObjectMap, TishOpaque, TishPromise, Value};
 
-use crate::http::{build_error_response, extract_body, extract_headers, extract_method};
+use crate::http::{
+    build_error_response, extract_body, extract_headers, extract_method, extract_multipart,
+    MultipartPart,
+};
 
 // --- Promises (Send payloads only; Value built on awaiting thread) ---
 
@@ -479,6 +482,7 @@ async fn send_request_parts(
     method: String,
     headers: Vec<(String, String)>,
     body: Option<String>,
+    multipart: Option<Vec<MultipartPart>>,
 ) -> Result<reqwest::Response, String> {
     if fetch_block_private() {
         ssrf_preflight(&url).await?;
@@ -496,7 +500,39 @@ async fn send_request_parts(
     for (key, value) in headers {
         req = req.header(key, value);
     }
-    if let Some(body) = body {
+    // A `multipart` option takes precedence over `body` — it builds a multipart/form-data request
+    // (reqwest sets the Content-Type + boundary). File parts are read as bytes, so binary uploads work.
+    if let Some(parts) = multipart {
+        let mut form = reqwest::multipart::Form::new();
+        for part in parts {
+            match part {
+                MultipartPart::Text { name, value } => {
+                    form = form.text(name, value);
+                }
+                MultipartPart::File {
+                    name,
+                    path,
+                    filename,
+                    content_type,
+                } => {
+                    let bytes = std::fs::read(&path)
+                        .map_err(|e| format!("multipart file '{path}': {e}"))?;
+                    let fname = filename.unwrap_or_else(|| {
+                        std::path::Path::new(&path)
+                            .file_name()
+                            .map(|s| s.to_string_lossy().into_owned())
+                            .unwrap_or_else(|| name.clone())
+                    });
+                    let mut p = reqwest::multipart::Part::bytes(bytes).file_name(fname);
+                    if let Some(ct) = content_type {
+                        p = p.mime_str(&ct).map_err(|e| e.to_string())?;
+                    }
+                    form = form.part(name, p);
+                }
+            }
+        }
+        req = req.multipart(form);
+    } else if let Some(body) = body {
         req = req.body(body);
     }
     req.send().await.map_err(|e| e.to_string())
@@ -517,10 +553,11 @@ pub fn fetch_promise_from_args(args: Vec<Value>) -> Value {
     let method = extract_method(args.get(1));
     let headers = extract_headers(args.get(1));
     let body = extract_body(args.get(1));
+    let multipart = extract_multipart(args.get(1));
     let (tx, rx) = tokio::sync::oneshot::channel();
     crate::http::RUNTIME.with(|rt| {
         rt.spawn(async move {
-            let r = send_request_parts(url, method, headers, body).await;
+            let r = send_request_parts(url, method, headers, body, multipart).await;
             let _ = tx.send(r);
         });
     });
@@ -541,7 +578,13 @@ pub fn fetch_all_promise_from_args(args: Vec<Value>) -> Value {
         }
     };
     #[allow(clippy::type_complexity)]
-    let mut parts: Vec<(String, String, Vec<(String, String)>, Option<String>)> = Vec::new();
+    let mut parts: Vec<(
+        String,
+        String,
+        Vec<(String, String)>,
+        Option<String>,
+        Option<Vec<MultipartPart>>,
+    )> = Vec::new();
     for req in requests {
         let (url, opt) = match &req {
             Value::String(s) => (s.to_string(), None),
@@ -576,14 +619,15 @@ pub fn fetch_all_promise_from_args(args: Vec<Value>) -> Value {
         let method = extract_method(opt.as_ref());
         let headers = extract_headers(opt.as_ref());
         let body = extract_body(opt.as_ref());
-        parts.push((url, method, headers, body));
+        let multipart = extract_multipart(opt.as_ref());
+        parts.push((url, method, headers, body, multipart));
     }
     let (tx, rx) = tokio::sync::oneshot::channel();
     crate::http::RUNTIME.with(|rt| {
         rt.spawn(async move {
             let futs: Vec<_> = parts
                 .into_iter()
-                .map(|(url, m, h, b)| send_request_parts(url, m, h, b))
+                .map(|(url, m, h, b, mp)| send_request_parts(url, m, h, b, mp))
                 .collect();
             let results = futures::future::join_all(futs).await;
             let mapped: Vec<Result<reqwest::Response, String>> = results.into_iter().collect();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish-format",
-  "version": "2.36.0",
+  "version": "2.37.0",
   "description": "Tish code formatter",
   "license": "PIF",
   "repository": {