Use new -Zmaximal-hir-to-mir-coverage flag on nightly-2022-12-07

Author: willcrichton

.github/workflows/release.yml

@@ -49,7 +49,7 @@ jobs:
       - uses: actions/checkout@v1
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2022-11-07
+          toolchain: nightly-2022-12-07
           components: rust-src, rustc-dev, llvm-tools-preview
           target: ${{ matrix.target }}
           profile: minimal

README.md

@@ -179,7 +179,7 @@ If rustup fails, especially with an error like "could not rename downloaded file
 To solve the issue, go to the command line and run:
 
 ```
-rustup toolchain install nightly-2022-11-07 -c rust-src -c rustc-dev -c llvm-tools-preview
+rustup toolchain install nightly-2022-12-07 -c rust-src -c rustc-dev -c llvm-tools-preview
 ```
 
 Then go back to VSCode and click "Continue" to let Flowistry continue installing.

crates/flowistry/src/lib.rs

@@ -38,14 +38,14 @@
   associated_type_defaults,  // for crate::indexed::Indexed
   min_specialization,        // for rustc_index::newtype_index
   type_alias_impl_trait,     // for impl Trait in trait definition, eg crate::mir::utils 
-  trait_alias,  
+  trait_alias,
 )]
 #![allow(
   clippy::single_match,
   clippy::needless_lifetimes,
   clippy::needless_return,
   clippy::len_zero,
-  clippy::len_without_is_empty,  
+  clippy::len_without_is_empty
 )]
 
 extern crate either;

crates/flowistry/src/mir/aliases.rs

@@ -32,7 +32,8 @@ use crate::{
   indexed::{
     impls::{
       build_location_arg_domain, LocationOrArgDomain, LocationOrArgIndex, PlaceSet,
-    }, ToIndex,
+    },
+    ToIndex,
   },
   mir::utils::{self, MutabilityExt, PlaceExt},
   timer::elapsed,
