296 lines
8.7 KiB
Rust
296 lines
8.7 KiB
Rust
use rnix::ast::{Attr, HasEntry};
|
|
use rowan::ast::AstNode;
|
|
|
|
use crate::{FileId, ast};
|
|
|
|
pub fn parse_file(file_id: FileId, source: &str) -> ast::ParsedFile {
|
|
let parse = rnix::Root::parse(source);
|
|
let source_len = source.len();
|
|
|
|
let syntax = parse.syntax();
|
|
let root = rnix::ast::Root::cast(syntax.clone()).expect("parser root is a root node");
|
|
let root = convert_expr(root.expr().expect("parser root has an expression"));
|
|
let (nodes, tokens) = convert_syntax(syntax);
|
|
|
|
ast::ParsedFile {
|
|
file_id,
|
|
root,
|
|
nodes,
|
|
tokens,
|
|
errors: parse
|
|
.errors()
|
|
.iter()
|
|
.map(|error| convert_parse_error(error, source_len))
|
|
.collect(),
|
|
}
|
|
}
|
|
|
|
fn convert_syntax(syntax: rnix::SyntaxNode) -> (Vec<ast::Node>, Vec<ast::Token>) {
|
|
let mut nodes = Vec::new();
|
|
let mut tokens = Vec::new();
|
|
|
|
for element in syntax.descendants_with_tokens() {
|
|
match element {
|
|
rnix::NodeOrToken::Node(node) => nodes.extend(convert_node(node)),
|
|
rnix::NodeOrToken::Token(token) => tokens.extend(convert_token(token)),
|
|
}
|
|
}
|
|
|
|
(nodes, tokens)
|
|
}
|
|
|
|
fn convert_expr(expr: rnix::ast::Expr) -> ast::Expr {
|
|
match expr {
|
|
rnix::ast::Expr::Ident(ident) => ast::Expr::Ident(ident.into()),
|
|
rnix::ast::Expr::Select(select) => convert_select_expr(select),
|
|
rnix::ast::Expr::Apply(apply) => ast::Expr::Apply(ast::Apply {
|
|
lambda: Box::new(convert_expr(apply.lambda().expect("applications have a lambda"))),
|
|
argument: Box::new(convert_expr(
|
|
apply.argument().expect("applications have an argument"),
|
|
)),
|
|
}),
|
|
rnix::ast::Expr::LetIn(let_in) => ast::Expr::Let {
|
|
range: let_in.syntax().text_range().into(),
|
|
bindings: let_in
|
|
.attrpath_values()
|
|
.filter_map(convert_binding_ast)
|
|
.collect(),
|
|
body: Box::new(convert_expr(
|
|
let_in.body().expect("let expressions have bodies"),
|
|
)),
|
|
},
|
|
rnix::ast::Expr::AttrSet(attr_set) => ast::Expr::AttrSet(convert_attr_set(attr_set)),
|
|
rnix::ast::Expr::Lambda(lambda) => ast::Expr::Lambda {
|
|
parameters: lambda_parameters(&lambda),
|
|
body: Box::new(convert_expr(lambda.body().expect("lambdas have bodies"))),
|
|
},
|
|
expr => ast::Expr::Other(
|
|
expr.syntax()
|
|
.children()
|
|
.filter_map(rnix::ast::Expr::cast)
|
|
.map(convert_expr)
|
|
.collect(),
|
|
),
|
|
}
|
|
}
|
|
|
|
fn convert_select_expr(select: rnix::ast::Select) -> ast::Expr {
|
|
select.clone().try_into().map(ast::Expr::Select).unwrap_or_else(|_| {
|
|
ast::Expr::Other(
|
|
select
|
|
.syntax()
|
|
.children()
|
|
.filter_map(rnix::ast::Expr::cast)
|
|
.map(convert_expr)
|
|
.collect(),
|
|
)
|
|
})
|
|
}
|
|
|
|
fn convert_binding_ast(binding: rnix::ast::AttrpathValue) -> Option<ast::Binding> {
|
|
let mut attrs = binding.attrpath()?.attrs();
|
|
let Attr::Ident(key) = attrs.next()? else {
|
|
return None;
|
|
};
|
|
|
|
Some(ast::Binding {
|
|
range: binding.syntax().text_range().into(),
|
|
key: key.into(),
|
|
value: convert_expr(binding.value()?),
|
|
})
|
|
}
|
|
|
|
fn convert_attr_set(attr_set: rnix::ast::AttrSet) -> Vec<ast::Binding> {
|
|
attr_set
|
|
.entries()
|
|
.flat_map(|entry| match entry {
|
|
rnix::ast::Entry::AttrpathValue(binding) => {
|
|
convert_binding_ast(binding).into_iter().collect()
|
|
}
|
|
rnix::ast::Entry::Inherit(inherit) => convert_inherit(inherit),
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
fn convert_inherit(inherit: rnix::ast::Inherit) -> Vec<ast::Binding> {
|
|
let value = inherit
|
|
.from()
|
|
.and_then(|from| from.expr())
|
|
.map(convert_expr);
|
|
|
|
inherit
|
|
.attrs()
|
|
.filter_map(|attr| match attr {
|
|
Attr::Ident(ident) => Some(ident),
|
|
_ => None,
|
|
})
|
|
.map(|key| ast::Binding {
|
|
range: key.syntax().text_range().into(),
|
|
value: value
|
|
.clone()
|
|
.unwrap_or_else(|| ast::Expr::Ident(key.clone().into())),
|
|
key: key.into(),
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
fn lambda_parameters(lambda: &rnix::ast::Lambda) -> Vec<ast::Ident> {
|
|
match lambda.param() {
|
|
Some(rnix::ast::Param::IdentParam(parameter)) => {
|
|
parameter.ident().map(Into::into).into_iter().collect()
|
|
}
|
|
Some(rnix::ast::Param::Pattern(pattern)) => pattern
|
|
.pat_entries()
|
|
.filter_map(|entry| entry.ident())
|
|
.chain(pattern.pat_bind().and_then(|binding| binding.ident()))
|
|
.map(Into::into)
|
|
.collect(),
|
|
None => Vec::new(),
|
|
}
|
|
}
|
|
|
|
fn convert_node(node: rnix::SyntaxNode) -> Option<ast::Node> {
|
|
match node.kind() {
|
|
rnix::SyntaxKind::NODE_ATTRPATH_VALUE => convert_binding(node),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn convert_binding(node: rnix::SyntaxNode) -> Option<ast::Node> {
|
|
let binding = rnix::ast::AttrpathValue::cast(node)?;
|
|
let range = binding.syntax().text_range().into();
|
|
let mut attrs = binding.attrpath()?.attrs();
|
|
let Attr::Ident(key) = attrs.next()? else {
|
|
return None;
|
|
};
|
|
if attrs.next().is_some() {
|
|
return None;
|
|
}
|
|
|
|
Some(ast::Node {
|
|
range,
|
|
data: ast::NodeData::Binding(ast::Binding {
|
|
range,
|
|
key: key.into(),
|
|
value: convert_expr(binding.value()?),
|
|
}),
|
|
})
|
|
}
|
|
|
|
impl TryFrom<rnix::ast::AttrpathValue> for ast::Binding {
|
|
type Error = ();
|
|
|
|
fn try_from(binding: rnix::ast::AttrpathValue) -> Result<Self, Self::Error> {
|
|
let mut attrs = binding.attrpath().ok_or(())?.attrs();
|
|
let key = match attrs.next().ok_or(())? {
|
|
Attr::Ident(ident) => ident.into(),
|
|
_ => return Err(()),
|
|
};
|
|
|
|
if attrs.next().is_some() {
|
|
return Err(());
|
|
}
|
|
|
|
let value = binding.value().ok_or(())?.try_into()?;
|
|
|
|
Ok(Self {
|
|
range: binding.syntax().text_range().into(),
|
|
key,
|
|
value,
|
|
})
|
|
}
|
|
}
|
|
|
|
impl TryFrom<rnix::ast::Expr> for ast::Expr {
|
|
type Error = ();
|
|
|
|
fn try_from(expr: rnix::ast::Expr) -> Result<Self, Self::Error> {
|
|
match expr {
|
|
rnix::ast::Expr::Ident(ident) => Ok(Self::Ident(ident.into())),
|
|
rnix::ast::Expr::Select(select) => Ok(Self::Select(select.try_into()?)),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<rnix::ast::Ident> for ast::Ident {
|
|
fn from(ident: rnix::ast::Ident) -> Self {
|
|
Self {
|
|
name: ident.to_string(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl TryFrom<rnix::ast::Select> for ast::Select {
|
|
type Error = ();
|
|
|
|
fn try_from(select: rnix::ast::Select) -> Result<Self, Self::Error> {
|
|
if select.or_token().is_some() {
|
|
return Err(());
|
|
}
|
|
|
|
let mut attrs = select.attrpath().ok_or(())?.attrs();
|
|
let attr = match attrs.next().ok_or(())? {
|
|
Attr::Ident(ident) => ident.into(),
|
|
_ => return Err(()),
|
|
};
|
|
|
|
if attrs.next().is_some() {
|
|
return Err(());
|
|
}
|
|
|
|
Ok(Self {
|
|
receiver: select.expr().ok_or(())?.syntax().to_string(),
|
|
attr,
|
|
})
|
|
}
|
|
}
|
|
|
|
fn convert_token(token: rnix::SyntaxToken) -> Option<ast::Token> {
|
|
match token.kind() {
|
|
rnix::SyntaxKind::TOKEN_URI => Some(ast::Token {
|
|
range: token.text_range().into(),
|
|
data: ast::TokenData::UnquotedUri(token.text().to_string()),
|
|
}),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn convert_parse_error(error: &rnix::ParseError, source_len: usize) -> ast::ParseError {
|
|
ast::ParseError {
|
|
range: parse_error_range(error, source_len),
|
|
message: error.to_string(),
|
|
}
|
|
}
|
|
|
|
fn parse_error_range(error: &rnix::ParseError, source_len: usize) -> ast::SourceRange {
|
|
match error {
|
|
rnix::ParseError::Unexpected(range)
|
|
| rnix::ParseError::UnexpectedExtra(range)
|
|
| rnix::ParseError::UnexpectedWanted(_, range, _)
|
|
| rnix::ParseError::UnexpectedDoubleBind(range)
|
|
| rnix::ParseError::DuplicatedArgs(range, _) => (*range).into(),
|
|
|
|
rnix::ParseError::UnexpectedEOF
|
|
| rnix::ParseError::UnexpectedEOFWanted(_)
|
|
| rnix::ParseError::RecursionLimitExceeded => ast::SourceRange {
|
|
start: source_len,
|
|
end: source_len,
|
|
},
|
|
|
|
_ => ast::SourceRange {
|
|
start: source_len,
|
|
end: source_len,
|
|
},
|
|
}
|
|
}
|
|
|
|
impl From<rnix::TextRange> for ast::SourceRange {
|
|
fn from(range: rnix::TextRange) -> Self {
|
|
Self {
|
|
start: usize::from(range.start()),
|
|
end: usize::from(range.end()),
|
|
}
|
|
}
|
|
}
|