Rust 1.37.0

Language

• #[must_use] will now warn if the type is contained in a tuple, Box, or an array and unused.
• You can now use the cfg and cfg_attr attributes on generic parameters.
• You can now use enum variants through type alias. e.g. You can write the following:

  type MyOption = Option<u8>;
  
  fn increment_or_zero(x: MyOption) -> u8 {
      match x {
          MyOption::Some(y) => y + 1,
          MyOption::None => 0,
      }
  }

• You can now use _ as an identifier for consts. e.g. You can write const _: u32 = 5;.
• You can now use #[repr(align(X)] on enums.
• The ? Kleene macro operator is now available in the 2015 edition.

Compiler

• You can now enable Profile-Guided Optimization with the -C profile-generate and -C profile-use flags. For more information on how to use profile guided optimization, please refer to the rustc book.
• The rust-lldb wrapper script should now work again.

Libraries

• mem::MaybeUninit<T> is now ABI-compatible with T.

Stabilized APIs

• BufReader::buffer
• BufWriter::buffer
• Cell::from_mut
• Cell<[T]>::as_slice_of_cells
• DoubleEndedIterator::nth_back
• Option::xor
• Wrapping::reverse_bits
• i128::reverse_bits
• i16::reverse_bits
• i32::reverse_bits
• i64::reverse_bits
• i8::reverse_bits
• isize::reverse_bits
• slice::copy_within
• u128::reverse_bits
• u16::reverse_bits
• u32::reverse_bits
• u64::reverse_bits
• u8::reverse_bits
• usize::reverse_bits

Cargo

• Cargo.lock files are now included by default when publishing executable crates with executables.
• You can now specify default-run="foo" in [package] to specify the default executable to use for cargo run.

Misc

Compatibility Notes

• Using ... for inclusive range patterns will now warn by default. Please transition your code to using the ..= syntax for inclusive ranges instead.
• Using a trait object without the dyn will now warn by default. Please transition your code to use dyn Trait for trait objects instead.

Rust 1.36.0

Language

• Non-Lexical Lifetimes are now enabled on the 2015 edition.
• The order of traits in trait objects no longer affects the semantics of that object. e.g. dyn Send + fmt::Debug is now equivalent to dyn fmt::Debug + Send, where this was previously not the case.

Libraries

• 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.
• Both NonNull::{dangling, cast} are now const fns.
• The 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>.
• You can now pass multiple arguments to the 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.

Stabilized APIs

• VecDeque::rotate_left
• VecDeque::rotate_right
• Iterator::copied
• io::IoSlice
• io::IoSliceMut
• Read::read_vectored
• Write::write_vectored
• str::as_mut_ptr
• mem::MaybeUninit
• pointer::align_offset
• future::Future
• task::Context
• task::RawWaker
• task::RawWakerVTable
• task::Waker
• task::Poll

Cargo

• Cargo will now produce an error if you attempt to use the name of a required dependency as a feature.
• You can now pass the --offline flag to run cargo without accessing the network.

You can find further change's in Cargo's 1.36.0 release notes.

Clippy

There have been numerous additions and fixes to clippy, see Clippy's 1.36.0 release notes for more details.

Misc

Compatibility Notes

• With the stabilisation of mem::MaybeUninit, mem::uninitialized use is no longer recommended, and will be deprecated in 1.39.0.

Rust 1.35.0

Language

• FnOnce, FnMut, and the Fn traits are now implemented for Box<FnOnce>, Box<FnMut>, and Box<Fn> respectively.
• You can now coerce closures into unsafe function pointers. e.g.

  unsafe fn call_unsafe(func: unsafe fn()) {
      func()
  }
  
  pub fn main() {
      unsafe { call_unsafe(|| {}); }
  }

Compiler

• Added the armv6-unknown-freebsd-gnueabihf and armv7-unknown-freebsd-gnueabihf targets.
• Added the wasm32-unknown-wasi target.

Libraries

