aboutsummaryrefslogtreecommitdiff
path: root/crates/completion
diff options
context:
space:
mode:
Diffstat (limited to 'crates/completion')
-rw-r--r--crates/completion/Cargo.toml32
-rw-r--r--crates/completion/src/complete_attribute.rs534
-rw-r--r--crates/completion/src/complete_dot.rs431
-rw-r--r--crates/completion/src/complete_fn_param.rs135
-rw-r--r--crates/completion/src/complete_keyword.rs566
-rw-r--r--crates/completion/src/complete_macro_in_item_position.rs41
-rw-r--r--crates/completion/src/complete_mod.rs324
-rw-r--r--crates/completion/src/complete_pattern.rs88
-rw-r--r--crates/completion/src/complete_postfix.rs452
-rw-r--r--crates/completion/src/complete_postfix/format_like.rs279
-rw-r--r--crates/completion/src/complete_qualified_path.rs755
-rw-r--r--crates/completion/src/complete_record.rs226
-rw-r--r--crates/completion/src/complete_snippet.rs114
-rw-r--r--crates/completion/src/complete_trait_impl.rs736
-rw-r--r--crates/completion/src/complete_unqualified_path.rs679
-rw-r--r--crates/completion/src/completion_config.rs35
-rw-r--r--crates/completion/src/completion_context.rs533
-rw-r--r--crates/completion/src/completion_item.rs403
-rw-r--r--crates/completion/src/generated_lint_completions.rs5
-rw-r--r--crates/completion/src/lib.rs264
-rw-r--r--crates/completion/src/patterns.rs249
-rw-r--r--crates/completion/src/presentation.rs1410
-rw-r--r--crates/completion/src/test_utils.rs130
23 files changed, 8421 insertions, 0 deletions
diff --git a/crates/completion/Cargo.toml b/crates/completion/Cargo.toml
new file mode 100644
index 000000000..25192456a
--- /dev/null
+++ b/crates/completion/Cargo.toml
@@ -0,0 +1,32 @@
1[package]
2name = "completion"
3version = "0.0.0"
4description = "TBD"
5license = "MIT OR Apache-2.0"
6authors = ["rust-analyzer developers"]
7edition = "2018"
8
9[lib]
10doctest = false
11
12[dependencies]
13itertools = "0.9.0"
14log = "0.4.8"
15rustc-hash = "1.1.0"
16
17stdx = { path = "../stdx", version = "0.0.0" }
18syntax = { path = "../syntax", version = "0.0.0" }
19text_edit = { path = "../text_edit", version = "0.0.0" }
20base_db = { path = "../base_db", version = "0.0.0" }
21ide_db = { path = "../ide_db", version = "0.0.0" }
22profile = { path = "../profile", version = "0.0.0" }
23test_utils = { path = "../test_utils", version = "0.0.0" }
24assists = { path = "../assists", version = "0.0.0" }
25call_info = { path = "../call_info", version = "0.0.0" }
26
27# completions crate should depend only on the top-level `hir` package. if you need
28# something from some `hir_xxx` subpackage, reexport the API via `hir`.
29hir = { path = "../hir", version = "0.0.0" }
30
31[dev-dependencies]
32expect-test = "1.0"
diff --git a/crates/completion/src/complete_attribute.rs b/crates/completion/src/complete_attribute.rs
new file mode 100644
index 000000000..f97ab7dd0
--- /dev/null
+++ b/crates/completion/src/complete_attribute.rs
@@ -0,0 +1,534 @@
1//! Completion for attributes
2//!
3//! This module uses a bit of static metadata to provide completions
4//! for built-in attributes.
5
6use rustc_hash::FxHashSet;
7use syntax::{ast, AstNode, SyntaxKind};
8
9use crate::{
10 completion_context::CompletionContext,
11 completion_item::{CompletionItem, CompletionItemKind, CompletionKind, Completions},
12 generated_lint_completions::{CLIPPY_LINTS, FEATURES},
13};
14
15pub(super) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
16 if ctx.mod_declaration_under_caret.is_some() {
17 return None;
18 }
19
20 let attribute = ctx.attribute_under_caret.as_ref()?;
21 match (attribute.path(), attribute.token_tree()) {
22 (Some(path), Some(token_tree)) if path.to_string() == "derive" => {
23 complete_derive(acc, ctx, token_tree)
24 }
25 (Some(path), Some(token_tree)) if path.to_string() == "feature" => {
26 complete_lint(acc, ctx, token_tree, FEATURES);
27 }
28 (Some(path), Some(token_tree))
29 if ["allow", "warn", "deny", "forbid"]
30 .iter()
31 .any(|lint_level| lint_level == &path.to_string()) =>
32 {
33 complete_lint(acc, ctx, token_tree.clone(), DEFAULT_LINT_COMPLETIONS);
34 complete_lint(acc, ctx, token_tree, CLIPPY_LINTS);
35 }
36 (_, Some(_token_tree)) => {}
37 _ => complete_attribute_start(acc, ctx, attribute),
38 }
39 Some(())
40}
41
42fn complete_attribute_start(acc: &mut Completions, ctx: &CompletionContext, attribute: &ast::Attr) {
43 for attr_completion in ATTRIBUTES {
44 let mut item = CompletionItem::new(
45 CompletionKind::Attribute,
46 ctx.source_range(),
47 attr_completion.label,
48 )
49 .kind(CompletionItemKind::Attribute);
50
51 if let Some(lookup) = attr_completion.lookup {
52 item = item.lookup_by(lookup);
53 }
54
55 match (attr_completion.snippet, ctx.config.snippet_cap) {
56 (Some(snippet), Some(cap)) => {
57 item = item.insert_snippet(cap, snippet);
58 }
59 _ => {}
60 }
61
62 if attribute.kind() == ast::AttrKind::Inner || !attr_completion.prefer_inner {
63 acc.add(item);
64 }
65 }
66}
67
68struct AttrCompletion {
69 label: &'static str,
70 lookup: Option<&'static str>,
71 snippet: Option<&'static str>,
72 prefer_inner: bool,
73}
74
75impl AttrCompletion {
76 const fn prefer_inner(self) -> AttrCompletion {
77 AttrCompletion { prefer_inner: true, ..self }
78 }
79}
80
81const fn attr(
82 label: &'static str,
83 lookup: Option<&'static str>,
84 snippet: Option<&'static str>,
85) -> AttrCompletion {
86 AttrCompletion { label, lookup, snippet, prefer_inner: false }
87}
88
89const ATTRIBUTES: &[AttrCompletion] = &[
90 attr("allow(…)", Some("allow"), Some("allow(${0:lint})")),
91 attr("cfg_attr(…)", Some("cfg_attr"), Some("cfg_attr(${1:predicate}, ${0:attr})")),
92 attr("cfg(…)", Some("cfg"), Some("cfg(${0:predicate})")),
93 attr("deny(…)", Some("deny"), Some("deny(${0:lint})")),
94 attr(r#"deprecated = "…""#, Some("deprecated"), Some(r#"deprecated = "${0:reason}""#)),
95 attr("derive(…)", Some("derive"), Some(r#"derive(${0:Debug})"#)),
96 attr(r#"doc = "…""#, Some("doc"), Some(r#"doc = "${0:docs}""#)),
97 attr("feature(…)", Some("feature"), Some("feature(${0:flag})")).prefer_inner(),
98 attr("forbid(…)", Some("forbid"), Some("forbid(${0:lint})")),
99 // FIXME: resolve through macro resolution?
100 attr("global_allocator", None, None).prefer_inner(),
101 attr(r#"ignore = "…""#, Some("ignore"), Some(r#"ignore = "${0:reason}""#)),
102 attr("inline(…)", Some("inline"), Some("inline(${0:lint})")),
103 attr(r#"link_name = "…""#, Some("link_name"), Some(r#"link_name = "${0:symbol_name}""#)),
104 attr("link", None, None),
105 attr("macro_export", None, None),
106 attr("macro_use", None, None),
107 attr(r#"must_use = "…""#, Some("must_use"), Some(r#"must_use = "${0:reason}""#)),
108 attr("no_mangle", None, None),
109 attr("no_std", None, None).prefer_inner(),
110 attr("non_exhaustive", None, None),
111 attr("panic_handler", None, None).prefer_inner(),
112 attr("path = \"…\"", Some("path"), Some("path =\"${0:path}\"")),
113 attr("proc_macro", None, None),
114 attr("proc_macro_attribute", None, None),
115 attr("proc_macro_derive(…)", Some("proc_macro_derive"), Some("proc_macro_derive(${0:Trait})")),
116 attr("recursion_limit = …", Some("recursion_limit"), Some("recursion_limit = ${0:128}"))
117 .prefer_inner(),
118 attr("repr(…)", Some("repr"), Some("repr(${0:C})")),
119 attr(
120 "should_panic(…)",
121 Some("should_panic"),
122 Some(r#"should_panic(expected = "${0:reason}")"#),
123 ),
124 attr(
125 r#"target_feature = "…""#,
126 Some("target_feature"),
127 Some("target_feature = \"${0:feature}\""),
128 ),
129 attr("test", None, None),
130 attr("used", None, None),
131 attr("warn(…)", Some("warn"), Some("warn(${0:lint})")),
132 attr(
133 r#"windows_subsystem = "…""#,
134 Some("windows_subsystem"),
135 Some(r#"windows_subsystem = "${0:subsystem}""#),
136 )
137 .prefer_inner(),
138];
139
140fn complete_derive(acc: &mut Completions, ctx: &CompletionContext, derive_input: ast::TokenTree) {
141 if let Ok(existing_derives) = parse_comma_sep_input(derive_input) {
142 for derive_completion in DEFAULT_DERIVE_COMPLETIONS
143 .into_iter()
144 .filter(|completion| !existing_derives.contains(completion.label))
145 {
146 let mut label = derive_completion.label.to_owned();
147 for dependency in derive_completion
148 .dependencies
149 .into_iter()
150 .filter(|&&dependency| !existing_derives.contains(dependency))
151 {
152 label.push_str(", ");
153 label.push_str(dependency);
154 }
155 acc.add(
156 CompletionItem::new(CompletionKind::Attribute, ctx.source_range(), label)
157 .kind(CompletionItemKind::Attribute),
158 );
159 }
160
161 for custom_derive_name in get_derive_names_in_scope(ctx).difference(&existing_derives) {
162 acc.add(
163 CompletionItem::new(
164 CompletionKind::Attribute,
165 ctx.source_range(),
166 custom_derive_name,
167 )
168 .kind(CompletionItemKind::Attribute),
169 );
170 }
171 }
172}
173
174fn complete_lint(
175 acc: &mut Completions,
176 ctx: &CompletionContext,
177 derive_input: ast::TokenTree,
178 lints_completions: &[LintCompletion],
179) {
180 if let Ok(existing_lints) = parse_comma_sep_input(derive_input) {
181 for lint_completion in lints_completions
182 .into_iter()
183 .filter(|completion| !existing_lints.contains(completion.label))
184 {
185 acc.add(
186 CompletionItem::new(
187 CompletionKind::Attribute,
188 ctx.source_range(),
189 lint_completion.label,
190 )
191 .kind(CompletionItemKind::Attribute)
192 .detail(lint_completion.description),
193 );
194 }
195 }
196}
197
198fn parse_comma_sep_input(derive_input: ast::TokenTree) -> Result<FxHashSet<String>, ()> {
199 match (derive_input.left_delimiter_token(), derive_input.right_delimiter_token()) {
200 (Some(left_paren), Some(right_paren))
201 if left_paren.kind() == SyntaxKind::L_PAREN
202 && right_paren.kind() == SyntaxKind::R_PAREN =>
203 {
204 let mut input_derives = FxHashSet::default();
205 let mut current_derive = String::new();
206 for token in derive_input
207 .syntax()
208 .children_with_tokens()
209 .filter_map(|token| token.into_token())
210 .skip_while(|token| token != &left_paren)
211 .skip(1)
212 .take_while(|token| token != &right_paren)
213 {
214 if SyntaxKind::COMMA == token.kind() {
215 if !current_derive.is_empty() {
216 input_derives.insert(current_derive);
217 current_derive = String::new();
218 }
219 } else {
220 current_derive.push_str(token.to_string().trim());
221 }
222 }
223
224 if !current_derive.is_empty() {
225 input_derives.insert(current_derive);
226 }
227 Ok(input_derives)
228 }
229 _ => Err(()),
230 }
231}
232
233fn get_derive_names_in_scope(ctx: &CompletionContext) -> FxHashSet<String> {
234 let mut result = FxHashSet::default();
235 ctx.scope.process_all_names(&mut |name, scope_def| {
236 if let hir::ScopeDef::MacroDef(mac) = scope_def {
237 if mac.is_derive_macro() {
238 result.insert(name.to_string());
239 }
240 }
241 });
242 result
243}
244
245struct DeriveCompletion {
246 label: &'static str,
247 dependencies: &'static [&'static str],
248}
249
250/// Standard Rust derives and the information about their dependencies
251/// (the dependencies are needed so that the main derive don't break the compilation when added)
252#[rustfmt::skip]
253const DEFAULT_DERIVE_COMPLETIONS: &[DeriveCompletion] = &[
254 DeriveCompletion { label: "Clone", dependencies: &[] },
255 DeriveCompletion { label: "Copy", dependencies: &["Clone"] },
256 DeriveCompletion { label: "Debug", dependencies: &[] },
257 DeriveCompletion { label: "Default", dependencies: &[] },
258 DeriveCompletion { label: "Hash", dependencies: &[] },
259 DeriveCompletion { label: "PartialEq", dependencies: &[] },
260 DeriveCompletion { label: "Eq", dependencies: &["PartialEq"] },
261 DeriveCompletion { label: "PartialOrd", dependencies: &["PartialEq"] },
262 DeriveCompletion { label: "Ord", dependencies: &["PartialOrd", "Eq", "PartialEq"] },
263];
264
265pub(super) struct LintCompletion {
266 pub(super) label: &'static str,
267 pub(super) description: &'static str,
268}
269
270#[rustfmt::skip]
271const DEFAULT_LINT_COMPLETIONS: &[LintCompletion] = &[
272 LintCompletion { label: "absolute_paths_not_starting_with_crate", description: r#"fully qualified paths that start with a module name instead of `crate`, `self`, or an extern crate name"# },
273 LintCompletion { label: "anonymous_parameters", description: r#"detects anonymous parameters"# },
274 LintCompletion { label: "box_pointers", description: r#"use of owned (Box type) heap memory"# },
275 LintCompletion { label: "deprecated_in_future", description: r#"detects use of items that will be deprecated in a future version"# },
276 LintCompletion { label: "elided_lifetimes_in_paths", description: r#"hidden lifetime parameters in types are deprecated"# },
277 LintCompletion { label: "explicit_outlives_requirements", description: r#"outlives requirements can be inferred"# },
278 LintCompletion { label: "indirect_structural_match", description: r#"pattern with const indirectly referencing non-structural-match type"# },
279 LintCompletion { label: "keyword_idents", description: r#"detects edition keywords being used as an identifier"# },
280 LintCompletion { label: "macro_use_extern_crate", description: r#"the `#[macro_use]` attribute is now deprecated in favor of using macros via the module system"# },
281 LintCompletion { label: "meta_variable_misuse", description: r#"possible meta-variable misuse at macro definition"# },
282 LintCompletion { label: "missing_copy_implementations", description: r#"detects potentially-forgotten implementations of `Copy`"# },
283 LintCompletion { label: "missing_crate_level_docs", description: r#"detects crates with no crate-level documentation"# },
284 LintCompletion { label: "missing_debug_implementations", description: r#"detects missing implementations of Debug"# },
285 LintCompletion { label: "missing_docs", description: r#"detects missing documentation for public members"# },
286 LintCompletion { label: "missing_doc_code_examples", description: r#"detects publicly-exported items without code samples in their documentation"# },
287 LintCompletion { label: "non_ascii_idents", description: r#"detects non-ASCII identifiers"# },
288 LintCompletion { label: "private_doc_tests", description: r#"detects code samples in docs of private items not documented by rustdoc"# },
289 LintCompletion { label: "single_use_lifetimes", description: r#"detects lifetime parameters that are only used once"# },
290 LintCompletion { label: "trivial_casts", description: r#"detects trivial casts which could be removed"# },
291 LintCompletion { label: "trivial_numeric_casts", description: r#"detects trivial casts of numeric types which could be removed"# },
292 LintCompletion { label: "unaligned_references", description: r#"detects unaligned references to fields of packed structs"# },
293 LintCompletion { label: "unreachable_pub", description: r#"`pub` items not reachable from crate root"# },
294 LintCompletion { label: "unsafe_code", description: r#"usage of `unsafe` code"# },
295 LintCompletion { label: "unsafe_op_in_unsafe_fn", description: r#"unsafe operations in unsafe functions without an explicit unsafe block are deprecated"# },
296 LintCompletion { label: "unstable_features", description: r#"enabling unstable features (deprecated. do not use)"# },
297 LintCompletion { label: "unused_crate_dependencies", description: r#"crate dependencies that are never used"# },
298 LintCompletion { label: "unused_extern_crates", description: r#"extern crates that are never used"# },
299 LintCompletion { label: "unused_import_braces", description: r#"unnecessary braces around an imported item"# },
300 LintCompletion { label: "unused_lifetimes", description: r#"detects lifetime parameters that are never used"# },
301 LintCompletion { label: "unused_qualifications", description: r#"detects unnecessarily qualified names"# },
302 LintCompletion { label: "unused_results", description: r#"unused result of an expression in a statement"# },
303 LintCompletion { label: "variant_size_differences", description: r#"detects enums with widely varying variant sizes"# },
304 LintCompletion { label: "array_into_iter", description: r#"detects calling `into_iter` on arrays"# },
305 LintCompletion { label: "asm_sub_register", description: r#"using only a subset of a register for inline asm inputs"# },
306 LintCompletion { label: "bare_trait_objects", description: r#"suggest using `dyn Trait` for trait objects"# },
307 LintCompletion { label: "bindings_with_variant_name", description: r#"detects pattern bindings with the same name as one of the matched variants"# },
308 LintCompletion { label: "cenum_impl_drop_cast", description: r#"a C-like enum implementing Drop is cast"# },
309 LintCompletion { label: "clashing_extern_declarations", description: r#"detects when an extern fn has been declared with the same name but different types"# },
310 LintCompletion { label: "coherence_leak_check", description: r#"distinct impls distinguished only by the leak-check code"# },
311 LintCompletion { label: "confusable_idents", description: r#"detects visually confusable pairs between identifiers"# },
312 LintCompletion { label: "dead_code", description: r#"detect unused, unexported items"# },
313 LintCompletion { label: "deprecated", description: r#"detects use of deprecated items"# },
314 LintCompletion { label: "ellipsis_inclusive_range_patterns", description: r#"`...` range patterns are deprecated"# },
315 LintCompletion { label: "exported_private_dependencies", description: r#"public interface leaks type from a private dependency"# },
316 LintCompletion { label: "illegal_floating_point_literal_pattern", description: r#"floating-point literals cannot be used in patterns"# },
317 LintCompletion { label: "improper_ctypes", description: r#"proper use of libc types in foreign modules"# },
318 LintCompletion { label: "improper_ctypes_definitions", description: r#"proper use of libc types in foreign item definitions"# },
319 LintCompletion { label: "incomplete_features", description: r#"incomplete features that may function improperly in some or all cases"# },
320 LintCompletion { label: "inline_no_sanitize", description: r#"detects incompatible use of `#[inline(always)]` and `#[no_sanitize(...)]`"# },
321 LintCompletion { label: "intra_doc_link_resolution_failure", description: r#"failures in resolving intra-doc link targets"# },
322 LintCompletion { label: "invalid_codeblock_attributes", description: r#"codeblock attribute looks a lot like a known one"# },
323 LintCompletion { label: "invalid_value", description: r#"an invalid value is being created (such as a NULL reference)"# },
324 LintCompletion { label: "irrefutable_let_patterns", description: r#"detects irrefutable patterns in if-let and while-let statements"# },
325 LintCompletion { label: "late_bound_lifetime_arguments", description: r#"detects generic lifetime arguments in path segments with late bound lifetime parameters"# },
326 LintCompletion { label: "mixed_script_confusables", description: r#"detects Unicode scripts whose mixed script confusables codepoints are solely used"# },
327 LintCompletion { label: "mutable_borrow_reservation_conflict", description: r#"reservation of a two-phased borrow conflicts with other shared borrows"# },
328 LintCompletion { label: "non_camel_case_types", description: r#"types, variants, traits and type parameters should have camel case names"# },
329 LintCompletion { label: "non_shorthand_field_patterns", description: r#"using `Struct { x: x }` instead of `Struct { x }` in a pattern"# },
330 LintCompletion { label: "non_snake_case", description: r#"variables, methods, functions, lifetime parameters and modules should have snake case names"# },
331 LintCompletion { label: "non_upper_case_globals", description: r#"static constants should have uppercase identifiers"# },
332 LintCompletion { label: "no_mangle_generic_items", description: r#"generic items must be mangled"# },
333 LintCompletion { label: "overlapping_patterns", description: r#"detects overlapping patterns"# },
334 LintCompletion { label: "path_statements", description: r#"path statements with no effect"# },
335 LintCompletion { label: "private_in_public", description: r#"detect private items in public interfaces not caught by the old implementation"# },
336 LintCompletion { label: "proc_macro_derive_resolution_fallback", description: r#"detects proc macro derives using inaccessible names from parent modules"# },
337 LintCompletion { label: "redundant_semicolons", description: r#"detects unnecessary trailing semicolons"# },
338 LintCompletion { label: "renamed_and_removed_lints", description: r#"lints that have been renamed or removed"# },
339 LintCompletion { label: "safe_packed_borrows", description: r#"safe borrows of fields of packed structs were erroneously allowed"# },
340 LintCompletion { label: "stable_features", description: r#"stable features found in `#[feature]` directive"# },
341 LintCompletion { label: "trivial_bounds", description: r#"these bounds don't depend on an type parameters"# },
342 LintCompletion { label: "type_alias_bounds", description: r#"bounds in type aliases are not enforced"# },
343 LintCompletion { label: "tyvar_behind_raw_pointer", description: r#"raw pointer to an inference variable"# },
344 LintCompletion { label: "uncommon_codepoints", description: r#"detects uncommon Unicode codepoints in identifiers"# },
345 LintCompletion { label: "unconditional_recursion", description: r#"functions that cannot return without calling themselves"# },
346 LintCompletion { label: "unknown_lints", description: r#"unrecognized lint attribute"# },
347 LintCompletion { label: "unnameable_test_items", description: r#"detects an item that cannot be named being marked as `#[test_case]`"# },
348 LintCompletion { label: "unreachable_code", description: r#"detects unreachable code paths"# },
349 LintCompletion { label: "unreachable_patterns", description: r#"detects unreachable patterns"# },
350 LintCompletion { label: "unstable_name_collisions", description: r#"detects name collision with an existing but unstable method"# },
351 LintCompletion { label: "unused_allocation", description: r#"detects unnecessary allocations that can be eliminated"# },
352 LintCompletion { label: "unused_assignments", description: r#"detect assignments that will never be read"# },
353 LintCompletion { label: "unused_attributes", description: r#"detects attributes that were not used by the compiler"# },
354 LintCompletion { label: "unused_braces", description: r#"unnecessary braces around an expression"# },
355 LintCompletion { label: "unused_comparisons", description: r#"comparisons made useless by limits of the types involved"# },
356 LintCompletion { label: "unused_doc_comments", description: r#"detects doc comments that aren't used by rustdoc"# },
357 LintCompletion { label: "unused_features", description: r#"unused features found in crate-level `#[feature]` directives"# },
358 LintCompletion { label: "unused_imports", description: r#"imports that are never used"# },
359 LintCompletion { label: "unused_labels", description: r#"detects labels that are never used"# },
360 LintCompletion { label: "unused_macros", description: r#"detects macros that were not used"# },
361 LintCompletion { label: "unused_must_use", description: r#"unused result of a type flagged as `#[must_use]`"# },
362 LintCompletion { label: "unused_mut", description: r#"detect mut variables which don't need to be mutable"# },
363 LintCompletion { label: "unused_parens", description: r#"`if`, `match`, `while` and `return` do not need parentheses"# },
364 LintCompletion { label: "unused_unsafe", description: r#"unnecessary use of an `unsafe` block"# },
365 LintCompletion { label: "unused_variables", description: r#"detect variables which are not used in any way"# },
366 LintCompletion { label: "warnings", description: r#"mass-change the level for lints which produce warnings"# },
367 LintCompletion { label: "where_clauses_object_safety", description: r#"checks the object safety of where clauses"# },
368 LintCompletion { label: "while_true", description: r#"suggest using `loop { }` instead of `while true { }`"# },
369 LintCompletion { label: "ambiguous_associated_items", description: r#"ambiguous associated items"# },
370 LintCompletion { label: "arithmetic_overflow", description: r#"arithmetic operation overflows"# },
371 LintCompletion { label: "conflicting_repr_hints", description: r#"conflicts between `#[repr(..)]` hints that were previously accepted and used in practice"# },
372 LintCompletion { label: "const_err", description: r#"constant evaluation detected erroneous expression"# },
373 LintCompletion { label: "ill_formed_attribute_input", description: r#"ill-formed attribute inputs that were previously accepted and used in practice"# },
374 LintCompletion { label: "incomplete_include", description: r#"trailing content in included file"# },
375 LintCompletion { label: "invalid_type_param_default", description: r#"type parameter default erroneously allowed in invalid location"# },
376 LintCompletion { label: "macro_expanded_macro_exports_accessed_by_absolute_paths", description: r#"macro-expanded `macro_export` macros from the current crate cannot be referred to by absolute paths"# },
377 LintCompletion { label: "missing_fragment_specifier", description: r#"detects missing fragment specifiers in unused `macro_rules!` patterns"# },
378 LintCompletion { label: "mutable_transmutes", description: r#"mutating transmuted &mut T from &T may cause undefined behavior"# },
379 LintCompletion { label: "no_mangle_const_items", description: r#"const items will not have their symbols exported"# },
380 LintCompletion { label: "order_dependent_trait_objects", description: r#"trait-object types were treated as different depending on marker-trait order"# },
381 LintCompletion { label: "overflowing_literals", description: r#"literal out of range for its type"# },
382 LintCompletion { label: "patterns_in_fns_without_body", description: r#"patterns in functions without body were erroneously allowed"# },
383 LintCompletion { label: "pub_use_of_private_extern_crate", description: r#"detect public re-exports of private extern crates"# },
384 LintCompletion { label: "soft_unstable", description: r#"a feature gate that doesn't break dependent crates"# },
385 LintCompletion { label: "unconditional_panic", description: r#"operation will cause a panic at runtime"# },
386 LintCompletion { label: "unknown_crate_types", description: r#"unknown crate type found in `#[crate_type]` directive"# },
387];
388
389#[cfg(test)]
390mod tests {
391 use expect_test::{expect, Expect};
392
393 use crate::{test_utils::completion_list, CompletionKind};
394
395 fn check(ra_fixture: &str, expect: Expect) {
396 let actual = completion_list(ra_fixture, CompletionKind::Attribute);
397 expect.assert_eq(&actual);
398 }
399
400 #[test]
401 fn empty_derive_completion() {
402 check(
403 r#"
404#[derive(<|>)]
405struct Test {}
406 "#,
407 expect![[r#"
408 at Clone
409 at Copy, Clone
410 at Debug
411 at Default
412 at Eq, PartialEq
413 at Hash
414 at Ord, PartialOrd, Eq, PartialEq
415 at PartialEq
416 at PartialOrd, PartialEq
417 "#]],
418 );
419 }
420
421 #[test]
422 fn no_completion_for_incorrect_derive() {
423 check(
424 r#"
425#[derive{<|>)]
426struct Test {}
427"#,
428 expect![[r#""#]],
429 )
430 }
431
432 #[test]
433 fn derive_with_input_completion() {
434 check(
435 r#"
436#[derive(serde::Serialize, PartialEq, <|>)]
437struct Test {}
438"#,
439 expect![[r#"
440 at Clone
441 at Copy, Clone
442 at Debug
443 at Default
444 at Eq
445 at Hash
446 at Ord, PartialOrd, Eq
447 at PartialOrd
448 "#]],
449 )
450 }
451
452 #[test]
453 fn test_attribute_completion() {
454 check(
455 r#"#[<|>]"#,
456 expect![[r#"
457 at allow(…)
458 at cfg(…)
459 at cfg_attr(…)
460 at deny(…)
461 at deprecated = "…"
462 at derive(…)
463 at doc = "…"
464 at forbid(…)
465 at ignore = "…"
466 at inline(…)
467 at link
468 at link_name = "…"
469 at macro_export
470 at macro_use
471 at must_use = "…"
472 at no_mangle
473 at non_exhaustive
474 at path = "…"
475 at proc_macro
476 at proc_macro_attribute
477 at proc_macro_derive(…)
478 at repr(…)
479 at should_panic(…)
480 at target_feature = "…"
481 at test
482 at used
483 at warn(…)
484 "#]],
485 )
486 }
487
488 #[test]
489 fn test_attribute_completion_inside_nested_attr() {
490 check(r#"#[cfg(<|>)]"#, expect![[]])
491 }
492
493 #[test]
494 fn test_inner_attribute_completion() {
495 check(
496 r"#![<|>]",
497 expect![[r#"
498 at allow(…)
499 at cfg(…)
500 at cfg_attr(…)
501 at deny(…)
502 at deprecated = "…"
503 at derive(…)
504 at doc = "…"
505 at feature(…)
506 at forbid(…)
507 at global_allocator
508 at ignore = "…"
509 at inline(…)
510 at link
511 at link_name = "…"
512 at macro_export
513 at macro_use
514 at must_use = "…"
515 at no_mangle
516 at no_std
517 at non_exhaustive
518 at panic_handler
519 at path = "…"
520 at proc_macro
521 at proc_macro_attribute
522 at proc_macro_derive(…)
523 at recursion_limit = …
524 at repr(…)
525 at should_panic(…)
526 at target_feature = "…"
527 at test
528 at used
529 at warn(…)
530 at windows_subsystem = "…"
531 "#]],
532 );
533 }
534}
diff --git a/crates/completion/src/complete_dot.rs b/crates/completion/src/complete_dot.rs
new file mode 100644
index 000000000..0eabb48ae
--- /dev/null
+++ b/crates/completion/src/complete_dot.rs
@@ -0,0 +1,431 @@
1//! Completes references after dot (fields and method calls).
2
3use hir::{HasVisibility, Type};
4use rustc_hash::FxHashSet;
5use test_utils::mark;
6
7use crate::{completion_context::CompletionContext, completion_item::Completions};
8
9/// Complete dot accesses, i.e. fields or methods.
10pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
11 let dot_receiver = match &ctx.dot_receiver {
12 Some(expr) => expr,
13 _ => return,
14 };
15
16 let receiver_ty = match ctx.sema.type_of_expr(&dot_receiver) {
17 Some(ty) => ty,
18 _ => return,
19 };
20
21 if ctx.is_call {
22 mark::hit!(test_no_struct_field_completion_for_method_call);
23 } else {
24 complete_fields(acc, ctx, &receiver_ty);
25 }
26 complete_methods(acc, ctx, &receiver_ty);
27}
28
29fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: &Type) {
30 for receiver in receiver.autoderef(ctx.db) {
31 for (field, ty) in receiver.fields(ctx.db) {
32 if ctx.scope.module().map_or(false, |m| !field.is_visible_from(ctx.db, m)) {
33 // Skip private field. FIXME: If the definition location of the
34 // field is editable, we should show the completion
35 continue;
36 }
37 acc.add_field(ctx, field, &ty);
38 }
39 for (i, ty) in receiver.tuple_fields(ctx.db).into_iter().enumerate() {
40 // FIXME: Handle visibility
41 acc.add_tuple_field(ctx, i, &ty);
42 }
43 }
44}
45
46fn complete_methods(acc: &mut Completions, ctx: &CompletionContext, receiver: &Type) {
47 if let Some(krate) = ctx.krate {
48 let mut seen_methods = FxHashSet::default();
49 let traits_in_scope = ctx.scope.traits_in_scope();
50 receiver.iterate_method_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, func| {
51 if func.self_param(ctx.db).is_some()
52 && ctx.scope.module().map_or(true, |m| func.is_visible_from(ctx.db, m))
53 && seen_methods.insert(func.name(ctx.db))
54 {
55 acc.add_function(ctx, func, None);
56 }
57 None::<()>
58 });
59 }
60}
61
62#[cfg(test)]
63mod tests {
64 use expect_test::{expect, Expect};
65 use test_utils::mark;
66
67 use crate::{test_utils::completion_list, CompletionKind};
68
69 fn check(ra_fixture: &str, expect: Expect) {
70 let actual = completion_list(ra_fixture, CompletionKind::Reference);
71 expect.assert_eq(&actual);
72 }
73
74 #[test]
75 fn test_struct_field_and_method_completion() {
76 check(
77 r#"
78struct S { foo: u32 }
79impl S {
80 fn bar(&self) {}
81}
82fn foo(s: S) { s.<|> }
83"#,
84 expect![[r#"
85 me bar() fn bar(&self)
86 fd foo u32
87 "#]],
88 );
89 }
90
91 #[test]
92 fn test_struct_field_completion_self() {
93 check(
94 r#"
95struct S { the_field: (u32,) }
96impl S {
97 fn foo(self) { self.<|> }
98}
99"#,
100 expect![[r#"
101 me foo() fn foo(self)
102 fd the_field (u32,)
103 "#]],
104 )
105 }
106
107 #[test]
108 fn test_struct_field_completion_autoderef() {
109 check(
110 r#"
111struct A { the_field: (u32, i32) }
112impl A {
113 fn foo(&self) { self.<|> }
114}
115"#,
116 expect![[r#"
117 me foo() fn foo(&self)
118 fd the_field (u32, i32)
119 "#]],
120 )
121 }
122
123 #[test]
124 fn test_no_struct_field_completion_for_method_call() {
125 mark::check!(test_no_struct_field_completion_for_method_call);
126 check(
127 r#"
128struct A { the_field: u32 }
129fn foo(a: A) { a.<|>() }
130"#,
131 expect![[""]],
132 );
133 }
134
135 #[test]
136 fn test_visibility_filtering() {
137 check(
138 r#"
139mod inner {
140 pub struct A {
141 private_field: u32,
142 pub pub_field: u32,
143 pub(crate) crate_field: u32,
144 pub(super) super_field: u32,
145 }
146}
147fn foo(a: inner::A) { a.<|> }
148"#,
149 expect![[r#"
150 fd crate_field u32
151 fd pub_field u32
152 fd super_field u32
153 "#]],
154 );
155
156 check(
157 r#"
158struct A {}
159mod m {
160 impl super::A {
161 fn private_method(&self) {}
162 pub(super) fn the_method(&self) {}
163 }
164}
165fn foo(a: A) { a.<|> }
166"#,
167 expect![[r#"
168 me the_method() pub(super) fn the_method(&self)
169 "#]],
170 );
171 }
172
173 #[test]
174 fn test_union_field_completion() {
175 check(
176 r#"
177union U { field: u8, other: u16 }
178fn foo(u: U) { u.<|> }
179"#,
180 expect![[r#"
181 fd field u8
182 fd other u16
183 "#]],
184 );
185 }
186
187 #[test]
188 fn test_method_completion_only_fitting_impls() {
189 check(
190 r#"
191struct A<T> {}
192impl A<u32> {
193 fn the_method(&self) {}
194}
195impl A<i32> {
196 fn the_other_method(&self) {}
197}
198fn foo(a: A<u32>) { a.<|> }
199"#,
200 expect![[r#"
201 me the_method() fn the_method(&self)
202 "#]],
203 )
204 }
205
206 #[test]
207 fn test_trait_method_completion() {
208 check(
209 r#"
210struct A {}
211trait Trait { fn the_method(&self); }
212impl Trait for A {}
213fn foo(a: A) { a.<|> }
214"#,
215 expect![[r#"
216 me the_method() fn the_method(&self)
217 "#]],
218 );
219 }
220
221 #[test]
222 fn test_trait_method_completion_deduplicated() {
223 check(
224 r"
225struct A {}
226trait Trait { fn the_method(&self); }
227impl<T> Trait for T {}
228fn foo(a: &A) { a.<|> }
229",
230 expect![[r#"
231 me the_method() fn the_method(&self)
232 "#]],
233 );
234 }
235
236 #[test]
237 fn completes_trait_method_from_other_module() {
238 check(
239 r"
240struct A {}
241mod m {
242 pub trait Trait { fn the_method(&self); }
243}
244use m::Trait;
245impl Trait for A {}
246fn foo(a: A) { a.<|> }
247",
248 expect![[r#"
249 me the_method() fn the_method(&self)
250 "#]],
251 );
252 }
253
254 #[test]
255 fn test_no_non_self_method() {
256 check(
257 r#"
258struct A {}
259impl A {
260 fn the_method() {}
261}
262fn foo(a: A) {
263 a.<|>
264}
265"#,
266 expect![[""]],
267 );
268 }
269
270 #[test]
271 fn test_tuple_field_completion() {
272 check(
273 r#"
274fn foo() {
275 let b = (0, 3.14);
276 b.<|>
277}
278"#,
279 expect![[r#"
280 fd 0 i32
281 fd 1 f64
282 "#]],
283 )
284 }
285
286 #[test]
287 fn test_tuple_field_inference() {
288 check(
289 r#"
290pub struct S;
291impl S { pub fn blah(&self) {} }
292
293struct T(S);
294
295impl T {
296 fn foo(&self) {
297 // FIXME: This doesn't work without the trailing `a` as `0.` is a float
298 self.0.a<|>
299 }
300}
301"#,
302 expect![[r#"
303 me blah() pub fn blah(&self)
304 "#]],
305 );
306 }
307
308 #[test]
309 fn test_completion_works_in_consts() {
310 check(
311 r#"
312struct A { the_field: u32 }
313const X: u32 = {
314 A { the_field: 92 }.<|>
315};
316"#,
317 expect![[r#"
318 fd the_field u32
319 "#]],
320 );
321 }
322
323 #[test]
324 fn works_in_simple_macro_1() {
325 check(
326 r#"
327macro_rules! m { ($e:expr) => { $e } }
328struct A { the_field: u32 }
329fn foo(a: A) {
330 m!(a.x<|>)
331}
332"#,
333 expect![[r#"
334 fd the_field u32
335 "#]],
336 );
337 }
338
339 #[test]
340 fn works_in_simple_macro_2() {
341 // this doesn't work yet because the macro doesn't expand without the token -- maybe it can be fixed with better recovery
342 check(
343 r#"
344macro_rules! m { ($e:expr) => { $e } }
345struct A { the_field: u32 }
346fn foo(a: A) {
347 m!(a.<|>)
348}
349"#,
350 expect![[r#"
351 fd the_field u32
352 "#]],
353 );
354 }
355
356 #[test]
357 fn works_in_simple_macro_recursive_1() {
358 check(
359 r#"
360macro_rules! m { ($e:expr) => { $e } }
361struct A { the_field: u32 }
362fn foo(a: A) {
363 m!(m!(m!(a.x<|>)))
364}
365"#,
366 expect![[r#"
367 fd the_field u32
368 "#]],
369 );
370 }
371
372 #[test]
373 fn macro_expansion_resilient() {
374 check(
375 r#"
376macro_rules! dbg {
377 () => {};
378 ($val:expr) => {
379 match $val { tmp => { tmp } }
380 };
381 // Trailing comma with single argument is ignored
382 ($val:expr,) => { $crate::dbg!($val) };
383 ($($val:expr),+ $(,)?) => {
384 ($($crate::dbg!($val)),+,)
385 };
386}
387struct A { the_field: u32 }
388fn foo(a: A) {
389 dbg!(a.<|>)
390}
391"#,
392 expect![[r#"
393 fd the_field u32
394 "#]],
395 );
396 }
397
398 #[test]
399 fn test_method_completion_issue_3547() {
400 check(
401 r#"
402struct HashSet<T> {}
403impl<T> HashSet<T> {
404 pub fn the_method(&self) {}
405}
406fn foo() {
407 let s: HashSet<_>;
408 s.<|>
409}
410"#,
411 expect![[r#"
412 me the_method() pub fn the_method(&self)
413 "#]],
414 );
415 }
416
417 #[test]
418 fn completes_method_call_when_receiver_is_a_macro_call() {
419 check(
420 r#"
421struct S;
422impl S { fn foo(&self) {} }
423macro_rules! make_s { () => { S }; }
424fn main() { make_s!().f<|>; }
425"#,
426 expect![[r#"
427 me foo() fn foo(&self)
428 "#]],
429 )
430 }
431}
diff --git a/crates/completion/src/complete_fn_param.rs b/crates/completion/src/complete_fn_param.rs
new file mode 100644
index 000000000..918996727
--- /dev/null
+++ b/crates/completion/src/complete_fn_param.rs
@@ -0,0 +1,135 @@
1//! See `complete_fn_param`.
2
3use rustc_hash::FxHashMap;
4use syntax::{
5 ast::{self, ModuleItemOwner},
6 match_ast, AstNode,
7};
8
9use crate::{CompletionContext, CompletionItem, CompletionKind, Completions};
10
11/// Complete repeated parameters, both name and type. For example, if all
12/// functions in a file have a `spam: &mut Spam` parameter, a completion with
13/// `spam: &mut Spam` insert text/label and `spam` lookup string will be
14/// suggested.
15pub(super) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext) {
16 if !ctx.is_param {
17 return;
18 }
19
20 let mut params = FxHashMap::default();
21
22 let me = ctx.token.ancestors().find_map(ast::Fn::cast);
23 let mut process_fn = |func: ast::Fn| {
24 if Some(&func) == me.as_ref() {
25 return;
26 }
27 func.param_list().into_iter().flat_map(|it| it.params()).for_each(|param| {
28 let text = param.syntax().text().to_string();
29 params.entry(text).or_insert(param);
30 })
31 };
32
33 for node in ctx.token.parent().ancestors() {
34 match_ast! {
35 match node {
36 ast::SourceFile(it) => it.items().filter_map(|item| match item {
37 ast::Item::Fn(it) => Some(it),
38 _ => None,
39 }).for_each(&mut process_fn),
40 ast::ItemList(it) => it.items().filter_map(|item| match item {
41 ast::Item::Fn(it) => Some(it),
42 _ => None,
43 }).for_each(&mut process_fn),
44 ast::AssocItemList(it) => it.assoc_items().filter_map(|item| match item {
45 ast::AssocItem::Fn(it) => Some(it),
46 _ => None,
47 }).for_each(&mut process_fn),
48 _ => continue,
49 }
50 };
51 }
52
53 params
54 .into_iter()
55 .filter_map(|(label, param)| {
56 let lookup = param.pat()?.syntax().text().to_string();
57 Some((label, lookup))
58 })
59 .for_each(|(label, lookup)| {
60 CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label)
61 .kind(crate::CompletionItemKind::Binding)
62 .lookup_by(lookup)
63 .add_to(acc)
64 });
65}
66
67#[cfg(test)]
68mod tests {
69 use expect_test::{expect, Expect};
70
71 use crate::{test_utils::completion_list, CompletionKind};
72
73 fn check(ra_fixture: &str, expect: Expect) {
74 let actual = completion_list(ra_fixture, CompletionKind::Magic);
75 expect.assert_eq(&actual);
76 }
77
78 #[test]
79 fn test_param_completion_last_param() {
80 check(
81 r#"
82fn foo(file_id: FileId) {}
83fn bar(file_id: FileId) {}
84fn baz(file<|>) {}
85"#,
86 expect![[r#"
87 bn file_id: FileId
88 "#]],
89 );
90 }
91
92 #[test]
93 fn test_param_completion_nth_param() {
94 check(
95 r#"
96fn foo(file_id: FileId) {}
97fn baz(file<|>, x: i32) {}
98"#,
99 expect![[r#"
100 bn file_id: FileId
101 "#]],
102 );
103 }
104
105 #[test]
106 fn test_param_completion_trait_param() {
107 check(
108 r#"
109pub(crate) trait SourceRoot {
110 pub fn contains(&self, file_id: FileId) -> bool;
111 pub fn module_map(&self) -> &ModuleMap;
112 pub fn lines(&self, file_id: FileId) -> &LineIndex;
113 pub fn syntax(&self, file<|>)
114}
115"#,
116 expect![[r#"
117 bn file_id: FileId
118 "#]],
119 );
120 }
121
122 #[test]
123 fn completes_param_in_inner_function() {
124 check(
125 r#"
126fn outer(text: String) {
127 fn inner(<|>)
128}
129"#,
130 expect![[r#"
131 bn text: String
132 "#]],
133 )
134 }
135}
diff --git a/crates/completion/src/complete_keyword.rs b/crates/completion/src/complete_keyword.rs
new file mode 100644
index 000000000..ace914f3f
--- /dev/null
+++ b/crates/completion/src/complete_keyword.rs
@@ -0,0 +1,566 @@
1//! Completes keywords.
2
3use syntax::{ast, SyntaxKind};
4use test_utils::mark;
5
6use crate::{CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions};
7
8pub(super) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionContext) {
9 // complete keyword "crate" in use stmt
10 let source_range = ctx.source_range();
11
12 if ctx.use_item_syntax.is_some() {
13 if ctx.path_qual.is_none() {
14 CompletionItem::new(CompletionKind::Keyword, source_range, "crate::")
15 .kind(CompletionItemKind::Keyword)
16 .insert_text("crate::")
17 .add_to(acc);
18 }
19 CompletionItem::new(CompletionKind::Keyword, source_range, "self")
20 .kind(CompletionItemKind::Keyword)
21 .add_to(acc);
22 CompletionItem::new(CompletionKind::Keyword, source_range, "super::")
23 .kind(CompletionItemKind::Keyword)
24 .insert_text("super::")
25 .add_to(acc);
26 }
27
28 // Suggest .await syntax for types that implement Future trait
29 if let Some(receiver) = &ctx.dot_receiver {
30 if let Some(ty) = ctx.sema.type_of_expr(receiver) {
31 if ty.impls_future(ctx.db) {
32 CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), "await")
33 .kind(CompletionItemKind::Keyword)
34 .detail("expr.await")
35 .insert_text("await")
36 .add_to(acc);
37 }
38 };
39 }
40}
41
42pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionContext) {
43 if ctx.token.kind() == SyntaxKind::COMMENT {
44 mark::hit!(no_keyword_completion_in_comments);
45 return;
46 }
47
48 let has_trait_or_impl_parent = ctx.has_impl_parent || ctx.has_trait_parent;
49 if ctx.trait_as_prev_sibling || ctx.impl_as_prev_sibling {
50 add_keyword(ctx, acc, "where", "where ");
51 return;
52 }
53 if ctx.unsafe_is_prev {
54 if ctx.has_item_list_or_source_file_parent || ctx.block_expr_parent {
55 add_keyword(ctx, acc, "fn", "fn $0() {}")
56 }
57
58 if (ctx.has_item_list_or_source_file_parent) || ctx.block_expr_parent {
59 add_keyword(ctx, acc, "trait", "trait $0 {}");
60 add_keyword(ctx, acc, "impl", "impl $0 {}");
61 }
62
63 return;
64 }
65 if ctx.has_item_list_or_source_file_parent || has_trait_or_impl_parent || ctx.block_expr_parent
66 {
67 add_keyword(ctx, acc, "fn", "fn $0() {}");
68 }
69 if (ctx.has_item_list_or_source_file_parent) || ctx.block_expr_parent {
70 add_keyword(ctx, acc, "use", "use ");
71 add_keyword(ctx, acc, "impl", "impl $0 {}");
72 add_keyword(ctx, acc, "trait", "trait $0 {}");
73 }
74
75 if ctx.has_item_list_or_source_file_parent {
76 add_keyword(ctx, acc, "enum", "enum $0 {}");
77 add_keyword(ctx, acc, "struct", "struct $0");
78 add_keyword(ctx, acc, "union", "union $0 {}");
79 }
80
81 if ctx.is_expr {
82 add_keyword(ctx, acc, "match", "match $0 {}");
83 add_keyword(ctx, acc, "while", "while $0 {}");
84 add_keyword(ctx, acc, "loop", "loop {$0}");
85 add_keyword(ctx, acc, "if", "if ");
86 add_keyword(ctx, acc, "if let", "if let ");
87 }
88
89 if ctx.if_is_prev || ctx.block_expr_parent {
90 add_keyword(ctx, acc, "let", "let ");
91 }
92
93 if ctx.after_if {
94 add_keyword(ctx, acc, "else", "else {$0}");
95 add_keyword(ctx, acc, "else if", "else if $0 {}");
96 }
97 if (ctx.has_item_list_or_source_file_parent) || ctx.block_expr_parent {
98 add_keyword(ctx, acc, "mod", "mod $0 {}");
99 }
100 if ctx.bind_pat_parent || ctx.ref_pat_parent {
101 add_keyword(ctx, acc, "mut", "mut ");
102 }
103 if ctx.has_item_list_or_source_file_parent || has_trait_or_impl_parent || ctx.block_expr_parent
104 {
105 add_keyword(ctx, acc, "const", "const ");
106 add_keyword(ctx, acc, "type", "type ");
107 }
108 if (ctx.has_item_list_or_source_file_parent) || ctx.block_expr_parent {
109 add_keyword(ctx, acc, "static", "static ");
110 };
111 if (ctx.has_item_list_or_source_file_parent) || ctx.block_expr_parent {
112 add_keyword(ctx, acc, "extern", "extern ");
113 }
114 if ctx.has_item_list_or_source_file_parent
115 || has_trait_or_impl_parent
116 || ctx.block_expr_parent
117 || ctx.is_match_arm
118 {
119 add_keyword(ctx, acc, "unsafe", "unsafe ");
120 }
121 if ctx.in_loop_body {
122 if ctx.can_be_stmt {
123 add_keyword(ctx, acc, "continue", "continue;");
124 add_keyword(ctx, acc, "break", "break;");
125 } else {
126 add_keyword(ctx, acc, "continue", "continue");
127 add_keyword(ctx, acc, "break", "break");
128 }
129 }
130 if ctx.has_item_list_or_source_file_parent || ctx.has_impl_parent | ctx.has_field_list_parent {
131 add_keyword(ctx, acc, "pub(crate)", "pub(crate) ");
132 add_keyword(ctx, acc, "pub", "pub ");
133 }
134
135 if !ctx.is_trivial_path {
136 return;
137 }
138 let fn_def = match &ctx.function_syntax {
139 Some(it) => it,
140 None => return,
141 };
142 acc.add_all(complete_return(ctx, &fn_def, ctx.can_be_stmt));
143}
144
145fn keyword(ctx: &CompletionContext, kw: &str, snippet: &str) -> CompletionItem {
146 let res = CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), kw)
147 .kind(CompletionItemKind::Keyword);
148
149 match ctx.config.snippet_cap {
150 Some(cap) => res.insert_snippet(cap, snippet),
151 _ => res.insert_text(if snippet.contains('$') { kw } else { snippet }),
152 }
153 .build()
154}
155
156fn add_keyword(ctx: &CompletionContext, acc: &mut Completions, kw: &str, snippet: &str) {
157 acc.add(keyword(ctx, kw, snippet));
158}
159
160fn complete_return(
161 ctx: &CompletionContext,
162 fn_def: &ast::Fn,
163 can_be_stmt: bool,
164) -> Option<CompletionItem> {
165 let snip = match (can_be_stmt, fn_def.ret_type().is_some()) {
166 (true, true) => "return $0;",
167 (true, false) => "return;",
168 (false, true) => "return $0",
169 (false, false) => "return",
170 };
171 Some(keyword(ctx, "return", snip))
172}
173
174#[cfg(test)]
175mod tests {
176 use expect_test::{expect, Expect};
177
178 use crate::{
179 test_utils::{check_edit, completion_list},
180 CompletionKind,
181 };
182 use test_utils::mark;
183
184 fn check(ra_fixture: &str, expect: Expect) {
185 let actual = completion_list(ra_fixture, CompletionKind::Keyword);
186 expect.assert_eq(&actual)
187 }
188
189 #[test]
190 fn test_keywords_in_use_stmt() {
191 check(
192 r"use <|>",
193 expect![[r#"
194 kw crate::
195 kw self
196 kw super::
197 "#]],
198 );
199
200 check(
201 r"use a::<|>",
202 expect![[r#"
203 kw self
204 kw super::
205 "#]],
206 );
207
208 check(
209 r"use a::{b, <|>}",
210 expect![[r#"
211 kw self
212 kw super::
213 "#]],
214 );
215 }
216
217 #[test]
218 fn test_keywords_at_source_file_level() {
219 check(
220 r"m<|>",
221 expect![[r#"
222 kw const
223 kw enum
224 kw extern
225 kw fn
226 kw impl
227 kw mod
228 kw pub
229 kw pub(crate)
230 kw static
231 kw struct
232 kw trait
233 kw type
234 kw union
235 kw unsafe
236 kw use
237 "#]],
238 );
239 }
240
241 #[test]
242 fn test_keywords_in_function() {
243 check(
244 r"fn quux() { <|> }",
245 expect![[r#"
246 kw const
247 kw extern
248 kw fn
249 kw if
250 kw if let
251 kw impl
252 kw let
253 kw loop
254 kw match
255 kw mod
256 kw return
257 kw static
258 kw trait
259 kw type
260 kw unsafe
261 kw use
262 kw while
263 "#]],
264 );
265 }
266
267 #[test]
268 fn test_keywords_inside_block() {
269 check(
270 r"fn quux() { if true { <|> } }",
271 expect![[r#"
272 kw const
273 kw extern
274 kw fn
275 kw if
276 kw if let
277 kw impl
278 kw let
279 kw loop
280 kw match
281 kw mod
282 kw return
283 kw static
284 kw trait
285 kw type
286 kw unsafe
287 kw use
288 kw while
289 "#]],
290 );
291 }
292
293 #[test]
294 fn test_keywords_after_if() {
295 check(
296 r#"fn quux() { if true { () } <|> }"#,
297 expect![[r#"
298 kw const
299 kw else
300 kw else if
301 kw extern
302 kw fn
303 kw if
304 kw if let
305 kw impl
306 kw let
307 kw loop
308 kw match
309 kw mod
310 kw return
311 kw static
312 kw trait
313 kw type
314 kw unsafe
315 kw use
316 kw while
317 "#]],
318 );
319 check_edit(
320 "else",
321 r#"fn quux() { if true { () } <|> }"#,
322 r#"fn quux() { if true { () } else {$0} }"#,
323 );
324 }
325
326 #[test]
327 fn test_keywords_in_match_arm() {
328 check(
329 r#"
330fn quux() -> i32 {
331 match () { () => <|> }
332}
333"#,
334 expect![[r#"
335 kw if
336 kw if let
337 kw loop
338 kw match
339 kw return
340 kw unsafe
341 kw while
342 "#]],
343 );
344 }
345
346 #[test]
347 fn test_keywords_in_trait_def() {
348 check(
349 r"trait My { <|> }",
350 expect![[r#"
351 kw const
352 kw fn
353 kw type
354 kw unsafe
355 "#]],
356 );
357 }
358
359 #[test]
360 fn test_keywords_in_impl_def() {
361 check(
362 r"impl My { <|> }",
363 expect![[r#"
364 kw const
365 kw fn
366 kw pub
367 kw pub(crate)
368 kw type
369 kw unsafe
370 "#]],
371 );
372 }
373
374 #[test]
375 fn test_keywords_in_loop() {
376 check(
377 r"fn my() { loop { <|> } }",
378 expect![[r#"
379 kw break
380 kw const
381 kw continue
382 kw extern
383 kw fn
384 kw if
385 kw if let
386 kw impl
387 kw let
388 kw loop
389 kw match
390 kw mod
391 kw return
392 kw static
393 kw trait
394 kw type
395 kw unsafe
396 kw use
397 kw while
398 "#]],
399 );
400 }
401
402 #[test]
403 fn test_keywords_after_unsafe_in_item_list() {
404 check(
405 r"unsafe <|>",
406 expect![[r#"
407 kw fn
408 kw impl
409 kw trait
410 "#]],
411 );
412 }
413
414 #[test]
415 fn test_keywords_after_unsafe_in_block_expr() {
416 check(
417 r"fn my_fn() { unsafe <|> }",
418 expect![[r#"
419 kw fn
420 kw impl
421 kw trait
422 "#]],
423 );
424 }
425
426 #[test]
427 fn test_mut_in_ref_and_in_fn_parameters_list() {
428 check(
429 r"fn my_fn(&<|>) {}",
430 expect![[r#"
431 kw mut
432 "#]],
433 );
434 check(
435 r"fn my_fn(<|>) {}",
436 expect![[r#"
437 kw mut
438 "#]],
439 );
440 check(
441 r"fn my_fn() { let &<|> }",
442 expect![[r#"
443 kw mut
444 "#]],
445 );
446 }
447
448 #[test]
449 fn test_where_keyword() {
450 check(
451 r"trait A <|>",
452 expect![[r#"
453 kw where
454 "#]],
455 );
456 check(
457 r"impl A <|>",
458 expect![[r#"
459 kw where
460 "#]],
461 );
462 }
463
464 #[test]
465 fn no_keyword_completion_in_comments() {
466 mark::check!(no_keyword_completion_in_comments);
467 check(
468 r#"
469fn test() {
470 let x = 2; // A comment<|>
471}
472"#,
473 expect![[""]],
474 );
475 check(
476 r#"
477/*
478Some multi-line comment<|>
479*/
480"#,
481 expect![[""]],
482 );
483 check(
484 r#"
485/// Some doc comment
486/// let test<|> = 1
487"#,
488 expect![[""]],
489 );
490 }
491
492 #[test]
493 fn test_completion_await_impls_future() {
494 check(
495 r#"
496//- /main.rs crate:main deps:std
497use std::future::*;
498struct A {}
499impl Future for A {}
500fn foo(a: A) { a.<|> }
501
502//- /std/lib.rs crate:std
503pub mod future {
504 #[lang = "future_trait"]
505 pub trait Future {}
506}
507"#,
508 expect![[r#"
509 kw await expr.await
510 "#]],
511 );
512
513 check(
514 r#"
515//- /main.rs crate:main deps:std
516use std::future::*;
517fn foo() {
518 let a = async {};
519 a.<|>
520}
521
522//- /std/lib.rs crate:std
523pub mod future {
524 #[lang = "future_trait"]
525 pub trait Future {
526 type Output;
527 }
528}
529"#,
530 expect![[r#"
531 kw await expr.await
532 "#]],
533 )
534 }
535
536 #[test]
537 fn after_let() {
538 check(
539 r#"fn main() { let _ = <|> }"#,
540 expect![[r#"
541 kw if
542 kw if let
543 kw loop
544 kw match
545 kw return
546 kw while
547 "#]],
548 )
549 }
550
551 #[test]
552 fn before_field() {
553 check(
554 r#"
555struct Foo {
556 <|>
557 pub f: i32,
558}
559"#,
560 expect![[r#"
561 kw pub
562 kw pub(crate)
563 "#]],
564 )
565 }
566}
diff --git a/crates/completion/src/complete_macro_in_item_position.rs b/crates/completion/src/complete_macro_in_item_position.rs
new file mode 100644
index 000000000..d1d8c23d2
--- /dev/null
+++ b/crates/completion/src/complete_macro_in_item_position.rs
@@ -0,0 +1,41 @@
1//! Completes macro invocations used in item position.
2
3use crate::{CompletionContext, Completions};
4
5pub(super) fn complete_macro_in_item_position(acc: &mut Completions, ctx: &CompletionContext) {
6 // Show only macros in top level.
7 if ctx.is_new_item {
8 ctx.scope.process_all_names(&mut |name, res| {
9 if let hir::ScopeDef::MacroDef(mac) = res {
10 acc.add_macro(ctx, Some(name.to_string()), mac);
11 }
12 })
13 }
14}
15
16#[cfg(test)]
17mod tests {
18 use expect_test::{expect, Expect};
19
20 use crate::{test_utils::completion_list, CompletionKind};
21
22 fn check(ra_fixture: &str, expect: Expect) {
23 let actual = completion_list(ra_fixture, CompletionKind::Reference);
24 expect.assert_eq(&actual)
25 }
26
27 #[test]
28 fn completes_macros_as_item() {
29 check(
30 r#"
31macro_rules! foo { () => {} }
32fn foo() {}
33
34<|>
35"#,
36 expect![[r#"
37 ma foo!(…) macro_rules! foo
38 "#]],
39 )
40 }
41}
diff --git a/crates/completion/src/complete_mod.rs b/crates/completion/src/complete_mod.rs
new file mode 100644
index 000000000..35a57aba3
--- /dev/null
+++ b/crates/completion/src/complete_mod.rs
@@ -0,0 +1,324 @@
1//! Completes mod declarations.
2
3use base_db::{SourceDatabaseExt, VfsPath};
4use hir::{Module, ModuleSource};
5use ide_db::RootDatabase;
6use rustc_hash::FxHashSet;
7
8use crate::{CompletionItem, CompletionItemKind};
9
10use super::{
11 completion_context::CompletionContext, completion_item::CompletionKind,
12 completion_item::Completions,
13};
14
15/// Complete mod declaration, i.e. `mod <|> ;`
16pub(super) fn complete_mod(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
17 let mod_under_caret = match &ctx.mod_declaration_under_caret {
18 Some(mod_under_caret) if mod_under_caret.item_list().is_some() => return None,
19 Some(mod_under_caret) => mod_under_caret,
20 None => return None,
21 };
22
23 let _p = profile::span("completion::complete_mod");
24
25 let current_module = ctx.scope.module()?;
26
27 let module_definition_file =
28 current_module.definition_source(ctx.db).file_id.original_file(ctx.db);
29 let source_root = ctx.db.source_root(ctx.db.file_source_root(module_definition_file));
30 let directory_to_look_for_submodules = directory_to_look_for_submodules(
31 current_module,
32 ctx.db,
33 source_root.path_for_file(&module_definition_file)?,
34 )?;
35
36 let existing_mod_declarations = current_module
37 .children(ctx.db)
38 .filter_map(|module| Some(module.name(ctx.db)?.to_string()))
39 .collect::<FxHashSet<_>>();
40
41 let module_declaration_file =
42 current_module.declaration_source(ctx.db).map(|module_declaration_source_file| {
43 module_declaration_source_file.file_id.original_file(ctx.db)
44 });
45
46 source_root
47 .iter()
48 .filter(|submodule_candidate_file| submodule_candidate_file != &module_definition_file)
49 .filter(|submodule_candidate_file| {
50 Some(submodule_candidate_file) != module_declaration_file.as_ref()
51 })
52 .filter_map(|submodule_file| {
53 let submodule_path = source_root.path_for_file(&submodule_file)?;
54 let directory_with_submodule = submodule_path.parent()?;
55 match submodule_path.name_and_extension()? {
56 ("lib", Some("rs")) | ("main", Some("rs")) => None,
57 ("mod", Some("rs")) => {
58 if directory_with_submodule.parent()? == directory_to_look_for_submodules {
59 match directory_with_submodule.name_and_extension()? {
60 (directory_name, None) => Some(directory_name.to_owned()),
61 _ => None,
62 }
63 } else {
64 None
65 }
66 }
67 (file_name, Some("rs"))
68 if directory_with_submodule == directory_to_look_for_submodules =>
69 {
70 Some(file_name.to_owned())
71 }
72 _ => None,
73 }
74 })
75 .filter(|name| !existing_mod_declarations.contains(name))
76 .for_each(|submodule_name| {
77 let mut label = submodule_name;
78 if mod_under_caret.semicolon_token().is_none() {
79 label.push(';')
80 }
81 acc.add(
82 CompletionItem::new(CompletionKind::Magic, ctx.source_range(), &label)
83 .kind(CompletionItemKind::Module),
84 )
85 });
86
87 Some(())
88}
89
90fn directory_to_look_for_submodules(
91 module: Module,
92 db: &RootDatabase,
93 module_file_path: &VfsPath,
94) -> Option<VfsPath> {
95 let directory_with_module_path = module_file_path.parent()?;
96 let base_directory = match module_file_path.name_and_extension()? {
97 ("mod", Some("rs")) | ("lib", Some("rs")) | ("main", Some("rs")) => {
98 Some(directory_with_module_path)
99 }
100 (regular_rust_file_name, Some("rs")) => {
101 if matches!(
102 (
103 directory_with_module_path
104 .parent()
105 .as_ref()
106 .and_then(|path| path.name_and_extension()),
107 directory_with_module_path.name_and_extension(),
108 ),
109 (Some(("src", None)), Some(("bin", None)))
110 ) {
111 // files in /src/bin/ can import each other directly
112 Some(directory_with_module_path)
113 } else {
114 directory_with_module_path.join(regular_rust_file_name)
115 }
116 }
117 _ => None,
118 }?;
119
120 let mut resulting_path = base_directory;
121 for module in module_chain_to_containing_module_file(module, db) {
122 if let Some(name) = module.name(db) {
123 resulting_path = resulting_path.join(&name.to_string())?;
124 }
125 }
126
127 Some(resulting_path)
128}
129
130fn module_chain_to_containing_module_file(
131 current_module: Module,
132 db: &RootDatabase,
133) -> Vec<Module> {
134 let mut path = Vec::new();
135
136 let mut current_module = Some(current_module);
137 while let Some(ModuleSource::Module(_)) =
138 current_module.map(|module| module.definition_source(db).value)
139 {
140 if let Some(module) = current_module {
141 path.insert(0, module);
142 current_module = module.parent(db);
143 } else {
144 current_module = None;
145 }
146 }
147
148 path
149}
150
151#[cfg(test)]
152mod tests {
153 use crate::{test_utils::completion_list, CompletionKind};
154 use expect_test::{expect, Expect};
155
156 fn check(ra_fixture: &str, expect: Expect) {
157 let actual = completion_list(ra_fixture, CompletionKind::Magic);
158 expect.assert_eq(&actual);
159 }
160
161 #[test]
162 fn lib_module_completion() {
163 check(
164 r#"
165 //- /lib.rs
166 mod <|>
167 //- /foo.rs
168 fn foo() {}
169 //- /foo/ignored_foo.rs
170 fn ignored_foo() {}
171 //- /bar/mod.rs
172 fn bar() {}
173 //- /bar/ignored_bar.rs
174 fn ignored_bar() {}
175 "#,
176 expect![[r#"
177 md bar;
178 md foo;
179 "#]],
180 );
181 }
182
183 #[test]
184 fn no_module_completion_with_module_body() {
185 check(
186 r#"
187 //- /lib.rs
188 mod <|> {
189
190 }
191 //- /foo.rs
192 fn foo() {}
193 "#,
194 expect![[r#""#]],
195 );
196 }
197
198 #[test]
199 fn main_module_completion() {
200 check(
201 r#"
202 //- /main.rs
203 mod <|>
204 //- /foo.rs
205 fn foo() {}
206 //- /foo/ignored_foo.rs
207 fn ignored_foo() {}
208 //- /bar/mod.rs
209 fn bar() {}
210 //- /bar/ignored_bar.rs
211 fn ignored_bar() {}
212 "#,
213 expect![[r#"
214 md bar;
215 md foo;
216 "#]],
217 );
218 }
219
220 #[test]
221 fn main_test_module_completion() {
222 check(
223 r#"
224 //- /main.rs
225 mod tests {
226 mod <|>;
227 }
228 //- /tests/foo.rs
229 fn foo() {}
230 "#,
231 expect![[r#"
232 md foo
233 "#]],
234 );
235 }
236
237 #[test]
238 fn directly_nested_module_completion() {
239 check(
240 r#"
241 //- /lib.rs
242 mod foo;
243 //- /foo.rs
244 mod <|>;
245 //- /foo/bar.rs
246 fn bar() {}
247 //- /foo/bar/ignored_bar.rs
248 fn ignored_bar() {}
249 //- /foo/baz/mod.rs
250 fn baz() {}
251 //- /foo/moar/ignored_moar.rs
252 fn ignored_moar() {}
253 "#,
254 expect![[r#"
255 md bar
256 md baz
257 "#]],
258 );
259 }
260
261 #[test]
262 fn nested_in_source_module_completion() {
263 check(
264 r#"
265 //- /lib.rs
266 mod foo;
267 //- /foo.rs
268 mod bar {
269 mod <|>
270 }
271 //- /foo/bar/baz.rs
272 fn baz() {}
273 "#,
274 expect![[r#"
275 md baz;
276 "#]],
277 );
278 }
279
280 // FIXME binary modules are not supported in tests properly
281 // Binary modules are a bit special, they allow importing the modules from `/src/bin`
282 // and that's why are good to test two things:
283 // * no cycles are allowed in mod declarations
284 // * no modules from the parent directory are proposed
285 // Unfortunately, binary modules support is in cargo not rustc,
286 // hence the test does not work now
287 //
288 // #[test]
289 // fn regular_bin_module_completion() {
290 // check(
291 // r#"
292 // //- /src/bin.rs
293 // fn main() {}
294 // //- /src/bin/foo.rs
295 // mod <|>
296 // //- /src/bin/bar.rs
297 // fn bar() {}
298 // //- /src/bin/bar/bar_ignored.rs
299 // fn bar_ignored() {}
300 // "#,
301 // expect![[r#"
302 // md bar;
303 // "#]],foo
304 // );
305 // }
306
307 #[test]
308 fn already_declared_bin_module_completion_omitted() {
309 check(
310 r#"
311 //- /src/bin.rs crate:main
312 fn main() {}
313 //- /src/bin/foo.rs
314 mod <|>
315 //- /src/bin/bar.rs
316 mod foo;
317 fn bar() {}
318 //- /src/bin/bar/bar_ignored.rs
319 fn bar_ignored() {}
320 "#,
321 expect![[r#""#]],
322 );
323 }
324}
diff --git a/crates/completion/src/complete_pattern.rs b/crates/completion/src/complete_pattern.rs
new file mode 100644
index 000000000..5606dcdd9
--- /dev/null
+++ b/crates/completion/src/complete_pattern.rs
@@ -0,0 +1,88 @@
1//! Completes constats and paths in patterns.
2
3use crate::{CompletionContext, Completions};
4
5/// Completes constats and paths in patterns.
6pub(super) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
7 if !ctx.is_pat_binding_or_const {
8 return;
9 }
10 if ctx.record_pat_syntax.is_some() {
11 return;
12 }
13
14 // FIXME: ideally, we should look at the type we are matching against and
15 // suggest variants + auto-imports
16 ctx.scope.process_all_names(&mut |name, res| {
17 match &res {
18 hir::ScopeDef::ModuleDef(def) => match def {
19 hir::ModuleDef::Adt(hir::Adt::Enum(..))
20 | hir::ModuleDef::Adt(hir::Adt::Struct(..))
21 | hir::ModuleDef::EnumVariant(..)
22 | hir::ModuleDef::Const(..)
23 | hir::ModuleDef::Module(..) => (),
24 _ => return,
25 },
26 hir::ScopeDef::MacroDef(_) => (),
27 _ => return,
28 };
29
30 acc.add_resolution(ctx, name.to_string(), &res)
31 });
32}
33
34#[cfg(test)]
35mod tests {
36 use expect_test::{expect, Expect};
37
38 use crate::{test_utils::completion_list, CompletionKind};
39
40 fn check(ra_fixture: &str, expect: Expect) {
41 let actual = completion_list(ra_fixture, CompletionKind::Reference);
42 expect.assert_eq(&actual)
43 }
44
45 #[test]
46 fn completes_enum_variants_and_modules() {
47 check(
48 r#"
49enum E { X }
50use self::E::X;
51const Z: E = E::X;
52mod m {}
53
54static FOO: E = E::X;
55struct Bar { f: u32 }
56
57fn foo() {
58 match E::X { <|> }
59}
60"#,
61 expect![[r#"
62 st Bar
63 en E
64 ev X ()
65 ct Z
66 md m
67 "#]],
68 );
69 }
70
71 #[test]
72 fn completes_in_simple_macro_call() {
73 check(
74 r#"
75macro_rules! m { ($e:expr) => { $e } }
76enum E { X }
77
78fn foo() {
79 m!(match E::X { <|> })
80}
81"#,
82 expect![[r#"
83 en E
84 ma m!(…) macro_rules! m
85 "#]],
86 );
87 }
88}
diff --git a/crates/completion/src/complete_postfix.rs b/crates/completion/src/complete_postfix.rs
new file mode 100644
index 000000000..700573cf2
--- /dev/null
+++ b/crates/completion/src/complete_postfix.rs
@@ -0,0 +1,452 @@
1//! Postfix completions, like `Ok(10).ifl<|>` => `if let Ok() = Ok(10) { <|> }`.
2
3mod format_like;
4
5use assists::utils::TryEnum;
6use syntax::{
7 ast::{self, AstNode, AstToken},
8 TextRange, TextSize,
9};
10use text_edit::TextEdit;
11
12use self::format_like::add_format_like_completions;
13use crate::{
14 completion_config::SnippetCap,
15 completion_context::CompletionContext,
16 completion_item::{Builder, CompletionKind, Completions},
17 CompletionItem, CompletionItemKind,
18};
19
20pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
21 if !ctx.config.enable_postfix_completions {
22 return;
23 }
24
25 let dot_receiver = match &ctx.dot_receiver {
26 Some(it) => it,
27 None => return,
28 };
29
30 let receiver_text =
31 get_receiver_text(dot_receiver, ctx.dot_receiver_is_ambiguous_float_literal);
32
33 let receiver_ty = match ctx.sema.type_of_expr(&dot_receiver) {
34 Some(it) => it,
35 None => return,
36 };
37
38 let cap = match ctx.config.snippet_cap {
39 Some(it) => it,
40 None => return,
41 };
42 let try_enum = TryEnum::from_ty(&ctx.sema, &receiver_ty);
43 if let Some(try_enum) = &try_enum {
44 match try_enum {
45 TryEnum::Result => {
46 postfix_snippet(
47 ctx,
48 cap,
49 &dot_receiver,
50 "ifl",
51 "if let Ok {}",
52 &format!("if let Ok($1) = {} {{\n $0\n}}", receiver_text),
53 )
54 .add_to(acc);
55
56 postfix_snippet(
57 ctx,
58 cap,
59 &dot_receiver,
60 "while",
61 "while let Ok {}",
62 &format!("while let Ok($1) = {} {{\n $0\n}}", receiver_text),
63 )
64 .add_to(acc);
65 }
66 TryEnum::Option => {
67 postfix_snippet(
68 ctx,
69 cap,
70 &dot_receiver,
71 "ifl",
72 "if let Some {}",
73 &format!("if let Some($1) = {} {{\n $0\n}}", receiver_text),
74 )
75 .add_to(acc);
76
77 postfix_snippet(
78 ctx,
79 cap,
80 &dot_receiver,
81 "while",
82 "while let Some {}",
83 &format!("while let Some($1) = {} {{\n $0\n}}", receiver_text),
84 )
85 .add_to(acc);
86 }
87 }
88 } else if receiver_ty.is_bool() || receiver_ty.is_unknown() {
89 postfix_snippet(
90 ctx,
91 cap,
92 &dot_receiver,
93 "if",
94 "if expr {}",
95 &format!("if {} {{\n $0\n}}", receiver_text),
96 )
97 .add_to(acc);
98 postfix_snippet(
99 ctx,
100 cap,
101 &dot_receiver,
102 "while",
103 "while expr {}",
104 &format!("while {} {{\n $0\n}}", receiver_text),
105 )
106 .add_to(acc);
107 postfix_snippet(ctx, cap, &dot_receiver, "not", "!expr", &format!("!{}", receiver_text))
108 .add_to(acc);
109 }
110
111 postfix_snippet(ctx, cap, &dot_receiver, "ref", "&expr", &format!("&{}", receiver_text))
112 .add_to(acc);
113 postfix_snippet(
114 ctx,
115 cap,
116 &dot_receiver,
117 "refm",
118 "&mut expr",
119 &format!("&mut {}", receiver_text),
120 )
121 .add_to(acc);
122
123 // The rest of the postfix completions create an expression that moves an argument,
124 // so it's better to consider references now to avoid breaking the compilation
125 let dot_receiver = include_references(dot_receiver);
126 let receiver_text =
127 get_receiver_text(&dot_receiver, ctx.dot_receiver_is_ambiguous_float_literal);
128
129 match try_enum {
130 Some(try_enum) => match try_enum {
131 TryEnum::Result => {
132 postfix_snippet(
133 ctx,
134 cap,
135 &dot_receiver,
136 "match",
137 "match expr {}",
138 &format!("match {} {{\n Ok(${{1:_}}) => {{$2}},\n Err(${{3:_}}) => {{$0}},\n}}", receiver_text),
139 )
140 .add_to(acc);
141 }
142 TryEnum::Option => {
143 postfix_snippet(
144 ctx,
145 cap,
146 &dot_receiver,
147 "match",
148 "match expr {}",
149 &format!(
150 "match {} {{\n Some(${{1:_}}) => {{$2}},\n None => {{$0}},\n}}",
151 receiver_text
152 ),
153 )
154 .add_to(acc);
155 }
156 },
157 None => {
158 postfix_snippet(
159 ctx,
160 cap,
161 &dot_receiver,
162 "match",
163 "match expr {}",
164 &format!("match {} {{\n ${{1:_}} => {{$0}},\n}}", receiver_text),
165 )
166 .add_to(acc);
167 }
168 }
169
170 postfix_snippet(
171 ctx,
172 cap,
173 &dot_receiver,
174 "box",
175 "Box::new(expr)",
176 &format!("Box::new({})", receiver_text),
177 )
178 .add_to(acc);
179
180 postfix_snippet(ctx, cap, &dot_receiver, "ok", "Ok(expr)", &format!("Ok({})", receiver_text))
181 .add_to(acc);
182
183 postfix_snippet(
184 ctx,
185 cap,
186 &dot_receiver,
187 "dbg",
188 "dbg!(expr)",
189 &format!("dbg!({})", receiver_text),
190 )
191 .add_to(acc);
192
193 postfix_snippet(
194 ctx,
195 cap,
196 &dot_receiver,
197 "dbgr",
198 "dbg!(&expr)",
199 &format!("dbg!(&{})", receiver_text),
200 )
201 .add_to(acc);
202
203 postfix_snippet(
204 ctx,
205 cap,
206 &dot_receiver,
207 "call",
208 "function(expr)",
209 &format!("${{1}}({})", receiver_text),
210 )
211 .add_to(acc);
212
213 if let ast::Expr::Literal(literal) = dot_receiver.clone() {
214 if let Some(literal_text) = ast::String::cast(literal.token()) {
215 add_format_like_completions(acc, ctx, &dot_receiver, cap, &literal_text);
216 }
217 }
218}
219
220fn get_receiver_text(receiver: &ast::Expr, receiver_is_ambiguous_float_literal: bool) -> String {
221 if receiver_is_ambiguous_float_literal {
222 let text = receiver.syntax().text();
223 let without_dot = ..text.len() - TextSize::of('.');
224 text.slice(without_dot).to_string()
225 } else {
226 receiver.to_string()
227 }
228}
229
230fn include_references(initial_element: &ast::Expr) -> ast::Expr {
231 let mut resulting_element = initial_element.clone();
232 while let Some(parent_ref_element) =
233 resulting_element.syntax().parent().and_then(ast::RefExpr::cast)
234 {
235 resulting_element = ast::Expr::from(parent_ref_element);
236 }
237 resulting_element
238}
239
240fn postfix_snippet(
241 ctx: &CompletionContext,
242 cap: SnippetCap,
243 receiver: &ast::Expr,
244 label: &str,
245 detail: &str,
246 snippet: &str,
247) -> Builder {
248 let edit = {
249 let receiver_syntax = receiver.syntax();
250 let receiver_range = ctx.sema.original_range(receiver_syntax).range;
251 let delete_range = TextRange::new(receiver_range.start(), ctx.source_range().end());
252 TextEdit::replace(delete_range, snippet.to_string())
253 };
254 CompletionItem::new(CompletionKind::Postfix, ctx.source_range(), label)
255 .detail(detail)
256 .kind(CompletionItemKind::Snippet)
257 .snippet_edit(cap, edit)
258}
259
260#[cfg(test)]
261mod tests {
262 use expect_test::{expect, Expect};
263
264 use crate::{
265 test_utils::{check_edit, completion_list},
266 CompletionKind,
267 };
268
269 fn check(ra_fixture: &str, expect: Expect) {
270 let actual = completion_list(ra_fixture, CompletionKind::Postfix);
271 expect.assert_eq(&actual)
272 }
273
274 #[test]
275 fn postfix_completion_works_for_trivial_path_expression() {
276 check(
277 r#"
278fn main() {
279 let bar = true;
280 bar.<|>
281}
282"#,
283 expect![[r#"
284 sn box Box::new(expr)
285 sn call function(expr)
286 sn dbg dbg!(expr)
287 sn dbgr dbg!(&expr)
288 sn if if expr {}
289 sn match match expr {}
290 sn not !expr
291 sn ok Ok(expr)
292 sn ref &expr
293 sn refm &mut expr
294 sn while while expr {}
295 "#]],
296 );
297 }
298
299 #[test]
300 fn postfix_type_filtering() {
301 check(
302 r#"
303fn main() {
304 let bar: u8 = 12;
305 bar.<|>
306}
307"#,
308 expect![[r#"
309 sn box Box::new(expr)
310 sn call function(expr)
311 sn dbg dbg!(expr)
312 sn dbgr dbg!(&expr)
313 sn match match expr {}
314 sn ok Ok(expr)
315 sn ref &expr
316 sn refm &mut expr
317 "#]],
318 )
319 }
320
321 #[test]
322 fn option_iflet() {
323 check_edit(
324 "ifl",
325 r#"
326enum Option<T> { Some(T), None }
327
328fn main() {
329 let bar = Option::Some(true);
330 bar.<|>
331}
332"#,
333 r#"
334enum Option<T> { Some(T), None }
335
336fn main() {
337 let bar = Option::Some(true);
338 if let Some($1) = bar {
339 $0
340}
341}
342"#,
343 );
344 }
345
346 #[test]
347 fn result_match() {
348 check_edit(
349 "match",
350 r#"
351enum Result<T, E> { Ok(T), Err(E) }
352
353fn main() {
354 let bar = Result::Ok(true);
355 bar.<|>
356}
357"#,
358 r#"
359enum Result<T, E> { Ok(T), Err(E) }
360
361fn main() {
362 let bar = Result::Ok(true);
363 match bar {
364 Ok(${1:_}) => {$2},
365 Err(${3:_}) => {$0},
366}
367}
368"#,
369 );
370 }
371
372 #[test]
373 fn postfix_completion_works_for_ambiguous_float_literal() {
374 check_edit("refm", r#"fn main() { 42.<|> }"#, r#"fn main() { &mut 42 }"#)
375 }
376
377 #[test]
378 fn works_in_simple_macro() {
379 check_edit(
380 "dbg",
381 r#"
382macro_rules! m { ($e:expr) => { $e } }
383fn main() {
384 let bar: u8 = 12;
385 m!(bar.d<|>)
386}
387"#,
388 r#"
389macro_rules! m { ($e:expr) => { $e } }
390fn main() {
391 let bar: u8 = 12;
392 m!(dbg!(bar))
393}
394"#,
395 );
396 }
397
398 #[test]
399 fn postfix_completion_for_references() {
400 check_edit("dbg", r#"fn main() { &&42.<|> }"#, r#"fn main() { dbg!(&&42) }"#);
401 check_edit("refm", r#"fn main() { &&42.<|> }"#, r#"fn main() { &&&mut 42 }"#);
402 }
403
404 #[test]
405 fn postfix_completion_for_format_like_strings() {
406 check_edit(
407 "fmt",
408 r#"fn main() { "{some_var:?}".<|> }"#,
409 r#"fn main() { format!("{:?}", some_var) }"#,
410 );
411 check_edit(
412 "panic",
413 r#"fn main() { "Panic with {a}".<|> }"#,
414 r#"fn main() { panic!("Panic with {}", a) }"#,
415 );
416 check_edit(
417 "println",
418 r#"fn main() { "{ 2+2 } { SomeStruct { val: 1, other: 32 } :?}".<|> }"#,
419 r#"fn main() { println!("{} {:?}", 2+2, SomeStruct { val: 1, other: 32 }) }"#,
420 );
421 check_edit(
422 "loge",
423 r#"fn main() { "{2+2}".<|> }"#,
424 r#"fn main() { log::error!("{}", 2+2) }"#,
425 );
426 check_edit(
427 "logt",
428 r#"fn main() { "{2+2}".<|> }"#,
429 r#"fn main() { log::trace!("{}", 2+2) }"#,
430 );
431 check_edit(
432 "logd",
433 r#"fn main() { "{2+2}".<|> }"#,
434 r#"fn main() { log::debug!("{}", 2+2) }"#,
435 );
436 check_edit(
437 "logi",
438 r#"fn main() { "{2+2}".<|> }"#,
439 r#"fn main() { log::info!("{}", 2+2) }"#,
440 );
441 check_edit(
442 "logw",
443 r#"fn main() { "{2+2}".<|> }"#,
444 r#"fn main() { log::warn!("{}", 2+2) }"#,
445 );
446 check_edit(
447 "loge",
448 r#"fn main() { "{2+2}".<|> }"#,
449 r#"fn main() { log::error!("{}", 2+2) }"#,
450 );
451 }
452}
diff --git a/crates/completion/src/complete_postfix/format_like.rs b/crates/completion/src/complete_postfix/format_like.rs
new file mode 100644
index 000000000..205c384e2
--- /dev/null
+++ b/crates/completion/src/complete_postfix/format_like.rs
@@ -0,0 +1,279 @@
1// Feature: Format String Completion.
2//
3// `"Result {result} is {2 + 2}"` is expanded to the `"Result {} is {}", result, 2 + 2`.
4//
5// The following postfix snippets are available:
6//
7// - `format` -> `format!(...)`
8// - `panic` -> `panic!(...)`
9// - `println` -> `println!(...)`
10// - `log`:
11// + `logd` -> `log::debug!(...)`
12// + `logt` -> `log::trace!(...)`
13// + `logi` -> `log::info!(...)`
14// + `logw` -> `log::warn!(...)`
15// + `loge` -> `log::error!(...)`
16
17use crate::{
18 complete_postfix::postfix_snippet, completion_config::SnippetCap,
19 completion_context::CompletionContext, completion_item::Completions,
20};
21use syntax::ast::{self, AstToken};
22
23/// Mapping ("postfix completion item" => "macro to use")
24static KINDS: &[(&str, &str)] = &[
25 ("fmt", "format!"),
26 ("panic", "panic!"),
27 ("println", "println!"),
28 ("eprintln", "eprintln!"),
29 ("logd", "log::debug!"),
30 ("logt", "log::trace!"),
31 ("logi", "log::info!"),
32 ("logw", "log::warn!"),
33 ("loge", "log::error!"),
34];
35
36pub(super) fn add_format_like_completions(
37 acc: &mut Completions,
38 ctx: &CompletionContext,
39 dot_receiver: &ast::Expr,
40 cap: SnippetCap,
41 receiver_text: &ast::String,
42) {
43 let input = match string_literal_contents(receiver_text) {
44 // It's not a string literal, do not parse input.
45 Some(input) => input,
46 None => return,
47 };
48
49 let mut parser = FormatStrParser::new(input);
50
51 if parser.parse().is_ok() {
52 for (label, macro_name) in KINDS {
53 let snippet = parser.into_suggestion(macro_name);
54
55 postfix_snippet(ctx, cap, &dot_receiver, label, macro_name, &snippet).add_to(acc);
56 }
57 }
58}
59
60/// Checks whether provided item is a string literal.
61fn string_literal_contents(item: &ast::String) -> Option<String> {
62 let item = item.text();
63 if item.len() >= 2 && item.starts_with("\"") && item.ends_with("\"") {
64 return Some(item[1..item.len() - 1].to_owned());
65 }
66
67 None
68}
69
70/// Parser for a format-like string. It is more allowing in terms of string contents,
71/// as we expect variable placeholders to be filled with expressions.
72#[derive(Debug)]
73pub struct FormatStrParser {
74 input: String,
75 output: String,
76 extracted_expressions: Vec<String>,
77 state: State,
78 parsed: bool,
79}
80
81#[derive(Debug, Clone, Copy, PartialEq)]
82enum State {
83 NotExpr,
84 MaybeExpr,
85 Expr,
86 MaybeIncorrect,
87 FormatOpts,
88}
89
90impl FormatStrParser {
91 pub fn new(input: String) -> Self {
92 Self {
93 input: input.into(),
94 output: String::new(),
95 extracted_expressions: Vec::new(),
96 state: State::NotExpr,
97 parsed: false,
98 }
99 }
100
101 pub fn parse(&mut self) -> Result<(), ()> {
102 let mut current_expr = String::new();
103
104 let mut placeholder_id = 1;
105
106 // Count of open braces inside of an expression.
107 // We assume that user knows what they're doing, thus we treat it like a correct pattern, e.g.
108 // "{MyStruct { val_a: 0, val_b: 1 }}".
109 let mut inexpr_open_count = 0;
110
111 for chr in self.input.chars() {
112 match (self.state, chr) {
113 (State::NotExpr, '{') => {
114 self.output.push(chr);
115 self.state = State::MaybeExpr;
116 }
117 (State::NotExpr, '}') => {
118 self.output.push(chr);
119 self.state = State::MaybeIncorrect;
120 }
121 (State::NotExpr, _) => {
122 self.output.push(chr);
123 }
124 (State::MaybeIncorrect, '}') => {
125 // It's okay, we met "}}".
126 self.output.push(chr);
127 self.state = State::NotExpr;
128 }
129 (State::MaybeIncorrect, _) => {
130 // Error in the string.
131 return Err(());
132 }
133 (State::MaybeExpr, '{') => {
134 self.output.push(chr);
135 self.state = State::NotExpr;
136 }
137 (State::MaybeExpr, '}') => {
138 // This is an empty sequence '{}'. Replace it with placeholder.
139 self.output.push(chr);
140 self.extracted_expressions.push(format!("${}", placeholder_id));
141 placeholder_id += 1;
142 self.state = State::NotExpr;
143 }
144 (State::MaybeExpr, _) => {
145 current_expr.push(chr);
146 self.state = State::Expr;
147 }
148 (State::Expr, '}') => {
149 if inexpr_open_count == 0 {
150 self.output.push(chr);
151 self.extracted_expressions.push(current_expr.trim().into());
152 current_expr = String::new();
153 self.state = State::NotExpr;
154 } else {
155 // We're closing one brace met before inside of the expression.
156 current_expr.push(chr);
157 inexpr_open_count -= 1;
158 }
159 }
160 (State::Expr, ':') => {
161 if inexpr_open_count == 0 {
162 // We're outside of braces, thus assume that it's a specifier, like "{Some(value):?}"
163 self.output.push(chr);
164 self.extracted_expressions.push(current_expr.trim().into());
165 current_expr = String::new();
166 self.state = State::FormatOpts;
167 } else {
168 // We're inside of braced expression, assume that it's a struct field name/value delimeter.
169 current_expr.push(chr);
170 }
171 }
172 (State::Expr, '{') => {
173 current_expr.push(chr);
174 inexpr_open_count += 1;
175 }
176 (State::Expr, _) => {
177 current_expr.push(chr);
178 }
179 (State::FormatOpts, '}') => {
180 self.output.push(chr);
181 self.state = State::NotExpr;
182 }
183 (State::FormatOpts, _) => {
184 self.output.push(chr);
185 }
186 }
187 }
188
189 if self.state != State::NotExpr {
190 return Err(());
191 }
192
193 self.parsed = true;
194 Ok(())
195 }
196
197 pub fn into_suggestion(&self, macro_name: &str) -> String {
198 assert!(self.parsed, "Attempt to get a suggestion from not parsed expression");
199
200 let expressions_as_string = self.extracted_expressions.join(", ");
201 format!(r#"{}("{}", {})"#, macro_name, self.output, expressions_as_string)
202 }
203}
204
205#[cfg(test)]
206mod tests {
207 use super::*;
208 use expect_test::{expect, Expect};
209
210 fn check(input: &str, expect: &Expect) {
211 let mut parser = FormatStrParser::new((*input).to_owned());
212 let outcome_repr = if parser.parse().is_ok() {
213 // Parsing should be OK, expected repr is "string; expr_1, expr_2".
214 if parser.extracted_expressions.is_empty() {
215 parser.output
216 } else {
217 format!("{}; {}", parser.output, parser.extracted_expressions.join(", "))
218 }
219 } else {
220 // Parsing should fail, expected repr is "-".
221 "-".to_owned()
222 };
223
224 expect.assert_eq(&outcome_repr);
225 }
226
227 #[test]
228 fn format_str_parser() {
229 let test_vector = &[
230 ("no expressions", expect![["no expressions"]]),
231 ("{expr} is {2 + 2}", expect![["{} is {}; expr, 2 + 2"]]),
232 ("{expr:?}", expect![["{:?}; expr"]]),
233 ("{malformed", expect![["-"]]),
234 ("malformed}", expect![["-"]]),
235 ("{{correct", expect![["{{correct"]]),
236 ("correct}}", expect![["correct}}"]]),
237 ("{correct}}}", expect![["{}}}; correct"]]),
238 ("{correct}}}}}", expect![["{}}}}}; correct"]]),
239 ("{incorrect}}", expect![["-"]]),
240 ("placeholders {} {}", expect![["placeholders {} {}; $1, $2"]]),
241 ("mixed {} {2 + 2} {}", expect![["mixed {} {} {}; $1, 2 + 2, $2"]]),
242 (
243 "{SomeStruct { val_a: 0, val_b: 1 }}",
244 expect![["{}; SomeStruct { val_a: 0, val_b: 1 }"]],
245 ),
246 ("{expr:?} is {2.32f64:.5}", expect![["{:?} is {:.5}; expr, 2.32f64"]]),
247 (
248 "{SomeStruct { val_a: 0, val_b: 1 }:?}",
249 expect![["{:?}; SomeStruct { val_a: 0, val_b: 1 }"]],
250 ),
251 ("{ 2 + 2 }", expect![["{}; 2 + 2"]]),
252 ];
253
254 for (input, output) in test_vector {
255 check(input, output)
256 }
257 }
258
259 #[test]
260 fn test_into_suggestion() {
261 let test_vector = &[
262 ("println!", "{}", r#"println!("{}", $1)"#),
263 ("eprintln!", "{}", r#"eprintln!("{}", $1)"#),
264 (
265 "log::info!",
266 "{} {expr} {} {2 + 2}",
267 r#"log::info!("{} {} {} {}", $1, expr, $2, 2 + 2)"#,
268 ),
269 ("format!", "{expr:?}", r#"format!("{:?}", expr)"#),
270 ];
271
272 for (kind, input, output) in test_vector {
273 let mut parser = FormatStrParser::new((*input).to_owned());
274 parser.parse().expect("Parsing must succeed");
275
276 assert_eq!(&parser.into_suggestion(*kind), output);
277 }
278 }
279}
diff --git a/crates/completion/src/complete_qualified_path.rs b/crates/completion/src/complete_qualified_path.rs
new file mode 100644
index 000000000..80b271fdf
--- /dev/null
+++ b/crates/completion/src/complete_qualified_path.rs
@@ -0,0 +1,755 @@
1//! Completion of paths, i.e. `some::prefix::<|>`.
2
3use hir::{Adt, HasVisibility, PathResolution, ScopeDef};
4use rustc_hash::FxHashSet;
5use syntax::AstNode;
6use test_utils::mark;
7
8use crate::{CompletionContext, Completions};
9
10pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionContext) {
11 let path = match &ctx.path_qual {
12 Some(path) => path.clone(),
13 None => return,
14 };
15
16 if ctx.attribute_under_caret.is_some() || ctx.mod_declaration_under_caret.is_some() {
17 return;
18 }
19
20 let context_module = ctx.scope.module();
21
22 let resolution = match ctx.sema.resolve_path(&path) {
23 Some(res) => res,
24 None => return,
25 };
26
27 // Add associated types on type parameters and `Self`.
28 resolution.assoc_type_shorthand_candidates(ctx.db, |alias| {
29 acc.add_type_alias(ctx, alias);
30 None::<()>
31 });
32
33 match resolution {
34 PathResolution::Def(hir::ModuleDef::Module(module)) => {
35 let module_scope = module.scope(ctx.db, context_module);
36 for (name, def) in module_scope {
37 if ctx.use_item_syntax.is_some() {
38 if let ScopeDef::Unknown = def {
39 if let Some(name_ref) = ctx.name_ref_syntax.as_ref() {
40 if name_ref.syntax().text() == name.to_string().as_str() {
41 // for `use self::foo<|>`, don't suggest `foo` as a completion
42 mark::hit!(dont_complete_current_use);
43 continue;
44 }
45 }
46 }
47 }
48
49 acc.add_resolution(ctx, name.to_string(), &def);
50 }
51 }
52 PathResolution::Def(def @ hir::ModuleDef::Adt(_))
53 | PathResolution::Def(def @ hir::ModuleDef::TypeAlias(_)) => {
54 if let hir::ModuleDef::Adt(Adt::Enum(e)) = def {
55 for variant in e.variants(ctx.db) {
56 acc.add_enum_variant(ctx, variant, None);
57 }
58 }
59 let ty = match def {
60 hir::ModuleDef::Adt(adt) => adt.ty(ctx.db),
61 hir::ModuleDef::TypeAlias(a) => a.ty(ctx.db),
62 _ => unreachable!(),
63 };
64
65 // XXX: For parity with Rust bug #22519, this does not complete Ty::AssocType.
66 // (where AssocType is defined on a trait, not an inherent impl)
67
68 let krate = ctx.krate;
69 if let Some(krate) = krate {
70 let traits_in_scope = ctx.scope.traits_in_scope();
71 ty.iterate_path_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, item| {
72 if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) {
73 return None;
74 }
75 match item {
76 hir::AssocItem::Function(func) => {
77 acc.add_function(ctx, func, None);
78 }
79 hir::AssocItem::Const(ct) => acc.add_const(ctx, ct),
80 hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
81 }
82 None::<()>
83 });
84
85 // Iterate assoc types separately
86 ty.iterate_assoc_items(ctx.db, krate, |item| {
87 if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) {
88 return None;
89 }
90 match item {
91 hir::AssocItem::Function(_) | hir::AssocItem::Const(_) => {}
92 hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
93 }
94 None::<()>
95 });
96 }
97 }
98 PathResolution::Def(hir::ModuleDef::Trait(t)) => {
99 // Handles `Trait::assoc` as well as `<Ty as Trait>::assoc`.
100 for item in t.items(ctx.db) {
101 if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) {
102 continue;
103 }
104 match item {
105 hir::AssocItem::Function(func) => {
106 acc.add_function(ctx, func, None);
107 }
108 hir::AssocItem::Const(ct) => acc.add_const(ctx, ct),
109 hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
110 }
111 }
112 }
113 PathResolution::TypeParam(_) | PathResolution::SelfType(_) => {
114 if let Some(krate) = ctx.krate {
115 let ty = match resolution {
116 PathResolution::TypeParam(param) => param.ty(ctx.db),
117 PathResolution::SelfType(impl_def) => impl_def.target_ty(ctx.db),
118 _ => return,
119 };
120
121 let traits_in_scope = ctx.scope.traits_in_scope();
122 let mut seen = FxHashSet::default();
123 ty.iterate_path_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, item| {
124 if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) {
125 return None;
126 }
127
128 // We might iterate candidates of a trait multiple times here, so deduplicate
129 // them.
130 if seen.insert(item) {
131 match item {
132 hir::AssocItem::Function(func) => {
133 acc.add_function(ctx, func, None);
134 }
135 hir::AssocItem::Const(ct) => acc.add_const(ctx, ct),
136 hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
137 }
138 }
139 None::<()>
140 });
141 }
142 }
143 _ => {}
144 }
145}
146
147#[cfg(test)]
148mod tests {
149 use expect_test::{expect, Expect};
150 use test_utils::mark;
151
152 use crate::{
153 test_utils::{check_edit, completion_list},
154 CompletionKind,
155 };
156
157 fn check(ra_fixture: &str, expect: Expect) {
158 let actual = completion_list(ra_fixture, CompletionKind::Reference);
159 expect.assert_eq(&actual);
160 }
161
162 fn check_builtin(ra_fixture: &str, expect: Expect) {
163 let actual = completion_list(ra_fixture, CompletionKind::BuiltinType);
164 expect.assert_eq(&actual);
165 }
166
167 #[test]
168 fn dont_complete_current_use() {
169 mark::check!(dont_complete_current_use);
170 check(r#"use self::foo<|>;"#, expect![[""]]);
171 }
172
173 #[test]
174 fn dont_complete_current_use_in_braces_with_glob() {
175 check(
176 r#"
177mod foo { pub struct S; }
178use self::{foo::*, bar<|>};
179"#,
180 expect![[r#"
181 st S
182 md foo
183 "#]],
184 );
185 }
186
187 #[test]
188 fn dont_complete_primitive_in_use() {
189 check_builtin(r#"use self::<|>;"#, expect![[""]]);
190 }
191
192 #[test]
193 fn dont_complete_primitive_in_module_scope() {
194 check_builtin(r#"fn foo() { self::<|> }"#, expect![[""]]);
195 }
196
197 #[test]
198 fn completes_primitives() {
199 check_builtin(
200 r#"fn main() { let _: <|> = 92; }"#,
201 expect![[r#"
202 bt bool
203 bt char
204 bt f32
205 bt f64
206 bt i128
207 bt i16
208 bt i32
209 bt i64
210 bt i8
211 bt isize
212 bt str
213 bt u128
214 bt u16
215 bt u32
216 bt u64
217 bt u8
218 bt usize
219 "#]],
220 );
221 }
222
223 #[test]
224 fn completes_mod_with_same_name_as_function() {
225 check(
226 r#"
227use self::my::<|>;
228
229mod my { pub struct Bar; }
230fn my() {}
231"#,
232 expect![[r#"
233 st Bar
234 "#]],
235 );
236 }
237
238 #[test]
239 fn filters_visibility() {
240 check(
241 r#"
242use self::my::<|>;
243
244mod my {
245 struct Bar;
246 pub struct Foo;
247 pub use Bar as PublicBar;
248}
249"#,
250 expect![[r#"
251 st Foo
252 st PublicBar
253 "#]],
254 );
255 }
256
257 #[test]
258 fn completes_use_item_starting_with_self() {
259 check(
260 r#"
261use self::m::<|>;
262
263mod m { pub struct Bar; }
264"#,
265 expect![[r#"
266 st Bar
267 "#]],
268 );
269 }
270
271 #[test]
272 fn completes_use_item_starting_with_crate() {
273 check(
274 r#"
275//- /lib.rs
276mod foo;
277struct Spam;
278//- /foo.rs
279use crate::Sp<|>
280"#,
281 expect![[r#"
282 st Spam
283 md foo
284 "#]],
285 );
286 }
287
288 #[test]
289 fn completes_nested_use_tree() {
290 check(
291 r#"
292//- /lib.rs
293mod foo;
294struct Spam;
295//- /foo.rs
296use crate::{Sp<|>};
297"#,
298 expect![[r#"
299 st Spam
300 md foo
301 "#]],
302 );
303 }
304
305 #[test]
306 fn completes_deeply_nested_use_tree() {
307 check(
308 r#"
309//- /lib.rs
310mod foo;
311pub mod bar {
312 pub mod baz {
313 pub struct Spam;
314 }
315}
316//- /foo.rs
317use crate::{bar::{baz::Sp<|>}};
318"#,
319 expect![[r#"
320 st Spam
321 "#]],
322 );
323 }
324
325 #[test]
326 fn completes_enum_variant() {
327 check(
328 r#"
329enum E { Foo, Bar(i32) }
330fn foo() { let _ = E::<|> }
331"#,
332 expect![[r#"
333 ev Bar(…) (i32)
334 ev Foo ()
335 "#]],
336 );
337 }
338
339 #[test]
340 fn completes_struct_associated_items() {
341 check(
342 r#"
343//- /lib.rs
344struct S;
345
346impl S {
347 fn a() {}
348 fn b(&self) {}
349 const C: i32 = 42;
350 type T = i32;
351}
352
353fn foo() { let _ = S::<|> }
354"#,
355 expect![[r#"
356 ct C const C: i32 = 42;
357 ta T type T = i32;
358 fn a() fn a()
359 me b() fn b(&self)
360 "#]],
361 );
362 }
363
364 #[test]
365 fn associated_item_visibility() {
366 check(
367 r#"
368struct S;
369
370mod m {
371 impl super::S {
372 pub(super) fn public_method() { }
373 fn private_method() { }
374 pub(super) type PublicType = u32;
375 type PrivateType = u32;
376 pub(super) const PUBLIC_CONST: u32 = 1;
377 const PRIVATE_CONST: u32 = 1;
378 }
379}
380
381fn foo() { let _ = S::<|> }
382"#,
383 expect![[r#"
384 ct PUBLIC_CONST pub(super) const PUBLIC_CONST: u32 = 1;
385 ta PublicType pub(super) type PublicType = u32;
386 fn public_method() pub(super) fn public_method()
387 "#]],
388 );
389 }
390
391 #[test]
392 fn completes_enum_associated_method() {
393 check(
394 r#"
395enum E {};
396impl E { fn m() { } }
397
398fn foo() { let _ = E::<|> }
399 "#,
400 expect![[r#"
401 fn m() fn m()
402 "#]],
403 );
404 }
405
406 #[test]
407 fn completes_union_associated_method() {
408 check(
409 r#"
410union U {};
411impl U { fn m() { } }
412
413fn foo() { let _ = U::<|> }
414"#,
415 expect![[r#"
416 fn m() fn m()
417 "#]],
418 );
419 }
420
421 #[test]
422 fn completes_use_paths_across_crates() {
423 check(
424 r#"
425//- /main.rs crate:main deps:foo
426use foo::<|>;
427
428//- /foo/lib.rs crate:foo
429pub mod bar { pub struct S; }
430"#,
431 expect![[r#"
432 md bar
433 "#]],
434 );
435 }
436
437 #[test]
438 fn completes_trait_associated_method_1() {
439 check(
440 r#"
441trait Trait { fn m(); }
442
443fn foo() { let _ = Trait::<|> }
444"#,
445 expect![[r#"
446 fn m() fn m()
447 "#]],
448 );
449 }
450
451 #[test]
452 fn completes_trait_associated_method_2() {
453 check(
454 r#"
455trait Trait { fn m(); }
456
457struct S;
458impl Trait for S {}
459
460fn foo() { let _ = S::<|> }
461"#,
462 expect![[r#"
463 fn m() fn m()
464 "#]],
465 );
466 }
467
468 #[test]
469 fn completes_trait_associated_method_3() {
470 check(
471 r#"
472trait Trait { fn m(); }
473
474struct S;
475impl Trait for S {}
476
477fn foo() { let _ = <S as Trait>::<|> }
478"#,
479 expect![[r#"
480 fn m() fn m()
481 "#]],
482 );
483 }
484
485 #[test]
486 fn completes_ty_param_assoc_ty() {
487 check(
488 r#"
489trait Super {
490 type Ty;
491 const CONST: u8;
492 fn func() {}
493 fn method(&self) {}
494}
495
496trait Sub: Super {
497 type SubTy;
498 const C2: ();
499 fn subfunc() {}
500 fn submethod(&self) {}
501}
502
503fn foo<T: Sub>() { T::<|> }
504"#,
505 expect![[r#"
506 ct C2 const C2: ();
507 ct CONST const CONST: u8;
508 ta SubTy type SubTy;
509 ta Ty type Ty;
510 fn func() fn func()
511 me method() fn method(&self)
512 fn subfunc() fn subfunc()
513 me submethod() fn submethod(&self)
514 "#]],
515 );
516 }
517
518 #[test]
519 fn completes_self_param_assoc_ty() {
520 check(
521 r#"
522trait Super {
523 type Ty;
524 const CONST: u8 = 0;
525 fn func() {}
526 fn method(&self) {}
527}
528
529trait Sub: Super {
530 type SubTy;
531 const C2: () = ();
532 fn subfunc() {}
533 fn submethod(&self) {}
534}
535
536struct Wrap<T>(T);
537impl<T> Super for Wrap<T> {}
538impl<T> Sub for Wrap<T> {
539 fn subfunc() {
540 // Should be able to assume `Self: Sub + Super`
541 Self::<|>
542 }
543}
544"#,
545 expect![[r#"
546 ct C2 const C2: () = ();
547 ct CONST const CONST: u8 = 0;
548 ta SubTy type SubTy;
549 ta Ty type Ty;
550 fn func() fn func()
551 me method() fn method(&self)
552 fn subfunc() fn subfunc()
553 me submethod() fn submethod(&self)
554 "#]],
555 );
556 }
557
558 #[test]
559 fn completes_type_alias() {
560 check(
561 r#"
562struct S;
563impl S { fn foo() {} }
564type T = S;
565impl T { fn bar() {} }
566
567fn main() { T::<|>; }
568"#,
569 expect![[r#"
570 fn bar() fn bar()
571 fn foo() fn foo()
572 "#]],
573 );
574 }
575
576 #[test]
577 fn completes_qualified_macros() {
578 check(
579 r#"
580#[macro_export]
581macro_rules! foo { () => {} }
582
583fn main() { let _ = crate::<|> }
584 "#,
585 expect![[r##"
586 ma foo!(…) #[macro_export]
587 macro_rules! foo
588 fn main() fn main()
589 "##]],
590 );
591 }
592
593 #[test]
594 fn test_super_super_completion() {
595 check(
596 r#"
597mod a {
598 const A: usize = 0;
599 mod b {
600 const B: usize = 0;
601 mod c { use super::super::<|> }
602 }
603}
604"#,
605 expect![[r#"
606 ct A
607 md b
608 "#]],
609 );
610 }
611
612 #[test]
613 fn completes_reexported_items_under_correct_name() {
614 check(
615 r#"
616fn foo() { self::m::<|> }
617
618mod m {
619 pub use super::p::wrong_fn as right_fn;
620 pub use super::p::WRONG_CONST as RIGHT_CONST;
621 pub use super::p::WrongType as RightType;
622}
623mod p {
624 fn wrong_fn() {}
625 const WRONG_CONST: u32 = 1;
626 struct WrongType {};
627}
628"#,
629 expect![[r#"
630 ct RIGHT_CONST
631 st RightType
632 fn right_fn() fn wrong_fn()
633 "#]],
634 );
635
636 check_edit(
637 "RightType",
638 r#"
639fn foo() { self::m::<|> }
640
641mod m {
642 pub use super::p::wrong_fn as right_fn;
643 pub use super::p::WRONG_CONST as RIGHT_CONST;
644 pub use super::p::WrongType as RightType;
645}
646mod p {
647 fn wrong_fn() {}
648 const WRONG_CONST: u32 = 1;
649 struct WrongType {};
650}
651"#,
652 r#"
653fn foo() { self::m::RightType }
654
655mod m {
656 pub use super::p::wrong_fn as right_fn;
657 pub use super::p::WRONG_CONST as RIGHT_CONST;
658 pub use super::p::WrongType as RightType;
659}
660mod p {
661 fn wrong_fn() {}
662 const WRONG_CONST: u32 = 1;
663 struct WrongType {};
664}
665"#,
666 );
667 }
668
669 #[test]
670 fn completes_in_simple_macro_call() {
671 check(
672 r#"
673macro_rules! m { ($e:expr) => { $e } }
674fn main() { m!(self::f<|>); }
675fn foo() {}
676"#,
677 expect![[r#"
678 fn foo() fn foo()
679 fn main() fn main()
680 "#]],
681 );
682 }
683
684 #[test]
685 fn function_mod_share_name() {
686 check(
687 r#"
688fn foo() { self::m::<|> }
689
690mod m {
691 pub mod z {}
692 pub fn z() {}
693}
694"#,
695 expect![[r#"
696 md z
697 fn z() pub fn z()
698 "#]],
699 );
700 }
701
702 #[test]
703 fn completes_hashmap_new() {
704 check(
705 r#"
706struct RandomState;
707struct HashMap<K, V, S = RandomState> {}
708
709impl<K, V> HashMap<K, V, RandomState> {
710 pub fn new() -> HashMap<K, V, RandomState> { }
711}
712fn foo() {
713 HashMap::<|>
714}
715"#,
716 expect![[r#"
717 fn new() pub fn new() -> HashMap<K, V, RandomState>
718 "#]],
719 );
720 }
721
722 #[test]
723 fn dont_complete_attr() {
724 check(
725 r#"
726mod foo { pub struct Foo; }
727#[foo::<|>]
728fn f() {}
729"#,
730 expect![[""]],
731 );
732 }
733
734 #[test]
735 fn completes_function() {
736 check(
737 r#"
738fn foo(
739 a: i32,
740 b: i32
741) {
742
743}
744
745fn main() {
746 fo<|>
747}
748"#,
749 expect![[r#"
750 fn foo(…) fn foo(a: i32, b: i32)
751 fn main() fn main()
752 "#]],
753 );
754 }
755}
diff --git a/crates/completion/src/complete_record.rs b/crates/completion/src/complete_record.rs
new file mode 100644
index 000000000..129ddc055
--- /dev/null
+++ b/crates/completion/src/complete_record.rs
@@ -0,0 +1,226 @@
1//! Complete fields in record literals and patterns.
2use crate::{CompletionContext, Completions};
3
4pub(super) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
5 let missing_fields = match (ctx.record_pat_syntax.as_ref(), ctx.record_lit_syntax.as_ref()) {
6 (None, None) => return None,
7 (Some(_), Some(_)) => unreachable!("A record cannot be both a literal and a pattern"),
8 (Some(record_pat), _) => ctx.sema.record_pattern_missing_fields(record_pat),
9 (_, Some(record_lit)) => ctx.sema.record_literal_missing_fields(record_lit),
10 };
11
12 for (field, ty) in missing_fields {
13 acc.add_field(ctx, field, &ty)
14 }
15
16 Some(())
17}
18
19#[cfg(test)]
20mod tests {
21 use expect_test::{expect, Expect};
22
23 use crate::{test_utils::completion_list, CompletionKind};
24
25 fn check(ra_fixture: &str, expect: Expect) {
26 let actual = completion_list(ra_fixture, CompletionKind::Reference);
27 expect.assert_eq(&actual);
28 }
29
30 #[test]
31 fn test_record_pattern_field() {
32 check(
33 r#"
34struct S { foo: u32 }
35
36fn process(f: S) {
37 match f {
38 S { f<|>: 92 } => (),
39 }
40}
41"#,
42 expect![[r#"
43 fd foo u32
44 "#]],
45 );
46 }
47
48 #[test]
49 fn test_record_pattern_enum_variant() {
50 check(
51 r#"
52enum E { S { foo: u32, bar: () } }
53
54fn process(e: E) {
55 match e {
56 E::S { <|> } => (),
57 }
58}
59"#,
60 expect![[r#"
61 fd bar ()
62 fd foo u32
63 "#]],
64 );
65 }
66
67 #[test]
68 fn test_record_pattern_field_in_simple_macro() {
69 check(
70 r"
71macro_rules! m { ($e:expr) => { $e } }
72struct S { foo: u32 }
73
74fn process(f: S) {
75 m!(match f {
76 S { f<|>: 92 } => (),
77 })
78}
79",
80 expect![[r#"
81 fd foo u32
82 "#]],
83 );
84 }
85
86 #[test]
87 fn only_missing_fields_are_completed_in_destruct_pats() {
88 check(
89 r#"
90struct S {
91 foo1: u32, foo2: u32,
92 bar: u32, baz: u32,
93}
94
95fn main() {
96 let s = S {
97 foo1: 1, foo2: 2,
98 bar: 3, baz: 4,
99 };
100 if let S { foo1, foo2: a, <|> } = s {}
101}
102"#,
103 expect![[r#"
104 fd bar u32
105 fd baz u32
106 "#]],
107 );
108 }
109
110 #[test]
111 fn test_record_literal_field() {
112 check(
113 r#"
114struct A { the_field: u32 }
115fn foo() {
116 A { the<|> }
117}
118"#,
119 expect![[r#"
120 fd the_field u32
121 "#]],
122 );
123 }
124
125 #[test]
126 fn test_record_literal_enum_variant() {
127 check(
128 r#"
129enum E { A { a: u32 } }
130fn foo() {
131 let _ = E::A { <|> }
132}
133"#,
134 expect![[r#"
135 fd a u32
136 "#]],
137 );
138 }
139
140 #[test]
141 fn test_record_literal_two_structs() {
142 check(
143 r#"
144struct A { a: u32 }
145struct B { b: u32 }
146
147fn foo() {
148 let _: A = B { <|> }
149}
150"#,
151 expect![[r#"
152 fd b u32
153 "#]],
154 );
155 }
156
157 #[test]
158 fn test_record_literal_generic_struct() {
159 check(
160 r#"
161struct A<T> { a: T }
162
163fn foo() {
164 let _: A<u32> = A { <|> }
165}
166"#,
167 expect![[r#"
168 fd a u32
169 "#]],
170 );
171 }
172
173 #[test]
174 fn test_record_literal_field_in_simple_macro() {
175 check(
176 r#"
177macro_rules! m { ($e:expr) => { $e } }
178struct A { the_field: u32 }
179fn foo() {
180 m!(A { the<|> })
181}
182"#,
183 expect![[r#"
184 fd the_field u32
185 "#]],
186 );
187 }
188
189 #[test]
190 fn only_missing_fields_are_completed() {
191 check(
192 r#"
193struct S {
194 foo1: u32, foo2: u32,
195 bar: u32, baz: u32,
196}
197
198fn main() {
199 let foo1 = 1;
200 let s = S { foo1, foo2: 5, <|> }
201}
202"#,
203 expect![[r#"
204 fd bar u32
205 fd baz u32
206 "#]],
207 );
208 }
209
210 #[test]
211 fn completes_functional_update() {
212 check(
213 r#"
214struct S { foo1: u32, foo2: u32 }
215
216fn main() {
217 let foo1 = 1;
218 let s = S { foo1, <|> .. loop {} }
219}
220"#,
221 expect![[r#"
222 fd foo2 u32
223 "#]],
224 );
225 }
226}
diff --git a/crates/completion/src/complete_snippet.rs b/crates/completion/src/complete_snippet.rs
new file mode 100644
index 000000000..06096722b
--- /dev/null
+++ b/crates/completion/src/complete_snippet.rs
@@ -0,0 +1,114 @@
1//! This file provides snippet completions, like `pd` => `eprintln!(...)`.
2
3use crate::{
4 completion_config::SnippetCap, completion_item::Builder, CompletionContext, CompletionItem,
5 CompletionItemKind, CompletionKind, Completions,
6};
7
8fn snippet(ctx: &CompletionContext, cap: SnippetCap, label: &str, snippet: &str) -> Builder {
9 CompletionItem::new(CompletionKind::Snippet, ctx.source_range(), label)
10 .insert_snippet(cap, snippet)
11 .kind(CompletionItemKind::Snippet)
12}
13
14pub(super) fn complete_expr_snippet(acc: &mut Completions, ctx: &CompletionContext) {
15 if !(ctx.is_trivial_path && ctx.function_syntax.is_some()) {
16 return;
17 }
18 let cap = match ctx.config.snippet_cap {
19 Some(it) => it,
20 None => return,
21 };
22
23 snippet(ctx, cap, "pd", "eprintln!(\"$0 = {:?}\", $0);").add_to(acc);
24 snippet(ctx, cap, "ppd", "eprintln!(\"$0 = {:#?}\", $0);").add_to(acc);
25}
26
27pub(super) fn complete_item_snippet(acc: &mut Completions, ctx: &CompletionContext) {
28 if !ctx.is_new_item {
29 return;
30 }
31 let cap = match ctx.config.snippet_cap {
32 Some(it) => it,
33 None => return,
34 };
35
36 snippet(
37 ctx,
38 cap,
39 "tmod (Test module)",
40 "\
41#[cfg(test)]
42mod tests {
43 use super::*;
44
45 #[test]
46 fn ${1:test_name}() {
47 $0
48 }
49}",
50 )
51 .lookup_by("tmod")
52 .add_to(acc);
53
54 snippet(
55 ctx,
56 cap,
57 "tfn (Test function)",
58 "\
59#[test]
60fn ${1:feature}() {
61 $0
62}",
63 )
64 .lookup_by("tfn")
65 .add_to(acc);
66
67 snippet(ctx, cap, "macro_rules", "macro_rules! $1 {\n\t($2) => {\n\t\t$0\n\t};\n}").add_to(acc);
68}
69
70#[cfg(test)]
71mod tests {
72 use expect_test::{expect, Expect};
73
74 use crate::{test_utils::completion_list, CompletionKind};
75
76 fn check(ra_fixture: &str, expect: Expect) {
77 let actual = completion_list(ra_fixture, CompletionKind::Snippet);
78 expect.assert_eq(&actual)
79 }
80
81 #[test]
82 fn completes_snippets_in_expressions() {
83 check(
84 r#"fn foo(x: i32) { <|> }"#,
85 expect![[r#"
86 sn pd
87 sn ppd
88 "#]],
89 );
90 }
91
92 #[test]
93 fn should_not_complete_snippets_in_path() {
94 check(r#"fn foo(x: i32) { ::foo<|> }"#, expect![[""]]);
95 check(r#"fn foo(x: i32) { ::<|> }"#, expect![[""]]);
96 }
97
98 #[test]
99 fn completes_snippets_in_items() {
100 check(
101 r#"
102#[cfg(test)]
103mod tests {
104 <|>
105}
106"#,
107 expect![[r#"
108 sn macro_rules
109 sn tfn (Test function)
110 sn tmod (Test module)
111 "#]],
112 )
113 }
114}
diff --git a/crates/completion/src/complete_trait_impl.rs b/crates/completion/src/complete_trait_impl.rs
new file mode 100644
index 000000000..c06af99e2
--- /dev/null
+++ b/crates/completion/src/complete_trait_impl.rs
@@ -0,0 +1,736 @@
1//! Completion for associated items in a trait implementation.
2//!
3//! This module adds the completion items related to implementing associated
4//! items within a `impl Trait for Struct` block. The current context node
5//! must be within either a `FN`, `TYPE_ALIAS`, or `CONST` node
6//! and an direct child of an `IMPL`.
7//!
8//! # Examples
9//!
10//! Considering the following trait `impl`:
11//!
12//! ```ignore
13//! trait SomeTrait {
14//! fn foo();
15//! }
16//!
17//! impl SomeTrait for () {
18//! fn f<|>
19//! }
20//! ```
21//!
22//! may result in the completion of the following method:
23//!
24//! ```ignore
25//! # trait SomeTrait {
26//! # fn foo();
27//! # }
28//!
29//! impl SomeTrait for () {
30//! fn foo() {}<|>
31//! }
32//! ```
33
34use assists::utils::get_missing_assoc_items;
35use hir::{self, HasAttrs, HasSource};
36use syntax::{
37 ast::{self, edit, Impl},
38 display::function_declaration,
39 AstNode, SyntaxKind, SyntaxNode, TextRange, T,
40};
41use text_edit::TextEdit;
42
43use crate::{
44 CompletionContext,
45 CompletionItem,
46 CompletionItemKind,
47 CompletionKind,
48 Completions,
49 // display::function_declaration,
50};
51
52#[derive(Debug, PartialEq, Eq)]
53enum ImplCompletionKind {
54 All,
55 Fn,
56 TypeAlias,
57 Const,
58}
59
60pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext) {
61 if let Some((kind, trigger, impl_def)) = completion_match(ctx) {
62 get_missing_assoc_items(&ctx.sema, &impl_def).into_iter().for_each(|item| match item {
63 hir::AssocItem::Function(fn_item)
64 if kind == ImplCompletionKind::All || kind == ImplCompletionKind::Fn =>
65 {
66 add_function_impl(&trigger, acc, ctx, fn_item)
67 }
68 hir::AssocItem::TypeAlias(type_item)
69 if kind == ImplCompletionKind::All || kind == ImplCompletionKind::TypeAlias =>
70 {
71 add_type_alias_impl(&trigger, acc, ctx, type_item)
72 }
73 hir::AssocItem::Const(const_item)
74 if kind == ImplCompletionKind::All || kind == ImplCompletionKind::Const =>
75 {
76 add_const_impl(&trigger, acc, ctx, const_item)
77 }
78 _ => {}
79 });
80 }
81}
82
83fn completion_match(ctx: &CompletionContext) -> Option<(ImplCompletionKind, SyntaxNode, Impl)> {
84 let mut token = ctx.token.clone();
85 // For keywork without name like `impl .. { fn <|> }`, the current position is inside
86 // the whitespace token, which is outside `FN` syntax node.
87 // We need to follow the previous token in this case.
88 if token.kind() == SyntaxKind::WHITESPACE {
89 token = token.prev_token()?;
90 }
91
92 let impl_item_offset = match token.kind() {
93 // `impl .. { const <|> }`
94 // ERROR 0
95 // CONST_KW <- *
96 SyntaxKind::CONST_KW => 0,
97 // `impl .. { fn/type <|> }`
98 // FN/TYPE_ALIAS 0
99 // FN_KW <- *
100 SyntaxKind::FN_KW | SyntaxKind::TYPE_KW => 0,
101 // `impl .. { fn/type/const foo<|> }`
102 // FN/TYPE_ALIAS/CONST 1
103 // NAME 0
104 // IDENT <- *
105 SyntaxKind::IDENT if token.parent().kind() == SyntaxKind::NAME => 1,
106 // `impl .. { foo<|> }`
107 // MACRO_CALL 3
108 // PATH 2
109 // PATH_SEGMENT 1
110 // NAME_REF 0
111 // IDENT <- *
112 SyntaxKind::IDENT if token.parent().kind() == SyntaxKind::NAME_REF => 3,
113 _ => return None,
114 };
115
116 let impl_item = token.ancestors().nth(impl_item_offset)?;
117 // Must directly belong to an impl block.
118 // IMPL
119 // ASSOC_ITEM_LIST
120 // <item>
121 let impl_def = ast::Impl::cast(impl_item.parent()?.parent()?)?;
122 let kind = match impl_item.kind() {
123 // `impl ... { const <|> fn/type/const }`
124 _ if token.kind() == SyntaxKind::CONST_KW => ImplCompletionKind::Const,
125 SyntaxKind::CONST | SyntaxKind::ERROR => ImplCompletionKind::Const,
126 SyntaxKind::TYPE_ALIAS => ImplCompletionKind::TypeAlias,
127 SyntaxKind::FN => ImplCompletionKind::Fn,
128 SyntaxKind::MACRO_CALL => ImplCompletionKind::All,
129 _ => return None,
130 };
131 Some((kind, impl_item, impl_def))
132}
133
134fn add_function_impl(
135 fn_def_node: &SyntaxNode,
136 acc: &mut Completions,
137 ctx: &CompletionContext,
138 func: hir::Function,
139) {
140 let fn_name = func.name(ctx.db).to_string();
141
142 let label = if func.params(ctx.db).is_empty() {
143 format!("fn {}()", fn_name)
144 } else {
145 format!("fn {}(..)", fn_name)
146 };
147
148 let builder = CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label)
149 .lookup_by(fn_name)
150 .set_documentation(func.docs(ctx.db));
151
152 let completion_kind = if func.self_param(ctx.db).is_some() {
153 CompletionItemKind::Method
154 } else {
155 CompletionItemKind::Function
156 };
157 let range = TextRange::new(fn_def_node.text_range().start(), ctx.source_range().end());
158
159 let function_decl = function_declaration(&func.source(ctx.db).value);
160 match ctx.config.snippet_cap {
161 Some(cap) => {
162 let snippet = format!("{} {{\n $0\n}}", function_decl);
163 builder.snippet_edit(cap, TextEdit::replace(range, snippet))
164 }
165 None => {
166 let header = format!("{} {{", function_decl);
167 builder.text_edit(TextEdit::replace(range, header))
168 }
169 }
170 .kind(completion_kind)
171 .add_to(acc);
172}
173
174fn add_type_alias_impl(
175 type_def_node: &SyntaxNode,
176 acc: &mut Completions,
177 ctx: &CompletionContext,
178 type_alias: hir::TypeAlias,
179) {
180 let alias_name = type_alias.name(ctx.db).to_string();
181
182 let snippet = format!("type {} = ", alias_name);
183
184 let range = TextRange::new(type_def_node.text_range().start(), ctx.source_range().end());
185
186 CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone())
187 .text_edit(TextEdit::replace(range, snippet))
188 .lookup_by(alias_name)
189 .kind(CompletionItemKind::TypeAlias)
190 .set_documentation(type_alias.docs(ctx.db))
191 .add_to(acc);
192}
193
194fn add_const_impl(
195 const_def_node: &SyntaxNode,
196 acc: &mut Completions,
197 ctx: &CompletionContext,
198 const_: hir::Const,
199) {
200 let const_name = const_.name(ctx.db).map(|n| n.to_string());
201
202 if let Some(const_name) = const_name {
203 let snippet = make_const_compl_syntax(&const_.source(ctx.db).value);
204
205 let range = TextRange::new(const_def_node.text_range().start(), ctx.source_range().end());
206
207 CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone())
208 .text_edit(TextEdit::replace(range, snippet))
209 .lookup_by(const_name)
210 .kind(CompletionItemKind::Const)
211 .set_documentation(const_.docs(ctx.db))
212 .add_to(acc);
213 }
214}
215
216fn make_const_compl_syntax(const_: &ast::Const) -> String {
217 let const_ = edit::remove_attrs_and_docs(const_);
218
219 let const_start = const_.syntax().text_range().start();
220 let const_end = const_.syntax().text_range().end();
221
222 let start =
223 const_.syntax().first_child_or_token().map_or(const_start, |f| f.text_range().start());
224
225 let end = const_
226 .syntax()
227 .children_with_tokens()
228 .find(|s| s.kind() == T![;] || s.kind() == T![=])
229 .map_or(const_end, |f| f.text_range().start());
230
231 let len = end - start;
232 let range = TextRange::new(0.into(), len);
233
234 let syntax = const_.syntax().text().slice(range).to_string();
235
236 format!("{} = ", syntax.trim_end())
237}
238
239#[cfg(test)]
240mod tests {
241 use expect_test::{expect, Expect};
242
243 use crate::{
244 test_utils::{check_edit, completion_list},
245 CompletionKind,
246 };
247
248 fn check(ra_fixture: &str, expect: Expect) {
249 let actual = completion_list(ra_fixture, CompletionKind::Magic);
250 expect.assert_eq(&actual)
251 }
252
253 #[test]
254 fn name_ref_function_type_const() {
255 check(
256 r#"
257trait Test {
258 type TestType;
259 const TEST_CONST: u16;
260 fn test();
261}
262struct T;
263
264impl Test for T {
265 t<|>
266}
267"#,
268 expect![["
269ct const TEST_CONST: u16 = \n\
270fn fn test()
271ta type TestType = \n\
272 "]],
273 );
274 }
275
276 #[test]
277 fn no_completion_inside_fn() {
278 check(
279 r"
280trait Test { fn test(); fn test2(); }
281struct T;
282
283impl Test for T {
284 fn test() {
285 t<|>
286 }
287}
288",
289 expect![[""]],
290 );
291
292 check(
293 r"
294trait Test { fn test(); fn test2(); }
295struct T;
296
297impl Test for T {
298 fn test() {
299 fn t<|>
300 }
301}
302",
303 expect![[""]],
304 );
305
306 check(
307 r"
308trait Test { fn test(); fn test2(); }
309struct T;
310
311impl Test for T {
312 fn test() {
313 fn <|>
314 }
315}
316",
317 expect![[""]],
318 );
319
320 // https://github.com/rust-analyzer/rust-analyzer/pull/5976#issuecomment-692332191
321 check(
322 r"
323trait Test { fn test(); fn test2(); }
324struct T;
325
326impl Test for T {
327 fn test() {
328 foo.<|>
329 }
330}
331",
332 expect![[""]],
333 );
334
335 check(
336 r"
337trait Test { fn test(_: i32); fn test2(); }
338struct T;
339
340impl Test for T {
341 fn test(t<|>)
342}
343",
344 expect![[""]],
345 );
346
347 check(
348 r"
349trait Test { fn test(_: fn()); fn test2(); }
350struct T;
351
352impl Test for T {
353 fn test(f: fn <|>)
354}
355",
356 expect![[""]],
357 );
358 }
359
360 #[test]
361 fn no_completion_inside_const() {
362 check(
363 r"
364trait Test { const TEST: fn(); const TEST2: u32; type Test; fn test(); }
365struct T;
366
367impl Test for T {
368 const TEST: fn <|>
369}
370",
371 expect![[""]],
372 );
373
374 check(
375 r"
376trait Test { const TEST: u32; const TEST2: u32; type Test; fn test(); }
377struct T;
378
379impl Test for T {
380 const TEST: T<|>
381}
382",
383 expect![[""]],
384 );
385
386 check(
387 r"
388trait Test { const TEST: u32; const TEST2: u32; type Test; fn test(); }
389struct T;
390
391impl Test for T {
392 const TEST: u32 = f<|>
393}
394",
395 expect![[""]],
396 );
397
398 check(
399 r"
400trait Test { const TEST: u32; const TEST2: u32; type Test; fn test(); }
401struct T;
402
403impl Test for T {
404 const TEST: u32 = {
405 t<|>
406 };
407}
408",
409 expect![[""]],
410 );
411
412 check(
413 r"
414trait Test { const TEST: u32; const TEST2: u32; type Test; fn test(); }
415struct T;
416
417impl Test for T {
418 const TEST: u32 = {
419 fn <|>
420 };
421}
422",
423 expect![[""]],
424 );
425
426 check(
427 r"
428trait Test { const TEST: u32; const TEST2: u32; type Test; fn test(); }
429struct T;
430
431impl Test for T {
432 const TEST: u32 = {
433 fn t<|>
434 };
435}
436",
437 expect![[""]],
438 );
439 }
440
441 #[test]
442 fn no_completion_inside_type() {
443 check(
444 r"
445trait Test { type Test; type Test2; fn test(); }
446struct T;
447
448impl Test for T {
449 type Test = T<|>;
450}
451",
452 expect![[""]],
453 );
454
455 check(
456 r"
457trait Test { type Test; type Test2; fn test(); }
458struct T;
459
460impl Test for T {
461 type Test = fn <|>;
462}
463",
464 expect![[""]],
465 );
466 }
467
468 #[test]
469 fn name_ref_single_function() {
470 check_edit(
471 "test",
472 r#"
473trait Test {
474 fn test();
475}
476struct T;
477
478impl Test for T {
479 t<|>
480}
481"#,
482 r#"
483trait Test {
484 fn test();
485}
486struct T;
487
488impl Test for T {
489 fn test() {
490 $0
491}
492}
493"#,
494 );
495 }
496
497 #[test]
498 fn single_function() {
499 check_edit(
500 "test",
501 r#"
502trait Test {
503 fn test();
504}
505struct T;
506
507impl Test for T {
508 fn t<|>
509}
510"#,
511 r#"
512trait Test {
513 fn test();
514}
515struct T;
516
517impl Test for T {
518 fn test() {
519 $0
520}
521}
522"#,
523 );
524 }
525
526 #[test]
527 fn hide_implemented_fn() {
528 check(
529 r#"
530trait Test {
531 fn foo();
532 fn foo_bar();
533}
534struct T;
535
536impl Test for T {
537 fn foo() {}
538 fn f<|>
539}
540"#,
541 expect![[r#"
542 fn fn foo_bar()
543 "#]],
544 );
545 }
546
547 #[test]
548 fn generic_fn() {
549 check_edit(
550 "foo",
551 r#"
552trait Test {
553 fn foo<T>();
554}
555struct T;
556
557impl Test for T {
558 fn f<|>
559}
560"#,
561 r#"
562trait Test {
563 fn foo<T>();
564}
565struct T;
566
567impl Test for T {
568 fn foo<T>() {
569 $0
570}
571}
572"#,
573 );
574 check_edit(
575 "foo",
576 r#"
577trait Test {
578 fn foo<T>() where T: Into<String>;
579}
580struct T;
581
582impl Test for T {
583 fn f<|>
584}
585"#,
586 r#"
587trait Test {
588 fn foo<T>() where T: Into<String>;
589}
590struct T;
591
592impl Test for T {
593 fn foo<T>()
594where T: Into<String> {
595 $0
596}
597}
598"#,
599 );
600 }
601
602 #[test]
603 fn associated_type() {
604 check_edit(
605 "SomeType",
606 r#"
607trait Test {
608 type SomeType;
609}
610
611impl Test for () {
612 type S<|>
613}
614"#,
615 "
616trait Test {
617 type SomeType;
618}
619
620impl Test for () {
621 type SomeType = \n\
622}
623",
624 );
625 }
626
627 #[test]
628 fn associated_const() {
629 check_edit(
630 "SOME_CONST",
631 r#"
632trait Test {
633 const SOME_CONST: u16;
634}
635
636impl Test for () {
637 const S<|>
638}
639"#,
640 "
641trait Test {
642 const SOME_CONST: u16;
643}
644
645impl Test for () {
646 const SOME_CONST: u16 = \n\
647}
648",
649 );
650
651 check_edit(
652 "SOME_CONST",
653 r#"
654trait Test {
655 const SOME_CONST: u16 = 92;
656}
657
658impl Test for () {
659 const S<|>
660}
661"#,
662 "
663trait Test {
664 const SOME_CONST: u16 = 92;
665}
666
667impl Test for () {
668 const SOME_CONST: u16 = \n\
669}
670",
671 );
672 }
673
674 #[test]
675 fn complete_without_name() {
676 let test = |completion: &str, hint: &str, completed: &str, next_sibling: &str| {
677 println!(
678 "completion='{}', hint='{}', next_sibling='{}'",
679 completion, hint, next_sibling
680 );
681
682 check_edit(
683 completion,
684 &format!(
685 r#"
686trait Test {{
687 type Foo;
688 const CONST: u16;
689 fn bar();
690}}
691struct T;
692
693impl Test for T {{
694 {}
695 {}
696}}
697"#,
698 hint, next_sibling
699 ),
700 &format!(
701 r#"
702trait Test {{
703 type Foo;
704 const CONST: u16;
705 fn bar();
706}}
707struct T;
708
709impl Test for T {{
710 {}
711 {}
712}}
713"#,
714 completed, next_sibling
715 ),
716 )
717 };
718
719 // Enumerate some possible next siblings.
720 for next_sibling in &[
721 "",
722 "fn other_fn() {}", // `const <|> fn` -> `const fn`
723 "type OtherType = i32;",
724 "const OTHER_CONST: i32 = 0;",
725 "async fn other_fn() {}",
726 "unsafe fn other_fn() {}",
727 "default fn other_fn() {}",
728 "default type OtherType = i32;",
729 "default const OTHER_CONST: i32 = 0;",
730 ] {
731 test("bar", "fn <|>", "fn bar() {\n $0\n}", next_sibling);
732 test("Foo", "type <|>", "type Foo = ", next_sibling);
733 test("CONST", "const <|>", "const CONST: u16 = ", next_sibling);
734 }
735 }
736}
diff --git a/crates/completion/src/complete_unqualified_path.rs b/crates/completion/src/complete_unqualified_path.rs
new file mode 100644
index 000000000..5464a160d
--- /dev/null
+++ b/crates/completion/src/complete_unqualified_path.rs
@@ -0,0 +1,679 @@
1//! Completion of names from the current scope, e.g. locals and imported items.
2
3use hir::{Adt, ModuleDef, ScopeDef, Type};
4use syntax::AstNode;
5use test_utils::mark;
6
7use crate::{CompletionContext, Completions};
8
9pub(super) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionContext) {
10 if !(ctx.is_trivial_path || ctx.is_pat_binding_or_const) {
11 return;
12 }
13 if ctx.record_lit_syntax.is_some()
14 || ctx.record_pat_syntax.is_some()
15 || ctx.attribute_under_caret.is_some()
16 || ctx.mod_declaration_under_caret.is_some()
17 {
18 return;
19 }
20
21 if let Some(ty) = &ctx.expected_type {
22 complete_enum_variants(acc, ctx, ty);
23 }
24
25 if ctx.is_pat_binding_or_const {
26 return;
27 }
28
29 ctx.scope.process_all_names(&mut |name, res| {
30 if ctx.use_item_syntax.is_some() {
31 if let (ScopeDef::Unknown, Some(name_ref)) = (&res, &ctx.name_ref_syntax) {
32 if name_ref.syntax().text() == name.to_string().as_str() {
33 mark::hit!(self_fulfilling_completion);
34 return;
35 }
36 }
37 }
38 acc.add_resolution(ctx, name.to_string(), &res)
39 });
40}
41
42fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &Type) {
43 if let Some(Adt::Enum(enum_data)) = ty.as_adt() {
44 let variants = enum_data.variants(ctx.db);
45
46 let module = if let Some(module) = ctx.scope.module() {
47 // Compute path from the completion site if available.
48 module
49 } else {
50 // Otherwise fall back to the enum's definition site.
51 enum_data.module(ctx.db)
52 };
53
54 for variant in variants {
55 if let Some(path) = module.find_use_path(ctx.db, ModuleDef::from(variant)) {
56 // Variants with trivial paths are already added by the existing completion logic,
57 // so we should avoid adding these twice
58 if path.segments.len() > 1 {
59 acc.add_qualified_enum_variant(ctx, variant, path);
60 }
61 }
62 }
63 }
64}
65
66#[cfg(test)]
67mod tests {
68 use expect_test::{expect, Expect};
69 use test_utils::mark;
70
71 use crate::{
72 test_utils::{check_edit, completion_list},
73 CompletionKind,
74 };
75
76 fn check(ra_fixture: &str, expect: Expect) {
77 let actual = completion_list(ra_fixture, CompletionKind::Reference);
78 expect.assert_eq(&actual)
79 }
80
81 #[test]
82 fn self_fulfilling_completion() {
83 mark::check!(self_fulfilling_completion);
84 check(
85 r#"
86use foo<|>
87use std::collections;
88"#,
89 expect![[r#"
90 ?? collections
91 "#]],
92 );
93 }
94
95 #[test]
96 fn bind_pat_and_path_ignore_at() {
97 check(
98 r#"
99enum Enum { A, B }
100fn quux(x: Option<Enum>) {
101 match x {
102 None => (),
103 Some(en<|> @ Enum::A) => (),
104 }
105}
106"#,
107 expect![[""]],
108 );
109 }
110
111 #[test]
112 fn bind_pat_and_path_ignore_ref() {
113 check(
114 r#"
115enum Enum { A, B }
116fn quux(x: Option<Enum>) {
117 match x {
118 None => (),
119 Some(ref en<|>) => (),
120 }
121}
122"#,
123 expect![[""]],
124 );
125 }
126
127 #[test]
128 fn bind_pat_and_path() {
129 check(
130 r#"
131enum Enum { A, B }
132fn quux(x: Option<Enum>) {
133 match x {
134 None => (),
135 Some(En<|>) => (),
136 }
137}
138"#,
139 expect![[r#"
140 en Enum
141 "#]],
142 );
143 }
144
145 #[test]
146 fn completes_bindings_from_let() {
147 check(
148 r#"
149fn quux(x: i32) {
150 let y = 92;
151 1 + <|>;
152 let z = ();
153}
154"#,
155 expect![[r#"
156 fn quux(…) fn quux(x: i32)
157 bn x i32
158 bn y i32
159 "#]],
160 );
161 }
162
163 #[test]
164 fn completes_bindings_from_if_let() {
165 check(
166 r#"
167fn quux() {
168 if let Some(x) = foo() {
169 let y = 92;
170 };
171 if let Some(a) = bar() {
172 let b = 62;
173 1 + <|>
174 }
175}
176"#,
177 expect![[r#"
178 bn a
179 bn b i32
180 fn quux() fn quux()
181 "#]],
182 );
183 }
184
185 #[test]
186 fn completes_bindings_from_for() {
187 check(
188 r#"
189fn quux() {
190 for x in &[1, 2, 3] { <|> }
191}
192"#,
193 expect![[r#"
194 fn quux() fn quux()
195 bn x
196 "#]],
197 );
198 }
199
200 #[test]
201 fn completes_if_prefix_is_keyword() {
202 mark::check!(completes_if_prefix_is_keyword);
203 check_edit(
204 "wherewolf",
205 r#"
206fn main() {
207 let wherewolf = 92;
208 drop(where<|>)
209}
210"#,
211 r#"
212fn main() {
213 let wherewolf = 92;
214 drop(wherewolf)
215}
216"#,
217 )
218 }
219
220 #[test]
221 fn completes_generic_params() {
222 check(
223 r#"fn quux<T>() { <|> }"#,
224 expect![[r#"
225 tp T
226 fn quux() fn quux<T>()
227 "#]],
228 );
229 }
230
231 #[test]
232 fn completes_generic_params_in_struct() {
233 check(
234 r#"struct S<T> { x: <|>}"#,
235 expect![[r#"
236 st S<…>
237 tp Self
238 tp T
239 "#]],
240 );
241 }
242
243 #[test]
244 fn completes_self_in_enum() {
245 check(
246 r#"enum X { Y(<|>) }"#,
247 expect![[r#"
248 tp Self
249 en X
250 "#]],
251 );
252 }
253
254 #[test]
255 fn completes_module_items() {
256 check(
257 r#"
258struct S;
259enum E {}
260fn quux() { <|> }
261"#,
262 expect![[r#"
263 en E
264 st S
265 fn quux() fn quux()
266 "#]],
267 );
268 }
269
270 /// Regression test for issue #6091.
271 #[test]
272 fn correctly_completes_module_items_prefixed_with_underscore() {
273 check_edit(
274 "_alpha",
275 r#"
276fn main() {
277 _<|>
278}
279fn _alpha() {}
280"#,
281 r#"
282fn main() {
283 _alpha()$0
284}
285fn _alpha() {}
286"#,
287 )
288 }
289
290 #[test]
291 fn completes_extern_prelude() {
292 check(
293 r#"
294//- /lib.rs crate:main deps:other_crate
295use <|>;
296
297//- /other_crate/lib.rs crate:other_crate
298// nothing here
299"#,
300 expect![[r#"
301 md other_crate
302 "#]],
303 );
304 }
305
306 #[test]
307 fn completes_module_items_in_nested_modules() {
308 check(
309 r#"
310struct Foo;
311mod m {
312 struct Bar;
313 fn quux() { <|> }
314}
315"#,
316 expect![[r#"
317 st Bar
318 fn quux() fn quux()
319 "#]],
320 );
321 }
322
323 #[test]
324 fn completes_return_type() {
325 check(
326 r#"
327struct Foo;
328fn x() -> <|>
329"#,
330 expect![[r#"
331 st Foo
332 fn x() fn x()
333 "#]],
334 );
335 }
336
337 #[test]
338 fn dont_show_both_completions_for_shadowing() {
339 check(
340 r#"
341fn foo() {
342 let bar = 92;
343 {
344 let bar = 62;
345 drop(<|>)
346 }
347}
348"#,
349 // FIXME: should be only one bar here
350 expect![[r#"
351 bn bar i32
352 bn bar i32
353 fn foo() fn foo()
354 "#]],
355 );
356 }
357
358 #[test]
359 fn completes_self_in_methods() {
360 check(
361 r#"impl S { fn foo(&self) { <|> } }"#,
362 expect![[r#"
363 tp Self
364 bn self &{unknown}
365 "#]],
366 );
367 }
368
369 #[test]
370 fn completes_prelude() {
371 check(
372 r#"
373//- /main.rs crate:main deps:std
374fn foo() { let x: <|> }
375
376//- /std/lib.rs crate:std
377#[prelude_import]
378use prelude::*;
379
380mod prelude { struct Option; }
381"#,
382 expect![[r#"
383 st Option
384 fn foo() fn foo()
385 md std
386 "#]],
387 );
388 }
389
390 #[test]
391 fn completes_std_prelude_if_core_is_defined() {
392 check(
393 r#"
394//- /main.rs crate:main deps:core,std
395fn foo() { let x: <|> }
396
397//- /core/lib.rs crate:core
398#[prelude_import]
399use prelude::*;
400
401mod prelude { struct Option; }
402
403//- /std/lib.rs crate:std deps:core
404#[prelude_import]
405use prelude::*;
406
407mod prelude { struct String; }
408"#,
409 expect![[r#"
410 st String
411 md core
412 fn foo() fn foo()
413 md std
414 "#]],
415 );
416 }
417
418 #[test]
419 fn completes_macros_as_value() {
420 check(
421 r#"
422macro_rules! foo { () => {} }
423
424#[macro_use]
425mod m1 {
426 macro_rules! bar { () => {} }
427}
428
429mod m2 {
430 macro_rules! nope { () => {} }
431
432 #[macro_export]
433 macro_rules! baz { () => {} }
434}
435
436fn main() { let v = <|> }
437"#,
438 expect![[r##"
439 ma bar!(…) macro_rules! bar
440 ma baz!(…) #[macro_export]
441 macro_rules! baz
442 ma foo!(…) macro_rules! foo
443 md m1
444 md m2
445 fn main() fn main()
446 "##]],
447 );
448 }
449
450 #[test]
451 fn completes_both_macro_and_value() {
452 check(
453 r#"
454macro_rules! foo { () => {} }
455fn foo() { <|> }
456"#,
457 expect![[r#"
458 ma foo!(…) macro_rules! foo
459 fn foo() fn foo()
460 "#]],
461 );
462 }
463
464 #[test]
465 fn completes_macros_as_type() {
466 check(
467 r#"
468macro_rules! foo { () => {} }
469fn main() { let x: <|> }
470"#,
471 expect![[r#"
472 ma foo!(…) macro_rules! foo
473 fn main() fn main()
474 "#]],
475 );
476 }
477
478 #[test]
479 fn completes_macros_as_stmt() {
480 check(
481 r#"
482macro_rules! foo { () => {} }
483fn main() { <|> }
484"#,
485 expect![[r#"
486 ma foo!(…) macro_rules! foo
487 fn main() fn main()
488 "#]],
489 );
490 }
491
492 #[test]
493 fn completes_local_item() {
494 check(
495 r#"
496fn main() {
497 return f<|>;
498 fn frobnicate() {}
499}
500"#,
501 expect![[r#"
502 fn frobnicate() fn frobnicate()
503 fn main() fn main()
504 "#]],
505 );
506 }
507
508 #[test]
509 fn completes_in_simple_macro_1() {
510 check(
511 r#"
512macro_rules! m { ($e:expr) => { $e } }
513fn quux(x: i32) {
514 let y = 92;
515 m!(<|>);
516}
517"#,
518 expect![[r#"
519 ma m!(…) macro_rules! m
520 fn quux(…) fn quux(x: i32)
521 bn x i32
522 bn y i32
523 "#]],
524 );
525 }
526
527 #[test]
528 fn completes_in_simple_macro_2() {
529 check(
530 r"
531macro_rules! m { ($e:expr) => { $e } }
532fn quux(x: i32) {
533 let y = 92;
534 m!(x<|>);
535}
536",
537 expect![[r#"
538 ma m!(…) macro_rules! m
539 fn quux(…) fn quux(x: i32)
540 bn x i32
541 bn y i32
542 "#]],
543 );
544 }
545
546 #[test]
547 fn completes_in_simple_macro_without_closing_parens() {
548 check(
549 r#"
550macro_rules! m { ($e:expr) => { $e } }
551fn quux(x: i32) {
552 let y = 92;
553 m!(x<|>
554}
555"#,
556 expect![[r#"
557 ma m!(…) macro_rules! m
558 fn quux(…) fn quux(x: i32)
559 bn x i32
560 bn y i32
561 "#]],
562 );
563 }
564
565 #[test]
566 fn completes_unresolved_uses() {
567 check(
568 r#"
569use spam::Quux;
570
571fn main() { <|> }
572"#,
573 expect![[r#"
574 ?? Quux
575 fn main() fn main()
576 "#]],
577 );
578 }
579 #[test]
580 fn completes_enum_variant_matcharm() {
581 check(
582 r#"
583enum Foo { Bar, Baz, Quux }
584
585fn main() {
586 let foo = Foo::Quux;
587 match foo { Qu<|> }
588}
589"#,
590 expect![[r#"
591 en Foo
592 ev Foo::Bar ()
593 ev Foo::Baz ()
594 ev Foo::Quux ()
595 "#]],
596 )
597 }
598
599 #[test]
600 fn completes_enum_variant_iflet() {
601 check(
602 r#"
603enum Foo { Bar, Baz, Quux }
604
605fn main() {
606 let foo = Foo::Quux;
607 if let Qu<|> = foo { }
608}
609"#,
610 expect![[r#"
611 en Foo
612 ev Foo::Bar ()
613 ev Foo::Baz ()
614 ev Foo::Quux ()
615 "#]],
616 )
617 }
618
619 #[test]
620 fn completes_enum_variant_basic_expr() {
621 check(
622 r#"
623enum Foo { Bar, Baz, Quux }
624fn main() { let foo: Foo = Q<|> }
625"#,
626 expect![[r#"
627 en Foo
628 ev Foo::Bar ()
629 ev Foo::Baz ()
630 ev Foo::Quux ()
631 fn main() fn main()
632 "#]],
633 )
634 }
635
636 #[test]
637 fn completes_enum_variant_from_module() {
638 check(
639 r#"
640mod m { pub enum E { V } }
641fn f() -> m::E { V<|> }
642"#,
643 expect![[r#"
644 fn f() fn f() -> m::E
645 md m
646 ev m::E::V ()
647 "#]],
648 )
649 }
650
651 #[test]
652 fn dont_complete_attr() {
653 check(
654 r#"
655struct Foo;
656#[<|>]
657fn f() {}
658"#,
659 expect![[""]],
660 )
661 }
662
663 #[test]
664 fn completes_type_or_trait_in_impl_block() {
665 check(
666 r#"
667trait MyTrait {}
668struct MyStruct {}
669
670impl My<|>
671"#,
672 expect![[r#"
673 st MyStruct
674 tt MyTrait
675 tp Self
676 "#]],
677 )
678 }
679}
diff --git a/crates/completion/src/completion_config.rs b/crates/completion/src/completion_config.rs
new file mode 100644
index 000000000..71b49ace8
--- /dev/null
+++ b/crates/completion/src/completion_config.rs
@@ -0,0 +1,35 @@
1//! Settings for tweaking completion.
2//!
3//! The fun thing here is `SnippetCap` -- this type can only be created in this
4//! module, and we use to statically check that we only produce snippet
5//! completions if we are allowed to.
6
7#[derive(Clone, Debug, PartialEq, Eq)]
8pub struct CompletionConfig {
9 pub enable_postfix_completions: bool,
10 pub add_call_parenthesis: bool,
11 pub add_call_argument_snippets: bool,
12 pub snippet_cap: Option<SnippetCap>,
13}
14
15impl CompletionConfig {
16 pub fn allow_snippets(&mut self, yes: bool) {
17 self.snippet_cap = if yes { Some(SnippetCap { _private: () }) } else { None }
18 }
19}
20
21#[derive(Clone, Copy, Debug, PartialEq, Eq)]
22pub struct SnippetCap {
23 _private: (),
24}
25
26impl Default for CompletionConfig {
27 fn default() -> Self {
28 CompletionConfig {
29 enable_postfix_completions: true,
30 add_call_parenthesis: true,
31 add_call_argument_snippets: true,
32 snippet_cap: Some(SnippetCap { _private: () }),
33 }
34 }
35}
diff --git a/crates/completion/src/completion_context.rs b/crates/completion/src/completion_context.rs
new file mode 100644
index 000000000..e4f86d0e0
--- /dev/null
+++ b/crates/completion/src/completion_context.rs
@@ -0,0 +1,533 @@
1//! See `CompletionContext` structure.
2
3use base_db::{FilePosition, SourceDatabase};
4use call_info::ActiveParameter;
5use hir::{Local, ScopeDef, Semantics, SemanticsScope, Type};
6use ide_db::RootDatabase;
7use syntax::{
8 algo::{find_covering_element, find_node_at_offset},
9 ast, match_ast, AstNode, NodeOrToken,
10 SyntaxKind::*,
11 SyntaxNode, SyntaxToken, TextRange, TextSize,
12};
13use test_utils::mark;
14use text_edit::Indel;
15
16use crate::{
17 patterns::{
18 fn_is_prev, for_is_prev2, has_bind_pat_parent, has_block_expr_parent,
19 has_field_list_parent, has_impl_as_prev_sibling, has_impl_parent,
20 has_item_list_or_source_file_parent, has_ref_parent, has_trait_as_prev_sibling,
21 has_trait_parent, if_is_prev, inside_impl_trait_block, is_in_loop_body, is_match_arm,
22 unsafe_is_prev,
23 },
24 CompletionConfig,
25};
26
27/// `CompletionContext` is created early during completion to figure out, where
28/// exactly is the cursor, syntax-wise.
29#[derive(Debug)]
30pub(crate) struct CompletionContext<'a> {
31 pub(super) sema: Semantics<'a, RootDatabase>,
32 pub(super) scope: SemanticsScope<'a>,
33 pub(super) db: &'a RootDatabase,
34 pub(super) config: &'a CompletionConfig,
35 pub(super) position: FilePosition,
36 /// The token before the cursor, in the original file.
37 pub(super) original_token: SyntaxToken,
38 /// The token before the cursor, in the macro-expanded file.
39 pub(super) token: SyntaxToken,
40 pub(super) krate: Option<hir::Crate>,
41 pub(super) expected_type: Option<Type>,
42 pub(super) name_ref_syntax: Option<ast::NameRef>,
43 pub(super) function_syntax: Option<ast::Fn>,
44 pub(super) use_item_syntax: Option<ast::Use>,
45 pub(super) record_lit_syntax: Option<ast::RecordExpr>,
46 pub(super) record_pat_syntax: Option<ast::RecordPat>,
47 pub(super) record_field_syntax: Option<ast::RecordExprField>,
48 pub(super) impl_def: Option<ast::Impl>,
49 /// FIXME: `ActiveParameter` is string-based, which is very very wrong
50 pub(super) active_parameter: Option<ActiveParameter>,
51 pub(super) is_param: bool,
52 /// If a name-binding or reference to a const in a pattern.
53 /// Irrefutable patterns (like let) are excluded.
54 pub(super) is_pat_binding_or_const: bool,
55 /// A single-indent path, like `foo`. `::foo` should not be considered a trivial path.
56 pub(super) is_trivial_path: bool,
57 /// If not a trivial path, the prefix (qualifier).
58 pub(super) path_qual: Option<ast::Path>,
59 pub(super) after_if: bool,
60 /// `true` if we are a statement or a last expr in the block.
61 pub(super) can_be_stmt: bool,
62 /// `true` if we expect an expression at the cursor position.
63 pub(super) is_expr: bool,
64 /// Something is typed at the "top" level, in module or impl/trait.
65 pub(super) is_new_item: bool,
66 /// The receiver if this is a field or method access, i.e. writing something.<|>
67 pub(super) dot_receiver: Option<ast::Expr>,
68 pub(super) dot_receiver_is_ambiguous_float_literal: bool,
69 /// If this is a call (method or function) in particular, i.e. the () are already there.
70 pub(super) is_call: bool,
71 /// Like `is_call`, but for tuple patterns.
72 pub(super) is_pattern_call: bool,
73 /// If this is a macro call, i.e. the () are already there.
74 pub(super) is_macro_call: bool,
75 pub(super) is_path_type: bool,
76 pub(super) has_type_args: bool,
77 pub(super) attribute_under_caret: Option<ast::Attr>,
78 pub(super) mod_declaration_under_caret: Option<ast::Module>,
79 pub(super) unsafe_is_prev: bool,
80 pub(super) if_is_prev: bool,
81 pub(super) block_expr_parent: bool,
82 pub(super) bind_pat_parent: bool,
83 pub(super) ref_pat_parent: bool,
84 pub(super) in_loop_body: bool,
85 pub(super) has_trait_parent: bool,
86 pub(super) has_impl_parent: bool,
87 pub(super) inside_impl_trait_block: bool,
88 pub(super) has_field_list_parent: bool,
89 pub(super) trait_as_prev_sibling: bool,
90 pub(super) impl_as_prev_sibling: bool,
91 pub(super) is_match_arm: bool,
92 pub(super) has_item_list_or_source_file_parent: bool,
93 pub(super) for_is_prev2: bool,
94 pub(super) fn_is_prev: bool,
95 pub(super) locals: Vec<(String, Local)>,
96}
97
98impl<'a> CompletionContext<'a> {
99 pub(super) fn new(
100 db: &'a RootDatabase,
101 position: FilePosition,
102 config: &'a CompletionConfig,
103 ) -> Option<CompletionContext<'a>> {
104 let sema = Semantics::new(db);
105
106 let original_file = sema.parse(position.file_id);
107
108 // Insert a fake ident to get a valid parse tree. We will use this file
109 // to determine context, though the original_file will be used for
110 // actual completion.
111 let file_with_fake_ident = {
112 let parse = db.parse(position.file_id);
113 let edit = Indel::insert(position.offset, "intellijRulezz".to_string());
114 parse.reparse(&edit).tree()
115 };
116 let fake_ident_token =
117 file_with_fake_ident.syntax().token_at_offset(position.offset).right_biased().unwrap();
118
119 let krate = sema.to_module_def(position.file_id).map(|m| m.krate());
120 let original_token =
121 original_file.syntax().token_at_offset(position.offset).left_biased()?;
122 let token = sema.descend_into_macros(original_token.clone());
123 let scope = sema.scope_at_offset(&token.parent(), position.offset);
124 let mut locals = vec![];
125 scope.process_all_names(&mut |name, scope| {
126 if let ScopeDef::Local(local) = scope {
127 locals.push((name.to_string(), local));
128 }
129 });
130 let mut ctx = CompletionContext {
131 sema,
132 scope,
133 db,
134 config,
135 original_token,
136 token,
137 position,
138 krate,
139 expected_type: None,
140 name_ref_syntax: None,
141 function_syntax: None,
142 use_item_syntax: None,
143 record_lit_syntax: None,
144 record_pat_syntax: None,
145 record_field_syntax: None,
146 impl_def: None,
147 active_parameter: ActiveParameter::at(db, position),
148 is_param: false,
149 is_pat_binding_or_const: false,
150 is_trivial_path: false,
151 path_qual: None,
152 after_if: false,
153 can_be_stmt: false,
154 is_expr: false,
155 is_new_item: false,
156 dot_receiver: None,
157 is_call: false,
158 is_pattern_call: false,
159 is_macro_call: false,
160 is_path_type: false,
161 has_type_args: false,
162 dot_receiver_is_ambiguous_float_literal: false,
163 attribute_under_caret: None,
164 mod_declaration_under_caret: None,
165 unsafe_is_prev: false,
166 in_loop_body: false,
167 ref_pat_parent: false,
168 bind_pat_parent: false,
169 block_expr_parent: false,
170 has_trait_parent: false,
171 has_impl_parent: false,
172 inside_impl_trait_block: false,
173 has_field_list_parent: false,
174 trait_as_prev_sibling: false,
175 impl_as_prev_sibling: false,
176 if_is_prev: false,
177 is_match_arm: false,
178 has_item_list_or_source_file_parent: false,
179 for_is_prev2: false,
180 fn_is_prev: false,
181 locals,
182 };
183
184 let mut original_file = original_file.syntax().clone();
185 let mut hypothetical_file = file_with_fake_ident.syntax().clone();
186 let mut offset = position.offset;
187 let mut fake_ident_token = fake_ident_token;
188
189 // Are we inside a macro call?
190 while let (Some(actual_macro_call), Some(macro_call_with_fake_ident)) = (
191 find_node_at_offset::<ast::MacroCall>(&original_file, offset),
192 find_node_at_offset::<ast::MacroCall>(&hypothetical_file, offset),
193 ) {
194 if actual_macro_call.path().as_ref().map(|s| s.syntax().text())
195 != macro_call_with_fake_ident.path().as_ref().map(|s| s.syntax().text())
196 {
197 break;
198 }
199 let hypothetical_args = match macro_call_with_fake_ident.token_tree() {
200 Some(tt) => tt,
201 None => break,
202 };
203 if let (Some(actual_expansion), Some(hypothetical_expansion)) = (
204 ctx.sema.expand(&actual_macro_call),
205 ctx.sema.speculative_expand(
206 &actual_macro_call,
207 &hypothetical_args,
208 fake_ident_token,
209 ),
210 ) {
211 let new_offset = hypothetical_expansion.1.text_range().start();
212 if new_offset > actual_expansion.text_range().end() {
213 break;
214 }
215 original_file = actual_expansion;
216 hypothetical_file = hypothetical_expansion.0;
217 fake_ident_token = hypothetical_expansion.1;
218 offset = new_offset;
219 } else {
220 break;
221 }
222 }
223 ctx.fill_keyword_patterns(&hypothetical_file, offset);
224 ctx.fill(&original_file, hypothetical_file, offset);
225 Some(ctx)
226 }
227
228 /// Checks whether completions in that particular case don't make much sense.
229 /// Examples:
230 /// - `fn <|>` -- we expect function name, it's unlikely that "hint" will be helpful.
231 /// Exception for this case is `impl Trait for Foo`, where we would like to hint trait method names.
232 /// - `for _ i<|>` -- obviously, it'll be "in" keyword.
233 pub(crate) fn no_completion_required(&self) -> bool {
234 (self.fn_is_prev && !self.inside_impl_trait_block) || self.for_is_prev2
235 }
236
237 /// The range of the identifier that is being completed.
238 pub(crate) fn source_range(&self) -> TextRange {
239 // check kind of macro-expanded token, but use range of original token
240 let kind = self.token.kind();
241 if kind == IDENT || kind == UNDERSCORE || kind.is_keyword() {
242 mark::hit!(completes_if_prefix_is_keyword);
243 self.original_token.text_range()
244 } else {
245 TextRange::empty(self.position.offset)
246 }
247 }
248
249 pub(crate) fn active_name_and_type(&self) -> Option<(String, Type)> {
250 if let Some(record_field) = &self.record_field_syntax {
251 mark::hit!(record_field_type_match);
252 let (struct_field, _local) = self.sema.resolve_record_field(record_field)?;
253 Some((struct_field.name(self.db).to_string(), struct_field.signature_ty(self.db)))
254 } else if let Some(active_parameter) = &self.active_parameter {
255 mark::hit!(active_param_type_match);
256 Some((active_parameter.name.clone(), active_parameter.ty.clone()))
257 } else {
258 None
259 }
260 }
261
262 fn fill_keyword_patterns(&mut self, file_with_fake_ident: &SyntaxNode, offset: TextSize) {
263 let fake_ident_token = file_with_fake_ident.token_at_offset(offset).right_biased().unwrap();
264 let syntax_element = NodeOrToken::Token(fake_ident_token);
265 self.block_expr_parent = has_block_expr_parent(syntax_element.clone());
266 self.unsafe_is_prev = unsafe_is_prev(syntax_element.clone());
267 self.if_is_prev = if_is_prev(syntax_element.clone());
268 self.bind_pat_parent = has_bind_pat_parent(syntax_element.clone());
269 self.ref_pat_parent = has_ref_parent(syntax_element.clone());
270 self.in_loop_body = is_in_loop_body(syntax_element.clone());
271 self.has_trait_parent = has_trait_parent(syntax_element.clone());
272 self.has_impl_parent = has_impl_parent(syntax_element.clone());
273 self.inside_impl_trait_block = inside_impl_trait_block(syntax_element.clone());
274 self.has_field_list_parent = has_field_list_parent(syntax_element.clone());
275 self.impl_as_prev_sibling = has_impl_as_prev_sibling(syntax_element.clone());
276 self.trait_as_prev_sibling = has_trait_as_prev_sibling(syntax_element.clone());
277 self.is_match_arm = is_match_arm(syntax_element.clone());
278 self.has_item_list_or_source_file_parent =
279 has_item_list_or_source_file_parent(syntax_element.clone());
280 self.mod_declaration_under_caret =
281 find_node_at_offset::<ast::Module>(&file_with_fake_ident, offset)
282 .filter(|module| module.item_list().is_none());
283 self.for_is_prev2 = for_is_prev2(syntax_element.clone());
284 self.fn_is_prev = fn_is_prev(syntax_element.clone());
285 }
286
287 fn fill(
288 &mut self,
289 original_file: &SyntaxNode,
290 file_with_fake_ident: SyntaxNode,
291 offset: TextSize,
292 ) {
293 // FIXME: this is wrong in at least two cases:
294 // * when there's no token `foo(<|>)`
295 // * when there is a token, but it happens to have type of it's own
296 self.expected_type = self
297 .token
298 .ancestors()
299 .find_map(|node| {
300 let ty = match_ast! {
301 match node {
302 ast::Pat(it) => self.sema.type_of_pat(&it),
303 ast::Expr(it) => self.sema.type_of_expr(&it),
304 _ => return None,
305 }
306 };
307 Some(ty)
308 })
309 .flatten();
310 self.attribute_under_caret = find_node_at_offset(&file_with_fake_ident, offset);
311
312 // First, let's try to complete a reference to some declaration.
313 if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(&file_with_fake_ident, offset) {
314 // Special case, `trait T { fn foo(i_am_a_name_ref) {} }`.
315 // See RFC#1685.
316 if is_node::<ast::Param>(name_ref.syntax()) {
317 self.is_param = true;
318 return;
319 }
320 // FIXME: remove this (V) duplication and make the check more precise
321 if name_ref.syntax().ancestors().find_map(ast::RecordPatFieldList::cast).is_some() {
322 self.record_pat_syntax =
323 self.sema.find_node_at_offset_with_macros(&original_file, offset);
324 }
325 self.classify_name_ref(original_file, name_ref, offset);
326 }
327
328 // Otherwise, see if this is a declaration. We can use heuristics to
329 // suggest declaration names, see `CompletionKind::Magic`.
330 if let Some(name) = find_node_at_offset::<ast::Name>(&file_with_fake_ident, offset) {
331 if let Some(bind_pat) = name.syntax().ancestors().find_map(ast::IdentPat::cast) {
332 self.is_pat_binding_or_const = true;
333 if bind_pat.at_token().is_some()
334 || bind_pat.ref_token().is_some()
335 || bind_pat.mut_token().is_some()
336 {
337 self.is_pat_binding_or_const = false;
338 }
339 if bind_pat.syntax().parent().and_then(ast::RecordPatFieldList::cast).is_some() {
340 self.is_pat_binding_or_const = false;
341 }
342 if let Some(let_stmt) = bind_pat.syntax().ancestors().find_map(ast::LetStmt::cast) {
343 if let Some(pat) = let_stmt.pat() {
344 if pat.syntax().text_range().contains_range(bind_pat.syntax().text_range())
345 {
346 self.is_pat_binding_or_const = false;
347 }
348 }
349 }
350 }
351 if is_node::<ast::Param>(name.syntax()) {
352 self.is_param = true;
353 return;
354 }
355 // FIXME: remove this (^) duplication and make the check more precise
356 if name.syntax().ancestors().find_map(ast::RecordPatFieldList::cast).is_some() {
357 self.record_pat_syntax =
358 self.sema.find_node_at_offset_with_macros(&original_file, offset);
359 }
360 }
361 }
362
363 fn classify_name_ref(
364 &mut self,
365 original_file: &SyntaxNode,
366 name_ref: ast::NameRef,
367 offset: TextSize,
368 ) {
369 self.name_ref_syntax =
370 find_node_at_offset(&original_file, name_ref.syntax().text_range().start());
371 let name_range = name_ref.syntax().text_range();
372 if ast::RecordExprField::for_field_name(&name_ref).is_some() {
373 self.record_lit_syntax =
374 self.sema.find_node_at_offset_with_macros(&original_file, offset);
375 }
376
377 self.impl_def = self
378 .sema
379 .ancestors_with_macros(self.token.parent())
380 .take_while(|it| it.kind() != SOURCE_FILE && it.kind() != MODULE)
381 .find_map(ast::Impl::cast);
382
383 let top_node = name_ref
384 .syntax()
385 .ancestors()
386 .take_while(|it| it.text_range() == name_range)
387 .last()
388 .unwrap();
389
390 match top_node.parent().map(|it| it.kind()) {
391 Some(SOURCE_FILE) | Some(ITEM_LIST) => {
392 self.is_new_item = true;
393 return;
394 }
395 _ => (),
396 }
397
398 self.use_item_syntax =
399 self.sema.ancestors_with_macros(self.token.parent()).find_map(ast::Use::cast);
400
401 self.function_syntax = self
402 .sema
403 .ancestors_with_macros(self.token.parent())
404 .take_while(|it| it.kind() != SOURCE_FILE && it.kind() != MODULE)
405 .find_map(ast::Fn::cast);
406
407 self.record_field_syntax = self
408 .sema
409 .ancestors_with_macros(self.token.parent())
410 .take_while(|it| {
411 it.kind() != SOURCE_FILE && it.kind() != MODULE && it.kind() != CALL_EXPR
412 })
413 .find_map(ast::RecordExprField::cast);
414
415 let parent = match name_ref.syntax().parent() {
416 Some(it) => it,
417 None => return,
418 };
419
420 if let Some(segment) = ast::PathSegment::cast(parent.clone()) {
421 let path = segment.parent_path();
422 self.is_call = path
423 .syntax()
424 .parent()
425 .and_then(ast::PathExpr::cast)
426 .and_then(|it| it.syntax().parent().and_then(ast::CallExpr::cast))
427 .is_some();
428 self.is_macro_call = path.syntax().parent().and_then(ast::MacroCall::cast).is_some();
429 self.is_pattern_call =
430 path.syntax().parent().and_then(ast::TupleStructPat::cast).is_some();
431
432 self.is_path_type = path.syntax().parent().and_then(ast::PathType::cast).is_some();
433 self.has_type_args = segment.generic_arg_list().is_some();
434
435 if let Some(path) = path_or_use_tree_qualifier(&path) {
436 self.path_qual = path
437 .segment()
438 .and_then(|it| {
439 find_node_with_range::<ast::PathSegment>(
440 original_file,
441 it.syntax().text_range(),
442 )
443 })
444 .map(|it| it.parent_path());
445 return;
446 }
447
448 if let Some(segment) = path.segment() {
449 if segment.coloncolon_token().is_some() {
450 return;
451 }
452 }
453
454 self.is_trivial_path = true;
455
456 // Find either enclosing expr statement (thing with `;`) or a
457 // block. If block, check that we are the last expr.
458 self.can_be_stmt = name_ref
459 .syntax()
460 .ancestors()
461 .find_map(|node| {
462 if let Some(stmt) = ast::ExprStmt::cast(node.clone()) {
463 return Some(stmt.syntax().text_range() == name_ref.syntax().text_range());
464 }
465 if let Some(block) = ast::BlockExpr::cast(node) {
466 return Some(
467 block.expr().map(|e| e.syntax().text_range())
468 == Some(name_ref.syntax().text_range()),
469 );
470 }
471 None
472 })
473 .unwrap_or(false);
474 self.is_expr = path.syntax().parent().and_then(ast::PathExpr::cast).is_some();
475
476 if let Some(off) = name_ref.syntax().text_range().start().checked_sub(2.into()) {
477 if let Some(if_expr) =
478 self.sema.find_node_at_offset_with_macros::<ast::IfExpr>(original_file, off)
479 {
480 if if_expr.syntax().text_range().end() < name_ref.syntax().text_range().start()
481 {
482 self.after_if = true;
483 }
484 }
485 }
486 }
487 if let Some(field_expr) = ast::FieldExpr::cast(parent.clone()) {
488 // The receiver comes before the point of insertion of the fake
489 // ident, so it should have the same range in the non-modified file
490 self.dot_receiver = field_expr
491 .expr()
492 .map(|e| e.syntax().text_range())
493 .and_then(|r| find_node_with_range(original_file, r));
494 self.dot_receiver_is_ambiguous_float_literal =
495 if let Some(ast::Expr::Literal(l)) = &self.dot_receiver {
496 match l.kind() {
497 ast::LiteralKind::FloatNumber { .. } => l.token().text().ends_with('.'),
498 _ => false,
499 }
500 } else {
501 false
502 };
503 }
504 if let Some(method_call_expr) = ast::MethodCallExpr::cast(parent) {
505 // As above
506 self.dot_receiver = method_call_expr
507 .receiver()
508 .map(|e| e.syntax().text_range())
509 .and_then(|r| find_node_with_range(original_file, r));
510 self.is_call = true;
511 }
512 }
513}
514
515fn find_node_with_range<N: AstNode>(syntax: &SyntaxNode, range: TextRange) -> Option<N> {
516 find_covering_element(syntax, range).ancestors().find_map(N::cast)
517}
518
519fn is_node<N: AstNode>(node: &SyntaxNode) -> bool {
520 match node.ancestors().find_map(N::cast) {
521 None => false,
522 Some(n) => n.syntax().text_range() == node.text_range(),
523 }
524}
525
526fn path_or_use_tree_qualifier(path: &ast::Path) -> Option<ast::Path> {
527 if let Some(qual) = path.qualifier() {
528 return Some(qual);
529 }
530 let use_tree_list = path.syntax().ancestors().find_map(ast::UseTreeList::cast)?;
531 let use_tree = use_tree_list.syntax().parent().and_then(ast::UseTree::cast)?;
532 use_tree.path()
533}
diff --git a/crates/completion/src/completion_item.rs b/crates/completion/src/completion_item.rs
new file mode 100644
index 000000000..2e1ca0e59
--- /dev/null
+++ b/crates/completion/src/completion_item.rs
@@ -0,0 +1,403 @@
1//! See `CompletionItem` structure.
2
3use std::fmt;
4
5use hir::{Documentation, Mutability};
6use syntax::TextRange;
7use text_edit::TextEdit;
8
9use crate::completion_config::SnippetCap;
10
11/// `CompletionItem` describes a single completion variant in the editor pop-up.
12/// It is basically a POD with various properties. To construct a
13/// `CompletionItem`, use `new` method and the `Builder` struct.
14pub struct CompletionItem {
15 /// Used only internally in tests, to check only specific kind of
16 /// completion (postfix, keyword, reference, etc).
17 #[allow(unused)]
18 pub(crate) completion_kind: CompletionKind,
19 /// Label in the completion pop up which identifies completion.
20 label: String,
21 /// Range of identifier that is being completed.
22 ///
23 /// It should be used primarily for UI, but we also use this to convert
24 /// genetic TextEdit into LSP's completion edit (see conv.rs).
25 ///
26 /// `source_range` must contain the completion offset. `insert_text` should
27 /// start with what `source_range` points to, or VSCode will filter out the
28 /// completion silently.
29 source_range: TextRange,
30 /// What happens when user selects this item.
31 ///
32 /// Typically, replaces `source_range` with new identifier.
33 text_edit: TextEdit,
34 insert_text_format: InsertTextFormat,
35
36 /// What item (struct, function, etc) are we completing.
37 kind: Option<CompletionItemKind>,
38
39 /// Lookup is used to check if completion item indeed can complete current
40 /// ident.
41 ///
42 /// That is, in `foo.bar<|>` lookup of `abracadabra` will be accepted (it
43 /// contains `bar` sub sequence), and `quux` will rejected.
44 lookup: Option<String>,
45
46 /// Additional info to show in the UI pop up.
47 detail: Option<String>,
48 documentation: Option<Documentation>,
49
50 /// Whether this item is marked as deprecated
51 deprecated: bool,
52
53 /// If completing a function call, ask the editor to show parameter popup
54 /// after completion.
55 trigger_call_info: bool,
56
57 /// Score is useful to pre select or display in better order completion items
58 score: Option<CompletionScore>,
59
60 /// Indicates that a reference or mutable reference to this variable is a
61 /// possible match.
62 ref_match: Option<(Mutability, CompletionScore)>,
63}
64
65// We use custom debug for CompletionItem to make snapshot tests more readable.
66impl fmt::Debug for CompletionItem {
67 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
68 let mut s = f.debug_struct("CompletionItem");
69 s.field("label", &self.label()).field("source_range", &self.source_range());
70 if self.text_edit().len() == 1 {
71 let atom = &self.text_edit().iter().next().unwrap();
72 s.field("delete", &atom.delete);
73 s.field("insert", &atom.insert);
74 } else {
75 s.field("text_edit", &self.text_edit);
76 }
77 if let Some(kind) = self.kind().as_ref() {
78 s.field("kind", kind);
79 }
80 if self.lookup() != self.label() {
81 s.field("lookup", &self.lookup());
82 }
83 if let Some(detail) = self.detail() {
84 s.field("detail", &detail);
85 }
86 if let Some(documentation) = self.documentation() {
87 s.field("documentation", &documentation);
88 }
89 if self.deprecated {
90 s.field("deprecated", &true);
91 }
92 if let Some(score) = &self.score {
93 s.field("score", score);
94 }
95 if self.trigger_call_info {
96 s.field("trigger_call_info", &true);
97 }
98 s.finish()
99 }
100}
101
102#[derive(Debug, Clone, Copy, Ord, PartialOrd, Eq, PartialEq)]
103pub enum CompletionScore {
104 /// If only type match
105 TypeMatch,
106 /// If type and name match
107 TypeAndNameMatch,
108}
109
110#[derive(Debug, Clone, Copy, PartialEq, Eq)]
111pub enum CompletionItemKind {
112 Snippet,
113 Keyword,
114 Module,
115 Function,
116 BuiltinType,
117 Struct,
118 Enum,
119 EnumVariant,
120 Binding,
121 Field,
122 Static,
123 Const,
124 Trait,
125 TypeAlias,
126 Method,
127 TypeParam,
128 Macro,
129 Attribute,
130 UnresolvedReference,
131}
132
133impl CompletionItemKind {
134 #[cfg(test)]
135 pub(crate) fn tag(&self) -> &'static str {
136 match self {
137 CompletionItemKind::Attribute => "at",
138 CompletionItemKind::Binding => "bn",
139 CompletionItemKind::BuiltinType => "bt",
140 CompletionItemKind::Const => "ct",
141 CompletionItemKind::Enum => "en",
142 CompletionItemKind::EnumVariant => "ev",
143 CompletionItemKind::Field => "fd",
144 CompletionItemKind::Function => "fn",
145 CompletionItemKind::Keyword => "kw",
146 CompletionItemKind::Macro => "ma",
147 CompletionItemKind::Method => "me",
148 CompletionItemKind::Module => "md",
149 CompletionItemKind::Snippet => "sn",
150 CompletionItemKind::Static => "sc",
151 CompletionItemKind::Struct => "st",
152 CompletionItemKind::Trait => "tt",
153 CompletionItemKind::TypeAlias => "ta",
154 CompletionItemKind::TypeParam => "tp",
155 CompletionItemKind::UnresolvedReference => "??",
156 }
157 }
158}
159
160#[derive(Debug, PartialEq, Eq, Copy, Clone)]
161pub(crate) enum CompletionKind {
162 /// Parser-based keyword completion.
163 Keyword,
164 /// Your usual "complete all valid identifiers".
165 Reference,
166 /// "Secret sauce" completions.
167 Magic,
168 Snippet,
169 Postfix,
170 BuiltinType,
171 Attribute,
172}
173
174#[derive(Debug, PartialEq, Eq, Copy, Clone)]
175pub enum InsertTextFormat {
176 PlainText,
177 Snippet,
178}
179
180impl CompletionItem {
181 pub(crate) fn new(
182 completion_kind: CompletionKind,
183 source_range: TextRange,
184 label: impl Into<String>,
185 ) -> Builder {
186 let label = label.into();
187 Builder {
188 source_range,
189 completion_kind,
190 label,
191 insert_text: None,
192 insert_text_format: InsertTextFormat::PlainText,
193 detail: None,
194 documentation: None,
195 lookup: None,
196 kind: None,
197 text_edit: None,
198 deprecated: None,
199 trigger_call_info: None,
200 score: None,
201 ref_match: None,
202 }
203 }
204 /// What user sees in pop-up in the UI.
205 pub fn label(&self) -> &str {
206 &self.label
207 }
208 pub fn source_range(&self) -> TextRange {
209 self.source_range
210 }
211
212 pub fn insert_text_format(&self) -> InsertTextFormat {
213 self.insert_text_format
214 }
215
216 pub fn text_edit(&self) -> &TextEdit {
217 &self.text_edit
218 }
219
220 /// Short one-line additional information, like a type
221 pub fn detail(&self) -> Option<&str> {
222 self.detail.as_deref()
223 }
224 /// A doc-comment
225 pub fn documentation(&self) -> Option<Documentation> {
226 self.documentation.clone()
227 }
228 /// What string is used for filtering.
229 pub fn lookup(&self) -> &str {
230 self.lookup.as_deref().unwrap_or(&self.label)
231 }
232
233 pub fn kind(&self) -> Option<CompletionItemKind> {
234 self.kind
235 }
236
237 pub fn deprecated(&self) -> bool {
238 self.deprecated
239 }
240
241 pub fn score(&self) -> Option<CompletionScore> {
242 self.score
243 }
244
245 pub fn trigger_call_info(&self) -> bool {
246 self.trigger_call_info
247 }
248
249 pub fn ref_match(&self) -> Option<(Mutability, CompletionScore)> {
250 self.ref_match
251 }
252}
253
254/// A helper to make `CompletionItem`s.
255#[must_use]
256#[derive(Clone)]
257pub(crate) struct Builder {
258 source_range: TextRange,
259 completion_kind: CompletionKind,
260 label: String,
261 insert_text: Option<String>,
262 insert_text_format: InsertTextFormat,
263 detail: Option<String>,
264 documentation: Option<Documentation>,
265 lookup: Option<String>,
266 kind: Option<CompletionItemKind>,
267 text_edit: Option<TextEdit>,
268 deprecated: Option<bool>,
269 trigger_call_info: Option<bool>,
270 score: Option<CompletionScore>,
271 ref_match: Option<(Mutability, CompletionScore)>,
272}
273
274impl Builder {
275 pub(crate) fn add_to(self, acc: &mut Completions) {
276 acc.add(self.build())
277 }
278
279 pub(crate) fn build(self) -> CompletionItem {
280 let label = self.label;
281 let text_edit = match self.text_edit {
282 Some(it) => it,
283 None => TextEdit::replace(
284 self.source_range,
285 self.insert_text.unwrap_or_else(|| label.clone()),
286 ),
287 };
288
289 CompletionItem {
290 source_range: self.source_range,
291 label,
292 insert_text_format: self.insert_text_format,
293 text_edit,
294 detail: self.detail,
295 documentation: self.documentation,
296 lookup: self.lookup,
297 kind: self.kind,
298 completion_kind: self.completion_kind,
299 deprecated: self.deprecated.unwrap_or(false),
300 trigger_call_info: self.trigger_call_info.unwrap_or(false),
301 score: self.score,
302 ref_match: self.ref_match,
303 }
304 }
305 pub(crate) fn lookup_by(mut self, lookup: impl Into<String>) -> Builder {
306 self.lookup = Some(lookup.into());
307 self
308 }
309 pub(crate) fn label(mut self, label: impl Into<String>) -> Builder {
310 self.label = label.into();
311 self
312 }
313 pub(crate) fn insert_text(mut self, insert_text: impl Into<String>) -> Builder {
314 self.insert_text = Some(insert_text.into());
315 self
316 }
317 pub(crate) fn insert_snippet(
318 mut self,
319 _cap: SnippetCap,
320 snippet: impl Into<String>,
321 ) -> Builder {
322 self.insert_text_format = InsertTextFormat::Snippet;
323 self.insert_text(snippet)
324 }
325 pub(crate) fn kind(mut self, kind: CompletionItemKind) -> Builder {
326 self.kind = Some(kind);
327 self
328 }
329 pub(crate) fn text_edit(mut self, edit: TextEdit) -> Builder {
330 self.text_edit = Some(edit);
331 self
332 }
333 pub(crate) fn snippet_edit(mut self, _cap: SnippetCap, edit: TextEdit) -> Builder {
334 self.insert_text_format = InsertTextFormat::Snippet;
335 self.text_edit(edit)
336 }
337 #[allow(unused)]
338 pub(crate) fn detail(self, detail: impl Into<String>) -> Builder {
339 self.set_detail(Some(detail))
340 }
341 pub(crate) fn set_detail(mut self, detail: Option<impl Into<String>>) -> Builder {
342 self.detail = detail.map(Into::into);
343 self
344 }
345 #[allow(unused)]
346 pub(crate) fn documentation(self, docs: Documentation) -> Builder {
347 self.set_documentation(Some(docs))
348 }
349 pub(crate) fn set_documentation(mut self, docs: Option<Documentation>) -> Builder {
350 self.documentation = docs.map(Into::into);
351 self
352 }
353 pub(crate) fn set_deprecated(mut self, deprecated: bool) -> Builder {
354 self.deprecated = Some(deprecated);
355 self
356 }
357 pub(crate) fn set_score(mut self, score: CompletionScore) -> Builder {
358 self.score = Some(score);
359 self
360 }
361 pub(crate) fn trigger_call_info(mut self) -> Builder {
362 self.trigger_call_info = Some(true);
363 self
364 }
365 pub(crate) fn set_ref_match(
366 mut self,
367 ref_match: Option<(Mutability, CompletionScore)>,
368 ) -> Builder {
369 self.ref_match = ref_match;
370 self
371 }
372}
373
374impl<'a> Into<CompletionItem> for Builder {
375 fn into(self) -> CompletionItem {
376 self.build()
377 }
378}
379
380/// Represents an in-progress set of completions being built.
381#[derive(Debug, Default)]
382pub struct Completions {
383 buf: Vec<CompletionItem>,
384}
385
386impl Completions {
387 pub fn add(&mut self, item: impl Into<CompletionItem>) {
388 self.buf.push(item.into())
389 }
390 pub fn add_all<I>(&mut self, items: I)
391 where
392 I: IntoIterator,
393 I::Item: Into<CompletionItem>,
394 {
395 items.into_iter().for_each(|item| self.add(item.into()))
396 }
397}
398
399impl Into<Vec<CompletionItem>> for Completions {
400 fn into(self) -> Vec<CompletionItem> {
401 self.buf
402 }
403}
diff --git a/crates/completion/src/generated_lint_completions.rs b/crates/completion/src/generated_lint_completions.rs
new file mode 100644
index 000000000..5a7dba1f5
--- /dev/null
+++ b/crates/completion/src/generated_lint_completions.rs
@@ -0,0 +1,5 @@
1//! Generated file, do not edit by hand, see `xtask/src/codegen`
2
3use crate::complete_attribute::LintCompletion;
4pub (super) const FEATURES : & [LintCompletion] = & [LintCompletion { label : "link_args" , description : "# `link_args`\n\nThe tracking issue for this feature is: [#29596]\n\n[#29596]: https://github.com/rust-lang/rust/issues/29596\n\n------------------------\n\nYou can tell `rustc` how to customize linking, and that is via the `link_args`\nattribute. This attribute is applied to `extern` blocks and specifies raw flags\nwhich need to get passed to the linker when producing an artifact. An example\nusage would be:\n\n```rust,no_run\n#![feature(link_args)]\n\n#[link_args = \"-foo -bar -baz\"]\nextern {}\n# fn main() {}\n```\n\nNote that this feature is currently hidden behind the `feature(link_args)` gate\nbecause this is not a sanctioned way of performing linking. Right now `rustc`\nshells out to the system linker (`gcc` on most systems, `link.exe` on MSVC), so\nit makes sense to provide extra command line arguments, but this will not\nalways be the case. In the future `rustc` may use LLVM directly to link native\nlibraries, in which case `link_args` will have no meaning. You can achieve the\nsame effect as the `link_args` attribute with the `-C link-args` argument to\n`rustc`.\n\nIt is highly recommended to *not* use this attribute, and rather use the more\nformal `#[link(...)]` attribute on `extern` blocks instead.\n" } , LintCompletion { label : "repr128" , description : "# `repr128`\n\nThe tracking issue for this feature is: [#56071]\n\n[#56071]: https://github.com/rust-lang/rust/issues/56071\n\n------------------------\n\nThe `repr128` feature adds support for `#[repr(u128)]` on `enum`s.\n\n```rust\n#![feature(repr128)]\n\n#[repr(u128)]\nenum Foo {\n Bar(u64),\n}\n```\n" } , LintCompletion { label : "crate_visibility_modifier" , description : "# `crate_visibility_modifier`\n\nThe tracking issue for this feature is: [#53120]\n\n[#53120]: https://github.com/rust-lang/rust/issues/53120\n\n-----\n\nThe `crate_visibility_modifier` feature allows the `crate` keyword to be used\nas a visibility modifier synonymous to `pub(crate)`, indicating that a type\n(function, _&c._) is to be visible to the entire enclosing crate, but not to\nother crates.\n\n```rust\n#![feature(crate_visibility_modifier)]\n\ncrate struct Foo {\n bar: usize,\n}\n```\n" } , LintCompletion { label : "doc_masked" , description : "# `doc_masked`\n\nThe tracking issue for this feature is: [#44027]\n\n-----\n\nThe `doc_masked` feature allows a crate to exclude types from a given crate from appearing in lists\nof trait implementations. The specifics of the feature are as follows:\n\n1. When rustdoc encounters an `extern crate` statement annotated with a `#[doc(masked)]` attribute,\n it marks the crate as being masked.\n\n2. When listing traits a given type implements, rustdoc ensures that traits from masked crates are\n not emitted into the documentation.\n\n3. When listing types that implement a given trait, rustdoc ensures that types from masked crates\n are not emitted into the documentation.\n\nThis feature was introduced in PR [#44026] to ensure that compiler-internal and\nimplementation-specific types and traits were not included in the standard library's documentation.\nSuch types would introduce broken links into the documentation.\n\n[#44026]: https://github.com/rust-lang/rust/pull/44026\n[#44027]: https://github.com/rust-lang/rust/pull/44027\n" } , LintCompletion { label : "cfg_sanitize" , description : "# `cfg_sanitize`\n\nThe tracking issue for this feature is: [#39699]\n\n[#39699]: https://github.com/rust-lang/rust/issues/39699\n\n------------------------\n\nThe `cfg_sanitize` feature makes it possible to execute different code\ndepending on whether a particular sanitizer is enabled or not.\n\n## Examples\n\n```rust\n#![feature(cfg_sanitize)]\n\n#[cfg(sanitize = \"thread\")]\nfn a() {\n // ...\n}\n\n#[cfg(not(sanitize = \"thread\"))]\nfn a() {\n // ...\n}\n\nfn b() {\n if cfg!(sanitize = \"leak\") {\n // ...\n } else {\n // ...\n }\n}\n```\n" } , LintCompletion { label : "generators" , description : "# `generators`\n\nThe tracking issue for this feature is: [#43122]\n\n[#43122]: https://github.com/rust-lang/rust/issues/43122\n\n------------------------\n\nThe `generators` feature gate in Rust allows you to define generator or\ncoroutine literals. A generator is a \"resumable function\" that syntactically\nresembles a closure but compiles to much different semantics in the compiler\nitself. The primary feature of a generator is that it can be suspended during\nexecution to be resumed at a later date. Generators use the `yield` keyword to\n\"return\", and then the caller can `resume` a generator to resume execution just\nafter the `yield` keyword.\n\nGenerators are an extra-unstable feature in the compiler right now. Added in\n[RFC 2033] they're mostly intended right now as a information/constraint\ngathering phase. The intent is that experimentation can happen on the nightly\ncompiler before actual stabilization. A further RFC will be required to\nstabilize generators/coroutines and will likely contain at least a few small\ntweaks to the overall design.\n\n[RFC 2033]: https://github.com/rust-lang/rfcs/pull/2033\n\nA syntactical example of a generator is:\n\n```rust\n#![feature(generators, generator_trait)]\n\nuse std::ops::{Generator, GeneratorState};\nuse std::pin::Pin;\n\nfn main() {\n let mut generator = || {\n yield 1;\n return \"foo\"\n };\n\n match Pin::new(&mut generator).resume(()) {\n GeneratorState::Yielded(1) => {}\n _ => panic!(\"unexpected value from resume\"),\n }\n match Pin::new(&mut generator).resume(()) {\n GeneratorState::Complete(\"foo\") => {}\n _ => panic!(\"unexpected value from resume\"),\n }\n}\n```\n\nGenerators are closure-like literals which can contain a `yield` statement. The\n`yield` statement takes an optional expression of a value to yield out of the\ngenerator. All generator literals implement the `Generator` trait in the\n`std::ops` module. The `Generator` trait has one main method, `resume`, which\nresumes execution of the generator at the previous suspension point.\n\nAn example of the control flow of generators is that the following example\nprints all numbers in order:\n\n```rust\n#![feature(generators, generator_trait)]\n\nuse std::ops::Generator;\nuse std::pin::Pin;\n\nfn main() {\n let mut generator = || {\n println!(\"2\");\n yield;\n println!(\"4\");\n };\n\n println!(\"1\");\n Pin::new(&mut generator).resume(());\n println!(\"3\");\n Pin::new(&mut generator).resume(());\n println!(\"5\");\n}\n```\n\nAt this time the main intended use case of generators is an implementation\nprimitive for async/await syntax, but generators will likely be extended to\nergonomic implementations of iterators and other primitives in the future.\nFeedback on the design and usage is always appreciated!\n\n### The `Generator` trait\n\nThe `Generator` trait in `std::ops` currently looks like:\n\n```rust\n# #![feature(arbitrary_self_types, generator_trait)]\n# use std::ops::GeneratorState;\n# use std::pin::Pin;\n\npub trait Generator<R = ()> {\n type Yield;\n type Return;\n fn resume(self: Pin<&mut Self>, resume: R) -> GeneratorState<Self::Yield, Self::Return>;\n}\n```\n\nThe `Generator::Yield` type is the type of values that can be yielded with the\n`yield` statement. The `Generator::Return` type is the returned type of the\ngenerator. This is typically the last expression in a generator's definition or\nany value passed to `return` in a generator. The `resume` function is the entry\npoint for executing the `Generator` itself.\n\nThe return value of `resume`, `GeneratorState`, looks like:\n\n```rust\npub enum GeneratorState<Y, R> {\n Yielded(Y),\n Complete(R),\n}\n```\n\nThe `Yielded` variant indicates that the generator can later be resumed. This\ncorresponds to a `yield` point in a generator. The `Complete` variant indicates\nthat the generator is complete and cannot be resumed again. Calling `resume`\nafter a generator has returned `Complete` will likely result in a panic of the\nprogram.\n\n### Closure-like semantics\n\nThe closure-like syntax for generators alludes to the fact that they also have\nclosure-like semantics. Namely:\n\n* When created, a generator executes no code. A closure literal does not\n actually execute any of the closure's code on construction, and similarly a\n generator literal does not execute any code inside the generator when\n constructed.\n\n* Generators can capture outer variables by reference or by move, and this can\n be tweaked with the `move` keyword at the beginning of the closure. Like\n closures all generators will have an implicit environment which is inferred by\n the compiler. Outer variables can be moved into a generator for use as the\n generator progresses.\n\n* Generator literals produce a value with a unique type which implements the\n `std::ops::Generator` trait. This allows actual execution of the generator\n through the `Generator::resume` method as well as also naming it in return\n types and such.\n\n* Traits like `Send` and `Sync` are automatically implemented for a `Generator`\n depending on the captured variables of the environment. Unlike closures,\n generators also depend on variables live across suspension points. This means\n that although the ambient environment may be `Send` or `Sync`, the generator\n itself may not be due to internal variables live across `yield` points being\n not-`Send` or not-`Sync`. Note that generators do\n not implement traits like `Copy` or `Clone` automatically.\n\n* Whenever a generator is dropped it will drop all captured environment\n variables.\n\n### Generators as state machines\n\nIn the compiler, generators are currently compiled as state machines. Each\n`yield` expression will correspond to a different state that stores all live\nvariables over that suspension point. Resumption of a generator will dispatch on\nthe current state and then execute internally until a `yield` is reached, at\nwhich point all state is saved off in the generator and a value is returned.\n\nLet's take a look at an example to see what's going on here:\n\n```rust\n#![feature(generators, generator_trait)]\n\nuse std::ops::Generator;\nuse std::pin::Pin;\n\nfn main() {\n let ret = \"foo\";\n let mut generator = move || {\n yield 1;\n return ret\n };\n\n Pin::new(&mut generator).resume(());\n Pin::new(&mut generator).resume(());\n}\n```\n\nThis generator literal will compile down to something similar to:\n\n```rust\n#![feature(arbitrary_self_types, generators, generator_trait)]\n\nuse std::ops::{Generator, GeneratorState};\nuse std::pin::Pin;\n\nfn main() {\n let ret = \"foo\";\n let mut generator = {\n enum __Generator {\n Start(&'static str),\n Yield1(&'static str),\n Done,\n }\n\n impl Generator for __Generator {\n type Yield = i32;\n type Return = &'static str;\n\n fn resume(mut self: Pin<&mut Self>, resume: ()) -> GeneratorState<i32, &'static str> {\n use std::mem;\n match mem::replace(&mut *self, __Generator::Done) {\n __Generator::Start(s) => {\n *self = __Generator::Yield1(s);\n GeneratorState::Yielded(1)\n }\n\n __Generator::Yield1(s) => {\n *self = __Generator::Done;\n GeneratorState::Complete(s)\n }\n\n __Generator::Done => {\n panic!(\"generator resumed after completion\")\n }\n }\n }\n }\n\n __Generator::Start(ret)\n };\n\n Pin::new(&mut generator).resume(());\n Pin::new(&mut generator).resume(());\n}\n```\n\nNotably here we can see that the compiler is generating a fresh type,\n`__Generator` in this case. This type has a number of states (represented here\nas an `enum`) corresponding to each of the conceptual states of the generator.\nAt the beginning we're closing over our outer variable `foo` and then that\nvariable is also live over the `yield` point, so it's stored in both states.\n\nWhen the generator starts it'll immediately yield 1, but it saves off its state\njust before it does so indicating that it has reached the yield point. Upon\nresuming again we'll execute the `return ret` which returns the `Complete`\nstate.\n\nHere we can also note that the `Done` state, if resumed, panics immediately as\nit's invalid to resume a completed generator. It's also worth noting that this\nis just a rough desugaring, not a normative specification for what the compiler\ndoes.\n" } , LintCompletion { label : "abi_ptx" , description : "# `abi_ptx`\n\nThe tracking issue for this feature is: [#38788]\n\n[#38788]: https://github.com/rust-lang/rust/issues/38788\n\n------------------------\n\nWhen emitting PTX code, all vanilla Rust functions (`fn`) get translated to\n\"device\" functions. These functions are *not* callable from the host via the\nCUDA API so a crate with only device functions is not too useful!\n\nOTOH, \"global\" functions *can* be called by the host; you can think of them\nas the real public API of your crate. To produce a global function use the\n`\"ptx-kernel\"` ABI.\n\n<!-- NOTE(ignore) this example is specific to the nvptx targets -->\n\n``` rust,ignore\n#![feature(abi_ptx)]\n#![no_std]\n\npub unsafe extern \"ptx-kernel\" fn global_function() {\n device_function();\n}\n\npub fn device_function() {\n // ..\n}\n```\n\n``` text\n$ xargo rustc --target nvptx64-nvidia-cuda --release -- --emit=asm\n\n$ cat $(find -name '*.s')\n//\n// Generated by LLVM NVPTX Back-End\n//\n\n.version 3.2\n.target sm_20\n.address_size 64\n\n // .globl _ZN6kernel15global_function17h46111ebe6516b382E\n\n.visible .entry _ZN6kernel15global_function17h46111ebe6516b382E()\n{\n\n\n ret;\n}\n\n // .globl _ZN6kernel15device_function17hd6a0e4993bbf3f78E\n.visible .func _ZN6kernel15device_function17hd6a0e4993bbf3f78E()\n{\n\n\n ret;\n}\n```\n" } , LintCompletion { label : "unsized_tuple_coercion" , description : "# `unsized_tuple_coercion`\n\nThe tracking issue for this feature is: [#42877]\n\n[#42877]: https://github.com/rust-lang/rust/issues/42877\n\n------------------------\n\nThis is a part of [RFC0401]. According to the RFC, there should be an implementation like this:\n\n```rust,ignore\nimpl<..., T, U: ?Sized> Unsized<(..., U)> for (..., T) where T: Unsized<U> {}\n```\n\nThis implementation is currently gated behind `#[feature(unsized_tuple_coercion)]` to avoid insta-stability. Therefore you can use it like this:\n\n```rust\n#![feature(unsized_tuple_coercion)]\n\nfn main() {\n let x : ([i32; 3], [i32; 3]) = ([1, 2, 3], [4, 5, 6]);\n let y : &([i32; 3], [i32]) = &x;\n assert_eq!(y.1[0], 4);\n}\n```\n\n[RFC0401]: https://github.com/rust-lang/rfcs/blob/master/text/0401-coercions.md\n" } , LintCompletion { label : "const_in_array_repeat_expressions" , description : "# `const_in_array_repeat_expressions`\n\nThe tracking issue for this feature is: [#49147]\n\n[#49147]: https://github.com/rust-lang/rust/issues/49147\n\n------------------------\n\nRelaxes the rules for repeat expressions, `[x; N]` such that `x` may also be `const` (strictly\nspeaking rvalue promotable), in addition to `typeof(x): Copy`. The result of `[x; N]` where `x` is\n`const` is itself also `const`.\n" } , LintCompletion { label : "impl_trait_in_bindings" , description : "# `impl_trait_in_bindings`\n\nThe tracking issue for this feature is: [#63065]\n\n[#63065]: https://github.com/rust-lang/rust/issues/63065\n\n------------------------\n\nThe `impl_trait_in_bindings` feature gate lets you use `impl Trait` syntax in\n`let`, `static`, and `const` bindings.\n\nA simple example is:\n\n```rust\n#![feature(impl_trait_in_bindings)]\n\nuse std::fmt::Debug;\n\nfn main() {\n let a: impl Debug + Clone = 42;\n let b = a.clone();\n println!(\"{:?}\", b); // prints `42`\n}\n```\n\nNote however that because the types of `a` and `b` are opaque in the above\nexample, calling inherent methods or methods outside of the specified traits\n(e.g., `a.abs()` or `b.abs()`) is not allowed, and yields an error.\n" } , LintCompletion { label : "trait_alias" , description : "# `trait_alias`\n\nThe tracking issue for this feature is: [#41517]\n\n[#41517]: https://github.com/rust-lang/rust/issues/41517\n\n------------------------\n\nThe `trait_alias` feature adds support for trait aliases. These allow aliases\nto be created for one or more traits (currently just a single regular trait plus\nany number of auto-traits), and used wherever traits would normally be used as\neither bounds or trait objects.\n\n```rust\n#![feature(trait_alias)]\n\ntrait Foo = std::fmt::Debug + Send;\ntrait Bar = Foo + Sync;\n\n// Use trait alias as bound on type parameter.\nfn foo<T: Foo>(v: &T) {\n println!(\"{:?}\", v);\n}\n\npub fn main() {\n foo(&1);\n\n // Use trait alias for trait objects.\n let a: &Bar = &123;\n println!(\"{:?}\", a);\n let b = Box::new(456) as Box<dyn Foo>;\n println!(\"{:?}\", b);\n}\n```\n" } , LintCompletion { label : "doc_cfg" , description : "# `doc_cfg`\n\nThe tracking issue for this feature is: [#43781]\n\n------\n\nThe `doc_cfg` feature allows an API be documented as only available in some specific platforms.\nThis attribute has two effects:\n\n1. In the annotated item's documentation, there will be a message saying \"This is supported on\n (platform) only\".\n\n2. The item's doc-tests will only run on the specific platform.\n\nIn addition to allowing the use of the `#[doc(cfg)]` attribute, this feature enables the use of a\nspecial conditional compilation flag, `#[cfg(doc)]`, set whenever building documentation on your\ncrate.\n\nThis feature was introduced as part of PR [#43348] to allow the platform-specific parts of the\nstandard library be documented.\n\n```rust\n#![feature(doc_cfg)]\n\n#[cfg(any(windows, doc))]\n#[doc(cfg(windows))]\n/// The application's icon in the notification area (a.k.a. system tray).\n///\n/// # Examples\n///\n/// ```no_run\n/// extern crate my_awesome_ui_library;\n/// use my_awesome_ui_library::current_app;\n/// use my_awesome_ui_library::windows::notification;\n///\n/// let icon = current_app().get::<notification::Icon>();\n/// icon.show();\n/// icon.show_message(\"Hello\");\n/// ```\npub struct Icon {\n // ...\n}\n```\n\n[#43781]: https://github.com/rust-lang/rust/issues/43781\n[#43348]: https://github.com/rust-lang/rust/issues/43348\n" } , LintCompletion { label : "lang_items" , description : "# `lang_items`\n\nThe tracking issue for this feature is: None.\n\n------------------------\n\nThe `rustc` compiler has certain pluggable operations, that is,\nfunctionality that isn't hard-coded into the language, but is\nimplemented in libraries, with a special marker to tell the compiler\nit exists. The marker is the attribute `#[lang = \"...\"]` and there are\nvarious different values of `...`, i.e. various different 'lang\nitems'.\n\nFor example, `Box` pointers require two lang items, one for allocation\nand one for deallocation. A freestanding program that uses the `Box`\nsugar for dynamic allocations via `malloc` and `free`:\n\n```rust,ignore\n#![feature(lang_items, box_syntax, start, libc, core_intrinsics)]\n#![no_std]\nuse core::intrinsics;\nuse core::panic::PanicInfo;\n\nextern crate libc;\n\n#[lang = \"owned_box\"]\npub struct Box<T>(*mut T);\n\n#[lang = \"exchange_malloc\"]\nunsafe fn allocate(size: usize, _align: usize) -> *mut u8 {\n let p = libc::malloc(size as libc::size_t) as *mut u8;\n\n // Check if `malloc` failed:\n if p as usize == 0 {\n intrinsics::abort();\n }\n\n p\n}\n\n#[lang = \"box_free\"]\nunsafe fn box_free<T: ?Sized>(ptr: *mut T) {\n libc::free(ptr as *mut libc::c_void)\n}\n\n#[start]\nfn main(_argc: isize, _argv: *const *const u8) -> isize {\n let _x = box 1;\n\n 0\n}\n\n#[lang = \"eh_personality\"] extern fn rust_eh_personality() {}\n#[lang = \"panic_impl\"] extern fn rust_begin_panic(info: &PanicInfo) -> ! { unsafe { intrinsics::abort() } }\n#[no_mangle] pub extern fn rust_eh_register_frames () {}\n#[no_mangle] pub extern fn rust_eh_unregister_frames () {}\n```\n\nNote the use of `abort`: the `exchange_malloc` lang item is assumed to\nreturn a valid pointer, and so needs to do the check internally.\n\nOther features provided by lang items include:\n\n- overloadable operators via traits: the traits corresponding to the\n `==`, `<`, dereferencing (`*`) and `+` (etc.) operators are all\n marked with lang items; those specific four are `eq`, `ord`,\n `deref`, and `add` respectively.\n- stack unwinding and general failure; the `eh_personality`,\n `panic` and `panic_bounds_checks` lang items.\n- the traits in `std::marker` used to indicate types of\n various kinds; lang items `send`, `sync` and `copy`.\n- the marker types and variance indicators found in\n `std::marker`; lang items `covariant_type`,\n `contravariant_lifetime`, etc.\n\nLang items are loaded lazily by the compiler; e.g. if one never uses\n`Box` then there is no need to define functions for `exchange_malloc`\nand `box_free`. `rustc` will emit an error when an item is needed\nbut not found in the current crate or any that it depends on.\n\nMost lang items are defined by `libcore`, but if you're trying to build\nan executable without the standard library, you'll run into the need\nfor lang items. The rest of this page focuses on this use-case, even though\nlang items are a bit broader than that.\n\n### Using libc\n\nIn order to build a `#[no_std]` executable we will need libc as a dependency.\nWe can specify this using our `Cargo.toml` file:\n\n```toml\n[dependencies]\nlibc = { version = \"0.2.14\", default-features = false }\n```\n\nNote that the default features have been disabled. This is a critical step -\n**the default features of libc include the standard library and so must be\ndisabled.**\n\n### Writing an executable without stdlib\n\nControlling the entry point is possible in two ways: the `#[start]` attribute,\nor overriding the default shim for the C `main` function with your own.\n\nThe function marked `#[start]` is passed the command line parameters\nin the same format as C:\n\n```rust,ignore\n#![feature(lang_items, core_intrinsics)]\n#![feature(start)]\n#![no_std]\nuse core::intrinsics;\nuse core::panic::PanicInfo;\n\n// Pull in the system libc library for what crt0.o likely requires.\nextern crate libc;\n\n// Entry point for this program.\n#[start]\nfn start(_argc: isize, _argv: *const *const u8) -> isize {\n 0\n}\n\n// These functions are used by the compiler, but not\n// for a bare-bones hello world. These are normally\n// provided by libstd.\n#[lang = \"eh_personality\"]\n#[no_mangle]\npub extern fn rust_eh_personality() {\n}\n\n#[lang = \"panic_impl\"]\n#[no_mangle]\npub extern fn rust_begin_panic(info: &PanicInfo) -> ! {\n unsafe { intrinsics::abort() }\n}\n```\n\nTo override the compiler-inserted `main` shim, one has to disable it\nwith `#![no_main]` and then create the appropriate symbol with the\ncorrect ABI and the correct name, which requires overriding the\ncompiler's name mangling too:\n\n```rust,ignore\n#![feature(lang_items, core_intrinsics)]\n#![feature(start)]\n#![no_std]\n#![no_main]\nuse core::intrinsics;\nuse core::panic::PanicInfo;\n\n// Pull in the system libc library for what crt0.o likely requires.\nextern crate libc;\n\n// Entry point for this program.\n#[no_mangle] // ensure that this symbol is called `main` in the output\npub extern fn main(_argc: i32, _argv: *const *const u8) -> i32 {\n 0\n}\n\n// These functions are used by the compiler, but not\n// for a bare-bones hello world. These are normally\n// provided by libstd.\n#[lang = \"eh_personality\"]\n#[no_mangle]\npub extern fn rust_eh_personality() {\n}\n\n#[lang = \"panic_impl\"]\n#[no_mangle]\npub extern fn rust_begin_panic(info: &PanicInfo) -> ! {\n unsafe { intrinsics::abort() }\n}\n```\n\nIn many cases, you may need to manually link to the `compiler_builtins` crate\nwhen building a `no_std` binary. You may observe this via linker error messages\nsuch as \"```undefined reference to `__rust_probestack'```\".\n\n## More about the language items\n\nThe compiler currently makes a few assumptions about symbols which are\navailable in the executable to call. Normally these functions are provided by\nthe standard library, but without it you must define your own. These symbols\nare called \"language items\", and they each have an internal name, and then a\nsignature that an implementation must conform to.\n\nThe first of these functions, `rust_eh_personality`, is used by the failure\nmechanisms of the compiler. This is often mapped to GCC's personality function\n(see the [libstd implementation][unwind] for more information), but crates\nwhich do not trigger a panic can be assured that this function is never\ncalled. The language item's name is `eh_personality`.\n\n[unwind]: https://github.com/rust-lang/rust/blob/master/src/libpanic_unwind/gcc.rs\n\nThe second function, `rust_begin_panic`, is also used by the failure mechanisms of the\ncompiler. When a panic happens, this controls the message that's displayed on\nthe screen. While the language item's name is `panic_impl`, the symbol name is\n`rust_begin_panic`.\n\nFinally, a `eh_catch_typeinfo` static is needed for certain targets which\nimplement Rust panics on top of C++ exceptions.\n\n## List of all language items\n\nThis is a list of all language items in Rust along with where they are located in\nthe source code.\n\n- Primitives\n - `i8`: `libcore/num/mod.rs`\n - `i16`: `libcore/num/mod.rs`\n - `i32`: `libcore/num/mod.rs`\n - `i64`: `libcore/num/mod.rs`\n - `i128`: `libcore/num/mod.rs`\n - `isize`: `libcore/num/mod.rs`\n - `u8`: `libcore/num/mod.rs`\n - `u16`: `libcore/num/mod.rs`\n - `u32`: `libcore/num/mod.rs`\n - `u64`: `libcore/num/mod.rs`\n - `u128`: `libcore/num/mod.rs`\n - `usize`: `libcore/num/mod.rs`\n - `f32`: `libstd/f32.rs`\n - `f64`: `libstd/f64.rs`\n - `char`: `libcore/char.rs`\n - `slice`: `liballoc/slice.rs`\n - `str`: `liballoc/str.rs`\n - `const_ptr`: `libcore/ptr.rs`\n - `mut_ptr`: `libcore/ptr.rs`\n - `unsafe_cell`: `libcore/cell.rs`\n- Runtime\n - `start`: `libstd/rt.rs`\n - `eh_personality`: `libpanic_unwind/emcc.rs` (EMCC)\n - `eh_personality`: `libpanic_unwind/gcc.rs` (GNU)\n - `eh_personality`: `libpanic_unwind/seh.rs` (SEH)\n - `eh_catch_typeinfo`: `libpanic_unwind/emcc.rs` (EMCC)\n - `panic`: `libcore/panicking.rs`\n - `panic_bounds_check`: `libcore/panicking.rs`\n - `panic_impl`: `libcore/panicking.rs`\n - `panic_impl`: `libstd/panicking.rs`\n- Allocations\n - `owned_box`: `liballoc/boxed.rs`\n - `exchange_malloc`: `liballoc/heap.rs`\n - `box_free`: `liballoc/heap.rs`\n- Operands\n - `not`: `libcore/ops/bit.rs`\n - `bitand`: `libcore/ops/bit.rs`\n - `bitor`: `libcore/ops/bit.rs`\n - `bitxor`: `libcore/ops/bit.rs`\n - `shl`: `libcore/ops/bit.rs`\n - `shr`: `libcore/ops/bit.rs`\n - `bitand_assign`: `libcore/ops/bit.rs`\n - `bitor_assign`: `libcore/ops/bit.rs`\n - `bitxor_assign`: `libcore/ops/bit.rs`\n - `shl_assign`: `libcore/ops/bit.rs`\n - `shr_assign`: `libcore/ops/bit.rs`\n - `deref`: `libcore/ops/deref.rs`\n - `deref_mut`: `libcore/ops/deref.rs`\n - `index`: `libcore/ops/index.rs`\n - `index_mut`: `libcore/ops/index.rs`\n - `add`: `libcore/ops/arith.rs`\n - `sub`: `libcore/ops/arith.rs`\n - `mul`: `libcore/ops/arith.rs`\n - `div`: `libcore/ops/arith.rs`\n - `rem`: `libcore/ops/arith.rs`\n - `neg`: `libcore/ops/arith.rs`\n - `add_assign`: `libcore/ops/arith.rs`\n - `sub_assign`: `libcore/ops/arith.rs`\n - `mul_assign`: `libcore/ops/arith.rs`\n - `div_assign`: `libcore/ops/arith.rs`\n - `rem_assign`: `libcore/ops/arith.rs`\n - `eq`: `libcore/cmp.rs`\n - `ord`: `libcore/cmp.rs`\n- Functions\n - `fn`: `libcore/ops/function.rs`\n - `fn_mut`: `libcore/ops/function.rs`\n - `fn_once`: `libcore/ops/function.rs`\n - `generator_state`: `libcore/ops/generator.rs`\n - `generator`: `libcore/ops/generator.rs`\n- Other\n - `coerce_unsized`: `libcore/ops/unsize.rs`\n - `drop`: `libcore/ops/drop.rs`\n - `drop_in_place`: `libcore/ptr.rs`\n - `clone`: `libcore/clone.rs`\n - `copy`: `libcore/marker.rs`\n - `send`: `libcore/marker.rs`\n - `sized`: `libcore/marker.rs`\n - `unsize`: `libcore/marker.rs`\n - `sync`: `libcore/marker.rs`\n - `phantom_data`: `libcore/marker.rs`\n - `discriminant_kind`: `libcore/marker.rs`\n - `freeze`: `libcore/marker.rs`\n - `debug_trait`: `libcore/fmt/mod.rs`\n - `non_zero`: `libcore/nonzero.rs`\n - `arc`: `liballoc/sync.rs`\n - `rc`: `liballoc/rc.rs`\n" } , LintCompletion { label : "transparent_unions" , description : "# `transparent_unions`\n\nThe tracking issue for this feature is [#60405]\n\n[#60405]: https://github.com/rust-lang/rust/issues/60405\n\n----\n\nThe `transparent_unions` feature allows you mark `union`s as\n`#[repr(transparent)]`. A `union` may be `#[repr(transparent)]` in exactly the\nsame conditions in which a `struct` may be `#[repr(transparent)]` (generally,\nthis means the `union` must have exactly one non-zero-sized field). Some\nconcrete illustrations follow.\n\n```rust\n#![feature(transparent_unions)]\n\n// This union has the same representation as `f32`.\n#[repr(transparent)]\nunion SingleFieldUnion {\n field: f32,\n}\n\n// This union has the same representation as `usize`.\n#[repr(transparent)]\nunion MultiFieldUnion {\n field: usize,\n nothing: (),\n}\n```\n\nFor consistency with transparent `struct`s, `union`s must have exactly one\nnon-zero-sized field. If all fields are zero-sized, the `union` must not be\n`#[repr(transparent)]`:\n\n```rust\n#![feature(transparent_unions)]\n\n// This (non-transparent) union is already valid in stable Rust:\npub union GoodUnion {\n pub nothing: (),\n}\n\n// Error: transparent union needs exactly one non-zero-sized field, but has 0\n// #[repr(transparent)]\n// pub union BadUnion {\n// pub nothing: (),\n// }\n```\n\nThe one exception is if the `union` is generic over `T` and has a field of type\n`T`, it may be `#[repr(transparent)]` even if `T` is a zero-sized type:\n\n```rust\n#![feature(transparent_unions)]\n\n// This union has the same representation as `T`.\n#[repr(transparent)]\npub union GenericUnion<T: Copy> { // Unions with non-`Copy` fields are unstable.\n pub field: T,\n pub nothing: (),\n}\n\n// This is okay even though `()` is a zero-sized type.\npub const THIS_IS_OKAY: GenericUnion<()> = GenericUnion { field: () };\n```\n\nLike transarent `struct`s, a transparent `union` of type `U` has the same\nlayout, size, and ABI as its single non-ZST field. If it is generic over a type\n`T`, and all its fields are ZSTs except for exactly one field of type `T`, then\nit has the same layout and ABI as `T` (even if `T` is a ZST when monomorphized).\n\nLike transparent `struct`s, transparent `union`s are FFI-safe if and only if\ntheir underlying representation type is also FFI-safe.\n\nA `union` may not be eligible for the same nonnull-style optimizations that a\n`struct` or `enum` (with the same fields) are eligible for. Adding\n`#[repr(transparent)]` to `union` does not change this. To give a more concrete\nexample, it is unspecified whether `size_of::<T>()` is equal to\n`size_of::<Option<T>>()`, where `T` is a `union` (regardless of whether or not\nit is transparent). The Rust compiler is free to perform this optimization if\npossible, but is not required to, and different compiler versions may differ in\ntheir application of these optimizations.\n" } , LintCompletion { label : "abi_msp430_interrupt" , description : "# `abi_msp430_interrupt`\n\nThe tracking issue for this feature is: [#38487]\n\n[#38487]: https://github.com/rust-lang/rust/issues/38487\n\n------------------------\n\nIn the MSP430 architecture, interrupt handlers have a special calling\nconvention. You can use the `\"msp430-interrupt\"` ABI to make the compiler apply\nthe right calling convention to the interrupt handlers you define.\n\n<!-- NOTE(ignore) this example is specific to the msp430 target -->\n\n``` rust,ignore\n#![feature(abi_msp430_interrupt)]\n#![no_std]\n\n// Place the interrupt handler at the appropriate memory address\n// (Alternatively, you can use `#[used]` and remove `pub` and `#[no_mangle]`)\n#[link_section = \"__interrupt_vector_10\"]\n#[no_mangle]\npub static TIM0_VECTOR: extern \"msp430-interrupt\" fn() = tim0;\n\n// The interrupt handler\nextern \"msp430-interrupt\" fn tim0() {\n // ..\n}\n```\n\n``` text\n$ msp430-elf-objdump -CD ./target/msp430/release/app\nDisassembly of section __interrupt_vector_10:\n\n0000fff2 <TIM0_VECTOR>:\n fff2: 00 c0 interrupt service routine at 0xc000\n\nDisassembly of section .text:\n\n0000c000 <int::tim0>:\n c000: 00 13 reti\n```\n" } , LintCompletion { label : "plugin" , description : "# `plugin`\n\nThe tracking issue for this feature is: [#29597]\n\n[#29597]: https://github.com/rust-lang/rust/issues/29597\n\n\nThis feature is part of \"compiler plugins.\" It will often be used with the\n[`plugin_registrar`] and `rustc_private` features.\n\n[`plugin_registrar`]: plugin-registrar.md\n\n------------------------\n\n`rustc` can load compiler plugins, which are user-provided libraries that\nextend the compiler's behavior with new lint checks, etc.\n\nA plugin is a dynamic library crate with a designated *registrar* function that\nregisters extensions with `rustc`. Other crates can load these extensions using\nthe crate attribute `#![plugin(...)]`. See the\n`rustc_driver::plugin` documentation for more about the\nmechanics of defining and loading a plugin.\n\nIn the vast majority of cases, a plugin should *only* be used through\n`#![plugin]` and not through an `extern crate` item. Linking a plugin would\npull in all of librustc_ast and librustc as dependencies of your crate. This is\ngenerally unwanted unless you are building another plugin.\n\nThe usual practice is to put compiler plugins in their own crate, separate from\nany `macro_rules!` macros or ordinary Rust code meant to be used by consumers\nof a library.\n\n# Lint plugins\n\nPlugins can extend [Rust's lint\ninfrastructure](../../reference/attributes/diagnostics.md#lint-check-attributes) with\nadditional checks for code style, safety, etc. Now let's write a plugin\n[`lint-plugin-test.rs`](https://github.com/rust-lang/rust/blob/master/src/test/ui-fulldeps/auxiliary/lint-plugin-test.rs)\nthat warns about any item named `lintme`.\n\n```rust,ignore\n#![feature(plugin_registrar)]\n#![feature(box_syntax, rustc_private)]\n\nextern crate rustc_ast;\n\n// Load rustc as a plugin to get macros\nextern crate rustc_driver;\n#[macro_use]\nextern crate rustc_lint;\n#[macro_use]\nextern crate rustc_session;\n\nuse rustc_driver::plugin::Registry;\nuse rustc_lint::{EarlyContext, EarlyLintPass, LintArray, LintContext, LintPass};\nuse rustc_ast::ast;\ndeclare_lint!(TEST_LINT, Warn, \"Warn about items named 'lintme'\");\n\ndeclare_lint_pass!(Pass => [TEST_LINT]);\n\nimpl EarlyLintPass for Pass {\n fn check_item(&mut self, cx: &EarlyContext, it: &ast::Item) {\n if it.ident.name.as_str() == \"lintme\" {\n cx.lint(TEST_LINT, |lint| {\n lint.build(\"item is named 'lintme'\").set_span(it.span).emit()\n });\n }\n }\n}\n\n#[plugin_registrar]\npub fn plugin_registrar(reg: &mut Registry) {\n reg.lint_store.register_lints(&[&TEST_LINT]);\n reg.lint_store.register_early_pass(|| box Pass);\n}\n```\n\nThen code like\n\n```rust,ignore\n#![feature(plugin)]\n#![plugin(lint_plugin_test)]\n\nfn lintme() { }\n```\n\nwill produce a compiler warning:\n\n```txt\nfoo.rs:4:1: 4:16 warning: item is named 'lintme', #[warn(test_lint)] on by default\nfoo.rs:4 fn lintme() { }\n ^~~~~~~~~~~~~~~\n```\n\nThe components of a lint plugin are:\n\n* one or more `declare_lint!` invocations, which define static `Lint` structs;\n\n* a struct holding any state needed by the lint pass (here, none);\n\n* a `LintPass`\n implementation defining how to check each syntax element. A single\n `LintPass` may call `span_lint` for several different `Lint`s, but should\n register them all through the `get_lints` method.\n\nLint passes are syntax traversals, but they run at a late stage of compilation\nwhere type information is available. `rustc`'s [built-in\nlints](https://github.com/rust-lang/rust/blob/master/src/librustc_session/lint/builtin.rs)\nmostly use the same infrastructure as lint plugins, and provide examples of how\nto access type information.\n\nLints defined by plugins are controlled by the usual [attributes and compiler\nflags](../../reference/attributes/diagnostics.md#lint-check-attributes), e.g.\n`#[allow(test_lint)]` or `-A test-lint`. These identifiers are derived from the\nfirst argument to `declare_lint!`, with appropriate case and punctuation\nconversion.\n\nYou can run `rustc -W help foo.rs` to see a list of lints known to `rustc`,\nincluding those provided by plugins loaded by `foo.rs`.\n" } , LintCompletion { label : "optin_builtin_traits" , description : "# `optin_builtin_traits`\n\nThe tracking issue for this feature is [#13231] \n\n[#13231]: https://github.com/rust-lang/rust/issues/13231\n\n----\n\nThe `optin_builtin_traits` feature gate allows you to define auto traits.\n\nAuto traits, like [`Send`] or [`Sync`] in the standard library, are marker traits\nthat are automatically implemented for every type, unless the type, or a type it contains, \nhas explicitly opted out via a negative impl. (Negative impls are separately controlled\nby the `negative_impls` feature.)\n\n[`Send`]: https://doc.rust-lang.org/std/marker/trait.Send.html\n[`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html\n\n```rust,ignore\nimpl !Trait for Type\n```\n\nExample:\n\n```rust\n#![feature(negative_impls)]\n#![feature(optin_builtin_traits)]\n\nauto trait Valid {}\n\nstruct True;\nstruct False;\n\nimpl !Valid for False {}\n\nstruct MaybeValid<T>(T);\n\nfn must_be_valid<T: Valid>(_t: T) { }\n\nfn main() {\n // works\n must_be_valid( MaybeValid(True) );\n \n // compiler error - trait bound not satisfied\n // must_be_valid( MaybeValid(False) );\n}\n```\n\n## Automatic trait implementations\n\nWhen a type is declared as an `auto trait`, we will automatically\ncreate impls for every struct/enum/union, unless an explicit impl is\nprovided. These automatic impls contain a where clause for each field\nof the form `T: AutoTrait`, where `T` is the type of the field and\n`AutoTrait` is the auto trait in question. As an example, consider the\nstruct `List` and the auto trait `Send`:\n\n```rust\nstruct List<T> {\n data: T,\n next: Option<Box<List<T>>>,\n}\n```\n\nPresuming that there is no explicit impl of `Send` for `List`, the\ncompiler will supply an automatic impl of the form:\n\n```rust\nstruct List<T> {\n data: T,\n next: Option<Box<List<T>>>,\n}\n\nunsafe impl<T> Send for List<T>\nwhere\n T: Send, // from the field `data`\n Option<Box<List<T>>>: Send, // from the field `next`\n{ }\n```\n\nExplicit impls may be either positive or negative. They take the form:\n\n```rust,ignore\nimpl<...> AutoTrait for StructName<..> { }\nimpl<...> !AutoTrait for StructName<..> { }\n```\n\n## Coinduction: Auto traits permit cyclic matching\n\nUnlike ordinary trait matching, auto traits are **coinductive**. This\nmeans, in short, that cycles which occur in trait matching are\nconsidered ok. As an example, consider the recursive struct `List`\nintroduced in the previous section. In attempting to determine whether\n`List: Send`, we would wind up in a cycle: to apply the impl, we must\nshow that `Option<Box<List>>: Send`, which will in turn require\n`Box<List>: Send` and then finally `List: Send` again. Under ordinary\ntrait matching, this cycle would be an error, but for an auto trait it\nis considered a successful match.\n\n## Items\n\nAuto traits cannot have any trait items, such as methods or associated types. This ensures that we can generate default implementations.\n\n## Supertraits\n\nAuto traits cannot have supertraits. This is for soundness reasons, as the interaction of coinduction with implied bounds is difficult to reconcile.\n\n" } , LintCompletion { label : "unboxed_closures" , description : "# `unboxed_closures`\n\nThe tracking issue for this feature is [#29625]\n\nSee Also: [`fn_traits`](../library-features/fn-traits.md)\n\n[#29625]: https://github.com/rust-lang/rust/issues/29625\n\n----\n\nThe `unboxed_closures` feature allows you to write functions using the `\"rust-call\"` ABI,\nrequired for implementing the [`Fn*`] family of traits. `\"rust-call\"` functions must have \nexactly one (non self) argument, a tuple representing the argument list.\n\n[`Fn*`]: https://doc.rust-lang.org/std/ops/trait.Fn.html\n\n```rust\n#![feature(unboxed_closures)]\n\nextern \"rust-call\" fn add_args(args: (u32, u32)) -> u32 {\n args.0 + args.1\n}\n\nfn main() {}\n```\n" } , LintCompletion { label : "intrinsics" , description : "# `intrinsics`\n\nThe tracking issue for this feature is: None.\n\nIntrinsics are never intended to be stable directly, but intrinsics are often\nexported in some sort of stable manner. Prefer using the stable interfaces to\nthe intrinsic directly when you can.\n\n------------------------\n\n\nThese are imported as if they were FFI functions, with the special\n`rust-intrinsic` ABI. For example, if one was in a freestanding\ncontext, but wished to be able to `transmute` between types, and\nperform efficient pointer arithmetic, one would import those functions\nvia a declaration like\n\n```rust\n#![feature(intrinsics)]\n# fn main() {}\n\nextern \"rust-intrinsic\" {\n fn transmute<T, U>(x: T) -> U;\n\n fn offset<T>(dst: *const T, offset: isize) -> *const T;\n}\n```\n\nAs with any other FFI functions, these are always `unsafe` to call.\n\n" } , LintCompletion { label : "no_sanitize" , description : "# `no_sanitize`\n\nThe tracking issue for this feature is: [#39699]\n\n[#39699]: https://github.com/rust-lang/rust/issues/39699\n\n------------------------\n\nThe `no_sanitize` attribute can be used to selectively disable sanitizer\ninstrumentation in an annotated function. This might be useful to: avoid\ninstrumentation overhead in a performance critical function, or avoid\ninstrumenting code that contains constructs unsupported by given sanitizer.\n\nThe precise effect of this annotation depends on particular sanitizer in use.\nFor example, with `no_sanitize(thread)`, the thread sanitizer will no longer\ninstrument non-atomic store / load operations, but it will instrument atomic\noperations to avoid reporting false positives and provide meaning full stack\ntraces.\n\n## Examples\n\n``` rust\n#![feature(no_sanitize)]\n\n#[no_sanitize(address)]\nfn foo() {\n // ...\n}\n```\n" } , LintCompletion { label : "ffi_const" , description : "# `ffi_const`\n\nThe tracking issue for this feature is: [#58328]\n\n------\n\nThe `#[ffi_const]` attribute applies clang's `const` attribute to foreign\nfunctions declarations.\n\nThat is, `#[ffi_const]` functions shall have no effects except for its return\nvalue, which can only depend on the values of the function parameters, and is\nnot affected by changes to the observable state of the program.\n\nApplying the `#[ffi_const]` attribute to a function that violates these\nrequirements is undefined behaviour.\n\nThis attribute enables Rust to perform common optimizations, like sub-expression\nelimination, and it can avoid emitting some calls in repeated invocations of the\nfunction with the same argument values regardless of other operations being\nperformed in between these functions calls (as opposed to `#[ffi_pure]`\nfunctions).\n\n## Pitfalls\n\nA `#[ffi_const]` function can only read global memory that would not affect\nits return value for the whole execution of the program (e.g. immutable global\nmemory). `#[ffi_const]` functions are referentially-transparent and therefore\nmore strict than `#[ffi_pure]` functions.\n\nA common pitfall involves applying the `#[ffi_const]` attribute to a\nfunction that reads memory through pointer arguments which do not necessarily\npoint to immutable global memory.\n\nA `#[ffi_const]` function that returns unit has no effect on the abstract\nmachine's state, and a `#[ffi_const]` function cannot be `#[ffi_pure]`.\n\nA `#[ffi_const]` function must not diverge, neither via a side effect (e.g. a\ncall to `abort`) nor by infinite loops.\n\nWhen translating C headers to Rust FFI, it is worth verifying for which targets\nthe `const` attribute is enabled in those headers, and using the appropriate\n`cfg` macros in the Rust side to match those definitions. While the semantics of\n`const` are implemented identically by many C and C++ compilers, e.g., clang,\n[GCC], [ARM C/C++ compiler], [IBM ILE C/C++], etc. they are not necessarily\nimplemented in this way on all of them. It is therefore also worth verifying\nthat the semantics of the C toolchain used to compile the binary being linked\nagainst are compatible with those of the `#[ffi_const]`.\n\n[#58328]: https://github.com/rust-lang/rust/issues/58328\n[ARM C/C++ compiler]: http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0491c/Cacgigch.html\n[GCC]: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-const-function-attribute\n[IBM ILE C/C++]: https://www.ibm.com/support/knowledgecenter/fr/ssw_ibm_i_71/rzarg/fn_attrib_const.htm\n" } , LintCompletion { label : "unsized_locals" , description : "# `unsized_locals`\n\nThe tracking issue for this feature is: [#48055]\n\n[#48055]: https://github.com/rust-lang/rust/issues/48055\n\n------------------------\n\nThis implements [RFC1909]. When turned on, you can have unsized arguments and locals:\n\n[RFC1909]: https://github.com/rust-lang/rfcs/blob/master/text/1909-unsized-rvalues.md\n\n```rust\n#![feature(unsized_locals)]\n\nuse std::any::Any;\n\nfn main() {\n let x: Box<dyn Any> = Box::new(42);\n let x: dyn Any = *x;\n // ^ unsized local variable\n // ^^ unsized temporary\n foo(x);\n}\n\nfn foo(_: dyn Any) {}\n// ^^^^^^ unsized argument\n```\n\nThe RFC still forbids the following unsized expressions:\n\n```rust,ignore\n#![feature(unsized_locals)]\n\nuse std::any::Any;\n\nstruct MyStruct<T: ?Sized> {\n content: T,\n}\n\nstruct MyTupleStruct<T: ?Sized>(T);\n\nfn answer() -> Box<dyn Any> {\n Box::new(42)\n}\n\nfn main() {\n // You CANNOT have unsized statics.\n static X: dyn Any = *answer(); // ERROR\n const Y: dyn Any = *answer(); // ERROR\n\n // You CANNOT have struct initialized unsized.\n MyStruct { content: *answer() }; // ERROR\n MyTupleStruct(*answer()); // ERROR\n (42, *answer()); // ERROR\n\n // You CANNOT have unsized return types.\n fn my_function() -> dyn Any { *answer() } // ERROR\n\n // You CAN have unsized local variables...\n let mut x: dyn Any = *answer(); // OK\n // ...but you CANNOT reassign to them.\n x = *answer(); // ERROR\n\n // You CANNOT even initialize them separately.\n let y: dyn Any; // OK\n y = *answer(); // ERROR\n\n // Not mentioned in the RFC, but by-move captured variables are also Sized.\n let x: dyn Any = *answer();\n (move || { // ERROR\n let y = x;\n })();\n\n // You CAN create a closure with unsized arguments,\n // but you CANNOT call it.\n // This is an implementation detail and may be changed in the future.\n let f = |x: dyn Any| {};\n f(*answer()); // ERROR\n}\n```\n\n## By-value trait objects\n\nWith this feature, you can have by-value `self` arguments without `Self: Sized` bounds.\n\n```rust\n#![feature(unsized_locals)]\n\ntrait Foo {\n fn foo(self) {}\n}\n\nimpl<T: ?Sized> Foo for T {}\n\nfn main() {\n let slice: Box<[i32]> = Box::new([1, 2, 3]);\n <[i32] as Foo>::foo(*slice);\n}\n```\n\nAnd `Foo` will also be object-safe.\n\n```rust\n#![feature(unsized_locals)]\n\ntrait Foo {\n fn foo(self) {}\n}\n\nimpl<T: ?Sized> Foo for T {}\n\nfn main () {\n let slice: Box<dyn Foo> = Box::new([1, 2, 3]);\n // doesn't compile yet\n <dyn Foo as Foo>::foo(*slice);\n}\n```\n\nOne of the objectives of this feature is to allow `Box<dyn FnOnce>`.\n\n## Variable length arrays\n\nThe RFC also describes an extension to the array literal syntax: `[e; dyn n]`. In the syntax, `n` isn't necessarily a constant expression. The array is dynamically allocated on the stack and has the type of `[T]`, instead of `[T; n]`.\n\n```rust,ignore\n#![feature(unsized_locals)]\n\nfn mergesort<T: Ord>(a: &mut [T]) {\n let mut tmp = [T; dyn a.len()];\n // ...\n}\n\nfn main() {\n let mut a = [3, 1, 5, 6];\n mergesort(&mut a);\n assert_eq!(a, [1, 3, 5, 6]);\n}\n```\n\nVLAs are not implemented yet. The syntax isn't final, either. We may need an alternative syntax for Rust 2015 because, in Rust 2015, expressions like `[e; dyn(1)]` would be ambiguous. One possible alternative proposed in the RFC is `[e; n]`: if `n` captures one or more local variables, then it is considered as `[e; dyn n]`.\n\n## Advisory on stack usage\n\nIt's advised not to casually use the `#![feature(unsized_locals)]` feature. Typical use-cases are:\n\n- When you need a by-value trait objects.\n- When you really need a fast allocation of small temporary arrays.\n\nAnother pitfall is repetitive allocation and temporaries. Currently the compiler simply extends the stack frame every time it encounters an unsized assignment. So for example, the code\n\n```rust\n#![feature(unsized_locals)]\n\nfn main() {\n let x: Box<[i32]> = Box::new([1, 2, 3, 4, 5]);\n let _x = {{{{{{{{{{*x}}}}}}}}}};\n}\n```\n\nand the code\n\n```rust\n#![feature(unsized_locals)]\n\nfn main() {\n for _ in 0..10 {\n let x: Box<[i32]> = Box::new([1, 2, 3, 4, 5]);\n let _x = *x;\n }\n}\n```\n\nwill unnecessarily extend the stack frame.\n" } , LintCompletion { label : "infer_static_outlives_requirements" , description : "# `infer_static_outlives_requirements`\n\nThe tracking issue for this feature is: [#54185]\n\n[#54185]: https://github.com/rust-lang/rust/issues/54185\n\n------------------------\nThe `infer_static_outlives_requirements` feature indicates that certain\n`'static` outlives requirements can be inferred by the compiler rather than\nstating them explicitly.\n\nNote: It is an accompanying feature to `infer_outlives_requirements`,\nwhich must be enabled to infer outlives requirements.\n\nFor example, currently generic struct definitions that contain\nreferences, require where-clauses of the form T: 'static. By using\nthis feature the outlives predicates will be inferred, although\nthey may still be written explicitly.\n\n```rust,ignore (pseudo-Rust)\nstruct Foo<U> where U: 'static { // <-- currently required\n bar: Bar<U>\n}\nstruct Bar<T: 'static> {\n x: T,\n}\n```\n\n\n## Examples:\n\n```rust,ignore (pseudo-Rust)\n#![feature(infer_outlives_requirements)]\n#![feature(infer_static_outlives_requirements)]\n\n#[rustc_outlives]\n// Implicitly infer U: 'static\nstruct Foo<U> {\n bar: Bar<U>\n}\nstruct Bar<T: 'static> {\n x: T,\n}\n```\n\n" } , LintCompletion { label : "const_fn" , description : "# `const_fn`\n\nThe tracking issue for this feature is: [#57563]\n\n[#57563]: https://github.com/rust-lang/rust/issues/57563\n\n------------------------\n\nThe `const_fn` feature allows marking free functions and inherent methods as\n`const`, enabling them to be called in constants contexts, with constant\narguments.\n\n## Examples\n\n```rust\n#![feature(const_fn)]\n\nconst fn double(x: i32) -> i32 {\n x * 2\n}\n\nconst FIVE: i32 = 5;\nconst TEN: i32 = double(FIVE);\n\nfn main() {\n assert_eq!(5, FIVE);\n assert_eq!(10, TEN);\n}\n```\n" } , LintCompletion { label : "custom_test_frameworks" , description : "# `custom_test_frameworks`\n\nThe tracking issue for this feature is: [#50297]\n\n[#50297]: https://github.com/rust-lang/rust/issues/50297\n\n------------------------\n\nThe `custom_test_frameworks` feature allows the use of `#[test_case]` and `#![test_runner]`.\nAny function, const, or static can be annotated with `#[test_case]` causing it to be aggregated (like `#[test]`)\nand be passed to the test runner determined by the `#![test_runner]` crate attribute.\n\n```rust\n#![feature(custom_test_frameworks)]\n#![test_runner(my_runner)]\n\nfn my_runner(tests: &[&i32]) {\n for t in tests {\n if **t == 0 {\n println!(\"PASSED\");\n } else {\n println!(\"FAILED\");\n }\n }\n}\n\n#[test_case]\nconst WILL_PASS: i32 = 0;\n\n#[test_case]\nconst WILL_FAIL: i32 = 4;\n```\n\n" } , LintCompletion { label : "or_patterns" , description : "# `or_patterns`\n\nThe tracking issue for this feature is: [#54883]\n\n[#54883]: https://github.com/rust-lang/rust/issues/54883\n\n------------------------\n\nThe `or_pattern` language feature allows `|` to be arbitrarily nested within\na pattern, for example, `Some(A(0) | B(1 | 2))` becomes a valid pattern.\n\n## Examples\n\n```rust,ignore\n#![feature(or_patterns)]\n\npub enum Foo {\n Bar,\n Baz,\n Quux,\n}\n\npub fn example(maybe_foo: Option<Foo>) {\n match maybe_foo {\n Some(Foo::Bar | Foo::Baz) => {\n println!(\"The value contained `Bar` or `Baz`\");\n }\n Some(_) => {\n println!(\"The value did not contain `Bar` or `Baz`\");\n }\n None => {\n println!(\"The value was `None`\");\n }\n }\n}\n```\n" } , LintCompletion { label : "marker_trait_attr" , description : "# `marker_trait_attr`\n\nThe tracking issue for this feature is: [#29864]\n\n[#29864]: https://github.com/rust-lang/rust/issues/29864\n\n------------------------\n\nNormally, Rust keeps you from adding trait implementations that could\noverlap with each other, as it would be ambiguous which to use. This\nfeature, however, carves out an exception to that rule: a trait can\nopt-in to having overlapping implementations, at the cost that those\nimplementations are not allowed to override anything (and thus the\ntrait itself cannot have any associated items, as they're pointless\nwhen they'd need to do the same thing for every type anyway).\n\n```rust\n#![feature(marker_trait_attr)]\n\n#[marker] trait CheapToClone: Clone {}\n\nimpl<T: Copy> CheapToClone for T {}\n\n// These could potentially overlap with the blanket implementation above,\n// so are only allowed because CheapToClone is a marker trait.\nimpl<T: CheapToClone, U: CheapToClone> CheapToClone for (T, U) {}\nimpl<T: CheapToClone> CheapToClone for std::ops::Range<T> {}\n\nfn cheap_clone<T: CheapToClone>(t: T) -> T {\n t.clone()\n}\n```\n\nThis is expected to replace the unstable `overlapping_marker_traits`\nfeature, which applied to all empty traits (without needing an opt-in).\n" } , LintCompletion { label : "compiler_builtins" , description : "# `compiler_builtins`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "member_constraints" , description : "# `member_constraints`\n\nThe tracking issue for this feature is: [#61997]\n\n[#61997]: https://github.com/rust-lang/rust/issues/61997\n\n------------------------\n\nThe `member_constraints` feature gate lets you use `impl Trait` syntax with\nmultiple unrelated lifetime parameters.\n\nA simple example is:\n\n```rust\n#![feature(member_constraints)]\n\ntrait Trait<'a, 'b> { }\nimpl<T> Trait<'_, '_> for T {}\n\nfn foo<'a, 'b>(x: &'a u32, y: &'b u32) -> impl Trait<'a, 'b> {\n (x, y)\n}\n\nfn main() { }\n```\n\nWithout the `member_constraints` feature gate, the above example is an\nerror because both `'a` and `'b` appear in the impl Trait bounds, but\nneither outlives the other.\n" } , LintCompletion { label : "link_cfg" , description : "# `link_cfg`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "plugin_registrar" , description : "# `plugin_registrar`\n\nThe tracking issue for this feature is: [#29597]\n\n[#29597]: https://github.com/rust-lang/rust/issues/29597\n\nThis feature is part of \"compiler plugins.\" It will often be used with the\n[`plugin`] and `rustc_private` features as well. For more details, see\ntheir docs.\n\n[`plugin`]: plugin.md\n\n------------------------\n" } , LintCompletion { label : "abi_thiscall" , description : "# `abi_thiscall`\n\nThe tracking issue for this feature is: [#42202]\n\n[#42202]: https://github.com/rust-lang/rust/issues/42202\n\n------------------------\n\nThe MSVC ABI on x86 Windows uses the `thiscall` calling convention for C++\ninstance methods by default; it is identical to the usual (C) calling\nconvention on x86 Windows except that the first parameter of the method,\nthe `this` pointer, is passed in the ECX register.\n" } , LintCompletion { label : "c_variadic" , description : "# `c_variadic`\n\nThe tracking issue for this feature is: [#44930]\n\n[#44930]: https://github.com/rust-lang/rust/issues/44930\n\n------------------------\n\nThe `c_variadic` language feature enables C-variadic functions to be\ndefined in Rust. The may be called both from within Rust and via FFI.\n\n## Examples\n\n```rust\n#![feature(c_variadic)]\n\npub unsafe extern \"C\" fn add(n: usize, mut args: ...) -> usize {\n let mut sum = 0;\n for _ in 0..n {\n sum += args.arg::<usize>();\n }\n sum\n}\n```\n" } , LintCompletion { label : "ffi_pure" , description : "# `ffi_pure`\n\nThe tracking issue for this feature is: [#58329]\n\n------\n\nThe `#[ffi_pure]` attribute applies clang's `pure` attribute to foreign\nfunctions declarations.\n\nThat is, `#[ffi_pure]` functions shall have no effects except for its return\nvalue, which shall not change across two consecutive function calls with\nthe same parameters.\n\nApplying the `#[ffi_pure]` attribute to a function that violates these\nrequirements is undefined behavior.\n\nThis attribute enables Rust to perform common optimizations, like sub-expression\nelimination and loop optimizations. Some common examples of pure functions are\n`strlen` or `memcmp`.\n\nThese optimizations are only applicable when the compiler can prove that no\nprogram state observable by the `#[ffi_pure]` function has changed between calls\nof the function, which could alter the result. See also the `#[ffi_const]`\nattribute, which provides stronger guarantees regarding the allowable behavior\nof a function, enabling further optimization.\n\n## Pitfalls\n\nA `#[ffi_pure]` function can read global memory through the function\nparameters (e.g. pointers), globals, etc. `#[ffi_pure]` functions are not\nreferentially-transparent, and are therefore more relaxed than `#[ffi_const]`\nfunctions.\n\nHowever, accesing global memory through volatile or atomic reads can violate the\nrequirement that two consecutive function calls shall return the same value.\n\nA `pure` function that returns unit has no effect on the abstract machine's\nstate.\n\nA `#[ffi_pure]` function must not diverge, neither via a side effect (e.g. a\ncall to `abort`) nor by infinite loops.\n\nWhen translating C headers to Rust FFI, it is worth verifying for which targets\nthe `pure` attribute is enabled in those headers, and using the appropriate\n`cfg` macros in the Rust side to match those definitions. While the semantics of\n`pure` are implemented identically by many C and C++ compilers, e.g., clang,\n[GCC], [ARM C/C++ compiler], [IBM ILE C/C++], etc. they are not necessarily\nimplemented in this way on all of them. It is therefore also worth verifying\nthat the semantics of the C toolchain used to compile the binary being linked\nagainst are compatible with those of the `#[ffi_pure]`.\n\n\n[#58329]: https://github.com/rust-lang/rust/issues/58329\n[ARM C/C++ compiler]: http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0491c/Cacigdac.html\n[GCC]: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-pure-function-attribute\n[IBM ILE C/C++]: https://www.ibm.com/support/knowledgecenter/fr/ssw_ibm_i_71/rzarg/fn_attrib_pure.htm\n" } , LintCompletion { label : "cfg_version" , description : "# `cfg_version`\n\nThe tracking issue for this feature is: [#64796]\n\n[#64796]: https://github.com/rust-lang/rust/issues/64796\n\n------------------------\n\nThe `cfg_version` feature makes it possible to execute different code\ndepending on the compiler version.\n\n## Examples\n\n```rust\n#![feature(cfg_version)]\n\n#[cfg(version(\"1.42\"))]\nfn a() {\n // ...\n}\n\n#[cfg(not(version(\"1.42\")))]\nfn a() {\n // ...\n}\n\nfn b() {\n if cfg!(version(\"1.42\")) {\n // ...\n } else {\n // ...\n }\n}\n```\n" } , LintCompletion { label : "doc_spotlight" , description : "# `doc_spotlight`\n\nThe tracking issue for this feature is: [#45040]\n\nThe `doc_spotlight` feature allows the use of the `spotlight` parameter to the `#[doc]` attribute,\nto \"spotlight\" a specific trait on the return values of functions. Adding a `#[doc(spotlight)]`\nattribute to a trait definition will make rustdoc print extra information for functions which return\na type that implements that trait. This attribute is applied to the `Iterator`, `io::Read`, and\n`io::Write` traits in the standard library.\n\nYou can do this on your own traits, like this:\n\n```\n#![feature(doc_spotlight)]\n\n#[doc(spotlight)]\npub trait MyTrait {}\n\npub struct MyStruct;\nimpl MyTrait for MyStruct {}\n\n/// The docs for this function will have an extra line about `MyStruct` implementing `MyTrait`,\n/// without having to write that yourself!\npub fn my_fn() -> MyStruct { MyStruct }\n```\n\nThis feature was originally implemented in PR [#45039].\n\n[#45040]: https://github.com/rust-lang/rust/issues/45040\n[#45039]: https://github.com/rust-lang/rust/pull/45039\n" } , LintCompletion { label : "arbitrary_enum_discriminant" , description : "# `arbitrary_enum_discriminant`\n\nThe tracking issue for this feature is: [#60553]\n\n[#60553]: https://github.com/rust-lang/rust/issues/60553\n\n------------------------\n\nThe `arbitrary_enum_discriminant` feature permits tuple-like and\nstruct-like enum variants with `#[repr(<int-type>)]` to have explicit discriminants.\n\n## Examples\n\n```rust\n#![feature(arbitrary_enum_discriminant)]\n\n#[allow(dead_code)]\n#[repr(u8)]\nenum Enum {\n Unit = 3,\n Tuple(u16) = 2,\n Struct {\n a: u8,\n b: u16,\n } = 1,\n}\n\nimpl Enum {\n fn tag(&self) -> u8 {\n unsafe { *(self as *const Self as *const u8) }\n }\n}\n\nassert_eq!(3, Enum::Unit.tag());\nassert_eq!(2, Enum::Tuple(5).tag());\nassert_eq!(1, Enum::Struct{a: 7, b: 11}.tag());\n```\n" } , LintCompletion { label : "cmse_nonsecure_entry" , description : "# `cmse_nonsecure_entry`\n\nThe tracking issue for this feature is: [#75835]\n\n[#75835]: https://github.com/rust-lang/rust/issues/75835\n\n------------------------\n\nThe [TrustZone-M\nfeature](https://developer.arm.com/documentation/100690/latest/) is available\nfor targets with the Armv8-M architecture profile (`thumbv8m` in their target\nname).\nLLVM, the Rust compiler and the linker are providing\n[support](https://developer.arm.com/documentation/ecm0359818/latest/) for the\nTrustZone-M feature.\n\nOne of the things provided, with this unstable feature, is the\n`cmse_nonsecure_entry` attribute. This attribute marks a Secure function as an\nentry function (see [section\n5.4](https://developer.arm.com/documentation/ecm0359818/latest/) for details).\nWith this attribute, the compiler will do the following:\n* add a special symbol on the function which is the `__acle_se_` prefix and the\n standard function name\n* constrain the number of parameters to avoid using the Non-Secure stack\n* before returning from the function, clear registers that might contain Secure\n information\n* use the `BXNS` instruction to return\n\nBecause the stack can not be used to pass parameters, there will be compilation\nerrors if:\n* the total size of all parameters is too big (for example more than four 32\n bits integers)\n* the entry function is not using a C ABI\n\nThe special symbol `__acle_se_` will be used by the linker to generate a secure\ngateway veneer.\n\n<!-- NOTE(ignore) this example is specific to thumbv8m targets -->\n\n``` rust,ignore\n#![feature(cmse_nonsecure_entry)]\n\n#[no_mangle]\n#[cmse_nonsecure_entry]\npub extern \"C\" fn entry_function(input: u32) -> u32 {\n input + 6\n}\n```\n\n``` text\n$ rustc --emit obj --crate-type lib --target thumbv8m.main-none-eabi function.rs\n$ arm-none-eabi-objdump -D function.o\n\n00000000 <entry_function>:\n 0: b580 push {r7, lr}\n 2: 466f mov r7, sp\n 4: b082 sub sp, #8\n 6: 9001 str r0, [sp, #4]\n 8: 1d81 adds r1, r0, #6\n a: 460a mov r2, r1\n c: 4281 cmp r1, r0\n e: 9200 str r2, [sp, #0]\n 10: d30b bcc.n 2a <entry_function+0x2a>\n 12: e7ff b.n 14 <entry_function+0x14>\n 14: 9800 ldr r0, [sp, #0]\n 16: b002 add sp, #8\n 18: e8bd 4080 ldmia.w sp!, {r7, lr}\n 1c: 4671 mov r1, lr\n 1e: 4672 mov r2, lr\n 20: 4673 mov r3, lr\n 22: 46f4 mov ip, lr\n 24: f38e 8800 msr CPSR_f, lr\n 28: 4774 bxns lr\n 2a: f240 0000 movw r0, #0\n 2e: f2c0 0000 movt r0, #0\n 32: f240 0200 movw r2, #0\n 36: f2c0 0200 movt r2, #0\n 3a: 211c movs r1, #28\n 3c: f7ff fffe bl 0 <_ZN4core9panicking5panic17h5c028258ca2fb3f5E>\n 40: defe udf #254 ; 0xfe\n```\n" } , LintCompletion { label : "const_eval_limit" , description : "# `const_eval_limit`\n\nThe tracking issue for this feature is: [#67217]\n\n[#67217]: https://github.com/rust-lang/rust/issues/67217\n\nThe `const_eval_limit` allows someone to limit the evaluation steps the CTFE undertakes to evaluate a `const fn`.\n" } , LintCompletion { label : "external_doc" , description : "# `external_doc`\n\nThe tracking issue for this feature is: [#44732]\n\nThe `external_doc` feature allows the use of the `include` parameter to the `#[doc]` attribute, to\ninclude external files in documentation. Use the attribute in place of, or in addition to, regular\ndoc comments and `#[doc]` attributes, and `rustdoc` will load the given file when it renders\ndocumentation for your crate.\n\nWith the following files in the same directory:\n\n`external-doc.md`:\n\n```markdown\n# My Awesome Type\n\nThis is the documentation for this spectacular type.\n```\n\n`lib.rs`:\n\n```no_run (needs-external-files)\n#![feature(external_doc)]\n\n#[doc(include = \"external-doc.md\")]\npub struct MyAwesomeType;\n```\n\n`rustdoc` will load the file `external-doc.md` and use it as the documentation for the `MyAwesomeType`\nstruct.\n\nWhen locating files, `rustdoc` will base paths in the `src/` directory, as if they were alongside the\n`lib.rs` for your crate. So if you want a `docs/` folder to live alongside the `src/` directory,\nstart your paths with `../docs/` for `rustdoc` to properly find the file.\n\nThis feature was proposed in [RFC #1990] and initially implemented in PR [#44781].\n\n[#44732]: https://github.com/rust-lang/rust/issues/44732\n[RFC #1990]: https://github.com/rust-lang/rfcs/pull/1990\n[#44781]: https://github.com/rust-lang/rust/pull/44781\n" } , LintCompletion { label : "rustc_attrs" , description : "# `rustc_attrs`\n\nThis feature has no tracking issue, and is therefore internal to\nthe compiler, not being intended for general use.\n\nNote: `rustc_attrs` enables many rustc-internal attributes and this page\nonly discuss a few of them.\n\n------------------------\n\nThe `rustc_attrs` feature allows debugging rustc type layouts by using\n`#[rustc_layout(...)]` to debug layout at compile time (it even works\nwith `cargo check`) as an alternative to `rustc -Z print-type-sizes`\nthat is way more verbose.\n\nOptions provided by `#[rustc_layout(...)]` are `debug`, `size`, `align`,\n`abi`. Note that it only works on sized types without generics.\n\n## Examples\n\n```rust,ignore\n#![feature(rustc_attrs)]\n\n#[rustc_layout(abi, size)]\npub enum X {\n Y(u8, u8, u8),\n Z(isize),\n}\n```\n\nWhen that is compiled, the compiler will error with something like\n\n```text\nerror: abi: Aggregate { sized: true }\n --> src/lib.rs:4:1\n |\n4 | / pub enum T {\n5 | | Y(u8, u8, u8),\n6 | | Z(isize),\n7 | | }\n | |_^\n\nerror: size: Size { raw: 16 }\n --> src/lib.rs:4:1\n |\n4 | / pub enum T {\n5 | | Y(u8, u8, u8),\n6 | | Z(isize),\n7 | | }\n | |_^\n\nerror: aborting due to 2 previous errors\n```\n" } , LintCompletion { label : "allocator_internals" , description : "# `allocator_internals`\n\nThis feature does not have a tracking issue, it is an unstable implementation\ndetail of the `global_allocator` feature not intended for use outside the\ncompiler.\n\n------------------------\n" } , LintCompletion { label : "non_ascii_idents" , description : "# `non_ascii_idents`\n\nThe tracking issue for this feature is: [#55467]\n\n[#55467]: https://github.com/rust-lang/rust/issues/55467\n\n------------------------\n\nThe `non_ascii_idents` feature adds support for non-ASCII identifiers.\n\n## Examples\n\n```rust\n#![feature(non_ascii_idents)]\n\nconst ε: f64 = 0.00001f64;\nconst Π: f64 = 3.14f64;\n```\n\n## Changes to the language reference\n\n> **<sup>Lexer:<sup>** \n> IDENTIFIER : \n> &nbsp;&nbsp; &nbsp;&nbsp; XID_start XID_continue<sup>\\*</sup> \n> &nbsp;&nbsp; | `_` XID_continue<sup>+</sup> \n\nAn identifier is any nonempty Unicode string of the following form:\n\nEither\n\n * The first character has property [`XID_start`]\n * The remaining characters have property [`XID_continue`]\n\nOr\n\n * The first character is `_`\n * The identifier is more than one character, `_` alone is not an identifier\n * The remaining characters have property [`XID_continue`]\n\nthat does _not_ occur in the set of [strict keywords].\n\n> **Note**: [`XID_start`] and [`XID_continue`] as character properties cover the\n> character ranges used to form the more familiar C and Java language-family\n> identifiers.\n\n[`XID_start`]: http://unicode.org/cldr/utility/list-unicodeset.jsp?a=%5B%3AXID_Start%3A%5D&abb=on&g=&i=\n[`XID_continue`]: http://unicode.org/cldr/utility/list-unicodeset.jsp?a=%5B%3AXID_Continue%3A%5D&abb=on&g=&i=\n[strict keywords]: ../../reference/keywords.md#strict-keywords\n" } , LintCompletion { label : "try_blocks" , description : "# `try_blocks`\n\nThe tracking issue for this feature is: [#31436]\n\n[#31436]: https://github.com/rust-lang/rust/issues/31436\n\n------------------------\n\nThe `try_blocks` feature adds support for `try` blocks. A `try`\nblock creates a new scope one can use the `?` operator in.\n\n```rust,edition2018\n#![feature(try_blocks)]\n\nuse std::num::ParseIntError;\n\nlet result: Result<i32, ParseIntError> = try {\n \"1\".parse::<i32>()?\n + \"2\".parse::<i32>()?\n + \"3\".parse::<i32>()?\n};\nassert_eq!(result, Ok(6));\n\nlet result: Result<i32, ParseIntError> = try {\n \"1\".parse::<i32>()?\n + \"foo\".parse::<i32>()?\n + \"3\".parse::<i32>()?\n};\nassert!(result.is_err());\n```\n" } , LintCompletion { label : "box_patterns" , description : "# `box_patterns`\n\nThe tracking issue for this feature is: [#29641]\n\n[#29641]: https://github.com/rust-lang/rust/issues/29641\n\nSee also [`box_syntax`](box-syntax.md)\n\n------------------------\n\nBox patterns let you match on `Box<T>`s:\n\n\n```rust\n#![feature(box_patterns)]\n\nfn main() {\n let b = Some(Box::new(5));\n match b {\n Some(box n) if n < 0 => {\n println!(\"Box contains negative number {}\", n);\n },\n Some(box n) if n >= 0 => {\n println!(\"Box contains non-negative number {}\", n);\n },\n None => {\n println!(\"No box\");\n },\n _ => unreachable!()\n }\n}\n```\n" } , LintCompletion { label : "profiler_runtime" , description : "# `profiler_runtime`\n\nThe tracking issue for this feature is: [#42524](https://github.com/rust-lang/rust/issues/42524).\n\n------------------------\n" } , LintCompletion { label : "negative_impls" , description : "# `negative_impls`\n\nThe tracking issue for this feature is [#68318].\n\n[#68318]: https://github.com/rust-lang/rust/issues/68318\n\n----\n\nWith the feature gate `negative_impls`, you can write negative impls as well as positive ones:\n\n```rust\n#![feature(negative_impls)]\ntrait DerefMut { }\nimpl<T: ?Sized> !DerefMut for &T { }\n```\n\nNegative impls indicate a semver guarantee that the given trait will not be implemented for the given types. Negative impls play an additional purpose for auto traits, described below.\n\nNegative impls have the following characteristics:\n\n* They do not have any items.\n* They must obey the orphan rules as if they were a positive impl.\n* They cannot \"overlap\" with any positive impls.\n\n## Semver interaction\n\nIt is a breaking change to remove a negative impl. Negative impls are a commitment not to implement the given trait for the named types.\n\n## Orphan and overlap rules\n\nNegative impls must obey the same orphan rules as a positive impl. This implies you cannot add a negative impl for types defined in upstream crates and so forth.\n\nSimilarly, negative impls cannot overlap with positive impls, again using the same \"overlap\" check that we ordinarily use to determine if two impls overlap. (Note that positive impls typically cannot overlap with one another either, except as permitted by specialization.)\n\n## Interaction with auto traits\n\nDeclaring a negative impl `impl !SomeAutoTrait for SomeType` for an\nauto-trait serves two purposes:\n\n* as with any trait, it declares that `SomeType` will never implement `SomeAutoTrait`;\n* it disables the automatic `SomeType: SomeAutoTrait` impl that would otherwise have been generated.\n\nNote that, at present, there is no way to indicate that a given type\ndoes not implement an auto trait *but that it may do so in the\nfuture*. For ordinary types, this is done by simply not declaring any\nimpl at all, but that is not an option for auto traits. A workaround\nis that one could embed a marker type as one of the fields, where the\nmarker type is `!AutoTrait`.\n\n## Immediate uses\n\nNegative impls are used to declare that `&T: !DerefMut` and `&mut T: !Clone`, as required to fix the soundness of `Pin` described in [#66544](https://github.com/rust-lang/rust/issues/66544).\n\nThis serves two purposes:\n\n* For proving the correctness of unsafe code, we can use that impl as evidence that no `DerefMut` or `Clone` impl exists.\n* It prevents downstream crates from creating such impls.\n" } , LintCompletion { label : "box_syntax" , description : "# `box_syntax`\n\nThe tracking issue for this feature is: [#49733]\n\n[#49733]: https://github.com/rust-lang/rust/issues/49733\n\nSee also [`box_patterns`](box-patterns.md)\n\n------------------------\n\nCurrently the only stable way to create a `Box` is via the `Box::new` method.\nAlso it is not possible in stable Rust to destructure a `Box` in a match\npattern. The unstable `box` keyword can be used to create a `Box`. An example\nusage would be:\n\n```rust\n#![feature(box_syntax)]\n\nfn main() {\n let b = box 5;\n}\n```\n" } , LintCompletion { label : "derive_clone_copy" , description : "# `derive_clone_copy`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "llvm_asm" , description : "# `llvm_asm`\n\nThe tracking issue for this feature is: [#70173]\n\n[#70173]: https://github.com/rust-lang/rust/issues/70173\n\n------------------------\n\nFor extremely low-level manipulations and performance reasons, one\nmight wish to control the CPU directly. Rust supports using inline\nassembly to do this via the `llvm_asm!` macro.\n\n```rust,ignore\nllvm_asm!(assembly template\n : output operands\n : input operands\n : clobbers\n : options\n );\n```\n\nAny use of `llvm_asm` is feature gated (requires `#![feature(llvm_asm)]` on the\ncrate to allow) and of course requires an `unsafe` block.\n\n> **Note**: the examples here are given in x86/x86-64 assembly, but\n> all platforms are supported.\n\n## Assembly template\n\nThe `assembly template` is the only required parameter and must be a\nliteral string (i.e. `\"\"`)\n\n```rust\n#![feature(llvm_asm)]\n\n#[cfg(any(target_arch = \"x86\", target_arch = \"x86_64\"))]\nfn foo() {\n unsafe {\n llvm_asm!(\"NOP\");\n }\n}\n\n// Other platforms:\n#[cfg(not(any(target_arch = \"x86\", target_arch = \"x86_64\")))]\nfn foo() { /* ... */ }\n\nfn main() {\n // ...\n foo();\n // ...\n}\n```\n\n(The `feature(llvm_asm)` and `#[cfg]`s are omitted from now on.)\n\nOutput operands, input operands, clobbers and options are all optional\nbut you must add the right number of `:` if you skip them:\n\n```rust\n# #![feature(llvm_asm)]\n# #[cfg(any(target_arch = \"x86\", target_arch = \"x86_64\"))]\n# fn main() { unsafe {\nllvm_asm!(\"xor %eax, %eax\"\n :\n :\n : \"eax\"\n );\n# } }\n# #[cfg(not(any(target_arch = \"x86\", target_arch = \"x86_64\")))]\n# fn main() {}\n```\n\nWhitespace also doesn't matter:\n\n```rust\n# #![feature(llvm_asm)]\n# #[cfg(any(target_arch = \"x86\", target_arch = \"x86_64\"))]\n# fn main() { unsafe {\nllvm_asm!(\"xor %eax, %eax\" ::: \"eax\");\n# } }\n# #[cfg(not(any(target_arch = \"x86\", target_arch = \"x86_64\")))]\n# fn main() {}\n```\n\n## Operands\n\nInput and output operands follow the same format: `:\n\"constraints1\"(expr1), \"constraints2\"(expr2), ...\"`. Output operand\nexpressions must be mutable place, or not yet assigned:\n\n```rust\n# #![feature(llvm_asm)]\n# #[cfg(any(target_arch = \"x86\", target_arch = \"x86_64\"))]\nfn add(a: i32, b: i32) -> i32 {\n let c: i32;\n unsafe {\n llvm_asm!(\"add $2, $0\"\n : \"=r\"(c)\n : \"0\"(a), \"r\"(b)\n );\n }\n c\n}\n# #[cfg(not(any(target_arch = \"x86\", target_arch = \"x86_64\")))]\n# fn add(a: i32, b: i32) -> i32 { a + b }\n\nfn main() {\n assert_eq!(add(3, 14159), 14162)\n}\n```\n\nIf you would like to use real operands in this position, however,\nyou are required to put curly braces `{}` around the register that\nyou want, and you are required to put the specific size of the\noperand. This is useful for very low level programming, where\nwhich register you use is important:\n\n```rust\n# #![feature(llvm_asm)]\n# #[cfg(any(target_arch = \"x86\", target_arch = \"x86_64\"))]\n# unsafe fn read_byte_in(port: u16) -> u8 {\nlet result: u8;\nllvm_asm!(\"in %dx, %al\" : \"={al}\"(result) : \"{dx}\"(port));\nresult\n# }\n```\n\n## Clobbers\n\nSome instructions modify registers which might otherwise have held\ndifferent values so we use the clobbers list to indicate to the\ncompiler not to assume any values loaded into those registers will\nstay valid.\n\n```rust\n# #![feature(llvm_asm)]\n# #[cfg(any(target_arch = \"x86\", target_arch = \"x86_64\"))]\n# fn main() { unsafe {\n// Put the value 0x200 in eax:\nllvm_asm!(\"mov $$0x200, %eax\" : /* no outputs */ : /* no inputs */ : \"eax\");\n# } }\n# #[cfg(not(any(target_arch = \"x86\", target_arch = \"x86_64\")))]\n# fn main() {}\n```\n\nInput and output registers need not be listed since that information\nis already communicated by the given constraints. Otherwise, any other\nregisters used either implicitly or explicitly should be listed.\n\nIf the assembly changes the condition code register `cc` should be\nspecified as one of the clobbers. Similarly, if the assembly modifies\nmemory, `memory` should also be specified.\n\n## Options\n\nThe last section, `options` is specific to Rust. The format is comma\nseparated literal strings (i.e. `:\"foo\", \"bar\", \"baz\"`). It's used to\nspecify some extra info about the inline assembly:\n\nCurrent valid options are:\n\n1. `volatile` - specifying this is analogous to\n `__asm__ __volatile__ (...)` in gcc/clang.\n2. `alignstack` - certain instructions expect the stack to be\n aligned a certain way (i.e. SSE) and specifying this indicates to\n the compiler to insert its usual stack alignment code\n3. `intel` - use intel syntax instead of the default AT&T.\n\n```rust\n# #![feature(llvm_asm)]\n# #[cfg(any(target_arch = \"x86\", target_arch = \"x86_64\"))]\n# fn main() {\nlet result: i32;\nunsafe {\n llvm_asm!(\"mov eax, 2\" : \"={eax}\"(result) : : : \"intel\")\n}\nprintln!(\"eax is currently {}\", result);\n# }\n# #[cfg(not(any(target_arch = \"x86\", target_arch = \"x86_64\")))]\n# fn main() {}\n```\n\n## More Information\n\nThe current implementation of the `llvm_asm!` macro is a direct binding to [LLVM's\ninline assembler expressions][llvm-docs], so be sure to check out [their\ndocumentation as well][llvm-docs] for more information about clobbers,\nconstraints, etc.\n\n[llvm-docs]: http://llvm.org/docs/LangRef.html#inline-assembler-expressions\n\nIf you need more power and don't mind losing some of the niceties of\n`llvm_asm!`, check out [global_asm](global-asm.md).\n" } , LintCompletion { label : "windows_c" , description : "# `windows_c`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "fmt_internals" , description : "# `fmt_internals`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "trace_macros" , description : "# `trace_macros`\n\nThe tracking issue for this feature is [#29598].\n\n[#29598]: https://github.com/rust-lang/rust/issues/29598\n\n------------------------\n\nWith `trace_macros` you can trace the expansion of macros in your code.\n\n## Examples\n\n```rust\n#![feature(trace_macros)]\n\nfn main() {\n trace_macros!(true);\n println!(\"Hello, Rust!\");\n trace_macros!(false);\n}\n```\n\nThe `cargo build` output:\n\n```txt\nnote: trace_macro\n --> src/main.rs:5:5\n |\n5 | println!(\"Hello, Rust!\");\n | ^^^^^^^^^^^^^^^^^^^^^^^^^\n |\n = note: expanding `println! { \"Hello, Rust!\" }`\n = note: to `print ! ( concat ! ( \"Hello, Rust!\" , \"\\n\" ) )`\n = note: expanding `print! { concat ! ( \"Hello, Rust!\" , \"\\n\" ) }`\n = note: to `$crate :: io :: _print ( format_args ! ( concat ! ( \"Hello, Rust!\" , \"\\n\" ) )\n )`\n\n Finished dev [unoptimized + debuginfo] target(s) in 0.60 secs\n```\n" } , LintCompletion { label : "str_internals" , description : "# `str_internals`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "c_void_variant" , description : "# `c_void_variant`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "update_panic_count" , description : "# `update_panic_count`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "windows_net" , description : "# `windows_net`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "libstd_sys_internals" , description : "# `libstd_sys_internals`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "rt" , description : "# `rt`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "asm" , description : "# `asm`\n\nThe tracking issue for this feature is: [#72016]\n\n[#72016]: https://github.com/rust-lang/rust/issues/72016\n\n------------------------\n\nFor extremely low-level manipulations and performance reasons, one\nmight wish to control the CPU directly. Rust supports using inline\nassembly to do this via the `asm!` macro.\n\n# Guide-level explanation\n[guide-level-explanation]: #guide-level-explanation\n\nRust provides support for inline assembly via the `asm!` macro.\nIt can be used to embed handwritten assembly in the assembly output generated by the compiler.\nGenerally this should not be necessary, but might be where the required performance or timing\ncannot be otherwise achieved. Accessing low level hardware primitives, e.g. in kernel code, may also demand this functionality.\n\n> **Note**: the examples here are given in x86/x86-64 assembly, but other architectures are also supported.\n\nInline assembly is currently supported on the following architectures:\n- x86 and x86-64\n- ARM\n- AArch64\n- RISC-V\n- NVPTX\n- Hexagon\n- MIPS32r2 and MIPS64r2\n\n## Basic usage\n\nLet us start with the simplest possible example:\n\n```rust,allow_fail\n# #![feature(asm)]\nunsafe {\n asm!(\"nop\");\n}\n```\n\nThis will insert a NOP (no operation) instruction into the assembly generated by the compiler.\nNote that all `asm!` invocations have to be inside an `unsafe` block, as they could insert\narbitrary instructions and break various invariants. The instructions to be inserted are listed\nin the first argument of the `asm!` macro as a string literal.\n\n## Inputs and outputs\n\nNow inserting an instruction that does nothing is rather boring. Let us do something that\nactually acts on data:\n\n```rust,allow_fail\n# #![feature(asm)]\nlet x: u64;\nunsafe {\n asm!(\"mov {}, 5\", out(reg) x);\n}\nassert_eq!(x, 5);\n```\n\nThis will write the value `5` into the `u64` variable `x`.\nYou can see that the string literal we use to specify instructions is actually a template string.\nIt is governed by the same rules as Rust [format strings][format-syntax].\nThe arguments that are inserted into the template however look a bit different then you may\nbe familiar with. First we need to specify if the variable is an input or an output of the\ninline assembly. In this case it is an output. We declared this by writing `out`.\nWe also need to specify in what kind of register the assembly expects the variable.\nIn this case we put it in an arbitrary general purpose register by specifying `reg`.\nThe compiler will choose an appropriate register to insert into\nthe template and will read the variable from there after the inline assembly finishes executing.\n\nLet us see another example that also uses an input:\n\n```rust,allow_fail\n# #![feature(asm)]\nlet i: u64 = 3;\nlet o: u64;\nunsafe {\n asm!(\n \"mov {0}, {1}\",\n \"add {0}, {number}\",\n out(reg) o,\n in(reg) i,\n number = const 5,\n );\n}\nassert_eq!(o, 8);\n```\n\nThis will add `5` to the input in variable `i` and write the result to variable `o`.\nThe particular way this assembly does this is first copying the value from `i` to the output,\nand then adding `5` to it.\n\nThe example shows a few things:\n\nFirst, we can see that `asm!` allows multiple template string arguments; each\none is treated as a separate line of assembly code, as if they were all joined\ntogether with newlines between them. This makes it easy to format assembly\ncode.\n\nSecond, we can see that inputs are declared by writing `in` instead of `out`.\n\nThird, one of our operands has a type we haven't seen yet, `const`.\nThis tells the compiler to expand this argument to value directly inside the assembly template.\nThis is only possible for constants and literals.\n\nFourth, we can see that we can specify an argument number, or name as in any format string.\nFor inline assembly templates this is particularly useful as arguments are often used more than once.\nFor more complex inline assembly using this facility is generally recommended, as it improves\nreadability, and allows reordering instructions without changing the argument order.\n\nWe can further refine the above example to avoid the `mov` instruction:\n\n```rust,allow_fail\n# #![feature(asm)]\nlet mut x: u64 = 3;\nunsafe {\n asm!(\"add {0}, {number}\", inout(reg) x, number = const 5);\n}\nassert_eq!(x, 8);\n```\n\nWe can see that `inout` is used to specify an argument that is both input and output.\nThis is different from specifying an input and output separately in that it is guaranteed to assign both to the same register.\n\nIt is also possible to specify different variables for the input and output parts of an `inout` operand:\n\n```rust,allow_fail\n# #![feature(asm)]\nlet x: u64 = 3;\nlet y: u64;\nunsafe {\n asm!(\"add {0}, {number}\", inout(reg) x => y, number = const 5);\n}\nassert_eq!(y, 8);\n```\n\n## Late output operands\n\nThe Rust compiler is conservative with its allocation of operands. It is assumed that an `out`\ncan be written at any time, and can therefore not share its location with any other argument.\nHowever, to guarantee optimal performance it is important to use as few registers as possible,\nso they won't have to be saved and reloaded around the inline assembly block.\nTo achieve this Rust provides a `lateout` specifier. This can be used on any output that is\nwritten only after all inputs have been consumed.\nThere is also a `inlateout` variant of this specifier.\n\nHere is an example where `inlateout` *cannot* be used:\n\n```rust,allow_fail\n# #![feature(asm)]\nlet mut a: u64 = 4;\nlet b: u64 = 4;\nlet c: u64 = 4;\nunsafe {\n asm!(\n \"add {0}, {1}\",\n \"add {0}, {2}\",\n inout(reg) a,\n in(reg) b,\n in(reg) c,\n );\n}\nassert_eq!(a, 12);\n```\n\nHere the compiler is free to allocate the same register for inputs `b` and `c` since it knows they have the same value. However it must allocate a separate register for `a` since it uses `inout` and not `inlateout`. If `inlateout` was used, then `a` and `c` could be allocated to the same register, in which case the first instruction to overwrite the value of `c` and cause the assembly code to produce the wrong result.\n\nHowever the following example can use `inlateout` since the output is only modified after all input registers have been read:\n\n```rust,allow_fail\n# #![feature(asm)]\nlet mut a: u64 = 4;\nlet b: u64 = 4;\nunsafe {\n asm!(\"add {0}, {1}\", inlateout(reg) a, in(reg) b);\n}\nassert_eq!(a, 8);\n```\n\nAs you can see, this assembly fragment will still work correctly if `a` and `b` are assigned to the same register.\n\n## Explicit register operands\n\nSome instructions require that the operands be in a specific register.\nTherefore, Rust inline assembly provides some more specific constraint specifiers.\nWhile `reg` is generally available on any architecture, these are highly architecture specific. E.g. for x86 the general purpose registers `eax`, `ebx`, `ecx`, `edx`, `ebp`, `esi`, and `edi`\namong others can be addressed by their name.\n\n```rust,allow_fail,no_run\n# #![feature(asm)]\nlet cmd = 0xd1;\nunsafe {\n asm!(\"out 0x64, eax\", in(\"eax\") cmd);\n}\n```\n\nIn this example we call the `out` instruction to output the content of the `cmd` variable\nto port `0x64`. Since the `out` instruction only accepts `eax` (and its sub registers) as operand\nwe had to use the `eax` constraint specifier.\n\nNote that unlike other operand types, explicit register operands cannot be used in the template string: you can't use `{}` and should write the register name directly instead. Also, they must appear at the end of the operand list after all other operand types.\n\nConsider this example which uses the x86 `mul` instruction:\n\n```rust,allow_fail\n# #![feature(asm)]\nfn mul(a: u64, b: u64) -> u128 {\n let lo: u64;\n let hi: u64;\n\n unsafe {\n asm!(\n // The x86 mul instruction takes rax as an implicit input and writes\n // the 128-bit result of the multiplication to rax:rdx.\n \"mul {}\",\n in(reg) a,\n inlateout(\"rax\") b => lo,\n lateout(\"rdx\") hi\n );\n }\n\n ((hi as u128) << 64) + lo as u128\n}\n```\n\nThis uses the `mul` instruction to multiply two 64-bit inputs with a 128-bit result.\nThe only explicit operand is a register, that we fill from the variable `a`.\nThe second operand is implicit, and must be the `rax` register, which we fill from the variable `b`.\nThe lower 64 bits of the result are stored in `rax` from which we fill the variable `lo`.\nThe higher 64 bits are stored in `rdx` from which we fill the variable `hi`.\n\n## Clobbered registers\n\nIn many cases inline assembly will modify state that is not needed as an output.\nUsually this is either because we have to use a scratch register in the assembly,\nor instructions modify state that we don't need to further examine.\nThis state is generally referred to as being \"clobbered\".\nWe need to tell the compiler about this since it may need to save and restore this state\naround the inline assembly block.\n\n```rust,allow_fail\n# #![feature(asm)]\nlet ebx: u32;\nlet ecx: u32;\n\nunsafe {\n asm!(\n \"cpuid\",\n // EAX 4 selects the \"Deterministic Cache Parameters\" CPUID leaf\n inout(\"eax\") 4 => _,\n // ECX 0 selects the L0 cache information.\n inout(\"ecx\") 0 => ecx,\n lateout(\"ebx\") ebx,\n lateout(\"edx\") _,\n );\n}\n\nprintln!(\n \"L1 Cache: {}\",\n ((ebx >> 22) + 1) * (((ebx >> 12) & 0x3ff) + 1) * ((ebx & 0xfff) + 1) * (ecx + 1)\n);\n```\n\nIn the example above we use the `cpuid` instruction to get the L1 cache size.\nThis instruction writes to `eax`, `ebx`, `ecx`, and `edx`, but for the cache size we only care about the contents of `ebx` and `ecx`.\n\nHowever we still need to tell the compiler that `eax` and `edx` have been modified so that it can save any values that were in these registers before the asm. This is done by declaring these as outputs but with `_` instead of a variable name, which indicates that the output value is to be discarded.\n\nThis can also be used with a general register class (e.g. `reg`) to obtain a scratch register for use inside the asm code:\n\n```rust,allow_fail\n# #![feature(asm)]\n// Multiply x by 6 using shifts and adds\nlet mut x: u64 = 4;\nunsafe {\n asm!(\n \"mov {tmp}, {x}\",\n \"shl {tmp}, 1\",\n \"shl {x}, 2\",\n \"add {x}, {tmp}\",\n x = inout(reg) x,\n tmp = out(reg) _,\n );\n}\nassert_eq!(x, 4 * 6);\n```\n\n## Symbol operands\n\nA special operand type, `sym`, allows you to use the symbol name of a `fn` or `static` in inline assembly code.\nThis allows you to call a function or access a global variable without needing to keep its address in a register.\n\n```rust,allow_fail\n# #![feature(asm)]\nextern \"C\" fn foo(arg: i32) {\n println!(\"arg = {}\", arg);\n}\n\nfn call_foo(arg: i32) {\n unsafe {\n asm!(\n \"call {}\",\n sym foo,\n // 1st argument in rdi, which is caller-saved\n inout(\"rdi\") arg => _,\n // All caller-saved registers must be marked as clobberred\n out(\"rax\") _, out(\"rcx\") _, out(\"rdx\") _, out(\"rsi\") _,\n out(\"r8\") _, out(\"r9\") _, out(\"r10\") _, out(\"r11\") _,\n out(\"xmm0\") _, out(\"xmm1\") _, out(\"xmm2\") _, out(\"xmm3\") _,\n out(\"xmm4\") _, out(\"xmm5\") _, out(\"xmm6\") _, out(\"xmm7\") _,\n out(\"xmm8\") _, out(\"xmm9\") _, out(\"xmm10\") _, out(\"xmm11\") _,\n out(\"xmm12\") _, out(\"xmm13\") _, out(\"xmm14\") _, out(\"xmm15\") _,\n )\n }\n}\n```\n\nNote that the `fn` or `static` item does not need to be public or `#[no_mangle]`:\nthe compiler will automatically insert the appropriate mangled symbol name into the assembly code.\n\n## Register template modifiers\n\nIn some cases, fine control is needed over the way a register name is formatted when inserted into the template string. This is needed when an architecture's assembly language has several names for the same register, each typically being a \"view\" over a subset of the register (e.g. the low 32 bits of a 64-bit register).\n\nBy default the compiler will always choose the name that refers to the full register size (e.g. `rax` on x86-64, `eax` on x86, etc).\n\nThis default can be overriden by using modifiers on the template string operands, just like you would with format strings:\n\n```rust,allow_fail\n# #![feature(asm)]\nlet mut x: u16 = 0xab;\n\nunsafe {\n asm!(\"mov {0:h}, {0:l}\", inout(reg_abcd) x);\n}\n\nassert_eq!(x, 0xabab);\n```\n\nIn this example, we use the `reg_abcd` register class to restrict the register allocator to the 4 legacy x86 register (`ax`, `bx`, `cx`, `dx`) of which the first two bytes can be addressed independently.\n\nLet us assume that the register allocator has chosen to allocate `x` in the `ax` register.\nThe `h` modifier will emit the register name for the high byte of that register and the `l` modifier will emit the register name for the low byte. The asm code will therefore be expanded as `mov ah, al` which copies the low byte of the value into the high byte.\n\nIf you use a smaller data type (e.g. `u16`) with an operand and forget the use template modifiers, the compiler will emit a warning and suggest the correct modifier to use.\n\n## Memory address operands\n\nSometimes assembly instructions require operands passed via memory addresses/memory locations.\nYou have to manually use the memory address syntax specified by the respectively architectures.\nFor example, in x86/x86_64 and intel assembly syntax, you should wrap inputs/outputs in `[]`\nto indicate they are memory operands:\n\n```rust,allow_fail\n# #![feature(asm, llvm_asm)]\n# fn load_fpu_control_word(control: u16) {\nunsafe {\n asm!(\"fldcw [{}]\", in(reg) &control, options(nostack));\n\n // Previously this would have been written with the deprecated `llvm_asm!` like this\n llvm_asm!(\"fldcw $0\" :: \"m\" (control) :: \"volatile\");\n}\n# }\n```\n\n## Options\n\nBy default, an inline assembly block is treated the same way as an external FFI function call with a custom calling convention: it may read/write memory, have observable side effects, etc. However in many cases, it is desirable to give the compiler more information about what the assembly code is actually doing so that it can optimize better.\n\nLet's take our previous example of an `add` instruction:\n\n```rust,allow_fail\n# #![feature(asm)]\nlet mut a: u64 = 4;\nlet b: u64 = 4;\nunsafe {\n asm!(\n \"add {0}, {1}\",\n inlateout(reg) a, in(reg) b,\n options(pure, nomem, nostack),\n );\n}\nassert_eq!(a, 8);\n```\n\nOptions can be provided as an optional final argument to the `asm!` macro. We specified three options here:\n- `pure` means that the asm code has no observable side effects and that its output depends only on its inputs. This allows the compiler optimizer to call the inline asm fewer times or even eliminate it entirely.\n- `nomem` means that the asm code does not read or write to memory. By default the compiler will assume that inline assembly can read or write any memory address that is accessible to it (e.g. through a pointer passed as an operand, or a global).\n- `nostack` means that the asm code does not push any data onto the stack. This allows the compiler to use optimizations such as the stack red zone on x86-64 to avoid stack pointer adjustments.\n\nThese allow the compiler to better optimize code using `asm!`, for example by eliminating pure `asm!` blocks whose outputs are not needed.\n\nSee the reference for the full list of available options and their effects.\n\n# Reference-level explanation\n[reference-level-explanation]: #reference-level-explanation\n\nInline assembler is implemented as an unsafe macro `asm!()`.\nThe first argument to this macro is a template string literal used to build the final assembly.\nThe following arguments specify input and output operands.\nWhen required, options are specified as the final argument.\n\nThe following ABNF specifies the general syntax:\n\n```ignore\ndir_spec := \"in\" / \"out\" / \"lateout\" / \"inout\" / \"inlateout\"\nreg_spec := <register class> / \"<explicit register>\"\noperand_expr := expr / \"_\" / expr \"=>\" expr / expr \"=>\" \"_\"\nreg_operand := dir_spec \"(\" reg_spec \")\" operand_expr\noperand := reg_operand / \"const\" const_expr / \"sym\" path\noption := \"pure\" / \"nomem\" / \"readonly\" / \"preserves_flags\" / \"noreturn\" / \"nostack\" / \"att_syntax\"\noptions := \"options(\" option *[\",\" option] [\",\"] \")\"\nasm := \"asm!(\" format_string *(\",\" format_string) *(\",\" [ident \"=\"] operand) [\",\" options] [\",\"] \")\"\n```\n\nThe macro will initially be supported only on ARM, AArch64, Hexagon, x86, x86-64 and RISC-V targets. Support for more targets may be added in the future. The compiler will emit an error if `asm!` is used on an unsupported target.\n\n[format-syntax]: https://doc.rust-lang.org/std/fmt/#syntax\n\n## Template string arguments\n\nThe assembler template uses the same syntax as [format strings][format-syntax] (i.e. placeholders are specified by curly braces). The corresponding arguments are accessed in order, by index, or by name. However, implicit named arguments (introduced by [RFC #2795][rfc-2795]) are not supported.\n\nAn `asm!` invocation may have one or more template string arguments; an `asm!` with multiple template string arguments is treated as if all the strings were concatenated with a `\\n` between them. The expected usage is for each template string argument to correspond to a line of assembly code. All template string arguments must appear before any other arguments.\n\nAs with format strings, named arguments must appear after positional arguments. Explicit register operands must appear at the end of the operand list, after named arguments if any.\n\nExplicit register operands cannot be used by placeholders in the template string. All other named and positional operands must appear at least once in the template string, otherwise a compiler error is generated.\n\nThe exact assembly code syntax is target-specific and opaque to the compiler except for the way operands are substituted into the template string to form the code passed to the assembler.\n\nThe 5 targets specified in this RFC (x86, ARM, AArch64, RISC-V, Hexagon) all use the assembly code syntax of the GNU assembler (GAS). On x86, the `.intel_syntax noprefix` mode of GAS is used by default. On ARM, the `.syntax unified` mode is used. These targets impose an additional restriction on the assembly code: any assembler state (e.g. the current section which can be changed with `.section`) must be restored to its original value at the end of the asm string. Assembly code that does not conform to the GAS syntax will result in assembler-specific behavior.\n\n[rfc-2795]: https://github.com/rust-lang/rfcs/pull/2795\n\n## Operand type\n\nSeveral types of operands are supported:\n\n* `in(<reg>) <expr>`\n - `<reg>` can refer to a register class or an explicit register. The allocated register name is substituted into the asm template string.\n - The allocated register will contain the value of `<expr>` at the start of the asm code.\n - The allocated register must contain the same value at the end of the asm code (except if a `lateout` is allocated to the same register).\n* `out(<reg>) <expr>`\n - `<reg>` can refer to a register class or an explicit register. The allocated register name is substituted into the asm template string.\n - The allocated register will contain an undefined value at the start of the asm code.\n - `<expr>` must be a (possibly uninitialized) place expression, to which the contents of the allocated register is written to at the end of the asm code.\n - An underscore (`_`) may be specified instead of an expression, which will cause the contents of the register to be discarded at the end of the asm code (effectively acting as a clobber).\n* `lateout(<reg>) <expr>`\n - Identical to `out` except that the register allocator can reuse a register allocated to an `in`.\n - You should only write to the register after all inputs are read, otherwise you may clobber an input.\n* `inout(<reg>) <expr>`\n - `<reg>` can refer to a register class or an explicit register. The allocated register name is substituted into the asm template string.\n - The allocated register will contain the value of `<expr>` at the start of the asm code.\n - `<expr>` must be a mutable initialized place expression, to which the contents of the allocated register is written to at the end of the asm code.\n* `inout(<reg>) <in expr> => <out expr>`\n - Same as `inout` except that the initial value of the register is taken from the value of `<in expr>`.\n - `<out expr>` must be a (possibly uninitialized) place expression, to which the contents of the allocated register is written to at the end of the asm code.\n - An underscore (`_`) may be specified instead of an expression for `<out expr>`, which will cause the contents of the register to be discarded at the end of the asm code (effectively acting as a clobber).\n - `<in expr>` and `<out expr>` may have different types.\n* `inlateout(<reg>) <expr>` / `inlateout(<reg>) <in expr> => <out expr>`\n - Identical to `inout` except that the register allocator can reuse a register allocated to an `in` (this can happen if the compiler knows the `in` has the same initial value as the `inlateout`).\n - You should only write to the register after all inputs are read, otherwise you may clobber an input.\n* `const <expr>`\n - `<expr>` must be an integer or floating-point constant expression.\n - The value of the expression is formatted as a string and substituted directly into the asm template string.\n* `sym <path>`\n - `<path>` must refer to a `fn` or `static`.\n - A mangled symbol name referring to the item is substituted into the asm template string.\n - The substituted string does not include any modifiers (e.g. GOT, PLT, relocations, etc).\n - `<path>` is allowed to point to a `#[thread_local]` static, in which case the asm code can combine the symbol with relocations (e.g. `@plt`, `@TPOFF`) to read from thread-local data.\n\nOperand expressions are evaluated from left to right, just like function call arguments. After the `asm!` has executed, outputs are written to in left to right order. This is significant if two outputs point to the same place: that place will contain the value of the rightmost output.\n\n## Register operands\n\nInput and output operands can be specified either as an explicit register or as a register class from which the register allocator can select a register. Explicit registers are specified as string literals (e.g. `\"eax\"`) while register classes are specified as identifiers (e.g. `reg`). Using string literals for register names enables support for architectures that use special characters in register names, such as MIPS (`$0`, `$1`, etc).\n\nNote that explicit registers treat register aliases (e.g. `r14` vs `lr` on ARM) and smaller views of a register (e.g. `eax` vs `rax`) as equivalent to the base register. It is a compile-time error to use the same explicit register for two input operands or two output operands. Additionally, it is also a compile-time error to use overlapping registers (e.g. ARM VFP) in input operands or in output operands.\n\nOnly the following types are allowed as operands for inline assembly:\n- Integers (signed and unsigned)\n- Floating-point numbers\n- Pointers (thin only)\n- Function pointers\n- SIMD vectors (structs defined with `#[repr(simd)]` and which implement `Copy`). This includes architecture-specific vector types defined in `std::arch` such as `__m128` (x86) or `int8x16_t` (ARM).\n\nHere is the list of currently supported register classes:\n\n| Architecture | Register class | Registers | LLVM constraint code |\n| ------------ | -------------- | --------- | -------------------- |\n| x86 | `reg` | `ax`, `bx`, `cx`, `dx`, `si`, `di`, `r[8-15]` (x86-64 only) | `r` |\n| x86 | `reg_abcd` | `ax`, `bx`, `cx`, `dx` | `Q` |\n| x86-32 | `reg_byte` | `al`, `bl`, `cl`, `dl`, `ah`, `bh`, `ch`, `dh` | `q` |\n| x86-64 | `reg_byte` | `al`, `bl`, `cl`, `dl`, `sil`, `dil`, `r[8-15]b`, `ah`\\*, `bh`\\*, `ch`\\*, `dh`\\* | `q` |\n| x86 | `xmm_reg` | `xmm[0-7]` (x86) `xmm[0-15]` (x86-64) | `x` |\n| x86 | `ymm_reg` | `ymm[0-7]` (x86) `ymm[0-15]` (x86-64) | `x` |\n| x86 | `zmm_reg` | `zmm[0-7]` (x86) `zmm[0-31]` (x86-64) | `v` |\n| x86 | `kreg` | `k[1-7]` | `Yk` |\n| AArch64 | `reg` | `x[0-28]`, `x30` | `r` |\n| AArch64 | `vreg` | `v[0-31]` | `w` |\n| AArch64 | `vreg_low16` | `v[0-15]` | `x` |\n| ARM | `reg` | `r[0-5]` `r7`\\*, `r[8-10]`, `r11`\\*, `r12`, `r14` | `r` |\n| ARM (Thumb) | `reg_thumb` | `r[0-r7]` | `l` |\n| ARM (ARM) | `reg_thumb` | `r[0-r10]`, `r12`, `r14` | `l` |\n| ARM | `sreg` | `s[0-31]` | `t` |\n| ARM | `sreg_low16` | `s[0-15]` | `x` |\n| ARM | `dreg` | `d[0-31]` | `w` |\n| ARM | `dreg_low16` | `d[0-15]` | `t` |\n| ARM | `dreg_low8` | `d[0-8]` | `x` |\n| ARM | `qreg` | `q[0-15]` | `w` |\n| ARM | `qreg_low8` | `q[0-7]` | `t` |\n| ARM | `qreg_low4` | `q[0-3]` | `x` |\n| MIPS | `reg` | `$[2-25]` | `r` |\n| MIPS | `freg` | `$f[0-31]` | `f` |\n| NVPTX | `reg16` | None\\* | `h` |\n| NVPTX | `reg32` | None\\* | `r` |\n| NVPTX | `reg64` | None\\* | `l` |\n| RISC-V | `reg` | `x1`, `x[5-7]`, `x[9-15]`, `x[16-31]` (non-RV32E) | `r` |\n| RISC-V | `freg` | `f[0-31]` | `f` |\n| Hexagon | `reg` | `r[0-28]` | `r` |\n\n> **Note**: On x86 we treat `reg_byte` differently from `reg` because the compiler can allocate `al` and `ah` separately whereas `reg` reserves the whole register.\n>\n> Note #2: On x86-64 the high byte registers (e.g. `ah`) are only available when used as an explicit register. Specifying the `reg_byte` register class for an operand will always allocate a low byte register.\n>\n> Note #3: NVPTX doesn't have a fixed register set, so named registers are not supported.\n>\n> Note #4: On ARM the frame pointer is either `r7` or `r11` depending on the platform.\n\nAdditional register classes may be added in the future based on demand (e.g. MMX, x87, etc).\n\nEach register class has constraints on which value types they can be used with. This is necessary because the way a value is loaded into a register depends on its type. For example, on big-endian systems, loading a `i32x4` and a `i8x16` into a SIMD register may result in different register contents even if the byte-wise memory representation of both values is identical. The availability of supported types for a particular register class may depend on what target features are currently enabled.\n\n| Architecture | Register class | Target feature | Allowed types |\n| ------------ | -------------- | -------------- | ------------- |\n| x86-32 | `reg` | None | `i16`, `i32`, `f32` |\n| x86-64 | `reg` | None | `i16`, `i32`, `f32`, `i64`, `f64` |\n| x86 | `reg_byte` | None | `i8` |\n| x86 | `xmm_reg` | `sse` | `i32`, `f32`, `i64`, `f64`, <br> `i8x16`, `i16x8`, `i32x4`, `i64x2`, `f32x4`, `f64x2` |\n| x86 | `ymm_reg` | `avx` | `i32`, `f32`, `i64`, `f64`, <br> `i8x16`, `i16x8`, `i32x4`, `i64x2`, `f32x4`, `f64x2` <br> `i8x32`, `i16x16`, `i32x8`, `i64x4`, `f32x8`, `f64x4` |\n| x86 | `zmm_reg` | `avx512f` | `i32`, `f32`, `i64`, `f64`, <br> `i8x16`, `i16x8`, `i32x4`, `i64x2`, `f32x4`, `f64x2` <br> `i8x32`, `i16x16`, `i32x8`, `i64x4`, `f32x8`, `f64x4` <br> `i8x64`, `i16x32`, `i32x16`, `i64x8`, `f32x16`, `f64x8` |\n| x86 | `kreg` | `axv512f` | `i8`, `i16` |\n| x86 | `kreg` | `axv512bw` | `i32`, `i64` |\n| AArch64 | `reg` | None | `i8`, `i16`, `i32`, `f32`, `i64`, `f64` |\n| AArch64 | `vreg` | `fp` | `i8`, `i16`, `i32`, `f32`, `i64`, `f64`, <br> `i8x8`, `i16x4`, `i32x2`, `i64x1`, `f32x2`, `f64x1`, <br> `i8x16`, `i16x8`, `i32x4`, `i64x2`, `f32x4`, `f64x2` |\n| ARM | `reg` | None | `i8`, `i16`, `i32`, `f32` |\n| ARM | `sreg` | `vfp2` | `i32`, `f32` |\n| ARM | `dreg` | `vfp2` | `i64`, `f64`, `i8x8`, `i16x4`, `i32x2`, `i64x1`, `f32x2` |\n| ARM | `qreg` | `neon` | `i8x16`, `i16x8`, `i32x4`, `i64x2`, `f32x4` |\n| MIPS32 | `reg` | None | `i8`, `i16`, `i32`, `f32` |\n| MIPS32 | `freg` | None | `f32`, `f64` |\n| MIPS64 | `reg` | None | `i8`, `i16`, `i32`, `i64`, `f32`, `f64` |\n| MIPS64 | `freg` | None | `f32`, `f64` |\n| NVPTX | `reg16` | None | `i8`, `i16` |\n| NVPTX | `reg32` | None | `i8`, `i16`, `i32`, `f32` |\n| NVPTX | `reg64` | None | `i8`, `i16`, `i32`, `f32`, `i64`, `f64` |\n| RISC-V32 | `reg` | None | `i8`, `i16`, `i32`, `f32` |\n| RISC-V64 | `reg` | None | `i8`, `i16`, `i32`, `f32`, `i64`, `f64` |\n| RISC-V | `freg` | `f` | `f32` |\n| RISC-V | `freg` | `d` | `f64` |\n| Hexagon | `reg` | None | `i8`, `i16`, `i32`, `f32` |\n\n> **Note**: For the purposes of the above table pointers, function pointers and `isize`/`usize` are treated as the equivalent integer type (`i16`/`i32`/`i64` depending on the target).\n\nIf a value is of a smaller size than the register it is allocated in then the upper bits of that register will have an undefined value for inputs and will be ignored for outputs. The only exception is the `freg` register class on RISC-V where `f32` values are NaN-boxed in a `f64` as required by the RISC-V architecture.\n\nWhen separate input and output expressions are specified for an `inout` operand, both expressions must have the same type. The only exception is if both operands are pointers or integers, in which case they are only required to have the same size. This restriction exists because the register allocators in LLVM and GCC sometimes cannot handle tied operands with different types.\n\n## Register names\n\nSome registers have multiple names. These are all treated by the compiler as identical to the base register name. Here is the list of all supported register aliases:\n\n| Architecture | Base register | Aliases |\n| ------------ | ------------- | ------- |\n| x86 | `ax` | `eax`, `rax` |\n| x86 | `bx` | `ebx`, `rbx` |\n| x86 | `cx` | `ecx`, `rcx` |\n| x86 | `dx` | `edx`, `rdx` |\n| x86 | `si` | `esi`, `rsi` |\n| x86 | `di` | `edi`, `rdi` |\n| x86 | `bp` | `bpl`, `ebp`, `rbp` |\n| x86 | `sp` | `spl`, `esp`, `rsp` |\n| x86 | `ip` | `eip`, `rip` |\n| x86 | `st(0)` | `st` |\n| x86 | `r[8-15]` | `r[8-15]b`, `r[8-15]w`, `r[8-15]d` |\n| x86 | `xmm[0-31]` | `ymm[0-31]`, `zmm[0-31]` |\n| AArch64 | `x[0-30]` | `w[0-30]` |\n| AArch64 | `x29` | `fp` |\n| AArch64 | `x30` | `lr` |\n| AArch64 | `sp` | `wsp` |\n| AArch64 | `xzr` | `wzr` |\n| AArch64 | `v[0-31]` | `b[0-31]`, `h[0-31]`, `s[0-31]`, `d[0-31]`, `q[0-31]` |\n| ARM | `r[0-3]` | `a[1-4]` |\n| ARM | `r[4-9]` | `v[1-6]` |\n| ARM | `r9` | `rfp` |\n| ARM | `r10` | `sl` |\n| ARM | `r11` | `fp` |\n| ARM | `r12` | `ip` |\n| ARM | `r13` | `sp` |\n| ARM | `r14` | `lr` |\n| ARM | `r15` | `pc` |\n| RISC-V | `x0` | `zero` |\n| RISC-V | `x1` | `ra` |\n| RISC-V | `x2` | `sp` |\n| RISC-V | `x3` | `gp` |\n| RISC-V | `x4` | `tp` |\n| RISC-V | `x[5-7]` | `t[0-2]` |\n| RISC-V | `x8` | `fp`, `s0` |\n| RISC-V | `x9` | `s1` |\n| RISC-V | `x[10-17]` | `a[0-7]` |\n| RISC-V | `x[18-27]` | `s[2-11]` |\n| RISC-V | `x[28-31]` | `t[3-6]` |\n| RISC-V | `f[0-7]` | `ft[0-7]` |\n| RISC-V | `f[8-9]` | `fs[0-1]` |\n| RISC-V | `f[10-17]` | `fa[0-7]` |\n| RISC-V | `f[18-27]` | `fs[2-11]` |\n| RISC-V | `f[28-31]` | `ft[8-11]` |\n| Hexagon | `r29` | `sp` |\n| Hexagon | `r30` | `fr` |\n| Hexagon | `r31` | `lr` |\n\nSome registers cannot be used for input or output operands:\n\n| Architecture | Unsupported register | Reason |\n| ------------ | -------------------- | ------ |\n| All | `sp` | The stack pointer must be restored to its original value at the end of an asm code block. |\n| All | `bp` (x86), `x29` (AArch64), `x8` (RISC-V), `fr` (Hexagon), `$fp` (MIPS) | The frame pointer cannot be used as an input or output. |\n| ARM | `r7` or `r11` | On ARM the frame pointer can be either `r7` or `r11` depending on the target. The frame pointer cannot be used as an input or output. |\n| ARM | `r6` | `r6` is used internally by LLVM as a base pointer and therefore cannot be used as an input or output. |\n| x86 | `k0` | This is a constant zero register which can't be modified. |\n| x86 | `ip` | This is the program counter, not a real register. |\n| x86 | `mm[0-7]` | MMX registers are not currently supported (but may be in the future). |\n| x86 | `st([0-7])` | x87 registers are not currently supported (but may be in the future). |\n| AArch64 | `xzr` | This is a constant zero register which can't be modified. |\n| ARM | `pc` | This is the program counter, not a real register. |\n| MIPS | `$0` or `$zero` | This is a constant zero register which can't be modified. |\n| MIPS | `$1` or `$at` | Reserved for assembler. |\n| MIPS | `$26`/`$k0`, `$27`/`$k1` | OS-reserved registers. |\n| MIPS | `$28`/`$gp` | Global pointer cannot be used as inputs or outputs. |\n| MIPS | `$ra` | Return address cannot be used as inputs or outputs. |\n| RISC-V | `x0` | This is a constant zero register which can't be modified. |\n| RISC-V | `gp`, `tp` | These registers are reserved and cannot be used as inputs or outputs. |\n| Hexagon | `lr` | This is the link register which cannot be used as an input or output. |\n\nIn some cases LLVM will allocate a \"reserved register\" for `reg` operands even though this register cannot be explicitly specified. Assembly code making use of reserved registers should be careful since `reg` operands may alias with those registers. Reserved registers are:\n- The frame pointer on all architectures.\n- `r6` on ARM.\n\n## Template modifiers\n\nThe placeholders can be augmented by modifiers which are specified after the `:` in the curly braces. These modifiers do not affect register allocation, but change the way operands are formatted when inserted into the template string. Only one modifier is allowed per template placeholder.\n\nThe supported modifiers are a subset of LLVM's (and GCC's) [asm template argument modifiers][llvm-argmod], but do not use the same letter codes.\n\n| Architecture | Register class | Modifier | Example output | LLVM modifier |\n| ------------ | -------------- | -------- | -------------- | ------------- |\n| x86-32 | `reg` | None | `eax` | `k` |\n| x86-64 | `reg` | None | `rax` | `q` |\n| x86-32 | `reg_abcd` | `l` | `al` | `b` |\n| x86-64 | `reg` | `l` | `al` | `b` |\n| x86 | `reg_abcd` | `h` | `ah` | `h` |\n| x86 | `reg` | `x` | `ax` | `w` |\n| x86 | `reg` | `e` | `eax` | `k` |\n| x86-64 | `reg` | `r` | `rax` | `q` |\n| x86 | `reg_byte` | None | `al` / `ah` | None |\n| x86 | `xmm_reg` | None | `xmm0` | `x` |\n| x86 | `ymm_reg` | None | `ymm0` | `t` |\n| x86 | `zmm_reg` | None | `zmm0` | `g` |\n| x86 | `*mm_reg` | `x` | `xmm0` | `x` |\n| x86 | `*mm_reg` | `y` | `ymm0` | `t` |\n| x86 | `*mm_reg` | `z` | `zmm0` | `g` |\n| x86 | `kreg` | None | `k1` | None |\n| AArch64 | `reg` | None | `x0` | `x` |\n| AArch64 | `reg` | `w` | `w0` | `w` |\n| AArch64 | `reg` | `x` | `x0` | `x` |\n| AArch64 | `vreg` | None | `v0` | None |\n| AArch64 | `vreg` | `v` | `v0` | None |\n| AArch64 | `vreg` | `b` | `b0` | `b` |\n| AArch64 | `vreg` | `h` | `h0` | `h` |\n| AArch64 | `vreg` | `s` | `s0` | `s` |\n| AArch64 | `vreg` | `d` | `d0` | `d` |\n| AArch64 | `vreg` | `q` | `q0` | `q` |\n| ARM | `reg` | None | `r0` | None |\n| ARM | `sreg` | None | `s0` | None |\n| ARM | `dreg` | None | `d0` | `P` |\n| ARM | `qreg` | None | `q0` | `q` |\n| ARM | `qreg` | `e` / `f` | `d0` / `d1` | `e` / `f` |\n| MIPS | `reg` | None | `$2` | None |\n| MIPS | `freg` | None | `$f0` | None |\n| NVPTX | `reg16` | None | `rs0` | None |\n| NVPTX | `reg32` | None | `r0` | None |\n| NVPTX | `reg64` | None | `rd0` | None |\n| RISC-V | `reg` | None | `x1` | None |\n| RISC-V | `freg` | None | `f0` | None |\n| Hexagon | `reg` | None | `r0` | None |\n\n> Notes:\n> - on ARM `e` / `f`: this prints the low or high doubleword register name of a NEON quad (128-bit) register.\n> - on x86: our behavior for `reg` with no modifiers differs from what GCC does. GCC will infer the modifier based on the operand value type, while we default to the full register size.\n> - on x86 `xmm_reg`: the `x`, `t` and `g` LLVM modifiers are not yet implemented in LLVM (they are supported by GCC only), but this should be a simple change.\n\nAs stated in the previous section, passing an input value smaller than the register width will result in the upper bits of the register containing undefined values. This is not a problem if the inline asm only accesses the lower bits of the register, which can be done by using a template modifier to use a subregister name in the asm code (e.g. `ax` instead of `rax`). Since this an easy pitfall, the compiler will suggest a template modifier to use where appropriate given the input type. If all references to an operand already have modifiers then the warning is suppressed for that operand.\n\n[llvm-argmod]: http://llvm.org/docs/LangRef.html#asm-template-argument-modifiers\n\n## Options\n\nFlags are used to further influence the behavior of the inline assembly block.\nCurrently the following options are defined:\n- `pure`: The `asm` block has no side effects, and its outputs depend only on its direct inputs (i.e. the values themselves, not what they point to) or values read from memory (unless the `nomem` options is also set). This allows the compiler to execute the `asm` block fewer times than specified in the program (e.g. by hoisting it out of a loop) or even eliminate it entirely if the outputs are not used.\n- `nomem`: The `asm` blocks does not read or write to any memory. This allows the compiler to cache the values of modified global variables in registers across the `asm` block since it knows that they are not read or written to by the `asm`.\n- `readonly`: The `asm` block does not write to any memory. This allows the compiler to cache the values of unmodified global variables in registers across the `asm` block since it knows that they are not written to by the `asm`.\n- `preserves_flags`: The `asm` block does not modify the flags register (defined in the rules below). This allows the compiler to avoid recomputing the condition flags after the `asm` block.\n- `noreturn`: The `asm` block never returns, and its return type is defined as `!` (never). Behavior is undefined if execution falls through past the end of the asm code. A `noreturn` asm block behaves just like a function which doesn't return; notably, local variables in scope are not dropped before it is invoked.\n- `nostack`: The `asm` block does not push data to the stack, or write to the stack red-zone (if supported by the target). If this option is *not* used then the stack pointer is guaranteed to be suitably aligned (according to the target ABI) for a function call.\n- `att_syntax`: This option is only valid on x86, and causes the assembler to use the `.att_syntax prefix` mode of the GNU assembler. Register operands are substituted in with a leading `%`.\n\nThe compiler performs some additional checks on options:\n- The `nomem` and `readonly` options are mutually exclusive: it is a compile-time error to specify both.\n- The `pure` option must be combined with either the `nomem` or `readonly` options, otherwise a compile-time error is emitted.\n- It is a compile-time error to specify `pure` on an asm block with no outputs or only discarded outputs (`_`).\n- It is a compile-time error to specify `noreturn` on an asm block with outputs.\n\n## Rules for inline assembly\n\n- Any registers not specified as inputs will contain an undefined value on entry to the asm block.\n - An \"undefined value\" in the context of inline assembly means that the register can (non-deterministically) have any one of the possible values allowed by the architecture. Notably it is not the same as an LLVM `undef` which can have a different value every time you read it (since such a concept does not exist in assembly code).\n- Any registers not specified as outputs must have the same value upon exiting the asm block as they had on entry, otherwise behavior is undefined.\n - This only applies to registers which can be specified as an input or output. Other registers follow target-specific rules.\n - Note that a `lateout` may be allocated to the same register as an `in`, in which case this rule does not apply. Code should not rely on this however since it depends on the results of register allocation.\n- Behavior is undefined if execution unwinds out of an asm block.\n - This also applies if the assembly code calls a function which then unwinds.\n- The set of memory locations that assembly code is allowed the read and write are the same as those allowed for an FFI function.\n - Refer to the unsafe code guidelines for the exact rules.\n - If the `readonly` option is set, then only memory reads are allowed.\n - If the `nomem` option is set then no reads or writes to memory are allowed.\n - These rules do not apply to memory which is private to the asm code, such as stack space allocated within the asm block.\n- The compiler cannot assume that the instructions in the asm are the ones that will actually end up executed.\n - This effectively means that the compiler must treat the `asm!` as a black box and only take the interface specification into account, not the instructions themselves.\n - Runtime code patching is allowed, via target-specific mechanisms (outside the scope of this RFC).\n- Unless the `nostack` option is set, asm code is allowed to use stack space below the stack pointer.\n - On entry to the asm block the stack pointer is guaranteed to be suitably aligned (according to the target ABI) for a function call.\n - You are responsible for making sure you don't overflow the stack (e.g. use stack probing to ensure you hit a guard page).\n - You should adjust the stack pointer when allocating stack memory as required by the target ABI.\n - The stack pointer must be restored to its original value before leaving the asm block.\n- If the `noreturn` option is set then behavior is undefined if execution falls through to the end of the asm block.\n- If the `pure` option is set then behavior is undefined if the `asm` has side-effects other than its direct outputs. Behavior is also undefined if two executions of the `asm` code with the same inputs result in different outputs.\n - When used with the `nomem` option, \"inputs\" are just the direct inputs of the `asm!`.\n - When used with the `readonly` option, \"inputs\" comprise the direct inputs of the `asm!` and any memory that the `asm!` block is allowed to read.\n- These flags registers must be restored upon exiting the asm block if the `preserves_flags` option is set:\n - x86\n - Status flags in `EFLAGS` (CF, PF, AF, ZF, SF, OF).\n - Floating-point status word (all).\n - Floating-point exception flags in `MXCSR` (PE, UE, OE, ZE, DE, IE).\n - ARM\n - Condition flags in `CPSR` (N, Z, C, V)\n - Saturation flag in `CPSR` (Q)\n - Greater than or equal flags in `CPSR` (GE).\n - Condition flags in `FPSCR` (N, Z, C, V)\n - Saturation flag in `FPSCR` (QC)\n - Floating-point exception flags in `FPSCR` (IDC, IXC, UFC, OFC, DZC, IOC).\n - AArch64\n - Condition flags (`NZCV` register).\n - Floating-point status (`FPSR` register).\n - RISC-V\n - Floating-point exception flags in `fcsr` (`fflags`).\n- On x86, the direction flag (DF in `EFLAGS`) is clear on entry to an asm block and must be clear on exit.\n - Behavior is undefined if the direction flag is set on exiting an asm block.\n- The requirement of restoring the stack pointer and non-output registers to their original value only applies when exiting an `asm!` block.\n - This means that `asm!` blocks that never return (even if not marked `noreturn`) don't need to preserve these registers.\n - When returning to a different `asm!` block than you entered (e.g. for context switching), these registers must contain the value they had upon entering the `asm!` block that you are *exiting*.\n - You cannot exit an `asm!` block that has not been entered. Neither can you exit an `asm!` block that has already been exited.\n - You are responsible for switching any target-specific state (e.g. thread-local storage, stack bounds).\n - The set of memory locations that you may access is the intersection of those allowed by the `asm!` blocks you entered and exited.\n- You cannot assume that an `asm!` block will appear exactly once in the output binary. The compiler is allowed to instantiate multiple copies of the `asm!` block, for example when the function containing it is inlined in multiple places.\n - As a consequence, you should only use [local labels] inside inline assembly code. Defining symbols in assembly code may lead to assembler and/or linker errors due to duplicate symbol definitions.\n\n> **Note**: As a general rule, the flags covered by `preserves_flags` are those which are *not* preserved when performing a function call.\n\n[local labels]: https://sourceware.org/binutils/docs/as/Symbol-Names.html#Local-Labels\n" } , LintCompletion { label : "windows_handle" , description : "# `windows_handle`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "fd_read" , description : "# `fd_read`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "sort_internals" , description : "# `sort_internals`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "print_internals" , description : "# `print_internals`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "allocator_api" , description : "# `allocator_api`\n\nThe tracking issue for this feature is [#32838]\n\n[#32838]: https://github.com/rust-lang/rust/issues/32838\n\n------------------------\n\nSometimes you want the memory for one collection to use a different\nallocator than the memory for another collection. In this case,\nreplacing the global allocator is not a workable option. Instead,\nyou need to pass in an instance of an `AllocRef` to each collection\nfor which you want a custom allocator.\n\nTBD\n" } , LintCompletion { label : "char_error_internals" , description : "# `char_error_internals`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "flt2dec" , description : "# `flt2dec`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "core_panic" , description : "# `core_panic`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "fn_traits" , description : "# `fn_traits`\n\nThe tracking issue for this feature is [#29625]\n\nSee Also: [`unboxed_closures`](../language-features/unboxed-closures.md)\n\n[#29625]: https://github.com/rust-lang/rust/issues/29625\n\n----\n\nThe `fn_traits` feature allows for implementation of the [`Fn*`] traits\nfor creating custom closure-like types.\n\n[`Fn*`]: https://doc.rust-lang.org/std/ops/trait.Fn.html\n\n```rust\n#![feature(unboxed_closures)]\n#![feature(fn_traits)]\n\nstruct Adder {\n a: u32\n}\n\nimpl FnOnce<(u32, )> for Adder {\n type Output = u32;\n extern \"rust-call\" fn call_once(self, b: (u32, )) -> Self::Output {\n self.a + b.0\n }\n}\n\nfn main() {\n let adder = Adder { a: 3 };\n assert_eq!(adder(2), 5);\n}\n```\n" } , LintCompletion { label : "global_asm" , description : "# `global_asm`\n\nThe tracking issue for this feature is: [#35119]\n\n[#35119]: https://github.com/rust-lang/rust/issues/35119\n\n------------------------\n\nThe `global_asm!` macro allows the programmer to write arbitrary\nassembly outside the scope of a function body, passing it through\n`rustc` and `llvm` to the assembler. The macro is a no-frills\ninterface to LLVM's concept of [module-level inline assembly]. That is,\nall caveats applicable to LLVM's module-level inline assembly apply\nto `global_asm!`.\n\n[module-level inline assembly]: http://llvm.org/docs/LangRef.html#module-level-inline-assembly\n\n`global_asm!` fills a role not currently satisfied by either `asm!`\nor `#[naked]` functions. The programmer has _all_ features of the\nassembler at their disposal. The linker will expect to resolve any\nsymbols defined in the inline assembly, modulo any symbols marked as\nexternal. It also means syntax for directives and assembly follow the\nconventions of the assembler in your toolchain.\n\nA simple usage looks like this:\n\n```rust,ignore\n# #![feature(global_asm)]\n# you also need relevant target_arch cfgs\nglobal_asm!(include_str!(\"something_neato.s\"));\n```\n\nAnd a more complicated usage looks like this:\n\n```rust,ignore\n# #![feature(global_asm)]\n# #![cfg(any(target_arch = \"x86\", target_arch = \"x86_64\"))]\n\npub mod sally {\n global_asm!(r#\"\n .global foo\n foo:\n jmp baz\n \"#);\n\n #[no_mangle]\n pub unsafe extern \"C\" fn baz() {}\n}\n\n// the symbols `foo` and `bar` are global, no matter where\n// `global_asm!` was used.\nextern \"C\" {\n fn foo();\n fn bar();\n}\n\npub mod harry {\n global_asm!(r#\"\n .global bar\n bar:\n jmp quux\n \"#);\n\n #[no_mangle]\n pub unsafe extern \"C\" fn quux() {}\n}\n```\n\nYou may use `global_asm!` multiple times, anywhere in your crate, in\nwhatever way suits you. The effect is as if you concatenated all\nusages and placed the larger, single usage in the crate root.\n\n------------------------\n\nIf you don't need quite as much power and flexibility as\n`global_asm!` provides, and you don't mind restricting your inline\nassembly to `fn` bodies only, you might try the\n[asm](asm.md) feature instead.\n" } , LintCompletion { label : "fd" , description : "# `fd`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "concat_idents" , description : "# `concat_idents`\n\nThe tracking issue for this feature is: [#29599]\n\n[#29599]: https://github.com/rust-lang/rust/issues/29599\n\n------------------------\n\nThe `concat_idents` feature adds a macro for concatenating multiple identifiers\ninto one identifier.\n\n## Examples\n\n```rust\n#![feature(concat_idents)]\n\nfn main() {\n fn foobar() -> u32 { 23 }\n let f = concat_idents!(foo, bar);\n assert_eq!(f(), 23);\n}\n```" } , LintCompletion { label : "derive_eq" , description : "# `derive_eq`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "profiler_runtime_lib" , description : "# `profiler_runtime_lib`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "default_free_fn" , description : "# `default_free_fn`\n\nThe tracking issue for this feature is: [#73014]\n\n[#73014]: https://github.com/rust-lang/rust/issues/73014\n\n------------------------\n\nAdds a free `default()` function to the `std::default` module. This function\njust forwards to [`Default::default()`], but may remove repetition of the word\n\"default\" from the call site.\n\nHere is an example:\n\n```rust\n#![feature(default_free_fn)]\nuse std::default::default;\n\n#[derive(Default)]\nstruct AppConfig {\n foo: FooConfig,\n bar: BarConfig,\n}\n\n#[derive(Default)]\nstruct FooConfig {\n foo: i32,\n}\n\n#[derive(Default)]\nstruct BarConfig {\n bar: f32,\n baz: u8,\n}\n\nfn main() {\n let options = AppConfig {\n foo: default(),\n bar: BarConfig {\n bar: 10.1,\n ..default()\n },\n };\n}\n```\n" } , LintCompletion { label : "int_error_internals" , description : "# `int_error_internals`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "slice_check_range" , description : "# `slice_check_range`\n\nThe tracking issue for this feature is: [#76393]\n\n------------------------\n\nThis adds [`slice::check_range`].\n\n[#76393]: https://github.com/rust-lang/rust/issues/76393\n[`slice::check_range`]: https://doc.rust-lang.org/nightly/std/primitive.slice.html#method.check_range\n" } , LintCompletion { label : "try_trait" , description : "# `try_trait`\n\nThe tracking issue for this feature is: [#42327]\n\n[#42327]: https://github.com/rust-lang/rust/issues/42327\n\n------------------------\n\nThis introduces a new trait `Try` for extending the `?` operator to types\nother than `Result` (a part of [RFC 1859]). The trait provides the canonical\nway to _view_ a type in terms of a success/failure dichotomy. This will\nallow `?` to supplant the `try_opt!` macro on `Option` and the `try_ready!`\nmacro on `Poll`, among other things.\n\n[RFC 1859]: https://github.com/rust-lang/rfcs/pull/1859\n\nHere's an example implementation of the trait:\n\n```rust,ignore\n/// A distinct type to represent the `None` value of an `Option`.\n///\n/// This enables using the `?` operator on `Option`; it's rarely useful alone.\n#[derive(Debug)]\n#[unstable(feature = \"try_trait\", issue = \"42327\")]\npub struct None { _priv: () }\n\n#[unstable(feature = \"try_trait\", issue = \"42327\")]\nimpl<T> ops::Try for Option<T> {\n type Ok = T;\n type Error = None;\n\n fn into_result(self) -> Result<T, None> {\n self.ok_or(None { _priv: () })\n }\n\n fn from_ok(v: T) -> Self {\n Some(v)\n }\n\n fn from_error(_: None) -> Self {\n None\n }\n}\n```\n\nNote the `Error` associated type here is a new marker. The `?` operator\nallows interconversion between different `Try` implementers only when\nthe error type can be converted `Into` the error type of the enclosing\nfunction (or catch block). Having a distinct error type (as opposed to\njust `()`, or similar) restricts this to where it's semantically meaningful.\n" } , LintCompletion { label : "c_variadic" , description : "# `c_variadic`\n\nThe tracking issue for this feature is: [#44930]\n\n[#44930]: https://github.com/rust-lang/rust/issues/44930\n\n------------------------\n\nThe `c_variadic` library feature exposes the `VaList` structure,\nRust's analogue of C's `va_list` type.\n\n## Examples\n\n```rust\n#![feature(c_variadic)]\n\nuse std::ffi::VaList;\n\npub unsafe extern \"C\" fn vadd(n: usize, mut args: VaList) -> usize {\n let mut sum = 0;\n for _ in 0..n {\n sum += args.arg::<usize>();\n }\n sum\n}\n```\n" } , LintCompletion { label : "dec2flt" , description : "# `dec2flt`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "set_stdio" , description : "# `set_stdio`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "libstd_thread_internals" , description : "# `libstd_thread_internals`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "windows_stdio" , description : "# `windows_stdio`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "format_args_capture" , description : "# `format_args_capture`\n\nThe tracking issue for this feature is: [#67984]\n\n[#67984]: https://github.com/rust-lang/rust/issues/67984\n\n------------------------\n\nEnables `format_args!` (and macros which use `format_args!` in their implementation, such\nas `format!`, `print!` and `panic!`) to capture variables from the surrounding scope.\nThis avoids the need to pass named parameters when the binding in question\nalready exists in scope.\n\n```rust\n#![feature(format_args_capture)]\n\nlet (person, species, name) = (\"Charlie Brown\", \"dog\", \"Snoopy\");\n\n// captures named argument `person`\nprint!(\"Hello {person}\");\n\n// captures named arguments `species` and `name`\nformat!(\"The {species}'s name is {name}.\");\n```\n\nThis also works for formatting parameters such as width and precision:\n\n```rust\n#![feature(format_args_capture)]\n\nlet precision = 2;\nlet s = format!(\"{:.precision$}\", 1.324223);\n\nassert_eq!(&s, \"1.32\");\n```\n\nA non-exhaustive list of macros which benefit from this functionality include:\n- `format!`\n- `print!` and `println!`\n- `eprint!` and `eprintln!`\n- `write!` and `writeln!`\n- `panic!`\n- `unreachable!`\n- `unimplemented!`\n- `todo!`\n- `assert!` and similar\n- macros in many thirdparty crates, such as `log`\n" } , LintCompletion { label : "thread_local_internals" , description : "# `thread_local_internals`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "core_private_diy_float" , description : "# `core_private_diy_float`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "libstd_io_internals" , description : "# `libstd_io_internals`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "core_private_bignum" , description : "# `core_private_bignum`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "is_sorted" , description : "# `is_sorted`\n\nThe tracking issue for this feature is: [#53485]\n\n[#53485]: https://github.com/rust-lang/rust/issues/53485\n\n------------------------\n\nAdd the methods `is_sorted`, `is_sorted_by` and `is_sorted_by_key` to `[T]`;\nadd the methods `is_sorted`, `is_sorted_by` and `is_sorted_by_key` to\n`Iterator`.\n" } , LintCompletion { label : "core_intrinsics" , description : "# `core_intrinsics`\n\nThis feature is internal to the Rust compiler and is not intended for general use.\n\n------------------------\n" } , LintCompletion { label : "test" , description : "# `test`\n\nThe tracking issue for this feature is: None.\n\n------------------------\n\nThe internals of the `test` crate are unstable, behind the `test` flag. The\nmost widely used part of the `test` crate are benchmark tests, which can test\nthe performance of your code. Let's make our `src/lib.rs` look like this\n(comments elided):\n\n```rust,ignore\n#![feature(test)]\n\nextern crate test;\n\npub fn add_two(a: i32) -> i32 {\n a + 2\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n use test::Bencher;\n\n #[test]\n fn it_works() {\n assert_eq!(4, add_two(2));\n }\n\n #[bench]\n fn bench_add_two(b: &mut Bencher) {\n b.iter(|| add_two(2));\n }\n}\n```\n\nNote the `test` feature gate, which enables this unstable feature.\n\nWe've imported the `test` crate, which contains our benchmarking support.\nWe have a new function as well, with the `bench` attribute. Unlike regular\ntests, which take no arguments, benchmark tests take a `&mut Bencher`. This\n`Bencher` provides an `iter` method, which takes a closure. This closure\ncontains the code we'd like to benchmark.\n\nWe can run benchmark tests with `cargo bench`:\n\n```bash\n$ cargo bench\n Compiling adder v0.0.1 (file:///home/steve/tmp/adder)\n Running target/release/adder-91b3e234d4ed382a\n\nrunning 2 tests\ntest tests::it_works ... ignored\ntest tests::bench_add_two ... bench: 1 ns/iter (+/- 0)\n\ntest result: ok. 0 passed; 0 failed; 1 ignored; 1 measured\n```\n\nOur non-benchmark test was ignored. You may have noticed that `cargo bench`\ntakes a bit longer than `cargo test`. This is because Rust runs our benchmark\na number of times, and then takes the average. Because we're doing so little\nwork in this example, we have a `1 ns/iter (+/- 0)`, but this would show\nthe variance if there was one.\n\nAdvice on writing benchmarks:\n\n\n* Move setup code outside the `iter` loop; only put the part you want to measure inside\n* Make the code do \"the same thing\" on each iteration; do not accumulate or change state\n* Make the outer function idempotent too; the benchmark runner is likely to run\n it many times\n* Make the inner `iter` loop short and fast so benchmark runs are fast and the\n calibrator can adjust the run-length at fine resolution\n* Make the code in the `iter` loop do something simple, to assist in pinpointing\n performance improvements (or regressions)\n\n## Gotcha: optimizations\n\nThere's another tricky part to writing benchmarks: benchmarks compiled with\noptimizations activated can be dramatically changed by the optimizer so that\nthe benchmark is no longer benchmarking what one expects. For example, the\ncompiler might recognize that some calculation has no external effects and\nremove it entirely.\n\n```rust,ignore\n#![feature(test)]\n\nextern crate test;\nuse test::Bencher;\n\n#[bench]\nfn bench_xor_1000_ints(b: &mut Bencher) {\n b.iter(|| {\n (0..1000).fold(0, |old, new| old ^ new);\n });\n}\n```\n\ngives the following results\n\n```text\nrunning 1 test\ntest bench_xor_1000_ints ... bench: 0 ns/iter (+/- 0)\n\ntest result: ok. 0 passed; 0 failed; 0 ignored; 1 measured\n```\n\nThe benchmarking runner offers two ways to avoid this. Either, the closure that\nthe `iter` method receives can return an arbitrary value which forces the\noptimizer to consider the result used and ensures it cannot remove the\ncomputation entirely. This could be done for the example above by adjusting the\n`b.iter` call to\n\n```rust\n# struct X;\n# impl X { fn iter<T, F>(&self, _: F) where F: FnMut() -> T {} } let b = X;\nb.iter(|| {\n // Note lack of `;` (could also use an explicit `return`).\n (0..1000).fold(0, |old, new| old ^ new)\n});\n```\n\nOr, the other option is to call the generic `test::black_box` function, which\nis an opaque \"black box\" to the optimizer and so forces it to consider any\nargument as used.\n\n```rust\n#![feature(test)]\n\nextern crate test;\n\n# fn main() {\n# struct X;\n# impl X { fn iter<T, F>(&self, _: F) where F: FnMut() -> T {} } let b = X;\nb.iter(|| {\n let n = test::black_box(1000);\n\n (0..n).fold(0, |a, b| a ^ b)\n})\n# }\n```\n\nNeither of these read or modify the value, and are very cheap for small values.\nLarger values can be passed indirectly to reduce overhead (e.g.\n`black_box(&huge_struct)`).\n\nPerforming either of the above changes gives the following benchmarking results\n\n```text\nrunning 1 test\ntest bench_xor_1000_ints ... bench: 131 ns/iter (+/- 3)\n\ntest result: ok. 0 passed; 0 failed; 0 ignored; 1 measured\n```\n\nHowever, the optimizer can still modify a testcase in an undesirable manner\neven when using either of the above.\n" }] ;
5pub (super) const CLIPPY_LINTS : & [LintCompletion] = & [LintCompletion { label : "clippy::absurd_extreme_comparisons" , description : "Checks for comparisons where one side of the relation is\\neither the minimum or maximum value for its type and warns if it involves a\\ncase that is always true or always false. Only integer and boolean types are\\nchecked." } , LintCompletion { label : "clippy::almost_swapped" , description : "Checks for `foo = bar; bar = foo` sequences." } , LintCompletion { label : "clippy::approx_constant" , description : "Checks for floating point literals that approximate\\nconstants which are defined in\\n[`std::f32::consts`](https://doc.rust-lang.org/stable/std/f32/consts/#constants)\\nor\\n[`std::f64::consts`](https://doc.rust-lang.org/stable/std/f64/consts/#constants),\\nrespectively, suggesting to use the predefined constant." } , LintCompletion { label : "clippy::as_conversions" , description : "Checks for usage of `as` conversions." } , LintCompletion { label : "clippy::assertions_on_constants" , description : "Checks for `assert!(true)` and `assert!(false)` calls." } , LintCompletion { label : "clippy::assign_op_pattern" , description : "Checks for `a = a op b` or `a = b commutative_op a`\\npatterns." } , LintCompletion { label : "clippy::assign_ops" , description : "Nothing. This lint has been deprecated." } , LintCompletion { label : "clippy::async_yields_async" , description : "Checks for async blocks that yield values of types\\nthat can themselves be awaited." } , LintCompletion { label : "clippy::await_holding_lock" , description : "Checks for calls to await while holding a\\nnon-async-aware MutexGuard." } , LintCompletion { label : "clippy::bad_bit_mask" , description : "Checks for incompatible bit masks in comparisons.\\n\\nThe formula for detecting if an expression of the type `_ <bit_op> m\\n<cmp_op> c` (where `<bit_op>` is one of {`&`, `|`} and `<cmp_op>` is one of\\n{`!=`, `>=`, `>`, `!=`, `>=`, `>`}) can be determined from the following\\ntable:\\n\\n|Comparison |Bit Op|Example |is always|Formula |\\n|------------|------|------------|---------|----------------------|\\n|`==` or `!=`| `&` |`x & 2 == 3`|`false` |`c & m != c` |\\n|`<` or `>=`| `&` |`x & 2 < 3` |`true` |`m < c` |\\n|`>` or `<=`| `&` |`x & 1 > 1` |`false` |`m <= c` |\\n|`==` or `!=`| `|` |`x | 1 == 0`|`false` |`c | m != c` |\\n|`<` or `>=`| `|` |`x | 1 < 1` |`false` |`m >= c` |\\n|`<=` or `>` | `|` |`x | 1 > 0` |`true` |`m > c` |" } , LintCompletion { label : "clippy::bind_instead_of_map" , description : "Checks for usage of `_.and_then(|x| Some(y))`, `_.and_then(|x| Ok(y))` or\\n`_.or_else(|x| Err(y))`." } , LintCompletion { label : "clippy::blacklisted_name" , description : "Checks for usage of blacklisted names for variables, such\\nas `foo`." } , LintCompletion { label : "clippy::blanket_clippy_restriction_lints" , description : "Checks for `warn`/`deny`/`forbid` attributes targeting the whole clippy::restriction category." } , LintCompletion { label : "clippy::blocks_in_if_conditions" , description : "Checks for `if` conditions that use blocks containing an\\nexpression, statements or conditions that use closures with blocks." } , LintCompletion { label : "clippy::bool_comparison" , description : "Checks for expressions of the form `x == true`,\\n`x != true` and order comparisons such as `x < true` (or vice versa) and\\nsuggest using the variable directly." } , LintCompletion { label : "clippy::borrow_interior_mutable_const" , description : "Checks if `const` items which is interior mutable (e.g.,\\ncontains a `Cell`, `Mutex`, `AtomicXxxx`, etc.) has been borrowed directly." } , LintCompletion { label : "clippy::borrowed_box" , description : "Checks for use of `&Box<T>` anywhere in the code.\\nCheck the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information." } , LintCompletion { label : "clippy::box_vec" , description : "Checks for use of `Box<Vec<_>>` anywhere in the code.\\nCheck the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information." } , LintCompletion { label : "clippy::boxed_local" , description : "Checks for usage of `Box<T>` where an unboxed `T` would\\nwork fine." } , LintCompletion { label : "clippy::builtin_type_shadow" , description : "Warns if a generic shadows a built-in type." } , LintCompletion { label : "clippy::cargo_common_metadata" , description : "Checks to see if all common metadata is defined in\\n`Cargo.toml`. See: https://rust-lang-nursery.github.io/api-guidelines/documentation.html#cargotoml-includes-all-common-metadata-c-metadata" } , LintCompletion { label : "clippy::cast_lossless" , description : "Checks for casts between numerical types that may\\nbe replaced by safe conversion functions." } , LintCompletion { label : "clippy::cast_possible_truncation" , description : "Checks for casts between numerical types that may\\ntruncate large values. This is expected behavior, so the cast is `Allow` by\\ndefault." } , LintCompletion { label : "clippy::cast_possible_wrap" , description : "Checks for casts from an unsigned type to a signed type of\\nthe same size. Performing such a cast is a 'no-op' for the compiler,\\ni.e., nothing is changed at the bit level, and the binary representation of\\nthe value is reinterpreted. This can cause wrapping if the value is too big\\nfor the target signed type. However, the cast works as defined, so this lint\\nis `Allow` by default." } , LintCompletion { label : "clippy::cast_precision_loss" , description : "Checks for casts from any numerical to a float type where\\nthe receiving type cannot store all values from the original type without\\nrounding errors. This possible rounding is to be expected, so this lint is\\n`Allow` by default.\\n\\nBasically, this warns on casting any integer with 32 or more bits to `f32`\\nor any 64-bit integer to `f64`." } , LintCompletion { label : "clippy::cast_ptr_alignment" , description : "Checks for casts from a less-strictly-aligned pointer to a\\nmore-strictly-aligned pointer" } , LintCompletion { label : "clippy::cast_ref_to_mut" , description : "Checks for casts of `&T` to `&mut T` anywhere in the code." } , LintCompletion { label : "clippy::cast_sign_loss" , description : "Checks for casts from a signed to an unsigned numerical\\ntype. In this case, negative values wrap around to large positive values,\\nwhich can be quite surprising in practice. However, as the cast works as\\ndefined, this lint is `Allow` by default." } , LintCompletion { label : "clippy::char_lit_as_u8" , description : "Checks for expressions where a character literal is cast\\nto `u8` and suggests using a byte literal instead." } , LintCompletion { label : "clippy::chars_last_cmp" , description : "Checks for usage of `_.chars().last()` or\\n`_.chars().next_back()` on a `str` to check if it ends with a given char." } , LintCompletion { label : "clippy::chars_next_cmp" , description : "Checks for usage of `.chars().next()` on a `str` to check\\nif it starts with a given char." } , LintCompletion { label : "clippy::checked_conversions" , description : "Checks for explicit bounds checking when casting." } , LintCompletion { label : "clippy::clone_double_ref" , description : "Checks for usage of `.clone()` on an `&&T`." } , LintCompletion { label : "clippy::clone_on_copy" , description : "Checks for usage of `.clone()` on a `Copy` type." } , LintCompletion { label : "clippy::clone_on_ref_ptr" , description : "Checks for usage of `.clone()` on a ref-counted pointer,\\n(`Rc`, `Arc`, `rc::Weak`, or `sync::Weak`), and suggests calling Clone via unified\\nfunction syntax instead (e.g., `Rc::clone(foo)`)." } , LintCompletion { label : "clippy::cmp_nan" , description : "Checks for comparisons to NaN." } , LintCompletion { label : "clippy::cmp_null" , description : "This lint checks for equality comparisons with `ptr::null`" } , LintCompletion { label : "clippy::cmp_owned" , description : "Checks for conversions to owned values just for the sake\\nof a comparison." } , LintCompletion { label : "clippy::cognitive_complexity" , description : "Checks for methods with high cognitive complexity." } , LintCompletion { label : "clippy::collapsible_if" , description : "Checks for nested `if` statements which can be collapsed\\nby `&&`-combining their conditions and for `else { if ... }` expressions\\nthat\\ncan be collapsed to `else if ...`." } , LintCompletion { label : "clippy::comparison_chain" , description : "Checks comparison chains written with `if` that can be\\nrewritten with `match` and `cmp`." } , LintCompletion { label : "clippy::copy_iterator" , description : "Checks for types that implement `Copy` as well as\\n`Iterator`." } , LintCompletion { label : "clippy::create_dir" , description : "Checks usage of `std::fs::create_dir` and suggest using `std::fs::create_dir_all` instead." } , LintCompletion { label : "clippy::crosspointer_transmute" , description : "Checks for transmutes between a type `T` and `*T`." } , LintCompletion { label : "clippy::dbg_macro" , description : "Checks for usage of dbg!() macro." } , LintCompletion { label : "clippy::debug_assert_with_mut_call" , description : "Checks for function/method calls with a mutable\\nparameter in `debug_assert!`, `debug_assert_eq!` and `debug_assert_ne!` macros." } , LintCompletion { label : "clippy::decimal_literal_representation" , description : "Warns if there is a better representation for a numeric literal." } , LintCompletion { label : "clippy::declare_interior_mutable_const" , description : "Checks for declaration of `const` items which is interior\\nmutable (e.g., contains a `Cell`, `Mutex`, `AtomicXxxx`, etc.)." } , LintCompletion { label : "clippy::default_trait_access" , description : "Checks for literal calls to `Default::default()`." } , LintCompletion { label : "clippy::deprecated_cfg_attr" , description : "Checks for `#[cfg_attr(rustfmt, rustfmt_skip)]` and suggests to replace it\\nwith `#[rustfmt::skip]`." } , LintCompletion { label : "clippy::deprecated_semver" , description : "Checks for `#[deprecated]` annotations with a `since`\\nfield that is not a valid semantic version." } , LintCompletion { label : "clippy::deref_addrof" , description : "Checks for usage of `*&` and `*&mut` in expressions." } , LintCompletion { label : "clippy::derive_hash_xor_eq" , description : "Checks for deriving `Hash` but implementing `PartialEq`\\nexplicitly or vice versa." } , LintCompletion { label : "clippy::derive_ord_xor_partial_ord" , description : "Checks for deriving `Ord` but implementing `PartialOrd`\\nexplicitly or vice versa." } , LintCompletion { label : "clippy::disallowed_method" , description : "Lints for specific trait methods defined in clippy.toml" } , LintCompletion { label : "clippy::diverging_sub_expression" , description : "Checks for diverging calls that are not match arms or\\nstatements." } , LintCompletion { label : "clippy::doc_markdown" , description : "Checks for the presence of `_`, `::` or camel-case words\\noutside ticks in documentation." } , LintCompletion { label : "clippy::double_comparisons" , description : "Checks for double comparisons that could be simplified to a single expression." } , LintCompletion { label : "clippy::double_must_use" , description : "Checks for a [`#[must_use]`] attribute without\\nfurther information on functions and methods that return a type already\\nmarked as `#[must_use]`.\\n\\n[`#[must_use]`]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute" } , LintCompletion { label : "clippy::double_neg" , description : "Detects expressions of the form `--x`." } , LintCompletion { label : "clippy::double_parens" , description : "Checks for unnecessary double parentheses." } , LintCompletion { label : "clippy::drop_bounds" , description : "Nothing. This lint has been deprecated." } , LintCompletion { label : "clippy::drop_copy" , description : "Checks for calls to `std::mem::drop` with a value\\nthat derives the Copy trait" } , LintCompletion { label : "clippy::drop_ref" , description : "Checks for calls to `std::mem::drop` with a reference\\ninstead of an owned value." } , LintCompletion { label : "clippy::duplicate_underscore_argument" , description : "Checks for function arguments having the similar names\\ndiffering by an underscore." } , LintCompletion { label : "clippy::duration_subsec" , description : "Checks for calculation of subsecond microseconds or milliseconds\\nfrom other `Duration` methods." } , LintCompletion { label : "clippy::else_if_without_else" , description : "Checks for usage of if expressions with an `else if` branch,\\nbut without a final `else` branch." } , LintCompletion { label : "clippy::empty_enum" , description : "Checks for `enum`s with no variants." } , LintCompletion { label : "clippy::empty_line_after_outer_attr" , description : "Checks for empty lines after outer attributes" } , LintCompletion { label : "clippy::empty_loop" , description : "Checks for empty `loop` expressions." } , LintCompletion { label : "clippy::enum_clike_unportable_variant" , description : "Checks for C-like enumerations that are\\n`repr(isize/usize)` and have values that don't fit into an `i32`." } , LintCompletion { label : "clippy::enum_glob_use" , description : "Checks for `use Enum::*`." } , LintCompletion { label : "clippy::enum_variant_names" , description : "Detects enumeration variants that are prefixed or suffixed\\nby the same characters." } , LintCompletion { label : "clippy::eq_op" , description : "Checks for equal operands to comparison, logical and\\nbitwise, difference and division binary operators (`==`, `>`, etc., `&&`,\\n`||`, `&`, `|`, `^`, `-` and `/`)." } , LintCompletion { label : "clippy::erasing_op" , description : "Checks for erasing operations, e.g., `x * 0`." } , LintCompletion { label : "clippy::eval_order_dependence" , description : "Checks for a read and a write to the same variable where\\nwhether the read occurs before or after the write depends on the evaluation\\norder of sub-expressions." } , LintCompletion { label : "clippy::excessive_precision" , description : "Checks for float literals with a precision greater\\nthan that supported by the underlying type." } , LintCompletion { label : "clippy::exit" , description : "`exit()` terminates the program and doesn't provide a\\nstack trace." } , LintCompletion { label : "clippy::expect_fun_call" , description : "Checks for calls to `.expect(&format!(...))`, `.expect(foo(..))`,\\netc., and suggests to use `unwrap_or_else` instead" } , LintCompletion { label : "clippy::expect_used" , description : "Checks for `.expect()` calls on `Option`s and `Result`s." } , LintCompletion { label : "clippy::expl_impl_clone_on_copy" , description : "Checks for explicit `Clone` implementations for `Copy`\\ntypes." } , LintCompletion { label : "clippy::explicit_counter_loop" , description : "Checks `for` loops over slices with an explicit counter\\nand suggests the use of `.enumerate()`." } , LintCompletion { label : "clippy::explicit_deref_methods" , description : "Checks for explicit `deref()` or `deref_mut()` method calls." } , LintCompletion { label : "clippy::explicit_into_iter_loop" , description : "Checks for loops on `y.into_iter()` where `y` will do, and\\nsuggests the latter." } , LintCompletion { label : "clippy::explicit_iter_loop" , description : "Checks for loops on `x.iter()` where `&x` will do, and\\nsuggests the latter." } , LintCompletion { label : "clippy::explicit_write" , description : "Checks for usage of `write!()` / `writeln()!` which can be\\nreplaced with `(e)print!()` / `(e)println!()`" } , LintCompletion { label : "clippy::extend_from_slice" , description : "Nothing. This lint has been deprecated." } , LintCompletion { label : "clippy::extra_unused_lifetimes" , description : "Checks for lifetimes in generics that are never used\\nanywhere else." } , LintCompletion { label : "clippy::fallible_impl_from" , description : "Checks for impls of `From<..>` that contain `panic!()` or `unwrap()`" } , LintCompletion { label : "clippy::filetype_is_file" , description : "Checks for `FileType::is_file()`." } , LintCompletion { label : "clippy::filter_map" , description : "Checks for usage of `_.filter(_).map(_)`,\\n`_.filter(_).flat_map(_)`, `_.filter_map(_).flat_map(_)` and similar." } , LintCompletion { label : "clippy::filter_map_next" , description : "Checks for usage of `_.filter_map(_).next()`." } , LintCompletion { label : "clippy::filter_next" , description : "Checks for usage of `_.filter(_).next()`." } , LintCompletion { label : "clippy::find_map" , description : "Checks for usage of `_.find(_).map(_)`." } , LintCompletion { label : "clippy::flat_map_identity" , description : "Checks for usage of `flat_map(|x| x)`." } , LintCompletion { label : "clippy::float_arithmetic" , description : "Checks for float arithmetic." } , LintCompletion { label : "clippy::float_cmp" , description : "Checks for (in-)equality comparisons on floating-point\\nvalues (apart from zero), except in functions called `*eq*` (which probably\\nimplement equality for a type involving floats)." } , LintCompletion { label : "clippy::float_cmp_const" , description : "Checks for (in-)equality comparisons on floating-point\\nvalue and constant, except in functions called `*eq*` (which probably\\nimplement equality for a type involving floats)." } , LintCompletion { label : "clippy::float_equality_without_abs" , description : "Checks for statements of the form `(a - b) < f32::EPSILON` or\\n`(a - b) < f64::EPSILON`. Notes the missing `.abs()`." } , LintCompletion { label : "clippy::fn_address_comparisons" , description : "Checks for comparisons with an address of a function item." } , LintCompletion { label : "clippy::fn_params_excessive_bools" , description : "Checks for excessive use of\\nbools in function definitions." } , LintCompletion { label : "clippy::fn_to_numeric_cast" , description : "Checks for casts of function pointers to something other than usize" } , LintCompletion { label : "clippy::fn_to_numeric_cast_with_truncation" , description : "Checks for casts of a function pointer to a numeric type not wide enough to\\nstore address." } , LintCompletion { label : "clippy::for_kv_map" , description : "Checks for iterating a map (`HashMap` or `BTreeMap`) and\\nignoring either the keys or values." } , LintCompletion { label : "clippy::for_loops_over_fallibles" , description : "Checks for `for` loops over `Option` or `Result` values." } , LintCompletion { label : "clippy::forget_copy" , description : "Checks for calls to `std::mem::forget` with a value that\\nderives the Copy trait" } , LintCompletion { label : "clippy::forget_ref" , description : "Checks for calls to `std::mem::forget` with a reference\\ninstead of an owned value." } , LintCompletion { label : "clippy::future_not_send" , description : "This lint requires Future implementations returned from\\nfunctions and methods to implement the `Send` marker trait. It is mostly\\nused by library authors (public and internal) that target an audience where\\nmultithreaded executors are likely to be used for running these Futures." } , LintCompletion { label : "clippy::get_last_with_len" , description : "Checks for using `x.get(x.len() - 1)` instead of\\n`x.last()`." } , LintCompletion { label : "clippy::get_unwrap" , description : "Checks for use of `.get().unwrap()` (or\\n`.get_mut().unwrap`) on a standard library type which implements `Index`" } , LintCompletion { label : "clippy::identity_op" , description : "Checks for identity operations, e.g., `x + 0`." } , LintCompletion { label : "clippy::if_let_mutex" , description : "Checks for `Mutex::lock` calls in `if let` expression\\nwith lock calls in any of the else blocks." } , LintCompletion { label : "clippy::if_let_redundant_pattern_matching" , description : "Nothing. This lint has been deprecated." } , LintCompletion { label : "clippy::if_let_some_result" , description : "* Checks for unnecessary `ok()` in if let." } , LintCompletion { label : "clippy::if_not_else" , description : "Checks for usage of `!` or `!=` in an if condition with an\\nelse branch." } , LintCompletion { label : "clippy::if_same_then_else" , description : "Checks for `if/else` with the same body as the *then* part\\nand the *else* part." } , LintCompletion { label : "clippy::ifs_same_cond" , description : "Checks for consecutive `if`s with the same condition." } , LintCompletion { label : "clippy::implicit_hasher" , description : "Checks for public `impl` or `fn` missing generalization\\nover different hashers and implicitly defaulting to the default hashing\\nalgorithm (`SipHash`)." } , LintCompletion { label : "clippy::implicit_return" , description : "Checks for missing return statements at the end of a block." } , LintCompletion { label : "clippy::implicit_saturating_sub" , description : "Checks for implicit saturating subtraction." } , LintCompletion { label : "clippy::imprecise_flops" , description : "Looks for floating-point expressions that\\ncan be expressed using built-in methods to improve accuracy\\nat the cost of performance." } , LintCompletion { label : "clippy::inconsistent_digit_grouping" , description : "Warns if an integral or floating-point constant is\\ngrouped inconsistently with underscores." } , LintCompletion { label : "clippy::indexing_slicing" , description : "Checks for usage of indexing or slicing. Arrays are special cases, this lint\\ndoes report on arrays if we can tell that slicing operations are in bounds and does not\\nlint on constant `usize` indexing on arrays because that is handled by rustc's `const_err` lint." } , LintCompletion { label : "clippy::ineffective_bit_mask" , description : "Checks for bit masks in comparisons which can be removed\\nwithout changing the outcome. The basic structure can be seen in the\\nfollowing table:\\n\\n|Comparison| Bit Op |Example |equals |\\n|----------|---------|-----------|-------|\\n|`>` / `<=`|`|` / `^`|`x | 2 > 3`|`x > 3`|\\n|`<` / `>=`|`|` / `^`|`x ^ 1 < 4`|`x < 4`|" } , LintCompletion { label : "clippy::inefficient_to_string" , description : "Checks for usage of `.to_string()` on an `&&T` where\\n`T` implements `ToString` directly (like `&&str` or `&&String`)." } , LintCompletion { label : "clippy::infallible_destructuring_match" , description : "Checks for matches being used to destructure a single-variant enum\\nor tuple struct where a `let` will suffice." } , LintCompletion { label : "clippy::infinite_iter" , description : "Checks for iteration that is guaranteed to be infinite." } , LintCompletion { label : "clippy::inherent_to_string" , description : "Checks for the definition of inherent methods with a signature of `to_string(&self) -> String`." } , LintCompletion { label : "clippy::inherent_to_string_shadow_display" , description : "Checks for the definition of inherent methods with a signature of `to_string(&self) -> String` and if the type implementing this method also implements the `Display` trait." } , LintCompletion { label : "clippy::inline_always" , description : "Checks for items annotated with `#[inline(always)]`,\\nunless the annotated function is empty or simply panics." } , LintCompletion { label : "clippy::inline_asm_x86_att_syntax" , description : "Checks for usage of AT&T x86 assembly syntax." } , LintCompletion { label : "clippy::inline_asm_x86_intel_syntax" , description : "Checks for usage of Intel x86 assembly syntax." } , LintCompletion { label : "clippy::inline_fn_without_body" , description : "Checks for `#[inline]` on trait methods without bodies" } , LintCompletion { label : "clippy::int_plus_one" , description : "Checks for usage of `x >= y + 1` or `x - 1 >= y` (and `<=`) in a block" } , LintCompletion { label : "clippy::integer_arithmetic" , description : "Checks for integer arithmetic operations which could overflow or panic.\\n\\nSpecifically, checks for any operators (`+`, `-`, `*`, `<<`, etc) which are capable\\nof overflowing according to the [Rust\\nReference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#overflow),\\nor which can panic (`/`, `%`). No bounds analysis or sophisticated reasoning is\\nattempted." } , LintCompletion { label : "clippy::integer_division" , description : "Checks for division of integers" } , LintCompletion { label : "clippy::into_iter_on_array" , description : "Nothing. This lint has been deprecated." } , LintCompletion { label : "clippy::into_iter_on_ref" , description : "Checks for `into_iter` calls on references which should be replaced by `iter`\\nor `iter_mut`." } , LintCompletion { label : "clippy::invalid_atomic_ordering" , description : "Checks for usage of invalid atomic\\nordering in atomic loads/stores/exchanges/updates and\\nmemory fences." } , LintCompletion { label : "clippy::invalid_ref" , description : "Nothing. This lint has been deprecated." } , LintCompletion { label : "clippy::invalid_regex" , description : "Checks [regex](https://crates.io/crates/regex) creation\\n(with `Regex::new`,`RegexBuilder::new` or `RegexSet::new`) for correct\\nregex syntax." } , LintCompletion { label : "clippy::invalid_upcast_comparisons" , description : "Checks for comparisons where the relation is always either\\ntrue or false, but where one side has been upcast so that the comparison is\\nnecessary. Only integer types are checked." } , LintCompletion { label : "clippy::invisible_characters" , description : "Checks for invisible Unicode characters in the code." } , LintCompletion { label : "clippy::items_after_statements" , description : "Checks for items declared after some statement in a block." } , LintCompletion { label : "clippy::iter_cloned_collect" , description : "Checks for the use of `.cloned().collect()` on slice to\\ncreate a `Vec`." } , LintCompletion { label : "clippy::iter_next_loop" , description : "Checks for loops on `x.next()`." } , LintCompletion { label : "clippy::iter_next_slice" , description : "Checks for usage of `iter().next()` on a Slice or an Array" } , LintCompletion { label : "clippy::iter_nth" , description : "Checks for use of `.iter().nth()` (and the related\\n`.iter_mut().nth()`) on standard library types with O(1) element access." } , LintCompletion { label : "clippy::iter_nth_zero" , description : "Checks for the use of `iter.nth(0)`." } , LintCompletion { label : "clippy::iter_skip_next" , description : "Checks for use of `.skip(x).next()` on iterators." } , LintCompletion { label : "clippy::iterator_step_by_zero" , description : "Checks for calling `.step_by(0)` on iterators which panics." } , LintCompletion { label : "clippy::just_underscores_and_digits" , description : "Checks if you have variables whose name consists of just\\nunderscores and digits." } , LintCompletion { label : "clippy::large_const_arrays" , description : "Checks for large `const` arrays that should\\nbe defined as `static` instead." } , LintCompletion { label : "clippy::large_digit_groups" , description : "Warns if the digits of an integral or floating-point\\nconstant are grouped into groups that\\nare too large." } , LintCompletion { label : "clippy::large_enum_variant" , description : "Checks for large size differences between variants on\\n`enum`s." } , LintCompletion { label : "clippy::large_stack_arrays" , description : "Checks for local arrays that may be too large." } , LintCompletion { label : "clippy::len_without_is_empty" , description : "Checks for items that implement `.len()` but not\\n`.is_empty()`." } , LintCompletion { label : "clippy::len_zero" , description : "Checks for getting the length of something via `.len()`\\njust to compare to zero, and suggests using `.is_empty()` where applicable." } , LintCompletion { label : "clippy::let_and_return" , description : "Checks for `let`-bindings, which are subsequently\\nreturned." } , LintCompletion { label : "clippy::let_underscore_lock" , description : "Checks for `let _ = sync_lock`" } , LintCompletion { label : "clippy::let_underscore_must_use" , description : "Checks for `let _ = <expr>`\\nwhere expr is #[must_use]" } , LintCompletion { label : "clippy::let_unit_value" , description : "Checks for binding a unit value." } , LintCompletion { label : "clippy::linkedlist" , description : "Checks for usage of any `LinkedList`, suggesting to use a\\n`Vec` or a `VecDeque` (formerly called `RingBuf`)." } , LintCompletion { label : "clippy::logic_bug" , description : "Checks for boolean expressions that contain terminals that\\ncan be eliminated." } , LintCompletion { label : "clippy::lossy_float_literal" , description : "Checks for whole number float literals that\\ncannot be represented as the underlying type without loss." } , LintCompletion { label : "clippy::macro_use_imports" , description : "Checks for `#[macro_use] use...`." } , LintCompletion { label : "clippy::main_recursion" , description : "Checks for recursion using the entrypoint." } , LintCompletion { label : "clippy::manual_async_fn" , description : "It checks for manual implementations of `async` functions." } , LintCompletion { label : "clippy::manual_memcpy" , description : "Checks for for-loops that manually copy items between\\nslices that could be optimized by having a memcpy." } , LintCompletion { label : "clippy::manual_non_exhaustive" , description : "Checks for manual implementations of the non-exhaustive pattern." } , LintCompletion { label : "clippy::manual_saturating_arithmetic" , description : "Checks for `.checked_add/sub(x).unwrap_or(MAX/MIN)`." } , LintCompletion { label : "clippy::manual_strip" , description : "Suggests using `strip_{prefix,suffix}` over `str::{starts,ends}_with` and slicing using\\nthe pattern's length." } , LintCompletion { label : "clippy::manual_swap" , description : "Checks for manual swapping." } , LintCompletion { label : "clippy::manual_unwrap_or" , description : "Finds patterns that reimplement `Option::unwrap_or`." } , LintCompletion { label : "clippy::many_single_char_names" , description : "Checks for too many variables whose name consists of a\\nsingle character." } , LintCompletion { label : "clippy::map_clone" , description : "Checks for usage of `iterator.map(|x| x.clone())` and suggests\\n`iterator.cloned()` instead" } , LintCompletion { label : "clippy::map_entry" , description : "Checks for uses of `contains_key` + `insert` on `HashMap`\\nor `BTreeMap`." } , LintCompletion { label : "clippy::map_err_ignore" , description : "Checks for instances of `map_err(|_| Some::Enum)`" } , LintCompletion { label : "clippy::map_flatten" , description : "Checks for usage of `_.map(_).flatten(_)`," } , LintCompletion { label : "clippy::map_identity" , description : "Checks for instances of `map(f)` where `f` is the identity function." } , LintCompletion { label : "clippy::map_unwrap_or" , description : "Checks for usage of `option.map(_).unwrap_or(_)` or `option.map(_).unwrap_or_else(_)` or\\n`result.map(_).unwrap_or_else(_)`." } , LintCompletion { label : "clippy::match_as_ref" , description : "Checks for match which is used to add a reference to an\\n`Option` value." } , LintCompletion { label : "clippy::match_bool" , description : "Checks for matches where match expression is a `bool`. It\\nsuggests to replace the expression with an `if...else` block." } , LintCompletion { label : "clippy::match_like_matches_macro" , description : "Checks for `match` or `if let` expressions producing a\\n`bool` that could be written using `matches!`" } , LintCompletion { label : "clippy::match_on_vec_items" , description : "Checks for `match vec[idx]` or `match vec[n..m]`." } , LintCompletion { label : "clippy::match_overlapping_arm" , description : "Checks for overlapping match arms." } , LintCompletion { label : "clippy::match_ref_pats" , description : "Checks for matches where all arms match a reference,\\nsuggesting to remove the reference and deref the matched expression\\ninstead. It also checks for `if let &foo = bar` blocks." } , LintCompletion { label : "clippy::match_same_arms" , description : "Checks for `match` with identical arm bodies." } , LintCompletion { label : "clippy::match_single_binding" , description : "Checks for useless match that binds to only one value." } , LintCompletion { label : "clippy::match_wild_err_arm" , description : "Checks for arm which matches all errors with `Err(_)`\\nand take drastic actions like `panic!`." } , LintCompletion { label : "clippy::match_wildcard_for_single_variants" , description : "Checks for wildcard enum matches for a single variant." } , LintCompletion { label : "clippy::maybe_infinite_iter" , description : "Checks for iteration that may be infinite." } , LintCompletion { label : "clippy::mem_discriminant_non_enum" , description : "Checks for calls of `mem::discriminant()` on a non-enum type." } , LintCompletion { label : "clippy::mem_forget" , description : "Checks for usage of `std::mem::forget(t)` where `t` is\\n`Drop`." } , LintCompletion { label : "clippy::mem_replace_option_with_none" , description : "Checks for `mem::replace()` on an `Option` with\\n`None`." } , LintCompletion { label : "clippy::mem_replace_with_default" , description : "Checks for `std::mem::replace` on a value of type\\n`T` with `T::default()`." } , LintCompletion { label : "clippy::mem_replace_with_uninit" , description : "Checks for `mem::replace(&mut _, mem::uninitialized())`\\nand `mem::replace(&mut _, mem::zeroed())`." } , LintCompletion { label : "clippy::min_max" , description : "Checks for expressions where `std::cmp::min` and `max` are\\nused to clamp values, but switched so that the result is constant." } , LintCompletion { label : "clippy::misaligned_transmute" , description : "Nothing. This lint has been deprecated." } , LintCompletion { label : "clippy::mismatched_target_os" , description : "Checks for cfg attributes having operating systems used in target family position." } , LintCompletion { label : "clippy::misrefactored_assign_op" , description : "Checks for `a op= a op b` or `a op= b op a` patterns." } , LintCompletion { label : "clippy::missing_const_for_fn" , description : "Suggests the use of `const` in functions and methods where possible." } , LintCompletion { label : "clippy::missing_docs_in_private_items" , description : "Warns if there is missing doc for any documentable item\\n(public or private)." } , LintCompletion { label : "clippy::missing_errors_doc" , description : "Checks the doc comments of publicly visible functions that\\nreturn a `Result` type and warns if there is no `# Errors` section." } , LintCompletion { label : "clippy::missing_inline_in_public_items" , description : "it lints if an exported function, method, trait method with default impl,\\nor trait method impl is not `#[inline]`." } , LintCompletion { label : "clippy::missing_safety_doc" , description : "Checks for the doc comments of publicly visible\\nunsafe functions and warns if there is no `# Safety` section." } , LintCompletion { label : "clippy::mistyped_literal_suffixes" , description : "Warns for mistyped suffix in literals" } , LintCompletion { label : "clippy::mixed_case_hex_literals" , description : "Warns on hexadecimal literals with mixed-case letter\\ndigits." } , LintCompletion { label : "clippy::module_inception" , description : "Checks for modules that have the same name as their\\nparent module" } , LintCompletion { label : "clippy::module_name_repetitions" , description : "Detects type names that are prefixed or suffixed by the\\ncontaining module's name." } , LintCompletion { label : "clippy::modulo_arithmetic" , description : "Checks for modulo arithmetic." } , LintCompletion { label : "clippy::modulo_one" , description : "Checks for getting the remainder of a division by one." } , LintCompletion { label : "clippy::multiple_crate_versions" , description : "Checks to see if multiple versions of a crate are being\\nused." } , LintCompletion { label : "clippy::multiple_inherent_impl" , description : "Checks for multiple inherent implementations of a struct" } , LintCompletion { label : "clippy::must_use_candidate" , description : "Checks for public functions that have no\\n[`#[must_use]`] attribute, but return something not already marked\\nmust-use, have no mutable arg and mutate no statics.\\n\\n[`#[must_use]`]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute" } , LintCompletion { label : "clippy::must_use_unit" , description : "Checks for a [`#[must_use]`] attribute on\\nunit-returning functions and methods.\\n\\n[`#[must_use]`]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute" } , LintCompletion { label : "clippy::mut_from_ref" , description : "This lint checks for functions that take immutable\\nreferences and return mutable ones." } , LintCompletion { label : "clippy::mut_mut" , description : "Checks for instances of `mut mut` references." } , LintCompletion { label : "clippy::mut_range_bound" , description : "Checks for loops which have a range bound that is a mutable variable" } , LintCompletion { label : "clippy::mutable_key_type" , description : "Checks for sets/maps with mutable key types." } , LintCompletion { label : "clippy::mutex_atomic" , description : "Checks for usages of `Mutex<X>` where an atomic will do." } , LintCompletion { label : "clippy::mutex_integer" , description : "Checks for usages of `Mutex<X>` where `X` is an integral\\ntype." } , LintCompletion { label : "clippy::naive_bytecount" , description : "Checks for naive byte counts" } , LintCompletion { label : "clippy::needless_arbitrary_self_type" , description : "The lint checks for `self` in fn parameters that\\nspecify the `Self`-type explicitly" } , LintCompletion { label : "clippy::needless_bool" , description : "Checks for expressions of the form `if c { true } else {\\nfalse }` (or vice versa) and suggests using the condition directly." } , LintCompletion { label : "clippy::needless_borrow" , description : "Checks for address of operations (`&`) that are going to\\nbe dereferenced immediately by the compiler." } , LintCompletion { label : "clippy::needless_borrowed_reference" , description : "Checks for useless borrowed references." } , LintCompletion { label : "clippy::needless_collect" , description : "Checks for functions collecting an iterator when collect\\nis not needed." } , LintCompletion { label : "clippy::needless_continue" , description : "The lint checks for `if`-statements appearing in loops\\nthat contain a `continue` statement in either their main blocks or their\\n`else`-blocks, when omitting the `else`-block possibly with some\\nrearrangement of code can make the code easier to understand." } , LintCompletion { label : "clippy::needless_doctest_main" , description : "Checks for `fn main() { .. }` in doctests" } , LintCompletion { label : "clippy::needless_lifetimes" , description : "Checks for lifetime annotations which can be removed by\\nrelying on lifetime elision." } , LintCompletion { label : "clippy::needless_pass_by_value" , description : "Checks for functions taking arguments by value, but not\\nconsuming them in its\\nbody." } , LintCompletion { label : "clippy::needless_range_loop" , description : "Checks for looping over the range of `0..len` of some\\ncollection just to get the values by index." } , LintCompletion { label : "clippy::needless_return" , description : "Checks for return statements at the end of a block." } , LintCompletion { label : "clippy::needless_update" , description : "Checks for needlessly including a base struct on update\\nwhen all fields are changed anyway." } , LintCompletion { label : "clippy::neg_cmp_op_on_partial_ord" , description : "Checks for the usage of negated comparison operators on types which only implement\\n`PartialOrd` (e.g., `f64`)." } , LintCompletion { label : "clippy::neg_multiply" , description : "Checks for multiplication by -1 as a form of negation." } , LintCompletion { label : "clippy::never_loop" , description : "Checks for loops that will always `break`, `return` or\\n`continue` an outer loop." } , LintCompletion { label : "clippy::new_ret_no_self" , description : "Checks for `new` not returning a type that contains `Self`." } , LintCompletion { label : "clippy::new_without_default" , description : "Checks for types with a `fn new() -> Self` method and no\\nimplementation of\\n[`Default`](https://doc.rust-lang.org/std/default/trait.Default.html)." } , LintCompletion { label : "clippy::no_effect" , description : "Checks for statements which have no effect." } , LintCompletion { label : "clippy::non_ascii_literal" , description : "Checks for non-ASCII characters in string literals." } , LintCompletion { label : "clippy::nonminimal_bool" , description : "Checks for boolean expressions that can be written more\\nconcisely." } , LintCompletion { label : "clippy::nonsensical_open_options" , description : "Checks for duplicate open options as well as combinations\\nthat make no sense." } , LintCompletion { label : "clippy::not_unsafe_ptr_arg_deref" , description : "Checks for public functions that dereference raw pointer\\narguments but are not marked unsafe." } , LintCompletion { label : "clippy::ok_expect" , description : "Checks for usage of `ok().expect(..)`." } , LintCompletion { label : "clippy::op_ref" , description : "Checks for arguments to `==` which have their address\\ntaken to satisfy a bound\\nand suggests to dereference the other argument instead" } , LintCompletion { label : "clippy::option_as_ref_deref" , description : "Checks for usage of `_.as_ref().map(Deref::deref)` or it's aliases (such as String::as_str)." } , LintCompletion { label : "clippy::option_env_unwrap" , description : "Checks for usage of `option_env!(...).unwrap()` and\\nsuggests usage of the `env!` macro." } , LintCompletion { label : "clippy::option_if_let_else" , description : "Lints usage of `if let Some(v) = ... { y } else { x }` which is more\\nidiomatically done with `Option::map_or` (if the else bit is a pure\\nexpression) or `Option::map_or_else` (if the else bit is an impure\\nexpression)." } , LintCompletion { label : "clippy::option_map_or_none" , description : "Checks for usage of `_.map_or(None, _)`." } , LintCompletion { label : "clippy::option_map_unit_fn" , description : "Checks for usage of `option.map(f)` where f is a function\\nor closure that returns the unit type `()`." } , LintCompletion { label : "clippy::option_option" , description : "Checks for use of `Option<Option<_>>` in function signatures and type\\ndefinitions" } , LintCompletion { label : "clippy::or_fun_call" , description : "Checks for calls to `.or(foo(..))`, `.unwrap_or(foo(..))`,\\netc., and suggests to use `or_else`, `unwrap_or_else`, etc., or\\n`unwrap_or_default` instead." } , LintCompletion { label : "clippy::out_of_bounds_indexing" , description : "Checks for out of bounds array indexing with a constant\\nindex." } , LintCompletion { label : "clippy::overflow_check_conditional" , description : "Detects classic underflow/overflow checks." } , LintCompletion { label : "clippy::panic" , description : "Checks for usage of `panic!`." } , LintCompletion { label : "clippy::panic_in_result_fn" , description : "Checks for usage of `panic!`, `unimplemented!`, `todo!` or `unreachable!` in a function of type result." } , LintCompletion { label : "clippy::panic_params" , description : "Checks for missing parameters in `panic!`." } , LintCompletion { label : "clippy::panicking_unwrap" , description : "Checks for calls of `unwrap[_err]()` that will always fail." } , LintCompletion { label : "clippy::partialeq_ne_impl" , description : "Checks for manual re-implementations of `PartialEq::ne`." } , LintCompletion { label : "clippy::path_buf_push_overwrite" , description : "* Checks for [push](https://doc.rust-lang.org/std/path/struct.PathBuf.html#method.push)\\ncalls on `PathBuf` that can cause overwrites." } , LintCompletion { label : "clippy::pattern_type_mismatch" , description : "Checks for patterns that aren't exact representations of the types\\nthey are applied to.\\n\\nTo satisfy this lint, you will have to adjust either the expression that is matched\\nagainst or the pattern itself, as well as the bindings that are introduced by the\\nadjusted patterns. For matching you will have to either dereference the expression\\nwith the `*` operator, or amend the patterns to explicitly match against `&<pattern>`\\nor `&mut <pattern>` depending on the reference mutability. For the bindings you need\\nto use the inverse. You can leave them as plain bindings if you wish for the value\\nto be copied, but you must use `ref mut <variable>` or `ref <variable>` to construct\\na reference into the matched structure.\\n\\nIf you are looking for a way to learn about ownership semantics in more detail, it\\nis recommended to look at IDE options available to you to highlight types, lifetimes\\nand reference semantics in your code. The available tooling would expose these things\\nin a general way even outside of the various pattern matching mechanics. Of course\\nthis lint can still be used to highlight areas of interest and ensure a good understanding\\nof ownership semantics." } , LintCompletion { label : "clippy::possible_missing_comma" , description : "Checks for possible missing comma in an array. It lints if\\nan array element is a binary operator expression and it lies on two lines." } , LintCompletion { label : "clippy::precedence" , description : "Checks for operations where precedence may be unclear\\nand suggests to add parentheses. Currently it catches the following:\\n* mixed usage of arithmetic and bit shifting/combining operators without\\nparentheses\\n* a \\\"negative\\\" numeric literal (which is really a unary `-` followed by a\\nnumeric literal)\\n followed by a method call" } , LintCompletion { label : "clippy::print_literal" , description : "This lint warns about the use of literals as `print!`/`println!` args." } , LintCompletion { label : "clippy::print_stdout" , description : "Checks for printing on *stdout*. The purpose of this lint\\nis to catch debugging remnants." } , LintCompletion { label : "clippy::print_with_newline" , description : "This lint warns when you use `print!()` with a format\\nstring that ends in a newline." } , LintCompletion { label : "clippy::println_empty_string" , description : "This lint warns when you use `println!(\\\"\\\")` to\\nprint a newline." } , LintCompletion { label : "clippy::ptr_arg" , description : "This lint checks for function arguments of type `&String`\\nor `&Vec` unless the references are mutable. It will also suggest you\\nreplace `.clone()` calls with the appropriate `.to_owned()`/`to_string()`\\ncalls." } , LintCompletion { label : "clippy::ptr_eq" , description : "Use `std::ptr::eq` when applicable" } , LintCompletion { label : "clippy::ptr_offset_with_cast" , description : "Checks for usage of the `offset` pointer method with a `usize` casted to an\\n`isize`." } , LintCompletion { label : "clippy::pub_enum_variant_names" , description : "Detects public enumeration variants that are\\nprefixed or suffixed by the same characters." } , LintCompletion { label : "clippy::question_mark" , description : "Checks for expressions that could be replaced by the question mark operator." } , LintCompletion { label : "clippy::range_minus_one" , description : "Checks for inclusive ranges where 1 is subtracted from\\nthe upper bound, e.g., `x..=(y-1)`." } , LintCompletion { label : "clippy::range_plus_one" , description : "Checks for exclusive ranges where 1 is added to the\\nupper bound, e.g., `x..(y+1)`." } , LintCompletion { label : "clippy::range_step_by_zero" , description : "Nothing. This lint has been deprecated." } , LintCompletion { label : "clippy::range_zip_with_len" , description : "Checks for zipping a collection with the range of\\n`0.._.len()`." } , LintCompletion { label : "clippy::rc_buffer" , description : "Checks for `Rc<T>` and `Arc<T>` when `T` is a mutable buffer type such as `String` or `Vec`." } , LintCompletion { label : "clippy::redundant_allocation" , description : "Checks for use of redundant allocations anywhere in the code." } , LintCompletion { label : "clippy::redundant_clone" , description : "Checks for a redundant `clone()` (and its relatives) which clones an owned\\nvalue that is going to be dropped without further use." } , LintCompletion { label : "clippy::redundant_closure" , description : "Checks for closures which just call another function where\\nthe function can be called directly. `unsafe` functions or calls where types\\nget adjusted are ignored." } , LintCompletion { label : "clippy::redundant_closure_call" , description : "Detects closures called in the same expression where they\\nare defined." } , LintCompletion { label : "clippy::redundant_closure_for_method_calls" , description : "Checks for closures which only invoke a method on the closure\\nargument and can be replaced by referencing the method directly." } , LintCompletion { label : "clippy::redundant_field_names" , description : "Checks for fields in struct literals where shorthands\\ncould be used." } , LintCompletion { label : "clippy::redundant_pattern" , description : "Checks for patterns in the form `name @ _`." } , LintCompletion { label : "clippy::redundant_pattern_matching" , description : "Lint for redundant pattern matching over `Result` or\\n`Option`" } , LintCompletion { label : "clippy::redundant_pub_crate" , description : "Checks for items declared `pub(crate)` that are not crate visible because they\\nare inside a private module." } , LintCompletion { label : "clippy::redundant_static_lifetimes" , description : "Checks for constants and statics with an explicit `'static` lifetime." } , LintCompletion { label : "clippy::ref_in_deref" , description : "Checks for references in expressions that use\\nauto dereference." } , LintCompletion { label : "clippy::regex_macro" , description : "Nothing. This lint has been deprecated." } , LintCompletion { label : "clippy::repeat_once" , description : "Checks for usage of `.repeat(1)` and suggest the following method for each types.\\n- `.to_string()` for `str`\\n- `.clone()` for `String`\\n- `.to_vec()` for `slice`" } , LintCompletion { label : "clippy::replace_consts" , description : "Nothing. This lint has been deprecated." } , LintCompletion { label : "clippy::rest_pat_in_fully_bound_structs" , description : "Checks for unnecessary '..' pattern binding on struct when all fields are explicitly matched." } , LintCompletion { label : "clippy::result_map_or_into_option" , description : "Checks for usage of `_.map_or(None, Some)`." } , LintCompletion { label : "clippy::result_map_unit_fn" , description : "Checks for usage of `result.map(f)` where f is a function\\nor closure that returns the unit type `()`." } , LintCompletion { label : "clippy::result_unit_err" , description : "Checks for public functions that return a `Result`\\nwith an `Err` type of `()`. It suggests using a custom type that\\nimplements [`std::error::Error`]." } , LintCompletion { label : "clippy::reversed_empty_ranges" , description : "Checks for range expressions `x..y` where both `x` and `y`\\nare constant and `x` is greater or equal to `y`." } , LintCompletion { label : "clippy::same_functions_in_if_condition" , description : "Checks for consecutive `if`s with the same function call." } , LintCompletion { label : "clippy::same_item_push" , description : "Checks whether a for loop is being used to push a constant\\nvalue into a Vec." } , LintCompletion { label : "clippy::search_is_some" , description : "Checks for an iterator search (such as `find()`,\\n`position()`, or `rposition()`) followed by a call to `is_some()`." } , LintCompletion { label : "clippy::self_assignment" , description : "Checks for explicit self-assignments." } , LintCompletion { label : "clippy::serde_api_misuse" , description : "Checks for mis-uses of the serde API." } , LintCompletion { label : "clippy::shadow_reuse" , description : "Checks for bindings that shadow other bindings already in\\nscope, while reusing the original value." } , LintCompletion { label : "clippy::shadow_same" , description : "Checks for bindings that shadow other bindings already in\\nscope, while just changing reference level or mutability." } , LintCompletion { label : "clippy::shadow_unrelated" , description : "Checks for bindings that shadow other bindings already in\\nscope, either without a initialization or with one that does not even use\\nthe original value." } , LintCompletion { label : "clippy::short_circuit_statement" , description : "Checks for the use of short circuit boolean conditions as\\na\\nstatement." } , LintCompletion { label : "clippy::should_assert_eq" , description : "Nothing. This lint has been deprecated." } , LintCompletion { label : "clippy::should_implement_trait" , description : "Checks for methods that should live in a trait\\nimplementation of a `std` trait (see [llogiq's blog\\npost](http://llogiq.github.io/2015/07/30/traits.html) for further\\ninformation) instead of an inherent implementation." } , LintCompletion { label : "clippy::similar_names" , description : "Checks for names that are very similar and thus confusing." } , LintCompletion { label : "clippy::single_char_pattern" , description : "Checks for string methods that receive a single-character\\n`str` as an argument, e.g., `_.split(\\\"x\\\")`." } , LintCompletion { label : "clippy::single_char_push_str" , description : "Warns when using `push_str` with a single-character string literal,\\nand `push` with a `char` would work fine." } , LintCompletion { label : "clippy::single_component_path_imports" , description : "Checking for imports with single component use path." } , LintCompletion { label : "clippy::single_match" , description : "Checks for matches with a single arm where an `if let`\\nwill usually suffice." } , LintCompletion { label : "clippy::single_match_else" , description : "Checks for matches with two arms where an `if let else` will\\nusually suffice." } , LintCompletion { label : "clippy::skip_while_next" , description : "Checks for usage of `_.skip_while(condition).next()`." } , LintCompletion { label : "clippy::slow_vector_initialization" , description : "Checks slow zero-filled vector initialization" } , LintCompletion { label : "clippy::stable_sort_primitive" , description : "When sorting primitive values (integers, bools, chars, as well\\nas arrays, slices, and tuples of such items), it is better to\\nuse an unstable sort than a stable sort." } , LintCompletion { label : "clippy::str_to_string" , description : "Nothing. This lint has been deprecated." } , LintCompletion { label : "clippy::string_add" , description : "Checks for all instances of `x + _` where `x` is of type\\n`String`, but only if [`string_add_assign`](#string_add_assign) does *not*\\nmatch." } , LintCompletion { label : "clippy::string_add_assign" , description : "Checks for string appends of the form `x = x + y` (without\\n`let`!)." } , LintCompletion { label : "clippy::string_extend_chars" , description : "Checks for the use of `.extend(s.chars())` where s is a\\n`&str` or `String`." } , LintCompletion { label : "clippy::string_lit_as_bytes" , description : "Checks for the `as_bytes` method called on string literals\\nthat contain only ASCII characters." } , LintCompletion { label : "clippy::string_to_string" , description : "Nothing. This lint has been deprecated." } , LintCompletion { label : "clippy::struct_excessive_bools" , description : "Checks for excessive\\nuse of bools in structs." } , LintCompletion { label : "clippy::suboptimal_flops" , description : "Looks for floating-point expressions that\\ncan be expressed using built-in methods to improve both\\naccuracy and performance." } , LintCompletion { label : "clippy::suspicious_arithmetic_impl" , description : "Lints for suspicious operations in impls of arithmetic operators, e.g.\\nsubtracting elements in an Add impl." } , LintCompletion { label : "clippy::suspicious_assignment_formatting" , description : "Checks for use of the non-existent `=*`, `=!` and `=-`\\noperators." } , LintCompletion { label : "clippy::suspicious_else_formatting" , description : "Checks for formatting of `else`. It lints if the `else`\\nis followed immediately by a newline or the `else` seems to be missing." } , LintCompletion { label : "clippy::suspicious_map" , description : "Checks for calls to `map` followed by a `count`." } , LintCompletion { label : "clippy::suspicious_op_assign_impl" , description : "Lints for suspicious operations in impls of OpAssign, e.g.\\nsubtracting elements in an AddAssign impl." } , LintCompletion { label : "clippy::suspicious_unary_op_formatting" , description : "Checks the formatting of a unary operator on the right hand side\\nof a binary operator. It lints if there is no space between the binary and unary operators,\\nbut there is a space between the unary and its operand." } , LintCompletion { label : "clippy::tabs_in_doc_comments" , description : "Checks doc comments for usage of tab characters." } , LintCompletion { label : "clippy::temporary_assignment" , description : "Checks for construction of a structure or tuple just to\\nassign a value in it." } , LintCompletion { label : "clippy::temporary_cstring_as_ptr" , description : "Checks for getting the inner pointer of a temporary\\n`CString`." } , LintCompletion { label : "clippy::to_digit_is_some" , description : "Checks for `.to_digit(..).is_some()` on `char`s." } , LintCompletion { label : "clippy::to_string_in_display" , description : "Checks for uses of `to_string()` in `Display` traits." } , LintCompletion { label : "clippy::todo" , description : "Checks for usage of `todo!`." } , LintCompletion { label : "clippy::too_many_arguments" , description : "Checks for functions with too many parameters." } , LintCompletion { label : "clippy::too_many_lines" , description : "Checks for functions with a large amount of lines." } , LintCompletion { label : "clippy::toplevel_ref_arg" , description : "Checks for function arguments and let bindings denoted as\\n`ref`." } , LintCompletion { label : "clippy::trait_duplication_in_bounds" , description : "Checks for cases where generics are being used and multiple\\nsyntax specifications for trait bounds are used simultaneously." } , LintCompletion { label : "clippy::transmute_bytes_to_str" , description : "Checks for transmutes from a `&[u8]` to a `&str`." } , LintCompletion { label : "clippy::transmute_float_to_int" , description : "Checks for transmutes from a float to an integer." } , LintCompletion { label : "clippy::transmute_int_to_bool" , description : "Checks for transmutes from an integer to a `bool`." } , LintCompletion { label : "clippy::transmute_int_to_char" , description : "Checks for transmutes from an integer to a `char`." } , LintCompletion { label : "clippy::transmute_int_to_float" , description : "Checks for transmutes from an integer to a float." } , LintCompletion { label : "clippy::transmute_ptr_to_ptr" , description : "Checks for transmutes from a pointer to a pointer, or\\nfrom a reference to a reference." } , LintCompletion { label : "clippy::transmute_ptr_to_ref" , description : "Checks for transmutes from a pointer to a reference." } , LintCompletion { label : "clippy::transmutes_expressible_as_ptr_casts" , description : "Checks for transmutes that could be a pointer cast." } , LintCompletion { label : "clippy::transmuting_null" , description : "Checks for transmute calls which would receive a null pointer." } , LintCompletion { label : "clippy::trivial_regex" , description : "Checks for trivial [regex](https://crates.io/crates/regex)\\ncreation (with `Regex::new`, `RegexBuilder::new` or `RegexSet::new`)." } , LintCompletion { label : "clippy::trivially_copy_pass_by_ref" , description : "Checks for functions taking arguments by reference, where\\nthe argument type is `Copy` and small enough to be more efficient to always\\npass by value." } , LintCompletion { label : "clippy::try_err" , description : "Checks for usages of `Err(x)?`." } , LintCompletion { label : "clippy::type_complexity" , description : "Checks for types used in structs, parameters and `let`\\ndeclarations above a certain complexity threshold." } , LintCompletion { label : "clippy::type_repetition_in_bounds" , description : "This lint warns about unnecessary type repetitions in trait bounds" } , LintCompletion { label : "clippy::unicode_not_nfc" , description : "Checks for string literals that contain Unicode in a form\\nthat is not equal to its\\n[NFC-recomposition](http://www.unicode.org/reports/tr15/#Norm_Forms)." } , LintCompletion { label : "clippy::unimplemented" , description : "Checks for usage of `unimplemented!`." } , LintCompletion { label : "clippy::uninit_assumed_init" , description : "Checks for `MaybeUninit::uninit().assume_init()`." } , LintCompletion { label : "clippy::unit_arg" , description : "Checks for passing a unit value as an argument to a function without using a\\nunit literal (`()`)." } , LintCompletion { label : "clippy::unit_cmp" , description : "Checks for comparisons to unit. This includes all binary\\ncomparisons (like `==` and `<`) and asserts." } , LintCompletion { label : "clippy::unit_return_expecting_ord" , description : "Checks for functions that expect closures of type\\nFn(...) -> Ord where the implemented closure returns the unit type.\\nThe lint also suggests to remove the semi-colon at the end of the statement if present." } , LintCompletion { label : "clippy::unknown_clippy_lints" , description : "Checks for `allow`/`warn`/`deny`/`forbid` attributes with scoped clippy\\nlints and if those lints exist in clippy. If there is an uppercase letter in the lint name\\n(not the tool name) and a lowercase version of this lint exists, it will suggest to lowercase\\nthe lint name." } , LintCompletion { label : "clippy::unnecessary_cast" , description : "Checks for casts to the same type." } , LintCompletion { label : "clippy::unnecessary_filter_map" , description : "Checks for `filter_map` calls which could be replaced by `filter` or `map`.\\nMore specifically it checks if the closure provided is only performing one of the\\nfilter or map operations and suggests the appropriate option." } , LintCompletion { label : "clippy::unnecessary_fold" , description : "Checks for using `fold` when a more succinct alternative exists.\\nSpecifically, this checks for `fold`s which could be replaced by `any`, `all`,\\n`sum` or `product`." } , LintCompletion { label : "clippy::unnecessary_lazy_evaluations" , description : "As the counterpart to `or_fun_call`, this lint looks for unnecessary\\nlazily evaluated closures on `Option` and `Result`.\\n\\nThis lint suggests changing the following functions, when eager evaluation results in\\nsimpler code:\\n - `unwrap_or_else` to `unwrap_or`\\n - `and_then` to `and`\\n - `or_else` to `or`\\n - `get_or_insert_with` to `get_or_insert`\\n - `ok_or_else` to `ok_or`" } , LintCompletion { label : "clippy::unnecessary_mut_passed" , description : "Detects passing a mutable reference to a function that only\\nrequires an immutable reference." } , LintCompletion { label : "clippy::unnecessary_operation" , description : "Checks for expression statements that can be reduced to a\\nsub-expression." } , LintCompletion { label : "clippy::unnecessary_sort_by" , description : "Detects uses of `Vec::sort_by` passing in a closure\\nwhich compares the two arguments, either directly or indirectly." } , LintCompletion { label : "clippy::unnecessary_unwrap" , description : "Checks for calls of `unwrap[_err]()` that cannot fail." } , LintCompletion { label : "clippy::unneeded_field_pattern" , description : "Checks for structure field patterns bound to wildcards." } , LintCompletion { label : "clippy::unneeded_wildcard_pattern" , description : "Checks for tuple patterns with a wildcard\\npattern (`_`) is next to a rest pattern (`..`).\\n\\n_NOTE_: While `_, ..` means there is at least one element left, `..`\\nmeans there are 0 or more elements left. This can make a difference\\nwhen refactoring, but shouldn't result in errors in the refactored code,\\nsince the wildcard pattern isn't used anyway." } , LintCompletion { label : "clippy::unnested_or_patterns" , description : "Checks for unnested or-patterns, e.g., `Some(0) | Some(2)` and\\nsuggests replacing the pattern with a nested one, `Some(0 | 2)`.\\n\\nAnother way to think of this is that it rewrites patterns in\\n*disjunctive normal form (DNF)* into *conjunctive normal form (CNF)*." } , LintCompletion { label : "clippy::unreachable" , description : "Checks for usage of `unreachable!`." } , LintCompletion { label : "clippy::unreadable_literal" , description : "Warns if a long integral or floating-point constant does\\nnot contain underscores." } , LintCompletion { label : "clippy::unsafe_derive_deserialize" , description : "Checks for deriving `serde::Deserialize` on a type that\\nhas methods using `unsafe`." } , LintCompletion { label : "clippy::unsafe_removed_from_name" , description : "Checks for imports that remove \\\"unsafe\\\" from an item's\\nname." } , LintCompletion { label : "clippy::unsafe_vector_initialization" , description : "Nothing. This lint has been deprecated." } , LintCompletion { label : "clippy::unseparated_literal_suffix" , description : "Warns if literal suffixes are not separated by an\\nunderscore." } , LintCompletion { label : "clippy::unsound_collection_transmute" , description : "Checks for transmutes between collections whose\\ntypes have different ABI, size or alignment." } , LintCompletion { label : "clippy::unstable_as_mut_slice" , description : "Nothing. This lint has been deprecated." } , LintCompletion { label : "clippy::unstable_as_slice" , description : "Nothing. This lint has been deprecated." } , LintCompletion { label : "clippy::unused_collect" , description : "Nothing. This lint has been deprecated." } , LintCompletion { label : "clippy::unused_io_amount" , description : "Checks for unused written/read amount." } , LintCompletion { label : "clippy::unused_label" , description : "Nothing. This lint has been deprecated." } , LintCompletion { label : "clippy::unused_self" , description : "Checks methods that contain a `self` argument but don't use it" } , LintCompletion { label : "clippy::unused_unit" , description : "Checks for unit (`()`) expressions that can be removed." } , LintCompletion { label : "clippy::unwrap_in_result" , description : "Checks for functions of type Result that contain `expect()` or `unwrap()`" } , LintCompletion { label : "clippy::unwrap_used" , description : "Checks for `.unwrap()` calls on `Option`s and on `Result`s." } , LintCompletion { label : "clippy::use_debug" , description : "Checks for use of `Debug` formatting. The purpose of this\\nlint is to catch debugging remnants." } , LintCompletion { label : "clippy::use_self" , description : "Checks for unnecessary repetition of structure name when a\\nreplacement with `Self` is applicable." } , LintCompletion { label : "clippy::used_underscore_binding" , description : "Checks for the use of bindings with a single leading\\nunderscore." } , LintCompletion { label : "clippy::useless_asref" , description : "Checks for usage of `.as_ref()` or `.as_mut()` where the\\ntypes before and after the call are the same." } , LintCompletion { label : "clippy::useless_attribute" , description : "Checks for `extern crate` and `use` items annotated with\\nlint attributes.\\n\\nThis lint permits `#[allow(unused_imports)]`, `#[allow(deprecated)]`,\\n`#[allow(unreachable_pub)]`, `#[allow(clippy::wildcard_imports)]` and\\n`#[allow(clippy::enum_glob_use)]` on `use` items and `#[allow(unused_imports)]` on\\n`extern crate` items with a `#[macro_use]` attribute." } , LintCompletion { label : "clippy::useless_conversion" , description : "Checks for `Into`, `TryInto`, `From`, `TryFrom`,`IntoIter` calls\\nthat useless converts to the same type as caller." } , LintCompletion { label : "clippy::useless_format" , description : "Checks for the use of `format!(\\\"string literal with no\\nargument\\\")` and `format!(\\\"{}\\\", foo)` where `foo` is a string." } , LintCompletion { label : "clippy::useless_let_if_seq" , description : "Checks for variable declarations immediately followed by a\\nconditional affectation." } , LintCompletion { label : "clippy::useless_transmute" , description : "Checks for transmutes to the original type of the object\\nand transmutes that could be a cast." } , LintCompletion { label : "clippy::useless_vec" , description : "Checks for usage of `&vec![..]` when using `&[..]` would\\nbe possible." } , LintCompletion { label : "clippy::vec_box" , description : "Checks for use of `Vec<Box<T>>` where T: Sized anywhere in the code.\\nCheck the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information." } , LintCompletion { label : "clippy::vec_resize_to_zero" , description : "Finds occurrences of `Vec::resize(0, an_int)`" } , LintCompletion { label : "clippy::verbose_bit_mask" , description : "Checks for bit masks that can be replaced by a call\\nto `trailing_zeros`" } , LintCompletion { label : "clippy::verbose_file_reads" , description : "Checks for use of File::read_to_end and File::read_to_string." } , LintCompletion { label : "clippy::vtable_address_comparisons" , description : "Checks for comparisons with an address of a trait vtable." } , LintCompletion { label : "clippy::while_immutable_condition" , description : "Checks whether variables used within while loop condition\\ncan be (and are) mutated in the body." } , LintCompletion { label : "clippy::while_let_loop" , description : "Detects `loop + match` combinations that are easier\\nwritten as a `while let` loop." } , LintCompletion { label : "clippy::while_let_on_iterator" , description : "Checks for `while let` expressions on iterators." } , LintCompletion { label : "clippy::wildcard_dependencies" , description : "Checks for wildcard dependencies in the `Cargo.toml`." } , LintCompletion { label : "clippy::wildcard_enum_match_arm" , description : "Checks for wildcard enum matches using `_`." } , LintCompletion { label : "clippy::wildcard_imports" , description : "Checks for wildcard imports `use _::*`." } , LintCompletion { label : "clippy::wildcard_in_or_patterns" , description : "Checks for wildcard pattern used with others patterns in same match arm." } , LintCompletion { label : "clippy::write_literal" , description : "This lint warns about the use of literals as `write!`/`writeln!` args." } , LintCompletion { label : "clippy::write_with_newline" , description : "This lint warns when you use `write!()` with a format\\nstring that\\nends in a newline." } , LintCompletion { label : "clippy::writeln_empty_string" , description : "This lint warns when you use `writeln!(buf, \\\"\\\")` to\\nprint a newline." } , LintCompletion { label : "clippy::wrong_pub_self_convention" , description : "This is the same as\\n[`wrong_self_convention`](#wrong_self_convention), but for public items." } , LintCompletion { label : "clippy::wrong_self_convention" , description : "Checks for methods with certain name prefixes and which\\ndoesn't match how self is taken. The actual rules are:\\n\\n|Prefix |`self` taken |\\n|-------|----------------------|\\n|`as_` |`&self` or `&mut self`|\\n|`from_`| none |\\n|`into_`|`self` |\\n|`is_` |`&self` or none |\\n|`to_` |`&self` |" } , LintCompletion { label : "clippy::wrong_transmute" , description : "Checks for transmutes that can't ever be correct on any\\narchitecture." } , LintCompletion { label : "clippy::zero_divided_by_zero" , description : "Checks for `0.0 / 0.0`." } , LintCompletion { label : "clippy::zero_prefixed_literal" , description : "Warns if an integral constant literal starts with `0`." } , LintCompletion { label : "clippy::zero_ptr" , description : "Catch casts from `0` to some pointer type" } , LintCompletion { label : "clippy::zst_offset" , description : "Checks for `offset(_)`, `wrapping_`{`add`, `sub`}, etc. on raw pointers to\\nzero-sized types" }] ;
diff --git a/crates/completion/src/lib.rs b/crates/completion/src/lib.rs
new file mode 100644
index 000000000..0a60ea7f2
--- /dev/null
+++ b/crates/completion/src/lib.rs
@@ -0,0 +1,264 @@
1//! `completions` crate provides utilities for generating completions of user input.
2
3mod completion_config;
4mod completion_item;
5mod completion_context;
6mod presentation;
7mod patterns;
8mod generated_lint_completions;
9#[cfg(test)]
10mod test_utils;
11
12mod complete_attribute;
13mod complete_dot;
14mod complete_record;
15mod complete_pattern;
16mod complete_fn_param;
17mod complete_keyword;
18mod complete_snippet;
19mod complete_qualified_path;
20mod complete_unqualified_path;
21mod complete_postfix;
22mod complete_macro_in_item_position;
23mod complete_trait_impl;
24mod complete_mod;
25
26use base_db::FilePosition;
27use ide_db::RootDatabase;
28
29use crate::{
30 completion_context::CompletionContext,
31 completion_item::{CompletionKind, Completions},
32};
33
34pub use crate::{
35 completion_config::CompletionConfig,
36 completion_item::{CompletionItem, CompletionItemKind, CompletionScore, InsertTextFormat},
37};
38
39//FIXME: split the following feature into fine-grained features.
40
41// Feature: Magic Completions
42//
43// In addition to usual reference completion, rust-analyzer provides some ✨magic✨
44// completions as well:
45//
46// Keywords like `if`, `else` `while`, `loop` are completed with braces, and cursor
47// is placed at the appropriate position. Even though `if` is easy to type, you
48// still want to complete it, to get ` { }` for free! `return` is inserted with a
49// space or `;` depending on the return type of the function.
50//
51// When completing a function call, `()` are automatically inserted. If a function
52// takes arguments, the cursor is positioned inside the parenthesis.
53//
54// There are postfix completions, which can be triggered by typing something like
55// `foo().if`. The word after `.` determines postfix completion. Possible variants are:
56//
57// - `expr.if` -> `if expr {}` or `if let ... {}` for `Option` or `Result`
58// - `expr.match` -> `match expr {}`
59// - `expr.while` -> `while expr {}` or `while let ... {}` for `Option` or `Result`
60// - `expr.ref` -> `&expr`
61// - `expr.refm` -> `&mut expr`
62// - `expr.not` -> `!expr`
63// - `expr.dbg` -> `dbg!(expr)`
64// - `expr.dbgr` -> `dbg!(&expr)`
65// - `expr.call` -> `(expr)`
66//
67// There also snippet completions:
68//
69// .Expressions
70// - `pd` -> `eprintln!(" = {:?}", );`
71// - `ppd` -> `eprintln!(" = {:#?}", );`
72//
73// .Items
74// - `tfn` -> `#[test] fn feature(){}`
75// - `tmod` ->
76// ```rust
77// #[cfg(test)]
78// mod tests {
79// use super::*;
80//
81// #[test]
82// fn test_name() {}
83// }
84// ```
85
86/// Main entry point for completion. We run completion as a two-phase process.
87///
88/// First, we look at the position and collect a so-called `CompletionContext.
89/// This is a somewhat messy process, because, during completion, syntax tree is
90/// incomplete and can look really weird.
91///
92/// Once the context is collected, we run a series of completion routines which
93/// look at the context and produce completion items. One subtlety about this
94/// phase is that completion engine should not filter by the substring which is
95/// already present, it should give all possible variants for the identifier at
96/// the caret. In other words, for
97///
98/// ```no_run
99/// fn f() {
100/// let foo = 92;
101/// let _ = bar<|>
102/// }
103/// ```
104///
105/// `foo` *should* be present among the completion variants. Filtering by
106/// identifier prefix/fuzzy match should be done higher in the stack, together
107/// with ordering of completions (currently this is done by the client).
108pub fn completions(
109 db: &RootDatabase,
110 config: &CompletionConfig,
111 position: FilePosition,
112) -> Option<Completions> {
113 let ctx = CompletionContext::new(db, position, config)?;
114
115 if ctx.no_completion_required() {
116 // No work required here.
117 return None;
118 }
119
120 let mut acc = Completions::default();
121 complete_attribute::complete_attribute(&mut acc, &ctx);
122 complete_fn_param::complete_fn_param(&mut acc, &ctx);
123 complete_keyword::complete_expr_keyword(&mut acc, &ctx);
124 complete_keyword::complete_use_tree_keyword(&mut acc, &ctx);
125 complete_snippet::complete_expr_snippet(&mut acc, &ctx);
126 complete_snippet::complete_item_snippet(&mut acc, &ctx);
127 complete_qualified_path::complete_qualified_path(&mut acc, &ctx);
128 complete_unqualified_path::complete_unqualified_path(&mut acc, &ctx);
129 complete_dot::complete_dot(&mut acc, &ctx);
130 complete_record::complete_record(&mut acc, &ctx);
131 complete_pattern::complete_pattern(&mut acc, &ctx);
132 complete_postfix::complete_postfix(&mut acc, &ctx);
133 complete_macro_in_item_position::complete_macro_in_item_position(&mut acc, &ctx);
134 complete_trait_impl::complete_trait_impl(&mut acc, &ctx);
135 complete_mod::complete_mod(&mut acc, &ctx);
136
137 Some(acc)
138}
139
140#[cfg(test)]
141mod tests {
142 use crate::completion_config::CompletionConfig;
143 use crate::test_utils;
144
145 struct DetailAndDocumentation<'a> {
146 detail: &'a str,
147 documentation: &'a str,
148 }
149
150 fn check_detail_and_documentation(ra_fixture: &str, expected: DetailAndDocumentation) {
151 let (db, position) = test_utils::position(ra_fixture);
152 let config = CompletionConfig::default();
153 let completions: Vec<_> = crate::completions(&db, &config, position).unwrap().into();
154 for item in completions {
155 if item.detail() == Some(expected.detail) {
156 let opt = item.documentation();
157 let doc = opt.as_ref().map(|it| it.as_str());
158 assert_eq!(doc, Some(expected.documentation));
159 return;
160 }
161 }
162 panic!("completion detail not found: {}", expected.detail)
163 }
164
165 fn check_no_completion(ra_fixture: &str) {
166 let (db, position) = test_utils::position(ra_fixture);
167 let config = CompletionConfig::default();
168
169 let completions: Option<Vec<String>> = crate::completions(&db, &config, position)
170 .and_then(|completions| {
171 let completions: Vec<_> = completions.into();
172 if completions.is_empty() {
173 None
174 } else {
175 Some(completions)
176 }
177 })
178 .map(|completions| {
179 completions.into_iter().map(|completion| format!("{:?}", completion)).collect()
180 });
181
182 // `assert_eq` instead of `assert!(completions.is_none())` to get the list of completions if test will panic.
183 assert_eq!(completions, None, "Completions were generated, but weren't expected");
184 }
185
186 #[test]
187 fn test_completion_detail_from_macro_generated_struct_fn_doc_attr() {
188 check_detail_and_documentation(
189 r#"
190 //- /lib.rs
191 macro_rules! bar {
192 () => {
193 struct Bar;
194 impl Bar {
195 #[doc = "Do the foo"]
196 fn foo(&self) {}
197 }
198 }
199 }
200
201 bar!();
202
203 fn foo() {
204 let bar = Bar;
205 bar.fo<|>;
206 }
207 "#,
208 DetailAndDocumentation { detail: "fn foo(&self)", documentation: "Do the foo" },
209 );
210 }
211
212 #[test]
213 fn test_completion_detail_from_macro_generated_struct_fn_doc_comment() {
214 check_detail_and_documentation(
215 r#"
216 //- /lib.rs
217 macro_rules! bar {
218 () => {
219 struct Bar;
220 impl Bar {
221 /// Do the foo
222 fn foo(&self) {}
223 }
224 }
225 }
226
227 bar!();
228
229 fn foo() {
230 let bar = Bar;
231 bar.fo<|>;
232 }
233 "#,
234 DetailAndDocumentation { detail: "fn foo(&self)", documentation: " Do the foo" },
235 );
236 }
237
238 #[test]
239 fn test_no_completions_required() {
240 // There must be no hint for 'in' keyword.
241 check_no_completion(
242 r#"
243 fn foo() {
244 for i i<|>
245 }
246 "#,
247 );
248 // After 'in' keyword hints may be spawned.
249 check_detail_and_documentation(
250 r#"
251 /// Do the foo
252 fn foo() -> &'static str { "foo" }
253
254 fn bar() {
255 for c in fo<|>
256 }
257 "#,
258 DetailAndDocumentation {
259 detail: "fn foo() -> &'static str",
260 documentation: "Do the foo",
261 },
262 );
263 }
264}
diff --git a/crates/completion/src/patterns.rs b/crates/completion/src/patterns.rs
new file mode 100644
index 000000000..b0f35f9bf
--- /dev/null
+++ b/crates/completion/src/patterns.rs
@@ -0,0 +1,249 @@
1//! Patterns telling us certain facts about current syntax element, they are used in completion context
2
3use syntax::{
4 algo::non_trivia_sibling,
5 ast::{self, LoopBodyOwner},
6 match_ast, AstNode, Direction, NodeOrToken, SyntaxElement,
7 SyntaxKind::*,
8 SyntaxNode, SyntaxToken,
9};
10
11#[cfg(test)]
12use crate::test_utils::{check_pattern_is_applicable, check_pattern_is_not_applicable};
13
14pub(crate) fn has_trait_parent(element: SyntaxElement) -> bool {
15 not_same_range_ancestor(element)
16 .filter(|it| it.kind() == ASSOC_ITEM_LIST)
17 .and_then(|it| it.parent())
18 .filter(|it| it.kind() == TRAIT)
19 .is_some()
20}
21#[test]
22fn test_has_trait_parent() {
23 check_pattern_is_applicable(r"trait A { f<|> }", has_trait_parent);
24}
25
26pub(crate) fn has_impl_parent(element: SyntaxElement) -> bool {
27 not_same_range_ancestor(element)
28 .filter(|it| it.kind() == ASSOC_ITEM_LIST)
29 .and_then(|it| it.parent())
30 .filter(|it| it.kind() == IMPL)
31 .is_some()
32}
33#[test]
34fn test_has_impl_parent() {
35 check_pattern_is_applicable(r"impl A { f<|> }", has_impl_parent);
36}
37
38pub(crate) fn inside_impl_trait_block(element: SyntaxElement) -> bool {
39 // Here we search `impl` keyword up through the all ancestors, unlike in `has_impl_parent`,
40 // where we only check the first parent with different text range.
41 element
42 .ancestors()
43 .find(|it| it.kind() == IMPL)
44 .map(|it| ast::Impl::cast(it).unwrap())
45 .map(|it| it.trait_().is_some())
46 .unwrap_or(false)
47}
48#[test]
49fn test_inside_impl_trait_block() {
50 check_pattern_is_applicable(r"impl Foo for Bar { f<|> }", inside_impl_trait_block);
51 check_pattern_is_applicable(r"impl Foo for Bar { fn f<|> }", inside_impl_trait_block);
52 check_pattern_is_not_applicable(r"impl A { f<|> }", inside_impl_trait_block);
53 check_pattern_is_not_applicable(r"impl A { fn f<|> }", inside_impl_trait_block);
54}
55
56pub(crate) fn has_field_list_parent(element: SyntaxElement) -> bool {
57 not_same_range_ancestor(element).filter(|it| it.kind() == RECORD_FIELD_LIST).is_some()
58}
59#[test]
60fn test_has_field_list_parent() {
61 check_pattern_is_applicable(r"struct Foo { f<|> }", has_field_list_parent);
62 check_pattern_is_applicable(r"struct Foo { f<|> pub f: i32}", has_field_list_parent);
63}
64
65pub(crate) fn has_block_expr_parent(element: SyntaxElement) -> bool {
66 not_same_range_ancestor(element).filter(|it| it.kind() == BLOCK_EXPR).is_some()
67}
68#[test]
69fn test_has_block_expr_parent() {
70 check_pattern_is_applicable(r"fn my_fn() { let a = 2; f<|> }", has_block_expr_parent);
71}
72
73pub(crate) fn has_bind_pat_parent(element: SyntaxElement) -> bool {
74 element.ancestors().find(|it| it.kind() == IDENT_PAT).is_some()
75}
76#[test]
77fn test_has_bind_pat_parent() {
78 check_pattern_is_applicable(r"fn my_fn(m<|>) {}", has_bind_pat_parent);
79 check_pattern_is_applicable(r"fn my_fn() { let m<|> }", has_bind_pat_parent);
80}
81
82pub(crate) fn has_ref_parent(element: SyntaxElement) -> bool {
83 not_same_range_ancestor(element)
84 .filter(|it| it.kind() == REF_PAT || it.kind() == REF_EXPR)
85 .is_some()
86}
87#[test]
88fn test_has_ref_parent() {
89 check_pattern_is_applicable(r"fn my_fn(&m<|>) {}", has_ref_parent);
90 check_pattern_is_applicable(r"fn my() { let &m<|> }", has_ref_parent);
91}
92
93pub(crate) fn has_item_list_or_source_file_parent(element: SyntaxElement) -> bool {
94 let ancestor = not_same_range_ancestor(element);
95 if !ancestor.is_some() {
96 return true;
97 }
98 ancestor.filter(|it| it.kind() == SOURCE_FILE || it.kind() == ITEM_LIST).is_some()
99}
100#[test]
101fn test_has_item_list_or_source_file_parent() {
102 check_pattern_is_applicable(r"i<|>", has_item_list_or_source_file_parent);
103 check_pattern_is_applicable(r"mod foo { f<|> }", has_item_list_or_source_file_parent);
104}
105
106pub(crate) fn is_match_arm(element: SyntaxElement) -> bool {
107 not_same_range_ancestor(element.clone()).filter(|it| it.kind() == MATCH_ARM).is_some()
108 && previous_sibling_or_ancestor_sibling(element)
109 .and_then(|it| it.into_token())
110 .filter(|it| it.kind() == FAT_ARROW)
111 .is_some()
112}
113#[test]
114fn test_is_match_arm() {
115 check_pattern_is_applicable(r"fn my_fn() { match () { () => m<|> } }", is_match_arm);
116}
117
118pub(crate) fn unsafe_is_prev(element: SyntaxElement) -> bool {
119 element
120 .into_token()
121 .and_then(|it| previous_non_trivia_token(it))
122 .filter(|it| it.kind() == UNSAFE_KW)
123 .is_some()
124}
125#[test]
126fn test_unsafe_is_prev() {
127 check_pattern_is_applicable(r"unsafe i<|>", unsafe_is_prev);
128}
129
130pub(crate) fn if_is_prev(element: SyntaxElement) -> bool {
131 element
132 .into_token()
133 .and_then(|it| previous_non_trivia_token(it))
134 .filter(|it| it.kind() == IF_KW)
135 .is_some()
136}
137
138pub(crate) fn fn_is_prev(element: SyntaxElement) -> bool {
139 element
140 .into_token()
141 .and_then(|it| previous_non_trivia_token(it))
142 .filter(|it| it.kind() == FN_KW)
143 .is_some()
144}
145#[test]
146fn test_fn_is_prev() {
147 check_pattern_is_applicable(r"fn l<|>", fn_is_prev);
148}
149
150/// Check if the token previous to the previous one is `for`.
151/// For example, `for _ i<|>` => true.
152pub(crate) fn for_is_prev2(element: SyntaxElement) -> bool {
153 element
154 .into_token()
155 .and_then(|it| previous_non_trivia_token(it))
156 .and_then(|it| previous_non_trivia_token(it))
157 .filter(|it| it.kind() == FOR_KW)
158 .is_some()
159}
160#[test]
161fn test_for_is_prev2() {
162 check_pattern_is_applicable(r"for i i<|>", for_is_prev2);
163}
164
165#[test]
166fn test_if_is_prev() {
167 check_pattern_is_applicable(r"if l<|>", if_is_prev);
168}
169
170pub(crate) fn has_trait_as_prev_sibling(element: SyntaxElement) -> bool {
171 previous_sibling_or_ancestor_sibling(element).filter(|it| it.kind() == TRAIT).is_some()
172}
173#[test]
174fn test_has_trait_as_prev_sibling() {
175 check_pattern_is_applicable(r"trait A w<|> {}", has_trait_as_prev_sibling);
176}
177
178pub(crate) fn has_impl_as_prev_sibling(element: SyntaxElement) -> bool {
179 previous_sibling_or_ancestor_sibling(element).filter(|it| it.kind() == IMPL).is_some()
180}
181#[test]
182fn test_has_impl_as_prev_sibling() {
183 check_pattern_is_applicable(r"impl A w<|> {}", has_impl_as_prev_sibling);
184}
185
186pub(crate) fn is_in_loop_body(element: SyntaxElement) -> bool {
187 let leaf = match element {
188 NodeOrToken::Node(node) => node,
189 NodeOrToken::Token(token) => token.parent(),
190 };
191 for node in leaf.ancestors() {
192 if node.kind() == FN || node.kind() == CLOSURE_EXPR {
193 break;
194 }
195 let loop_body = match_ast! {
196 match node {
197 ast::ForExpr(it) => it.loop_body(),
198 ast::WhileExpr(it) => it.loop_body(),
199 ast::LoopExpr(it) => it.loop_body(),
200 _ => None,
201 }
202 };
203 if let Some(body) = loop_body {
204 if body.syntax().text_range().contains_range(leaf.text_range()) {
205 return true;
206 }
207 }
208 }
209 false
210}
211
212fn not_same_range_ancestor(element: SyntaxElement) -> Option<SyntaxNode> {
213 element
214 .ancestors()
215 .take_while(|it| it.text_range() == element.text_range())
216 .last()
217 .and_then(|it| it.parent())
218}
219
220fn previous_non_trivia_token(token: SyntaxToken) -> Option<SyntaxToken> {
221 let mut token = token.prev_token();
222 while let Some(inner) = token.clone() {
223 if !inner.kind().is_trivia() {
224 return Some(inner);
225 } else {
226 token = inner.prev_token();
227 }
228 }
229 None
230}
231
232fn previous_sibling_or_ancestor_sibling(element: SyntaxElement) -> Option<SyntaxElement> {
233 let token_sibling = non_trivia_sibling(element.clone(), Direction::Prev);
234 if let Some(sibling) = token_sibling {
235 Some(sibling)
236 } else {
237 // if not trying to find first ancestor which has such a sibling
238 let node = match element {
239 NodeOrToken::Node(node) => node,
240 NodeOrToken::Token(token) => token.parent(),
241 };
242 let range = node.text_range();
243 let top_node = node.ancestors().take_while(|it| it.text_range() == range).last()?;
244 let prev_sibling_node = top_node.ancestors().find(|it| {
245 non_trivia_sibling(NodeOrToken::Node(it.to_owned()), Direction::Prev).is_some()
246 })?;
247 non_trivia_sibling(NodeOrToken::Node(prev_sibling_node), Direction::Prev)
248 }
249}
diff --git a/crates/completion/src/presentation.rs b/crates/completion/src/presentation.rs
new file mode 100644
index 000000000..0a6f5a1ea
--- /dev/null
+++ b/crates/completion/src/presentation.rs
@@ -0,0 +1,1410 @@
1//! This modules takes care of rendering various definitions as completion items.
2//! It also handles scoring (sorting) completions.
3
4use hir::{HasAttrs, HasSource, HirDisplay, ModPath, Mutability, ScopeDef, StructKind, Type};
5use itertools::Itertools;
6use syntax::{ast::NameOwner, display::*};
7use test_utils::mark;
8
9use crate::{
10 // display::{const_label, function_declaration, macro_label, type_label},
11 CompletionScore,
12 RootDatabase,
13 {
14 completion_item::Builder, CompletionContext, CompletionItem, CompletionItemKind,
15 CompletionKind, Completions,
16 },
17};
18
19impl Completions {
20 pub(crate) fn add_field(&mut self, ctx: &CompletionContext, field: hir::Field, ty: &Type) {
21 let is_deprecated = is_deprecated(field, ctx.db);
22 let name = field.name(ctx.db);
23 let mut completion_item =
24 CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name.to_string())
25 .kind(CompletionItemKind::Field)
26 .detail(ty.display(ctx.db).to_string())
27 .set_documentation(field.docs(ctx.db))
28 .set_deprecated(is_deprecated);
29
30 if let Some(score) = compute_score(ctx, &ty, &name.to_string()) {
31 completion_item = completion_item.set_score(score);
32 }
33
34 completion_item.add_to(self);
35 }
36
37 pub(crate) fn add_tuple_field(&mut self, ctx: &CompletionContext, field: usize, ty: &Type) {
38 CompletionItem::new(CompletionKind::Reference, ctx.source_range(), field.to_string())
39 .kind(CompletionItemKind::Field)
40 .detail(ty.display(ctx.db).to_string())
41 .add_to(self);
42 }
43
44 pub(crate) fn add_resolution(
45 &mut self,
46 ctx: &CompletionContext,
47 local_name: String,
48 resolution: &ScopeDef,
49 ) {
50 use hir::ModuleDef::*;
51
52 let completion_kind = match resolution {
53 ScopeDef::ModuleDef(BuiltinType(..)) => CompletionKind::BuiltinType,
54 _ => CompletionKind::Reference,
55 };
56
57 let kind = match resolution {
58 ScopeDef::ModuleDef(Module(..)) => CompletionItemKind::Module,
59 ScopeDef::ModuleDef(Function(func)) => {
60 return self.add_function(ctx, *func, Some(local_name));
61 }
62 ScopeDef::ModuleDef(Adt(hir::Adt::Struct(_))) => CompletionItemKind::Struct,
63 // FIXME: add CompletionItemKind::Union
64 ScopeDef::ModuleDef(Adt(hir::Adt::Union(_))) => CompletionItemKind::Struct,
65 ScopeDef::ModuleDef(Adt(hir::Adt::Enum(_))) => CompletionItemKind::Enum,
66
67 ScopeDef::ModuleDef(EnumVariant(var)) => {
68 return self.add_enum_variant(ctx, *var, Some(local_name));
69 }
70 ScopeDef::ModuleDef(Const(..)) => CompletionItemKind::Const,
71 ScopeDef::ModuleDef(Static(..)) => CompletionItemKind::Static,
72 ScopeDef::ModuleDef(Trait(..)) => CompletionItemKind::Trait,
73 ScopeDef::ModuleDef(TypeAlias(..)) => CompletionItemKind::TypeAlias,
74 ScopeDef::ModuleDef(BuiltinType(..)) => CompletionItemKind::BuiltinType,
75 ScopeDef::GenericParam(..) => CompletionItemKind::TypeParam,
76 ScopeDef::Local(..) => CompletionItemKind::Binding,
77 // (does this need its own kind?)
78 ScopeDef::AdtSelfType(..) | ScopeDef::ImplSelfType(..) => CompletionItemKind::TypeParam,
79 ScopeDef::MacroDef(mac) => {
80 return self.add_macro(ctx, Some(local_name), *mac);
81 }
82 ScopeDef::Unknown => {
83 return self.add(
84 CompletionItem::new(CompletionKind::Reference, ctx.source_range(), local_name)
85 .kind(CompletionItemKind::UnresolvedReference),
86 );
87 }
88 };
89
90 let docs = match resolution {
91 ScopeDef::ModuleDef(Module(it)) => it.docs(ctx.db),
92 ScopeDef::ModuleDef(Adt(it)) => it.docs(ctx.db),
93 ScopeDef::ModuleDef(EnumVariant(it)) => it.docs(ctx.db),
94 ScopeDef::ModuleDef(Const(it)) => it.docs(ctx.db),
95 ScopeDef::ModuleDef(Static(it)) => it.docs(ctx.db),
96 ScopeDef::ModuleDef(Trait(it)) => it.docs(ctx.db),
97 ScopeDef::ModuleDef(TypeAlias(it)) => it.docs(ctx.db),
98 _ => None,
99 };
100
101 let mut completion_item =
102 CompletionItem::new(completion_kind, ctx.source_range(), local_name.clone());
103 if let ScopeDef::Local(local) = resolution {
104 let ty = local.ty(ctx.db);
105 if !ty.is_unknown() {
106 completion_item = completion_item.detail(ty.display(ctx.db).to_string());
107 }
108 };
109
110 let mut ref_match = None;
111 if let ScopeDef::Local(local) = resolution {
112 if let Some((active_name, active_type)) = ctx.active_name_and_type() {
113 let ty = local.ty(ctx.db);
114 if let Some(score) =
115 compute_score_from_active(&active_type, &active_name, &ty, &local_name)
116 {
117 completion_item = completion_item.set_score(score);
118 }
119 ref_match = refed_type_matches(&active_type, &active_name, &ty, &local_name);
120 }
121 }
122
123 // Add `<>` for generic types
124 if ctx.is_path_type && !ctx.has_type_args && ctx.config.add_call_parenthesis {
125 if let Some(cap) = ctx.config.snippet_cap {
126 let has_non_default_type_params = match resolution {
127 ScopeDef::ModuleDef(Adt(it)) => it.has_non_default_type_params(ctx.db),
128 ScopeDef::ModuleDef(TypeAlias(it)) => it.has_non_default_type_params(ctx.db),
129 _ => false,
130 };
131 if has_non_default_type_params {
132 mark::hit!(inserts_angle_brackets_for_generics);
133 completion_item = completion_item
134 .lookup_by(local_name.clone())
135 .label(format!("{}<…>", local_name))
136 .insert_snippet(cap, format!("{}<$0>", local_name));
137 }
138 }
139 }
140
141 completion_item.kind(kind).set_documentation(docs).set_ref_match(ref_match).add_to(self)
142 }
143
144 pub(crate) fn add_macro(
145 &mut self,
146 ctx: &CompletionContext,
147 name: Option<String>,
148 macro_: hir::MacroDef,
149 ) {
150 // FIXME: Currently proc-macro do not have ast-node,
151 // such that it does not have source
152 if macro_.is_proc_macro() {
153 return;
154 }
155
156 let name = match name {
157 Some(it) => it,
158 None => return,
159 };
160
161 let ast_node = macro_.source(ctx.db).value;
162 let detail = macro_label(&ast_node);
163
164 let docs = macro_.docs(ctx.db);
165
166 let mut builder = CompletionItem::new(
167 CompletionKind::Reference,
168 ctx.source_range(),
169 &format!("{}!", name),
170 )
171 .kind(CompletionItemKind::Macro)
172 .set_documentation(docs.clone())
173 .set_deprecated(is_deprecated(macro_, ctx.db))
174 .detail(detail);
175
176 let needs_bang = ctx.use_item_syntax.is_none() && !ctx.is_macro_call;
177 builder = match ctx.config.snippet_cap {
178 Some(cap) if needs_bang => {
179 let docs = docs.as_ref().map_or("", |s| s.as_str());
180 let (bra, ket) = guess_macro_braces(&name, docs);
181 builder
182 .insert_snippet(cap, format!("{}!{}$0{}", name, bra, ket))
183 .label(format!("{}!{}…{}", name, bra, ket))
184 .lookup_by(format!("{}!", name))
185 }
186 None if needs_bang => builder.insert_text(format!("{}!", name)),
187 _ => {
188 mark::hit!(dont_insert_macro_call_parens_unncessary);
189 builder.insert_text(name)
190 }
191 };
192
193 self.add(builder);
194 }
195
196 pub(crate) fn add_function(
197 &mut self,
198 ctx: &CompletionContext,
199 func: hir::Function,
200 local_name: Option<String>,
201 ) {
202 fn add_arg(arg: &str, ty: &Type, ctx: &CompletionContext) -> String {
203 if let Some(derefed_ty) = ty.remove_ref() {
204 for (name, local) in ctx.locals.iter() {
205 if name == arg && local.ty(ctx.db) == derefed_ty {
206 return (if ty.is_mutable_reference() { "&mut " } else { "&" }).to_string()
207 + &arg.to_string();
208 }
209 }
210 }
211 arg.to_string()
212 };
213 let name = local_name.unwrap_or_else(|| func.name(ctx.db).to_string());
214 let ast_node = func.source(ctx.db).value;
215
216 let mut builder =
217 CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name.clone())
218 .kind(if func.self_param(ctx.db).is_some() {
219 CompletionItemKind::Method
220 } else {
221 CompletionItemKind::Function
222 })
223 .set_documentation(func.docs(ctx.db))
224 .set_deprecated(is_deprecated(func, ctx.db))
225 .detail(function_declaration(&ast_node));
226
227 let params_ty = func.params(ctx.db);
228 let params = ast_node
229 .param_list()
230 .into_iter()
231 .flat_map(|it| it.params())
232 .zip(params_ty)
233 .flat_map(|(it, param_ty)| {
234 if let Some(pat) = it.pat() {
235 let name = pat.to_string();
236 let arg = name.trim_start_matches("mut ").trim_start_matches('_');
237 return Some(add_arg(arg, param_ty.ty(), ctx));
238 }
239 None
240 })
241 .collect();
242
243 builder = builder.add_call_parens(ctx, name, Params::Named(params));
244
245 self.add(builder)
246 }
247
248 pub(crate) fn add_const(&mut self, ctx: &CompletionContext, constant: hir::Const) {
249 let ast_node = constant.source(ctx.db).value;
250 let name = match ast_node.name() {
251 Some(name) => name,
252 _ => return,
253 };
254 let detail = const_label(&ast_node);
255
256 CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name.text().to_string())
257 .kind(CompletionItemKind::Const)
258 .set_documentation(constant.docs(ctx.db))
259 .set_deprecated(is_deprecated(constant, ctx.db))
260 .detail(detail)
261 .add_to(self);
262 }
263
264 pub(crate) fn add_type_alias(&mut self, ctx: &CompletionContext, type_alias: hir::TypeAlias) {
265 let type_def = type_alias.source(ctx.db).value;
266 let name = match type_def.name() {
267 Some(name) => name,
268 _ => return,
269 };
270 let detail = type_label(&type_def);
271
272 CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name.text().to_string())
273 .kind(CompletionItemKind::TypeAlias)
274 .set_documentation(type_alias.docs(ctx.db))
275 .set_deprecated(is_deprecated(type_alias, ctx.db))
276 .detail(detail)
277 .add_to(self);
278 }
279
280 pub(crate) fn add_qualified_enum_variant(
281 &mut self,
282 ctx: &CompletionContext,
283 variant: hir::EnumVariant,
284 path: ModPath,
285 ) {
286 self.add_enum_variant_impl(ctx, variant, None, Some(path))
287 }
288
289 pub(crate) fn add_enum_variant(
290 &mut self,
291 ctx: &CompletionContext,
292 variant: hir::EnumVariant,
293 local_name: Option<String>,
294 ) {
295 self.add_enum_variant_impl(ctx, variant, local_name, None)
296 }
297
298 fn add_enum_variant_impl(
299 &mut self,
300 ctx: &CompletionContext,
301 variant: hir::EnumVariant,
302 local_name: Option<String>,
303 path: Option<ModPath>,
304 ) {
305 let is_deprecated = is_deprecated(variant, ctx.db);
306 let name = local_name.unwrap_or_else(|| variant.name(ctx.db).to_string());
307 let (qualified_name, short_qualified_name) = match &path {
308 Some(path) => {
309 let full = path.to_string();
310 let short =
311 path.segments[path.segments.len().saturating_sub(2)..].iter().join("::");
312 (full, short)
313 }
314 None => (name.to_string(), name.to_string()),
315 };
316 let detail_types = variant
317 .fields(ctx.db)
318 .into_iter()
319 .map(|field| (field.name(ctx.db), field.signature_ty(ctx.db)));
320 let variant_kind = variant.kind(ctx.db);
321 let detail = match variant_kind {
322 StructKind::Tuple | StructKind::Unit => format!(
323 "({})",
324 detail_types.map(|(_, t)| t.display(ctx.db).to_string()).format(", ")
325 ),
326 StructKind::Record => format!(
327 "{{ {} }}",
328 detail_types
329 .map(|(n, t)| format!("{}: {}", n, t.display(ctx.db).to_string()))
330 .format(", ")
331 ),
332 };
333 let mut res = CompletionItem::new(
334 CompletionKind::Reference,
335 ctx.source_range(),
336 qualified_name.clone(),
337 )
338 .kind(CompletionItemKind::EnumVariant)
339 .set_documentation(variant.docs(ctx.db))
340 .set_deprecated(is_deprecated)
341 .detail(detail);
342
343 if variant_kind == StructKind::Tuple {
344 mark::hit!(inserts_parens_for_tuple_enums);
345 let params = Params::Anonymous(variant.fields(ctx.db).len());
346 res = res.add_call_parens(ctx, short_qualified_name, params)
347 } else if path.is_some() {
348 res = res.lookup_by(short_qualified_name);
349 }
350
351 res.add_to(self);
352 }
353}
354
355fn compute_score_from_active(
356 active_type: &Type,
357 active_name: &str,
358 ty: &Type,
359 name: &str,
360) -> Option<CompletionScore> {
361 // Compute score
362 // For the same type
363 if active_type != ty {
364 return None;
365 }
366
367 let mut res = CompletionScore::TypeMatch;
368
369 // If same type + same name then go top position
370 if active_name == name {
371 res = CompletionScore::TypeAndNameMatch
372 }
373
374 Some(res)
375}
376fn refed_type_matches(
377 active_type: &Type,
378 active_name: &str,
379 ty: &Type,
380 name: &str,
381) -> Option<(Mutability, CompletionScore)> {
382 let derefed_active = active_type.remove_ref()?;
383 let score = compute_score_from_active(&derefed_active, &active_name, &ty, &name)?;
384 Some((
385 if active_type.is_mutable_reference() { Mutability::Mut } else { Mutability::Shared },
386 score,
387 ))
388}
389
390fn compute_score(ctx: &CompletionContext, ty: &Type, name: &str) -> Option<CompletionScore> {
391 let (active_name, active_type) = ctx.active_name_and_type()?;
392 compute_score_from_active(&active_type, &active_name, ty, name)
393}
394
395enum Params {
396 Named(Vec<String>),
397 Anonymous(usize),
398}
399
400impl Params {
401 fn len(&self) -> usize {
402 match self {
403 Params::Named(xs) => xs.len(),
404 Params::Anonymous(len) => *len,
405 }
406 }
407
408 fn is_empty(&self) -> bool {
409 self.len() == 0
410 }
411}
412
413impl Builder {
414 fn add_call_parens(mut self, ctx: &CompletionContext, name: String, params: Params) -> Builder {
415 if !ctx.config.add_call_parenthesis {
416 return self;
417 }
418 if ctx.use_item_syntax.is_some() {
419 mark::hit!(no_parens_in_use_item);
420 return self;
421 }
422 if ctx.is_pattern_call {
423 mark::hit!(dont_duplicate_pattern_parens);
424 return self;
425 }
426 if ctx.is_call {
427 return self;
428 }
429
430 // Don't add parentheses if the expected type is some function reference.
431 if let Some(ty) = &ctx.expected_type {
432 if ty.is_fn() {
433 mark::hit!(no_call_parens_if_fn_ptr_needed);
434 return self;
435 }
436 }
437
438 let cap = match ctx.config.snippet_cap {
439 Some(it) => it,
440 None => return self,
441 };
442 // If not an import, add parenthesis automatically.
443 mark::hit!(inserts_parens_for_function_calls);
444
445 let (snippet, label) = if params.is_empty() {
446 (format!("{}()$0", name), format!("{}()", name))
447 } else {
448 self = self.trigger_call_info();
449 let snippet = match (ctx.config.add_call_argument_snippets, params) {
450 (true, Params::Named(params)) => {
451 let function_params_snippet =
452 params.iter().enumerate().format_with(", ", |(index, param_name), f| {
453 f(&format_args!("${{{}:{}}}", index + 1, param_name))
454 });
455 format!("{}({})$0", name, function_params_snippet)
456 }
457 _ => {
458 mark::hit!(suppress_arg_snippets);
459 format!("{}($0)", name)
460 }
461 };
462
463 (snippet, format!("{}(…)", name))
464 };
465 self.lookup_by(name).label(label).insert_snippet(cap, snippet)
466 }
467}
468
469fn is_deprecated(node: impl HasAttrs, db: &RootDatabase) -> bool {
470 node.attrs(db).by_key("deprecated").exists()
471}
472
473fn guess_macro_braces(macro_name: &str, docs: &str) -> (&'static str, &'static str) {
474 let mut votes = [0, 0, 0];
475 for (idx, s) in docs.match_indices(&macro_name) {
476 let (before, after) = (&docs[..idx], &docs[idx + s.len()..]);
477 // Ensure to match the full word
478 if after.starts_with('!')
479 && !before.ends_with(|c: char| c == '_' || c.is_ascii_alphanumeric())
480 {
481 // It may have spaces before the braces like `foo! {}`
482 match after[1..].chars().find(|&c| !c.is_whitespace()) {
483 Some('{') => votes[0] += 1,
484 Some('[') => votes[1] += 1,
485 Some('(') => votes[2] += 1,
486 _ => {}
487 }
488 }
489 }
490
491 // Insert a space before `{}`.
492 // We prefer the last one when some votes equal.
493 let (_vote, (bra, ket)) = votes
494 .iter()
495 .zip(&[(" {", "}"), ("[", "]"), ("(", ")")])
496 .max_by_key(|&(&vote, _)| vote)
497 .unwrap();
498 (*bra, *ket)
499}
500
501#[cfg(test)]
502mod tests {
503 use std::cmp::Reverse;
504
505 use expect_test::{expect, Expect};
506 use test_utils::mark;
507
508 use crate::{
509 test_utils::{check_edit, check_edit_with_config, do_completion, get_all_completion_items},
510 CompletionConfig, CompletionKind, CompletionScore,
511 };
512
513 fn check(ra_fixture: &str, expect: Expect) {
514 let actual = do_completion(ra_fixture, CompletionKind::Reference);
515 expect.assert_debug_eq(&actual);
516 }
517
518 fn check_scores(ra_fixture: &str, expect: Expect) {
519 fn display_score(score: Option<CompletionScore>) -> &'static str {
520 match score {
521 Some(CompletionScore::TypeMatch) => "[type]",
522 Some(CompletionScore::TypeAndNameMatch) => "[type+name]",
523 None => "[]".into(),
524 }
525 }
526
527 let mut completions = get_all_completion_items(CompletionConfig::default(), ra_fixture);
528 completions.sort_by_key(|it| (Reverse(it.score()), it.label().to_string()));
529 let actual = completions
530 .into_iter()
531 .filter(|it| it.completion_kind == CompletionKind::Reference)
532 .map(|it| {
533 let tag = it.kind().unwrap().tag();
534 let score = display_score(it.score());
535 format!("{} {} {}\n", tag, it.label(), score)
536 })
537 .collect::<String>();
538 expect.assert_eq(&actual);
539 }
540
541 #[test]
542 fn enum_detail_includes_record_fields() {
543 check(
544 r#"
545enum Foo { Foo { x: i32, y: i32 } }
546
547fn main() { Foo::Fo<|> }
548"#,
549 expect![[r#"
550 [
551 CompletionItem {
552 label: "Foo",
553 source_range: 54..56,
554 delete: 54..56,
555 insert: "Foo",
556 kind: EnumVariant,
557 detail: "{ x: i32, y: i32 }",
558 },
559 ]
560 "#]],
561 );
562 }
563
564 #[test]
565 fn enum_detail_doesnt_include_tuple_fields() {
566 check(
567 r#"
568enum Foo { Foo (i32, i32) }
569
570fn main() { Foo::Fo<|> }
571"#,
572 expect![[r#"
573 [
574 CompletionItem {
575 label: "Foo(…)",
576 source_range: 46..48,
577 delete: 46..48,
578 insert: "Foo($0)",
579 kind: EnumVariant,
580 lookup: "Foo",
581 detail: "(i32, i32)",
582 trigger_call_info: true,
583 },
584 ]
585 "#]],
586 );
587 }
588
589 #[test]
590 fn enum_detail_just_parentheses_for_unit() {
591 check(
592 r#"
593enum Foo { Foo }
594
595fn main() { Foo::Fo<|> }
596"#,
597 expect![[r#"
598 [
599 CompletionItem {
600 label: "Foo",
601 source_range: 35..37,
602 delete: 35..37,
603 insert: "Foo",
604 kind: EnumVariant,
605 detail: "()",
606 },
607 ]
608 "#]],
609 );
610 }
611
612 #[test]
613 fn lookup_enums_by_two_qualifiers() {
614 check(
615 r#"
616mod m {
617 pub enum Spam { Foo, Bar(i32) }
618}
619fn main() { let _: m::Spam = S<|> }
620"#,
621 expect![[r#"
622 [
623 CompletionItem {
624 label: "Spam::Bar(…)",
625 source_range: 75..76,
626 delete: 75..76,
627 insert: "Spam::Bar($0)",
628 kind: EnumVariant,
629 lookup: "Spam::Bar",
630 detail: "(i32)",
631 trigger_call_info: true,
632 },
633 CompletionItem {
634 label: "m",
635 source_range: 75..76,
636 delete: 75..76,
637 insert: "m",
638 kind: Module,
639 },
640 CompletionItem {
641 label: "m::Spam::Foo",
642 source_range: 75..76,
643 delete: 75..76,
644 insert: "m::Spam::Foo",
645 kind: EnumVariant,
646 lookup: "Spam::Foo",
647 detail: "()",
648 },
649 CompletionItem {
650 label: "main()",
651 source_range: 75..76,
652 delete: 75..76,
653 insert: "main()$0",
654 kind: Function,
655 lookup: "main",
656 detail: "fn main()",
657 },
658 ]
659 "#]],
660 )
661 }
662
663 #[test]
664 fn sets_deprecated_flag_in_completion_items() {
665 check(
666 r#"
667#[deprecated]
668fn something_deprecated() {}
669#[deprecated(since = "1.0.0")]
670fn something_else_deprecated() {}
671
672fn main() { som<|> }
673"#,
674 expect![[r#"
675 [
676 CompletionItem {
677 label: "main()",
678 source_range: 121..124,
679 delete: 121..124,
680 insert: "main()$0",
681 kind: Function,
682 lookup: "main",
683 detail: "fn main()",
684 },
685 CompletionItem {
686 label: "something_deprecated()",
687 source_range: 121..124,
688 delete: 121..124,
689 insert: "something_deprecated()$0",
690 kind: Function,
691 lookup: "something_deprecated",
692 detail: "fn something_deprecated()",
693 deprecated: true,
694 },
695 CompletionItem {
696 label: "something_else_deprecated()",
697 source_range: 121..124,
698 delete: 121..124,
699 insert: "something_else_deprecated()$0",
700 kind: Function,
701 lookup: "something_else_deprecated",
702 detail: "fn something_else_deprecated()",
703 deprecated: true,
704 },
705 ]
706 "#]],
707 );
708
709 check(
710 r#"
711struct A { #[deprecated] the_field: u32 }
712fn foo() { A { the<|> } }
713"#,
714 expect![[r#"
715 [
716 CompletionItem {
717 label: "the_field",
718 source_range: 57..60,
719 delete: 57..60,
720 insert: "the_field",
721 kind: Field,
722 detail: "u32",
723 deprecated: true,
724 },
725 ]
726 "#]],
727 );
728 }
729
730 #[test]
731 fn renders_docs() {
732 check(
733 r#"
734struct S {
735 /// Field docs
736 foo:
737}
738impl S {
739 /// Method docs
740 fn bar(self) { self.<|> }
741}"#,
742 expect![[r#"
743 [
744 CompletionItem {
745 label: "bar()",
746 source_range: 94..94,
747 delete: 94..94,
748 insert: "bar()$0",
749 kind: Method,
750 lookup: "bar",
751 detail: "fn bar(self)",
752 documentation: Documentation(
753 "Method docs",
754 ),
755 },
756 CompletionItem {
757 label: "foo",
758 source_range: 94..94,
759 delete: 94..94,
760 insert: "foo",
761 kind: Field,
762 detail: "{unknown}",
763 documentation: Documentation(
764 "Field docs",
765 ),
766 },
767 ]
768 "#]],
769 );
770
771 check(
772 r#"
773use self::my<|>;
774
775/// mod docs
776mod my { }
777
778/// enum docs
779enum E {
780 /// variant docs
781 V
782}
783use self::E::*;
784"#,
785 expect![[r#"
786 [
787 CompletionItem {
788 label: "E",
789 source_range: 10..12,
790 delete: 10..12,
791 insert: "E",
792 kind: Enum,
793 documentation: Documentation(
794 "enum docs",
795 ),
796 },
797 CompletionItem {
798 label: "V",
799 source_range: 10..12,
800 delete: 10..12,
801 insert: "V",
802 kind: EnumVariant,
803 detail: "()",
804 documentation: Documentation(
805 "variant docs",
806 ),
807 },
808 CompletionItem {
809 label: "my",
810 source_range: 10..12,
811 delete: 10..12,
812 insert: "my",
813 kind: Module,
814 documentation: Documentation(
815 "mod docs",
816 ),
817 },
818 ]
819 "#]],
820 )
821 }
822
823 #[test]
824 fn dont_render_attrs() {
825 check(
826 r#"
827struct S;
828impl S {
829 #[inline]
830 fn the_method(&self) { }
831}
832fn foo(s: S) { s.<|> }
833"#,
834 expect![[r#"
835 [
836 CompletionItem {
837 label: "the_method()",
838 source_range: 81..81,
839 delete: 81..81,
840 insert: "the_method()$0",
841 kind: Method,
842 lookup: "the_method",
843 detail: "fn the_method(&self)",
844 },
845 ]
846 "#]],
847 )
848 }
849
850 #[test]
851 fn inserts_parens_for_function_calls() {
852 mark::check!(inserts_parens_for_function_calls);
853 check_edit(
854 "no_args",
855 r#"
856fn no_args() {}
857fn main() { no_<|> }
858"#,
859 r#"
860fn no_args() {}
861fn main() { no_args()$0 }
862"#,
863 );
864
865 check_edit(
866 "with_args",
867 r#"
868fn with_args(x: i32, y: String) {}
869fn main() { with_<|> }
870"#,
871 r#"
872fn with_args(x: i32, y: String) {}
873fn main() { with_args(${1:x}, ${2:y})$0 }
874"#,
875 );
876
877 check_edit(
878 "foo",
879 r#"
880struct S;
881impl S {
882 fn foo(&self) {}
883}
884fn bar(s: &S) { s.f<|> }
885"#,
886 r#"
887struct S;
888impl S {
889 fn foo(&self) {}
890}
891fn bar(s: &S) { s.foo()$0 }
892"#,
893 );
894
895 check_edit(
896 "foo",
897 r#"
898struct S {}
899impl S {
900 fn foo(&self, x: i32) {}
901}
902fn bar(s: &S) {
903 s.f<|>
904}
905"#,
906 r#"
907struct S {}
908impl S {
909 fn foo(&self, x: i32) {}
910}
911fn bar(s: &S) {
912 s.foo(${1:x})$0
913}
914"#,
915 );
916 }
917
918 #[test]
919 fn suppress_arg_snippets() {
920 mark::check!(suppress_arg_snippets);
921 check_edit_with_config(
922 CompletionConfig { add_call_argument_snippets: false, ..CompletionConfig::default() },
923 "with_args",
924 r#"
925fn with_args(x: i32, y: String) {}
926fn main() { with_<|> }
927"#,
928 r#"
929fn with_args(x: i32, y: String) {}
930fn main() { with_args($0) }
931"#,
932 );
933 }
934
935 #[test]
936 fn strips_underscores_from_args() {
937 check_edit(
938 "foo",
939 r#"
940fn foo(_foo: i32, ___bar: bool, ho_ge_: String) {}
941fn main() { f<|> }
942"#,
943 r#"
944fn foo(_foo: i32, ___bar: bool, ho_ge_: String) {}
945fn main() { foo(${1:foo}, ${2:bar}, ${3:ho_ge_})$0 }
946"#,
947 );
948 }
949
950 #[test]
951 fn insert_ref_when_matching_local_in_scope() {
952 check_edit(
953 "ref_arg",
954 r#"
955struct Foo {}
956fn ref_arg(x: &Foo) {}
957fn main() {
958 let x = Foo {};
959 ref_ar<|>
960}
961"#,
962 r#"
963struct Foo {}
964fn ref_arg(x: &Foo) {}
965fn main() {
966 let x = Foo {};
967 ref_arg(${1:&x})$0
968}
969"#,
970 );
971 }
972
973 #[test]
974 fn insert_mut_ref_when_matching_local_in_scope() {
975 check_edit(
976 "ref_arg",
977 r#"
978struct Foo {}
979fn ref_arg(x: &mut Foo) {}
980fn main() {
981 let x = Foo {};
982 ref_ar<|>
983}
984"#,
985 r#"
986struct Foo {}
987fn ref_arg(x: &mut Foo) {}
988fn main() {
989 let x = Foo {};
990 ref_arg(${1:&mut x})$0
991}
992"#,
993 );
994 }
995
996 #[test]
997 fn insert_ref_when_matching_local_in_scope_for_method() {
998 check_edit(
999 "apply_foo",
1000 r#"
1001struct Foo {}
1002struct Bar {}
1003impl Bar {
1004 fn apply_foo(&self, x: &Foo) {}
1005}
1006
1007fn main() {
1008 let x = Foo {};
1009 let y = Bar {};
1010 y.<|>
1011}
1012"#,
1013 r#"
1014struct Foo {}
1015struct Bar {}
1016impl Bar {
1017 fn apply_foo(&self, x: &Foo) {}
1018}
1019
1020fn main() {
1021 let x = Foo {};
1022 let y = Bar {};
1023 y.apply_foo(${1:&x})$0
1024}
1025"#,
1026 );
1027 }
1028
1029 #[test]
1030 fn trim_mut_keyword_in_func_completion() {
1031 check_edit(
1032 "take_mutably",
1033 r#"
1034fn take_mutably(mut x: &i32) {}
1035
1036fn main() {
1037 take_m<|>
1038}
1039"#,
1040 r#"
1041fn take_mutably(mut x: &i32) {}
1042
1043fn main() {
1044 take_mutably(${1:x})$0
1045}
1046"#,
1047 );
1048 }
1049
1050 #[test]
1051 fn inserts_parens_for_tuple_enums() {
1052 mark::check!(inserts_parens_for_tuple_enums);
1053 check_edit(
1054 "Some",
1055 r#"
1056enum Option<T> { Some(T), None }
1057use Option::*;
1058fn main() -> Option<i32> {
1059 Som<|>
1060}
1061"#,
1062 r#"
1063enum Option<T> { Some(T), None }
1064use Option::*;
1065fn main() -> Option<i32> {
1066 Some($0)
1067}
1068"#,
1069 );
1070 check_edit(
1071 "Some",
1072 r#"
1073enum Option<T> { Some(T), None }
1074use Option::*;
1075fn main(value: Option<i32>) {
1076 match value {
1077 Som<|>
1078 }
1079}
1080"#,
1081 r#"
1082enum Option<T> { Some(T), None }
1083use Option::*;
1084fn main(value: Option<i32>) {
1085 match value {
1086 Some($0)
1087 }
1088}
1089"#,
1090 );
1091 }
1092
1093 #[test]
1094 fn dont_duplicate_pattern_parens() {
1095 mark::check!(dont_duplicate_pattern_parens);
1096 check_edit(
1097 "Var",
1098 r#"
1099enum E { Var(i32) }
1100fn main() {
1101 match E::Var(92) {
1102 E::<|>(92) => (),
1103 }
1104}
1105"#,
1106 r#"
1107enum E { Var(i32) }
1108fn main() {
1109 match E::Var(92) {
1110 E::Var(92) => (),
1111 }
1112}
1113"#,
1114 );
1115 }
1116
1117 #[test]
1118 fn no_call_parens_if_fn_ptr_needed() {
1119 mark::check!(no_call_parens_if_fn_ptr_needed);
1120 check_edit(
1121 "foo",
1122 r#"
1123fn foo(foo: u8, bar: u8) {}
1124struct ManualVtable { f: fn(u8, u8) }
1125
1126fn main() -> ManualVtable {
1127 ManualVtable { f: f<|> }
1128}
1129"#,
1130 r#"
1131fn foo(foo: u8, bar: u8) {}
1132struct ManualVtable { f: fn(u8, u8) }
1133
1134fn main() -> ManualVtable {
1135 ManualVtable { f: foo }
1136}
1137"#,
1138 );
1139 }
1140
1141 #[test]
1142 fn no_parens_in_use_item() {
1143 mark::check!(no_parens_in_use_item);
1144 check_edit(
1145 "foo",
1146 r#"
1147mod m { pub fn foo() {} }
1148use crate::m::f<|>;
1149"#,
1150 r#"
1151mod m { pub fn foo() {} }
1152use crate::m::foo;
1153"#,
1154 );
1155 }
1156
1157 #[test]
1158 fn no_parens_in_call() {
1159 check_edit(
1160 "foo",
1161 r#"
1162fn foo(x: i32) {}
1163fn main() { f<|>(); }
1164"#,
1165 r#"
1166fn foo(x: i32) {}
1167fn main() { foo(); }
1168"#,
1169 );
1170 check_edit(
1171 "foo",
1172 r#"
1173struct Foo;
1174impl Foo { fn foo(&self){} }
1175fn f(foo: &Foo) { foo.f<|>(); }
1176"#,
1177 r#"
1178struct Foo;
1179impl Foo { fn foo(&self){} }
1180fn f(foo: &Foo) { foo.foo(); }
1181"#,
1182 );
1183 }
1184
1185 #[test]
1186 fn inserts_angle_brackets_for_generics() {
1187 mark::check!(inserts_angle_brackets_for_generics);
1188 check_edit(
1189 "Vec",
1190 r#"
1191struct Vec<T> {}
1192fn foo(xs: Ve<|>)
1193"#,
1194 r#"
1195struct Vec<T> {}
1196fn foo(xs: Vec<$0>)
1197"#,
1198 );
1199 check_edit(
1200 "Vec",
1201 r#"
1202type Vec<T> = (T,);
1203fn foo(xs: Ve<|>)
1204"#,
1205 r#"
1206type Vec<T> = (T,);
1207fn foo(xs: Vec<$0>)
1208"#,
1209 );
1210 check_edit(
1211 "Vec",
1212 r#"
1213struct Vec<T = i128> {}
1214fn foo(xs: Ve<|>)
1215"#,
1216 r#"
1217struct Vec<T = i128> {}
1218fn foo(xs: Vec)
1219"#,
1220 );
1221 check_edit(
1222 "Vec",
1223 r#"
1224struct Vec<T> {}
1225fn foo(xs: Ve<|><i128>)
1226"#,
1227 r#"
1228struct Vec<T> {}
1229fn foo(xs: Vec<i128>)
1230"#,
1231 );
1232 }
1233
1234 #[test]
1235 fn dont_insert_macro_call_parens_unncessary() {
1236 mark::check!(dont_insert_macro_call_parens_unncessary);
1237 check_edit(
1238 "frobnicate!",
1239 r#"
1240//- /main.rs crate:main deps:foo
1241use foo::<|>;
1242//- /foo/lib.rs crate:foo
1243#[macro_export]
1244macro_rules frobnicate { () => () }
1245"#,
1246 r#"
1247use foo::frobnicate;
1248"#,
1249 );
1250
1251 check_edit(
1252 "frobnicate!",
1253 r#"
1254macro_rules frobnicate { () => () }
1255fn main() { frob<|>!(); }
1256"#,
1257 r#"
1258macro_rules frobnicate { () => () }
1259fn main() { frobnicate!(); }
1260"#,
1261 );
1262 }
1263
1264 #[test]
1265 fn active_param_score() {
1266 mark::check!(active_param_type_match);
1267 check_scores(
1268 r#"
1269struct S { foo: i64, bar: u32, baz: u32 }
1270fn test(bar: u32) { }
1271fn foo(s: S) { test(s.<|>) }
1272"#,
1273 expect![[r#"
1274 fd bar [type+name]
1275 fd baz [type]
1276 fd foo []
1277 "#]],
1278 );
1279 }
1280
1281 #[test]
1282 fn record_field_scores() {
1283 mark::check!(record_field_type_match);
1284 check_scores(
1285 r#"
1286struct A { foo: i64, bar: u32, baz: u32 }
1287struct B { x: (), y: f32, bar: u32 }
1288fn foo(a: A) { B { bar: a.<|> }; }
1289"#,
1290 expect![[r#"
1291 fd bar [type+name]
1292 fd baz [type]
1293 fd foo []
1294 "#]],
1295 )
1296 }
1297
1298 #[test]
1299 fn record_field_and_call_scores() {
1300 check_scores(
1301 r#"
1302struct A { foo: i64, bar: u32, baz: u32 }
1303struct B { x: (), y: f32, bar: u32 }
1304fn f(foo: i64) { }
1305fn foo(a: A) { B { bar: f(a.<|>) }; }
1306"#,
1307 expect![[r#"
1308 fd foo [type+name]
1309 fd bar []
1310 fd baz []
1311 "#]],
1312 );
1313 check_scores(
1314 r#"
1315struct A { foo: i64, bar: u32, baz: u32 }
1316struct B { x: (), y: f32, bar: u32 }
1317fn f(foo: i64) { }
1318fn foo(a: A) { f(B { bar: a.<|> }); }
1319"#,
1320 expect![[r#"
1321 fd bar [type+name]
1322 fd baz [type]
1323 fd foo []
1324 "#]],
1325 );
1326 }
1327
1328 #[test]
1329 fn prioritize_exact_ref_match() {
1330 check_scores(
1331 r#"
1332struct WorldSnapshot { _f: () };
1333fn go(world: &WorldSnapshot) { go(w<|>) }
1334"#,
1335 expect![[r#"
1336 bn world [type+name]
1337 st WorldSnapshot []
1338 fn go(…) []
1339 "#]],
1340 );
1341 }
1342
1343 #[test]
1344 fn too_many_arguments() {
1345 check_scores(
1346 r#"
1347struct Foo;
1348fn f(foo: &Foo) { f(foo, w<|>) }
1349"#,
1350 expect![[r#"
1351 st Foo []
1352 fn f(…) []
1353 bn foo []
1354 "#]],
1355 );
1356 }
1357
1358 #[test]
1359 fn guesses_macro_braces() {
1360 check_edit(
1361 "vec!",
1362 r#"
1363/// Creates a [`Vec`] containing the arguments.
1364///
1365/// ```
1366/// let v = vec![1, 2, 3];
1367/// assert_eq!(v[0], 1);
1368/// assert_eq!(v[1], 2);
1369/// assert_eq!(v[2], 3);
1370/// ```
1371macro_rules! vec { () => {} }
1372
1373fn fn main() { v<|> }
1374"#,
1375 r#"
1376/// Creates a [`Vec`] containing the arguments.
1377///
1378/// ```
1379/// let v = vec![1, 2, 3];
1380/// assert_eq!(v[0], 1);
1381/// assert_eq!(v[1], 2);
1382/// assert_eq!(v[2], 3);
1383/// ```
1384macro_rules! vec { () => {} }
1385
1386fn fn main() { vec![$0] }
1387"#,
1388 );
1389
1390 check_edit(
1391 "foo!",
1392 r#"
1393/// Foo
1394///
1395/// Don't call `fooo!()` `fooo!()`, or `_foo![]` `_foo![]`,
1396/// call as `let _=foo! { hello world };`
1397macro_rules! foo { () => {} }
1398fn main() { <|> }
1399"#,
1400 r#"
1401/// Foo
1402///
1403/// Don't call `fooo!()` `fooo!()`, or `_foo![]` `_foo![]`,
1404/// call as `let _=foo! { hello world };`
1405macro_rules! foo { () => {} }
1406fn main() { foo! {$0} }
1407"#,
1408 )
1409 }
1410}
diff --git a/crates/completion/src/test_utils.rs b/crates/completion/src/test_utils.rs
new file mode 100644
index 000000000..f2cf2561f
--- /dev/null
+++ b/crates/completion/src/test_utils.rs
@@ -0,0 +1,130 @@
1//! Runs completion for testing purposes.
2
3use base_db::{fixture::ChangeFixture, FileLoader, FilePosition};
4use hir::Semantics;
5use ide_db::RootDatabase;
6use itertools::Itertools;
7use stdx::{format_to, trim_indent};
8use syntax::{AstNode, NodeOrToken, SyntaxElement};
9use test_utils::{assert_eq_text, RangeOrOffset};
10
11use crate::{completion_item::CompletionKind, CompletionConfig, CompletionItem};
12
13/// Creates analysis from a multi-file fixture, returns positions marked with <|>.
14pub(crate) fn position(ra_fixture: &str) -> (RootDatabase, FilePosition) {
15 let change_fixture = ChangeFixture::parse(ra_fixture);
16 let mut database = RootDatabase::default();
17 database.apply_change(change_fixture.change);
18 let (file_id, range_or_offset) = change_fixture.file_position.expect("expected a marker (<|>)");
19 let offset = match range_or_offset {
20 RangeOrOffset::Range(_) => panic!(),
21 RangeOrOffset::Offset(it) => it,
22 };
23 (database, FilePosition { file_id, offset })
24}
25
26pub(crate) fn do_completion(code: &str, kind: CompletionKind) -> Vec<CompletionItem> {
27 do_completion_with_config(CompletionConfig::default(), code, kind)
28}
29
30pub(crate) fn do_completion_with_config(
31 config: CompletionConfig,
32 code: &str,
33 kind: CompletionKind,
34) -> Vec<CompletionItem> {
35 let mut kind_completions: Vec<CompletionItem> = get_all_completion_items(config, code)
36 .into_iter()
37 .filter(|c| c.completion_kind == kind)
38 .collect();
39 kind_completions.sort_by(|l, r| l.label().cmp(r.label()));
40 kind_completions
41}
42
43pub(crate) fn completion_list(code: &str, kind: CompletionKind) -> String {
44 completion_list_with_config(CompletionConfig::default(), code, kind)
45}
46
47pub(crate) fn completion_list_with_config(
48 config: CompletionConfig,
49 code: &str,
50 kind: CompletionKind,
51) -> String {
52 let mut kind_completions: Vec<CompletionItem> = get_all_completion_items(config, code)
53 .into_iter()
54 .filter(|c| c.completion_kind == kind)
55 .collect();
56 kind_completions.sort_by_key(|c| c.label().to_owned());
57 let label_width = kind_completions
58 .iter()
59 .map(|it| monospace_width(it.label()))
60 .max()
61 .unwrap_or_default()
62 .min(16);
63 kind_completions
64 .into_iter()
65 .map(|it| {
66 let tag = it.kind().unwrap().tag();
67 let var_name = format!("{} {}", tag, it.label());
68 let mut buf = var_name;
69 if let Some(detail) = it.detail() {
70 let width = label_width.saturating_sub(monospace_width(it.label()));
71 format_to!(buf, "{:width$} {}", "", detail, width = width);
72 }
73 format_to!(buf, "\n");
74 buf
75 })
76 .collect()
77}
78
79fn monospace_width(s: &str) -> usize {
80 s.chars().count()
81}
82
83pub(crate) fn check_edit(what: &str, ra_fixture_before: &str, ra_fixture_after: &str) {
84 check_edit_with_config(CompletionConfig::default(), what, ra_fixture_before, ra_fixture_after)
85}
86
87pub(crate) fn check_edit_with_config(
88 config: CompletionConfig,
89 what: &str,
90 ra_fixture_before: &str,
91 ra_fixture_after: &str,
92) {
93 let ra_fixture_after = trim_indent(ra_fixture_after);
94 let (db, position) = position(ra_fixture_before);
95 let completions: Vec<CompletionItem> =
96 crate::completions(&db, &config, position).unwrap().into();
97 let (completion,) = completions
98 .iter()
99 .filter(|it| it.lookup() == what)
100 .collect_tuple()
101 .unwrap_or_else(|| panic!("can't find {:?} completion in {:#?}", what, completions));
102 let mut actual = db.file_text(position.file_id).to_string();
103 completion.text_edit().apply(&mut actual);
104 assert_eq_text!(&ra_fixture_after, &actual)
105}
106
107pub(crate) fn check_pattern_is_applicable(code: &str, check: fn(SyntaxElement) -> bool) {
108 let (db, pos) = position(code);
109
110 let sema = Semantics::new(&db);
111 let original_file = sema.parse(pos.file_id);
112 let token = original_file.syntax().token_at_offset(pos.offset).left_biased().unwrap();
113 assert!(check(NodeOrToken::Token(token)));
114}
115
116pub(crate) fn check_pattern_is_not_applicable(code: &str, check: fn(SyntaxElement) -> bool) {
117 let (db, pos) = position(code);
118 let sema = Semantics::new(&db);
119 let original_file = sema.parse(pos.file_id);
120 let token = original_file.syntax().token_at_offset(pos.offset).left_biased().unwrap();
121 assert!(!check(NodeOrToken::Token(token)));
122}
123
124pub(crate) fn get_all_completion_items(
125 config: CompletionConfig,
126 code: &str,
127) -> Vec<CompletionItem> {
128 let (db, position) = position(code);
129 crate::completions(&db, &config, position).unwrap().into()
130}
generated by cgit v1.2.3 (git 2.25.1) at 2024-09-13 10:12:59 +0100