Fix #119: nofmt comment filtering

crates/aargvark_tests/examples/ultrathon.rs

@@ -1,4 +1,5 @@
 #![allow(dead_code)]
+
 use {
     aargvark::Aargvark,
     std::path::PathBuf,

crates/genemichaels-lib/src/lib.rs

@@ -2,7 +2,7 @@
     clippy::too_many_arguments,
     clippy::field_reassign_with_default,
     clippy::never_loop,
     clippy::derive_hash_xor_eq
 )]
 
 use {
@@ -54,6 +54,7 @@
 pub struct Comment {
     pub mode: CommentMode,
     pub lines: String,
+    pub orig_start_offset: usize,
 }
 
 #[derive(Debug)]
@@ -183,7 +184,7 @@
     }
     new_segs.extend(line.segs.split_off(off));
     {
         let seg_i = new_segs.get(0).unwrap();
         let seg = out.segs.get(seg_i.0).unwrap();
         match &seg.content {
             SegmentContent::Break(a, activate) => {
@@ -473,8 +474,8 @@
 
 fn render_indent(config: &FormatConfig, current_indent: IndentLevel) -> String {
     match config.indent_unit {
         IndentUnit::Spaces => return " ".repeat(config.indent_spaces * current_indent.0),
         IndentUnit::Tabs => return "\t".repeat(current_indent.0),
     }
 }
 
@@ -554,13 +555,13 @@
             whitespaces,
         )?;
     if let Some(shebang) = shebang {
         return Ok(FormatRes {
             rendered: format!("{}{}", shebang, out.rendered),
             lost_comments: out.lost_comments,
             warnings: out.warnings,
         });
     } else {
         return Ok(out);
     }
 }
 
@@ -574,7 +575,7 @@
         nodes: vec![],
         segs: vec![],
         whitespaces,
         config: config.clone(),
     };
     let base_indent = Alignment(Rc::new(RefCell::new(Alignment_ {
         parent: None,
@@ -882,8 +883,8 @@
         line_i += 1;
     }
     Ok(FormatRes {
         rendered: rendered,
         lost_comments: out.whitespaces,
         warnings: warnings,
     })
 }

crates/genemichaels-lib/src/sg_general.rs

@@ -31,7 +31,10 @@
     },
     std::{
         fmt::Write,
-        ops::Bound,
+        ops::{
+            Bound,
+            RangeBounds,
+        },
     },
     syn::{
         spanned::Spanned,
@@ -271,6 +274,8 @@
                 after_attr_line_col = Bound::Included(HashLineColumn(span_including_attrs.start()));
             }
             sg.seg(out, &text[after_attr_byte_offset - span_including_attrs.span().byte_range().start..]);
+
+            // Remove comments used within subtree from global block
             let remove_whitespaces_keys =
                 out
                     .whitespaces
@@ -287,7 +292,11 @@
                     match ws.mode {
                         WhitespaceMode::BlankLines(_) => { },
                         WhitespaceMode::Comment(comment) => {
-                            if text.contains(&comment.lines) {
+                            if match span_including_attrs.byte_range().end_bound() {
+                                Bound::Included(x) => comment.orig_start_offset <= *x,
+                                Bound::Excluded(x) => comment.orig_start_offset < *x,
+                                Bound::Unbounded => unreachable!(),
+                            } {
                                 continue;
                             }
                             sg.add(out, crate::Segment {
@@ -299,6 +308,7 @@
                                     mode: WhitespaceMode::Comment(crate::Comment {
                                         mode: crate::CommentMode::Normal,
                                         lines: comment.lines,
+                                        orig_start_offset: 0,
                                     }),
                                 }])),
                             });
