@tishlang/tish 1.6.0 → 1.8.0

package/crates/tish_parser/src/parser.rs

@@ -52,7 +52,7 @@ macro_rules! binary_multi_op {
 }
 
 use tishlang_ast::{
-    ArrowBody, ArrayElement, BinOp, CallArg, CompoundOp, DestructElement, DestructPattern,
+    ArrayElement, ArrowBody, BinOp, CallArg, CompoundOp, DestructElement, DestructPattern,
     DestructProp, ExportDeclaration, Expr, FunParam, ImportSpecifier, JsxAttrValue, JsxChild,
     JsxProp, Literal, LogicalAssignOp, MemberProp, ObjectProp, Program, Span, Statement,
     TypeAnnotation, TypedParam, UnaryOp,
@@ -86,19 +86,21 @@ impl<'a> Parser<'a> {
     }
 
     fn expect(&mut self, kind: TokenKind) -> Result<&Token, String> {
-        let t = self.advance().ok_or_else(|| format!("Expected {:?}, got EOF", kind))?;
+        let t = self
+            .advance()
+            .ok_or_else(|| format!("Expected {:?}, got EOF", kind))?;
         if t.kind == kind {
             Ok(t)
         } else {
-            Err(format!("Expected {:?}, got {:?} at {:?}", kind, t.kind, t.span))
+            Err(format!(
+                "Expected {:?}, got {:?} at {:?}",
+                kind, t.kind, t.span
+            ))
         }
     }
 
     fn span_end(&self, start: (usize, usize)) -> Span {
-        let end = self
-            .peek()
-            .map(|t| t.span.start)
-            .unwrap_or(start);
+        let end = self.peek().map(|t| t.span.start).unwrap_or(start);
         Span { start, end }
     }
 
@@ -157,6 +159,8 @@ impl<'a> Parser<'a> {
             }
             TokenKind::Import => self.parse_import()?,
             TokenKind::Export => self.parse_export()?,
+            TokenKind::Type => self.parse_type_alias()?,
+            TokenKind::Declare => self.parse_declare()?,
             _ => {
                 let expr = self.parse_expr()?;
                 let span_end = expr.span().end;
@@ -207,18 +211,33 @@ impl<'a> Parser<'a> {
             statements.push(self.parse_statement()?);
         }
 
-        if matches!(self.peek_kind(), Some(TokenKind::RBrace | TokenKind::Dedent)) {
+        if matches!(
+            self.peek_kind(),
+            Some(TokenKind::RBrace | TokenKind::Dedent)
+        ) {
             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,
+        };
+
         Ok(Statement::Block {
             statements,
             span: Span {
                 start: span_start,
-                end: self
-                    .peek()
-                    .map(|x| x.span.end)
-                    .unwrap_or(span_start),
+                end,
             },
         })
     }
@@ -229,9 +248,12 @@ impl<'a> Parser<'a> {
         } else {
             self.expect(TokenKind::Const)?.span.start
         };
-        
+
         // Check for destructuring pattern
-        if matches!(self.peek_kind(), Some(TokenKind::LBracket) | Some(TokenKind::LBrace)) {
+        if matches!(
+            self.peek_kind(),
+            Some(TokenKind::LBracket) | Some(TokenKind::LBrace)
+        ) {
             let pattern = self.parse_destruct_pattern()?;
             self.expect(TokenKind::Assign)?;
             let init = self.parse_expr()?;
@@ -242,9 +264,13 @@ impl<'a> Parser<'a> {
                 span: self.span_end(span_start),
             });
         }
-        
-        let name = self
-            .expect(TokenKind::Ident)?
+
+        let name_tok = self.expect(TokenKind::Ident)?;
+        let name_span = Span {
+            start: name_tok.span.start,
+            end: name_tok.span.end,
+        };
+        let name = name_tok
             .literal
             .clone()
             .ok_or("Expected identifier")?;
@@ -265,13 +291,14 @@ impl<'a> Parser<'a> {
         };
         Ok(Statement::VarDecl {
             name,
+            name_span,
             mutable,
             type_ann,
             init,
             span: self.span_end(span_start),
         })
     }
-    
+
     fn parse_destruct_pattern(&mut self) -> Result<DestructPattern, String> {
         match self.peek_kind() {
             Some(TokenKind::LBracket) => self.parse_array_destruct_pattern(),
@@ -279,11 +306,11 @@ impl<'a> Parser<'a> {
             _ => Err("Expected destructuring pattern".to_string()),
         }
     }
-    
+
     fn parse_array_destruct_pattern(&mut self) -> Result<DestructPattern, String> {
         self.expect(TokenKind::LBracket)?;
         let mut elements = Vec::new();
-        
+
         while !matches!(self.peek_kind(), Some(TokenKind::RBracket)) {
             // Handle holes (elision): [a, , b]
             if matches!(self.peek_kind(), Some(TokenKind::Comma)) {
@@ -291,15 +318,23 @@ impl<'a> Parser<'a> {
                 self.advance();
                 continue;
             }
-            
+
             // Rest element: ...rest
             if matches!(self.peek_kind(), Some(TokenKind::Spread)) {
                 self.advance();
-                let name = self.expect(TokenKind::Ident)?.literal.clone().ok_or("Expected identifier")?;
-                elements.push(Some(DestructElement::Rest(name)));
+                let name_tok = self.expect(TokenKind::Ident)?;
+                let name_span = Span {
+                    start: name_tok.span.start,
+                    end: name_tok.span.end,
+                };
+                let name = name_tok
+                    .literal
+                    .clone()
+                    .ok_or("Expected identifier")?;
+                elements.push(Some(DestructElement::Rest(name, name_span)));
                 break;
             }
-            
+
             // Nested pattern or identifier
             let elem = match self.peek_kind() {
                 Some(TokenKind::LBracket) | Some(TokenKind::LBrace) => {
@@ -307,31 +342,47 @@ impl<'a> Parser<'a> {
                     DestructElement::Pattern(Box::new(nested))
                 }
                 Some(TokenKind::Ident) => {
-                    let name = self.advance().ok_or("Unexpected EOF")?.literal.clone().ok_or("Expected identifier")?;
-                    DestructElement::Ident(name)
+                    let name_tok = self.advance().ok_or("Unexpected EOF")?;
+                    let name_span = Span {
+                        start: name_tok.span.start,
+                        end: name_tok.span.end,
+                    };
+                    let name = name_tok
+                        .literal
+                        .clone()
+                        .ok_or("Expected identifier")?;
+                    DestructElement::Ident(name, name_span)
                 }
                 _ => return Err("Expected identifier or pattern in destructuring".to_string()),
             };
             elements.push(Some(elem));
-            
+
             if matches!(self.peek_kind(), Some(TokenKind::Comma)) {
                 self.advance();
             } else {
                 break;
             }
         }
-        
+
         self.expect(TokenKind::RBracket)?;
         Ok(DestructPattern::Array(elements))
     }
-    
+
     fn parse_object_destruct_pattern(&mut self) -> Result<DestructPattern, String> {
         self.expect(TokenKind::LBrace)?;
         let mut props = Vec::new();
-        
+
         while !matches!(self.peek_kind(), Some(TokenKind::RBrace)) {
-            let key = self.expect(TokenKind::Ident)?.literal.clone().ok_or("Expected identifier")?;
-            
+            let key_tok = self.expect(TokenKind::Ident)?;
+            let key_span = Span {
+                start: key_tok.span.start,
+                end: key_tok.span.end,
+            };
+            let key = key_tok
+                .literal
+                .clone()
+                .ok_or("Expected identifier")?;
+
             let value = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
                 self.advance();
                 // Could be renamed binding or nested pattern
@@ -341,25 +392,33 @@ impl<'a> Parser<'a> {
                         DestructElement::Pattern(Box::new(nested))
                     }
                     Some(TokenKind::Ident) => {
-                        let name = self.advance().ok_or("Unexpected EOF")?.literal.clone().ok_or("Expected identifier")?;
-                        DestructElement::Ident(name)
+                        let name_tok = self.advance().ok_or("Unexpected EOF")?;
+                        let name_span = Span {
+                            start: name_tok.span.start,
+                            end: name_tok.span.end,
+                        };
+                        let name = name_tok
+                            .literal
+                            .clone()
+                            .ok_or("Expected identifier")?;
+                        DestructElement::Ident(name, name_span)
                     }
                     _ => return Err("Expected identifier or pattern after ':'".to_string()),
                 }
             } else {
                 // Shorthand: { key } is equivalent to { key: key }
-                DestructElement::Ident(key.clone())
+                DestructElement::Ident(key.clone(), key_span)
             };
-            
+
             props.push(DestructProp { key, value });
-            
+
             if matches!(self.peek_kind(), Some(TokenKind::Comma)) {
                 self.advance();
             } else {
                 break;
             }
         }
-        
+
         self.expect(TokenKind::RBrace)?;
         Ok(DestructPattern::Object(props))
     }
@@ -389,8 +448,12 @@ impl<'a> Parser<'a> {
                 default,
             });
         }
