Auto merge of #154466 - fmease:rollup-RqOocPd, r=fmease

Rollup of 10 pull requests

Successful merges:

 - #154070 (Unstable book options parser)
 - #154371 (Use LocalDefId for more tcx method calls)
 - #154405 (Improve doc comment unicode guidance)
 - #154431 (Avoid ICE in explicit reference cast suggestion for unrelated leaf pr…)
 - #153528 (Fix LegacyKeyValueFormat report from docker build: mips)
 - #154246 (Add test for issue #101532: dead code warnings in const _)
 - #154421 (Rustdoc rejects html emits with json output)
 - #154428 (bootstrap: `-Zjson-target-spec` for synthetic targets)
 - #154437 (bootstrap.example.toml: Hint how to allow `build.warnings`)
 - #154454 (fix: [rustfmt] prevent panic when rewritng associated item delegations)

Failed merges:

 - #154450 (Use the normal arg-parsing machinery for `-Zassert-incr-state`)

Author: bors

Cargo.lock

@@ -6088,6 +6088,8 @@ name = "unstable-book-gen"
 version = "0.1.0"
 dependencies = [
  "num-traits",
+ "proc-macro2",
+ "syn 2.0.110",
  "tidy",
 ]
 

bootstrap.example.toml

@@ -826,7 +826,8 @@
 # in the sysroot. It is required for running nvptx tests.
 #rust.llvm-bitcode-linker = false
 
-# Whether to deny warnings in crates
+# Whether to deny warnings in crates. Set to `false` to avoid
+# error: warnings are denied by `build.warnings` configuration
 #rust.deny-warnings = true
 
 # Print backtrace on internal compiler errors during bootstrap

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -1569,10 +1569,8 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
         let tcx = self.infcx.tcx;
         let generics = tcx.generics_of(self.mir_def_id());
 
-        let Some(hir_generics) = tcx
-            .typeck_root_def_id(self.mir_def_id().to_def_id())
-            .as_local()
-            .and_then(|def_id| tcx.hir_get_generics(def_id))
+        let Some(hir_generics) =
+            tcx.hir_get_generics(tcx.typeck_root_def_id_local(self.mir_def_id()))
         else {
             return;
         };

compiler/rustc_borrowck/src/diagnostics/mod.rs

@@ -1274,12 +1274,9 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                     if let ty::Param(param_ty) = *self_ty.kind()
                         && let generics = self.infcx.tcx.generics_of(self.mir_def_id())
                         && let param = generics.type_param(param_ty, self.infcx.tcx)
-                        && let Some(hir_generics) = self
-                            .infcx
-                            .tcx
-                            .typeck_root_def_id(self.mir_def_id().to_def_id())
-                            .as_local()
-                            .and_then(|def_id| self.infcx.tcx.hir_get_generics(def_id))
+                        && let Some(hir_generics) = self.infcx.tcx.hir_get_generics(
+                            self.infcx.tcx.typeck_root_def_id_local(self.mir_def_id()),
+                        )
                         && let spans = hir_generics
                             .predicates
                             .iter()

compiler/rustc_borrowck/src/universal_regions.rs

