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

use super::{Leading, UnexpectedToken};
use crate::{Lexer, Token, punct::*};

macro_rules! alias {
  (
    $(
      $(#[$attr:meta])*
      $name:ident
    ), +$(,)?
  ) => {
    paste::paste! {
      $(
        $(#[$attr])*
        pub type [< UnexpectedLeading $name >] <'inp, L, Lang = ()> = UnexpectedLeadingOf<'inp, $name, L, Lang>;

        impl<T, Kind, S> UnexpectedToken<'_, T, Kind, S, Leading<$name>> {
          #[doc = "Create a new `UnexpectedToken` error indicating a leading `" $name "` was found."]
          #[cfg_attr(not(tarpaulin), inline(always))]
          pub const fn [< leading_ $name:snake>](
            span: S,
            token: T,
          ) -> Self {
            Self::[< leading_ $name:snake _of>](span, token)
          }
        }

        impl<T, Kind, S, Lang> UnexpectedToken<'_, T, Kind, S, Leading<$name, Lang>> {
          #[doc = "Create a new `UnexpectedToken` error indicating a leading `" $name "` was found for the given langauge."]
          #[cfg_attr(not(tarpaulin), inline(always))]
          pub const fn [< leading_ $name:snake _of>](
            span: S,
            token: T,
          ) -> Self {
            Self::leading_of(span, token)
          }
        }

        impl<T, Kind, S, Lang> ::core::fmt::Debug for UnexpectedToken<'_, T, Kind, S, Leading<$name, Lang>>
        where
          S: ::core::fmt::Debug,
          T: ::core::fmt::Debug,
          Lang: ?Sized,
        {
          #[cfg_attr(not(tarpaulin), inline(always))]
          fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            f.debug_struct(stringify!([< UnexpectedLeading $name >]))
              .field("span", &self.span)
              .field("found", &self.found)
              .finish()
          }
        }

        impl<T, Kind, S, Lang> ::core::fmt::Display for UnexpectedToken<'_, T, Kind, S, Leading<$name, Lang>>
        where
          S: ::core::fmt::Display,
          Lang: ?Sized,
        {
          #[cfg_attr(not(tarpaulin), inline(always))]
          fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            write!(
              f,
              "unexpected leading {} token at {}",
              stringify!([< $name: snake >]),
              self.span
            )
          }
        }

        impl<T, Kind, S, Lang> ::core::error::Error for UnexpectedToken<'_, T, Kind, S, Leading<$name, Lang>>
        where
          S: ::core::fmt::Display + ::core::fmt::Debug,
          T: ::core::fmt::Debug,
          Lang: ?Sized,
        {
        }
      )*
    }
  };
}

alias! {
  /// A type alias for an `UnexpectedToken` error indicating a leading comma was found.
  Comma,
  /// A type alias for an `UnexpectedToken` error indicating a leading dot was found.
  Dot,
  /// A type alias for an `UnexpectedToken` error indicating a leading underscore was found.
  Underscore,
  /// A type alias for an `UnexpectedToken` error indicating a leading pipe was found.
  Pipe,
  /// A type alias for an `UnexpectedToken` error indicating a leading ampersand was found.
  Ampersand,
  /// A type alias for an `UnexpectedToken` error indicating a leading hyphen was found.
  Hyphen,
  /// A type alias for an `UnexpectedToken` error indicating a leading double colon was found.
  DoubleColon,
}

/// A type alias for an `UnexpectedPrefix` error indicating a leading punctuator was found for a given lexer and separator.
pub type UnexpectedLeadingOf<'inp, Sep, L, Lang = ()> = UnexpectedToken<
  'inp,
  <L as Lexer<'inp>>::Token,
  <<L as Lexer<'inp>>::Token as Token<'inp>>::Kind,
  <L as Lexer<'inp>>::Span,
  Leading<Sep, Lang>,
>;