@tishlang/tish-format 1.0.12 → 1.0.13

package/crates/tish_lexer/src/token.rs

@@ -0,0 +1,163 @@
+//! Token types for the Tish lexer.
+
+use std::sync::Arc;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Span {
+    pub start: (usize, usize), // line, col
+    pub end: (usize, usize),
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Token {
+    pub kind: TokenKind,
+    pub span: Span,
+    pub literal: Option<Arc<str>>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TokenKind {
+    // Virtual tokens for optional braces
+    Indent,
+    Dedent,
+
+    // Literals
+    Number,
+    String,
+    True,
+    False,
+    Null,
+
+    // Identifiers and keywords
+    Ident,
+    Fn,
+    Let,
+    Const,
+    If,
+    Else,
+    While,
+    For,
+    Return,
+    Break,
+    Continue,
+    Throw,
+    Try,
+    Catch,
+    Finally,
+    Switch,
+    Case,
+    Default,
+    Do,
+    TypeOf,
+    Void,
+    Of,
+    In,
+    Async,
+    Await,
+    New,
+    Import,
+    Export,
+    Type,
+    Declare,
+
+    // Punctuation
+    LParen,
+    RParen,
+    LBrace,
+    RBrace,
+    LBracket,
+    RBracket,
+    Semicolon,
+    Comma,
+    Dot,
+    Spread,
+    Colon,
+
+    // Operators
+    Assign,
+    AndAndAssign,
+    OrOrAssign,
+    NullishAssign,
+    PlusAssign,
+    MinusAssign,
+    StarAssign,
+    SlashAssign,
+    PercentAssign,
+    Eq,
+    Ne,
+    StrictEq,
+    StrictNe,
+    Lt,
+    Le,
+    Gt,
+    Ge,
+    Plus,
+    Minus,
+    PlusPlus,
+    MinusMinus,
+    Star,
+    StarStar,
+    Slash,
+    Percent,
+    And,
+    Or,
+    Not,
+    BitAnd,
+    BitOr,
+    BitXor,
+    BitNot,
+    Shl,
+    Shr,
+    OptionalChain,
+    NullishCoalesce,
+    Question,
+    Arrow,
+
+    // Template literal tokens
+    TemplateNoSub,  // `text` (no interpolation)
+    TemplateHead,   // `text${  (start with interpolation)
+    TemplateMiddle, // }text${  (middle part)
+    TemplateTail,   // }text`   (end part)
+
+    JsxText, // Raw text in JSX children (emojis, etc.); only {}<> are special
+}
+
+impl TokenKind {
+    pub fn keyword_or_ident(s: &str) -> Self {
+        match s {
+            "fn" | "function" => TokenKind::Fn,
+            "let" => TokenKind::Let,
+            "const" => TokenKind::Const,
+            "if" => TokenKind::If,
+            "else" => TokenKind::Else,
+            "while" => TokenKind::While,
+            "for" => TokenKind::For,
+            "return" => TokenKind::Return,
+            "break" => TokenKind::Break,
+            "continue" => TokenKind::Continue,
+            "true" => TokenKind::True,
+            "false" => TokenKind::False,
+            "null" => TokenKind::Null,
+            "throw" => TokenKind::Throw,
+            "try" => TokenKind::Try,
+            "catch" => TokenKind::Catch,
+            "finally" => TokenKind::Finally,
+            "switch" => TokenKind::Switch,
+            "case" => TokenKind::Case,
+            "default" => TokenKind::Default,
+            "do" => TokenKind::Do,
+            "typeof" => TokenKind::TypeOf,
+            "void" => TokenKind::Void,
+            "of" => TokenKind::Of,
+            "in" => TokenKind::In,
+            "async" => TokenKind::Async,
+            "await" => TokenKind::Await,
+            "new" => TokenKind::New,
+            "import" => TokenKind::Import,
+            "export" => TokenKind::Export,
+            "type" => TokenKind::Type,
+            "declare" => TokenKind::Declare,
+            _ => TokenKind::Ident,
+        }
+    }
+}

package/crates/tish_lint/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "tishlang_lint"
+version = "0.1.0"
+edition = "2021"
+description = "AST-based linter for Tish"
+license-file = { workspace = true }
+repository = { workspace = true }
+
+[[bin]]
+name = "tish-lint"
+path = "src/bin/tish-lint.rs"
+
+[dependencies]
+clap = { version = "4.6.0", features = ["derive"] }
+serde_json = "1.0"
+walkdir = "2"
+tishlang_ast = { path = "../tish_ast", version = ">=0.1" }
+tishlang_parser = { path = "../tish_parser", version = ">=0.1" }

package/crates/tish_lint/src/bin/tish-lint.rs

@@ -0,0 +1,195 @@
+//! Standalone linter — not part of the `tish` compiler CLI.
+
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use clap::{Parser, ValueEnum};
+use serde_json::json;
+
+#[derive(Clone, Copy, Debug, ValueEnum)]
+enum OutputFormat {
+    Text,
+    Sarif,
+}
+
+#[derive(Parser)]
+#[command(name = "tish-lint")]
+#[command(about = "AST-based linter for Tish")]
+struct Cli {
+    /// Output format (SARIF 2.1.0 for code scanning integrations).
+    #[arg(long = "format", value_enum, default_value_t = OutputFormat::Text)]
+    output_format: OutputFormat,
+
+    #[arg(required = true)]
+    paths: Vec<String>,
+}
+
+#[derive(Debug)]
+struct Issue {
+    path: PathBuf,
+    line: u32,
+    col: u32,
+    code: String,
+    message: String,
+    level: &'static str,
+}
+
+fn main() {
+    let cli = Cli::parse();
+    if let Err(e) = run(&cli.paths, cli.output_format) {
+        eprintln!("{}", e);
+        std::process::exit(1);
+    }
+}
+
+fn collect_files(paths: &[String]) -> Result<Vec<PathBuf>, String> {
+    let mut files: Vec<PathBuf> = Vec::new();
+    for p in paths {
+        let path = Path::new(p);
+        if path.is_dir() {
+            for e in walkdir::WalkDir::new(path)
+                .into_iter()
+                .filter_map(|e| e.ok())
+            {
+                if e.path().extension().map(|x| x == "tish").unwrap_or(false) {
+                    files.push(e.path().to_path_buf());
+                }
+            }
+        } else if path.exists() {
+            files.push(path.to_path_buf());
+        } else {
+            return Err(format!("Not found: {}", p));
+        }
+    }
+    if files.is_empty() {
+        return Err("No .tish files to lint".into());
+    }
+    Ok(files)
+}
+
+fn run(paths: &[String], format: OutputFormat) -> Result<(), String> {
+    let files = collect_files(paths)?;
+    let mut issues: Vec<Issue> = Vec::new();
+    for f in files {
+        let src = fs::read_to_string(&f).map_err(|e| format!("{}: {}", f.display(), e))?;
+        match tishlang_lint::lint_source(&src) {
+            Ok(diags) => {
+                for d in diags {
+                    let level = match d.severity {
+                        tishlang_lint::Severity::Error => "error",
+                        tishlang_lint::Severity::Warning => "warning",
+                    };
+                    issues.push(Issue {
+                        path: f.clone(),
+                        line: d.line,
+                        col: d.col,
+                        code: d.code.to_string(),
+                        message: d.message,
+                        level,
+                    });
+                }
+            }
+            Err(e) => {
+                issues.push(Issue {
+                    path: f.clone(),
+                    line: 1,
+                    col: 1,
+                    code: "tish-parse-error".into(),
+                    message: e,
+                    level: "error",
+                });
+            }
+        }
+    }
+
+    let error_count = issues.iter().filter(|i| i.level == "error").count();
+
+    match format {
+        OutputFormat::Text => {
+            for i in &issues {
+                println!(
+                    "{}:{}:{}: {} [{}] {}",
+                    i.path.display(),
+                    i.line,
+                    i.col,
+                    i.level,
+                    i.code,
+                    i.message
+                );
+            }
+            if error_count > 0 {
+                return Err(format!("{} issue(s)", error_count));
+            }
+        }
+        OutputFormat::Sarif => {
+            print_sarif(&issues)?;
+            if error_count > 0 {
+                return Err(format!("{} issue(s)", error_count));
+            }
+        }
+    }
+
+    Ok(())
+}
+
+fn print_sarif(issues: &[Issue]) -> Result<(), String> {
+    let rules: Vec<_> = tishlang_lint::RULES
+        .iter()
+        .map(|(id, desc)| {
+            json!({
+                "id": id,
+                "name": id,
+                "shortDescription": { "text": desc },
+                "helpUri": "https://tishlang.com/docs/reference/linting/"
+            })
+        })
+        .chain(std::iter::once(json!({
+            "id": "tish-parse-error",
+            "name": "tish-parse-error",
+            "shortDescription": { "text": "Source failed to parse as Tish." },
+            "helpUri": "https://tishlang.com/docs/language/overview/"
+        })))
+        .collect();
+
+    let results: Vec<_> = issues
+        .iter()
+        .map(|i| {
+            let uri = i.path.to_str().unwrap_or("unknown").replace('\\', "/");
+            json!({
+                "ruleId": i.code,
+                "level": i.level,
+                "message": { "text": i.message },
+                "locations": [{
+                    "physicalLocation": {
+                        "artifactLocation": { "uri": uri },
+                        "region": {
+                            "startLine": i.line,
+                            "startColumn": i.col
+                        }
+                    }
+                }]
+            })
+        })
+        .collect();
+
+    let doc = json!({
+        "version": "2.1.0",
+        "$schema": "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json",
+        "runs": [{
+            "tool": {
+                "driver": {
+                    "name": "tish-lint",
+                    "informationUri": "https://tishlang.com/docs/reference/linting/",
+                    "rules": rules
+                }
+            },
+            "results": results
+        }]
+    });
+
+    println!(
+        "{}",
+        serde_json::to_string_pretty(&doc).map_err(|e| e.to_string())?
+    );
+    Ok(())
+}

package/crates/tish_lint/src/lib.rs

@@ -0,0 +1,289 @@
+//! AST-based lints for Tish. Rule IDs are stable for CI and editors.
+
+use std::collections::HashSet;
+
+use tishlang_ast::{Expr, ObjectProp, Program, Statement};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Severity {
+    Warning,
+    Error,
+}
+
+#[derive(Debug, Clone)]
+pub struct LintDiagnostic {
+    pub code: &'static str,
+    pub message: String,
+    /// 1-based line
+    pub line: u32,
+    /// 1-based column (UTF-16 offset preferred for LSP; we use byte col as approx)
+    pub col: u32,
+    pub severity: Severity,
+}
+
+/// Run all default rules on parsed program.
+pub fn lint_program(program: &Program) -> Vec<LintDiagnostic> {
+    let mut out = Vec::new();
+    for s in &program.statements {
+        lint_stmt(s, &mut out);
+    }
+    out
+}
+
+/// Lint source: parse then lint. Parse errors are not reported here.
+pub fn lint_source(source: &str) -> Result<Vec<LintDiagnostic>, String> {
+    let program = tishlang_parser::parse(source)?;
+    Ok(lint_program(&program))
+}
+
+fn lint_stmt(s: &Statement, out: &mut Vec<LintDiagnostic>) {
+    match s {
+        Statement::Try {
+            body,
+            catch_param,
+            catch_body,
+            finally_body,
+            ..
+        } => {
+            lint_stmt(body, out);
+            if let (Some(_), Some(cb)) = (catch_param, catch_body) {
+                if is_empty_block_or_stmt(cb) {
+                    let span = stmt_span(cb);
+                    out.push(LintDiagnostic {
+                        code: "tish-empty-catch",
+                        message: "Empty catch block; handle or rethrow the error.".into(),
+                        line: span.0,
+                        col: span.1,
+                        severity: Severity::Warning,
+                    });
+                }
+                lint_stmt(cb, out);
+            }
+            if let Some(fb) = finally_body {
+                lint_stmt(fb, out);
+            }
+        }
+        Statement::Block { statements, .. } => {
+            for st in statements {
+                lint_stmt(st, out);
+            }
+        }
+        Statement::If {
+            then_branch,
+            else_branch,
+            ..
+        } => {
+            lint_stmt(then_branch, out);
+            if let Some(e) = else_branch {
+                lint_stmt(e, out);
+            }
+        }
+        Statement::While { body, .. } | Statement::ForOf { body, .. } => lint_stmt(body, out),
+        Statement::For { init, body, .. } => {
+            if let Some(i) = init {
+                lint_stmt(i, out);
+            }
+            lint_stmt(body, out);
+        }
+        Statement::FunDecl { body, .. } => lint_stmt(body, out),
+        Statement::Switch {
+            cases,
+            default_body,
+            ..
+        } => {
+            for (_, stmts) in cases {
+                for st in stmts {
+                    lint_stmt(st, out);
+                }
+            }
+            if let Some(def) = default_body {
+                for st in def {
+                    lint_stmt(st, out);
+                }
+            }
+        }
+        Statement::DoWhile { body, .. } => lint_stmt(body, out),
+        Statement::Export { declaration, .. } => {
+            if let tishlang_ast::ExportDeclaration::Named(inner) = declaration.as_ref() {
+                lint_stmt(inner, out);
+            }
+        }
+        Statement::ExprStmt { expr, .. } => lint_expr(expr, out),
+        Statement::VarDecl { init, .. } => {
+            if let Some(e) = init {
+                lint_expr(e, out);
+            }
+        }
+        Statement::VarDeclDestructure { init, .. } => lint_expr(init, out),
+        Statement::Return { value, .. } => {
+            if let Some(e) = value {
+                lint_expr(e, out);
+            }
+        }
+        Statement::Throw { value, .. } => lint_expr(value, out),
+        _ => {}
+    }
+}
+
+fn is_empty_block_or_stmt(s: &Statement) -> bool {
+    match s {
+        Statement::Block { statements, .. } => statements.is_empty(),
+        Statement::ExprStmt { .. } => false,
+        _ => false,
+    }
+}
+
+fn stmt_span(s: &Statement) -> (u32, u32) {
+    let sp = match s {
+        Statement::Block { span, .. } => *span,
+        Statement::Try { span, .. } => *span,
+        _ => tishlang_ast::Span {
+            start: (1, 1),
+            end: (1, 1),
+        },
+    };
+    (sp.start.0 as u32, sp.start.1 as u32)
+}
+
+fn lint_expr(e: &Expr, out: &mut Vec<LintDiagnostic>) {
+    match e {
+        Expr::Object { props, span, .. } => {
+            let mut seen: HashSet<&str> = HashSet::new();
+            for p in props {
+                if let ObjectProp::KeyValue(k, v) = p {
+                    if !seen.insert(k.as_ref()) {
+                        out.push(LintDiagnostic {
+                            code: "tish-duplicate-key",
+                            message: format!("Duplicate object key `{}`", k),
+                            line: span.start.0 as u32,
+                            col: span.start.1 as u32,
+                            severity: Severity::Warning,
+                        });
+                    }
+                    lint_expr(v, out);
+                } else if let ObjectProp::Spread(ex) = p {
+                    lint_expr(ex, out);
+                }
+            }
+        }
+        Expr::Binary { left, right, .. } => {
+            lint_expr(left, out);
+            lint_expr(right, out);
+        }
+        Expr::Unary { operand, .. } => lint_expr(operand, out),
+        Expr::Call { callee, args, .. } => {
+            lint_expr(callee, out);
+            for a in args {
+                match a {
+                    tishlang_ast::CallArg::Expr(x) => lint_expr(x, out),
+                    tishlang_ast::CallArg::Spread(x) => lint_expr(x, out),
+                }
+            }
+        }
+        Expr::New { callee, args, .. } => {
+            lint_expr(callee, out);
+            for a in args {
+                match a {
+                    tishlang_ast::CallArg::Expr(x) => lint_expr(x, out),
+                    tishlang_ast::CallArg::Spread(x) => lint_expr(x, out),
+                }
+            }
+        }
+        Expr::Member { object, .. } => {
+            lint_expr(object, out);
+        }
+        Expr::Index { object, index, .. } => {
+            lint_expr(object, out);
+            lint_expr(index, out);
+        }
+        Expr::Conditional {
+            cond,
+            then_branch,
+            else_branch,
+            ..
+        } => {
+            lint_expr(cond, out);
+            lint_expr(then_branch, out);
+            lint_expr(else_branch, out);
+        }
+        Expr::NullishCoalesce { left, right, .. } => {
+            lint_expr(left, out);
+            lint_expr(right, out);
+        }
+        Expr::Array { elements, .. } => {
+            for el in elements {
+                match el {
+                    tishlang_ast::ArrayElement::Expr(x) => lint_expr(x, out),
+                    tishlang_ast::ArrayElement::Spread(x) => lint_expr(x, out),
+                }
+            }
+        }
+        Expr::Assign { value, .. }
+        | Expr::CompoundAssign { value, .. }
+        | Expr::LogicalAssign { value, .. } => lint_expr(value, out),
+        Expr::MemberAssign { object, value, .. } => {
+            lint_expr(object, out);
+            lint_expr(value, out);
+        }
+        Expr::IndexAssign {
+            object,
+            index,
+            value,
+            ..
+        } => {
+            lint_expr(object, out);
+            lint_expr(index, out);
+            lint_expr(value, out);
+        }
+        Expr::ArrowFunction { body, .. } => match body {
+            tishlang_ast::ArrowBody::Expr(x) => lint_expr(x, out),
+            tishlang_ast::ArrowBody::Block(b) => lint_stmt(b, out),
+        },
+        Expr::TemplateLiteral { exprs, .. } => {
+            for x in exprs {
+                lint_expr(x, out);
+            }
+        }
+        Expr::Await { operand, .. } => lint_expr(operand, out),
+        Expr::TypeOf { operand, .. } => lint_expr(operand, out),
+        Expr::JsxElement {
+            props, children, ..
+        } => {
+            for pr in props {
+                match pr {
+                    tishlang_ast::JsxProp::Attr { value, .. } => {
+                        if let tishlang_ast::JsxAttrValue::Expr(x) = value {
+                            lint_expr(x, out);
+                        }
+                    }
+                    tishlang_ast::JsxProp::Spread(x) => lint_expr(x, out),
+                }
+            }
+            for ch in children {
+                if let tishlang_ast::JsxChild::Expr(x) = ch {
+                    lint_expr(x, out);
+                }
+            }
+        }
+        Expr::JsxFragment { children, .. } => {
+            for ch in children {
+                if let tishlang_ast::JsxChild::Expr(x) = ch {
+                    lint_expr(x, out);
+                }
+            }
+        }
+        _ => {}
+    }
+}
+
+/// Human-readable catalog for documentation.
+pub const RULES: &[(&str, &str)] = &[
+    (
+        "tish-empty-catch",
+        "Warns on catch blocks with no statements (likely mistake).",
+    ),
+    (
+        "tish-duplicate-key",
+        "Warns when an object literal repeats the same key.",
+    ),
+];

package/crates/tish_llvm/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "tishlang_llvm"
+version = "0.1.0"
+edition = "2021"
+description = "LLVM backend for Tish (bytecode → native via clang/LLVM)"
+
+license-file = { workspace = true }
+repository = { workspace = true }
+[dependencies]
+tishlang_bytecode = { path = "../tish_bytecode", version = ">=0.1" }
+tishlang_compile = { path = "../tish_compile", version = ">=0.1" }
+tishlang_cranelift = { path = "../tish_cranelift", version = ">=0.1" }
+tishlang_build_utils = { path = "../tish_build_utils", version = ">=0.1" }