From 9fc51efe3344a32d9e522f08383f052277b6ab63 Mon Sep 17 00:00:00 2001 From: Aaron Turon Date: Mon, 30 Mar 2015 15:15:27 -0700 Subject: [PATCH] Stabilize `std::convert` and related code * Marks `#[stable]` the contents of the `std::convert` module. * Added methods `PathBuf::as_path`, `OsString::as_os_str`, `String::as_str`, `Vec::{as_slice, as_mut_slice}`. * Deprecates `OsStr::from_str` in favor of a new, stable, and more general `OsStr::new`. * Adds unstable methods `OsString::from_bytes` and `OsStr::{to_bytes, to_cstring}` for ergonomic FFI usage. [breaking-change] --- src/compiletest/compiletest.rs | 1 - src/libcollections/lib.rs | 1 - src/libcollections/string.rs | 9 +++- src/libcollections/vec.rs | 20 ++++---- src/libcore/convert.rs | 38 ++++++++------ src/librustc/lib.rs | 1 - src/librustc_back/lib.rs | 1 - src/librustc_driver/lib.rs | 1 - src/librustc_trans/lib.rs | 1 - src/librustdoc/lib.rs | 1 - src/libserialize/lib.rs | 1 - src/libstd/dynamic_lib.rs | 1 - src/libstd/env.rs | 1 - src/libstd/ffi/os_str.rs | 85 ++++++++++++++++++++++++++++--- src/libstd/lib.rs | 3 +- src/libstd/path.rs | 15 +++--- src/libstd/sys/unix/ext.rs | 9 +--- src/libstd/sys/unix/fs2.rs | 4 +- src/libstd/sys/unix/process2.rs | 2 +- src/libsyntax/lib.rs | 1 - src/libterm/lib.rs | 1 - src/libtest/lib.rs | 1 - src/rustbook/main.rs | 1 - src/test/run-pass/env-home-dir.rs | 1 - src/test/run-pass/issue-20797.rs | 2 - 25 files changed, 132 insertions(+), 70 deletions(-) diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs index f0aacc1460b..7fd09f9e1f5 100644 --- a/src/compiletest/compiletest.rs +++ b/src/compiletest/compiletest.rs @@ -18,7 +18,6 @@ #![feature(std_misc)] #![feature(test)] #![feature(path_ext)] -#![feature(convert)] #![feature(str_char)] #![deny(warnings)] diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs index c769b3df37f..367a7b41207 100644 --- a/src/libcollections/lib.rs +++ b/src/libcollections/lib.rs @@ -38,7 +38,6 @@ #![feature(unsafe_no_drop_flag, filling_drop)] #![feature(step_by)] #![feature(str_char)] -#![feature(convert)] #![feature(slice_patterns)] #![feature(debug_builders)] #![cfg_attr(test, feature(rand, rustc_private, test, hash, collections))] diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index 7131c1cd881..dff01039f7d 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -364,6 +364,14 @@ pub fn into_bytes(self) -> Vec { self.vec } + /// Extract a string slice containing the entire string. + #[inline] + #[unstable(feature = "convert", + reason = "waiting on RFC revision")] + pub fn as_str(&self) -> &str { + self + } + /// Pushes the given string onto this string buffer. /// /// # Examples @@ -848,7 +856,6 @@ fn ne(&self, other: &Cow<'a, str>) -> bool { PartialEq::ne(&**self, &**other) } #[allow(deprecated)] impl Str for String { #[inline] - #[stable(feature = "rust1", since = "1.0.0")] fn as_slice(&self) -> &str { unsafe { mem::transmute(&*self.vec) } } diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 14bc7f65e09..6ee7b0a86c8 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -423,11 +423,18 @@ pub fn truncate(&mut self, len: usize) { } } + /// Extract a slice containing the entire vector. + #[inline] + #[unstable(feature = "convert", + reason = "waiting on RFC revision")] + pub fn as_slice(&self) -> &[T] { + self + } + /// Deprecated: use `&mut s[..]` instead. #[inline] - #[unstable(feature = "collections", - reason = "will be replaced by slice syntax")] - #[deprecated(since = "1.0.0", reason = "use &mut s[..] instead")] + #[unstable(feature = "convert", + reason = "waiting on RFC revision")] pub fn as_mut_slice(&mut self) -> &mut [T] { &mut self[..] } @@ -1640,13 +1647,6 @@ fn as_ref(&self) -> &Vec { } } -#[stable(feature = "rust1", since = "1.0.0")] -impl Into> for Vec { - fn into(self) -> Vec { - self - } -} - #[stable(feature = "rust1", since = "1.0.0")] impl AsRef<[T]> for Vec { fn as_ref(&self) -> &[T] { diff --git a/src/libcore/convert.rs b/src/libcore/convert.rs index 21f9b1f5513..4a99f1a756a 100644 --- a/src/libcore/convert.rs +++ b/src/libcore/convert.rs @@ -14,33 +14,40 @@ //! conversions from one type to another. They follow the standard //! Rust conventions of `as`/`to`/`into`/`from`. -#![unstable(feature = "convert", - reason = "recently added, experimental traits")] +#![stable(feature = "rust1", since = "1.0.0")] use marker::Sized; /// A cheap, reference-to-reference conversion. +#[stable(feature = "rust1", since = "1.0.0")] pub trait AsRef { /// Perform the conversion. + #[stable(feature = "rust1", since = "1.0.0")] fn as_ref(&self) -> &T; } /// A cheap, mutable reference-to-mutable reference conversion. +#[stable(feature = "rust1", since = "1.0.0")] pub trait AsMut { /// Perform the conversion. + #[stable(feature = "rust1", since = "1.0.0")] fn as_mut(&mut self) -> &mut T; } /// A conversion that consumes `self`, which may or may not be /// expensive. +#[stable(feature = "rust1", since = "1.0.0")] pub trait Into: Sized { /// Perform the conversion. + #[stable(feature = "rust1", since = "1.0.0")] fn into(self) -> T; } /// Construct `Self` via a conversion. +#[stable(feature = "rust1", since = "1.0.0")] pub trait From { /// Perform the conversion. + #[stable(feature = "rust1", since = "1.0.0")] fn from(T) -> Self; } @@ -48,14 +55,8 @@ pub trait From { // GENERIC IMPLS //////////////////////////////////////////////////////////////////////////////// -// As implies Into -impl<'a, T: ?Sized, U: ?Sized> Into<&'a U> for &'a T where T: AsRef { - fn into(self) -> &'a U { - self.as_ref() - } -} - // As lifts over & +#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T: ?Sized, U: ?Sized> AsRef for &'a T where T: AsRef { fn as_ref(&self) -> &U { >::as_ref(*self) @@ -63,6 +64,7 @@ fn as_ref(&self) -> &U { } // As lifts over &mut +#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T: ?Sized, U: ?Sized> AsRef for &'a mut T where T: AsRef { fn as_ref(&self) -> &U { >::as_ref(*self) @@ -77,14 +79,8 @@ fn as_ref(&self) -> &U { // } // } -// AsMut implies Into -impl<'a, T: ?Sized, U: ?Sized> Into<&'a mut U> for &'a mut T where T: AsMut { - fn into(self) -> &'a mut U { - (*self).as_mut() - } -} - // AsMut lifts over &mut +#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T: ?Sized, U: ?Sized> AsMut for &'a mut T where T: AsMut { fn as_mut(&mut self) -> &mut U { (*self).as_mut() @@ -100,28 +96,38 @@ fn as_mut(&mut self) -> &mut U { // } // From implies Into +#[stable(feature = "rust1", since = "1.0.0")] impl Into for T where U: From { fn into(self) -> U { U::from(self) } } +// From (and thus Into) is reflexive +#[stable(feature = "rust1", since = "1.0.0")] +impl From for T { + fn from(t: T) -> T { t } +} + //////////////////////////////////////////////////////////////////////////////// // CONCRETE IMPLS //////////////////////////////////////////////////////////////////////////////// +#[stable(feature = "rust1", since = "1.0.0")] impl AsRef<[T]> for [T] { fn as_ref(&self) -> &[T] { self } } +#[stable(feature = "rust1", since = "1.0.0")] impl AsMut<[T]> for [T] { fn as_mut(&mut self) -> &mut [T] { self } } +#[stable(feature = "rust1", since = "1.0.0")] impl AsRef for str { fn as_ref(&self) -> &str { self diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index f31f8e8d4ce..6215f823142 100644 --- a/src/librustc/lib.rs +++ b/src/librustc/lib.rs @@ -41,7 +41,6 @@ #![feature(path_ext)] #![feature(str_words)] #![feature(str_char)] -#![feature(convert)] #![feature(into_cow)] #![feature(slice_patterns)] #![cfg_attr(test, feature(test))] diff --git a/src/librustc_back/lib.rs b/src/librustc_back/lib.rs index fe457841e91..5d7457da7e0 100644 --- a/src/librustc_back/lib.rs +++ b/src/librustc_back/lib.rs @@ -46,7 +46,6 @@ #![feature(path_ext)] #![feature(std_misc)] #![feature(step_by)] -#![feature(convert)] #![cfg_attr(test, feature(test, rand))] extern crate syntax; diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index 456d5f7a60a..112f1502643 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -38,7 +38,6 @@ #![feature(io)] #![feature(set_stdio)] #![feature(unicode)] -#![feature(convert)] extern crate arena; extern crate flate; diff --git a/src/librustc_trans/lib.rs b/src/librustc_trans/lib.rs index a3ac0473bfa..b0eacd1a55d 100644 --- a/src/librustc_trans/lib.rs +++ b/src/librustc_trans/lib.rs @@ -39,7 +39,6 @@ #![feature(unicode)] #![feature(path_ext)] #![feature(fs)] -#![feature(convert)] #![feature(path_relative_from)] #![allow(trivial_casts)] diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index 431cb4a2898..98598509cbc 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -36,7 +36,6 @@ #![feature(file_path)] #![feature(path_ext)] #![feature(path_relative_from)] -#![feature(convert)] #![feature(slice_patterns)] extern crate arena; diff --git a/src/libserialize/lib.rs b/src/libserialize/lib.rs index b79323b3f96..2e86712c9bc 100644 --- a/src/libserialize/lib.rs +++ b/src/libserialize/lib.rs @@ -36,7 +36,6 @@ #![feature(std_misc)] #![feature(unicode)] #![feature(str_char)] -#![feature(convert)] #![cfg_attr(test, feature(test, old_io))] // test harness access diff --git a/src/libstd/dynamic_lib.rs b/src/libstd/dynamic_lib.rs index d8a95133d94..f9bb7e6cbd4 100644 --- a/src/libstd/dynamic_lib.rs +++ b/src/libstd/dynamic_lib.rs @@ -190,7 +190,6 @@ mod dl { use ffi::{CStr, OsStr}; use str; use libc; - use os::unix::prelude::*; use ptr; pub fn open(filename: Option<&OsStr>) -> Result<*mut u8, String> { diff --git a/src/libstd/env.rs b/src/libstd/env.rs index 71f072302fb..6553b40b745 100644 --- a/src/libstd/env.rs +++ b/src/libstd/env.rs @@ -327,7 +327,6 @@ pub struct JoinPathsError { /// # Examples /// /// ``` -/// # #![feature(convert)] /// use std::env; /// use std::path::PathBuf; /// diff --git a/src/libstd/ffi/os_str.rs b/src/libstd/ffi/os_str.rs index 49dbac4585b..30e96ec465f 100644 --- a/src/libstd/ffi/os_str.rs +++ b/src/libstd/ffi/os_str.rs @@ -35,6 +35,7 @@ use core::prelude::*; use borrow::{Borrow, Cow, ToOwned}; +use ffi::CString; use fmt::{self, Debug}; use mem; use string::String; @@ -42,6 +43,7 @@ use cmp; use hash::{Hash, Hasher}; use old_path::{Path, GenericPath}; +use vec::Vec; use sys::os_str::{Buf, Slice}; use sys_common::{AsInner, IntoInner, FromInner}; @@ -83,6 +85,37 @@ pub fn new() -> OsString { OsString { inner: Buf::from_string(String::new()) } } + /// Construct an `OsString` from a byte sequence. + /// + /// # Platform behavior + /// + /// On Unix systems, any byte sequence can be successfully + /// converted into an `OsString`. + /// + /// On Windows system, only UTF-8 byte sequences will successfully + /// convert; non UTF-8 data will produce `None`. + #[unstable(feature = "convert", reason = "recently added")] + pub fn from_bytes(bytes: B) -> Option where B: Into> { + #[cfg(unix)] + fn from_bytes_inner(vec: Vec) -> Option { + use os::unix::ffi::OsStringExt; + Some(OsString::from_vec(vec)) + } + + #[cfg(windows)] + fn from_bytes_inner(vec: Vec) -> Option { + String::from_utf8(vec).ok().map(OsString::from) + } + + from_bytes_inner(bytes.into()) + } + + /// Convert to an `OsStr` slice. + #[stable(feature = "rust1", since = "1.0.0")] + pub fn as_os_str(&self) -> &OsStr { + self + } + /// Convert the `OsString` into a `String` if it contains valid Unicode data. /// /// On failure, ownership of the original `OsString` is returned. @@ -211,8 +244,16 @@ fn hash(&self, state: &mut H) { } impl OsStr { + /// Coerce into an `OsStr` slice. + #[stable(feature = "rust1", since = "1.0.0")] + pub fn new + ?Sized>(s: &S) -> &OsStr { + s.as_ref() + } + /// Coerce directly from a `&str` slice to a `&OsStr` slice. #[stable(feature = "rust1", since = "1.0.0")] + #[deprecated(since = "1.0.0", + reason = "use `OsStr::new` instead")] pub fn from_str(s: &str) -> &OsStr { unsafe { mem::transmute(Slice::from_str(s)) } } @@ -239,6 +280,36 @@ pub fn to_os_string(&self) -> OsString { OsString { inner: self.inner.to_owned() } } + /// Yield this `OsStr` as a byte slice. + /// + /// # Platform behavior + /// + /// On Unix systems, this is a no-op. + /// + /// On Windows systems, this returns `None` unless the `OsStr` is + /// valid unicode, in which case it produces UTF-8-encoded + /// data. This may entail checking validity. + #[unstable(feature = "convert", reason = "recently added")] + pub fn to_bytes(&self) -> Option<&[u8]> { + if cfg!(windows) { + self.to_str().map(|s| s.as_bytes()) + } else { + Some(self.bytes()) + } + } + + /// Create a `CString` containing this `OsStr` data. + /// + /// Fails if the `OsStr` contains interior nulls. + /// + /// This is a convenience for creating a `CString` from + /// `self.to_bytes()`, and inherits the platform behavior of the + /// `to_bytes` method. + #[unstable(feature = "convert", reason = "recently added")] + pub fn to_cstring(&self) -> Option { + self.to_bytes().and_then(|b| CString::new(b).ok()) + } + /// Get the underlying byte representation. /// /// Note: it is *crucial* that this API is private, to avoid @@ -258,14 +329,14 @@ fn eq(&self, other: &OsStr) -> bool { #[stable(feature = "rust1", since = "1.0.0")] impl PartialEq for OsStr { fn eq(&self, other: &str) -> bool { - *self == *OsStr::from_str(other) + *self == *OsStr::new(other) } } #[stable(feature = "rust1", since = "1.0.0")] impl PartialEq for str { fn eq(&self, other: &OsStr) -> bool { - *other == *OsStr::from_str(self) + *other == *OsStr::new(self) } } @@ -292,7 +363,7 @@ fn ge(&self, other: &OsStr) -> bool { self.bytes().ge(other.bytes()) } impl PartialOrd for OsStr { #[inline] fn partial_cmp(&self, other: &str) -> Option { - self.partial_cmp(OsStr::from_str(other)) + self.partial_cmp(OsStr::new(other)) } } @@ -359,7 +430,7 @@ fn as_os_str(&self) -> &OsStr { #[deprecated(since = "1.0.0", reason = "trait is deprecated")] impl AsOsStr for str { fn as_os_str(&self) -> &OsStr { - OsStr::from_str(self) + unsafe { mem::transmute(Slice::from_str(self)) } } } @@ -367,7 +438,7 @@ fn as_os_str(&self) -> &OsStr { #[deprecated(since = "1.0.0", reason = "trait is deprecated")] impl AsOsStr for String { fn as_os_str(&self) -> &OsStr { - OsStr::from_str(&self[..]) + unsafe { mem::transmute(Slice::from_str(self)) } } } @@ -388,14 +459,14 @@ fn as_ref(&self) -> &OsStr { #[stable(feature = "rust1", since = "1.0.0")] impl AsRef for str { fn as_ref(&self) -> &OsStr { - OsStr::from_str(self) + unsafe { mem::transmute(Slice::from_str(self)) } } } #[stable(feature = "rust1", since = "1.0.0")] impl AsRef for String { fn as_ref(&self) -> &OsStr { - OsStr::from_str(&self[..]) + unsafe { mem::transmute(Slice::from_str(self)) } } } diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index b7cb8f9ed50..cd7fcc433a6 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -122,12 +122,11 @@ #![feature(unsafe_no_drop_flag, filling_drop)] #![feature(macro_reexport)] #![feature(unique)] -#![feature(convert)] #![feature(allow_internal_unstable)] #![feature(str_char)] #![feature(into_cow)] -#![feature(slice_patterns)] #![feature(std_misc)] +#![feature(slice_patterns)] #![feature(debug_builders)] #![cfg_attr(test, feature(test, rustc_private, std_misc))] diff --git a/src/libstd/path.rs b/src/libstd/path.rs index 58d3ae9f7cf..36a5d1465f0 100644 --- a/src/libstd/path.rs +++ b/src/libstd/path.rs @@ -35,7 +35,6 @@ //! To build or modify paths, use `PathBuf`: //! //! ```rust -//! # #![feature(convert)] //! use std::path::PathBuf; //! //! let mut path = PathBuf::from("c:\\"); @@ -521,9 +520,9 @@ impl<'a> Component<'a> { pub fn as_os_str(self) -> &'a OsStr { match self { Component::Prefix(p) => p.as_os_str(), - Component::RootDir => OsStr::from_str(MAIN_SEP_STR), - Component::CurDir => OsStr::from_str("."), - Component::ParentDir => OsStr::from_str(".."), + Component::RootDir => OsStr::new(MAIN_SEP_STR), + Component::CurDir => OsStr::new("."), + Component::ParentDir => OsStr::new(".."), Component::Normal(path) => path, } } @@ -893,7 +892,6 @@ fn cmp(&self, other: &Components<'a>) -> cmp::Ordering { /// # Examples /// /// ``` -/// # #![feature(convert)] /// use std::path::PathBuf; /// /// let mut path = PathBuf::from("c:\\"); @@ -918,6 +916,12 @@ pub fn new() -> PathBuf { PathBuf { inner: OsString::new() } } + /// Coerce to a `Path` slice. + #[stable(feature = "rust1", since = "1.0.0")] + pub fn as_path(&self) -> &Path { + self + } + /// Extend `self` with `path`. /// /// If `path` is absolute, it replaces the current path. @@ -985,7 +989,6 @@ pub fn pop(&mut self) -> bool { /// # Examples /// /// ``` - /// # #![feature(convert)] /// use std::path::PathBuf; /// /// let mut buf = PathBuf::from("/"); diff --git a/src/libstd/sys/unix/ext.rs b/src/libstd/sys/unix/ext.rs index 0805949d560..d197d04c0a4 100644 --- a/src/libstd/sys/unix/ext.rs +++ b/src/libstd/sys/unix/ext.rs @@ -138,7 +138,7 @@ fn as_raw_fd(&self) -> Fd { *self.as_inner().socket().as_inner() } /// Unix-specific extension to the primitives in the `std::ffi` module #[stable(feature = "rust1", since = "1.0.0")] pub mod ffi { - use ffi::{CString, NulError, OsStr, OsString}; + use ffi::{OsStr, OsString}; use mem; use prelude::v1::*; use sys::os_str::Buf; @@ -175,10 +175,6 @@ pub trait OsStrExt { /// Get the underlying byte view of the `OsStr` slice. #[stable(feature = "rust1", since = "1.0.0")] fn as_bytes(&self) -> &[u8]; - - /// Convert the `OsStr` slice into a `CString`. - #[stable(feature = "rust1", since = "1.0.0")] - fn to_cstring(&self) -> Result; } #[stable(feature = "rust1", since = "1.0.0")] @@ -189,9 +185,6 @@ fn from_bytes(slice: &[u8]) -> &OsStr { fn as_bytes(&self) -> &[u8] { &self.as_inner().inner } - fn to_cstring(&self) -> Result { - CString::new(self.as_bytes()) - } } } diff --git a/src/libstd/sys/unix/fs2.rs b/src/libstd/sys/unix/fs2.rs index 202e5ddaec4..c7bfb8604bc 100644 --- a/src/libstd/sys/unix/fs2.rs +++ b/src/libstd/sys/unix/fs2.rs @@ -276,8 +276,8 @@ pub fn fd(&self) -> &FileDesc { &self.0 } } fn cstr(path: &Path) -> io::Result { - let cstring = try!(path.as_os_str().to_cstring()); - Ok(cstring) + path.as_os_str().to_cstring().ok_or( + io::Error::new(io::ErrorKind::InvalidInput, "path contained a null", None)) } pub fn mkdir(p: &Path) -> io::Result<()> { diff --git a/src/libstd/sys/unix/process2.rs b/src/libstd/sys/unix/process2.rs index 20c409154b8..c2a8b26aef4 100644 --- a/src/libstd/sys/unix/process2.rs +++ b/src/libstd/sys/unix/process2.rs @@ -54,7 +54,7 @@ pub fn arg(&mut self, arg: &OsStr) { self.args.push(arg.to_cstring().unwrap()) } pub fn args<'a, I: Iterator>(&mut self, args: I) { - self.args.extend(args.map(|s| OsStrExt::to_cstring(s).unwrap())) + self.args.extend(args.map(|s| s.to_cstring().unwrap())) } fn init_env_map(&mut self) { if self.env.is_none() { diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs index c471d9e3179..0980acd3433 100644 --- a/src/libsyntax/lib.rs +++ b/src/libsyntax/lib.rs @@ -37,7 +37,6 @@ #![feature(unicode)] #![feature(path_ext)] #![feature(str_char)] -#![feature(convert)] #![feature(into_cow)] #![feature(slice_patterns)] diff --git a/src/libterm/lib.rs b/src/libterm/lib.rs index ed2d00d6ad7..38d58f042b9 100644 --- a/src/libterm/lib.rs +++ b/src/libterm/lib.rs @@ -62,7 +62,6 @@ #![feature(std_misc)] #![feature(str_char)] #![feature(path_ext)] -#![feature(convert)] #![cfg_attr(windows, feature(libc))] #[macro_use] extern crate log; diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs index ee0d190d729..a08d125c233 100644 --- a/src/libtest/lib.rs +++ b/src/libtest/lib.rs @@ -44,7 +44,6 @@ #![feature(libc)] #![feature(set_stdio)] #![feature(os)] -#![feature(convert)] #![cfg_attr(test, feature(old_io))] extern crate getopts; diff --git a/src/rustbook/main.rs b/src/rustbook/main.rs index 4a652f846ed..09fcd518c1e 100644 --- a/src/rustbook/main.rs +++ b/src/rustbook/main.rs @@ -15,7 +15,6 @@ #![feature(rustdoc)] #![feature(rustc_private)] #![feature(path_relative_from)] -#![feature(convert)] extern crate rustdoc; extern crate rustc_back; diff --git a/src/test/run-pass/env-home-dir.rs b/src/test/run-pass/env-home-dir.rs index 2d0128ba89e..7fb96112125 100644 --- a/src/test/run-pass/env-home-dir.rs +++ b/src/test/run-pass/env-home-dir.rs @@ -11,7 +11,6 @@ // pretty-expanded FIXME #23616 #![feature(path)] -#![feature(convert)] use std::env::*; use std::path::PathBuf; diff --git a/src/test/run-pass/issue-20797.rs b/src/test/run-pass/issue-20797.rs index d0720ec593f..45d31d4a7f1 100644 --- a/src/test/run-pass/issue-20797.rs +++ b/src/test/run-pass/issue-20797.rs @@ -12,8 +12,6 @@ // pretty-expanded FIXME #23616 -#![feature(convert)] - use std::default::Default; use std::io; use std::fs; -- 2.44.0