safe transmute: revise safety analysis

Migrate to a simplified safety analysis that does not use visibility.

Closes https://github.com/rust-lang/project-safe-transmute/issues/15

compiler/rustc_transmute/src/maybe_transmutable/query_context.rs

@@ -6,9 +6,6 @@ pub(crate) trait QueryContext {
     type Ref: layout::Ref;
     type Scope: Copy;
 
-    /// Is `def` accessible from the defining module of `scope`?
-    fn is_accessible_from(&self, def: Self::Def, scope: Self::Scope) -> bool;
-
     fn min_align(&self, reference: Self::Ref) -> usize;
 }
 
@@ -20,21 +17,21 @@ pub(crate) mod test {
 
     #[derive(Debug, Hash, Eq, PartialEq, Clone, Copy)]
     pub(crate) enum Def {
-        Visible,
-        Invisible,
+        HasSafetyInvariants,
+        NoSafetyInvariants,
     }
 
-    impl crate::layout::Def for Def {}
+    impl crate::layout::Def for Def {
+        fn has_safety_invariants(&self) -> bool {
+            self == &Self::HasSafetyInvariants
+        }
+    }
 
     impl QueryContext for UltraMinimal {
         type Def = Def;
         type Ref = !;
         type Scope = ();
 
-        fn is_accessible_from(&self, def: Def, scope: ()) -> bool {
-            matches!(Def::Visible, def)
-        }
-
         fn min_align(&self, reference: !) -> usize {
             unimplemented!()
         }
@@ -52,34 +49,6 @@ mod rustc {
 
         type Scope = Ty<'tcx>;
 
-        #[instrument(level = "debug", skip(self))]
-        fn is_accessible_from(&self, def: Self::Def, scope: Self::Scope) -> bool {
-            use layout::rustc::Def;
-            use rustc_middle::ty;
-
-            let parent = if let ty::Adt(adt_def, ..) = scope.kind() {
-                self.parent(adt_def.did())
-            } else {
-                // Is this always how we want to handle a non-ADT scope?
-                return false;
-            };
-
-            let def_id = match def {
-                Def::Adt(adt_def) => adt_def.did(),
-                Def::Variant(variant_def) => variant_def.def_id,
-                Def::Field(field_def) => field_def.did,
-                Def::Primitive => {
-                    // primitives do not have a def_id, but they're always accessible
-                    return true;
-                }
-            };
-
-            let ret: bool = self.visibility(def_id).is_accessible_from(parent, *self);
-
-            trace!(?ret, "ret");
-            ret
-        }
-
         fn min_align(&self, reference: Self::Ref) -> usize {
             unimplemented!()
         }