Rust 1.45.2

• Fix bindings in tuple struct patterns
• Fix track_caller integration with trait objects

Rust 1.45.1

• Fix const propagation with references.
• rustfmt accepts rustfmt_skip in cfg_attr again.
• Avoid spurious implicit region bound.
• Install clippy on x.py install

Rust 1.45.0

Language

• Out of range float to int conversions using 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.
• Function like procedural macros can now be used in expression, pattern, and statement positions. This means you can now use a function-like procedural macro anywhere you can use a declarative (macro_rules!) macro.

Compiler

• You can now override individual target features through the target-feature flag. E.g. -C target-feature=+avx2 -C target-feature=+fma is now equivalent to -C target-feature=+avx2,+fma.
• Added the force-unwind-tables flag. This option allows rustc to always generate unwind tables regardless of panic strategy.
• Added the embed-bitcode flag. This codegen flag allows rustc to include LLVM bitcode into generated rlibs (this is on by default).
• Added the tiny value to the code-model codegen flag.
• Added tier 3 support* for the mipsel-sony-psp target.
• Added tier 3 support for the thumbv7a-uwp-windows-msvc target.
• Upgraded to LLVM 10.

* Refer to Rust's platform support page for more information on Rust's tiered platform support.

Libraries

• net::{SocketAddr, SocketAddrV4, SocketAddrV6} now implements PartialOrd and Ord.
• proc_macro::TokenStream now implements Default.
• You can now use 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.
• The 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.
• The fetch_min, and fetch_max methods have been added to all atomic integer types.
• The fetch_update method has been added to all atomic integer types.

Stabilized APIs

• Arc::as_ptr
• BTreeMap::remove_entry
• Rc::as_ptr
• rc::Weak::as_ptr
• rc::Weak::from_raw
• rc::Weak::into_raw
• str::strip_prefix
• str::strip_suffix
• sync::Weak::as_ptr
• sync::Weak::from_raw
• sync::Weak::into_raw
• char::UNICODE_VERSION
• Span::resolved_at
• Span::located_at
• Span::mixed_site
• unix::process::CommandExt::arg0

Cargo

• Cargo uses the embed-bitcode flag to optimize disk usage and build time.

Misc

• Rustdoc now supports strikethrough text in Markdown. E.g. ~~outdated information~~ becomes "outdated information".
• Added an emoji to Rustdoc's deprecated API message.

Compatibility Notes

• Trying to self initialize a static value (that is creating a value using itself) is unsound and now causes a compile error.
• {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.
• Rustdoc's CLI's extra error exit codes have been removed. These were previously undocumented and not intended for public use. Rustdoc still provides a non-zero exit code on errors.
• Rustc's 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.

Internals Only

• Make clippy a git subtree instead of a git submodule
• Unify the undo log of all snapshot types

Rust 1.44.1

• rustfmt accepts rustfmt_skip in cfg_attr again.
• Don't hash executable filenames on apple platforms, fixing backtraces.
• Fix crashes when finding backtrace on macOS.
• Clippy applies lint levels into different files.

Rust 1.44.0

Language

• You can now use async/.await with #[no_std] enabled.
• Added the unused_braces lint.

Syntax-only changes

• Expansion-driven outline module parsing

#[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.

Compiler

• Rustc now respects the -C codegen-units flag in incremental mode. Additionally when in incremental mode rustc defaults to 256 codegen units.
• Refactored catch_unwind to have zero-cost, unless unwinding is enabled and a panic is thrown.
• Added tier 3* support for the aarch64-unknown-none and aarch64-unknown-none-softfloat targets.
• Added tier 3 support for arm64-apple-tvos and x86_64-apple-tvos targets.

Libraries

• Special cased 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.
• Unicode 13 is now supported.
• 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.

Stabilized APIs

• PathBuf::with_capacity
• PathBuf::capacity
• PathBuf::clear
• PathBuf::reserve
• PathBuf::reserve_exact
• PathBuf::shrink_to_fit
• f32::to_int_unchecked
• f64::to_int_unchecked
• Layout::align_to
• Layout::pad_to_align
• Layout::array
• Layout::extend

Cargo

• Added the cargo 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).

Misc

• Rustdoc now allows you to specify --crate-version to have rustdoc include the version in the sidebar.

Compatibility Notes

• Rustc now correctly generates static libraries on Windows GNU targets with the .a extension, rather than the previous .lib.
• Removed the -C no_integrated_as flag from rustc.
• The 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.
• The minimum required external LLVM version has been bumped to LLVM 8.
• mem::{zeroed, uninitialised} will now panic when used with types that do not allow zero initialization such as NonZeroU8. This was previously a warning.
• In 1.45.0 (the next release) converting a 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.

Internal Only

These changes provide no direct user facing benefits, but represent significant improvements to the internals and overall performance of rustc and related tools.

• dep_graph Avoid allocating a set on when the number reads are small.
• Replace big JS dict with JSON parsing.

Rust 1.43.1

• Updated openssl-src to 1.1.1g for CVE-2020-1967.
• Fixed the stabilization of AVX-512 features.
• Fixed cargo package --list not working with unpublished dependencies.

