Make AsMut unambiguous

src/compat.rs

@@ -277,6 +277,14 @@ impl Compatibility {
     }
 }
 
+pub(crate) mod private {
+    use crate::CompatLevel;
+
+    pub trait OptionCompatLevelMut {
+        fn as_option_compat_level_mut(&mut self) -> &mut Option<CompatLevel>;
+    }
+}
+
 /// Properly handles runtime unsupported features.
 ///
 /// This guarantees consistent behaviors across crate users
@@ -292,7 +300,7 @@ impl Compatibility {
 /// (e.g. applications carefully designed to only be run with a specific set of kernel features),
 /// it may be required to error out if some of these features are not available
 /// and will then not be enforced.
-pub trait Compatible: Sized + AsMut<Option<CompatLevel>> {
+pub trait Compatible: Sized + private::OptionCompatLevelMut {
     /// To enable a best-effort security approach,
     /// Landlock features that are not supported by the running system
     /// are silently ignored by default,
@@ -396,7 +404,7 @@ pub trait Compatible: Sized + AsMut<Option<CompatLevel>> {
     /// }
     /// ```
     fn set_compatibility(mut self, level: CompatLevel) -> Self {
-        *self.as_mut() = Some(level);
+        *self.as_option_compat_level_mut() = Some(level);
         self
     }
 
@@ -491,7 +499,7 @@ where
         // Using a mutable reference is not required but it makes the code simpler (no double AsRef
         // implementations for each Compatible types), and more importantly it guarantees
         // consistency with Compatible::set_compatibility().
-        match self.as_mut() {
+        match self.as_option_compat_level_mut() {
             None => parent_level.into(),
             // Returns the most constrained compatibility level.
             Some(ref level) => parent_level.into().max(*level),

src/fs.rs

@@ -1,3 +1,4 @@
+use crate::compat::private::OptionCompatLevelMut;
 use crate::{
     uapi, Access, AddRuleError, AddRulesError, CompatError, CompatLevel, CompatResult, CompatState,
     Compatible, HandleAccessError, HandleAccessesError, PathBeneathError, PathFdError,
@@ -338,8 +339,14 @@ fn path_beneath_try_compat() {
     }
 }
 
-impl<F> AsMut<Option<CompatLevel>> for PathBeneath<F> {
-    fn as_mut(&mut self) -> &mut Option<CompatLevel> {
+impl<F> OptionCompatLevelMut for PathBeneath<F> {
+    fn as_option_compat_level_mut(&mut self) -> &mut Option<CompatLevel> {
+        &mut self.compat_level
+    }
+}
+
+impl<F> OptionCompatLevelMut for &mut PathBeneath<F> {
+    fn as_option_compat_level_mut(&mut self) -> &mut Option<CompatLevel> {
         &mut self.compat_level
     }
 }
@@ -353,15 +360,18 @@ fn path_beneath_compatibility() {
     let mut path = PathBeneath::new(PathFd::new("/").unwrap(), AccessFs::from_all(ABI::V1));
     let path_ref = &mut path;
 
-    let level = path_ref.as_mut();
+    let level = path_ref.as_option_compat_level_mut();
     assert_eq!(level, &None);
     assert_eq!(
         <Option<CompatLevel> as Into<CompatLevel>>::into(*level),
         CompatLevel::BestEffort
     );
 
     path_ref.set_compatibility(CompatLevel::SoftRequirement);
-    assert_eq!(path_ref.as_mut(), &Some(CompatLevel::SoftRequirement));
+    assert_eq!(
+        path_ref.as_option_compat_level_mut(),
+        &Some(CompatLevel::SoftRequirement)
+    );
 
     path.set_compatibility(CompatLevel::HardRequirement);
 }

src/ruleset.rs

@@ -1,3 +1,4 @@
+use crate::compat::private::OptionCompatLevelMut;
 use crate::{
     uapi, Access, AccessFs, AddRuleError, AddRulesError, BitFlags, CompatLevel, CompatState,
     Compatibility, Compatible, CreateRulesetError, RestrictSelfError, RulesetError, TryCompat,
@@ -284,8 +285,14 @@ impl Ruleset {
     }
 }
 
-impl AsMut<Option<CompatLevel>> for Ruleset {
-    fn as_mut(&mut self) -> &mut Option<CompatLevel> {
+impl OptionCompatLevelMut for Ruleset {
+    fn as_option_compat_level_mut(&mut self) -> &mut Option<CompatLevel> {
+        &mut self.compat.level
+    }
+}
+
+impl OptionCompatLevelMut for &mut Ruleset {
+    fn as_option_compat_level_mut(&mut self) -> &mut Option<CompatLevel> {
         &mut self.compat.level
     }
 }
@@ -300,6 +307,20 @@ impl AsMut<Ruleset> for Ruleset {
     }
 }
 
+// Tests unambiguous type.
+#[test]
+fn ruleset_as_mut() {
+    let mut ruleset = Ruleset::from(ABI::Unsupported);
+    let _ = ruleset.as_mut();
+
+    let mut ruleset_created = Ruleset::from(ABI::Unsupported)
+        .handle_access(AccessFs::Execute)
+        .unwrap()
+        .create()
+        .unwrap();
+    let _ = ruleset_created.as_mut();
+}
+
 pub trait RulesetAttr: Sized + AsMut<Ruleset> + Compatible {
     /// Attempts to add a set of access rights that will be supported by this ruleset.
     /// By default, all actions requiring these access rights will be denied.
@@ -372,8 +393,14 @@ fn ruleset_created_handle_access_or() {
     ));
 }
 
-impl AsMut<Option<CompatLevel>> for RulesetCreated {
-    fn as_mut(&mut self) -> &mut Option<CompatLevel> {
+impl OptionCompatLevelMut for RulesetCreated {
+    fn as_option_compat_level_mut(&mut self) -> &mut Option<CompatLevel> {
+        &mut self.compat.level
+    }
+}
+
+impl OptionCompatLevelMut for &mut RulesetCreated {
+    fn as_option_compat_level_mut(&mut self) -> &mut Option<CompatLevel> {
         &mut self.compat.level
     }
 }