@tishlang/tish 1.5.0 → 1.7.0

package/Cargo.toml

@@ -28,6 +28,7 @@ members = [
     "crates/tish_fmt",
     "crates/tish_lint",
     "crates/tish_lsp",
+    "crates/tishlang_cargo_bindgen",
 ]
 resolver = "2"
 

package/crates/js_to_tish/src/error.rs

@@ -30,15 +30,9 @@ pub enum ConvertErrorKind {
     /// Semantic analysis error from OXC.
     Semantic(String),
     /// Unsupported construct (class, this, for-in, etc.).
-    Unsupported {
-        what: String,
-        hint: Option<String>,
-    },
+    Unsupported { what: String, hint: Option<String> },
     /// JS feature that cannot be expressed in Tish.
-    Incompatible {
-        what: String,
-        reason: String,
-    },
+    Incompatible { what: String, reason: String },
 }
 
 impl fmt::Display for ConvertErrorKind {

package/crates/js_to_tish/src/transform/expr.rs

@@ -5,8 +5,8 @@ use std::sync::Arc;
 use oxc::ast::ast::Expression as OxcExpr;
 use oxc::semantic::Semantic;
 use tishlang_ast::{
-    ArrayElement, ArrowBody, BinOp, CompoundOp, DestructPattern, Expr, Literal, LogicalAssignOp,
-    FunParam, MemberProp, ObjectProp, TypedParam,
+    ArrayElement, ArrowBody, BinOp, CompoundOp, DestructPattern, Expr, FunParam, Literal,
+    LogicalAssignOp, MemberProp, ObjectProp, TypedParam,
 };
 
 use crate::error::{ConvertError, ConvertErrorKind};
@@ -57,7 +57,12 @@ pub fn convert_expr(expr: &OxcExpr<'_>, ctx: &Ctx<'_>) -> Result<Expr, ConvertEr
             let left = Box::new(convert_expr(&b.left, ctx)?);
             let right = Box::new(convert_expr(&b.right, ctx)?);
             let op = convert_bin_op(&b.operator)?;
-            Ok(Expr::Binary { left, op, right, span })
+            Ok(Expr::Binary {
+                left,
+                op,
+                right,
+                span,
+            })
         }
         OxcExpr::UnaryExpression(u) => {
             let operand = Box::new(convert_expr(&u.argument, ctx)?);
@@ -112,10 +117,7 @@ pub fn convert_expr(expr: &OxcExpr<'_>, ctx: &Ctx<'_>) -> Result<Expr, ConvertEr
             })
         }
         OxcExpr::LogicalExpression(l) => {
-            if matches!(
-                l.operator,
-                oxc::ast::ast::LogicalOperator::Coalesce
-            ) {
+            if matches!(l.operator, oxc::ast::ast::LogicalOperator::Coalesce) {
                 Ok(Expr::NullishCoalesce {
                     left: Box::new(convert_expr(&l.left, ctx)?),
                     right: Box::new(convert_expr(&l.right, ctx)?),
@@ -155,12 +157,12 @@ pub fn convert_expr(expr: &OxcExpr<'_>, ctx: &Ctx<'_>) -> Result<Expr, ConvertEr
         OxcExpr::ArrowFunctionExpression(arrow) => {
             let params = convert_arrow_params(&arrow.params, ctx)?;
             let body = if arrow.expression {
-                let e = arrow
-                    .get_expression()
-                    .ok_or_else(|| ConvertError::new(ConvertErrorKind::Incompatible {
+                let e = arrow.get_expression().ok_or_else(|| {
+                    ConvertError::new(ConvertErrorKind::Incompatible {
                         what: "arrow expression body".into(),
                         reason: "expected expression".into(),
-                    }))?;
+                    })
+                })?;
                 ArrowBody::Expr(Box::new(convert_expr(e, ctx)?))
             } else {
                 let stmts = super::stmt::convert_statements(&arrow.body.statements, ctx.0, ctx.1)?;
@@ -169,11 +171,7 @@ pub fn convert_expr(expr: &OxcExpr<'_>, ctx: &Ctx<'_>) -> Result<Expr, ConvertEr
                     span: span_util::oxc_span_to_tish(ctx.1, &*arrow.body),
                 }))
             };
-            Ok(Expr::ArrowFunction {
-                params,
-                body,
-                span,
-            })
+            Ok(Expr::ArrowFunction { params, body, span })
         }
         OxcExpr::AwaitExpression(a) => Ok(Expr::Await {
             operand: Box::new(convert_expr(&a.argument, ctx)?),
@@ -226,11 +224,7 @@ pub fn convert_expr(expr: &OxcExpr<'_>, ctx: &Ctx<'_>) -> Result<Expr, ConvertEr
                     }))
                 }
             };
