rustc_transmute cleanups

compiler/rustc_transmute/src/lib.rs

@@ -9,7 +9,7 @@ extern crate tracing;
 pub(crate) use rustc_data_structures::fx::{FxIndexMap as Map, FxIndexSet as Set};
 
 pub mod layout;
-pub(crate) mod maybe_transmutable;
+mod maybe_transmutable;
 
 #[derive(Default)]
 pub struct Assume {
@@ -19,7 +19,7 @@ pub struct Assume {
  pub validity: bool,
 }
 
-/// Either we have an error, transmutation is allowed, or we have an optional
+/// Either transmutation is allowed, we have an error, or we have an optional
 /// Condition that must hold.
 #[derive(Debug, Hash, Eq, PartialEq, Clone)]
 pub enum Answer<R> {

compiler/rustc_transmute/src/maybe_transmutable/mod.rs

@@ -32,26 +32,6 @@ where
  ) -> Self {
  Self { src, dst, scope, assume, context }
  }
-
- // FIXME(bryangarza): Delete this when all usages are removed
- pub(crate) fn map_layouts<F, M>(
- self,
- f: F,
- ) -> Result<MaybeTransmutableQuery<M, C>, Answer<<C as QueryContext>::Ref>>
- where
- F: FnOnce(
- L,
- L,
- <C as QueryContext>::Scope,
- &C,
- ) -> Result<(M, M), Answer<<C as QueryContext>::Ref>>,
- {
- let Self { src, dst, scope, assume, context } = self;
-
- let (src, dst) = f(src, dst, scope, &context)?;
-
- Ok(MaybeTransmutableQuery { src, dst, scope, assume, context })
- }
 }
 
 // FIXME: Nix this cfg, so we can write unit tests independently of rustc
@@ -107,42 +87,42 @@ where
  #[instrument(level = "debug", skip(self), fields(src = ?self.src, dst = ?self.dst))]
  pub(crate) fn answer(self) -> Answer<<C as QueryContext>::Ref> {
  let assume_visibility = self.assume.safety;
- // FIXME(bryangarza): Refactor this code to get rid of `map_layouts`
- let query_or_answer = self.map_layouts(|src, dst, scope, context| {
- // Remove all `Def` nodes from `src`, without checking their visibility.
- let src = src.prune(&|def| true);
 
-  trace!(?src, "pruned src");
+ let Self { src, dst, scope, assume, context } = self;
 
- // Remove all `Def` nodes from `dst`, additionally...
- let dst = if assume_visibility {
- // ...if visibility is assumed, don't check their visibility.
- dst.prune(&|def| true)
- } else {
- // ...otherwise, prune away all unreachable paths through the `Dst` layout.
- dst.prune(&|def| context.is_accessible_from(def, scope))
- };
+ // Remove all `Def` nodes from `src`, without checking their visibility.
+ let src = src.prune(&|def| true);
 
-  trace!(?dst, "pruned dst");
+ trace!(?src, "pruned src");
 
- // Convert `src` from a tree-based representation to an NFA-based representation.
- // If the conversion fails because `src` is uninhabited, conclude that the transmutation
- // is acceptable, because instances of the `src` type do not exist.
- let src = Nfa::from_tree(src).map_err(|Uninhabited| Answer::Yes)?;
+ // Remove all `Def` nodes from `dst`, additionally...
+ let dst = if assume_visibility {
+ // ...if visibility is assumed, don't check their visibility.
+ dst.prune(&|def| true)
+ } else {
+ // ...otherwise, prune away all unreachable paths through the `Dst` layout.
+ dst.prune(&|def| context.is_accessible_from(def, scope))
+ };
 
- // Convert `dst` from a tree-based representation to an NFA-based representation.
- // If the conversion fails because `src` is uninhabited, conclude that the transmutation
- // is unacceptable, because instances of the `dst` type do not exist.
- let dst =
- Nfa::from_tree(dst).map_err(|Uninhabited| Answer::No(Reason::DstIsPrivate))?;
+ trace!(?dst, "pruned dst");
 
- Ok((src, dst))
- });
+ // Convert `src` from a tree-based representation to an NFA-based representation.
+ // If the conversion fails because `src` is uninhabited, conclude that the transmutation
+ // is acceptable, because instances of the `src` type do not exist.
+ let src = match Nfa::from_tree(src) {
+ Ok(src) => src,
+ Err(Uninhabited) => return Answer::Yes,
+ };
 
- match query_or_answer {
- Ok(query) => query.answer(),
- Err(answer) => answer,
- }
+ // Convert `dst` from a tree-based representation to an NFA-based representation.
+ // If the conversion fails because `src` is uninhabited, conclude that the transmutation
+ // is unacceptable, because instances of the `dst` type do not exist.
+ let dst = match Nfa::from_tree(dst) {
+ Ok(dst) => dst,
+ Err(Uninhabited) => return Answer::No(Reason::DstIsPrivate),
+ };
+
+ MaybeTransmutableQuery { src, dst, scope, assume, context }.answer()
  }
 }
 
@@ -156,41 +136,19 @@ where
  #[inline(always)]
  #[instrument(level = "debug", skip(self), fields(src = ?self.src, dst = ?self.dst))]
  pub(crate) fn answer(self) -> Answer<<C as QueryContext>::Ref> {
- // FIXME(bryangarza): Refactor this code to get rid of `map_layouts`
- let query_or_answer = self
- .map_layouts(|src, dst, scope, context| Ok((Dfa::from_nfa(src), Dfa::from_nfa(dst))));
-
- match query_or_answer {
- Ok(query) => query.answer(),
- Err(answer) => answer,
- }
+ let Self { src, dst, scope, assume, context } = self;
+ let src = Dfa::from_nfa(src);
+ let dst = Dfa::from_nfa(dst);
+ MaybeTransmutableQuery { src, dst, scope, assume, context }.answer()
  }
 }
 
 impl<C> MaybeTransmutableQuery<Dfa<<C as QueryContext>::Ref>, C>
 where
  C: QueryContext,
 {
- /// Answers whether a `Nfa` is transmutable into another `Nfa`.
- ///
- /// This method converts `src` and `dst` to DFAs, then computes an answer using those DFAs.
+ /// Answers whether a `Dfa` is transmutable into another `Dfa`.
  pub(crate) fn answer(self) -> Answer<<C as QueryContext>::Ref> {
- MaybeTransmutableQuery {
- src: &self.src,
- dst: &self.dst,
- scope: self.scope,
- assume: self.assume,
- context: self.context,
- }
- .answer()
- }
-}
-
-impl<'l, C> MaybeTransmutableQuery<&'l Dfa<<C as QueryContext>::Ref>, C>
-where
- C: QueryContext,
-{
- pub(crate) fn answer(&mut self) -> Answer<<C as QueryContext>::Ref> {
  self.answer_memo(&mut Map::default(), self.src.start, self.dst.start)
  }