Rustup

clippy_lints/Cargo.toml

@@ -15,7 +15,6 @@ clippy_utils = { path = "../clippy_utils" }
 declare_clippy_lint = { path = "../declare_clippy_lint" }
 if_chain = "1.0"
 itertools = "0.10.1"
-pulldown-cmark = { version = "0.9", default-features = false }
 quine-mc_cluskey = "0.2"
 regex-syntax = "0.7"
 serde = { version = "1.0", features = ["derive"] }

clippy_lints/src/await_holding_invalid.rs

@@ -2,9 +2,9 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::{match_def_path, paths};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def_id::DefId;
-use rustc_hir::{AsyncGeneratorKind, Body, BodyId, GeneratorKind};
+use rustc_hir::{AsyncGeneratorKind, Body, GeneratorKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::GeneratorInteriorTypeCause;
+use rustc_middle::mir::GeneratorLayout;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, Span};
 
@@ -197,36 +197,43 @@ impl LateLintPass<'_> for AwaitHolding {
     fn check_body(&mut self, cx: &LateContext<'_>, body: &'_ Body<'_>) {
         use AsyncGeneratorKind::{Block, Closure, Fn};
         if let Some(GeneratorKind::Async(Block | Closure | Fn)) = body.generator_kind {
-            let body_id = BodyId {
-                hir_id: body.value.hir_id,
-            };
-            let typeck_results = cx.tcx.typeck_body(body_id);
-            self.check_interior_types(
-                cx,
-                typeck_results.generator_interior_types.as_ref().skip_binder(),
-                body.value.span,
-            );
+            let def_id = cx.tcx.hir().body_owner_def_id(body.id());
+            if let Some(generator_layout) = cx.tcx.mir_generator_witnesses(def_id) {
+                self.check_interior_types(cx, generator_layout);
+            }
         }
     }
 }
 
 impl AwaitHolding {
-    fn check_interior_types(&self, cx: &LateContext<'_>, ty_causes: &[GeneratorInteriorTypeCause<'_>], span: Span) {
-        for ty_cause in ty_causes {
+    fn check_interior_types(&self, cx: &LateContext<'_>, generator: &GeneratorLayout<'_>) {
+        for (ty_index, ty_cause) in generator.field_tys.iter_enumerated() {
             if let rustc_middle::ty::Adt(adt, _) = ty_cause.ty.kind() {
+                let await_points = || {
+                    generator
+                        .variant_source_info
+                        .iter_enumerated()
+                        .filter_map(|(variant, source_info)| {
+                            generator.variant_fields[variant]
+                                .raw
+                                .contains(&ty_index)
+                                .then_some(source_info.span)
+                        })
+                        .collect::<Vec<_>>()
+                };
                 if is_mutex_guard(cx, adt.did()) {
                     span_lint_and_then(
                         cx,
                         AWAIT_HOLDING_LOCK,
-                        ty_cause.span,
+                        ty_cause.source_info.span,
                         "this `MutexGuard` is held across an `await` point",
                         |diag| {
                             diag.help(
                                 "consider using an async-aware `Mutex` type or ensuring the \
                                 `MutexGuard` is dropped before calling await",
                             );
                             diag.span_note(
-                                ty_cause.scope_span.unwrap_or(span),
+                                await_points(),
                                 "these are all the `await` points this lock is held through",
                             );
                         },
@@ -235,18 +242,18 @@ impl AwaitHolding {
                     span_lint_and_then(
                         cx,
                         AWAIT_HOLDING_REFCELL_REF,
-                        ty_cause.span,
+                        ty_cause.source_info.span,
                         "this `RefCell` reference is held across an `await` point",
                         |diag| {
                             diag.help("ensure the reference is dropped before calling `await`");
                             diag.span_note(
-                                ty_cause.scope_span.unwrap_or(span),
+                                await_points(),
                                 "these are all the `await` points this reference is held through",
                             );
                         },
                     );
                 } else if let Some(disallowed) = self.def_ids.get(&adt.did()) {
-                    emit_invalid_type(cx, ty_cause.span, disallowed);
+                    emit_invalid_type(cx, ty_cause.source_info.span, disallowed);
                 }
             }
         }

clippy_lints/src/dereference.rs

@@ -844,7 +844,6 @@ impl TyCoercionStability {
                 | ty::FnDef(..)
                 | ty::Generator(..)
                 | ty::GeneratorWitness(..)
-                | ty::GeneratorWitnessMIR(..)
                 | ty::Closure(..)
                 | ty::Never
                 | ty::Tuple(_)

clippy_lints/src/derive.rs

@@ -343,7 +343,7 @@ fn check_copy_clone<'tcx>(cx: &LateContext<'tcx>, item: &Item<'_>, trait_ref: &h
     // If the current self type doesn't implement Copy (due to generic constraints), search to see if
     // there's a Copy impl for any instance of the adt.
     if !is_copy(cx, ty) {
-        if ty_subs.non_erasable_generics().next().is_some() {
+        if ty_subs.non_erasable_generics(cx.tcx, ty_adt.did()).next().is_some() {
             let has_copy_impl = cx.tcx.all_local_trait_impls(()).get(&copy_id).map_or(false, |impls| {
                 impls.iter().any(|&id| {
                     matches!(cx.tcx.type_of(id).instantiate_identity().kind(), ty::Adt(adt, _)