1 files changed, 302 insertions, 19 deletions

diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index c73533861..c22e026cf 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -131,7 +131,15 @@ impl<R: TreeRoot<RaTypes>> ArrayTypeNode<R> {
 }
 
 
-impl<'a> ArrayType<'a> {}
+impl<'a> ArrayType<'a> {
+    pub fn type_ref(self) -> Option<TypeRef<'a>> {
+        super::child_opt(self)
+    }
+
+    pub fn expr(self) -> Option<Expr<'a>> {
+        super::child_opt(self)
+    }
+}
 
 // Attr
 #[derive(Debug, Clone, Copy,)]
@@ -806,7 +814,94 @@ impl<'a> ast::NameOwner<'a> for EnumDef<'a> {}
 impl<'a> ast::TypeParamsOwner<'a> for EnumDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for EnumDef<'a> {}
 impl<'a> ast::DocCommentsOwner<'a> for EnumDef<'a> {}
-impl<'a> EnumDef<'a> {}
+impl<'a> EnumDef<'a> {
+    pub fn variant_list(self) -> Option<EnumVariantList<'a>> {
+        super::child_opt(self)
+    }
+}
+
+// EnumVariant
+#[derive(Debug, Clone, Copy,)]
+pub struct EnumVariantNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
+}
+pub type EnumVariant<'a> = EnumVariantNode<RefRoot<'a>>;
+
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<EnumVariantNode<R1>> for EnumVariantNode<R2> {
+    fn eq(&self, other: &EnumVariantNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for EnumVariantNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for EnumVariantNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
+impl<'a> AstNode<'a> for EnumVariant<'a> {
+    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+        match syntax.kind() {
+            ENUM_VARIANT => Some(EnumVariant { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
+}
+
+impl<R: TreeRoot<RaTypes>> EnumVariantNode<R> {
+    pub fn borrowed(&self) -> EnumVariant {
+        EnumVariantNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> EnumVariantNode {
+        EnumVariantNode { syntax: self.syntax.owned() }
+    }
+}
+
+
+impl<'a> ast::NameOwner<'a> for EnumVariant<'a> {}
+impl<'a> EnumVariant<'a> {
+    pub fn expr(self) -> Option<Expr<'a>> {
+        super::child_opt(self)
+    }
+}
+
+// EnumVariantList
+#[derive(Debug, Clone, Copy,)]
+pub struct EnumVariantListNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
+}
+pub type EnumVariantList<'a> = EnumVariantListNode<RefRoot<'a>>;
+
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<EnumVariantListNode<R1>> for EnumVariantListNode<R2> {
+    fn eq(&self, other: &EnumVariantListNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for EnumVariantListNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for EnumVariantListNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
+impl<'a> AstNode<'a> for EnumVariantList<'a> {
+    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+        match syntax.kind() {
+            ENUM_VARIANT_LIST => Some(EnumVariantList { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
+}
+
+impl<R: TreeRoot<RaTypes>> EnumVariantListNode<R> {
+    pub fn borrowed(&self) -> EnumVariantList {
+        EnumVariantListNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> EnumVariantListNode {
+        EnumVariantListNode { syntax: self.syntax.owned() }
+    }
+}
+
+
+impl<'a> EnumVariantList<'a> {
+    pub fn variants(self) -> impl Iterator<Item = EnumVariant<'a>> + 'a {
+        super::children(self)
+    }
+}
 
 // Expr
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -1036,7 +1131,15 @@ impl<R: TreeRoot<RaTypes>> FieldExprNode<R> {
 }
 
 
-impl<'a> FieldExpr<'a> {}
+impl<'a> FieldExpr<'a> {
+    pub fn expr(self) -> Option<Expr<'a>> {
+        super::child_opt(self)
+    }
+
+    pub fn name_ref(self) -> Option<NameRef<'a>> {
+        super::child_opt(self)
+    }
+}
 
 // FieldPatList
 #[derive(Debug, Clone, Copy,)]
@@ -1163,7 +1266,15 @@ impl<R: TreeRoot<RaTypes>> FnPointerTypeNode<R> {
 }
 
 
-impl<'a> FnPointerType<'a> {}
+impl<'a> FnPointerType<'a> {
+    pub fn param_list(self) -> Option<ParamList<'a>> {
+        super::child_opt(self)
+    }
+
+    pub fn ret_type(self) -> Option<RetType<'a>> {
+        super::child_opt(self)
+    }
+}
 
 // ForExpr
 #[derive(Debug, Clone, Copy,)]
@@ -1246,7 +1357,11 @@ impl<R: TreeRoot<RaTypes>> ForTypeNode<R> {
 }
 
 
-impl<'a> ForType<'a> {}
+impl<'a> ForType<'a> {
+    pub fn type_ref(self) -> Option<TypeRef<'a>> {
+        super::child_opt(self)
+    }
+}
 
 // IfExpr
 #[derive(Debug, Clone, Copy,)]
@@ -1935,6 +2050,10 @@ impl<'a> MethodCallExpr<'a> {
     pub fn expr(self) -> Option<Expr<'a>> {
         super::child_opt(self)
     }
+
+    pub fn name_ref(self) -> Option<NameRef<'a>> {
+        super::child_opt(self)
+    }
 }
 
 // Module
@@ -2142,7 +2261,15 @@ impl<R: TreeRoot<RaTypes>> NamedFieldNode<R> {
 }
 
 
-impl<'a> NamedField<'a> {}
+impl<'a> NamedField<'a> {
+    pub fn name_ref(self) -> Option<NameRef<'a>> {
+        super::child_opt(self)
+    }
+
+    pub fn expr(self) -> Option<Expr<'a>> {
+        super::child_opt(self)
+    }
+}
 
 // NamedFieldDef
 #[derive(Debug, Clone, Copy,)]
