refactor: use deno_ast

Author: dsherret

Cargo.toml

@@ -25,13 +25,11 @@ wasm = ["serde_json", "dprint-core/wasm"]
 tracing = ["dprint-core/tracing"]
 
 [dependencies]
+deno_ast = { version = "0.4.0", features = ["view"] }
 dprint-core = { version = "0.46.4", features = ["formatting"] }
 rustc-hash = "1.1.0"
 serde = { version = "1.0.118", features = ["derive"] }
 serde_json = { version = "1.0", optional = true }
-swc_ast_view = { version = "0.39.0", package = "dprint-swc-ecma-ast-view" }
-swc_common = "0.13.4"
-swc_ecmascript = { version = "0.73.0", features = ["parser"] }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 parking_lot_core = "=0.8.0" # https://github.com/Amanieu/parking_lot/issues/269 todo: submit pr to parking_lot

src/format_text.rs

@@ -1,10 +1,11 @@
 use std::path::Path;
 
+use deno_ast::ParsedSource;
 use dprint_core::configuration::resolve_new_line_kind;
 use dprint_core::formatting::*;
 use dprint_core::types::ErrBox;
-use swc_common::comments::SingleThreadedCommentsMapInner;
-use swc_ecmascript::parser::token::TokenAndSpan;
+
+use crate::swc::ensure_no_specific_syntax_errors;
 
 use super::configuration::Configuration;
 use super::parsing::parse;
@@ -39,75 +40,40 @@ use super::swc::parse_swc_ast;
 /// ```
 pub fn format_text(file_path: &Path, file_text: &str, config: &Configuration) -> Result<String, ErrBox> {
   if super::utils::file_text_has_ignore_comment(file_text, &config.ignore_file_comment_text) {
-    return Ok(String::from(file_text));
+    Ok(String::from(file_text))
+  } else {
+    let parsed_source = parse_swc_ast(file_path, file_text)?;
+    inner_format(&parsed_source, config)
   }
-
-  let parsed_source_file = parse_swc_ast(file_path, file_text)?;
-  Ok(dprint_core::formatting::format(
-    || {
-      let print_items = parse(
-        &SourceFileInfo {
-          is_jsx: parsed_source_file.is_jsx,
-          module: &parsed_source_file.module,
-          info: &parsed_source_file.info,
-          tokens: &parsed_source_file.tokens,
-          leading_comments: &parsed_source_file.leading_comments,
-          trailing_comments: &parsed_source_file.trailing_comments,
-        },
-        config,
-      );
-      // println!("{}", print_items.get_as_text());
-      print_items
-    },
-    config_to_print_options(file_text, config),
-  ))
 }
 
-#[derive(Clone)]
-pub struct SourceFileInfo<'a> {
-  pub is_jsx: bool,
-  pub module: &'a swc_ecmascript::ast::Module,
-  pub info: &'a dyn swc_ast_view::SourceFile,
-  pub tokens: &'a [TokenAndSpan],
-  pub leading_comments: &'a SingleThreadedCommentsMapInner,
-  pub trailing_comments: &'a SingleThreadedCommentsMapInner,
+/// Formats an already parsed source. This is useful as a performance optimization.
+pub fn format_parsed_source(source: &ParsedSource, config: &Configuration) -> Result<String, ErrBox> {
+  if super::utils::file_text_has_ignore_comment(source.source().text_str(), &config.ignore_file_comment_text) {
+    Ok(source.source().text_str().to_string())
+  } else {
+    inner_format(source, config)
+  }
 }
 
