Auto merge of rust-lang#134380 - matthiaskrgr:rollup-a47jc6z, r=matthiaskrgr

Rollup of 5 pull requests

Successful merges:

 - rust-lang#134202 (Remove `rustc::existing_doc_keyword` lint)
 - rust-lang#134354 (Handle fndef rendering together with signature rendering)
 - rust-lang#134368 (Use links to edition guide for edition migrations)
 - rust-lang#134371 (Check for array lengths that aren't actually `usize`)
 - rust-lang#134378 (An octuple of polonius fact generation cleanups)

Failed merges:

 - rust-lang#134365 (Rename `rustc_mir_build::build` to `builder`)

r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

Diff for: Cargo.lock

@@ -4275,7 +4275,6 @@ dependencies = [
  "rustc_fluent_macro",
  "rustc_hir",
  "rustc_index",
- "rustc_lexer",
  "rustc_macros",
  "rustc_middle",
  "rustc_privacy",

Diff for: compiler/rustc_borrowck/src/nll.rs

@@ -124,6 +124,7 @@ pub(crate) fn compute_regions<'a, 'tcx>(
         borrow_set,
         move_data,
         &universal_region_relations,
+        &constraints,
     );
 
     let mut regioncx = RegionInferenceContext::new(

Diff for: compiler/rustc_borrowck/src/polonius/legacy/accesses.rs

@@ -0,0 +1,85 @@
+use rustc_middle::mir::visit::{MutatingUseContext, PlaceContext, Visitor};
+use rustc_middle::mir::{Body, Local, Location, Place};
+use rustc_middle::ty::TyCtxt;
+use rustc_mir_dataflow::move_paths::{LookupResult, MoveData};
+use tracing::debug;
+
+use crate::def_use::{self, DefUse};
+use crate::facts::AllFacts;
+use crate::location::{LocationIndex, LocationTable};
+use crate::universal_regions::UniversalRegions;
+
+/// Emit polonius facts for variable defs, uses, drops, and path accesses.
+pub(crate) fn emit_access_facts<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    facts: &mut AllFacts,
+    body: &Body<'tcx>,
+    location_table: &LocationTable,
+    move_data: &MoveData<'tcx>,
+    universal_regions: &UniversalRegions<'tcx>,
+) {
+    let mut extractor = AccessFactsExtractor { facts, move_data, location_table };
+    extractor.visit_body(body);
+
+    for (local, local_decl) in body.local_decls.iter_enumerated() {
+        debug!("add use_of_var_derefs_origin facts - local={:?}, type={:?}", local, local_decl.ty);
+        tcx.for_each_free_region(&local_decl.ty, |region| {
+            let region_vid = universal_regions.to_region_vid(region);
+            facts.use_of_var_derefs_origin.push((local, region_vid.into()));
+        });
+    }
+}
+
+/// MIR visitor extracting point-wise facts about accesses.
+struct AccessFactsExtractor<'a, 'tcx> {
+    facts: &'a mut AllFacts,
+    move_data: &'a MoveData<'tcx>,
+    location_table: &'a LocationTable,
+}
+
+impl<'tcx> AccessFactsExtractor<'_, 'tcx> {
+    fn location_to_index(&self, location: Location) -> LocationIndex {
+        self.location_table.mid_index(location)
+    }
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for AccessFactsExtractor<'a, 'tcx> {
+    fn visit_local(&mut self, local: Local, context: PlaceContext, location: Location) {
+        match def_use::categorize(context) {
+            Some(DefUse::Def) => {
+                debug!("AccessFactsExtractor - emit def");
+                self.facts.var_defined_at.push((local, self.location_to_index(location)));
+            }
+            Some(DefUse::Use) => {
+                debug!("AccessFactsExtractor - emit use");
+                self.facts.var_used_at.push((local, self.location_to_index(location)));
+            }
+            Some(DefUse::Drop) => {
+                debug!("AccessFactsExtractor - emit drop");
+                self.facts.var_dropped_at.push((local, self.location_to_index(location)));
+            }
+            _ => (),
+        }
+    }
+
+    fn visit_place(&mut self, place: &Place<'tcx>, context: PlaceContext, location: Location) {
+        self.super_place(place, context, location);
+
+        match context {
+            PlaceContext::NonMutatingUse(_)
+            | PlaceContext::MutatingUse(MutatingUseContext::Borrow) => {
+                let path = match self.move_data.rev_lookup.find(place.as_ref()) {
+                    LookupResult::Exact(path) | LookupResult::Parent(Some(path)) => path,
+                    _ => {
+                        // There's no path access to emit.
+                        return;
+                    }
+                };
+                debug!("AccessFactsExtractor - emit path access ({path:?}, {location:?})");
+                self.facts.path_accessed_at_base.push((path, self.location_to_index(location)));
+            }
+
+            _ => {}
+        }
+    }
+}

Diff for: compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs

@@ -21,22 +21,22 @@ use crate::{
 /// Emit `loan_invalidated_at` facts.
 pub(super) fn emit_loan_invalidations<'tcx>(
     tcx: TyCtxt<'tcx>,
-    all_facts: &mut AllFacts,
-    location_table: &LocationTable,
+    facts: &mut AllFacts,
     body: &Body<'tcx>,
+    location_table: &LocationTable,
     borrow_set: &BorrowSet<'tcx>,
 ) {
     let dominators = body.basic_blocks.dominators();
     let mut visitor =
-        LoanInvalidationsGenerator { all_facts, borrow_set, tcx, location_table, body, dominators };
+        LoanInvalidationsGenerator { facts, borrow_set, tcx, location_table, body, dominators };
     visitor.visit_body(body);
 }
 
 struct LoanInvalidationsGenerator<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
-    all_facts: &'a mut AllFacts,
-    location_table: &'a LocationTable,
+    facts: &'a mut AllFacts,
     body: &'a Body<'tcx>,
+    location_table: &'a LocationTable,
     dominators: &'a Dominators<BasicBlock>,
     borrow_set: &'a BorrowSet<'tcx>,
 }
