@tishlang/tish-format 1.0.12 → 2.0.1

package/crates/tish_resolve/src/pos.rs

@@ -0,0 +1,141 @@
+//! Map LSP (UTF-16) positions to lexer [`Span`] corners (1-based line, 1-based **character** column).
+
+use tishlang_ast::Span;
+
+/// Byte offset in `source` for LSP `Position` (0-based line, UTF-16 code unit column).
+pub fn lsp_position_to_byte_offset(source: &str, line: u32, character: u32) -> Option<usize> {
+    let mut cur_line: u32 = 0;
+    let mut col_utf16: u32 = 0;
+    for (i, ch) in source.char_indices() {
+        if cur_line == line && col_utf16 == character {
+            return Some(i);
+        }
+        if ch == '\n' {
+            if cur_line == line {
+                return Some(i);
+            }
+            cur_line += 1;
+            col_utf16 = 0;
+        } else if cur_line == line {
+            col_utf16 = col_utf16.saturating_add(ch.len_utf16() as u32);
+        }
+    }
+    if cur_line == line && col_utf16 == character {
+        Some(source.len())
+    } else {
+        None
+    }
+}
+
+fn line_byte_start(source: &str, line1: usize) -> Option<usize> {
+    if line1 == 0 {
+        return None;
+    }
+    if line1 == 1 {
+        return Some(0);
+    }
+    let mut line = 1usize;
+    let mut offset = 0usize;
+    for ch in source.chars() {
+        offset += ch.len_utf8();
+        if ch == '\n' {
+            line += 1;
+            if line == line1 {
+                return Some(offset);
+            }
+        }
+    }
+    None
+}
+
+/// Byte offset for lexer (1-based line, 1-based char column) — first character of that cell.
+pub fn lex_corner_to_byte_offset(source: &str, line1: usize, col1: usize) -> Option<usize> {
+    let line_str = source.lines().nth(line1.checked_sub(1)?)?;
+    let base = line_byte_start(source, line1)?;
+    let mut pos = base;
+    let mut c = 1usize;
+    for ch in line_str.chars() {
+        if c == col1 {
+            return Some(pos);
+        }
+        c += 1;
+        pos += ch.len_utf8();
+    }
+    if c == col1 {
+        Some(pos)
+    } else {
+        None
+    }
+}
+
+/// Half-open byte range `[start, end)` for lexer span corners.
+pub fn lex_span_byte_range(source: &str, span: &Span) -> Option<(usize, usize)> {
+    let start = lex_corner_to_byte_offset(source, span.start.0, span.start.1)?;
+    let end = lex_corner_to_byte_offset(source, span.end.0, span.end.1).unwrap_or(start);
+    let end = end.max(start);
+    Some((start, end))
+}
+
+/// LSP `(line, character)` for the lexer corner `span.start` (first character of the span).
+pub fn lsp_position_for_span_start(source: &str, span: &Span) -> Option<(u32, u32)> {
+    let b = lex_corner_to_byte_offset(source, span.start.0, span.start.1)?;
+    byte_offset_to_lsp(source, b)
+}
+
+pub fn byte_offset_to_lsp(source: &str, byte: usize) -> Option<(u32, u32)> {
+    let mut line = 0u32;
+    let mut utf16 = 0u32;
+    for (i, ch) in source.char_indices() {
+        if i == byte {
+            return Some((line, utf16));
+        }
+        if ch == '\n' {
+            line += 1;
+            utf16 = 0;
+        } else {
+            utf16 += ch.len_utf16() as u32;
+        }
+    }
+    if byte == source.len() {
+        Some((line, utf16))
+    } else {
+        None
+    }
+}
+
+/// True if LSP position lies inside `span` (half-open in byte space).
+pub fn span_contains_lsp_position(
+    source: &str,
+    span: &Span,
+    lsp_line: u32,
+    lsp_character: u32,
+) -> bool {
+    let Some(b) = lsp_position_to_byte_offset(source, lsp_line, lsp_character) else {
+        return false;
+    };
+    let Some((lo, hi)) = lex_span_byte_range(source, span) else {
+        return false;
+    };
+    b >= lo && b < hi
+}
+
+/// LSP start (inclusive) and end (exclusive) positions for a lexer span.
+pub fn span_to_lsp_range_exclusive(source: &str, span: &Span) -> Option<((u32, u32), (u32, u32))> {
+    let (lo, hi) = lex_span_byte_range(source, span)?;
+    Some((
+        byte_offset_to_lsp(source, lo)?,
+        byte_offset_to_lsp(source, hi)?,
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn lsp_first_char() {
+        let s = "let x = 1\n";
+        assert_eq!(lsp_position_to_byte_offset(s, 0, 0), Some(0));
+        assert_eq!(lsp_position_to_byte_offset(s, 0, 4), Some(4));
+    }
+}

package/crates/tish_runtime/Cargo.toml

@@ -0,0 +1,100 @@
+[package]
+name = "tishlang_runtime"
+version = "0.1.0"
+edition = "2021"
+description = "Minimal runtime for Tish compiled output"
+
+license-file = { workspace = true }
+repository = { workspace = true }
+[features]
+default = []
+http = [
+    "dep:tokio",
+    "dep:reqwest",
+    "dep:futures",
+    "dep:bytes",
+    "dep:tiny_http",
+    "dep:socket2",
+    "dep:libc",
+    "dep:arc-swap",
+    "tishlang_core/regex",
+    # `serve(port, handler)` dispatches handler closures across worker
+    # threads (or subprocesses, in prefork mode). Both require `Value: Send`.
+    "tishlang_core/send-values",
+    "tishlang_builtins/send-values",
+    "send-values",
+]
+# Enables `Arc`/`Mutex` values in `tishlang_core` so `Value: Send + Sync`.
+# Used by `http` / `ws` and by dependents (e.g. `tish-callbacks`) that keep
+# `Value` in a `static` registry and dispatch from multi-threaded async libs.
+send-values = [
+    "tishlang_core/send-values",
+    "tishlang_builtins/send-values",
+]
+# Promise / `await` on settled values only (no `fetch` / HTTP stack). Used for WASI and other
+# targets where the full `http` feature does not compile.
+promise = ["send-values"]
+# Phase-3 item 13: io_uring-backed accept + send loop (Linux only).
+# Disabled by default; enable with `--feature http,http-io-uring` on Linux
+# to pick up the experimental accept path.
+http-io-uring = ["http"]
+# hyper-based HTTP backend: async single-threaded tokio runtime per core, no
+# per-connection OS threads. Unblocks the tiny_http thread-churn ceiling on
+# macOS loopback (~140k RPS) and enables HTTP/2. Opt-in via the
+# `TISH_HTTP_BACKEND=hyper` env var at runtime when the feature is compiled in.
+http-hyper = [
+    "http",
+    "dep:hyper",
+    "dep:hyper-util",
+    "dep:http-body-util",
+    "dep:http",
+    "dep:pin-project-lite",
+    "dep:core_affinity",
+    "tokio/net",
+    "tokio/rt",
+    "tokio/io-util",
+]
+fs = []
+process = []
+# Interactive terminal I/O (issue #101): raw mode, key/resize events, size, alt screen.
+tty = ["dep:crossterm"]
+regex = ["tishlang_core/regex"]
+# WebSocket (JS-like API). Modular: import { WebSocket, Server } from 'tish:ws'.
+# Requires `send-values` because the WS server keeps an `Arc<dyn Fn + Send +
+# Sync>`-typed listener closure that captures `VmRef`s; under `Rc<RefCell>`
+# those captures aren't `Send` and the closure won't satisfy `NativeFn`.
+ws = [
+    "dep:tokio",
+    "tokio/net",
+    "tokio/io-util",
+    "dep:tokio-tungstenite",
+    "dep:futures-util",
+    "dep:lazy_static",
+    "send-values",
+    "tishlang_core/send-values",
+    "tishlang_builtins/send-values",
+]
+
+[dependencies]
+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 }
+futures = { version = "0.3.32", optional = true }
+bytes = { version = "1", optional = true }
+tiny_http = { version = "0.12.0", optional = true }
+socket2 = { version = "0.5", features = ["all"], optional = true }
+libc = { version = "0.2", optional = true }
+arc-swap = { version = "1", optional = true }
+# Interactive terminal I/O (feature = tty): cross-platform raw mode, key/resize events, size.
+crossterm = { version = "0.28", optional = true }
+# hyper backend (feature = http-hyper)
+hyper = { version = "1", default-features = false, features = ["server", "http1", "http2"], optional = true }
+hyper-util = { version = "0.1", features = ["server", "tokio"], optional = true }
+http-body-util = { version = "0.1", optional = true }
+http = { version = "1", optional = true }
+pin-project-lite = { version = "0.2", optional = true }
+core_affinity = { version = "0.8", optional = true }
+tokio-tungstenite = { version = "0.29", optional = true }
+futures-util = { version = "0.3", optional = true }
+lazy_static = { version = "1", optional = true }