@tishlang/tish 1.9.1 → 1.10.0

package/crates/tish_lsp/src/main.rs

@@ -8,15 +8,15 @@ use regex::Regex;
 use tower_lsp::jsonrpc::Result;
 use tower_lsp::lsp_types::{
     CompletionItem, CompletionItemKind, CompletionParams, CompletionResponse,
-    CompletionTriggerKind, Diagnostic, DiagnosticSeverity, DiagnosticTag, DidChangeTextDocumentParams,
-    DidCloseTextDocumentParams, DidOpenTextDocumentParams, DocumentFormattingParams,
-    DocumentSymbolParams, DocumentSymbolResponse, GotoDefinitionParams, GotoDefinitionResponse,
-    Hover, HoverContents, HoverParams, HoverProviderCapability, InitializeParams, InitializeResult,
-    Location, MarkupContent, MarkupKind, MessageType, NumberOrString, OneOf, Position, Range,
-    ReferenceParams, RenameOptions, RenameParams, ServerCapabilities, ServerInfo,
-    WorkDoneProgressOptions,
-    SymbolInformation, SymbolKind, TextDocumentPositionParams, TextDocumentSyncCapability,
-    TextDocumentSyncKind, Url, WorkspaceEdit, WorkspaceSymbolParams,
+    CompletionTriggerKind, Diagnostic, DiagnosticSeverity, DiagnosticTag,
+    DidChangeTextDocumentParams, DidCloseTextDocumentParams, DidOpenTextDocumentParams,
+    DocumentFormattingParams, DocumentSymbol, DocumentSymbolParams, DocumentSymbolResponse,
+    GotoDefinitionParams, GotoDefinitionResponse, Hover, HoverContents, HoverParams,
+    HoverProviderCapability, InitializeParams, InitializeResult, Location, MarkupContent,
+    MarkupKind, MessageType, NumberOrString, OneOf, Position, Range, ReferenceParams,
+    RenameOptions, RenameParams, ServerCapabilities, ServerInfo, SymbolInformation, SymbolKind,
+    SymbolTag, TextDocumentPositionParams, TextDocumentSyncCapability, TextDocumentSyncKind, Url,
+    WorkDoneProgressOptions, WorkspaceEdit, WorkspaceSymbolParams,
 };
 use tower_lsp::lsp_types::{PrepareRenameResponse, TextEdit};
 use tower_lsp::{Client, LanguageServer, LspService, Server};
@@ -78,6 +78,49 @@ fn diag_range(line: u32, col: u32, text: &str) -> Range {
     }
 }
 
