Less hackish impl structure

6 files changed, 386 insertions, 19 deletions

diff --git a/crates/libeditor/src/symbols.rs b/crates/libeditor/src/symbols.rs
index 43f4164da..8419f08e6 100644
--- a/crates/libeditor/src/symbols.rs
+++ b/crates/libeditor/src/symbols.rs
@@ -6,7 +6,6 @@ use libsyntax2::{
         visit::{visitor, Visitor},
         walk::{walk, WalkEvent, preorder},
     },
-    SyntaxKind::*,
 };
 use TextRange;
 
@@ -104,24 +103,21 @@ fn structure_node(node: SyntaxNodeRef) -> Option<StructureNode> {
         .visit(decl::<ast::ConstDef<_>>)
         .visit(decl::<ast::StaticDef<_>>)
         .visit(|im: ast::ImplItem<_>| {
-            let mut label = String::new();
-            let brace = im.syntax().children()
-                .find(|it| {
-                    let stop = it.kind() == L_CURLY;
-                    if !stop {
-                        label.push_str(&it.text());
-                    }
-                    stop
-                })?;
-            let navigation_range = TextRange::from_to(
-                im.syntax().range().start(),
-                brace.range().start(),
-            );
+            let target_type = im.target_type()?;
+            let target_trait = im.target_trait();
+            let label = match target_trait {
+                None => format!("impl {}", target_type.syntax().text()),
+                Some(t) => format!(
+                    "impl {} for {}",
+                    t.syntax().text(),
+                    target_type.syntax().text(),
+                ),
+            };
 
             let node = StructureNode {
                 parent: None,
                 label,
-                navigation_range,
+                navigation_range: target_type.syntax().range(),
                 node_range: im.syntax().range(),
                 kind: im.syntax().kind(),
             };
diff --git a/crates/libeditor/tests/test.rs b/crates/libeditor/tests/test.rs
index 97fa30e1f..91df74bd6 100644
--- a/crates/libeditor/tests/test.rs
+++ b/crates/libeditor/tests/test.rs
@@ -66,7 +66,7 @@ fn test_foo() {}
 }
 
 #[test]
-fn test_structure() {
+fn test_file_structure() {
     let file = file(r#"
 struct Foo {
     x: i32
@@ -94,8 +94,8 @@ impl fmt::Debug for E {}
            StructureNode { parent: None, label: "T", navigation_range: [81; 82), node_range: [76; 88), kind: TYPE_DEF },
            StructureNode { parent: None, label: "S", navigation_range: [96; 97), node_range: [89; 108), kind: STATIC_DEF },
            StructureNode { parent: None, label: "C", navigation_range: [115; 116), node_range: [109; 127), kind: CONST_DEF },
-           StructureNode { parent: None, label: "impl E ", navigation_range: [129; 136), node_range: [129; 138), kind: IMPL_ITEM },
-           StructureNode { parent: None, label: "impl fmt::Debug for E ", navigation_range: [140; 162), node_range: [140; 164), kind: IMPL_ITEM }]"#,
+           StructureNode { parent: None, label: "impl E", navigation_range: [134; 135), node_range: [129; 138), kind: IMPL_ITEM },
+           StructureNode { parent: None, label: "impl fmt::Debug for E", navigation_range: [160; 161), node_range: [140; 164), kind: IMPL_ITEM }]"#,
         &symbols,
     )
 }
diff --git a/crates/libsyntax2/src/ast/generated.rs b/crates/libsyntax2/src/ast/generated.rs
index 13668b803..3e6c673ab 100644
--- a/crates/libsyntax2/src/ast/generated.rs
+++ b/crates/libsyntax2/src/ast/generated.rs
@@ -5,6 +5,24 @@ use {
     SyntaxKind::*,
 };
 
+// ArrayType
+#[derive(Debug, Clone, Copy)]
+pub struct ArrayType<R: TreeRoot = Arc<SyntaxRoot>> {
+    syntax: SyntaxNode<R>,
+}
+
+impl<R: TreeRoot> AstNode<R> for ArrayType<R> {
+    fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
+        match syntax.kind() {
+            ARRAY_TYPE => Some(ArrayType { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
+}
+
+impl<R: TreeRoot> ArrayType<R> {}
+
 // ConstDef
 #[derive(Debug, Clone, Copy)]
 pub struct ConstDef<R: TreeRoot = Arc<SyntaxRoot>> {
@@ -24,6 +42,24 @@ impl<R: TreeRoot> AstNode<R> for ConstDef<R> {
 impl<R: TreeRoot> ast::NameOwner<R> for ConstDef<R> {}
 impl<R: TreeRoot> ConstDef<R> {}
 
+// DynTraitType
+#[derive(Debug, Clone, Copy)]
+pub struct DynTraitType<R: TreeRoot = Arc<SyntaxRoot>> {
+    syntax: SyntaxNode<R>,
+}
+
+impl<R: TreeRoot> AstNode<R> for DynTraitType<R> {
+    fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
+        match syntax.kind() {
+            DYN_TRAIT_TYPE => Some(DynTraitType { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
+}
+
+impl<R: TreeRoot> DynTraitType<R> {}
+
 // EnumDef
 #[derive(Debug, Clone, Copy)]
 pub struct EnumDef<R: TreeRoot = Arc<SyntaxRoot>> {
@@ -86,6 +122,42 @@ impl<R: TreeRoot> AstNode<R> for FnDef<R> {
 impl<R: TreeRoot> ast::NameOwner<R> for FnDef<R> {}
 impl<R: TreeRoot> FnDef<R> {}
 
+// FnPointerType
+#[derive(Debug, Clone, Copy)]
+pub struct FnPointerType<R: TreeRoot = Arc<SyntaxRoot>> {
+    syntax: SyntaxNode<R>,
+}
+
+impl<R: TreeRoot> AstNode<R> for FnPointerType<R> {
+    fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
+        match syntax.kind() {
+            FN_POINTER_TYPE => Some(FnPointerType { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
+}
+
+impl<R: TreeRoot> FnPointerType<R> {}
+
+// ForType
+#[derive(Debug, Clone, Copy)]
+pub struct ForType<R: TreeRoot = Arc<SyntaxRoot>> {
+    syntax: SyntaxNode<R>,
+}
+
+impl<R: TreeRoot> AstNode<R> for ForType<R> {
+    fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
+        match syntax.kind() {
+            FOR_TYPE => Some(ForType { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
+}
+
+impl<R: TreeRoot> ForType<R> {}
+
 // ImplItem
 #[derive(Debug, Clone, Copy)]
 pub struct ImplItem<R: TreeRoot = Arc<SyntaxRoot>> {
@@ -104,6 +176,24 @@ impl<R: TreeRoot> AstNode<R> for ImplItem<R> {
 
 impl<R: TreeRoot> ImplItem<R> {}
 
+// ImplTraitType
+#[derive(Debug, Clone, Copy)]
+pub struct ImplTraitType<R: TreeRoot = Arc<SyntaxRoot>> {
+    syntax: SyntaxNode<R>,
+}
+
+impl<R: TreeRoot> AstNode<R> for ImplTraitType<R> {
+    fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
+        match syntax.kind() {
+            IMPL_TRAIT_TYPE => Some(ImplTraitType { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
+}
+
+impl<R: TreeRoot> ImplTraitType<R> {}
+
 // Module
 #[derive(Debug, Clone, Copy)]
 pub struct Module<R: TreeRoot = Arc<SyntaxRoot>> {
@@ -159,6 +249,132 @@ impl<R: TreeRoot> AstNode<R> for NameRef<R> {
 
 impl<R: TreeRoot> NameRef<R> {}
 
+// NeverType
+#[derive(Debug, Clone, Copy)]
+pub struct NeverType<R: TreeRoot = Arc<SyntaxRoot>> {
+    syntax: SyntaxNode<R>,
+}
+
+impl<R: TreeRoot> AstNode<R> for NeverType<R> {
+    fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
+        match syntax.kind() {
+            NEVER_TYPE => Some(NeverType { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
+}
+
+impl<R: TreeRoot> NeverType<R> {}
+
+// ParenType
+#[derive(Debug, Clone, Copy)]
+pub struct ParenType<R: TreeRoot = Arc<SyntaxRoot>> {
+    syntax: SyntaxNode<R>,
+}
+
+impl<R: TreeRoot> AstNode<R> for ParenType<R> {
+    fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
+        match syntax.kind() {
+            PAREN_TYPE => Some(ParenType { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
+}
+
+impl<R: TreeRoot> ParenType<R> {}
+
+// PathType
+#[derive(Debug, Clone, Copy)]
+pub struct PathType<R: TreeRoot = Arc<SyntaxRoot>> {
+    syntax: SyntaxNode<R>,
+}
+
+impl<R: TreeRoot> AstNode<R> for PathType<R> {
+    fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
+        match syntax.kind() {
+            PATH_TYPE => Some(PathType { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
+}
+
+impl<R: TreeRoot> PathType<R> {}
+
+// PlaceholderType
+#[derive(Debug, Clone, Copy)]
+pub struct PlaceholderType<R: TreeRoot = Arc<SyntaxRoot>> {
+    syntax: SyntaxNode<R>,
+}
+
+impl<R: TreeRoot> AstNode<R> for PlaceholderType<R> {
+    fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
+        match syntax.kind() {
+            PLACEHOLDER_TYPE => Some(PlaceholderType { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
+}
+
+impl<R: TreeRoot> PlaceholderType<R> {}
+
+// PointerType
+#[derive(Debug, Clone, Copy)]
+pub struct PointerType<R: TreeRoot = Arc<SyntaxRoot>> {
+    syntax: SyntaxNode<R>,
+}
+
+impl<R: TreeRoot> AstNode<R> for PointerType<R> {
+    fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
+        match syntax.kind() {
+            POINTER_TYPE => Some(PointerType { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
+}
+
+impl<R: TreeRoot> PointerType<R> {}
+
+// ReferenceType
+#[derive(Debug, Clone, Copy)]
+pub struct ReferenceType<R: TreeRoot = Arc<SyntaxRoot>> {
+    syntax: SyntaxNode<R>,
+}
+
+impl<R: TreeRoot> AstNode<R> for ReferenceType<R> {
+    fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
+        match syntax.kind() {
+            REFERENCE_TYPE => Some(ReferenceType { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
+}
+
+impl<R: TreeRoot> ReferenceType<R> {}
+
+// SliceType
+#[derive(Debug, Clone, Copy)]
+pub struct SliceType<R: TreeRoot = Arc<SyntaxRoot>> {
+    syntax: SyntaxNode<R>,
+}
+
+impl<R: TreeRoot> AstNode<R> for SliceType<R> {
+    fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
+        match syntax.kind() {
+            SLICE_TYPE => Some(SliceType { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
+}
+
+impl<R: TreeRoot> SliceType<R> {}
+
 // StaticDef
 #[derive(Debug, Clone, Copy)]
 pub struct StaticDef<R: TreeRoot = Arc<SyntaxRoot>> {
@@ -216,6 +432,24 @@ impl<R: TreeRoot> AstNode<R> for TraitDef<R> {
 impl<R: TreeRoot> ast::NameOwner<R> for TraitDef<R> {}
 impl<R: TreeRoot> TraitDef<R> {}
 
+// TupleType
+#[derive(Debug, Clone, Copy)]
+pub struct TupleType<R: TreeRoot = Arc<SyntaxRoot>> {
+    syntax: SyntaxNode<R>,
+}
+
+impl<R: TreeRoot> AstNode<R> for TupleType<R> {
+    fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
+        match syntax.kind() {
+            TUPLE_TYPE => Some(TupleType { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
+}
+
+impl<R: TreeRoot> TupleType<R> {}
+
 // TypeDef
 #[derive(Debug, Clone, Copy)]
 pub struct TypeDef<R: TreeRoot = Arc<SyntaxRoot>> {
@@ -235,3 +469,61 @@ impl<R: TreeRoot> AstNode<R> for TypeDef<R> {
 impl<R: TreeRoot> ast::NameOwner<R> for TypeDef<R> {}
 impl<R: TreeRoot> TypeDef<R> {}
 
+// TypeRef
+#[derive(Debug, Clone, Copy)]
+pub enum TypeRef<R: TreeRoot = Arc<SyntaxRoot>> {
+    ParenType(ParenType<R>),
+    TupleType(TupleType<R>),
+    NeverType(NeverType<R>),
+    PathType(PathType<R>),
+    PointerType(PointerType<R>),
+    ArrayType(ArrayType<R>),
+    SliceType(SliceType<R>),
+    ReferenceType(ReferenceType<R>),
+    PlaceholderType(PlaceholderType<R>),
+    FnPointerType(FnPointerType<R>),
+    ForType(ForType<R>),
+    ImplTraitType(ImplTraitType<R>),
+    DynTraitType(DynTraitType<R>),
+}
+
+impl<R: TreeRoot> AstNode<R> for TypeRef<R> {
+    fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
+        match syntax.kind() {
+            PAREN_TYPE => Some(TypeRef::ParenType(ParenType { syntax })),
+            TUPLE_TYPE => Some(TypeRef::TupleType(TupleType { syntax })),
+            NEVER_TYPE => Some(TypeRef::NeverType(NeverType { syntax })),
+            PATH_TYPE => Some(TypeRef::PathType(PathType { syntax })),
+            POINTER_TYPE => Some(TypeRef::PointerType(PointerType { syntax })),
+            ARRAY_TYPE => Some(TypeRef::ArrayType(ArrayType { syntax })),
+            SLICE_TYPE => Some(TypeRef::SliceType(SliceType { syntax })),
+            REFERENCE_TYPE => Some(TypeRef::ReferenceType(ReferenceType { syntax })),
+            PLACEHOLDER_TYPE => Some(TypeRef::PlaceholderType(PlaceholderType { syntax })),
+            FN_POINTER_TYPE => Some(TypeRef::FnPointerType(FnPointerType { syntax })),
+            FOR_TYPE => Some(TypeRef::ForType(ForType { syntax })),
+            IMPL_TRAIT_TYPE => Some(TypeRef::ImplTraitType(ImplTraitType { syntax })),
+            DYN_TRAIT_TYPE => Some(TypeRef::DynTraitType(DynTraitType { syntax })),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode<R> {
+        match self {
+            TypeRef::ParenType(inner) => inner.syntax(),
+            TypeRef::TupleType(inner) => inner.syntax(),
+            TypeRef::NeverType(inner) => inner.syntax(),
+            TypeRef::PathType(inner) => inner.syntax(),
+            TypeRef::PointerType(inner) => inner.syntax(),
+            TypeRef::ArrayType(inner) => inner.syntax(),
+            TypeRef::SliceType(inner) => inner.syntax(),
+            TypeRef::ReferenceType(inner) => inner.syntax(),
+            TypeRef::PlaceholderType(inner) => inner.syntax(),
+            TypeRef::FnPointerType(inner) => inner.syntax(),
+            TypeRef::ForType(inner) => inner.syntax(),
+            TypeRef::ImplTraitType(inner) => inner.syntax(),
+            TypeRef::DynTraitType(inner) => inner.syntax(),
+        }
+    }
+}
+
+impl<R: TreeRoot> TypeRef<R> {}
+
diff --git a/crates/libsyntax2/src/ast/generated.rs.tera b/crates/libsyntax2/src/ast/generated.rs.tera
index 3d79b5543..f83da0326 100644
--- a/crates/libsyntax2/src/ast/generated.rs.tera
+++ b/crates/libsyntax2/src/ast/generated.rs.tera
@@ -6,6 +6,32 @@ use {
 };
 {% for node, methods in ast %}
 // {{ node }}
+{%- if methods.enum %}
+#[derive(Debug, Clone, Copy)]
+pub enum {{ node }}<R: TreeRoot = Arc<SyntaxRoot>> {
+{%- for kind in methods.enum %}
+    {{ kind }}({{ kind }}<R>),
+{%- endfor %}
+}
+
+impl<R: TreeRoot> AstNode<R> for {{ node }}<R> {
+    fn cast(syntax: SyntaxNode<R>) -> Option<Self> {
+        match syntax.kind() {
+{%- for kind in methods.enum %}
+            {{ kind | SCREAM }} => Some({{ node }}::{{ kind }}({{ kind }} { syntax })),
+{%- endfor %}
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode<R> {
+        match self {
+{%- for kind in methods.enum %}
+            {{ node }}::{{ kind }}(inner) => inner.syntax(),
+{%- endfor %}
+        }
+    }
+}
+{% else %}
 #[derive(Debug, Clone, Copy)]
 pub struct {{ node }}<R: TreeRoot = Arc<SyntaxRoot>> {
     syntax: SyntaxNode<R>,
@@ -20,7 +46,7 @@ impl<R: TreeRoot> AstNode<R> for {{ node }}<R> {
     }
     fn syntax(&self) -> &SyntaxNode<R> { &self.syntax }
 }
-
+{% endif %}
 {% if methods.traits -%}
 {%- for t in methods.traits -%}
 impl<R: TreeRoot> ast::{{ t }}<R> for {{ node }}<R> {}
diff --git a/crates/libsyntax2/src/ast/mod.rs b/crates/libsyntax2/src/ast/mod.rs
index f001d340e..679e292a2 100644
--- a/crates/libsyntax2/src/ast/mod.rs
+++ b/crates/libsyntax2/src/ast/mod.rs
@@ -82,3 +82,26 @@ impl<R: TreeRoot> NameRef<R> {
         ident.leaf_text().unwrap()
     }
 }
+
+impl <R: TreeRoot> ImplItem<R> {
+    pub fn target_type(&self) -> Option<TypeRef<R>> {
+        match self.target() {
+            (Some(t), None) | (_, Some(t)) => Some(t),
+            _ => None,
+        }
+    }
+
+    pub fn target_trait(&self) -> Option<TypeRef<R>> {
+        match self.target() {
+            (Some(t), Some(_)) => Some(t),
+            _ => None,
+        }
+    }
+
+    fn target(&self) -> (Option<TypeRef<R>>, Option<TypeRef<R>>) {
+        let mut types = self.syntax().children().filter_map(TypeRef::cast);
+        let first = types.next();
+        let second = types.next();
+        (first, second)
+    }
+}
diff --git a/crates/libsyntax2/src/grammar.ron b/crates/libsyntax2/src/grammar.ron
index ebd7d3943..3641b65e2 100644
--- a/crates/libsyntax2/src/grammar.ron
+++ b/crates/libsyntax2/src/grammar.ron
@@ -232,5 +232,35 @@ Grammar(
         "ImplItem": (),
         "Name": (),
         "NameRef": (),
+
+        "ParenType": (),
+        "TupleType": (),
+        "NeverType": (),
+        "PathType": (),
+        "PointerType": (),
+        "ArrayType": (),
+        "SliceType": (),
+        "ReferenceType": (),
+        "PlaceholderType": (),
+        "FnPointerType": (),
+        "ForType": (),
+        "ImplTraitType": (),
+        "DynTraitType": (),
+
+        "TypeRef": ( enum: [
+            "ParenType",
+            "TupleType",
+            "NeverType",
+            "PathType",
+            "PointerType",
+            "ArrayType",
+            "SliceType",
+            "ReferenceType",
+            "PlaceholderType",
+            "FnPointerType",
+            "ForType",
+            "ImplTraitType",
+            "DynTraitType",
+        ])
     },
 )