diff options
Diffstat (limited to 'crates/ra_syntax/src/ast/generated/tokens.rs')
-rw-r--r-- | crates/ra_syntax/src/ast/generated/tokens.rs | 239 |
1 files changed, 0 insertions, 239 deletions
diff --git a/crates/ra_syntax/src/ast/generated/tokens.rs b/crates/ra_syntax/src/ast/generated/tokens.rs index 7611ce4cb..293f91c2e 100644 --- a/crates/ra_syntax/src/ast/generated/tokens.rs +++ b/crates/ra_syntax/src/ast/generated/tokens.rs | |||
@@ -1365,242 +1365,3 @@ impl AstToken for RDollar { | |||
1365 | } | 1365 | } |
1366 | fn syntax(&self) -> &SyntaxToken { &self.syntax } | 1366 | fn syntax(&self) -> &SyntaxToken { &self.syntax } |
1367 | } | 1367 | } |
1368 | #[derive(Debug, Clone, PartialEq, Eq, Hash)] | ||
1369 | pub enum RangeSeparator { | ||
1370 | Dotdot(Dotdot), | ||
1371 | Dotdotdot(Dotdotdot), | ||
1372 | Dotdoteq(Dotdoteq), | ||
1373 | } | ||
1374 | impl From<Dotdot> for RangeSeparator { | ||
1375 | fn from(node: Dotdot) -> RangeSeparator { RangeSeparator::Dotdot(node) } | ||
1376 | } | ||
1377 | impl From<Dotdotdot> for RangeSeparator { | ||
1378 | fn from(node: Dotdotdot) -> RangeSeparator { RangeSeparator::Dotdotdot(node) } | ||
1379 | } | ||
1380 | impl From<Dotdoteq> for RangeSeparator { | ||
1381 | fn from(node: Dotdoteq) -> RangeSeparator { RangeSeparator::Dotdoteq(node) } | ||
1382 | } | ||
1383 | impl std::fmt::Display for RangeSeparator { | ||
1384 | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { | ||
1385 | std::fmt::Display::fmt(self.syntax(), f) | ||
1386 | } | ||
1387 | } | ||
1388 | impl AstToken for RangeSeparator { | ||
1389 | fn can_cast(kind: SyntaxKind) -> bool { | ||
1390 | match kind { | ||
1391 | DOTDOT | DOTDOTDOT | DOTDOTEQ => true, | ||
1392 | _ => false, | ||
1393 | } | ||
1394 | } | ||
1395 | fn cast(syntax: SyntaxToken) -> Option<Self> { | ||
1396 | let res = match syntax.kind() { | ||
1397 | DOTDOT => RangeSeparator::Dotdot(Dotdot { syntax }), | ||
1398 | DOTDOTDOT => RangeSeparator::Dotdotdot(Dotdotdot { syntax }), | ||
1399 | DOTDOTEQ => RangeSeparator::Dotdoteq(Dotdoteq { syntax }), | ||
1400 | _ => return None, | ||
1401 | }; | ||
1402 | Some(res) | ||
1403 | } | ||
1404 | fn syntax(&self) -> &SyntaxToken { | ||
1405 | match self { | ||
1406 | RangeSeparator::Dotdot(it) => &it.syntax, | ||
1407 | RangeSeparator::Dotdotdot(it) => &it.syntax, | ||
1408 | RangeSeparator::Dotdoteq(it) => &it.syntax, | ||
1409 | } | ||
1410 | } | ||
1411 | } | ||
1412 | #[derive(Debug, Clone, PartialEq, Eq, Hash)] | ||
1413 | pub enum PrefixOp { | ||
1414 | Minus(Minus), | ||
1415 | Excl(Excl), | ||
1416 | Star(Star), | ||
1417 | } | ||
1418 | impl From<Minus> for PrefixOp { | ||
1419 | fn from(node: Minus) -> PrefixOp { PrefixOp::Minus(node) } | ||
1420 | } | ||
1421 | impl From<Excl> for PrefixOp { | ||
1422 | fn from(node: Excl) -> PrefixOp { PrefixOp::Excl(node) } | ||
1423 | } | ||
1424 | impl From<Star> for PrefixOp { | ||
1425 | fn from(node: Star) -> PrefixOp { PrefixOp::Star(node) } | ||
1426 | } | ||
1427 | impl std::fmt::Display for PrefixOp { | ||
1428 | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { | ||
1429 | std::fmt::Display::fmt(self.syntax(), f) | ||
1430 | } | ||
1431 | } | ||
1432 | impl AstToken for PrefixOp { | ||
1433 | fn can_cast(kind: SyntaxKind) -> bool { | ||
1434 | match kind { | ||
1435 | MINUS | EXCL | STAR => true, | ||
1436 | _ => false, | ||
1437 | } | ||
1438 | } | ||
1439 | fn cast(syntax: SyntaxToken) -> Option<Self> { | ||
1440 | let res = match syntax.kind() { | ||
1441 | MINUS => PrefixOp::Minus(Minus { syntax }), | ||
1442 | EXCL => PrefixOp::Excl(Excl { syntax }), | ||
1443 | STAR => PrefixOp::Star(Star { syntax }), | ||
1444 | _ => return None, | ||
1445 | }; | ||
1446 | Some(res) | ||
1447 | } | ||
1448 | fn syntax(&self) -> &SyntaxToken { | ||
1449 | match self { | ||
1450 | PrefixOp::Minus(it) => &it.syntax, | ||
1451 | PrefixOp::Excl(it) => &it.syntax, | ||
1452 | PrefixOp::Star(it) => &it.syntax, | ||
1453 | } | ||
1454 | } | ||
1455 | } | ||
1456 | #[derive(Debug, Clone, PartialEq, Eq, Hash)] | ||
1457 | pub enum RangeOp { | ||
1458 | Dotdot(Dotdot), | ||
1459 | Dotdoteq(Dotdoteq), | ||
1460 | } | ||
1461 | impl From<Dotdot> for RangeOp { | ||
1462 | fn from(node: Dotdot) -> RangeOp { RangeOp::Dotdot(node) } | ||
1463 | } | ||
1464 | impl From<Dotdoteq> for RangeOp { | ||
1465 | fn from(node: Dotdoteq) -> RangeOp { RangeOp::Dotdoteq(node) } | ||
1466 | } | ||
1467 | impl std::fmt::Display for RangeOp { | ||
1468 | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { | ||
1469 | std::fmt::Display::fmt(self.syntax(), f) | ||
1470 | } | ||
1471 | } | ||
1472 | impl AstToken for RangeOp { | ||
1473 | fn can_cast(kind: SyntaxKind) -> bool { | ||
1474 | match kind { | ||
1475 | DOTDOT | DOTDOTEQ => true, | ||
1476 | _ => false, | ||
1477 | } | ||
1478 | } | ||
1479 | fn cast(syntax: SyntaxToken) -> Option<Self> { | ||
1480 | let res = match syntax.kind() { | ||
1481 | DOTDOT => RangeOp::Dotdot(Dotdot { syntax }), | ||
1482 | DOTDOTEQ => RangeOp::Dotdoteq(Dotdoteq { syntax }), | ||
1483 | _ => return None, | ||
1484 | }; | ||
1485 | Some(res) | ||
1486 | } | ||
1487 | fn syntax(&self) -> &SyntaxToken { | ||
1488 | match self { | ||
1489 | RangeOp::Dotdot(it) => &it.syntax, | ||
1490 | RangeOp::Dotdoteq(it) => &it.syntax, | ||
1491 | } | ||
1492 | } | ||
1493 | } | ||
1494 | #[derive(Debug, Clone, PartialEq, Eq, Hash)] | ||
1495 | pub enum LiteralToken { | ||
1496 | IntNumber(IntNumber), | ||
1497 | FloatNumber(FloatNumber), | ||
1498 | String(String), | ||
1499 | RawString(RawString), | ||
1500 | ByteString(ByteString), | ||
1501 | RawByteString(RawByteString), | ||
1502 | Char(Char), | ||
1503 | Byte(Byte), | ||
1504 | } | ||
1505 | impl From<IntNumber> for LiteralToken { | ||
1506 | fn from(node: IntNumber) -> LiteralToken { LiteralToken::IntNumber(node) } | ||
1507 | } | ||
1508 | impl From<FloatNumber> for LiteralToken { | ||
1509 | fn from(node: FloatNumber) -> LiteralToken { LiteralToken::FloatNumber(node) } | ||
1510 | } | ||
1511 | impl From<String> for LiteralToken { | ||
1512 | fn from(node: String) -> LiteralToken { LiteralToken::String(node) } | ||
1513 | } | ||
1514 | impl From<RawString> for LiteralToken { | ||
1515 | fn from(node: RawString) -> LiteralToken { LiteralToken::RawString(node) } | ||
1516 | } | ||
1517 | impl From<ByteString> for LiteralToken { | ||
1518 | fn from(node: ByteString) -> LiteralToken { LiteralToken::ByteString(node) } | ||
1519 | } | ||
1520 | impl From<RawByteString> for LiteralToken { | ||
1521 | fn from(node: RawByteString) -> LiteralToken { LiteralToken::RawByteString(node) } | ||
1522 | } | ||
1523 | impl From<Char> for LiteralToken { | ||
1524 | fn from(node: Char) -> LiteralToken { LiteralToken::Char(node) } | ||
1525 | } | ||
1526 | impl From<Byte> for LiteralToken { | ||
1527 | fn from(node: Byte) -> LiteralToken { LiteralToken::Byte(node) } | ||
1528 | } | ||
1529 | impl std::fmt::Display for LiteralToken { | ||
1530 | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { | ||
1531 | std::fmt::Display::fmt(self.syntax(), f) | ||
1532 | } | ||
1533 | } | ||
1534 | impl AstToken for LiteralToken { | ||
1535 | fn can_cast(kind: SyntaxKind) -> bool { | ||
1536 | match kind { | ||
1537 | INT_NUMBER | FLOAT_NUMBER | STRING | RAW_STRING | BYTE_STRING | RAW_BYTE_STRING | ||
1538 | | CHAR | BYTE => true, | ||
1539 | _ => false, | ||
1540 | } | ||
1541 | } | ||
1542 | fn cast(syntax: SyntaxToken) -> Option<Self> { | ||
1543 | let res = match syntax.kind() { | ||
1544 | INT_NUMBER => LiteralToken::IntNumber(IntNumber { syntax }), | ||
1545 | FLOAT_NUMBER => LiteralToken::FloatNumber(FloatNumber { syntax }), | ||
1546 | STRING => LiteralToken::String(String { syntax }), | ||
1547 | RAW_STRING => LiteralToken::RawString(RawString { syntax }), | ||
1548 | BYTE_STRING => LiteralToken::ByteString(ByteString { syntax }), | ||
1549 | RAW_BYTE_STRING => LiteralToken::RawByteString(RawByteString { syntax }), | ||
1550 | CHAR => LiteralToken::Char(Char { syntax }), | ||
1551 | BYTE => LiteralToken::Byte(Byte { syntax }), | ||
1552 | _ => return None, | ||
1553 | }; | ||
1554 | Some(res) | ||
1555 | } | ||
1556 | fn syntax(&self) -> &SyntaxToken { | ||
1557 | match self { | ||
1558 | LiteralToken::IntNumber(it) => &it.syntax, | ||
1559 | LiteralToken::FloatNumber(it) => &it.syntax, | ||
1560 | LiteralToken::String(it) => &it.syntax, | ||
1561 | LiteralToken::RawString(it) => &it.syntax, | ||
1562 | LiteralToken::ByteString(it) => &it.syntax, | ||
1563 | LiteralToken::RawByteString(it) => &it.syntax, | ||
1564 | LiteralToken::Char(it) => &it.syntax, | ||
1565 | LiteralToken::Byte(it) => &it.syntax, | ||
1566 | } | ||
1567 | } | ||
1568 | } | ||
1569 | #[derive(Debug, Clone, PartialEq, Eq, Hash)] | ||
1570 | pub enum NameRefToken { | ||
1571 | Ident(Ident), | ||
1572 | IntNumber(IntNumber), | ||
1573 | } | ||
1574 | impl From<Ident> for NameRefToken { | ||
1575 | fn from(node: Ident) -> NameRefToken { NameRefToken::Ident(node) } | ||
1576 | } | ||
1577 | impl From<IntNumber> for NameRefToken { | ||
1578 | fn from(node: IntNumber) -> NameRefToken { NameRefToken::IntNumber(node) } | ||
1579 | } | ||
1580 | impl std::fmt::Display for NameRefToken { | ||
1581 | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { | ||
1582 | std::fmt::Display::fmt(self.syntax(), f) | ||
1583 | } | ||
1584 | } | ||
1585 | impl AstToken for NameRefToken { | ||
1586 | fn can_cast(kind: SyntaxKind) -> bool { | ||
1587 | match kind { | ||
1588 | IDENT | INT_NUMBER => true, | ||
1589 | _ => false, | ||
1590 | } | ||
1591 | } | ||
1592 | fn cast(syntax: SyntaxToken) -> Option<Self> { | ||
1593 | let res = match syntax.kind() { | ||
1594 | IDENT => NameRefToken::Ident(Ident { syntax }), | ||
1595 | INT_NUMBER => NameRefToken::IntNumber(IntNumber { syntax }), | ||
1596 | _ => return None, | ||
1597 | }; | ||
1598 | Some(res) | ||
1599 | } | ||
1600 | fn syntax(&self) -> &SyntaxToken { | ||
1601 | match self { | ||
1602 | NameRefToken::Ident(it) => &it.syntax, | ||
1603 | NameRefToken::IntNumber(it) => &it.syntax, | ||
1604 | } | ||
1605 | } | ||
1606 | } | ||