diff --git a/RELEASES.md b/RELEASES.md index e3597473f62fd..02edb0cf83c98 100644 --- a/RELEASES.md +++ b/RELEASES.md @@ -1,3 +1,118 @@ +Version 1.41.0 (2020-01-30) +=========================== + +Language +-------- + +- [You can now pass type parameters to foreign items when implementing + traits.][65879] E.g. You can now write `impl From for Vec {}`. +- [You can now arbitrarily nest receiver types in the `self` position.][64325] 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.][66847] + Previously identifiers starting with an underscore were not allowed. +- [Visibility modifiers (e.g. `pub`) are now syntactically allowed on trait items and + enum variants.][66183] 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 `'label`s.][66325] +- [Removed support for the `i686-unknown-dragonfly` target.][67255] +- [Added tier 3 support\* for the `riscv64gc-unknown-linux-gnu` target.][66661] +- [You can now pass an arguments file passing the `@path` syntax + to rustc.][66172] Note that the format differs somewhat from what is + found in other tooling; please see [the documentation][argfile-docs] 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.][64882] + +\* Refer to Rust's [platform support page][forge-platform-support] for more +information on Rust's tiered platform support. + +[argfile-docs]: https://doc.rust-lang.org/nightly/rustc/command-line-arguments.html#path-load-command-line-flags-from-a-path + +Libraries +--------- + +- [The `core::panic` module is now stable.][66771] It was already stable + through `std`. +- [`NonZero*` numerics now implement `From` if it's a smaller integer + width.][66277] E.g. `NonZeroU16` now implements `From`. +- [`MaybeUninit` now implements `fmt::Debug`.][65013] + +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/7593] +- [`cargo-install` will now reinstall the package if it detects that it is out + of date.][cargo/7560] +- [Cargo.lock now uses a more git friendly format that should help to reduce + merge conflicts.][cargo/7579] +- [You can now override specific dependencies's build settings][cargo/7591] E.g. + `[profile.dev.overrides.image] opt-level = 2` sets the `image` crate's + optimisation level to `2` for debug builds. You can also use + `[profile..build_overrides]` to override build scripts and + their dependencies. + +Misc +---- + +- [You can now specify `edition` in documentation code blocks to compile the block + for that edition.][66238] 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`.][54733] +- [You can use `#[cfg(doc)]` to compile an item when building documentation.][61351] + +Compatibility Notes +------------------- + +- [As previously announced 1.41.0 will be the last tier 1 release for 32-bit + Apple targets.][apple-32bit-drop] 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. + +[54733]: https://github.com/rust-lang/rust/pull/54733/ +[61351]: https://github.com/rust-lang/rust/pull/61351/ +[67255]: https://github.com/rust-lang/rust/pull/67255/ +[66661]: https://github.com/rust-lang/rust/pull/66661/ +[66771]: https://github.com/rust-lang/rust/pull/66771/ +[66847]: https://github.com/rust-lang/rust/pull/66847/ +[66238]: https://github.com/rust-lang/rust/pull/66238/ +[66277]: https://github.com/rust-lang/rust/pull/66277/ +[66325]: https://github.com/rust-lang/rust/pull/66325/ +[66172]: https://github.com/rust-lang/rust/pull/66172/ +[66183]: https://github.com/rust-lang/rust/pull/66183/ +[65879]: https://github.com/rust-lang/rust/pull/65879/ +[65013]: https://github.com/rust-lang/rust/pull/65013/ +[64882]: https://github.com/rust-lang/rust/pull/64882/ +[64325]: https://github.com/rust-lang/rust/pull/64325/ +[cargo/7560]: https://github.com/rust-lang/cargo/pull/7560/ +[cargo/7579]: https://github.com/rust-lang/cargo/pull/7579/ +[cargo/7591]: https://github.com/rust-lang/cargo/pull/7591/ +[cargo/7593]: https://github.com/rust-lang/cargo/pull/7593/ +[`Result::map_or_else`]: https://doc.rust-lang.org/std/result/enum.Result.html#method.map_or_else +[`Result::map_or`]: https://doc.rust-lang.org/std/result/enum.Result.html#method.map_or +[`std::rc::Weak::weak_count`]: https://doc.rust-lang.org/std/rc/struct.Weak.html#method.weak_count +[`std::rc::Weak::strong_count`]: https://doc.rust-lang.org/std/rc/struct.Weak.html#method.strong_count +[`std::sync::Weak::weak_count`]: https://doc.rust-lang.org/std/sync/struct.Weak.html#method.weak_count +[`std::sync::Weak::strong_count`]: https://doc.rust-lang.org/std/sync/struct.Weak.html#method.strong_count +[apple-32bit-drop]: https://blog.rust-lang.org/2020/01/03/reducing-support-for-32-bit-apple-targets.html + Version 1.40.0 (2019-12-19) =========================== diff --git a/src/librustc_ast_lowering/pat.rs b/src/librustc_ast_lowering/pat.rs index 6cf640a0e98a2..4c3c4ddac78ee 100644 --- a/src/librustc_ast_lowering/pat.rs +++ b/src/librustc_ast_lowering/pat.rs @@ -129,7 +129,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { let mut prev_rest_span = None; let mut iter = pats.iter(); - // Lower all the patterns until the first occurence of a sub-slice pattern. + // Lower all the patterns until the first occurrence of a sub-slice pattern. for pat in iter.by_ref() { match pat.kind { // Found a sub-slice pattern `..`. Record, lower it to `_`, and stop here. diff --git a/src/librustc_data_structures/lib.rs b/src/librustc_data_structures/lib.rs index 6db2910bca496..aaac7fb4460cd 100644 --- a/src/librustc_data_structures/lib.rs +++ b/src/librustc_data_structures/lib.rs @@ -23,6 +23,7 @@ #![feature(integer_atomics)] #![feature(test)] #![feature(associated_type_bounds)] +#![feature(thread_id_value)] #![cfg_attr(unix, feature(libc))] #![allow(rustc::default_hash_types)] diff --git a/src/librustc_data_structures/profiling.rs b/src/librustc_data_structures/profiling.rs index 44cef727f034b..90f74328a1d51 100644 --- a/src/librustc_data_structures/profiling.rs +++ b/src/librustc_data_structures/profiling.rs @@ -88,7 +88,6 @@ use std::fs; use std::path::Path; use std::process; use std::sync::Arc; -use std::thread::ThreadId; use std::time::{Duration, Instant}; use std::u32; @@ -129,17 +128,13 @@ bitflags::bitflags! { Self::QUERY_PROVIDERS.bits | Self::QUERY_BLOCKED.bits | Self::INCR_CACHE_LOADS.bits; - - // empty() and none() aren't const-fns unfortunately - const NONE = 0; - const ALL = !Self::NONE.bits; } } // keep this in sync with the `-Z self-profile-events` help message in librustc_session/options.rs const EVENT_FILTERS_BY_NAME: &[(&str, EventFilter)] = &[ - ("none", EventFilter::NONE), - ("all", EventFilter::ALL), + ("none", EventFilter::empty()), + ("all", EventFilter::all()), ("default", EventFilter::DEFAULT), ("generic-activity", EventFilter::GENERIC_ACTIVITIES), ("query-provider", EventFilter::QUERY_PROVIDERS), @@ -149,10 +144,6 @@ const EVENT_FILTERS_BY_NAME: &[(&str, EventFilter)] = &[ ("query-keys", EventFilter::QUERY_KEYS), ]; -fn thread_id_to_u32(tid: ThreadId) -> u32 { - unsafe { std::mem::transmute::(tid) as u32 } -} - /// Something that uniquely identifies a query invocation. pub struct QueryInvocationId(pub u32); @@ -185,7 +176,7 @@ impl SelfProfilerRef { // If there is no SelfProfiler then the filter mask is set to NONE, // ensuring that nothing ever tries to actually access it. let event_filter_mask = - profiler.as_ref().map(|p| p.event_filter_mask).unwrap_or(EventFilter::NONE); + profiler.as_ref().map(|p| p.event_filter_mask).unwrap_or(EventFilter::empty()); SelfProfilerRef { profiler, @@ -318,7 +309,7 @@ impl SelfProfilerRef { ) { drop(self.exec(event_filter, |profiler| { let event_id = StringId::new_virtual(query_invocation_id.0); - let thread_id = thread_id_to_u32(std::thread::current().id()); + let thread_id = std::thread::current().id().as_u64() as u32; profiler.profiler.record_instant_event( event_kind(profiler), @@ -477,7 +468,7 @@ impl<'a> TimingGuard<'a> { event_kind: StringId, event_id: EventId, ) -> TimingGuard<'a> { - let thread_id = thread_id_to_u32(std::thread::current().id()); + let thread_id = std::thread::current().id().as_u64() as u32; let raw_profiler = &profiler.profiler; let timing_guard = raw_profiler.start_recording_interval_event(event_kind, event_id, thread_id); diff --git a/src/librustc_typeck/check/op.rs b/src/librustc_typeck/check/op.rs index 91e1731ac458b..1ab8f05db1266 100644 --- a/src/librustc_typeck/check/op.rs +++ b/src/librustc_typeck/check/op.rs @@ -477,7 +477,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } /// If one of the types is an uncalled function and calling it would yield the other type, - /// suggest calling the function. Returns wether a suggestion was given. + /// suggest calling the function. Returns whether a suggestion was given. fn add_type_neq_err_label( &self, err: &mut rustc_errors::DiagnosticBuilder<'_>, diff --git a/src/libstd/sys/sgx/os.rs b/src/libstd/sys/sgx/os.rs index 6ed7a2f20444e..56fc84b4a3fca 100644 --- a/src/libstd/sys/sgx/os.rs +++ b/src/libstd/sys/sgx/os.rs @@ -19,7 +19,7 @@ pub fn errno() -> i32 { pub fn error_string(errno: i32) -> String { if errno == RESULT_SUCCESS { - "operation succesful".into() + "operation successful".into() } else if ((Error::UserRangeStart as _)..=(Error::UserRangeEnd as _)).contains(&errno) { format!("user-specified error {:08x}", errno) } else { diff --git a/src/test/ui/consts/miri_unleashed/abi-mismatch.rs b/src/test/ui/consts/miri_unleashed/abi-mismatch.rs new file mode 100644 index 0000000000000..d8e63b0bfb24e --- /dev/null +++ b/src/test/ui/consts/miri_unleashed/abi-mismatch.rs @@ -0,0 +1,16 @@ +// Checks that we report ABI mismatches for "const extern fn" +// compile-flags: -Z unleash-the-miri-inside-of-you + +#![feature(const_extern_fn)] + +const extern "C" fn c_fn() {} + +const fn call_rust_fn(my_fn: extern "Rust" fn()) { + my_fn(); //~ ERROR any use of this value will cause an error + //~^ WARN skipping const checks +} + +const VAL: () = call_rust_fn(unsafe { std::mem::transmute(c_fn as extern "C" fn()) }); +//~^ WARN skipping const checks + +fn main() {} diff --git a/src/test/ui/consts/miri_unleashed/abi-mismatch.stderr b/src/test/ui/consts/miri_unleashed/abi-mismatch.stderr new file mode 100644 index 0000000000000..da00c49963eec --- /dev/null +++ b/src/test/ui/consts/miri_unleashed/abi-mismatch.stderr @@ -0,0 +1,28 @@ +warning: skipping const checks + --> $DIR/abi-mismatch.rs:9:5 + | +LL | my_fn(); + | ^^^^^^^ + +warning: skipping const checks + --> $DIR/abi-mismatch.rs:13:39 + | +LL | const VAL: () = call_rust_fn(unsafe { std::mem::transmute(c_fn as extern "C" fn()) }); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: any use of this value will cause an error + --> $DIR/abi-mismatch.rs:9:5 + | +LL | my_fn(); + | ^^^^^^^ + | | + | tried to call a function with ABI C using caller ABI Rust + | inside call to `call_rust_fn` at $DIR/abi-mismatch.rs:13:17 +... +LL | const VAL: () = call_rust_fn(unsafe { std::mem::transmute(c_fn as extern "C" fn()) }); + | -------------------------------------------------------------------------------------- + | + = note: `#[deny(const_err)]` on by default + +error: aborting due to previous error + diff --git a/src/test/ui/issues/issue-67037-pat-tup-scrut-ty-diff-less-fields.rs b/src/test/ui/issues/issue-67037-pat-tup-scrut-ty-diff-less-fields.rs index 44bd645598ae0..a3023ee906de8 100644 --- a/src/test/ui/issues/issue-67037-pat-tup-scrut-ty-diff-less-fields.rs +++ b/src/test/ui/issues/issue-67037-pat-tup-scrut-ty-diff-less-fields.rs @@ -10,7 +10,7 @@ // However, we did not account for the expected type being different than the tuple pattern type. // This caused an issue when the tuple pattern type (`P`) was generic. // Specifically, we tried deriving the 0th field's type using the `substs` of the expected type. -// When attempting to substitute `T`, there was no such substitution, so "out of range" occured. +// When attempting to substitute `T`, there was no such substitution, so "out of range" occurred. struct U {} // 0 type parameters offered struct P(T); // 1 type parameter wanted diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs index d1ee60d74e7e2..be66c9ab2db67 100644 --- a/src/tools/compiletest/src/runtest.rs +++ b/src/tools/compiletest/src/runtest.rs @@ -2949,7 +2949,7 @@ impl<'test> TestCx<'test> { }; if run_output_errors > 0 { self.fatal_proc_rec( - &format!("{} errors occured comparing run output.", run_output_errors), + &format!("{} errors occurred comparing run output.", run_output_errors), &proc_res, ); }