LastPass (64-bit)

What's new in this version:

Rust 1.46.0
Language:
- if, match, and loop expressions can now be used in const functions
- Additionally you are now also able to coerce and cast to slices (&[T]) in const functions
- The #[track_caller] attribute can now be added to functions to use the function's caller's location information for panic messages
- Recursively indexing into tuples no longer needs parentheses. E.g. x.0.0 over (x.0).0
- mem::transmute can now be used in static and constants. Note You currently can't use mem::transmute in constant functions

Compiler:
- You can now use the cdylib target on Apple iOS and tvOS platforms
- Enabled static "Position Independent Executables" by default for x86_64-unknown-linux-musl

Libraries:
- mem::forget is now a const fn
- String now implements From<char>
- The leading_ones, and trailing_ones methods have been stabilised for all integer types
- vec::IntoIter<T> now implements AsRef<[T]>
- All non-zero integer types (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]>

Stabilized APIs:
- Option::zip
- vec::Drain::as_slice

Cargo
- 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

Compatibility Notes:
- The target configuration option abi_blacklist has been renamed to unsupported_abis. The old name will still continue to work
- Rustc will now warn if you have a C-like enum that implements Drop. This was previously accepted but will become a hard error in a future release
- Rustc will fail to compile if you have a struct with #[repr(i128)] or #[repr(u128)]. This representation is currently only allowed on enums
- Tokens passed to 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
- The InnoSetup installer for Windows is no longer available. This was a legacy installer that was replaced by a MSI installer a few years ago but was still being built
- {f32, f64}::asinh now returns the correct values for negative numbers
- Rustc will no longer accept overlapping trait implementations that only differ in how the lifetime was bound
- Rustc now correctly relates the lifetime of an existential associated type. This fixes some edge cases where rustc would erroneously allow you to pass a shorter lifetime than expected
- Rustc now dynamically links to 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
- Tests annotated with #[should_panic] are broken on ARMv7 while running under QEMU
- Pretty printing of some tokens in procedural macros changed. The exact output returned by rustc's pretty printing is an unstable implementation detail: we recommend any macro relying on it to switch to a more robust parsing system


Rust 1.45.2
- Fix bindings in tuple struct patterns
- Fix track_caller integration with trait objects


Rust 1.45.1
- Change log not available for this version


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 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
- 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
- OsString now implements FromStr
- The saturating_neg method as been added to all signed integer primitive types, and the saturating_abs method has been added for all integer primitive types
- Arc, Rc now implement From<Cow<'_, T>>, and Box now implements From 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


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
- 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 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
- 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 . Note: this may not point 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, you can use the {f64, f32}::to_int_unchecked methods to continue using the current behaviour which may 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
- 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.
- 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_ pointing to a binary's executable path when running integration tests or benchmarks. 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.41.0
Language:
- You can now pass type parameters to foreign items when implementing traits. E.g. You can now write impl From for Vec {}
- You can now arbitrarily nest receiver types in the self position. E.g. you can now write fn foo(self: Box) {}. Previously only Self, &Self, &mut Self, Arc, Rc, and Box 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

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
- MaybeUninit 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..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


Rust 1.40.0
Language:
- 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!()
- Function-like and attribute procedural macros can now emit macro_rules! items, so you can now have your macros generate macros
- 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)]

Compiler:
- Added tier 3 support* for the thumbv7neon-unknown-linux-musleabihf target
- Added tier 3 support for the aarch64-unknown-none-softfloat target
- Added tier 3 support for the 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

Libraries:
- The is_power_of_two method on unsigned numeric types is now a const function

Stabilized APIs:
- BTreeMap::get_key_value
- HashMap::get_key_value
- Option::as_deref_mut
- Option::as_deref
- Option::flatten
- UdpSocket::peer_addr
- f32::to_be_bytes
- f32::to_le_bytes
- f32::to_ne_bytes
- f64::to_be_bytes
- f64::to_le_bytes
- f64::to_ne_bytes
- f32::from_be_bytes
- f32::from_le_bytes
- f32::from_ne_bytes
- f64::from_be_bytes
- f64::from_le_bytes
- f64::from_ne_bytes
- mem::take
- slice::repeat
- todo!

