From 5bf5b127070b510dee82770b921aa39137c1d889 Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Fri, 1 Jan 2021 15:35:12 +0100 Subject: [PATCH 1/9] Add suggestion in case a "ignore" doc block has invalid rust code inside --- src/librustdoc/html/markdown.rs | 11 ++++++++--- src/librustdoc/passes/check_code_block_syntax.rs | 15 ++++++++++++--- 2 files changed, 20 insertions(+), 6 deletions(-) diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs index 6261e843d239d..f1d00b81eed1c 100644 --- a/src/librustdoc/html/markdown.rs +++ b/src/librustdoc/html/markdown.rs @@ -1213,6 +1213,7 @@ crate struct RustCodeBlock { crate code: Range, crate is_fenced: bool, crate syntax: Option, + crate is_ignore: bool, } /// Returns a range of bytes for each code block in the markdown that is tagged as `rust` or @@ -1228,7 +1229,7 @@ crate fn rust_code_blocks(md: &str, extra_info: &ExtraInfo<'_, '_>) -> Vec { let syntax = syntax.as_ref(); let lang_string = if syntax.is_empty() { @@ -1249,6 +1250,7 @@ crate fn rust_code_blocks(md: &str, extra_info: &ExtraInfo<'_, '_>) -> Vec) -> Vec) -> Vec { // The ending of the offset goes too far sometime so we reduce it by one in @@ -1278,9 +1281,10 @@ crate fn rust_code_blocks(md: &str, extra_info: &ExtraInfo<'_, '_>) -> Vec) -> Vec SyntaxChecker<'a, 'tcx> { let mut diag = if let Some(sp) = super::source_span_for_markdown_range(self.cx, &dox, &code_block.range, &item.attrs) { - let warning_message = if buffer.has_errors { - "could not parse code block as Rust code" + let (warning_message, suggest_using_text) = if buffer.has_errors { + ("could not parse code block as Rust code", true) } else { - "Rust code block is empty" + ("Rust code block is empty", false) }; let mut diag = self.cx.sess().struct_span_warn(sp, warning_message); @@ -67,6 +67,15 @@ impl<'a, 'tcx> SyntaxChecker<'a, 'tcx> { String::from("```text"), Applicability::MachineApplicable, ); + } else if suggest_using_text && code_block.is_ignore { + let sp = sp.from_inner(InnerSpan::new(0, 3)); + diag.span_suggestion( + sp, + "`ignore` code blocks require valid Rust code for syntax highlighting. \ + Mark blocks that do not contain Rust code as text", + String::from("```text,"), + Applicability::MachineApplicable, + ); } diag From c3ae82690150a9edc09ceef6319eabedfebf3931 Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Fri, 1 Jan 2021 16:05:36 +0100 Subject: [PATCH 2/9] Add test for suggestion in case a "ignore" doc block has invalid rust code inside --- src/test/rustdoc-ui/ignore-block-help.rs | 7 +++++++ src/test/rustdoc-ui/ignore-block-help.stderr | 17 +++++++++++++++++ 2 files changed, 24 insertions(+) create mode 100644 src/test/rustdoc-ui/ignore-block-help.rs create mode 100644 src/test/rustdoc-ui/ignore-block-help.stderr diff --git a/src/test/rustdoc-ui/ignore-block-help.rs b/src/test/rustdoc-ui/ignore-block-help.rs new file mode 100644 index 0000000000000..c22dddd11dffa --- /dev/null +++ b/src/test/rustdoc-ui/ignore-block-help.rs @@ -0,0 +1,7 @@ +// check-pass + +/// ```ignore (to-prevent-tidy-error) +/// let heart = '❤️'; +/// ``` +//~^^^ WARN +pub struct X; diff --git a/src/test/rustdoc-ui/ignore-block-help.stderr b/src/test/rustdoc-ui/ignore-block-help.stderr new file mode 100644 index 0000000000000..d45cd92d2d106 --- /dev/null +++ b/src/test/rustdoc-ui/ignore-block-help.stderr @@ -0,0 +1,17 @@ +warning: could not parse code block as Rust code + --> $DIR/ignore-block-help.rs:3:5 + | +LL | /// ```ignore (to-prevent-tidy-error) + | _____^ +LL | | /// let heart = '❤️'; +LL | | /// ``` + | |_______^ + | + = note: error from rustc: character literal may only contain one codepoint +help: `ignore` code blocks require valid Rust code for syntax highlighting. Mark blocks that do not contain Rust code as text + | +LL | /// ```text,ignore (to-prevent-tidy-error) + | ^^^^^^^^ + +warning: 1 warning emitted + From 6cf47ff4f0ed0395343c97dddbd278281189f446 Mon Sep 17 00:00:00 2001 From: Bastian Kauschke Date: Fri, 1 Jan 2021 19:37:58 +0100 Subject: [PATCH 3/9] remove incomplete features from std --- library/alloc/src/lib.rs | 3 +-- library/core/src/lib.rs | 3 +-- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs index e6db66ac57155..cfad111aa546f 100644 --- a/library/alloc/src/lib.rs +++ b/library/alloc/src/lib.rs @@ -70,7 +70,6 @@ #![warn(missing_docs)] #![warn(missing_debug_implementations)] #![allow(explicit_outlives_requirements)] -#![allow(incomplete_features)] #![deny(unsafe_op_in_unsafe_fn)] #![feature(rustc_allow_const_fn_unstable)] #![cfg_attr(not(test), feature(generator_trait))] @@ -90,7 +89,6 @@ #![feature(coerce_unsized)] #![feature(const_btree_new)] #![feature(const_fn)] -#![feature(const_generics)] #![feature(const_in_array_repeat_expressions)] #![feature(cow_is_borrowed)] #![feature(const_cow_is_borrowed)] @@ -120,6 +118,7 @@ #![feature(raw_ref_op)] #![feature(rustc_attrs)] #![feature(receiver_trait)] +#![cfg_attr(bootstrap, feature(min_const_generics))] #![feature(min_specialization)] #![feature(slice_ptr_get)] #![feature(slice_ptr_len)] diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs index 099b98b824d82..df8d9ff371fe4 100644 --- a/library/core/src/lib.rs +++ b/library/core/src/lib.rs @@ -62,7 +62,6 @@ #![warn(missing_docs)] #![warn(missing_debug_implementations)] #![allow(explicit_outlives_requirements)] -#![allow(incomplete_features)] #![feature(rustc_allow_const_fn_unstable)] #![feature(allow_internal_unstable)] #![feature(arbitrary_self_types)] @@ -89,7 +88,6 @@ #![feature(const_impl_trait)] #![feature(const_fn_floating_point_arithmetic)] #![feature(const_fn_fn_ptr_basics)] -#![feature(const_generics)] #![feature(const_option)] #![feature(const_precise_live_drops)] #![feature(const_ptr_offset)] @@ -131,6 +129,7 @@ #![feature(repr_simd, platform_intrinsics)] #![feature(rustc_attrs)] #![feature(simd_ffi)] +#![cfg_attr(bootstrap, feature(min_const_generics))] #![feature(min_specialization)] #![feature(staged_api)] #![feature(std_internals)] From 8a90626a4608907a7be01dd0c9f9d7cfeb63e2f9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= Date: Sat, 2 Jan 2021 20:09:17 +0100 Subject: [PATCH 4/9] reduce borrowing and (de)referencing around match patterns (clippy::match_ref_pats) --- compiler/rustc_ast/src/ast.rs | 6 +++--- .../rustc_ast_passes/src/ast_validation.rs | 6 +++--- .../rustc_builtin_macros/src/deriving/hash.rs | 10 +++++----- compiler/rustc_hir/src/hir.rs | 12 +++++------ compiler/rustc_hir/src/intravisit.rs | 8 ++++---- compiler/rustc_hir_pretty/src/lib.rs | 20 +++++++++---------- .../rustc_incremental/src/assert_dep_graph.rs | 6 +++--- .../src/infer/error_reporting/mod.rs | 2 +- compiler/rustc_lint/src/builtin.rs | 4 ++-- compiler/rustc_lint/src/nonstandard_style.rs | 2 +- compiler/rustc_lint/src/unused.rs | 8 ++++---- compiler/rustc_metadata/src/native_libs.rs | 8 ++++---- compiler/rustc_middle/src/ty/diagnostics.rs | 4 ++-- .../borrow_check/diagnostics/move_errors.rs | 2 +- .../src/borrow_check/type_check/mod.rs | 4 ++-- compiler/rustc_passes/src/naked_functions.rs | 2 +- .../rustc_save_analysis/src/dump_visitor.rs | 6 +++--- .../src/traits/auto_trait.rs | 10 +++++----- .../src/traits/error_reporting/mod.rs | 2 +- .../src/traits/select/mod.rs | 10 +++++----- compiler/rustc_typeck/src/astconv/mod.rs | 2 +- compiler/rustc_typeck/src/check/callee.rs | 6 +++--- compiler/rustc_typeck/src/check/coercion.rs | 12 +++++------ compiler/rustc_typeck/src/check/expr.rs | 6 +++--- .../rustc_typeck/src/check/method/suggest.rs | 2 +- compiler/rustc_typeck/src/collect.rs | 12 +++++------ src/librustdoc/clean/auto_trait.rs | 4 ++-- src/librustdoc/clean/utils.rs | 4 ++-- 28 files changed, 89 insertions(+), 91 deletions(-) diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs index 8167bde0322f2..6c70b3e5596aa 100644 --- a/compiler/rustc_ast/src/ast.rs +++ b/compiler/rustc_ast/src/ast.rs @@ -433,9 +433,9 @@ pub enum WherePredicate { impl WherePredicate { pub fn span(&self) -> Span { match self { - &WherePredicate::BoundPredicate(ref p) => p.span, - &WherePredicate::RegionPredicate(ref p) => p.span, - &WherePredicate::EqPredicate(ref p) => p.span, + WherePredicate::BoundPredicate(p) => p.span, + WherePredicate::RegionPredicate(p) => p.span, + WherePredicate::EqPredicate(p) => p.span, } } } diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs index e172f9d71ffbc..b6f980f9177f8 100644 --- a/compiler/rustc_ast_passes/src/ast_validation.rs +++ b/compiler/rustc_ast_passes/src/ast_validation.rs @@ -1212,11 +1212,11 @@ impl<'a> Visitor<'a> for AstValidator<'a> { } fn visit_pat(&mut self, pat: &'a Pat) { - match pat.kind { - PatKind::Lit(ref expr) => { + match &pat.kind { + PatKind::Lit(expr) => { self.check_expr_within_pat(expr, false); } - PatKind::Range(ref start, ref end, _) => { + PatKind::Range(start, end, _) => { if let Some(expr) = start { self.check_expr_within_pat(expr, true); } diff --git a/compiler/rustc_builtin_macros/src/deriving/hash.rs b/compiler/rustc_builtin_macros/src/deriving/hash.rs index 868f863b99021..7114b98768091 100644 --- a/compiler/rustc_builtin_macros/src/deriving/hash.rs +++ b/compiler/rustc_builtin_macros/src/deriving/hash.rs @@ -48,8 +48,8 @@ pub fn expand_deriving_hash( } fn hash_substructure(cx: &mut ExtCtxt<'_>, trait_span: Span, substr: &Substructure<'_>) -> P { - let state_expr = match &substr.nonself_args { - &[o_f] => o_f, + let state_expr = match substr.nonself_args { + [o_f] => o_f, _ => cx.span_bug(trait_span, "incorrect number of arguments in `derive(Hash)`"), }; let call_hash = |span, thing_expr| { @@ -64,9 +64,9 @@ fn hash_substructure(cx: &mut ExtCtxt<'_>, trait_span: Span, substr: &Substructu }; let mut stmts = Vec::new(); - let fields = match *substr.fields { - Struct(_, ref fs) | EnumMatching(_, 1, .., ref fs) => fs, - EnumMatching(.., ref fs) => { + let fields = match substr.fields { + Struct(_, fs) | EnumMatching(_, 1, .., fs) => fs, + EnumMatching(.., fs) => { let variant_value = deriving::call_intrinsic( cx, trait_span, diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs index ebeb1bae2a314..ead39d702635a 100644 --- a/compiler/rustc_hir/src/hir.rs +++ b/compiler/rustc_hir/src/hir.rs @@ -378,9 +378,9 @@ impl GenericBound<'_> { pub fn span(&self) -> Span { match self { - &GenericBound::Trait(ref t, ..) => t.span, - &GenericBound::LangItemTrait(_, span, ..) => span, - &GenericBound::Outlives(ref l) => l.span, + GenericBound::Trait(t, ..) => t.span, + GenericBound::LangItemTrait(_, span, ..) => *span, + GenericBound::Outlives(l) => l.span, } } } @@ -538,9 +538,9 @@ pub enum WherePredicate<'hir> { impl WherePredicate<'_> { pub fn span(&self) -> Span { match self { - &WherePredicate::BoundPredicate(ref p) => p.span, - &WherePredicate::RegionPredicate(ref p) => p.span, - &WherePredicate::EqPredicate(ref p) => p.span, + WherePredicate::BoundPredicate(p) => p.span, + WherePredicate::RegionPredicate(p) => p.span, + WherePredicate::EqPredicate(p) => p.span, } } } diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs index 87a2434152fcf..b0e82214cf95f 100644 --- a/compiler/rustc_hir/src/intravisit.rs +++ b/compiler/rustc_hir/src/intravisit.rs @@ -896,8 +896,8 @@ pub fn walk_where_predicate<'v, V: Visitor<'v>>( visitor: &mut V, predicate: &'v WherePredicate<'v>, ) { - match predicate { - &WherePredicate::BoundPredicate(WhereBoundPredicate { + match *predicate { + WherePredicate::BoundPredicate(WhereBoundPredicate { ref bounded_ty, bounds, bound_generic_params, @@ -907,11 +907,11 @@ pub fn walk_where_predicate<'v, V: Visitor<'v>>( walk_list!(visitor, visit_param_bound, bounds); walk_list!(visitor, visit_generic_param, bound_generic_params); } - &WherePredicate::RegionPredicate(WhereRegionPredicate { ref lifetime, bounds, .. }) => { + WherePredicate::RegionPredicate(WhereRegionPredicate { ref lifetime, bounds, .. }) => { visitor.visit_lifetime(lifetime); walk_list!(visitor, visit_param_bound, bounds); } - &WherePredicate::EqPredicate(WhereEqPredicate { + WherePredicate::EqPredicate(WhereEqPredicate { hir_id, ref lhs_ty, ref rhs_ty, .. }) => { visitor.visit_id(hir_id); diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs index eb6c65fcd8c81..ddd3827c81df6 100644 --- a/compiler/rustc_hir_pretty/src/lib.rs +++ b/compiler/rustc_hir_pretty/src/lib.rs @@ -2233,19 +2233,19 @@ impl<'a> State<'a> { } match predicate { - &hir::WherePredicate::BoundPredicate(hir::WhereBoundPredicate { - ref bound_generic_params, - ref bounded_ty, + hir::WherePredicate::BoundPredicate(hir::WhereBoundPredicate { + bound_generic_params, + bounded_ty, bounds, .. }) => { self.print_formal_generic_params(bound_generic_params); self.print_type(&bounded_ty); - self.print_bounds(":", bounds); + self.print_bounds(":", *bounds); } - &hir::WherePredicate::RegionPredicate(hir::WhereRegionPredicate { - ref lifetime, - ref bounds, + hir::WherePredicate::RegionPredicate(hir::WhereRegionPredicate { + lifetime, + bounds, .. }) => { self.print_lifetime(lifetime); @@ -2264,10 +2264,8 @@ impl<'a> State<'a> { } } } - &hir::WherePredicate::EqPredicate(hir::WhereEqPredicate { - ref lhs_ty, - ref rhs_ty, - .. + hir::WherePredicate::EqPredicate(hir::WhereEqPredicate { + lhs_ty, rhs_ty, .. }) => { self.print_type(lhs_ty); self.s.space(); diff --git a/compiler/rustc_incremental/src/assert_dep_graph.rs b/compiler/rustc_incremental/src/assert_dep_graph.rs index 9b4388c911f1b..f39a92b9a32ba 100644 --- a/compiler/rustc_incremental/src/assert_dep_graph.rs +++ b/compiler/rustc_incremental/src/assert_dep_graph.rs @@ -310,13 +310,13 @@ fn filter_nodes<'q>( sources: &Option>, targets: &Option>, ) -> FxHashSet<&'q DepNode> { - if let &Some(ref sources) = sources { - if let &Some(ref targets) = targets { + if let Some(sources) = sources { + if let Some(targets) = targets { walk_between(query, sources, targets) } else { walk_nodes(query, sources, OUTGOING) } - } else if let &Some(ref targets) = targets { + } else if let Some(targets) = targets { walk_nodes(query, targets, INCOMING) } else { query.nodes().into_iter().collect() diff --git a/compiler/rustc_infer/src/infer/error_reporting/mod.rs b/compiler/rustc_infer/src/infer/error_reporting/mod.rs index 14a56119f21e3..d1d6cb43fc74c 100644 --- a/compiler/rustc_infer/src/infer/error_reporting/mod.rs +++ b/compiler/rustc_infer/src/infer/error_reporting/mod.rs @@ -915,7 +915,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { self.highlight_outer(&mut t1_out, &mut t2_out, path, sub, i, &other_ty); return Some(()); } - if let &ty::Adt(def, _) = ta.kind() { + if let ty::Adt(def, _) = ta.kind() { let path_ = self.tcx.def_path_str(def.did); if path_ == other_path { self.highlight_outer(&mut t1_out, &mut t2_out, path, sub, i, &other_ty); diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs index a8371274f61f8..374bd6d0d791f 100644 --- a/compiler/rustc_lint/src/builtin.rs +++ b/compiler/rustc_lint/src/builtin.rs @@ -938,8 +938,8 @@ impl EarlyLintPass for DeprecatedAttr { if attr.ident().map(|ident| ident.name) == Some(n) { if let &AttributeGate::Gated( Stability::Deprecated(link, suggestion), - ref name, - ref reason, + name, + reason, _, ) = g { diff --git a/compiler/rustc_lint/src/nonstandard_style.rs b/compiler/rustc_lint/src/nonstandard_style.rs index 6d61b86f32ef9..e9a507874af2e 100644 --- a/compiler/rustc_lint/src/nonstandard_style.rs +++ b/compiler/rustc_lint/src/nonstandard_style.rs @@ -397,7 +397,7 @@ impl<'tcx> LateLintPass<'tcx> for NonSnakeCase { } fn check_pat(&mut self, cx: &LateContext<'_>, p: &hir::Pat<'_>) { - if let &PatKind::Binding(_, hid, ident, _) = &p.kind { + if let PatKind::Binding(_, hid, ident, _) = p.kind { if let hir::Node::Pat(parent_pat) = cx.tcx.hir().get(cx.tcx.hir().get_parent_node(hid)) { if let PatKind::Struct(_, field_pats, _) = &parent_pat.kind { diff --git a/compiler/rustc_lint/src/unused.rs b/compiler/rustc_lint/src/unused.rs index 5e1f94c071c65..35915dc7a9753 100644 --- a/compiler/rustc_lint/src/unused.rs +++ b/compiler/rustc_lint/src/unused.rs @@ -862,11 +862,11 @@ impl EarlyLintPass for UnusedParens { } fn check_ty(&mut self, cx: &EarlyContext<'_>, ty: &ast::Ty) { - if let &ast::TyKind::Paren(ref r) = &ty.kind { + if let ast::TyKind::Paren(r) = &ty.kind { match &r.kind { - &ast::TyKind::TraitObject(..) => {} - &ast::TyKind::ImplTrait(_, ref bounds) if bounds.len() > 1 => {} - &ast::TyKind::Array(_, ref len) => { + ast::TyKind::TraitObject(..) => {} + ast::TyKind::ImplTrait(_, bounds) if bounds.len() > 1 => {} + ast::TyKind::Array(_, len) => { self.check_unused_delims_expr( cx, &len.value, diff --git a/compiler/rustc_metadata/src/native_libs.rs b/compiler/rustc_metadata/src/native_libs.rs index 744fdc83a91ec..5b33678b25ae2 100644 --- a/compiler/rustc_metadata/src/native_libs.rs +++ b/compiler/rustc_metadata/src/native_libs.rs @@ -192,13 +192,13 @@ impl Collector<'tcx> { fn process_command_line(&mut self) { // First, check for errors let mut renames = FxHashSet::default(); - for &(ref name, ref new_name, _) in &self.tcx.sess.opts.libs { - if let &Some(ref new_name) = new_name { + for (name, new_name, _) in &self.tcx.sess.opts.libs { + if let Some(ref new_name) = new_name { let any_duplicate = self .libs .iter() .filter_map(|lib| lib.name.as_ref()) - .any(|n| n.as_str() == *name); + .any(|n| &n.as_str() == name); if new_name.is_empty() { self.tcx.sess.err(&format!( "an empty renaming target was specified for library `{}`", @@ -240,7 +240,7 @@ impl Collector<'tcx> { if kind != NativeLibKind::Unspecified { lib.kind = kind; } - if let &Some(ref new_name) = new_name { + if let Some(new_name) = new_name { lib.name = Some(Symbol::intern(new_name)); } return true; diff --git a/compiler/rustc_middle/src/ty/diagnostics.rs b/compiler/rustc_middle/src/ty/diagnostics.rs index 65703d04c7040..3adcdbe591fc3 100644 --- a/compiler/rustc_middle/src/ty/diagnostics.rs +++ b/compiler/rustc_middle/src/ty/diagnostics.rs @@ -245,8 +245,8 @@ pub fn suggest_constraining_type_param( } } - match ¶m_spans[..] { - &[¶m_span] => suggest_restrict(param_span.shrink_to_hi()), + match param_spans[..] { + [¶m_span] => suggest_restrict(param_span.shrink_to_hi()), _ => { err.span_suggestion_verbose( generics.where_clause.tail_span_for_suggestion(), diff --git a/compiler/rustc_mir/src/borrow_check/diagnostics/move_errors.rs b/compiler/rustc_mir/src/borrow_check/diagnostics/move_errors.rs index b1cebbd1f381b..350e0d045fa35 100644 --- a/compiler/rustc_mir/src/borrow_check/diagnostics/move_errors.rs +++ b/compiler/rustc_mir/src/borrow_check/diagnostics/move_errors.rs @@ -302,7 +302,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> { .find_map(|p| self.is_upvar_field_projection(p)); let deref_base = match deref_target_place.projection.as_ref() { - &[ref proj_base @ .., ProjectionElem::Deref] => { + [proj_base @ .., ProjectionElem::Deref] => { PlaceRef { local: deref_target_place.local, projection: &proj_base } } _ => bug!("deref_target_place is not a deref projection"), diff --git a/compiler/rustc_mir/src/borrow_check/type_check/mod.rs b/compiler/rustc_mir/src/borrow_check/type_check/mod.rs index 42cd050abc5dd..5aad7523c8903 100644 --- a/compiler/rustc_mir/src/borrow_check/type_check/mod.rs +++ b/compiler/rustc_mir/src/borrow_check/type_check/mod.rs @@ -1855,8 +1855,8 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> { self.assert_iscleanup(body, block_data, unwind, true); } } - TerminatorKind::InlineAsm { ref destination, .. } => { - if let &Some(target) = destination { + TerminatorKind::InlineAsm { destination, .. } => { + if let Some(target) = destination { self.assert_iscleanup(body, block_data, target, is_cleanup); } } diff --git a/compiler/rustc_passes/src/naked_functions.rs b/compiler/rustc_passes/src/naked_functions.rs index 5b50ef8627b25..788f1df328cc4 100644 --- a/compiler/rustc_passes/src/naked_functions.rs +++ b/compiler/rustc_passes/src/naked_functions.rs @@ -149,7 +149,7 @@ impl<'tcx> Visitor<'tcx> for CheckParameters<'tcx> { fn check_asm<'tcx>(tcx: TyCtxt<'tcx>, hir_id: HirId, body: &'tcx hir::Body<'tcx>, fn_span: Span) { let mut this = CheckInlineAssembly { tcx, items: Vec::new() }; this.visit_body(body); - if let &[(ItemKind::Asm, _)] = &this.items[..] { + if let [(ItemKind::Asm, _)] = this.items[..] { // Ok. } else { tcx.struct_span_lint_hir(UNSUPPORTED_NAKED_FUNCTIONS, hir_id, fn_span, |lint| { diff --git a/compiler/rustc_save_analysis/src/dump_visitor.rs b/compiler/rustc_save_analysis/src/dump_visitor.rs index 987badcedde4c..617a28ed51938 100644 --- a/compiler/rustc_save_analysis/src/dump_visitor.rs +++ b/compiler/rustc_save_analysis/src/dump_visitor.rs @@ -582,7 +582,7 @@ impl<'tcx> DumpVisitor<'tcx> { } ref v => { let mut value = format!("{}::{}", enum_data.name, name); - if let &hir::VariantData::Tuple(ref fields, _) = v { + if let hir::VariantData::Tuple(fields, _) = v { value.push('('); value.push_str( &fields @@ -653,7 +653,7 @@ impl<'tcx> DumpVisitor<'tcx> { let map = &self.tcx.hir(); self.nest_typeck_results(map.local_def_id(item.hir_id), |v| { v.visit_ty(&typ); - if let &Some(ref trait_ref) = trait_ref { + if let Some(trait_ref) = trait_ref { v.process_path(trait_ref.hir_ref_id, &hir::QPath::Resolved(None, &trait_ref.path)); } v.process_generic_params(generics, "", item.hir_id); @@ -1082,7 +1082,7 @@ impl<'tcx> DumpVisitor<'tcx> { ); } - if let &Some(ref default_ty) = default_ty { + if let Some(default_ty) = default_ty { self.visit_ty(default_ty) } } diff --git a/compiler/rustc_trait_selection/src/traits/auto_trait.rs b/compiler/rustc_trait_selection/src/traits/auto_trait.rs index fc6a9a7f20972..d677103df1f58 100644 --- a/compiler/rustc_trait_selection/src/traits/auto_trait.rs +++ b/compiler/rustc_trait_selection/src/traits/auto_trait.rs @@ -305,8 +305,8 @@ impl AutoTraitFinder<'tcx> { infcx.resolve_vars_if_possible(Obligation::new(dummy_cause.clone(), new_env, pred)); let result = select.select(&obligation); - match &result { - &Ok(Some(ref impl_source)) => { + match result { + Ok(Some(ref impl_source)) => { // If we see an explicit negative impl (e.g., `impl !Send for MyStruct`), // we immediately bail out, since it's impossible for us to continue. @@ -339,8 +339,8 @@ impl AutoTraitFinder<'tcx> { return None; } } - &Ok(None) => {} - &Err(SelectionError::Unimplemented) => { + Ok(None) => {} + Err(SelectionError::Unimplemented) => { if self.is_param_no_infer(pred.skip_binder().trait_ref.substs) { already_visited.remove(&pred); self.add_user_pred( @@ -863,7 +863,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for RegionReplacer<'a, 'tcx> { fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> { (match r { - &ty::ReVar(vid) => self.vid_to_region.get(&vid).cloned(), + ty::ReVar(vid) => self.vid_to_region.get(vid).cloned(), _ => None, }) .unwrap_or_else(|| r.super_fold_with(self)) diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs index 1d82e732907ba..a439bb892f8e7 100644 --- a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs +++ b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs @@ -1368,7 +1368,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> { code: &ObligationCauseCode<'tcx>, ) -> Option<(String, Option)> { match code { - &ObligationCauseCode::BuiltinDerivedObligation(ref data) => { + ObligationCauseCode::BuiltinDerivedObligation(data) => { let parent_trait_ref = self.resolve_vars_if_possible(data.parent_trait_ref); match self.get_parent_trait_ref(&data.parent_code) { Some(t) => Some(t), diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs index a8f81445b0397..8ca540fc8933c 100644 --- a/compiler/rustc_trait_selection/src/traits/select/mod.rs +++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs @@ -69,16 +69,16 @@ impl IntercrateAmbiguityCause { pub fn intercrate_ambiguity_hint(&self) -> String { match self { - &IntercrateAmbiguityCause::DownstreamCrate { ref trait_desc, ref self_desc } => { - let self_desc = if let &Some(ref ty) = self_desc { + IntercrateAmbiguityCause::DownstreamCrate { trait_desc, self_desc } => { + let self_desc = if let Some(ty) = self_desc { format!(" for type `{}`", ty) } else { String::new() }; format!("downstream crates may implement trait `{}`{}", trait_desc, self_desc) } - &IntercrateAmbiguityCause::UpstreamCrateUpdate { ref trait_desc, ref self_desc } => { - let self_desc = if let &Some(ref ty) = self_desc { + IntercrateAmbiguityCause::UpstreamCrateUpdate { trait_desc, self_desc } => { + let self_desc = if let Some(ty) = self_desc { format!(" for type `{}`", ty) } else { String::new() @@ -89,7 +89,7 @@ impl IntercrateAmbiguityCause { trait_desc, self_desc ) } - &IntercrateAmbiguityCause::ReservationImpl { ref message } => message.clone(), + IntercrateAmbiguityCause::ReservationImpl { message } => message.clone(), } } } diff --git a/compiler/rustc_typeck/src/astconv/mod.rs b/compiler/rustc_typeck/src/astconv/mod.rs index 9a2210e4f0e80..878993d512cee 100644 --- a/compiler/rustc_typeck/src/astconv/mod.rs +++ b/compiler/rustc_typeck/src/astconv/mod.rs @@ -770,7 +770,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { // Try to find an unbound in bounds. let mut unbound = None; for ab in ast_bounds { - if let &hir::GenericBound::Trait(ref ptr, hir::TraitBoundModifier::Maybe) = ab { + if let hir::GenericBound::Trait(ptr, hir::TraitBoundModifier::Maybe) = ab { if unbound.is_none() { unbound = Some(&ptr.trait_ref); } else { diff --git a/compiler/rustc_typeck/src/check/callee.rs b/compiler/rustc_typeck/src/check/callee.rs index 22e287320d842..116b079e7425a 100644 --- a/compiler/rustc_typeck/src/check/callee.rs +++ b/compiler/rustc_typeck/src/check/callee.rs @@ -290,16 +290,16 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { ty::FnPtr(sig) => (sig, None), ref t => { let mut unit_variant = None; - if let &ty::Adt(adt_def, ..) = t { + if let ty::Adt(adt_def, ..) = t { if adt_def.is_enum() { - if let hir::ExprKind::Call(ref expr, _) = call_expr.kind { + if let hir::ExprKind::Call(expr, _) = call_expr.kind { unit_variant = self.tcx.sess.source_map().span_to_snippet(expr.span).ok(); } } } - if let hir::ExprKind::Call(ref callee, _) = call_expr.kind { + if let hir::ExprKind::Call(callee, _) = call_expr.kind { let mut err = type_error_struct!( self.tcx.sess, callee.span, diff --git a/compiler/rustc_typeck/src/check/coercion.rs b/compiler/rustc_typeck/src/check/coercion.rs index 0f5f0ab026087..67ec739d8614d 100644 --- a/compiler/rustc_typeck/src/check/coercion.rs +++ b/compiler/rustc_typeck/src/check/coercion.rs @@ -926,11 +926,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { false } }; - if is_capturing_closure(&prev_ty.kind()) || is_capturing_closure(&new_ty.kind()) { + if is_capturing_closure(prev_ty.kind()) || is_capturing_closure(new_ty.kind()) { (None, None) } else { - match (&prev_ty.kind(), &new_ty.kind()) { - (&ty::FnDef(..), &ty::FnDef(..)) => { + match (prev_ty.kind(), new_ty.kind()) { + (ty::FnDef(..), ty::FnDef(..)) => { // Don't reify if the function types have a LUB, i.e., they // are the same function and their parameters have a LUB. match self @@ -943,21 +943,21 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } } } - (&ty::Closure(_, substs), &ty::FnDef(..)) => { + (ty::Closure(_, substs), ty::FnDef(..)) => { let b_sig = new_ty.fn_sig(self.tcx); let a_sig = self .tcx .signature_unclosure(substs.as_closure().sig(), b_sig.unsafety()); (Some(a_sig), Some(b_sig)) } - (&ty::FnDef(..), &ty::Closure(_, substs)) => { + (ty::FnDef(..), ty::Closure(_, substs)) => { let a_sig = prev_ty.fn_sig(self.tcx); let b_sig = self .tcx .signature_unclosure(substs.as_closure().sig(), a_sig.unsafety()); (Some(a_sig), Some(b_sig)) } - (&ty::Closure(_, substs_a), &ty::Closure(_, substs_b)) => ( + (ty::Closure(_, substs_a), ty::Closure(_, substs_b)) => ( Some(self.tcx.signature_unclosure( substs_a.as_closure().sig(), hir::Unsafety::Normal, diff --git a/compiler/rustc_typeck/src/check/expr.rs b/compiler/rustc_typeck/src/check/expr.rs index e84d813ffbcc0..d76a80d5a3990 100644 --- a/compiler/rustc_typeck/src/check/expr.rs +++ b/compiler/rustc_typeck/src/check/expr.rs @@ -1125,7 +1125,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { fields, base_expr.is_none(), ); - if let &Some(ref base_expr) = base_expr { + if let Some(base_expr) = base_expr { // If check_expr_struct_fields hit an error, do not attempt to populate // the fields with the base_expr. This could cause us to hit errors later // when certain fields are assumed to exist that in fact do not. @@ -1182,8 +1182,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { // re-link the regions that EIfEO can erase. self.demand_eqtype(span, adt_ty_hint, adt_ty); - let (substs, adt_kind, kind_name) = match &adt_ty.kind() { - &ty::Adt(adt, substs) => (substs, adt.adt_kind(), adt.variant_descr()), + let (substs, adt_kind, kind_name) = match adt_ty.kind() { + ty::Adt(adt, substs) => (substs, adt.adt_kind(), adt.variant_descr()), _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields"), }; diff --git a/compiler/rustc_typeck/src/check/method/suggest.rs b/compiler/rustc_typeck/src/check/method/suggest.rs index 3bf41981ef6b0..5cfd78ebeacad 100644 --- a/compiler/rustc_typeck/src/check/method/suggest.rs +++ b/compiler/rustc_typeck/src/check/method/suggest.rs @@ -333,7 +333,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } ExprKind::Path(ref qpath) => { // local binding - if let &QPath::Resolved(_, ref path) = &qpath { + if let QPath::Resolved(_, path) = qpath { if let hir::def::Res::Local(hir_id) = path.res { let span = tcx.hir().span(hir_id); let snippet = tcx.sess.source_map().span_to_snippet(span); diff --git a/compiler/rustc_typeck/src/collect.rs b/compiler/rustc_typeck/src/collect.rs index 2ebb1a3be4e44..ae97fa3f7e423 100644 --- a/compiler/rustc_typeck/src/collect.rs +++ b/compiler/rustc_typeck/src/collect.rs @@ -1920,7 +1920,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericP let where_clause = &ast_generics.where_clause; for predicate in where_clause.predicates { match predicate { - &hir::WherePredicate::BoundPredicate(ref bound_pred) => { + hir::WherePredicate::BoundPredicate(bound_pred) => { let ty = icx.to_ty(&bound_pred.bounded_ty); // Keep the type around in a dummy predicate, in case of no bounds. @@ -1949,7 +1949,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericP for bound in bound_pred.bounds.iter() { match bound { - &hir::GenericBound::Trait(ref poly_trait_ref, modifier) => { + hir::GenericBound::Trait(poly_trait_ref, modifier) => { let constness = match modifier { hir::TraitBoundModifier::MaybeConst => hir::Constness::NotConst, hir::TraitBoundModifier::None => constness, @@ -1959,7 +1959,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericP let mut bounds = Bounds::default(); let _ = AstConv::instantiate_poly_trait_ref( &icx, - poly_trait_ref, + &poly_trait_ref, constness, ty, &mut bounds, @@ -1981,7 +1981,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericP predicates.extend(bounds.predicates(tcx, ty)); } - &hir::GenericBound::Outlives(ref lifetime) => { + hir::GenericBound::Outlives(lifetime) => { let region = AstConv::ast_region_to_region(&icx, lifetime, None); predicates.insert(( ty::Binder::bind(ty::PredicateAtom::TypeOutlives( @@ -1995,7 +1995,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericP } } - &hir::WherePredicate::RegionPredicate(ref region_pred) => { + hir::WherePredicate::RegionPredicate(region_pred) => { let r1 = AstConv::ast_region_to_region(&icx, ®ion_pred.lifetime, None); predicates.extend(region_pred.bounds.iter().map(|bound| { let (r2, span) = match bound { @@ -2011,7 +2011,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericP })) } - &hir::WherePredicate::EqPredicate(..) => { + hir::WherePredicate::EqPredicate(..) => { // FIXME(#20041) } } diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs index 8b63ddddc1fa1..3b13cb9e98c0c 100644 --- a/src/librustdoc/clean/auto_trait.rs +++ b/src/librustdoc/clean/auto_trait.rs @@ -351,8 +351,8 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> { if let Some(data) = ty_to_fn.get(&ty) { let (poly_trait, output) = (data.0.as_ref().expect("as_ref failed").clone(), data.1.as_ref().cloned()); - let new_ty = match &poly_trait.trait_ { - &Type::ResolvedPath { + let new_ty = match poly_trait.trait_ { + Type::ResolvedPath { ref path, ref param_names, ref did, diff --git a/src/librustdoc/clean/utils.rs b/src/librustdoc/clean/utils.rs index d4482d6fa9015..3b2f50db8c7c2 100644 --- a/src/librustdoc/clean/utils.rs +++ b/src/librustdoc/clean/utils.rs @@ -179,12 +179,12 @@ crate fn get_real_types( if arg.is_full_generic() { let arg_s = Symbol::intern(&arg.print().to_string()); if let Some(where_pred) = generics.where_predicates.iter().find(|g| match g { - &WherePredicate::BoundPredicate { ref ty, .. } => ty.def_id() == arg.def_id(), + WherePredicate::BoundPredicate { ty, .. } => ty.def_id() == arg.def_id(), _ => false, }) { let bounds = where_pred.get_bounds().unwrap_or_else(|| &[]); for bound in bounds.iter() { - if let GenericBound::TraitBound(ref poly_trait, _) = *bound { + if let GenericBound::TraitBound(poly_trait, _) = bound { for x in poly_trait.generic_params.iter() { if !x.is_type() { continue; From 675059a9ebab0b00b25542dd955f8efa9aed5dee Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1niel=20Buga?= Date: Sun, 3 Jan 2021 12:47:38 +0100 Subject: [PATCH 5/9] Clean up convoluted macros_only logic --- compiler/rustc_metadata/src/rmeta/decoder.rs | 22 ++++++++------------ 1 file changed, 9 insertions(+), 13 deletions(-) diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs index 43f7b2a992838..1c80523c9c650 100644 --- a/compiler/rustc_metadata/src/rmeta/decoder.rs +++ b/compiler/rustc_metadata/src/rmeta/decoder.rs @@ -1055,19 +1055,15 @@ impl<'a, 'tcx> CrateMetadataRef<'a> { // Iterate over all children. let macros_only = self.dep_kind.lock().macros_only(); - let children = self.root.tables.children.get(self, id).unwrap_or_else(Lazy::empty); - for child_index in children.decode((self, sess)) { - if macros_only { - continue; - } - - // Get the item. - if let Some(child_kind) = self.maybe_kind(child_index) { - match child_kind { - EntryKind::MacroDef(..) => {} - _ if macros_only => continue, - _ => {} - } + if !macros_only { + let children = self.root.tables.children.get(self, id).unwrap_or_else(Lazy::empty); + + for child_index in children.decode((self, sess)) { + // Get the item. + let child_kind = match self.maybe_kind(child_index) { + Some(child_kind) => child_kind, + None => continue, + }; // Hand off the item to the callback. match child_kind { From da3eef61f521f442d02235da0ebc6abaec614e22 Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Sat, 2 Jan 2021 14:11:19 +0100 Subject: [PATCH 6/9] Detect invalid rustdoc test commands --- src/etc/htmldocck.py | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/src/etc/htmldocck.py b/src/etc/htmldocck.py index 440181a7611cb..2f7233685db52 100644 --- a/src/etc/htmldocck.py +++ b/src/etc/htmldocck.py @@ -218,7 +218,7 @@ def concat_multi_lines(f): LINE_PATTERN = re.compile(r''' - (?<=(?!?) + (?<=(?!?)@(?P!?) (?P[A-Za-z]+(?:-[A-Za-z]+)*) (?P.*)$ ''', re.X | re.UNICODE) @@ -233,6 +233,16 @@ def get_commands(template): negated = (m.group('negated') == '!') cmd = m.group('cmd') + if m.group('invalid') == '!': + print_err( + lineno, + line, + 'Invalid command: `!@{0}{1}`, (help: try with `@!{1}`)'.format( + '!' if negated else '', + cmd, + ), + ) + continue args = m.group('args') if args and not args[:1].isspace(): print_err(lineno, line, 'Invalid template syntax') From 250fb72d1b39b013d661544428bd5db315573da3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1niel=20Buga?= Date: Sun, 3 Jan 2021 12:49:53 +0100 Subject: [PATCH 7/9] No need to collect result of get_item_attrs --- compiler/rustc_metadata/src/rmeta/decoder.rs | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs index 1c80523c9c650..90e72ba2ac2de 100644 --- a/compiler/rustc_metadata/src/rmeta/decoder.rs +++ b/compiler/rustc_metadata/src/rmeta/decoder.rs @@ -1133,9 +1133,8 @@ impl<'a, 'tcx> CrateMetadataRef<'a> { // within the crate. We only need this for fictive constructors, // for other constructors correct visibilities // were already encoded in metadata. - let attrs: Vec<_> = - self.get_item_attrs(def_id.index, sess).collect(); - if sess.contains_name(&attrs, sym::non_exhaustive) { + let mut attrs = self.get_item_attrs(def_id.index, sess); + if attrs.any(|item| item.has_name(sym::non_exhaustive)) { let crate_def_id = self.local_def_id(CRATE_DEF_INDEX); vis = ty::Visibility::Restricted(crate_def_id); } From 4d3227fe1c14c089afb6d2bfa266a78336bf4fc1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1niel=20Buga?= Date: Sun, 3 Jan 2021 12:50:29 +0100 Subject: [PATCH 8/9] Move variable into condition where it's used --- compiler/rustc_metadata/src/rmeta/decoder.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs index 90e72ba2ac2de..a4bb5f8dc954d 100644 --- a/compiler/rustc_metadata/src/rmeta/decoder.rs +++ b/compiler/rustc_metadata/src/rmeta/decoder.rs @@ -1098,8 +1098,8 @@ impl<'a, 'tcx> CrateMetadataRef<'a> { } let def_key = self.def_key(child_index); - let span = self.get_span(child_index, sess); if def_key.disambiguated_data.data.get_opt_name().is_some() { + let span = self.get_span(child_index, sess); let kind = self.def_kind(child_index); let ident = self.item_ident(child_index, sess); let vis = self.get_visibility(child_index); From 7bc1eb4506170e0750de4757af97f341c427a35a Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Sun, 3 Jan 2021 14:56:56 +0100 Subject: [PATCH 9/9] Create a "is_ignore" variable instead of doing the comparison multiple times --- src/librustdoc/html/markdown.rs | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs index f1d00b81eed1c..291a01d7468ce 100644 --- a/src/librustdoc/html/markdown.rs +++ b/src/librustdoc/html/markdown.rs @@ -1240,6 +1240,7 @@ crate fn rust_code_blocks(md: &str, extra_info: &ExtraInfo<'_, '_>) -> Vec (offset.start, offset.end), @@ -1250,7 +1251,7 @@ crate fn rust_code_blocks(md: &str, extra_info: &ExtraInfo<'_, '_>) -> Vec) -> Vec) -> Vec { // The ending of the offset goes too far sometime so we reduce it by one in