@tishlang/tish 2.2.5 → 2.8.0

package/crates/tish_opt/src/lib.rs

@@ -429,8 +429,8 @@ fn optimize_expr(expr: &Expr) -> Expr {
             props: props
                 .iter()
                 .map(|p| match p {
-                    tishlang_ast::ObjectProp::KeyValue(k, v) => {
-                        tishlang_ast::ObjectProp::KeyValue(Arc::clone(k), optimize_expr(v))
+                    tishlang_ast::ObjectProp::KeyValue(k, v, s) => {
+                        tishlang_ast::ObjectProp::KeyValue(Arc::clone(k), optimize_expr(v), *s)
                     }
                     tishlang_ast::ObjectProp::Spread(e) => {
                         tishlang_ast::ObjectProp::Spread(optimize_expr(e))
@@ -578,7 +578,9 @@ fn js_number_to_string(value: f64) -> String {
         return "-Infinity".to_string();
     }
     if value == 0.0 {
-        return if value.is_sign_negative() { "-0" } else { "0" }.to_string();
+        // ECMAScript `Number::toString`: both `+0` and `-0` → `"0"` (a constant-folded
+        // `"" + (-0)` must match the runtime ToString, not the inspect form). (#247)
+        return "0".to_string();
     }
     let negative = value < 0.0;
     let sci = format!("{:e}", value.abs());

package/crates/tish_parser/src/lib.rs

@@ -45,6 +45,24 @@ mod tests {
         }
     }
 
+    // #158: a block's span — and the enclosing function's span — must end at the closing `}`, not
+    // overrun onto the statement on the following line.
+    #[test]
+    fn block_and_fn_spans_stop_at_closing_brace() {
+        // `}` is on line 3 (1-based); `let after` begins on line 4.
+        let program = parse("fn f(a) {\n  let x = a\n}\nlet after = 1\n").expect("parse");
+        let Statement::FunDecl { span, body, .. } = &program.statements[0] else {
+            panic!("expected FunDecl");
+        };
+        assert_eq!(span.end.0, 3, "fn span must end on the `}}` line, not the next statement: {span:?}");
+        assert_eq!(
+            body.span().end.0,
+            3,
+            "body block span must end on the `}}` line: {:?}",
+            body.span()
+        );
+    }
+
     #[test]
     fn test_object_literal_shorthand_single() {
         let program = parse("const o = { port }").expect("parse object shorthand");
@@ -62,7 +80,7 @@ mod tests {
         };
         assert_eq!(props.len(), 1);
         match &props[0] {
-            ObjectProp::KeyValue(k, v) => {
+            ObjectProp::KeyValue(k, v, _) => {
                 assert_eq!(k.as_ref(), "port");
                 if let Expr::Ident { ref name, .. } = v {
                     assert_eq!(name.as_ref(), "port");
@@ -92,11 +110,11 @@ mod tests {
         };
         assert_eq!(props.len(), 2);
         match &props[0] {
-            ObjectProp::KeyValue(k, _) => assert_eq!(k.as_ref(), "ai-a"),
+            ObjectProp::KeyValue(k, _, _) => assert_eq!(k.as_ref(), "ai-a"),
             _ => panic!("expected KeyValue prop"),
         }
         match &props[1] {
-            ObjectProp::KeyValue(k, _) => assert_eq!(k.as_ref(), "human"),
+            ObjectProp::KeyValue(k, _, _) => assert_eq!(k.as_ref(), "human"),
             _ => panic!("expected KeyValue prop"),
         }
     }
@@ -118,7 +136,7 @@ mod tests {
         };
         assert_eq!(props.len(), 2);
         match &props[0] {
-            ObjectProp::KeyValue(k, v) => {
+            ObjectProp::KeyValue(k, v, _) => {
                 assert_eq!(k.as_ref(), "port");
                 if let Expr::Ident { ref name, .. } = v {
                     assert_eq!(name.as_ref(), "port");
@@ -129,7 +147,7 @@ mod tests {
             _ => panic!("expected KeyValue prop"),
         }
         match &props[1] {
-            ObjectProp::KeyValue(k, v) => {
+            ObjectProp::KeyValue(k, v, _) => {
                 assert_eq!(k.as_ref(), "x");
                 if let Expr::Literal { .. } = v {
                     // x: 1

package/crates/tish_parser/src/parser.rs

@@ -68,7 +68,7 @@ fn mangle_generic(base: &str, args: &[TypeAnnotation]) -> String {
 
 fn mangle_type(t: &TypeAnnotation) -> String {
     match t {
-        TypeAnnotation::Simple(s) => s.chars().map(|c| if c.is_alphanumeric() { c } else { '_' }).collect(),
+        TypeAnnotation::Simple(s, _) => s.chars().map(|c| if c.is_alphanumeric() { c } else { '_' }).collect(),
         TypeAnnotation::Array(inner) => format!("{}Arr", mangle_type(inner)),
         TypeAnnotation::Tuple(es) => {
             format!("Tup{}", es.iter().map(mangle_type).collect::<Vec<_>>().join(""))
@@ -84,7 +84,7 @@ fn mangle_type(t: &TypeAnnotation) -> String {
 /// Substitute generic type parameters with their concrete arguments throughout a type body.
 fn subst_type(t: &TypeAnnotation, map: &HashMap<&str, &TypeAnnotation>) -> TypeAnnotation {
     match t {
-        TypeAnnotation::Simple(s) => map
+        TypeAnnotation::Simple(s, _) => map
             .get(s.as_ref())
             .map(|rep| (*rep).clone())
             .unwrap_or_else(|| t.clone()),
@@ -364,27 +364,21 @@ impl<'a> Parser<'a> {
             statements.push(self.parse_statement()?);
         }
 
+        // Block ends at its CLOSING `}`/`Dedent`. Capture that token's end BEFORE advancing past it:
+        // reading `self.peek()` *after* the advance pointed at the NEXT token, overrunning the block
+        // span onto the following statement — so a cursor on the line after `}` was still "inside"
+        // the block and completion offered the body's params/locals there (#158). Fall back to the
+        // last inner statement's end for an unterminated block at EOF, else the block start.
+        let mut closer_end: Option<(usize, usize)> = None;
         if matches!(
             self.peek_kind(),
             Some(TokenKind::RBrace | TokenKind::Dedent)
         ) {
+            closer_end = self.peek().map(|t| t.span.end);
             self.advance();
         }
-
-        let peek_end = self.peek().map(|x| x.span.end);
         let last_end = statements.last().map(|s| s.span().end);
-        let end = match (peek_end, last_end) {
-            (Some(p), Some(l)) => {
-                if p.0 > l.0 || (p.0 == l.0 && p.1 > l.1) {
-                    p
-                } else {
-                    l
-                }
-            }
-            (Some(p), None) => p,
-            (None, Some(l)) => l,
-            (None, None) => span_start,
-        };
+        let end = closer_end.or(last_end).unwrap_or(span_start);
 
         Ok(Statement::Block {
             statements,
@@ -758,7 +752,10 @@ impl<'a> Parser<'a> {
                 }
                 Some(TokenKind::Question) => {
                     self.advance(); // ?
-                    t = TypeAnnotation::Union(vec![t, TypeAnnotation::Simple("null".into())]);
+                    t = TypeAnnotation::Union(vec![
+                        t,
+                        TypeAnnotation::Simple("null".into(), Span::default()),
+                    ]);
                 }
                 _ => break,
             }
@@ -772,6 +769,10 @@ impl<'a> Parser<'a> {
             Some(TokenKind::Ident) => {
                 let tok = self.advance().ok_or("Expected type name")?;
                 let name = tok.literal.clone().ok_or("Expected type name")?;
+                let span = Span {
+                    start: tok.span.start,
+                    end: tok.span.end,
+                };
                 // Generic reference `Name<Args>`: `Array<T>` desugars to the native `T[]`; other
                 // generic refs erase their args (the base name resolves to its alias, whose type
                 // params already act as unknown -> `Value`).
@@ -786,25 +787,29 @@ impl<'a> Parser<'a> {
                     // alias `Box__number` (a native struct). Falls back to erasing the args when
                     // `name` isn't a known generic alias (e.g. forward reference) or arity mismatches.
                     if let Some(spec) = self.monomorphize_generic(name.as_ref(), &args) {
-                        return Ok(TypeAnnotation::Simple(Arc::from(spec.as_str())));
+                        return Ok(TypeAnnotation::Simple(Arc::from(spec.as_str()), span));
                     }
-                    return Ok(TypeAnnotation::Simple(name));
+                    return Ok(TypeAnnotation::Simple(name, span));
                 }
-                Ok(TypeAnnotation::Simple(name))
+                Ok(TypeAnnotation::Simple(name, span))
             }
             Some(TokenKind::Type | TokenKind::Declare) => {
                 let tok = self.advance().ok_or("Expected type name")?;
                 let name = tok.literal.clone().ok_or("Expected type name")?;
-                Ok(TypeAnnotation::Simple(name))
+                let span = Span {
+                    start: tok.span.start,
+                    end: tok.span.end,
+                };
+                Ok(TypeAnnotation::Simple(name, span))
             }
             // Handle keywords that can be type names
             Some(TokenKind::Null) => {
                 self.advance();
-                Ok(TypeAnnotation::Simple("null".into()))
+                Ok(TypeAnnotation::Simple("null".into(), Span::default()))
             }
             Some(TokenKind::Void) => {
                 self.advance();
-                Ok(TypeAnnotation::Simple("void".into()))
+                Ok(TypeAnnotation::Simple("void".into(), Span::default()))
             }
             Some(TokenKind::LBrace) => {
                 // Object type: { key: Type, ... }
@@ -974,17 +979,12 @@ impl<'a> Parser<'a> {
             Box::new(self.parse_block()?)
         };
 
-        // Span must cover the whole declaration through the body. `peek().start` alone can sit on
-        // the opening `{` (same as `span_start` at EOF) or otherwise truncate before inner spans.
-        let peek_start = self.peek().map(|t| t.span.start).unwrap_or(span_start);
-        let body_end = body.as_ref().span().end;
-        let end = if peek_start.0 > body_end.0
-            || (peek_start.0 == body_end.0 && peek_start.1 > body_end.1)
-        {
-            peek_start
-        } else {
-            body_end
-        };
+        // The declaration spans from `fn`/`async` through the END of its body. `parse_block` now
+        // ends the body block exactly at its closing `}` (#158), so the body's end IS the function's
+        // end. (This previously maxed with `peek().start` — the NEXT token after the function — to
+        // compensate for the old block-span truncation, which instead overran the function span past
+        // `}` and inflated its folding / document-symbol range onto the following line. #158)
+        let end = body.as_ref().span().end;
 
         Ok(Statement::FunDecl {
             async_,
@@ -2232,7 +2232,7 @@ impl<'a> Parser<'a> {
                                 return Err("String key in object literal requires explicit value (key: value)".to_string());
                             }
                         };
-                        props.push(ObjectProp::KeyValue(key, value));
+                        props.push(ObjectProp::KeyValue(key, value, key_span));
                     }
                     if !matches!(self.peek_kind(), Some(TokenKind::RBrace)) {
                         self.expect(TokenKind::Comma)?;