refactor(path): delegate implementations where possible

Stebalien · Stebalien · commit 7c16f4e379fc · 2025-09-24T13:47:18.000-07:00
diff --git a/src/path/arg.rs b/src/path/arg.rs
@@ -243,19 +243,15 @@ impl Arg for &OsStr {
 
     #[inline]
     fn as_cow_c_str(&self) -> io::Result<Cow<'_, CStr>> {
-        Ok(Cow::Owned(
-            CString::new(self.as_bytes()).map_err(|_cstr_err| io::Errno::INVAL)?,
-        ))
+        self.into_c_str()
     }
 
     #[inline]
     fn into_c_str<'b>(self) -> io::Result<Cow<'b, CStr>>
     where
         Self: 'b,
     {
-        Ok(Cow::Owned(
-            CString::new(self.as_bytes()).map_err(|_cstr_err| io::Errno::INVAL)?,
-        ))
+        return self.as_bytes().into_c_str();
     }
 
     #[inline]
@@ -264,7 +260,7 @@ impl Arg for &OsStr {
         Self: Sized,
         F: FnOnce(&CStr) -> io::Result<T>,
     {
-        with_c_str(self.as_bytes(), f)
+        return self.as_bytes().into_with_c_str(f);
     }
 }
 
@@ -283,10 +279,7 @@ impl Arg for &OsString {
 
     #[inline]
     fn as_cow_c_str(&self) -> io::Result<Cow<'_, CStr>> {
-        Ok(Cow::Owned(
-            CString::new(OsString::as_os_str(self).as_bytes())
-                .map_err(|_cstr_err| io::Errno::INVAL)?,
-        ))
+        self.as_os_str().into_c_str()
     }
 
     #[inline]
@@ -303,12 +296,11 @@ impl Arg for &OsString {
         Self: Sized,
         F: FnOnce(&CStr) -> io::Result<T>,
     {
-        with_c_str(self.as_bytes(), f)
+        self.as_os_str().into_with_c_str(f)
     }
 }
 
 #[cfg(feature = "std")]
