Reorganize completions structure

popzxc · popzxc · commit 19c10672023e · 2020-10-25T10:59:15.000+03:00
diff --git a/crates/completion/src/completions.rs b/crates/completion/src/completions.rs
@@ -0,0 +1,13 @@
+pub(crate) mod attribute;
+pub(crate) mod dot;
+pub(crate) mod record;
+pub(crate) mod pattern;
+pub(crate) mod fn_param;
+pub(crate) mod keyword;
+pub(crate) mod snippet;
+pub(crate) mod qualified_path;
+pub(crate) mod unqualified_path;
+pub(crate) mod postfix;
+pub(crate) mod macro_in_item_position;
+pub(crate) mod trait_impl;
+pub(crate) mod mod_;
diff --git a/crates/completion/src/completions/attribute.rs b/crates/completion/src/completions/attribute.rs
@@ -7,12 +7,12 @@ use rustc_hash::FxHashSet;
 use syntax::{ast, AstNode, SyntaxKind};
 
 use crate::{
-    completion_context::CompletionContext,
-    completion_item::{CompletionItem, CompletionItemKind, CompletionKind, Completions},
+    context::CompletionContext,
     generated_lint_completions::{CLIPPY_LINTS, FEATURES},
+    item::{CompletionItem, CompletionItemKind, CompletionKind, Completions},
 };
 
-pub(super) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
+pub(crate) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
     if ctx.mod_declaration_under_caret.is_some() {
         return None;
     }
@@ -262,9 +262,9 @@ const DEFAULT_DERIVE_COMPLETIONS: &[DeriveCompletion] = &[
     DeriveCompletion { label: "Ord", dependencies: &["PartialOrd", "Eq", "PartialEq"] },
 ];
 
-pub(super) struct LintCompletion {
-    pub(super) label: &'static str,
-    pub(super) description: &'static str,
+pub(crate) struct LintCompletion {
+    pub(crate) label: &'static str,
+    pub(crate) description: &'static str,
 }
 
 #[rustfmt::skip]
diff --git a/crates/completion/src/completions/dot.rs b/crates/completion/src/completions/dot.rs
@@ -4,10 +4,10 @@ use hir::{HasVisibility, Type};
 use rustc_hash::FxHashSet;
 use test_utils::mark;
 
-use crate::{completion_context::CompletionContext, completion_item::Completions};
+use crate::{context::CompletionContext, item::Completions};
 
 /// Complete dot accesses, i.e. fields or methods.
-pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
+pub(crate) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
     let dot_receiver = match &ctx.dot_receiver {
         Some(expr) => expr,
         _ => return,
@@ -141,7 +141,7 @@ mod inner {
         private_field: u32,
         pub pub_field: u32,
         pub(crate) crate_field: u32,
-        pub(super) super_field: u32,
+        pub(crate) super_field: u32,
     }
 }
 fn foo(a: inner::A) { a.<|> }
@@ -159,13 +159,13 @@ struct A {}
 mod m {
     impl super::A {
         fn private_method(&self) {}
-        pub(super) fn the_method(&self) {}
+        pub(crate) fn the_method(&self) {}
     }
 }
 fn foo(a: A) { a.<|> }
 "#,
             expect![[r#"
-                me the_method() pub(super) fn the_method(&self)
+                me the_method() pub(crate) fn the_method(&self)
             "#]],
         );
     }
diff --git a/crates/completion/src/completions/fn_param.rs b/crates/completion/src/completions/fn_param.rs
@@ -12,7 +12,7 @@ use crate::{CompletionContext, CompletionItem, CompletionKind, Completions};
 /// functions in a file have a `spam: &mut Spam` parameter, a completion with
 /// `spam: &mut Spam` insert text/label and `spam` lookup string will be
 /// suggested.
-pub(super) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext) {
+pub(crate) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext) {
     if !ctx.is_param {
         return;
     }
diff --git a/crates/completion/src/completions/keyword.rs b/crates/completion/src/completions/keyword.rs
@@ -5,7 +5,7 @@ use test_utils::mark;
 
 use crate::{CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions};
 
-pub(super) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionContext) {
+pub(crate) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionContext) {
     // complete keyword "crate" in use stmt
     let source_range = ctx.source_range();
 
@@ -39,7 +39,7 @@ pub(super) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionC
     }
 }
 
-pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionContext) {
+pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionContext) {
     if ctx.token.kind() == SyntaxKind::COMMENT {
         mark::hit!(no_keyword_completion_in_comments);
         return;
diff --git a/crates/completion/src/completions/macro_in_item_position.rs b/crates/completion/src/completions/macro_in_item_position.rs
@@ -2,7 +2,7 @@
 
 use crate::{CompletionContext, Completions};
 
-pub(super) fn complete_macro_in_item_position(acc: &mut Completions, ctx: &CompletionContext) {
+pub(crate) fn complete_macro_in_item_position(acc: &mut Completions, ctx: &CompletionContext) {
     // Show only macros in top level.
     if ctx.is_new_item {
         ctx.scope.process_all_names(&mut |name, res| {
diff --git a/crates/completion/src/completions/mod_.rs b/crates/completion/src/completions/mod_.rs
@@ -7,13 +7,10 @@ use rustc_hash::FxHashSet;
 
 use crate::{CompletionItem, CompletionItemKind};
 
-use super::{
-    completion_context::CompletionContext, completion_item::CompletionKind,
-    completion_item::Completions,
-};
+use crate::{context::CompletionContext, item::CompletionKind, item::Completions};
 
 /// Complete mod declaration, i.e. `mod <|> ;`
-pub(super) fn complete_mod(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
+pub(crate) fn complete_mod(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
     let mod_under_caret = match &ctx.mod_declaration_under_caret {
         Some(mod_under_caret) if mod_under_caret.item_list().is_some() => return None,
         Some(mod_under_caret) => mod_under_caret,
diff --git a/crates/completion/src/completions/pattern.rs b/crates/completion/src/completions/pattern.rs
@@ -3,7 +3,7 @@
 use crate::{CompletionContext, Completions};
 
 /// Completes constats and paths in patterns.
-pub(super) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
+pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
     if !ctx.is_pat_binding_or_const {
         return;
     }
diff --git a/crates/completion/src/completions/postfix.rs b/crates/completion/src/completions/postfix.rs
@@ -11,13 +11,13 @@ use text_edit::TextEdit;
 
 use self::format_like::add_format_like_completions;
 use crate::{
-    completion_config::SnippetCap,
-    completion_context::CompletionContext,
-    completion_item::{Builder, CompletionKind, Completions},
+    config::SnippetCap,
+    context::CompletionContext,
+    item::{Builder, CompletionKind, Completions},
     CompletionItem, CompletionItemKind,
 };
 
-pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
+pub(crate) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
     if !ctx.config.enable_postfix_completions {
         return;
     }
diff --git a/crates/completion/src/completions/postfix/format_like.rs b/crates/completion/src/completions/postfix/format_like.rs
@@ -15,8 +15,8 @@
 //   + `loge` -> `log::error!(...)`
 
 use crate::{
-    complete_postfix::postfix_snippet, completion_config::SnippetCap,
-    completion_context::CompletionContext, completion_item::Completions,
+    completions::postfix::postfix_snippet, config::SnippetCap, context::CompletionContext,
+    item::Completions,
 };
 use syntax::ast::{self, AstToken};
 
@@ -33,7 +33,7 @@ static KINDS: &[(&str, &str)] = &[
     ("loge", "log::error!"),
 ];
 
-pub(super) fn add_format_like_completions(
+pub(crate) fn add_format_like_completions(
     acc: &mut Completions,
     ctx: &CompletionContext,
     dot_receiver: &ast::Expr,
diff --git a/crates/completion/src/completions/qualified_path.rs b/crates/completion/src/completions/qualified_path.rs
@@ -7,7 +7,7 @@ use test_utils::mark;
 
 use crate::{CompletionContext, Completions};
 
-pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionContext) {
+pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionContext) {
     let path = match &ctx.path_qual {
         Some(path) => path.clone(),
         None => return,
@@ -369,21 +369,21 @@ struct S;
 
 mod m {
     impl super::S {
-        pub(super) fn public_method() { }
+        pub(crate) fn public_method() { }
         fn private_method() { }
-        pub(super) type PublicType = u32;
+        pub(crate) type PublicType = u32;
         type PrivateType = u32;
-        pub(super) const PUBLIC_CONST: u32 = 1;
+        pub(crate) const PUBLIC_CONST: u32 = 1;
         const PRIVATE_CONST: u32 = 1;
     }
 }
 
 fn foo() { let _ = S::<|> }
 "#,
             expect![[r#"
-                ct PUBLIC_CONST    pub(super) const PUBLIC_CONST: u32 = 1;
-                ta PublicType      pub(super) type PublicType = u32;
-                fn public_method() pub(super) fn public_method()
+                ct PUBLIC_CONST    pub(crate) const PUBLIC_CONST: u32 = 1;
+                ta PublicType      pub(crate) type PublicType = u32;
+                fn public_method() pub(crate) fn public_method()
             "#]],
         );
     }
diff --git a/crates/completion/src/completions/record.rs b/crates/completion/src/completions/record.rs
@@ -1,7 +1,7 @@
 //! Complete fields in record literals and patterns.
 use crate::{CompletionContext, Completions};
 
-pub(super) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
+pub(crate) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
     let missing_fields = match (ctx.record_pat_syntax.as_ref(), ctx.record_lit_syntax.as_ref()) {
         (None, None) => return None,
         (Some(_), Some(_)) => unreachable!("A record cannot be both a literal and a pattern"),
diff --git a/crates/completion/src/completions/snippet.rs b/crates/completion/src/completions/snippet.rs
@@ -1,8 +1,8 @@
 //! This file provides snippet completions, like `pd` => `eprintln!(...)`.
 
 use crate::{
-    completion_config::SnippetCap, completion_item::Builder, CompletionContext, CompletionItem,
-    CompletionItemKind, CompletionKind, Completions,
+    config::SnippetCap, item::Builder, CompletionContext, CompletionItem, CompletionItemKind,
+    CompletionKind, Completions,
 };
 
 fn snippet(ctx: &CompletionContext, cap: SnippetCap, label: &str, snippet: &str) -> Builder {
@@ -11,7 +11,7 @@ fn snippet(ctx: &CompletionContext, cap: SnippetCap, label: &str, snippet: &str)
         .kind(CompletionItemKind::Snippet)
 }
 
-pub(super) fn complete_expr_snippet(acc: &mut Completions, ctx: &CompletionContext) {
+pub(crate) fn complete_expr_snippet(acc: &mut Completions, ctx: &CompletionContext) {
     if !(ctx.is_trivial_path && ctx.function_syntax.is_some()) {
         return;
     }
@@ -24,7 +24,7 @@ pub(super) fn complete_expr_snippet(acc: &mut Completions, ctx: &CompletionConte
     snippet(ctx, cap, "ppd", "eprintln!(\"$0 = {:#?}\", $0);").add_to(acc);
 }
 
-pub(super) fn complete_item_snippet(acc: &mut Completions, ctx: &CompletionContext) {
+pub(crate) fn complete_item_snippet(acc: &mut Completions, ctx: &CompletionContext) {
     if !ctx.is_new_item {
         return;
     }
diff --git a/crates/completion/src/completions/trait_impl.rs b/crates/completion/src/completions/trait_impl.rs
diff --git a/crates/completion/src/completions/unqualified_path.rs b/crates/completion/src/completions/unqualified_path.rs
@@ -6,7 +6,7 @@ use test_utils::mark;
 
 use crate::{CompletionContext, Completions};
 
-pub(super) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionContext) {
+pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionContext) {
     if !(ctx.is_trivial_path || ctx.is_pat_binding_or_const) {
         return;
     }
diff --git a/crates/completion/src/config.rs b/crates/completion/src/config.rs
diff --git a/crates/completion/src/context.rs b/crates/completion/src/context.rs
diff --git a/crates/completion/src/generated_lint_completions.rs b/crates/completion/src/generated_lint_completions.rs
diff --git a/crates/completion/src/item.rs b/crates/completion/src/item.rs
@@ -6,7 +6,7 @@ use hir::{Documentation, Mutability};
 use syntax::TextRange;
 use text_edit::TextEdit;
 
-use crate::completion_config::SnippetCap;
+use crate::config::SnippetCap;
 
 /// `CompletionItem` describes a single completion variant in the editor pop-up.
 /// It is basically a POD with various properties. To construct a
diff --git a/crates/completion/src/lib.rs b/crates/completion/src/lib.rs
@@ -1,39 +1,27 @@
 //! `completions` crate provides utilities for generating completions of user input.
 
-mod completion_config;
-mod completion_item;
-mod completion_context;
+mod config;
+mod item;
+mod context;
 mod presentation;
 mod patterns;
 mod generated_lint_completions;
 #[cfg(test)]
 mod test_utils;
 
-mod complete_attribute;
-mod complete_dot;
-mod complete_record;
-mod complete_pattern;
-mod complete_fn_param;
-mod complete_keyword;
-mod complete_snippet;
-mod complete_qualified_path;
-mod complete_unqualified_path;
-mod complete_postfix;
-mod complete_macro_in_item_position;
-mod complete_trait_impl;
-mod complete_mod;
+mod completions;
 
 use ide_db::base_db::FilePosition;
 use ide_db::RootDatabase;
 
 use crate::{
-    completion_context::CompletionContext,
-    completion_item::{CompletionKind, Completions},
+    context::CompletionContext,
+    item::{CompletionKind, Completions},
 };
 
 pub use crate::{
-    completion_config::CompletionConfig,
-    completion_item::{CompletionItem, CompletionItemKind, CompletionScore, InsertTextFormat},
+    config::CompletionConfig,
+    item::{CompletionItem, CompletionItemKind, CompletionScore, InsertTextFormat},
 };
 
 //FIXME: split the following feature into fine-grained features.
@@ -118,28 +106,28 @@ pub fn completions(
     }
 
     let mut acc = Completions::default();
-    complete_attribute::complete_attribute(&mut acc, &ctx);
-    complete_fn_param::complete_fn_param(&mut acc, &ctx);
-    complete_keyword::complete_expr_keyword(&mut acc, &ctx);
-    complete_keyword::complete_use_tree_keyword(&mut acc, &ctx);
-    complete_snippet::complete_expr_snippet(&mut acc, &ctx);
-    complete_snippet::complete_item_snippet(&mut acc, &ctx);
-    complete_qualified_path::complete_qualified_path(&mut acc, &ctx);
-    complete_unqualified_path::complete_unqualified_path(&mut acc, &ctx);
-    complete_dot::complete_dot(&mut acc, &ctx);
-    complete_record::complete_record(&mut acc, &ctx);
-    complete_pattern::complete_pattern(&mut acc, &ctx);
-    complete_postfix::complete_postfix(&mut acc, &ctx);
-    complete_macro_in_item_position::complete_macro_in_item_position(&mut acc, &ctx);
-    complete_trait_impl::complete_trait_impl(&mut acc, &ctx);
-    complete_mod::complete_mod(&mut acc, &ctx);
+    completions::attribute::complete_attribute(&mut acc, &ctx);
+    completions::fn_param::complete_fn_param(&mut acc, &ctx);
+    completions::keyword::complete_expr_keyword(&mut acc, &ctx);
+    completions::keyword::complete_use_tree_keyword(&mut acc, &ctx);
+    completions::snippet::complete_expr_snippet(&mut acc, &ctx);
+    completions::snippet::complete_item_snippet(&mut acc, &ctx);
+    completions::qualified_path::complete_qualified_path(&mut acc, &ctx);
+    completions::unqualified_path::complete_unqualified_path(&mut acc, &ctx);
+    completions::dot::complete_dot(&mut acc, &ctx);
+    completions::record::complete_record(&mut acc, &ctx);
+    completions::pattern::complete_pattern(&mut acc, &ctx);
+    completions::postfix::complete_postfix(&mut acc, &ctx);
+    completions::macro_in_item_position::complete_macro_in_item_position(&mut acc, &ctx);
+    completions::trait_impl::complete_trait_impl(&mut acc, &ctx);
+    completions::mod_::complete_mod(&mut acc, &ctx);
 
     Some(acc)
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::completion_config::CompletionConfig;
+    use crate::config::CompletionConfig;
     use crate::test_utils;
 
     struct DetailAndDocumentation<'a> {
diff --git a/crates/completion/src/presentation.rs b/crates/completion/src/presentation.rs
diff --git a/crates/completion/src/test_utils.rs b/crates/completion/src/test_utils.rs
diff --git a/xtask/src/codegen/gen_lint_completions.rs b/xtask/src/codegen/gen_lint_completions.rs

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ use crate::{CompletionContext, CompletionItem, CompletionKind, Completions};`
`12`	`12`	/// functions in a file have a `spam: &mut Spam` parameter, a completion with
`13`	`13`	/// `spam: &mut Spam` insert text/label and `spam` lookup string will be
`14`	`14`	`/// suggested.`
`15`		`-pub(super) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext) {`
	`15`	`+pub(crate) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext) {`
`16`	`16`	`if !ctx.is_param {`
`17`	`17`	`return;`
`18`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ use test_utils::mark;`
`5`	`5`
`6`	`6`	`use crate::{CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions};`
`7`	`7`
`8`		`-pub(super) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionContext) {`
	`8`	`+pub(crate) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionContext) {`
`9`	`9`	`// complete keyword "crate" in use stmt`
`10`	`10`	`let source_range = ctx.source_range();`
`11`	`11`
`@@ -39,7 +39,7 @@ pub(super) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionC`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`
`42`		`-pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionContext) {`
	`42`	`+pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionContext) {`
`43`	`43`	`if ctx.token.kind() == SyntaxKind::COMMENT {`
`44`	`44`	`mark::hit!(no_keyword_completion_in_comments);`
`45`	`45`	`return;`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`	`use crate::{CompletionContext, Completions};`
`4`	`4`
`5`	`5`	`/// Completes constats and paths in patterns.`
`6`		`-pub(super) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {`
	`6`	`+pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {`
`7`	`7`	`if !ctx.is_pat_binding_or_const {`
`8`	`8`	`return;`
`9`	`9`	`}`