View quotes around parsed Str value in AST

[msrcodes]

Hi there 👋

Question

I'm currently writing a JavaScript code linter using SWC. I am using a parser to parse .js files into a module via an AST, and then using swc:_ecmascript::visit::Visit to visit relevant parts of the AST, applying a set of swc_ecma_lints::rule::Rule's on each file.

Currently, I am working on an implementation of the quotes rule from ESLint, however I cannot seem to find a way to access the quotes within the AST. Any Str value only contains the contents of the string, and not the quotes surrounding it.

How can I access the quotes surrounding a Str? Thanks in advance!

Relevant Code

rules/quotes.rs

use swc_ecma_lints::rule::Rule;
use swc_ecmascript::{
    ast::{Expr, Module, Str},
    visit::{noop_visit_type, Visit, VisitWith},
};

use super::visitor_rule;

pub fn quotes() -> Box<dyn Rule> {
    visitor_rule(Quotes::default())
}

#[derive(Debug, Default)]
struct Quotes;

impl Visit for Quotes {
    noop_visit_type!();

    fn visit_str(&mut self, str: &Str) {
        println!("{}", str.value.to_string());

        // TODO: does this have the correct type of quotes?
        // foo()

        str.visit_children_with(self);
    }

    fn visit_expr(&mut self, expr: &Expr) {
        // println!("{:?}", expr);

        expr.visit_children_with(self);
    }

    fn visit_module(&mut self, program: &Module) {
        // println!("{:?}", program.body);
        program.visit_children_with(self);
    }
}

rules/mod.rs

use std::path::Path;

mod rules;

use swc_common::{
    self,
    errors::{ColorConfig, Handler},
    input::SourceFileInput,
    sync::Lrc,
    SourceMap,
};

use swc_ecmascript::parser::{lexer::Lexer, Parser};
use swc_ecmascript::{ast::Module, parser::Syntax};

use rules::get_all_rules;

fn parse_module_file(path: &Path) -> Module {
    let cm: Lrc<SourceMap> = Default::default();
    let handler = Handler::with_tty_emitter(ColorConfig::Auto, true, false, Some(cm.clone()));

    // Real usage
    let fm = cm.load_file(path).expect("failed to load test.js");

    let lexer = Lexer::new(
        // We want to parse ecmascript
        Syntax::Es(Default::default()),
        // EsVersion defaults to es5
        Default::default(),
        SourceFileInput::from(&*fm),
        None,
    );

    let mut parser = Parser::new_from(lexer);

    for e in parser.take_errors() {
        e.into_diagnostic(&handler).emit();
    }

    parser
        .parse_module()
        .map_err(|e| {
            // Unrecoverable fatal error occurred
            e.into_diagnostic(&handler).emit()
        })
        .expect("failed to parser module")
}

pub fn lint_file(path: &Path) {
    // parse file into AST
    let module = parse_module_file(path);

    // apply all rules
    for mut rule in get_all_rules() {
        rule.lint_module(&module);
    }
}

rules/rules.rs

use swc_ecma_lints::rule::Rule;
use swc_ecmascript::{
    ast::{Module, Script},
    visit::{Visit, VisitWith},
};

mod quotes;

use std::fmt::Debug;

#[derive(Debug)]
struct VisitorRule<V>(V)
where
    V: Send + Sync + Visit;

impl<V> Rule for VisitorRule<V>
where
    V: Send + Sync + Visit + Debug,
{
    fn lint_module(&mut self, program: &Module) {
        program.visit_with(&mut self.0);
    }

    fn lint_script(&mut self, program: &Script) {
        program.visit_with(&mut self.0);
    }
}

pub(crate) fn visitor_rule<V>(v: V) -> Box<dyn Rule>
where
    V: 'static + Send + Sync + Visit + Default + Debug,
{
    Box::new(VisitorRule(v))
}

pub fn get_all_rules() -> Vec<Box<dyn Rule>> {
    vec![quotes::quotes()]
}

[kdy1]

I think you should use SourceMap

[msrcodes]

as in the following?

#[derive(Debug)]
struct VisitorRule<V>(V, Lrc<SourceFile>) // change happened here to add Lrc<SourceFile>
where
    V: Send + Sync + Visit;

impl<V> Rule for VisitorRule<V>
where
    V: Send + Sync + Visit + Debug,
{
    fn lint_module(&mut self, program: &Module) {
        program.visit_with(&mut self.0);
    }

    fn lint_script(&mut self, program: &Script) {
        program.visit_with(&mut self.0);
    }
}

Apologies, I still don't understand how this gives visit_with access to the SourceFile.

[kdy1]

No, if you are implementing Rule on it, you should store it in V instead of VisitorRule<V>

[msrcodes]

Would you be able to describe using code? I don't understand how to store Lrc<SourceFile> within V.

[ShayRubach]

I think what @kdy1 meant is that you add a member field of type Lrc<SourceFile> inside your visitor implementation struct. In your case, it seems like it is the struct Quotes, so it will look something like:

struct Quotes {
    sf: Lrc<SourceFile>
}

Theb you'll have access to it during the visit implementations, i.e:

impl Visit for Quotes {
    noop_visit_type!();

    fn visit_str(&mut self, str: &Str) {
        str.visit_children_with(self);
        // --> now you have access to self.fs
    }
...
}

I hope I got it right, hehe.

[msrcodes]

Thank you both for your help. This and the work done recently on the Quotes rule implementation directly in swc_emca_lints has helped a tonne. Cheers!