Getting line numbers from Span

[liangchunn]

Hello,

I'm writing a program uses oxc_ast::Visit::enter_node to visit the AST, and filters out nodes that I want and gets its respective Spans. How do I correlate the Spans back to the source code's line number?

I've tried using oxc_codegen, but the returning SourceMap doesn't have any functions that accept Span.start and/or Span.ends.

Minimal example:

Note: Span is stored inside ASTParse.parsed_args

// main.rs
use oxc_allocator::Allocator;
use oxc_ast::{
    ast::{Argument, Expression},
    AstKind, Visit,
};
use oxc_parser::Parser;
use oxc_span::{SourceType, Span};
use std::fs::read_to_string;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let path = "./test2.tsx";
    let source_text = read_to_string(&path)?;

    let allocator = Allocator::default();
    let source_type = SourceType::from_path(&path).unwrap();
    let ret = Parser::new(&allocator, &source_text, source_type).parse();

    for error in ret.errors {
        let error = error.with_source_code(source_text.clone());
        println!("error: {error:?}")
    }

    let program = ret.program;

    let mut ast_pass = ASTPass::default();
    ast_pass.visit_program(&program);
    println!("{ast_pass:?}");

    Ok(())
}

#[derive(Debug, Default)]
struct ASTPass {
    parsed_args: Vec<(String, Span)>,
}

impl<'a> Visit<'a> for ASTPass {
    fn enter_node(&mut self, kind: AstKind<'a>) {
        match kind {
            AstKind::CallExpression(c) => {
                if let Expression::Identifier(ident) = &c.callee {
                    if ident.name == "useOneArg" {
                        let first_arg = c.arguments.first();
                        match first_arg {
                            Some(Argument::Expression(Expression::StringLiteral(lit))) => {
                                self.parsed_args.push((lit.value.to_string(), lit.span));
                            }
                            Some(arg) => {
                                panic!("invalid arguments for useOneArg: must be Argument::Expression(Expression::StringLiteral(_)), but got {:?}", arg)
                            }
                            None => panic!("first arg is empty"),
                        }
                    }
                }
            }
            _ => {}
        }
    }
}

// test2.tsx
export default function Test() {
  const arg1 = useOneArg("abcdefg");
  const arg2 = useOneArg("hijklmnop");
}

The program outputs:

ASTPass { parsed_args: [("abcdefg", Span { start: 58, end: 67 }), ("hijklmnop", Span { start: 95, end: 106 })] }

[alyalin]

Hi, my approach to this problem

fn get_line_number(source_text: &str, offset: usize) -> usize {
    source_text[..offset].lines().count()
}

And use this like this

fn visit_call_expression(&mut self, it: &mut CallExpression<'a>) {
  let line = get_line_number(&self.source_text, it.span.start.try_into().unwrap());
}

[overlookmotel]

Please also see #7764 - something that helps with this was merged today.