Cargo:
- Cargo will now always display warnings, rather than only on fresh builds
- Feature flags (except --all-features) passed to a virtual workspace will now produce an error. Previously these flags were ignored
- You can now publish dev-dependencies without including a version.

Misc:
- You can now specify the #[cfg(doctest)] attribute to include an item only when running documentation tests with rustdoc

Compatibility Notes:
- As previously announced, any previous NLL warnings in the 2015 edition are now hard errors
- The 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.
- Using #[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


Rust 1.39.0
Language:
- You can now create async functions and blocks with async fn, async move {}, and async {} respectively, and you can now call .await on async expressions.
- You can now use certain attributes on function, closure, and function pointer parameters. These attributes include 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()
- You can now take shared references to bind-by-move patterns in the 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::() == 10
- // ^------ `.iter()` implicitly takes a reference to `nums`.
- => {
- drop(nums);
- // ----------- Legal as `nums` was bound by move and so we have ownership.
- _ => unreachable!(),

Compiler:
- Added tier 3* support for the i686-unknown-uefi target
- Added tier 3 support for the sparc64-unknown-openbsd target
- rustc will now trim code snippets in diagnostics to fit in your terminal. Note Cargo currently doesn't use this feature. Refer to cargo#7315 to track this feature's progress
- You can now pass --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

Libraries:
- 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
- The abs, wrapping_abs, and overflowing_abs numeric functions are now const

Stabilized APIs:
- Pin::into_inner
- Instant::checked_duration_since
- Instant::saturating_duration_since

Cargo:
- You can now publish git dependencies if supplied with a version
- The --all flag has been renamed to --workspace. Using --all is now deprecated

Misc:
- You can now pass -Clinker to rustdoc to control the linker used for compiling doctests

Compatibility Notes:
- Code that was previously accepted by the old borrow checker, but rejected by the NLL borrow checker is now a hard error in Rust 2018. This was previously a warning, and will also become a hard error in the Rust 2015 edition in the 1.40.0 release
- 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
- The 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


Rust 1.38.0
Language:
- The #[global_allocator] attribute can now be used in submodules
- The #[deprecated] attribute can now be used on macros

Compiler:
- Added pipelined compilation support to rustc. This will improve compilation times in some cases. For further information please refer to the "Evaluating pipelined rustc compilation" thread
- Added tier 3 support for the aarch64-uwp-windows-msvc, i686-uwp-windows-gnu, i686-uwp-windows-msvc, x86_64-uwp-windows-gnu, and x86_64-uwp-windows-msvc targets
- Added tier 3 support for the armv7-unknown-linux-gnueabi and armv7-unknown-linux-musleabi targets
- Added tier 3 support for the hexagon-unknown-linux-musl target
- Added tier 3 support for the riscv32i-unknown-none-elf target

Libraries:
- ascii::EscapeDefault now implements Clone and Display
- Derive macros for prelude traits (e.g. 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.
- Added euclidean remainder and division operations (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

Stabilized APIs:
- <*const T>::cast
- <*mut T>::cast
- Duration::as_secs_f32
- Duration::as_secs_f64
- Duration::div_duration_f32
- Duration::div_duration_f64
- Duration::div_f32
- Duration::div_f64
- Duration::from_secs_f32
- Duration::from_secs_f64
- Duration::mul_f32
- Duration::mul_f64
- any::type_name

Cargo:
- Added pipelined compilation support to cargo
- You can now pass the --features option multiple times to enable multiple features

Misc:
- rustc will now warn about some incorrect uses of mem::{uninitialized, zeroed} that are known to cause undefined behaviour

Compatibility Notes:
- The x86_64-unknown-uefi platform can not be built with rustc 1.38.0
- The armv7-unknown-linux-gnueabihf platform is known to have issues with certain crates such as libc


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;
- 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 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.