chore: Some cleanup.

Author: dsherret

src/parsing/comments.rs

@@ -32,17 +32,13 @@ impl<'a> CommentTracker<'a> {
             iterator.extend(previous_token.hi().trailing_comments_fast(self.module));
         }
 
-        loop {
-            if let Some(token) = self.tokens.get(self.token_index) {
-                iterator.extend(token.lo().leading_comments_fast(self.module));
+        while let Some(token) = self.tokens.get(self.token_index) {
+            iterator.extend(token.lo().leading_comments_fast(self.module));
 
-                let token_hi = token.hi();
-                if token_hi < pos {
-                    iterator.extend(token_hi.trailing_comments_fast(self.module));
-                    self.token_index += 1;
-                } else {
-                    break;
-                }
+            let token_hi = token.hi();
+            if token_hi < pos {
+                iterator.extend(token_hi.trailing_comments_fast(self.module));
+                self.token_index += 1;
             } else {
                 break;
             }
@@ -55,22 +51,18 @@ impl<'a> CommentTracker<'a> {
     pub fn trailing_comments_with_previous(&mut self, end: BytePos) -> CommentsIterator<'a> {
         let mut iterator = CommentsIterator::new(Vec::new());
 
-        loop {
-            if let Some(token) = self.tokens.get(self.token_index) {
-                iterator.extend(token.lo().leading_comments_fast(self.module));
+        while let Some(token) = self.tokens.get(self.token_index) {
+            iterator.extend(token.lo().leading_comments_fast(self.module));
 
-                let is_comma = token.token == Token::Comma;
-                if !is_comma && token.lo() >= end {
-                    break;
-                }
+            let is_comma = token.token == Token::Comma;
+            if !is_comma && token.lo() >= end {
+                break;
+            }
 
-                let token_hi = token.hi();
-                if is_comma || token_hi <= end {
-                    iterator.extend(token.hi().trailing_comments_fast(self.module));
-                    self.token_index += 1;
-                } else {
-                    break;
-                }
+            let token_hi = token.hi();
+            if is_comma || token_hi <= end {
+                iterator.extend(token.hi().trailing_comments_fast(self.module));
+                self.token_index += 1;
             } else {
                 break;
             }

src/parsing/context.rs

@@ -0,0 +1,145 @@
+use dprint_core::formatting::{Info, ConditionReference};
+use swc_common::SourceFile;
+use swc_ast_view::*;
+use fnv::{FnvHashMap, FnvHashSet};
+
+use super::*;
+use crate::configuration::*;
+use crate::utils::Stack;
+
+pub struct Context<'a> {
+    pub module: &'a Module<'a>,
+    pub config: &'a Configuration,
+    pub comments: CommentTracker<'a>,
+    pub token_finder: TokenFinder<'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>,
+    before_comments_start_info_stack: Stack<(Span, Info)>,
+    if_stmt_last_brace_condition_ref: Option<ConditionReference>,
+    expr_stmt_single_line_parent_brace_ref: Option<ConditionReference>,
+    /// Used for ensuring nodes are parsed in order.
+    #[cfg(debug_assertions)]
+    pub last_parsed_node_pos: u32,
+}
+
+impl<'a> Context<'a> {
+    pub fn new(
+        config: &'a Configuration,
+        tokens: &'a [TokenAndSpan],
+        current_node: Node<'a>,
+        info: &'a SourceFile,
+        module: &'a Module,
+    ) -> Context<'a> {
+        Context {
+            module,
+            config,
+            comments: CommentTracker::new(module, tokens),
+            token_finder: TokenFinder::new(module),
+            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(),
+            before_comments_start_info_stack: Stack::new(),
+            if_stmt_last_brace_condition_ref: None,
+            expr_stmt_single_line_parent_brace_ref: None,
+            #[cfg(debug_assertions)]
+            last_parsed_node_pos: 0,
+        }
+    }
+
+    pub fn parent(&self) -> &Node<'a> {
+        self.parent_stack.peek().unwrap()
+    }
+
+    pub fn has_handled_comment(&self, comment: &Comment) -> bool {
+        self.handled_comments.contains(&comment.lo())
+    }
+
+    pub fn mark_comment_handled(&mut self, comment: &Comment) {
+        self.handled_comments.insert(comment.lo());
+    }
+
+    pub fn store_info_for_node(&mut self, node: &dyn Spanned, info: Info) {
+        self.stored_infos.insert((node.lo(), node.hi()), info);
+    }
+
+    pub fn get_info_for_node(&self, node: &dyn Spanned) -> Option<Info> {
+        self.stored_infos.get(&(node.lo(), node.hi())).map(|x| x.to_owned())
+    }
+
+    pub fn store_info_range_for_node(&mut self, node: &dyn Spanned, infos: (Info, Info)) {
+        self.stored_info_ranges.insert((node.lo(), node.hi()), infos);
+    }
+
+    pub fn get_info_range_for_node(&self, node: &dyn Spanned) -> Option<(Info, Info)> {
+        self.stored_info_ranges.get(&(node.lo(), node.hi())).map(|x| x.to_owned())
+    }
+
+    pub fn store_if_stmt_last_brace_condition_ref(&mut self, condition_reference: ConditionReference) {
+        self.if_stmt_last_brace_condition_ref = Some(condition_reference);
+    }
+
+    pub fn take_if_stmt_last_brace_condition_ref(&mut self) -> Option<ConditionReference> {
+        self.if_stmt_last_brace_condition_ref.take()
+    }
+
+    pub fn store_expr_stmt_single_line_parent_brace_ref(&mut self, condition_reference: ConditionReference) {
+        self.expr_stmt_single_line_parent_brace_ref = Some(condition_reference);
+    }
+
+    pub fn take_expr_stmt_single_line_parent_brace_ref(&mut self) -> Option<ConditionReference> {
+        self.expr_stmt_single_line_parent_brace_ref.take()
+    }
+
+    pub fn get_or_create_current_before_comments_start_info(&mut self) -> Info {
+        let current_span = self.current_node.span();
+        if let Some((span, info)) = self.before_comments_start_info_stack.peek() {
+            if *span == current_span {
+                return *info;
+            }
+        }
+
+        let new_info = Info::new("beforeComments");
+        self.before_comments_start_info_stack.push((current_span, new_info));
+        new_info
+    }
+
+    pub fn take_current_before_comments_start_info(&mut self) -> Option<Info> {
+        let mut had_span = false;
+        if let Some((span, _)) = self.before_comments_start_info_stack.peek() {
+            if *span == self.current_node.span() {
+                had_span = true;
+            }
+        }
+
+        if had_span {
+            Some(self.before_comments_start_info_stack.pop().1)
+        } else {
+            None
+        }
+    }
+
+    // do any assertions for how the state of this context should be at the end of the file
+    #[cfg(debug_assertions)]
+    pub fn assert_end_of_file_state(&self) {
+        if self.before_comments_start_info_stack.iter().next().is_some() {
+            panic!("Debug panic! There were infos in the before comments start info stack.");
+        }
+    }
+
+    #[cfg(debug_assertions)]
+    pub fn assert_text(&self, span: Span, expected_text: &str) {
+        let actual_text = span.text_fast(self.module);
+        if actual_text != expected_text {
+            panic!("Debug Panic Expected text `{}`, but found `{}`", expected_text, actual_text)
+        }
+    }
+}

src/parsing/mod.rs

@@ -1,4 +1,5 @@
 mod comments;
+mod context;
 mod node_helpers;
 mod helpers;
 mod parser_types;
@@ -8,6 +9,7 @@ mod tokens;
 mod swc;
 
 use comments::*;
+use context::*;
 use helpers::*;
 use parser_types::*;
 use tokens::*;

src/parsing/node_helpers.rs

@@ -7,12 +7,12 @@ pub fn is_first_node_on_line(node: &dyn Spanned, module: &Module) -> bool {
 
     for i in (0..start).rev() {
         let c = source_file_text[i];
-        if c != ' ' as u8 && c != '\t' as u8 {
-            return c == '\n' as u8;
+        if c != b' ' && c != b'\t' {
+            return c == b'\n';
         }
     }
 
-    return true;
+    true
 }
 
 pub fn has_separating_blank_line(first_node: &dyn Spanned, second_node: &dyn Spanned, module: &Module) -> bool {
@@ -33,14 +33,14 @@ pub fn has_separating_blank_line(first_node: &dyn Spanned, second_node: &dyn Spa
 }
 
 pub fn get_use_new_lines_for_nodes(first_node: &dyn Spanned, second_node: &dyn Spanned, module: &Module) -> bool {
-    return first_node.end_line_fast(module) != second_node.start_line_fast(module);
+    first_node.end_line_fast(module) != second_node.start_line_fast(module)
 }
 
-pub fn has_leading_comment_on_different_line<'a>(node: &dyn Spanned, comments_to_ignore: Option<&Vec<&'a Comment>>, module: &Module<'a>) -> bool {
+pub fn has_leading_comment_on_different_line<'a>(node: &dyn Spanned, comments_to_ignore: Option<&[&'a Comment]>, module: &Module<'a>) -> bool {
     get_leading_comment_on_different_line(node, comments_to_ignore, module).is_some()
 }
 
-pub fn get_leading_comment_on_different_line<'a>(node: &dyn Spanned, comments_to_ignore: Option<&Vec<&'a Comment>>, module: &Module<'a>) -> Option<&'a Comment> {
+pub fn get_leading_comment_on_different_line<'a>(node: &dyn Spanned, comments_to_ignore: Option<&[&'a Comment]>, module: &Module<'a>) -> Option<&'a Comment> {
     let comments_to_ignore: Option<Vec<BytePos>> = comments_to_ignore.map(|x| x.iter().map(|c| c.lo()).collect());
     let node_start_line = node.start_line_fast(module);
     for comment in node.leading_comments_fast(module) {
@@ -55,18 +55,18 @@ pub fn get_leading_comment_on_different_line<'a>(node: &dyn Spanned, comments_to
         }
     }
 
-    return None;
+    None
 }
 
 pub fn nodes_have_only_spaces_between(previous_node: &Node, next_node: &Node, module: &Module) -> bool {
     if let Node::JSXText(previous_node) = previous_node {
         let previous_node_text = previous_node.text_fast(module);
         crate::utils::has_no_new_lines_in_trailing_whitespace(previous_node_text)
-            && previous_node_text.chars().last() == Some(' ')
+            && previous_node_text.ends_with(' ')
     } else if let Node::JSXText(next_node) = next_node {
         let next_node_text = next_node.text_fast(module);
         crate::utils::has_no_new_lines_in_leading_whitespace(next_node_text)
-            && next_node_text.chars().next() == Some(' ')
+            && 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])
@@ -192,11 +192,11 @@ pub fn is_test_library_call_expr(node: &CallExpr, module: &Module) -> bool {
     }
 }
 
-pub fn is_optional_call_expr<'a>(node: &dyn NodeTrait<'a>) -> bool {
-    return node.parent().unwrap().kind() == NodeKind::OptChainExpr;
+pub fn is_optional_call_expr(node: &dyn NodeTrait) -> bool {
+    node.parent().unwrap().kind() == NodeKind::OptChainExpr
 }
 
-pub fn is_expr_stmt_or_body_with_single_expr_stmt<'a>(node: Node<'a>) -> bool {
+pub fn is_expr_stmt_or_body_with_single_expr_stmt(node: Node) -> bool {
     match node {
         Node::ExprStmt(_) => true,
         Node::BlockStmt(block) => block.stmts.len() == 1 && block.stmts[0].is::<ExprStmt>(),