@@ -2181,7 +2308,52 @@ impl<R: TreeRoot<RaTypes>> NamedFieldDefNode<R> {
 
 impl<'a> ast::NameOwner<'a> for NamedFieldDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for NamedFieldDef<'a> {}
-impl<'a> NamedFieldDef<'a> {}
+impl<'a> NamedFieldDef<'a> {
+    pub fn type_ref(self) -> Option<TypeRef<'a>> {
+        super::child_opt(self)
+    }
+}
+
+// NamedFieldDefList
+#[derive(Debug, Clone, Copy,)]
+pub struct NamedFieldDefListNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
+}
+pub type NamedFieldDefList<'a> = NamedFieldDefListNode<RefRoot<'a>>;
+
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<NamedFieldDefListNode<R1>> for NamedFieldDefListNode<R2> {
+    fn eq(&self, other: &NamedFieldDefListNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for NamedFieldDefListNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for NamedFieldDefListNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
+impl<'a> AstNode<'a> for NamedFieldDefList<'a> {
+    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+        match syntax.kind() {
+            NAMED_FIELD_DEF_LIST => Some(NamedFieldDefList { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
+}
+
+impl<R: TreeRoot<RaTypes>> NamedFieldDefListNode<R> {
+    pub fn borrowed(&self) -> NamedFieldDefList {
+        NamedFieldDefListNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> NamedFieldDefListNode {
+        NamedFieldDefListNode { syntax: self.syntax.owned() }
+    }
+}
+
+
+impl<'a> NamedFieldDefList<'a> {
+    pub fn fields(self) -> impl Iterator<Item = NamedFieldDef<'a>> + 'a {
+        super::children(self)
+    }
+}
 
 // NamedFieldList
 #[derive(Debug, Clone, Copy,)]
@@ -2218,7 +2390,11 @@ impl<R: TreeRoot<RaTypes>> NamedFieldListNode<R> {
 }
 
 
-impl<'a> NamedFieldList<'a> {}
+impl<'a> NamedFieldList<'a> {
+    pub fn fields(self) -> impl Iterator<Item = NamedField<'a>> + 'a {
+        super::children(self)
+    }
+}
 
 // NeverType
 #[derive(Debug, Clone, Copy,)]
@@ -2451,7 +2627,11 @@ impl<R: TreeRoot<RaTypes>> ParenTypeNode<R> {
 }
 
 
-impl<'a> ParenType<'a> {}
+impl<'a> ParenType<'a> {
+    pub fn type_ref(self) -> Option<TypeRef<'a>> {
+        super::child_opt(self)
+    }
+}
 
 // Pat
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -2816,7 +2996,94 @@ impl<R: TreeRoot<RaTypes>> PointerTypeNode<R> {
 }
 
 
-impl<'a> PointerType<'a> {}
+impl<'a> PointerType<'a> {
+    pub fn type_ref(self) -> Option<TypeRef<'a>> {
+        super::child_opt(self)
+    }
+}
+
+// PosField
+#[derive(Debug, Clone, Copy,)]
+pub struct PosFieldNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
+}
+pub type PosField<'a> = PosFieldNode<RefRoot<'a>>;
+
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<PosFieldNode<R1>> for PosFieldNode<R2> {
+    fn eq(&self, other: &PosFieldNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for PosFieldNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for PosFieldNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
+impl<'a> AstNode<'a> for PosField<'a> {
+    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+        match syntax.kind() {
+            POS_FIELD => Some(PosField { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
+}
+
+impl<R: TreeRoot<RaTypes>> PosFieldNode<R> {
+    pub fn borrowed(&self) -> PosField {
+        PosFieldNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> PosFieldNode {
+        PosFieldNode { syntax: self.syntax.owned() }
+    }
+}
+
+
+impl<'a> ast::AttrsOwner<'a> for PosField<'a> {}
+impl<'a> PosField<'a> {
+    pub fn type_ref(self) -> Option<TypeRef<'a>> {
+        super::child_opt(self)
+    }
+}
+
+// PosFieldList
+#[derive(Debug, Clone, Copy,)]
+pub struct PosFieldListNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
+}
+pub type PosFieldList<'a> = PosFieldListNode<RefRoot<'a>>;
+
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<PosFieldListNode<R1>> for PosFieldListNode<R2> {
+    fn eq(&self, other: &PosFieldListNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for PosFieldListNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for PosFieldListNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
+impl<'a> AstNode<'a> for PosFieldList<'a> {
+    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+        match syntax.kind() {
+            POS_FIELD_LIST => Some(PosFieldList { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
+}
+
+impl<R: TreeRoot<RaTypes>> PosFieldListNode<R> {
+    pub fn borrowed(&self) -> PosFieldList {
+        PosFieldListNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> PosFieldListNode {
+        PosFieldListNode { syntax: self.syntax.owned() }
+    }
+}
+
+
+impl<'a> PosFieldList<'a> {
+    pub fn fields(self) -> impl Iterator<Item = PosField<'a>> + 'a {
+        super::children(self)
+    }
+}
 
 // PrefixExpr
 #[derive(Debug, Clone, Copy,)]
@@ -3046,7 +3313,11 @@ impl<R: TreeRoot<RaTypes>> ReferenceTypeNode<R> {
 }
 
 
-impl<'a> ReferenceType<'a> {}
+impl<'a> ReferenceType<'a> {
+    pub fn type_ref(self) -> Option<TypeRef<'a>> {
+        super::child_opt(self)
+    }
+}
 
 // RetType
 #[derive(Debug, Clone, Copy,)]
@@ -3239,7 +3510,11 @@ impl<R: TreeRoot<RaTypes>> SliceTypeNode<R> {
 }
 
 
-impl<'a> SliceType<'a> {}
+impl<'a> SliceType<'a> {
+    pub fn type_ref(self) -> Option<TypeRef<'a>> {
+        super::child_opt(self)
+    }
+}
 
 // SourceFile
 #[derive(Debug, Clone, Copy,)]
@@ -3426,11 +3701,7 @@ impl<'a> ast::NameOwner<'a> for StructDef<'a> {}
 impl<'a> ast::TypeParamsOwner<'a> for StructDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for StructDef<'a> {}
 impl<'a> ast::DocCommentsOwner<'a> for StructDef<'a> {}
-impl<'a> StructDef<'a> {
-    pub fn fields(self) -> impl Iterator<Item = NamedFieldDef<'a>> + 'a {
-        super::children(self)
-    }
-}
+impl<'a> StructDef<'a> {}
 
 // StructLit
 #[derive(Debug, Clone, Copy,)]
@@ -3467,7 +3738,15 @@ impl<R: TreeRoot<RaTypes>> StructLitNode<R> {
 }
 
 
-impl<'a> StructLit<'a> {}
+impl<'a> StructLit<'a> {
+    pub fn path(self) -> Option<Path<'a>> {
+        super::child_opt(self)
+    }
+
+    pub fn named_field_list(self) -> Option<NamedFieldList<'a>> {
+        super::child_opt(self)
+    }
+}
 
 // StructPat
 #[derive(Debug, Clone, Copy,)]
@@ -3770,7 +4049,11 @@ impl<R: TreeRoot<RaTypes>> TupleTypeNode<R> {
 }
 
 
-impl<'a> TupleType<'a> {}
+impl<'a> TupleType<'a> {
+    pub fn fields(self) -> impl Iterator<Item = TypeRef<'a>> + 'a {
+        super::children(self)
+    }
+}
 
 // TypeDef
 #[derive(Debug, Clone, Copy,)]