@@ -524,7 +525,7 @@ impl<'a, 'tcx> Aliases<'a, 'tcx> {
 
   /// Returns all [direct](PlaceExt::is_direct) places that are reachable from `place`
   /// and can be used at the provided level of [`Mutability`].
-  /// 
+  ///
   /// For example, if `x = 0` and `y = (0, &x)`, then `reachable_values(y, Mutability::Not)`
   /// is `{y, y.0, y.1, x}`. With `Mutability::Mut`, then the output is `{y, y.0, y.1}` (no `x`).
   pub fn reachable_values(

crates/flowistry/src/mir/utils.rs

@@ -13,7 +13,7 @@ use either::Either;
 use log::{trace, warn};
 use rustc_data_structures::fx::{FxHashMap as HashMap, FxHashSet as HashSet};
 use rustc_graphviz as dot;
-use rustc_hir::def_id::DefId;
+use rustc_hir::{def_id::DefId, HirId};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_middle::{
   mir::{
@@ -31,7 +31,7 @@ use rustc_span::{
   source_map::SourceMap, BytePos, Pos, Span, SpanData, Symbol, SyntaxContext,
 };
 use rustc_target::abi::VariantIdx;
-use rustc_trait_selection::infer::InferCtxtExt;
+use rustc_trait_selection::traits::NormalizeExt;
 use smallvec::SmallVec;
 
 use crate::{
@@ -250,7 +250,7 @@ pub fn location_to_string(location: LocationOrArg, body: &Body<'_>) -> String {
 }
 
 /// MIR pass to remove instructions not important for Flowistry.
-/// 
+///
 /// This pass helps reduce the number of intermediates during dataflow analysis, which
 /// reduces memory usage.
 pub struct SimplifyMir;
@@ -527,7 +527,8 @@ impl<'tcx> PlaceExt<'tcx> for Place<'tcx> {
     let place = tcx.erase_regions(*self);
     let infcx = tcx.infer_ctxt().build();
     let place = infcx
-      .partially_normalize_associated_types_in(ObligationCause::dummy(), param_env, place)
+      .at(&ObligationCause::dummy(), param_env)
+      .normalize(place)
       .value;
 
     let projection = place
@@ -770,7 +771,7 @@ pub trait BodyExt<'tcx> {
     Self: 'a;
 
   /// Returns all the locations of [`TerminatorKind::Return`] instructions in a body.
-  fn all_returns(&self) -> Self::AllReturnsIter<'_>;
+  fn all_returns<'a>(&'a self) -> Self::AllReturnsIter<'a>;
 
   type AllLocationsIter<'a>: Iterator<Item = Location>
   where
@@ -787,10 +788,22 @@ pub trait BodyExt<'tcx> {
   fn debug_info_name_map(&self) -> HashMap<Local, Symbol>;
 
   fn to_string(&self, tcx: TyCtxt<'tcx>) -> Result<String>;
+
+  /// Returns the HirId corresponding to a MIR location.
+  ///
+  /// You **MUST** use the `-Zmaximize-hir-to-mir-mapping` flag for this
+  /// function to work.
+  fn location_to_hir_id(&self, location: Location) -> HirId;
+
+  fn source_info_to_hir_id(&self, info: &SourceInfo) -> HirId;
 }
 
+// https://github.com/rust-lang/rust/issues/66551#issuecomment-629815002
+pub trait Captures<'a> {}
+impl<'a, T> Captures<'a> for T {}
+
 impl<'tcx> BodyExt<'tcx> for Body<'tcx> {
-  type AllReturnsIter<'a> = impl Iterator<Item = Location> + 'a where Self: 'a ;
+  type AllReturnsIter<'a> = impl Iterator<Item = Location> + Captures<'tcx> + 'a where Self: 'a;
   fn all_returns(&self) -> Self::AllReturnsIter<'_> {
     self
       .basic_blocks
@@ -804,7 +817,7 @@ impl<'tcx> BodyExt<'tcx> for Body<'tcx> {
       })
   }
 
-  type AllLocationsIter<'a> = impl Iterator<Item = Location> + 'a    where Self: 'a;
+  type AllLocationsIter<'a> = impl Iterator<Item = Location> + Captures<'tcx> + 'a where Self: 'a;
   fn all_locations(&self) -> Self::AllLocationsIter<'_> {
     self
       .basic_blocks
@@ -842,6 +855,17 @@ impl<'tcx> BodyExt<'tcx> for Body<'tcx> {
     write_mir_fn(tcx, self, &mut |_, _| Ok(()), &mut buffer)?;
     Ok(String::from_utf8(buffer)?)
   }
+
+  fn location_to_hir_id(&self, location: Location) -> HirId {
+    let source_info = self.source_info(location);
+    self.source_info_to_hir_id(source_info)
+  }
+
+  fn source_info_to_hir_id(&self, info: &SourceInfo) -> HirId {
+    let scope = &self.source_scopes[info.scope];
+    let local_data = scope.local_data.as_ref().assert_crate_local();
+    local_data.lint_root
+  }
 }
 
 /// Extension trait for [`Span`].

crates/flowistry/src/source_map/hir_span.rs

@@ -1,11 +1,10 @@
-use hir::LoopSource;
-use log::trace;
+use hir::{HirId, LoopSource};
 use rustc_hir::{
   self as hir,
   intravisit::{self, Visitor as HirVisitor},
-  Expr, ExprKind, MatchSource, Node, Param, Stmt,
+  ExprKind, MatchSource, Node,
 };
-use rustc_span::{BytePos, Span, SpanData};
+use rustc_span::{BytePos, Span};
 
 use super::Spanner;
 use crate::mir::utils::SpanExt;
