1 files changed, 112 insertions, 538 deletions

diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index 84f39cda1..0376c91c8 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -376,64 +376,6 @@ impl BreakExpr {
     }
 }
 
-// Byte
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct Byte {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for Byte {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-
-impl AstNode for Byte {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            BYTE => Some(Byte::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-
-impl ToOwned for Byte {
-    type Owned = TreeArc<Byte>;
-    fn to_owned(&self) -> TreeArc<Byte> { TreeArc::cast(self.syntax.to_owned()) }
-}
-
-
-impl ast::AstToken for Byte {}
-impl Byte {}
-
-// ByteString
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct ByteString {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for ByteString {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-
-impl AstNode for ByteString {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            BYTE_STRING => Some(ByteString::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-
-impl ToOwned for ByteString {
-    type Owned = TreeArc<ByteString>;
-    fn to_owned(&self) -> TreeArc<ByteString> { TreeArc::cast(self.syntax.to_owned()) }
-}
-
-
-impl ast::AstToken for ByteString {}
-impl ByteString {}
-
 // CallExpr
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
@@ -503,64 +445,6 @@ impl CastExpr {
     }
 }
 
-// Char
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct Char {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for Char {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-
-impl AstNode for Char {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            CHAR => Some(Char::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-
-impl ToOwned for Char {
-    type Owned = TreeArc<Char>;
-    fn to_owned(&self) -> TreeArc<Char> { TreeArc::cast(self.syntax.to_owned()) }
-}
-
-
-impl ast::AstToken for Char {}
-impl Char {}
-
-// Comment
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct Comment {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for Comment {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-
-impl AstNode for Comment {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            COMMENT => Some(Comment::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-
-impl ToOwned for Comment {
-    type Owned = TreeArc<Comment>;
-    fn to_owned(&self) -> TreeArc<Comment> { TreeArc::cast(self.syntax.to_owned()) }
-}
-
-
-impl ast::AstToken for Comment {}
-impl Comment {}
-
 // Condition
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
@@ -689,6 +573,7 @@ impl ToOwned for DynTraitType {
 }
 
 
+impl ast::TypeBoundsOwner for DynTraitType {}
 impl DynTraitType {}
 
 // EnumDef
@@ -834,6 +719,7 @@ pub enum ExprKind<'a> {
     RangeExpr(&'a RangeExpr),
     BinExpr(&'a BinExpr),
     Literal(&'a Literal),
+    MacroCall(&'a MacroCall),
 }
 impl<'a> From<&'a TupleExpr> for &'a Expr {
     fn from(n: &'a TupleExpr) -> &'a Expr {
@@ -970,6 +856,11 @@ impl<'a> From<&'a Literal> for &'a Expr {
         Expr::cast(&n.syntax).unwrap()
     }
 }
+impl<'a> From<&'a MacroCall> for &'a Expr {
+    fn from(n: &'a MacroCall) -> &'a Expr {
+        Expr::cast(&n.syntax).unwrap()
+    }
+}
 
 
 impl AstNode for Expr {
@@ -1001,7 +892,8 @@ impl AstNode for Expr {
             | PREFIX_EXPR
             | RANGE_EXPR
             | BIN_EXPR
-            | LITERAL => Some(Expr::from_repr(syntax.into_repr())),
+            | LITERAL
+            | MACRO_CALL => Some(Expr::from_repr(syntax.into_repr())),
             _ => None,
         }
     }
@@ -1043,6 +935,7 @@ impl Expr {
             RANGE_EXPR => ExprKind::RangeExpr(RangeExpr::cast(&self.syntax).unwrap()),
             BIN_EXPR => ExprKind::BinExpr(BinExpr::cast(&self.syntax).unwrap()),
             LITERAL => ExprKind::Literal(Literal::cast(&self.syntax).unwrap()),
+            MACRO_CALL => ExprKind::MacroCall(MacroCall::cast(&self.syntax).unwrap()),
             _ => unreachable!(),
         }
     }
@@ -1118,35 +1011,6 @@ impl ExternCrateItem {
     }
 }
 
-// FalseKw
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct FalseKw {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for FalseKw {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-
-impl AstNode for FalseKw {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            FALSE_KW => Some(FalseKw::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-
-impl ToOwned for FalseKw {
-    type Owned = TreeArc<FalseKw>;
-    fn to_owned(&self) -> TreeArc<FalseKw> { TreeArc::cast(self.syntax.to_owned()) }
-}
-
-
-impl ast::AstToken for FalseKw {}
-impl FalseKw {}
-
 // FieldExpr
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
@@ -1252,35 +1116,6 @@ impl FieldPatList {
     }
 }
 
-// FloatNumber
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct FloatNumber {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for FloatNumber {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-
-impl AstNode for FloatNumber {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            FLOAT_NUMBER => Some(FloatNumber::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-
-impl ToOwned for FloatNumber {
-    type Owned = TreeArc<FloatNumber>;
-    fn to_owned(&self) -> TreeArc<FloatNumber> { TreeArc::cast(self.syntax.to_owned()) }
-}
-
-
-impl ast::AstToken for FloatNumber {}
-impl FloatNumber {}
-
 // FnDef
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
@@ -1585,6 +1420,7 @@ impl ToOwned for ImplTraitType {
 }
 
 
+impl ast::TypeBoundsOwner for ImplTraitType {}
 impl ImplTraitType {}
 
 // IndexExpr
@@ -1615,35 +1451,6 @@ impl ToOwned for IndexExpr {
 
 impl IndexExpr {}
 
-// IntNumber
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct IntNumber {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for IntNumber {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-
-impl AstNode for IntNumber {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            INT_NUMBER => Some(IntNumber::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-
-impl ToOwned for IntNumber {
-    type Owned = TreeArc<IntNumber>;
-    fn to_owned(&self) -> TreeArc<IntNumber> { TreeArc::cast(self.syntax.to_owned()) }
-}
-
-
-impl ast::AstToken for IntNumber {}
-impl IntNumber {}
-
 // ItemList
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
@@ -1779,35 +1586,6 @@ impl LetStmt {
     }
 }
 
-// Lifetime
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct Lifetime {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for Lifetime {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-
-impl AstNode for Lifetime {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            LIFETIME => Some(Lifetime::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-
-impl ToOwned for Lifetime {
-    type Owned = TreeArc<Lifetime>;
-    fn to_owned(&self) -> TreeArc<Lifetime> { TreeArc::cast(self.syntax.to_owned()) }
-}
-
-
-impl ast::AstToken for Lifetime {}
-impl Lifetime {}
-
 // LifetimeArg
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
@@ -1834,11 +1612,7 @@ impl ToOwned for LifetimeArg {
 }
 
 
-impl LifetimeArg {
-    pub fn lifetime(&self) -> Option<&Lifetime> {
-        super::child_opt(self)
-    }
-}
+impl LifetimeArg {}
 
 // LifetimeParam
 #[derive(Debug, PartialEq, Eq, Hash)]
@@ -1867,11 +1641,7 @@ impl ToOwned for LifetimeParam {
 
 
 impl ast::AttrsOwner for LifetimeParam {}
-impl LifetimeParam {
-    pub fn lifetime(&self) -> Option<&Lifetime> {
-        super::child_opt(self)
-    }
-}
+impl LifetimeParam {}
 
 // Literal
 #[derive(Debug, PartialEq, Eq, Hash)]
@@ -1899,130 +1669,7 @@ impl ToOwned for Literal {
 }
 
 
-impl Literal {
-    pub fn literal_expr(&self) -> Option<&LiteralExpr> {
-        super::child_opt(self)
-    }
-}
-
-// LiteralExpr
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct LiteralExpr {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for LiteralExpr {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum LiteralExprKind<'a> {
-    String(&'a String),
-    ByteString(&'a ByteString),
-    RawString(&'a RawString),
-    RawByteString(&'a RawByteString),
-    Char(&'a Char),
-    Byte(&'a Byte),
-    IntNumber(&'a IntNumber),
-    FloatNumber(&'a FloatNumber),
-    TrueKw(&'a TrueKw),
-    FalseKw(&'a FalseKw),
-}
-impl<'a> From<&'a String> for &'a LiteralExpr {
-    fn from(n: &'a String) -> &'a LiteralExpr {
-        LiteralExpr::cast(&n.syntax).unwrap()
-    }
-}
-impl<'a> From<&'a ByteString> for &'a LiteralExpr {
-    fn from(n: &'a ByteString) -> &'a LiteralExpr {
-        LiteralExpr::cast(&n.syntax).unwrap()
-    }
-}
-impl<'a> From<&'a RawString> for &'a LiteralExpr {
-    fn from(n: &'a RawString) -> &'a LiteralExpr {
-        LiteralExpr::cast(&n.syntax).unwrap()
-    }
-}
-impl<'a> From<&'a RawByteString> for &'a LiteralExpr {
-    fn from(n: &'a RawByteString) -> &'a LiteralExpr {
-        LiteralExpr::cast(&n.syntax).unwrap()
-    }
-}
-impl<'a> From<&'a Char> for &'a LiteralExpr {
-    fn from(n: &'a Char) -> &'a LiteralExpr {
-        LiteralExpr::cast(&n.syntax).unwrap()
-    }
-}
-impl<'a> From<&'a Byte> for &'a LiteralExpr {
-    fn from(n: &'a Byte) -> &'a LiteralExpr {
-        LiteralExpr::cast(&n.syntax).unwrap()
-    }
-}
-impl<'a> From<&'a IntNumber> for &'a LiteralExpr {
-    fn from(n: &'a IntNumber) -> &'a LiteralExpr {
-        LiteralExpr::cast(&n.syntax).unwrap()
-    }
-}
-impl<'a> From<&'a FloatNumber> for &'a LiteralExpr {
-    fn from(n: &'a FloatNumber) -> &'a LiteralExpr {
-        LiteralExpr::cast(&n.syntax).unwrap()
-    }
-}
-impl<'a> From<&'a TrueKw> for &'a LiteralExpr {
-    fn from(n: &'a TrueKw) -> &'a LiteralExpr {
-        LiteralExpr::cast(&n.syntax).unwrap()
-    }
-}
-impl<'a> From<&'a FalseKw> for &'a LiteralExpr {
-    fn from(n: &'a FalseKw) -> &'a LiteralExpr {
-        LiteralExpr::cast(&n.syntax).unwrap()
-    }
-}
-
-
-impl AstNode for LiteralExpr {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            | STRING
-            | BYTE_STRING
-            | RAW_STRING
-            | RAW_BYTE_STRING
-            | CHAR
-            | BYTE
-            | INT_NUMBER
-            | FLOAT_NUMBER
-            | TRUE_KW
-            | FALSE_KW => Some(LiteralExpr::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-
-impl ToOwned for LiteralExpr {
-    type Owned = TreeArc<LiteralExpr>;
-    fn to_owned(&self) -> TreeArc<LiteralExpr> { TreeArc::cast(self.syntax.to_owned()) }
-}
-
-impl LiteralExpr {
-    pub fn kind(&self) -> LiteralExprKind {
-        match self.syntax.kind() {
-            STRING => LiteralExprKind::String(String::cast(&self.syntax).unwrap()),
-            BYTE_STRING => LiteralExprKind::ByteString(ByteString::cast(&self.syntax).unwrap()),
-            RAW_STRING => LiteralExprKind::RawString(RawString::cast(&self.syntax).unwrap()),
-            RAW_BYTE_STRING => LiteralExprKind::RawByteString(RawByteString::cast(&self.syntax).unwrap()),
-            CHAR => LiteralExprKind::Char(Char::cast(&self.syntax).unwrap()),
-            BYTE => LiteralExprKind::Byte(Byte::cast(&self.syntax).unwrap()),
-            INT_NUMBER => LiteralExprKind::IntNumber(IntNumber::cast(&self.syntax).unwrap()),
-            FLOAT_NUMBER => LiteralExprKind::FloatNumber(FloatNumber::cast(&self.syntax).unwrap()),
-            TRUE_KW => LiteralExprKind::TrueKw(TrueKw::cast(&self.syntax).unwrap()),
-            FALSE_KW => LiteralExprKind::FalseKw(FalseKw::cast(&self.syntax).unwrap()),
-            _ => unreachable!(),
-        }
-    }
-}
-
-impl LiteralExpr {}
+impl Literal {}
 
 // LiteralPat
 #[derive(Debug, PartialEq, Eq, Hash)]
@@ -3406,64 +3053,6 @@ impl ToOwned for RangePat {
 
 impl RangePat {}
 
-// RawByteString
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct RawByteString {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for RawByteString {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-
-impl AstNode for RawByteString {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            RAW_BYTE_STRING => Some(RawByteString::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-
-impl ToOwned for RawByteString {
-    type Owned = TreeArc<RawByteString>;
-    fn to_owned(&self) -> TreeArc<RawByteString> { TreeArc::cast(self.syntax.to_owned()) }
-}
-
-
-impl ast::AstToken for RawByteString {}
-impl RawByteString {}
-
-// RawString
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct RawString {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for RawString {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-
-impl AstNode for RawString {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            RAW_STRING => Some(RawString::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-
-impl ToOwned for RawString {
-    type Owned = TreeArc<RawString>;
-    fn to_owned(&self) -> TreeArc<RawString> { TreeArc::cast(self.syntax.to_owned()) }
-}
-
-
-impl ast::AstToken for RawString {}
-impl RawString {}
-
 // RefExpr
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
@@ -3624,34 +3213,6 @@ impl ReturnExpr {
     }
 }
 
-// SelfKw
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct SelfKw {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for SelfKw {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-
-impl AstNode for SelfKw {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            SELF_KW => Some(SelfKw::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-
-impl ToOwned for SelfKw {
-    type Owned = TreeArc<SelfKw>;
-    fn to_owned(&self) -> TreeArc<SelfKw> { TreeArc::cast(self.syntax.to_owned()) }
-}
-
-
-impl SelfKw {}
-
 // SelfParam
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
@@ -3679,11 +3240,7 @@ impl ToOwned for SelfParam {
 
 
 impl ast::TypeAscriptionOwner for SelfParam {}
-impl SelfParam {
-    pub fn self_kw(&self) -> Option<&SelfKw> {
-        super::child_opt(self)
-    }
-}
+impl SelfParam {}
 
 // SlicePat
 #[derive(Debug, PartialEq, Eq, Hash)]
@@ -3872,35 +3429,6 @@ impl Stmt {
 
 impl Stmt {}
 
-// String
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct String {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for String {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-
-impl AstNode for String {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            STRING => Some(String::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-
-impl ToOwned for String {
-    type Owned = TreeArc<String>;
-    fn to_owned(&self) -> TreeArc<String> { TreeArc::cast(self.syntax.to_owned()) }
-}
-
-
-impl ast::AstToken for String {}
-impl String {}
-
 // StructDef
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
@@ -4069,41 +3597,13 @@ impl ast::NameOwner for TraitDef {}
 impl ast::AttrsOwner for TraitDef {}
 impl ast::DocCommentsOwner for TraitDef {}
 impl ast::TypeParamsOwner for TraitDef {}
+impl ast::TypeBoundsOwner for TraitDef {}
 impl TraitDef {
     pub fn item_list(&self) -> Option<&ItemList> {
         super::child_opt(self)
     }
 }
 
-// TrueKw
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct TrueKw {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for TrueKw {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-
-impl AstNode for TrueKw {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            TRUE_KW => Some(TrueKw::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-
-impl ToOwned for TrueKw {
-    type Owned = TreeArc<TrueKw>;
-    fn to_owned(&self) -> TreeArc<TrueKw> { TreeArc::cast(self.syntax.to_owned()) }
-}
-
-
-impl ast::AstToken for TrueKw {}
-impl TrueKw {}
-
 // TryExpr
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
@@ -4299,6 +3799,7 @@ impl ast::NameOwner for TypeAliasDef {}
 impl ast::TypeParamsOwner for TypeAliasDef {}
 impl ast::AttrsOwner for TypeAliasDef {}
 impl ast::DocCommentsOwner for TypeAliasDef {}
+impl ast::TypeBoundsOwner for TypeAliasDef {}
 impl TypeAliasDef {
     pub fn type_ref(&self) -> Option<&TypeRef> {
         super::child_opt(self)
@@ -4377,6 +3878,70 @@ impl TypeArgList {
     }
 }
 
+// TypeBound
+#[derive(Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct TypeBound {
+    pub(crate) syntax: SyntaxNode,
+}
+unsafe impl TransparentNewType for TypeBound {
+    type Repr = rowan::SyntaxNode<RaTypes>;
+}
+
+impl AstNode for TypeBound {
+    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+        match syntax.kind() {
+            TYPE_BOUND => Some(TypeBound::from_repr(syntax.into_repr())),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for TypeBound {
+    type Owned = TreeArc<TypeBound>;
+    fn to_owned(&self) -> TreeArc<TypeBound> { TreeArc::cast(self.syntax.to_owned()) }
+}
+
+
+impl TypeBound {
+    pub fn type_ref(&self) -> Option<&TypeRef> {
+        super::child_opt(self)
+    }
+}
+
+// TypeBoundList
+#[derive(Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct TypeBoundList {
+    pub(crate) syntax: SyntaxNode,
+}
+unsafe impl TransparentNewType for TypeBoundList {
+    type Repr = rowan::SyntaxNode<RaTypes>;
+}
+
+impl AstNode for TypeBoundList {
+    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+        match syntax.kind() {
+            TYPE_BOUND_LIST => Some(TypeBoundList::from_repr(syntax.into_repr())),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for TypeBoundList {
+    type Owned = TreeArc<TypeBoundList>;
+    fn to_owned(&self) -> TreeArc<TypeBoundList> { TreeArc::cast(self.syntax.to_owned()) }
+}
+
+
+impl TypeBoundList {
+    pub fn bounds(&self) -> impl Iterator<Item = &TypeBound> {
+        super::children(self)
+    }
+}
+
 // TypeParam
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
@@ -4405,6 +3970,7 @@ impl ToOwned for TypeParam {
 
 impl ast::NameOwner for TypeParam {}
 impl ast::AttrsOwner for TypeParam {}
+impl ast::TypeBoundsOwner for TypeParam {}
 impl TypeParam {}
 
 // TypeParamList
@@ -4745,67 +4311,75 @@ impl ToOwned for WhereClause {
 }
 
 
-impl WhereClause {}
+impl WhereClause {
+    pub fn predicates(&self) -> impl Iterator<Item = &WherePred> {
+        super::children(self)
+    }
+}
 
-// WhileExpr
+// WherePred
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
-pub struct WhileExpr {
+pub struct WherePred {
     pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for WhileExpr {
+unsafe impl TransparentNewType for WherePred {
     type Repr = rowan::SyntaxNode<RaTypes>;
 }
 
-impl AstNode for WhileExpr {
+impl AstNode for WherePred {
     fn cast(syntax: &SyntaxNode) -> Option<&Self> {
         match syntax.kind() {
-            WHILE_EXPR => Some(WhileExpr::from_repr(syntax.into_repr())),
+            WHERE_PRED => Some(WherePred::from_repr(syntax.into_repr())),
             _ => None,
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 
-impl ToOwned for WhileExpr {
-    type Owned = TreeArc<WhileExpr>;
-    fn to_owned(&self) -> TreeArc<WhileExpr> { TreeArc::cast(self.syntax.to_owned()) }
+impl ToOwned for WherePred {
+    type Owned = TreeArc<WherePred>;
+    fn to_owned(&self) -> TreeArc<WherePred> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
 
-impl ast::LoopBodyOwner for WhileExpr {}
-impl WhileExpr {
-    pub fn condition(&self) -> Option<&Condition> {
+impl ast::TypeBoundsOwner for WherePred {}
+impl WherePred {
+    pub fn type_ref(&self) -> Option<&TypeRef> {
         super::child_opt(self)
     }
 }
 
-// Whitespace
+// WhileExpr
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
-pub struct Whitespace {
+pub struct WhileExpr {
     pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for Whitespace {
+unsafe impl TransparentNewType for WhileExpr {
     type Repr = rowan::SyntaxNode<RaTypes>;
 }
 
-impl AstNode for Whitespace {
+impl AstNode for WhileExpr {
     fn cast(syntax: &SyntaxNode) -> Option<&Self> {
         match syntax.kind() {
-            WHITESPACE => Some(Whitespace::from_repr(syntax.into_repr())),
+            WHILE_EXPR => Some(WhileExpr::from_repr(syntax.into_repr())),
             _ => None,
         }
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 
-impl ToOwned for Whitespace {
-    type Owned = TreeArc<Whitespace>;
-    fn to_owned(&self) -> TreeArc<Whitespace> { TreeArc::cast(self.syntax.to_owned()) }
+impl ToOwned for WhileExpr {
+    type Owned = TreeArc<WhileExpr>;
+    fn to_owned(&self) -> TreeArc<WhileExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
 
 
-impl ast::AstToken for Whitespace {}
-impl Whitespace {}
+impl ast::LoopBodyOwner for WhileExpr {}
+impl WhileExpr {
+    pub fn condition(&self) -> Option<&Condition> {
+        super::child_opt(self)
+    }
+}