|
| 1 | +--- |
| 2 | +layout: post |
| 3 | +title: "Announcing Rust 1.82.0" |
| 4 | +author: The Rust Release Team |
| 5 | +release: true |
| 6 | +--- |
| 7 | + |
| 8 | +The Rust team is happy to announce a new version of Rust, 1.82.0. Rust is a programming language empowering everyone to build reliable and efficient software. |
| 9 | + |
| 10 | +If you have a previous version of Rust installed via `rustup`, you can get 1.82.0 with: |
| 11 | + |
| 12 | +```console |
| 13 | +$ rustup update stable |
| 14 | +``` |
| 15 | + |
| 16 | +If you don't have it already, you can [get `rustup`](https://www.rust-lang.org/install.html) from the appropriate page on our website, and check out the [detailed release notes for 1.82.0](https://doc.rust-lang.org/nightly/releases.html#version-1820-2024-10-17). |
| 17 | + |
| 18 | +If you'd like to help us out by testing future releases, you might consider updating locally to use the beta channel (`rustup default beta`) or the nightly channel (`rustup default nightly`). Please [report](https://github.com/rust-lang/rust/issues/new/choose) any bugs you might come across! |
| 19 | + |
| 20 | +## What's in 1.82.0 stable |
| 21 | + |
| 22 | +### `cargo info` |
| 23 | + |
| 24 | +Cargo now has an [`info` subcommand](https://doc.rust-lang.org/nightly/cargo/commands/cargo-info.html) to display information about a package in the registry, fulfilling a [long standing request](https://github.com/rust-lang/cargo/issues/948) just shy of its tenth anniversary! Several third-party extensions like this have been written over the years, and this implementation was developed as [cargo-information](https://crates.io/crates/cargo-information) before merging into Cargo itself. |
| 25 | + |
| 26 | +For example, here's what you could see for `cargo info cc`: |
| 27 | + |
| 28 | +<pre> |
| 29 | +<b><span style="color:#0A0">cc</span></b> <b><span style="color:#0AA">#build-dependencies</span></b> |
| 30 | +A build-time dependency for Cargo build scripts to assist in invoking the native |
| 31 | +C compiler to compile native C code into a static archive to be linked into Rust |
| 32 | +code. |
| 33 | +<b><span style="color:#0A0">version:</span></b> 1.1.23 <b><span style="color:#A50">(latest 1.1.30)</span></b> |
| 34 | +<b><span style="color:#0A0">license:</span></b> MIT OR Apache-2.0 |
| 35 | +<b><span style="color:#0A0">rust-version:</span></b> 1.63 |
| 36 | +<b><span style="color:#0A0">documentation:</span></b> https://docs.rs/cc |
| 37 | +<b><span style="color:#0A0">homepage:</span></b> https://github.com/rust-lang/cc-rs |
| 38 | +<b><span style="color:#0A0">repository:</span></b> https://github.com/rust-lang/cc-rs |
| 39 | +<b><span style="color:#0A0">crates.io:</span></b> https://crates.io/crates/cc/1.1.23 |
| 40 | +<b><span style="color:#0A0">features:</span></b> |
| 41 | + jobserver = [] |
| 42 | + parallel = [dep:libc, dep:jobserver] |
| 43 | +<b><span style="color:#0AA">note</span></b><b>:</b> to see how you depend on cc, run `<b><span style="color:#0AA">cargo tree --invert --package cc@1.1.23</span></b>` |
| 44 | +</pre> |
| 45 | + |
| 46 | +By default `cargo info` describes the package version in the local `Cargo.lock`, if any, but as you can see it will indicate when there's a newer version too, and `cargo info cc@1.1.30` would report on that. |
| 47 | + |
| 48 | +### Apple target promotions |
| 49 | + |
| 50 | +#### macOS on ARM64 is now Tier 1 |
| 51 | + |
| 52 | +The Rust target `aarch64-apple-darwin` for macOS on ARM64 (M1-family or later Apple Silicon CPUs) is now a tier 1 target, indicating our highest guarantee of working properly. As the [platform support](https://doc.rust-lang.org/stable/rustc/platform-support.html) page describes, every change in the Rust repository must pass full tests on every tier 1 target before it can be merged. This ARM64 target was added to tier 2 back in Rust 1.49, making it available in `rustup`, and this new milestone raises it on par with ARM64 Linux and the X86 macOS, Linux, and Windows targets. |
| 53 | + |
| 54 | +#### Mac Catalyst targets are now Tier 2 |
| 55 | + |
| 56 | +[Mac Catalyst](https://developer.apple.com/mac-catalyst/) is a technology by Apple that allows running iOS applications natively on the Mac. This is especially useful when testing iOS-specific code, as `cargo test --target=aarch64-apple-ios-macabi --target=x86_64-apple-ios-macabi` mostly just works (in contrast to the usual iOS targets, which need to be bundled using external tooling before they can be run on a native device or in the simulator). |
| 57 | + |
| 58 | +[The targets](https://doc.rust-lang.org/nightly/rustc/platform-support/apple-ios-macabi.html) are now tier 2, and can be downloaded with `rustup target add aarch64-apple-ios-macabi x86_64-apple-ios-macabi`, so now is an excellent time to update your CI pipeline to test that your code also runs in iOS-like environments. |
| 59 | + |
| 60 | +### Minimal exhaustive patterns |
| 61 | + |
| 62 | +Empty patterns can now be omitted in common cases: |
| 63 | + |
| 64 | +```rust |
| 65 | +use std::convert::Infallible; |
| 66 | +pub fn safe_unwrap<T>(x: Result<T, Infallible>) -> T { |
| 67 | + let Ok(x) = x; // the `Err` case does not need to appear |
| 68 | + x |
| 69 | +} |
| 70 | +``` |
| 71 | + |
| 72 | +This works with empty types such as a variant-less `enum Void {}`, or structs and enums with a visible empty field and no `#[non_exhaustive]` attribute. It will also be particularly useful in combination with the never type `!`, although that type is still unstable at this time. |
| 73 | + |
| 74 | +This feature is "minimal" because there are still some exclusions at this time. For reasons related to uninitialized values and unsafe code, omitting patterns is not allowed if the empty type is accessed through a reference, pointer, or union field: |
| 75 | + |
| 76 | +```rust |
| 77 | +pub fn safe_unwrap_ref<T>(x: &Result<T, Infallible>) -> &T { |
| 78 | + match x { |
| 79 | + Ok(x) => x, |
| 80 | + // this branch cannot be omitted because of the reference |
| 81 | + Err(infallible) => match *infallible {}, |
| 82 | + } |
| 83 | +} |
| 84 | +``` |
| 85 | + |
| 86 | +To avoid interfering with crates that wish to support several rust versions, branches with empty patterns are not yet warned as "unreachable", despite the fact that they can be removed. |
| 87 | + |
| 88 | +### Floating-point NaN semantics and `const` |
| 89 | + |
| 90 | +Operations on floating-point values (of type `f32` and `f64`) are famously subtle. One of the reasons for this is the existence of "NaN values": this is short for "Not a Number", and is used to represent e.g. the result of `0.0 / 0.0`. What makes NaN values subtle is that more than one possible NaN value exists: a NaN value has a sign that can be checked with `f.is_sign_positive()`, and it has a "payload" that can be extracted with `f.to_bits()`. Despite very successful efforts to standardize the behavior of floating-point operations across hardware architectures, the details of when a NaN is positive or negative and what its exact payload is differ across architectures. To make matters even more complicated, Rust and its LLVM backend apply optimizations to floating-point operations when the exact numeric result is guaranteed not to change, but those optimizations can change which NaN value is produced. For instance, `f * 1.0` may be optimized to just `f`. However, if `f` is a NaN, this can change the exact bit pattern of the result! |
| 91 | + |
| 92 | +With this release, Rust standardizes on a set of rules for how NaN values behave. This set of rules is *not* fully deterministic, which means that the result of operations like `(0.0 / 0.0).is_sign_positive()` can differ depending on the hardware architecture, optimization levels, and the surrounding code. Code that aims to be fully portable should avoid using `to_bits` and should use `f.signum() == 1.0` instead of `f.is_sign_positive()`. However, the rules are carefully chosen to still allow advanced optimization techniques such as NaN boxing to be realized in Rust code. For more details on what the exact rules are, check out our [documentation](https://doc.rust-lang.org/std/primitive.f32.html#nan-bit-patterns). |
| 93 | + |
| 94 | +With the semantics for NaN values settled, this release also permits the use of floating-point operations in `const fn`. Due to the reasons described above, operations like `(0.0 / 0.0).is_sign_positive()` can produce a different result when executed at compile-time vs at run-time; this is not a bug and code must not rely on a `const fn` always producing the exact same result. |
| 95 | + |
| 96 | +### Native syntax for creating a raw pointer |
| 97 | + |
| 98 | +Unsafe code sometimes has to deal with pointers that may dangle, may be misaligned, or may not point to valid data. A common case where this comes up are packed structs. In such a case, it is important to avoid creating a reference, as that would cause undefined behavior. This means the usual `&` and `&mut` operators cannot be used, as those create a reference -- even if the reference is immediately cast to a raw pointer, it's too late to avoid the undefined behavior. |
| 99 | + |
| 100 | +For several years, the macros `std::ptr::addr_of!` and `std::ptr::addr_of_mut!` have served this purpose. Now the time has come to provide a proper native syntax for this operation: `addr_of!(expr)` becomes `&raw const expr`, and `addr_of_mut!(expr)` becomes `&raw mut expr`. For example: |
| 101 | + |
| 102 | +```rust |
| 103 | +#[repr(packed)] |
| 104 | +struct Packed { |
| 105 | + not_aligned_field: i32, |
| 106 | +} |
| 107 | + |
| 108 | +fn main() { |
| 109 | + let p = Packed { not_aligned_field: 1_82 }; |
| 110 | + |
| 111 | + // This would be undefined behavior! |
| 112 | + // It is rejected by the compiler. |
| 113 | + //let ptr = &p.not_aligned_field as *const i32; |
| 114 | + |
| 115 | + // This is the old way of creating a pointer. |
| 116 | + let ptr = std::ptr::addr_of!(p.not_aligned_field); |
| 117 | + |
| 118 | + // This is the new way. |
| 119 | + let ptr = &raw const p.not_aligned_field; |
| 120 | + |
| 121 | + // Accessing the pointer has not changed. |
| 122 | + // Note that `val = *ptr` would be undefined behavior because |
| 123 | + // the pointer is not aligned! |
| 124 | + let val = unsafe { ptr.read_unaligned() }; |
| 125 | +} |
| 126 | +``` |
| 127 | + |
| 128 | +The native syntax makes it more clear that the operand expression of these operators is interpreted as a [place expression](https://www.ralfj.de/blog/2024/08/14/places.html). It also avoids the term "address-of" when referring to the action of creating a pointer. A pointer is [more than just an address](https://rust-lang.github.io/rfcs/3559-rust-has-provenance.html), so Rust is moving away from terms like "address-of" that reaffirm a false equivalence of pointers and addresses. |
| 129 | + |
| 130 | +### Safely addressing unsafe `static`s |
| 131 | + |
| 132 | +This code is now allowed: |
| 133 | + |
| 134 | +```rust |
| 135 | +static mut STATIC_MUT: Type = Type::new(); |
| 136 | +extern "C" { |
| 137 | + static EXTERN_STATIC: Type; |
| 138 | +} |
| 139 | +fn main() { |
| 140 | + let static_mut_ptr = std::ptr::addr_of_mut!(STATIC_MUT); |
| 141 | + let extern_static_ptr = &raw const EXTERN_STATIC; |
| 142 | +} |
| 143 | +``` |
| 144 | + |
| 145 | +In an expression context, `STATIC_MUT` and `EXTERN_STATIC` are [place expressions](https://doc.rust-lang.org/reference/expressions.html#place-expressions-and-value-expressions). Previously, the compiler's safety checks were not aware that the raw ref operator did not actually affect the operand's place, treating it as a possible read or write to a pointer. No unsafety is actually present, however, as it just creates a pointer. |
| 146 | + |
| 147 | +Relaxing this may cause problems where some unsafe blocks are now reported as unused if you deny the `unused_unsafe` lint, but they are now only useful on older versions. Annotate these unsafe blocks with `#[allow(unused_unsafe)]` if you wish to support multiple versions of Rust, as in this example diff: |
| 148 | + |
| 149 | +```diff |
| 150 | + static mut STATIC_MUT: Type = Type::new(); |
| 151 | + fn main() { |
| 152 | ++ #[allow(unused_unsafe)] |
| 153 | + let static_mut_ptr = unsafe { std::ptr::addr_of_mut!(STATIC_MUT) }; |
| 154 | + } |
| 155 | +``` |
| 156 | + |
| 157 | +A future version of Rust is expected to generalize this to other expressions which would be safe in this position, not just statics. |
| 158 | + |
| 159 | +### Unsafe attributes |
| 160 | + |
| 161 | +Some Rust attributes, such as `no_mangle`, can be used to [cause Undefined Behavior without any `unsafe` block](https://github.com/rust-lang/rust/issues/28179). If this was regular code we would require them to be placed in an `unsafe {}` block, but so far attributes have not had comparable syntax. To reflect the fact that these attributes can undermine Rust's safety guarantees, they are now considered "unsafe" and should be written as follows: |
| 162 | + |
| 163 | +```rust |
| 164 | +#[unsafe(no_mangle)] |
| 165 | +pub fn my_global_function() { } |
| 166 | +``` |
| 167 | + |
| 168 | +The old form of the attribute (without `unsafe`) is currently still accepted, but might be linted against at some point in the future, and will be a hard error in a future edition. |
| 169 | + |
| 170 | +This affects the following attributes: |
| 171 | +- `no_mangle` |
| 172 | +- `link_section` |
| 173 | +- `export_name` |
| 174 | + |
| 175 | +### Constants as assembly immediates |
| 176 | + |
| 177 | +The `const` assembly operand now provides a way to use integers as immediates |
| 178 | +without first storing them in a register. As an example, we implement a syscall to |
| 179 | +[`write`](https://man7.org/linux/man-pages/man2/write.2.html) by hand: |
| 180 | + |
| 181 | +```rust |
| 182 | +const WRITE_SYSCALL: c_int = 0x01; // syscall 1 is `write` |
| 183 | +const STDOUT_HANDLE: c_int = 0x01; // `stdout` has file handle 1 |
| 184 | +const MSG: &str = "Hello, world!\n"; |
| 185 | + |
| 186 | +let written: usize; |
| 187 | + |
| 188 | +// Signature: `ssize_t write(int fd, const void buf[], size_t count)` |
| 189 | +unsafe { |
| 190 | + core::arch::asm!( |
| 191 | + "mov rax, {SYSCALL} // rax holds the syscall number", |
| 192 | + "mov rdi, {OUTPUT} // rdi is `fd` (first argument)", |
| 193 | + "mov rdx, {LEN} // rdx is `count` (third argument)", |
| 194 | + "syscall // invoke the syscall", |
| 195 | + "mov {written}, rax // save the return value", |
| 196 | + SYSCALL = const WRITE_SYSCALL, |
| 197 | + OUTPUT = const STDOUT_HANDLE, |
| 198 | + LEN = const MSG.len(), |
| 199 | + in("rsi") MSG.as_ptr(), // rsi is `buf *` (second argument) |
| 200 | + written = out(reg) written, |
| 201 | + ); |
| 202 | +} |
| 203 | + |
| 204 | +assert_eq!(written, MSG.len()); |
| 205 | +``` |
| 206 | + |
| 207 | +Output: |
| 208 | + |
| 209 | +```text |
| 210 | +Hello, world! |
| 211 | +``` |
| 212 | + |
| 213 | +[Playground link](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=0cf8e21335b38011b49156c6c65929bc). |
| 214 | + |
| 215 | +In the above, a statement such as `LEN = const MSG.len()` populates the format |
| 216 | +specifier `LEN` with an immediate that takes the value of `MSG.len()`. This can be seen |
| 217 | +in the generated assembly (the value is `14`): |
| 218 | + |
| 219 | +```asm |
| 220 | +lea rsi, [rip + .L__unnamed_3] |
| 221 | +mov rax, 1 # rax holds the syscall number |
| 222 | +mov rdi, 1 # rdi is `fd` (first argument) |
| 223 | +mov rdx, 14 # rdx is `count` (third argument) |
| 224 | +syscall # invoke the syscall |
| 225 | +mov rax, rax # save the return value |
| 226 | +``` |
| 227 | + |
| 228 | +See [the reference](https://doc.rust-lang.org/reference/inline-assembly.html) |
| 229 | +for more details. |
| 230 | + |
| 231 | +### Stabilized APIs |
| 232 | + |
| 233 | +- [`std::thread::Builder::spawn_unchecked`](https://doc.rust-lang.org/stable/std/thread/struct.Builder.html#method.spawn_unchecked) |
| 234 | +- [`std::str::CharIndices::offset`](https://doc.rust-lang.org/nightly/std/str/struct.CharIndices.html#method.offset) |
| 235 | +- [`std::option::Option::is_none_or`](https://doc.rust-lang.org/nightly/std/option/enum.Option.html#method.is_none_or) |
| 236 | +- [`[T]::is_sorted`](https://doc.rust-lang.org/nightly/std/primitive.slice.html#method.is_sorted) |
| 237 | +- [`[T]::is_sorted_by`](https://doc.rust-lang.org/nightly/std/primitive.slice.html#method.is_sorted_by) |
| 238 | +- [`[T]::is_sorted_by_key`](https://doc.rust-lang.org/nightly/std/primitive.slice.html#method.is_sorted_by_key) |
| 239 | +- [`Iterator::is_sorted`](https://doc.rust-lang.org/nightly/std/iter/trait.Iterator.html#method.is_sorted) |
| 240 | +- [`Iterator::is_sorted_by`](https://doc.rust-lang.org/nightly/std/iter/trait.Iterator.html#method.is_sorted_by) |
| 241 | +- [`Iterator::is_sorted_by_key`](https://doc.rust-lang.org/nightly/std/iter/trait.Iterator.html#method.is_sorted_by_key) |
| 242 | +- [`std::future::Ready::into_inner`](https://doc.rust-lang.org/nightly/std/future/struct.Ready.html#method.into_inner) |
| 243 | +- [`std::iter::repeat_n`](https://doc.rust-lang.org/nightly/std/iter/fn.repeat_n.html) |
| 244 | +- [`impl<T: Clone> DoubleEndedIterator for Take<Repeat<T>>`](https://doc.rust-lang.org/nightly/std/iter/struct.Take.html#impl-DoubleEndedIterator-for-Take%3CRepeat%3CT%3E%3E) |
| 245 | +- [`impl<T: Clone> ExactSizeIterator for Take<Repeat<T>>`](https://doc.rust-lang.org/nightly/std/iter/struct.Take.html#impl-ExactSizeIterator-for-Take%3CRepeat%3CT%3E%3E) |
| 246 | +- [`impl<T: Clone> ExactSizeIterator for Take<RepeatWith<T>>`](https://doc.rust-lang.org/nightly/std/iter/struct.Take.html#impl-ExactSizeIterator-for-Take%3CRepeatWith%3CF%3E%3E) |
| 247 | +- [`impl Default for std::collections::binary_heap::Iter`](https://doc.rust-lang.org/nightly/std/collections/binary_heap/struct.Iter.html#impl-Default-for-Iter%3C'_,+T%3E) |
| 248 | +- [`impl Default for std::collections::btree_map::RangeMut`](https://doc.rust-lang.org/nightly/std/collections/btree_map/struct.RangeMut.html#impl-Default-for-RangeMut%3C'_,+K,+V%3E) |
| 249 | +- [`impl Default for std::collections::btree_map::ValuesMut`](https://doc.rust-lang.org/nightly/std/collections/btree_map/struct.ValuesMut.html#impl-Default-for-ValuesMut%3C'_,+K,+V%3E) |
| 250 | +- [`impl Default for std::collections::vec_deque::Iter`](https://doc.rust-lang.org/nightly/std/collections/vec_deque/struct.Iter.html#impl-Default-for-Iter%3C'_,+T%3E) |
| 251 | +- [`impl Default for std::collections::vec_deque::IterMut`](https://doc.rust-lang.org/nightly/std/collections/vec_deque/struct.IterMut.html#impl-Default-for-IterMut%3C'_,+T%3E) |
| 252 | +- [`Rc<T>::new_uninit`](https://doc.rust-lang.org/nightly/std/rc/struct.Rc.html#method.new_uninit) |
| 253 | +- [`Rc<T>::assume_init`](https://doc.rust-lang.org/nightly/std/rc/struct.Rc.html#method.assume_init) |
| 254 | +- [`Rc<[T]>::new_uninit_slice`](https://doc.rust-lang.org/nightly/std/rc/struct.Rc.html#method.new_uninit_slice) |
| 255 | +- [`Rc<[MaybeUninit<T>]>::assume_init`](https://doc.rust-lang.org/nightly/std/rc/struct.Rc.html#method.assume_init-1) |
| 256 | +- [`Arc<T>::new_uninit`](https://doc.rust-lang.org/nightly/std/sync/struct.Arc.html#method.new_uninit) |
| 257 | +- [`Arc<T>::assume_init`](https://doc.rust-lang.org/nightly/std/sync/struct.Arc.html#method.assume_init) |
| 258 | +- [`Arc<[T]>::new_uninit_slice`](https://doc.rust-lang.org/nightly/std/sync/struct.Arc.html#method.new_uninit_slice) |
| 259 | +- [`Arc<[MaybeUninit<T>]>::assume_init`](https://doc.rust-lang.org/nightly/std/sync/struct.Arc.html#method.assume_init-1) |
| 260 | +- [`Box<T>::new_uninit`](https://doc.rust-lang.org/nightly/std/boxed/struct.Box.html#method.new_uninit) |
| 261 | +- [`Box<T>::assume_init`](https://doc.rust-lang.org/nightly/std/boxed/struct.Box.html#method.assume_init) |
| 262 | +- [`Box<[T]>::new_uninit_slice`](https://doc.rust-lang.org/nightly/std/boxed/struct.Box.html#method.new_uninit_slice) |
| 263 | +- [`Box<[MaybeUninit<T>]>::assume_init`](https://doc.rust-lang.org/nightly/std/boxed/struct.Box.html#method.assume_init-1) |
| 264 | +- [`core::arch::x86_64::_bextri_u64`](https://doc.rust-lang.org/stable/core/arch/x86_64/fn._bextri_u64.html) |
| 265 | +- [`core::arch::x86_64::_bextri_u32`](https://doc.rust-lang.org/stable/core/arch/x86_64/fn._bextri_u32.html) |
| 266 | +- [`core::arch::x86::_mm_broadcastsi128_si256`](https://doc.rust-lang.org/stable/core/arch/x86/fn._mm_broadcastsi128_si256.html) |
| 267 | +- [`core::arch::x86::_mm256_stream_load_si256`](https://doc.rust-lang.org/stable/core/arch/x86/fn._mm256_stream_load_si256.html) |
| 268 | +- [`core::arch::x86::_tzcnt_u16`](https://doc.rust-lang.org/stable/core/arch/x86/fn._tzcnt_u16.html) |
| 269 | +- [`core::arch::x86::_mm_extracti_si64`](https://doc.rust-lang.org/stable/core/arch/x86/fn._mm_extracti_si64.html) |
| 270 | +- [`core::arch::x86::_mm_inserti_si64`](https://doc.rust-lang.org/stable/core/arch/x86/fn._mm_inserti_si64.html) |
| 271 | +- [`core::arch::x86::_mm_storeu_si16`](https://doc.rust-lang.org/stable/core/arch/x86/fn._mm_storeu_si16.html) |
| 272 | +- [`core::arch::x86::_mm_storeu_si32`](https://doc.rust-lang.org/stable/core/arch/x86/fn._mm_storeu_si32.html) |
| 273 | +- [`core::arch::x86::_mm_storeu_si64`](https://doc.rust-lang.org/stable/core/arch/x86/fn._mm_storeu_si64.html) |
| 274 | +- [`core::arch::x86::_mm_loadu_si16`](https://doc.rust-lang.org/stable/core/arch/x86/fn._mm_loadu_si16.html) |
| 275 | +- [`core::arch::x86::_mm_loadu_si32`](https://doc.rust-lang.org/stable/core/arch/x86/fn._mm_loadu_si32.html) |
| 276 | +- [`core::arch::wasm32::u8x16_relaxed_swizzle`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u8x16_relaxed_swizzle.html) |
| 277 | +- [`core::arch::wasm32::i8x16_relaxed_swizzle`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i8x16_relaxed_swizzle.html) |
| 278 | +- [`core::arch::wasm32::i32x4_relaxed_trunc_f32x4`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i32x4_relaxed_trunc_f32x4.html) |
| 279 | +- [`core::arch::wasm32::u32x4_relaxed_trunc_f32x4`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u32x4_relaxed_trunc_f32x4.html) |
| 280 | +- [`core::arch::wasm32::i32x4_relaxed_trunc_f64x2_zero`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i32x4_relaxed_trunc_f64x2_zero.html) |
| 281 | +- [`core::arch::wasm32::u32x4_relaxed_trunc_f64x2_zero`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u32x4_relaxed_trunc_f64x2_zero.html) |
| 282 | +- [`core::arch::wasm32::f32x4_relaxed_madd`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.f32x4_relaxed_madd.html) |
| 283 | +- [`core::arch::wasm32::f32x4_relaxed_nmadd`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.f32x4_relaxed_nmadd.html) |
| 284 | +- [`core::arch::wasm32::f64x2_relaxed_madd`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.f64x2_relaxed_madd.html) |
| 285 | +- [`core::arch::wasm32::f64x2_relaxed_nmadd`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.f64x2_relaxed_nmadd.html) |
| 286 | +- [`core::arch::wasm32::i8x16_relaxed_laneselect`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i8x16_relaxed_laneselect.html) |
| 287 | +- [`core::arch::wasm32::u8x16_relaxed_laneselect`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u8x16_relaxed_laneselect.html) |
| 288 | +- [`core::arch::wasm32::i16x8_relaxed_laneselect`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i16x8_relaxed_laneselect.html) |
| 289 | +- [`core::arch::wasm32::u16x8_relaxed_laneselect`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u16x8_relaxed_laneselect.html) |
| 290 | +- [`core::arch::wasm32::i32x4_relaxed_laneselect`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i32x4_relaxed_laneselect.html) |
| 291 | +- [`core::arch::wasm32::u32x4_relaxed_laneselect`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u32x4_relaxed_laneselect.html) |
| 292 | +- [`core::arch::wasm32::i64x2_relaxed_laneselect`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i64x2_relaxed_laneselect.html) |
| 293 | +- [`core::arch::wasm32::u64x2_relaxed_laneselect`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u64x2_relaxed_laneselect.html) |
| 294 | +- [`core::arch::wasm32::f32x4_relaxed_min`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.f32x4_relaxed_min.html) |
| 295 | +- [`core::arch::wasm32::f32x4_relaxed_max`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.f32x4_relaxed_max.html) |
| 296 | +- [`core::arch::wasm32::f64x2_relaxed_min`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.f64x2_relaxed_min.html) |
| 297 | +- [`core::arch::wasm32::f64x2_relaxed_max`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.f64x2_relaxed_max.html) |
| 298 | +- [`core::arch::wasm32::i16x8_relaxed_q15mulr`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i16x8_relaxed_q15mulr.html) |
| 299 | +- [`core::arch::wasm32::u16x8_relaxed_q15mulr`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u16x8_relaxed_q15mulr.html) |
| 300 | +- [`core::arch::wasm32::i16x8_relaxed_dot_i8x16_i7x16`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i16x8_relaxed_dot_i8x16_i7x16.html) |
| 301 | +- [`core::arch::wasm32::u16x8_relaxed_dot_i8x16_i7x16`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u16x8_relaxed_dot_i8x16_i7x16.html) |
| 302 | +- [`core::arch::wasm32::i32x4_relaxed_dot_i8x16_i7x16_add`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i32x4_relaxed_dot_i8x16_i7x16_add.html) |
| 303 | +- [`core::arch::wasm32::u32x4_relaxed_dot_i8x16_i7x16_add`](https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u32x4_relaxed_dot_i8x16_i7x16_add.html) |
| 304 | + |
| 305 | +These APIs are now stable in const contexts: |
| 306 | + |
| 307 | +- [`std::task::Waker::from_raw`](https://doc.rust-lang.org/nightly/std/task/struct.Waker.html#method.from_raw) |
| 308 | +- [`std::task::Waker::waker`](https://doc.rust-lang.org/nightly/std/task/struct.Waker.html#method.from_raw) |
| 309 | +- [`std::task::Context::from_waker`](https://doc.rust-lang.org/nightly/std/task/struct.Context.html#method.from_waker) |
| 310 | +- [`std::task::Context::waker`](https://doc.rust-lang.org/nightly/std/task/struct.Context.html#method.waker) |
| 311 | +- [`$integer::from_str_radix`](https://doc.rust-lang.org/nightly/std/primitive.u32.html#method.from_str_radix) |
| 312 | +- [`std::num::ParseIntError::kind`](https://doc.rust-lang.org/nightly/std/num/struct.ParseIntError.html#method.kind) |
| 313 | + |
| 314 | +### Other changes |
| 315 | + |
| 316 | +Check out everything that changed in [Rust](https://github.com/rust-lang/rust/releases/tag/1.82.0), [Cargo](https://github.com/rust-lang/cargo/blob/master/CHANGELOG.md#cargo-182-2024-10-17), and [Clippy](https://github.com/rust-lang/rust-clippy/blob/master/CHANGELOG.md#rust-182). |
| 317 | + |
| 318 | +## Contributors to 1.82.0 |
| 319 | + |
| 320 | +Many people came together to create Rust 1.82.0. We couldn't have done it without all of you. [Thanks!](https://thanks.rust-lang.org/rust/1.82.0/) |
0 commit comments