+/// `lsp-types` still requires the `deprecated` field on these structs, but marks it
+/// `#[deprecated(note = "Use tags instead")]`. Use `tags` with [`SymbolTag::Deprecated`] when a
+/// symbol is actually deprecated; this helper keeps a single `#[allow(deprecated)]` boundary.
+#[allow(deprecated)]
+fn symbol_information(
+    name: String,
+    kind: SymbolKind,
+    tags: Option<Vec<SymbolTag>>,
+    location: Location,
+    container_name: Option<String>,
+) -> SymbolInformation {
+    SymbolInformation {
+        name,
+        kind,
+        tags,
+        deprecated: None,
+        location,
+        container_name,
+    }
+}
+
+#[allow(deprecated)]
+fn document_symbol(
+    name: String,
+    detail: Option<String>,
+    kind: SymbolKind,
+    tags: Option<Vec<SymbolTag>>,
+    range: Range,
+    selection_range: Range,
+    children: Option<Vec<DocumentSymbol>>,
+) -> DocumentSymbol {
+    DocumentSymbol {
+        name,
+        detail,
+        kind,
+        tags,
+        deprecated: None,
+        range,
+        selection_range,
+        children,
+    }
+}
+
 fn publish_parse_and_lint(client: &Client, uri: Url, text: &str) {
     let mut diags = Vec::new();
     match tishlang_parser::parse(text) {
@@ -115,10 +158,7 @@ fn publish_parse_and_lint(client: &Client, uri: Url, text: &str) {
                         "tish-unused-parameter",
                     ),
                     tishlang_resolve::UnusedBindingKind::Variable => (
-                        format!(
-                            "`{}` is declared but its value is never read",
-                            ub.name
-                        ),
+                        format!("`{}` is declared but its value is never read", ub.name),
                         "tish-unused-variable",
                     ),
                 };
@@ -317,7 +357,7 @@ impl LanguageServer for Backend {
             return Ok(None);
         };
 
-        let mut syms: Vec<tower_lsp::lsp_types::DocumentSymbol> = Vec::new();
+        let mut syms: Vec<DocumentSymbol> = Vec::new();
         for s in &program.statements {
             doc_symbol_stmt(s, &text, &mut syms);
         }
@@ -432,7 +472,9 @@ impl LanguageServer for Backend {
             }
             None => {
                 if tishlang_resolve::is_runtime_global_ident(use_site.name.as_ref()) {
-                    md.push_str("\n\n_Interpreter root global (no lexical declaration in this file)._");
+                    md.push_str(
+                        "\n\n_Interpreter root global (no lexical declaration in this file)._",
+                    );
                     let word = word_at_position(&text, pos);
                     if !word.is_empty() {
                         if let Some(root) = self.tishlang_source_root.read().unwrap().clone() {
@@ -583,12 +625,8 @@ impl LanguageServer for Backend {
         else {
             return Ok(None);
         };
-        let spans = tishlang_resolve::reference_spans_for_def(
-            &program,
-            &text,
-            nu.name.as_ref(),
-            def,
-        );
+        let spans =
+            tishlang_resolve::reference_spans_for_def(&program, &text, nu.name.as_ref(), def);
         let mut edits: Vec<TextEdit> = spans
             .into_iter()
             .map(|sp| TextEdit {
@@ -598,10 +636,8 @@ impl LanguageServer for Backend {
             .collect();
         // Apply from end of document so earlier ranges stay valid when lengths change.
         edits.sort_by(|a, b| {
-            (b.range.start.line, b.range.start.character).cmp(&(
-                a.range.start.line,
-                a.range.start.character,
-            ))
+            (b.range.start.line, b.range.start.character)
+                .cmp(&(a.range.start.line, a.range.start.character))
         });
         let mut m = HashMap::new();
         m.insert(uri, edits);
@@ -689,41 +725,35 @@ fn collect_workspace_syms(
 ) {
     match s {
         tishlang_ast::Statement::FunDecl {
-            name,
-            name_span,
-            ..
+            name, name_span, ..
         } => {
             if name.to_lowercase().contains(query) {
-                out.push(SymbolInformation {
-                    name: name.to_string(),
-                    kind: SymbolKind::FUNCTION,
-                    tags: None,
-                    deprecated: None,
-                    location: Location {
+                out.push(symbol_information(
+                    name.to_string(),
+                    SymbolKind::FUNCTION,
+                    None,
+                    Location {
                         uri: uri.clone(),
                         range: span_to_range(name_span, text),
                     },
-                    container_name: None,
-                });
+                    None,
+                ));
             }
         }
         tishlang_ast::Statement::VarDecl {
-            name,
-            name_span,
-            ..
+            name, name_span, ..
         } => {
             if name.to_lowercase().contains(query) {
-                out.push(SymbolInformation {
-                    name: name.to_string(),
-                    kind: SymbolKind::VARIABLE,
-                    tags: None,
-                    deprecated: None,
-                    location: Location {
+                out.push(symbol_information(
+                    name.to_string(),
+                    SymbolKind::VARIABLE,
+                    None,
+                    Location {
                         uri: uri.clone(),
                         range: span_to_range(name_span, text),
                     },
-                    container_name: None,
-                });
+                    None,
+                ));
             }
         }
         tishlang_ast::Statement::Block { statements, .. } => {
@@ -744,9 +774,7 @@ pub(crate) fn find_export(
     for s in &program.statements {
         match s {
             tishlang_ast::Statement::FunDecl {
-                name: n,
-                name_span,
-                ..
+                name: n, name_span, ..
             } if n.as_ref() == name => {
                 return Some(Location {
                     uri: uri.clone(),
@@ -754,9 +782,7 @@ pub(crate) fn find_export(
                 });
             }
             tishlang_ast::Statement::VarDecl {
-                name: n,
-                name_span,
-                ..
+                name: n, name_span, ..
             } if n.as_ref() == name => {
                 return Some(Location {
                     uri: uri.clone(),
@@ -785,17 +811,13 @@ fn find_decl_in_stmt(
 ) -> Option<Location> {
     match s {
         tishlang_ast::Statement::FunDecl {
-            name,
-            name_span,
-            ..
+            name, name_span, ..
         } if name.as_ref() == word => Some(Location {
             uri: uri.clone(),
             range: span_to_range(name_span, text),
         }),
         tishlang_ast::Statement::VarDecl {
-            name,
-            name_span,
-            ..
+            name, name_span, ..
         } if name.as_ref() == word => Some(Location {
             uri: uri.clone(),
             range: span_to_range(name_span, text),
@@ -915,15 +937,26 @@ fn value_completion_kind_stmt(
             finally_body,
             ..
         } => value_completion_kind_stmt(body, name)
-            .or_else(|| catch_body.as_ref().and_then(|b| value_completion_kind_stmt(b, name)))
-            .or_else(|| finally_body.as_ref().and_then(|b| value_completion_kind_stmt(b, name))),
+            .or_else(|| {
+                catch_body
+                    .as_ref()
+                    .and_then(|b| value_completion_kind_stmt(b, name))
+            })
+            .or_else(|| {
+                finally_body
+                    .as_ref()
+                    .and_then(|b| value_completion_kind_stmt(b, name))
+            }),
         tishlang_ast::Statement::Switch {
             cases,
             default_body,
             ..
         } => {
             for (_e, stmts) in cases {
-                if let Some(k) = stmts.iter().find_map(|st| value_completion_kind_stmt(st, name)) {
+                if let Some(k) = stmts
+                    .iter()
+                    .find_map(|st| value_completion_kind_stmt(st, name))
+                {
                     return Some(k);
                 }
             }
@@ -934,7 +967,9 @@ fn value_completion_kind_stmt(
             })
         }
         tishlang_ast::Statement::Export { declaration, .. } => match declaration.as_ref() {
-            tishlang_ast::ExportDeclaration::Named(inner) => value_completion_kind_stmt(inner, name),
+            tishlang_ast::ExportDeclaration::Named(inner) => {
+                value_completion_kind_stmt(inner, name)
+            }
             tishlang_ast::ExportDeclaration::Default(_) => None,
         },
         _ => None,
@@ -944,7 +979,7 @@ fn value_completion_kind_stmt(
 fn doc_symbol_stmt(
     s: &tishlang_ast::Statement,
     text: &str,
-    out: &mut Vec<tower_lsp::lsp_types::DocumentSymbol>,
+    out: &mut Vec<DocumentSymbol>,
 ) {
     match s {
         tishlang_ast::Statement::FunDecl {
@@ -956,20 +991,19 @@ fn doc_symbol_stmt(
         } => {
             let mut children = Vec::new();
             collect_child_syms(body, text, &mut children);
-            out.push(tower_lsp::lsp_types::DocumentSymbol {
-                name: name.to_string(),
-                detail: None,
-                kind: tower_lsp::lsp_types::SymbolKind::FUNCTION,
-                tags: None,
-                deprecated: None,
-                range: span_to_range(span, text),
-                selection_range: span_to_range(name_span, text),
-                children: if children.is_empty() {
+            out.push(document_symbol(
+                name.to_string(),
+                None,
+                SymbolKind::FUNCTION,
+                None,
+                span_to_range(span, text),
+                span_to_range(name_span, text),
+                if children.is_empty() {
                     None
                 } else {
                     Some(children)
                 },
-            });
+            ));
         }
         tishlang_ast::Statement::VarDecl {
             name,
@@ -977,16 +1011,15 @@ fn doc_symbol_stmt(
             span,
             ..
         } => {
-            out.push(tower_lsp::lsp_types::DocumentSymbol {
-                name: name.to_string(),
-                detail: None,
-                kind: tower_lsp::lsp_types::SymbolKind::VARIABLE,
-                tags: None,
-                deprecated: None,
-                range: span_to_range(span, text),
-                selection_range: span_to_range(name_span, text),
-                children: None,
-            });
+            out.push(document_symbol(
+                name.to_string(),
+                None,
+                SymbolKind::VARIABLE,
+                None,
+                span_to_range(span, text),
+                span_to_range(name_span, text),
+                None,
+            ));
         }
         tishlang_ast::Statement::Block { statements, .. } => {
             for x in statements {
@@ -1000,7 +1033,7 @@ fn doc_symbol_stmt(
 fn collect_child_syms(
     s: &tishlang_ast::Statement,
     text: &str,
-    out: &mut Vec<tower_lsp::lsp_types::DocumentSymbol>,
+    out: &mut Vec<DocumentSymbol>,
 ) {
     match s {
         tishlang_ast::Statement::Block { statements, .. } => {

package/crates/tish_native/src/build.rs

@@ -6,8 +6,15 @@ use std::path::Path;
 use tishlang_compile::ResolvedNativeModule;
 
 /// `tishlang_runtime` Cargo feature names (subset of CLI / compile feature names).
-const RUNTIME_CARGO_FEATURES: &[&str] =
-    &["http", "http-hyper", "http-io-uring", "fs", "process", "regex", "ws"];
+const RUNTIME_CARGO_FEATURES: &[&str] = &[
+    "http",
+    "http-hyper",
+    "http-io-uring",
+    "fs",
+    "process",
+    "regex",
+    "ws",
+];
 
 /// Map CLI/compile features to flags passed to `tishlang_runtime` in the temp crate's Cargo.toml.
 /// `full` enables every optional runtime capability (matches `tish build --feature full` / LANGUAGE.md).
@@ -29,6 +36,29 @@ fn runtime_features_for_cargo(features: &[String]) -> Vec<String> {
     out
 }
 
+/// `[profile.release]` for nested `cargo build` of generated crates.
+fn nested_release_profile_toml() -> &'static str {
+    if std::env::var("TISH_FAST_NATIVE_BUILD").as_deref() == Ok("1") {
+        r#"[profile.release]
+opt-level = 1
+lto = false
+codegen-units = 16
+incremental = true
+strip = false
+debug = 0
+panic = "abort"
+"#
+    } else {
+        r#"[profile.release]
+# Reduce binary size: strip symbols, abort on panic (no unwinding), single codegen unit
+strip = true
+panic = "abort"
+codegen-units = 1
+lto = "fat"
+"#
+    }
+}
+
 /// Inject `mod generated_native;` after the crate attribute so the binary crate can call `crate::generated_native::…`.
 fn inject_generated_native_mod(rust_code: &str) -> String {
     if let Some(pos) = rust_code.find("\n\n") {
@@ -108,6 +138,7 @@ pub fn build_via_cargo(
         String::new()
     };
 
+    let profile = nested_release_profile_toml();
     let cargo_toml = format!(
         r#"[package]
 name = "tish_output"
@@ -118,17 +149,12 @@ edition = "2021"
 name = "{}"
 path = "src/main.rs"
 
-[profile.release]
-# Reduce binary size: strip symbols, abort on panic (no unwinding), single codegen unit
-strip = true
-panic = "abort"
-codegen-units = 1
-lto = "fat"
+{}
 
 [dependencies]
 tishlang_runtime = {{ path = {:?}{} }}
 {}{}"#,
-        out_name, runtime_path, features_str, more_deps, ui_dep
+        out_name, profile, runtime_path, features_str, more_deps, ui_dep
     );
 
     fs::write(build_dir.join("Cargo.toml"), cargo_toml)
@@ -159,6 +185,155 @@ tishlang_runtime = {{ path = {:?}{} }}
     Ok(())
 }
 
+/// Build several native binaries in **one** nested Cargo project (shared `tishlang_runtime` compile).
+///
+/// `bins` order must match `outputs`: each `(stem, rust_code, generated_native_rs)` pairs with
+/// `outputs[i].0` (entry path — used only for validation) and `outputs[i].1` (final binary path).
+pub(crate) fn build_many_via_cargo(
+    bins: Vec<(String, String, Option<String>)>,
+    native_modules: Vec<ResolvedNativeModule>,
+    features: &[String],
+    extra_dependencies_toml: &str,
+    needs_tokio: bool,
+    needs_ui: bool,
+    outputs: &[(&Path, &Path)],
+    project_root: Option<&Path>,
+) -> Result<(), String> {
+    if bins.len() != outputs.len() {
+        return Err(format!(
+            "build_many_via_cargo: bins ({}) != outputs ({})",
+            bins.len(),
+            outputs.len()
+        ));
+    }
+    for (i, (stem, _, _)) in bins.iter().enumerate() {
+        let entry = outputs[i].0;
+        let expect = entry.file_stem().and_then(|s| s.to_str()).unwrap_or("");
+        if expect != stem {
+            return Err(format!(
+                "build_many_via_cargo: stem mismatch at {}: {} vs {}",
+                i, stem, expect
+            ));
+        }
+    }
+
+    let batch_id = format!("many_{}", std::process::id());
+    let build_dir = tishlang_build_utils::create_build_dir("tish_build_many", &batch_id)?;
+
+    let runtime_path = tishlang_build_utils::find_runtime_path_for_project(project_root)?;
+
+    let runtime_features = runtime_features_for_cargo(features);
+    let runtime_refs: Vec<&str> = runtime_features.iter().map(String::as_str).collect();
+    let features_str = if runtime_refs.is_empty() {
+        String::new()
+    } else {
+        format!(", features = {:?}", runtime_refs)
+    };
+
+    let tokio_dep = if needs_tokio {
+        "\ntokio = { version = \"1\", features = [\"rt-multi-thread\", \"macros\"] }\n"
+    } else {
+        ""
+    };
+
+    let native_deps: String = native_modules
+        .iter()
+        .filter(|m| m.use_path_dependency)
+        .map(|m| {
+            let path = m.crate_path.display().to_string().replace('\\', "/");
+            format!("{} = {{ path = {:?} }}\n", m.package_name, path)
+        })
+        .collect();
+
+    let mut more_deps = String::new();
+    more_deps.push_str(tokio_dep);
+    if !native_deps.is_empty() {
+        more_deps.push_str(&format!("\n{}", native_deps));
+    }
+    if !extra_dependencies_toml.trim().is_empty() {
+        more_deps.push_str(&format!("\n{}", extra_dependencies_toml));
+    }
+
+    let tish_ui_path = std::path::Path::new(&runtime_path)
+        .parent()
+        .ok_or_else(|| "invalid tishlang_runtime path (no parent)".to_string())?
+        .join("tish_ui");
+    let ui_dep = if needs_ui {
+        format!(
+            "\ntishlang_ui = {{ path = {:?}, default-features = false, features = [\"runtime\"] }}\n",
+            tish_ui_path.display().to_string().replace('\\', "/")
+        )
+    } else {
+        String::new()
+    };
+
+    let mut bin_tables = String::new();
+    for (stem, rust_code, generated_native_rs) in &bins {
+        let bin_dir = build_dir.join("src/bin").join(stem);
+        fs::create_dir_all(&bin_dir).map_err(|e| format!("create bin dir: {}", e))?;
+
+        let rust_main = if generated_native_rs.is_some() {
+            inject_generated_native_mod(rust_code)
+        } else {
+            rust_code.clone()
+        };
+
+        fs::write(bin_dir.join("main.rs"), rust_main)
+            .map_err(|e| format!("write main.rs for {}: {}", stem, e))?;
+        if let Some(gen) = generated_native_rs {
+            fs::write(bin_dir.join("generated_native.rs"), gen)
+                .map_err(|e| format!("write generated_native.rs for {}: {}", stem, e))?;
+        }
+
+        bin_tables.push_str(&format!(
+            r#"[[bin]]
+name = "{stem}"
+path = "src/bin/{stem}/main.rs"
+
+"#
+        ));
+    }
+
+    let profile = nested_release_profile_toml();
+    let cargo_toml = format!(
+        r#"[package]
+name = "tish_output_many"
+version = "0.1.0"
+edition = "2021"
+
+{}{}
+[dependencies]
+tishlang_runtime = {{ path = {:?}{} }}
+{}{}"#,
+        bin_tables, profile, runtime_path, features_str, more_deps, ui_dep
+    );
+
+    fs::write(build_dir.join("Cargo.toml"), cargo_toml)
+        .map_err(|e| format!("Cannot write Cargo.toml: {}", e))?;
+
+    let workspace_target = Path::new(&runtime_path)
+        .parent()
+        .and_then(|p| p.parent())
+        .map(|ws| ws.join("target"));
+    let target_dir = workspace_target.filter(|p| p.exists());
+    let binary_dir = target_dir
+        .as_ref()
+        .map(|t| t.join("release"))
+        .unwrap_or_else(|| build_dir.join("target").join("release"));
+
+    tishlang_build_utils::run_cargo_build(&build_dir, target_dir.as_deref())?;
+
+    for i in 0..bins.len() {
+        let stem = bins[i].0.as_str();
+        let output_path = outputs[i].1;
+        let binary = tishlang_build_utils::find_release_binary(binary_dir.as_path(), stem)?;
+        let target = tishlang_build_utils::resolve_output_path(output_path, stem);
+        tishlang_build_utils::copy_binary_to_output(&binary, &target)?;
+    }
+
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use super::runtime_features_for_cargo;
@@ -176,6 +351,8 @@ mod tests {
     #[test]
     fn runtime_features_merges_full_and_specific() {
         let f = runtime_features_for_cargo(&["full".to_string(), "http".to_string()]);
-        assert_eq!(f.len(), 5);
+        // `full` expands to every RUNTIME_CARGO_FEATURES entry; redundant `http` must not duplicate.
+        assert_eq!(f.len(), super::RUNTIME_CARGO_FEATURES.len());
+        assert_eq!(f.iter().filter(|x| *x == "http").count(), 1);
     }
 }