@@ -476,12 +476,10 @@ impl<'cx, 'tcx> UniversalRegionsBuilder<'cx, 'tcx> {
         let mut indices = self.compute_indices(fr_static, defining_ty);
         debug!("build: indices={:?}", indices);
 
-        let typeck_root_def_id = self.infcx.tcx.typeck_root_def_id(self.mir_def.to_def_id());
-
         // If this is a 'root' body (not a closure/coroutine/inline const), then
         // there are no extern regions, so the local regions start at the same
         // position as the (empty) sub-list of extern regions
-        let first_local_index = if self.mir_def.to_def_id() == typeck_root_def_id {
+        let first_local_index = if !self.infcx.tcx.is_typeck_child(self.mir_def.to_def_id()) {
             first_extern_index
         } else {
             // If this is a closure, coroutine, or inline-const, then the late-bound regions from the enclosing
@@ -583,7 +581,7 @@ impl<'cx, 'tcx> UniversalRegionsBuilder<'cx, 'tcx> {
     /// see `DefiningTy` for details.
     fn defining_ty(&self) -> DefiningTy<'tcx> {
         let tcx = self.infcx.tcx;
-        let typeck_root_def_id = tcx.typeck_root_def_id(self.mir_def.to_def_id());
+        let typeck_root_def_id = tcx.typeck_root_def_id_local(self.mir_def);
 
         match tcx.hir_body_owner_kind(self.mir_def) {
             BodyOwnerKind::Closure | BodyOwnerKind::Fn => {
@@ -614,7 +612,7 @@ impl<'cx, 'tcx> UniversalRegionsBuilder<'cx, 'tcx> {
 
             BodyOwnerKind::Const { .. } | BodyOwnerKind::Static(..) => {
                 let identity_args = GenericArgs::identity_for_item(tcx, typeck_root_def_id);
-                if self.mir_def.to_def_id() == typeck_root_def_id {
+                if self.mir_def == typeck_root_def_id {
                     let args = self.infcx.replace_free_regions_with_nll_infer_vars(
                         NllRegionVariableOrigin::FreeRegion,
                         identity_args,
@@ -660,7 +658,7 @@ impl<'cx, 'tcx> UniversalRegionsBuilder<'cx, 'tcx> {
         defining_ty: DefiningTy<'tcx>,
     ) -> UniversalRegionIndices<'tcx> {
         let tcx = self.infcx.tcx;
-        let typeck_root_def_id = tcx.typeck_root_def_id(self.mir_def.to_def_id());
+        let typeck_root_def_id = tcx.typeck_root_def_id_local(self.mir_def);
         let identity_args = GenericArgs::identity_for_item(tcx, typeck_root_def_id);
         let renumbered_args = defining_ty.args();
 
@@ -948,16 +946,14 @@ fn for_each_late_bound_region_in_recursive_scope<'tcx>(
     mut mir_def_id: LocalDefId,
     mut f: impl FnMut(ty::Region<'tcx>),
 ) {
-    let typeck_root_def_id = tcx.typeck_root_def_id(mir_def_id.to_def_id());
-
     // Walk up the tree, collecting late-bound regions until we hit the typeck root
     loop {
         for_each_late_bound_region_in_item(tcx, mir_def_id, &mut f);
 
-        if mir_def_id.to_def_id() == typeck_root_def_id {
-            break;
-        } else {
+        if tcx.is_typeck_child(mir_def_id.to_def_id()) {
             mir_def_id = tcx.local_parent(mir_def_id);
+        } else {
+            break;
         }
     }
 }

compiler/rustc_hir_analysis/src/check/region.rs

@@ -11,7 +11,7 @@ use std::mem;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, DefKind, Res};
-use rustc_hir::def_id::DefId;
+use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::{Arm, Block, Expr, LetStmt, Pat, PatKind, Stmt};
 use rustc_index::Idx;
@@ -849,13 +849,13 @@ impl<'tcx> Visitor<'tcx> for ScopeResolutionVisitor<'tcx> {
 /// re-use in incremental scenarios. We may sometimes need to rerun the
 /// type checker even when the HIR hasn't changed, and in those cases
 /// we can avoid reconstructing the region scope tree.
-pub(crate) fn region_scope_tree(tcx: TyCtxt<'_>, def_id: DefId) -> &ScopeTree {
-    let typeck_root_def_id = tcx.typeck_root_def_id(def_id);
+pub(crate) fn region_scope_tree(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &ScopeTree {
+    let typeck_root_def_id = tcx.typeck_root_def_id_local(def_id);
     if typeck_root_def_id != def_id {
         return tcx.region_scope_tree(typeck_root_def_id);
     }
 
-    let scope_tree = if let Some(body) = tcx.hir_maybe_body_owned_by(def_id.expect_local()) {
+    let scope_tree = if let Some(body) = tcx.hir_maybe_body_owned_by(def_id) {
         let mut visitor = ScopeResolutionVisitor {
             tcx,
             scope_tree: ScopeTree::default(),

compiler/rustc_hir_analysis/src/collect/generics_of.rs

@@ -76,12 +76,12 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
         | Node::Ctor(..)
         | Node::Field(_) => {
             let parent_id = tcx.hir_get_parent_item(hir_id);
-            Some(parent_id.to_def_id())
+            Some(parent_id.def_id)
         }
         // FIXME(#43408) always enable this once `lazy_normalization` is
         // stable enough and does not need a feature gate anymore.
         Node::AnonConst(_) => {
-            let parent_did = tcx.parent(def_id.to_def_id());
+            let parent_did = tcx.local_parent(def_id);
             debug!(?parent_did);
 
             let mut in_param_ty = false;
@@ -175,7 +175,7 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
         }
         Node::ConstBlock(_)
         | Node::Expr(&hir::Expr { kind: hir::ExprKind::Closure { .. }, .. }) => {
-            Some(tcx.typeck_root_def_id(def_id.to_def_id()))
+            Some(tcx.typeck_root_def_id_local(def_id))
         }
         Node::OpaqueTy(&hir::OpaqueTy {
             origin:
@@ -188,7 +188,7 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
             } else {
                 assert_matches!(tcx.def_kind(fn_def_id), DefKind::AssocFn | DefKind::Fn);
             }
-            Some(fn_def_id.to_def_id())
+            Some(fn_def_id)
         }
         Node::OpaqueTy(&hir::OpaqueTy {
             origin: hir::OpaqueTyOrigin::TyAlias { parent, in_assoc_ty },
@@ -202,7 +202,7 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
             debug!("generics_of: parent of opaque ty {:?} is {:?}", def_id, parent);
             // Opaque types are always nested within another item, and
             // inherit the generics of the item.
-            Some(parent.to_def_id())
+            Some(parent)
         }
 
         // All of these nodes have no parent from which to inherit generics.
@@ -380,7 +380,7 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
         own_params.iter().map(|param| (param.def_id, param.index)).collect();
 
     ty::Generics {
-        parent: parent_def_id,
+        parent: parent_def_id.map(LocalDefId::to_def_id),
         parent_count,
         own_params,
         param_def_id_to_index,

compiler/rustc_hir_analysis/src/collect/predicates_of.rs

@@ -107,7 +107,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
             );
 
             return ty::GenericPredicates {
-                parent: Some(tcx.parent(def_id.to_def_id())),
+                parent: Some(tcx.local_parent(def_id).to_def_id()),
                 predicates: tcx.arena.alloc_from_iter(predicates),
             };
         }

compiler/rustc_hir_typeck/src/closure.rs

@@ -72,7 +72,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         debug!(?bound_sig, ?liberated_sig);
 
         let parent_args =
-            GenericArgs::identity_for_item(tcx, tcx.typeck_root_def_id(expr_def_id.to_def_id()));
+            GenericArgs::identity_for_item(tcx, tcx.typeck_root_def_id_local(expr_def_id));
 
         let tupled_upvars_ty = self.next_ty_var(expr_span);
 

compiler/rustc_hir_typeck/src/lib.rs

@@ -106,7 +106,7 @@ fn typeck_with_inspect<'tcx>(
 ) -> &'tcx ty::TypeckResults<'tcx> {
     // Closures' typeck results come from their outermost function,
     // as they are part of the same "inference environment".
-    let typeck_root_def_id = tcx.typeck_root_def_id(def_id.to_def_id()).expect_local();
+    let typeck_root_def_id = tcx.typeck_root_def_id_local(def_id);
     if typeck_root_def_id != def_id {
         return tcx.typeck(typeck_root_def_id);
     }