-        let param_name = self
-            .expect(TokenKind::Ident)?
+        let param_tok = self.expect(TokenKind::Ident)?;
+        let name_span = Span {
+            start: param_tok.span.start,
+            end: param_tok.span.end,
+        };
+        let param_name = param_tok
             .literal
             .clone()
             .ok_or("Expected param name")?;
@@ -408,22 +471,23 @@ impl<'a> Parser<'a> {
         };
         Ok(FunParam::Simple(TypedParam {
             name: param_name,
+            name_span,
             type_ann,
             default,
         }))
     }
-    
+
     /// Parse a type annotation (number, string, T[], {a: T}, etc.)
     fn parse_type_annotation(&mut self) -> Result<TypeAnnotation, String> {
         let base = self.parse_type_primary()?;
-        
+
         // Check for array suffix: T[]
         if matches!(self.peek_kind(), Some(TokenKind::LBracket)) {
             self.advance(); // [
             self.expect(TokenKind::RBracket)?; // ]
             return Ok(TypeAnnotation::Array(Box::new(base)));
         }
-        
+
         // Check for union: T | U
         if matches!(self.peek_kind(), Some(TokenKind::BitOr)) {
             let mut types = vec![base];
@@ -433,10 +497,10 @@ impl<'a> Parser<'a> {
             }
             return Ok(TypeAnnotation::Union(types));
         }
-        
+
         Ok(base)
     }