@@ -25,11 +24,17 @@ impl<'hir> HirVisitor<'hir> for ChildExprSpans {
       ExprKind::Block(..) => {
         intravisit::walk_expr(self, ex);
       }
-      // The HIR span for a for-loop desugared to a match is *smaller*
-      // than the span of its children. So we have to explicitly recurse
-      // into the match arm instead of just taking the span for the match.
-      // See `forloop_some_relevant` for where this matters.
-      ExprKind::Match(_, arms, MatchSource::ForLoopDesugar) => {
+      // ForLoopDesgar case:
+      //   The HIR span for a for-loop desugared to a match is *smaller*
+      //   than the span of its children. So we have to explicitly recurse
+      //   into the match arm instead of just taking the span for the match.
+      //   See `forloop_some_relevant` for where this matters.
+      //
+      // Normal case:
+      //   The SwitchInts for a normal match exclusively source-map to the patterns
+      //   in the arms, not the matched expression. So to make sure that `match e { .. }`
+      //   includes `e` when `match` is relevant, we exclude `e` from the child spans.
+      ExprKind::Match(_, arms, MatchSource::ForLoopDesugar | MatchSource::Normal) => {
         for arm in arms {
           intravisit::walk_arm(self, arm);
         }
@@ -63,134 +68,64 @@ pub enum EnclosingHirSpans {
 
   /// The spans of the node minus its children
   OuterOnly,
-  
+
   /// No span
   None,
 }
 
-#[derive(Clone, Debug)]
-pub struct HirSpannedNode<'hir> {
-  pub full: SpanData,
-  pub outer: Vec<Span>,
-  pub node: hir::Node<'hir>,
-}
-
-impl HirSpannedNode<'_> {
-  pub fn get_spans(&self, span_type: EnclosingHirSpans) -> Vec<Span> {
-    match span_type {
-      EnclosingHirSpans::OuterOnly => self.outer.clone(),
-      EnclosingHirSpans::Full => vec![self.full.span()],
-      EnclosingHirSpans::None => Vec::new(),
-    }
-  }
-}
-
-pub struct HirSpanCollector<'a, 'hir, 'tcx>(pub &'a mut Spanner<'hir, 'tcx>);
-
 macro_rules! try_span {
   ($self:expr, $span:expr) => {
-    match $span.as_local($self.0.item_span) {
-      Some(span) if !$self.0.invalid_span(span) => span,
+    match $span.as_local($self.item_span) {
+      Some(span) if !$self.invalid_span(span) => span,
       _ => {
-        return;
+        return None;
       }
     }
   };
 }
 
-fn expr_to_string(ex: &Expr) -> String {
-  rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_expr(ex))
-}
-
-impl<'hir> HirVisitor<'hir> for HirSpanCollector<'_, 'hir, '_> {
-  fn visit_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
-    intravisit::walk_expr(self, expr);
-
-    let span = try_span!(self, expr.span);
-
-    let inner_spans = match expr.kind {
-      ExprKind::Loop(_, _, loop_source, header) => match loop_source {
-        LoopSource::ForLoop | LoopSource::While => {
-          vec![expr.span.trim_start(header).unwrap_or(expr.span)]
-        }
-        LoopSource::Loop => {
-          vec![expr.span.with_lo(expr.span.lo() + BytePos(4))]
+impl<'tcx> Spanner<'tcx> {
+  pub fn hir_spans(&self, id: HirId, mode: EnclosingHirSpans) -> Option<Vec<Span>> {
+    let hir = self.tcx.hir();
+    let span = try_span!(self, hir.span(id));
+    let inner_spans = match hir.get(id) {
+      Node::Expr(expr) => match expr.kind {
+        ExprKind::Loop(_, _, loop_source, header) => match loop_source {
+          LoopSource::ForLoop | LoopSource::While => {
+            vec![expr.span.trim_start(header).unwrap_or(expr.span)]
+          }
+
+          LoopSource::Loop => vec![expr.span.with_lo(expr.span.lo() + BytePos(4))],
+        },
+        ExprKind::Break(..) => return None,
+        _ => {
+          let mut visitor = ChildExprSpans {
+            spans: Vec::new(),
+            item_span: self.item_span,
+          };
+          intravisit::walk_expr(&mut visitor, expr);
+
+          visitor.spans
         }
       },
-      ExprKind::Break(..) => {
-        return;
-      }
-      _ => {
+      Node::Stmt(stmt) => {
         let mut visitor = ChildExprSpans {
           spans: Vec::new(),
-          item_span: self.0.item_span,
+          item_span: self.item_span,
         };
-        intravisit::walk_expr(&mut visitor, expr);
+        intravisit::walk_stmt(&mut visitor, stmt);
         visitor.spans
       }
-    };
-
-    let mut outer_spans = span.subtract(inner_spans.clone());
-
-    // In an expression `match e { .. }` the span of `e` is only stored in a `FakeRead`,
-    // so we have to ensure that the span of the HIR match includes the matched expression.
-    if let ExprKind::Match(matched, _, _) = expr.kind {
-      outer_spans.push(matched.span);
-    }
-
-    trace!(
-      "Expr:\n{}\nhas span: {:?}\nand inner spans: {:?}\nand outer spans: {:?}",
-      expr_to_string(expr),
-      span,
-      inner_spans,
-      outer_spans
-    );
-
-    if outer_spans.is_empty() {
-      return;
-    }
-
-    self.0.hir_spans.push(HirSpannedNode {
-      full: span.data(),
-      outer: outer_spans,
-      node: Node::Expr(expr),
-    });
-  }
-
-  fn visit_stmt(&mut self, stmt: &'hir Stmt<'hir>) {
-    intravisit::walk_stmt(self, stmt);
-
-    let span = try_span!(self, stmt.span);
-
-    let mut visitor = ChildExprSpans {
-      spans: Vec::new(),
-      item_span: self.0.item_span,
-    };
-    intravisit::walk_stmt(&mut visitor, stmt);
-    let outer_spans = span.subtract(visitor.spans);
-
-    self.0.hir_spans.push(HirSpannedNode {
-      full: span.data(),
-      outer: outer_spans,
-      node: Node::Stmt(stmt),
-    });
-  }
-
-  fn visit_param(&mut self, param: &'hir Param<'hir>) {
-    intravisit::walk_param(self, param);
-
-    let span = match param.span.as_local(self.0.item_span) {
-      Some(span) if !self.0.invalid_span(span) => span,
+      Node::Param(_param) => vec![],
       _ => {
-        return;
+        return None;
       }
     };
 
-    // TODO: more precise outer spans
-    self.0.hir_spans.push(HirSpannedNode {
-      full: span.data(),
-      outer: vec![span],
-      node: Node::Param(param),
-    });
+    Some(match mode {
+      EnclosingHirSpans::Full => vec![span],
+      EnclosingHirSpans::OuterOnly => span.subtract(inner_spans),
+      EnclosingHirSpans::None => vec![],
+    })
   }
 }

crates/flowistry/src/source_map/mir_span.rs

@@ -25,10 +25,7 @@ pub struct MirSpannedPlace<'tcx> {
   pub locations: SmallVec<[LocationOrArg; 1]>,
 }
 
-pub struct MirSpanCollector<'a, 'hir, 'tcx>(
-  pub &'a mut Spanner<'hir, 'tcx>,
-  pub &'a Body<'tcx>,
-);
+pub struct MirSpanCollector<'a, 'tcx>(pub &'a mut Spanner<'tcx>, pub &'a Body<'tcx>);
 
 macro_rules! try_span {
   ($self:expr, $span:expr) => {
@@ -41,7 +38,7 @@ macro_rules! try_span {
   };
 }
 
-impl<'tcx> MirVisitor<'tcx> for MirSpanCollector<'_, '_, 'tcx> {
+impl<'tcx> MirVisitor<'tcx> for MirSpanCollector<'_, 'tcx> {
   fn visit_body(&mut self, body: &Body<'tcx>) {
     self.super_body(body);