mirror of
https://github.com/rust-lang/rust-analyzer
synced 2025-01-12 21:28:51 +00:00
Somewhat more san directory structure
This commit is contained in:
Aleksey Kladov
parent
a40b715ce1
commit
d94124e3b4
15 changed files with 153 additions and 152 deletions
140
src/parser/event.rs
Normal file
140
src/parser/event.rs
Normal file
|
|
@ -0,0 +1,140 @@
|
|||
use {File, FileBuilder, Sink, SyntaxKind, Token};
|
||||
use syntax_kinds::TOMBSTONE;
|
||||
use super::is_insignificant;
|
||||
|
||||
/// `Parser` produces a flat list of `Event`s.
|
||||
/// They are converted to a tree-structure in
|
||||
/// a separate pass, via `TreeBuilder`.
|
||||
#[derive(Debug)]
|
||||
pub(crate) enum Event {
|
||||
/// This event signifies the start of the node.
|
||||
/// It should be either abandoned (in which case the
|
||||
/// `kind` is `TOMBSTONE`, and the event is ignored),
|
||||
/// or completed via a `Finish` event.
|
||||
///
|
||||
/// All tokens between a `Start` and a `Finish` would
|
||||
/// become the children of the respective node.
|
||||
///
|
||||
/// For left-recursive syntactic constructs, the parser produces
|
||||
/// a child node before it sees a parent. `forward_parent`
|
||||
/// exists to allow to tweak parent-child relationships.
|
||||
///
|
||||
/// Consider this path
|
||||
///
|
||||
/// foo::bar
|
||||
///
|
||||
/// The events for it would look like this:
|
||||
///
|
||||
///
|
||||
/// START(PATH) IDENT('foo') FINISH START(PATH) COLONCOLON IDENT('bar') FINISH
|
||||
/// | /\
|
||||
/// | |
|
||||
/// +------forward-parent------+
|
||||
///
|
||||
/// And the tree would look like this
|
||||
///
|
||||
/// +--PATH---------+
|
||||
/// | | |
|
||||
/// | | |
|
||||
/// | '::' 'bar'
|
||||
/// |
|
||||
/// PATH
|
||||
/// |
|
||||
/// 'foo'
|
||||
///
|
||||
/// See also `CompleteMarker::precede`.
|
||||
Start {
|
||||
kind: SyntaxKind,
|
||||
forward_parent: Option<u32>,
|
||||
},
|
||||
|
||||
/// Complete the previous `Start` event
|
||||
Finish,
|
||||
|
||||
/// Produce a single leaf-element.
|
||||
/// `n_raw_tokens` is used to glue complex contextual tokens.
|
||||
/// For example, lexer tokenizes `>>` as `>`, `>`, and
|
||||
/// `n_raw_tokens = 2` is used to produced a single `>>`.
|
||||
Token {
|
||||
kind: SyntaxKind,
|
||||
n_raw_tokens: u8,
|
||||
},
|
||||
|
||||
Error {
|
||||
message: String,
|
||||
},
|
||||
}
|
||||
|
||||
pub(super) fn to_file(text: String, tokens: &[Token], events: Vec<Event>) -> File {
|
||||
let mut builder = FileBuilder::new(text);
|
||||
let mut idx = 0;
|
||||
|
||||
let mut holes = Vec::new();
|
||||
let mut forward_parents = Vec::new();
|
||||
|
||||
for (i, event) in events.iter().enumerate() {
|
||||
if holes.last() == Some(&i) {
|
||||
holes.pop();
|
||||
continue;
|
||||
}
|
||||
|
||||
match event {
|
||||
&Event::Start {
|
||||
kind: TOMBSTONE, ..
|
||||
} => (),
|
||||
|
||||
&Event::Start { .. } => {
|
||||
forward_parents.clear();
|
||||
let mut idx = i;
|
||||
loop {
|
||||
let (kind, fwd) = match events[idx] {
|
||||
Event::Start {
|
||||
kind,
|
||||
forward_parent,
|
||||
} => (kind, forward_parent),
|
||||
_ => unreachable!(),
|
||||
};
|
||||
forward_parents.push((idx, kind));
|
||||
if let Some(fwd) = fwd {
|
||||
idx += fwd as usize;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
for &(idx, kind) in forward_parents.iter().into_iter().rev() {
|
||||
builder.start_internal(kind);
|
||||
holes.push(idx);
|
||||
}
|
||||
holes.pop();
|
||||
}
|
||||
&Event::Finish => {
|
||||
while idx < tokens.len() {
|
||||
let token = tokens[idx];
|
||||
if is_insignificant(token.kind) {
|
||||
idx += 1;
|
||||
builder.leaf(token.kind, token.len);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
builder.finish_internal()
|
||||
}
|
||||
&Event::Token {
|
||||
kind: _,
|
||||
mut n_raw_tokens,
|
||||
} => loop {
|
||||
let token = tokens[idx];
|
||||
if !is_insignificant(token.kind) {
|
||||
n_raw_tokens -= 1;
|
||||
}
|
||||
idx += 1;
|
||||
builder.leaf(token.kind, token.len);
|
||||
if n_raw_tokens == 0 {
|
||||
break;
|
||||
}
|
||||
},
|
||||
&Event::Error { ref message } => builder.error().message(message.clone()).emit(),
|
||||
}
|
||||
}
|
||||
builder.finish()
|
||||
}
|
||||
|
|
@ -1,74 +0,0 @@
|
|||
use {SyntaxKind, Token};
|
||||
|
||||
#[macro_use]
|
||||
mod parser;
|
||||
mod grammar;
|
||||
|
||||
/// `Parser` produces a flat list of `Event`s.
|
||||
/// They are converted to a tree-structure in
|
||||
/// a separate pass, via `TreeBuilder`.
|
||||
#[derive(Debug)]
|
||||
pub(crate) enum Event {
|
||||
/// This event signifies the start of the node.
|
||||
/// It should be either abandoned (in which case the
|
||||
/// `kind` is `TOMBSTONE`, and the event is ignored),
|
||||
/// or completed via a `Finish` event.
|
||||
///
|
||||
/// All tokens between a `Start` and a `Finish` would
|
||||
/// become the children of the respective node.
|
||||
///
|
||||
/// For left-recursive syntactic constructs, the parser produces
|
||||
/// a child node before it sees a parent. `forward_parent`
|
||||
/// exists to allow to tweak parent-child relationships.
|
||||
///
|
||||
/// Consider this path
|
||||
///
|
||||
/// foo::bar
|
||||
///
|
||||
/// The events for it would look like this:
|
||||
///
|
||||
///
|
||||
/// START(PATH) IDENT('foo') FINISH START(PATH) COLONCOLON IDENT('bar') FINISH
|
||||
/// | /\
|
||||
/// | |
|
||||
/// +------forward-parent------+
|
||||
///
|
||||
/// And the tree would look like this
|
||||
///
|
||||
/// +--PATH---------+
|
||||
/// | | |
|
||||
/// | | |
|
||||
/// | '::' 'bar'
|
||||
/// |
|
||||
/// PATH
|
||||
/// |
|
||||
/// 'foo'
|
||||
///
|
||||
/// See also `CompleteMarker::precede`.
|
||||
Start {
|
||||
kind: SyntaxKind,
|
||||
forward_parent: Option<u32>,
|
||||
},
|
||||
|
||||
/// Complete the previous `Start` event
|
||||
Finish,
|
||||
|
||||
/// Produce a single leaf-element.
|
||||
/// `n_raw_tokens` is used to glue complex contextual tokens.
|
||||
/// For example, lexer tokenizes `>>` as `>`, `>`, and
|
||||
/// `n_raw_tokens = 2` is used to produced a single `>>`.
|
||||
Token {
|
||||
kind: SyntaxKind,
|
||||
n_raw_tokens: u8,
|
||||
},
|
||||
|
||||
Error {
|
||||
message: String,
|
||||
},
|
||||
}
|
||||
|
||||
pub(crate) fn parse<'t>(text: &'t str, raw_tokens: &'t [Token]) -> Vec<Event> {
|
||||
let mut parser = parser::Parser::new(text, raw_tokens);
|
||||
grammar::file(&mut parser);
|
||||
parser.into_events()
|
||||
}
|
||||
|
|
@ -1,88 +1,23 @@
|
|||
use {File, FileBuilder, Sink, SyntaxKind, Token};
|
||||
use {File, SyntaxKind, Token};
|
||||
|
||||
use syntax_kinds::*;
|
||||
|
||||
mod event_parser;
|
||||
use self::event_parser::Event;
|
||||
#[macro_use]
|
||||
mod parser;
|
||||
mod event;
|
||||
mod grammar;
|
||||
use self::event::Event;
|
||||
|
||||
/// Parse a sequence of tokens into the representative node tree
|
||||
pub fn parse(text: String, tokens: &[Token]) -> File {
|
||||
let events = event_parser::parse(&text, tokens);
|
||||
from_events_to_file(text, tokens, events)
|
||||
let events = parse_into_events(&text, tokens);
|
||||
event::to_file(text, tokens, events)
|
||||
}
|
||||
|
||||
fn from_events_to_file(text: String, tokens: &[Token], events: Vec<Event>) -> File {
|
||||
let mut builder = FileBuilder::new(text);
|
||||
let mut idx = 0;
|
||||
|
||||
let mut holes = Vec::new();
|
||||
let mut forward_parents = Vec::new();
|
||||
|
||||
for (i, event) in events.iter().enumerate() {
|
||||
if holes.last() == Some(&i) {
|
||||
holes.pop();
|
||||
continue;
|
||||
}
|
||||
|
||||
match event {
|
||||
&Event::Start {
|
||||
kind: TOMBSTONE, ..
|
||||
} => (),
|
||||
|
||||
&Event::Start { .. } => {
|
||||
forward_parents.clear();
|
||||
let mut idx = i;
|
||||
loop {
|
||||
let (kind, fwd) = match events[idx] {
|
||||
Event::Start {
|
||||
kind,
|
||||
forward_parent,
|
||||
} => (kind, forward_parent),
|
||||
_ => unreachable!(),
|
||||
};
|
||||
forward_parents.push((idx, kind));
|
||||
if let Some(fwd) = fwd {
|
||||
idx += fwd as usize;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
for &(idx, kind) in forward_parents.iter().into_iter().rev() {
|
||||
builder.start_internal(kind);
|
||||
holes.push(idx);
|
||||
}
|
||||
holes.pop();
|
||||
}
|
||||
&Event::Finish => {
|
||||
while idx < tokens.len() {
|
||||
let token = tokens[idx];
|
||||
if is_insignificant(token.kind) {
|
||||
idx += 1;
|
||||
builder.leaf(token.kind, token.len);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
builder.finish_internal()
|
||||
}
|
||||
&Event::Token {
|
||||
kind: _,
|
||||
mut n_raw_tokens,
|
||||
} => loop {
|
||||
let token = tokens[idx];
|
||||
if !is_insignificant(token.kind) {
|
||||
n_raw_tokens -= 1;
|
||||
}
|
||||
idx += 1;
|
||||
builder.leaf(token.kind, token.len);
|
||||
if n_raw_tokens == 0 {
|
||||
break;
|
||||
}
|
||||
},
|
||||
&Event::Error { ref message } => builder.error().message(message.clone()).emit(),
|
||||
}
|
||||
}
|
||||
builder.finish()
|
||||
pub(crate) fn parse_into_events<'t>(text: &'t str, raw_tokens: &'t [Token]) -> Vec<Event> {
|
||||
let mut parser = parser::Parser::new(text, raw_tokens);
|
||||
grammar::file(&mut parser);
|
||||
parser.into_events()
|
||||
}
|
||||
|
||||
fn is_insignificant(kind: SyntaxKind) -> bool {
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
use {SyntaxKind, TextUnit, Token};
|
||||
use super::Event;
|
||||
use super::super::is_insignificant;
|
||||
use super::is_insignificant;
|
||||
use SyntaxKind::{EOF, TOMBSTONE};
|
||||
|
||||
pub(crate) struct Marker {
|
||||
Loading…
Reference in a new issue