crates/syntax/src/ast/generated/tokens.rs

   1 //! Generated file, do not edit by hand, see `xtask/src/codegen`
   2
   3 use crate::{
   4     ast::AstToken,
   5     SyntaxKind::{self, *},
   6     SyntaxToken,
   7 };
   8
   9 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
  10 pub struct Whitespace {
  11     pub(crate) syntax: SyntaxToken,
  12 }
  13 impl std::fmt::Display for Whitespace {
  14     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  15         std::fmt::Display::fmt(&self.syntax, f)
  16     }
  17 }
  18 impl AstToken for Whitespace {
  19     fn can_cast(kind: SyntaxKind) -> bool { kind == WHITESPACE }
  20     fn cast(syntax: SyntaxToken) -> Option<Self> {
  21         if Self::can_cast(syntax.kind()) {
  22             Some(Self { syntax })
  23         } else {
  24             None
  25         }
  26     }
  27     fn syntax(&self) -> &SyntaxToken { &self.syntax }
  28 }
  29
  30 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
  31 pub struct Comment {
  32     pub(crate) syntax: SyntaxToken,
  33 }
  34 impl std::fmt::Display for Comment {
  35     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  36         std::fmt::Display::fmt(&self.syntax, f)
  37     }
  38 }
  39 impl AstToken for Comment {
  40     fn can_cast(kind: SyntaxKind) -> bool { kind == COMMENT }
  41     fn cast(syntax: SyntaxToken) -> Option<Self> {
  42         if Self::can_cast(syntax.kind()) {
  43             Some(Self { syntax })
  44         } else {
  45             None
  46         }
  47     }
  48     fn syntax(&self) -> &SyntaxToken { &self.syntax }
  49 }
  50
  51 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
  52 pub struct String {
  53     pub(crate) syntax: SyntaxToken,
  54 }
  55 impl std::fmt::Display for String {
  56     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  57         std::fmt::Display::fmt(&self.syntax, f)
  58     }
  59 }
  60 impl AstToken for String {
  61     fn can_cast(kind: SyntaxKind) -> bool { kind == STRING }
  62     fn cast(syntax: SyntaxToken) -> Option<Self> {
  63         if Self::can_cast(syntax.kind()) {
  64             Some(Self { syntax })
  65         } else {
  66             None
  67         }
  68     }
  69     fn syntax(&self) -> &SyntaxToken { &self.syntax }
  70 }
  71
  72 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
  73 pub struct ByteString {
  74     pub(crate) syntax: SyntaxToken,
  75 }
  76 impl std::fmt::Display for ByteString {
  77     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  78         std::fmt::Display::fmt(&self.syntax, f)
  79     }
  80 }
  81 impl AstToken for ByteString {
  82     fn can_cast(kind: SyntaxKind) -> bool { kind == BYTE_STRING }
  83     fn cast(syntax: SyntaxToken) -> Option<Self> {
  84         if Self::can_cast(syntax.kind()) {
  85             Some(Self { syntax })
  86         } else {
  87             None
  88         }
  89     }
  90     fn syntax(&self) -> &SyntaxToken { &self.syntax }
  91 }
  92
  93 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
  94 pub struct IntNumber {
  95     pub(crate) syntax: SyntaxToken,
  96 }
  97 impl std::fmt::Display for IntNumber {
  98     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  99         std::fmt::Display::fmt(&self.syntax, f)
 100     }
 101 }
 102 impl AstToken for IntNumber {
 103     fn can_cast(kind: SyntaxKind) -> bool { kind == INT_NUMBER }
 104     fn cast(syntax: SyntaxToken) -> Option<Self> {
 105         if Self::can_cast(syntax.kind()) {
 106             Some(Self { syntax })
 107         } else {
 108             None
 109         }
 110     }
 111     fn syntax(&self) -> &SyntaxToken { &self.syntax }
 112 }
 113
 114 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 115 pub struct FloatNumber {
 116     pub(crate) syntax: SyntaxToken,
 117 }
 118 impl std::fmt::Display for FloatNumber {
 119     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 120         std::fmt::Display::fmt(&self.syntax, f)
 121     }
 122 }
 123 impl AstToken for FloatNumber {
 124     fn can_cast(kind: SyntaxKind) -> bool { kind == FLOAT_NUMBER }
 125     fn cast(syntax: SyntaxToken) -> Option<Self> {
 126         if Self::can_cast(syntax.kind()) {
 127             Some(Self { syntax })
 128         } else {
 129             None
 130         }
 131     }
 132     fn syntax(&self) -> &SyntaxToken { &self.syntax }
 133 }