• Thread will now show its ID in Debug output.
• StdinLock, StdoutLock, and StderrLock now implement AsRawFd.
• alloc::System now implements Default.
• Expanded Debug output ({:#?}) for structs now has a trailing comma on the last field.
• char::{ToLowercase, ToUppercase} now implement ExactSizeIterator.
• All NonZero numeric types now implement FromStr.
• Removed the Read trait bounds on the BufReader::{get_ref, get_mut, into_inner} methods.
• You can now call the dbg! macro without any parameters to print the file and line where it is called.
• In place ASCII case conversions are now up to 4× faster. e.g. str::make_ascii_lowercase
• hash_map::{OccupiedEntry, VacantEntry} now implement Sync and Send.

Stabilized APIs

• f32::copysign
• f64::copysign
• RefCell::replace_with
• RefCell::map_split
• ptr::hash
• Range::contains
• RangeFrom::contains
• RangeTo::contains
• RangeInclusive::contains
• RangeToInclusive::contains
• Option::copied

Cargo

• You can now set cargo:rustc-cdylib-link-arg at build time to pass custom linker arguments when building a cdylib. Its usage is highly platform specific.

Misc

• The Rust toolchain is now available natively for musl based distros.

Rust 1.34.2

• Destabilize the Error::type_id function due to a security vulnerability (CVE-2019-12083)

Rust 1.34.1

• Fix false positives for the redundant_closure Clippy lint
• Fix false positives for the missing_const_for_fn Clippy lint
• Fix Clippy panic when checking some macros

Rust 1.34.0

Language

• You can now use #[deprecated = "reason"] as a shorthand for #[deprecated(note = "reason")]. This was previously allowed by mistake but had no effect.
• You can now accept token streams in #[attr()],#[attr[]], and #[attr{}] procedural macros.
• You can now write extern crate self as foo; to import your crate's root into the extern prelude.

Compiler

• You can now target riscv64imac-unknown-none-elf and riscv64gc-unknown-none-elf.
• You can now enable linker plugin LTO optimisations with -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.
• You can now target powerpc64-unknown-freebsd.

Libraries

• The trait bounds have been removed on some of 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.
• The 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.
• The methods overflowing_neg and wrapping_neg are now const functions for all numeric types.
• Indexing a 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.
• The methods 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.

Stabilized APIs

std & core

• Any::type_id
• Error::type_id
• atomic::AtomicI16
• atomic::AtomicI32
• atomic::AtomicI64
• atomic::AtomicI8
• atomic::AtomicU16
• atomic::AtomicU32
• atomic::AtomicU64
• atomic::AtomicU8
• convert::Infallible
• convert::TryFrom
• convert::TryInto
• iter::from_fn
• iter::successors
• num::NonZeroI128
• num::NonZeroI16
• num::NonZeroI32
• num::NonZeroI64
• num::NonZeroI8
• num::NonZeroIsize
• slice::sort_by_cached_key
• str::escape_debug
• str::escape_default
• str::escape_unicode
• str::split_ascii_whitespace

std

• Instant::checked_add
• Instant::checked_sub
• SystemTime::checked_add
• SystemTime::checked_sub

Cargo

• You can now use alternative registries to crates.io.

Misc

• You can now use the ? operator in your documentation tests without manually adding fn main() -> Result<(), _> {}.

Compatibility Notes

• Command::before_exec is being replaced by the unsafe method Command::pre_exec and will be deprecated with Rust 1.37.0.
• Use of ATOMIC_{BOOL, ISIZE, USIZE}_INIT is now deprecated as you can now use const functions in static variables.

Rust 1.33.0

Language

• You can now use the cfg(target_vendor) attribute. E.g. #[cfg(target_vendor="apple")] fn main() { println!("Hello Apple!"); }
• Integer patterns such as in a match expression can now be exhaustive. E.g. You can have match statement on a u8 that covers 0..=255 and you would no longer be required to have a _ => unreachable!() case.
• You can now have multiple patterns in 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);
      }
  }

• You can now have irrefutable 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 {}
• You can now use let bindings, assignments, expression statements, and irrefutable pattern destructuring in const functions.
• You can now call unsafe const functions. E.g.

  const unsafe fn foo() -> i32 { 5 }
  const fn bar() -> i32 {
      unsafe { foo() }
  }

• You can now specify multiple attributes in a cfg_attr attribute. E.g. #[cfg_attr(all(), must_use, optimize)]
• You can now specify a specific alignment with the #[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.
• You can now import an item from a module as an _. 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 {}

• You may now use Rc, Arc, and Pin as method receivers.

Compiler

• You can now set a linker flavor for rustc with the -Clinker-flavor command line argument.
• The minimum required LLVM version has been bumped to 6.0.
• Added support for the PowerPC64 architecture on FreeBSD.
• The 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.
• Added support for the thumbv7neon-linux-androideabi and thumbv7neon-unknown-linux-gnueabihf targets.
• Added support for the x86_64-unknown-uefi target.

Libraries

• The methods overflowing_{add, sub, mul, shl, shr} are now const functions for all numeric types.
• The methods rotate_left, rotate_right, and wrapping_{add, sub, mul, shl, shr} are now const functions for all numeric types.
• The methods is_positive and is_negative are now const functions for all signed numeric types.
• The get method for all NonZero types is now const.
• The methods 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 function

Stabilized APIs

• unix::FileExt::read_exact_at
• unix::FileExt::write_all_at
• Option::transpose
• Result::transpose
• convert::identity
• pin::Pin
• marker::Unpin
• marker::PhantomPinned
• Vec::resize_with
• VecDeque::resize_with
• Duration::as_millis
• Duration::as_micros
• Duration::as_nanos

Cargo

• You can now publish crates that require a feature flag to compile with cargo publish --features or cargo publish --all-features.
• Cargo should now rebuild a crate if a file was modified during the initial build.

Compatibility Notes

• The methods 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.
• The Error::cause method has been deprecated in favor of Error::source which supports downcasting.
• Libtest no longer creates a new thread for each test when --test-threads=1. It also runs the tests in deterministic order

Rust 1.32.0

Language

2018 edition

