#![allow(dead_code)]
use super::{SyntaxKind, SyntaxNode};
pub(crate) trait AstNode: Clone {
fn can_cast(kind: SyntaxKind) -> bool;
fn cast(syntax: SyntaxNode) -> Option<Self>;
fn syntax(&self) -> &SyntaxNode;
}
#[derive(Clone, Debug)]
pub(crate) struct Root {
syntax: SyntaxNode,
}
impl AstNode for Root {
fn can_cast(kind: SyntaxKind) -> bool {
kind == SyntaxKind::Root
}
fn cast(syntax: SyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind()).then_some(Self { syntax })
}
fn syntax(&self) -> &SyntaxNode {
&self.syntax
}
}
#[derive(Clone, Debug)]
pub(crate) struct KeyValue {
syntax: SyntaxNode,
}
impl AstNode for KeyValue {
fn can_cast(kind: SyntaxKind) -> bool {
kind == SyntaxKind::KeyValue
}
fn cast(syntax: SyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind()).then_some(Self { syntax })
}
fn syntax(&self) -> &SyntaxNode {
&self.syntax
}
}
#[derive(Clone, Debug)]
pub(crate) struct Table {
syntax: SyntaxNode,
}
impl AstNode for Table {
fn can_cast(kind: SyntaxKind) -> bool {
kind == SyntaxKind::Table
}
fn cast(syntax: SyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind()).then_some(Self { syntax })
}
fn syntax(&self) -> &SyntaxNode {
&self.syntax
}
}
#[derive(Clone, Debug)]
pub(crate) struct ArrayTable {
syntax: SyntaxNode,
}
impl AstNode for ArrayTable {
fn can_cast(kind: SyntaxKind) -> bool {
kind == SyntaxKind::ArrayTable
}
fn cast(syntax: SyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind()).then_some(Self { syntax })
}
fn syntax(&self) -> &SyntaxNode {
&self.syntax
}
}
#[derive(Clone, Debug)]
pub(crate) struct Key {
syntax: SyntaxNode,
}
impl AstNode for Key {
fn can_cast(kind: SyntaxKind) -> bool {
kind == SyntaxKind::Key
}
fn cast(syntax: SyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind()).then_some(Self { syntax })
}
fn syntax(&self) -> &SyntaxNode {
&self.syntax
}
}
#[derive(Clone, Debug)]
pub(crate) struct Value {
syntax: SyntaxNode,
}
impl AstNode for Value {
fn can_cast(kind: SyntaxKind) -> bool {
kind == SyntaxKind::Value
}
fn cast(syntax: SyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind()).then_some(Self { syntax })
}
fn syntax(&self) -> &SyntaxNode {
&self.syntax
}
}
#[derive(Clone, Debug)]
pub(crate) struct Array {
syntax: SyntaxNode,
}
impl AstNode for Array {
fn can_cast(kind: SyntaxKind) -> bool {
kind == SyntaxKind::Array
}
fn cast(syntax: SyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind()).then_some(Self { syntax })
}
fn syntax(&self) -> &SyntaxNode {
&self.syntax
}
}
#[derive(Clone, Debug)]
pub(crate) struct InlineTable {
syntax: SyntaxNode,
}
impl AstNode for InlineTable {
fn can_cast(kind: SyntaxKind) -> bool {
kind == SyntaxKind::InlineTable
}
fn cast(syntax: SyntaxNode) -> Option<Self> {
Self::can_cast(syntax.kind()).then_some(Self { syntax })
}
fn syntax(&self) -> &SyntaxNode {
&self.syntax
}
}
#[derive(Clone, Debug)]
pub(crate) enum Statement {
KeyValue(KeyValue),
Table(Table),
ArrayTable(ArrayTable),
}
impl Statement {
pub(crate) fn cast(syntax: SyntaxNode) -> Option<Self> {
match syntax.kind() {
SyntaxKind::KeyValue => KeyValue::cast(syntax).map(Self::KeyValue),
SyntaxKind::Table => Table::cast(syntax).map(Self::Table),
SyntaxKind::ArrayTable => ArrayTable::cast(syntax).map(Self::ArrayTable),
_ => None,
}
}
pub(crate) fn syntax(&self) -> &SyntaxNode {
match self {
Self::KeyValue(node) => node.syntax(),
Self::Table(node) => node.syntax(),
Self::ArrayTable(node) => node.syntax(),
}
}
}