use cpp_parser::{CppTokenData, CppTokenKind, SourceRange};
use crate::preprocess::directive::{DirectiveKind, SpannedDirective, scan_directives};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FoldKind {
Code,
Comment,
Region,
Imports,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Fold {
pub range: SourceRange,
pub kind: FoldKind,
}
pub fn folding_ranges(source: &str, tokens: &[CppTokenData]) -> Vec<Fold> {
let mut folds = brace_folds(source, tokens);
folds.extend(comment_folds(source, tokens));
folds.extend(directive_folds(source, &scan_directives(source, tokens)));
folds.sort_by_key(|fold| (fold.range.start_offset, fold.range.end_offset()));
folds
}
fn brace_folds(source: &str, tokens: &[CppTokenData]) -> Vec<Fold> {
let mut open: Vec<usize> = Vec::new();
let mut folds = Vec::new();
for (index, token) in tokens.iter().enumerate() {
match token.kind {
CppTokenKind::LeftBrace => open.push(index),
CppTokenKind::RightBrace => {
let Some(start) = open.pop() else {
continue;
};
let range = SourceRange::new(
tokens[start].range.start_offset,
tokens[index].range.end_offset() - tokens[start].range.start_offset,
);
if spans_lines(source, range) {
folds.push(Fold {
range,
kind: FoldKind::Code,
});
}
}
_ => {}
}
}
folds
}
fn comment_folds(source: &str, tokens: &[CppTokenData]) -> Vec<Fold> {
let mut folds = Vec::new();
let mut index = 0usize;
while index < tokens.len() {
if !is_a_comment(tokens[index].kind) {
index += 1;
continue;
}
let first = index;
let mut last = index;
let mut at = index + 1;
let mut newlines = 0usize;
while at < tokens.len() {
match tokens[at].kind {
kind if is_a_comment(kind) && newlines <= 1 => {
last = at;
newlines = 0;
}
CppTokenKind::Newline => newlines += 1,
kind if cpp_parser::is_trivia(kind) => {}
_ => break,
}
at += 1;
}
let range = SourceRange::new(
tokens[first].range.start_offset,
tokens[last].range.end_offset() - tokens[first].range.start_offset,
);
if spans_lines(source, range) {
folds.push(Fold {
range,
kind: FoldKind::Comment,
});
}
index = last + 1;
}
folds
}
fn directive_folds(source: &str, directives: &[SpannedDirective]) -> Vec<Fold> {
let mut folds = Vec::new();
let mut open: Vec<usize> = Vec::new();
for directive in directives {
match directive.directive.kind() {
DirectiveKind::If | DirectiveKind::Ifdef | DirectiveKind::Ifndef => {
open.push(directive.range.start_offset)
}
DirectiveKind::Endif => {
let Some(start) = open.pop() else {
continue;
};
let range =
SourceRange::new(start, directive.line.end_offset().saturating_sub(start));
if spans_lines(source, range) {
folds.push(Fold {
range,
kind: FoldKind::Region,
});
}
}
_ => {}
}
}
let includes: Vec<&SpannedDirective> = directives
.iter()
.filter(|directive| {
matches!(
directive.directive.kind(),
DirectiveKind::Include | DirectiveKind::IncludeNext
)
})
.collect();
let mut at = 0usize;
while at < includes.len() {
let first = at;
let mut last = at;
while last + 1 < includes.len()
&& newlines_between(source, &includes[last].range, &includes[last + 1].range) == 1
{
last += 1;
}
if last > first {
folds.push(Fold {
range: SourceRange::new(
includes[first].line.start_offset,
includes[last]
.line
.end_offset()
.saturating_sub(includes[first].line.start_offset),
),
kind: FoldKind::Imports,
});
}
at = last + 1;
}
folds
}
fn spans_lines(source: &str, range: SourceRange) -> bool {
source
.get(range.start_offset..range.end_offset())
.is_some_and(|text| text.contains('\n'))
}
fn newlines_between(source: &str, one: &SourceRange, other: &SourceRange) -> usize {
let (from, to) = if one.start_offset <= other.start_offset {
(one.start_offset, other.start_offset)
} else {
(other.start_offset, one.start_offset)
};
source
.get(from..to)
.map(|text| text.matches('\n').count())
.unwrap_or(0)
}
fn is_a_comment(kind: CppTokenKind) -> bool {
matches!(kind, CppTokenKind::LineComment | CppTokenKind::BlockComment)
}