@@ -505,23 +515,23 @@
             {
                 /// Identify punctuation that connects things tightly
                 fn is_pull_next_punct(p: &Punct) -> bool {
                     return match p.as_char() {
                         '.' => true,
                         '\'' => true,
                         '$' => true,
                         '#' => true,
                         _ => false,
                     };
                 }
 
                 // With exceptions, the default heterogeneous adjacent token tree behavior is to
                 // push. For punctuation-adjacent, it depends on the punctuation type.
                 fn is_hetero_push_next(prev: &Option<TokenTree>) -> bool {
                     return match &prev {
                         Some(prev) => match prev {
                             TokenTree::Group(_) => true,
                             TokenTree::Ident(_) | TokenTree::Literal(_) => true,
                             TokenTree::Punct(punct) => !is_pull_next_punct(&punct),
                         },
                         None => false,
                     };
@@ -573,18 +583,18 @@
                                 sg.seg(out, " ");
                             }
                             append_whitespace(out, base_indent, sg, i.span().start());
                             sg.seg(out, &i.to_string());
                         },
                         TokenTree::Punct(p) => {
                             if match &previous {
                                 Some(previous) => match previous {
                                     TokenTree::Group(_) |
                                     TokenTree::Ident(_) |
                                     TokenTree::Literal(_) => match p.as_char() {
                                         ':' => false,
                                         '.' => false,
                                         _ => true,
                                     },
                                     TokenTree::Punct(prev_p) => prev_p.span().end() != p.span().start(),
                                 },
                                 None => false,
@@ -592,14 +602,14 @@
                                 sg.seg(out, " ");
                             }
                             append_whitespace(out, base_indent, sg, p.span().start());
                             sg.seg(out, &p.to_string());
                         },
                         TokenTree::Literal(l) => {
                             if is_hetero_push_next(&previous) {
                                 sg.seg(out, " ");
                             }
                             append_whitespace(out, base_indent, sg, l.span().start());
                             sg.seg(out, &l.to_string());
                         },
                     }
                     previous = Some(t);
@@ -634,16 +644,16 @@
                 if use_lines == 0 {
                     return None;
                 }
                 return Some(Whitespace {
                     loc: w.loc,
                     mode: WhitespaceMode::BlankLines(use_lines),
                 });
             },
             WhitespaceMode::Comment(c) => {
                 return Some(Whitespace {
                     loc: w.loc,
                     mode: WhitespaceMode::Comment(c),
                 });
             },
         }
     }).collect();

crates/genemichaels-lib/src/whitespace.rs

@@ -33,13 +33,13 @@
 
 impl Ord for HashLineColumn {
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
         return self.0.line.cmp(&other.0.line).then(self.0.column.cmp(&other.0.column));
     }
 }
 
 impl PartialOrd for HashLineColumn {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
         return Some(self.0.cmp(&other.0));
     }
 }
 
@@ -95,7 +95,7 @@
                 self.source[line_start_offset..].chars().take(loc.column).map(char::len_utf8).sum::<usize>()
         }
 
