rename

3 files changed, 53 insertions, 53 deletions

diff --git a/crates/libsyntax2/src/ast/generated.rs b/crates/libsyntax2/src/ast/generated.rs
index a557e6d73..b347a05b4 100644
--- a/crates/libsyntax2/src/ast/generated.rs
+++ b/crates/libsyntax2/src/ast/generated.rs
@@ -5,43 +5,43 @@ use {
     SyntaxKind::*,
 };
 
-// ConstItem
+// ConstDef
 #[derive(Debug, Clone, Copy)]
-pub struct ConstItem<R: TreeRoot = Arc<SyntaxRoot>> {
+pub struct ConstDef<R: TreeRoot = Arc<SyntaxRoot>> {
     syntax: SyntaxNode<R>,
 }
 
-impl<R: TreeRoot> AstNode<R> for ConstItem<R> {
+impl<R: TreeRoot> AstNode<R> for ConstDef<R> {
     fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
         match syntax.kind() {
-            CONST_DEF => Some(ConstItem { syntax }),
+            CONST_DEF => Some(ConstDef { syntax }),
             _ => None,
         }
     }
     fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
 }
 
-impl<R: TreeRoot> ast::NameOwner<R> for ConstItem<R> {}
-impl<R: TreeRoot> ConstItem<R> {}
+impl<R: TreeRoot> ast::NameOwner<R> for ConstDef<R> {}
+impl<R: TreeRoot> ConstDef<R> {}
 
-// Enum
+// EnumDef
 #[derive(Debug, Clone, Copy)]
-pub struct Enum<R: TreeRoot = Arc<SyntaxRoot>> {
+pub struct EnumDef<R: TreeRoot = Arc<SyntaxRoot>> {
     syntax: SyntaxNode<R>,
 }
 
-impl<R: TreeRoot> AstNode<R> for Enum<R> {
+impl<R: TreeRoot> AstNode<R> for EnumDef<R> {
     fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
         match syntax.kind() {
-            ENUM_DEF => Some(Enum { syntax }),
+            ENUM_DEF => Some(EnumDef { syntax }),
             _ => None,
         }
     }
     fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
 }
 
-impl<R: TreeRoot> ast::NameOwner<R> for Enum<R> {}
-impl<R: TreeRoot> Enum<R> {}
+impl<R: TreeRoot> ast::NameOwner<R> for EnumDef<R> {}
+impl<R: TreeRoot> EnumDef<R> {}
 
 // File
 #[derive(Debug, Clone, Copy)]
@@ -60,31 +60,31 @@ impl<R: TreeRoot> AstNode<R> for File<R> {
 }
 
 impl<R: TreeRoot> File<R> {
-    pub fn functions<'a>(&'a self) -> impl Iterator<Item = Function<R>> + 'a {
+    pub fn functions<'a>(&'a self) -> impl Iterator<Item = FnDef<R>> + 'a {
         self.syntax()
             .children()
-            .filter_map(Function::cast)
+            .filter_map(FnDef::cast)
     }
 }
 
-// Function
+// FnDef
 #[derive(Debug, Clone, Copy)]
