From 5bf5b127070b510dee82770b921aa39137c1d889 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
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<usize>,
crate is_fenced: bool,
crate syntax: Option<String>,
+ 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<RustC
while let Some((event, offset)) = p.next() {
if let Event::Start(Tag::CodeBlock(syntax)) = event {
- let (syntax, code_start, code_end, range, is_fenced) = match syntax {
+ let (syntax, code_start, code_end, range, is_fenced, is_ignore) = match syntax {
CodeBlockKind::Fenced(syntax) => {
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<RustC
range: offset,
code,
syntax,
+ is_ignore: lang_string.ignore != Ignore::None,
});
continue;
}
@@ -1259,6 +1261,7 @@ crate fn rust_code_blocks(md: &str, extra_info: &ExtraInfo<'_, '_>) -> Vec<RustC
range: offset,
code,
syntax,
+ is_ignore: lang_string.ignore != Ignore::None,
});
continue;
}
@@ -1266,7 +1269,7 @@ crate fn rust_code_blocks(md: &str, extra_info: &ExtraInfo<'_, '_>) -> Vec<RustC
while let Some((Event::Text(_), offset)) = p.next() {
code_end = offset.end;
}
- (syntax, code_start, code_end, offset, true)
+ (syntax, code_start, code_end, offset, true, lang_string.ignore != Ignore::None)
}
CodeBlockKind::Indented => {
// 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<RustC
offset.end,
Range { start: offset.start, end: offset.end - 1 },
false,
+ false,
)
} else {
- (None, offset.start, offset.end, offset, false)
+ (None, offset.start, offset.end, offset, false, false)
}
}
};
@@ -1290,6 +1294,7 @@ crate fn rust_code_blocks(md: &str, extra_info: &ExtraInfo<'_, '_>) -> Vec<RustC
range,
code: Range { start: code_start, end: code_end },
syntax,
+ is_ignore,
});
}
}
diff --git a/src/librustdoc/passes/check_code_block_syntax.rs b/src/librustdoc/passes/check_code_block_syntax.rs
index 0c76dc571beee..554392c213e24 100644
--- a/src/librustdoc/passes/check_code_block_syntax.rs
+++ b/src/librustdoc/passes/check_code_block_syntax.rs
@@ -51,10 +51,10 @@ impl<'a, 'tcx> 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 <guillaume1.gomez@gmail.com>
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 <bastian_kauschke@hotmail.de>
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?= <matthias.krueger@famsik.de>
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<Expr> {
- 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<FxHashSet<&'q DepNode>>,
targets: &Option<FxHashSet<&'q DepNode>>,
) -> 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<Span>)> {
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?= <bugadani@gmail.com>
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 <guillaume1.gomez@gmail.com>
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'''
- (?<=(?<!\S)@)(?P<negated>!?)
+ (?<=(?<!\S))(?P<invalid>!?)@(?P<negated>!?)
(?P<cmd>[A-Za-z]+(?:-[A-Za-z]+)*)
(?P<args>.*)$
''', 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?= <bugadani@gmail.com>
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?= <bugadani@gmail.com>
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 <guillaume1.gomez@gmail.com>
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<RustC
if !lang_string.rust {
continue;
}
+ let is_ignore = lang_string.ignore != Ignore::None;
let syntax = if syntax.is_empty() { None } else { Some(syntax.to_owned()) };
let (code_start, mut code_end) = match p.next() {
Some((Event::Text(_), offset)) => (offset.start, offset.end),
@@ -1250,7 +1251,7 @@ crate fn rust_code_blocks(md: &str, extra_info: &ExtraInfo<'_, '_>) -> Vec<RustC
range: offset,
code,
syntax,
- is_ignore: lang_string.ignore != Ignore::None,
+ is_ignore,
});
continue;
}
@@ -1261,7 +1262,7 @@ crate fn rust_code_blocks(md: &str, extra_info: &ExtraInfo<'_, '_>) -> Vec<RustC
range: offset,
code,
syntax,
- is_ignore: lang_string.ignore != Ignore::None,
+ is_ignore,
});
continue;
}
@@ -1269,7 +1270,7 @@ crate fn rust_code_blocks(md: &str, extra_info: &ExtraInfo<'_, '_>) -> Vec<RustC
while let Some((Event::Text(_), offset)) = p.next() {
code_end = offset.end;
}
- (syntax, code_start, code_end, offset, true, lang_string.ignore != Ignore::None)
+ (syntax, code_start, code_end, offset, true, is_ignore)
}
CodeBlockKind::Indented => {
// The ending of the offset goes too far sometime so we reduce it by one in