tomlsmith 0.4.1

A lossless, error-tolerant TOML toolchain
Documentation
// This file is generated by `cargo run -p xtask -- codegen`.
// Do not edit it by hand.

#![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(),
        }
    }
}