diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 36362635b15..fe67a14c0fe 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -263,6 +263,7 @@ jobs: env: IMAGE: x86_64-gnu RUST_CI_OVERRIDE_RELEASE_CHANNEL: stable + CI_ONLY_WHEN_CHANNEL: nightly os: ubuntu-latest-xl - name: x86_64-gnu-aux os: ubuntu-latest-xl diff --git a/compiler/rustc_error_codes/src/error_codes.rs b/compiler/rustc_error_codes/src/error_codes.rs index 6f65d386f0d..65999ba707c 100644 --- a/compiler/rustc_error_codes/src/error_codes.rs +++ b/compiler/rustc_error_codes/src/error_codes.rs @@ -248,6 +248,7 @@ E0493: include_str!("./error_codes/E0493.md"), E0495: include_str!("./error_codes/E0495.md"), E0496: include_str!("./error_codes/E0496.md"), E0497: include_str!("./error_codes/E0497.md"), +E0498: include_str!("./error_codes/E0498.md"), E0499: include_str!("./error_codes/E0499.md"), E0500: include_str!("./error_codes/E0500.md"), E0501: include_str!("./error_codes/E0501.md"), @@ -604,7 +605,6 @@ E0783: include_str!("./error_codes/E0783.md"), // E0488, // lifetime of variable does not enclose its declaration // E0489, // type/lifetime parameter not in scope here E0490, // a value of type `..` is borrowed for too long - E0498, // malformed plugin attribute E0514, // metadata version mismatch E0519, // local crate and dependency have same (crate-name, disambiguator) // two dependencies have same (crate-name, disambiguator) but different SVH diff --git a/compiler/rustc_error_codes/src/error_codes/E0498.md b/compiler/rustc_error_codes/src/error_codes/E0498.md new file mode 100644 index 00000000000..c9ea4a7947f --- /dev/null +++ b/compiler/rustc_error_codes/src/error_codes/E0498.md @@ -0,0 +1,22 @@ +The `plugin` attribute was malformed. + +Erroneous code example: + +```compile_fail,E0498 +#![feature(plugin)] +#![plugin(foo(args))] // error: invalid argument +#![plugin(bar="test")] // error: invalid argument +``` + +The `#[plugin]` attribute should take a single argument: the name of the plugin. + +For example, for the plugin `foo`: + +```ignore (requires external plugin crate) +#![feature(plugin)] +#![plugin(foo)] // ok! +``` + +See the [`plugin` feature] section of the Unstable book for more details. + +[`plugin` feature]: https://doc.rust-lang.org/nightly/unstable-book/language-features/plugin.html diff --git a/compiler/rustc_error_codes/src/error_codes/E0617.md b/compiler/rustc_error_codes/src/error_codes/E0617.md index 1c5d1f87b91..eed384b4959 100644 --- a/compiler/rustc_error_codes/src/error_codes/E0617.md +++ b/compiler/rustc_error_codes/src/error_codes/E0617.md @@ -3,12 +3,13 @@ Attempted to pass an invalid type of variable into a variadic function. Erroneous code example: ```compile_fail,E0617 +# use std::os::raw::{c_char, c_int}; extern "C" { - fn printf(c: *const i8, ...); + fn printf(format: *const c_char, ...) -> c_int; } unsafe { - printf(::std::ptr::null(), 0f32); + printf("%f\n\0".as_ptr() as _, 0f32); // error: cannot pass an `f32` to variadic function, cast to `c_double` } ``` @@ -21,10 +22,12 @@ to import from `std::os::raw`). In this case, `c_double` has the same size as `f64` so we can use it directly: ```no_run +# use std::os::raw::{c_char, c_int}; # extern "C" { -# fn printf(c: *const i8, ...); +# fn printf(format: *const c_char, ...) -> c_int; # } + unsafe { - printf(::std::ptr::null(), 0f64); // ok! + printf("%f\n\0".as_ptr() as _, 0f64); // ok! } ``` diff --git a/compiler/rustc_mir/src/transform/mod.rs b/compiler/rustc_mir/src/transform/mod.rs index 3fbc81d5426..e58a7d90308 100644 --- a/compiler/rustc_mir/src/transform/mod.rs +++ b/compiler/rustc_mir/src/transform/mod.rs @@ -259,10 +259,12 @@ fn mir_const<'tcx>( } // Unsafety check uses the raw mir, so make sure it is run. - if let Some(param_did) = def.const_param_did { - tcx.ensure().unsafety_check_result_for_const_arg((def.did, param_did)); - } else { - tcx.ensure().unsafety_check_result(def.did); + if !tcx.sess.opts.debugging_opts.thir_unsafeck { + if let Some(param_did) = def.const_param_did { + tcx.ensure().unsafety_check_result_for_const_arg((def.did, param_did)); + } else { + tcx.ensure().unsafety_check_result(def.did); + } } let mut body = tcx.mir_built(def).steal(); diff --git a/library/core/src/future/future.rs b/library/core/src/future/future.rs index 15952c6806f..7cd0ce9d2ef 100644 --- a/library/core/src/future/future.rs +++ b/library/core/src/future/future.rs @@ -111,11 +111,11 @@ impl Future for &mut F { #[stable(feature = "futures_api", since = "1.36.0")] impl

