diff options
author | Aleksey Kladov <[email protected]> | 2020-04-09 16:58:15 +0100 |
---|---|---|
committer | Aleksey Kladov <[email protected]> | 2020-04-09 16:58:15 +0100 |
commit | 4a063e651f0ec0da852ce1f87589d5c0a893c59d (patch) | |
tree | 1206b6185253043900f325b620997a7a648f82cb /crates/ra_syntax/src/ast/generated/tokens.rs | |
parent | c80795e27491527487f97368be54b4467eb8b41e (diff) |
Move the rest of the tokens to generated/tokens
Diffstat (limited to 'crates/ra_syntax/src/ast/generated/tokens.rs')
-rw-r--r-- | crates/ra_syntax/src/ast/generated/tokens.rs | 651 |
1 files changed, 651 insertions, 0 deletions
diff --git a/crates/ra_syntax/src/ast/generated/tokens.rs b/crates/ra_syntax/src/ast/generated/tokens.rs index 27b2d2977..3aea5bef1 100644 --- a/crates/ra_syntax/src/ast/generated/tokens.rs +++ b/crates/ra_syntax/src/ast/generated/tokens.rs | |||
@@ -3056,3 +3056,654 @@ impl AstToken for RDollar { | |||
3056 | &self.syntax | 3056 | &self.syntax |
3057 | } | 3057 | } |
3058 | } | 3058 | } |
3059 | #[derive(Debug, Clone, PartialEq, Eq, Hash)] | ||
3060 | pub enum LeftDelimiter { | ||
3061 | LParen(LParen), | ||
3062 | LBrack(LBrack), | ||
3063 | LCurly(LCurly), | ||
3064 | } | ||
3065 | impl From<LParen> for LeftDelimiter { | ||
3066 | fn from(node: LParen) -> LeftDelimiter { | ||
3067 | LeftDelimiter::LParen(node) | ||
3068 | } | ||
3069 | } | ||
3070 | impl From<LBrack> for LeftDelimiter { | ||
3071 | fn from(node: LBrack) -> LeftDelimiter { | ||
3072 | LeftDelimiter::LBrack(node) | ||
3073 | } | ||
3074 | } | ||
3075 | impl From<LCurly> for LeftDelimiter { | ||
3076 | fn from(node: LCurly) -> LeftDelimiter { | ||
3077 | LeftDelimiter::LCurly(node) | ||
3078 | } | ||
3079 | } | ||
3080 | impl std::fmt::Display for LeftDelimiter { | ||
3081 | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { | ||
3082 | std::fmt::Display::fmt(self.syntax(), f) | ||
3083 | } | ||
3084 | } | ||
3085 | impl AstToken for LeftDelimiter { | ||
3086 | fn can_cast(kind: SyntaxKind) -> bool { | ||
3087 | match kind { | ||
3088 | L_PAREN | L_BRACK | L_CURLY => true, | ||
3089 | _ => false, | ||
3090 | } | ||
3091 | } | ||
3092 | fn cast(syntax: SyntaxToken) -> Option<Self> { | ||
3093 | let res = match syntax.kind() { | ||
3094 | L_PAREN => LeftDelimiter::LParen(LParen { syntax }), | ||
3095 | L_BRACK => LeftDelimiter::LBrack(LBrack { syntax }), | ||
3096 | L_CURLY => LeftDelimiter::LCurly(LCurly { syntax }), | ||
3097 | _ => return None, | ||
3098 | }; | ||
3099 | Some(res) | ||
3100 | } | ||
3101 | fn syntax(&self) -> &SyntaxToken { | ||
3102 | match self { | ||
3103 | LeftDelimiter::LParen(it) => &it.syntax, | ||
3104 | LeftDelimiter::LBrack(it) => &it.syntax, | ||
3105 | LeftDelimiter::LCurly(it) => &it.syntax, | ||
3106 | } | ||
3107 | } | ||
3108 | } | ||
3109 | #[derive(Debug, Clone, PartialEq, Eq, Hash)] | ||
3110 | pub enum RightDelimiter { | ||
3111 | RParen(RParen), | ||
3112 | RBrack(RBrack), | ||
3113 | RCurly(RCurly), | ||
3114 | } | ||
3115 | impl From<RParen> for RightDelimiter { | ||
3116 | fn from(node: RParen) -> RightDelimiter { | ||
3117 | RightDelimiter::RParen(node) | ||
3118 | } | ||
3119 | } | ||
3120 | impl From<RBrack> for RightDelimiter { | ||
3121 | fn from(node: RBrack) -> RightDelimiter { | ||
3122 | RightDelimiter::RBrack(node) | ||
3123 | } | ||
3124 | } | ||
3125 | impl From<RCurly> for RightDelimiter { | ||
3126 | fn from(node: RCurly) -> RightDelimiter { | ||
3127 | RightDelimiter::RCurly(node) | ||
3128 | } | ||
3129 | } | ||
3130 | impl std::fmt::Display for RightDelimiter { | ||
3131 | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { | ||
3132 | std::fmt::Display::fmt(self.syntax(), f) | ||
3133 | } | ||
3134 | } | ||
3135 | impl AstToken for RightDelimiter { | ||
3136 | fn can_cast(kind: SyntaxKind) -> bool { | ||
3137 | match kind { | ||
3138 | R_PAREN | R_BRACK | R_CURLY => true, | ||
3139 | _ => false, | ||
3140 | } | ||
3141 | } | ||
3142 | fn cast(syntax: SyntaxToken) -> Option<Self> { | ||
3143 | let res = match syntax.kind() { | ||
3144 | R_PAREN => RightDelimiter::RParen(RParen { syntax }), | ||
3145 | R_BRACK => RightDelimiter::RBrack(RBrack { syntax }), | ||
3146 | R_CURLY => RightDelimiter::RCurly(RCurly { syntax }), | ||
3147 | _ => return None, | ||
3148 | }; | ||
3149 | Some(res) | ||
3150 | } | ||
3151 | fn syntax(&self) -> &SyntaxToken { | ||
3152 | match self { | ||
3153 | RightDelimiter::RParen(it) => &it.syntax, | ||
3154 | RightDelimiter::RBrack(it) => &it.syntax, | ||
3155 | RightDelimiter::RCurly(it) => &it.syntax, | ||
3156 | } | ||
3157 | } | ||
3158 | } | ||
3159 | #[derive(Debug, Clone, PartialEq, Eq, Hash)] | ||
3160 | pub enum RangeSeparator { | ||
3161 | Dotdot(Dotdot), | ||
3162 | Dotdotdot(Dotdotdot), | ||
3163 | Dotdoteq(Dotdoteq), | ||
3164 | } | ||
3165 | impl From<Dotdot> for RangeSeparator { | ||
3166 | fn from(node: Dotdot) -> RangeSeparator { | ||
3167 | RangeSeparator::Dotdot(node) | ||
3168 | } | ||
3169 | } | ||
3170 | impl From<Dotdotdot> for RangeSeparator { | ||
3171 | fn from(node: Dotdotdot) -> RangeSeparator { | ||
3172 | RangeSeparator::Dotdotdot(node) | ||
3173 | } | ||
3174 | } | ||
3175 | impl From<Dotdoteq> for RangeSeparator { | ||
3176 | fn from(node: Dotdoteq) -> RangeSeparator { | ||
3177 | RangeSeparator::Dotdoteq(node) | ||
3178 | } | ||
3179 | } | ||
3180 | impl std::fmt::Display for RangeSeparator { | ||
3181 | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { | ||
3182 | std::fmt::Display::fmt(self.syntax(), f) | ||
3183 | } | ||
3184 | } | ||
3185 | impl AstToken for RangeSeparator { | ||
3186 | fn can_cast(kind: SyntaxKind) -> bool { | ||
3187 | match kind { | ||
3188 | DOTDOT | DOTDOTDOT | DOTDOTEQ => true, | ||
3189 | _ => false, | ||
3190 | } | ||
3191 | } | ||
3192 | fn cast(syntax: SyntaxToken) -> Option<Self> { | ||
3193 | let res = match syntax.kind() { | ||
3194 | DOTDOT => RangeSeparator::Dotdot(Dotdot { syntax }), | ||
3195 | DOTDOTDOT => RangeSeparator::Dotdotdot(Dotdotdot { syntax }), | ||
3196 | DOTDOTEQ => RangeSeparator::Dotdoteq(Dotdoteq { syntax }), | ||
3197 | _ => return None, | ||
3198 | }; | ||
3199 | Some(res) | ||
3200 | } | ||
3201 | fn syntax(&self) -> &SyntaxToken { | ||
3202 | match self { | ||
3203 | RangeSeparator::Dotdot(it) => &it.syntax, | ||
3204 | RangeSeparator::Dotdotdot(it) => &it.syntax, | ||
3205 | RangeSeparator::Dotdoteq(it) => &it.syntax, | ||
3206 | } | ||
3207 | } | ||
3208 | } | ||
3209 | #[derive(Debug, Clone, PartialEq, Eq, Hash)] | ||
3210 | pub enum BinOp { | ||
3211 | Pipepipe(Pipepipe), | ||
3212 | Ampamp(Ampamp), | ||
3213 | Eqeq(Eqeq), | ||
3214 | Neq(Neq), | ||
3215 | Lteq(Lteq), | ||
3216 | Gteq(Gteq), | ||
3217 | LAngle(LAngle), | ||
3218 | RAngle(RAngle), | ||
3219 | Plus(Plus), | ||
3220 | Star(Star), | ||
3221 | Minus(Minus), | ||
3222 | Slash(Slash), | ||
3223 | Percent(Percent), | ||
3224 | Shl(Shl), | ||
3225 | Shr(Shr), | ||
3226 | Caret(Caret), | ||
3227 | Pipe(Pipe), | ||
3228 | Amp(Amp), | ||
3229 | Eq(Eq), | ||
3230 | Pluseq(Pluseq), | ||
3231 | Slasheq(Slasheq), | ||
3232 | Stareq(Stareq), | ||
3233 | Percenteq(Percenteq), | ||
3234 | Shreq(Shreq), | ||
3235 | Shleq(Shleq), | ||
3236 | Minuseq(Minuseq), | ||
3237 | Pipeeq(Pipeeq), | ||
3238 | Ampeq(Ampeq), | ||
3239 | Careteq(Careteq), | ||
3240 | } | ||
3241 | impl From<Pipepipe> for BinOp { | ||
3242 | fn from(node: Pipepipe) -> BinOp { | ||
3243 | BinOp::Pipepipe(node) | ||
3244 | } | ||
3245 | } | ||
3246 | impl From<Ampamp> for BinOp { | ||
3247 | fn from(node: Ampamp) -> BinOp { | ||
3248 | BinOp::Ampamp(node) | ||
3249 | } | ||
3250 | } | ||
3251 | impl From<Eqeq> for BinOp { | ||
3252 | fn from(node: Eqeq) -> BinOp { | ||
3253 | BinOp::Eqeq(node) | ||
3254 | } | ||
3255 | } | ||
3256 | impl From<Neq> for BinOp { | ||
3257 | fn from(node: Neq) -> BinOp { | ||
3258 | BinOp::Neq(node) | ||
3259 | } | ||
3260 | } | ||
3261 | impl From<Lteq> for BinOp { | ||
3262 | fn from(node: Lteq) -> BinOp { | ||
3263 | BinOp::Lteq(node) | ||
3264 | } | ||
3265 | } | ||
3266 | impl From<Gteq> for BinOp { | ||
3267 | fn from(node: Gteq) -> BinOp { | ||
3268 | BinOp::Gteq(node) | ||
3269 | } | ||
3270 | } | ||
3271 | impl From<LAngle> for BinOp { | ||
3272 | fn from(node: LAngle) -> BinOp { | ||
3273 | BinOp::LAngle(node) | ||
3274 | } | ||
3275 | } | ||
3276 | impl From<RAngle> for BinOp { | ||
3277 | fn from(node: RAngle) -> BinOp { | ||
3278 | BinOp::RAngle(node) | ||
3279 | } | ||
3280 | } | ||
3281 | impl From<Plus> for BinOp { | ||
3282 | fn from(node: Plus) -> BinOp { | ||
3283 | BinOp::Plus(node) | ||
3284 | } | ||
3285 | } | ||
3286 | impl From<Star> for BinOp { | ||
3287 | fn from(node: Star) -> BinOp { | ||
3288 | BinOp::Star(node) | ||
3289 | } | ||
3290 | } | ||
3291 | impl From<Minus> for BinOp { | ||
3292 | fn from(node: Minus) -> BinOp { | ||
3293 | BinOp::Minus(node) | ||
3294 | } | ||
3295 | } | ||
3296 | impl From<Slash> for BinOp { | ||
3297 | fn from(node: Slash) -> BinOp { | ||
3298 | BinOp::Slash(node) | ||
3299 | } | ||
3300 | } | ||
3301 | impl From<Percent> for BinOp { | ||
3302 | fn from(node: Percent) -> BinOp { | ||
3303 | BinOp::Percent(node) | ||
3304 | } | ||
3305 | } | ||
3306 | impl From<Shl> for BinOp { | ||
3307 | fn from(node: Shl) -> BinOp { | ||
3308 | BinOp::Shl(node) | ||
3309 | } | ||
3310 | } | ||
3311 | impl From<Shr> for BinOp { | ||
3312 | fn from(node: Shr) -> BinOp { | ||
3313 | BinOp::Shr(node) | ||
3314 | } | ||
3315 | } | ||
3316 | impl From<Caret> for BinOp { | ||
3317 | fn from(node: Caret) -> BinOp { | ||
3318 | BinOp::Caret(node) | ||
3319 | } | ||
3320 | } | ||
3321 | impl From<Pipe> for BinOp { | ||
3322 | fn from(node: Pipe) -> BinOp { | ||
3323 | BinOp::Pipe(node) | ||
3324 | } | ||
3325 | } | ||
3326 | impl From<Amp> for BinOp { | ||
3327 | fn from(node: Amp) -> BinOp { | ||
3328 | BinOp::Amp(node) | ||
3329 | } | ||
3330 | } | ||
3331 | impl From<Eq> for BinOp { | ||
3332 | fn from(node: Eq) -> BinOp { | ||
3333 | BinOp::Eq(node) | ||
3334 | } | ||
3335 | } | ||
3336 | impl From<Pluseq> for BinOp { | ||
3337 | fn from(node: Pluseq) -> BinOp { | ||
3338 | BinOp::Pluseq(node) | ||
3339 | } | ||
3340 | } | ||
3341 | impl From<Slasheq> for BinOp { | ||
3342 | fn from(node: Slasheq) -> BinOp { | ||
3343 | BinOp::Slasheq(node) | ||
3344 | } | ||
3345 | } | ||
3346 | impl From<Stareq> for BinOp { | ||
3347 | fn from(node: Stareq) -> BinOp { | ||
3348 | BinOp::Stareq(node) | ||
3349 | } | ||
3350 | } | ||
3351 | impl From<Percenteq> for BinOp { | ||
3352 | fn from(node: Percenteq) -> BinOp { | ||
3353 | BinOp::Percenteq(node) | ||
3354 | } | ||
3355 | } | ||
3356 | impl From<Shreq> for BinOp { | ||
3357 | fn from(node: Shreq) -> BinOp { | ||
3358 | BinOp::Shreq(node) | ||
3359 | } | ||
3360 | } | ||
3361 | impl From<Shleq> for BinOp { | ||
3362 | fn from(node: Shleq) -> BinOp { | ||
3363 | BinOp::Shleq(node) | ||
3364 | } | ||
3365 | } | ||
3366 | impl From<Minuseq> for BinOp { | ||
3367 | fn from(node: Minuseq) -> BinOp { | ||
3368 | BinOp::Minuseq(node) | ||
3369 | } | ||
3370 | } | ||
3371 | impl From<Pipeeq> for BinOp { | ||
3372 | fn from(node: Pipeeq) -> BinOp { | ||
3373 | BinOp::Pipeeq(node) | ||
3374 | } | ||
3375 | } | ||
3376 | impl From<Ampeq> for BinOp { | ||
3377 | fn from(node: Ampeq) -> BinOp { | ||
3378 | BinOp::Ampeq(node) | ||
3379 | } | ||
3380 | } | ||
3381 | impl From<Careteq> for BinOp { | ||
3382 | fn from(node: Careteq) -> BinOp { | ||
3383 | BinOp::Careteq(node) | ||
3384 | } | ||
3385 | } | ||
3386 | impl std::fmt::Display for BinOp { | ||
3387 | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { | ||
3388 | std::fmt::Display::fmt(self.syntax(), f) | ||
3389 | } | ||
3390 | } | ||
3391 | impl AstToken for BinOp { | ||
3392 | fn can_cast(kind: SyntaxKind) -> bool { | ||
3393 | match kind { | ||
3394 | PIPEPIPE | AMPAMP | EQEQ | NEQ | LTEQ | GTEQ | L_ANGLE | R_ANGLE | PLUS | STAR | ||
3395 | | MINUS | SLASH | PERCENT | SHL | SHR | CARET | PIPE | AMP | EQ | PLUSEQ | SLASHEQ | ||
3396 | | STAREQ | PERCENTEQ | SHREQ | SHLEQ | MINUSEQ | PIPEEQ | AMPEQ | CARETEQ => true, | ||
3397 | _ => false, | ||
3398 | } | ||
3399 | } | ||
3400 | fn cast(syntax: SyntaxToken) -> Option<Self> { | ||
3401 | let res = match syntax.kind() { | ||
3402 | PIPEPIPE => BinOp::Pipepipe(Pipepipe { syntax }), | ||
3403 | AMPAMP => BinOp::Ampamp(Ampamp { syntax }), | ||
3404 | EQEQ => BinOp::Eqeq(Eqeq { syntax }), | ||
3405 | NEQ => BinOp::Neq(Neq { syntax }), | ||
3406 | LTEQ => BinOp::Lteq(Lteq { syntax }), | ||
3407 | GTEQ => BinOp::Gteq(Gteq { syntax }), | ||
3408 | L_ANGLE => BinOp::LAngle(LAngle { syntax }), | ||
3409 | R_ANGLE => BinOp::RAngle(RAngle { syntax }), | ||
3410 | PLUS => BinOp::Plus(Plus { syntax }), | ||
3411 | STAR => BinOp::Star(Star { syntax }), | ||
3412 | MINUS => BinOp::Minus(Minus { syntax }), | ||
3413 | SLASH => BinOp::Slash(Slash { syntax }), | ||
3414 | PERCENT => BinOp::Percent(Percent { syntax }), | ||
3415 | SHL => BinOp::Shl(Shl { syntax }), | ||
3416 | SHR => BinOp::Shr(Shr { syntax }), | ||
3417 | CARET => BinOp::Caret(Caret { syntax }), | ||
3418 | PIPE => BinOp::Pipe(Pipe { syntax }), | ||
3419 | AMP => BinOp::Amp(Amp { syntax }), | ||
3420 | EQ => BinOp::Eq(Eq { syntax }), | ||
3421 | PLUSEQ => BinOp::Pluseq(Pluseq { syntax }), | ||
3422 | SLASHEQ => BinOp::Slasheq(Slasheq { syntax }), | ||
3423 | STAREQ => BinOp::Stareq(Stareq { syntax }), | ||
3424 | PERCENTEQ => BinOp::Percenteq(Percenteq { syntax }), | ||
3425 | SHREQ => BinOp::Shreq(Shreq { syntax }), | ||
3426 | SHLEQ => BinOp::Shleq(Shleq { syntax }), | ||
3427 | MINUSEQ => BinOp::Minuseq(Minuseq { syntax }), | ||
3428 | PIPEEQ => BinOp::Pipeeq(Pipeeq { syntax }), | ||
3429 | AMPEQ => BinOp::Ampeq(Ampeq { syntax }), | ||
3430 | CARETEQ => BinOp::Careteq(Careteq { syntax }), | ||
3431 | _ => return None, | ||
3432 | }; | ||
3433 | Some(res) | ||
3434 | } | ||
3435 | fn syntax(&self) -> &SyntaxToken { | ||
3436 | match self { | ||
3437 | BinOp::Pipepipe(it) => &it.syntax, | ||
3438 | BinOp::Ampamp(it) => &it.syntax, | ||
3439 | BinOp::Eqeq(it) => &it.syntax, | ||
3440 | BinOp::Neq(it) => &it.syntax, | ||
3441 | BinOp::Lteq(it) => &it.syntax, | ||
3442 | BinOp::Gteq(it) => &it.syntax, | ||
3443 | BinOp::LAngle(it) => &it.syntax, | ||
3444 | BinOp::RAngle(it) => &it.syntax, | ||
3445 | BinOp::Plus(it) => &it.syntax, | ||
3446 | BinOp::Star(it) => &it.syntax, | ||
3447 | BinOp::Minus(it) => &it.syntax, | ||
3448 | BinOp::Slash(it) => &it.syntax, | ||
3449 | BinOp::Percent(it) => &it.syntax, | ||
3450 | BinOp::Shl(it) => &it.syntax, | ||
3451 | BinOp::Shr(it) => &it.syntax, | ||
3452 | BinOp::Caret(it) => &it.syntax, | ||
3453 | BinOp::Pipe(it) => &it.syntax, | ||
3454 | BinOp::Amp(it) => &it.syntax, | ||
3455 | BinOp::Eq(it) => &it.syntax, | ||
3456 | BinOp::Pluseq(it) => &it.syntax, | ||
3457 | BinOp::Slasheq(it) => &it.syntax, | ||
3458 | BinOp::Stareq(it) => &it.syntax, | ||
3459 | BinOp::Percenteq(it) => &it.syntax, | ||
3460 | BinOp::Shreq(it) => &it.syntax, | ||
3461 | BinOp::Shleq(it) => &it.syntax, | ||
3462 | BinOp::Minuseq(it) => &it.syntax, | ||
3463 | BinOp::Pipeeq(it) => &it.syntax, | ||
3464 | BinOp::Ampeq(it) => &it.syntax, | ||
3465 | BinOp::Careteq(it) => &it.syntax, | ||
3466 | } | ||
3467 | } | ||
3468 | } | ||
3469 | #[derive(Debug, Clone, PartialEq, Eq, Hash)] | ||
3470 | pub enum PrefixOp { | ||
3471 | Minus(Minus), | ||
3472 | Excl(Excl), | ||
3473 | Star(Star), | ||
3474 | } | ||
3475 | impl From<Minus> for PrefixOp { | ||
3476 | fn from(node: Minus) -> PrefixOp { | ||
3477 | PrefixOp::Minus(node) | ||
3478 | } | ||
3479 | } | ||
3480 | impl From<Excl> for PrefixOp { | ||
3481 | fn from(node: Excl) -> PrefixOp { | ||
3482 | PrefixOp::Excl(node) | ||
3483 | } | ||
3484 | } | ||
3485 | impl From<Star> for PrefixOp { | ||
3486 | fn from(node: Star) -> PrefixOp { | ||
3487 | PrefixOp::Star(node) | ||
3488 | } | ||
3489 | } | ||
3490 | impl std::fmt::Display for PrefixOp { | ||
3491 | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { | ||
3492 | std::fmt::Display::fmt(self.syntax(), f) | ||
3493 | } | ||
3494 | } | ||
3495 | impl AstToken for PrefixOp { | ||
3496 | fn can_cast(kind: SyntaxKind) -> bool { | ||
3497 | match kind { | ||
3498 | MINUS | EXCL | STAR => true, | ||
3499 | _ => false, | ||
3500 | } | ||
3501 | } | ||
3502 | fn cast(syntax: SyntaxToken) -> Option<Self> { | ||
3503 | let res = match syntax.kind() { | ||
3504 | MINUS => PrefixOp::Minus(Minus { syntax }), | ||
3505 | EXCL => PrefixOp::Excl(Excl { syntax }), | ||
3506 | STAR => PrefixOp::Star(Star { syntax }), | ||
3507 | _ => return None, | ||
3508 | }; | ||
3509 | Some(res) | ||
3510 | } | ||
3511 | fn syntax(&self) -> &SyntaxToken { | ||
3512 | match self { | ||
3513 | PrefixOp::Minus(it) => &it.syntax, | ||
3514 | PrefixOp::Excl(it) => &it.syntax, | ||
3515 | PrefixOp::Star(it) => &it.syntax, | ||
3516 | } | ||
3517 | } | ||
3518 | } | ||
3519 | #[derive(Debug, Clone, PartialEq, Eq, Hash)] | ||
3520 | pub enum RangeOp { | ||
3521 | Dotdot(Dotdot), | ||
3522 | Dotdoteq(Dotdoteq), | ||
3523 | } | ||
3524 | impl From<Dotdot> for RangeOp { | ||
3525 | fn from(node: Dotdot) -> RangeOp { | ||
3526 | RangeOp::Dotdot(node) | ||
3527 | } | ||
3528 | } | ||
3529 | impl From<Dotdoteq> for RangeOp { | ||
3530 | fn from(node: Dotdoteq) -> RangeOp { | ||
3531 | RangeOp::Dotdoteq(node) | ||
3532 | } | ||
3533 | } | ||
3534 | impl std::fmt::Display for RangeOp { | ||
3535 | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { | ||
3536 | std::fmt::Display::fmt(self.syntax(), f) | ||
3537 | } | ||
3538 | } | ||
3539 | impl AstToken for RangeOp { | ||
3540 | fn can_cast(kind: SyntaxKind) -> bool { | ||
3541 | match kind { | ||
3542 | DOTDOT | DOTDOTEQ => true, | ||
3543 | _ => false, | ||
3544 | } | ||
3545 | } | ||
3546 | fn cast(syntax: SyntaxToken) -> Option<Self> { | ||
3547 | let res = match syntax.kind() { | ||
3548 | DOTDOT => RangeOp::Dotdot(Dotdot { syntax }), | ||
3549 | DOTDOTEQ => RangeOp::Dotdoteq(Dotdoteq { syntax }), | ||
3550 | _ => return None, | ||
3551 | }; | ||
3552 | Some(res) | ||
3553 | } | ||
3554 | fn syntax(&self) -> &SyntaxToken { | ||
3555 | match self { | ||
3556 | RangeOp::Dotdot(it) => &it.syntax, | ||
3557 | RangeOp::Dotdoteq(it) => &it.syntax, | ||
3558 | } | ||
3559 | } | ||
3560 | } | ||
3561 | #[derive(Debug, Clone, PartialEq, Eq, Hash)] | ||
3562 | pub enum LiteralToken { | ||
3563 | IntNumber(IntNumber), | ||
3564 | FloatNumber(FloatNumber), | ||
3565 | String(String), | ||
3566 | RawString(RawString), | ||
3567 | TrueKw(TrueKw), | ||
3568 | FalseKw(FalseKw), | ||
3569 | ByteString(ByteString), | ||
3570 | RawByteString(RawByteString), | ||
3571 | Char(Char), | ||
3572 | Byte(Byte), | ||
3573 | } | ||
3574 | impl From<IntNumber> for LiteralToken { | ||
3575 | fn from(node: IntNumber) -> LiteralToken { | ||
3576 | LiteralToken::IntNumber(node) | ||
3577 | } | ||
3578 | } | ||
3579 | impl From<FloatNumber> for LiteralToken { | ||
3580 | fn from(node: FloatNumber) -> LiteralToken { | ||
3581 | LiteralToken::FloatNumber(node) | ||
3582 | } | ||
3583 | } | ||
3584 | impl From<String> for LiteralToken { | ||
3585 | fn from(node: String) -> LiteralToken { | ||
3586 | LiteralToken::String(node) | ||
3587 | } | ||
3588 | } | ||
3589 | impl From<RawString> for LiteralToken { | ||
3590 | fn from(node: RawString) -> LiteralToken { | ||
3591 | LiteralToken::RawString(node) | ||
3592 | } | ||
3593 | } | ||
3594 | impl From<TrueKw> for LiteralToken { | ||
3595 | fn from(node: TrueKw) -> LiteralToken { | ||
3596 | LiteralToken::TrueKw(node) | ||
3597 | } | ||
3598 | } | ||
3599 | impl From<FalseKw> for LiteralToken { | ||
3600 | fn from(node: FalseKw) -> LiteralToken { | ||
3601 | LiteralToken::FalseKw(node) | ||
3602 | } | ||
3603 | } | ||
3604 | impl From<ByteString> for LiteralToken { | ||
3605 | fn from(node: ByteString) -> LiteralToken { | ||
3606 | LiteralToken::ByteString(node) | ||
3607 | } | ||
3608 | } | ||
3609 | impl From<RawByteString> for LiteralToken { | ||
3610 | fn from(node: RawByteString) -> LiteralToken { | ||
3611 | LiteralToken::RawByteString(node) | ||
3612 | } | ||
3613 | } | ||
3614 | impl From<Char> for LiteralToken { | ||
3615 | fn from(node: Char) -> LiteralToken { | ||
3616 | LiteralToken::Char(node) | ||
3617 | } | ||
3618 | } | ||
3619 | impl From<Byte> for LiteralToken { | ||
3620 | fn from(node: Byte) -> LiteralToken { | ||
3621 | LiteralToken::Byte(node) | ||
3622 | } | ||
3623 | } | ||
3624 | impl std::fmt::Display for LiteralToken { | ||
3625 | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { | ||
3626 | std::fmt::Display::fmt(self.syntax(), f) | ||
3627 | } | ||
3628 | } | ||
3629 | impl AstToken for LiteralToken { | ||
3630 | fn can_cast(kind: SyntaxKind) -> bool { | ||
3631 | match kind { | ||
3632 | INT_NUMBER | FLOAT_NUMBER | STRING | RAW_STRING | TRUE_KW | FALSE_KW | BYTE_STRING | ||
3633 | | RAW_BYTE_STRING | CHAR | BYTE => true, | ||
3634 | _ => false, | ||
3635 | } | ||
3636 | } | ||
3637 | fn cast(syntax: SyntaxToken) -> Option<Self> { | ||
3638 | let res = match syntax.kind() { | ||
3639 | INT_NUMBER => LiteralToken::IntNumber(IntNumber { syntax }), | ||
3640 | FLOAT_NUMBER => LiteralToken::FloatNumber(FloatNumber { syntax }), | ||
3641 | STRING => LiteralToken::String(String { syntax }), | ||
3642 | RAW_STRING => LiteralToken::RawString(RawString { syntax }), | ||
3643 | TRUE_KW => LiteralToken::TrueKw(TrueKw { syntax }), | ||
3644 | FALSE_KW => LiteralToken::FalseKw(FalseKw { syntax }), | ||
3645 | BYTE_STRING => LiteralToken::ByteString(ByteString { syntax }), | ||
3646 | RAW_BYTE_STRING => LiteralToken::RawByteString(RawByteString { syntax }), | ||
3647 | CHAR => LiteralToken::Char(Char { syntax }), | ||
3648 | BYTE => LiteralToken::Byte(Byte { syntax }), | ||
3649 | _ => return None, | ||
3650 | }; | ||
3651 | Some(res) | ||
3652 | } | ||
3653 | fn syntax(&self) -> &SyntaxToken { | ||
3654 | match self { | ||
3655 | LiteralToken::IntNumber(it) => &it.syntax, | ||
3656 | LiteralToken::FloatNumber(it) => &it.syntax, | ||
3657 | LiteralToken::String(it) => &it.syntax, | ||
3658 | LiteralToken::RawString(it) => &it.syntax, | ||
3659 | LiteralToken::TrueKw(it) => &it.syntax, | ||
3660 | LiteralToken::FalseKw(it) => &it.syntax, | ||
3661 | LiteralToken::ByteString(it) => &it.syntax, | ||
3662 | LiteralToken::RawByteString(it) => &it.syntax, | ||
3663 | LiteralToken::Char(it) => &it.syntax, | ||
3664 | LiteralToken::Byte(it) => &it.syntax, | ||
3665 | } | ||
3666 | } | ||
3667 | } | ||
3668 | #[derive(Debug, Clone, PartialEq, Eq, Hash)] | ||
3669 | pub enum NameRefToken { | ||
3670 | Ident(Ident), | ||
3671 | IntNumber(IntNumber), | ||
3672 | } | ||
3673 | impl From<Ident> for NameRefToken { | ||
3674 | fn from(node: Ident) -> NameRefToken { | ||
3675 | NameRefToken::Ident(node) | ||
3676 | } | ||
3677 | } | ||
3678 | impl From<IntNumber> for NameRefToken { | ||
3679 | fn from(node: IntNumber) -> NameRefToken { | ||
3680 | NameRefToken::IntNumber(node) | ||
3681 | } | ||
3682 | } | ||
3683 | impl std::fmt::Display for NameRefToken { | ||
3684 | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { | ||
3685 | std::fmt::Display::fmt(self.syntax(), f) | ||
3686 | } | ||
3687 | } | ||
3688 | impl AstToken for NameRefToken { | ||
3689 | fn can_cast(kind: SyntaxKind) -> bool { | ||
3690 | match kind { | ||
3691 | IDENT | INT_NUMBER => true, | ||
3692 | _ => false, | ||
3693 | } | ||
3694 | } | ||
3695 | fn cast(syntax: SyntaxToken) -> Option<Self> { | ||
3696 | let res = match syntax.kind() { | ||
3697 | IDENT => NameRefToken::Ident(Ident { syntax }), | ||
3698 | INT_NUMBER => NameRefToken::IntNumber(IntNumber { syntax }), | ||
3699 | _ => return None, | ||
3700 | }; | ||
3701 | Some(res) | ||
3702 | } | ||
3703 | fn syntax(&self) -> &SyntaxToken { | ||
3704 | match self { | ||
3705 | NameRefToken::Ident(it) => &it.syntax, | ||
3706 | NameRefToken::IntNumber(it) => &it.syntax, | ||
3707 | } | ||
3708 | } | ||
3709 | } | ||