feat: ability to format an already parsed file

Author: dsherret

Cargo.toml

@@ -29,7 +29,7 @@ dprint-core = { version = "0.44.0", features = ["formatting"] }
 fnv = "1.0.7"
 serde = { version = "1.0.118", features = ["derive"] }
 serde_json = { version = "1.0", optional = true }
-swc_ast_view = { version = "0.25.0", package = "dprint-swc-ecma-ast-view" }
+swc_ast_view = { version = "0.27.1", package = "dprint-swc-ecma-ast-view" }
 swc_common = "0.11.4"
 swc_ecmascript = { version = "0.52.1", features = ["parser"] }
 

src/format_text.rs

@@ -3,14 +3,16 @@ use std::path::Path;
 use dprint_core::formatting::*;
 use dprint_core::types::ErrBox;
 use dprint_core::configuration::{resolve_new_line_kind};
+use swc_ast_view::TokenAndSpan;
+use swc_common::comments::SingleThreadedCommentsMapInner;
 
 use super::parsing::parse;
 use super::swc::parse_swc_ast;
 use super::configuration::Configuration;
 
 /// Formats a file.
 ///
-/// Returns the file text `Ok(formatted_text)` or an error when it failed to parse.
+/// Returns the file text or an error when it failed to parse.
 ///
 /// # Example
 ///
