privacy: Make "greater than" the new base operation for comparing visibilities

Author: petrochenkov

compiler/rustc_middle/src/middle/privacy.rs

@@ -84,7 +84,7 @@ impl EffectiveVisibility {
             let lhs_vis = *lhs.at_level(l);
             // FIXME: figure out why unordered visibilities occur here,
             // and what the behavior for them should be.
-            if rhs_vis.is_at_least_ext(lhs_vis, tcx, false) {
+            if rhs_vis.greater_than_ext(lhs_vis, tcx, false) {
                 *rhs_vis = lhs_vis;
             };
         }
@@ -254,13 +254,11 @@ impl<Id: Eq + Hash> EffectiveVisibilities<Id> {
                 // same id
                 // FIXME: figure out why unordered visibilities occur here,
                 // and what the behavior for them should be.
-                if *current_effective_vis_at_level != calculated_effective_vis
-                    && calculated_effective_vis.is_at_least_ext(
-                        *current_effective_vis_at_level,
-                        tcx,
-                        false,
-                    )
-                {
+                if calculated_effective_vis.greater_than_ext(
+                    *current_effective_vis_at_level,
+                    tcx,
+                    false,
+                ) {
                     changed = true;
                     *current_effective_vis_at_level = calculated_effective_vis;
                 }

compiler/rustc_middle/src/ty/mod.rs

@@ -375,33 +375,32 @@ impl<Id: Into<DefId>> Visibility<Id> {
         }
     }
 
-    /// Returns `true` if this visibility is at least as accessible as the given visibility
+    /// Returns `true` if this visibility is strictly larger than the given visibility.
     #[track_caller]
-    pub fn is_at_least_ext(
+    pub fn greater_than_ext(
         self,
         vis: Visibility<impl Into<DefId>>,
         tcx: TyCtxt<'_>,
         assert_ordered: bool,
     ) -> bool {
         match (self, vis) {
-            (Visibility::Public, _) => true,
             (_, Visibility::Public) => false,
+            (Visibility::Public, _) => true,
             (Visibility::Restricted(lhs_id), Visibility::Restricted(rhs_id)) => {
                 let lhs_id = lhs_id.into();
                 let rhs_id = rhs_id.into();
-                let ge = tcx.is_descendant_of(rhs_id, lhs_id);
-                if !ge && assert_ordered && !tcx.is_descendant_of(lhs_id, rhs_id) {
+                let gt = lhs_id != rhs_id && tcx.is_descendant_of(rhs_id, lhs_id);
+                if !gt && assert_ordered && !tcx.is_descendant_of(lhs_id, rhs_id) {
                     bug!("unordered visibilities: {lhs_id:?} and {rhs_id:?}");
                 }
-                ge
+                gt
             }
         }
     }
 
     #[track_caller]
     pub fn greater_than(self, vis: Visibility<impl Into<DefId>>, tcx: TyCtxt<'_>) -> bool {
-        let (lhs, rhs) = (self.to_def_id(), vis.to_def_id());
-        lhs != rhs && lhs.is_at_least_ext(rhs, tcx, true)
+        self.greater_than_ext(vis, tcx, true)
     }
 }
 

compiler/rustc_resolve/src/imports.rs

@@ -369,7 +369,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         let import_vis = import.vis.to_def_id();
         // FIXME: figure out why unordered visibilities occur here,
         // and what the behavior for them should be.
-        let vis = if decl.vis().is_at_least_ext(import_vis, self.tcx, false)
+        let vis = if decl.vis().greater_than_ext(import_vis, self.tcx, false)
             || pub_use_of_private_extern_crate_hack(import, decl).is_some()
         {
             import_vis