Copy fields.cmpxchg16b target feature on x86 and x86_64.Self: Autotrait bounds on dyn-safe trait methods.str as containing [u8] for auto trait purposes.*-pc-windows-gnu on CI to mingw-w64 v10 and GCC 12.2.true and false as boolean flags in compiler arguments.repr(C) enums to c_int size.DispatchFromDyn for cell types, allowing downstream experimentation with custom method receivers.fmt::Arguments::as_str() may return Some(_) in more cases after optimization, subject to change.AsFd and AsRawFd for Rc.These APIs are now stable in const contexts:
SocketAddr::newSocketAddr::ipSocketAddr::portSocketAddr::is_ipv4SocketAddr::is_ipv6SocketAddrV4::newSocketAddrV4::ipSocketAddrV4::portSocketAddrV6::newSocketAddrV6::ipSocketAddrV6::portSocketAddrV6::flowinfoSocketAddrV6::scope_idcargo fix or cargo clippy --fix when compilation warnings are auto-fixable.cargo add if you try to install a library crate.CARGO_BIN_NAME environment variable also for binary examples.rustdoc::all group.!.rust-analysis component from rustup now only contains a warning placeholder. This was primarily intended for RLS, and the corresponding -Zsave-analysis flag has been removed from the compiler as well.default-features is set to false of a workspace dependency, and an inherited dependency of a member has default-features = true, Cargo will enable default features of that dependency.CARGO_HOME in the [env] configuration table. Cargo itself doesn't pick up this value, but recursive calls to cargo would, which was not intended.tools = [...] is set in config.toml, we will respect a missing rustdoc in that list. By default rustdoc remains included. To retain the prior behavior explicitly add "rustdoc" to the list.These changes do not affect any public interfaces of Rust, but they represent significant improvements to the performance or internals of rustc and related tools.
@revoked and a better error message for @cert-authority in Cargo's SSH host key verification$prefix-clang as clang in linker detection codealloc on stable without requiring the definition of a handler for allocation failure. Defining custom handlers is still unstable.efiapi calling convention.bindings_with_variant_name to deny-by-defaultarmv7-sony-vita-newlibeabihf as a tier 3 targetstd::task::Context !Send and !SyncOnceWith & RepeatWithVec -> VecDeque conversion guarantee{core,std}::pin::pin!impl From<bool> for {f32,f64}std::path::MAIN_SEPARATOR_STRimpl DerefMut for PathBufThese APIs are now stable in const contexts:
cargo build --verbose tells you more about why it recompiles.net.git-fetch-with-cli option enabledSEMICOLON_IN_EXPRESSIONS_FROM_MACROS to future-incompat report--target by default for -Zgcc-ld=lld on wasmIMPLIED_BOUNDS_ENTAILMENT to Deny + ReportNowstd::task::Context no longer implements Send and SyncThese changes do not affect any public interfaces of Rust, but they represent significant improvements to the performance or internals of rustc and related tools.
x86_64-pc-windows-msvcx86_64-apple-darwinclippy::uninlined_format_args to pedantic.Sized predicates coinductive, allowing cycles.#[must_use] annotations on async fn also affect the Future::Output.cfg(FALSE).C or cdecl.verbatim.Added, updated, and removed targets:
powerpc64-ibm-aix.mipsel-sony-psx.no_std targets for the QNX Neutrino RTOS, aarch64-unknown-nto-qnx710 and x86_64-pc-nto-qnx710.aarch64-unknown-uefi, i686-unknown-uefi, and x86_64-unknown-uefi.linuxkernel targets (not used by the actual kernel).Refer to Rust‘s platform support page for more information on Rust’s tiered platform support.
crossbeam-channel into std::sync::mpsc.Eq and Hash for ControlFlow.compiler_builtins with -C panic=abort.{integer}::checked_ilog{integer}::checked_ilog2{integer}::checked_ilog10{integer}::ilog{integer}::ilog2{integer}::ilog10NonZeroU*::ilog2NonZeroU*::ilog10NonZero*::BITSThese APIs are now stable in const contexts:
repr(Rust) types now groups m*2^n-sized fields with equivalently aligned ones. This is intended to be an optimization, but it is also known to increase type sizes in a few cases for the placement of enum tags. As a reminder, the layout of repr(Rust) types is an implementation detail, subject to change.&& and || will now drop temporaries from their sub-expressions in evaluation order, left-to-right. Previously, it was “twisted” such that the first expression dropped its temporaries last, after all of the other expressions dropped in order.-export-dynamic to wasm-ld.main is now mangled as __main_void on wasm32-wasi.These changes do not affect any public interfaces of Rust, but they represent significant improvements to the performance or internals of rustc and related tools.
repr(Int) enums#[repr(u8)] enum Foo { A(u8) = 0, B(i8) = 1, C(bool) = 42, }
must_use on impl Trait for supertraits This makes impl ExactSizeIterator respect the existing #[must_use] annotation on Iterator...=X in patternsclippy::for_loops_over_fallibles lint into rustcsym operands in inline assembly#[derive(Default)] on a generic #[default] enum adding unnecessary Default boundsproc_macro::Span::source_textuX::{checked_add_signed, overflowing_add_signed, saturating_add_signed, wrapping_add_signed}iX::{checked_add_unsigned, overflowing_add_unsigned, saturating_add_unsigned, wrapping_add_unsigned}iX::{checked_sub_unsigned, overflowing_sub_unsigned, saturating_sub_unsigned, wrapping_sub_unsigned}BTreeSet::{first, last, pop_first, pop_last}BTreeMap::{first_key_value, last_key_value, first_entry, last_entry, pop_first, pop_last}AsFd implementations for stdio lock types on WASI.impl TryFrom<Vec<T>> for Box<[T; N]>core::hint::black_boxDuration::try_from_secs_{f32,f64}Option::unzipstd::os::fdcargo remove to remove dependencies from Cargo.tomlcargo publish now waits for the new version to be downloadable before exitingSee detailed release notes for more.
ProceduralMasquerade hack to older versions of rental__heap_base and __data_end on wasm32-wasi.__wasm_init_memory on WebAssembly.__tls_* on wasm32-unknown-unknown.libresolv in libstd on Darwinlibstd no longer pull in libiconv.dylib on Darwin)order_dependent_trait_objects show up in future-breakage reportsThese changes do not affect any public interfaces of Rust, but they represent significant improvements to the performance or internals of rustc and related tools.
as casts of enums with #[non_exhaustive] variantslet elselet_underscore_drop and let_underscore_lock from Clippybreaking from arbitrary labeled blocks (“label-break-value”)MaybeUninit is the correct way to work with uninitialized memory.Drop impl on foreign ADTsspecial_module_name lint-C instrument-coverageNew targets:
PartialEq::ne in derive(PartialEq)BCRYPT_RNG_ALG_HANDLE by defaultSystem with direct system allocator callsstd::layout::Layout size must not overflow isize::MAX when rounded up to align This also changes the safety conditions on Layout::from_size_align_unchecked.std::backtrace::BacktraceBound::as_refstd::io::read_to_string<*const T>::cast_mut<*mut T>::cast_constThese APIs are now stable in const contexts:
std::layout::Layout size must not overflow isize::MAX when rounded up to align. This also changes the safety conditions on Layout::from_size_align_unchecked.PollFn now only implements Unpin if the closure is Unpin. This is a possible breaking change if users were relying on the blanket unpin implementation. See discussion on the PR for details of why this change was made.#![cfg_attr(..., crate_type = ...)] to set the crate type This strengthens the forward compatibility lint deprecated_cfg_attr_crate_type_name to deny.llvm-has-rust-patches allows setting the build system to treat the LLVM as having Rust-specific patches This option may need to be set for distributions that are building Rust with a patched LLVM via llvm-config, not the built-in LLVM.lld. For more information, see issue 102754.These changes do not affect any public interfaces of Rust, but they represent significant improvements to the performance or internals of rustc and related tools.
x.sh and x.ps1 shell scripts&T if every byte in T is inside an UnsafeCellunused_tuple_struct_fields, similar to the existing warning for unused struct fields. This lint will become warn-by-default in the future.#[used] as llvm.compiler.used for ELF targets--diagnostic-width compiler flag to define the terminal width.rust-lld for iOS, tvOS and watchOSwrite! or writeln! into an OsString: Implement fmt::Write for OsStringFusedIterator for std::net::[Into]Incomingimpl<T: AsRawFd> AsRawFd for {Arc,Box}<T>ptr::copy and ptr::swap are doing untyped copiesavailable_parallelismmem::uninitializedfuture::IntoFuturefuture::poll_fntask::ready!num::NonZero*::checked_mulnum::NonZero*::checked_pownum::NonZero*::saturating_mulnum::NonZero*::saturating_pownum::NonZeroI*::absnum::NonZeroI*::checked_absnum::NonZeroI*::overflowing_absnum::NonZeroI*::saturating_absnum::NonZeroI*::unsigned_absnum::NonZeroI*::wrapping_absnum::NonZeroU*::checked_addnum::NonZeroU*::checked_next_power_of_twonum::NonZeroU*::saturating_addos::unix::process::CommandExt::process_groupos::windows::fs::FileTypeExt::is_symlink_diros::windows::fs::FileTypeExt::is_symlink_fileThese types were previously stable in std::ffi, but are now also available in core and alloc:
core::ffi::CStrcore::ffi::FromBytesWithNulErroralloc::ffi::CStringalloc::ffi::FromVecWithNulErroralloc::ffi::IntoStringErroralloc::ffi::NulErrorThese types were previously stable in std::os::raw, but are now also available in core::ffi and std::ffi:
ffi::c_charffi::c_doubleffi::c_floatffi::c_intffi::c_longffi::c_longlongffi::c_scharffi::c_shortffi::c_ucharffi::c_uintffi::c_ulongffi::c_ulonglongffi::c_ushortThese APIs are now usable in const contexts:
workspace.package and workspace.dependencies for more details on how to define these common settings.--target flags to build for multiple targets at once, and the build.target config option may now take an array of multiple targets.--jobs argument can now take a negative number to count backwards from the max CPUs.cargo add will now update Cargo.lock.--crate-type flag to cargo rustc to override the crate type.rev field.-linux-gnu targets are now at least kernel 3.2 and glibc 2.17, for targets that previously supported older versions: Increase the minimum linux-gnu versionstransmute_copy's U is not larger than TBTreeMap was fixed that allowed data it was borrowing to be dropped before the container.thumbv6m-none-eabi target, some incorrect asm! statements were erroneously accepted if they used the high registers (r8 to r14) as an input/output operand. This is no longer accepted.impl Trait was accidentally accepted as the associated type value of return-position impl Trait, without fulfilling all the trait bounds of that associated type, as long as the hidden type satisfies said bounds. This has been fixed.These changes do not affect any public interfaces of Rust, but they represent significant improvements to the performance or internals of rustc and related tools.
Vec::insert for the case where index == len.impl Trait args.cenum_impl_drop_cast warnings deny-by-default.-C panic=abort is used regardless of declared ABI.bundle native library modifier, also removing the deprecated static-nobundle linking kind.* Refer to Rust‘s platform support page for more information on Rust’s tiered platform support.
Copy, Clone, PartialEq and Eq for core::fmt::Alignment.ptr::null and null_mut to all thin (including extern) types.impl Read and Write for VecDeque<u8>.[OsStr]::join.Hash for core::alloc::Layout.OsString.std::mem::needs_drop accept ?Sized.impl Termination for Infallible and then make the Result impls of Termination more generic./proc/self/mem.array::from_fnBox::into_pinBinaryHeap::try_reserveBinaryHeap::try_reserve_exactOsString::try_reserveOsString::try_reserve_exactPathBuf::try_reservePathBuf::try_reserve_exactPath::try_existsRef::filter_mapRefMut::filter_mapNonNull::<[T]>::lenToOwned::clone_intoIpv6Addr::to_ipv4_mappedunix::io::AsFdunix::io::BorrowedFd<'fd>unix::io::OwnedFdwindows::io::AsHandlewindows::io::BorrowedHandle<'handle>windows::io::OwnedHandlewindows::io::HandleOrInvalidwindows::io::HandleOrNullwindows::io::InvalidHandleErrorwindows::io::NullHandleErrorwindows::io::AsSocketwindows::io::BorrowedSocket<'handle>windows::io::OwnedSocketthread::scopethread::Scopethread::ScopedJoinHandleThese APIs are now usable in const contexts:
array::from_refslice::from_refintrinsics::copyintrinsics::copy_nonoverlapping<*const T>::copy_to<*const T>::copy_to_nonoverlapping<*mut T>::copy_to<*mut T>::copy_to_nonoverlapping<*mut T>::copy_from<*mut T>::copy_from_nonoverlappingstr::from_utf8Utf8Error::error_lenUtf8Error::valid_up_toCondvar::newMutex::newRwLock::new--config path command-line argument.CARGO_PKG_RUST_VERSION.#[link] attributes are now checked more strictly, which may introduce errors for invalid attribute arguments that were previously ignored.Duration. The converted duration can differ slightly from what it was.These changes provide no direct user facing benefits, but represent significant improvements to the internals and overall performance of rustc and related tools.
Rust 1.62.1 addresses a few recent regressions in the compiler and standard library, and also mitigates a CPU vulnerability on Intel SGX.
impl Trait return types.async fn lifetimes.x86_64-fortanix-unknown-sgx target added a mitigation for the MMIO stale data vulnerability, advisory INTEL-SA-00615.#[derive(Default)] on enums with a #[default] variantconst functions may now specify extern "C" or extern "Rust"unaligned_references lint deny-by-default This lint is also a future compatibility lint, and is expected to eventually become a hard error.#[thread_local] attribute on non-static itemsaarch64-pc-windows-gnullvm and x86_64-pc-windows-gnullvm targets*x86_64-unknown-none target to Tier 2** Refer to Rust‘s platform support page for more information on Rust’s tiered platform support.
bool::then_somef32::total_cmpf64::total_cmpStdin::lineswindows::CommandExt::raw_argimpl<T: Default> Default for AssertUnwindSafe<T>From<Rc<str>> for Rc<[u8]>From<Arc<str>> for Arc<[u8]>FusedIterator for EncodeWidecargo add command for adding dependencies to Cargo.toml from the command-line. docsname@version syntax in addition to the previous name:version to align with the behavior in cargo add and other tools. cargo install and cargo yank also now support this syntax so the version does not need to passed as a separate flag.git and registry directories in Cargo's home directory (usually ~/.cargo) are now marked as cache directories so that they are not included in backups or content indexing (on Windows).@ argfile support, which will use “response files” if the command-line to rustc exceeds the operating system's limit.cargo test now passes --target to rustdoc if the specified target is the same as the host target. #10594macro_rules! macros, matching other private itemsFile reads or writes cannot complete synchronously.These changes provide no direct user facing benefits, but represent significant improvements to the internals and overall performance of rustc and related tools.
const fn signatures can now include generic trait boundsconst fn signatures can now use impl Trait in argument and return positionconst fnimpl Trait return type#[link] attributes and on the command line, as well as the whole-archive modifier specifically, are now supportedchar type is now described as UTF-32 in debuginfo#[target_feature] attribute can now be used with aarch64 features#[target_feature = "adx"] is now stableManuallyDrop<T> is now documented to have the same layout as T#[ignore = "…"] messages are printed when running testsstd::io::stdio::lock() return 'static handles. Previously, the creation of locked handles to stdin/stdout/stderr would borrow the handles being locked, which prevented writing let out = std::io::stdout().lock(); because out would outlive the return value of stdout(). Such code now works, eliminating a common pitfall that affected many Rust users.Vec::from_raw_parts is now less restrictive about its inputsstd::thread::available_parallelism now takes cgroup quotas into account. Since available_parallelism is often used to create a thread pool for parallel computation, which may be CPU-bound for performance, available_parallelism will return a value consistent with the ability to use that many threads continuously, if possible. For instance, in a container with 8 virtual CPUs but quotas only allowing for 50% usage, available_parallelism will return 4.Pin::static_mutPin::static_refVec::retain_mutVecDeque::retain_mutWrite for Cursor<[u8; N]>std::os::unix::net::SocketAddr::from_pathnamestd::process::ExitCode and std::process::Termination. The stabilization of these two APIs now makes it possible for programs to return errors from main with custom exit codes.std::thread::JoinHandle::is_finishedThese APIs are now usable in const contexts:
<*const T>::offset and <*mut T>::offset<*const T>::wrapping_offset and <*mut T>::wrapping_offset<*const T>::add and <*mut T>::add<*const T>::sub and <*mut T>::sub<*const T>::wrapping_add and <*mut T>::wrapping_add<*const T>::wrapping_sub and <*mut T>::wrapping_sub<[T]>::as_mut_ptr<[T]>::as_ptr_range<[T]>::as_mut_ptr_rangeNo feature changes, but see compatibility notes.
whole-archive in some cases, but now rustc tries not to use whole-archive unless explicitly requested. This change may result in linking errors in some cases. To fix such errors, native libraries linked from the command line, build scripts, or #[link] attributes need toa depends on b then a should go first and b second)+whole-archive modifier.ident matchers wrapped in groups# in r# raw string literals is now required to be less than 256cargo vendor now only accepts one value for each --sync flagcfg predicates in all() and any() are always evaluated to detect errors, instead of short-circuiting. The compatibility considerations here arise in nightly-only code that used the short-circuiting behavior of all to write something like cfg(all(feature = "nightly", syntax-requiring-nightly)), which will now fail to compile. Instead, use either cfg_attr(feature = "nightly", ...) or nested uses of cfg.These changes provide no direct user facing benefits, but represent significant improvements to the internals and overall performance of rustc and related tools.
#[cfg(panic = "...")] for either "unwind" or "abort".#[cfg(target_has_atomic = "...")] for each integer size and "ptr".+crt-static and relocation-model=pic on x86_64-unknown-linux-gnuunreachable_pub lints on nested and glob public reexport-Z instrument-coverage as -C instrument-coverage-Z print-link-args as --print link-argsmips64-openwrt-linux-musl*armv7-unknown-linux-uclibceabi (softfloat)*RUST_BACKTRACE=full by default* Refer to Rust‘s platform support page for more information on Rust’s tiered platform support.
sort_by_cached_keyDuration::try_from_secs_f32/f64 accuracy by directly processing exponent and mantissaInstant::{duration_since, elapsed, sub} saturatingInstant::nowBuildHasherDefault, iter::Empty and future::Pending covariantArc::new_cyclicRc::new_cyclicslice::EscapeAscii<[u8]>::escape_asciiu8::escape_asciiVec::spare_capacity_mutMaybeUninit::assume_init_dropMaybeUninit::assume_init_readi8::abs_diffi16::abs_diffi32::abs_diffi64::abs_diffi128::abs_diffisize::abs_diffu8::abs_diffu16::abs_diffu32::abs_diffu64::abs_diffu128::abs_diffusize::abs_diffDisplay for io::ErrorKindFrom<u8> for ExitCodeNot for ! (the “never” type)Assign<$t> for Wrapping<$t>arch::is_aarch64_feature_detected!toml-rs to toml_edit-Ztimings as --timingscargo:rustc-link-arg-* types from build script output.Instant::now. On platforms that don't provide monotonic clocks, an instant is not guaranteed to be greater than an earlier instant anymore.Instant::{duration_since, elapsed, sub} do not panic anymore on underflow, saturating to 0 instead. In the real world the panic happened mostly on platforms with buggy monotonic clock implementations rather than catching programming errors like reversing the start and end times. Such programming errors will now results in 0 rather than a panic.These changes provide no direct user facing benefits, but represent significant improvements to the internals and overall performance of rustc and related tools.
-Cremark#[test]-like built-in attribute macro is present multiple times.-Z emit-future-incompat as --json future-incompatThis release disables incremental compilation, unless the user has explicitly opted in via the newly added RUSTC_FORCE_INCREMENTAL=1 environment variable. This is due to a known and relatively frequently occurring bug in incremental compilation, which causes builds to issue internal compiler errors. This particular bug is already fixed on nightly, but that fix has not yet rolled out to stable and is deemed too risky for a direct stable backport.
As always, we encourage users to test with nightly and report bugs so that we can track failures and fix issues earlier.
See 94124 for more details.
std::thread::available_parallelismResult::copiedResult::clonedarch::asm!arch::global_asm!ops::ControlFlow::is_breakops::ControlFlow::is_continueTryFrom<char> for u8char::TryFromCharError implementing Clone, Debug, Display, PartialEq, Copy, Eq, Erroriter::zipNonZeroU8::is_power_of_twoNonZeroU16::is_power_of_twoNonZeroU32::is_power_of_twoNonZeroU64::is_power_of_twoNonZeroU128::is_power_of_twoNonZeroUsize::is_power_of_twoDoubleEndedIterator for ToLowercaseDoubleEndedIterator for ToUppercaseTryFrom<&mut [T]> for [T; N]UnwindSafe for OnceRefUnwindSafe for OnceConst-stable:
mem::MaybeUninit::as_ptrmem::MaybeUninit::assume_initmem::MaybeUninit::assume_init_refffi::CStr::from_bytes_with_nul_uncheckedstrip profile option--release as -rterm.quiet configuration--host from cargo {publish,search,login}#![cfg_attr] This adds a future compatibility lint to supporting the use of cfg_attr wrapping either crate_type or crate_name specification within Rust files; it is recommended that users migrate to setting the equivalent command line flags.#[no_link] attribute on name resolution This may expose new names, leading to conflicts with preexisting names in a given namespace and a compilation failure.These changes provide no direct user facing benefits, but represent significant improvements to the internals and overall performance of rustc and related tools.
std::fs::remove_dir_all (CVE-2022-21658)useless_format Clippy lintnon_send_fields_in_send_ty Clippy lint to nursery{ident} in the string. This works in all macros accepting format strings. Support for this in panic! (panic!("{ident}")) requires the 2021 edition; panic invocations in previous editions that appear to be trying to use this will result in a warning lint about not having the intended effect.*const T pointers can now be dereferenced in const contexts.Unsize have been relaxed.strip option to remove these symbols to produce smaller release binaries. Note that this release only includes support in rustc, not directly in cargo.-Cremarkx86_64-unknown-none at Tier 3** Refer to Rust‘s platform support page for more information on Rust’s tiered platform support.
#[must_use] annotations where appropriate, producing a warning when ignoring their return value. This helps catch mistakes such as expecting a function to mutate a value in place rather than return a new value.copy and copy_nonoverlappingRefUnwindSafe for Rc<T>Termination for Result<Infallible, E>. This allows writing fn main() -> Result<Infallible, ErrorType>, for a program whose successful exits never involve returning from main (for instance, a program that calls exit, or that uses exec to run another program).Metadata::is_symlinkPath::is_symlink{integer}::saturating_divOption::unwrap_uncheckedResult::unwrap_uncheckedResult::unwrap_err_uncheckedFile::optionsThese APIs are now usable in const contexts:
Duration::newDuration::checked_addDuration::saturating_addDuration::checked_subDuration::saturating_subDuration::checked_mulDuration::saturating_mulDuration::checked_divstd::process::Command will no longer search the current directory for executables.These changes provide no direct user facing benefits, but represent significant improvements to the internals and overall performance of rustc and related tools.
#[derive] and will see the original (pre-cfg) input.m!{ .. }.method() and m!{ .. }?.Clone and Debug implementations during dead code analysis.armv6k-nintendo-3ds at Tier 3*.armv7-unknown-linux-uclibceabihf at Tier 3*.m68k-unknown-linux-gnu at Tier 3*.aarch64-kmc-solid_asp3, armv7a-kmc-solid_asp3-eabi, armv7a-kmc-solid_asp3-eabihf* Refer to Rust‘s platform support page for more information on Rust’s tiered platform support.
Vec::leak#[repr(i8)] to OrderingFile::read_to_end and read_to_string#[must_use], producing a warning when ignoring their return value. This helps catch mistakes such as expecting a function to mutate a value in place rather than return a new value.[T; N]::as_mut_slice[T; N]::as_slicecollections::TryReserveErrorHashMap::try_reserveHashSet::try_reserveString::try_reserveString::try_reserve_exactVec::try_reserveVec::try_reserve_exactVecDeque::try_reserveVecDeque::try_reserve_exactIterator::map_whileiter::MapWhileproc_macro::is_availableCommand::get_programCommand::get_argsCommand::get_envsCommand::get_current_dirCommandArgsCommandEnvsThese APIs are now usable in const contexts:
Clone and Debug implementations during dead code analysis. This will break some builds that set #![deny(dead_code)].These changes provide no direct user facing benefits, but represent significant improvements to the internals and overall performance of rustc and related tools.
binding @ pattern can now also introduce new bindings.const fn.--force-warn. This feature is primarily intended for usage by cargo fix, rather than end users.aarch64-apple-ios-sim to Tier 2*.powerpc-unknown-freebsd at Tier 3*.riscv32imc-esp-espidf at Tier 3*.* Refer to Rust‘s platform support page for more information on Rust’s tiered platform support.
AtomicU{64,128} over Mutex for Instant backsliding protection. For this use case, atomics scale much better under contention.Extend<(A, B)> for (Extend<A>, Extend<B>)impl From<[(K, V); N]> for all collections.P: Unpin bound on impl Future for Pin.=). Now, these functions will just treat such names as nonexistent variables, since the OS cannot represent the existence of a variable with such a name.std::os::unix::fs::chrootUnsafeCell::raw_getBufWriter::into_partscore::panic::{UnwindSafe, RefUnwindSafe, AssertUnwindSafe} These APIs were previously stable in std, but are now also available in core.Vec::shrink_toString::shrink_toOsString::shrink_toPathBuf::shrink_toBinaryHeap::shrink_toVecDeque::shrink_toHashMap::shrink_toHashSet::shrink_toThese APIs are now usable in const contexts:
SEMICOLON_IN_EXPRESSIONS_FROM_MACROS warn by defaultlibc::getpid / std::process::id from Command::pre_exec may return different values on glibc <= 2.24. Rust now invokes the clone3 system call directly, when available, to use new functionality available via that system call. Older versions of glibc cache the result of getpid, and only update that cache when calling glibc's clone/fork functions, so a direct system call bypasses that cache update. glibc 2.25 and newer no longer cache getpid for exactly this reason.These changes provide no direct user facing benefits, but represent significant improvements to the internals and overall performance of rustc and related tools.
X..), which will start at X and will end at the maximum value of the integer.std::prelude (e.g. use std::prelude::rust_2021::*;).* Refer to Rust‘s platform support page for more information on Rust’s tiered platform support.
string::Drain now implements AsRef<str> and AsRef<[u8]>.Bound::clonedDrain::as_strIntoInnerError::into_errorIntoInnerError::into_partsMaybeUninit::assume_init_mutMaybeUninit::assume_init_refMaybeUninit::writearray::mapops::ControlFlowx86::_bittestx86::_bittestandcomplementx86::_bittestandresetx86::_bittestandsetx86_64::_bittest64x86_64::_bittestandcomplement64x86_64::_bittestandreset64x86_64::_bittestandset64The following previously stable functions are now const.
cargo test.cargo metadata now includes the "default_run" field from the manifest.cargo d as an alias for cargo doc.{lib} as formatting option for cargo tree to print the "lib_name" of packages.CTRL+F in your browser.#[doc(hidden)] will no longer appear in the “Trait Implementations” section.io::Error will no longer use the ErrorKind::Other variant. This is to better reflect that these kinds of errors could be categorised into newer more specific ErrorKind variants, and that they do not represent a user error.process::Command on Windows now behaves as expected. Previously using environment variables with Command would cause them to be ASCII-uppercased.rustdoc::RUSTFLAGS is no longer set for build scripts. Build scripts should use CARGO_ENCODED_RUSTFLAGS instead. See the documentation for more details.You can now use macros for values in some built-in attributes. This primarily allows you to call macros within the #[doc] attribute. For example, to include external documentation in your crate, you can now write the following:
#![doc = include_str!("README.md")]
You can now cast between unsized slice types (and types which contain unsized slices) in const fn.
You can now use multiple generic lifetimes with impl Trait where the lifetimes don't explicitly outlive another. In code this means that you can now have impl Trait<'a, 'b> where as before you could only have impl Trait<'a, 'b> where 'b: 'a.
/lib/rustlib/<target-triple>/target.json where / is the “sysroot” directory. You can find your sysroot directory by running rustc --print sysroot.wasm as a target_family for WebAssembly platforms.#[target_feature] on safe functions when targeting WebAssembly platforms.bpfel-unknown-none and bpfeb-unknown-none.-Zmutable-noalias=yes is enabled by default when using LLVM 12 or above.* Refer to Rust‘s platform support page for more information on Rust’s tiered platform support.
panic::panic_any will now #[track_caller].OutOfMemory as a variant of io::ErrorKind.proc_macro::Literal now implements FromStr.BTreeMap::into_keysBTreeMap::into_valuesHashMap::into_keysHashMap::into_valuesarch::wasm32VecDeque::binary_searchVecDeque::binary_search_byVecDeque::binary_search_by_keyVecDeque::partition_point--prune <spec> option to cargo-tree to remove a package from the dependency graph.--depth option to cargo-tree to print only to a certain depth in the tree no-proc-macro value to cargo-tree --edges to hide procedural macro dependencies.CARGO_TARGET_TMPDIR is available. This variable points to a directory that integration tests and benches can use as a “scratchpad” for testing filesystem operations.? is no longer permitted in closures for inferred types.std::arch intrinsics now uses stricter const checking than before and may reject some previously accepted code.i128 multiplication on Cortex M0+ platforms currently unconditionally causes overflow when compiled with codegen-units = 1.◆ or 🦀. More specifically you can now use any identifier that matches the UAX #31 “Unicode Identifier and Pattern Syntax” standard. This is the same standard as languages like Python, however Rust uses NFC normalization which may be different from other languages.| (OR) on complete patterns. E.g.let x = Some(2u8); // Before matches!(x, Some(1) | Some(2)); // Now matches!(x, Some(1 | 2));
:pat_param macro_rules! matcher. This matcher has the same semantics as the :pat matcher. This is to allow :pat to change semantics to being a pattern fragment in a future edition.wasm64-unknown-unknown target.* Refer to Rust‘s platform support page for more information on Rust’s tiered platform support.
android_set_abort_message on Android platforms when available.slice::IterMut<'_, T> now implements AsRef<[T]>IntoIterator. Currently calling .into_iter() as a method on an array will return impl Iterator<Item=&T>, but this may change in a future edition to change Item to T. Calling IntoIterator::into_iter directly on arrays will provide impl Iterator<Item=T> as expected.leading_zeros, and trailing_zeros are now available on all NonZero integer types.{f32, f64}::from_str now parse and print special values (NaN, -0) according to IEEE 754.(Bound<usize>, Bound<usize>).BITS associated constant to all numeric types.AtomicBool::fetch_updateAtomicPtr::fetch_updateBTreeMap::retainBTreeSet::retainBufReader::seek_relativeDebugStruct::non_exhaustiveDuration::MAXDuration::ZERODuration::is_zeroDuration::saturating_addDuration::saturating_mulDuration::saturating_subErrorKind::UnsupportedOption::insertOrdering::is_eqOrdering::is_geOrdering::is_gtOrdering::is_leOrdering::is_ltOrdering::is_neOsStr::is_asciiOsStr::make_ascii_lowercaseOsStr::make_ascii_uppercaseOsStr::to_ascii_lowercaseOsStr::to_ascii_uppercasePeekable::peek_mutRc::decrement_strong_countRc::increment_strong_countVec::extend_from_withinarray::from_mutarray::from_refcmp::max_by_keycmp::max_bycmp::min_by_keycmp::min_byf32::is_subnormalf64::is_subnormalHEAD branch is not “master”. This also includes a switch to the version 3 Cargo.lock format which can handle default branches correctly.unpacked split-debuginfo.authors field is no longer included in Cargo.toml for new projects.Ipv4::from_str will now reject octal format IP addresses in addition to rejecting hexadecimal IP addresses. The octal format can lead to confusion and potential security vulnerabilities and is no longer recommended.BITS constant may conflict with external definitions. In particular, this was known to be a problem in the lexical-core crate, but they have published fixes for semantic versions 0.4 through 0.7. To update this dependency alone, use cargo update -p lexical-core.RUSTC_FORCE_INCREMENTAL=1 environment variable added in 1.52.1.These changes provide no direct user facing benefits, but represent significant improvements to the internals and overall performance of rustc and related tools.
std::sys::windows::alloc implementation.get_blanket_implsThis release disables incremental compilation, unless the user has explicitly opted in via the newly added RUSTC_FORCE_INCREMENTAL=1 environment variable.
This is due to the widespread, and frequently occurring, breakage encountered by Rust users due to newly enabled incremental verification in 1.52.0. Notably, Rust users should upgrade to 1.52.0 or 1.52.1: the bugs that are detected by newly added incremental verification are still present in past stable versions, and are not yet fixed on any channel. These bugs can lead to miscompilation of Rust binaries.
These problems only affect incremental builds, so release builds with Cargo should not be affected unless the user has explicitly opted into incremental. Debug and check builds are affected.
See 84970 for more details.
unsafe_op_in_unsafe_fn lint, which checks whether the unsafe code in an unsafe fn is wrapped in a unsafe block. This lint is allowed by default, and may become a warning or hard error in a future edition.Added tier 3* support for the following targets.
s390x-unknown-linux-muslriscv32gc-unknown-linux-musl & riscv64gc-unknown-linux-muslpowerpc-unknown-openbsd* Refer to Rust‘s platform support page for more information on Rust’s tiered platform support.
OsString now implements Extend and FromIterator.cmp::Reverse now has #[repr(transparent)] representation.Arc<impl Error> now implements error::Error.const.Arguments::as_strchar::MAXchar::REPLACEMENT_CHARACTERchar::UNICODE_VERSIONchar::decode_utf16char::from_digitchar::from_u32_uncheckedchar::from_u32slice::partition_pointstr::rsplit_oncestr::split_onceThe following previously stable APIs are now const.
char::len_utf8char::len_utf16char::to_ascii_uppercasechar::to_ascii_lowercasechar::eq_ignore_ascii_caseu8::to_ascii_uppercaseu8::to_ascii_lowercaseu8::eq_ignore_ascii_caserustdoc:: (e.g. #[warn(rustdoc::broken_intra_doc_links)]). Using the old style is still allowed, and will become a warning in a future release.- [x] Complete - [ ] Todo
cargo test -- foo bar will run all tests that match foo and bar.std library on Windows, allowing you to see std symbols when debugging.These changes provide no direct user facing benefits, but represent significant improvements to the internals and overall performance of rustc and related tools.
RUSTC_BOOTSTRAP.x86_64-rumprun-netbsd target.x86_64-sun-solaris target in favor of x86_64-pc-solaris.,, , and \t as delimiters for specifying languages in code blocks.pub_use_of_private_extern_crateproc-macro-hack versions. A cargo update should be sufficient to fix this in all cases.#[derive] into a regular macro attributestructs by constant values in addition to by types and lifetimes. Also known as “const generics” E.g. you can now write the following. Note: Only values of primitive integers, bool, or char types are currently permitted.struct GenericArray<T, const LENGTH: usize> { inner: [T; LENGTH] } impl<T, const LENGTH: usize> GenericArray<T, LENGTH> { const fn last(&self) -> Option<&T> { if LENGTH == 0 { None } else { Some(&self.inner[LENGTH - 1]) } } }
-Csplit-debuginfo codegen option for macOS platforms. This option controls whether debug information is split across multiple files or packed into a single file. Note This option is unstable on other platforms.aarch64_be-unknown-linux-gnu, aarch64-unknown-linux-gnu_ilp32, and aarch64_be-unknown-linux-gnu_ilp32 targets.i386-unknown-linux-gnu and i486-unknown-linux-gnu targets.target-cpu=native option will now detect individual features of CPUs.* Refer to Rust‘s platform support page for more information on Rust’s tiered platform support.
Box::downcast is now also implemented for any dyn Any + Send + Sync object.str now implements AsMut<str>.u64 and u128 now implement From<char>.Error is now implemented for &T where T implements Error.Poll::{map_ok, map_err} are now implemented for Poll<Option<Result<T, E>>>.unsigned_abs is now implemented for all signed integer types.io::Empty now implements io::Seek.rc::Weak<T> and sync::Weak<T>'s methods such as as_ptr are now implemented for T: ?Sized types.Div and Rem by their NonZero variant is now implemented for all unsigned integers.Arc::decrement_strong_countArc::increment_strong_countOnce::call_once_forcePeekable::next_if_eqPeekable::next_ifSeek::stream_positionarray::IntoIterpanic::panic_anyptr::addr_of!ptr::addr_of_mut!slice::fill_withslice::split_inclusive_mutslice::split_inclusiveslice::strip_prefixslice::strip_suffixstr::split_inclusivesync::OnceStatetask::WakeVecDeque::rangeVecDeque::range_mutsplit-debuginfo profile option to control the -Csplit-debuginfo codegen option.resolver field to Cargo.toml to enable the new feature resolver and CLI option behavior. Version 2 of the feature resolver will try to avoid unifying features of dependencies where that unification could be unwanted. Such as using the same dependency with a std feature in a build scripts and proc-macros, while using the no-std feature in the final binary. See the Cargo book documentation for more information on the feature.Deref traits.--default-theme flag which sets the default theme to use for documentation.Various improvements to intra-doc links:
slice.Vec<T>.wasm-bindgen ABI, and instead use the wasm32 ABI.rustc no longer promotes division, modulo and indexing operations to const that could fail.armv5te-unknown-linux-gnueabisparc64-unknown-linux-gnuthumbv7neon-unknown-linux-gnueabihfarmv7-unknown-linux-gnueabix86_64-unknown-linux-gnux32atomic::spin_loop_hint has been deprecated. It's recommended to use hint::spin_loop instead.const values for x in [x; N] array expressions. This has been technically possible since 1.38.0, as it was unintentionally stabilized.ManuallyDrop<T> union fields are now considered safe.armv5te-unknown-linux-uclibceabi target.aarch64-apple-ios-macabi target.x86_64-unknown-freebsd is now built with the full toolset.* Refer to Rust‘s platform support page for more information on Rust’s tiered platform support.
proc_macro::Punct now implements PartialEq<char>.ops::{Index, IndexMut} are now implemented for fixed sized arrays of any length.std::fs::File type now has a “niche” of -1. This value cannot be a valid file descriptor, and now means Option<File> takes up the same amount of space as File.bool::thenbtree_map::Entry::or_insert_with_keyf32::clampf64::clamphash_map::Entry::or_insert_with_keyOrd::clampRefCell::takeslice::fillUnsafeCell::get_mutThe following previously stable methods are now const.
IpAddr::is_ipv4IpAddr::is_ipv6IpAddr::is_unspecifiedIpAddr::is_loopbackIpAddr::is_multicastIpv4Addr::octetsIpv4Addr::is_loopbackIpv4Addr::is_privateIpv4Addr::is_link_localIpv4Addr::is_multicastIpv4Addr::is_broadcastIpv4Addr::is_documentationIpv4Addr::to_ipv6_compatibleIpv4Addr::to_ipv6_mappedIpv6Addr::segmentsIpv6Addr::is_unspecifiedIpv6Addr::is_loopbackIpv6Addr::is_multicastIpv6Addr::to_ipv4Layout::sizeLayout::alignLayout::from_size_alignpow for all integer types.checked_pow for all integer types.saturating_pow for all integer types.wrapping_pow for all integer types.next_power_of_two for all unsigned integer types.checked_next_power_of_two for all unsigned integer types.[build.rustc-workspace-wrapper] option. This option sets a wrapper to execute instead of rustc, for workspace members only.cargo:rerun-if-changed will now, if provided a directory, scan the entire contents of that directory for changes.--workspace flag to the cargo update command.compare_and_swap method on atomics has been deprecated. It's recommended to use the compare_exchange and compare_exchange_weak methods instead.TokenStreams are checked have fixed some cases where you could write unhygenic macro_rules! macros.#![test] as an inner attribute is now considered unstable like other inner macro attributes, and reports an error by default through the soft_unstable lint.forbid lint at the same level that it was set is now a hard error.panic! calls by supplying your own macro. It's recommended to use the #[panic_handler] attribute to provide your own implementation.struct Foo {};) now produce a warning.Drop, and you can now have a field in a union with ManuallyDrop<T>.#[derive(Debug)] struct Person { name: String, age: u8, } let person = Person { name: String::from("Alice"), age: 20, }; // `name` is moved out of person, but `age` is referenced. let Person { name, ref age } = person; println!("{} {}", name, age);
aarch64-unknown-linux-gnu.aarch64-apple-darwin.aarch64-pc-windows-msvc.mipsel-unknown-none.* Refer to Rust‘s platform support page for more information on Rust’s tiered platform support.
RangeInclusive now checks for exhaustion when calling contains and indexing.ToString::to_string now no longer shrinks the internal buffer in the default implementation.The following previously stable methods are now const.
cargo-package should now be independently reproducible.cargo-tree now marks proc-macro crates.CARGO_PRIMARY_PACKAGE build-time environment variable. This variable will be set if the crate being built is one the user selected to build, either with -p or through defaults.i686-unknown-freebsd from host tier 2 to target tier 2 support.These changes provide no direct user facing benefits, but represent significant improvements to the internals and overall performance of rustc and related tools.
initial-exec Thread Local Storage model.system to the llvm-libunwind bootstrap config option.--color for configuring terminal color support to bootstrap.unsafe keyword is now syntactically permitted on modules. This is still rejected semantically, but can now be parsed by procedural macros.-C link-self-contained=<yes|no> compiler flag. This tells rustc whether to link its own C runtime and libraries or to rely on a external linker to find them. (Supported only on windows-gnu, linux-musl, and wasi platforms.)-C target-feature=+crt-static on linux-gnu targets. Note: If you're using cargo you must explicitly pass the --target flag.aarch64-unknown-linux-musl.* Refer to Rust‘s platform support page for more information on Rust’s tiered platform support.
io::Write is now implemented for &ChildStdin &Sink, &Stdout, and &Stderr.TryFrom<Vec<T>>.matches! macro now supports having a trailing comma.Vec<A> now implements PartialEq<[B]> where A: PartialEq<B>.RefCell::{replace, replace_with, clone} methods now all use #[track_caller].The following previously stable methods are now const fn's:
Option::is_someOption::is_noneOption::as_refResult::is_okResult::is_errResult::as_refOrdering::reverseOrdering::thenrustdoc using the intra-doc link syntax. E.g. /// Uses [`std::future`] will automatically generate a link to std::future's documentation. See “Linking to items by name” for more information.#[doc(alias = "<alias>")] on items to add search aliases when searching through rustdoc's UI.'static lifetime inside const fn now follows the same rules as inside a fn body. In particular, &foo() will not be promoted to 'static lifetime any more inside const fns.&mut references to non zero-sized types are no longer promoted.rustc will now warn if you use attributes like #[link_name] or #[cold] in places where they have no effect._mm256_extract_epi8 and _mm256_extract_epi16 signatures in arch::{x86, x86_64} to return i32 to match the vendor signatures.mem::uninitialized will now panic if any inner types inside a struct or enum disallow zero-initialization.#[target_feature] will now error if used in a place where it has no effect.catch_unwind and will cause an abort. Note: This behaviour is not guaranteed and is still considered undefined behaviour, see the catch_unwind documentation for further information.These changes provide no direct user facing benefits, but represent significant improvements to the internals and overall performance of rustc and related tools.
rustc from source now uses ninja by default over make. You can continue building with make by setting ninja=false in your config.toml.fewer_names in uncached_llvm_typeensure_sufficient_stack() non-generic-C control-flow-guard codegen option, which enables Control Flow Guard for Windows platforms, and is ignored on other platforms.thumbv4t-none-eabi target.RUST_BACKTRACE's output is now more compact.* Refer to Rust‘s platform support page for more information on Rust’s tiered platform support.
CStr now implements Index<RangeFrom<usize>>.std/core are now implemented for arrays of any length, not just those of length less than 33.ops::RangeFull and ops::Range now implement Default.panic::Location now implements Copy, Clone, Eq, Hash, Ord, PartialEq, and PartialOrd.Ident::new_rawRange::is_emptyRangeInclusive::is_emptyResult::as_derefResult::as_deref_mutVec::leakpointer::offset_fromf32::TAUf64::TAUThe following previously stable APIs have now been made const.
new method for all NonZero integers.checked_add,checked_sub,checked_mul,checked_neg, checked_shl, checked_shr, saturating_add, saturating_sub, and saturating_mul methods for all integers.checked_abs, saturating_abs, saturating_neg, and signum for all signed integers.is_ascii_alphabetic, is_ascii_uppercase, is_ascii_lowercase, is_ascii_alphanumeric, is_ascii_digit, is_ascii_hexdigit, is_ascii_punctuation, is_ascii_graphic, is_ascii_whitespace, and is_ascii_control methods for char and u8.build-dependencies are now built with opt-level 0 by default. You can override this by setting the following in your Cargo.toml.[profile.release.build-override] opt-level = 3
cargo-help will now display man pages for commands rather just the --help text.cargo-metadata now emits a test field indicating if a target has tests enabled.workspace.default-members now respects workspace.exclude.cargo-publish will now use an alternative registry by default if it's the only registry specified in package.publish.{} && false in tail expressions.macro_rules! that should help to preserve more span information. These changes may cause compilation errors if your macro was unhygenic or didn't correctly handle Delimiter::None.linux-gnu targets now require minimum kernel 2.6.32 and glibc 2.11.rustc-docs component. This allows you to install and read the documentation for the compiler internal APIs. (Currently only available for x86_64-unknown-linux-gnu.)x.py. You can read details about this change in the “Changes to x.py defaults” post on the Inside Rust blog.if, match, and loop expressions can now be used in const functions.&[T]) in const functions.#[track_caller] attribute can now be added to functions to use the function‘s caller’s location information for panic messages.x.0.0 over (x.0).0.mem::transmute can now be used in statics and constants. Note You currently can't use mem::transmute in constant functions.cdylib target on Apple iOS and tvOS platforms.x86_64-unknown-linux-musl.mem::forget is now a const fn.String now implements From<char>.leading_ones, and trailing_ones methods have been stabilised for all integer types.vec::IntoIter<T> now implements AsRef<[T]>.NonZeroU8) now implement TryFrom for their zero-able equivalent (e.g. TryFrom<u8>).&[T] and &mut [T] now implement PartialEq<Vec<T>>.(String, u16) now implements ToSocketAddrs.vec::Drain<'_, T> now implements AsRef<[T]>.Added a number of new environment variables that are now available when compiling your crate.
CARGO_BIN_NAME and CARGO_CRATE_NAME Providing the name of the specific binary being compiled and the name of the crate.CARGO_PKG_LICENSE The license from the manifest of the package.CARGO_PKG_LICENSE_FILE The path to the license file.abi_blacklist has been renamed to unsupported_abis. The old name will still continue to work.Drop. This was previously accepted but will become a hard error in a future release.#[repr(i128)] or #[repr(u128)]. This representation is currently only allowed on enums.macro_rules! are now always captured. This helps ensure that spans have the correct information, and may cause breakage if you were relying on receiving spans with dummy information.{f32, f64}::asinh now returns the correct values for negative numbers.rustc would erroneously allow you to pass a shorter lifetime than expected.libz (also called zlib) on Linux. The library will need to be installed for rustc to work, even though we expect it to be already available on most systems.#[should_panic] are broken on ARMv7 while running under QEMU.as has been defined as a saturating conversion. This was previously undefined behaviour, but you can use the {f64, f32}::to_int_unchecked methods to continue using the current behaviour, which may be desirable in rare performance sensitive situations.mem::Discriminant<T> now uses T's discriminant type instead of always using u64.macro_rules!) macro.target-feature flag. E.g. -C target-feature=+avx2 -C target-feature=+fma is now equivalent to -C target-feature=+avx2,+fma.force-unwind-tables flag. This option allows rustc to always generate unwind tables regardless of panic strategy.embed-bitcode flag. This codegen flag allows rustc to include LLVM bitcode into generated rlibs (this is on by default).tiny value to the code-model codegen flag.mipsel-sony-psp target.thumbv7a-uwp-windows-msvc target.* Refer to Rust‘s platform support page for more information on Rust’s tiered platform support.
net::{SocketAddr, SocketAddrV4, SocketAddrV6} now implements PartialOrd and Ord.proc_macro::TokenStream now implements Default.char with ops::{Range, RangeFrom, RangeFull, RangeInclusive, RangeTo} to iterate over a range of codepoints. E.g. you can now write the following;for ch in 'a'..='z' { print!("{}", ch); } println!(); // Prints "abcdefghijklmnopqrstuvwxyz"
OsString now implements FromStr.saturating_neg method has been added to all signed integer primitive types, and the saturating_abs method has been added for all integer primitive types.Arc<T>, Rc<T> now implement From<Cow<'_, T>>, and Box now implements From<Cow> when T is [T: Copy], str, CStr, OsStr, or Path.Box<[T]> now implements From<[T; N]>.BitOr and BitOrAssign are implemented for all NonZero integer types.fetch_min, and fetch_max methods have been added to all atomic integer types.fetch_update method has been added to all atomic integer types.Arc::as_ptrBTreeMap::remove_entryRc::as_ptrrc::Weak::as_ptrrc::Weak::from_rawrc::Weak::into_rawstr::strip_prefixstr::strip_suffixsync::Weak::as_ptrsync::Weak::from_rawsync::Weak::into_rawchar::UNICODE_VERSIONSpan::resolved_atSpan::located_atSpan::mixed_siteunix::process::CommandExt::arg0~~outdated information~~ becomes “{f32, f64}::powi now returns a slightly different value on Windows. This is due to changes in LLVM's intrinsics which {f32, f64}::powi uses.lto flag is incompatible with the new embed-bitcode=no. This may cause issues if LTO is enabled through RUSTFLAGS or cargo rustc flags while cargo is adding embed-bitcode itself. The recommended way to control LTO is with Cargo profiles, either in Cargo.toml or .cargo/config, or by setting CARGO_PROFILE_<name>_LTO in the environment.Syntax-only changes
#[cfg(FALSE)] mod foo { mod bar { mod baz; // `foo/bar/baz.rs` doesn't exist, but no error! } }
These are still rejected semantically, so you will likely receive an error but these changes can be seen and parsed by macros and conditional compilation.
-C codegen-units flag in incremental mode. Additionally when in incremental mode rustc defaults to 256 codegen units.catch_unwind to have zero-cost, unless unwinding is enabled and a panic is thrown.aarch64-unknown-none and aarch64-unknown-none-softfloat targets.arm64-apple-tvos and x86_64-apple-tvos targets.vec![] to map directly to Vec::new(). This allows vec![] to be able to be used in const contexts.convert::Infallible now implements Hash.OsString now implements DerefMut and IndexMut returning a &mut OsStr.String now implements From<&mut str>.IoSlice now implements Copy.Vec<T> now implements From<[T; N]>. Where N is at most 32.proc_macro::LexError now implements fmt::Display and Error.from_le_bytes, to_le_bytes, from_be_bytes, to_be_bytes, from_ne_bytes, and to_ne_bytes methods are now const for all integer types.PathBuf::with_capacityPathBuf::capacityPathBuf::clearPathBuf::reservePathBuf::reserve_exactPathBuf::shrink_to_fitf32::to_int_uncheckedf64::to_int_uncheckedLayout::align_toLayout::pad_to_alignLayout::arrayLayout::extendcargo tree command which will print a tree graph of your dependencies. E.g.mdbook v0.3.2 (/Users/src/rust/mdbook) ├── ammonia v3.0.0 │ ├── html5ever v0.24.0 │ │ ├── log v0.4.8 │ │ │ └── cfg-if v0.1.9 │ │ ├── mac v0.1.1 │ │ └── markup5ever v0.9.0 │ │ ├── log v0.4.8 (*) │ │ ├── phf v0.7.24 │ │ │ └── phf_shared v0.7.24 │ │ │ ├── siphasher v0.2.3 │ │ │ └── unicase v1.4.2 │ │ │ [build-dependencies] │ │ │ └── version_check v0.1.5 ...You can also display dependencies on multiple versions of the same crate with
cargo tree -d (short for cargo tree --duplicates)..a extension, rather than the previous .lib.-C no_integrated_as flag from rustc.file_name property in JSON output of macro errors now points the actual source file rather than the previous format of <NAME macros>. Note: this may not point to a file that actually exists on the user's system.mem::{zeroed, uninitialised} will now panic when used with types that do not allow zero initialization such as NonZeroU8. This was previously a warning.f64 to u32 using the as operator has been defined as a saturating operation. This was previously undefined behaviour, but you can use the {f64, f32}::to_int_unchecked methods to continue using the current behaviour, which may be desirable in rare performance sensitive situations.These changes provide no direct user facing benefits, but represent significant improvements to the internals and overall performance of rustc and related tools.
cargo package --list not working with unpublished dependencies.&{number} (e.g. &1.0) not having the type inferred correctly.#[cfg()] can now be used on if expressions.Syntax only changes
type Foo: Ord syntactically.self in all fn contexts.fn syntax + cleanup item parsing.item macro fragments can be interpolated into traits, impls, and extern blocks. For example, you may now write:macro_rules! mac_trait { ($i:item) => { trait T { $i } } } mac_trait! { fn foo() {} }
These are still rejected semantically, so you will likely receive an error but these changes can be seen and parsed by macros and conditional compilation.
rustc -D unused -A unused-variables denies everything in the unused lint group except unused-variables which is explicitly allowed. However, passing rustc -A unused-variables -D unused denies everything in the unused lint group including unused-variables since the allow flag is specified before the deny flag (and therefore overridden).windows-gnu.Arc<[T; N]>, Box<[T; N]>, and Rc<[T; N]>, now implement TryFrom<Arc<[T]>>,TryFrom<Box<[T]>>, and TryFrom<Rc<[T]>> respectively. Note These conversions are only available when N is 0..=32.u32::MAX or f32::NAN with no imports.u8::is_ascii is now const.String now implements AsMut<str>.primitive module to std and core. This module reexports Rust's primitive types. This is mainly useful in macros where you want avoid these types being shadowed.HashMap and HashSet.string::FromUtf8Error now implements Clone + Eq.[profile]s in your .cargo/config, or through your environment.CARGO_BIN_EXE_<name> pointing to a binary's executable path when running integration tests or benchmarks. <name> is the name of your binary as-is e.g. If you wanted the executable path for a binary named my-programyou would use env!("CARGO_BIN_EXE_my-program").const_err lint were deemed unrelated to const evaluation, and have been moved to the unconditional_panic and arithmetic_overflow lints.assert! macro is now a hard error. This has been a warning since 1.36.0.Self not having the correctly inferred type. This incorrectly led to some instances being accepted, and now correctly emits a hard error.These changes provide no direct user facing benefits, but represent significant improvements to the internals and overall performance of rustc and related tools.
opt-level=3 instead of 2.#[inline]-ing certain hot functions.Drop terminators for enum variants without drop glueYou can now use the slice pattern syntax with subslices. e.g.
fn foo(words: &[&str]) { match words { ["Hello", "World", "!", ..] => println!("Hello World!"), ["Foo", "Bar", ..] => println!("Baz"), rest => println!("{:?}", rest), } }
You can now use #[repr(transparent)] on univariant enums. Meaning that you can create an enum that has the exact layout and ABI of the type it contains.
You can now use outer attribute procedural macros on inline modules.
There are some syntax-only changes:
default is syntactically allowed before items in trait definitions.impls (i.e. consts, types, and fns) may syntactically leave out their bodies in favor of ;.impls are now syntactically allowed (e.g. type Foo: Ord;).... (the C-variadic type) may occur syntactically directly as the type of any function parameter.These are still rejected semantically, so you will likely receive an error but these changes can be seen and parsed by procedural macros and conditional compilation.
armv7a-none-eabi.riscv64gc-unknown-linux-gnu.Option::{expect,unwrap} and Result::{expect, expect_err, unwrap, unwrap_err} now produce panic messages pointing to the location where they were called, rather than core's internals. * Refer to Rust‘s platform support page for more information on Rust’s tiered platform support.
iter::Empty<T> now implements Send and Sync for any T.Pin::{map_unchecked, map_unchecked_mut} no longer require the return type to implement Sized.io::Cursor now derives PartialEq and Eq.Layout::new is now const.riscv64gc-unknown-linux-gnu.CondVar::wait_whileCondVar::wait_timeout_whileDebugMap::keyDebugMap::valueManuallyDrop::takematches!ptr::slice_from_raw_parts_mutptr::slice_from_raw_partsError::description has been deprecated, and its use will now produce a warning. It's recommended to use Display/to_string instead.Copy implsLayout::repeatimpl<T> From<Foo> for Vec<T> {}.self position. E.g. you can now write fn foo(self: Box<Box<Self>>) {}. Previously only Self, &Self, &mut Self, Arc<Self>, Rc<Self>, and Box<Self> were allowed.format_args macro. Previously identifiers starting with an underscore were not allowed.pub) are now syntactically allowed on trait items and enum variants. These are still rejected semantically, but can be seen and parsed by procedural macros and conditional compilation.extern "C" function with Box<T> and use T* as the corresponding type on the C side. Please see the documentation for more information, including the important caveat about preferring to avoid Box<T> in Rust signatures for functions defined in C.'labels.i686-unknown-dragonfly target.riscv64gc-unknown-linux-gnu target.@path syntax to rustc. Note that the format differs somewhat from what is found in other tooling; please see the documentation for more information.--extern flag without a path, indicating that it is available from the search path or specified with an -L flag.* Refer to Rust‘s platform support page for more information on Rust’s tiered platform support.
core::panic module is now stable. It was already stable through std.NonZero* numerics now implement From<NonZero*> if it's a smaller integer width. E.g. NonZeroU16 now implements From<NonZeroU8>.MaybeUninit<T> now implements fmt::Debug.Result::map_orResult::map_or_elsestd::rc::Weak::weak_countstd::rc::Weak::strong_countstd::sync::Weak::weak_countstd::sync::Weak::strong_countcargo-install will now reinstall the package if it detects that it is out of date.[profile.dev.package.image] opt-level = 2 sets the image crate's optimisation level to 2 for debug builds. You can also use [profile.<profile>.build-override] to override build scripts and their dependencies.edition in documentation code blocks to compile the block for that edition. E.g. edition2018 tells rustdoc that the code sample should be compiled the 2018 edition of Rust.--theme, and check the current theme with --check-theme.#[cfg(doc)] to compile an item when building documentation.You can now use tuple structs and tuple enum variant's constructors in const contexts. e.g.
pub struct Point(i32, i32); const ORIGIN: Point = { let constructor = Point; constructor(0, 0) };
You can now mark structs, enums, and enum variants with the #[non_exhaustive] attribute to indicate that there may be variants or fields added in the future. For example this requires adding a wild-card branch (_ => {}) to any match statements on a non-exhaustive enum. (RFC 2008)
You can now use function-like procedural macros in extern blocks and in type positions. e.g. type Generated = macro!();
The meta pattern matcher in macro_rules! now correctly matches the modern attribute syntax. For example (#[$m:meta]) now matches #[attr], #[attr{tokens}], #[attr[tokens]], and #[attr(tokens)].
thumbv7neon-unknown-linux-musleabihf target.aarch64-unknown-none-softfloat target.mips64-unknown-linux-muslabi64, and mips64el-unknown-linux-muslabi64 targets.* Refer to Rust‘s platform support page for more information on Rust’s tiered platform support.
BTreeMap::get_key_valueHashMap::get_key_valueOption::as_deref_mutOption::as_derefOption::flattenUdpSocket::peer_addrf32::to_be_bytesf32::to_le_bytesf32::to_ne_bytesf64::to_be_bytesf64::to_le_bytesf64::to_ne_bytesf32::from_be_bytesf32::from_le_bytesf32::from_ne_bytesf64::from_be_bytesf64::from_le_bytesf64::from_ne_bytesmem::takeslice::repeattodo!--all-features) passed to a virtual workspace will now produce an error. Previously these flags were ignored.dev-dependencies without including a version.include! macro will now warn if it failed to include the entire file. The include! macro unintentionally only includes the first expression in a file, and this can be unintuitive. This will become either a hard error in a future release, or the behavior may be fixed to include all expressions as expected.#[inline] on function prototypes and consts now emits a warning under unused_attribute lint. Using #[inline] anywhere else inside traits or extern blocks now correctly emits a hard error.async functions and blocks with async fn, async move {}, and async {} respectively, and you can now call .await on async expressions.cfg, cfg_attr, allow, warn, deny, forbid as well as inert helper attributes used by procedural macro attributes applied to items. e.g.fn len( #[cfg(windows)] slice: &[u16], #[cfg(not(windows))] slice: &[u8], ) -> usize { slice.len() }
if guards of match arms. e.g.fn main() { let array: Box<[u8; 4]> = Box::new([1, 2, 3, 4]); match array { nums // ---- `nums` is bound by move. if nums.iter().sum::<u8>() == 10 // ^------ `.iter()` implicitly takes a reference to `nums`. => { drop(nums); // ----------- Legal as `nums` was bound by move and so we have ownership. } _ => unreachable!(), } }
i686-unknown-uefi target.sparc64-unknown-openbsd target.--show-output argument to test binaries to print the output of successful tests.* Refer to Rust‘s platform support page for more information on Rust’s tiered platform support.
Vec::new and String::new are now const functions.LinkedList::new is now a const function.str::len, [T]::len and str::as_bytes are now const functions.abs, wrapping_abs, and overflowing_abs numeric functions are now const.version.--all flag has been renamed to --workspace. Using --all is now deprecated.rustdoc now requires rustc to be installed and in the same directory to run tests. This should improve performance when running a large amount of doctests.try! macro will now issue a deprecation warning. It is recommended to use the ? operator instead.asinh(-0.0) now correctly returns -0.0. Previously this returned 0.0.#[global_allocator] attribute can now be used in submodules.#[deprecated] attribute can now be used on macros.rustc. This will improve compilation times in some cases. For further information please refer to the “Evaluating pipelined rustc compilation” thread.aarch64-uwp-windows-msvc, i686-uwp-windows-gnu, i686-uwp-windows-msvc, x86_64-uwp-windows-gnu, and x86_64-uwp-windows-msvc targets.armv7-unknown-linux-gnueabi and armv7-unknown-linux-musleabi targets.hexagon-unknown-linux-musl target.riscv32i-unknown-none-elf target.* Refer to Rust‘s platform support page for more information on Rust’s tiered platform support.
ascii::EscapeDefault now implements Clone and Display.Clone, Debug, Hash) are now available at the same path as the trait. (e.g. The Clone derive macro is available at std::clone::Clone). This also makes all built-in macros available in std/core root. e.g. std::include_bytes!.str::Chars now implements Debug.slice::{concat, connect, join} now accepts &[T] in addition to &T.*const T and *mut T now implement marker::Unpin.Arc<[T]> and Rc<[T]> now implement FromIterator<T>.div_euclid, rem_euclid) to all numeric primitives. Additionally checked, overflowing, and wrapping versions are available for all integer primitives.thread::AccessError now implements Clone, Copy, Eq, Error, and PartialEq.iter::{StepBy, Peekable, Take} now implement DoubleEndedIterator.<*const T>::cast<*mut T>::castDuration::as_secs_f32Duration::as_secs_f64Duration::div_f32Duration::div_f64Duration::from_secs_f32Duration::from_secs_f64Duration::mul_f32Duration::mul_f64any::type_namecargo.--features option multiple times to enable multiple features.x86_64-unknown-uefi platform can not be built with rustc 1.38.0.armv7-unknown-linux-gnueabihf platform is known to have issues with certain crates such as libc.#[must_use] will now warn if the type is contained in a tuple, Box, or an array and unused.cfg and cfg_attr attributes on generic parameters.type MyOption = Option<u8>; fn increment_or_zero(x: MyOption) -> u8 { match x { MyOption::Some(y) => y + 1, MyOption::None => 0, } }
_ as an identifier for consts. e.g. You can write const _: u32 = 5;.#[repr(align(X)] on enums.? Kleene macro operator is now available in the 2015 edition.-C profile-generate and -C profile-use flags. For more information on how to use profile guided optimization, please refer to the rustc book.rust-lldb wrapper script should now work again.BufReader::bufferBufWriter::bufferCell::from_mutCell<[T]>::as_slice_of_cellsDoubleEndedIterator::nth_backOption::xorWrapping::reverse_bitsi128::reverse_bitsi16::reverse_bitsi32::reverse_bitsi64::reverse_bitsi8::reverse_bitsisize::reverse_bitsslice::copy_withinu128::reverse_bitsu16::reverse_bitsu32::reverse_bitsu64::reverse_bitsu8::reverse_bitsusize::reverse_bitsCargo.lock files are now included by default when publishing executable crates with executables.default-run="foo" in [package] to specify the default executable to use for cargo run.... for inclusive range patterns will now warn by default. Please transition your code to using the ..= syntax for inclusive ranges instead.dyn will now warn by default. Please transition your code to use dyn Trait for trait objects instead.dyn Send + fmt::Debug is now equivalent to dyn fmt::Debug + Send, where this was previously not the case.HashMap's implementation has been replaced with hashbrown::HashMap implementation.TryFromSliceError now implements From<Infallible>.mem::needs_drop is now available as a const fn.alloc::Layout::from_size_align_unchecked is now available as a const fn.String now implements BorrowMut<str>.io::Cursor now implements Default.NonNull::{dangling, cast} are now const fns.alloc crate is now stable. alloc allows you to use a subset of std (e.g. Vec, Box, Arc) in #![no_std] environments if the environment has access to heap memory allocation.String now implements From<&String>.dbg! macro. dbg! will return a tuple of each argument when there is multiple arguments.Result::{is_err, is_ok} are now #[must_use] and will produce a warning if not used.VecDeque::rotate_leftVecDeque::rotate_rightIterator::copiedio::IoSliceio::IoSliceMutRead::read_vectoredWrite::write_vectoredstr::as_mut_ptrmem::MaybeUninitpointer::align_offsetfuture::Futuretask::Contexttask::RawWakertask::RawWakerVTabletask::Wakertask::Poll--offline flag to run cargo without accessing the network.You can find further change's in Cargo's 1.36.0 release notes.
There have been numerous additions and fixes to clippy, see Clippy's 1.36.0 release notes for more details.
mem::MaybeUninit, mem::uninitialized use is no longer recommended, and will be deprecated in 1.39.0.FnOnce, FnMut, and the Fn traits are now implemented for Box<FnOnce>, Box<FnMut>, and Box<Fn> respectively.unsafe fn call_unsafe(func: unsafe fn()) { func() } pub fn main() { unsafe { call_unsafe(|| {}); } }
armv6-unknown-freebsd-gnueabihf and armv7-unknown-freebsd-gnueabihf targets.wasm32-unknown-wasi target.Thread will now show its ID in Debug output.StdinLock, StdoutLock, and StderrLock now implement AsRawFd.alloc::System now implements Default.Debug output ({:#?}) for structs now has a trailing comma on the last field.char::{ToLowercase, ToUppercase} now implement ExactSizeIterator.NonZero numeric types now implement FromStr.Read trait bounds on the BufReader::{get_ref, get_mut, into_inner} methods.dbg! macro without any parameters to print the file and line where it is called.str::make_ascii_lowercasehash_map::{OccupiedEntry, VacantEntry} now implement Sync and Send.f32::copysignf64::copysignRefCell::replace_withRefCell::map_splitptr::hashRange::containsRangeFrom::containsRangeTo::containsRangeInclusive::containsRangeToInclusive::containsOption::copiedcargo:rustc-cdylib-link-arg at build time to pass custom linker arguments when building a cdylib. Its usage is highly platform specific.redundant_closure Clippy lintmissing_const_for_fn Clippy lint#[deprecated = "reason"] as a shorthand for #[deprecated(note = "reason")]. This was previously allowed by mistake but had no effect.#[attr()],#[attr[]], and #[attr{}] procedural macros.extern crate self as foo; to import your crate's root into the extern prelude.riscv64imac-unknown-none-elf and riscv64gc-unknown-none-elf.-C linker-plugin-lto. This allows rustc to compile your Rust code into LLVM bitcode allowing LLVM to perform LTO optimisations across C/C++ FFI boundaries.powerpc64-unknown-freebsd.HashMap<K, V, S>'s and HashSet<T, S>'s basic methods. Most notably you no longer require the Hash trait to create an iterator.Ord trait bounds have been removed on some of BinaryHeap<T>'s basic methods. Most notably you no longer require the Ord trait to create an iterator.overflowing_neg and wrapping_neg are now const functions for all numeric types.str is now generic over all types that implement SliceIndex<str>.str::trim, str::trim_matches, str::trim_{start, end}, and str::trim_{start, end}_matches are now #[must_use] and will produce a warning if their returning type is unused.checked_pow, saturating_pow, wrapping_pow, and overflowing_pow are now available for all numeric types. These are equivalent to methods such as wrapping_add for the pow operation.Any::type_idError::type_idatomic::AtomicI16atomic::AtomicI32atomic::AtomicI64atomic::AtomicI8atomic::AtomicU16atomic::AtomicU32atomic::AtomicU64atomic::AtomicU8convert::Infallibleconvert::TryFromconvert::TryIntoiter::from_fniter::successorsnum::NonZeroI128num::NonZeroI16num::NonZeroI32num::NonZeroI64num::NonZeroI8num::NonZeroIsizeslice::sort_by_cached_keystr::escape_debugstr::escape_defaultstr::escape_unicodestr::split_ascii_whitespaceCommand::before_exec is being replaced by the unsafe method Command::pre_exec and will be deprecated with Rust 1.37.0.ATOMIC_{BOOL, ISIZE, USIZE}_INIT is now deprecated as you can now use const functions in static variables.cfg(target_vendor) attribute. E.g. #[cfg(target_vendor="apple")] fn main() { println!("Hello Apple!"); }u8 that covers 0..=255 and you would no longer be required to have a _ => unreachable!() case.if let and while let expressions. You can do this with the same syntax as a match expression. E.g.enum Creature { Crab(String), Lobster(String), Person(String), } fn main() { let state = Creature::Crab("Ferris"); if let Creature::Crab(name) | Creature::Person(name) = state { println!("This creature's name is: {}", name); } }
if let and while let patterns. Using this feature will by default produce a warning as this behaviour can be unintuitive. E.g. if let _ = 5 {}let bindings, assignments, expression statements, and irrefutable pattern destructuring in const functions.const unsafe fn foo() -> i32 { 5 } const fn bar() -> i32 { unsafe { foo() } }
cfg_attr attribute. E.g. #[cfg_attr(all(), must_use, optimize)]#[repr(packed)] attribute. E.g. #[repr(packed(2))] struct Foo(i16, i32); is a struct with an alignment of 2 bytes and a size of 6 bytes._. This allows you to import a trait's impls, and not have the name in the namespace. E.g.use std::io::Read as _; // Allowed as there is only one `Read` in the module. pub trait Read {}
Rc, Arc, and Pin as method receivers.rustc with the -Clinker-flavor command line argument.x86_64-fortanix-unknown-sgx target support has been upgraded to tier 2 support. Visit the platform support page for information on Rust's platform support.thumbv7neon-linux-androideabi and thumbv7neon-unknown-linux-gnueabihf targets.x86_64-unknown-uefi target.overflowing_{add, sub, mul, shl, shr} are now const functions for all numeric types.rotate_left, rotate_right, and wrapping_{add, sub, mul, shl, shr} are now const functions for all numeric types.is_positive and is_negative are now const functions for all signed numeric types.get method for all NonZero types is now const.count_ones, count_zeros, leading_zeros, trailing_zeros, swap_bytes, from_be, from_le, to_be, to_le are now const for all numeric types.Ipv4Addr::new is now a const functionunix::FileExt::read_exact_atunix::FileExt::write_all_atOption::transposeResult::transposeconvert::identitypin::Pinmarker::Unpinmarker::PhantomPinnedVec::resize_withVecDeque::resize_withDuration::as_millisDuration::as_microsDuration::as_nanoscargo publish --features or cargo publish --all-features.str::{trim_left, trim_right, trim_left_matches, trim_right_matches} are now deprecated in the standard library, and their usage will now produce a warning. Please use the str::{trim_start, trim_end, trim_start_matches, trim_end_matches} methods instead.Error::cause method has been deprecated in favor of Error::source which supports downcasting.--test-threads=1. It also runs the tests in deterministic order? operator in macro definitions. The ? operator allows you to specify zero or one repetitions similar to the * and + operators.super, self, or crate, will now always resolve to the item (enum, struct, etc.) available in the module if present, before resolving to a external crate or an item the prelude. E.g.enum Color { Red, Green, Blue } use Color::*;
PhantomData<T> types.literal specifier. This will match against a literal of any type. E.g. 1, 'A', "Hello World"struct Point(i32, i32); impl Point { pub fn new(x: i32, y: i32) -> Self { Self(x, y) } pub fn is_origin(&self) -> bool { match self { Self(0, 0) => true, _ => false, } } }
enum List<T> where Self: PartialOrd<Self> // can write `Self` instead of `List<T>` { Nil, Cons(T, Box<Self>) // likewise here }
#[must_use]. This provides a warning if a impl Trait or dyn Trait is returned and unused in the program.aarch64-pc-windows-msvc target.PathBuf now implements FromStr.Box<[T]> now implements FromIterator<T>.dbg! macro has been stabilized. This macro enables you to easily debug expressions in your rust program. E.g.let a = 2; let b = dbg!(a * 2) + 1; // ^-- prints: [src/main.rs:4] a * 2 = 4 assert_eq!(b, 5);
The following APIs are now const functions and can be used in a const context.
Cell::as_ptrUnsafeCell::getchar::is_asciiiter::emptyManuallyDrop::newManuallyDrop::into_innerRangeInclusive::startRangeInclusive::endNonNull::as_ptrslice::as_ptrstr::as_ptrDuration::as_secsDuration::subsec_millisDuration::subsec_microsDuration::subsec_nanosCStr::as_ptrIpv4Addr::is_unspecifiedIpv6Addr::newIpv6Addr::octetsi8::to_be_bytesi8::to_le_bytesi8::to_ne_bytesi8::from_be_bytesi8::from_le_bytesi8::from_ne_bytesi16::to_be_bytesi16::to_le_bytesi16::to_ne_bytesi16::from_be_bytesi16::from_le_bytesi16::from_ne_bytesi32::to_be_bytesi32::to_le_bytesi32::to_ne_bytesi32::from_be_bytesi32::from_le_bytesi32::from_ne_bytesi64::to_be_bytesi64::to_le_bytesi64::to_ne_bytesi64::from_be_bytesi64::from_le_bytesi64::from_ne_bytesi128::to_be_bytesi128::to_le_bytesi128::to_ne_bytesi128::from_be_bytesi128::from_le_bytesi128::from_ne_bytesisize::to_be_bytesisize::to_le_bytesisize::to_ne_bytesisize::from_be_bytesisize::from_le_bytesisize::from_ne_bytesu8::to_be_bytesu8::to_le_bytesu8::to_ne_bytesu8::from_be_bytesu8::from_le_bytesu8::from_ne_bytesu16::to_be_bytesu16::to_le_bytesu16::to_ne_bytesu16::from_be_bytesu16::from_le_bytesu16::from_ne_bytesu32::to_be_bytesu32::to_le_bytesu32::to_ne_bytesu32::from_be_bytesu32::from_le_bytesu32::from_ne_bytesu64::to_be_bytesu64::to_le_bytesu64::to_ne_bytesu64::from_be_bytesu64::from_le_bytesu64::from_ne_bytesu128::to_be_bytesu128::to_le_bytesu128::to_ne_bytesu128::from_be_bytesu128::from_le_bytesu128::from_ne_bytesusize::to_be_bytesusize::to_le_bytesusize::to_ne_bytesusize::from_be_bytesusize::from_le_bytesusize::from_ne_bytes_mm256_stream_si256, _mm256_stream_pd, _mm256_stream_ps have been changed from *const to *mut as the previous implementation was unsound.powerpc-unknown-netbsdimpl<'a> Reader for BufReader<'a> {} can now be impl Reader for BufReader<'_> {}. Lifetimes are still required to be defined in structs.const functions. These are currently a strict minimal subset of the const fn RFC. Refer to the language reference for what exactly is available.#[allow(clippy::filter_map)].#[no_mangle] and #[export_name] attributes can now be located anywhere in a crate, not just in exported functions.num::NonZero* types to their raw equivalents using the From trait. E.g. u8 now implements From<NonZeroU8>.&Option<T> into Option<&T> and &mut Option<T> into Option<&mut T> using the From trait.*) a time::Duration by a u32.slice::align_toslice::align_to_mutslice::chunks_exactslice::chunks_exact_mutslice::rchunksslice::rchunks_mutslice::rchunks_exactslice::rchunks_exact_mutOption::replacepackage key in your dependencies.r#), e.g. let r#for = true;crate in paths. This allows you to refer to the crate root in the path, e.g. use crate::foo; refers to foo in src/lib.rs.::. Previously, using a external crate in a module without a use statement required let json = ::serde_json::from_str(foo); but can now be written as let json = serde_json::from_str(foo);.#[used] attribute to static items to prevent the compiler from optimising them away, even if they appear to be unused, e.g. #[used] static FOO: u32 = 1;use syntax. Macros exported with #[macro_export] are now placed into the root module of the crate. If your macro relies on calling other local macros, it is recommended to export with the #[macro_export(local_inner_macros)] attribute so users won't have to import those macros.pub, pub(crate)) in macros using the vis specifier.#[attr("true")], and you can now write #[attr(true)].#[panic_handler] attribute.riscv32imc-unknown-none-elf target.aarch64-unknown-netbsd targetThe following methods are replacement methods for trim_left, trim_right, trim_left_matches, and trim_right_matches, which will be deprecated in 1.33.0:
cargo run doesn't require specifying a package in workspaces.cargo doc now supports --message-format=json. This is equivalent to calling rustdoc --error-format=json.rustdoc allows you to specify what edition to treat your code as with the --edition option.rustdoc now has the --color (specify whether to output color) and --error-format (specify error format, e.g. json) options.rust-gdbgui script that invokes gdbgui with Rust debug symbols.rustfmt or clippy are now available, e.g. #[rustfmt::skip] will skip formatting the next item.rls-preview component on the windows-gnu targets has been restored.The standard library's str::repeat function contained an out of bounds write caused by an integer overflow. This has been fixed by deterministically panicking when an overflow happens.
Thank you to Scott McMurray for responsibly disclosing this vulnerability to us.
powerpc64le-unknown-linux-musl target.aarch64-unknown-hermit and x86_64-unknown-hermit targets.Once::call_once no longer requires Once to be 'static.BuildHasherDefault now implements PartialEq and Eq.Box<CStr>, Box<OsStr>, and Box<Path> now implement Clone.PartialEq<&str> for OsString and PartialEq<OsString> for &str.Cell<T> now allows T to be unsized.SocketAddr is now stable on Redox.--locked to disable this behavior.cargo-install will now allow you to cross compile an install using --target.cargo-fix subcommand to automatically move project code from 2015 edition to 2018.cargo doc can now optionally document private types using the --document-private-items flag.rustdoc now has the --cap-lints option which demotes all lints above the specified level to that level. For example --cap-lints warn will demote deny and forbid lints to warn.rustc and rustdoc will now have the exit code of 1 if compilation fails and 101 if there is a panic.rustup component add clippy-preview.str::{slice_unchecked, slice_unchecked_mut} are now deprecated. Use str::get_unchecked(begin..end) instead.std::env::home_dir is now deprecated for its unintuitive behavior. Consider using the home_dir function from https://crates.io/crates/dirs instead.rustc will no longer silently ignore invalid data in target spec.cfg attributes and --cfg command line flags are now more strictly validated.#[repr(transparent)] attribute is now stable. This attribute allows a Rust newtype wrapper (struct NewType<T>(T);) to be represented as the inner type across Foreign Function Interface (FFI) boundaries.pure, sizeof, alignof, and offsetof have been unreserved and can now be used as identifiers.GlobalAlloc trait and #[global_allocator] attribute are now stable. This will allow users to specify a global allocator for their program.#[test] attribute can now return Result<(), E: Debug> in addition to ().lifetime specifier for macro_rules! is now stable. This allows macros to easily target lifetimes.s and z optimisation levels are now stable. These optimisations prioritise making smaller binary sizes. z is the same as s with the exception that it does not vectorise loops, which typically results in an even smaller binary.--error-format=short this option will provide a more compressed output of rust error messages.macro_exports.Default for &mut str.From<bool> for all integer and unsigned number types.Extend for ().Debug implementation of time::Duration should now be more easily human readable. Previously a Duration of one second would printed as Duration { secs: 1, nanos: 0 } and will now be printed as 1s.From<&String> for Cow<str>, From<&Vec<T>> for Cow<[T]>, From<Cow<CStr>> for CString, From<CString>, From<CStr>, From<&CString> for Cow<CStr>, From<OsString>, From<OsStr>, From<&OsString> for Cow<OsStr>, From<&PathBuf> for Cow<Path>, and From<Cow<Path>> for PathBuf.Shl and Shr for Wrapping<u128> and Wrapping<i128>.DirEntry::metadata now uses fstatat instead of lstat when possible. This can provide up to a 40% speed increase.format!.Iterator::step_byPath::ancestorsSystemTime::UNIX_EPOCHalloc::GlobalAllocalloc::Layoutalloc::LayoutErralloc::Systemalloc::allocalloc::alloc_zeroedalloc::deallocalloc::reallocalloc::handle_alloc_errorbtree_map::Entry::or_defaultfmt::Alignmenthash_map::Entry::or_defaultiter::repeat_withnum::NonZeroUsizenum::NonZeroU128num::NonZeroU16num::NonZeroU32num::NonZeroU64num::NonZeroU8ops::RangeBoundsslice::SliceIndexslice::from_mutslice::from_ref{Any + Send + Sync}::downcast_mut{Any + Send + Sync}::downcast_ref{Any + Send + Sync}::issrc directory. The src directory in a crate should be considered to be immutable.suggestion_applicability field in rustc's json output is now stable. This will allow dev tools to check whether a code suggestion would apply to them.trait Trait {} impl Trait + Send { fn test(&self) { println!("one"); } //~ ERROR duplicate definitions with name `test` } impl Trait + Send + Send { fn test(&self) { println!("two"); } }
rustdoc would execute plugins in the /tmp/rustdoc/plugins directory when running, which enabled executing code as some other user on a given machine. This release fixes that vulnerability; you can read more about this on the blog. The associated CVE is CVE-2018-1000622.
Thank you to Red Hat for responsibly disclosing this vulnerability to us.
proc to be used as an identifier.Trait syntax, and should make it clearer when being used in tandem with impl Trait because it is equivalent to the following syntax: &Trait == &dyn Trait, &mut Trait == &mut dyn Trait, and Box<Trait> == Box<dyn Trait>.fn foo<#[lifetime_attr] 'a, #[type_attr] T: 'a>() {}#[must_use] attribute can now also be used on functions as well as types. It provides a lint that by default warns users when the value returned by a function has not been used.arch::x86 & arch::x86_64 modules which contain SIMD intrinsics, a new macro called is_x86_feature_detected!, the #[target_feature(enable="")] attribute, and adding target_feature = "" to the cfg attribute.[u8], f32, and f64 previously only available in std are now available in core.Rhs type parameter on ops::{Shl, ShlAssign, Shr} now defaults to Self.std::str::replace now has the #[must_use] attribute to clarify that the operation isn't done in place.Clone::clone, Iterator::collect, and ToOwned::to_owned now have the #[must_use] attribute to warn about unused potentially expensive allocations.DoubleEndedIterator::rfindDoubleEndedIterator::rfoldDoubleEndedIterator::try_rfoldDuration::from_microsDuration::from_nanosDuration::subsec_microsDuration::subsec_millisHashMap::remove_entryIterator::try_foldIterator::try_for_eachNonNull::castOption::filterString::replace_rangeTake::set_limithint::unreachable_uncheckedos::unix::process::parent_idptr::swap_nonoverlappingslice::rsplit_mutslice::rsplitslice::swap_with_slicecargo-metadata now includes authors, categories, keywords, readme, and repository fields.cargo-metadata now includes a package's metadata table.--target-dir optional argument. This allows you to specify a different directory than target for placing compilation artifacts.[[bin]], and have other binaries in locations where cargo would infer a binary, Cargo will produce a warning. You can disable this feature ahead of time by setting any of the following to false: autobins, autobenches, autoexamples, autotests.CARGO_CACHE_RUSTC_INFO=0 in your environment.doc.rust-lang.org are now searchable.CharExt or StrExt method directly on core will no longer work. e.g. ::core::prelude::v1::StrExt::is_empty("") will not compile, "".is_empty() will still compile.Debug output on atomic::{AtomicBool, AtomicIsize, AtomicPtr, AtomicUsize} will only print the inner type. E.g. print!("{:?}", AtomicBool::new(true)) will print true, not AtomicBool(true).repr(align(N)) is now 2²⁹. Previously you could enter higher numbers but they were not supported by LLVM. Up to 512MB alignment should cover all use cases..description() method on the std::error::Error trait has been soft-deprecated. It is no longer required to implement it.fn main() -> impl Trait no longer works for non-Termination trait. This reverts an accidental stabilization.NaN > NaN no longer returns true in const-fn contexts.impl Trait in method arguments.Copy and/or Clone if all captured variables implement either or both traits.for x in 0..=10 is now stable.'_ lifetime is now stable. The underscore lifetime can be used anywhere a lifetime can be elided.impl Trait is now stable allowing you to have abstract types in returns or in function parameters. E.g. fn foo() -> impl Iterator<Item=u8> or fn open(path: impl AsRef<Path>).u128 and i128 are now stable.main can now return Result<(), E: Debug> in addition to ().let points = [1, 2, 3, 4]; match points { [1, 2, 3, 4] => println!("All points were sequential."), _ => println!("Not all points were sequential."), }
wasm32-unknown-unknown.--remap-path-prefix option to rustc. Allowing you to remap path prefixes outputted by the compiler.powerpc-unknown-netbsd target.From<u16> for usize & From<{u8, i16}> for isize.assert!(format!("{:02x?}", b"Foo\0") == "[46, 6f, 6f, 00]")Default, Hash for cmp::Reverse.str::repeat being 8x faster in large cases.ascii::escape_default is now available in libcore.Copy, Clone for cmp::ReverseClone for char::{ToLowercase, ToUppercase}.*const T::add*const T::copy_to_nonoverlapping*const T::copy_to*const T::read_unaligned*const T::read_volatile*const T::read*const T::sub*const T::wrapping_add*const T::wrapping_sub*mut T::add*mut T::copy_to_nonoverlapping*mut T::copy_to*mut T::read_unaligned*mut T::read_volatile*mut T::read*mut T::replace*mut T::sub*mut T::swap*mut T::wrapping_add*mut T::wrapping_sub*mut T::write_bytes*mut T::write_unaligned*mut T::write_volatile*mut T::writeBox::leakFromUtf8Error::as_bytesLocalKey::try_withOption::clonedbtree_map::Entry::and_modifyfs::read_to_stringfs::readfs::writehash_map::Entry::and_modifyiter::FusedIteratorops::RangeInclusiveops::RangeToInclusiveprocess::idslice::rotate_leftslice::rotate_rightString::retain-v is passed with --listFn trait as dyn no longer works. E.g. the following syntax is now invalid.use std::ops::Fn as dyn;
fn g(_: Box<dyn(std::fmt::Debug)>) {}
'static. e.g.fn main() { const PAIR: &(i32, i32) = &(0, 1); let _reversed_pair: &'static _ = &(PAIR.1, PAIR.0); // Doesn't work }
AsciiExt trait in favor of inherent methods.".e0" will now no longer parse as 0.0 and will instead cause an error.#[repr(align(x))] attribute is now stable. RFC 1358use std::{fs::File, io::Read, path::{Path, PathBuf}};| at the start of a match arm. e.g.enum Foo { A, B, C } fn main() { let x = Foo::A; match x { | Foo::A | Foo::B => println!("AB"), | Foo::C => println!("C"), } }
process::Command on Unix.ParseCharError.UnsafeCell::into_inner is now safe.Float::{from_bits, to_bits} is now available in libcore.AsRef<Path> for ComponentWrite for Cursor<&mut Vec<u8>>Duration to libcore.The following functions can now be used in a constant expression. eg. static MINUTE: Duration = Duration::from_secs(60);
cargo new no longer removes rust or rs prefixes/suffixes.cargo new now defaults to creating a binary crate, instead of a library crate.net::lookup_host.rustdoc has switched to pulldown as the default markdown renderer.#[simd].sysv64 ffi is now available. eg. extern "sysv64" fn foo () {}codegen-units=1.armv4t-unknown-linux-gnueabi target.aarch64-unknown-openbsd supportstr::find::<char> now uses memchr. This should lead to a 10x improvement in performance in the majority of cases.OsStr's Debug implementation is now lossless and consistent with Windows.time::{SystemTime, Instant} now implement Hash.From<bool> for AtomicBoolFrom<{CString, &CStr}> for {Arc<CStr>, Rc<CStr>}From<{OsString, &OsStr}> for {Arc<OsStr>, Rc<OsStr>}From<{PathBuf, &Path}> for {Arc<Path>, Rc<Path>}AsciiExt methods onto charT: Sized requirement on ptr::is_null()From<RecvError> for {TryRecvError, RecvTimeoutError}f32::{min, max} to generate more efficient x86 assembly[u8]::contains now uses memchr which provides a 3x speed improvementThe following functions can now be used in a constant expression. eg. let buffer: [u8; size_of::<usize>()];, static COUNTER: AtomicUsize = AtomicUsize::new(1);
AtomicBool::newAtomicUsize::newAtomicIsize::newAtomicPtr::newCell::new{integer}::min_value{integer}::max_valuemem::size_ofmem::align_ofptr::nullptr::null_mutRefCell::newUnsafeCell::newworkspace.default-members config that overrides implied --all in virtual workspaces.Cargo.toml and .cargo/config to disable on a per-project or global basis respectively.Debug impl now always prints a decimal point.Ipv6Addr now rejects superfluous ::'s in IPv6 addresses This is in accordance with IETF RFC 4291 §2.2.Formatter::flags method is now deprecated. The sign_plus, sign_minus, alternate, and sign_aware_zero_pad should be used instead.column!() macro is one-based instead of zero-basedfmt::Arguments can no longer be shared across threads#[repr(packed)] struct fields is now unsafeauto traits are now permitted in trait objects.TrapUnreachable in LLVM which should mitigate the impact of undefined behavior.assert_eq/ne macroFrom<*mut T> for AtomicPtr<T>From<usize/isize> for AtomicUsize/AtomicIsize.T: Sync requirement for RwLock<T>: SendT: Sized requirement for {<*const T>, <*mut T>}::as_ref and <*mut T>::as_mutThread::{park, unpark} implementationSliceExt::binary_search performance.FromIterator<()> for ()AsciiExt trait methods to primitive types. Use of AsciiExt is now deprecated.cargo uninstall foo bar uninstalls foo and bar.cargo checkcargo install --versionchar::escape_debug now uses Unicode 10 over 9.non_snake_case lint now allows extern no-mangle functionsT op= &T now works for numeric types. eg. let mut x = 2; x += &8;Drop are now allowed in const and static typesle32-unknown-naclarmv5te_unknown_linux_gnueabiBox<Error> now impls From<Cow<str>>std::mem::Discriminant is now guaranteed to be Send + Syncfs::copy now returns the length of the main stream on NTFS.Instant += Duration.Hasher for {&mut Hasher, Box<Hasher>}fmt::Debug for SplitWhitespace.Option<T> now impls Try This allows for using ? with Option types.examples folder that have a main.rs file.[root] to [package] in Cargo.lock Packages with the old format will continue to work and can be updated with cargo update.libbacktrace is now available on Apple platforms.compile_fail attribute for code fences in doc-comments. This now lets you specify that a given code example will fail to compile.4.0 from 2.3T op= &T for numeric types has broken some type inference casesfn main() { let x: &'static u32 = &0; }
:: before < is now allowed in all contexts. Example:my_macro!(Vec<i32>::new); // Always worked my_macro!(Vec::<i32>::new); // Now works
Clone for all arrays and tuples that are T: CloneStdin, Stdout, and Stderr now implement AsRawFd.Rc and Arc now implement From<&[T]> where T: Clone, From<str>, From<String>, From<Box<T>> where T: ?Sized, and From<Vec<T>>.cargo install with multiple package names--all[patch] section to Cargo.toml to handle prepublication dependencies RFC 1969include & exclude fields in Cargo.toml now accept gitignore like patterns--all-targets optionrustup component add rls-previewstd::os documentation for Unix, Linux, and Windows now appears on doc.rust-lang.org Previously only showed std::os::unix.CodeMap struct which required the unstable library libsyntax to correctly use.unused_results lint no longer ignores booleanswasm32-experimental-emscripten target.msp430-none-elf target.{HashMap,BTreeMap}::{Keys,Values}.PartialEq, Eq, PartialOrd, Ord, Debug, Hash for unsized tuples.fmt::{Display, Debug} for Ref, RefMut, MutexGuard, RwLockReadGuard, RwLockWriteGuardClone for DefaultHasher.Sync for SyncSender.FromStr for char{f32, f64}::{is_sign_negative, is_sign_positive} handles NaN.unimplemented!() macro. ie. unimplemented!("Waiting for 1.21 to be stable")pub(restricted) is now supported in the thread_local! macro.{f32, f64}::{min, max} in Rust instead of using CMath.ops::{Range, RangeFrom} is now done in O(1) time#[repr(align(N))] attribute max number is now 2^31 - 1. This was previously 2^15.{OsStr, Path}::Display now avoids allocations where possibleCStr::into_c_stringCString::as_c_strCString::into_boxed_c_strChain::get_mutChain::get_refChain::into_innerOption::get_or_insert_withOption::get_or_insertOsStr::into_os_stringOsString::into_boxed_os_strTake::get_mutTake::get_refUtf8Error::error_lenchar::EscapeDebugchar::escape_debugcompile_error!f32::from_bitsf32::to_bitsf64::from_bitsf64::to_bitsmem::ManuallyDropslice::sort_unstable_by_keyslice::sort_unstable_byslice::sort_unstablestr::from_boxed_utf8_uncheckedstr::as_bytes_mutstr::as_bytes_mutstr::from_utf8_mutstr::from_utf8_unchecked_mutstr::get_mutstr::get_unchecked_mutstr::get_uncheckedstr::getstr::into_boxed_bytes~/.cargo/config to ~/.cargo/credentials.main.rs binaries that are in sub-directories of src/bin. ie. Having src/bin/server/main.rs and src/bin/client/main.rs generates target/debug/server and target/debug/clientcargo install using --vers.--no-fail-fast flag to cargo to run all benchmarks regardless of failure.'static in their return types will now not be as usable as if they were using lifetime parameters instead.{f32, f64}::is_sign_{negative, positive} now takes the sign of NaN into account where previously didn't.struct Point(u32, u32); let x = Point { 0: 7, 1: 0 };.loop can now return a value with break. RFC 1624 For example: let x = loop { break 7; };unions are now available. RFC 1444 They can only contain Copy types and cannot have a Drop implementation. Example: union Foo { bar: u8, baz: usize }fns, RFC 1558 Example: let foo: fn(u8) -> u8 = |v: u8| { v };arm-linux-androideabi to correspond to the armeabi official ABI. If you wish to continue targeting the armeabi-v7a ABI you should use --target armv7-linux-androideabi.aborting due to previous error(s) instead of aborting due to N previous errors This was previously inaccurate and would only count certain kinds of errors.target-feature=+crt-static option RFC 1721 Which allows libraries with C Run-time Libraries(CRT) to be statically linked.String now implements FromIterator<Cow<'a, str>> and Extend<Cow<'a, str>>Vec now implements From<&mut [T]>Box<[u8]> now implements From<Box<str>>SplitWhitespace now implements Clone[u8]::reverse is now 5x faster and [u16]::reverse is now 1.5x fastereprint! and eprintln! macros added to prelude. Same as the print! macros, but for printing to stderr.println!("cargo:rustc-env=FOO=bar");--all flag to the cargo bench subcommand to run benchmarks of all the members in a given workspace.libssh2-sys to 0.2.6--exclude option for excluding certain packages when using the --all option--features option now accepts multiple comma or space delimited values.rust-windbg.cmd for loading rust .natvis files in the Windows Debugger.# in rust documentation By adding additional #'s ie. ## is now #MutexGuard<T> may only be Sync if T is Sync.-Z flags are now no longer allowed to be used on the stable compiler. This has been a warning for a year previous to this.-Z flag change, the cargo-check plugin no longer works. Users should migrate to the built-in check command, which has been available since 1.16.._ is now a hard error. Example: 42._ .extern crate outside of its module is now a hard error. This was previously a warning.use ::self::foo; is now a hard error. self paths are always relative while the :: prefix makes a path absolute, but was ignored and the path was relative regardless.PartialEq & Eq used match patterns is now a hard error This was previously a warning.'_ are no longer allowed. This was previously a warning.#s are now visibleVCINSTALLDIR is set incorrectly, rustc will try to use it to find the linker, and the build will fail where it did not previouslypub can now accept a module path to make the item visible to just that module tree. Also accepts the keyword crate to make something public to the whole crate but not users of the library. Example: pub(crate) mod utils;. RFC 1422.#![windows_subsystem] attribute conservative exposure of the /SUBSYSTEM linker flag on Windows platforms. RFC 1665.ty in macros can accept types like Write + Send, trailing + are now supported in trait objects, and better error reporting for trait objects starting with ?Sized.repr attribute or with #[repr(Rust)] are reordered to minimize padding and produce a smaller representation in some cases.--emit mirVec::from_iter being passed vec::IntoIter if the iterator hasn't been advanced the original Vec is reassembled with no actual iteration or reallocation.AtomicBool::fetch_nandChild::try_waitHashMap::retainHashSet::retainPeekMut::popTcpStream::peekUdpSocket::peekUdpSocket::peek_fromcargo new --vcs pijul--bins and --tests flags now you can build all programs of a certain type, for example cargo build --bins will build all binaries.--enable-commonmark flag# at the start of filesChanges to how the 0 flag works in format! Padding zeroes are now always placed after the sign if it exists and before the digits. With the # flag the zeroes are placed after the prefix and before the digits.
Due to the struct field optimisation, using transmute on structs that have no repr attribute or #[repr(Rust)] will no longer work. This has always been undefined behavior, but is now more likely to break in practice.
The refactor of trait object type parsing fixed a bug where + was receiving the wrong priority parsing things like &for<'a> Tr<'a> + Send as &(for<'a> Tr<'a> + Send) instead of (&for<'a> Tr<'a>) + Send
rustc main.rs -o out --emit=asm,llvm-ir Now will output out.asm and out.ll instead of only one of the filetypes.
calling a function that returns Self will no longer work when the size of Self cannot be statically determined.
rustc now builds with a “pthreads” flavour of MinGW for Windows GNU this has caused a few regressions namely:
'static. RFC 1623Self may be included in the where clause of impls. RFC 1647T and U when T: Unsize<U>. For example, coercing &mut [&'a X; N] to &mut [&'b X] requires 'a be equal to 'b. Soundness fix.[], automatically coerce--emit dep-info-C relocation-model more correctly determine whether the linker creates a position-independent executable-C overflow-checks to directly control whether integer overflow panicsSelf to appear in impl where clauses.usepanic=abort&str + &strArc::into_rawArc::from_rawArc::ptr_eqRc::into_rawRc::from_rawRc::ptr_eqOrdering::thenOrdering::then_withBTreeMap::rangeBTreeMap::range_mutcollections::Boundprocess::abortptr::read_unalignedptr::write_unalignedResult::expect_errCell::swapCell::replaceCell::into_innerCell::takeBTreeMap and BTreeSet can iterate over rangesCell can store non-Copy types. RFC 1651String implements FromIterator<&char>Box implements a number of new conversions: From<Box<str>> for String, From<Box<[T]>> for Vec<T>, From<Box<CStr>> for CString, From<Box<OsStr>> for OsString, From<Box<Path>> for PathBuf, Into<Box<str>> for String, Into<Box<[T]>> for Vec<T>, Into<Box<CStr>> for CString, Into<Box<OsStr>> for OsString, Into<Box<Path>> for PathBuf, Default for Box<str>, Default for Box<CStr>, Default for Box<OsStr>, From<&CStr> for Box<CStr>, From<&OsStr> for Box<OsStr>, From<&Path> for Box<Path>ffi::FromBytesWithNulError implements Error and DisplayPartialOrd<A> for [A] where A: Ordslice::sortToString trait specialization for Cow<'a, str> and StringBox<[T]> implements From<&[T]> where T: Copy, Box<str> implements From<&str>IpAddr implements From for various arrays. SocketAddr implements From<(I, u16)> where I: Into<IpAddr>format! estimates the needed capacity before writing a stringPathBuf implements DefaultPartialEq<[A]> for VecDeque<A>HashMap resizes adaptively to guard against DOS attacks and poor hash functions.cargo check --allcargo run --packagerequired_featuresbuild.rs is a build scriptworkspace_root link in containing memberrustbooki128rustc is linked statically on Windows MSVC targets, allowing it to run without installing the MSVC runtime.rustdoc --test includes file names in test namesstd for sparc64-unknown-linux-gnu, aarch64-unknown-linux-fuchsia, and x86_64-unknown-linux-fuchsia.aarch64-unknown-freebsdi686-unknown-netbsdTypeId implements PartialOrd and Ord--test-threads=0 produces an errorrustup installs documentation by defaultT and U when T: Unsize<U>, e.g. coercing &mut [&'a X; N] to &mut [&'b X] requires 'a be equal to 'b. Soundness fix.format! and Display::to_string panic if an underlying formatting implementation returns an error. Previously the error was silently ignored. It is incorrect for write_fmt to return an error when writing to a string.proc_macro_deriveshr_lifetime_in_assoc_type future-compatibility lint has been in effect since April of 2016.dead_code lint now accounts for type aliases.self in an import listSelf may appear in impl headersSelf may appear in struct expressionsrustc now supports --emit=metadata, which causes rustc to emit a .rmeta file containing only crate metadata. This can be used by tools like the Rust Language Service to perform metadata-only builds.transmute::<T, U> where T requires a bigger alignment than Urustc no longer attempts to provide “consider using an explicit lifetime” suggestions. They were inaccurate.VecDeque::truncateVecDeque::resizeString::insert_strDuration::checked_addDuration::checked_subDuration::checked_divDuration::checked_mulstr::replacenstr::repeatSocketAddr::is_ipv4SocketAddr::is_ipv6IpAddr::is_ipv4IpAddr::is_ipv6Vec::dedup_byVec::dedup_by_keyResult::unwrap_or_default<*const T>::wrapping_offset<*mut T>::wrapping_offsetCommandExt::creation_flagsFile::set_permissionsString::split_off[T]::binary_search and [T]::binary_search_by_key now take their argument by Borrow parameterDebugIpAddr implements From<Ipv4Addr> and From<Ipv6Addr>Ipv6Addr implements From<[u16; 8]>Stdin.read() when reading from the console on WindowsLineWriter&str slicing errorsTcpListener::set_only_v6 is deprecated. This functionality cannot be achieved in std currently.writeln!, like println!, now accepts a form with no string or formatting arguments, to just print a newlineiter::Sum and iter::Product for Resultstd_unicode::tableschar::EscapeDebug, EscapeDefault, EscapeUnicode, CaseMappingIter, ToLowercase, ToUppercase, implement DisplayDuration implements SumString implements ToSocketAddrscargo check command does a type check of a project without building itdebug, in addition to true and false. These are passed to rustc as the value to -C debuginfocargo --version --verbosebuild --alldoc --allrustdoc has a --sysroot argument that, like rustc, specifies the path to the Rust implementationarmv7-linux-androideabi target no longer enables NEON extensions, per Google's ABI guidedead_code lint now accounts for type aliases.Stdin.read() when reading from the console on Windowsself in an import list#[derive], aka “macros 1.1”, are stable. This allows popular code-generating crates like Serde and Diesel to work ergonomically. RFC 1681.legacy_imports lint since 1.14, with no known regressions.macro_rules, path fragments can now be parsed as type parameter bounds?Sized can be used in where clauses#![type_size_limit] crate attribute, similarly to the #![recursion_limit] attribute--test flag works with procedural macro cratesextern "aapcs" fn ABI-C no-stack-check flag is deprecated. It does nothing.format! expander recognizes incorrect printf and shell-style formatting directives and suggests the correct format.mk_ty calls in Ty::super_fold_withmk_ty calls in Ty::super_fold_withUnificationTable::probescope_auxiliary to cut RSS by 10%HirVec<P<T>> to HirVec<T> in hir::Exprstd::iter::Iterator::min_bystd::iter::Iterator::max_bystd::os::*::fs::FileExtstd::sync::atomic::Atomic*::get_mutstd::sync::atomic::Atomic*::into_innerstd::vec::IntoIter::as_slicestd::vec::IntoIter::as_mut_slicestd::sync::mpsc::Receiver::try_iterstd::os::unix::process::CommandExt::before_execstd::rc::Rc::strong_countstd::rc::Rc::weak_countstd::sync::Arc::strong_countstd::sync::Arc::weak_countstd::char::encode_utf8std::char::encode_utf16std::cell::Ref::clonestd::io::Take::into_innerIterator::nth no longer has a Sized boundExtend<&T> is specialized for Vec where T: Copy to improve performance.chars().count() is much faster and so are chars().last() and char_indices().last()std::env::argsfmt::DebugDefault for Durationmpsc::RecvTimeoutError implements ErrorOUT_DIR environment variable at build time via env!("OUT_DIR"). They should instead check the variable at runtime with std::env. That the value was set at build time was a bug, and incorrect when cross-compiling. This change is known to cause breakage.--all flag to cargo testcargo install --vers to take a semver versionbuild.rustflags config keybuild.rs in the same directory as Cargo.toml is a build script--message-format JSON when rustc emits non-JSON warnings--test) now support a --list argument that lists the tests it contains--exact argument that makes the test filter match exactly, instead of matching only a substring of the test name--playground-url flag#[should_panic] errors--disable-rustbuild to the configure script, but they will be deleted soon. Note that the new build system uses a different on-disk layout that will likely affect any scripts building Rust.legacy_imports lint since 1.14, with no known regressions.OUT_DIR environment variable at build time via env!("OUT_DIR"). They should instead check the variable at runtime with std::env. That the value was set at build time was a bug, and incorrect when cross-compiling. This change is known to cause breakage.hr_lifetime_in_assoc_type lint has been a warning since 1.10 and is now an error by default. It will become a hard error in the near future.legacy_directory_ownership lint, which is a warning in this release, and will become a hard error in the future.Peekable peeks a None it will return that None without re-querying the underlying iterator.. matches multiple tuple fields in enum variants, structs and tuples. RFC 1492.fn items can be coerced to unsafe fn pointersuse * and use ::* both glob-import from the crate rootVec<Box<Fn()>> without explicit dereferencingstatic mut names are linted like other statics and consts[u8; m!()])x”--version --verboseExpr_::ExprInlineAsmIchHasherSmallVector in CombineFields::instantiateArrayVec and AccumulateVec to reduce heap allocations during interning of sliceswrite_metadataCrateConfig clonesSubsts::super_fold_withObligationForest's NodeState handlingplug_leaksprintln!(), with no arguments, prints newline. Previously, an empty string was required to achieve the same.Wrapping impls standard binary and unary operators, as well as the Sum and Product iteratorsFrom<Cow<str>> for String and From<Cow<[T]>> for Vec<T>fold performance for chain, cloned, map, and VecDeque iteratorsSipHasher performance on small values.zip() specialization to .map() and .cloned()ReadDir implements DebugRefUnwindSafe for atomic typesVec::extend to Vec::extend_from_sliceDecoder::read_strio::Error implements From<io::ErrorKind>Debug for raw pointers to unsized dataHashMap random seedsHashMap is more cache-friendly, for significant improvements in some operationsHashMap uses less memory on 32-bit architecturesAdd<{str, Cow<str>}> for Cow<str>CARGO_HOMEreplace sections from lock filespanic configuration for test/bench profilesrustup target add. The new target triples are:mips-unknown-linux-gnumipsel-unknown-linux-gnumips64-unknown-linux-gnuabi64mips64el-unknown-linux-gnuabi64 powerpc-unknown-linux-gnupowerpc64-unknown-linux-gnupowerpc64le-unknown-linux-gnus390x-unknown-linux-gnu rustup target add:arm-unknown-linux-musleabiarm-unknown-linux-musleabihfarmv7-unknown-linux-musleabihfwasm32-unknown-emscripten target. This target is known to have major defects. Please test, report, and fix.rustup component add rust-docs to install.#[derive(PartialEq, Eq)]”'_ were erroneously allowed”Ordering enum may not be matched exhaustively#[no_link] breaks some obscure cases$crate macro variable is accepted in fewer locations? operator. ? is a simple way to propagate errors, like the try! macro, described in RFC 0243.#[derive] for empty tuple structs/variants-C link-arg argumentuse self when such an import resolvesassert_ne! and debug_assert_ne!vec_deque::Drain, hash_map::Drain, and hash_set::Drain covariantAsRef<[T]> for std::slice::IterDebug for std::vec::IntoIterCString: avoid excessive growth just to 0-terminateCoerceUnsized for {Cell, RefCell, UnsafeCell}Debug for std::path::{Components,Iter}charDebug for DirEntrygetaddrinfo returns EAI_SYSTEM retrieve actual error from errnoSipHasher is deprecated. Use DefaultHasher.std::io::ErrorKindVec::extend_from_slice, extend_with_elementcargo packagecargo installCommandExt::exec for cargo run on Unix--sysroot argument! from macro URLs and titlesSipHasher is deprecated. Use DefaultHasher.#[derive] for empty tuple structs/variants. Part of RFC 1506.ethcore crate fails with LLVM errorrustc translates code to LLVM IR via its own “middle” IR (MIR). This translation pass is far simpler than the previous AST->LLVM pass, and creates opportunities to perform new optimizations directly on the MIR. It was previously described on the Rust blog.rustc presents a new, more readable error format, along with machine-readable JSON error output for use by IDEs. Most common editors supporting Rust have been updated to work with it. It was previously described on the Rust blog.rustc translates code to LLVM IR via its own “middle” IR (MIR). This translation pass is far simpler than the previous AST->LLVM pass, and creates opportunities to perform new optimizations directly on the MIR. It was previously described on the Rust blog.--print target-listTypeId is correct in some cases where it was previously producing inconsistent resultsmips-unknown-linux-gnu target uses hardware floating point by defaultrustc arguments, --print target-cpus, --print target-features, --print relocation-models, and --print code-models print the available options to the -C target-cpu, -C target-feature, -C relocation-model and -C code-model code generation argumentsrustc supports three new MUSL targets on ARM: arm-unknown-linux-musleabi, arm-unknown-linux-musleabihf, and armv7-unknown-linux-musleabihf. These targets produce statically-linked binaries. There are no binary release builds yet though.rustc presents a new, more readable error format, along with machine-readable JSON error output for use by IDEs. Most common editors supporting Rust have been updated to work with it. It was previously described on the Rust blog.{integer} or {float} instead of _rustc emits a clearer error when inner attributes follow a doc commentmacro_rules! invocations can be made within macro_rules! invocationsmacro_rules! meta-variables are hygienicmacro_rules! tt matchers can be reparsed correctly, making them much more usefulmacro_rules! stmt matchers correctly consume the entire contents when inside non-braces invocationsmacro_rules! invocationscfg_attr works on path attributesCell::as_ptrRefCell::as_ptrIpAddr::is_unspecifiedIpAddr::is_loopbackIpAddr::is_multicastIpv4Addr::is_unspecifiedIpv6Addr::octetsLinkedList::containsVecDeque::containsExitStatusExt::from_raw. Both on Unix and Windows.Receiver::recv_timeoutRecvTimeoutErrorBinaryHeap::peek_mutPeekMutiter::Productiter::SumOccupiedEntry::remove_entryVacantEntry::into_keyformat! macro and friends now allow a single argument to be formatted in multiple styles[T]::binary_search_by and [T]::binary_search_by_key have been adjusted to be more flexibleOption implements From for its contained typeCell, RefCell and UnsafeCell implement From for their contained typeRwLock panics if the reader count overflowsvec_deque::Drain, hash_map::Drain and hash_set::Drain are covariantvec::Drain and binary_heap::Drain are covariantCow<str> implements FromIterator for char, &str and StringSOCK_CLOEXEChash_map::Entry, hash_map::VacantEntry and hash_map::OccupiedEntry implement Debugbtree_map::Entry, btree_map::VacantEntry and btree_map::OccupiedEntry implement DebugString implements AddAssignextern fn pointers implement the Clone, PartialEq, Eq, PartialOrd, Ord, Hash, fmt::Pointer, and fmt::Debug traitsFileType implements DebugMutex and RwLock are unwind-safempsc::sync_channel Receivers return any available message before reporting a disconnectenv iterators implement DoubleEndedIteratoropt-level="s" / opt-level="z" in profile overridescargo doc --open --target work as expected--panic=abort with plugins-C metadata to the compiler--lib flag to cargo newhttp.cainfo for custom certs--features--jobs flag to cargo package--dry-run to cargo publishRUSTDOCFLAGSpanic::catch_unwind is more optimizedpanic::catch_unwind no longer accesses thread-local storage on entry--test-threads argument to specify the number of threads used to run tests, and which acts the same as the RUST_TEST_THREADS environment variablerust-lldb warns about unsupported versions of LLDBrustup component add rust-src. The resulting source code can be used by tools and IDES, located in the sysroot under lib/rustlib/src.OsStrs, unpaired surrogate codepoints are escaped with the lowercase format instead of the uppercaseDebug impl for strings no longer escapes all non-ASCII characterscfg_attr attributes#[macro_use] works properly when it is itself expanded from a macroBinaryHeap::appendBTreeMap::appendBTreeMap::split_offBTreeSet::appendBTreeSet::split_offf32::to_degrees (in libcore - previously stabilized in libstd)f32::to_radians (in libcore - previously stabilized in libstd)f64::to_degrees (in libcore - previously stabilized in libstd)f64::to_radians (in libcore - previously stabilized in libstd)Iterator::sumIterator::productCell::get_mutRefCell::get_mutthread_local! macro supports multiple definitions in a single invocation, and can apply attributesCow implements DefaultWrapping implements binary, octal, lower-hex and upper-hex Display formattingHashlookup_host ignores unknown address typesassert_eq! accepts a custom error message, like assert! doesharness = false on [lib] sectionslinks contains a ‘.’-vv prints warnings for all crates.package.metadata keys. This provides room for expansion by arbitrary tools.cargo doc --open on WindowsHashMap hasher is SipHash 1-3 instead of SipHash 2-4 This hasher is faster, but is believed to provide sufficient protection from collision attacks.Ipv4Addr is 10x fasterconsts and statics may not have unsized typesmacro_rules! in order to ensure syntax forward-compatibility have been enabled This was an amendment to RFC 550, and has been a warning since 1.10.cfg attribute process has been refactored to fix various bugs. This causes breakage in some corner cases.Copy types are required to have a trivial implementation of Clone. RFC 1521.#[repr(..)] attribute.#[derive(RustcEncodable)] in the presence of other encode methods.panic! can be converted to a runtime abort with the -C panic=abort flag. RFC 1513.os::windows::fs::OpenOptionsExt::access_modeos::windows::fs::OpenOptionsExt::share_modeos::windows::fs::OpenOptionsExt::custom_flagsos::windows::fs::OpenOptionsExt::attributesos::windows::fs::OpenOptionsExt::security_qos_flagsos::unix::fs::OpenOptionsExt::custom_flagssync::Weak::newDefault for sync::Weakpanic::set_hookpanic::take_hookpanic::PanicInfopanic::PanicInfo::payloadpanic::PanicInfo::locationpanic::Locationpanic::Location::filepanic::Location::lineffi::CStr::from_bytes_with_nulffi::CStr::from_bytes_with_nul_uncheckedffi::FromBytesWithNulErrorfs::Metadata::modifiedfs::Metadata::accessedfs::Metadata::createdsync::atomic::Atomic{Usize,Isize,Bool,Ptr}::compare_exchangesync::atomic::Atomic{Usize,Isize,Bool,Ptr}::compare_exchange_weakcollections::{btree,hash}_map::{Occupied,Vacant,}Entry::keyos::unix::net::{UnixStream, UnixListener, UnixDatagram, SocketAddr}SocketAddr::is_unnamedSocketAddr::as_pathnameUnixStream::connectUnixStream::pairUnixStream::try_cloneUnixStream::local_addrUnixStream::peer_addrUnixStream::set_read_timeoutUnixStream::set_write_timeoutUnixStream::read_timeoutUnixStream::write_timeoutUnixStream::set_nonblockingUnixStream::take_errorUnixStream::shutdownUnixStreamUnixListener::bindUnixListener::acceptUnixListener::try_cloneUnixListener::local_addrUnixListener::set_nonblockingUnixListener::take_errorUnixListener::incomingUnixListenerUnixDatagram::bindUnixDatagram::unboundUnixDatagram::pairUnixDatagram::connectUnixDatagram::try_cloneUnixDatagram::local_addrUnixDatagram::peer_addrUnixDatagram::recv_fromUnixDatagram::recvUnixDatagram::send_toUnixDatagram::sendUnixDatagram::set_read_timeoutUnixDatagram::set_write_timeoutUnixDatagram::read_timeoutUnixDatagram::write_timeoutUnixDatagram::set_nonblockingUnixDatagram::take_errorUnixDatagram::shutdownUnixDatagram{BTree,Hash}Map::values_mut<[_]>::binary_search_by_keyabs_sub method of floats is deprecated. The semantics of this minor method are subtle and probably not what most people want.HashMaps can't be initialized with getrandom they will fall back to /dev/urandom temporarily to avoid blocking during early boot.Clone for binary_heap::IntoIter.Display and Hash for std::num::Wrapping.Default implementation for &CStr, CString.From<Vec<T>> and Into<Vec<T>> for VecDeque<T>.Default for UnsafeCell, fmt::Error, Condvar, Mutex, RwLock.profile.*.panic option. This controls the runtime behavior of the panic! macro and can be either “unwind” (the default), or “abort”. RFC 1513.-p arguments.CARGO_MANIFEST_LINKS environment variable that corresponds to the links field of the manifest.CARGO_HOME on Windows.net.retry value in .cargo/config.--force flag to cargo install.flock on NFS mounts.cargo install artifacts in temporary directories. Makes it possible to install multiple crates in parallel.cargo test --doc.cargo --explain.-q is passed.cargo doc --lib and --bin.HashMaps by caching the random keys used to initialize the hash state.find implementation for Chain iterators is 2x faster.#[derive(Copy, Clone)] to avoid bloat.fn type.&mut self to &mut mut self.std no longer prints backtraces on platforms where the running module must be loaded with env::current_exe, which can't be relied on.rust-gdb and rust-lldb scripts are distributed on all Unix platforms.libc::abort instead of generating an illegal instruction.AtomicBool is now bool-sized, not word-sized.target_env for Linux ARM targets is just gnu, not gnueabihf, gnueabi, etc.Duration::new.String::truncate to panic less.:block to the follow set for :ty and :path. Affects how macros are parsed.#[deprecated] attribute when applied to an API will generate warnings when used. The warnings may be suppressed with #[allow(deprecated)]. RFC 1270.fn item types are zero sized, and each fn names a unique type. This will break code that transmutes fns, so calling transmute on a fn type will generate a warning for a few cycles, then will be converted to an error.PATTERN_WHITE_SPACE category to be whitespace.std::panicstd::panic::catch_unwind (renamed from recover)std::panic::resume_unwind (renamed from propagate)std::panic::AssertUnwindSafe (renamed from AssertRecoverSafe)std::panic::UnwindSafe (renamed from RecoverSafe)str::is_char_boundary<*const T>::as_ref<*mut T>::as_ref<*mut T>::as_mutAsciiExt::make_ascii_uppercaseAsciiExt::make_ascii_lowercasechar::decode_utf16char::DecodeUtf16char::DecodeUtf16Errorchar::DecodeUtf16Error::unpaired_surrogateBTreeSet::takeBTreeSet::replaceBTreeSet::getHashSet::takeHashSet::replaceHashSet::getOsString::with_capacityOsString::clearOsString::capacityOsString::reserveOsString::reserve_exactOsStr::is_emptyOsStr::lenstd::os::unix::threadRawPthreadJoinHandleExtJoinHandleExt::as_pthread_tJoinHandleExt::into_pthread_tHashSet::hasherHashMap::hasherCommandExt::execFile::try_cloneSocketAddr::set_ipSocketAddr::set_portSocketAddrV4::set_ipSocketAddrV4::set_portSocketAddrV6::set_ipSocketAddrV6::set_portSocketAddrV6::set_flowinfoSocketAddrV6::set_scope_idslice::copy_from_sliceptr::read_volatileptr::write_volatileOpenOptions::create_newTcpStream::set_nodelayTcpStream::nodelayTcpStream::set_ttlTcpStream::ttlTcpStream::set_only_v6TcpStream::only_v6TcpStream::take_errorTcpStream::set_nonblockingTcpListener::set_ttlTcpListener::ttlTcpListener::set_only_v6TcpListener::only_v6TcpListener::take_errorTcpListener::set_nonblockingUdpSocket::set_broadcastUdpSocket::broadcastUdpSocket::set_multicast_loop_v4UdpSocket::multicast_loop_v4UdpSocket::set_multicast_ttl_v4UdpSocket::multicast_ttl_v4UdpSocket::set_multicast_loop_v6UdpSocket::multicast_loop_v6UdpSocket::set_multicast_ttl_v6UdpSocket::multicast_ttl_v6UdpSocket::set_ttlUdpSocket::ttlUdpSocket::set_only_v6UdpSocket::only_v6UdpSocket::join_multicast_v4UdpSocket::join_multicast_v6UdpSocket::leave_multicast_v4UdpSocket::leave_multicast_v6UdpSocket::take_errorUdpSocket::connectUdpSocket::sendUdpSocket::recvUdpSocket::set_nonblockingstd::sync::Once is poisoned if its initialization function fails.cell::Ref and cell::RefMut can contain unsized types.fmt::Debug.BufReader and BufWriter was reduced to 8K, from 64K. This is in line with the buffer size used by other languages.Instant, SystemTime and Duration implement += and -=. Duration additionally implements *= and /=.Skip is a DoubleEndedIterator.From<[u8; 4]> is implemented for Ipv4Addr.Chain implements BufRead.HashMap, HashSet and iterators are covariant.CARGO_PKG_AUTHORS environment variable.RUSTFLAGS variable to rustc on the commandline. rustc arguments can also be specified in the build.rustflags configuration key.ToString is specialized for str, giving it the same performance as to_owned.Command::output no longer creates extra threads.#[derive(PartialEq)] and #[derive(PartialOrd)] emit less code for C-like enums.--quiet flag to a test runner will produce much-abbreviated output.mips-unknown-linux-musl, mipsel-unknown-linux-musl, and i586-pc-windows-msvc targets.std::sync::Once is poisoned if its initialization function fails.impl blocks.fn item types are zero sized, and each fn names a unique type. This will break code that transmutes fns, so calling transmute on a fn type will generate a warning for a few cycles, then will be converted to an error.+= by implementing the AddAssign, SubAssign, MulAssign, DivAssign, RemAssign, BitAndAssign, BitOrAssign, BitXorAssign, ShlAssign, or ShrAssign traits. RFC 953.struct Foo { }, in addition to the non-braced form, struct Foo;. RFC 218.str::encode_utf16 (renamed from utf16_units)str::EncodeUtf16 (renamed from Utf16Units)Ref::mapRefMut::mapptr::drop_in_placetime::Instanttime::SystemTimeInstant::nowInstant::duration_since (renamed from duration_from_earlier)Instant::elapsedSystemTime::nowSystemTime::duration_since (renamed from duration_from_earlier)SystemTime::elapsedAdd/Sub impls for Time and SystemTimeSystemTimeErrorSystemTimeError::durationSystemTimeErrorUNIX_EPOCHAddAssign, SubAssign, MulAssign, DivAssign, RemAssign, BitAndAssign, BitOrAssign, BitXorAssign, ShlAssign, ShrAssign.write! and writeln! macros correctly emit errors if any of their arguments can't be formatted.raw modules, which contain a number of redefined C types are deprecated, including os::raw::unix, os::raw::macos, and os::raw::linux. These modules defined types such as ino_t and dev_t. The inconsistency of these definitions across platforms was making it difficult to implement std correctly. Those that need these definitions should use the libc crate. RFC 1415.MetadataExt traits, including os::unix::fs::MetadataExt, which expose values such as inode numbers no longer return platform-specific types, but instead return widened integers. RFC 1415.btree_set::{IntoIter, Iter, Range} are covariant.sync::mpsc implement fmt::Debug.--print targets flag prints a list of supported targets.--print cfg flag prints the cfgs defined for the current target.rustc can be built with an new Cargo-based build system, written in Rust. It will eventually replace Rust's Makefile-based build system. To enable it configure with configure --rustbuild.match patterns now list up to 3 missing variants while also indicating the total number of missing variants if more than 3.armv7-unknown-linux-gnueabihf, powerpc-unknown-linux-gnu, powerpc64-unknown-linux-gnu, powerpc64le-unknown-linux-gnu x86_64-rumprun-netbsd. These can be installed with tools such as multirust.cargo init creates a new Cargo project in the current directory. It is otherwise like cargo new.-v and --color. verbose and color, respectively, go in the [term] section of .cargo/config.build.jobs key can be set via CARGO_BUILD_JOBS. Environment variables take precedence over config files.cfg syntax for describing targets so that dependencies for multiple targets can be specified together. RFC 1361.CARGO_TARGET_ROOT, RUSTC, and RUSTDOC take precedence over the build.target-dir, build.rustc, and build.rustdoc configuration values.build.target configuration value sets the target platform, like --target.-Z flags have been considered unstable, and other flags that were considered unstable additionally required passing -Z unstable-options to access. Unlike unstable language and library features though, these options have been accessible on the stable release channel. Going forward, new unstable flags will not be available on the stable release channel, and old unstable flags will warn about their usage. In the future, all unstable flags will be unavailable on the stable release channel.match on empty enum variants using the Variant(..) syntax. This has been a warning since 1.6.MetadataExt traits, including os::unix::fs::MetadataExt, which expose values such as inode numbers no longer return platform-specific types, but instead return widened integers. RFC 1415.--cfg compiler flags are parsed strictly as identifiers.Command::spawn and its equivalents return an error if any of its command-line arguments contain interior NULs.rustc emits .lib files for the staticlib library type instead of .a files. Additionally, for the MSVC toolchain, rustc emits import libraries named foo.dll.lib instead of foo.lib.PathPath::strip_prefix (renamed from relative_from)path::StripPrefixError (new error type returned from strip_prefix)Ipv4AddrIpv6AddrVecString<[T]>::clone_from_slice, which now requires the two slices to be the same length<[T]>::sort_by_keyi32::checked_rem, i32::checked_neg, i32::checked_shl, i32::checked_shri32::saturating_muli32::overflowing_add, i32::overflowing_sub, i32::overflowing_mul, i32::overflowing_divi32::overflowing_rem, i32::overflowing_neg, i32::overflowing_shl, i32::overflowing_shru32::checked_rem, u32::checked_neg, u32::checked_shl, u32::checked_shlu32::saturating_mulu32::overflowing_add, u32::overflowing_sub, u32::overflowing_mul, u32::overflowing_divu32::overflowing_rem, u32::overflowing_neg, u32::overflowing_shl, u32::overflowing_shrffi::IntoStringErrorCString::into_stringCString::into_bytesCString::into_bytes_with_nulFrom<CString> for Vec<u8>IntoStringErrorIntoStringError::into_cstringIntoStringError::utf8_errorError for IntoStringErrorStrings and strs from bytes is faster.LineWriter (and thus io::stdout) was improved by using memchr to search for newlines.f32::to_degrees and f32::to_radians are stable. The f64 variants were stabilized previously.BTreeMap was rewritten to use less memory and improve the performance of insertion and iteration, the latter by as much as 5x.BTreeSet and its iterators, Iter, IntoIter, and Range are covariant over their contained type.LinkedList and its iterators, Iter and IntoIter are covariant over their contained type.str::replace now accepts a Pattern, like other string searching methods.Any is implemented for unsized types.Hash is implemented for Duration.--test, rustdoc will pass --cfg arguments to the compiler.rustc when installed in unusual configurations without configuring the dynamic linker search path explicitly.rustc passes --enable-new-dtags to GNU ld. This makes any RPATH entries (emitted with -C rpath) not take precedence over LD_LIBRARY_PATH.cargo rustc accepts a --profile flag that runs rustc under any of the compilation profiles, ‘dev’, ‘bench’, or ‘test’.rerun-if-changed build script directive no longer causes the build script to incorrectly run twice in certain scenarios.private_in_public lint.".".parse::<f32>() returns Err, not Ok(0.0).#![no_std] attribute causes a crate to not be linked to the standard library, but only the core library, as described in RFC 1184. The core library defines common types and traits but has no platform dependencies whatsoever, and is the basis for Rust software in environments that cannot support a full port of the standard library, such as operating systems. Most of the core library is now stable.Read::read_exact, ErrorKind::UnexpectedEof (renamed from UnexpectedEOF), fs::DirBuilder, fs::DirBuilder::new, fs::DirBuilder::recursive, fs::DirBuilder::create, os::unix::fs::DirBuilderExt, os::unix::fs::DirBuilderExt::mode, vec::Drain, vec::Vec::drain, string::Drain, string::String::drain, vec_deque::Drain, vec_deque::VecDeque::drain, collections::hash_map::Drain, collections::hash_map::HashMap::drain, collections::hash_set::Drain, collections::hash_set::HashSet::drain, collections::binary_heap::Drain, collections::binary_heap::BinaryHeap::drain, Vec::extend_from_slice (renamed from push_all), Mutex::get_mut, Mutex::into_inner, RwLock::get_mut, RwLock::into_inner, Iterator::min_by_key (renamed from min_by), Iterator::max_by_key (renamed from max_by).assert_eq! macro supports arguments that don't implement Sized, such as arrays. In this way it behaves more like assert!.Duration. These include Condvar::wait_timeout_ms, thread::sleep_ms, and thread::park_timeout_ms.Vec reserves additional elements was tweaked to not allocate excessive space while still growing exponentially.From conversions are implemented from integers to floats in cases where the conversion is lossless. Thus they are not implemented for 32-bit ints to f32, nor for 64-bit ints to f32 or f64. They are also not implemented for isize and usize because the implementations would be platform-specific. From is also implemented from f32 to f64.From<&Path> and From<PathBuf> are implemented for Cow<Path>.From<T> is implemented for Box<T>, Rc<T> and Arc<T>.IntoIterator is implemented for &PathBuf and &Path.BinaryHeap was refactored for modest performance improvements.$CARGO_HOME/bin for subcommands by default.rerun-if-changed key.cargo clean accepts a --release flag to clean the release folder. A variety of artifacts that Cargo failed to clean are now correctly deleted.unreachable_code lint warns when a function call's argument diverges.RUST_PATH environment variable when locating crates. This was a pre-cargo feature for integrating with the package manager that was accidentally never removed.Foo(..)) can no longer be used to match unit structs. This is a warning now, but will become an error in future releases. Patterns that share the same name as a const are now an error.BinaryHeap::from, BinaryHeap::into_sorted_vec, BinaryHeap::into_vec, Condvar::wait_timeout, FileTypeExt::is_block_device, FileTypeExt::is_char_device, FileTypeExt::is_fifo, FileTypeExt::is_socket, FileTypeExt, Formatter::alternate, Formatter::fill, Formatter::precision, Formatter::sign_aware_zero_pad, Formatter::sign_minus, Formatter::sign_plus, Formatter::width, Iterator::cmp, Iterator::eq, Iterator::ge, Iterator::gt, Iterator::le, Iterator::lt, Iterator::ne, Iterator::partial_cmp, Path::canonicalize, Path::exists, Path::is_dir, Path::is_file, Path::metadata, Path::read_dir, Path::read_link, Path::symlink_metadata, Utf8Error::valid_up_to, Vec::resize, VecDeque::as_mut_slices, VecDeque::as_slices, VecDeque::insert, VecDeque::shrink_to_fit, VecDeque::swap_remove_back, VecDeque::swap_remove_front, slice::split_first_mut, slice::split_first, slice::split_last_mut, slice::split_last, char::from_u32_unchecked, fs::canonicalize, str::MatchIndices, str::RMatchIndices, str::match_indices, str::rmatch_indices, str::slice_mut_unchecked, string::ParseError.~/.cargo/bin with the cargo install command. Among other things this makes it easier to augment Cargo with new subcommands: when a binary named e.g. cargo-foo is found in $PATH it can be invoked as cargo foo.*) dependencies will emit warnings when published. In 1.6 it will no longer be possible to publish crates with wildcard dependencies.AsRef and AsMut were added to Box, Rc, and Arc. Because these smart pointer types implement Deref, this causes breakage in cases where the interior type contains methods of the same name.Self are not object safe. Soundness fix.no_default_libraries setting that controls whether -nodefaultlibs is passed to the linker, and in turn the is_like_windows setting no longer affects the -nodefaultlibs flag.#[derive(Show)], long-deprecated, has been removed.#[inline] and #[repr] attributes can only appear in valid locations.#[no_debug] and #[omit_gdb_pretty_printer_section] are feature gated.use statements to import unstable features.improper_ctypes lint no longer warns about using isize and usize in FFI.Arc<T> and Rc<T> are covariant with respect to T instead of invariant.Default is implemented for mutable slices.FromStr is implemented for SockAddrV4 and SockAddrV6.From conversions between floating point types where the conversions are lossless.From conversions between integer types where the conversions are lossless.fs::Metadata implements Clone.parse method accepts a leading “+” when parsing integers.AsMut is implemented for Vec.clone_from implementations for String and BinaryHeap have been optimized and no longer rely on the default impl.extern "Rust", extern "C", unsafe extern "Rust" and unsafe extern "C" function types now implement Clone, PartialEq, Eq, PartialOrd, Ord, Hash, fmt::Pointer, and fmt::Debug for up to 12 arguments.Vecs is much faster in unoptimized builds when the element types don't implement Drop.VecDeque with zero-sized types was resolved.PartialOrd for slices is faster.str::lines and BufRead::lines iterators treat \r\n as line breaks in addition to \n.'static lifetime extend to the end of a function.str::parse no longer introduces avoidable rounding error when parsing floating point numbers. Together with earlier changes to float formatting/output, “round trips” like f.to_string().parse() now preserve the value of f exactly. Additionally, leading plus signs are now accepted.use statements that import multiple items can now rename them, as in use foo::{bar as kitten, baz as puppy}.pub extern crate, which does not behave as expected, issues a warning until a better solution is found.<Box<str>>::into_string, Arc::downgrade, Arc::get_mut, Arc::make_mut, Arc::try_unwrap, Box::from_raw, Box::into_raw, CStr::to_str, CStr::to_string_lossy, CString::from_raw, CString::into_raw, IntoRawFd::into_raw_fd, IntoRawFd, IntoRawHandle::into_raw_handle, IntoRawHandle, IntoRawSocket::into_raw_socket, IntoRawSocket, Rc::downgrade, Rc::get_mut, Rc::make_mut, Rc::try_unwrap, Result::expect, String::into_boxed_str, TcpStream::read_timeout, TcpStream::set_read_timeout, TcpStream::set_write_timeout, TcpStream::write_timeout, UdpSocket::read_timeout, UdpSocket::set_read_timeout, UdpSocket::set_write_timeout, UdpSocket::write_timeout, Vec::append, Vec::split_off, VecDeque::append, VecDeque::retain, VecDeque::split_off, rc::Weak::upgrade, rc::Weak, slice::Iter::as_slice, slice::IterMut::into_slice, str::CharIndices::as_str, str::Chars::as_str, str::split_at_mut, str::split_at, sync::Weak::upgrade, sync::Weak, thread::park_timeout, thread::sleep.BTreeMap::with_b, BTreeSet::with_b, Option::as_mut_slice, Option::as_slice, Result::as_mut_slice, Result::as_slice, f32::from_str_radix, f64::from_str_radix.std::io::copy allows ?Sized arguments.Windows, Chunks, and ChunksMut iterators over slices all override count, nth and last with an O(1) implementation.Default is implemented for arrays up to [T; 32].IntoRawFd has been added to the Unix-specific prelude, IntoRawSocket and IntoRawHandle to the Windows-specific prelude.Extend<String> and FromIterator<String are both implemented for String.IntoIterator is implemented for references to Option and Result.HashMap and HashSet implement Extend<&T> where T: Copy as part of RFC 839. This will cause type inference breakage in rare situations.BinaryHeap implements Debug.Borrow and BorrowMut are implemented for fixed-size arrays.extern fns with the “Rust” and “C” ABIs implement common traits including Eq, Ord, Debug, Hash.&mut T where T: std::fmt::Write also implements std::fmt::Write.VecDeque::push_back and other capacity-altering methods that caused panics for zero-sized types was fixed.isize and usize.cargo update.&'a Box<Trait> (or &'a Rc<Trait>, etc) will change from being interpreted as &'a Box<Trait+'a> to &'a Box<Trait+'static>.Duration API, has been stabilized. This basic unit of timekeeping is employed by other std APIs, as well as out-of-tree time crates.#[prelude_import] attribute, an internal implementation detail, was accidentally stabilized previously. It has been put behind the prelude_import feature gate. This change is believed to break no existing code.size_of_val and align_of_val is more sane for dynamically sized types. Code that relied on the previous behavior is thought to be broken.dropck rules, which checks that destructors can't access destroyed values, have been updated to match the RFC. This fixes some soundness holes, and as such will cause some previously-compiling code to no longer build.size_of_val and align_of_val is more sane for dynamically sized types. Code that relied on the previous behavior is not known to exist, and suspected to be broken.'static variables may now be recursive.ref bindings choose between Deref and DerefMut implementations correctly.dropck rules, which checks that destructors can't access destroyed values, have been updated to match the RFC.Duration API, has been stabilized, as well as the std::time module, which presently contains only Duration.Box<str> and Box<[T]> both implement Clone.CString, implements Borrow and the borrowed C string, CStr, implements ToOwned. The two of these allow C strings to be borrowed and cloned in generic code.CStr implements Debug.AtomicPtr implements Debug.Error trait objects can be downcast to their concrete types in many common configurations, using the is, downcast, downcast_ref and downcast_mut methods, similarly to the Any trait.contains, find, rfind, split. starts_with and ends_with are also faster.PartialEq for slices is much faster.Hash trait offers the default method, hash_slice, which is overridden and optimized by the implementations for scalars.Hasher trait now has a number of specialized write_* methods for primitive types, for efficiency.std::io::Error, gained a set of methods for accessing the ‘inner error’, if any: get_ref, get_mut, into_inner. As well, the implementation of std::error::Error::cause also delegates to the inner error.process::Child gained the id method, which returns a u32 representing the platform-specific process identifier.connect method on slices is deprecated, replaced by the new join method (note that both of these are on the unstable SliceConcatExt trait, but through the magic of the prelude are available to stable code anyway).Div operator is implemented for Wrapping types.DerefMut is implemented for String.HashMap) is better for long data.AtomicPtr implements Send.read_to_end implementations for Stdin and File are now specialized to use uninitialized buffers for increased performance.--explain flag.dropck pass, which checks that destructors can't access destroyed values, has been rewritten. This fixes some soundness holes, and as such will cause some previously-compiling code to no longer build.rustc now uses LLVM to write archive files where possible. Eventually this will eliminate the compiler's dependency on the ar utility.unused_mut, unconditional_recursion, improper_ctypes, and negate_unsigned lints are more strict.-Z no-landing-pads), panic! will kill the process instead of leaking.Rc to contain types without a fixed size, arrays and trait objects, finally enabling use of Rc<[T]> and completing the implementation of DST.-C codegen-units=N flag to rustc.to_uppercase and to_lowercase methods on char now do unicode case mapping, which is a previously-planned change in behavior and considered a bugfix.mem::align_of now specifies the minimum alignment for T, which is usually the alignment programs are interested in, and the same value reported by clang's alignof. mem::min_align_of is deprecated. This is not known to break real code.#[packed] attribute is no longer silently accepted by the compiler. This attribute did nothing and code that mentioned it likely did not work as intended.associated_type_defaults feature gate. In 1.1 associated type defaults did not work, but could be mentioned syntactically. As such this breakage has minimal impact.ref mut now correctly invoke DerefMut when matching against dereferenceable values.Extend trait, which grows a collection from an iterator, is implemented over iterators of references, for String, Vec, LinkedList, VecDeque, EnumSet, BinaryHeap, VecMap, BTreeSet and BTreeMap. RFC.iter::once function returns an iterator that yields a single element, and iter::empty returns an iterator that yields no elements.matches and rmatches methods on str return iterators over substring matches.Cell and RefCell both implement Eq.wrapping_div, wrapping_rem, wrapping_neg, wrapping_shl, wrapping_shr. These are in addition to the existing wrapping_add, wrapping_sub, and wrapping_mul methods, and alternatives to the Wrapping type.. It is illegal for the default arithmetic operations in Rust to overflow; the desire to wrap must be explicit.{:#?} formatting specifier displays the alternate, pretty-printed form of the Debug formatter. This feature was actually introduced prior to 1.0 with little fanfare.fmt::Formatter implements fmt::Write, a fmt-specific trait for writing data to formatted strings, similar to io::Write.fmt::Formatter adds ‘debug builder’ methods, debug_struct, debug_tuple, debug_list, debug_set, debug_map. These are used by code generators to emit implementations of Debug.str has new to_uppercase and to_lowercase methods that convert case, following Unicode case mapping.PoisonError type, returned by failing lock operations, exposes into_inner, get_ref, and get_mut, which all give access to the inner lock guard, and allow the poisoned lock to continue to operate. The is_poisoned method of RwLock and Mutex can poll for a poisoned lock without attempting to take the lock.FromRawFd trait is implemented for Stdio, and AsRawFd for ChildStdin, ChildStdout, ChildStderr. On Windows the FromRawHandle trait is implemented for Stdio, and AsRawHandle for ChildStdin, ChildStdout, ChildStderr.io::ErrorKind has a new variant, InvalidData, which indicates malformed input.rustc employs smarter heuristics for guessing at typos.rustc emits more efficient code for no-op conversions between unsafe pointers.std::fs module has been expanded to expand the set of functionality exposed:DirEntry now supports optimizations like file_type and metadata which don't incur a syscall on some platforms.symlink_metadata function has been added.fs::Metadata structure now lowers to its OS counterpart, providing access to all underlying information.--explain flag to read the explanation. Error explanations are also available online.str::split_whitespace method splits a string on unicode whitespace boundaries.FromRawFd and AsRawFd, on Windows FromRawHandle and AsRawHandle. These are implemented for File, TcpStream, TcpListener, and UpdSocket. Further implementations for std::process will be stabilized later.std::os::unix::symlink creates symlinks. On Windows, symlinks can be created with std::os::windows::symlink_dir and std::os::windows::symlink_file.mpsc::Receiver type can now be converted into an iterator with into_iter on the IntoIterator trait.Ipv4Addr can be created from u32 with the From<u32> implementation of the From trait.Debug implementation for RangeFull creates output that is more consistent with other implementations.Debug is implemented for File.Default implementation for Arc no longer requires Sync + Send.Iterator methods count, nth, and last have been overridden for slices to have O(1) performance instead of O(n).AtomicPtr gained a Default implementation.abs now panics on overflow when debug assertions are enabled.Cloned iterator, which was accidentally left unstable for 1.0 has been stabilized.Incoming iterator, which iterates over incoming TCP connections, and which was accidentally unnamable in 1.0, is now properly exported.BinaryHeap no longer corrupts itself when functions called by sift_up or sift_down panic.split_off method of LinkedList no longer corrupts the list in certain scenarios.target_env cfg value, which is used for distinguishing toolchains that are otherwise for the same platform. Presently this is set to gnu for common GNU Linux targets and for MinGW targets, and musl for MUSL Linux targets.cargo rustc command invokes a build with custom flags to rustc.drop_with_repr_extern lint warns about mixing repr(C) with Drop.#[stable]. It is no longer possible to use unstable features with a stable build of the compiler.0b1234 is now lexed as 0b1234 instead of two tokens, 0b1 and 234.PhantomFn and MarkerTrait lang items, which have been removed.extern crate "foo" as bar syntax has been replaced with extern crate foo as bar, and Cargo now automatically translates “-” in package names to underscore for the crate name.Send no longer implies 'static.MyType::default().SliceExt.Self: Sized in their where clause are considered object-safe, allowing many extension traits like IteratorExt to be merged into the traits they extended.where clause.Send and Sync are now library-defined.Any trait is effectively limited to concrete types. This helps retain the potentially-important “parametricity” property: generic code cannot behave differently for different type arguments except in minor ways.unsafe_destructor feature is now deprecated in favor of the new dropck. This change is a major reduction in unsafe code.thread_local module has been renamed to std::thread.IteratorExt have been moved to the Iterator trait itself.AsMut, AsRef, From, and Into have been centralized in the std::convert module.FromError trait was removed in favor of From.std::thread::sleep_ms.splitn function now takes an n parameter that represents the number of items yielded by the returned iterator instead of the number of ‘splits’.CLOEXEC by default.PartialOrd now order enums according to their explicitly-assigned discriminants.Patterns, implemented presently by &char, &str, FnMut(char) -> bool and some others.String::from_str has been deprecated in favor of the From impl, String::from.io::Error implements Sync.words method on &str has been replaced with split_whitespace, to avoid answering the tricky question, ‘what is a word?’#[stable]. This was the major library focus for this cycle.., adjusting the tradeoffs in favor of the most common usage.std were also stabilized during this cycle; about 75% of the non-deprecated API surface is now stable.Fn traits are now related via inheritance and provide ergonomic blanket implementations.Index and IndexMut traits were changed to take the index by value, enabling code like hash_map["string"] to work.Copy now inherits from Clone, meaning that all Copy data is known to be Clone as well.--explain flag to rustc.~1300 changes, numerous bugfixes
Highlights
io module remains temporarily at std::old_io.#![feature(...)] attribute. The impact of this change is described on the forum. RFC.Language
for loops now operate on the IntoIterator trait, which eliminates the need to call .iter(), etc. to iterate over collections. There are some new subtleties to remember though regarding what sort of iterators various types yield, in particular that for foo in bar { } yields values from a move iterator, destroying the original collection. RFC.Box<Trait+'static> when you don’t care about storing references. RFC.Drop, lifetimes must outlive the value. This will soon make it possible to safely implement Drop for types where #[unsafe_destructor] is now required. Read the gorgeous RFC for details.Deref<U> now automatically coerce to references to the dereferenced type U, e.g. &T where T: Deref<U> automatically coerces to &U. This should eliminate many unsightly uses of &*, as when converting from references to vectors into references to slices. RFC.|&:|, |&mut:|, |:|) is obsolete and closure kind is inferred from context.Self is a keyword.Libraries
Show and String formatting traits have been renamed to Debug and Display to more clearly reflect their related purposes. Automatically getting a string conversion to use with format!("{:?}", something_to_debug) is now written #[derive(Debug)].std::ff::{OsString, OsStr}, provide strings in platform-specific encodings for easier interop with system APIs. RFC.boxed::into_raw and Box::from_raw functions convert between Box<T> and *mut T, a common pattern for creating raw pointers.Tooling
/usr/local/lib/rustlib/uninstall.sh.#[rustc_on_unimplemented] attribute, requiring the ‘on_unimplemented’ feature, lets rustc display custom error messages when a trait is expected to be implemented for a type but is not.Misc
~2400 changes, numerous bugfixes
Highlights
isize and usize, rather than int and uint, for pointer-sized integers. Guidelines will be rolled out during the alpha cycle.std have been moved out of the Rust distribution into the Cargo ecosystem so they can evolve separately and don't need to be stabilized as quickly, including ‘time’, ‘getopts’, ‘num’, ‘regex’, and ‘term’.Language
where clauses provide a more versatile and attractive syntax for specifying generic bounds, though the previous syntax remains valid.str) more deeply into the type system, making it more consistent.i..j, i.., and ..j that produce range types and which, when combined with the Index operator and multidispatch, leads to a convenient slice notation, [i..j].[T; N].Copy trait is no longer implemented automatically. Unsafe pointers no longer implement Sync and Send so types containing them don't automatically either. Sync and Send are now ‘unsafe traits’ so one can “forcibly” implement them via unsafe impl if a type confirms to the requirements for them even though the internals do not (e.g. structs containing unsafe pointers like Arc). These changes are intended to prevent some footguns and are collectively known as opt-in built-in traits (though Sync and Send will soon become pure library types unknown to the compiler).String to be compared with &str.if let and while let are no longer feature-gated.macro_rules! has been declared stable. Though it is a flawed system it is sufficiently popular that it must be usable for 1.0. Effort has gone into future-proofing it in ways that will allow other macro systems to be developed in parallel, and won't otherwise impact the evolution of the language.vec![1i32, 2, 3].len() work as expected.#[derive(...)] not #[deriving(...)] for consistency with other naming conventions.self instead of mod, as in use foo::{self, bar}box operator and box patterns have been feature-gated pending a redesign. For now unique boxes should be allocated like other containers, with Box::new.Libraries
fail! macro has been renamed to panic! so that it is easier to discuss failure in the context of error handling without making clarifications as to whether you are referring to the ‘fail’ macro or failure more generally.OsRng prefers the new, more reliable getrandom syscall when available.Show formatter, typically implemented with #[derive(Show)] is now requested with the {:?} specifier and is intended for use by all types, for uses such as println! debugging. The new String formatter must be implemented by hand, uses the {} specifier, and is intended for full-fidelity conversions of things that can logically be represented as strings.Tooling
Misc
Option<Vec<T>> and Option<String> take up no more space than the inner types themselves.~1900 changes, numerous bugfixes
Highlights
std have been reviewed and updated for consistency with the in-development Rust coding guidelines. The standard library documentation tracks stabilization progress.Language
Index and IndexMut traits.if let construct takes a branch only if the let pattern matches, currently behind the ‘if_let’ feature gate.[0..4]) has been introduced behind the ‘slicing_syntax’ feature gate, and can be overloaded with the Slice or SliceMut traits... instead of prefix (.e.g. [a, b, c..]), for consistency with other uses of .. and to future-proof potential additional uses of the syntax.0..3 to 0...4 to be consistent with the exclusive range syntax for slicing.[a.., b, c]) has been put behind the ‘advanced_slice_patterns’ feature gate and may be removed in the future.value.0 syntax, currently behind the tuple_indexing feature gate.#[crate_id] attribute is no longer supported; versioning is handled by the package manager.extern crate foo as bar instead of extern crate bar = foo.use foo as bar instead of use bar = foo.let and match bindings and argument names in macros are now hygienic.move has been added as a keyword, for indicating closures that capture by value.Share trait is now called Sync to free up the term ‘shared’ to refer to ‘shared reference’ (the default reference type.Sized trait has been introduced, which qualifying types implement by default, and which type parameters expect by default. To specify that a type parameter does not need to be sized, write <Sized? T>. Most types are Sized, notable exceptions being unsized arrays ([T]) and trait types.!, as in || -> ! or proc() -> !.Gc<T> which was once denoted by the @ sigil, has finally been removed. GC will be revisited in the future.Libraries
std::time::Duration type has been added for use in I/O methods that rely on timers, as well as in the ‘time’ crate's Timespec arithmetic.collections::btree has been rewritten to have a more idiomatic and efficient design.Tooling
--crate-name flag can specify the name of the crate being compiled, like #[crate_name].-C metadata specifies additional metadata to hash into symbol names, and -C extra-filename specifies additional information to put into the output filename, for use by the package manager for versioning.-C codegen-units flag.Misc
~1700 changes, numerous bugfixes
Language
uint instead of any integral type.b.<'a>|A, B|: 'b + K -> Tpriv keyword has been removed from the language.use foo, bar, baz; syntax has been removed from the language.int, and floating point literals no longer default to f64. Literals must be suffixed with an appropriate type if inference cannot determine the type of the literal.Libraries
rev() on their forward-iteration counterparts.--cfg ndebug is passed to the compiler.Tooling
[breaking-change] to allow for easy discovery of breaking changes.mod foo;.pub use has been greatly improved.~1500 changes, numerous bugfixes
Language
@-pointers have been removed from the language.~[T]) have been removed from the language.~str) have been removed from the language.@str has been removed from the language.@[T] has been removed from the language.@self has been removed from the language.@Trait has been removed from the language.~ allocations which contain @ boxes inside the type for reference counting have been removed.macro_rules! macros as well as syntax extensions such as format!.#[deriving] with raw pointerslog_syntax! are now behind feature gates.#[simd] attribute is now behind a feature gate.extern crate statements, and unnecessary visibility (priv) is no longer allowed on use statements.do keyword has been removed, it is now a reserved keyword.extern mod is now extern crateFreeze trait has been removed.Share trait has been added for types that can be shared among threads.{} now.static mut locations has been tweaked.* and . operators are now overloadable through the Deref and DerefMut traits.~Trait and proc no longer have Send bounds by default._ type marker.Unsafe type was introduced for interior mutability. It is now considered undefined to transmute from &T to &mut T without using the Unsafe type.#[foo]; to #![foo].Pod was renamed to Copy.Libraries
libextra library has been removed. It has now been decomposed into component libraries with smaller and more focused nuggets of functionality. The full list of libraries can be found on the documentation index page.std::condition has been removed. All I/O errors are now propagated through the Result type. In order to assist with error handling, a try! macro for unwrapping errors with an early return and a lint for unused results has been added. See #12039 for more information.vec module has been renamed to slice.Vec<T>, has been added in preparation for DST. This will become the only growable vector in the future.std::io now has more public re-exports. Types such as BufferedReader are now found at std::io::BufferedReader instead of std::io::buffered::BufferedReader.print and println are no longer in the prelude, the print! and println! macros are intended to be used instead.Rc now has a Weak pointer for breaking cycles, and it no longer attempts to statically prevent cycles.slice::last()) now return Option<T> instead of T + failing.fmt::Default has been renamed to fmt::Show, and it now has a new deriving mode: #[deriving(Show)].ToStr is now implemented for all types implementing Show.&self instead of &Tinvert() method on iterators has been renamed to rev()std::num has seen a reduction in the genericity of its traits, consolidating functionality into a few core traits.RUST_BACKTRACE is present.eof() has been removed from the Reader trait. Specific types may still implement the function.assert_approx_eq! has been removede and E formatting specifiers for floats have been added to print them in exponential notation.Times trait has been removedstd::kinds::marker nowhash has been rewritten, IterBytes has been removed, and #[deriving(Hash)] is now possible.SharedChan has been removed, Sender is now cloneable.Chan and Port were renamed to Sender and Receiver.Chan::new is now channel().select! macro is now provided for selecting over Receivers.hashmap and trie have been moved to libcollectionsrun has been rolled into io::processassert_eq! now uses {} instead of {:?}rand has moved to librand.to_{lower,upper}case has been implemented for char.liblog.HashMap has been rewritten for higher performance and less memory usage.libnative. If libgreen is desired, it can be booted manually. The runtime guide has more information and examples.libgreen has been optimized with stack caching and various trimming of code.libgreen now have an unmapped guard page.extra::sync module has been updated to modern rust (and moved to the sync library), tweaking and improving various interfaces while dropping redundant functionality.Barrier type has been added to the sync library.base64 module has seen some improvement. It treats newlines better, has non-string error values, and has seen general cleanup.fourcc! macro was introducedhexfloat! macro was implemented for specifying floats via a hexadecimal literal.Tooling
rustpkg has been deprecated and removed from the main repository. Its replacement, cargo, is under development.--emit flag.--crate-type flag.-C flag.rustdoc improvements:~1800 changes, numerous bugfixes
Language
float type has been removed. Use f32 or f64 instead.#[feature(foo)] attribute.#[feature(managed_boxes)]) in preparation for future removal. Use the standard library's Gc or Rc types instead.@mut has been removed. Use std::cell::{Cell, RefCell} instead.continue instead of loop.r"foo" syntax or with matched hash delimiters, as in r###"foo"###.~fn is now written proc (args) -> retval { ... } and may only be called once.&fn type is now written |args| -> ret to match the literal form.@fns have been removed.do only works with procs in order to make it obvious what the cost of do is.#[link(...)] attribute has been replaced with #[crate_id = "name#vers"].impls must be terminated with empty braces and may not be terminated with a semicolon.self lifetime no longer has any special meaning.fmt! string formatting macro has been removed.printf! and printfln! (old-style formatting) removed in favor of print! and println!.mut works in patterns now, as in let (mut x, y) = (1, 2);.extern mod foo (name = "bar") syntax has been removed. Use extern mod foo = "bar" instead.alignof, offsetof, sizeof.asm! macro is feature-gated (#[feature(asm)]).as.repr attribute can be used to override the discriminant size, as in #[repr(int)] for integer-sized, and #[repr(C)] to match C enums.0o7777.concat! syntax extension performs compile-time string concatenation.#[fixed_stack_segment] and #[rust_stack] attributes have been removed as Rust no longer uses segmented stacks.#[feature(non_ascii_idents)])..., not *; ignoring remaining fields of a struct is also done with .., not _; ignoring a slice of a vector is done with .., not .._.rustc supports the “win64” calling convention via extern "win64".rustc supports the “system” calling convention, which defaults to the preferred convention for the target platform, “stdcall” on 32-bit Windows, “C” elsewhere.type_overflow lint (default: warn) checks literals for overflow.unsafe_block lint (default: allow) checks for usage of unsafe.attribute_usage lint (default: warn) warns about unknown attributes.unknown_features lint (default: warn) warns about unknown feature gates.dead_code lint (default: warn) checks for dead code.#[link_args] is behind the link_args feature gate.#[link(name = "foo")]#[link(name = "foo", kind = "static")]).#[link(name = "foo", kind = "framework")]).#[thread_local] attribute creates thread-local (not task-local) variables. Currently behind the thread_local feature gate.return keyword may be used in closures.Pod kind.cfg attribute can now be used on struct fields and enum variants.Libraries
option and result API's have been overhauled to make them simpler, more consistent, and more composable.std::io module has been replaced with one that is more comprehensive and that properly interfaces with the underlying scheduler. File, TCP, UDP, Unix sockets, pipes, and timers are all implemented.io::util contains a number of useful implementations of Reader and Writer, including NullReader, NullWriter, ZeroReader, TeeReader.extra::rc moved into std.Gc type in the gc module will replace @ (it is currently just a wrapper around it).Either type has been removed.fmt::Default can be implemented for any type to provide default formatting to the format! macro, as in format!("{}", myfoo).rand API continues to be tweaked.rust_begin_unwind function, useful for inserting breakpoints on failure in gdb, is now named rust_fail.each_key and each_value methods on HashMap have been replaced by the keys and values iterators.sys module to the mem module.path module was written and API changed.str::from_utf8 has been changed to cast instead of allocate.starts_with and ends_with methods added to vectors via the ImmutableEqVector trait, which is in the prelude.get_opt method, which returns None if the index is out of bounds.Any type can be used for dynamic typing.~Any can be passed to the fail! macro and retrieved via task::try._iter suffix now.cell::Cell and cell::RefCell can be used to introduce mutability roots (mutable fields, etc.). Use instead of e.g. @mut.util::ignore renamed to prelude::drop.sort and sort_by methods via the MutableVector trait.vec::raw has seen a lot of cleanup and API changes.comm module has been rewritten to be much faster, have a simpler, more consistent API, and to work for both native and green threading.flatpipes module had bitrotted and was removed.c_vec has been modernized.sort module has been removed. Use the sort method on mutable slices.Tooling
rust and rusti commands have been removed, due to lack of maintenance.rustdoc was completely rewritten.rustdoc can test code examples in documentation.rustpkg can test packages with the argument, ‘test’.rustpkg supports arbitrary dependencies, including C libraries.rustc's support for generating debug info is improved again.rustc has better error reporting for unbalanced delimiters.rustc's JIT support was removed due to bitrot.rustc adds a --dep-info flag for communicating dependencies to build tools.~2200 changes, numerous bugfixes
Language
for loop syntax has changed to work with the Iterator trait.copy is no longer a keyword. It has been replaced by the Clone trait.debug! macro if it is passed --cfg ndebugmod foo;, rustc will now look for foo.rs, then foo/mod.rs, and will generate an error when both are present.std::c_str module provides new mechanisms for converting to C strings.extern "C" fn instead of `*u8'.#[fixed_stack_segment] attribute.externfn! macro can be used to declare both a foreign function and a #[fixed_stack_segment] wrapper at once.pub and priv modifiers on extern blocks are no longer parsed.unsafe is no longer allowed on extern fns - they are all unsafe.priv is disallowed everywhere except for struct fields and enum variants.&T (besides &'static T) is no longer allowed in @T.ref bindings in irrefutable patterns work correctly now.char is now prevented from containing invalid code points.bool is no longer allowed.\0 is now accepted as an escape in chars and strings.yield is a reserved keyword.typeof is a reserved keyword.extern mod foo = "url";.enum E { V = 0u }static foo: [u8, .. 100]: [0, .. 100];.static foo: Foo = Foo { a: 5, .. bar };.cfg! can be used to conditionally execute code based on the crate configuration, similarly to #[cfg(...)].unnecessary_qualification lint detects unneeded module prefixes (default: allow).std::unstable::simd.format! implements a completely new, extensible, and higher-performance string formatting system. It will replace fmt!.print! and println! write formatted strings (using the format! extension) to stdout.write! and writeln! write formatted strings (using the format! extension) to the new Writers in std::rt::io.#[link_section = "..."].proto! syntax extension for defining bounded message protocols was removed.macro_rules! is hygienic for let declarations.#[export_name] attribute specifies the name of a symbol.unreachable! can be used to indicate unreachable code, and fails if executed.Libraries
rt::io, based on the new runtime.range function was added to the prelude, replacing uint::range and friends.range_rev no longer exists. Since range is an iterator it can be reversed with range(lo, hi).invert().chain method on option renamed to and_then; unwrap_or_default renamed to unwrap_or.iterator module was renamed to iter.checked_add, checked_sub, and checked_mul operations for detecting overflow.str, vec, option, result` were renamed for consistency.to_foo for copying, into_foo for moving, as_foo for temporary and cheap casts.CString type in c_str provides new ways to convert to and from C strings.DoubleEndedIterator can yield elements in two directions.mut_split method on vectors partitions an &mut [T] into two splices.str::from_bytes renamed to str::from_utf8.pop_opt and shift_opt methods added to vectors.swap_unwrap method of Option renamed to take_unwrap.SharedPort to comm.Eq has a default method for ne; only eq is required in implementations.Ord has default methods for le, gt and ge; only lt is required in implementations.is_utf8 performance is improved, impacting many string functions.os::MemoryMap provides cross-platform mmap.ptr::offset is now unsafe, but also more optimized. Offsets that are not ‘in-bounds’ are considered undefined.vec removed in favor of methods.FromIterator so can be created by the collect method.unstable::atomics.comm::PortSet removed.Set and Map traits have been moved into the MutableSet and MutableMap traits. Container::is_empty, Map::contains_key, MutableMap::insert, and MutableMap::remove have default implementations.from_str functions were removed in favor of a generic from_str which is available in the prelude.util::unreachable removed in favor of the unreachable! macro.dlist, the doubly-linked list was modernized.hex module with ToHex and FromHex traits.glob module, replacing std::os::glob.rope was removed.deque was renamed to ringbuf. RingBuf implements Deque.net, and timer were removed. The experimental replacements are std::rt::io::net and std::rt::io::timer.SmallIntMap.Bitv and BitvSet.SmallIntSet removed. Use BitvSet.semver updated to SemVer 2.0.0.term handles more terminals correctly.dbg module removed.par module removed.future was cleaned up, with some method renames.getopts were converted to methods.Other
-Z debug-info) is greatly improved.--target-cpu to compile to a specific CPU architecture, similarly to gcc's --march flag.--test now support the -h and --help flags.rustdoc command.~2000 changes, numerous bugfixes
Language
impls no longer accept a visibility qualifier. Put them on methods instead.self parameter no longer implicitly means &'self self, and can be explicitly marked with a lifetime.+=, etc.) have been temporarily removed due to bugs.for loop protocol now requires for-iterators to return bool so they compose better.Durable trait is replaced with the 'static bounds.#[packed] attribute have byte alignment and no padding between fields.Copy must now be copied explicitly with the copy keyword.Option<~T> is now represented as a nullable pointer.@mut does dynamic borrow checks correctly.main function is only detected at the topmost level of the crate. The #[main] attribute is still valid anywhere.#[no_send] attribute makes a type that would otherwise be Send, not.#[no_freeze] attribute makes a type that would otherwise be Freeze, not.RUST_MAX_STACK environment variable (default: 1GB).vecs_implicitly_copyable lint mode has been removed. Vectors are never implicitly copyable.#[static_assert] makes compile-time assertions about static bools.use mod statement no longer exists.Syntax extensions
fail! and assert! accept ~str, &'static str or fmt!-style argument list.Encodable, Decodable, Ord, TotalOrd, TotalEq, DeepClone, Rand, Zero and ToStr can all be automatically derived with #[deriving(...)].bytes! macro returns a vector of bytes for string, u8, char, and unsuffixed integer literals.Libraries
core crate was renamed to std.std crate was renamed to extra.iterator module for external iterator objects.Iterator.any, all. removed.finalize method of Drop renamed to drop.drop method now takes &mut self instead of &self.print, println, FromStr, ApproxEq, Equiv, Iterator, IteratorUtil, many numeric traits, many tuple traits.Fractional, Real, RealExt, Integer, Ratio, Algebraic, Trigonometric, Exponential, Primitive.(0, 1, 2).n2() or (0, 1, 2).n2_ref().Clone.path type renamed to Path.mut module and Mut type removed.vec, str. In the future methods will also work as functions.reinterpret_cast removed. Use transmute.std::ascii.Rand is implemented for ~/@.run module for spawning processes overhauled.unstable::atomic.Zero.LinearMap and LinearSet renamed to HashMap and HashSet.ptr to borrow.os::mkdir_recursive.os::glob function performs filesystems globs.FuzzyEq renamed to ApproxEq.Map now defines pop and swap methods.Cell constructors converted to static methods.rc module adds the reference counted pointers, Rc and RcMut.flate module moved from std to extra.fileinput module for iterating over a series of files.Complex number type and complex module.Rational number type and rational module.BigInt, BigUint implement numeric and comparison traits.term uses terminfo now, is more correct.arc functions converted to methods.Tooling
unused_variables lint mode for unused variables (default: warn).unused_unsafe lint mode for detecting unnecessary unsafe blocks (default: warn).unused_mut lint mode for identifying unused mut qualifiers (default: warn).dead_assignment lint mode for unread variables (default: warn).unnecessary_allocation lint mode detects some heap allocations that are immediately borrowed so could be written without allocating (default: warn).missing_doc lint mode (default: allow).unreachable_code lint mode (default: warn).rusti command has been rewritten and a number of bugs addressed.--link-args flag to pass arguments to the linker.-Z print-link-args flag for debugging linkage.-g will make the binary record information about dynamic borrowcheck failures for debugging.~2100 changes, numerous bugfixes
Syntax changes
Selfself parameter in trait and impl methods must now be explicitly named (for example: fn f(&self) { }). Implicit self is deprecated.static keyword and instead are distinguished by the lack of a self parameterDurable trait with the 'static lifetimesuper is a keyword, and may be prefixed to paths+ instead of whitespaceimpl Trait for Type instead of impl Type: Trait&'l foo instead of &l/fooexport keyword has finally been removedmove keyword has been removed (see “Semantic changes”)[mut T], has been removed. Use &mut [T], etc.mut is no longer valid in ~mut T. Use inherited mutabilityfail is no longer a keyword. Use fail!()assert is no longer a keyword. Use assert!()log is no longer a keyword. use debug!, etc.(T,)mut. Use inherited mutability, @mut T, core::mut or core::cellextern mod { ... } is no longer valid syntax for foreign function modules. Use extern blocks: extern { ... }const renamed to static to correspond to lifetime name, and make room for future static mut unsafe mutable globals.#[deriving_eq] with #[deriving(Eq)], etc.Clone implementations can be automatically generated with #[deriving(Clone)]@foo as @Bar instead of foo as Bar.[int, .. 3] instead of [int * 3].[int, .. GL_BUFFER_SIZE - 2])Semantic changes
move keyworduse statements may no longer be “chained” - they cannot import identifiers imported by previous use statementsuse statements are crate relative, importing from the “top” of the crate by default. Paths may be prefixed with super:: or self:: to change the search behavior.Libraries
std::bigintcore::oldcomm modulecore::comm modulecore::numvec::slice finally returns a slicedebug! and friends don't require a format string, e.g. debug!(Foo)core::containercore::dvec removed, ~[T] is a drop-in replacementcore::send_map renamed to core::hashmapstd::map removed; replaced with core::hashmapstd::treemap reimplemented as an owned balanced treestd::deque and std::smallintmap reimplemented as owned containerscore::trie added as a fast ordered map for integer keyscore::hashmap, core::trie and std::treemapOrd split into Ord and TotalOrd. Ord is still used to overload the comparison operators, whereas TotalOrd is used by certain container typesOther
rustc --test now supports benchmarks with the #[bench] attribute~900 changes, numerous bugfixes
Syntax changes
<- move operator#fmt extension syntax to fmt![T]/Nquote_tokens!, quote_expr!, etc.a.b() is always parsed as a method call, never as a field projectionEq and IterBytes implementations can be automatically generated with #[deriving_eq] and #[deriving_iter_bytes] respectively.rc filesSemantic changes
& and ~ pointers may point to objectsstruct Foo(Bar, Baz). Will replace newtype enums.move explicitly&T may now be coerced to *Tlet statements as well as function callsuse statements now take crate-relative pathsImproved support for language features
self, &self @self, and ~self all generally work as expectedLibraries
core::conditionstd::sortstd::priority_queuegetopts definitionsstdcore::comm renamed to oldcomm. Still deprecatedrustdoc and cargo are libraries nowMisc
rusti~2000 changes, numerous bugfixes
Syntax
ret became return and alt became matchimport is now use; use is now extern mod`extern mod { ... } is now extern { ... }use mod is the recommended way to import modulespub and priv replace deprecated export listsmatch pattern arms now uses fat arrow (=>)main no longer accepts an args vector; use os::args insteadSemantics
Libraries
std::net::url for representing URLscore::send_mapConcurrency
core::pipesstd::arc, an atomically reference counted, immutable, shared memory typestd::sync, various exotic synchronization tools based on arcs and pipesOther
~1900 changes, numerous bugfixes
New coding conveniences
Semantic cleanup
Experimental new language features
Type reflection
Removal of various obsolete features
Keywords: ‘be’, ‘prove’, ‘syntax’, ‘note’, ‘mutable’, ‘bind’, ‘crust’, ‘native’ (now ‘extern’), ‘cont’ (now ‘again’)
Constructs: do-while loops (‘do’ repurposed), fn binding, resources (replaced by destructors)
Compiler reorganization
New library code
Tool improvements
1500 changes, numerous bugfixes
New docs and doc tooling
New port: FreeBSD x86_64
Compilation model enhancements
Scheduling, stack and threading fixes
Experimental new language features
Various language extensions
New library code
Most language features work, including:
Compiler works with the following configurations:
Cross compilation / multi-target configuration supported.
Preliminary API-documentation and package-management tools included.
Known issues:
Documentation is incomplete.
Performance is below intended target.
Standard library APIs are subject to extensive change, reorganization.
Language-level versioning is not yet operational - future code will break unexpectedly.