-pub struct Function<R: TreeRoot = Arc<SyntaxRoot>> {
+pub struct FnDef<R: TreeRoot = Arc<SyntaxRoot>> {
     syntax: SyntaxNode<R>,
 }
 
-impl<R: TreeRoot> AstNode<R> for Function<R> {
+impl<R: TreeRoot> AstNode<R> for FnDef<R> {
     fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
         match syntax.kind() {
-            FN_DEF => Some(Function { syntax }),
+            FN_DEF => Some(FnDef { syntax }),
             _ => None,
         }
     }
     fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
 }
 
-impl<R: TreeRoot> ast::NameOwner<R> for Function<R> {}
-impl<R: TreeRoot> Function<R> {}
+impl<R: TreeRoot> ast::NameOwner<R> for FnDef<R> {}
+impl<R: TreeRoot> FnDef<R> {}
 
 // Module
 #[derive(Debug, Clone, Copy)]
@@ -141,79 +141,79 @@ impl<R: TreeRoot> AstNode<R> for NameRef<R> {
 
 impl<R: TreeRoot> NameRef<R> {}
 
-// StaticItem
+// StaticDef
 #[derive(Debug, Clone, Copy)]
-pub struct StaticItem<R: TreeRoot = Arc<SyntaxRoot>> {
+pub struct StaticDef<R: TreeRoot = Arc<SyntaxRoot>> {
     syntax: SyntaxNode<R>,
 }
 
-impl<R: TreeRoot> AstNode<R> for StaticItem<R> {
+impl<R: TreeRoot> AstNode<R> for StaticDef<R> {
     fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
         match syntax.kind() {
-            STATIC_DEF => Some(StaticItem { syntax }),
+            STATIC_DEF => Some(StaticDef { syntax }),
             _ => None,
         }
     }
     fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
 }
 
-impl<R: TreeRoot> ast::NameOwner<R> for StaticItem<R> {}
-impl<R: TreeRoot> StaticItem<R> {}
+impl<R: TreeRoot> ast::NameOwner<R> for StaticDef<R> {}
+impl<R: TreeRoot> StaticDef<R> {}
 
-// Struct
+// StructDef
 #[derive(Debug, Clone, Copy)]
-pub struct Struct<R: TreeRoot = Arc<SyntaxRoot>> {
+pub struct StructDef<R: TreeRoot = Arc<SyntaxRoot>> {
     syntax: SyntaxNode<R>,
 }
 
-impl<R: TreeRoot> AstNode<R> for Struct<R> {
+impl<R: TreeRoot> AstNode<R> for StructDef<R> {
     fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
         match syntax.kind() {
-            STRUCT_DEF => Some(Struct { syntax }),
+            STRUCT_DEF => Some(StructDef { syntax }),
             _ => None,
         }
     }
     fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
 }
 
-impl<R: TreeRoot> ast::NameOwner<R> for Struct<R> {}
-impl<R: TreeRoot> Struct<R> {}
+impl<R: TreeRoot> ast::NameOwner<R> for StructDef<R> {}
+impl<R: TreeRoot> StructDef<R> {}
 
-// Trait
+// TraitDef
 #[derive(Debug, Clone, Copy)]
-pub struct Trait<R: TreeRoot = Arc<SyntaxRoot>> {
+pub struct TraitDef<R: TreeRoot = Arc<SyntaxRoot>> {
     syntax: SyntaxNode<R>,
 }
 
-impl<R: TreeRoot> AstNode<R> for Trait<R> {
+impl<R: TreeRoot> AstNode<R> for TraitDef<R> {
     fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
         match syntax.kind() {
-            TRAIT_DEF => Some(Trait { syntax }),
+            TRAIT_DEF => Some(TraitDef { syntax }),
             _ => None,
         }
     }
     fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
 }
 
-impl<R: TreeRoot> ast::NameOwner<R> for Trait<R> {}
-impl<R: TreeRoot> Trait<R> {}
+impl<R: TreeRoot> ast::NameOwner<R> for TraitDef<R> {}
+impl<R: TreeRoot> TraitDef<R> {}
 
-// TypeItem
+// TypeDef
 #[derive(Debug, Clone, Copy)]
-pub struct TypeItem<R: TreeRoot = Arc<SyntaxRoot>> {
+pub struct TypeDef<R: TreeRoot = Arc<SyntaxRoot>> {
     syntax: SyntaxNode<R>,
 }
 
-impl<R: TreeRoot> AstNode<R> for TypeItem<R> {
+impl<R: TreeRoot> AstNode<R> for TypeDef<R> {
     fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
         match syntax.kind() {
-            TYPE_DEF => Some(TypeItem { syntax }),
+            TYPE_DEF => Some(TypeDef { syntax }),
             _ => None,
         }
     }
     fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
 }
 
-impl<R: TreeRoot> ast::NameOwner<R> for TypeItem<R> {}
-impl<R: TreeRoot> TypeItem<R> {}
+impl<R: TreeRoot> ast::NameOwner<R> for TypeDef<R> {}
+impl<R: TreeRoot> TypeDef<R> {}
 
diff --git a/crates/libsyntax2/src/ast/mod.rs b/crates/libsyntax2/src/ast/mod.rs
index 2e1fb2d1c..18a9f5d17 100644
--- a/crates/libsyntax2/src/ast/mod.rs
+++ b/crates/libsyntax2/src/ast/mod.rs
@@ -36,7 +36,7 @@ impl<R: TreeRoot> File<R> {
     }
 }
 
-impl<R: TreeRoot> Function<R> {
+impl<R: TreeRoot> FnDef<R> {
     pub fn has_atom_attr(&self, atom: &str) -> bool {
         self.syntax()
             .children()
diff --git a/crates/libsyntax2/src/grammar.ron b/crates/libsyntax2/src/grammar.ron
index 16300af41..ef56761fd 100644
--- a/crates/libsyntax2/src/grammar.ron
+++ b/crates/libsyntax2/src/grammar.ron
@@ -218,17 +218,17 @@ Grammar(
     ast: {
         "File": (
             collections: [
-                ["functions", "Function"]
+                ["functions", "FnDef"]
             ]
         ),
-        "Function": ( traits: ["NameOwner"] ),
-        "Struct": ( traits: ["NameOwner"] ),
-        "Enum": ( traits: ["NameOwner"] ),
-        "Trait": ( traits: ["NameOwner"] ),
+        "FnDef": ( traits: ["NameOwner"] ),
+        "StructDef": ( traits: ["NameOwner"] ),
+        "EnumDef": ( traits: ["NameOwner"] ),
+        "TraitDef": ( traits: ["NameOwner"] ),
         "Module": ( traits: ["NameOwner"] ),
-        "ConstItem": ( traits: ["NameOwner"] ),
-        "StaticItem": ( traits: ["NameOwner"] ),
-        "TypeItem": ( traits: ["NameOwner"] ),
+        "ConstDef": ( traits: ["NameOwner"] ),
+        "StaticDef": ( traits: ["NameOwner"] ),
+        "TypeDef": ( traits: ["NameOwner"] ),
         "Name": (),
         "NameRef": (),
     },