#[doc(hidden)]
mod __m2_syn_delimiters {
use ::m2_syn::{
DelimiterKind, DelimiterToken, Parse, ParseStream, PrettyNode, PrettyTree, Span, Spanned,
ToTokens, TokenParseError, TokenStream, parse_delimiter,
};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Spanned)]
pub struct _EmptyDelimiter {
span: Span,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _EmptyDelimiter<S: Spanned>(span: S) -> _EmptyDelimiter {
<_EmptyDelimiter as DelimiterToken>::new(span.span())
}
impl DelimiterToken for _EmptyDelimiter {
const KIND: DelimiterKind = DelimiterKind::Empty;
fn new(span: Span) -> Self {
Self { span }
}
}
impl Parse for _EmptyDelimiter {
fn parse(input: &mut ParseStream) -> Result<Self, TokenParseError> {
parse_delimiter(input)
}
}
impl ToTokens for _EmptyDelimiter {
fn to_tokens(&self, output: &mut TokenStream) {
self.surround(output, TokenStream::new());
}
}
impl PrettyTree for _EmptyDelimiter {
fn pretty_tree(&self) -> PrettyNode {
PrettyNode::delimiter(Self::KIND, self.span())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Spanned)]
pub struct _SemicolonDelimiter {
span: Span,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _SemicolonDelimiter<S: Spanned>(span: S) -> _SemicolonDelimiter {
<_SemicolonDelimiter as DelimiterToken>::new(span.span())
}
impl DelimiterToken for _SemicolonDelimiter {
const KIND: DelimiterKind = DelimiterKind::Semicolon;
fn new(span: Span) -> Self {
Self { span }
}
}
impl Parse for _SemicolonDelimiter {
fn parse(input: &mut ParseStream) -> Result<Self, TokenParseError> {
parse_delimiter(input)
}
}
impl ToTokens for _SemicolonDelimiter {
fn to_tokens(&self, output: &mut TokenStream) {
self.surround(output, TokenStream::new());
}
}
impl PrettyTree for _SemicolonDelimiter {
fn pretty_tree(&self) -> PrettyNode {
PrettyNode::delimiter(Self::KIND, self.span())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Spanned)]
pub struct _ParenthesisDelimiter {
span: Span,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _ParenthesisDelimiter<S: Spanned>(span: S) -> _ParenthesisDelimiter {
<_ParenthesisDelimiter as DelimiterToken>::new(span.span())
}
impl DelimiterToken for _ParenthesisDelimiter {
const KIND: DelimiterKind = DelimiterKind::Parenthesis;
fn new(span: Span) -> Self {
Self { span }
}
}
impl Parse for _ParenthesisDelimiter {
fn parse(input: &mut ParseStream) -> Result<Self, TokenParseError> {
parse_delimiter(input)
}
}
impl ToTokens for _ParenthesisDelimiter {
fn to_tokens(&self, output: &mut TokenStream) {
self.surround(output, TokenStream::new());
}
}
impl PrettyTree for _ParenthesisDelimiter {
fn pretty_tree(&self) -> PrettyNode {
PrettyNode::delimiter(Self::KIND, self.span())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Spanned)]
pub struct _BracketDelimiter {
span: Span,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _BracketDelimiter<S: Spanned>(span: S) -> _BracketDelimiter {
<_BracketDelimiter as DelimiterToken>::new(span.span())
}
impl DelimiterToken for _BracketDelimiter {
const KIND: DelimiterKind = DelimiterKind::Bracket;
fn new(span: Span) -> Self {
Self { span }
}
}
impl Parse for _BracketDelimiter {
fn parse(input: &mut ParseStream) -> Result<Self, TokenParseError> {
parse_delimiter(input)
}
}
impl ToTokens for _BracketDelimiter {
fn to_tokens(&self, output: &mut TokenStream) {
self.surround(output, TokenStream::new());
}
}
impl PrettyTree for _BracketDelimiter {
fn pretty_tree(&self) -> PrettyNode {
PrettyNode::delimiter(Self::KIND, self.span())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Spanned)]
pub struct _BraceDelimiter {
span: Span,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _BraceDelimiter<S: Spanned>(span: S) -> _BraceDelimiter {
<_BraceDelimiter as DelimiterToken>::new(span.span())
}
impl DelimiterToken for _BraceDelimiter {
const KIND: DelimiterKind = DelimiterKind::Brace;
fn new(span: Span) -> Self {
Self { span }
}
}
impl Parse for _BraceDelimiter {
fn parse(input: &mut ParseStream) -> Result<Self, TokenParseError> {
parse_delimiter(input)
}
}
impl ToTokens for _BraceDelimiter {
fn to_tokens(&self, output: &mut TokenStream) {
self.surround(output, TokenStream::new());
}
}
impl PrettyTree for _BraceDelimiter {
fn pretty_tree(&self) -> PrettyNode {
PrettyNode::delimiter(Self::KIND, self.span())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Spanned)]
pub struct _AngleBarDelimiter {
span: Span,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _AngleBarDelimiter<S: Spanned>(span: S) -> _AngleBarDelimiter {
<_AngleBarDelimiter as DelimiterToken>::new(span.span())
}
impl DelimiterToken for _AngleBarDelimiter {
const KIND: DelimiterKind = DelimiterKind::AngleBar;
fn new(span: Span) -> Self {
Self { span }
}
}
impl Parse for _AngleBarDelimiter {
fn parse(input: &mut ParseStream) -> Result<Self, TokenParseError> {
parse_delimiter(input)
}
}
impl ToTokens for _AngleBarDelimiter {
fn to_tokens(&self, output: &mut TokenStream) {
self.surround(output, TokenStream::new());
}
}
impl PrettyTree for _AngleBarDelimiter {
fn pretty_tree(&self) -> PrettyNode {
PrettyNode::delimiter(Self::KIND, self.span())
}
}
}
#[doc(hidden)]
pub use __m2_syn_delimiters::*;
#[macro_export]
macro_rules! Delimiter {
[] => { $crate::_EmptyDelimiter };
[;] => { $crate::_SemicolonDelimiter };
[()] => { $crate::_ParenthesisDelimiter };
[[]] => { $crate::_BracketDelimiter };
[{}] => { $crate::_BraceDelimiter };
[<| |>] => { $crate::_AngleBarDelimiter };
[$($unsupported:tt)*] => { compile_error!("delimiter was not declared") };
}
pub(crate) const PREC_CLOSER: u8 = 6;
pub(crate) const PREC_SEMICOLON: u8 = 8;
pub(crate) const PREC_COMMA: u8 = 10;
pub(crate) const PREC_CONTROL: u8 = 12;
pub(crate) const PREC_LOOP_CLAUSE: u8 = 16;
pub(crate) const PREC_COLLECTION: u8 = 56;
pub(crate) const PREC_APPLICATION_RIGHT: u8 = 61;
pub(crate) const PREC_APPLICATION: u8 = 62;
pub(crate) const PREC_QUOTE: u8 = 74;
pub(crate) const GENERATED_OPERATOR_SPELLINGS: &[&str] = &[
"!=", "#", "#?", "%", "%=", "&", "&=", "*", "*=", "**", "**=", "+", "+=", "++", "++=", "-",
"-=", "->", ".", "..", "..=", "..<", "..<=", ".?", "/", "/=", "//", "//=", ":", ":=", "<",
"<-", "<<", "<<=", "<=", "<==", "<===", "<==>", "<==>=", "=", "=!=", "==", "===", "===>",
"===>=", "==>", "==>=", "=>", ">", ">=", ">>", ">>=", "?", "??", "??=", "@", "@=", "@@", "@@=",
"@@?", "@@?=", "\\", "\\=", "\\\\", "\\\\=", "^", "^=", "^**", "^**=", "^<", "^<=", "^>",
"^>=", "^^", "^^=", "_", "_=", "_<", "_<=", "_>", "_>=", "|", "|=", "|-", "|-=", "|_", "|_=",
"||", "||=", "~", "~=", "·", "·=", "⊠", "⊠=", "⧢", "⧢=", "and", "or", "SPACE", "xor", "!",
"(*)", "^!", "^*", "^~", "_!", "_*", "_~", "not",
];
pub(crate) const GENERATED_POSTFIX_OPERATOR_SPELLINGS: &[&str] =
&["!", "(*)", "^!", "^*", "^~", "_!", "_*", "_~"];
pub(crate) const GENERATED_KEYWORD_SPELLINGS: &[&str] = &[
"break",
"breakpoint",
"catch",
"continue",
"do",
"elapsedTime",
"elapsedTiming",
"else",
"except",
"finish",
"for",
"from",
"global",
"if",
"in",
"list",
"local",
"new",
"of",
"profile",
"return",
"shield",
"step",
"symbol",
"TEST",
"then",
"threadLocal",
"threadVariable",
"throw",
"time",
"timing",
"to",
"trap",
"try",
"when",
"while",
];
pub(crate) const GENERATED_PUNCTUATION_SPELLINGS: &[&str] = &[
"!=", "#", "#?", "%", "%=", "&", "&=", "*", "*=", "**", "**=", "+", "+=", "++", "++=", "-",
"-=", "->", ".", "..", "..=", "..<", "..<=", ".?", "/", "/=", "//", "//=", ":", ":=", "<",
"<-", "<<", "<<=", "<=", "<==", "<===", "<==>", "<==>=", "=", "=!=", "==", "===", "===>",
"===>=", "==>", "==>=", "=>", ">", ">=", ">>", ">>=", "?", "??", "??=", "@", "@=", "@@", "@@=",
"@@?", "@@?=", "\\", "\\=", "\\\\", "\\\\=", "^", "^=", "^**", "^**=", "^<", "^<=", "^>",
"^>=", "^^", "^^=", "_", "_=", "_<", "_<=", "_>", "_>=", "|", "|=", "|-", "|-=", "|_", "|_=",
"||", "||=", "~", "~=", "·", "·=", "⊠", "⊠=", "⧢", "⧢=", "!", "(*)", "^!", "^*", "^~", "_!",
"_*", "_~", ";", ",",
];
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _BngEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _BngEql<S: ::m2_syn::Spanned>(span: S) -> _BngEql {
let span = span.span();
_BngEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("!=", span))),
}
}
impl ::m2_syn::Token for _BngEql {
const SPELLING: &'static str = "!=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "!=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _BngEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _BngEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _BngEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _BngEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("!=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"!=",
false,
node.identity(),
));
}
Ok(_BngEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Hsh {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Hsh<S: ::m2_syn::Spanned>(span: S) -> _Hsh {
let span = span.span();
_Hsh {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("#", span))),
}
}
impl ::m2_syn::Token for _Hsh {
const SPELLING: &'static str = "#";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "#",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Hsh {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Hsh {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Hsh {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Hsh
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("#", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"#",
false,
node.identity(),
));
}
Ok(_Hsh(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _HshQsm {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _HshQsm<S: ::m2_syn::Spanned>(span: S) -> _HshQsm {
let span = span.span();
_HshQsm {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("#?", span))),
}
}
impl ::m2_syn::Token for _HshQsm {
const SPELLING: &'static str = "#?";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "#?",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _HshQsm {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _HshQsm {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _HshQsm {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _HshQsm
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("#?", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"#?",
false,
node.identity(),
));
}
Ok(_HshQsm(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Mod {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Mod<S: ::m2_syn::Spanned>(span: S) -> _Mod {
let span = span.span();
_Mod {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("%", span))),
}
}
impl ::m2_syn::Token for _Mod {
const SPELLING: &'static str = "%";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "%",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Mod {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Mod {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Mod {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Mod
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("%", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"%",
false,
node.identity(),
));
}
Ok(_Mod(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _ModEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _ModEql<S: ::m2_syn::Spanned>(span: S) -> _ModEql {
let span = span.span();
_ModEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("%=", span))),
}
}
impl ::m2_syn::Token for _ModEql {
const SPELLING: &'static str = "%=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "%=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _ModEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _ModEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _ModEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _ModEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("%=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"%=",
false,
node.identity(),
));
}
Ok(_ModEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Amp {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Amp<S: ::m2_syn::Spanned>(span: S) -> _Amp {
let span = span.span();
_Amp {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("&", span))),
}
}
impl ::m2_syn::Token for _Amp {
const SPELLING: &'static str = "&";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "&",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Amp {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Amp {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Amp {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Amp
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("&", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"&",
false,
node.identity(),
));
}
Ok(_Amp(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _AmpEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _AmpEql<S: ::m2_syn::Spanned>(span: S) -> _AmpEql {
let span = span.span();
_AmpEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("&=", span))),
}
}
impl ::m2_syn::Token for _AmpEql {
const SPELLING: &'static str = "&=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "&=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _AmpEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _AmpEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _AmpEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _AmpEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("&=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"&=",
false,
node.identity(),
));
}
Ok(_AmpEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Mul {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Mul<S: ::m2_syn::Spanned>(span: S) -> _Mul {
let span = span.span();
_Mul {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("*", span))),
}
}
impl ::m2_syn::Token for _Mul {
const SPELLING: &'static str = "*";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "*",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Mul {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Mul {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Mul {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Mul
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("*", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"*",
false,
node.identity(),
));
}
Ok(_Mul(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _MulEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _MulEql<S: ::m2_syn::Spanned>(span: S) -> _MulEql {
let span = span.span();
_MulEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("*=", span))),
}
}
impl ::m2_syn::Token for _MulEql {
const SPELLING: &'static str = "*=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "*=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _MulEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _MulEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _MulEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _MulEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("*=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"*=",
false,
node.identity(),
));
}
Ok(_MulEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _MulMul {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _MulMul<S: ::m2_syn::Spanned>(span: S) -> _MulMul {
let span = span.span();
_MulMul {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("**", span))),
}
}
impl ::m2_syn::Token for _MulMul {
const SPELLING: &'static str = "**";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "**",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _MulMul {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _MulMul {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _MulMul {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _MulMul
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("**", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"**",
false,
node.identity(),
));
}
Ok(_MulMul(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _MulMulEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _MulMulEql<S: ::m2_syn::Spanned>(span: S) -> _MulMulEql {
let span = span.span();
_MulMulEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"**=", span,
))),
}
}
impl ::m2_syn::Token for _MulMulEql {
const SPELLING: &'static str = "**=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "**=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _MulMulEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _MulMulEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _MulMulEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _MulMulEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("**=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"**=",
false,
node.identity(),
));
}
Ok(_MulMulEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Add {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Add<S: ::m2_syn::Spanned>(span: S) -> _Add {
let span = span.span();
_Add {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("+", span))),
}
}
impl ::m2_syn::Token for _Add {
const SPELLING: &'static str = "+";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "+",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Add {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Add {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Add {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Add
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("+", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"+",
false,
node.identity(),
));
}
Ok(_Add(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _AddEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _AddEql<S: ::m2_syn::Spanned>(span: S) -> _AddEql {
let span = span.span();
_AddEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("+=", span))),
}
}
impl ::m2_syn::Token for _AddEql {
const SPELLING: &'static str = "+=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "+=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _AddEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _AddEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _AddEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _AddEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("+=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"+=",
false,
node.identity(),
));
}
Ok(_AddEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _AddAdd {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _AddAdd<S: ::m2_syn::Spanned>(span: S) -> _AddAdd {
let span = span.span();
_AddAdd {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("++", span))),
}
}
impl ::m2_syn::Token for _AddAdd {
const SPELLING: &'static str = "++";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "++",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _AddAdd {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _AddAdd {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _AddAdd {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _AddAdd
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("++", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"++",
false,
node.identity(),
));
}
Ok(_AddAdd(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _AddAddEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _AddAddEql<S: ::m2_syn::Spanned>(span: S) -> _AddAddEql {
let span = span.span();
_AddAddEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"++=", span,
))),
}
}
impl ::m2_syn::Token for _AddAddEql {
const SPELLING: &'static str = "++=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "++=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _AddAddEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _AddAddEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _AddAddEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _AddAddEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("++=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"++=",
false,
node.identity(),
));
}
Ok(_AddAddEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Sub {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Sub<S: ::m2_syn::Spanned>(span: S) -> _Sub {
let span = span.span();
_Sub {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("-", span))),
}
}
impl ::m2_syn::Token for _Sub {
const SPELLING: &'static str = "-";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "-",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Sub {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Sub {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Sub {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Sub
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("-", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"-",
false,
node.identity(),
));
}
Ok(_Sub(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _SubEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _SubEql<S: ::m2_syn::Spanned>(span: S) -> _SubEql {
let span = span.span();
_SubEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("-=", span))),
}
}
impl ::m2_syn::Token for _SubEql {
const SPELLING: &'static str = "-=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "-=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _SubEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _SubEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _SubEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _SubEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("-=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"-=",
false,
node.identity(),
));
}
Ok(_SubEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _SubGst {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _SubGst<S: ::m2_syn::Spanned>(span: S) -> _SubGst {
let span = span.span();
_SubGst {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("->", span))),
}
}
impl ::m2_syn::Token for _SubGst {
const SPELLING: &'static str = "->";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "->",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _SubGst {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _SubGst {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _SubGst {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _SubGst
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("->", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"->",
false,
node.identity(),
));
}
Ok(_SubGst(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Dot {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Dot<S: ::m2_syn::Spanned>(span: S) -> _Dot {
let span = span.span();
_Dot {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(".", span))),
}
}
impl ::m2_syn::Token for _Dot {
const SPELLING: &'static str = ".";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == ".",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Dot {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Dot {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Dot {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Dot
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches(".", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
".",
false,
node.identity(),
));
}
Ok(_Dot(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _DotDot {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _DotDot<S: ::m2_syn::Spanned>(span: S) -> _DotDot {
let span = span.span();
_DotDot {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("..", span))),
}
}
impl ::m2_syn::Token for _DotDot {
const SPELLING: &'static str = "..";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "..",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _DotDot {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _DotDot {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _DotDot {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _DotDot
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("..", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"..",
false,
node.identity(),
));
}
Ok(_DotDot(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _DotDotEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _DotDotEql<S: ::m2_syn::Spanned>(span: S) -> _DotDotEql {
let span = span.span();
_DotDotEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"..=", span,
))),
}
}
impl ::m2_syn::Token for _DotDotEql {
const SPELLING: &'static str = "..=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "..=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _DotDotEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _DotDotEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _DotDotEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _DotDotEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("..=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"..=",
false,
node.identity(),
));
}
Ok(_DotDotEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _DotDotLst {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _DotDotLst<S: ::m2_syn::Spanned>(span: S) -> _DotDotLst {
let span = span.span();
_DotDotLst {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"..<", span,
))),
}
}
impl ::m2_syn::Token for _DotDotLst {
const SPELLING: &'static str = "..<";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "..<",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _DotDotLst {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _DotDotLst {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _DotDotLst {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _DotDotLst
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("..<", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"..<",
false,
node.identity(),
));
}
Ok(_DotDotLst(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _DotDotLstEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _DotDotLstEql<S: ::m2_syn::Spanned>(span: S) -> _DotDotLstEql {
let span = span.span();
_DotDotLstEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"..<=", span,
))),
}
}
impl ::m2_syn::Token for _DotDotLstEql {
const SPELLING: &'static str = "..<=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "..<=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _DotDotLstEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _DotDotLstEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _DotDotLstEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _DotDotLstEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("..<=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"..<=",
false,
node.identity(),
));
}
Ok(_DotDotLstEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _DotQsm {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _DotQsm<S: ::m2_syn::Spanned>(span: S) -> _DotQsm {
let span = span.span();
_DotQsm {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(".?", span))),
}
}
impl ::m2_syn::Token for _DotQsm {
const SPELLING: &'static str = ".?";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == ".?",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _DotQsm {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _DotQsm {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _DotQsm {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _DotQsm
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches(".?", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
".?",
false,
node.identity(),
));
}
Ok(_DotQsm(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Slh {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Slh<S: ::m2_syn::Spanned>(span: S) -> _Slh {
let span = span.span();
_Slh {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("/", span))),
}
}
impl ::m2_syn::Token for _Slh {
const SPELLING: &'static str = "/";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "/",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Slh {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Slh {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Slh {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Slh
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("/", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"/",
false,
node.identity(),
));
}
Ok(_Slh(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _SlhEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _SlhEql<S: ::m2_syn::Spanned>(span: S) -> _SlhEql {
let span = span.span();
_SlhEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("/=", span))),
}
}
impl ::m2_syn::Token for _SlhEql {
const SPELLING: &'static str = "/=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "/=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _SlhEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _SlhEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _SlhEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _SlhEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("/=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"/=",
false,
node.identity(),
));
}
Ok(_SlhEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _SlhSlh {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _SlhSlh<S: ::m2_syn::Spanned>(span: S) -> _SlhSlh {
let span = span.span();
_SlhSlh {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("//", span))),
}
}
impl ::m2_syn::Token for _SlhSlh {
const SPELLING: &'static str = "//";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "//",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _SlhSlh {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _SlhSlh {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _SlhSlh {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _SlhSlh
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("//", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"//",
false,
node.identity(),
));
}
Ok(_SlhSlh(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _SlhSlhEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _SlhSlhEql<S: ::m2_syn::Spanned>(span: S) -> _SlhSlhEql {
let span = span.span();
_SlhSlhEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"//=", span,
))),
}
}
impl ::m2_syn::Token for _SlhSlhEql {
const SPELLING: &'static str = "//=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "//=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _SlhSlhEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _SlhSlhEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _SlhSlhEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _SlhSlhEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("//=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"//=",
false,
node.identity(),
));
}
Ok(_SlhSlhEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Col {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Col<S: ::m2_syn::Spanned>(span: S) -> _Col {
let span = span.span();
_Col {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(":", span))),
}
}
impl ::m2_syn::Token for _Col {
const SPELLING: &'static str = ":";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == ":",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Col {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Col {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Col {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Col
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches(":", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
":",
false,
node.identity(),
));
}
Ok(_Col(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _ColEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _ColEql<S: ::m2_syn::Spanned>(span: S) -> _ColEql {
let span = span.span();
_ColEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(":=", span))),
}
}
impl ::m2_syn::Token for _ColEql {
const SPELLING: &'static str = ":=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == ":=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _ColEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _ColEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _ColEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _ColEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches(":=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
":=",
false,
node.identity(),
));
}
Ok(_ColEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Lst {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Lst<S: ::m2_syn::Spanned>(span: S) -> _Lst {
let span = span.span();
_Lst {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("<", span))),
}
}
impl ::m2_syn::Token for _Lst {
const SPELLING: &'static str = "<";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "<",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Lst {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Lst {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Lst {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Lst
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("<", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"<",
false,
node.identity(),
));
}
Ok(_Lst(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _LstSub {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _LstSub<S: ::m2_syn::Spanned>(span: S) -> _LstSub {
let span = span.span();
_LstSub {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("<-", span))),
}
}
impl ::m2_syn::Token for _LstSub {
const SPELLING: &'static str = "<-";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "<-",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _LstSub {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _LstSub {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _LstSub {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _LstSub
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("<-", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"<-",
false,
node.identity(),
));
}
Ok(_LstSub(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _LstLst {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _LstLst<S: ::m2_syn::Spanned>(span: S) -> _LstLst {
let span = span.span();
_LstLst {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("<<", span))),
}
}
impl ::m2_syn::Token for _LstLst {
const SPELLING: &'static str = "<<";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "<<",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _LstLst {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _LstLst {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _LstLst {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _LstLst
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("<<", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"<<",
false,
node.identity(),
));
}
Ok(_LstLst(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _LstLstEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _LstLstEql<S: ::m2_syn::Spanned>(span: S) -> _LstLstEql {
let span = span.span();
_LstLstEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"<<=", span,
))),
}
}
impl ::m2_syn::Token for _LstLstEql {
const SPELLING: &'static str = "<<=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "<<=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _LstLstEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _LstLstEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _LstLstEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _LstLstEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("<<=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"<<=",
false,
node.identity(),
));
}
Ok(_LstLstEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _LstEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _LstEql<S: ::m2_syn::Spanned>(span: S) -> _LstEql {
let span = span.span();
_LstEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("<=", span))),
}
}
impl ::m2_syn::Token for _LstEql {
const SPELLING: &'static str = "<=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "<=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _LstEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _LstEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _LstEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _LstEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("<=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"<=",
false,
node.identity(),
));
}
Ok(_LstEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _LstEqlEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _LstEqlEql<S: ::m2_syn::Spanned>(span: S) -> _LstEqlEql {
let span = span.span();
_LstEqlEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"<==", span,
))),
}
}
impl ::m2_syn::Token for _LstEqlEql {
const SPELLING: &'static str = "<==";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "<==",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _LstEqlEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _LstEqlEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _LstEqlEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _LstEqlEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("<==", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"<==",
false,
node.identity(),
));
}
Ok(_LstEqlEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _LstEqlEqlEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _LstEqlEqlEql<S: ::m2_syn::Spanned>(span: S) -> _LstEqlEqlEql {
let span = span.span();
_LstEqlEqlEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"<===", span,
))),
}
}
impl ::m2_syn::Token for _LstEqlEqlEql {
const SPELLING: &'static str = "<===";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "<===",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _LstEqlEqlEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _LstEqlEqlEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _LstEqlEqlEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _LstEqlEqlEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("<===", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"<===",
false,
node.identity(),
));
}
Ok(_LstEqlEqlEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _LstEqlEqlGst {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _LstEqlEqlGst<S: ::m2_syn::Spanned>(span: S) -> _LstEqlEqlGst {
let span = span.span();
_LstEqlEqlGst {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"<==>", span,
))),
}
}
impl ::m2_syn::Token for _LstEqlEqlGst {
const SPELLING: &'static str = "<==>";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "<==>",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _LstEqlEqlGst {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _LstEqlEqlGst {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _LstEqlEqlGst {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _LstEqlEqlGst
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("<==>", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"<==>",
false,
node.identity(),
));
}
Ok(_LstEqlEqlGst(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _LstEqlEqlGstEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _LstEqlEqlGstEql<S: ::m2_syn::Spanned>(span: S) -> _LstEqlEqlGstEql {
let span = span.span();
_LstEqlEqlGstEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"<==>=", span,
))),
}
}
impl ::m2_syn::Token for _LstEqlEqlGstEql {
const SPELLING: &'static str = "<==>=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "<==>=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _LstEqlEqlGstEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _LstEqlEqlGstEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _LstEqlEqlGstEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _LstEqlEqlGstEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("<==>=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"<==>=",
false,
node.identity(),
));
}
Ok(_LstEqlEqlGstEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Eql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Eql<S: ::m2_syn::Spanned>(span: S) -> _Eql {
let span = span.span();
_Eql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("=", span))),
}
}
impl ::m2_syn::Token for _Eql {
const SPELLING: &'static str = "=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Eql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Eql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Eql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Eql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"=",
false,
node.identity(),
));
}
Ok(_Eql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _EqlBngEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _EqlBngEql<S: ::m2_syn::Spanned>(span: S) -> _EqlBngEql {
let span = span.span();
_EqlBngEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"=!=", span,
))),
}
}
impl ::m2_syn::Token for _EqlBngEql {
const SPELLING: &'static str = "=!=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "=!=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _EqlBngEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _EqlBngEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _EqlBngEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _EqlBngEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("=!=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"=!=",
false,
node.identity(),
));
}
Ok(_EqlBngEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _EqlEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _EqlEql<S: ::m2_syn::Spanned>(span: S) -> _EqlEql {
let span = span.span();
_EqlEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("==", span))),
}
}
impl ::m2_syn::Token for _EqlEql {
const SPELLING: &'static str = "==";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "==",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _EqlEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _EqlEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _EqlEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _EqlEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("==", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"==",
false,
node.identity(),
));
}
Ok(_EqlEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _EqlEqlEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _EqlEqlEql<S: ::m2_syn::Spanned>(span: S) -> _EqlEqlEql {
let span = span.span();
_EqlEqlEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"===", span,
))),
}
}
impl ::m2_syn::Token for _EqlEqlEql {
const SPELLING: &'static str = "===";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "===",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _EqlEqlEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _EqlEqlEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _EqlEqlEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _EqlEqlEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("===", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"===",
false,
node.identity(),
));
}
Ok(_EqlEqlEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _EqlEqlEqlGst {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _EqlEqlEqlGst<S: ::m2_syn::Spanned>(span: S) -> _EqlEqlEqlGst {
let span = span.span();
_EqlEqlEqlGst {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"===>", span,
))),
}
}
impl ::m2_syn::Token for _EqlEqlEqlGst {
const SPELLING: &'static str = "===>";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "===>",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _EqlEqlEqlGst {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _EqlEqlEqlGst {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _EqlEqlEqlGst {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _EqlEqlEqlGst
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("===>", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"===>",
false,
node.identity(),
));
}
Ok(_EqlEqlEqlGst(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _EqlEqlEqlGstEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _EqlEqlEqlGstEql<S: ::m2_syn::Spanned>(span: S) -> _EqlEqlEqlGstEql {
let span = span.span();
_EqlEqlEqlGstEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"===>=", span,
))),
}
}
impl ::m2_syn::Token for _EqlEqlEqlGstEql {
const SPELLING: &'static str = "===>=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "===>=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _EqlEqlEqlGstEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _EqlEqlEqlGstEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _EqlEqlEqlGstEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _EqlEqlEqlGstEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("===>=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"===>=",
false,
node.identity(),
));
}
Ok(_EqlEqlEqlGstEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _EqlEqlGst {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _EqlEqlGst<S: ::m2_syn::Spanned>(span: S) -> _EqlEqlGst {
let span = span.span();
_EqlEqlGst {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"==>", span,
))),
}
}
impl ::m2_syn::Token for _EqlEqlGst {
const SPELLING: &'static str = "==>";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "==>",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _EqlEqlGst {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _EqlEqlGst {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _EqlEqlGst {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _EqlEqlGst
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("==>", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"==>",
false,
node.identity(),
));
}
Ok(_EqlEqlGst(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _EqlEqlGstEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _EqlEqlGstEql<S: ::m2_syn::Spanned>(span: S) -> _EqlEqlGstEql {
let span = span.span();
_EqlEqlGstEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"==>=", span,
))),
}
}
impl ::m2_syn::Token for _EqlEqlGstEql {
const SPELLING: &'static str = "==>=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "==>=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _EqlEqlGstEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _EqlEqlGstEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _EqlEqlGstEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _EqlEqlGstEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("==>=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"==>=",
false,
node.identity(),
));
}
Ok(_EqlEqlGstEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _EqlGst {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _EqlGst<S: ::m2_syn::Spanned>(span: S) -> _EqlGst {
let span = span.span();
_EqlGst {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("=>", span))),
}
}
impl ::m2_syn::Token for _EqlGst {
const SPELLING: &'static str = "=>";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "=>",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _EqlGst {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _EqlGst {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _EqlGst {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _EqlGst
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("=>", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"=>",
false,
node.identity(),
));
}
Ok(_EqlGst(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Gst {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Gst<S: ::m2_syn::Spanned>(span: S) -> _Gst {
let span = span.span();
_Gst {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(">", span))),
}
}
impl ::m2_syn::Token for _Gst {
const SPELLING: &'static str = ">";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == ">",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Gst {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Gst {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Gst {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Gst
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches(">", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
">",
false,
node.identity(),
));
}
Ok(_Gst(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _GstEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _GstEql<S: ::m2_syn::Spanned>(span: S) -> _GstEql {
let span = span.span();
_GstEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(">=", span))),
}
}
impl ::m2_syn::Token for _GstEql {
const SPELLING: &'static str = ">=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == ">=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _GstEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _GstEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _GstEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _GstEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches(">=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
">=",
false,
node.identity(),
));
}
Ok(_GstEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _GstGst {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _GstGst<S: ::m2_syn::Spanned>(span: S) -> _GstGst {
let span = span.span();
_GstGst {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(">>", span))),
}
}
impl ::m2_syn::Token for _GstGst {
const SPELLING: &'static str = ">>";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == ">>",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _GstGst {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _GstGst {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _GstGst {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _GstGst
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches(">>", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
">>",
false,
node.identity(),
));
}
Ok(_GstGst(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _GstGstEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _GstGstEql<S: ::m2_syn::Spanned>(span: S) -> _GstGstEql {
let span = span.span();
_GstGstEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
">>=", span,
))),
}
}
impl ::m2_syn::Token for _GstGstEql {
const SPELLING: &'static str = ">>=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == ">>=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _GstGstEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _GstGstEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _GstGstEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _GstGstEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches(">>=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
">>=",
false,
node.identity(),
));
}
Ok(_GstGstEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Qsm {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Qsm<S: ::m2_syn::Spanned>(span: S) -> _Qsm {
let span = span.span();
_Qsm {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("?", span))),
}
}
impl ::m2_syn::Token for _Qsm {
const SPELLING: &'static str = "?";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "?",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Qsm {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Qsm {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Qsm {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Qsm
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("?", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"?",
false,
node.identity(),
));
}
Ok(_Qsm(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _QsmQsm {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _QsmQsm<S: ::m2_syn::Spanned>(span: S) -> _QsmQsm {
let span = span.span();
_QsmQsm {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("??", span))),
}
}
impl ::m2_syn::Token for _QsmQsm {
const SPELLING: &'static str = "??";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "??",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _QsmQsm {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _QsmQsm {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _QsmQsm {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _QsmQsm
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("??", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"??",
false,
node.identity(),
));
}
Ok(_QsmQsm(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _QsmQsmEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _QsmQsmEql<S: ::m2_syn::Spanned>(span: S) -> _QsmQsmEql {
let span = span.span();
_QsmQsmEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"??=", span,
))),
}
}
impl ::m2_syn::Token for _QsmQsmEql {
const SPELLING: &'static str = "??=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "??=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _QsmQsmEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _QsmQsmEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _QsmQsmEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _QsmQsmEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("??=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"??=",
false,
node.identity(),
));
}
Ok(_QsmQsmEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Att {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Att<S: ::m2_syn::Spanned>(span: S) -> _Att {
let span = span.span();
_Att {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("@", span))),
}
}
impl ::m2_syn::Token for _Att {
const SPELLING: &'static str = "@";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "@",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Att {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Att {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Att {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Att
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("@", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"@",
false,
node.identity(),
));
}
Ok(_Att(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _AttEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _AttEql<S: ::m2_syn::Spanned>(span: S) -> _AttEql {
let span = span.span();
_AttEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("@=", span))),
}
}
impl ::m2_syn::Token for _AttEql {
const SPELLING: &'static str = "@=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "@=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _AttEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _AttEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _AttEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _AttEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("@=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"@=",
false,
node.identity(),
));
}
Ok(_AttEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _AttAtt {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _AttAtt<S: ::m2_syn::Spanned>(span: S) -> _AttAtt {
let span = span.span();
_AttAtt {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("@@", span))),
}
}
impl ::m2_syn::Token for _AttAtt {
const SPELLING: &'static str = "@@";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "@@",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _AttAtt {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _AttAtt {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _AttAtt {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _AttAtt
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("@@", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"@@",
false,
node.identity(),
));
}
Ok(_AttAtt(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _AttAttEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _AttAttEql<S: ::m2_syn::Spanned>(span: S) -> _AttAttEql {
let span = span.span();
_AttAttEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"@@=", span,
))),
}
}
impl ::m2_syn::Token for _AttAttEql {
const SPELLING: &'static str = "@@=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "@@=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _AttAttEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _AttAttEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _AttAttEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _AttAttEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("@@=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"@@=",
false,
node.identity(),
));
}
Ok(_AttAttEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _AttAttQsm {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _AttAttQsm<S: ::m2_syn::Spanned>(span: S) -> _AttAttQsm {
let span = span.span();
_AttAttQsm {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"@@?", span,
))),
}
}
impl ::m2_syn::Token for _AttAttQsm {
const SPELLING: &'static str = "@@?";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "@@?",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _AttAttQsm {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _AttAttQsm {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _AttAttQsm {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _AttAttQsm
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("@@?", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"@@?",
false,
node.identity(),
));
}
Ok(_AttAttQsm(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _AttAttQsmEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _AttAttQsmEql<S: ::m2_syn::Spanned>(span: S) -> _AttAttQsmEql {
let span = span.span();
_AttAttQsmEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"@@?=", span,
))),
}
}
impl ::m2_syn::Token for _AttAttQsmEql {
const SPELLING: &'static str = "@@?=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "@@?=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _AttAttQsmEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _AttAttQsmEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _AttAttQsmEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _AttAttQsmEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("@@?=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"@@?=",
false,
node.identity(),
));
}
Ok(_AttAttQsmEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Bsl {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Bsl<S: ::m2_syn::Spanned>(span: S) -> _Bsl {
let span = span.span();
_Bsl {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("\\", span))),
}
}
impl ::m2_syn::Token for _Bsl {
const SPELLING: &'static str = "\\";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "\\",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Bsl {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Bsl {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Bsl {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Bsl
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("\\", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"\\",
false,
node.identity(),
));
}
Ok(_Bsl(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _BslEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _BslEql<S: ::m2_syn::Spanned>(span: S) -> _BslEql {
let span = span.span();
_BslEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"\\=", span,
))),
}
}
impl ::m2_syn::Token for _BslEql {
const SPELLING: &'static str = "\\=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "\\=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _BslEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _BslEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _BslEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _BslEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("\\=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"\\=",
false,
node.identity(),
));
}
Ok(_BslEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _BslBsl {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _BslBsl<S: ::m2_syn::Spanned>(span: S) -> _BslBsl {
let span = span.span();
_BslBsl {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"\\\\", span,
))),
}
}
impl ::m2_syn::Token for _BslBsl {
const SPELLING: &'static str = "\\\\";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "\\\\",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _BslBsl {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _BslBsl {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _BslBsl {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _BslBsl
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("\\\\", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"\\\\",
false,
node.identity(),
));
}
Ok(_BslBsl(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _BslBslEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _BslBslEql<S: ::m2_syn::Spanned>(span: S) -> _BslBslEql {
let span = span.span();
_BslBslEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"\\\\=", span,
))),
}
}
impl ::m2_syn::Token for _BslBslEql {
const SPELLING: &'static str = "\\\\=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "\\\\=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _BslBslEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _BslBslEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _BslBslEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _BslBslEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("\\\\=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"\\\\=",
false,
node.identity(),
));
}
Ok(_BslBslEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Crt {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Crt<S: ::m2_syn::Spanned>(span: S) -> _Crt {
let span = span.span();
_Crt {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("^", span))),
}
}
impl ::m2_syn::Token for _Crt {
const SPELLING: &'static str = "^";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "^",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Crt {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Crt {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Crt {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Crt
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("^", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"^",
false,
node.identity(),
));
}
Ok(_Crt(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _CrtEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _CrtEql<S: ::m2_syn::Spanned>(span: S) -> _CrtEql {
let span = span.span();
_CrtEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("^=", span))),
}
}
impl ::m2_syn::Token for _CrtEql {
const SPELLING: &'static str = "^=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "^=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _CrtEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _CrtEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _CrtEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _CrtEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("^=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"^=",
false,
node.identity(),
));
}
Ok(_CrtEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _CrtMulMul {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _CrtMulMul<S: ::m2_syn::Spanned>(span: S) -> _CrtMulMul {
let span = span.span();
_CrtMulMul {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"^**", span,
))),
}
}
impl ::m2_syn::Token for _CrtMulMul {
const SPELLING: &'static str = "^**";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "^**",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _CrtMulMul {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _CrtMulMul {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _CrtMulMul {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _CrtMulMul
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("^**", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"^**",
false,
node.identity(),
));
}
Ok(_CrtMulMul(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _CrtMulMulEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _CrtMulMulEql<S: ::m2_syn::Spanned>(span: S) -> _CrtMulMulEql {
let span = span.span();
_CrtMulMulEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"^**=", span,
))),
}
}
impl ::m2_syn::Token for _CrtMulMulEql {
const SPELLING: &'static str = "^**=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "^**=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _CrtMulMulEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _CrtMulMulEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _CrtMulMulEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _CrtMulMulEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("^**=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"^**=",
false,
node.identity(),
));
}
Ok(_CrtMulMulEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _CrtLst {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _CrtLst<S: ::m2_syn::Spanned>(span: S) -> _CrtLst {
let span = span.span();
_CrtLst {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("^<", span))),
}
}
impl ::m2_syn::Token for _CrtLst {
const SPELLING: &'static str = "^<";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "^<",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _CrtLst {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _CrtLst {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _CrtLst {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _CrtLst
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("^<", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"^<",
false,
node.identity(),
));
}
Ok(_CrtLst(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _CrtLstEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _CrtLstEql<S: ::m2_syn::Spanned>(span: S) -> _CrtLstEql {
let span = span.span();
_CrtLstEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"^<=", span,
))),
}
}
impl ::m2_syn::Token for _CrtLstEql {
const SPELLING: &'static str = "^<=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "^<=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _CrtLstEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _CrtLstEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _CrtLstEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _CrtLstEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("^<=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"^<=",
false,
node.identity(),
));
}
Ok(_CrtLstEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _CrtGst {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _CrtGst<S: ::m2_syn::Spanned>(span: S) -> _CrtGst {
let span = span.span();
_CrtGst {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("^>", span))),
}
}
impl ::m2_syn::Token for _CrtGst {
const SPELLING: &'static str = "^>";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "^>",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _CrtGst {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _CrtGst {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _CrtGst {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _CrtGst
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("^>", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"^>",
false,
node.identity(),
));
}
Ok(_CrtGst(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _CrtGstEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _CrtGstEql<S: ::m2_syn::Spanned>(span: S) -> _CrtGstEql {
let span = span.span();
_CrtGstEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"^>=", span,
))),
}
}
impl ::m2_syn::Token for _CrtGstEql {
const SPELLING: &'static str = "^>=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "^>=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _CrtGstEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _CrtGstEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _CrtGstEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _CrtGstEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("^>=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"^>=",
false,
node.identity(),
));
}
Ok(_CrtGstEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _CrtCrt {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _CrtCrt<S: ::m2_syn::Spanned>(span: S) -> _CrtCrt {
let span = span.span();
_CrtCrt {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("^^", span))),
}
}
impl ::m2_syn::Token for _CrtCrt {
const SPELLING: &'static str = "^^";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "^^",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _CrtCrt {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _CrtCrt {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _CrtCrt {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _CrtCrt
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("^^", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"^^",
false,
node.identity(),
));
}
Ok(_CrtCrt(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _CrtCrtEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _CrtCrtEql<S: ::m2_syn::Spanned>(span: S) -> _CrtCrtEql {
let span = span.span();
_CrtCrtEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"^^=", span,
))),
}
}
impl ::m2_syn::Token for _CrtCrtEql {
const SPELLING: &'static str = "^^=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "^^=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _CrtCrtEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _CrtCrtEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _CrtCrtEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _CrtCrtEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("^^=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"^^=",
false,
node.identity(),
));
}
Ok(_CrtCrtEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Ubs {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Ubs<S: ::m2_syn::Spanned>(span: S) -> _Ubs {
let span = span.span();
_Ubs {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("_", span))),
}
}
impl ::m2_syn::Token for _Ubs {
const SPELLING: &'static str = "_";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "_",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Ubs {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Ubs {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Ubs {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Ubs
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("_", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"_",
false,
node.identity(),
));
}
Ok(_Ubs(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _UbsEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _UbsEql<S: ::m2_syn::Spanned>(span: S) -> _UbsEql {
let span = span.span();
_UbsEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("_=", span))),
}
}
impl ::m2_syn::Token for _UbsEql {
const SPELLING: &'static str = "_=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "_=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _UbsEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _UbsEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _UbsEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _UbsEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("_=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"_=",
false,
node.identity(),
));
}
Ok(_UbsEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _UbsLst {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _UbsLst<S: ::m2_syn::Spanned>(span: S) -> _UbsLst {
let span = span.span();
_UbsLst {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("_<", span))),
}
}
impl ::m2_syn::Token for _UbsLst {
const SPELLING: &'static str = "_<";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "_<",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _UbsLst {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _UbsLst {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _UbsLst {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _UbsLst
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("_<", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"_<",
false,
node.identity(),
));
}
Ok(_UbsLst(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _UbsLstEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _UbsLstEql<S: ::m2_syn::Spanned>(span: S) -> _UbsLstEql {
let span = span.span();
_UbsLstEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"_<=", span,
))),
}
}
impl ::m2_syn::Token for _UbsLstEql {
const SPELLING: &'static str = "_<=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "_<=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _UbsLstEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _UbsLstEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _UbsLstEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _UbsLstEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("_<=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"_<=",
false,
node.identity(),
));
}
Ok(_UbsLstEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _UbsGst {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _UbsGst<S: ::m2_syn::Spanned>(span: S) -> _UbsGst {
let span = span.span();
_UbsGst {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("_>", span))),
}
}
impl ::m2_syn::Token for _UbsGst {
const SPELLING: &'static str = "_>";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "_>",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _UbsGst {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _UbsGst {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _UbsGst {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _UbsGst
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("_>", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"_>",
false,
node.identity(),
));
}
Ok(_UbsGst(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _UbsGstEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _UbsGstEql<S: ::m2_syn::Spanned>(span: S) -> _UbsGstEql {
let span = span.span();
_UbsGstEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"_>=", span,
))),
}
}
impl ::m2_syn::Token for _UbsGstEql {
const SPELLING: &'static str = "_>=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "_>=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _UbsGstEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _UbsGstEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _UbsGstEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _UbsGstEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("_>=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"_>=",
false,
node.identity(),
));
}
Ok(_UbsGstEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Pip {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Pip<S: ::m2_syn::Spanned>(span: S) -> _Pip {
let span = span.span();
_Pip {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("|", span))),
}
}
impl ::m2_syn::Token for _Pip {
const SPELLING: &'static str = "|";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "|",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Pip {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Pip {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Pip {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Pip
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("|", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"|",
false,
node.identity(),
));
}
Ok(_Pip(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _PipEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _PipEql<S: ::m2_syn::Spanned>(span: S) -> _PipEql {
let span = span.span();
_PipEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("|=", span))),
}
}
impl ::m2_syn::Token for _PipEql {
const SPELLING: &'static str = "|=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "|=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _PipEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _PipEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _PipEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _PipEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("|=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"|=",
false,
node.identity(),
));
}
Ok(_PipEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _PipSub {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _PipSub<S: ::m2_syn::Spanned>(span: S) -> _PipSub {
let span = span.span();
_PipSub {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("|-", span))),
}
}
impl ::m2_syn::Token for _PipSub {
const SPELLING: &'static str = "|-";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "|-",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _PipSub {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _PipSub {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _PipSub {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _PipSub
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("|-", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"|-",
false,
node.identity(),
));
}
Ok(_PipSub(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _PipSubEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _PipSubEql<S: ::m2_syn::Spanned>(span: S) -> _PipSubEql {
let span = span.span();
_PipSubEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"|-=", span,
))),
}
}
impl ::m2_syn::Token for _PipSubEql {
const SPELLING: &'static str = "|-=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "|-=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _PipSubEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _PipSubEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _PipSubEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _PipSubEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("|-=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"|-=",
false,
node.identity(),
));
}
Ok(_PipSubEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _PipUbs {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _PipUbs<S: ::m2_syn::Spanned>(span: S) -> _PipUbs {
let span = span.span();
_PipUbs {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("|_", span))),
}
}
impl ::m2_syn::Token for _PipUbs {
const SPELLING: &'static str = "|_";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "|_",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _PipUbs {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _PipUbs {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _PipUbs {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _PipUbs
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("|_", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"|_",
false,
node.identity(),
));
}
Ok(_PipUbs(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _PipUbsEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _PipUbsEql<S: ::m2_syn::Spanned>(span: S) -> _PipUbsEql {
let span = span.span();
_PipUbsEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"|_=", span,
))),
}
}
impl ::m2_syn::Token for _PipUbsEql {
const SPELLING: &'static str = "|_=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "|_=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _PipUbsEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _PipUbsEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _PipUbsEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _PipUbsEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("|_=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"|_=",
false,
node.identity(),
));
}
Ok(_PipUbsEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _PipPip {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _PipPip<S: ::m2_syn::Spanned>(span: S) -> _PipPip {
let span = span.span();
_PipPip {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("||", span))),
}
}
impl ::m2_syn::Token for _PipPip {
const SPELLING: &'static str = "||";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "||",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _PipPip {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _PipPip {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _PipPip {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _PipPip
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("||", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"||",
false,
node.identity(),
));
}
Ok(_PipPip(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _PipPipEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _PipPipEql<S: ::m2_syn::Spanned>(span: S) -> _PipPipEql {
let span = span.span();
_PipPipEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"||=", span,
))),
}
}
impl ::m2_syn::Token for _PipPipEql {
const SPELLING: &'static str = "||=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "||=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _PipPipEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _PipPipEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _PipPipEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _PipPipEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("||=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"||=",
false,
node.identity(),
));
}
Ok(_PipPipEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Tld {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Tld<S: ::m2_syn::Spanned>(span: S) -> _Tld {
let span = span.span();
_Tld {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("~", span))),
}
}
impl ::m2_syn::Token for _Tld {
const SPELLING: &'static str = "~";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "~",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Tld {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Tld {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Tld {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Tld
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("~", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"~",
false,
node.identity(),
));
}
Ok(_Tld(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _TldEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _TldEql<S: ::m2_syn::Spanned>(span: S) -> _TldEql {
let span = span.span();
_TldEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("~=", span))),
}
}
impl ::m2_syn::Token for _TldEql {
const SPELLING: &'static str = "~=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "~=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _TldEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _TldEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _TldEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _TldEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("~=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"~=",
false,
node.identity(),
));
}
Ok(_TldEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Cdt {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Cdt<S: ::m2_syn::Spanned>(span: S) -> _Cdt {
let span = span.span();
_Cdt {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("·", span))),
}
}
impl ::m2_syn::Token for _Cdt {
const SPELLING: &'static str = "·";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "·",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Cdt {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Cdt {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Cdt {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Cdt
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("·", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"·",
false,
node.identity(),
));
}
Ok(_Cdt(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _CdtEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _CdtEql<S: ::m2_syn::Spanned>(span: S) -> _CdtEql {
let span = span.span();
_CdtEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("·=", span))),
}
}
impl ::m2_syn::Token for _CdtEql {
const SPELLING: &'static str = "·=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "·=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _CdtEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _CdtEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _CdtEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _CdtEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("·=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"·=",
false,
node.identity(),
));
}
Ok(_CdtEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Box {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Box<S: ::m2_syn::Spanned>(span: S) -> _Box {
let span = span.span();
_Box {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("⊠", span))),
}
}
impl ::m2_syn::Token for _Box {
const SPELLING: &'static str = "⊠";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "⊠",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Box {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Box {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Box {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Box
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("⊠", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"⊠",
false,
node.identity(),
));
}
Ok(_Box(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _BoxEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _BoxEql<S: ::m2_syn::Spanned>(span: S) -> _BoxEql {
let span = span.span();
_BoxEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("⊠=", span))),
}
}
impl ::m2_syn::Token for _BoxEql {
const SPELLING: &'static str = "⊠=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "⊠=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _BoxEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _BoxEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _BoxEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _BoxEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("⊠=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"⊠=",
false,
node.identity(),
));
}
Ok(_BoxEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Sfp {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Sfp<S: ::m2_syn::Spanned>(span: S) -> _Sfp {
let span = span.span();
_Sfp {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("⧢", span))),
}
}
impl ::m2_syn::Token for _Sfp {
const SPELLING: &'static str = "⧢";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "⧢",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Sfp {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Sfp {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Sfp {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Sfp
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("⧢", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"⧢",
false,
node.identity(),
));
}
Ok(_Sfp(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _SfpEql {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _SfpEql<S: ::m2_syn::Spanned>(span: S) -> _SfpEql {
let span = span.span();
_SfpEql {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("⧢=", span))),
}
}
impl ::m2_syn::Token for _SfpEql {
const SPELLING: &'static str = "⧢=";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "⧢=",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _SfpEql {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _SfpEql {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _SfpEql {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _SfpEql
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("⧢=", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"⧢=",
false,
node.identity(),
));
}
Ok(_SfpEql(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _And {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _And<S: ::m2_syn::Spanned>(span: S) -> _And {
let span = span.span();
_And {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"and", span,
))),
}
}
impl ::m2_syn::Token for _And {
const SPELLING: &'static str = "and";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "and" || token.text().strip_prefix("Core$") == Some("and")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _And {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _And {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _And {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _And
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("and", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"and",
false,
node.identity(),
));
}
Ok(_And(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Or {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Or<S: ::m2_syn::Spanned>(span: S) -> _Or {
let span = span.span();
_Or {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"or", span,
))),
}
}
impl ::m2_syn::Token for _Or {
const SPELLING: &'static str = "or";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "or" || token.text().strip_prefix("Core$") == Some("or")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Or {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Or {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Or {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Or
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("or", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"or",
false,
node.identity(),
));
}
Ok(_Or(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Space {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Space<S: ::m2_syn::Spanned>(span: S) -> _Space {
let span = span.span();
_Space {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Trivia(::m2_syn::Trivia::new(
::m2_syn::TriviaKind::Whitespace,
" ",
span,
))),
}
}
impl ::m2_syn::Token for _Space {
const SPELLING: &'static str = "SPACE";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Trivia(token) => {
token.kind() == ::m2_syn::TriviaKind::Whitespace && !token.contains_line_break()
}
::m2_syn::TokenTree::Ident(token) => token.text() == "SPACE",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Space {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Space {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Space {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Space
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("SPACE", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"SPACE",
false,
node.identity(),
));
}
Ok(_Space(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Xor {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Xor<S: ::m2_syn::Spanned>(span: S) -> _Xor {
let span = span.span();
_Xor {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"xor", span,
))),
}
}
impl ::m2_syn::Token for _Xor {
const SPELLING: &'static str = "xor";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "xor" || token.text().strip_prefix("Core$") == Some("xor")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Xor {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Xor {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Xor {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Xor
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("xor", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"xor",
false,
node.identity(),
));
}
Ok(_Xor(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Bng {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Bng<S: ::m2_syn::Spanned>(span: S) -> _Bng {
let span = span.span();
_Bng {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("!", span))),
}
}
impl ::m2_syn::Token for _Bng {
const SPELLING: &'static str = "!";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "!",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Bng {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Bng {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Bng {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Bng
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("!", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"!",
false,
node.identity(),
));
}
Ok(_Bng(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Graded {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Graded<S: ::m2_syn::Spanned>(span: S) -> _Graded {
let span = span.span();
_Graded {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
"(*)", span,
))),
}
}
impl ::m2_syn::Token for _Graded {
const SPELLING: &'static str = "(*)";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "(*)",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Graded {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Graded {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Graded {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Graded
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("(*)", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"(*)",
false,
node.identity(),
));
}
Ok(_Graded(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _CrtBng {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _CrtBng<S: ::m2_syn::Spanned>(span: S) -> _CrtBng {
let span = span.span();
_CrtBng {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("^!", span))),
}
}
impl ::m2_syn::Token for _CrtBng {
const SPELLING: &'static str = "^!";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "^!",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _CrtBng {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _CrtBng {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _CrtBng {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _CrtBng
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("^!", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"^!",
false,
node.identity(),
));
}
Ok(_CrtBng(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _CrtMul {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _CrtMul<S: ::m2_syn::Spanned>(span: S) -> _CrtMul {
let span = span.span();
_CrtMul {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("^*", span))),
}
}
impl ::m2_syn::Token for _CrtMul {
const SPELLING: &'static str = "^*";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "^*",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _CrtMul {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _CrtMul {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _CrtMul {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _CrtMul
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("^*", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"^*",
false,
node.identity(),
));
}
Ok(_CrtMul(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _CrtTld {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _CrtTld<S: ::m2_syn::Spanned>(span: S) -> _CrtTld {
let span = span.span();
_CrtTld {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("^~", span))),
}
}
impl ::m2_syn::Token for _CrtTld {
const SPELLING: &'static str = "^~";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "^~",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _CrtTld {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _CrtTld {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _CrtTld {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _CrtTld
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("^~", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"^~",
false,
node.identity(),
));
}
Ok(_CrtTld(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _UbsBng {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _UbsBng<S: ::m2_syn::Spanned>(span: S) -> _UbsBng {
let span = span.span();
_UbsBng {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("_!", span))),
}
}
impl ::m2_syn::Token for _UbsBng {
const SPELLING: &'static str = "_!";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "_!",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _UbsBng {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _UbsBng {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _UbsBng {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _UbsBng
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("_!", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"_!",
false,
node.identity(),
));
}
Ok(_UbsBng(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _UbsMul {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _UbsMul<S: ::m2_syn::Spanned>(span: S) -> _UbsMul {
let span = span.span();
_UbsMul {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("_*", span))),
}
}
impl ::m2_syn::Token for _UbsMul {
const SPELLING: &'static str = "_*";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "_*",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _UbsMul {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _UbsMul {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _UbsMul {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _UbsMul
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("_*", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"_*",
false,
node.identity(),
));
}
Ok(_UbsMul(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _UbsTld {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _UbsTld<S: ::m2_syn::Spanned>(span: S) -> _UbsTld {
let span = span.span();
_UbsTld {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("_~", span))),
}
}
impl ::m2_syn::Token for _UbsTld {
const SPELLING: &'static str = "_~";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == "_~",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _UbsTld {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _UbsTld {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _UbsTld {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _UbsTld
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("_~", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"_~",
false,
node.identity(),
));
}
Ok(_UbsTld(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Not {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Not<S: ::m2_syn::Spanned>(span: S) -> _Not {
let span = span.span();
_Not {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"not", span,
))),
}
}
impl ::m2_syn::Token for _Not {
const SPELLING: &'static str = "not";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "not" || token.text().strip_prefix("Core$") == Some("not")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Not {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Not {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Not {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Not
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("not", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"not",
false,
node.identity(),
));
}
Ok(_Not(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _BreakKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _BreakKeyword<S: ::m2_syn::Spanned>(span: S) -> _BreakKeyword {
let span = span.span();
_BreakKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"break", span,
))),
}
}
impl ::m2_syn::Token for _BreakKeyword {
const SPELLING: &'static str = "break";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "break" || token.text().strip_prefix("Core$") == Some("break")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _BreakKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _BreakKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _BreakKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _BreakKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("break", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"break",
false,
node.identity(),
));
}
Ok(_BreakKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _BreakpointKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _BreakpointKeyword<S: ::m2_syn::Spanned>(span: S) -> _BreakpointKeyword {
let span = span.span();
_BreakpointKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"breakpoint",
span,
))),
}
}
impl ::m2_syn::Token for _BreakpointKeyword {
const SPELLING: &'static str = "breakpoint";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "breakpoint"
|| token.text().strip_prefix("Core$") == Some("breakpoint")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _BreakpointKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _BreakpointKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _BreakpointKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _BreakpointKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("breakpoint", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"breakpoint",
false,
node.identity(),
));
}
Ok(_BreakpointKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _CatchKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _CatchKeyword<S: ::m2_syn::Spanned>(span: S) -> _CatchKeyword {
let span = span.span();
_CatchKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"catch", span,
))),
}
}
impl ::m2_syn::Token for _CatchKeyword {
const SPELLING: &'static str = "catch";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "catch" || token.text().strip_prefix("Core$") == Some("catch")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _CatchKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _CatchKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _CatchKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _CatchKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("catch", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"catch",
false,
node.identity(),
));
}
Ok(_CatchKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _ContinueKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _ContinueKeyword<S: ::m2_syn::Spanned>(span: S) -> _ContinueKeyword {
let span = span.span();
_ContinueKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"continue", span,
))),
}
}
impl ::m2_syn::Token for _ContinueKeyword {
const SPELLING: &'static str = "continue";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "continue" || token.text().strip_prefix("Core$") == Some("continue")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _ContinueKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _ContinueKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _ContinueKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _ContinueKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("continue", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"continue",
false,
node.identity(),
));
}
Ok(_ContinueKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _DoKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _DoKeyword<S: ::m2_syn::Spanned>(span: S) -> _DoKeyword {
let span = span.span();
_DoKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"do", span,
))),
}
}
impl ::m2_syn::Token for _DoKeyword {
const SPELLING: &'static str = "do";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "do" || token.text().strip_prefix("Core$") == Some("do")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _DoKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _DoKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _DoKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _DoKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("do", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"do",
false,
node.identity(),
));
}
Ok(_DoKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _ElapsedTimeKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _ElapsedTimeKeyword<S: ::m2_syn::Spanned>(span: S) -> _ElapsedTimeKeyword {
let span = span.span();
_ElapsedTimeKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"elapsedTime",
span,
))),
}
}
impl ::m2_syn::Token for _ElapsedTimeKeyword {
const SPELLING: &'static str = "elapsedTime";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "elapsedTime"
|| token.text().strip_prefix("Core$") == Some("elapsedTime")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _ElapsedTimeKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _ElapsedTimeKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _ElapsedTimeKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _ElapsedTimeKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("elapsedTime", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"elapsedTime",
false,
node.identity(),
));
}
Ok(_ElapsedTimeKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _ElapsedTimingKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _ElapsedTimingKeyword<S: ::m2_syn::Spanned>(span: S) -> _ElapsedTimingKeyword {
let span = span.span();
_ElapsedTimingKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"elapsedTiming",
span,
))),
}
}
impl ::m2_syn::Token for _ElapsedTimingKeyword {
const SPELLING: &'static str = "elapsedTiming";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "elapsedTiming"
|| token.text().strip_prefix("Core$") == Some("elapsedTiming")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _ElapsedTimingKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _ElapsedTimingKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _ElapsedTimingKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _ElapsedTimingKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("elapsedTiming", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"elapsedTiming",
false,
node.identity(),
));
}
Ok(_ElapsedTimingKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _ElseKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _ElseKeyword<S: ::m2_syn::Spanned>(span: S) -> _ElseKeyword {
let span = span.span();
_ElseKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"else", span,
))),
}
}
impl ::m2_syn::Token for _ElseKeyword {
const SPELLING: &'static str = "else";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "else" || token.text().strip_prefix("Core$") == Some("else")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _ElseKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _ElseKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _ElseKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _ElseKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("else", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"else",
false,
node.identity(),
));
}
Ok(_ElseKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _ExceptKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _ExceptKeyword<S: ::m2_syn::Spanned>(span: S) -> _ExceptKeyword {
let span = span.span();
_ExceptKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"except", span,
))),
}
}
impl ::m2_syn::Token for _ExceptKeyword {
const SPELLING: &'static str = "except";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "except" || token.text().strip_prefix("Core$") == Some("except")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _ExceptKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _ExceptKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _ExceptKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _ExceptKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("except", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"except",
false,
node.identity(),
));
}
Ok(_ExceptKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _FinishKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _FinishKeyword<S: ::m2_syn::Spanned>(span: S) -> _FinishKeyword {
let span = span.span();
_FinishKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"finish", span,
))),
}
}
impl ::m2_syn::Token for _FinishKeyword {
const SPELLING: &'static str = "finish";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "finish" || token.text().strip_prefix("Core$") == Some("finish")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _FinishKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _FinishKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _FinishKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _FinishKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("finish", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"finish",
false,
node.identity(),
));
}
Ok(_FinishKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _ForKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _ForKeyword<S: ::m2_syn::Spanned>(span: S) -> _ForKeyword {
let span = span.span();
_ForKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"for", span,
))),
}
}
impl ::m2_syn::Token for _ForKeyword {
const SPELLING: &'static str = "for";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "for" || token.text().strip_prefix("Core$") == Some("for")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _ForKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _ForKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _ForKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _ForKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("for", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"for",
false,
node.identity(),
));
}
Ok(_ForKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _FromKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _FromKeyword<S: ::m2_syn::Spanned>(span: S) -> _FromKeyword {
let span = span.span();
_FromKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"from", span,
))),
}
}
impl ::m2_syn::Token for _FromKeyword {
const SPELLING: &'static str = "from";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "from" || token.text().strip_prefix("Core$") == Some("from")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _FromKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _FromKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _FromKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _FromKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("from", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"from",
false,
node.identity(),
));
}
Ok(_FromKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _GlobalKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _GlobalKeyword<S: ::m2_syn::Spanned>(span: S) -> _GlobalKeyword {
let span = span.span();
_GlobalKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"global", span,
))),
}
}
impl ::m2_syn::Token for _GlobalKeyword {
const SPELLING: &'static str = "global";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "global" || token.text().strip_prefix("Core$") == Some("global")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _GlobalKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _GlobalKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _GlobalKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _GlobalKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("global", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"global",
false,
node.identity(),
));
}
Ok(_GlobalKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _IfKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _IfKeyword<S: ::m2_syn::Spanned>(span: S) -> _IfKeyword {
let span = span.span();
_IfKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"if", span,
))),
}
}
impl ::m2_syn::Token for _IfKeyword {
const SPELLING: &'static str = "if";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "if" || token.text().strip_prefix("Core$") == Some("if")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _IfKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _IfKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _IfKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _IfKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("if", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"if",
false,
node.identity(),
));
}
Ok(_IfKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _InKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _InKeyword<S: ::m2_syn::Spanned>(span: S) -> _InKeyword {
let span = span.span();
_InKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"in", span,
))),
}
}
impl ::m2_syn::Token for _InKeyword {
const SPELLING: &'static str = "in";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "in" || token.text().strip_prefix("Core$") == Some("in")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _InKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _InKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _InKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _InKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("in", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"in",
false,
node.identity(),
));
}
Ok(_InKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _ListKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _ListKeyword<S: ::m2_syn::Spanned>(span: S) -> _ListKeyword {
let span = span.span();
_ListKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"list", span,
))),
}
}
impl ::m2_syn::Token for _ListKeyword {
const SPELLING: &'static str = "list";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "list" || token.text().strip_prefix("Core$") == Some("list")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _ListKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _ListKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _ListKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _ListKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("list", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"list",
false,
node.identity(),
));
}
Ok(_ListKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _LocalKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _LocalKeyword<S: ::m2_syn::Spanned>(span: S) -> _LocalKeyword {
let span = span.span();
_LocalKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"local", span,
))),
}
}
impl ::m2_syn::Token for _LocalKeyword {
const SPELLING: &'static str = "local";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "local" || token.text().strip_prefix("Core$") == Some("local")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _LocalKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _LocalKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _LocalKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _LocalKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("local", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"local",
false,
node.identity(),
));
}
Ok(_LocalKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _NewKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _NewKeyword<S: ::m2_syn::Spanned>(span: S) -> _NewKeyword {
let span = span.span();
_NewKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"new", span,
))),
}
}
impl ::m2_syn::Token for _NewKeyword {
const SPELLING: &'static str = "new";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "new" || token.text().strip_prefix("Core$") == Some("new")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _NewKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _NewKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _NewKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _NewKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("new", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"new",
false,
node.identity(),
));
}
Ok(_NewKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _OfKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _OfKeyword<S: ::m2_syn::Spanned>(span: S) -> _OfKeyword {
let span = span.span();
_OfKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"of", span,
))),
}
}
impl ::m2_syn::Token for _OfKeyword {
const SPELLING: &'static str = "of";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "of" || token.text().strip_prefix("Core$") == Some("of")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _OfKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _OfKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _OfKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _OfKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("of", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"of",
false,
node.identity(),
));
}
Ok(_OfKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _ProfileKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _ProfileKeyword<S: ::m2_syn::Spanned>(span: S) -> _ProfileKeyword {
let span = span.span();
_ProfileKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"profile", span,
))),
}
}
impl ::m2_syn::Token for _ProfileKeyword {
const SPELLING: &'static str = "profile";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "profile" || token.text().strip_prefix("Core$") == Some("profile")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _ProfileKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _ProfileKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _ProfileKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _ProfileKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("profile", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"profile",
false,
node.identity(),
));
}
Ok(_ProfileKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _ReturnKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _ReturnKeyword<S: ::m2_syn::Spanned>(span: S) -> _ReturnKeyword {
let span = span.span();
_ReturnKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"return", span,
))),
}
}
impl ::m2_syn::Token for _ReturnKeyword {
const SPELLING: &'static str = "return";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "return" || token.text().strip_prefix("Core$") == Some("return")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _ReturnKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _ReturnKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _ReturnKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _ReturnKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("return", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"return",
false,
node.identity(),
));
}
Ok(_ReturnKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _ShieldKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _ShieldKeyword<S: ::m2_syn::Spanned>(span: S) -> _ShieldKeyword {
let span = span.span();
_ShieldKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"shield", span,
))),
}
}
impl ::m2_syn::Token for _ShieldKeyword {
const SPELLING: &'static str = "shield";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "shield" || token.text().strip_prefix("Core$") == Some("shield")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _ShieldKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _ShieldKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _ShieldKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _ShieldKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("shield", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"shield",
false,
node.identity(),
));
}
Ok(_ShieldKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _StepKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _StepKeyword<S: ::m2_syn::Spanned>(span: S) -> _StepKeyword {
let span = span.span();
_StepKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"step", span,
))),
}
}
impl ::m2_syn::Token for _StepKeyword {
const SPELLING: &'static str = "step";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "step" || token.text().strip_prefix("Core$") == Some("step")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _StepKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _StepKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _StepKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _StepKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("step", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"step",
false,
node.identity(),
));
}
Ok(_StepKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _SymbolKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _SymbolKeyword<S: ::m2_syn::Spanned>(span: S) -> _SymbolKeyword {
let span = span.span();
_SymbolKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"symbol", span,
))),
}
}
impl ::m2_syn::Token for _SymbolKeyword {
const SPELLING: &'static str = "symbol";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "symbol" || token.text().strip_prefix("Core$") == Some("symbol")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _SymbolKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _SymbolKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _SymbolKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _SymbolKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("symbol", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"symbol",
false,
node.identity(),
));
}
Ok(_SymbolKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _TestKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _TestKeyword<S: ::m2_syn::Spanned>(span: S) -> _TestKeyword {
let span = span.span();
_TestKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"TEST", span,
))),
}
}
impl ::m2_syn::Token for _TestKeyword {
const SPELLING: &'static str = "TEST";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "TEST" || token.text().strip_prefix("Core$") == Some("TEST")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _TestKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _TestKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _TestKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _TestKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("TEST", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"TEST",
false,
node.identity(),
));
}
Ok(_TestKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _ThenKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _ThenKeyword<S: ::m2_syn::Spanned>(span: S) -> _ThenKeyword {
let span = span.span();
_ThenKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"then", span,
))),
}
}
impl ::m2_syn::Token for _ThenKeyword {
const SPELLING: &'static str = "then";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "then" || token.text().strip_prefix("Core$") == Some("then")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _ThenKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _ThenKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _ThenKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _ThenKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("then", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"then",
false,
node.identity(),
));
}
Ok(_ThenKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _ThreadLocalKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _ThreadLocalKeyword<S: ::m2_syn::Spanned>(span: S) -> _ThreadLocalKeyword {
let span = span.span();
_ThreadLocalKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"threadLocal",
span,
))),
}
}
impl ::m2_syn::Token for _ThreadLocalKeyword {
const SPELLING: &'static str = "threadLocal";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "threadLocal"
|| token.text().strip_prefix("Core$") == Some("threadLocal")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _ThreadLocalKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _ThreadLocalKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _ThreadLocalKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _ThreadLocalKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("threadLocal", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"threadLocal",
false,
node.identity(),
));
}
Ok(_ThreadLocalKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _ThreadVariableKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _ThreadVariableKeyword<S: ::m2_syn::Spanned>(span: S) -> _ThreadVariableKeyword {
let span = span.span();
_ThreadVariableKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"threadVariable",
span,
))),
}
}
impl ::m2_syn::Token for _ThreadVariableKeyword {
const SPELLING: &'static str = "threadVariable";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "threadVariable"
|| token.text().strip_prefix("Core$") == Some("threadVariable")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _ThreadVariableKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _ThreadVariableKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _ThreadVariableKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _ThreadVariableKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("threadVariable", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"threadVariable",
false,
node.identity(),
));
}
Ok(_ThreadVariableKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _ThrowKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _ThrowKeyword<S: ::m2_syn::Spanned>(span: S) -> _ThrowKeyword {
let span = span.span();
_ThrowKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"throw", span,
))),
}
}
impl ::m2_syn::Token for _ThrowKeyword {
const SPELLING: &'static str = "throw";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "throw" || token.text().strip_prefix("Core$") == Some("throw")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _ThrowKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _ThrowKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _ThrowKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _ThrowKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("throw", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"throw",
false,
node.identity(),
));
}
Ok(_ThrowKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _TimeKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _TimeKeyword<S: ::m2_syn::Spanned>(span: S) -> _TimeKeyword {
let span = span.span();
_TimeKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"time", span,
))),
}
}
impl ::m2_syn::Token for _TimeKeyword {
const SPELLING: &'static str = "time";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "time" || token.text().strip_prefix("Core$") == Some("time")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _TimeKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _TimeKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _TimeKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _TimeKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("time", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"time",
false,
node.identity(),
));
}
Ok(_TimeKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _TimingKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _TimingKeyword<S: ::m2_syn::Spanned>(span: S) -> _TimingKeyword {
let span = span.span();
_TimingKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"timing", span,
))),
}
}
impl ::m2_syn::Token for _TimingKeyword {
const SPELLING: &'static str = "timing";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "timing" || token.text().strip_prefix("Core$") == Some("timing")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _TimingKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _TimingKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _TimingKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _TimingKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("timing", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"timing",
false,
node.identity(),
));
}
Ok(_TimingKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _ToKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _ToKeyword<S: ::m2_syn::Spanned>(span: S) -> _ToKeyword {
let span = span.span();
_ToKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"to", span,
))),
}
}
impl ::m2_syn::Token for _ToKeyword {
const SPELLING: &'static str = "to";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "to" || token.text().strip_prefix("Core$") == Some("to")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _ToKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _ToKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _ToKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _ToKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("to", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"to",
false,
node.identity(),
));
}
Ok(_ToKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _TrapKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _TrapKeyword<S: ::m2_syn::Spanned>(span: S) -> _TrapKeyword {
let span = span.span();
_TrapKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"trap", span,
))),
}
}
impl ::m2_syn::Token for _TrapKeyword {
const SPELLING: &'static str = "trap";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "trap" || token.text().strip_prefix("Core$") == Some("trap")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _TrapKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _TrapKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _TrapKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _TrapKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("trap", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"trap",
false,
node.identity(),
));
}
Ok(_TrapKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _TryKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _TryKeyword<S: ::m2_syn::Spanned>(span: S) -> _TryKeyword {
let span = span.span();
_TryKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"try", span,
))),
}
}
impl ::m2_syn::Token for _TryKeyword {
const SPELLING: &'static str = "try";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "try" || token.text().strip_prefix("Core$") == Some("try")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _TryKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _TryKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _TryKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _TryKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("try", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"try",
false,
node.identity(),
));
}
Ok(_TryKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _WhenKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _WhenKeyword<S: ::m2_syn::Spanned>(span: S) -> _WhenKeyword {
let span = span.span();
_WhenKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"when", span,
))),
}
}
impl ::m2_syn::Token for _WhenKeyword {
const SPELLING: &'static str = "when";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "when" || token.text().strip_prefix("Core$") == Some("when")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _WhenKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _WhenKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _WhenKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _WhenKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("when", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"when",
false,
node.identity(),
));
}
Ok(_WhenKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _WhileKeyword {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _WhileKeyword<S: ::m2_syn::Spanned>(span: S) -> _WhileKeyword {
let span = span.span();
_WhileKeyword {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
"while", span,
))),
}
}
impl ::m2_syn::Token for _WhileKeyword {
const SPELLING: &'static str = "while";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Ident(token) => {
token.text() == "while" || token.text().strip_prefix("Core$") == Some("while")
}
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _WhileKeyword {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _WhileKeyword {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _WhileKeyword {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _WhileKeyword
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches("while", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
"while",
false,
node.identity(),
));
}
Ok(_WhileKeyword(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Scl {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Scl<S: ::m2_syn::Spanned>(span: S) -> _Scl {
let span = span.span();
_Scl {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(";", span))),
}
}
impl ::m2_syn::Token for _Scl {
const SPELLING: &'static str = ";";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == ";",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Scl {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Scl {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Scl {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Scl
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches(";", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
";",
false,
node.identity(),
));
}
Ok(_Scl(node.span()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
pub struct _Cma {
raw: ::std::boxed::Box<::m2_syn::TokenTree>,
}
#[doc(hidden)]
#[allow(non_snake_case)]
pub fn _Cma<S: ::m2_syn::Spanned>(span: S) -> _Cma {
let span = span.span();
_Cma {
raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(",", span))),
}
}
impl ::m2_syn::Token for _Cma {
const SPELLING: &'static str = ",";
fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
match token {
::m2_syn::TokenTree::Punct(token) => token.text() == ",",
_ => false,
}
}
fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
Self::matches_token_tree(&token).then_some(Self {
raw: ::std::boxed::Box::new(token),
})
}
}
impl ::m2_syn::Parse for _Cma {
fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
input.parse_token()
}
}
impl ::m2_syn::ToTokens for _Cma {
fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
::m2_syn::ToTokens::to_tokens(&self.raw, output);
}
}
impl ::m2_syn::PrettyTree for _Cma {
fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
::m2_syn::PrettyNode::token(
::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
<Self as ::m2_syn::Token>::SPELLING,
::m2_syn::Spanned::span(self),
)
}
}
impl<N> ::m2_syn::Reconstruct<N> for _Cma
where
N: ::m2_syn::ExternalCstNode,
{
fn matches(node: &N) -> bool {
node.identity().matches(",", false)
}
fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
return Err(::m2_syn::ReconstructError::wrong_node(
",",
false,
node.identity(),
));
}
Ok(_Cma(node.span()))
}
}
#[macro_export]
macro_rules! Token {
[!=] => { $crate::_BngEql };
[#] => { $crate::_Hsh };
[#?] => { $crate::_HshQsm };
[%] => { $crate::_Mod };
[%=] => { $crate::_ModEql };
[&] => { $crate::_Amp };
[&=] => { $crate::_AmpEql };
[*] => { $crate::_Mul };
[*=] => { $crate::_MulEql };
[**] => { $crate::_MulMul };
[**=] => { $crate::_MulMulEql };
[+] => { $crate::_Add };
[+=] => { $crate::_AddEql };
[++] => { $crate::_AddAdd };
[++=] => { $crate::_AddAddEql };
[-] => { $crate::_Sub };
[-=] => { $crate::_SubEql };
[->] => { $crate::_SubGst };
[.] => { $crate::_Dot };
[..] => { $crate::_DotDot };
[..=] => { $crate::_DotDotEql };
[..<] => { $crate::_DotDotLst };
[..<=] => { $crate::_DotDotLstEql };
[.?] => { $crate::_DotQsm };
[/] => { $crate::_Slh };
[/=] => { $crate::_SlhEql };
[/ /] => { $crate::_SlhSlh };
[/ /=] => { $crate::_SlhSlhEql };
[:] => { $crate::_Col };
[:=] => { $crate::_ColEql };
[<] => { $crate::_Lst };
[<-] => { $crate::_LstSub };
[<<] => { $crate::_LstLst };
[<<=] => { $crate::_LstLstEql };
[<=] => { $crate::_LstEql };
[<==] => { $crate::_LstEqlEql };
[<===] => { $crate::_LstEqlEqlEql };
[<==>] => { $crate::_LstEqlEqlGst };
[<==>=] => { $crate::_LstEqlEqlGstEql };
[=] => { $crate::_Eql };
[=!=] => { $crate::_EqlBngEql };
[==] => { $crate::_EqlEql };
[===] => { $crate::_EqlEqlEql };
[===>] => { $crate::_EqlEqlEqlGst };
[===>=] => { $crate::_EqlEqlEqlGstEql };
[==>] => { $crate::_EqlEqlGst };
[==>=] => { $crate::_EqlEqlGstEql };
[=>] => { $crate::_EqlGst };
[>] => { $crate::_Gst };
[>=] => { $crate::_GstEql };
[>>] => { $crate::_GstGst };
[>>=] => { $crate::_GstGstEql };
[?] => { $crate::_Qsm };
[??] => { $crate::_QsmQsm };
[??=] => { $crate::_QsmQsmEql };
[@] => { $crate::_Att };
[@=] => { $crate::_AttEql };
[@@] => { $crate::_AttAtt };
[@@=] => { $crate::_AttAttEql };
[@@?] => { $crate::_AttAttQsm };
[@@?=] => { $crate::_AttAttQsmEql };
["\\"] => { $crate::_Bsl };
["\\="] => { $crate::_BslEql };
["\\\\"] => { $crate::_BslBsl };
["\\\\="] => { $crate::_BslBslEql };
[^] => { $crate::_Crt };
[^=] => { $crate::_CrtEql };
[^**] => { $crate::_CrtMulMul };
[^**=] => { $crate::_CrtMulMulEql };
[^<] => { $crate::_CrtLst };
[^<=] => { $crate::_CrtLstEql };
[^>] => { $crate::_CrtGst };
[^>=] => { $crate::_CrtGstEql };
[^^] => { $crate::_CrtCrt };
[^^=] => { $crate::_CrtCrtEql };
[_] => { $crate::_Ubs };
[_=] => { $crate::_UbsEql };
[_<] => { $crate::_UbsLst };
[_<=] => { $crate::_UbsLstEql };
[_>] => { $crate::_UbsGst };
[_>=] => { $crate::_UbsGstEql };
[|] => { $crate::_Pip };
[|=] => { $crate::_PipEql };
[|-] => { $crate::_PipSub };
[|-=] => { $crate::_PipSubEql };
[|_] => { $crate::_PipUbs };
[|_=] => { $crate::_PipUbsEql };
[||] => { $crate::_PipPip };
[||=] => { $crate::_PipPipEql };
[~] => { $crate::_Tld };
[~=] => { $crate::_TldEql };
["·"] => { $crate::_Cdt };
["·="] => { $crate::_CdtEql };
["⊠"] => { $crate::_Box };
["⊠="] => { $crate::_BoxEql };
["⧢"] => { $crate::_Sfp };
["⧢="] => { $crate::_SfpEql };
[and] => { $crate::_And };
[or] => { $crate::_Or };
[SPACE] => { $crate::_Space };
[xor] => { $crate::_Xor };
[!] => { $crate::_Bng };
[(*)] => { $crate::_Graded };
[^!] => { $crate::_CrtBng };
[^*] => { $crate::_CrtMul };
[^~] => { $crate::_CrtTld };
[_!] => { $crate::_UbsBng };
[_*] => { $crate::_UbsMul };
[_~] => { $crate::_UbsTld };
[not] => { $crate::_Not };
[break] => { $crate::_BreakKeyword };
[breakpoint] => { $crate::_BreakpointKeyword };
[catch] => { $crate::_CatchKeyword };
[continue] => { $crate::_ContinueKeyword };
[do] => { $crate::_DoKeyword };
[elapsedTime] => { $crate::_ElapsedTimeKeyword };
[elapsedTiming] => { $crate::_ElapsedTimingKeyword };
[else] => { $crate::_ElseKeyword };
[except] => { $crate::_ExceptKeyword };
[finish] => { $crate::_FinishKeyword };
[for] => { $crate::_ForKeyword };
[from] => { $crate::_FromKeyword };
[global] => { $crate::_GlobalKeyword };
[if] => { $crate::_IfKeyword };
[in] => { $crate::_InKeyword };
[list] => { $crate::_ListKeyword };
[local] => { $crate::_LocalKeyword };
[new] => { $crate::_NewKeyword };
[of] => { $crate::_OfKeyword };
[profile] => { $crate::_ProfileKeyword };
[return] => { $crate::_ReturnKeyword };
[shield] => { $crate::_ShieldKeyword };
[step] => { $crate::_StepKeyword };
[symbol] => { $crate::_SymbolKeyword };
[TEST] => { $crate::_TestKeyword };
[then] => { $crate::_ThenKeyword };
[threadLocal] => { $crate::_ThreadLocalKeyword };
[threadVariable] => { $crate::_ThreadVariableKeyword };
[throw] => { $crate::_ThrowKeyword };
[time] => { $crate::_TimeKeyword };
[timing] => { $crate::_TimingKeyword };
[to] => { $crate::_ToKeyword };
[trap] => { $crate::_TrapKeyword };
[try] => { $crate::_TryKeyword };
[when] => { $crate::_WhenKeyword };
[while] => { $crate::_WhileKeyword };
[;] => { $crate::_Scl };
[,] => { $crate::_Cma };
[$($unsupported:tt)*] => { compile_error!("token was not declared in `syntax!`") };
}
#[doc(hidden)]
#[macro_export]
macro_rules! __m2_syn_parse_info {
($spelling:expr , $parse_info:ident) => {
match $spelling {
"!=" => Some($parse_info::binary(36u8, 35u8)),
"#" => Some($parse_info::prefix_binary(70u8, 70u8, 61u8)),
"#?" => Some($parse_info::binary(70u8, 70u8)),
"%" => Some($parse_info::binary(58u8, 58u8)),
"%=" => Some($parse_info::binary(14u8, 13u8)),
"&" => Some($parse_info::binary(46u8, 46u8)),
"&=" => Some($parse_info::binary(14u8, 13u8)),
"*" => Some($parse_info::prefix_binary(58u8, 58u8, 58u8)),
"*=" => Some($parse_info::binary(14u8, 13u8)),
"**" => Some($parse_info::binary(54u8, 54u8)),
"**=" => Some($parse_info::binary(14u8, 13u8)),
"+" => Some($parse_info::prefix_binary(50u8, 50u8, 50u8)),
"+=" => Some($parse_info::binary(14u8, 13u8)),
"++" => Some($parse_info::binary(50u8, 50u8)),
"++=" => Some($parse_info::binary(14u8, 13u8)),
"-" => Some($parse_info::prefix_binary(50u8, 50u8, 50u8)),
"-=" => Some($parse_info::binary(14u8, 13u8)),
"->" => Some($parse_info::binary(14u8, 13u8)),
"." => Some($parse_info::binary(70u8, 70u8)),
".." => Some($parse_info::binary(48u8, 48u8)),
"..=" => Some($parse_info::binary(14u8, 13u8)),
"..<" => Some($parse_info::binary(48u8, 48u8)),
"..<=" => Some($parse_info::binary(14u8, 13u8)),
".?" => Some($parse_info::binary(70u8, 70u8)),
"/" => Some($parse_info::binary(58u8, 58u8)),
"/=" => Some($parse_info::binary(14u8, 13u8)),
"//" => Some($parse_info::binary(58u8, 58u8)),
"//=" => Some($parse_info::binary(14u8, 13u8)),
":" => Some($parse_info::binary(40u8, 39u8)),
":=" => Some($parse_info::binary(14u8, 13u8)),
"<" => Some($parse_info::prefix_binary(36u8, 35u8, 36u8)),
"<-" => Some($parse_info::binary(14u8, 13u8)),
"<<" => Some($parse_info::prefix_binary(18u8, 18u8, 18u8)),
"<<=" => Some($parse_info::binary(14u8, 13u8)),
"<=" => Some($parse_info::prefix_binary(36u8, 35u8, 36u8)),
"<==" => Some($parse_info::prefix_binary(26u8, 25u8, 26u8)),
"<===" => Some($parse_info::prefix_binary(22u8, 21u8, 22u8)),
"<==>" => Some($parse_info::binary(24u8, 23u8)),
"<==>=" => Some($parse_info::binary(14u8, 13u8)),
"=" => Some($parse_info::binary(14u8, 13u8)),
"=!=" => Some($parse_info::binary(36u8, 35u8)),
"==" => Some($parse_info::binary(36u8, 35u8)),
"===" => Some($parse_info::binary(36u8, 35u8)),
"===>" => Some($parse_info::binary(22u8, 21u8)),
"===>=" => Some($parse_info::binary(14u8, 13u8)),
"==>" => Some($parse_info::binary(26u8, 25u8)),
"==>=" => Some($parse_info::binary(14u8, 13u8)),
"=>" => Some($parse_info::binary(14u8, 13u8)),
">" => Some($parse_info::prefix_binary(36u8, 35u8, 36u8)),
">=" => Some($parse_info::prefix_binary(36u8, 35u8, 36u8)),
">>" => Some($parse_info::binary(14u8, 13u8)),
">>=" => Some($parse_info::binary(14u8, 13u8)),
"?" => Some($parse_info::prefix_binary(36u8, 35u8, 36u8)),
"??" => Some($parse_info::prefix_binary(28u8, 27u8, 28u8)),
"??=" => Some($parse_info::binary(14u8, 13u8)),
"@" => Some($parse_info::binary(60u8, 59u8)),
"@=" => Some($parse_info::binary(14u8, 13u8)),
"@@" => Some($parse_info::binary(66u8, 66u8)),
"@@=" => Some($parse_info::binary(14u8, 13u8)),
"@@?" => Some($parse_info::binary(66u8, 66u8)),
"@@?=" => Some($parse_info::binary(14u8, 13u8)),
"\\" => Some($parse_info::binary(58u8, 57u8)),
"\\=" => Some($parse_info::binary(14u8, 13u8)),
"\\\\" => Some($parse_info::binary(58u8, 57u8)),
"\\\\=" => Some($parse_info::binary(14u8, 13u8)),
"^" => Some($parse_info::binary(70u8, 70u8)),
"^=" => Some($parse_info::binary(14u8, 13u8)),
"^**" => Some($parse_info::binary(70u8, 70u8)),
"^**=" => Some($parse_info::binary(14u8, 13u8)),
"^<" => Some($parse_info::binary(70u8, 70u8)),
"^<=" => Some($parse_info::binary(70u8, 70u8)),
"^>" => Some($parse_info::binary(70u8, 70u8)),
"^>=" => Some($parse_info::binary(70u8, 70u8)),
"^^" => Some($parse_info::binary(44u8, 44u8)),
"^^=" => Some($parse_info::binary(14u8, 13u8)),
"_" => Some($parse_info::binary(70u8, 70u8)),
"_=" => Some($parse_info::binary(14u8, 13u8)),
"_<" => Some($parse_info::binary(70u8, 70u8)),
"_<=" => Some($parse_info::binary(70u8, 70u8)),
"_>" => Some($parse_info::binary(70u8, 70u8)),
"_>=" => Some($parse_info::binary(70u8, 70u8)),
"|" => Some($parse_info::binary(42u8, 42u8)),
"|=" => Some($parse_info::binary(14u8, 13u8)),
"|-" => Some($parse_info::prefix_binary(20u8, 20u8, 20u8)),
"|-=" => Some($parse_info::binary(14u8, 13u8)),
"|_" => Some($parse_info::binary(70u8, 70u8)),
"|_=" => Some($parse_info::binary(14u8, 13u8)),
"||" => Some($parse_info::binary(38u8, 38u8)),
"||=" => Some($parse_info::binary(14u8, 13u8)),
"~" => Some($parse_info::prefix_binary(36u8, 35u8, 36u8)),
"~=" => Some($parse_info::binary(14u8, 13u8)),
"·" => Some($parse_info::binary(52u8, 52u8)),
"·=" => Some($parse_info::binary(14u8, 13u8)),
"⊠" => Some($parse_info::binary(54u8, 54u8)),
"⊠=" => Some($parse_info::binary(14u8, 13u8)),
"⧢" => Some($parse_info::binary(54u8, 54u8)),
"⧢=" => Some($parse_info::binary(14u8, 13u8)),
"and" => Some($parse_info::binary(32u8, 31u8)),
"or" => Some($parse_info::binary(28u8, 27u8)),
"SPACE" => Some($parse_info::binary(62u8, 61u8)),
"xor" => Some($parse_info::binary(30u8, 29u8)),
"!" => Some($parse_info::postfix(72u8)),
"(*)" => Some($parse_info::postfix(64u8)),
"^!" => Some($parse_info::postfix(72u8)),
"^*" => Some($parse_info::postfix(68u8)),
"^~" => Some($parse_info::postfix(68u8)),
"_!" => Some($parse_info::postfix(72u8)),
"_*" => Some($parse_info::postfix(68u8)),
"_~" => Some($parse_info::postfix(68u8)),
"not" => Some($parse_info::prefix(34u8, 34u8)),
_ => None,
}
};
}