@tishlang/tish 1.6.0 → 1.8.0

package/crates/tish_lexer/src/lib.rs

@@ -5,7 +5,7 @@
 
 mod token;
 
-pub use token::{Token, TokenKind, Span};
+pub use token::{Span, Token, TokenKind};
 
 use std::collections::VecDeque;
 use std::iter::Peekable;
@@ -74,14 +74,21 @@ impl<'a> Lexer<'a> {
         loop {
             match self.peek() {
                 None | Some('{') | Some('<') => break,
-                Some(c) => { self.advance(); s.push(c); }
+                Some(c) => {
+                    self.advance();
+                    s.push(c);
+                }
             }
         }
         if s.is_empty() {
             Ok(None)
         } else {
             let end = self.span_start();
-            Ok(Some(Token { kind: TokenKind::JsxText, span: Span { start, end }, literal: Some(s.into()) }))
+            Ok(Some(Token {
+                kind: TokenKind::JsxText,
+                span: Span { start, end },
+                literal: Some(s.into()),
+            }))
         }
     }
 
@@ -139,7 +146,9 @@ impl<'a> Lexer<'a> {
 
     fn skip_line_comment(&mut self) {
         while let Some(c) = self.advance() {
-            if c == '\n' { break; }
+            if c == '\n' {
+                break;
+            }
         }
     }
 
@@ -147,8 +156,14 @@ impl<'a> Lexer<'a> {
         let mut depth = 1;
         while depth > 0 {
             match self.advance() {
-                Some('*') if self.peek() == Some('/') => { self.advance(); depth -= 1; }
-                Some('/') if self.peek() == Some('*') => { self.advance(); depth += 1; }
+                Some('*') if self.peek() == Some('/') => {
+                    self.advance();
+                    depth -= 1;
+                }
+                Some('/') if self.peek() == Some('*') => {
+                    self.advance();
+                    depth += 1;
+                }
                 None => return Err("Unterminated block comment".to_string()),
                 _ => {}
             }
@@ -186,7 +201,11 @@ impl<'a> Lexer<'a> {
 
     fn read_string(&mut self, quote: char) -> Result<String, String> {
         let mut s = String::with_capacity(32);
-        let extra = if quote == '"' { &['"', '\''][..] } else { &['\'', '"'][..] };
+        let extra = if quote == '"' {
+            &['"', '\''][..]
+        } else {
+            &['\'', '"'][..]
+        };
         loop {
             match self.advance() {
                 None => return Err("Unterminated string".to_string()),
@@ -213,24 +232,44 @@ impl<'a> Lexer<'a> {
     }
 
     /// Read a template literal. If `is_continuation` is true, we're continuing after a `}`.
-    fn read_template(&mut self, start: (usize, usize), is_continuation: bool) -> Result<Option<Token>, String> {
+    fn read_template(
+        &mut self,
+        start: (usize, usize),
+        is_continuation: bool,
+    ) -> Result<Option<Token>, String> {
         let mut s = String::with_capacity(if is_continuation { 32 } else { 64 });
         let extra = &['`', '$', '{'][..];
-        
+
         loop {
             match self.advance() {
                 None => return Err("Unterminated template literal".to_string()),
                 Some('`') => {
                     let end = self.span_start();
-                    let kind = if is_continuation { TokenKind::TemplateTail } else { TokenKind::TemplateNoSub };
-                    return Ok(Some(Token { kind, span: Span { start, end }, literal: Some(s.into()) }));
+                    let kind = if is_continuation {
+                        TokenKind::TemplateTail
+                    } else {
+                        TokenKind::TemplateNoSub
+                    };
+                    return Ok(Some(Token {
+                        kind,
+                        span: Span { start, end },
+                        literal: Some(s.into()),
+                    }));
                 }
                 Some('$') if self.peek() == Some('{') => {
                     self.advance();
                     self.template_brace_stack.push(1);
                     let end = self.span_start();
-                    let kind = if is_continuation { TokenKind::TemplateMiddle } else { TokenKind::TemplateHead };
-                    return Ok(Some(Token { kind, span: Span { start, end }, literal: Some(s.into()) }));
+                    let kind = if is_continuation {
+                        TokenKind::TemplateMiddle
+                    } else {
+                        TokenKind::TemplateHead
+                    };
+                    return Ok(Some(Token {
+                        kind,
+                        span: Span { start, end },
+                        literal: Some(s.into()),
+                    }));
                 }
                 Some('\\') => s.push(self.handle_escape(extra)?),
                 Some(c) => s.push(c),
@@ -308,7 +347,10 @@ impl<'a> Lexer<'a> {
                     self.indent_stack.pop();
                     return Ok(Some(Token {
                         kind: TokenKind::Dedent,
-                        span: Span { start: (self.line, self.col), end: (self.line, self.col) },
+                        span: Span {
+                            start: (self.line, self.col),
+                            end: (self.line, self.col),
+                        },
                         literal: None,
                     }));
                 }
@@ -362,31 +404,66 @@ impl<'a> Lexer<'a> {
             ';' => TokenKind::Semicolon,
             ',' => TokenKind::Comma,
             '.' => {
-                if self.peek() == Some('?') { self.advance(); TokenKind::OptionalChain }
-                else if self.peek() == Some('.') {
+                if self.peek() == Some('?') {
+                    self.advance();
+                    TokenKind::OptionalChain
+                } else if self.peek() == Some('.') {
                     self.advance();
-                    if self.peek() == Some('.') { self.advance(); TokenKind::Spread }
-                    else { return Err("Unexpected .. (use ... for rest params)".to_string()); }
-                } else { TokenKind::Dot }
+                    if self.peek() == Some('.') {
+                        self.advance();
+                        TokenKind::Spread
+                    } else {
+                        return Err("Unexpected .. (use ... for rest params)".to_string());
+                    }
+                } else {
+                    TokenKind::Dot
+                }
             }
             '=' => {
                 if self.peek() == Some('=') {
                     self.advance();
-                    if self.peek() == Some('=') { self.advance(); TokenKind::StrictEq } else { TokenKind::Eq }
-                } else if self.peek() == Some('>') { self.advance(); TokenKind::Arrow }
-                else { TokenKind::Assign }
+                    if self.peek() == Some('=') {
+                        self.advance();
+                        TokenKind::StrictEq
+                    } else {
+                        TokenKind::Eq
+                    }
+                } else if self.peek() == Some('>') {
+                    self.advance();
+                    TokenKind::Arrow
+                } else {
+                    TokenKind::Assign
+                }
             }
             '!' => {
                 if self.peek() == Some('=') {
                     self.advance();
-                    if self.peek() == Some('=') { self.advance(); TokenKind::StrictNe } else { TokenKind::Ne }
-                } else { TokenKind::Not }
+                    if self.peek() == Some('=') {
+                        self.advance();
+                        TokenKind::StrictNe
+                    } else {
+                        TokenKind::Ne
+                    }
+                } else {
+                    TokenKind::Not
+                }
             }
             '<' => {
-                if self.peek() == Some('=') { self.advance(); TokenKind::Le }
-                else if self.peek() == Some('<') { self.advance(); TokenKind::Shl }
-                else if self.peek() == Some('/') { self.jsx_in_closing_tag = true; TokenKind::Lt }
-                else if self.peek() == Some('>') || self.peek().map(|c| c.is_ascii_alphabetic() || c == '_').unwrap_or(false) {
+                if self.peek() == Some('=') {
+                    self.advance();
+                    TokenKind::Le
+                } else if self.peek() == Some('<') {
+                    self.advance();
+                    TokenKind::Shl
+                } else if self.peek() == Some('/') {
+                    self.jsx_in_closing_tag = true;
+                    TokenKind::Lt
+                } else if self.peek() == Some('>')
+                    || self
+                        .peek()
+                        .map(|c| c.is_ascii_alphabetic() || c == '_')
+                        .unwrap_or(false)
+                {
                     self.jsx_depth += 1;
                     self.jsx_stack.push(JsxEl {
                         in_opener: true,
@@ -394,12 +471,18 @@ impl<'a> Lexer<'a> {
                     });
                     self.jsx_in_opening_tag = true;
                     TokenKind::Lt
-                } else { TokenKind::Lt }
+                } else {
+                    TokenKind::Lt
+                }
             }
             '>' => {
-                if self.peek() == Some('=') { self.advance(); TokenKind::Ge }
-                else if self.peek() == Some('>') { self.advance(); TokenKind::Shr }
-                else {
+                if self.peek() == Some('=') {
+                    self.advance();
+                    TokenKind::Ge
+                } else if self.peek() == Some('>') {
+                    self.advance();
+                    TokenKind::Shr
+                } else {
                     if self.jsx_in_closing_tag {
                         self.jsx_depth = (self.jsx_depth - 1).max(0);
                         self.jsx_stack.pop();
@@ -425,66 +508,133 @@ impl<'a> Lexer<'a> {
             '^' => TokenKind::BitXor,
             '~' => TokenKind::BitNot,
             '+' => {
-                if self.peek() == Some('+') { self.advance(); TokenKind::PlusPlus }
-                else if self.peek() == Some('=') { self.advance(); TokenKind::PlusAssign }
-                else { TokenKind::Plus }
+                if self.peek() == Some('+') {
+                    self.advance();
+                    TokenKind::PlusPlus
+                } else if self.peek() == Some('=') {
+                    self.advance();
+                    TokenKind::PlusAssign
+                } else {
+                    TokenKind::Plus
+                }
             }
             '-' => {
-                if self.peek() == Some('-') { self.advance(); TokenKind::MinusMinus }
-                else if self.peek() == Some('=') { self.advance(); TokenKind::MinusAssign }
-                else { TokenKind::Minus }
+                if self.peek() == Some('-') {
+                    self.advance();
+                    TokenKind::MinusMinus
+                } else if self.peek() == Some('=') {
+                    self.advance();
+                    TokenKind::MinusAssign
+                } else {
+                    TokenKind::Minus
+                }
             }
             '*' => {
-                if self.peek() == Some('*') { self.advance(); TokenKind::StarStar }
-                else if self.peek() == Some('=') { self.advance(); TokenKind::StarAssign }
-                else { TokenKind::Star }
+                if self.peek() == Some('*') {
+                    self.advance();
+                    TokenKind::StarStar
+                } else if self.peek() == Some('=') {
+                    self.advance();
+                    TokenKind::StarAssign
+                } else {
+                    TokenKind::Star
+                }
             }
             '/' => {
-                if self.peek() == Some('/') { self.advance(); self.skip_line_comment(); return self.next_token(); }
-                else if self.peek() == Some('*') { self.advance(); self.skip_block_comment()?; return self.next_token(); }
-                else if self.peek() == Some('=') { self.advance(); TokenKind::SlashAssign }
-                else {
-                    if self.jsx_in_opening_tag { self.jsx_saw_slash_before_gt = true; }
+                if self.peek() == Some('/') {
+                    self.advance();
+                    self.skip_line_comment();
+                    // `skip_line_comment` consumes the newline via `advance()`, which sets
+                    // `at_line_start` before we would normally run `skip_whitespace()`. Without
+                    // stripping the next line's leading spaces here, `read_indent_level` would see
+                    // physical indentation and emit a spurious `Indent` (breaks e.g. object
+                    // literals with trailing `//` comments). Newlines handled in `skip_whitespace`
+                    // eat those spaces before the indent pass; match that behavior.
+                    self.skip_whitespace();
+                    return self.next_token();
+                } else if self.peek() == Some('*') {
+                    self.advance();
+                    self.skip_block_comment()?;
+                    return self.next_token();
+                } else if self.peek() == Some('=') {
+                    self.advance();
+                    TokenKind::SlashAssign
+                } else {
+                    if self.jsx_in_opening_tag {
+                        self.jsx_saw_slash_before_gt = true;
+                    }
                     TokenKind::Slash
                 }
             }
             '%' => {
-                if self.peek() == Some('=') { self.advance(); TokenKind::PercentAssign }
-                else { TokenKind::Percent }
+                if self.peek() == Some('=') {
+                    self.advance();
+                    TokenKind::PercentAssign
+                } else {
+                    TokenKind::Percent
+                }
             }
             '&' => {
                 if self.peek() == Some('&') {
                     self.advance();
-                    if self.peek() == Some('=') { self.advance(); TokenKind::AndAndAssign }
-                    else { TokenKind::And }
-                } else { TokenKind::BitAnd }
+                    if self.peek() == Some('=') {
+                        self.advance();
+                        TokenKind::AndAndAssign
+                    } else {
+                        TokenKind::And
+                    }
+                } else {
+                    TokenKind::BitAnd
+                }
             }
             '|' => {
                 if self.peek() == Some('|') {
                     self.advance();
-                    if self.peek() == Some('=') { self.advance(); TokenKind::OrOrAssign }
-                    else { TokenKind::Or }
-                } else { TokenKind::BitOr }
+                    if self.peek() == Some('=') {
+                        self.advance();
+                        TokenKind::OrOrAssign
+                    } else {
+                        TokenKind::Or
+                    }
+                } else {
+                    TokenKind::BitOr
+                }
             }
             '?' => {
                 if self.peek() == Some('?') {
                     self.advance();
-                    if self.peek() == Some('=') { self.advance(); TokenKind::NullishAssign }
-                    else { TokenKind::NullishCoalesce }
-                } else if self.peek() == Some('.') { self.advance(); TokenKind::OptionalChain }
-                else { TokenKind::Question }
+                    if self.peek() == Some('=') {
+                        self.advance();
+                        TokenKind::NullishAssign
+                    } else {
+                        TokenKind::NullishCoalesce
+                    }
+                } else if self.peek() == Some('.') {
+                    self.advance();
+                    TokenKind::OptionalChain
+                } else {
+                    TokenKind::Question
+                }
             }
             ':' => TokenKind::Colon,
             '"' | '\'' => {
                 let s = self.read_string(c)?;
                 let end = self.span_start();
-                return Ok(Some(Token { kind: TokenKind::String, span: Span { start, end }, literal: Some(s.into()) }));
+                return Ok(Some(Token {
+                    kind: TokenKind::String,
+                    span: Span { start, end },
+                    literal: Some(s.into()),
+                }));
             }
             '`' => return self.read_template(start, false),
             '0'..='9' => {
                 let num = self.read_number(c);
                 let end = self.span_start();
-                return Ok(Some(Token { kind: TokenKind::Number, span: Span { start, end }, literal: Some(num.into()) }));
+                return Ok(Some(Token {
+                    kind: TokenKind::Number,
+                    span: Span { start, end },
+                    literal: Some(num.into()),
+                }));
             }
             'a'..='z' | 'A'..='Z' | '_' => {
                 let ident = self.read_ident_or_keyword(c);
@@ -493,15 +643,23 @@ impl<'a> Lexer<'a> {
                 return Ok(Some(Token {
                     kind,
                     span: Span { start, end },
-                    literal: if matches!(kind, TokenKind::Ident) { Some(ident.into()) } else { None },
+                    // Spelling is useful for keywords too (e.g. object keys, type names like `type`).
+                    literal: Some(ident.into()),
                 }));
             }
-            '\n' => { self.at_line_start = true; return self.next_token(); }
+            '\n' => {
+                self.at_line_start = true;
+                return self.next_token();
+            }
             _ => return Err(format!("Unexpected character: {:?}", c)),
         };
 
         let end = self.span_start();
-        Ok(Some(Token { kind, span: Span { start, end }, literal: None }))
+        Ok(Some(Token {
+            kind,
+            span: Span { start, end },
+            literal: None,
+        }))
     }
 }
 
@@ -539,4 +697,15 @@ mod tests {
         let string_tok = tokens.iter().find(|t| t.kind == TokenKind::String).unwrap();
         assert_eq!(string_tok.literal.as_deref(), Some("H"));
     }
+
+    #[test]
+    fn line_comment_does_not_emit_spurious_indent_before_next_line() {
+        let with_comment = "fn f() {\n  return {\n    a: 1, // c\n    b: 2\n  }\n}\n";
+        let tokens: Vec<_> = Lexer::new(with_comment).collect::<Result<Vec<_>, _>>().unwrap();
+        assert!(
+            !tokens.iter().any(|t| t.kind == TokenKind::Indent),
+            "unexpected Indent after line comment: {:?}",
+            tokens.iter().map(|t| format!("{:?}", t.kind)).collect::<Vec<_>>()
+        );
+    }
 }

package/crates/tish_lexer/src/token.rs

@@ -57,6 +57,8 @@ pub enum TokenKind {
     New,
     Import,
     Export,
+    Type,
+    Declare,
 
     // Punctuation
     LParen,
@@ -110,14 +112,14 @@ pub enum TokenKind {
     NullishCoalesce,
     Question,
     Arrow,
-    
+
     // Template literal tokens
-    TemplateNoSub,   // `text` (no interpolation)
-    TemplateHead,    // `text${  (start with interpolation)
-    TemplateMiddle,  // }text${  (middle part)
-    TemplateTail,    // }text`   (end part)
+    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
+    JsxText, // Raw text in JSX children (emojis, etc.); only {}<> are special
 }
 
 impl TokenKind {
@@ -153,6 +155,8 @@ impl TokenKind {
             "new" => TokenKind::New,
             "import" => TokenKind::Import,
             "export" => TokenKind::Export,
+            "type" => TokenKind::Type,
+            "declare" => TokenKind::Declare,
             _ => TokenKind::Ident,
         }
     }

package/crates/tish_llvm/src/lib.rs

@@ -17,10 +17,17 @@ pub fn compile_to_native(
     project_root: Option<&Path>,
     output_path: &Path,
 ) -> Result<(), LlvmError> {
-    let modules = resolve_project(entry_path, project_root)
-        .map_err(|e| LlvmError { message: e.to_string() })?;
-    detect_cycles(&modules).map_err(|e| LlvmError { message: e.to_string() })?;
-    let program = merge_modules(modules).map_err(|e| LlvmError { message: e.to_string() })?;
+    let modules = resolve_project(entry_path, project_root).map_err(|e| LlvmError {
+        message: e.to_string(),
+    })?;
+    detect_cycles(&modules).map_err(|e| LlvmError {
+        message: e.to_string(),
+    })?;
+    let program = merge_modules(modules)
+        .map(|m| m.program)
+        .map_err(|e| LlvmError {
+        message: e.to_string(),
+    })?;
     let chunk = tishlang_bytecode::compile(&program).map_err(|e| LlvmError {
         message: e.to_string(),
     })?;
@@ -71,7 +78,10 @@ const uint64_t tish_chunk_len = sizeof(tish_chunk_data);
         .arg(&chunk_c_path)
         .status()
         .map_err(|e| LlvmError {
-            message: format!("Failed to run clang: {}. Install clang (LLVM) or set CLANG env var.", e),
+            message: format!(
+                "Failed to run clang: {}. Install clang (LLVM) or set CLANG env var.",
+                e
+            ),
         })?;
 
     if !status.success() {
@@ -84,9 +94,8 @@ const uint64_t tish_chunk_len = sizeof(tish_chunk_data);
     let object_path_canonical = object_path.canonicalize().map_err(|e| LlvmError {
         message: format!("Cannot canonicalize object path: {}", e),
     })?;
-    tishlang_cranelift::link_to_binary(&object_path_canonical, output_path, features).map_err(|e| LlvmError {
-        message: e.message,
-    })?;
+    tishlang_cranelift::link_to_binary(&object_path_canonical, output_path, features)
+        .map_err(|e| LlvmError { message: e.message })?;
 
     Ok(())
 }

package/crates/tish_lsp/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang_lsp"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 description = "Language Server Protocol implementation for Tish"
 license-file = { workspace = true }
@@ -12,9 +12,12 @@ path = "src/main.rs"
 
 [dependencies]
 tishlang_ast = { path = "../tish_ast", version = ">=0.1" }
+tishlang_cargo_bindgen = { path = "../tishlang_cargo_bindgen", version = ">=0.1" }
+tishlang_compile = { path = "../tish_compile", version = ">=0.1" }
 tishlang_parser = { path = "../tish_parser", version = ">=0.1" }
 tishlang_fmt = { path = "../tish_fmt", version = ">=0.1" }
 tishlang_lint = { path = "../tish_lint", version = ">=0.1" }
+tishlang_resolve = { path = "../tish_resolve", version = ">=0.1" }
 tower-lsp = "0.20"
 tokio = { version = "1", features = ["rt-multi-thread", "macros", "io-std"] }
 serde_json = "1"

package/crates/tish_lsp/README.md

@@ -14,7 +14,7 @@ Binary: `target/release/tish-lsp` (stdio LSP).
 
 - Parse diagnostics + lint warnings (via `tish_lint` **library** — use **`tish-lint`** CLI separately in CI)
 - Document symbols, completion, formatting (via `tish_fmt` **library** — use **`tish-fmt`** CLI separately in CI)
-- Go to definition (same file + relative imports)
+- Go to definition (same file, relative `./` / `../`, bare `node_modules` packages like Node, and native `tish:` / `@scope/pkg` / `cargo:` → Rust `pub fn` via `syn` + `cargo metadata` where configured)
 - Workspace symbol search (`**/*.tish`)
 
 ## Client configuration