@@ -151,7 +151,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LoanInvalidationsGenerator<'a, 'tcx> {
                 let resume = self.location_table.start_index(resume.start_location());
                 for (i, data) in borrow_set.iter_enumerated() {
                     if borrow_of_local_data(data.borrowed_place) {
-                        self.all_facts.loan_invalidated_at.push((resume, i));
+                        self.facts.loan_invalidated_at.push((resume, i));
                     }
                 }
 
@@ -165,7 +165,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LoanInvalidationsGenerator<'a, 'tcx> {
                 let start = self.location_table.start_index(location);
                 for (i, data) in borrow_set.iter_enumerated() {
                     if borrow_of_local_data(data.borrowed_place) {
-                        self.all_facts.loan_invalidated_at.push((start, i));
+                        self.facts.loan_invalidated_at.push((start, i));
                     }
                 }
             }
@@ -409,7 +409,7 @@ impl<'a, 'tcx> LoanInvalidationsGenerator<'a, 'tcx> {
     /// Generates a new `loan_invalidated_at(L, B)` fact.
     fn emit_loan_invalidated_at(&mut self, b: BorrowIndex, l: Location) {
         let lidx = self.location_table.start_index(l);
-        self.all_facts.loan_invalidated_at.push((lidx, b));
+        self.facts.loan_invalidated_at.push((lidx, b));
     }
 
     fn check_activations(&mut self, location: Location) {

Diff for: compiler/rustc_borrowck/src/polonius/legacy/loan_kills.rs

@@ -14,20 +14,20 @@ use crate::places_conflict;
 /// Emit `loan_killed_at` and `cfg_edge` facts at the same time.
 pub(super) fn emit_loan_kills<'tcx>(
     tcx: TyCtxt<'tcx>,
-    all_facts: &mut AllFacts,
-    location_table: &LocationTable,
+    facts: &mut AllFacts,
     body: &Body<'tcx>,
+    location_table: &LocationTable,
     borrow_set: &BorrowSet<'tcx>,
 ) {
-    let mut visitor = LoanKillsGenerator { borrow_set, tcx, location_table, all_facts, body };
+    let mut visitor = LoanKillsGenerator { borrow_set, tcx, location_table, facts, body };
     for (bb, data) in body.basic_blocks.iter_enumerated() {
         visitor.visit_basic_block_data(bb, data);
     }
 }
 
 struct LoanKillsGenerator<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
-    all_facts: &'a mut AllFacts,
+    facts: &'a mut AllFacts,
     location_table: &'a LocationTable,
     borrow_set: &'a BorrowSet<'tcx>,
     body: &'a Body<'tcx>,
@@ -36,12 +36,12 @@ struct LoanKillsGenerator<'a, 'tcx> {
 impl<'a, 'tcx> Visitor<'tcx> for LoanKillsGenerator<'a, 'tcx> {
     fn visit_statement(&mut self, statement: &Statement<'tcx>, location: Location) {
         // Also record CFG facts here.
-        self.all_facts.cfg_edge.push((
+        self.facts.cfg_edge.push((
             self.location_table.start_index(location),
             self.location_table.mid_index(location),
         ));
 
-        self.all_facts.cfg_edge.push((
+        self.facts.cfg_edge.push((
             self.location_table.mid_index(location),
             self.location_table.start_index(location.successor_within_block()),
         ));
@@ -63,15 +63,15 @@ impl<'a, 'tcx> Visitor<'tcx> for LoanKillsGenerator<'a, 'tcx> {
 
     fn visit_terminator(&mut self, terminator: &Terminator<'tcx>, location: Location) {
         // Also record CFG facts here.
-        self.all_facts.cfg_edge.push((
+        self.facts.cfg_edge.push((
             self.location_table.start_index(location),
             self.location_table.mid_index(location),
         ));
 
         let successor_blocks = terminator.successors();
-        self.all_facts.cfg_edge.reserve(successor_blocks.size_hint().0);
+        self.facts.cfg_edge.reserve(successor_blocks.size_hint().0);
         for successor_block in successor_blocks {
-            self.all_facts.cfg_edge.push((
+            self.facts.cfg_edge.push((
                 self.location_table.mid_index(location),
                 self.location_table.start_index(successor_block.start_location()),
             ));
@@ -128,7 +128,7 @@ impl<'tcx> LoanKillsGenerator<'_, 'tcx> {
 
                         if places_conflict {
                             let location_index = self.location_table.mid_index(location);
-                            self.all_facts.loan_killed_at.push((borrow_index, location_index));
+                            self.facts.loan_killed_at.push((borrow_index, location_index));
                         }
                     }
                 }
@@ -140,9 +140,9 @@ impl<'tcx> LoanKillsGenerator<'_, 'tcx> {
     fn record_killed_borrows_for_local(&mut self, local: Local, location: Location) {
         if let Some(borrow_indices) = self.borrow_set.local_map.get(&local) {
             let location_index = self.location_table.mid_index(location);
-            self.all_facts.loan_killed_at.reserve(borrow_indices.len());
+            self.facts.loan_killed_at.reserve(borrow_indices.len());
             for &borrow_index in borrow_indices {
-                self.all_facts.loan_killed_at.push((borrow_index, location_index));
+                self.facts.loan_killed_at.push((borrow_index, location_index));
             }
         }
     }