tokit 0.0.0

Blazing fast parser combinators: parse-while-lexing (zero-copy), deterministic LALR-style parsing, no backtracking. Flexible emitters for fail-fast runtime or greedy compiler diagnostics
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use super::super::{CstElement, Language};
use derive_more::{From, Into};
use rowan::SyntaxNode;

/// An error indicating a mismatch between expected and actual syntax node kinds.
///
/// This error occurs when attempting to cast a [`SyntaxNode`] to a typed [`CstNode`](crate::cst::CstNode)
/// type, but the node's kind doesn't match the expected kind for that type.
///
/// # Examples
///
/// ```rust,ignore
/// use tokit::cst::{CstNode, error};
///
/// let result = IdentifierNode::try_cast_node(syntax_node);
///
/// match result {
///     Ok(identifier) => {
///         // Successfully cast
///         println!("Identifier: {}", identifier.source_string());
///     }
///     Err(mismatch) => {
///         // Cast failed
///         eprintln!("Type mismatch: {}", mismatch);
///         eprintln!("Expected: {:?}", mismatch.expected());
///         eprintln!("Found: {:?}", mismatch.found().kind());
///     }
/// }
/// ```
///
/// ## Recovering from Errors
///
/// ```rust,ignore
/// use tokit::cst::error::CstNodeMismatch;
///
/// let result = Expression::try_cast_node(syntax_node);
///
/// let node = match result {
///     Ok(expr) => expr,
///     Err(mismatch) => {
///         // Recover the original syntax node
///         let (expected_kind, original_node) = mismatch.into_components();
///         // Try a different type
///         Statement::try_cast_node(original_node)?
///     }
/// };
/// ```
#[derive(Debug, Clone, PartialEq, Eq, Hash, From, Into)]
pub struct CstNodeMismatch<N, Lang: Language> {
  found: SyntaxNode<Lang>,
  _m: core::marker::PhantomData<N>,
}

impl<N: CstElement<Lang>, Lang: Language> core::fmt::Display for CstNodeMismatch<N, Lang>
where
  Lang::Kind: core::fmt::Display,
{
  #[inline]
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    write!(
      f,
      "syntax node mismatch: expected syntax node of kind {}, but found syntax node of kind {}",
      N::KIND,
      self.found.kind()
    )
  }
}

impl<N: CstElement<Lang>, Lang: Language> core::error::Error for CstNodeMismatch<N, Lang>
where
  N: CstElement<Lang> + core::fmt::Debug,
  Lang::Kind: core::fmt::Display,
{
}

impl<N, Lang: Language> CstNodeMismatch<N, Lang> {
  /// Creates a new syntax node mismatch error.
  ///
  /// # Examples
  ///
  /// ```rust,ignore
  /// use tokit::cst::error::CstNodeMismatch;
  ///
  /// let error = CstNodeMismatch::new(
  ///     SyntaxKind::Identifier,
  ///     syntax_node
  /// );
  /// ```
  #[inline]
  pub const fn new(found: SyntaxNode<Lang>) -> Self {
    Self {
      found,
      _m: core::marker::PhantomData,
    }
  }

  /// Returns the expected syntax node kind.
  ///
  /// # Examples
  ///
  /// ```rust,ignore
  /// use tokit::cst::Node;
  ///
  /// if let Err(mismatch) = IdentifierNode::try_cast_node(node) {
  ///     println!("Expected kind: {:?}", mismatch.expected());
  /// }
  /// ```
  #[inline]
  pub const fn expected(&self) -> Lang::Kind
  where
    N: CstElement<Lang>,
  {
    N::KIND
  }

  /// Returns a reference to the syntax node that was found.
  ///
  /// # Examples
  ///
  /// ```rust,ignore
  /// use tokit::cst::CstNode;
  ///
  /// if let Err(mismatch) = IdentifierNode::try_cast_node(node) {
  ///     println!("Found kind: {:?}", mismatch.found().kind());
  ///     println!("Found text: {}", mismatch.found().text());
  /// }
  /// ```
  #[inline]
  pub const fn found(&self) -> &SyntaxNode<Lang> {
    &self.found
  }

  /// Consumes the error and returns the expected kind and found node.
  ///
  /// This is useful for recovering the original syntax node after a failed cast,
  /// allowing you to try casting to a different type.
  ///
  /// # Examples
  ///
  /// ```rust,ignore
  /// use tokit::cst::CstNode;
  ///
  /// let result = IdentifierNode::try_cast_node(syntax_node);
  ///
  /// if let Err(mismatch) = result {
  ///     let (expected, node) = mismatch.into_components();
  ///     // Try casting to a different type
  ///     let keyword = KeywordNode::try_cast_node(node)?;
  /// }
  /// ```
  #[inline]
  pub fn into_components(self) -> (Lang::Kind, SyntaxNode<Lang>)
  where
    N: CstElement<Lang>,
  {
    (N::KIND, self.found)
  }
}