-    
+
     /// Parse a primary type (identifier, object, or function type)
     fn parse_type_primary(&mut self) -> Result<TypeAnnotation, String> {
         match self.peek_kind() {
@@ -445,6 +509,11 @@ impl<'a> Parser<'a> {
                 let name = tok.literal.clone().ok_or("Expected type name")?;
                 Ok(TypeAnnotation::Simple(name))
             }
+            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))
+            }
             // Handle keywords that can be type names
             Some(TokenKind::Null) => {
                 self.advance();
@@ -459,14 +528,22 @@ impl<'a> Parser<'a> {
                 self.advance(); // {
                 let mut props = Vec::new();
                 while !matches!(self.peek_kind(), Some(TokenKind::RBrace)) {
-                    let key = self.expect(TokenKind::Ident)?.literal.clone()
+                    let key = self
+                        .expect(TokenKind::Ident)?
+                        .literal
+                        .clone()
                         .ok_or("Expected property name")?;
                     self.expect(TokenKind::Colon)?;
                     let typ = self.parse_type_annotation()?;
                     props.push((key, typ));
                     if !matches!(self.peek_kind(), Some(TokenKind::RBrace)) {
-                        // Allow trailing comma or require comma between items
-                        if matches!(self.peek_kind(), Some(TokenKind::Comma)) {
+                        // Accept `,` or `;` between items (TypeScript-style
+                        // semicolons are common in interface/object type
+                        // declarations); also tolerate a trailing separator.
+                        if matches!(
+                            self.peek_kind(),
+                            Some(TokenKind::Comma) | Some(TokenKind::Semicolon)
+                        ) {
                             self.advance();
                         }
                     }
@@ -485,9 +562,7 @@ impl<'a> Parser<'a> {
                     }
                 }
                 self.expect(TokenKind::RParen)?;
-                // Expect => for return type
-                self.expect(TokenKind::Assign)?; // = 
-                self.expect(TokenKind::Gt)?; // > (forms =>)
+                self.expect(TokenKind::Arrow)?;
                 let returns = self.parse_type_annotation()?;
                 Ok(TypeAnnotation::Function {
                     params,
@@ -500,8 +575,12 @@ impl<'a> Parser<'a> {
 
     fn parse_fun_decl(&mut self, async_: bool) -> Result<Statement, String> {
         let span_start = self.expect(TokenKind::Fn)?.span.start;
-        let name = self
-            .expect(TokenKind::Ident)?
+        let name_tok = self.expect(TokenKind::Ident)?;
+        let name_span = Span {
+            start: name_tok.span.start,
+            end: name_tok.span.end,
+        };
+        let name = name_tok
             .literal
             .clone()
             .ok_or("Expected function name")?;
@@ -511,8 +590,12 @@ impl<'a> Parser<'a> {
         while !matches!(self.peek_kind(), Some(TokenKind::RParen)) {
             if matches!(self.peek_kind(), Some(TokenKind::Spread)) {
                 self.advance();
-                let param_name = self
-                    .expect(TokenKind::Ident)?
+                let rest_tok = self.expect(TokenKind::Ident)?;
+                let rest_name_span = Span {
+                    start: rest_tok.span.start,
+                    end: rest_tok.span.end,
+                };
+                let param_name = rest_tok
                     .literal
                     .clone()
                     .ok_or("Expected rest param name")?;
@@ -523,7 +606,12 @@ impl<'a> Parser<'a> {
                 } else {
                     None
                 };
-                rest_param = Some(TypedParam { name: param_name, type_ann, default: None });
+                rest_param = Some(TypedParam {
+                    name: param_name,
+                    name_span: rest_name_span,
+                    type_ann,
+                    default: None,
+                });
                 if !matches!(self.peek_kind(), Some(TokenKind::RParen)) {
                     return Err("Rest parameter must be last".to_string());
                 }
@@ -535,7 +623,7 @@ impl<'a> Parser<'a> {
             }
         }
         self.expect(TokenKind::RParen)?;
-        
+
         // Optional return type: `: Type`
         let return_type = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
             self.advance();
@@ -559,13 +647,182 @@ 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
+        };
+
         Ok(Statement::FunDecl {
             async_,
             name,
+            name_span,
             params,
             rest_param,
             return_type,
             body,
+            span: Span {
+                start: span_start,
+                end,
+            },
+        })
+    }
+
+    fn parse_type_alias(&mut self) -> Result<Statement, String> {
+        let span_start = self.expect(TokenKind::Type)?.span.start;
+        let name_tok = self.expect(TokenKind::Ident)?;
+        let name_span = Span {
+            start: name_tok.span.start,
+            end: name_tok.span.end,
+        };
+        let name = name_tok
+            .literal
+            .clone()
+            .ok_or("Expected type alias name")?;
+        self.expect(TokenKind::Assign)?;
+        let ty = self.parse_type_annotation()?;
+        Ok(Statement::TypeAlias {
+            name,
+            name_span,
+            ty,
+            span: self.span_end(span_start),
+        })
+    }
+
+    fn parse_declare(&mut self) -> Result<Statement, String> {
+        let span_start = self.expect(TokenKind::Declare)?.span.start;
+        let async_ = if matches!(self.peek_kind(), Some(TokenKind::Async)) {
+            self.advance();
+            true
+        } else {
+            false
+        };
+        if matches!(self.peek_kind(), Some(TokenKind::Fn)) {
+            return self.parse_declare_fun(span_start, async_);
+        }
+        let const_ = match self.peek_kind() {
+            Some(TokenKind::Let) => {
+                self.advance();
+                false
+            }
+            Some(TokenKind::Const) => {
+                self.advance();
+                true
+            }
+            _ => {
+                return Err(
+                    "Expected `let`, `const`, `async fn`, or `fn` after `declare`".to_string(),
+                );
+            }
+        };
+        let name_tok = self.expect(TokenKind::Ident)?;
+        let name_span = Span {
+            start: name_tok.span.start,
+            end: name_tok.span.end,
+        };
+        let name = name_tok
+            .literal
+            .clone()
+            .ok_or("Expected identifier")?;
+        let type_ann = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
+            self.advance();
+            Some(self.parse_type_annotation()?)
+        } else {
+            None
+        };
+        if matches!(self.peek_kind(), Some(TokenKind::Assign)) {
+            return Err("`declare` cannot have an initializer".to_string());
+        }
+        Ok(Statement::DeclareVar {
+            name,
+            name_span,
+            type_ann,
+            const_,
+            span: self.span_end(span_start),
+        })
+    }
+
+    fn parse_declare_fun(
+        &mut self,
+        span_start: (usize, usize),
+        async_: bool,
+    ) -> Result<Statement, String> {
+        self.expect(TokenKind::Fn)?;
+        let name_tok = self.expect(TokenKind::Ident)?;
+        let name_span = Span {
+            start: name_tok.span.start,
+            end: name_tok.span.end,
+        };
+        let name = name_tok
+            .literal
+            .clone()
+            .ok_or("Expected function name")?;
+        self.expect(TokenKind::LParen)?;
+        let mut params = Vec::with_capacity(4);
+        let mut rest_param = None;
+        while !matches!(self.peek_kind(), Some(TokenKind::RParen)) {
+            if matches!(self.peek_kind(), Some(TokenKind::Spread)) {
+                self.advance();
+                let rest_tok = self.expect(TokenKind::Ident)?;
+                let rest_name_span = Span {
+                    start: rest_tok.span.start,
+                    end: rest_tok.span.end,
+                };
+                let param_name = rest_tok
+                    .literal
+                    .clone()
+                    .ok_or("Expected rest param name")?;
+                let type_ann = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
+                    self.advance();
+                    Some(self.parse_type_annotation()?)
+                } else {
+                    None
+                };
+                rest_param = Some(TypedParam {
+                    name: param_name,
+                    name_span: rest_name_span,
+                    type_ann,
+                    default: None,
+                });
+                if !matches!(self.peek_kind(), Some(TokenKind::RParen)) {
+                    return Err("Rest parameter must be last".to_string());
+                }
+                break;
+            }
+            params.push(self.parse_fun_param()?);
+            if !matches!(self.peek_kind(), Some(TokenKind::RParen)) {
+                self.expect(TokenKind::Comma)?;
+            }
+        }
+        self.expect(TokenKind::RParen)?;
+        let return_type = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
+            self.advance();
+            Some(self.parse_type_annotation()?)
+        } else {
+            None
+        };
+        if matches!(
+            self.peek_kind(),
+            Some(TokenKind::Assign | TokenKind::LBrace | TokenKind::Indent)
+        ) {
+            return Err("`declare function` must not have a body".to_string());
+        }
+        if matches!(self.peek_kind(), Some(TokenKind::Semicolon)) {
+            self.advance();
+        }
+        Ok(Statement::DeclareFun {
+            async_,
+            name,
+            name_span,
+            params,
+            rest_param,
+            return_type,
             span: self.span_end(span_start),
         })
     }
@@ -610,8 +867,12 @@ impl<'a> Parser<'a> {
             let mutable = matches!(self.peek_kind(), Some(TokenKind::Let));
             let var_span_start = self.peek().map(|t| t.span.start).unwrap_or((0, 0));
             self.advance();
-            let name = self
-                .expect(TokenKind::Ident)?
+            let for_name_tok = self.expect(TokenKind::Ident)?;
+            let name_span = Span {
+                start: for_name_tok.span.start,
+                end: for_name_tok.span.end,
+            };
+            let name = for_name_tok
                 .literal
                 .clone()
                 .ok_or("Expected identifier")?;
@@ -622,6 +883,7 @@ impl<'a> Parser<'a> {
                 let body = Box::new(self.parse_block_or_statement()?);
                 return Ok(Statement::ForOf {
                     name,
+                    name_span,
                     iterable,
                     body,
                     span: self.span_end(span_start),
@@ -644,6 +906,7 @@ impl<'a> Parser<'a> {
             }
             Some(Box::new(Statement::VarDecl {
                 name,
+                name_span,
                 mutable,
                 type_ann,
                 init: init_expr,
@@ -665,7 +928,10 @@ impl<'a> Parser<'a> {
         if matches!(self.peek_kind(), Some(TokenKind::Semicolon)) {
             self.advance();
         }
-        let cond = if matches!(self.peek_kind(), Some(TokenKind::Semicolon | TokenKind::RParen)) {
+        let cond = if matches!(
+            self.peek_kind(),
+            Some(TokenKind::Semicolon | TokenKind::RParen)
+        ) {
             None
         } else {
             let c = self.parse_expr()?;
@@ -780,31 +1046,38 @@ impl<'a> Parser<'a> {
     fn parse_try(&mut self) -> Result<Statement, String> {
         let span_start = self.expect(TokenKind::Try)?.span.start;
         let body = Box::new(self.parse_block_or_statement()?);
-        
+
         let mut catch_param = None;
+        let mut catch_param_span = None;
         let mut catch_body = None;
         let mut finally_body = None;
-        
+
         if matches!(self.peek_kind(), Some(TokenKind::Catch)) {
             self.advance();
             self.expect(TokenKind::LParen)?;
-            catch_param = self.expect(TokenKind::Ident)?.literal.clone();
+            let catch_tok = self.expect(TokenKind::Ident)?;
+            catch_param_span = Some(Span {
+                start: catch_tok.span.start,
+                end: catch_tok.span.end,
+            });
+            catch_param = catch_tok.literal.clone();
             self.expect(TokenKind::RParen)?;
             catch_body = Some(Box::new(self.parse_block_or_statement()?));
         }
-        
+
         if matches!(self.peek_kind(), Some(TokenKind::Finally)) {
             self.advance();
             finally_body = Some(Box::new(self.parse_block_or_statement()?));
         }
-        
+
         if catch_body.is_none() && finally_body.is_none() {
             return Err("try statement requires catch or finally".to_string());
         }
-        
+
         Ok(Statement::Try {
             body,
             catch_param,
+            catch_param_span,
             catch_body,
             finally_body,
             span: self.span_end(span_start),
@@ -818,25 +1091,42 @@ impl<'a> Parser<'a> {
             self.advance();
             let mut specs = Vec::new();
             while !matches!(self.peek_kind(), Some(TokenKind::RBrace)) {
-                let name = self
-                    .expect(TokenKind::Ident)?
+                let name_tok = self.expect(TokenKind::Ident)?;
+                let name_span = Span {
+                    start: name_tok.span.start,
+                    end: name_tok.span.end,
+                };
+                let name = name_tok
                     .literal
                     .clone()
                     .ok_or("Expected identifier in import")?;
-                let alias = if matches!(self.peek_kind(), Some(TokenKind::Ident))
+                let (alias, alias_span) = if matches!(self.peek_kind(), Some(TokenKind::Ident))
                     && self.peek().and_then(|t| t.literal.as_deref()) == Some("as")
                 {
                     self.advance(); // consume 'as'
-                    Some(
-                        self.expect(TokenKind::Ident)?
-                            .literal
-                            .clone()
-                            .ok_or("Expected alias after 'as'")?,
+                    let alias_tok = self.expect(TokenKind::Ident)?;
+                    let asp = Span {
+                        start: alias_tok.span.start,
+                        end: alias_tok.span.end,
+                    };
+                    (
+                        Some(
+                            alias_tok
+                                .literal
+                                .clone()
+                                .ok_or("Expected alias after 'as'")?,
+                        ),
+                        Some(asp),
                     )
                 } else {
-                    None
+                    (None, None)
                 };
-                specs.push(ImportSpecifier::Named { name, alias });
+                specs.push(ImportSpecifier::Named {
+                    name,
+                    name_span,
+                    alias,
+                    alias_span,
+                });
                 if !matches!(self.peek_kind(), Some(TokenKind::RBrace)) {
                     self.expect(TokenKind::Comma)?;
                 }
@@ -850,20 +1140,31 @@ impl<'a> Parser<'a> {
             if as_tok.literal.as_deref() != Some("as") {
                 return Err("Expected 'as' after '*' in namespace import".to_string());
             }
-            let alias = self
-                .expect(TokenKind::Ident)?
+            let alias_tok = self.expect(TokenKind::Ident)?;
+            let name_span = Span {
+                start: alias_tok.span.start,
+                end: alias_tok.span.end,
+            };
+            let alias = alias_tok
                 .literal
                 .clone()
                 .ok_or("Expected identifier after 'as'")?;
-            vec![ImportSpecifier::Namespace(alias)]
+            vec![ImportSpecifier::Namespace {
+                name: alias,
+                name_span,
+            }]
         } else if matches!(self.peek_kind(), Some(TokenKind::Ident)) {
             // Default: import X from "..."
-            let name = self
-                .expect(TokenKind::Ident)?
+            let def_tok = self.expect(TokenKind::Ident)?;
+            let name_span = Span {
+                start: def_tok.span.start,
+                end: def_tok.span.end,
+            };
+            let name = def_tok
                 .literal
                 .clone()
                 .ok_or("Expected identifier")?;
-            vec![ImportSpecifier::Default(name)]
+            vec![ImportSpecifier::Default { name, name_span }]
         } else {
             return Err("Expected { }, * as name, or default import".to_string());
         };
@@ -889,6 +1190,10 @@ impl<'a> Parser<'a> {
             self.advance();
             let expr = self.parse_expr()?;
             ExportDeclaration::Default(expr)
+        } else if matches!(self.peek_kind(), Some(TokenKind::Type)) {
+            ExportDeclaration::Named(Box::new(self.parse_type_alias()?))
+        } else if matches!(self.peek_kind(), Some(TokenKind::Declare)) {
+            ExportDeclaration::Named(Box::new(self.parse_declare()?))
         } else if matches!(self.peek_kind(), Some(TokenKind::Const)) {
             ExportDeclaration::Named(Box::new(self.parse_var_decl(false)?))
         } else if matches!(self.peek_kind(), Some(TokenKind::Let)) {
@@ -902,7 +1207,10 @@ impl<'a> Parser<'a> {
             }
             ExportDeclaration::Named(Box::new(self.parse_fun_decl(async_)?))
         } else {
-            return Err("Expected 'default', 'const', 'let', or 'fn' after export".to_string());
+            return Err(
+                "Expected 'default', 'type', 'declare', 'const', 'let', or 'fn' after export"
+                    .to_string(),
+            );
         };
         Ok(Statement::Export {
             declaration: Box::new(declaration),
@@ -920,7 +1228,7 @@ impl<'a> Parser<'a> {
         // Check for simple assignment
         if matches!(self.peek_kind(), Some(TokenKind::Assign)) {
             let start = left.span().start;
-            
+
             // Variable assignment: x = val
             if let Expr::Ident { name, .. } = &left {
                 let name = Arc::clone(name);
@@ -933,9 +1241,14 @@ impl<'a> Parser<'a> {
                     span: Span { start, end },
                 });
             }
-            
+
             // Member assignment: obj.prop = val
-            if let Expr::Member { object, prop: MemberProp::Name(prop_name), .. } = &left {
+            if let Expr::Member {
+                object,
+                prop: MemberProp::Name { name: prop_name, .. },
+                ..
+            } = &left
+            {
                 let object = Box::clone(object);
                 let prop = Arc::clone(prop_name);
                 self.advance(); // =
@@ -948,7 +1261,7 @@ impl<'a> Parser<'a> {
                     span: Span { start, end },
                 });
             }
-            
+
             // Index assignment: arr[idx] = val or obj[key] = val
             if let Expr::Index { object, index, .. } = &left {
                 let object = Box::clone(object);
@@ -1060,7 +1373,7 @@ impl<'a> Parser<'a> {
     binary_single_op!(parse_bit_or, parse_bit_xor, BitOr, BinOp::BitOr);
     binary_single_op!(parse_bit_xor, parse_bit_and, BitXor, BinOp::BitXor);
     binary_single_op!(parse_bit_and, parse_shift, BitAnd, BinOp::BitAnd);
-    
+
     binary_multi_op!(parse_shift, parse_equality, Shl => BinOp::Shl, Shr => BinOp::Shr);
     binary_multi_op!(parse_equality, parse_comparison,
         StrictEq => BinOp::StrictEq, StrictNe => BinOp::StrictNe,
@@ -1099,14 +1412,20 @@ impl<'a> Parser<'a> {
             let operand = self.parse_unary()?;
             if let Expr::Ident { name, span } = &operand {
                 let name = Arc::clone(name);
-                let span = Span { start: span_start, end: span.end };
+                let span = Span {
+                    start: span_start,
+                    end: span.end,
+                };
                 return Ok(if is_inc {
                     Expr::PrefixInc { name, span }
                 } else {
                     Expr::PrefixDec { name, span }
                 });
             }
-            return Err(format!("Prefix {} requires an identifier", if is_inc { "++" } else { "--" }));
+            return Err(format!(
+                "Prefix {} requires an identifier",
+                if is_inc { "++" } else { "--" }
+            ));
         }
         let op = match self.peek_kind() {
             Some(TokenKind::Not) => UnaryOp::Not,
@@ -1134,7 +1453,10 @@ impl<'a> Parser<'a> {
                 let end = operand.span().end;
                 return Ok(Expr::Await {
                     operand: Box::new(operand),
-                    span: Span { start: span_start, end },
+                    span: Span {
+                        start: span_start,
+                        end,
+                    },
                 });
             }
             _ => return self.parse_postfix(),
@@ -1161,16 +1483,23 @@ impl<'a> Parser<'a> {
                 TokenKind::Dot | TokenKind::OptionalChain => {
                     let optional = kind == TokenKind::OptionalChain;
                     self.advance();
-                    let prop = self
-                        .expect(TokenKind::Ident)?
+                    let prop_tok = self.expect(TokenKind::Ident)?;
+                    let prop = prop_tok
                         .literal
                         .clone()
                         .ok_or("Expected property name")?;
+                    let prop_span = Span {
+                        start: prop_tok.span.start,
+                        end: prop_tok.span.end,
+                    };
                     let start = expr.span().start;
                     let end = self.peek().map(|x| x.span.start).unwrap_or(start);
                     expr = Expr::Member {
                         object: Box::new(expr),
-                        prop: MemberProp::Name(prop),
+                        prop: MemberProp::Name {
+                            name: prop,
+                            span: prop_span,
+                        },
                         optional,
                         span: Span { start, end },
                     };
@@ -1274,16 +1603,23 @@ impl<'a> Parser<'a> {
                 TokenKind::Dot | TokenKind::OptionalChain => {
                     let optional = kind == TokenKind::OptionalChain;
                     self.advance();
-                    let prop = self
-                        .expect(TokenKind::Ident)?
+                    let prop_tok = self.expect(TokenKind::Ident)?;
+                    let prop = prop_tok
                         .literal
                         .clone()
                         .ok_or("Expected property name")?;
+                    let prop_span = Span {
+                        start: prop_tok.span.start,
+                        end: prop_tok.span.end,
+                    };
                     let start = expr.span().start;
                     let end = self.peek().map(|x| x.span.start).unwrap_or(start);
                     expr = Expr::Member {
                         object: Box::new(expr),
-                        prop: MemberProp::Name(prop),
+                        prop: MemberProp::Name {
+                            name: prop,
+                            span: prop_span,
+                        },
                         optional,
                         span: Span { start, end },
                     };
@@ -1302,11 +1638,18 @@ impl<'a> Parser<'a> {
                     };
                 }
                 TokenKind::PlusPlus | TokenKind::MinusMinus => {
-                    if let Expr::Ident { name, span: ident_span } = &expr {
+                    if let Expr::Ident {
+                        name,
+                        span: ident_span,
+                    } = &expr
+                    {
                         let name = Arc::clone(name);
                         let is_inc = kind == TokenKind::PlusPlus;
                         let tok = self.advance().ok_or("Unexpected EOF")?;
-                        let span = Span { start: ident_span.start, end: tok.span.end };
+                        let span = Span {
+                            start: ident_span.start,
+                            end: tok.span.end,
+                        };
                         expr = if is_inc {
                             Expr::PostfixInc { name, span }
                         } else {
@@ -1370,11 +1713,15 @@ impl<'a> Parser<'a> {
                     return Ok(Expr::ArrowFunction {
                         params: vec![FunParam::Simple(TypedParam {
                             name: name.clone(),
+                            name_span: span,
                             type_ann: None,
                             default: None,
                         })],
                         body,
-                        span: Span { start: span.start, end },
+                        span: Span {
+                            start: span.start,
+                            end,
+                        },
                     });
                 }
                 Ok(Expr::Ident { name, span })
@@ -1418,7 +1765,10 @@ impl<'a> Parser<'a> {
                 match self.peek_kind() {
                     Some(TokenKind::Ident) => self.parse_jsx_element(span.start),
                     Some(TokenKind::Gt) => self.parse_jsx_fragment(span.start),
-                    _ => Err(format!("Invalid JSX: expected tag name or <> after <, got {:?}", self.peek_kind())),
+                    _ => Err(format!(
+                        "Invalid JSX: expected tag name or <> after <, got {:?}",
+                        self.peek_kind()
+                    )),
                 }
             }
             TokenKind::LBrace => {
@@ -1431,11 +1781,8 @@ impl<'a> Parser<'a> {
                     } else {
                         let key_tok = self.advance().ok_or("Expected object key")?;
                         let (key, key_span, is_ident_key) = match key_tok.kind {
-                            TokenKind::Ident => {
-                                let k = key_tok
-                                    .literal
-                                    .clone()
-                                    .ok_or("Expected key")?;
+                            TokenKind::Ident | TokenKind::Type | TokenKind::Declare => {
+                                let k = key_tok.literal.clone().ok_or("Expected key")?;
                                 let sp = Span {
                                     start: key_tok.span.start,
                                     end: key_tok.span.end,
@@ -1443,20 +1790,19 @@ impl<'a> Parser<'a> {
                                 (k, sp, true)
                             }
                             TokenKind::String => {
-                                let k = key_tok
-                                    .literal
-                                    .clone()
-                                    .ok_or("Expected string key")?;
+                                let k = key_tok.literal.clone().ok_or("Expected string key")?;
                                 let sp = Span {
                                     start: key_tok.span.start,
                                     end: key_tok.span.end,
                                 };
                                 (k, sp, false)
                             }
-                            _ => return Err(format!(
-                                "Expected object key (ident or string), got {:?}",
-                                key_tok.kind
-                            )),
+                            _ => {
+                                return Err(format!(
+                                    "Expected object key (ident or string), got {:?}",
+                                    key_tok.kind
+                                ))
+                            }
                         };
                         let value = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
                             self.expect(TokenKind::Colon)?;
@@ -1499,12 +1845,12 @@ impl<'a> Parser<'a> {
                 // Template literal with interpolation: `text${
                 let mut quasis = vec![t.literal.clone().unwrap_or_default()];
                 let mut exprs = Vec::new();
-                
+
                 loop {
                     // Parse the expression inside ${}
                     let expr = self.parse_expr()?;
                     exprs.push(expr);
-                    
+
                     // Next token should be TemplateMiddle or TemplateTail
                     let next = self.advance().ok_or("Unexpected EOF in template literal")?;
                     match next.kind {
@@ -1514,14 +1860,22 @@ impl<'a> Parser<'a> {
                             return Ok(Expr::TemplateLiteral {
                                 quasis,
                                 exprs,
-                                span: Span { start: span.start, end },
+                                span: Span {
+                                    start: span.start,
+                                    end,
+                                },
                             });
                         }
                         TokenKind::TemplateMiddle => {
                             quasis.push(next.literal.clone().unwrap_or_default());
                             // Continue parsing more expressions
                         }
-                        _ => return Err(format!("Expected template continuation, got {:?}", next.kind)),
+                        _ => {
+                            return Err(format!(
+                                "Expected template continuation, got {:?}",
+                                next.kind
+                            ))
+                        }
                     }
                 }
             }
@@ -1534,11 +1888,11 @@ impl<'a> Parser<'a> {
     fn try_parse_arrow_function(&mut self, start_span: &Span) -> Result<Option<Expr>, String> {
         // Save position for backtracking
         let saved_pos = self.pos;
-        
+
         // Try to parse as arrow function params
         let mut params = Vec::new();
         let mut is_arrow = false;
-        
+
         // Check for empty params: () => ...
         if matches!(self.peek_kind(), Some(TokenKind::RParen)) {
             self.advance(); // consume )
@@ -1574,20 +1928,23 @@ impl<'a> Parser<'a> {
                 }
             }
         }
-        
+
         if !is_arrow {
             // Backtrack - it's not an arrow function
             self.pos = saved_pos;
             return Ok(None);
         }
-        
+
         let body = self.parse_arrow_body()?;
         let end = self.previous_span_end();
-        
+
         Ok(Some(Expr::ArrowFunction {
             params,
             body,
-            span: Span { start: start_span.start, end },
+            span: Span {
+                start: start_span.start,
+                end,
+            },
         }))
     }
 
@@ -1651,7 +2008,11 @@ impl<'a> Parser<'a> {
                             self.expect(TokenKind::RBrace)?; // }
                             JsxAttrValue::Expr(expr)
                         } else {
-                            let s = self.expect(TokenKind::String)?.literal.clone().ok_or("Expected string")?;
+                            let s = self
+                                .expect(TokenKind::String)?
+                                .literal
+                                .clone()
+                                .ok_or("Expected string")?;
                             JsxAttrValue::String(s)
                         };
                         props.push(JsxProp::Attr { name, value });
@@ -1662,7 +2023,12 @@ impl<'a> Parser<'a> {
                         });
                     }
                 }
-                _ => return Err(format!("Unexpected token in JSX props: {:?}", self.peek_kind())),
+                _ => {
+                    return Err(format!(
+                        "Unexpected token in JSX props: {:?}",
+                        self.peek_kind()
+                    ))
+                }
             }
         }
         self.advance(); // consume >
@@ -1745,9 +2111,16 @@ 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 = self
+                                .expect(TokenKind::Ident)?
+                                .literal
+                                .clone()
+                                .ok_or("Expected tag name")?;
                             if name.as_ref() != close_tag {
-                                return Err(format!("Mismatched JSX tag: expected </{}> got </{}>", close_tag, name));
+                                return Err(format!(
+                                    "Mismatched JSX tag: expected </{}> got </{}>",
+                                    close_tag, name
+                                ));
                             }
                             self.expect(TokenKind::Gt)?; // >
                             return Ok(children);
@@ -1827,7 +2200,10 @@ impl<'a> Parser<'a> {
                                     self.advance();
                                     self.advance();
                                     let end = self.previous_span_end();
-                                    return Ok(Expr::JsxFragment { children, span: Span { start, end } });
+                                    return Ok(Expr::JsxFragment {
+                                        children,
+                                        span: Span { start, end },
+                                    });
                                 }
                             }
                             return Err("Expected </> to close fragment".to_string());
@@ -1929,4 +2305,3 @@ impl ExprSpan for Expr {
         }
     }
 }
-