complete self

crates/libeditor/src/completion.rs

@@ -142,6 +142,12 @@ fn complete_fn(name_ref: ast::NameRef, scopes: &FnScopes, acc: &mut Vec<Completi
                 snippet: None,
             })
     );
+    if scopes.self_param.is_some() {
+        acc.push(CompletionItem {
+            name: "self".to_string(),
+            snippet: None,
+        })
+    }
 }
 
 #[cfg(test)]
@@ -249,6 +255,13 @@ mod tests {
                CompletionItem { name: "foo", snippet: None }]"#)
     }
 
+    #[test]
+    fn test_complete_self() {
+        check_scope_completion(r"
+            impl S { fn foo(&self) { <|> } }
+        ", r#"[CompletionItem { name: "self", snippet: None }]"#)
+    }
+
     #[test]
     fn test_completion_kewords() {
         check_snippet_completion(r"

crates/libeditor/src/scope/fn_scope.rs

@@ -13,6 +13,7 @@ type ScopeId = usize;
 
 #[derive(Debug)]
 pub struct FnScopes {
+    pub self_param: Option<SyntaxNode>,
     scopes: Vec<ScopeData>,
     scope_for: HashMap<SyntaxNode, ScopeId>,
 }
@@ -20,6 +21,9 @@ pub struct FnScopes {
 impl FnScopes {
     pub fn new(fn_def: ast::FnDef) -> FnScopes {
         let mut scopes = FnScopes {
+            self_param: fn_def.param_list()
+                .and_then(|it| it.self_param())
+                .map(|it| it.syntax().owned()),
             scopes: Vec::new(),
             scope_for: HashMap::new()
         };

crates/libsyntax2/src/ast/generated.rs

@@ -1168,6 +1168,9 @@ impl<'a> ParamList<'a> {
     pub fn params(self) -> impl Iterator<Item = Param<'a>> + 'a {
         super::children(self)
     }
+pub fn self_param(self) -> Option<SelfParam<'a>> {
+        super::child_opt(self)
+    }
 }
 
 // ParenExpr
@@ -1579,6 +1582,24 @@ impl<'a> Root<'a> {
     }
 }
 
+// SelfParam
+#[derive(Debug, Clone, Copy)]
+pub struct SelfParam<'a> {
+    syntax: SyntaxNodeRef<'a>,
+}
+
+impl<'a> AstNode<'a> for SelfParam<'a> {
+    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+        match syntax.kind() {
+            SELF_PARAM => Some(SelfParam { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
+}
+
+impl<'a> SelfParam<'a> {}
+
 // SlicePat
 #[derive(Debug, Clone, Copy)]
 pub struct SlicePat<'a> {

crates/libsyntax2/src/grammar.ron

@@ -488,10 +488,12 @@ Grammar(
             ]
         ),
         "ParamList": (
+            options: [ "SelfParam" ],
             collections: [
                 ["params", "Param"]
             ]
         ),
+        "SelfParam": (),
         "Param": (
             options: [ "Pat" ],
         ),