use crate::diagnostics::{FileDiagnostics, SourceFile, Spanned, SpannedWithSourceFile};
pub use rowan::SmolStr;
use std::convert::TryFrom;
mod document;
mod expressions;
mod statements;
mod r#type;
mod prelude {
#[cfg(test)]
pub use super::{syntax_nodes, SyntaxNode, SyntaxNodeVerify};
pub use super::{DefaultParser, Parser, SyntaxKind};
#[cfg(test)]
pub use parser_test_macro::parser_test;
}
#[cfg(test)]
pub trait SyntaxNodeVerify {
const KIND: SyntaxKind;
fn verify(node: SyntaxNode) {
assert_eq!(node.kind(), Self::KIND)
}
}
#[cfg(test)]
macro_rules! verify_node {
($node:ident, _) => {};
($node:ident, [ $($t1:tt $($t2:ident)?),* ]) => {
$(verify_node!(@check_has_children $node, $t1 $($t2)* );)*
for c in $node.children() {
assert!(
false $(|| c.kind() == verify_node!(@extract_kind $t1 $($t2)*))*,
format!("Node is none of [{}]\n{:?}", stringify!($($t1 $($t2)*),*) ,c));
}
$(
for _c in $node.children().filter(|n| n.kind() == verify_node!(@extract_kind $t1 $($t2)*)) {
<verify_node!(@extract_type $t1 $($t2)*)>::verify(_c)
}
)*
};
(@check_has_children $node:ident, * $kind:ident) => {};
(@check_has_children $node:ident, ? $kind:ident) => {
let count = $node.children_with_tokens().filter(|n| n.kind() == SyntaxKind::$kind).count();
assert!(count <= 1, "Expecting one or zero sub-node of type {}, found {}\n{:?}", stringify!($kind), count, $node);
};
(@check_has_children $node:ident, $kind:ident) => {
let count = $node.children_with_tokens().filter(|n| n.kind() == SyntaxKind::$kind).count();
assert_eq!(count, 1, "Expecting exactly one sub-node of type {}\n{:?}", stringify!($kind), $node);
};
(@check_has_children $node:ident, $count:literal $kind:ident) => {
let count = $node.children_with_tokens().filter(|n| n.kind() == SyntaxKind::$kind).count();
assert_eq!(count, $count, "Expecting {} sub-node of type {}, found {}\n{:?}", $count, stringify!($kind), count, $node);
};
(@extract_kind * $kind:ident) => {SyntaxKind::$kind};
(@extract_kind ? $kind:ident) => {SyntaxKind::$kind};
(@extract_kind $count:literal $kind:ident) => {SyntaxKind::$kind};
(@extract_kind $kind:ident) => {SyntaxKind::$kind};
(@extract_type * $kind:ident) => {$crate::parser::syntax_nodes::$kind};
(@extract_type ? $kind:ident) => {$crate::parser::syntax_nodes::$kind};
(@extract_type $count:literal $kind:ident) => {$crate::parser::syntax_nodes::$kind};
(@extract_type $kind:ident) => {$crate::parser::syntax_nodes::$kind};
}
macro_rules! node_accessors {
(_) => {};
([ $($t1:tt $($t2:ident)?),* ]) => {
$(node_accessors!{@ $t1 $($t2)*} )*
};
(@ * $kind:ident) => {
#[allow(non_snake_case)]
pub fn $kind(&self) -> impl Iterator<Item = $kind> {
self.0.children().filter(|n| n.kind() == SyntaxKind::$kind).map(Into::into)
}
};
(@ ? $kind:ident) => {
#[allow(non_snake_case)]
pub fn $kind(&self) -> Option<$kind> {
self.0.child_node(SyntaxKind::$kind).map(Into::into)
}
};
(@ 2 $kind:ident) => {
#[allow(non_snake_case)]
pub fn $kind(&self) -> ($kind, $kind) {
let mut it = self.0.children().filter(|n| n.kind() == SyntaxKind::$kind);
let a = it.next().unwrap();
let b = it.next().unwrap();
debug_assert!(it.next().is_none());
(a.into(), b.into())
}
};
(@ 3 $kind:ident) => {
#[allow(non_snake_case)]
pub fn $kind(&self) -> ($kind, $kind, $kind) {
let mut it = self.0.children().filter(|n| n.kind() == SyntaxKind::$kind);
let a = it.next().unwrap();
let b = it.next().unwrap();
let c = it.next().unwrap();
debug_assert!(it.next().is_none());
(a.into(), b.into(), c.into())
}
};
(@ $kind:ident) => {
#[allow(non_snake_case)]
pub fn $kind(&self) -> $kind {
self.0.child_node(SyntaxKind::$kind).unwrap().into()
}
};
}
macro_rules! declare_syntax {
({
$($token:ident -> $rule:expr ,)*
}
{
$( $(#[$attr:meta])* $nodekind:ident -> $children:tt ,)*
})
=> {
#[repr(u16)]
#[derive(Debug, Copy, Clone, Eq, PartialEq, num_enum::IntoPrimitive, num_enum::TryFromPrimitive)]
pub enum SyntaxKind {
Error,
Eof,
$(
$token,
)*
$(
$(#[$attr])*
$nodekind,
)*
}
pub fn lex_next_token(text : &str) -> Option<(usize, SyntaxKind)> {
use crate::lexer::LexingRule;
$(
let len = ($rule).lex(text);
if len > 0 {
return Some((len, SyntaxKind::$token));
}
)*
None
}
pub mod syntax_nodes {
use super::*;
use derive_more::*;
$(
#[derive(Debug, Clone, From, Deref, DerefMut, Into)]
pub struct $nodekind(pub SyntaxNodeWithSourceFile);
#[cfg(test)]
impl SyntaxNodeVerify for $nodekind {
const KIND: SyntaxKind = SyntaxKind::$nodekind;
fn verify(node: SyntaxNode) {
assert_eq!(node.kind(), Self::KIND);
verify_node!(node, $children);
}
}
impl $nodekind {
node_accessors!{$children}
}
impl Spanned for $nodekind {
fn span(&self) -> crate::diagnostics::Span {
self.0.span()
}
}
impl SpannedWithSourceFile for $nodekind {
fn source_file(&self) -> Option<&SourceFile> {
self.0.source_file()
}
}
)*
}
}
}
declare_syntax! {
{
Whitespace -> &crate::lexer::lex_whitespace,
Comment -> &crate::lexer::lex_comment,
StringLiteral -> &crate::lexer::lex_string,
NumberLiteral -> &crate::lexer::lex_number,
ColorLiteral -> &crate::lexer::lex_color,
Identifier -> &crate::lexer::lex_identifier,
DoubleArrow -> "<=>",
PlusEqual -> "+=",
MinusEqual -> "-=",
StarEqual -> "*=",
DivEqual -> "/=",
LessEqual -> "<=",
GreaterEqual -> ">=",
EqualEqual -> "==",
NotEqual -> "!=",
ColonEqual -> ":=",
FatArrow -> "=>",
OrOr -> "||",
AndAnd -> "&&",
LBrace -> "{",
RBrace -> "}",
LParent -> "(",
RParent -> ")",
LAngle -> "<",
RAngle -> ">",
LBracket -> "[",
RBracket -> "]",
Plus -> "+",
Minus -> "-",
Star -> "*",
Div -> "/",
Equal -> "=",
Colon -> ":",
Comma -> ",",
Semicolon -> ";",
Bang -> "!",
Dot -> ".",
Question -> "?",
Dollar -> "$",
}
{
Document -> [ *Component, *ExportsList, *ImportSpecifier ],
Component -> [ Element ],
SubElement -> [ Element ],
Element -> [ ?QualifiedName, *PropertyDeclaration, *Binding, *SignalConnection,
*SignalDeclaration, *SubElement, *RepeatedElement, *PropertyAnimation,
*TwoWayBinding, *States, *Transitions, ?ChildrenPlaceholder ],
RepeatedElement -> [ ?DeclaredIdentifier, ?RepeatedIndex, Expression , Element],
RepeatedIndex -> [],
ConditionalElement -> [ Expression , Element],
SignalDeclaration -> [ DeclaredIdentifier, *Type ],
SignalConnection -> [ *DeclaredIdentifier, CodeBlock ],
PropertyDeclaration-> [ Type , DeclaredIdentifier, ?BindingExpression, ?TwoWayBinding ],
PropertyAnimation-> [ *QualifiedName, *Binding ],
QualifiedName-> [],
DeclaredIdentifier -> [],
ChildrenPlaceholder -> [],
Binding-> [ BindingExpression ],
TwoWayBinding -> [ Expression ],
BindingExpression-> [ ?CodeBlock, ?Expression ],
CodeBlock-> [ *Expression ],
Expression-> [ ?Expression, ?BangExpression, ?FunctionCallExpression, ?SelfAssignment,
?ConditionalExpression, ?QualifiedName, ?BinaryExpression, ?Array, ?ObjectLiteral,
?UnaryOpExpression, ?CodeBlock],
BangExpression -> [Expression],
FunctionCallExpression -> [*Expression],
SelfAssignment -> [2 Expression],
ConditionalExpression -> [3 Expression],
BinaryExpression -> [2 Expression],
UnaryOpExpression -> [Expression],
Array -> [ *Expression ],
ObjectLiteral -> [ *ObjectMember ],
ObjectMember -> [ Expression ],
States -> [*State],
State -> [DeclaredIdentifier, ?Expression, *StatePropertyChange],
StatePropertyChange -> [ QualifiedName, BindingExpression ],
Transitions -> [*Transition],
Transition -> [DeclaredIdentifier, *PropertyAnimation],
ExportsList -> [ *ExportSpecifier, *Component ],
ExportSpecifier -> [ ExportIdentifier, ?ExportName ],
ExportIdentifier -> [],
ExportName -> [],
ImportSpecifier -> [ ImportIdentifierList ],
ImportIdentifierList -> [ *ImportIdentifier ],
ImportIdentifier -> [ ExternalName, ?InternalName ],
ExternalName -> [],
InternalName -> [],
Type -> [ ?QualifiedName, ?ObjectType, ?ArrayType ],
ObjectType ->[ *ObjectTypeMember ],
ObjectTypeMember -> [ Type ],
ArrayType -> [ Type ],
}
}
impl From<SyntaxKind> for rowan::SyntaxKind {
fn from(v: SyntaxKind) -> Self {
rowan::SyntaxKind(v.into())
}
}
#[derive(Clone, Debug)]
pub struct Token {
pub kind: SyntaxKind,
pub text: SmolStr,
pub offset: usize,
#[cfg(feature = "proc_macro_span")]
pub span: Option<proc_macro::Span>,
}
impl Default for Token {
fn default() -> Self {
Token {
kind: SyntaxKind::Eof,
text: Default::default(),
offset: 0,
#[cfg(feature = "proc_macro_span")]
span: None,
}
}
}
impl Token {
pub fn as_str(&self) -> &str {
self.text.as_str()
}
pub fn kind(&self) -> SyntaxKind {
self.kind
}
}
mod parser_trait {
use super::*;
pub trait Parser: Sized {
type Checkpoint: Clone;
#[must_use = "The node will be finished when it is dropped"]
fn start_node(&mut self, kind: SyntaxKind) -> Node<Self> {
self.start_node_impl(kind, None, NodeToken(()));
Node(self)
}
#[must_use = "use start_node_at to use this checkpoint"]
fn checkpoint(&mut self) -> Self::Checkpoint;
#[must_use = "The node will be finished when it is dropped"]
fn start_node_at(&mut self, checkpoint: Self::Checkpoint, kind: SyntaxKind) -> Node<Self> {
self.start_node_impl(kind, Some(checkpoint), NodeToken(()));
Node(self)
}
fn finish_node_impl(&mut self, token: NodeToken);
fn start_node_impl(
&mut self,
kind: SyntaxKind,
checkpoint: Option<Self::Checkpoint>,
token: NodeToken,
);
fn peek(&mut self) -> Token {
self.nth(0)
}
fn nth(&mut self, n: usize) -> Token;
fn consume(&mut self);
fn error(&mut self, e: impl Into<String>);
fn expect(&mut self, kind: SyntaxKind) -> bool {
if !self.test(kind) {
self.error(format!("Syntax error: expected {:?}", kind));
return false;
}
return true;
}
fn test(&mut self, kind: SyntaxKind) -> bool {
if self.nth(0).kind() != kind {
return false;
}
self.consume();
return true;
}
fn until(&mut self, kind: SyntaxKind) {
while {
let k = self.nth(0).kind();
k != kind && k != SyntaxKind::Eof
} {
self.consume();
}
self.expect(kind);
}
}
pub struct NodeToken(());
#[derive(derive_more::DerefMut)]
pub struct Node<'a, P: Parser>(&'a mut P);
impl<'a, P: Parser> Drop for Node<'a, P> {
fn drop(&mut self) {
self.0.finish_node_impl(NodeToken(()));
}
}
impl<'a, P: Parser> core::ops::Deref for Node<'a, P> {
type Target = P;
fn deref(&self) -> &Self::Target {
self.0
}
}
}
#[doc(inline)]
pub use parser_trait::*;
pub struct DefaultParser {
builder: rowan::GreenNodeBuilder<'static>,
tokens: Vec<Token>,
cursor: usize,
diags: FileDiagnostics,
}
impl From<Vec<Token>> for DefaultParser {
fn from(tokens: Vec<Token>) -> Self {
Self { builder: Default::default(), tokens, cursor: 0, diags: Default::default() }
}
}
impl DefaultParser {
pub fn new(source: String) -> Self {
let mut parser = Self::from(crate::lexer::lex(&source));
parser.diags.source = Some(source);
parser
}
fn current_token(&self) -> Token {
self.tokens.get(self.cursor).cloned().unwrap_or_default()
}
pub fn consume_ws(&mut self) {
while matches!(self.current_token().kind, SyntaxKind::Whitespace | SyntaxKind::Comment) {
self.consume()
}
}
}
impl Parser for DefaultParser {
fn start_node_impl(
&mut self,
kind: SyntaxKind,
checkpoint: Option<Self::Checkpoint>,
_: NodeToken,
) {
match checkpoint {
None => self.builder.start_node(kind.into()),
Some(cp) => self.builder.start_node_at(cp, kind.into()),
}
}
fn finish_node_impl(&mut self, _: NodeToken) {
self.builder.finish_node();
}
fn nth(&mut self, mut n: usize) -> Token {
self.consume_ws();
let mut c = self.cursor;
while n > 0 {
n -= 1;
c += 1;
while c < self.tokens.len()
&& matches!(self.tokens[c].kind, SyntaxKind::Whitespace | SyntaxKind::Comment)
{
c += 1;
}
}
self.tokens.get(c).cloned().unwrap_or_default()
}
fn consume(&mut self) {
let t = self.current_token();
self.builder.token(t.kind.into(), t.text);
self.cursor += 1;
}
fn error(&mut self, e: impl Into<String>) {
let current_token = self.current_token();
#[allow(unused_mut)]
let mut span = crate::diagnostics::Span::new(current_token.offset);
#[cfg(feature = "proc_macro_span")]
{
span.span = current_token.span;
}
self.diags.push_error_with_span(e.into(), span);
}
type Checkpoint = rowan::Checkpoint;
fn checkpoint(&mut self) -> Self::Checkpoint {
self.builder.checkpoint()
}
}
#[derive(Clone, Copy, Debug, Eq, Ord, Hash, PartialEq, PartialOrd)]
pub enum Language {}
impl rowan::Language for Language {
type Kind = SyntaxKind;
fn kind_from_raw(raw: rowan::SyntaxKind) -> Self::Kind {
SyntaxKind::try_from(raw.0).unwrap()
}
fn kind_to_raw(kind: Self::Kind) -> rowan::SyntaxKind {
kind.into()
}
}
pub type SyntaxNode = rowan::SyntaxNode<Language>;
pub type SyntaxToken = rowan::SyntaxToken<Language>;
pub trait SyntaxNodeEx {
fn child_node(&self, kind: SyntaxKind) -> Option<SyntaxNode>;
fn child_token(&self, kind: SyntaxKind) -> Option<SyntaxToken>;
fn child_text(&self, kind: SyntaxKind) -> Option<String>;
}
impl SyntaxNodeEx for SyntaxNode {
fn child_node(&self, kind: SyntaxKind) -> Option<SyntaxNode> {
self.children().find(|n| n.kind() == kind)
}
fn child_token(&self, kind: SyntaxKind) -> Option<SyntaxToken> {
self.children_with_tokens().find(|n| n.kind() == kind).and_then(|x| x.into_token())
}
fn child_text(&self, kind: SyntaxKind) -> Option<String> {
self.children_with_tokens()
.find(|n| n.kind() == kind)
.and_then(|x| x.as_token().map(|x| x.text().to_string()))
}
}
impl Spanned for SyntaxNode {
fn span(&self) -> crate::diagnostics::Span {
crate::diagnostics::Span::new(self.text_range().start().into())
}
}
impl Spanned for SyntaxToken {
fn span(&self) -> crate::diagnostics::Span {
crate::diagnostics::Span::new(self.text_range().start().into())
}
}
#[derive(Debug, Clone)]
pub struct SyntaxNodeWithSourceFile {
pub node: SyntaxNode,
pub source_file: Option<SourceFile>,
}
#[derive(Debug, Clone, derive_more::Deref)]
pub struct SyntaxTokenWithSourceFile {
#[deref]
pub token: SyntaxToken,
pub source_file: Option<SourceFile>,
}
impl std::fmt::Display for SyntaxTokenWithSourceFile {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
self.token.fmt(f)
}
}
impl SyntaxNodeWithSourceFile {
pub fn child_node(&self, kind: SyntaxKind) -> Option<SyntaxNodeWithSourceFile> {
self.node
.children()
.find(|n| n.kind() == kind)
.map(|node| SyntaxNodeWithSourceFile { node, source_file: self.source_file.clone() })
}
pub fn child_token(&self, kind: SyntaxKind) -> Option<SyntaxTokenWithSourceFile> {
self.node
.children_with_tokens()
.find(|n| n.kind() == kind)
.and_then(|x| x.into_token())
.map(|token| SyntaxTokenWithSourceFile { token, source_file: self.source_file.clone() })
}
pub fn child_text(&self, kind: SyntaxKind) -> Option<String> {
self.node
.children_with_tokens()
.find(|n| n.kind() == kind)
.and_then(|x| x.as_token().map(|x| x.text().to_string()))
}
pub fn kind(&self) -> SyntaxKind {
self.node.kind()
}
pub fn children(&self) -> impl Iterator<Item = SyntaxNodeWithSourceFile> {
let source_file = self.source_file.clone();
self.node
.children()
.map(move |node| SyntaxNodeWithSourceFile { node, source_file: source_file.clone() })
}
pub fn children_with_tokens(&self) -> impl Iterator<Item = NodeOrTokenWithSourceFile> {
let source_file = self.source_file.clone();
self.node.children_with_tokens().map(move |token| NodeOrTokenWithSourceFile {
node_or_token: token,
source_file: source_file.clone(),
})
}
pub fn text(&self) -> rowan::SyntaxText {
self.node.text()
}
}
pub struct NodeOrTokenWithSourceFile {
node_or_token: rowan::NodeOrToken<SyntaxNode, SyntaxToken>,
source_file: Option<SourceFile>,
}
impl NodeOrTokenWithSourceFile {
pub fn kind(&self) -> SyntaxKind {
self.node_or_token.kind()
}
pub fn as_node(&self) -> Option<SyntaxNodeWithSourceFile> {
self.node_or_token.as_node().map(|node| SyntaxNodeWithSourceFile {
node: node.clone(),
source_file: self.source_file.clone(),
})
}
pub fn as_token(&self) -> Option<SyntaxTokenWithSourceFile> {
self.node_or_token.as_token().map(|token| SyntaxTokenWithSourceFile {
token: token.clone(),
source_file: self.source_file.clone(),
})
}
pub fn into_token(self) -> Option<SyntaxTokenWithSourceFile> {
let source_file = self.source_file.clone();
self.node_or_token
.into_token()
.map(move |token| SyntaxTokenWithSourceFile { token, source_file: source_file.clone() })
}
}
impl Spanned for SyntaxNodeWithSourceFile {
fn span(&self) -> crate::diagnostics::Span {
self.node.span()
}
}
impl SpannedWithSourceFile for SyntaxNodeWithSourceFile {
fn source_file(&self) -> Option<&SourceFile> {
self.source_file.as_ref()
}
}
impl Spanned for Option<SyntaxNodeWithSourceFile> {
fn span(&self) -> crate::diagnostics::Span {
self.as_ref().map(|n| n.span()).unwrap_or_default()
}
}
impl SpannedWithSourceFile for Option<SyntaxNodeWithSourceFile> {
fn source_file(&self) -> Option<&SourceFile> {
self.as_ref().map(|n| n.source_file.as_ref()).unwrap_or_default()
}
}
impl Spanned for SyntaxTokenWithSourceFile {
fn span(&self) -> crate::diagnostics::Span {
self.token.span()
}
}
impl SpannedWithSourceFile for SyntaxTokenWithSourceFile {
fn source_file(&self) -> Option<&SourceFile> {
self.source_file.as_ref()
}
}
pub fn parse(
source: String,
path: Option<&std::path::Path>,
) -> (SyntaxNodeWithSourceFile, FileDiagnostics) {
let mut p = DefaultParser::new(source);
document::parse_document(&mut p);
let source_file = if let Some(path) = path {
p.diags.current_path = std::rc::Rc::new(path.to_path_buf());
Some(p.diags.current_path.clone())
} else {
None
};
(
SyntaxNodeWithSourceFile { node: SyntaxNode::new_root(p.builder.finish()), source_file },
p.diags,
)
}
pub fn parse_file<P: AsRef<std::path::Path>>(
path: P,
) -> std::io::Result<(SyntaxNodeWithSourceFile, FileDiagnostics)> {
let source = std::fs::read_to_string(&path)?;
Ok(parse(source, Some(path.as_ref())))
}
#[allow(dead_code)]
pub fn parse_tokens(tokens: Vec<Token>) -> (SyntaxNode, FileDiagnostics) {
let mut p = DefaultParser::from(tokens);
document::parse_document(&mut p);
(SyntaxNode::new_root(p.builder.finish()), p.diags)
}