-/// Formats the already parsed file. This is useful as a performance optimization.
-pub fn format_parsed_file(info: &SourceFileInfo<'_>, config: &Configuration) -> String {
-  if super::utils::file_text_has_ignore_comment(info.info.text(), &config.ignore_file_comment_text) {
-    return info.info.text().to_string();
-  }
+fn inner_format(parsed_source: &ParsedSource, config: &Configuration) -> Result<String, ErrBox> {
+  ensure_no_specific_syntax_errors(parsed_source)?;
 
-  dprint_core::formatting::format(
+  Ok(dprint_core::formatting::format(
     || {
-      let print_items = parse(&info, config);
+      let print_items = parse(&parsed_source, config);
       // println!("{}", print_items.get_as_text());
       print_items
     },
-    config_to_print_options(info.info.text(), config),
-  )
+    config_to_print_options(parsed_source.source().text_str(), config),
+  ))
 }
 
 #[cfg(feature = "tracing")]
 pub fn trace_file(file_path: &Path, file_text: &str, config: &Configuration) -> dprint_core::formatting::TracingResult {
-  let parsed_source_file = parse_swc_ast(file_path, file_text).expect("Expected to parse to SWC AST.");
-  dprint_core::formatting::trace_printing(
-    || {
-      parse(
-        &SourceFileInfo {
-          is_jsx: parsed_source_file.is_jsx,
-          info: &parsed_source_file.info,
-          module: &parsed_source_file.module,
-          tokens: &parsed_source_file.tokens,
-          leading_comments: &parsed_source_file.leading_comments,
-          trailing_comments: &parsed_source_file.trailing_comments,
-        },
-        config,
-      )
-    },
-    config_to_print_options(file_text, config),
-  )
+  let parsed_source = parse_swc_ast(file_path, file_text).unwrap();
+  ensure_no_specific_syntax_errors(parsed_source).unwrap();
+  dprint_core::formatting::trace_printing(|| parse(&parsed_source, config), config_to_print_options(file_text, config))
 }
 
 fn config_to_print_options(file_text: &str, config: &Configuration) -> PrintOptions {
@@ -118,3 +84,53 @@ fn config_to_print_options(file_text: &str, config: &Configuration) -> PrintOpti
     new_line_text: resolve_new_line_kind(file_text, config.new_line_kind),
   }
 }
+
+#[cfg(test)]
+mod test {
+  use std::path::PathBuf;
+
+  use crate::configuration::ConfigurationBuilder;
+
+  use super::*;
+
+  #[test]
+  fn it_should_error_for_no_equals_sign_in_var_decl() {
+    run_diagnostic_test(
+      "./test.ts",
+      "const Methods {\nf: (x, y) => x + y,\n};",
+      concat!("Line 1, column 15: Expected a semicolon\n", "\n", "  const Methods {\n", "                ~"),
+    );
+  }
+
+  #[test]
+  fn it_should_error_when_var_stmts_sep_by_comma() {
+    run_diagnostic_test(
+      "./test.ts",
+      "let a = 0, let b = 1;",
+      concat!(
+        "Line 1, column 16: Expected a semicolon\n",
+        "\n",
+        "  let a = 0, let b = 1;\n",
+        "                 ~"
+      ),
+    );
+  }
+
+  #[test]
+  fn it_should_error_for_exected_expr_issue_121() {
+    run_diagnostic_test(
+      "./test.ts",
+      "type T =\n  | unknown\n  { } & unknown;",
+      concat!("Line 3, column 7: Expression expected\n", "\n", "    { } & unknown;\n", "        ~"),
+    );
+  }
+
+  fn run_diagnostic_test(file_path: &str, text: &str, expected: &str) {
+    let file_path = PathBuf::from(file_path);
+    let parsed_source = crate::swc::parse_swc_ast(&file_path, text).unwrap();
+    let config = ConfigurationBuilder::new().build();
+    // ensure it happens for both of these methods
+    assert_eq!(format_text(&file_path, text, &config).err().unwrap().to_string(), expected);
+    assert_eq!(format_parsed_source(&parsed_source, &config).err().unwrap().to_string(), expected);
+  }
+}

src/lib.rs

@@ -6,9 +6,8 @@ mod parsing;
 mod swc;
 mod utils;
 
-pub use format_text::format_parsed_file;
+pub use format_text::format_parsed_source;
 pub use format_text::format_text;
-pub use format_text::SourceFileInfo;
 
 #[cfg(feature = "tracing")]
 pub use format_text::trace_file;

src/parsing/comments.rs

@@ -1,18 +1,18 @@
-use swc_ast_view::*;
-use swc_common::BytePos;
-use swc_ecmascript::parser::token::Token;
-use swc_ecmascript::parser::token::TokenAndSpan;
+use deno_ast::swc::common::BytePos;
+use deno_ast::swc::parser::token::Token;
+use deno_ast::swc::parser::token::TokenAndSpan;
+use deno_ast::view::*;
 
 pub struct CommentTracker<'a> {