Future for Pin

where - P: Unpin + ops::DerefMut, + P: ops::DerefMut, { type Output = <

::Target as Future>::Output; fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - Pin::get_mut(self).as_mut().poll(cx) + ::poll(self.as_deref_mut(), cx) } } diff --git a/library/core/src/future/ready.rs b/library/core/src/future/ready.rs index b0c7fbb1d7a..cc905d288f9 100644 --- a/library/core/src/future/ready.rs +++ b/library/core/src/future/ready.rs @@ -20,7 +20,7 @@ impl Future for Ready { #[inline] fn poll(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll { - Poll::Ready(self.0.take().expect("Ready polled after completion")) + Poll::Ready(self.0.take().expect("`Ready` polled after completion")) } } diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs index 839be5a143f..f7d48a91396 100644 --- a/library/core/src/lib.rs +++ b/library/core/src/lib.rs @@ -128,6 +128,7 @@ #![feature(exhaustive_patterns)] #![feature(no_core)] #![feature(auto_traits)] +#![feature(pin_deref_mut)] #![feature(prelude_import)] #![feature(ptr_metadata)] #![feature(repr_simd, platform_intrinsics)] diff --git a/library/core/src/pin.rs b/library/core/src/pin.rs index 3d888299485..6b1a12ed18c 100644 --- a/library/core/src/pin.rs +++ b/library/core/src/pin.rs @@ -802,6 +802,44 @@ impl Pin<&'static T> { } } +impl<'a, P: DerefMut> Pin<&'a mut Pin

> { + /// Gets a pinned mutable reference from this nested pinned pointer. + /// + /// This is a generic method to go from `Pin<&mut Pin>>` to `Pin<&mut T>`. It is + /// safe because the existence of a `Pin>` ensures that the pointee, `T`, cannot + /// move in the future, and this method does not enable the pointee to move. "Malicious" + /// implementations of `P::DerefMut` are likewise ruled out by the contract of + /// `Pin::new_unchecked`. + #[unstable(feature = "pin_deref_mut", issue = "86918")] + #[inline(always)] + pub fn as_deref_mut(self) -> Pin<&'a mut P::Target> { + // SAFETY: What we're asserting here is that going from + // + // Pin<&mut Pin

> + // + // to + // + // Pin<&mut P::Target> + // + // is safe. + // + // We need to ensure that two things hold for that to be the case: + // + // 1) Once we give out a `Pin<&mut P::Target>`, an `&mut P::Target` will not be given out. + // 2) By giving out a `Pin<&mut P::Target>`, we do not risk of violating `Pin<&mut Pin

>` + // + // The existence of `Pin

` is sufficient to guarantee #1: since we already have a + // `Pin

`, it must already uphold the pinning guarantees, which must mean that + // `Pin<&mut P::Target>` does as well, since `Pin::as_mut` is safe. We do not have to rely + // on the fact that P is _also_ pinned. + // + // For #2, we need to ensure that code given a `Pin<&mut P::Target>` cannot cause the + // `Pin

` to move? That is not possible, since `Pin<&mut P::Target>` no longer retains + // any access to the `P` itself, much less the `Pin

`. + unsafe { self.get_unchecked_mut() }.as_mut() + } +} + impl Pin<&'static mut T> { /// Get a pinned mutable reference from a static mutable reference. /// diff --git a/library/core/src/task/mod.rs b/library/core/src/task/mod.rs index 3d6f4f5971a..5f077f77bbc 100644 --- a/library/core/src/task/mod.rs +++ b/library/core/src/task/mod.rs @@ -11,5 +11,5 @@ mod wake; pub use self::wake::{Context, RawWaker, RawWakerVTable, Waker}; mod ready; -#[unstable(feature = "ready_macro", issue = "70922")] +#[stable(feature = "ready_macro", since = "1.56.0")] pub use ready::ready; diff --git a/library/core/src/task/ready.rs b/library/core/src/task/ready.rs index cbf69900015..2834ca5fe22 100644 --- a/library/core/src/task/ready.rs +++ b/library/core/src/task/ready.rs @@ -8,8 +8,6 @@ /// # Examples /// /// ``` -/// #![feature(ready_macro)] -/// /// use std::task::{ready, Context, Poll}; /// use std::future::{self, Future}; /// use std::pin::Pin; @@ -29,8 +27,6 @@ /// The `ready!` call expands to: /// /// ``` -/// # #![feature(ready_macro)] -/// # /// # use std::task::{Context, Poll}; /// # use std::future::{self, Future}; /// # use std::pin::Pin; @@ -49,7 +45,7 @@ /// # Poll::Ready(()) /// # } /// ``` -#[unstable(feature = "ready_macro", issue = "70922")] +#[stable(feature = "ready_macro", since = "1.56.0")] #[rustc_macro_transparency = "semitransparent"] pub macro ready($e:expr) { match $e { diff --git a/library/std/src/fs.rs b/library/std/src/fs.rs index bbe1ab40537..f72f88bb05c 100644 --- a/library/std/src/fs.rs +++ b/library/std/src/fs.rs @@ -1912,6 +1912,7 @@ pub fn canonicalize>(path: P) -> io::Result { /// Ok(()) /// } /// ``` +#[doc(alias = "mkdir")] #[stable(feature = "rust1", since = "1.0.0")] pub fn create_dir>(path: P) -> io::Result<()> { DirBuilder::new().create(path.as_ref()) @@ -1991,6 +1992,7 @@ pub fn create_dir_all>(path: P) -> io::Result<()> { /// Ok(()) /// } /// ``` +#[doc(alias = "rmdir")] #[stable(feature = "rust1", since = "1.0.0")] pub fn remove_dir>(path: P) -> io::Result<()> { fs_imp::rmdir(path.as_ref()) diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs index f0e628c3d83..9cbaa06562a 100644 --- a/library/std/src/lib.rs +++ b/library/std/src/lib.rs @@ -304,7 +304,6 @@ #![feature(pin_static_ref)] #![feature(prelude_import)] #![feature(ptr_internals)] -#![feature(ready_macro)] #![feature(rustc_attrs)] #![feature(rustc_private)] #![feature(shrink_to)] diff --git a/src/ci/github-actions/ci.yml b/src/ci/github-actions/ci.yml index e704071e401..128897e580b 100644 --- a/src/ci/github-actions/ci.yml +++ b/src/ci/github-actions/ci.yml @@ -416,6 +416,10 @@ jobs: env: IMAGE: x86_64-gnu RUST_CI_OVERRIDE_RELEASE_CHANNEL: stable + # Only run this job on the nightly channel. Running this on beta + # could cause failures when `dev: 1` in `stage0.txt`, and running + # this on stable is useless. + CI_ONLY_WHEN_CHANNEL: nightly <<: *job-linux-xl - name: x86_64-gnu-aux diff --git a/src/ci/scripts/should-skip-this.sh b/src/ci/scripts/should-skip-this.sh index fa738fe70c8..bb48fcb5a21 100755 --- a/src/ci/scripts/should-skip-this.sh +++ b/src/ci/scripts/should-skip-this.sh @@ -8,31 +8,43 @@ IFS=$'\n\t' source "$(cd "$(dirname "$0")" && pwd)/../shared.sh" -if [[ -z "${CI_ONLY_WHEN_SUBMODULES_CHANGED+x}" ]]; then - echo "Executing the job since there is no skip rule in effect" - exit 0 +if [[ -n "${CI_ONLY_WHEN_SUBMODULES_CHANGED-}" ]]; then + git fetch "https://github.com/$GITHUB_REPOSITORY" "$GITHUB_BASE_REF" + BASE_COMMIT="$(git merge-base FETCH_HEAD HEAD)" + + echo "Searching for toolstate changes between $BASE_COMMIT and $(git rev-parse HEAD)" + + if git diff "$BASE_COMMIT" | grep --quiet "^index .* 160000"; then + # Submodules pseudo-files inside git have the 160000 permissions, so when + # those files are present in the diff a submodule was updated. + echo "Submodules were updated" + elif ! git diff --quiet "$BASE_COMMIT" -- src/tools/clippy src/tools/rustfmt; then + # There is not an easy blanket search for subtrees. For now, manually list + # the subtrees. + echo "Clippy or rustfmt subtrees were updated" + elif ! (git diff --quiet "$BASE_COMMIT" -- \ + src/test/rustdoc-gui \ + src/librustdoc \ + src/tools/rustdoc-gui); then + # There was a change in either rustdoc or in its GUI tests. + echo "Rustdoc was updated" + else + echo "Not executing this job since no submodules nor subtrees were updated" + ciCommandSetEnv SKIP_JOB 1 + exit 0 + fi fi -git fetch "https://github.com/$GITHUB_REPOSITORY" "$GITHUB_BASE_REF" -BASE_COMMIT="$(git merge-base FETCH_HEAD HEAD)" - -echo "Searching for toolstate changes between $BASE_COMMIT and $(git rev-parse HEAD)" - -if git diff "$BASE_COMMIT" | grep --quiet "^index .* 160000"; then - # Submodules pseudo-files inside git have the 160000 permissions, so when - # those files are present in the diff a submodule was updated. - echo "Executing the job since submodules are updated" -elif ! git diff --quiet "$BASE_COMMIT" -- src/tools/clippy src/tools/rustfmt; then - # There is not an easy blanket search for subtrees. For now, manually list - # the subtrees. - echo "Executing the job since clippy or rustfmt subtree was updated" -elif ! (git diff --quiet "$BASE_COMMIT" -- \ - src/test/rustdoc-gui \ - src/librustdoc \ - src/tools/rustdoc-gui); then - # There was a change in either rustdoc or in its GUI tests. - echo "Executing the job since rustdoc was updated" -else - echo "Not executing this job since no submodules nor subtrees were updated" - ciCommandSetEnv SKIP_JOB 1 +if [[ -n "${CI_ONLY_WHEN_CHANNEL-}" ]]; then + if [[ "${CI_ONLY_WHEN_CHANNEL}" = "$(cat src/ci/channel)" ]]; then + echo "The channel is the expected one" + else + echo "Not executing this job as the channel is not the expected one" + ciCommandSetEnv SKIP_JOB 1 + exit 0 + fi fi + + +echo "Executing the job since there is no skip rule preventing the execution" +exit 0 diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 27c2f6cc87e..fd79292477c 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1730,9 +1730,13 @@ impl Clean for hir::VariantData<'_> { fn clean(&self, cx: &mut DocContext<'_>) -> Variant { match self { hir::VariantData::Struct(..) => Variant::Struct(self.clean(cx)), - hir::VariantData::Tuple(..) => { - Variant::Tuple(self.fields().iter().map(|x| x.ty.clean(cx)).collect()) - } + // Important note here: `Variant::Tuple` is used on tuple structs which are not in an + // enum (so where converting from `ty::VariantDef`). In case we are in an enum, the kind + // is provided by the `Variant` wrapper directly, and since we need the fields' name + // (even for a tuple struct variant!), it's simpler to just store it as a + // `Variant::Struct` instead of a `Variant::Tuple` (otherwise it would force us to make + // a lot of changes when rendering them to generate the name as well). + hir::VariantData::Tuple(..) => Variant::Struct(self.clean(cx)), hir::VariantData::Unit(..) => Variant::CLike, } } diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs index 2b7f7aa3691..c05ea81ac1f 100644 --- a/src/librustdoc/html/render/mod.rs +++ b/src/librustdoc/html/render/mod.rs @@ -2007,6 +2007,9 @@ fn sidebar_struct(cx: &Context<'_>, buf: &mut Buffer, it: &clean::Item, s: &clea } sidebar.push_str(""); + } else if let CtorKind::Fn = s.struct_type { + sidebar + .push_str("

Tuple Fields

"); } } diff --git a/src/librustdoc/html/render/print_item.rs b/src/librustdoc/html/render/print_item.rs index 83ad4f7097b..5c30d8bbd17 100644 --- a/src/librustdoc/html/render/print_item.rs +++ b/src/librustdoc/html/render/print_item.rs @@ -1037,8 +1037,9 @@ fn item_enum(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, e: &clean::Enum write!(w, "
", id = variant_id); write!( w, - "

Fields of {name}

", - name = variant.name.as_ref().unwrap() + "

{extra}Fields of {name}

", + extra = if s.struct_type == CtorKind::Fn { "Tuple " } else { "" }, + name = variant.name.as_ref().unwrap(), ); for field in &s.fields { use crate::clean::StructFieldItem; @@ -1176,21 +1177,21 @@ fn item_struct(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, s: &clean::St _ => None, }) .peekable(); - if let CtorKind::Fictive = s.struct_type { + if let CtorKind::Fictive | CtorKind::Fn = s.struct_type { if fields.peek().is_some() { write!( w, "

\ - Fields{}

", + {}{}\ + ", + if let CtorKind::Fictive = s.struct_type { "Fields" } else { "Tuple Fields" }, document_non_exhaustive_header(it) ); document_non_exhaustive(w, it); - for (field, ty) in fields { - let id = cx.derive_id(format!( - "{}.{}", - ItemType::StructField, - field.name.as_ref().unwrap() - )); + for (index, (field, ty)) in fields.enumerate() { + let field_name = + field.name.map_or_else(|| index.to_string(), |sym| (*sym.as_str()).to_string()); + let id = cx.derive_id(format!("{}.{}", ItemType::StructField, field_name)); write!( w, "\ @@ -1199,7 +1200,7 @@ fn item_struct(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, s: &clean::St ", item_type = ItemType::StructField, id = id, - name = field.name.as_ref().unwrap(), + name = field_name, ty = ty.print(cx) ); document(w, cx, field, Some(it)); @@ -1507,7 +1508,10 @@ fn render_struct( if let Some(g) = g { write!(w, "{}", print_where_clause(g, cx, 0, false),) } - w.write_str(";"); + // We only want a ";" when we are displaying a tuple struct, not a variant tuple struct. + if structhead { + w.write_str(";"); + } } CtorKind::Const => { // Needed for PhantomData. diff --git a/src/test/rustdoc-ui/coverage/enums.stdout b/src/test/rustdoc-ui/coverage/enums.stdout index 64c012c1f66..414d60c86d3 100644 --- a/src/test/rustdoc-ui/coverage/enums.stdout +++ b/src/test/rustdoc-ui/coverage/enums.stdout @@ -1,7 +1,7 @@ +-------------------------------------+------------+------------+------------+------------+ | File | Documented | Percentage | Examples | Percentage | +-------------------------------------+------------+------------+------------+------------+ -| ...est/rustdoc-ui/coverage/enums.rs | 6 | 75.0% | 0 | 0.0% | +| ...est/rustdoc-ui/coverage/enums.rs | 6 | 66.7% | 0 | 0.0% | +-------------------------------------+------------+------------+------------+------------+ -| Total | 6 | 75.0% | 0 | 0.0% | +| Total | 6 | 66.7% | 0 | 0.0% | +-------------------------------------+------------+------------+------------+------------+ diff --git a/src/test/rustdoc/toggle-item-contents.rs b/src/test/rustdoc/toggle-item-contents.rs index 8d2046591d0..ae871e79d7f 100644 --- a/src/test/rustdoc/toggle-item-contents.rs +++ b/src/test/rustdoc/toggle-item-contents.rs @@ -81,8 +81,8 @@ pub enum EnumStructVariant { } // @has 'toggle_item_contents/enum.LargeEnum.html' -// @count - '//details[@class="rustdoc-toggle type-contents-toggle"]' 1 -// @has - '//details[@class="rustdoc-toggle type-contents-toggle"]' 'Show 13 variants' +// @count - '//*[@class="rust enum"]//details[@class="rustdoc-toggle type-contents-toggle"]' 1 +// @has - '//*[@class="rust enum"]//details[@class="rustdoc-toggle type-contents-toggle"]' 'Show 13 variants' pub enum LargeEnum { A, B, C, D, E, F(u8), G, H, I, J, K, L, M } diff --git a/src/test/rustdoc/tuple-struct-fields-doc.rs b/src/test/rustdoc/tuple-struct-fields-doc.rs new file mode 100644 index 00000000000..f3d8e39ea2d --- /dev/null +++ b/src/test/rustdoc/tuple-struct-fields-doc.rs @@ -0,0 +1,36 @@ +#![crate_name = "foo"] + +// @has foo/struct.Foo.html +// @has - '//h2[@id="fields"]' 'Tuple Fields' +// @has - '//h3[@class="sidebar-title"]/a[@href="#fields"]' 'Tuple Fields' +// @has - '//*[@id="structfield.0"]' '0: u32' +// @has - '//*[@id="main"]/div[@class="docblock"]' 'hello' +// @!has - '//*[@id="structfield.1"]' +// @has - '//*[@id="structfield.2"]' '2: char' +// @has - '//*[@id="structfield.3"]' '3: i8' +// @has - '//*[@id="main"]/div[@class="docblock"]' 'not hello' +pub struct Foo( + /// hello + pub u32, + char, + pub char, + /// not hello + pub i8, +); + +// @has foo/enum.Bar.html +// @has - '//pre[@class="rust enum"]' 'BarVariant(String),' +// @matches - '//*[@id="variant.BarVariant.fields"]/h3' '^Tuple Fields of BarVariant$' +// @has - '//*[@id="variant.BarVariant.field.0"]' '0: String' +// @has - '//*[@id="variant.BarVariant.fields"]//*[@class="docblock"]' 'Hello docs' +// @matches - '//*[@id="variant.FooVariant.fields"]/h3' '^Fields of FooVariant$' +pub enum Bar { + BarVariant( + /// Hello docs + String + ), + FooVariant { + /// hello + x: u32, + }, +} diff --git a/src/test/ui-fulldeps/plugin-args.stderr b/src/test/ui-fulldeps/plugin-args.stderr index 2e255f185e2..177f33005c8 100644 --- a/src/test/ui-fulldeps/plugin-args.stderr +++ b/src/test/ui-fulldeps/plugin-args.stderr @@ -14,3 +14,4 @@ LL | #![plugin(empty_plugin(args))] error: aborting due to previous error; 1 warning emitted +For more information about this error, try `rustc --explain E0498`. diff --git a/src/test/ui/bastion-of-the-turbofish.rs b/src/test/ui/bastion-of-the-turbofish.rs index 233ddbbe117..e12857008a5 100644 --- a/src/test/ui/bastion-of-the-turbofish.rs +++ b/src/test/ui/bastion-of-the-turbofish.rs @@ -20,13 +20,17 @@ // in permitting generic arguments to be provided without the consent of the // Great Turbofish. Should you be so naïve as to try to revolt against its // mighty clutches, here shall its wrath be indomitably displayed. This -// program must pass for all eternity, fundamentally at odds with an impetuous -// rebellion against the Turbofish. +// program must pass for all eternity: forever watched by the guardian angel +// which gave this beast its name, and stands fundamentally at odds with the +// impetuous rebellion against the Turbofish. // // My heart aches in sorrow, for I know I am defeated. Let this be a warning -// to all those who come after. Here stands the bastion of the Turbofish. +// to all those who come after: for they too must overcome the impassible +// hurdle of defeating the great beast, championed by a resolute winged +// guardian. // -// RIP Anna Harren, Guardian Angel of the Hallowed Turbofish. <3 +// Here stands the Bastion of the Turbofish, a memorial to Anna Harren, +// Guardian Angel of these Hallowed Grounds. <3 // See https://github.com/rust-lang/rust/pull/53562 // and https://github.com/rust-lang/rfcs/pull/2527 @@ -34,6 +38,6 @@ // for context. fn main() { - let (oh, woe, is, me) = ("the", "Turbofish", "remains", "undefeated"); - let _: (bool, bool) = (oh(me)); + let (the, guardian, stands, resolute) = ("the", "Turbofish", "remains", "undefeated"); + let _: (bool, bool) = (the(resolute)); } diff --git a/src/test/ui/malformed/malformed-plugin-3.stderr b/src/test/ui/malformed/malformed-plugin-3.stderr index 11abdb16e0b..64cb429ea74 100644 --- a/src/test/ui/malformed/malformed-plugin-3.stderr +++ b/src/test/ui/malformed/malformed-plugin-3.stderr @@ -14,3 +14,4 @@ LL | #![plugin(foo="bleh")] error: aborting due to previous error; 1 warning emitted +For more information about this error, try `rustc --explain E0498`.