-        fn add_comments(&mut self, end: LineColumn, between_ast_nodes: &str) {
+        fn add_comments(&mut self, end: LineColumn, abs_start: usize, between_ast_nodes: &str) {
             let start_re = &self.start_re.get_or_insert_with(|| Regex::new(
                 // `//` maybe followed by `[/!.?]`, `/**/`, or `/*` maybe followed by `[*!]`
                 r#"(?:(//)(/|!|\.|\?)?)|(/\*\*/)|(?:(/\*)(\*|!)?)"#,
@@ -110,6 +110,7 @@
                 mode: CommentMode,
                 lines: Vec<String>,
                 loc: LineColumn,
+                orig_start_offset: Option<usize>,
             }
 
             impl CommentBuffer {
@@ -122,9 +123,11 @@
                         mode: crate::WhitespaceMode::Comment(Comment {
                             mode: self.mode,
                             lines: self.lines.split_off(0).join("\n"),
+                            orig_start_offset: self.orig_start_offset.unwrap(),
                         }),
                     });
                     self.blank_lines = 0;
+                    self.orig_start_offset = None;
                 }
 
                 fn add(&mut self, mode: CommentMode, line: &str) {
@@ -156,19 +159,21 @@
                 mode: CommentMode::Normal,
                 lines: vec![],
                 loc: end,
+                orig_start_offset: None,
             };
-            let mut text = between_ast_nodes;
+            let mut text = (abs_start, between_ast_nodes);
             'comment_loop : loop {
-                match start_re.captures(text) {
+                match start_re.captures(text.1) {
                     Some(found_start) => {
+                        buffer.orig_start_offset.get_or_insert(abs_start + found_start.get(0).unwrap().start());
                         let start_prefix_match =
                             found_start
                                 .get(1)
                                 .or_else(|| found_start.get(3))
                                 .or_else(|| found_start.get(4))
                                 .unwrap();
                         if buffer.out.is_empty() && buffer.lines.is_empty() {
-                            buffer.add_blank_lines(&text[..start_prefix_match.start()]);
+                            buffer.add_blank_lines(&text.1[..start_prefix_match.start()]);
                         }
                         match start_prefix_match.as_str() {
                             "//" => {
@@ -184,24 +189,24 @@
                                         }, start_suffix_match.end()),
                                         None => (CommentMode::Normal, start_prefix_match.end()),
                                     };
-                                    if mode == CommentMode::DocOuter && text[match_end..].starts_with("/") {
+                                    if mode == CommentMode::DocOuter && text.1[match_end..].starts_with("/") {
                                         // > 3 slashes, so actually not a doc comment
                                         mode = CommentMode::Normal;
                                         match_end = start_prefix_match.end();
                                     }
-                                    text = &text[match_end..];
+                                    text = (text.0 + match_end, &text.1[match_end..]);
                                     mode
                                 };
-                                let (line, next_start) = match text.find('\n') {
-                                    Some(line_end) => (&text[..line_end], line_end + 1),
-                                    None => (text, text.len()),
+                                let (line, next_start) = match text.1.find('\n') {
+                                    Some(line_end) => (&text.1[..line_end], line_end + 1),
+                                    None => (text.1, text.1.len()),
                                 };
                                 buffer.add(mode, line);
-                                text = &text[next_start..];
+                                text = (text.0 + next_start, &text.1[next_start..]);
                             },
                             "/**/" => {
                                 buffer.add(CommentMode::Normal, "".into());
-                                text = &text[start_prefix_match.end()..];
+                                text = (text.0 + start_prefix_match.end(), &text.1[start_prefix_match.end()..]);
                             },
                             "/*" => {
                                 let mode = {
@@ -214,14 +219,14 @@
                                         }, start_suffix_match.end()),
                                         None => (CommentMode::Normal, start_prefix_match.end()),
                                     };
-                                    text = &text[match_end..];
+                                    text = (text.0 + match_end, &text.1[match_end..]);
                                     mode
                                 };
                                 let mut nesting = 1;
                                 let mut search_end_at = 0usize;
                                 let (lines, next_start) = loop {
                                     let found_event =
-                                        block_event_re.captures(&text[search_end_at..]).unwrap().get(1).unwrap();
+                                        block_event_re.captures(&text.1[search_end_at..]).unwrap().get(1).unwrap();
                                     let event_start = search_end_at + found_event.start();
                                     search_end_at += found_event.end();
                                     match found_event.as_str() {
@@ -231,7 +236,7 @@
                                         "*/" => {
                                             nesting -= 1;
                                             if nesting == 0 {
-                                                break (&text[..event_start], search_end_at);
+                                                break (&text.1[..event_start], search_end_at);
                                             }
                                         },
                                         _ => unreachable!(),
@@ -242,14 +247,14 @@
                                     line = line.strip_prefix("* ").unwrap_or(line);
                                     buffer.add(mode, line);
                                 }
-                                text = &text[next_start..];
+                                text = (text.0 + next_start, &text.1[next_start..]);
                             },
                             _ => unreachable!(),
                         }
                     },
                     None => {
                         if buffer.out.is_empty() && buffer.lines.is_empty() {
-                            buffer.add_blank_lines(text);
+                            buffer.add_blank_lines(text.1);
                         }
                         break 'comment_loop;
                     },
@@ -257,7 +262,7 @@
             }
             buffer.flush();
             if !buffer.out.is_empty() {
                 let whitespaces = self.whitespaces.entry(HashLineColumn(end)).or_insert(vec![]);
 
                 // Merge with existing comments (basically only if comments come before and after
                 // at the end of the line)
@@ -276,7 +281,7 @@
                         if previous_comment.mode != start_comment.mode {
                             break;
                         }
                         previous_comment.lines.push_str("\n");
                         previous_comment.lines.push_str(&start_comment.lines);
                         break 'merge;
                     }
@@ -307,7 +312,7 @@
                 };
                 let text = &self.source[start .. eol];
                 if text.trim_start().starts_with("//") {
-                    self.add_comments(*previous_start, text);
+                    self.add_comments(*previous_start, start, text);
                 }
                 start = eol;
                 break true;
@@ -321,15 +326,15 @@
                 return;
             }
             let whole_text = &self.source[start .. end_offset];
-            self.add_comments(end, whole_text);
+            self.add_comments(end, start, whole_text);
         }
     }
 
     // Extract comments
     let mut state = State {
         source: source,
         keep_max_blank_lines: keep_max_blank_lines,
         line_lookup: line_lookup,
         whitespaces: BTreeMap::new(),
         last_offset: 0usize,
         line_start: None,
@@ -398,7 +403,7 @@
                         line = e.span().start().line,
                         column = e.span().start().column,
                         error = e.to_string(),
                         source = source.lines().skip(e.span().start().line - 1).next().unwrap()
                     ),
                 ),
             )?,
@@ -406,7 +411,7 @@
     state.add_comments(LineColumn {
         line: 0,
         column: 1,
-    }, &source[state.last_offset..]);
+    }, state.last_offset, &source[state.last_offset..]);
     Ok((state.whitespaces, tokens))
 }
 
