Complete types

crates/libeditor/src/completion.rs

@@ -21,11 +21,10 @@ pub fn scope_completion(file: &File, offset: TextUnit) -> Option<Vec<CompletionI
     // Insert a fake ident to get a valid parse tree
     let file = {
         let edit = AtomEdit::insert(offset, "intellijRulezz".to_string());
-        // Don't bother with completion if incremental reparse fails
+        file.reparse(&edit)
-        file.incremental_reparse(&edit)?
     };
     let name_ref = find_node_at_offset::<ast::NameRef>(file.syntax(), offset)?;
-    if !is_ident_expr(name_ref) {
+    if !is_single_segment(name_ref) {
         return None;
     }
 
@@ -50,11 +49,11 @@ pub fn scope_completion(file: &File, offset: TextUnit) -> Option<Vec<CompletionI
     Some(res)
 }
 
-fn is_ident_expr(name_ref: ast::NameRef) -> bool {
+fn is_single_segment(name_ref: ast::NameRef) -> bool {
-    match ancestors(name_ref.syntax()).filter_map(ast::Expr::cast).next() {
+    match ancestors(name_ref.syntax()).filter_map(ast::Path::cast).next() {
         None => false,
-        Some(expr) => {
+        Some(path) => {
-            expr.syntax().range() == name_ref.syntax().range()
+            path.syntax().range() == name_ref.syntax().range()
         }
     }
 }
@@ -203,6 +202,15 @@ mod tests {
                    CompletionItem { name: "quux", snippet: None }]"#);
     }
 
+    #[test]
+    fn test_complete_type() {
+        check_scope_completion(r"
+            struct Foo;
+            fn x() -> <|>
+        ", r#"[CompletionItem { name: "Foo", snippet: None },
+               CompletionItem { name: "x", snippet: None }]"#)
+    }
+
     #[test]
     fn test_completion_kewords() {
         check_snippet_completion(r"

crates/libsyntax2/src/ast/generated.rs

@@ -1278,6 +1278,24 @@ impl<'a> AstNode<'a> for Pat<'a> {
 
 impl<'a> Pat<'a> {}
 
+// Path
+#[derive(Debug, Clone, Copy)]
+pub struct Path<'a> {
+    syntax: SyntaxNodeRef<'a>,
+}
+
+impl<'a> AstNode<'a> for Path<'a> {
+    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+        match syntax.kind() {
+            PATH => Some(Path { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
+}
+
+impl<'a> Path<'a> {}
+
 // PathExpr
 #[derive(Debug, Clone, Copy)]
 pub struct PathExpr<'a> {

crates/libsyntax2/src/grammar.ron

@@ -513,6 +513,7 @@ Grammar(
             collections: [
                 ["args", "Expr"]
             ]
-        )
+        ),
+        "Path": (),
     },
 )