-  module: &'a Module<'a>,
+  program: &'a Program<'a>,
   tokens: &'a [TokenAndSpan],
   token_index: usize,
 }
 
 impl<'a> CommentTracker<'a> {
-  pub fn new(module: &'a Module<'a>, tokens: &'a [TokenAndSpan]) -> CommentTracker<'a> {
+  pub fn new(program: &'a Program<'a>, tokens: &'a [TokenAndSpan]) -> CommentTracker<'a> {
     CommentTracker {
-      module,
+      program,
       tokens,
       token_index: 0,
     }
@@ -26,18 +26,18 @@ impl<'a> CommentTracker<'a> {
       // get any comments stored at the beginning of the file
       // todo: investigate what's required here
       let file_start = BytePos(0);
-      iterator.extend(file_start.leading_comments_fast(self.module));
-      iterator.extend(file_start.trailing_comments_fast(self.module));
+      iterator.extend(file_start.leading_comments_fast(self.program));
+      iterator.extend(file_start.trailing_comments_fast(self.program));
     } else if let Some(previous_token) = self.tokens.get(self.token_index - 1) {
-      iterator.extend(previous_token.hi().trailing_comments_fast(self.module));
+      iterator.extend(previous_token.hi().trailing_comments_fast(self.program));
     }
 
     while let Some(token) = self.tokens.get(self.token_index) {
-      iterator.extend(token.lo().leading_comments_fast(self.module));
+      iterator.extend(token.lo().leading_comments_fast(self.program));
 
       let token_hi = token.hi();
       if token_hi < pos {
-        iterator.extend(token_hi.trailing_comments_fast(self.module));
+        iterator.extend(token_hi.trailing_comments_fast(self.program));
         self.token_index += 1;
       } else {
         break;
@@ -52,7 +52,7 @@ impl<'a> CommentTracker<'a> {
     let mut iterator = CommentsIterator::new(Vec::new());
 
     while let Some(token) = self.tokens.get(self.token_index) {
-      iterator.extend(token.lo().leading_comments_fast(self.module));
+      iterator.extend(token.lo().leading_comments_fast(self.program));
 
       let is_comma = token.token == Token::Comma;
       if !is_comma && token.lo() >= end {
@@ -61,7 +61,7 @@ impl<'a> CommentTracker<'a> {
 
       let token_hi = token.hi();
       if is_comma || token_hi <= end {
-        iterator.extend(token.hi().trailing_comments_fast(self.module));
+        iterator.extend(token.hi().trailing_comments_fast(self.program));
         self.token_index += 1;
       } else {
         break;

src/parsing/context.rs

@@ -1,20 +1,20 @@
+use deno_ast::swc::common::comments::Comment;
+use deno_ast::swc::common::BytePos;
+use deno_ast::swc::common::Span;
+use deno_ast::swc::common::Spanned;
+use deno_ast::swc::parser::token::TokenAndSpan;
+use deno_ast::view::*;
 use dprint_core::formatting::{ConditionReference, Info};
 use rustc_hash::FxHashMap;
 use rustc_hash::FxHashSet;
-use swc_ast_view::*;
-use swc_common::comments::Comment;
-use swc_common::BytePos;
-use swc_common::Span;
-use swc_common::Spanned;
-use swc_ecmascript::parser::token::TokenAndSpan;
 
 use super::*;
 use crate::configuration::*;
 use crate::utils::Stack;
 
 pub struct Context<'a> {
   pub is_jsx: bool,
-  pub module: &'a Module<'a>,
+  pub program: &'a Program<'a>,
   pub config: &'a Configuration,
   pub comments: CommentTracker<'a>,
   pub token_finder: TokenFinder<'a>,
@@ -33,13 +33,13 @@ pub struct Context<'a> {
 }
 
 impl<'a> Context<'a> {
-  pub fn new(is_jsx: bool, tokens: &'a [TokenAndSpan], current_node: Node<'a>, module: &'a Module, config: &'a Configuration) -> Context<'a> {
+  pub fn new(is_jsx: bool, tokens: &'a [TokenAndSpan], current_node: Node<'a>, program: &'a Program<'a>, config: &'a Configuration) -> Context<'a> {
     Context {
       is_jsx,
-      module,
+      program,
       config,
-      comments: CommentTracker::new(module, tokens),
-      token_finder: TokenFinder::new(module),
+      comments: CommentTracker::new(program, tokens),
+      token_finder: TokenFinder::new(program),
       current_node,
       parent_stack: Stack::new(),
       handled_comments: FxHashSet::default(),
@@ -136,7 +136,7 @@ impl<'a> Context<'a> {
 
   #[cfg(debug_assertions)]
   pub fn assert_text(&self, span: Span, expected_text: &str) {
-    let actual_text = span.text_fast(self.module);
+    let actual_text = span.text_fast(self.program);
     if actual_text != expected_text {
       panic!("Debug Panic Expected text `{}`, but found `{}`", expected_text, actual_text)
     }