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

use super::{MissingToken, Trailing};
use crate::{Lexer, Token, punct::*};

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

        impl<Kind, O> MissingToken<'_, Kind, O, Trailing<$name>> {
          #[doc = "Create a new `MissingToken` error indicating a trailing `" $name "` was missing for a specific language."]
          #[cfg_attr(not(tarpaulin), inline(always))]
          pub const fn [< trailing_ $name:snake>](
            offset: O,
          ) -> Self {
            Self::[< trailing_ $name:snake _of>](offset)
          }
        }

        impl<Kind, O, Lang: ?Sized> MissingToken<'_, Kind, O, Trailing<$name, Lang>> {
          #[doc = "Create a new `MissingToken` error indicating a trailing `" $name "` was missing for a specific language."]
          #[cfg_attr(not(tarpaulin), inline(always))]
          pub const fn [< trailing_ $name:snake _of>](
            offset: O,
          ) -> Self {
            Self::trailing_of(offset)
          }
        }

        impl<Kind, O, Lang: ?Sized> ::core::fmt::Debug for MissingToken<'_, Kind, O, Trailing<$name, Lang>>
        where
          O: ::core::fmt::Debug,
        {
          #[cfg_attr(not(tarpaulin), inline(always))]
          fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            f.debug_struct(stringify!([< MissingTrailing $name >]))
              .field("offset", &self.offset)
              .finish()
          }
        }

        impl<Kind, O, Lang: ?Sized> ::core::fmt::Display for MissingToken<'_, Kind, O, Trailing<$name, Lang>>
        where
          O: ::core::fmt::Display,
        {
          #[cfg_attr(not(tarpaulin), inline(always))]
          fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            write!(
              f,
              "missing trailing {} token at {}",
              stringify!([< $name: snake >]),
              self.offset
            )
          }
        }

        impl<Kind, O, Lang: ?Sized> ::core::error::Error for MissingToken<'_, Kind, O, Trailing<$name, Lang>>
        where
          O: ::core::fmt::Display + ::core::fmt::Debug,
        {
        }
      )*
    }
  };
}

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

/// A type alias for an `MissingPrefix` error indicating a trailing punctuator was missing for a given lexer and separator.
pub type MissingTrailingOf<'inp, Sep, L, Lang = ()> = MissingToken<
  'inp,
  <<L as Lexer<'inp>>::Token as Token<'inp>>::Kind,
  <L as Lexer<'inp>>::Offset,
  Trailing<Sep, Lang>,
>;