@tishlang/tish 2.2.0 → 2.2.4

package/crates/tish_lsp/src/main.rs

@@ -69,6 +69,16 @@ fn pos(line: u32, col: u32) -> Position {
     }
 }
 
+/// End position of a full-document range. Splits on '\n' (not `str::lines`, which drops a trailing
+/// newline) so the range reaches *past* the document's final newline; the last segment is counted in
+/// UTF-16 code units, as the LSP position encoding requires.
+fn full_doc_end(text: &str) -> (u32, u32) {
+    let line = text.matches('\n').count() as u32;
+    let last_seg = text.rsplit('\n').next().unwrap_or("");
+    let col = last_seg.encode_utf16().count() as u32;
+    (line, col)
+}
+
 fn diag_range(line: u32, col: u32, text: &str) -> Range {
     let line_str = text.lines().nth(line as usize).unwrap_or("");
     let end_char = line_str.len().max(col as usize + 1) as u32;
@@ -400,6 +410,24 @@ impl LanguageServer for Backend {
         if let Some(def) =
             tishlang_resolve::definition_span(&program, &text, position.line, position.character)
         {
+            // If the use resolves to an import specifier, jump THROUGH the import into the source
+            // module (a relative .tish file) instead of to the local import line. Falls back to the
+            // specifier span when the source module can't be located.
+            if is_import_specifier_span(&program, &def) {
+                if let Ok(ref file_path) = uri.to_file_path() {
+                    let word = word_at_position(&text, position);
+                    let roots = self.roots.read().unwrap().clone();
+                    if let Some(loc) = import_goto::definition_for_import(
+                        &program,
+                        file_path,
+                        word.as_str(),
+                        &roots,
+                        self.cargo_src_cache.as_ref(),
+                    ) {
+                        return Ok(Some(GotoDefinitionResponse::Scalar(loc)));
+                    }
+                }
+            }
             let range = span_to_range(&def, &text);
             return Ok(Some(GotoDefinitionResponse::Scalar(Location {
                 uri: uri.clone(),
@@ -608,8 +636,12 @@ impl LanguageServer for Backend {
         };
         let spans =
             tishlang_resolve::reference_spans_for_def(&program, &text, nu.name.as_ref(), def);
+        // Honor the client's includeDeclaration flag: reference_spans_for_def returns the definition
+        // span plus the use spans, so drop the definition when only uses were requested.
+        let include_decl = params.context.include_declaration;
         let locs: Vec<Location> = spans
             .into_iter()
+            .filter(|sp| include_decl || *sp != def)
             .map(|sp| Location {
                 uri: uri.clone(),
                 range: span_to_range(&sp, &text),
@@ -703,12 +735,14 @@ impl LanguageServer for Backend {
         };
         match tishlang_fmt::format_source(&text) {
             Ok(formatted) => {
-                let lines = text.lines().count() as u32;
-                let last_line = text.lines().last().map(|l| l.len() as u32).unwrap_or(0);
+                // Replace the WHOLE document. Using a range that stops before the document's final
+                // newline appends the formatter's own trailing newline on top of it, adding a blank
+                // line on every format (see full_doc_end).
+                let (end_line, end_char) = full_doc_end(&text);
                 Ok(Some(vec![tower_lsp::lsp_types::TextEdit {
                     range: Range {
                         start: pos(0, 0),
-                        end: pos(lines.saturating_sub(1), last_line),
+                        end: pos(end_line, end_char),
                     },
                     new_text: formatted,
                 }]))
@@ -798,7 +832,61 @@ fn collect_workspace_syms(
                 ));
             }
         }
-        tishlang_ast::Statement::Block { statements, .. } => {
+        tishlang_ast::Statement::TypeAlias {
+            name, name_span, ..
+        } => {
+            if name.to_lowercase().contains(query) {
+                out.push(symbol_information(
+                    name.to_string(),
+                    SymbolKind::INTERFACE,
+                    None,
+                    Location {
+                        uri: uri.clone(),
+                        range: span_to_range(name_span, text),
+                    },
+                    None,
+                ));
+            }
+        }
+        tishlang_ast::Statement::DeclareFun {
+            name, name_span, ..
+        } => {
+            if name.to_lowercase().contains(query) {
+                out.push(symbol_information(
+                    name.to_string(),
+                    SymbolKind::FUNCTION,
+                    None,
+                    Location {
+                        uri: uri.clone(),
+                        range: span_to_range(name_span, text),
+                    },
+                    None,
+                ));
+            }
+        }
+        tishlang_ast::Statement::DeclareVar {
+            name, name_span, ..
+        } => {
+            if name.to_lowercase().contains(query) {
+                out.push(symbol_information(
+                    name.to_string(),
+                    SymbolKind::VARIABLE,
+                    None,
+                    Location {
+                        uri: uri.clone(),
+                        range: span_to_range(name_span, text),
+                    },
+                    None,
+                ));
+            }
+        }
+        tishlang_ast::Statement::Export { declaration, .. } => {
+            if let tishlang_ast::ExportDeclaration::Named(inner) = declaration.as_ref() {
+                collect_workspace_syms(inner, text, uri, query, out);
+            }
+        }
+        tishlang_ast::Statement::Block { statements, .. }
+        | tishlang_ast::Statement::Multi { statements, .. } => {
             for x in statements {
                 collect_workspace_syms(x, text, uri, query, out);
             }
@@ -842,6 +930,28 @@ pub(crate) fn find_export(
     None
 }
 
+/// Locate the `export default …` statement in a module (the target of a default import).
+pub(crate) fn find_default_export(
+    program: &tishlang_ast::Program,
+    uri: &Url,
+    text: &str,
+) -> Option<Location> {
+    for s in &program.statements {
+        if let tishlang_ast::Statement::Export { declaration, span } = s {
+            if matches!(
+                declaration.as_ref(),
+                tishlang_ast::ExportDeclaration::Default(_)
+            ) {
+                return Some(Location {
+                    uri: uri.clone(),
+                    range: span_to_range(span, text),
+                });
+            }
+        }
+    }
+    None
+}
+
 fn find_decl_in_stmt(
     s: &tishlang_ast::Statement,
     word: &str,
@@ -893,6 +1003,31 @@ fn span_to_range(span: &tishlang_ast::Span, text: &str) -> Range {
     }
 }
 
+/// Whether `span` is the local-name span of an import specifier — i.e. `definition_span` resolved a
+/// use to an `import { … }` line. Go-to-definition should follow such a result through to the source
+/// module rather than jumping to the import line itself.
+fn is_import_specifier_span(program: &tishlang_ast::Program, span: &tishlang_ast::Span) -> bool {
+    use tishlang_ast::{ImportSpecifier, Statement};
+    program.statements.iter().any(|s| {
+        if let Statement::Import { specifiers, .. } = s {
+            specifiers.iter().any(|sp| {
+                let local = match sp {
+                    ImportSpecifier::Named {
+                        name_span,
+                        alias_span,
+                        ..
+                    } => alias_span.as_ref().unwrap_or(name_span),
+                    ImportSpecifier::Namespace { name_span, .. }
+                    | ImportSpecifier::Default { name_span, .. } => name_span,
+                };
+                local == span
+            })
+        } else {
+            false
+        }
+    })
+}
+
 fn word_at_position(text: &str, position: Position) -> String {
     let line = text.lines().nth(position.line as usize).unwrap_or("");
     let chars: Vec<(usize, char)> = line.char_indices().collect();
@@ -1296,7 +1431,64 @@ fn doc_symbol_stmt(
                 None,
             ));
         }
-        tishlang_ast::Statement::Block { statements, .. } => {
+        tishlang_ast::Statement::TypeAlias {
+            name,
+            name_span,
+            span,
+            ..
+        } => {
+            out.push(document_symbol(
+                name.to_string(),
+                None,
+                SymbolKind::INTERFACE,
+                None,
+                span_to_range(span, text),
+                span_to_range(name_span, text),
+                None,
+            ));
+        }
+        tishlang_ast::Statement::DeclareFun {
+            name,
+            name_span,
+            span,
+            ..
+        } => {
+            out.push(document_symbol(
+                name.to_string(),
+                None,
+                SymbolKind::FUNCTION,
+                None,
+                span_to_range(span, text),
+                span_to_range(name_span, text),
+                None,
+            ));
+        }
+        tishlang_ast::Statement::DeclareVar {
+            name,
+            name_span,
+            span,
+            ..
+        } => {
+            out.push(document_symbol(
+                name.to_string(),
+                None,
+                SymbolKind::VARIABLE,
+                None,
+                span_to_range(span, text),
+                span_to_range(name_span, text),
+                None,
+            ));
+        }
+        // `export fn` / `export let` / `export type` wrap the declaration — descend into it so
+        // exported symbols appear in the outline.
+        tishlang_ast::Statement::Export { declaration, .. } => {
+            if let tishlang_ast::ExportDeclaration::Named(inner) = declaration.as_ref() {
+                doc_symbol_stmt(inner, text, out);
+            }
+        }
+        // Block and the transparent comma-declarator group (`let a = 1, b = 2`).
+        tishlang_ast::Statement::Block { statements, .. }
+        | tishlang_ast::Statement::Multi { statements, .. } => {
             for x in statements {
                 doc_symbol_stmt(x, text, out);
             }
@@ -1381,6 +1573,50 @@ mod hover_tests {
         type_hint_at_def(p, span).expect("expected a type hint")
     }
 
+    #[test]
+    fn document_symbols_include_exported_type_and_comma_decls() {
+        let src = "export fn foo() {}\ntype Status = number\nlet a = 1, b = 2\ndeclare fn ext(): void\nlet plain = 3\n";
+        let program = tishlang_parser::parse(src).unwrap();
+        let mut syms = Vec::new();
+        for s in &program.statements {
+            doc_symbol_stmt(s, src, &mut syms);
+        }
+        let names: Vec<&str> = syms.iter().map(|s| s.name.as_str()).collect();
+        for expected in ["foo", "Status", "a", "b", "ext", "plain"] {
+            assert!(names.contains(&expected), "outline missing `{expected}`: {names:?}");
+        }
+    }
+
+    #[test]
+    fn is_import_specifier_span_detects_imports() {
+        let src = "import { foo } from \"./m\"\nfoo()\nlet x = 1\nx\n";
+        let program = tishlang_parser::parse(src).unwrap();
+        // `foo()` (line 1) resolves to the import specifier → go-to-def should follow it cross-file.
+        let foo_def = tishlang_resolve::definition_span(&program, src, 1, 0).expect("foo resolves");
+        assert!(
+            is_import_specifier_span(&program, &foo_def),
+            "foo resolves to an import specifier"
+        );
+        // `x` (line 3) resolves to the local `let` → not an import, jump to the local def as usual.
+        let x_def = tishlang_resolve::definition_span(&program, src, 3, 0).expect("x resolves");
+        assert!(
+            !is_import_specifier_span(&program, &x_def),
+            "x is a local binding, not an import"
+        );
+    }
+
+    #[test]
+    fn find_default_export_locates_export_default() {
+        let src = "export fn foo() {}\nexport default 42\n";
+        let program = tishlang_parser::parse(src).unwrap();
+        let uri = Url::parse("file:///m.tish").unwrap();
+        let loc = find_default_export(&program, &uri, src).expect("default export found");
+        assert_eq!(loc.range.start.line, 1, "export default is on line 1");
+        let none_src = "export fn bar() {}\n";
+        let p2 = tishlang_parser::parse(none_src).unwrap();
+        assert!(find_default_export(&p2, &uri, none_src).is_none());
+    }
+
     #[test]
     fn annotated_var() {
         let p = parse("let count: number = 0\n");
@@ -1426,6 +1662,15 @@ mod hover_tests {
         let arr_of_union = T::Array(Box::new(uni));
         assert_eq!(render_type(&arr_of_union), "(number | null)[]");
     }
+
+    #[test]
+    fn full_doc_end_reaches_past_trailing_newline_in_utf16() {
+        assert_eq!(full_doc_end("a\nb\n"), (2, 0)); // past the final newline (was the blank-line bug)
+        assert_eq!(full_doc_end("a\nb"), (1, 1)); // no trailing newline
+        assert_eq!(full_doc_end("x\n"), (1, 0));
+        assert_eq!(full_doc_end(""), (0, 0));
+        assert_eq!(full_doc_end("café"), (0, 4)); // UTF-16 units (é = 1), not bytes (5)
+    }
 }
 
 #[cfg(test)]

package/crates/tish_parser/src/parser.rs

@@ -2391,6 +2391,10 @@ impl<'a> Parser<'a> {
     fn parse_jsx_element(&mut self, start: (usize, usize)) -> Result<Expr, String> {
         let tag_tok = self.expect(TokenKind::Ident)?;
         let tag = tag_tok.literal.clone().ok_or("Expected tag name")?;
+        let tag_span = Span {
+            start: tag_tok.span.start,
+            end: tag_tok.span.end,
+        };
 
         let mut props = Vec::new();
         loop {
@@ -2402,6 +2406,8 @@ impl<'a> Parser<'a> {
                     let end = self.previous_span_end();
                     return Ok(Expr::JsxElement {
                         tag,
+                        tag_span,
+                        close_tag_span: None,
                         props,
                         children: vec![],
                         span: Span { start, end },
@@ -2451,10 +2457,12 @@ impl<'a> Parser<'a> {
         }
         self.advance(); // consume >
 
-        let children = self.parse_jsx_children(&tag)?;
+        let (children, close_tag_span) = self.parse_jsx_children(&tag)?;
         let end = self.previous_span_end();
         Ok(Expr::JsxElement {
             tag,
+            tag_span,
+            close_tag_span,
             props,
             children,
             span: Span { start, end },
@@ -2517,7 +2525,10 @@ impl<'a> Parser<'a> {
     }
 
     /// Parse JSX children until </Tag> or </>
-    fn parse_jsx_children(&mut self, close_tag: &str) -> Result<Vec<JsxChild>, String> {
+    fn parse_jsx_children(
+        &mut self,
+        close_tag: &str,
+    ) -> Result<(Vec<JsxChild>, Option<Span>), String> {
         let mut children = Vec::new();
         loop {
             match self.peek_kind() {
@@ -2529,11 +2540,12 @@ impl<'a> Parser<'a> {
                             // </ closing tag
                             self.advance(); // <
                             self.advance(); // /
-                            let name = self
-                                .expect(TokenKind::Ident)?
-                                .literal
-                                .clone()
-                                .ok_or("Expected tag name")?;
+                            let name_tok = self.expect(TokenKind::Ident)?;
+                            let name = name_tok.literal.clone().ok_or("Expected tag name")?;
+                            let close_tag_span = Span {
+                                start: name_tok.span.start,
+                                end: name_tok.span.end,
+                            };
                             if name.as_ref() != close_tag {
                                 return Err(format!(
                                     "Mismatched JSX tag: expected </{}> got </{}>",
@@ -2541,7 +2553,7 @@ impl<'a> Parser<'a> {
                                 ));
                             }
                             self.expect(TokenKind::Gt)?; // >
-                            return Ok(children);
+                            return Ok((children, Some(close_tag_span)));
                         }
                         if t.kind == TokenKind::Gt {
                             return Err("Unexpected <> in JSX children".to_string());