foundry_common/comments/
mod.rs
1mod comment;
2
3use comment::{Comment, CommentStyle};
4use solar_parse::{
5 ast::{CommentKind, Span},
6 interface::{BytePos, CharPos, SourceMap, source_map::SourceFile},
7 lexer::token::RawTokenKind as TokenKind,
8};
9use std::fmt;
10
11pub struct Comments {
12 comments: std::vec::IntoIter<Comment>,
13}
14
15impl fmt::Debug for Comments {
16 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17 f.write_str("Comments")?;
18 f.debug_list().entries(self.iter()).finish()
19 }
20}
21
22fn all_whitespace(s: &str, col: CharPos) -> Option<usize> {
26 let mut idx = 0;
27 for (i, ch) in s.char_indices().take(col.to_usize()) {
28 if !ch.is_whitespace() {
29 return None;
30 }
31 idx = i + ch.len_utf8();
32 }
33 Some(idx)
34}
35
36fn trim_whitespace_prefix(s: &str, col: CharPos) -> &str {
37 let len = s.len();
38 match all_whitespace(s, col) {
39 Some(col) => {
40 if col < len {
41 &s[col..]
42 } else {
43 ""
44 }
45 }
46 None => s,
47 }
48}
49
50fn split_block_comment_into_lines(text: &str, col: CharPos) -> Vec<String> {
51 let mut res: Vec<String> = vec![];
52 let mut lines = text.lines();
53 res.extend(lines.next().map(|it| it.to_string()));
55 for line in lines {
57 res.push(trim_whitespace_prefix(line, col).to_string())
58 }
59 res
60}
61
62fn line_begin_pos(sf: &SourceFile, pos: BytePos) -> BytePos {
64 let pos = sf.relative_position(pos);
65 let line_index = sf.lookup_line(pos).unwrap();
66 let line_start_pos = sf.lines()[line_index];
67 sf.absolute_position(line_start_pos)
68}
69
70fn gather_comments(sf: &SourceFile) -> Vec<Comment> {
71 let text = sf.src.as_str();
72 let start_bpos = sf.start_pos;
73 let mut pos = 0;
74 let mut comments: Vec<Comment> = Vec::new();
75 let mut code_to_the_left = false;
76
77 let make_span = |range: std::ops::Range<usize>| {
78 Span::new(start_bpos + range.start as u32, start_bpos + range.end as u32)
79 };
80
81 for token in solar_parse::Cursor::new(&text[pos..]) {
93 let token_range = pos..pos + token.len as usize;
94 let span = make_span(token_range.clone());
95 let token_text = &text[token_range];
96 match token.kind {
97 TokenKind::Whitespace => {
98 if let Some(mut idx) = token_text.find('\n') {
99 code_to_the_left = false;
100
101 if let Some(next_newline) = token_text[idx + 1..].find('\n') {
103 idx += 1 + next_newline;
104 let pos = pos + idx;
105 comments.push(Comment {
106 is_doc: false,
107 kind: CommentKind::Line,
108 style: CommentStyle::BlankLine,
109 lines: vec![],
110 span: make_span(pos..pos),
111 });
112 }
113 }
114 }
115 TokenKind::BlockComment { is_doc, .. } => {
116 let code_to_the_right =
117 !matches!(text[pos + token.len as usize..].chars().next(), Some('\r' | '\n'));
118 let style = match (code_to_the_left, code_to_the_right) {
119 (_, true) => CommentStyle::Mixed,
120 (false, false) => CommentStyle::Isolated,
121 (true, false) => CommentStyle::Trailing,
122 };
123 let kind = CommentKind::Block;
124
125 let pos_in_file = start_bpos + BytePos(pos as u32);
127 let line_begin_in_file = line_begin_pos(sf, pos_in_file);
128 let line_begin_pos = (line_begin_in_file - start_bpos).to_usize();
129 let col = CharPos(text[line_begin_pos..pos].chars().count());
130
131 let lines = split_block_comment_into_lines(token_text, col);
132 comments.push(Comment { is_doc, kind, style, lines, span })
133 }
134 TokenKind::LineComment { is_doc } => {
135 comments.push(Comment {
136 is_doc,
137 kind: CommentKind::Line,
138 style: if code_to_the_left {
139 CommentStyle::Trailing
140 } else {
141 CommentStyle::Isolated
142 },
143 lines: vec![token_text.to_string()],
144 span,
145 });
146 }
147 _ => {
148 code_to_the_left = true;
149 }
150 }
151 pos += token.len as usize;
152 }
153
154 comments
155}
156
157impl Comments {
158 pub fn new(sf: &SourceFile) -> Self {
159 Self { comments: gather_comments(sf).into_iter() }
160 }
161
162 pub fn peek(&self) -> Option<&Comment> {
163 self.comments.as_slice().first()
164 }
165
166 #[allow(clippy::should_implement_trait)]
167 pub fn next(&mut self) -> Option<Comment> {
168 self.comments.next()
169 }
170
171 pub fn iter(&self) -> impl Iterator<Item = &Comment> {
172 self.comments.as_slice().iter()
173 }
174
175 pub fn trailing_comment(
176 &mut self,
177 sm: &SourceMap,
178 span: Span,
179 next_pos: Option<BytePos>,
180 ) -> Option<Comment> {
181 if let Some(cmnt) = self.peek() {
182 if cmnt.style != CommentStyle::Trailing {
183 return None;
184 }
185 let span_line = sm.lookup_char_pos(span.hi());
186 let comment_line = sm.lookup_char_pos(cmnt.pos());
187 let next = next_pos.unwrap_or_else(|| cmnt.pos() + BytePos(1));
188 if span.hi() < cmnt.pos() && cmnt.pos() < next && span_line.line == comment_line.line {
189 return Some(self.next().unwrap());
190 }
191 }
192
193 None
194 }
195}