@tishlang/tish 1.6.0 → 1.8.0

package/Cargo.toml

@@ -28,6 +28,8 @@ members = [
     "crates/tish_fmt",
     "crates/tish_lint",
     "crates/tish_lsp",
+    "crates/tish_resolve",
+    "crates/tishlang_cargo_bindgen",
 ]
 resolver = "2"
 

package/README.md

@@ -4,6 +4,8 @@
 
 This npm package ships the **Tish CLI**. It includes platform-specific native binaries under `platform/`; **`npm install`** runs `postinstall`, which copies the correct binary to `bin/tish`. That file is what runs when you invoke `tish` — the CLI itself is native, not Node. Node **22+** is required for install scripts and tooling (e.g. semantic-release in this repo); the `tish` binary has no Node runtime dependency.
 
+Those prebuilt binaries are built with **`--features full`** (http, fs, process, regex, ws) so `tish run` and the bytecode VM match a full developer toolchain. For a minimal CLI, build `tishlang` from the repo with `--no-default-features` (see the workspace `justfile`).
+
 ## Install
 
 ```bash

package/crates/js_to_tish/src/error.rs

@@ -30,15 +30,9 @@ pub enum ConvertErrorKind {
     /// Semantic analysis error from OXC.
     Semantic(String),
     /// Unsupported construct (class, this, for-in, etc.).
-    Unsupported {
-        what: String,
-        hint: Option<String>,
-    },
+    Unsupported { what: String, hint: Option<String> },
     /// JS feature that cannot be expressed in Tish.
-    Incompatible {
-        what: String,
-        reason: String,
-    },
+    Incompatible { what: String, reason: String },
 }
 
 impl fmt::Display for ConvertErrorKind {

package/crates/js_to_tish/src/transform/expr.rs

@@ -5,8 +5,8 @@ use std::sync::Arc;
 use oxc::ast::ast::Expression as OxcExpr;
 use oxc::semantic::Semantic;
 use tishlang_ast::{
-    ArrayElement, ArrowBody, BinOp, CompoundOp, DestructPattern, Expr, Literal, LogicalAssignOp,
-    FunParam, MemberProp, ObjectProp, TypedParam,
+    ArrayElement, ArrowBody, BinOp, CompoundOp, DestructPattern, Expr, FunParam, Literal,
+    LogicalAssignOp, MemberProp, ObjectProp, TypedParam,
 };
 
 use crate::error::{ConvertError, ConvertErrorKind};
@@ -57,7 +57,12 @@ pub fn convert_expr(expr: &OxcExpr<'_>, ctx: &Ctx<'_>) -> Result<Expr, ConvertEr
             let left = Box::new(convert_expr(&b.left, ctx)?);
             let right = Box::new(convert_expr(&b.right, ctx)?);
             let op = convert_bin_op(&b.operator)?;
-            Ok(Expr::Binary { left, op, right, span })
+            Ok(Expr::Binary {
+                left,
+                op,
+                right,
+                span,
+            })
         }
         OxcExpr::UnaryExpression(u) => {
             let operand = Box::new(convert_expr(&u.argument, ctx)?);
@@ -84,9 +89,14 @@ pub fn convert_expr(expr: &OxcExpr<'_>, ctx: &Ctx<'_>) -> Result<Expr, ConvertEr
         }
         OxcExpr::StaticMemberExpression(s) => {
             let object = Box::new(convert_expr(&s.object, ctx)?);
+            let name = Arc::from(s.property.name.as_str());
+            let name_span = span_util::oxc_span_to_tish(ctx.1, &s.property);
             Ok(Expr::Member {
                 object,
-                prop: MemberProp::Name(Arc::from(s.property.name.as_str())),
+                prop: MemberProp::Name {
+                    name,
+                    span: name_span,
+                },
                 optional: s.optional,
                 span,
             })
@@ -112,10 +122,7 @@ pub fn convert_expr(expr: &OxcExpr<'_>, ctx: &Ctx<'_>) -> Result<Expr, ConvertEr
             })
         }
         OxcExpr::LogicalExpression(l) => {
-            if matches!(
-                l.operator,
-                oxc::ast::ast::LogicalOperator::Coalesce
-            ) {
+            if matches!(l.operator, oxc::ast::ast::LogicalOperator::Coalesce) {
                 Ok(Expr::NullishCoalesce {
                     left: Box::new(convert_expr(&l.left, ctx)?),
                     right: Box::new(convert_expr(&l.right, ctx)?),
@@ -155,12 +162,12 @@ pub fn convert_expr(expr: &OxcExpr<'_>, ctx: &Ctx<'_>) -> Result<Expr, ConvertEr
         OxcExpr::ArrowFunctionExpression(arrow) => {
             let params = convert_arrow_params(&arrow.params, ctx)?;
             let body = if arrow.expression {
-                let e = arrow
-                    .get_expression()
-                    .ok_or_else(|| ConvertError::new(ConvertErrorKind::Incompatible {
+                let e = arrow.get_expression().ok_or_else(|| {
+                    ConvertError::new(ConvertErrorKind::Incompatible {
                         what: "arrow expression body".into(),
                         reason: "expected expression".into(),
-                    }))?;
+                    })
+                })?;
                 ArrowBody::Expr(Box::new(convert_expr(e, ctx)?))
             } else {
                 let stmts = super::stmt::convert_statements(&arrow.body.statements, ctx.0, ctx.1)?;
@@ -169,11 +176,7 @@ pub fn convert_expr(expr: &OxcExpr<'_>, ctx: &Ctx<'_>) -> Result<Expr, ConvertEr
                     span: span_util::oxc_span_to_tish(ctx.1, &*arrow.body),
                 }))
             };
-            Ok(Expr::ArrowFunction {
-                params,
-                body,
-                span,
-            })
+            Ok(Expr::ArrowFunction { params, body, span })
         }
         OxcExpr::AwaitExpression(a) => Ok(Expr::Await {
             operand: Box::new(convert_expr(&a.argument, ctx)?),
@@ -226,11 +229,7 @@ pub fn convert_expr(expr: &OxcExpr<'_>, ctx: &Ctx<'_>) -> Result<Expr, ConvertEr
                     }))
                 }
             };
-            Ok(Expr::ArrowFunction {
-                params,
-                body,
-                span,
-            })
+            Ok(Expr::ArrowFunction { params, body, span })
         }
         _ => Err(ConvertError::new(ConvertErrorKind::Unsupported {
             what: format!("expression: {:?}", std::mem::discriminant(expr)),
@@ -247,9 +246,14 @@ fn convert_chain_element(
     match ce {
         oxc::ast::ast::ChainElement::StaticMemberExpression(m) => {
             let object = Box::new(convert_expr(&m.object, ctx)?);
+            let name = Arc::from(m.property.name.as_str());
+            let name_span = span_util::oxc_span_to_tish(ctx.1, &m.property);
             Ok(Expr::Member {
                 object,
-                prop: MemberProp::Name(Arc::from(m.property.name.as_str())),
+                prop: MemberProp::Name {
+                    name,
+                    span: name_span,
+                },
                 optional: m.optional,
                 span,
             })
@@ -285,7 +289,10 @@ fn convert_call_arg(
 ) -> Result<tishlang_ast::CallArg, ConvertError> {
     if arg.is_spread() {
         if let oxc::ast::ast::Argument::SpreadElement(s) = arg {
-            Ok(tishlang_ast::CallArg::Spread(convert_expr(&s.argument, ctx)?))
+            Ok(tishlang_ast::CallArg::Spread(convert_expr(
+                &s.argument,
+                ctx,
+            )?))
         } else {
             unreachable!()
         }
@@ -307,10 +314,12 @@ fn convert_array_element(
         oxc::ast::ast::ArrayExpressionElement::SpreadElement(s) => {
             Ok(ArrayElement::Spread(convert_expr(&s.argument, ctx)?))
         }
-        oxc::ast::ast::ArrayExpressionElement::Elision(_) => Ok(ArrayElement::Expr(Expr::Literal {
-            value: Literal::Null,
-            span: span_util::stub_span(),
-        })),
+        oxc::ast::ast::ArrayExpressionElement::Elision(_) => {
+            Ok(ArrayElement::Expr(Expr::Literal {
+                value: Literal::Null,
+                span: span_util::stub_span(),
+            }))
+        }
         _ => {
             if let Some(e) = el.as_expression() {
                 Ok(ArrayElement::Expr(convert_expr(e, ctx)?))
@@ -358,77 +367,59 @@ fn convert_assignment(
         let name = id.name.as_str();
         let value = Box::new(convert_expr(right, ctx)?);
         return match &a.operator {
-                oxc::ast::ast::AssignmentOperator::Assign => {
-                    Ok(Expr::Assign {
-                        name: Arc::from(name),
-                        value,
-                        span,
-                    })
-                }
-                oxc::ast::ast::AssignmentOperator::Addition => {
-                    Ok(Expr::CompoundAssign {
-                        name: Arc::from(name),
-                        op: CompoundOp::Add,
-                        value,
-                        span,
-                    })
-                }
-                oxc::ast::ast::AssignmentOperator::Subtraction => {
-                    Ok(Expr::CompoundAssign {
-                        name: Arc::from(name),
-                        op: CompoundOp::Sub,
-                        value,
-                        span,
-                    })
-                }
-                oxc::ast::ast::AssignmentOperator::Multiplication => {
-                    Ok(Expr::CompoundAssign {
-                        name: Arc::from(name),
-                        op: CompoundOp::Mul,
-                        value,
-                        span,
-                    })
-                }
-                oxc::ast::ast::AssignmentOperator::Division => {
-                    Ok(Expr::CompoundAssign {
-                        name: Arc::from(name),
-                        op: CompoundOp::Div,
-                        value,
-                        span,
-                    })
-                }
-                oxc::ast::ast::AssignmentOperator::Remainder => {
-                    Ok(Expr::CompoundAssign {
-                        name: Arc::from(name),
-                        op: CompoundOp::Mod,
-                        value,
-                        span,
-                    })
-                }
-                oxc::ast::ast::AssignmentOperator::LogicalAnd => {
-                    Ok(Expr::LogicalAssign {
-                        name: Arc::from(name),
-                        op: LogicalAssignOp::AndAnd,
-                        value,
-                        span,
-                    })
-                }
-                oxc::ast::ast::AssignmentOperator::LogicalOr => {
-                    Ok(Expr::LogicalAssign {
-                        name: Arc::from(name),
-                        op: LogicalAssignOp::OrOr,
-                        value,
-                        span,
-                    })
-                }
-                oxc::ast::ast::AssignmentOperator::LogicalNullish => {
-                    Ok(Expr::LogicalAssign {
-                        name: Arc::from(name),
-                        op: LogicalAssignOp::Nullish,
-                        value,
-                        span,
-                    })
-                }
+            oxc::ast::ast::AssignmentOperator::Assign => Ok(Expr::Assign {
+                name: Arc::from(name),
+                value,
+                span,
+            }),
+            oxc::ast::ast::AssignmentOperator::Addition => Ok(Expr::CompoundAssign {
+                name: Arc::from(name),
+                op: CompoundOp::Add,
+                value,
+                span,
+            }),
+            oxc::ast::ast::AssignmentOperator::Subtraction => Ok(Expr::CompoundAssign {
+                name: Arc::from(name),
+                op: CompoundOp::Sub,
+                value,
+                span,
+            }),
+            oxc::ast::ast::AssignmentOperator::Multiplication => Ok(Expr::CompoundAssign {
+                name: Arc::from(name),
+                op: CompoundOp::Mul,
+                value,
+                span,
+            }),
+            oxc::ast::ast::AssignmentOperator::Division => Ok(Expr::CompoundAssign {
+                name: Arc::from(name),
+                op: CompoundOp::Div,
+                value,
+                span,
+            }),
+            oxc::ast::ast::AssignmentOperator::Remainder => Ok(Expr::CompoundAssign {
+                name: Arc::from(name),
+                op: CompoundOp::Mod,
+                value,
+                span,
+            }),
+            oxc::ast::ast::AssignmentOperator::LogicalAnd => Ok(Expr::LogicalAssign {
+                name: Arc::from(name),
+                op: LogicalAssignOp::AndAnd,
+                value,
+                span,
+            }),
+            oxc::ast::ast::AssignmentOperator::LogicalOr => Ok(Expr::LogicalAssign {
+                name: Arc::from(name),
+                op: LogicalAssignOp::OrOr,
+                value,
+                span,
+            }),
+            oxc::ast::ast::AssignmentOperator::LogicalNullish => Ok(Expr::LogicalAssign {
+                name: Arc::from(name),
+                op: LogicalAssignOp::Nullish,
+                value,
+                span,
+            }),
             _ => Err(ConvertError::new(ConvertErrorKind::Unsupported {
                 what: "assignment operator".into(),
                 hint: None,
@@ -458,24 +449,14 @@ fn convert_update_expr(
         }
     };
     Ok(match (u.operator, u.prefix) {
-        (oxc::ast::ast::UpdateOperator::Increment, true) => {
-            Expr::PrefixInc { name, span }
-        }
-        (oxc::ast::ast::UpdateOperator::Increment, false) => {
-            Expr::PostfixInc { name, span }
-        }
-        (oxc::ast::ast::UpdateOperator::Decrement, true) => {
-            Expr::PrefixDec { name, span }
-        }
-        (oxc::ast::ast::UpdateOperator::Decrement, false) => {
-            Expr::PostfixDec { name, span }
-        }
+        (oxc::ast::ast::UpdateOperator::Increment, true) => Expr::PrefixInc { name, span },
+        (oxc::ast::ast::UpdateOperator::Increment, false) => Expr::PostfixInc { name, span },
+        (oxc::ast::ast::UpdateOperator::Decrement, true) => Expr::PrefixDec { name, span },
+        (oxc::ast::ast::UpdateOperator::Decrement, false) => Expr::PostfixDec { name, span },
     })
 }
 
-fn convert_bin_op(
-    op: &oxc::ast::ast::BinaryOperator,
-) -> Result<BinOp, ConvertError> {
+fn convert_bin_op(op: &oxc::ast::ast::BinaryOperator) -> Result<BinOp, ConvertError> {
     Ok(match op {
         oxc::ast::ast::BinaryOperator::Equality => BinOp::Eq,
         oxc::ast::ast::BinaryOperator::Inequality => BinOp::Ne,
@@ -533,8 +514,11 @@ pub fn convert_params(
     for (i, p) in params.items.iter().enumerate() {
         if params.rest.is_some() && i == params.items.len() - 1 {
             if let Some(rest) = &params.rest {
-                let rest_name = match &rest.rest.argument {
-                    oxc::ast::ast::BindingPattern::BindingIdentifier(b) => b.name.as_str(),
+                let (rest_name, rest_name_span) = match &rest.rest.argument {
+                    oxc::ast::ast::BindingPattern::BindingIdentifier(b) => (
+                        b.name.as_str(),
+                        crate::span_util::oxc_span_to_tish(ctx.1, b.as_ref()),
+                    ),
                     _ => {
                         return Err(ConvertError::new(ConvertErrorKind::Unsupported {
                             what: "rest param with non-identifier".into(),
@@ -544,6 +528,7 @@ pub fn convert_params(
                 };
                 rest_param = Some(TypedParam {
                     name: Arc::from(rest_name),
+                    name_span: rest_name_span,
                     type_ann: None,
                     default: None,
                 });
@@ -553,31 +538,36 @@ pub fn convert_params(
         // params.items contains FormalParameter structs (not enum)
         let fp = p;
         {
-            let name = match &fp.pattern {
-                    oxc::ast::ast::BindingPattern::BindingIdentifier(b) => b.name.as_str(),
-                    _ => {
-                        return Err(ConvertError::new(ConvertErrorKind::Unsupported {
-                            what: "destructuring in params".into(),
-                            hint: None,
-                        }))
-                    }
-                };
-                let default = fp
-                    .initializer
-                    .as_ref()
-                    .map(|e| convert_expr(e, ctx))
-                    .transpose()?;
-                typed_params.push(FunParam::Simple(TypedParam {
-                    name: Arc::from(name),
-                    type_ann: None,
-                    default,
-                }));
+            let (name, name_span) = match &fp.pattern {
+                oxc::ast::ast::BindingPattern::BindingIdentifier(b) => {
+                    (b.name.as_str(), crate::span_util::oxc_span_to_tish(ctx.1, b.as_ref()))
+                }
+                _ => {
+                    return Err(ConvertError::new(ConvertErrorKind::Unsupported {
+                        what: "destructuring in params".into(),
+                        hint: None,
+                    }))
+                }
+            };
+            let default = fp
+                .initializer
+                .as_ref()
+                .map(|e| convert_expr(e, ctx))
+                .transpose()?;
+            typed_params.push(FunParam::Simple(TypedParam {
+                name: Arc::from(name),
+                name_span,
+                type_ann: None,
+                default,
+            }));
         }
     }
     if rest_param.is_none() {
         if let Some(rest) = &params.rest {
-            let rest_name = match &rest.rest.argument {
-                oxc::ast::ast::BindingPattern::BindingIdentifier(b) => b.name.as_str(),
+            let (rest_name, rest_name_span) = match &rest.rest.argument {
+                oxc::ast::ast::BindingPattern::BindingIdentifier(b) => {
+                    (b.name.as_str(), crate::span_util::oxc_span_to_tish(ctx.1, b.as_ref()))
+                }
                 _ => {
                     return Err(ConvertError::new(ConvertErrorKind::Unsupported {
                         what: "rest param with non-identifier".into(),
@@ -587,6 +577,7 @@ pub fn convert_params(
             };
             rest_param = Some(TypedParam {
                 name: Arc::from(rest_name),
+                name_span: rest_name_span,
                 type_ann: None,
                 default: None,
             });

package/crates/js_to_tish/src/transform/stmt.rs

@@ -4,7 +4,7 @@ use std::sync::Arc;
 
 use oxc::ast::ast::Statement as OxcStmt;
 use oxc::semantic::Semantic;
-use tishlang_ast::{Statement, Span};
+use tishlang_ast::{Span, Statement};
 
 use super::expr;
 use crate::error::{ConvertError, ConvertErrorKind};
@@ -19,9 +19,7 @@ pub fn convert_statements(
     source: &str,
 ) -> Result<Vec<Statement>, ConvertError> {
     let ctx = (semantic, source);
-    body.iter()
-        .map(|s| convert_statement(s, &ctx))
-        .collect()
+    body.iter().map(|s| convert_statement(s, &ctx)).collect()
 }
 
 fn convert_statement(stmt: &OxcStmt<'_>, ctx: &Ctx<'_>) -> Result<Statement, ConvertError> {
@@ -29,10 +27,7 @@ fn convert_statement(stmt: &OxcStmt<'_>, ctx: &Ctx<'_>) -> Result<Statement, Con
     match stmt {
         OxcStmt::BlockStatement(b) => {
             let statements = convert_statements(&b.body, ctx.0, ctx.1)?;
-            Ok(Statement::Block {
-                statements,
-                span,
-            })
+            Ok(Statement::Block { statements, span })
         }
         OxcStmt::VariableDeclaration(v) => convert_var_decl(v, ctx, span),
         OxcStmt::ExpressionStatement(e) => {
@@ -146,12 +141,18 @@ fn convert_var_decl(
     if v.declarations.len() == 1 {
         let d = &v.declarations[0];
         let id = &d.id;
-        let init = d.init.as_ref().map(|i| expr::convert_expr(i, ctx)).transpose()?;
+        let init = d
+            .init
+            .as_ref()
+            .map(|i| expr::convert_expr(i, ctx))
+            .transpose()?;
         match id {
             oxc::ast::ast::BindingPattern::BindingIdentifier(b) => {
                 let name: Arc<str> = Arc::from(b.name.as_str());
+                let name_span = span_util::oxc_span_to_tish(ctx.1, b.as_ref());
                 Ok(Statement::VarDecl {
                     name,
+                    name_span,
                     mutable,
                     type_ann: None,
                     init,
@@ -241,12 +242,14 @@ fn convert_for_of_statement(
     ctx: &Ctx<'_>,
     span: Span,
 ) -> Result<Statement, ConvertError> {
-    let name = match &f.left {
+    let (name, name_span) = match &f.left {
         oxc::ast::ast::ForStatementLeft::VariableDeclaration(v) => {
             if v.declarations.len() == 1 {
                 let d = &v.declarations[0];
                 match &d.id {
-                    oxc::ast::ast::BindingPattern::BindingIdentifier(b) => b.name.as_str(),
+                    oxc::ast::ast::BindingPattern::BindingIdentifier(b) => {
+                        (b.name.as_str(), span_util::oxc_span_to_tish(ctx.1, b.as_ref()))
+                    }
                     _ => {
                         return Err(ConvertError::new(ConvertErrorKind::Incompatible {
                             what: "for-of with destructuring".into(),
@@ -272,6 +275,7 @@ fn convert_for_of_statement(
     let body = Box::new(convert_statement(&f.body, ctx)?);
     Ok(Statement::ForOf {
         name: Arc::from(name),
+        name_span,
         iterable,
         body,
         span,
@@ -312,23 +316,30 @@ fn convert_try_statement(
         statements: body_stmts,
         span: span_util::oxc_span_to_tish(ctx.1, &*t.block),
     });
-    let (catch_param, catch_body) = match &t.handler {
+    let (catch_param, catch_param_span, catch_body) = match &t.handler {
         Some(h) => {
-            let param = h.param.as_ref().and_then(|cp: &oxc::ast::ast::CatchParameter<'_>| {
-                if let oxc::ast::ast::BindingPattern::BindingIdentifier(b) = &cp.pattern {
-                    Some(Arc::from(b.name.as_str()))
-                } else {
-                    None
-                }
-            });
+            let (param, pspan) = h
+                .param
+                .as_ref()
+                .and_then(|cp: &oxc::ast::ast::CatchParameter<'_>| {
+                    if let oxc::ast::ast::BindingPattern::BindingIdentifier(b) = &cp.pattern {
+                        Some((
+                            Arc::from(b.name.as_str()),
+                            span_util::oxc_span_to_tish(ctx.1, b.as_ref()),
+                        ))
+                    } else {
+                        None
+                    }
+                })
+                .map_or((None, None), |(n, s)| (Some(n), Some(s)));
             let catch_stmts = convert_statements(&h.body.body, ctx.0, ctx.1)?;
             let cb = Box::new(Statement::Block {
                 statements: catch_stmts,
                 span: span_util::oxc_span_to_tish(ctx.1, &*h.body),
             });
-            (param, Some(cb))
+            (param, pspan, Some(cb))
         }
-        None => (None, None),
+        None => (None, None, None),
     };
     let finally_body = t
         .finalizer
@@ -344,6 +355,7 @@ fn convert_try_statement(
     Ok(Statement::Try {
         body,
         catch_param,
+        catch_param_span,
         catch_body,
         finally_body,
         span,
@@ -361,6 +373,11 @@ fn convert_function_decl(
         .as_ref()
         .map(|id| Arc::from(id.name.as_str()))
         .unwrap_or_else(|| Arc::from(""));
+    let name_span = f
+        .id
+        .as_ref()
+        .map(|id| span_util::oxc_span_to_tish(ctx.1, id))
+        .unwrap_or_else(span_util::stub_span);
     let (params, rest_param) = expr::convert_params(&f.params, ctx)?;
     let body = match &f.body {
         Some(fb) => {
@@ -380,6 +397,7 @@ fn convert_function_decl(
     Ok(Statement::FunDecl {
         async_,
         name,
+        name_span,
         params,
         rest_param,
         return_type: None,
@@ -390,7 +408,7 @@ fn convert_function_decl(
 
 fn convert_import(
     i: &oxc::ast::ast::ImportDeclaration<'_>,
-    _ctx: &Ctx<'_>,
+    ctx: &Ctx<'_>,
     span: Span,
 ) -> Result<Statement, ConvertError> {
     let from: Arc<str> = Arc::from(i.source.value.as_str());
@@ -401,25 +419,35 @@ fn convert_import(
                 oxc::ast::ast::ImportDeclarationSpecifier::ImportSpecifier(is) => {
                     let imported_name = is.imported.name().as_str();
                     let local_name = is.local.name.as_str();
-                    let alias = if imported_name == local_name {
-                        None
+                    let name_span = crate::span_util::oxc_span_to_tish(ctx.1, &is.imported);
+                    let (alias, alias_span) = if imported_name == local_name {
+                        (None, None)
                     } else {
-                        Some(Arc::from(local_name))
+                        (
+                            Some(Arc::from(local_name)),
+                            Some(crate::span_util::oxc_span_to_tish(ctx.1, &is.local)),
+                        )
                     };
                     specifiers.push(tishlang_ast::ImportSpecifier::Named {
                         name: Arc::from(imported_name),
+                        name_span,
                         alias,
+                        alias_span,
                     });
                 }
                 oxc::ast::ast::ImportDeclarationSpecifier::ImportDefaultSpecifier(ds) => {
-                    specifiers.push(tishlang_ast::ImportSpecifier::Default(Arc::from(
-                        ds.local.name.as_str(),
-                    )));
+                    let name_span = crate::span_util::oxc_span_to_tish(ctx.1, &ds.local);
+                    specifiers.push(tishlang_ast::ImportSpecifier::Default {
+                        name: Arc::from(ds.local.name.as_str()),
+                        name_span,
+                    });
                 }
                 oxc::ast::ast::ImportDeclarationSpecifier::ImportNamespaceSpecifier(ns) => {
-                    specifiers.push(tishlang_ast::ImportSpecifier::Namespace(Arc::from(
-                        ns.local.name.as_str(),
-                    )));
+                    let name_span = crate::span_util::oxc_span_to_tish(ctx.1, &ns.local);
+                    specifiers.push(tishlang_ast::ImportSpecifier::Namespace {
+                        name: Arc::from(ns.local.name.as_str()),
+                        name_span,
+                    });
                 }
             }
         }
@@ -439,7 +467,9 @@ fn convert_export_default(
     let declaration = if let Some(expr) = e.declaration.as_expression() {
         let expr = expr::convert_expr(expr, ctx)?;
         tishlang_ast::ExportDeclaration::Default(expr)
-    } else if let oxc::ast::ast::ExportDefaultDeclarationKind::FunctionDeclaration(f) = &e.declaration {
+    } else if let oxc::ast::ast::ExportDefaultDeclarationKind::FunctionDeclaration(f) =
+        &e.declaration
+    {
         let stmt = convert_function_decl(f.as_ref(), ctx, span_util::stub_span())?;
         tishlang_ast::ExportDeclaration::Named(Box::new(stmt))
     } else {