use cpp_parser::{CppSyntaxNode, CppSyntaxTree, SourceRange};
use crate::{
expand::{Expansion, expand},
preprocess::{FilePreprocessing, preprocess},
token::Token,
};
#[derive(Debug, Clone)]
pub struct FileTokens {
source: Box<str>,
tokens: Vec<Token>,
}
impl FileTokens {
pub fn from_tree(source: &str, tree: &CppSyntaxTree) -> Self {
let tokens = tree
.get_red_root()
.descendants_with_tokens()
.filter_map(|element| element.into_token())
.map(|token| Token::from_syntax(&token))
.collect();
FileTokens {
source: source.into(),
tokens,
}
}
pub fn source(&self) -> &str {
&self.source
}
pub fn tokens(&self) -> &[Token] {
&self.tokens
}
pub fn is_empty(&self) -> bool {
self.tokens.is_empty()
}
pub fn len(&self) -> usize {
self.tokens.len()
}
pub fn in_range(&self, range: SourceRange) -> Vec<Token> {
self.tokens
.iter()
.filter(|token| {
token.range.start_offset >= range.start_offset
&& token.range.end_offset() <= range.end_offset()
})
.cloned()
.collect()
}
pub fn token_at(&self, offset: usize) -> Option<&Token> {
let index = self
.tokens
.partition_point(|token| token.range.end_offset() <= offset);
self.tokens
.get(index)
.filter(|token| token.range.start_offset <= offset)
}
pub fn span(&self) -> Option<SourceRange> {
let first = self.tokens.first()?;
let last = self.tokens.last()?;
Some(SourceRange::new(
first.range.start_offset,
last.range.end_offset() - first.range.start_offset,
))
}
}
#[derive(Debug, Clone)]
pub struct FileAnalysis {
pub tokens: FileTokens,
pub preprocessing: FilePreprocessing,
}
impl FileAnalysis {
pub fn new(source: &str, tree: &CppSyntaxTree) -> Self {
FileAnalysis {
tokens: FileTokens::from_tree(source, tree),
preprocessing: preprocess(source, tree.get_tokens()),
}
}
pub fn parse(source: &str, config: cpp_parser::ParserConfig<'_>) -> Self {
let tree = cpp_parser::CppParser::parse(source, config);
FileAnalysis::new(source, &tree)
}
pub fn expand_range(&self, range: SourceRange) -> Expansion {
let tokens = self.tokens.in_range(range);
expand(&tokens, &self.preprocessing.macros_at(range.start_offset))
}
pub fn expand_node(&self, node: &CppSyntaxNode) -> Expansion {
self.expand_range(cpp_parser::source_range(node.text_range()))
}
pub fn expand_line_at(&self, offset: usize) -> Expansion {
let span = self.line_range_at(offset);
self.expand_range(span)
}
pub fn line_range_at(&self, offset: usize) -> SourceRange {
let source = self.tokens.source();
let offset = offset.min(source.len());
let start = source[..offset]
.rfind('\n')
.map(|index| index + 1)
.unwrap_or(0);
let end = source[offset..]
.find('\n')
.map(|index| offset + index + 1)
.unwrap_or(source.len());
SourceRange::new(start, end - start)
}
}
pub mod coordinates;
pub mod paths;
pub mod token;
pub mod vfs;
pub mod view;