-#[cfg(any(not(target_os = "wasi"), not(target_env = "p2"), wasip2))]
 impl Arg for OsString {
     #[inline]
     fn as_str(&self) -> io::Result<&str> {
@@ -322,19 +314,15 @@ impl Arg for OsString {
 
     #[inline]
     fn as_cow_c_str(&self) -> io::Result<Cow<'_, CStr>> {
-        Ok(Cow::Owned(
-            CString::new(self.as_bytes()).map_err(|_cstr_err| io::Errno::INVAL)?,
-        ))
+        self.as_os_str().into_c_str()
     }
 
     #[inline]
     fn into_c_str<'b>(self) -> io::Result<Cow<'b, CStr>>
     where
         Self: 'b,
     {
-        Ok(Cow::Owned(
-            CString::new(self.into_vec()).map_err(|_cstr_err| io::Errno::INVAL)?,
-        ))
+        self.into_vec().into_c_str()
     }
 
     #[inline]
@@ -343,12 +331,11 @@ impl Arg for OsString {
         Self: Sized,
         F: FnOnce(&CStr) -> io::Result<T>,
     {
-        f(&CString::new(self.into_vec()).map_err(|_cstr_err| io::Errno::INVAL)?)
+        f(&self.into_c_str()?)
     }
 }
 
 #[cfg(feature = "std")]
-#[cfg(any(not(target_os = "wasi"), not(target_env = "p2"), wasip2))]
 impl Arg for &Path {
     #[inline]
     fn as_str(&self) -> io::Result<&str> {
@@ -362,19 +349,15 @@ impl Arg for &Path {
 
     #[inline]
     fn as_cow_c_str(&self) -> io::Result<Cow<'_, CStr>> {
-        Ok(Cow::Owned(
-            CString::new(self.as_os_str().as_bytes()).map_err(|_cstr_err| io::Errno::INVAL)?,
-        ))
+        self.as_os_str().into_c_str()
     }
 
     #[inline]
     fn into_c_str<'b>(self) -> io::Result<Cow<'b, CStr>>
     where
         Self: 'b,
     {
-        Ok(Cow::Owned(
-            CString::new(self.as_os_str().as_bytes()).map_err(|_cstr_err| io::Errno::INVAL)?,
-        ))
+        self.as_os_str().into_c_str()
     }
 
     #[inline]
@@ -383,19 +366,15 @@ impl Arg for &Path {
         Self: Sized,
         F: FnOnce(&CStr) -> io::Result<T>,
     {
-        with_c_str(self.as_os_str().as_bytes(), f)
+        self.as_os_str().into_with_c_str(f)
     }
 }
 
 #[cfg(feature = "std")]
-#[cfg(any(not(target_os = "wasi"), not(target_env = "p2"), wasip2))]
 impl Arg for &PathBuf {
     #[inline]
     fn as_str(&self) -> io::Result<&str> {
-        PathBuf::as_path(self)
-            .as_os_str()
-            .to_str()
-            .ok_or(io::Errno::INVAL)
+        self.as_os_str().to_str().ok_or(io::Errno::INVAL)
     }
 
     #[inline]
@@ -405,10 +384,7 @@ impl Arg for &PathBuf {
 
     #[inline]
     fn as_cow_c_str(&self) -> io::Result<Cow<'_, CStr>> {
-        Ok(Cow::Owned(
-            CString::new(PathBuf::as_path(self).as_os_str().as_bytes())
-                .map_err(|_cstr_err| io::Errno::INVAL)?,
-        ))
+        self.as_os_str().into_c_str()
     }
 
     #[inline]
@@ -425,12 +401,11 @@ impl Arg for &PathBuf {
         Self: Sized,
         F: FnOnce(&CStr) -> io::Result<T>,
     {
-        with_c_str(self.as_os_str().as_bytes(), f)
+        self.as_os_str().into_with_c_str(f)
     }
 }
 
 #[cfg(feature = "std")]
-#[cfg(any(not(target_os = "wasi"), not(target_env = "p2"), wasip2))]
 impl Arg for PathBuf {
     #[inline]
     fn as_str(&self) -> io::Result<&str> {
@@ -444,19 +419,15 @@ impl Arg for PathBuf {
 
     #[inline]
     fn as_cow_c_str(&self) -> io::Result<Cow<'_, CStr>> {
-        Ok(Cow::Owned(
-            CString::new(self.as_os_str().as_bytes()).map_err(|_cstr_err| io::Errno::INVAL)?,
-        ))
+        self.as_os_str().into_c_str()
     }
 
     #[inline]
     fn into_c_str<'b>(self) -> io::Result<Cow<'b, CStr>>
     where
         Self: 'b,
     {
-        Ok(Cow::Owned(
-            CString::new(self.into_os_string().into_vec()).map_err(|_cstr_err| io::Errno::INVAL)?,
-        ))
+        self.into_os_string().into_c_str()
     }
 
     #[inline]
@@ -465,10 +436,7 @@ impl Arg for PathBuf {
         Self: Sized,
         F: FnOnce(&CStr) -> io::Result<T>,
     {
-        f(
-            &CString::new(self.into_os_string().into_vec())
-                .map_err(|_cstr_err| io::Errno::INVAL)?,
-        )
+        self.into_os_string().into_with_c_str(f)
     }
 }
 
@@ -637,23 +605,18 @@ impl<'a> Arg for Cow<'a, OsStr> {
 
     #[inline]
     fn as_cow_c_str(&self) -> io::Result<Cow<'_, CStr>> {
-        Ok(Cow::Owned(
-            CString::new(self.as_bytes()).map_err(|_cstr_err| io::Errno::INVAL)?,
-        ))
+        (&**self).into_c_str()
     }
 
     #[inline]
     fn into_c_str<'b>(self) -> io::Result<Cow<'b, CStr>>
     where
         Self: 'b,
     {
-        Ok(Cow::Owned(
-            match self {
-                Cow::Owned(os) => CString::new(os.into_vec()),
-                Cow::Borrowed(os) => CString::new(os.as_bytes()),
-            }
-            .map_err(|_cstr_err| io::Errno::INVAL)?,
-        ))
+        match self {
+            Cow::Owned(os) => os.into_c_str(),
+            Cow::Borrowed(os) => os.into_c_str(),
+        }
     }
 
     #[inline]
@@ -662,7 +625,7 @@ impl<'a> Arg for Cow<'a, OsStr> {
         Self: Sized,
         F: FnOnce(&CStr) -> io::Result<T>,
     {
-        with_c_str(self.as_bytes(), f)
+        (&*self).into_with_c_str(f)
     }
 }
 
@@ -717,19 +680,15 @@ impl<'a> Arg for Component<'a> {
 
     #[inline]
     fn as_cow_c_str(&self) -> io::Result<Cow<'_, CStr>> {
-        Ok(Cow::Owned(
-            CString::new(self.as_os_str().as_bytes()).map_err(|_cstr_err| io::Errno::INVAL)?,
-        ))
+        self.as_os_str().into_c_str()
     }
 
     #[inline]
     fn into_c_str<'b>(self) -> io::Result<Cow<'b, CStr>>
     where
         Self: 'b,
     {
-        Ok(Cow::Owned(
-            CString::new(self.as_os_str().as_bytes()).map_err(|_cstr_err| io::Errno::INVAL)?,
-        ))
+        self.as_os_str().into_c_str()
     }
 
     #[inline]
@@ -738,12 +697,11 @@ impl<'a> Arg for Component<'a> {
         Self: Sized,
         F: FnOnce(&CStr) -> io::Result<T>,
     {
-        with_c_str(self.as_os_str().as_bytes(), f)
+        self.as_os_str().into_with_c_str(f)
     }
 }
 
 #[cfg(feature = "std")]
-#[cfg(any(not(target_os = "wasi"), not(target_env = "p2"), wasip2))]
 impl<'a> Arg for Components<'a> {
     #[inline]
     fn as_str(&self) -> io::Result<&str> {
@@ -757,21 +715,15 @@ impl<'a> Arg for Components<'a> {
 
     #[inline]
     fn as_cow_c_str(&self) -> io::Result<Cow<'_, CStr>> {
-        Ok(Cow::Owned(
-            CString::new(self.as_path().as_os_str().as_bytes())
-                .map_err(|_cstr_err| io::Errno::INVAL)?,
-        ))
+        self.as_path().into_c_str()
     }
 
     #[inline]
     fn into_c_str<'b>(self) -> io::Result<Cow<'b, CStr>>
     where
         Self: 'b,
     {
-        Ok(Cow::Owned(
-            CString::new(self.as_path().as_os_str().as_bytes())
-                .map_err(|_cstr_err| io::Errno::INVAL)?,
-        ))
+        self.as_path().into_c_str()
     }
 
     #[inline]
@@ -780,12 +732,11 @@ impl<'a> Arg for Components<'a> {
         Self: Sized,
         F: FnOnce(&CStr) -> io::Result<T>,
     {
-        with_c_str(self.as_path().as_os_str().as_bytes(), f)
+        self.as_path().into_with_c_str(f)
     }
 }
 
 #[cfg(feature = "std")]
-#[cfg(any(not(target_os = "wasi"), not(target_env = "p2"), wasip2))]
 impl<'a> Arg for Iter<'a> {
     #[inline]
     fn as_str(&self) -> io::Result<&str> {
@@ -799,21 +750,15 @@ impl<'a> Arg for Iter<'a> {
 
     #[inline]
     fn as_cow_c_str(&self) -> io::Result<Cow<'_, CStr>> {
-        Ok(Cow::Owned(
-            CString::new(self.as_path().as_os_str().as_bytes())
-                .map_err(|_cstr_err| io::Errno::INVAL)?,
-        ))
+        self.as_path().into_c_str()
     }
 
     #[inline]
     fn into_c_str<'b>(self) -> io::Result<Cow<'b, CStr>>
     where
         Self: 'b,
     {
-        Ok(Cow::Owned(
-            CString::new(self.as_path().as_os_str().as_bytes())
-                .map_err(|_cstr_err| io::Errno::INVAL)?,
-        ))
+        self.as_path().into_c_str()
     }
 
     #[inline]
@@ -822,7 +767,7 @@ impl<'a> Arg for Iter<'a> {
         Self: Sized,
         F: FnOnce(&CStr) -> io::Result<T>,
     {
-        with_c_str(self.as_path().as_os_str().as_bytes(), f)
+        self.as_path().into_with_c_str(f)
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -243,19 +243,15 @@ impl Arg for &OsStr {`
`243`	`243`
`244`	`244`	`#[inline]`
`245`	`245`	`fn as_cow_c_str(&self) -> io::Result<Cow<'_, CStr>> {`
`246`		`- Ok(Cow::Owned(`
`247`		`- CString::new(self.as_bytes()).map_err(\|_cstr_err\| io::Errno::INVAL)?,`
`248`		`- ))`
	`246`	`+ self.into_c_str()`
`249`	`247`	`}`
`250`	`248`
`251`	`249`	`#[inline]`
`252`	`250`	`fn into_c_str<'b>(self) -> io::Result<Cow<'b, CStr>>`
`253`	`251`	`where`
`254`	`252`	`Self: 'b,`
`255`	`253`	`{`
`256`		`- Ok(Cow::Owned(`
`257`		`- CString::new(self.as_bytes()).map_err(\|_cstr_err\| io::Errno::INVAL)?,`
`258`		`- ))`
	`254`	`+ return self.as_bytes().into_c_str();`
`259`	`255`	`}`
`260`	`256`
`261`	`257`	`#[inline]`
`@@ -264,7 +260,7 @@ impl Arg for &OsStr {`
`264`	`260`	`Self: Sized,`
`265`	`261`	`F: FnOnce(&CStr) -> io::Result<T>,`
`266`	`262`	`{`
`267`		`- with_c_str(self.as_bytes(), f)`
	`263`	`+ return self.as_bytes().into_with_c_str(f);`
`268`	`264`	`}`
`269`	`265`	`}`
`270`	`266`
`@@ -283,10 +279,7 @@ impl Arg for &OsString {`
`283`	`279`
`284`	`280`	`#[inline]`
`285`	`281`	`fn as_cow_c_str(&self) -> io::Result<Cow<'_, CStr>> {`
`286`		`- Ok(Cow::Owned(`
`287`		`- CString::new(OsString::as_os_str(self).as_bytes())`
`288`		`- .map_err(\|_cstr_err\| io::Errno::INVAL)?,`
`289`		`- ))`
	`282`	`+ self.as_os_str().into_c_str()`
`290`	`283`	`}`
`291`	`284`
`292`	`285`	`#[inline]`
`@@ -303,12 +296,11 @@ impl Arg for &OsString {`
`303`	`296`	`Self: Sized,`
`304`	`297`	`F: FnOnce(&CStr) -> io::Result<T>,`
`305`	`298`	`{`
`306`		`- with_c_str(self.as_bytes(), f)`
	`299`	`+ self.as_os_str().into_with_c_str(f)`
`307`	`300`	`}`
`308`	`301`	`}`
`309`	`302`
`310`	`303`	`#[cfg(feature = "std")]`
`311`		`-#[cfg(any(not(target_os = "wasi"), not(target_env = "p2"), wasip2))]`
`312`	`304`	`impl Arg for OsString {`
`313`	`305`	`#[inline]`
`314`	`306`	`fn as_str(&self) -> io::Result<&str> {`
`@@ -322,19 +314,15 @@ impl Arg for OsString {`
`322`	`314`
`323`	`315`	`#[inline]`
`324`	`316`	`fn as_cow_c_str(&self) -> io::Result<Cow<'_, CStr>> {`
`325`		`- Ok(Cow::Owned(`
`326`		`- CString::new(self.as_bytes()).map_err(\|_cstr_err\| io::Errno::INVAL)?,`
`327`		`- ))`
	`317`	`+ self.as_os_str().into_c_str()`
`328`	`318`	`}`
`329`	`319`
`330`	`320`	`#[inline]`
`331`	`321`	`fn into_c_str<'b>(self) -> io::Result<Cow<'b, CStr>>`
`332`	`322`	`where`
`333`	`323`	`Self: 'b,`
`334`	`324`	`{`
`335`		`- Ok(Cow::Owned(`
`336`		`- CString::new(self.into_vec()).map_err(\|_cstr_err\| io::Errno::INVAL)?,`
`337`		`- ))`
	`325`	`+ self.into_vec().into_c_str()`
`338`	`326`	`}`
`339`	`327`
`340`	`328`	`#[inline]`
`@@ -343,12 +331,11 @@ impl Arg for OsString {`
`343`	`331`	`Self: Sized,`
`344`	`332`	`F: FnOnce(&CStr) -> io::Result<T>,`
`345`	`333`	`{`
`346`		`- f(&CString::new(self.into_vec()).map_err(\|_cstr_err\| io::Errno::INVAL)?)`
	`334`	`+ f(&self.into_c_str()?)`
`347`	`335`	`}`
`348`	`336`	`}`
`349`	`337`
`350`	`338`	`#[cfg(feature = "std")]`
`351`		`-#[cfg(any(not(target_os = "wasi"), not(target_env = "p2"), wasip2))]`
`352`	`339`	`impl Arg for &Path {`
`353`	`340`	`#[inline]`
`354`	`341`	`fn as_str(&self) -> io::Result<&str> {`
`@@ -362,19 +349,15 @@ impl Arg for &Path {`
`362`	`349`
`363`	`350`	`#[inline]`
`364`	`351`	`fn as_cow_c_str(&self) -> io::Result<Cow<'_, CStr>> {`
`365`		`- Ok(Cow::Owned(`
`366`		`- CString::new(self.as_os_str().as_bytes()).map_err(\|_cstr_err\| io::Errno::INVAL)?,`
`367`		`- ))`
	`352`	`+ self.as_os_str().into_c_str()`
`368`	`353`	`}`
`369`	`354`
`370`	`355`	`#[inline]`
`371`	`356`	`fn into_c_str<'b>(self) -> io::Result<Cow<'b, CStr>>`
`372`	`357`	`where`
`373`	`358`	`Self: 'b,`
`374`	`359`	`{`
`375`		`- Ok(Cow::Owned(`
`376`		`- CString::new(self.as_os_str().as_bytes()).map_err(\|_cstr_err\| io::Errno::INVAL)?,`
`377`		`- ))`
	`360`	`+ self.as_os_str().into_c_str()`
`378`	`361`	`}`
`379`	`362`
`380`	`363`	`#[inline]`
`@@ -383,19 +366,15 @@ impl Arg for &Path {`
`383`	`366`	`Self: Sized,`
`384`	`367`	`F: FnOnce(&CStr) -> io::Result<T>,`
`385`	`368`	`{`
`386`		`- with_c_str(self.as_os_str().as_bytes(), f)`
	`369`	`+ self.as_os_str().into_with_c_str(f)`
`387`	`370`	`}`
`388`	`371`	`}`
`389`	`372`
`390`	`373`	`#[cfg(feature = "std")]`
`391`		`-#[cfg(any(not(target_os = "wasi"), not(target_env = "p2"), wasip2))]`
`392`	`374`	`impl Arg for &PathBuf {`
`393`	`375`	`#[inline]`
`394`	`376`	`fn as_str(&self) -> io::Result<&str> {`
`395`		`- PathBuf::as_path(self)`
`396`		`- .as_os_str()`
`397`		`- .to_str()`
`398`		`- .ok_or(io::Errno::INVAL)`
	`377`	`+ self.as_os_str().to_str().ok_or(io::Errno::INVAL)`
`399`	`378`	`}`
`400`	`379`
`401`	`380`	`#[inline]`
`@@ -405,10 +384,7 @@ impl Arg for &PathBuf {`
`405`	`384`
`406`	`385`	`#[inline]`
`407`	`386`	`fn as_cow_c_str(&self) -> io::Result<Cow<'_, CStr>> {`
`408`		`- Ok(Cow::Owned(`
`409`		`- CString::new(PathBuf::as_path(self).as_os_str().as_bytes())`
`410`		`- .map_err(\|_cstr_err\| io::Errno::INVAL)?,`
`411`		`- ))`
	`387`	`+ self.as_os_str().into_c_str()`
`412`	`388`	`}`
`413`	`389`
`414`	`390`	`#[inline]`
`@@ -425,12 +401,11 @@ impl Arg for &PathBuf {`
`425`	`401`	`Self: Sized,`
`426`	`402`	`F: FnOnce(&CStr) -> io::Result<T>,`
`427`	`403`	`{`
`428`		`- with_c_str(self.as_os_str().as_bytes(), f)`
	`404`	`+ self.as_os_str().into_with_c_str(f)`
`429`	`405`	`}`
`430`	`406`	`}`
`431`	`407`
`432`	`408`	`#[cfg(feature = "std")]`
`433`		`-#[cfg(any(not(target_os = "wasi"), not(target_env = "p2"), wasip2))]`
`434`	`409`	`impl Arg for PathBuf {`
`435`	`410`	`#[inline]`
`436`	`411`	`fn as_str(&self) -> io::Result<&str> {`
`@@ -444,19 +419,15 @@ impl Arg for PathBuf {`
`444`	`419`
`445`	`420`	`#[inline]`
`446`	`421`	`fn as_cow_c_str(&self) -> io::Result<Cow<'_, CStr>> {`
`447`		`- Ok(Cow::Owned(`
`448`		`- CString::new(self.as_os_str().as_bytes()).map_err(\|_cstr_err\| io::Errno::INVAL)?,`
`449`		`- ))`
	`422`	`+ self.as_os_str().into_c_str()`
`450`	`423`	`}`
`451`	`424`
`452`	`425`	`#[inline]`
`453`	`426`	`fn into_c_str<'b>(self) -> io::Result<Cow<'b, CStr>>`
`454`	`427`	`where`
`455`	`428`	`Self: 'b,`
`456`	`429`	`{`
`457`		`- Ok(Cow::Owned(`
`458`		`- CString::new(self.into_os_string().into_vec()).map_err(\|_cstr_err\| io::Errno::INVAL)?,`
`459`		`- ))`
	`430`	`+ self.into_os_string().into_c_str()`
`460`	`431`	`}`
`461`	`432`
`462`	`433`	`#[inline]`
`@@ -465,10 +436,7 @@ impl Arg for PathBuf {`
`465`	`436`	`Self: Sized,`
`466`	`437`	`F: FnOnce(&CStr) -> io::Result<T>,`
`467`	`438`	`{`
`468`		`- f(`
`469`		`- &CString::new(self.into_os_string().into_vec())`
`470`		`- .map_err(\|_cstr_err\| io::Errno::INVAL)?,`
`471`		`- )`
	`439`	`+ self.into_os_string().into_with_c_str(f)`
`472`	`440`	`}`
`473`	`441`	`}`
`474`	`442`
`@@ -637,23 +605,18 @@ impl<'a> Arg for Cow<'a, OsStr> {`
`637`	`605`
`638`	`606`	`#[inline]`
`639`	`607`	`fn as_cow_c_str(&self) -> io::Result<Cow<'_, CStr>> {`
`640`		`- Ok(Cow::Owned(`
`641`		`- CString::new(self.as_bytes()).map_err(\|_cstr_err\| io::Errno::INVAL)?,`
`642`		`- ))`
	`608`	`+ (&**self).into_c_str()`
`643`	`609`	`}`
`644`	`610`
`645`	`611`	`#[inline]`
`646`	`612`	`fn into_c_str<'b>(self) -> io::Result<Cow<'b, CStr>>`
`647`	`613`	`where`
`648`	`614`	`Self: 'b,`
`649`	`615`	`{`
`650`		`- Ok(Cow::Owned(`
`651`		`- match self {`
`652`		`- Cow::Owned(os) => CString::new(os.into_vec()),`
`653`		`- Cow::Borrowed(os) => CString::new(os.as_bytes()),`
`654`		`- }`
`655`		`- .map_err(\|_cstr_err\| io::Errno::INVAL)?,`
`656`		`- ))`
	`616`	`+ match self {`
	`617`	`+ Cow::Owned(os) => os.into_c_str(),`
	`618`	`+ Cow::Borrowed(os) => os.into_c_str(),`
	`619`	`+ }`
`657`	`620`	`}`
`658`	`621`
`659`	`622`	`#[inline]`
`@@ -662,7 +625,7 @@ impl<'a> Arg for Cow<'a, OsStr> {`
`662`	`625`	`Self: Sized,`
`663`	`626`	`F: FnOnce(&CStr) -> io::Result<T>,`
`664`	`627`	`{`
`665`		`- with_c_str(self.as_bytes(), f)`
	`628`	`+ (&*self).into_with_c_str(f)`
`666`	`629`	`}`
`667`	`630`	`}`
`668`	`631`
`@@ -717,19 +680,15 @@ impl<'a> Arg for Component<'a> {`
`717`	`680`
`718`	`681`	`#[inline]`
`719`	`682`	`fn as_cow_c_str(&self) -> io::Result<Cow<'_, CStr>> {`
`720`		`- Ok(Cow::Owned(`
`721`		`- CString::new(self.as_os_str().as_bytes()).map_err(\|_cstr_err\| io::Errno::INVAL)?,`
`722`		`- ))`
	`683`	`+ self.as_os_str().into_c_str()`
`723`	`684`	`}`
`724`	`685`
`725`	`686`	`#[inline]`
`726`	`687`	`fn into_c_str<'b>(self) -> io::Result<Cow<'b, CStr>>`
`727`	`688`	`where`
`728`	`689`	`Self: 'b,`
`729`	`690`	`{`
`730`		`- Ok(Cow::Owned(`
`731`		`- CString::new(self.as_os_str().as_bytes()).map_err(\|_cstr_err\| io::Errno::INVAL)?,`
`732`		`- ))`
	`691`	`+ self.as_os_str().into_c_str()`
`733`	`692`	`}`
`734`	`693`
`735`	`694`	`#[inline]`
`@@ -738,12 +697,11 @@ impl<'a> Arg for Component<'a> {`
`738`	`697`	`Self: Sized,`
`739`	`698`	`F: FnOnce(&CStr) -> io::Result<T>,`
`740`	`699`	`{`
`741`		`- with_c_str(self.as_os_str().as_bytes(), f)`
	`700`	`+ self.as_os_str().into_with_c_str(f)`
`742`	`701`	`}`
`743`	`702`	`}`
`744`	`703`
`745`	`704`	`#[cfg(feature = "std")]`
`746`		`-#[cfg(any(not(target_os = "wasi"), not(target_env = "p2"), wasip2))]`
`747`	`705`	`impl<'a> Arg for Components<'a> {`
`748`	`706`	`#[inline]`
`749`	`707`	`fn as_str(&self) -> io::Result<&str> {`
`@@ -757,21 +715,15 @@ impl<'a> Arg for Components<'a> {`
`757`	`715`
`758`	`716`	`#[inline]`
`759`	`717`	`fn as_cow_c_str(&self) -> io::Result<Cow<'_, CStr>> {`
`760`		`- Ok(Cow::Owned(`
`761`		`- CString::new(self.as_path().as_os_str().as_bytes())`
`762`		`- .map_err(\|_cstr_err\| io::Errno::INVAL)?,`
`763`		`- ))`
	`718`	`+ self.as_path().into_c_str()`
`764`	`719`	`}`
`765`	`720`
`766`	`721`	`#[inline]`
`767`	`722`	`fn into_c_str<'b>(self) -> io::Result<Cow<'b, CStr>>`
`768`	`723`	`where`
`769`	`724`	`Self: 'b,`
`770`	`725`	`{`
`771`		`- Ok(Cow::Owned(`
`772`		`- CString::new(self.as_path().as_os_str().as_bytes())`
`773`		`- .map_err(\|_cstr_err\| io::Errno::INVAL)?,`
`774`		`- ))`
	`726`	`+ self.as_path().into_c_str()`
`775`	`727`	`}`
`776`	`728`
`777`	`729`	`#[inline]`
`@@ -780,12 +732,11 @@ impl<'a> Arg for Components<'a> {`
`780`	`732`	`Self: Sized,`
`781`	`733`	`F: FnOnce(&CStr) -> io::Result<T>,`
`782`	`734`	`{`
`783`		`- with_c_str(self.as_path().as_os_str().as_bytes(), f)`
	`735`	`+ self.as_path().into_with_c_str(f)`
`784`	`736`	`}`
`785`	`737`	`}`
`786`	`738`
`787`	`739`	`#[cfg(feature = "std")]`
`788`		`-#[cfg(any(not(target_os = "wasi"), not(target_env = "p2"), wasip2))]`
`789`	`740`	`impl<'a> Arg for Iter<'a> {`
`790`	`741`	`#[inline]`
`791`	`742`	`fn as_str(&self) -> io::Result<&str> {`
`@@ -799,21 +750,15 @@ impl<'a> Arg for Iter<'a> {`
`799`	`750`
`800`	`751`	`#[inline]`
`801`	`752`	`fn as_cow_c_str(&self) -> io::Result<Cow<'_, CStr>> {`
`802`		`- Ok(Cow::Owned(`
`803`		`- CString::new(self.as_path().as_os_str().as_bytes())`
`804`		`- .map_err(\|_cstr_err\| io::Errno::INVAL)?,`
`805`		`- ))`
	`753`	`+ self.as_path().into_c_str()`
`806`	`754`	`}`
`807`	`755`
`808`	`756`	`#[inline]`
`809`	`757`	`fn into_c_str<'b>(self) -> io::Result<Cow<'b, CStr>>`
`810`	`758`	`where`
`811`	`759`	`Self: 'b,`
`812`	`760`	`{`
`813`		`- Ok(Cow::Owned(`
`814`		`- CString::new(self.as_path().as_os_str().as_bytes())`
`815`		`- .map_err(\|_cstr_err\| io::Errno::INVAL)?,`
`816`		`- ))`
	`761`	`+ self.as_path().into_c_str()`
`817`	`762`	`}`
`818`	`763`
`819`	`764`	`#[inline]`
`@@ -822,7 +767,7 @@ impl<'a> Arg for Iter<'a> {`
`822`	`767`	`Self: Sized,`
`823`	`768`	`F: FnOnce(&CStr) -> io::Result<T>,`
`824`	`769`	`{`
`825`		`- with_c_str(self.as_path().as_os_str().as_bytes(), f)`
	`770`	`+ self.as_path().into_with_c_str(f)`
`826`	`771`	`}`
`827`	`772`	`}`
`828`	`773`