-            Ok(Expr::ArrowFunction {
-                params,
-                body,
-                span,
-            })
+            Ok(Expr::ArrowFunction { params, body, span })
         }
         _ => Err(ConvertError::new(ConvertErrorKind::Unsupported {
             what: format!("expression: {:?}", std::mem::discriminant(expr)),
@@ -285,7 +279,10 @@ fn convert_call_arg(
 ) -> Result<tishlang_ast::CallArg, ConvertError> {
     if arg.is_spread() {
         if let oxc::ast::ast::Argument::SpreadElement(s) = arg {
-            Ok(tishlang_ast::CallArg::Spread(convert_expr(&s.argument, ctx)?))
+            Ok(tishlang_ast::CallArg::Spread(convert_expr(
+                &s.argument,
+                ctx,
+            )?))
         } else {
             unreachable!()
         }
@@ -307,10 +304,12 @@ fn convert_array_element(
         oxc::ast::ast::ArrayExpressionElement::SpreadElement(s) => {
             Ok(ArrayElement::Spread(convert_expr(&s.argument, ctx)?))
         }
-        oxc::ast::ast::ArrayExpressionElement::Elision(_) => Ok(ArrayElement::Expr(Expr::Literal {
-            value: Literal::Null,
-            span: span_util::stub_span(),
-        })),
+        oxc::ast::ast::ArrayExpressionElement::Elision(_) => {
+            Ok(ArrayElement::Expr(Expr::Literal {
+                value: Literal::Null,
+                span: span_util::stub_span(),
+            }))
+        }
         _ => {
             if let Some(e) = el.as_expression() {
                 Ok(ArrayElement::Expr(convert_expr(e, ctx)?))
@@ -358,77 +357,59 @@ fn convert_assignment(
         let name = id.name.as_str();
         let value = Box::new(convert_expr(right, ctx)?);
         return match &a.operator {
-                oxc::ast::ast::AssignmentOperator::Assign => {
-                    Ok(Expr::Assign {
-                        name: Arc::from(name),
-                        value,
-                        span,
-                    })
-                }
-                oxc::ast::ast::AssignmentOperator::Addition => {
-                    Ok(Expr::CompoundAssign {
-                        name: Arc::from(name),
-                        op: CompoundOp::Add,
-                        value,
-                        span,
-                    })
-                }
-                oxc::ast::ast::AssignmentOperator::Subtraction => {
-                    Ok(Expr::CompoundAssign {
-                        name: Arc::from(name),
-                        op: CompoundOp::Sub,
-                        value,
-                        span,
-                    })
-                }
-                oxc::ast::ast::AssignmentOperator::Multiplication => {
-                    Ok(Expr::CompoundAssign {
-                        name: Arc::from(name),
-                        op: CompoundOp::Mul,
-                        value,
-                        span,
-                    })
-                }
-                oxc::ast::ast::AssignmentOperator::Division => {
-                    Ok(Expr::CompoundAssign {
-                        name: Arc::from(name),
-                        op: CompoundOp::Div,
-                        value,
-                        span,
-                    })
-                }
-                oxc::ast::ast::AssignmentOperator::Remainder => {
-                    Ok(Expr::CompoundAssign {
-                        name: Arc::from(name),
-                        op: CompoundOp::Mod,
-                        value,
-                        span,
-                    })
-                }
-                oxc::ast::ast::AssignmentOperator::LogicalAnd => {
-                    Ok(Expr::LogicalAssign {
-                        name: Arc::from(name),
-                        op: LogicalAssignOp::AndAnd,
-                        value,
-                        span,
-                    })
-                }
-                oxc::ast::ast::AssignmentOperator::LogicalOr => {
-                    Ok(Expr::LogicalAssign {
-                        name: Arc::from(name),
-                        op: LogicalAssignOp::OrOr,
-                        value,
-                        span,
-                    })
-                }
-                oxc::ast::ast::AssignmentOperator::LogicalNullish => {
-                    Ok(Expr::LogicalAssign {
-                        name: Arc::from(name),
-                        op: LogicalAssignOp::Nullish,
-                        value,
-                        span,
-                    })
-                }
+            oxc::ast::ast::AssignmentOperator::Assign => Ok(Expr::Assign {
+                name: Arc::from(name),
+                value,
+                span,
+            }),
+            oxc::ast::ast::AssignmentOperator::Addition => Ok(Expr::CompoundAssign {
+                name: Arc::from(name),
+                op: CompoundOp::Add,
+                value,
+                span,
+            }),
+            oxc::ast::ast::AssignmentOperator::Subtraction => Ok(Expr::CompoundAssign {
+                name: Arc::from(name),
+                op: CompoundOp::Sub,
+                value,
+                span,
+            }),
+            oxc::ast::ast::AssignmentOperator::Multiplication => Ok(Expr::CompoundAssign {
+                name: Arc::from(name),
+                op: CompoundOp::Mul,
+                value,
+                span,
+            }),
+            oxc::ast::ast::AssignmentOperator::Division => Ok(Expr::CompoundAssign {
+                name: Arc::from(name),
+                op: CompoundOp::Div,
+                value,
+                span,
+            }),
+            oxc::ast::ast::AssignmentOperator::Remainder => Ok(Expr::CompoundAssign {
+                name: Arc::from(name),
+                op: CompoundOp::Mod,
+                value,
+                span,
+            }),
+            oxc::ast::ast::AssignmentOperator::LogicalAnd => Ok(Expr::LogicalAssign {
+                name: Arc::from(name),
+                op: LogicalAssignOp::AndAnd,
+                value,
+                span,
+            }),
+            oxc::ast::ast::AssignmentOperator::LogicalOr => Ok(Expr::LogicalAssign {
+                name: Arc::from(name),
+                op: LogicalAssignOp::OrOr,
+                value,
+                span,
+            }),
+            oxc::ast::ast::AssignmentOperator::LogicalNullish => Ok(Expr::LogicalAssign {
+                name: Arc::from(name),
+                op: LogicalAssignOp::Nullish,
+                value,
+                span,
+            }),
             _ => Err(ConvertError::new(ConvertErrorKind::Unsupported {
                 what: "assignment operator".into(),
                 hint: None,
@@ -458,24 +439,14 @@ fn convert_update_expr(
         }
     };
     Ok(match (u.operator, u.prefix) {
-        (oxc::ast::ast::UpdateOperator::Increment, true) => {
-            Expr::PrefixInc { name, span }
-        }
-        (oxc::ast::ast::UpdateOperator::Increment, false) => {
-            Expr::PostfixInc { name, span }
-        }
-        (oxc::ast::ast::UpdateOperator::Decrement, true) => {
-            Expr::PrefixDec { name, span }
-        }
-        (oxc::ast::ast::UpdateOperator::Decrement, false) => {
-            Expr::PostfixDec { name, span }
-        }
+        (oxc::ast::ast::UpdateOperator::Increment, true) => Expr::PrefixInc { name, span },
+        (oxc::ast::ast::UpdateOperator::Increment, false) => Expr::PostfixInc { name, span },
+        (oxc::ast::ast::UpdateOperator::Decrement, true) => Expr::PrefixDec { name, span },
+        (oxc::ast::ast::UpdateOperator::Decrement, false) => Expr::PostfixDec { name, span },
     })
 }
 
-fn convert_bin_op(
-    op: &oxc::ast::ast::BinaryOperator,
-) -> Result<BinOp, ConvertError> {
+fn convert_bin_op(op: &oxc::ast::ast::BinaryOperator) -> Result<BinOp, ConvertError> {
     Ok(match op {
         oxc::ast::ast::BinaryOperator::Equality => BinOp::Eq,
         oxc::ast::ast::BinaryOperator::Inequality => BinOp::Ne,
@@ -554,24 +525,24 @@ pub fn convert_params(
         let fp = p;
         {
             let name = match &fp.pattern {
-                    oxc::ast::ast::BindingPattern::BindingIdentifier(b) => b.name.as_str(),
-                    _ => {
-                        return Err(ConvertError::new(ConvertErrorKind::Unsupported {
-                            what: "destructuring in params".into(),
-                            hint: None,
-                        }))
-                    }
-                };
-                let default = fp
-                    .initializer
-                    .as_ref()
-                    .map(|e| convert_expr(e, ctx))
-                    .transpose()?;
-                typed_params.push(FunParam::Simple(TypedParam {
-                    name: Arc::from(name),
-                    type_ann: None,
-                    default,
-                }));
+                oxc::ast::ast::BindingPattern::BindingIdentifier(b) => b.name.as_str(),
+                _ => {
+                    return Err(ConvertError::new(ConvertErrorKind::Unsupported {
+                        what: "destructuring in params".into(),
+                        hint: None,
+                    }))
+                }
+            };
+            let default = fp
+                .initializer
+                .as_ref()
+                .map(|e| convert_expr(e, ctx))
+                .transpose()?;
+            typed_params.push(FunParam::Simple(TypedParam {
+                name: Arc::from(name),
+                type_ann: None,
+                default,
+            }));
         }
     }
     if rest_param.is_none() {

package/crates/js_to_tish/src/transform/stmt.rs

@@ -4,7 +4,7 @@ use std::sync::Arc;
 
 use oxc::ast::ast::Statement as OxcStmt;
 use oxc::semantic::Semantic;
-use tishlang_ast::{Statement, Span};
+use tishlang_ast::{Span, Statement};
 
 use super::expr;
 use crate::error::{ConvertError, ConvertErrorKind};
@@ -19,9 +19,7 @@ pub fn convert_statements(
     source: &str,
 ) -> Result<Vec<Statement>, ConvertError> {
     let ctx = (semantic, source);
-    body.iter()
-        .map(|s| convert_statement(s, &ctx))
-        .collect()
+    body.iter().map(|s| convert_statement(s, &ctx)).collect()
 }
 
 fn convert_statement(stmt: &OxcStmt<'_>, ctx: &Ctx<'_>) -> Result<Statement, ConvertError> {
@@ -29,10 +27,7 @@ fn convert_statement(stmt: &OxcStmt<'_>, ctx: &Ctx<'_>) -> Result<Statement, Con
     match stmt {
         OxcStmt::BlockStatement(b) => {
             let statements = convert_statements(&b.body, ctx.0, ctx.1)?;
-            Ok(Statement::Block {
-                statements,
-                span,
-            })
+            Ok(Statement::Block { statements, span })
         }
         OxcStmt::VariableDeclaration(v) => convert_var_decl(v, ctx, span),
         OxcStmt::ExpressionStatement(e) => {
@@ -146,7 +141,11 @@ fn convert_var_decl(
     if v.declarations.len() == 1 {
         let d = &v.declarations[0];
         let id = &d.id;
-        let init = d.init.as_ref().map(|i| expr::convert_expr(i, ctx)).transpose()?;
+        let init = d
+            .init
+            .as_ref()
+            .map(|i| expr::convert_expr(i, ctx))
+            .transpose()?;
         match id {
             oxc::ast::ast::BindingPattern::BindingIdentifier(b) => {
                 let name: Arc<str> = Arc::from(b.name.as_str());
@@ -314,13 +313,16 @@ fn convert_try_statement(
     });
     let (catch_param, catch_body) = match &t.handler {
         Some(h) => {
-            let param = h.param.as_ref().and_then(|cp: &oxc::ast::ast::CatchParameter<'_>| {
-                if let oxc::ast::ast::BindingPattern::BindingIdentifier(b) = &cp.pattern {
-                    Some(Arc::from(b.name.as_str()))
-                } else {
-                    None
-                }
-            });
+            let param = h
+                .param
+                .as_ref()
+                .and_then(|cp: &oxc::ast::ast::CatchParameter<'_>| {
+                    if let oxc::ast::ast::BindingPattern::BindingIdentifier(b) = &cp.pattern {
+                        Some(Arc::from(b.name.as_str()))
+                    } else {
+                        None
+                    }
+                });
             let catch_stmts = convert_statements(&h.body.body, ctx.0, ctx.1)?;
             let cb = Box::new(Statement::Block {
                 statements: catch_stmts,
@@ -356,11 +358,10 @@ fn convert_function_decl(
     span: Span,
 ) -> Result<Statement, ConvertError> {
     let async_ = f.r#async;
-    let name: Arc<str> = f
-        .id
-        .as_ref()
-        .map(|id| Arc::from(id.name.as_str()))
-        .unwrap_or_else(|| Arc::from(""));
+    let name: Arc<str> =
+        f.id.as_ref()
+            .map(|id| Arc::from(id.name.as_str()))
+            .unwrap_or_else(|| Arc::from(""));
     let (params, rest_param) = expr::convert_params(&f.params, ctx)?;
     let body = match &f.body {
         Some(fb) => {
@@ -439,7 +440,9 @@ fn convert_export_default(
     let declaration = if let Some(expr) = e.declaration.as_expression() {
         let expr = expr::convert_expr(expr, ctx)?;
         tishlang_ast::ExportDeclaration::Default(expr)
-    } else if let oxc::ast::ast::ExportDefaultDeclarationKind::FunctionDeclaration(f) = &e.declaration {
+    } else if let oxc::ast::ast::ExportDefaultDeclarationKind::FunctionDeclaration(f) =
+        &e.declaration
+    {
         let stmt = convert_function_decl(f.as_ref(), ctx, span_util::stub_span())?;
         tishlang_ast::ExportDeclaration::Named(Box::new(stmt))
     } else {

package/crates/tish/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang"
-version = "1.5.0"
+version = "1.7.0"
 edition = "2021"
 description = "Tish CLI - run, REPL, compile to native"
 license-file = { workspace = true }

package/crates/tish/src/cli_help.rs

@@ -9,7 +9,7 @@ use clap::{CommandFactory, Parser, Subcommand};
 
 /// FIGlet-style block letters (UTF-8). On a TTY, a short expand + palette-color animation runs.
 const TISH_BANNER_LINES: &[&str] = &[
-        "",
+    "",
     "████████╗██╗███████╗██╗  ██╗",
     "╚══██╔══╝██║██╔════╝██║  ██║",
     "   ██║   ██║███████╗███████║",
@@ -26,13 +26,13 @@ const BANNER_FRAME_MS: u64 = 20;
 
 /// Orange → Yellow → Green → Teal → Blue → Purple → Pink (matching the brand palette).
 const PALETTE: &[(u8, u8, u8)] = &[
-    (255, 159,  64),  // Orange
-    (255, 213,  64),  // Yellow
-    ( 52, 199,  89),  // Green
-    ( 48, 209, 188),  // Teal
-    ( 10, 132, 255),  // Blue
-    (175,  82, 222),  // Purple
-    (255,  55, 148),  // Pink
+    (255, 159, 64), // Orange
+    (255, 213, 64), // Yellow
+    (52, 199, 89),  // Green
+    (48, 209, 188), // Teal
+    (10, 132, 255), // Blue
+    (175, 82, 222), // Purple
+    (255, 55, 148), // Pink
 ];
 
 fn ease_out_cubic(t: f32) -> f32 {
@@ -128,8 +128,8 @@ pub fn print_tish_banner() {
 pub fn build_command() -> clap::Command {
     Cli::command()
         .after_help(cli_after_help())
-        .mut_subcommand("run",   |sub| sub.after_help(run_after_help()))
-        .mut_subcommand("repl",  |sub| sub.after_help(repl_after_help()))
+        .mut_subcommand("run", |sub| sub.after_help(run_after_help()))
+        .mut_subcommand("repl", |sub| sub.after_help(repl_after_help()))
         .mut_subcommand("build", |sub| sub.after_long_help(build_after_help()))
 }
 
@@ -138,7 +138,10 @@ fn count_help_lines(cmd: &mut clap::Command, sub_name: Option<&str>) -> usize {
     let mut buf = Vec::<u8>::new();
     if let Some(name) = sub_name {
         if cmd.find_subcommand(name).is_some() {
-            let _ = cmd.find_subcommand_mut(name).unwrap().write_long_help(&mut buf);
+            let _ = cmd
+                .find_subcommand_mut(name)
+                .unwrap()
+                .write_long_help(&mut buf);
         } else {
             let _ = cmd.write_long_help(&mut buf);
         }
@@ -236,8 +239,11 @@ pub fn print_banner_with_help(argv: &[String]) {
         let mut out = io::stdout().lock();
         write_tish_banner_frame(&mut out, 1.0, 0);
         let _ = writeln!(out); // blank separator  (row n+1)
-        // ── Manual prefix (MAIN_PREFIX_LINES = 4 lines) ──────────────────
-        let _ = writeln!(out, "{H_PURPLE}Tish{H_RESET} {H_GREY}(version {VERSION}){H_RESET}");
+                               // ── Manual prefix (MAIN_PREFIX_LINES = 4 lines) ──────────────────
+        let _ = writeln!(
+            out,
+            "{H_PURPLE}Tish{H_RESET} {H_GREY}(version {VERSION}){H_RESET}"
+        );
         let _ = writeln!(out, "Minimal TS/JS-ish language");
         let _ = writeln!(out, "{H_PINK}https://tishlang.com{H_RESET}");
         let _ = writeln!(out); // blank before Usage
@@ -289,20 +295,24 @@ fn rgb_bold(r: u8, g: u8, b: u8) -> Style {
 /// Orange → section headers / usage.  Teal → literals (commands, flags).  Yellow → placeholders.
 pub fn cargo_help_styles() -> Styles {
     Styles::styled()
-        .header(rgb_bold(255, 159,  64))      // Orange  – "Commands:", "Options:", "Usage:"
-        .usage(rgb_bold(255, 159,  64))       // Orange
-        .literal(rgb_bold( 48, 209, 188))     // Teal    – run, repl, --help, -V …
-        .placeholder(rgb_bold(255, 213,  64)) // Yellow  – <FILE>, <NAME>, …
-        .error(rgb_bold(255,  55, 148))       // Pink    – error messages
-        .valid(rgb_bold( 52, 199,  89))       // Green   – valid values
-        .invalid(rgb_bold(255,  55, 148))     // Pink    – invalid values
+        .header(rgb_bold(255, 159, 64)) // Orange  – "Commands:", "Options:", "Usage:"
+        .usage(rgb_bold(255, 159, 64)) // Orange
+        .literal(rgb_bold(48, 209, 188)) // Teal    – run, repl, --help, -V …
+        .placeholder(rgb_bold(255, 213, 64)) // Yellow  – <FILE>, <NAME>, …
+        .error(rgb_bold(255, 55, 148)) // Pink    – error messages
+        .valid(rgb_bold(52, 199, 89)) // Green   – valid values
+        .invalid(rgb_bold(255, 55, 148)) // Pink    – invalid values
 }
 
 /// Returns the colored `after_help` text for the top-level `tish --help`.
 /// Colors are emitted only when stdout is a TTY.
 pub fn cli_after_help() -> String {
     let (oh, t, r) = if io::stdout().is_terminal() {
-        ("\x1b[1;38;2;255;159;64m", "\x1b[1;38;2;48;209;188m", "\x1b[0m")
+        (
+            "\x1b[1;38;2;255;159;64m",
+            "\x1b[1;38;2;48;209;188m",
+            "\x1b[0m",
+        )
     } else {
         ("", "", "")
     };
@@ -346,7 +356,11 @@ Omit --feature to use every capability linked into this binary."
 /// Returns the colored `after_help` for `tish run --help`.
 pub fn run_after_help() -> String {
     let (oh, t, r) = if io::stdout().is_terminal() {
-        ("\x1b[1;38;2;255;159;64m", "\x1b[1;38;2;48;209;188m", "\x1b[0m")
+        (
+            "\x1b[1;38;2;255;159;64m",
+            "\x1b[1;38;2;48;209;188m",
+            "\x1b[0m",
+        )
     } else {
         ("", "", "")
     };
@@ -356,7 +370,11 @@ pub fn run_after_help() -> String {
 /// Returns the colored `after_help` for `tish repl --help`.
 pub fn repl_after_help() -> String {
     let (oh, t, r) = if io::stdout().is_terminal() {
-        ("\x1b[1;38;2;255;159;64m", "\x1b[1;38;2;48;209;188m", "\x1b[0m")
+        (
+            "\x1b[1;38;2;255;159;64m",
+            "\x1b[1;38;2;48;209;188m",
+            "\x1b[0m",
+        )
     } else {
         ("", "", "")
     };
@@ -366,7 +384,11 @@ pub fn repl_after_help() -> String {
 /// Returns the colored `after_long_help` for `tish build --help`.
 pub fn build_after_help() -> String {
     let (oh, t, r) = if io::stdout().is_terminal() {
-        ("\x1b[1;38;2;255;159;64m", "\x1b[1;38;2;48;209;188m", "\x1b[0m")
+        (
+            "\x1b[1;38;2;255;159;64m",
+            "\x1b[1;38;2;48;209;188m",
+            "\x1b[0m",
+        )
     } else {
         ("", "", "")
     };
@@ -421,10 +443,20 @@ pub(crate) struct Cli {
 #[derive(Parser)]
 pub(crate) struct RunArgs {
     /// Path to a `.tish` file, or `-` to read the program from stdin (like `node -`).
-    #[arg(required = true, allow_hyphen_values = true, value_name = "FILE", help_heading = "Arguments")]
+    #[arg(
+        required = true,
+        allow_hyphen_values = true,
+        value_name = "FILE",
+        help_heading = "Arguments"
+    )]
     pub file: String,
     /// `vm` or `interp` (see `tish --help` for capabilities / `--feature`).
-    #[arg(long, default_value = "vm", value_name = "NAME", help_heading = "Options")]
+    #[arg(
+        long,
+        default_value = "vm",
+        value_name = "NAME",
+        help_heading = "Options"
+    )]
     pub backend: String,
     /// Subset of capabilities (see `tish --help` for the full list).
     #[arg(
@@ -442,7 +474,12 @@ pub(crate) struct RunArgs {
 #[derive(Parser)]
 pub(crate) struct ReplArgs {
     /// `vm` or `interp` (see `tish --help`).
-    #[arg(long, default_value = "vm", value_name = "NAME", help_heading = "Options")]
+    #[arg(
+        long,
+        default_value = "vm",
+        value_name = "NAME",
+        help_heading = "Options"
+    )]
     pub backend: String,
     /// Subset of capabilities (see `tish --help` for the full list).
     #[arg(
@@ -467,10 +504,20 @@ pub(crate) struct BuildArgs {
     )]
     pub output: String,
     /// `native`, `js`, `wasm`, or `wasi` (see long help below).
-    #[arg(long, default_value = "native", value_name = "TARGET", help_heading = "Options")]
+    #[arg(
+        long,
+        default_value = "native",
+        value_name = "TARGET",
+        help_heading = "Options"
+    )]
     pub target: String,
     /// `rust`, `cranelift`, or `llvm` (only for `--target native`).
-    #[arg(long, default_value = "rust", value_name = "BACKEND", help_heading = "Options")]
+    #[arg(
+        long,
+        default_value = "rust",
+        value_name = "BACKEND",
+        help_heading = "Options"
+    )]
     pub native_backend: String,
     /// Capability subset for native output (see long help below).
     #[arg(