• You can now use the ? operator in macro definitions. The ? operator allows you to specify zero or one repetitions similar to the * and + operators.
• Module paths with no leading keyword like 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::*;

All editions

• You can now match against PhantomData<T> types.
• You can now match against literals in macros with the literal specifier. This will match against a literal of any type. E.g. 1, 'A', "Hello World"
• Self can now be used as a constructor and pattern for unit and tuple structs. E.g.

  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,
          }
      }
  }

• Self can also now be used in type definitions. E.g.

  enum List<T>
  where
      Self: PartialOrd<Self> // can write `Self` instead of `List<T>`
  {
      Nil,
      Cons(T, Box<Self>) // likewise here
  }

• You can now mark traits with #[must_use]. This provides a warning if a impl Trait or dyn Trait is returned and unused in the program.

Compiler

• The default allocator has changed from jemalloc to the default allocator on your system. The compiler itself on Linux & macOS will still use jemalloc, but programs compiled with it will use the system allocator.
• Added the aarch64-pc-windows-msvc target.

Libraries

• PathBuf now implements FromStr.
• Box<[T]> now implements FromIterator<T>.
• The 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_ptr
• UnsafeCell::get
• char::is_ascii
• iter::empty
• ManuallyDrop::new
• ManuallyDrop::into_inner
• RangeInclusive::start
• RangeInclusive::end
• NonNull::as_ptr
• slice::as_ptr
• str::as_ptr
• Duration::as_secs
• Duration::subsec_millis
• Duration::subsec_micros
• Duration::subsec_nanos
• CStr::as_ptr
• Ipv4Addr::is_unspecified
• Ipv6Addr::new
• Ipv6Addr::octets

Stabilized APIs

• i8::to_be_bytes
• i8::to_le_bytes
• i8::to_ne_bytes
• i8::from_be_bytes
• i8::from_le_bytes
• i8::from_ne_bytes
• i16::to_be_bytes
• i16::to_le_bytes
• i16::to_ne_bytes
• i16::from_be_bytes
• i16::from_le_bytes
• i16::from_ne_bytes
• i32::to_be_bytes
• i32::to_le_bytes
• i32::to_ne_bytes
• i32::from_be_bytes
• i32::from_le_bytes
• i32::from_ne_bytes
• i64::to_be_bytes
• i64::to_le_bytes
• i64::to_ne_bytes
• i64::from_be_bytes
• i64::from_le_bytes
• i64::from_ne_bytes
• i128::to_be_bytes
• i128::to_le_bytes
• i128::to_ne_bytes
• i128::from_be_bytes
• i128::from_le_bytes
• i128::from_ne_bytes
• isize::to_be_bytes
• isize::to_le_bytes
• isize::to_ne_bytes
• isize::from_be_bytes
• isize::from_le_bytes
• isize::from_ne_bytes
• u8::to_be_bytes
• u8::to_le_bytes
• u8::to_ne_bytes
• u8::from_be_bytes
• u8::from_le_bytes
• u8::from_ne_bytes
• u16::to_be_bytes
• u16::to_le_bytes
• u16::to_ne_bytes
• u16::from_be_bytes
• u16::from_le_bytes
• u16::from_ne_bytes
• u32::to_be_bytes
• u32::to_le_bytes
• u32::to_ne_bytes
• u32::from_be_bytes
• u32::from_le_bytes
• [u32::from_ne_bytes](https://doc.rust-lang.org/stable/std/primitive....

Rust 1.31.1

• Fix Rust failing to build on powerpc-unknown-netbsd
• Fix broken go-to-definition in RLS
• Fix infinite loop on hover in RLS

Rust 1.31.0

Language

• 🎉 This version marks the release of the 2018 edition of Rust. 🎉
• New lifetime elision rules now allow for eliding lifetimes in functions and impl headers. E.g. impl<'a> Reader for BufReader<'a> {} can now be impl Reader for BufReader<'_> {}. Lifetimes are still required to be defined in structs.
• You can now define and use const functions. These are currently a strict minimal subset of the const fn RFC. Refer to the language reference for what exactly is available.
• You can now use tool lints, which allow you to scope lints from external tools using attributes. E.g. #[allow(clippy::filter_map)].
• #[no_mangle] and #[export_name] attributes can now be located anywhere in a crate, not just in exported functions.
• You can now use parentheses in pattern matches.

Compiler

• Updated musl to 1.1.20

Libraries

• You can now convert num::NonZero* types to their raw equivalents using the From trait. E.g. u8 now implements From<NonZeroU8>.
• You can now convert a &Option<T> into Option<&T> and &mut Option<T> into Option<&mut T> using the From trait.
• You can now multiply (*) a time::Duration by a u32.

Stabilized APIs

• slice::align_to
• slice::align_to_mut
• slice::chunks_exact
• slice::chunks_exact_mut
• slice::rchunks
• slice::rchunks_mut
• slice::rchunks_exact
• slice::rchunks_exact_mut
• Option::replace

Cargo

• Cargo will now download crates in parallel using HTTP/2.
• You can now rename packages in your Cargo.toml We have a guide on how to use the package key in your dependencies.