Restrict completions inside visibility modifiers

crates/ide_completion/src/completions/keyword.rs

@@ -39,6 +39,12 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
     let has_block_expr_parent = ctx.has_block_expr_parent();
     let expects_item = ctx.expects_item();
 
+    if let Some(ImmediateLocation::Visibility(vis)) = &ctx.completion_location {
+        if vis.in_token().is_none() {
+            add_keyword("in", "in");
+        }
+        return;
+    }
     if ctx.has_impl_or_trait_prev_sibling() {
         add_keyword("where", "where");
         if ctx.has_impl_prev_sibling() {

crates/ide_completion/src/completions/unqualified_path.rs

@@ -24,6 +24,9 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
         return;
     }
     std::array::IntoIter::new(["self", "super", "crate"]).for_each(|kw| acc.add_keyword(ctx, kw));
+    if let Some(ImmediateLocation::Visibility(_)) = ctx.completion_location {
+        return;
+    }
 
     if ctx.expects_item() || ctx.expects_assoc_item() {
         // only show macros in {Assoc}ItemList

crates/ide_completion/src/patterns.rs

@@ -41,6 +41,7 @@ pub(crate) enum ImmediateLocation {
     Attribute(ast::Attr),
     // Fake file ast node
     ModDeclaration(ast::Module),
+    Visibility(ast::Visibility),
     // Original file ast node
     MethodCall {
         receiver: Option<ast::Expr>,
@@ -246,6 +247,8 @@ pub(crate) fn determine_location(
                     .and_then(|r| find_node_with_range(original_file, r)),
                 has_parens: it.arg_list().map_or(false, |it| it.l_paren_token().is_some())
             },
+            ast::Visibility(it) => it.pub_token()
+                .and_then(|t| (t.text_range().end() < offset).then(|| ImmediateLocation::Visibility(it)))?,
             _ => return None,
         }
     };

crates/ide_completion/src/tests.rs

@@ -9,10 +9,10 @@
 mod item;
 mod pattern;
 mod predicate;
+mod sourcegen;
 mod type_pos;
 mod use_tree;
-
-mod sourcegen;
+mod visibility;
 
 use std::mem;
 

crates/ide_completion/src/tests/visibility.rs

@@ -0,0 +1,24 @@
+//! Completion tests for visibility modifiers.
+use expect_test::{expect, Expect};
+
+use crate::tests::completion_list;
+
+fn check(ra_fixture: &str, expect: Expect) {
+    let actual = completion_list(ra_fixture);
+    expect.assert_eq(&actual)
+}
+
+#[test]
+fn empty_pub() {
+    check(
+        r#"
+pub($0)
+"#,
+        expect![[r#"
+            kw in
+            kw self
+            kw super
+            kw crate
+        "#]],
+    );
+}

crates/parser/src/grammar.rs

@@ -162,7 +162,7 @@ fn opt_visibility(p: &mut Parser) -> bool {
                     // test pub_parens_typepath
                     // struct B(pub (super::A));
                     // struct B(pub (crate::A,));
-                    T![crate] | T![self] | T![super] if p.nth(2) != T![:] => {
+                    T![crate] | T![self] | T![super] | T![ident] if p.nth(2) != T![:] => {
                         p.bump_any();
                         let path_m = p.start();
                         let path_segment_m = p.start();

crates/syntax/src/validation.rs

@@ -211,6 +211,14 @@ fn int_token(name_ref: Option<ast::NameRef>) -> Option<SyntaxToken> {
 }
 
 fn validate_visibility(vis: ast::Visibility, errors: &mut Vec<SyntaxError>) {
+    if vis.in_token().is_none() {
+        if vis.path().and_then(|p| p.as_single_name_ref()).and_then(|n| n.ident_token()).is_some() {
+            errors.push(SyntaxError::new(
+                "incorrect visibility restriction",
+                vis.syntax.text_range(),
+            ));
+        }
+    }
     let parent = match vis.syntax().parent() {
         Some(it) => it,
         None => return,