@@ -42,17 +44,51 @@ pub fn format_text(file_path: &Path, file_text: &str, config: &Configuration) ->
 
     let parsed_source_file = parse_swc_ast(file_path, file_text)?;
     Ok(dprint_core::formatting::format(|| {
-        let print_items = parse(&parsed_source_file, config);
+        let print_items = parse(&SourceFileInfo {
+            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 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 the already parsed file. This is useful as a performance optimization.
+pub fn format_parsed_file(info: &SourceFileInfo<'_>, config: &Configuration) -> Result<String, ErrBox> {
+    if super::utils::file_text_has_ignore_comment(info.info.text(), &config.ignore_file_comment_text) {
+        return Ok(info.info.text().to_string());
+    }
+
+    Ok(dprint_core::formatting::format(|| {
+        let print_items = parse(&info, config);
+        // println!("{}", print_items.get_as_text());
+        print_items
+    }, config_to_print_options(info.info.text(), 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(&parsed_source_file, config),
+        || parse(&SourceFileInfo {
+            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),
     )
 }

src/lib.rs

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

src/parsing/context.rs

@@ -1,5 +1,4 @@
 use dprint_core::formatting::{Info, ConditionReference};
-use swc_common::SourceFile;
 use swc_ast_view::*;
 use fnv::{FnvHashMap, FnvHashSet};
 
@@ -15,7 +14,6 @@ pub struct Context<'a> {
     pub current_node: Node<'a>,
     pub parent_stack: Stack<Node<'a>>,
     handled_comments: FnvHashSet<BytePos>,
-    pub info: &'a SourceFile,
     stored_infos: FnvHashMap<(BytePos, BytePos), Info>,
     stored_info_ranges: FnvHashMap<(BytePos, BytePos), (Info, Info)>,
     pub end_statement_or_member_infos: Stack<Info>,
@@ -32,7 +30,6 @@ impl<'a> Context<'a> {
         config: &'a Configuration,
         tokens: &'a [TokenAndSpan],
         current_node: Node<'a>,
-        info: &'a SourceFile,
         module: &'a Module,
     ) -> Context<'a> {
         Context {
@@ -43,7 +40,6 @@ impl<'a> Context<'a> {
             current_node,
             parent_stack: Stack::new(),
             handled_comments: FnvHashSet::default(),
-            info,
             stored_infos: FnvHashMap::default(),
             stored_info_ranges: FnvHashMap::default(),
             end_statement_or_member_infos: Stack::new(),

src/parsing/node_helpers.rs

@@ -3,7 +3,7 @@ use swc_ast_view::*;
 pub fn is_first_node_on_line(node: &dyn Spanned, module: &Module) -> bool {
     let start = node.lo().0 as usize;
     let source_file = module.source_file.as_ref().unwrap();
-    let source_file_text = source_file.src.as_bytes();
+    let source_file_text = source_file.text().as_bytes();
 
     for i in (0..start).rev() {
         let c = source_file_text[i];
@@ -69,7 +69,7 @@ pub fn nodes_have_only_spaces_between(previous_node: &Node, next_node: &Node, mo
             && next_node_text.starts_with(' ')
     } else {
         let source_file = module.source_file.as_ref().unwrap();
-        crate::utils::is_not_empty_and_only_spaces(&source_file.src[previous_node.hi().0 as usize..next_node.lo().0 as usize])
+        crate::utils::is_not_empty_and_only_spaces(&source_file.text()[previous_node.hi().0 as usize..next_node.lo().0 as usize])
     }
 }
 

src/parsing/parser.rs

@@ -3,29 +3,30 @@ use dprint_core::formatting::*;
 use dprint_core::formatting::{parser_helpers::*,condition_resolvers, conditions::*};
 use swc_ast_view::*;
 
-use crate::configuration::*;
-use crate::swc::ParsedSourceFile;
+use crate::{SourceFileInfo, configuration::*};
 use crate::utils;
 use super::sorting::*;
 use super::swc::*;
 use super::swc::{get_flattened_bin_expr};
 use super::*;
 
-pub fn parse(source_file: &ParsedSourceFile, config: &Configuration) -> PrintItems {
+pub fn parse(info: &SourceFileInfo<'_>, config: &Configuration) -> PrintItems {
     let source_file_info = swc_ast_view::ModuleInfo {
-        module: &source_file.module,
-        source_file: Some(&source_file.info),
-        tokens: Some(&source_file.tokens),
-        comments: Some(&source_file.comments),
+        module: info.module,
+        source_file: Some(info.info),
+        tokens: Some(info.tokens),
+        comments: Some(Comments {
+            leading: info.leading_comments,
+            trailing: info.trailing_comments,
+        }),
     };
 
     swc_ast_view::with_ast_view_for_module(source_file_info, |module| {
         let module_node = Node::Module(module);
         let mut context = Context::new(
             config,
-            &source_file.tokens,
+            info.tokens,
             module_node,
-            &source_file.info,
             module,
         );
         let mut items = parse_node(module_node, &mut context);

src/swc/parse_swc_ast.rs

@@ -1,15 +1,16 @@
 use std::path::Path;
-use swc_common::{
-    FileName, comments::SingleThreadedComments, SourceFile, BytePos, Spanned
-};
+use std::rc::Rc;
+use swc_common::{BytePos, Spanned, comments::{SingleThreadedComments, SingleThreadedCommentsMapInner}};
 use swc_ecmascript::parser::{Parser, StringInput, Syntax, error::{SyntaxError, Error as SwcError}, lexer::Lexer, Capturing, JscTarget, token::{TokenAndSpan}};
 use dprint_core::types::{ErrBox, Error};
+use swc_ast_view::SourceFileTextInfo;
 
 pub struct ParsedSourceFile {
     pub module: swc_ecmascript::ast::Module,
-    pub info: SourceFile,
+    pub info: SourceFileTextInfo,
     pub tokens: Vec<TokenAndSpan>,
-    pub comments: SingleThreadedComments,
+    pub leading_comments: SingleThreadedCommentsMapInner,
+    pub trailing_comments: SingleThreadedCommentsMapInner,
 }
 
 pub fn parse_swc_ast(file_path: &Path, file_text: &str) -> Result<ParsedSourceFile, ErrBox> {
@@ -31,13 +32,8 @@ pub fn parse_swc_ast(file_path: &Path, file_text: &str) -> Result<ParsedSourceFi
 }
 
 fn parse_inner(file_path: &Path, file_text: &str) -> Result<ParsedSourceFile, ErrBox> {
-    let source_file = SourceFile::new(
-        FileName::Custom(file_path.to_string_lossy().into()),
-        false,
-        FileName::Custom(file_path.to_string_lossy().into()),
-        file_text.into(),
-        BytePos(0),
-    );
+    let string_input = StringInput::new(file_text, BytePos(0), BytePos(file_text.len() as u32));
+    let source_file_info = SourceFileTextInfo::new(BytePos(0), file_text.to_string());
 
     let comments: SingleThreadedComments = Default::default();
     let (module, tokens) = {
@@ -52,7 +48,7 @@ fn parse_inner(file_path: &Path, file_text: &str) -> Result<ParsedSourceFile, Er
         let lexer = Lexer::new(
             Syntax::Typescript(ts_config),
             JscTarget::Es2019,
-            StringInput::from(&source_file),
+            string_input,
             Some(&comments)
         );
         let lexer = Capturing::new(lexer);
@@ -66,6 +62,9 @@ fn parse_inner(file_path: &Path, file_text: &str) -> Result<ParsedSourceFile, Er
             Ok(module) => Ok((module, tokens))
         }
     }?;
+    let (leading, trailing) = comments.take_all();
+    let leading_comments = Rc::try_unwrap(leading).unwrap().into_inner();
+    let trailing_comments = Rc::try_unwrap(trailing).unwrap().into_inner();
 
     // {
     //     let (leading, trailing) = comments.borrow_all();
@@ -74,9 +73,10 @@ fn parse_inner(file_path: &Path, file_text: &str) -> Result<ParsedSourceFile, Er
     // }
 
     return Ok(ParsedSourceFile {
-        comments,
+        leading_comments,
+        trailing_comments,
         module,
-        info: source_file,
+        info: source_file_info,
         tokens,
     });