Rust 1.43.0

Language

• Fixed using binary operations with &{number} (e.g. &1.0) not having the type inferred correctly.
• Attributes such as #[cfg()] can now be used on if expressions.

Syntax only changes

• Allow type Foo: Ord syntactically.
• Fuse associated and extern items up to defaultness.
• Syntactically allow self in all fn contexts.
• Merge 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.

Compiler

• You can now pass multiple lint flags to rustc to override the previous flags. For example; 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).
• rustc will now prefer your system MinGW libraries over its bundled libraries if they are available on windows-gnu.
• rustc now buffers errors/warnings printed in JSON.

Libraries

• 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.
• You can now use associated constants on floats and integers directly, rather than having to import the module. e.g. You can now write u32::MAX or f32::NAN with no imports.
• u8::is_ascii is now const.
• String now implements AsMut<str>.
• Added the 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.
• Relaxed some of the trait bounds on HashMap and HashSet.
• string::FromUtf8Error now implements Clone + Eq.

Stabilized APIs

• Once::is_completed
• f32::LOG10_2
• f32::LOG2_10
• f64::LOG10_2
• f64::LOG2_10
• iter::once_with

Cargo

• You can now set config [profile]s in your .cargo/config, or through your environment.
• Cargo will now set 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").

Misc

• Certain checks in the const_err lint were deemed unrelated to const evaluation, and have been moved to the unconditional_panic and arithmetic_overflow lints.

Compatibility Notes

• Having trailing syntax in the assert! macro is now a hard error. This has been a warning since 1.36.0.
• Fixed Self not having the correctly inferred type. This incorrectly led to some instances being accepted, and now correctly emits a hard error.

Internal Only

These changes provide no direct user facing benefits, but represent significant improvements to the internals and overall performance of rustc and related tools.

• All components are now built with opt-level=3 instead of 2.
• Improved how rustc generates drop code.
• Improved performance from #[inline]-ing certain hot functions.
• traits: preallocate 2 Vecs of known initial size
• Avoid exponential behaviour when relating types
• Skip Drop terminators for enum variants without drop glue
• Improve performance of coherence checks
• Deduplicate types in the generator witness
• Invert control in struct_lint_level.

Rust 1.42.0

Language

• You 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.
  • Items in impls (i.e. consts, types, and fns) may syntactically leave out their bodies in favor of ;.
  • Bounds on associated types in 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.

Compiler

• Added tier 2* support for armv7a-none-eabi.
• Added tier 2 support for 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.

Libraries

• 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.
• Added Standard Library support for riscv64gc-unknown-linux-gnu.

Stabilized APIs

• CondVar::wait_while
• CondVar::wait_timeout_while
• DebugMap::key
• DebugMap::value
• ManuallyDrop::take
• matches!
• ptr::slice_from_raw_parts_mut
• ptr::slice_from_raw_parts

Cargo

• You no longer need to include extern crate proc_macro; to be able to use proc_macro; in the 2018 edition.

Compatibility Notes

• Error::description has been deprecated, and its use will now produce a warning. It's recommended to use Display/to_string instead.

Rust 1.41.1

• Always check types of static items
• Always check lifetime bounds of Copy impls
• Fix miscompilation in callers of Layout::repeat
• Rust 1.41.0 was announced as the last Rust release with tier 1 or tier 2 support for 32-bit Apple targets. That announcement did not expect a patch release. 1.41.1 also includes release binaries for these targets.

Rust 1.41.0

Language

• You can now pass type parameters to foreign items when implementing traits. E.g. You can now write impl<T> From<Foo> for Vec<T> {}.
• You can now arbitrarily nest receiver types in the 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.
• You can now use any valid identifier in a format_args macro. Previously identifiers starting with an underscore were not allowed.
• Visibility modifiers (e.g. 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.
• You can now define a Rust 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.

Compiler

• Rustc will now warn if you have unused loop 'labels.
• Removed support for the i686-unknown-dragonfly target.
• Added tier 3 support* for the riscv64gc-unknown-linux-gnu target.
• You can now pass an arguments file passing the @path syntax to rustc. Note that the format differs somewhat from what is found in other tooling; please see the documentation for more information.
• You can now provide --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.

Libraries

• The 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.

Stabilized APIs

• Result::map_or
• Result::map_or_else
• std::rc::Weak::weak_count
• std::rc::Weak::strong_count
• std::sync::Weak::weak_count
• std::sync::Weak::strong_count

Cargo

• Cargo will now document all the private items for binary crates by default.
• cargo-install will now reinstall the package if it detects that it is out of date.
• Cargo.lock now uses a more git friendly format that should help to reduce merge conflicts.
• You can now override specific dependencies's build settings E.g. [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.

Misc

• You can now specify 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.
• You can now provide custom themes to rustdoc with --theme, and check the current theme with --check-theme.
• You can use #[cfg(doc)] to compile an item when building documentation.

Compatibility Notes

• As previously announced 1.41 will be the last tier 1 release for 32-bit Apple targets. This means that the source code is still available to build, but the targets are no longer being tested and release binaries for those platforms will no longer be distributed by the Rust project. Please refer to the linked blog post for more information.