@@ -487,7 +492,7 @@
         explicit_wrap: bool,
     ) -> LineState {
         LineState(Rc::new(RefCell::new(LineState_ {
             base_prefix_len: base_prefix_len,
             first_prefix,
             prefix,
             explicit_wrap,
@@ -563,21 +568,21 @@
                 let next_break = Some((b, &breaks[i + 1..]));
                 if width + unicode_len(&text[..b]) > max_len {
                     return FoundWritableLen {
                         writable: writable,
                         previous_break: previous_break,
                         next_break: next_break,
                     };
                 }
                 previous_break = next_break;
                 writable = b;
             }
             return FoundWritableLen {
                 writable: if width + unicode_len(&text) > max_len {
                     writable
                 } else {
                     text.len()
                 },
                 previous_break: previous_break,
                 next_break: None,
             };
         }
@@ -587,7 +592,7 @@
             if let Some(b) = b {
                 s.backward_break = Some((state.line_buffer.len() + b, s.explicit_wrap));
             }
             state.line_buffer.push_str(&text);
         }
 
         fn write_forward_breaks(
@@ -634,7 +639,7 @@
                 out,
                 max_len,
                 false,
                 (&text[found.writable..]).to_string(),
                 found.writable,
                 found.previous_break.map(|b| b.1).unwrap_or(breaks),
             );
@@ -649,10 +654,10 @@
             // No retroactive split, try first split after max len (overflow, but better than
             // nothing)
             write_forward(state, &mut s, &text[..b], Some(b));
             write_forward_breaks(state, &mut s, out, max_len, false, (&text[b..]).to_string(), b, breaks);
         } else {
             state.line_buffer.push_str(text);
             return;
         }
     }
 
@@ -843,7 +848,7 @@
         },
         Node::Image(x) => {
             let alt = join_lines(&x.alt);
             match (get_splits(&join_lines(&alt)).first().is_some(), &x.title) {
                 (false, None) => {
                     line.write_unbreakable(state, out, &format!("![{}]({})", alt, x.url));
                 },
@@ -875,11 +880,11 @@
             let simple_text = if x.children.len() != 1 {
                 None
             } else {
                 x.children.get(0)
             }.and_then(|c| match c {
                 Node::Text(t) => {
                     let t = join_lines(&t.value);
                     if get_splits(&t).first().is_some() {
                         None
                     } else {
                         Some(t)
@@ -887,7 +892,7 @@
                 },
                 Node::InlineCode(t) => {
                     let t = join_lines(&t.value);
                     if get_splits(&t).first().is_some() {
                         None
                     } else {
                         Some(format!("`{}`", t))
@@ -932,14 +937,14 @@
             let simple_text = if x.children.len() != 1 {
                 None
             } else {
                 x.children.get(0)
             }.and_then(|c| match c {
                 Node::Text(t) => if get_splits(&t.value).first().is_some() {
                     None
                 } else {
                     Some(t.value.clone())
                 },
                 Node::InlineCode(t) => if get_splits(&t.value).first().is_some() {
                     None
                 } else {
                     Some(format!("`{}`", t.value))
@@ -1003,7 +1008,7 @@
             &mut state,
             &mut out,
             LineState::new(
                 unicode_len(&prefix),
                 None,
                 prefix.to_string(),
                 VisualLen(max_width),

crates/genemichaels-lib/tests/comments.rs

@@ -66,6 +66,7 @@ fn comment(mode: CommentMode, lines: &str) -> Whitespace {
         mode: genemichaels_lib::WhitespaceMode::Comment(Comment {
             mode: mode,
             lines: lines.to_string(),
+            orig_start_offset: 0,
         }),
     };
 }

crates/genemichaels-lib/tests/roundtrip.rs

@@ -574,6 +574,32 @@ fn rt_rustfmt_skip_subtree_comment() {
     );
 }
 
+#[test]
+fn rt_rustfmt_skip_subtree_comment_array() {
+    rt(
+        r#"fn main() {
+    #[rustfmt::skip]
+    let src_attribs = [
+        // EGL_WIDTH
+        0x3057, src.width() as i32,
+        // EGL_HEIGHT
+        0x3056, src.height() as i32,
+        //EGL_DMA_BUF_PLANE0_FD_EXT
+        0x3271, srcfd,
+        // EGL_DMA_BUF_PLANE0_OFFSET_EXT
+        0x3273, 0,
+        // EGL_DMA_BUF_PLANE0_PITCH_EXT
+        0x3274, src.stride() as i32,
+        // EGL_LINUX_DRM_FOURCC_EXT
+        // DRM_FORMAT_XRGB8888
+        0x3203, 0x34325258,
+        egl::EGL_NONE,
+     ];
+}
+"#,
+    );
+}
+
 #[test]
 fn rttabs_struct_generic1() {
     rt_tabs(