fmt::Debug for F {
/// `addr_of!(expr)` is equivalent to `&raw const expr`. The macro is *soft-deprecated*;
/// use `&raw const` instead.
///
+/// It is still an open question under which conditions writing through an `addr_of!`-created
+/// pointer is permitted. If the place `expr` evaluates to is based on a raw pointer, then the
+/// result of `addr_of!` inherits all permissions from that raw pointer. However, if the place is
+/// based on a reference, local variable, or `static`, then until all details are decided, the same
+/// rules as for shared references apply: it is UB to write through a pointer created with this
+/// operation, except for bytes located inside an `UnsafeCell`. Use `&raw mut` (or [`addr_of_mut`])
+/// to create a raw pointer that definitely permits mutation.
+///
/// Creating a reference with `&`/`&mut` is only allowed if the pointer is properly aligned
/// and points to initialized data. For cases where those requirements do not hold,
/// raw pointers should be used instead. However, `&expr as *const _` creates a reference
diff --git a/library/core/src/time.rs b/library/core/src/time.rs
index 0390bb59a8984..c19eeedb35426 100644
--- a/library/core/src/time.rs
+++ b/library/core/src/time.rs
@@ -250,7 +250,7 @@ impl Duration {
/// ```
/// use std::time::Duration;
///
- /// let duration = Duration::from_millis(2569);
+ /// let duration = Duration::from_millis(2_569);
///
/// assert_eq!(2, duration.as_secs());
/// assert_eq!(569_000_000, duration.subsec_nanos());
@@ -279,7 +279,7 @@ impl Duration {
/// let duration = Duration::from_micros(1_000_002);
///
/// assert_eq!(1, duration.as_secs());
- /// assert_eq!(2000, duration.subsec_nanos());
+ /// assert_eq!(2_000, duration.subsec_nanos());
/// ```
#[stable(feature = "duration_from_micros", since = "1.27.0")]
#[must_use]
@@ -472,7 +472,7 @@ impl Duration {
/// ```
/// use std::time::Duration;
///
- /// let duration = Duration::new(5, 730023852);
+ /// let duration = Duration::new(5, 730_023_852);
/// assert_eq!(duration.as_secs(), 5);
/// ```
///
@@ -501,7 +501,7 @@ impl Duration {
/// ```
/// use std::time::Duration;
///
- /// let duration = Duration::from_millis(5432);
+ /// let duration = Duration::from_millis(5_432);
/// assert_eq!(duration.as_secs(), 5);
/// assert_eq!(duration.subsec_millis(), 432);
/// ```
@@ -547,7 +547,7 @@ impl Duration {
/// ```
/// use std::time::Duration;
///
- /// let duration = Duration::from_millis(5010);
+ /// let duration = Duration::from_millis(5_010);
/// assert_eq!(duration.as_secs(), 5);
/// assert_eq!(duration.subsec_nanos(), 10_000_000);
/// ```
@@ -566,8 +566,8 @@ impl Duration {
/// ```
/// use std::time::Duration;
///
- /// let duration = Duration::new(5, 730023852);
- /// assert_eq!(duration.as_millis(), 5730);
+ /// let duration = Duration::new(5, 730_023_852);
+ /// assert_eq!(duration.as_millis(), 5_730);
/// ```
#[stable(feature = "duration_as_u128", since = "1.33.0")]
#[rustc_const_stable(feature = "duration_as_u128", since = "1.33.0")]
@@ -584,8 +584,8 @@ impl Duration {
/// ```
/// use std::time::Duration;
///
- /// let duration = Duration::new(5, 730023852);
- /// assert_eq!(duration.as_micros(), 5730023);
+ /// let duration = Duration::new(5, 730_023_852);
+ /// assert_eq!(duration.as_micros(), 5_730_023);
/// ```
#[stable(feature = "duration_as_u128", since = "1.33.0")]
#[rustc_const_stable(feature = "duration_as_u128", since = "1.33.0")]
@@ -602,8 +602,8 @@ impl Duration {
/// ```
/// use std::time::Duration;
///
- /// let duration = Duration::new(5, 730023852);
- /// assert_eq!(duration.as_nanos(), 5730023852);
+ /// let duration = Duration::new(5, 730_023_852);
+ /// assert_eq!(duration.as_nanos(), 5_730_023_852);
/// ```
#[stable(feature = "duration_as_u128", since = "1.33.0")]
#[rustc_const_stable(feature = "duration_as_u128", since = "1.33.0")]
@@ -879,7 +879,7 @@ impl Duration {
/// use std::time::Duration;
///
/// let dur = Duration::new(2, 345_678_000);
- /// assert_eq!(dur.as_millis_f64(), 2345.678);
+ /// assert_eq!(dur.as_millis_f64(), 2_345.678);
/// ```
#[unstable(feature = "duration_millis_float", issue = "122451")]
#[must_use]
@@ -900,7 +900,7 @@ impl Duration {
/// use std::time::Duration;
///
/// let dur = Duration::new(2, 345_678_000);
- /// assert_eq!(dur.as_millis_f32(), 2345.678);
+ /// assert_eq!(dur.as_millis_f32(), 2_345.678);
/// ```
#[unstable(feature = "duration_millis_float", issue = "122451")]
#[must_use]
@@ -1017,7 +1017,7 @@ impl Duration {
///
/// let dur = Duration::new(2, 700_000_000);
/// assert_eq!(dur.mul_f32(3.14), Duration::new(8, 478_000_641));
- /// assert_eq!(dur.mul_f32(3.14e5), Duration::new(847800, 0));
+ /// assert_eq!(dur.mul_f32(3.14e5), Duration::new(847_800, 0));
/// ```
#[stable(feature = "duration_float", since = "1.38.0")]
#[must_use = "this returns the result of the operation, \
diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index eef548033f1c6..71e217bbbfc42 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -931,7 +931,12 @@ impl Step for Rustc {
// NOTE: the ABI of the beta compiler is different from the ABI of the downloaded compiler,
// so its artifacts can't be reused.
if builder.download_rustc() && compiler.stage != 0 {
- builder.ensure(Sysroot { compiler, force_recompile: false });
+ let sysroot = builder.ensure(Sysroot { compiler, force_recompile: false });
+ cp_rustc_component_to_ci_sysroot(
+ builder,
+ &sysroot,
+ builder.config.ci_rustc_dev_contents(),
+ );
return compiler.stage;
}
diff --git a/src/bootstrap/src/core/build_steps/doc.rs b/src/bootstrap/src/core/build_steps/doc.rs
index ffb617c642baf..ac68bbf805092 100644
--- a/src/bootstrap/src/core/build_steps/doc.rs
+++ b/src/bootstrap/src/core/build_steps/doc.rs
@@ -1186,6 +1186,9 @@ impl Step for RustcBook {
cmd.arg("--rustc");
cmd.arg(&rustc);
cmd.arg("--rustc-target").arg(self.target.rustc_target_arg());
+ if let Some(target_linker) = builder.linker(self.target) {
+ cmd.arg("--rustc-linker").arg(target_linker);
+ }
if builder.is_verbose() {
cmd.arg("--verbose");
}
diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 84a6b26a491ed..0858edc690b71 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -3526,11 +3526,13 @@ impl Step for TestFloatParse {
fn run(self, builder: &Builder<'_>) {
let bootstrap_host = builder.config.build;
- let compiler = builder.compiler(0, bootstrap_host);
+ let compiler = builder.compiler(builder.top_stage, bootstrap_host);
let path = self.path.to_str().unwrap();
let crate_name = self.path.components().last().unwrap().as_os_str().to_str().unwrap();
- builder.ensure(compile::Std::new(compiler, self.host));
+ if !builder.download_rustc() {
+ builder.ensure(compile::Std::new(compiler, self.host));
+ }
// Run any unit tests in the crate
let cargo_test = tool::prepare_tool_cargo(
diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index 82b640f54234d..c81ec710f2dc2 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -332,14 +332,20 @@ impl Build {
.trim()
.to_string();
- let initial_libdir = initial_target_dir
- .parent()
- .unwrap()
- .parent()
- .unwrap()
- .strip_prefix(&initial_sysroot)
- .unwrap()
- .to_path_buf();
+ // FIXME(Zalathar): Determining this path occasionally fails locally for
+ // unknown reasons, so we print some extra context to help track down why.
+ let find_initial_libdir = || {
+ let initial_libdir =
+ initial_target_dir.parent()?.parent()?.strip_prefix(&initial_sysroot).ok()?;
+ Some(initial_libdir.to_path_buf())
+ };
+ let Some(initial_libdir) = find_initial_libdir() else {
+ panic!(
+ "couldn't determine `initial_libdir` \
+ from target dir {initial_target_dir:?} \
+ and sysroot {initial_sysroot:?}"
+ )
+ };
let version = std::fs::read_to_string(src.join("src").join("version"))
.expect("failed to read src/version");
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index dc34c7844bfdd..095bfe158ff19 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -1794,13 +1794,64 @@ fn render_impl(
let mut default_impl_items = Buffer::empty_from(w);
let impl_ = i.inner_impl();
+ // Impl items are grouped by kinds:
+ //
+ // 1. Constants
+ // 2. Types
+ // 3. Functions
+ //
+ // This order is because you can have associated constants used in associated types (like array
+ // length), and both in associcated functions. So with this order, when reading from top to
+ // bottom, you should see items definitions before they're actually used most of the time.
+ let mut assoc_types = Vec::new();
+ let mut methods = Vec::new();
+
if !impl_.is_negative_trait_impl() {
for trait_item in &impl_.items {
+ match *trait_item.kind {
+ clean::MethodItem(..) | clean::TyMethodItem(_) => methods.push(trait_item),
+ clean::TyAssocTypeItem(..) | clean::AssocTypeItem(..) => {
+ assoc_types.push(trait_item)
+ }
+ clean::TyAssocConstItem(..) | clean::AssocConstItem(_) => {
+ // We render it directly since they're supposed to come first.
+ doc_impl_item(
+ &mut default_impl_items,
+ &mut impl_items,
+ cx,
+ trait_item,
+ if trait_.is_some() { &i.impl_item } else { parent },
+ link,
+ render_mode,
+ false,
+ trait_,
+ rendering_params,
+ );
+ }
+ _ => {}
+ }
+ }
+
+ for assoc_type in assoc_types {
doc_impl_item(
&mut default_impl_items,
&mut impl_items,
cx,
- trait_item,
+ assoc_type,
+ if trait_.is_some() { &i.impl_item } else { parent },
+ link,
+ render_mode,
+ false,
+ trait_,
+ rendering_params,
+ );
+ }
+ for method in methods {
+ doc_impl_item(
+ &mut default_impl_items,
+ &mut impl_items,
+ cx,
+ method,
if trait_.is_some() { &i.impl_item } else { parent },
link,
render_mode,
diff --git a/src/librustdoc/html/render/print_item.rs b/src/librustdoc/html/render/print_item.rs
index a0a72d59d123f..cda5409a460ee 100644
--- a/src/librustdoc/html/render/print_item.rs
+++ b/src/librustdoc/html/render/print_item.rs
@@ -843,55 +843,55 @@ fn item_trait(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, t: &clean:
}
}
- if !required_types.is_empty() {
+ if !required_consts.is_empty() {
write_section_heading(
w,
- "Required Associated Types",
- "required-associated-types",
+ "Required Associated Constants",
+ "required-associated-consts",
None,
"",
);
- for t in required_types {
+ for t in required_consts {
trait_item(w, cx, t, it);
}
w.write_str("
");
}
- if !provided_types.is_empty() {
+ if !provided_consts.is_empty() {
write_section_heading(
w,
- "Provided Associated Types",
- "provided-associated-types",
+ "Provided Associated Constants",
+ "provided-associated-consts",
None,
"",
);
- for t in provided_types {
+ for t in provided_consts {
trait_item(w, cx, t, it);
}
w.write_str("
");
}
- if !required_consts.is_empty() {
+ if !required_types.is_empty() {
write_section_heading(
w,
- "Required Associated Constants",
- "required-associated-consts",
+ "Required Associated Types",
+ "required-associated-types",
None,
"",
);
- for t in required_consts {
+ for t in required_types {
trait_item(w, cx, t, it);
}
w.write_str("
");
}
- if !provided_consts.is_empty() {
+ if !provided_types.is_empty() {
write_section_heading(
w,
- "Provided Associated Constants",
- "provided-associated-consts",
+ "Provided Associated Types",
+ "provided-associated-types",
None,
"",
);
- for t in provided_consts {
+ for t in provided_types {
trait_item(w, cx, t, it);
}
w.write_str("
");
diff --git a/src/librustdoc/html/render/sidebar.rs b/src/librustdoc/html/render/sidebar.rs
index 5b9c93ef74aaa..7adce2aef770d 100644
--- a/src/librustdoc/html/render/sidebar.rs
+++ b/src/librustdoc/html/render/sidebar.rs
@@ -224,10 +224,10 @@ fn sidebar_trait<'a>(
}
let mut blocks: Vec> = [
- ("required-associated-types", "Required Associated Types", req_assoc),
- ("provided-associated-types", "Provided Associated Types", prov_assoc),
("required-associated-consts", "Required Associated Constants", req_assoc_const),
("provided-associated-consts", "Provided Associated Constants", prov_assoc_const),
+ ("required-associated-types", "Required Associated Types", req_assoc),
+ ("provided-associated-types", "Provided Associated Types", prov_assoc),
("required-methods", "Required Methods", req_method),
("provided-methods", "Provided Methods", prov_method),
("foreign-impls", "Implementations on Foreign Types", foreign_impls),
@@ -320,6 +320,7 @@ fn sidebar_assoc_items<'a>(
let cache = cx.cache();
let mut assoc_consts = Vec::new();
+ let mut assoc_types = Vec::new();
let mut methods = Vec::new();
if let Some(v) = cache.impls.get(&did) {
let mut used_links = FxHashSet::default();
@@ -327,22 +328,14 @@ fn sidebar_assoc_items<'a>(
{
let used_links_bor = &mut used_links;
- assoc_consts.extend(
- v.iter()
- .filter(|i| i.inner_impl().trait_.is_none())
- .flat_map(|i| get_associated_constants(i.inner_impl(), used_links_bor)),
- );
+ for impl_ in v.iter().map(|i| i.inner_impl()).filter(|i| i.trait_.is_none()) {
+ assoc_consts.extend(get_associated_constants(impl_, used_links_bor));
+ assoc_types.extend(get_associated_types(impl_, used_links_bor));
+ methods.extend(get_methods(impl_, false, used_links_bor, false, cx.tcx()));
+ }
// We want links' order to be reproducible so we don't use unstable sort.
assoc_consts.sort();
-
- #[rustfmt::skip] // rustfmt makes the pipeline less readable
- methods.extend(
- v.iter()
- .filter(|i| i.inner_impl().trait_.is_none())
- .flat_map(|i| get_methods(i.inner_impl(), false, used_links_bor, false, cx.tcx())),
- );
-
- // We want links' order to be reproducible so we don't use unstable sort.
+ assoc_types.sort();
methods.sort();
}
@@ -379,6 +372,11 @@ fn sidebar_assoc_items<'a>(
"associatedconstant",
assoc_consts,
),
+ LinkBlock::new(
+ Link::new("implementations", "Associated Types"),
+ "associatedtype",
+ assoc_types,
+ ),
LinkBlock::new(Link::new("implementations", "Methods"), "method", methods),
];
blocks.append(&mut deref_methods);
@@ -629,3 +627,19 @@ fn get_associated_constants<'a>(
})
.collect::>()
}
+
+fn get_associated_types<'a>(
+ i: &'a clean::Impl,
+ used_links: &mut FxHashSet,
+) -> Vec> {
+ i.items
+ .iter()
+ .filter_map(|item| match item.name {
+ Some(ref name) if !name.is_empty() && item.is_associated_type() => Some(Link::new(
+ get_next_url(used_links, format!("{typ}.{name}", typ = ItemType::AssocType)),
+ name.as_str(),
+ )),
+ _ => None,
+ })
+ .collect::>()
+}
diff --git a/src/tools/lint-docs/src/lib.rs b/src/tools/lint-docs/src/lib.rs
index 72bb9db7e7414..532a27b22aa6f 100644
--- a/src/tools/lint-docs/src/lib.rs
+++ b/src/tools/lint-docs/src/lib.rs
@@ -56,6 +56,8 @@ pub struct LintExtractor<'a> {
pub rustc_path: &'a Path,
/// The target arch to build the docs for.
pub rustc_target: &'a str,
+ /// The target linker overriding `rustc`'s default
+ pub rustc_linker: Option<&'a str>,
/// Verbose output.
pub verbose: bool,
/// Validate the style and the code example.
@@ -459,6 +461,9 @@ impl<'a> LintExtractor<'a> {
}
cmd.arg("--error-format=json");
cmd.arg("--target").arg(self.rustc_target);
+ if let Some(target_linker) = self.rustc_linker {
+ cmd.arg(format!("-Clinker={target_linker}"));
+ }
if options.contains(&"test") {
cmd.arg("--test");
}
diff --git a/src/tools/lint-docs/src/main.rs b/src/tools/lint-docs/src/main.rs
index 2055fed2b480c..e377283b1a453 100644
--- a/src/tools/lint-docs/src/main.rs
+++ b/src/tools/lint-docs/src/main.rs
@@ -27,6 +27,7 @@ fn doit() -> Result<(), Box> {
let mut out_path = None;
let mut rustc_path = None;
let mut rustc_target = None;
+ let mut rustc_linker = None;
let mut verbose = false;
let mut validate = false;
while let Some(arg) = args.next() {
@@ -55,6 +56,12 @@ fn doit() -> Result<(), Box> {
None => return Err("--rustc-target requires a value".into()),
};
}
+ "--rustc-linker" => {
+ rustc_linker = match args.next() {
+ Some(s) => Some(s),
+ None => return Err("--rustc-linker requires a value".into()),
+ };
+ }
"-v" | "--verbose" => verbose = true,
"--validate" => validate = true,
s => return Err(format!("unexpected argument `{}`", s).into()),
@@ -77,6 +84,7 @@ fn doit() -> Result<(), Box> {
out_path: &out_path.unwrap(),
rustc_path: &rustc_path.unwrap(),
rustc_target: &rustc_target.unwrap(),
+ rustc_linker: rustc_linker.as_deref(),
verbose,
validate,
};
diff --git a/src/tools/rust-analyzer/crates/hir-expand/src/inert_attr_macro.rs b/src/tools/rust-analyzer/crates/hir-expand/src/inert_attr_macro.rs
index ee15b1b5ce9d5..5c25a55362e64 100644
--- a/src/tools/rust-analyzer/crates/hir-expand/src/inert_attr_macro.rs
+++ b/src/tools/rust-analyzer/crates/hir-expand/src/inert_attr_macro.rs
@@ -464,6 +464,9 @@ pub const INERT_ATTRIBUTES: &[BuiltinAttribute] = &[
// Used by the `rustc::potential_query_instability` lint to warn methods which
// might not be stable during incremental compilation.
rustc_attr!(rustc_lint_query_instability, Normal, template!(Word), WarnFollowing, INTERNAL_UNSTABLE),
+ // Used by the `rustc::untracked_query_information` lint to warn methods which
+ // might break incremental compilation.
+ rustc_attr!(rustc_lint_untracked_query_information, Normal, template!(Word), WarnFollowing, INTERNAL_UNSTABLE),
// Used by the `rustc::untranslatable_diagnostic` and `rustc::diagnostic_outside_of_impl` lints
// to assist in changes to diagnostic APIs.
rustc_attr!(rustc_lint_diagnostics, Normal, template!(Word), WarnFollowing, INTERNAL_UNSTABLE),
diff --git a/tests/assembly/s390x-backchain-toggle.rs b/tests/assembly/s390x-backchain-toggle.rs
new file mode 100644
index 0000000000000..8b6d0cf212320
--- /dev/null
+++ b/tests/assembly/s390x-backchain-toggle.rs
@@ -0,0 +1,46 @@
+//@ revisions: enable-backchain disable-backchain
+//@ assembly-output: emit-asm
+//@ compile-flags: -O --crate-type=lib --target=s390x-unknown-linux-gnu
+//@ needs-llvm-components: systemz
+//@[enable-backchain] compile-flags: -Ctarget-feature=+backchain
+//@[disable-backchain] compile-flags: -Ctarget-feature=-backchain
+#![feature(no_core, lang_items)]
+#![no_std]
+#![no_core]
+
+#[lang = "sized"]
+trait Sized {}
+
+extern "C" {
+ fn extern_func();
+}
+
+// CHECK-LABEL: test_backchain
+#[no_mangle]
+extern "C" fn test_backchain() -> i32 {
+ // Here we try to match if backchain register is saved to the parameter area (stored in r15/sp)
+ // And also if a new parameter area (160 bytes) is allocated for the upcoming function call
+ // enable-backchain: lgr [[REG1:.*]], %r15
+ // enable-backchain-NEXT: aghi %r15, -160
+ // enable-backchain: stg [[REG1]], 0(%r15)
+ // disable-backchain: aghi %r15, -160
+ // disable-backchain-NOT: stg %r{{.*}}, 0(%r15)
+ unsafe {
+ extern_func();
+ }
+ // enable-backchain-NEXT: brasl %r{{.*}}, extern_func@PLT
+ // disable-backchain: brasl %r{{.*}}, extern_func@PLT
+
+ // Make sure that the expected return value is written into %r2 (return register):
+ // enable-backchain-NEXT: lghi %r2, 1
+ // disable-backchain: lghi %r2, 0
+ #[cfg(target_feature = "backchain")]
+ {
+ 1
+ }
+ #[cfg(not(target_feature = "backchain"))]
+ {
+ 0
+ }
+ // CHECK: br %r{{.*}}
+}
diff --git a/tests/rustdoc/impl-associated-items-order.rs b/tests/rustdoc/impl-associated-items-order.rs
new file mode 100644
index 0000000000000..759e0f0b40095
--- /dev/null
+++ b/tests/rustdoc/impl-associated-items-order.rs
@@ -0,0 +1,42 @@
+// This test ensures that impl associated items always follow this order:
+//
+// 1. Consts
+// 2. Types
+// 3. Functions
+
+#![feature(inherent_associated_types)]
+#![allow(incomplete_features)]
+#![crate_name = "foo"]
+
+//@ has 'foo/struct.Bar.html'
+pub struct Bar;
+
+impl Bar {
+ //@ has - '//*[@id="implementations-list"]//*[@class="impl-items"]/section[3]/h4' \
+ // 'pub fn foo()'
+ pub fn foo() {}
+ //@ has - '//*[@id="implementations-list"]//*[@class="impl-items"]/section[1]/h4' \
+ // 'pub const X: u8 = 12u8'
+ pub const X: u8 = 12;
+ //@ has - '//*[@id="implementations-list"]//*[@class="impl-items"]/section[2]/h4' \
+ // 'pub type Y = u8'
+ pub type Y = u8;
+}
+
+pub trait Foo {
+ const W: u32;
+ fn yeay();
+ type Z;
+}
+
+impl Foo for Bar {
+ //@ has - '//*[@id="trait-implementations-list"]//*[@class="impl-items"]/section[2]/h4' \
+ // 'type Z = u8'
+ type Z = u8;
+ //@ has - '//*[@id="trait-implementations-list"]//*[@class="impl-items"]/section[1]/h4' \
+ // 'const W: u32 = 12u32'
+ const W: u32 = 12;
+ //@ has - '//*[@id="trait-implementations-list"]//*[@class="impl-items"]/section[3]/h4' \
+ // 'fn yeay()'
+ fn yeay() {}
+}
diff --git a/tests/rustdoc/impl-associated-items-sidebar.rs b/tests/rustdoc/impl-associated-items-sidebar.rs
new file mode 100644
index 0000000000000..d393a577e5009
--- /dev/null
+++ b/tests/rustdoc/impl-associated-items-sidebar.rs
@@ -0,0 +1,42 @@
+// This test ensures that impl/trait associated items are listed in the sidebar.
+
+// ignore-tidy-linelength
+
+#![feature(inherent_associated_types)]
+#![feature(associated_type_defaults)]
+#![allow(incomplete_features)]
+#![crate_name = "foo"]
+
+//@ has 'foo/struct.Bar.html'
+pub struct Bar;
+
+impl Bar {
+ //@ has - '//*[@class="sidebar-elems"]//h3[1]' 'Associated Constants'
+ //@ has - '//*[@class="sidebar-elems"]//ul[@class="block associatedconstant"]/li/a[@href="#associatedconstant.X"]' 'X'
+ pub const X: u8 = 12;
+ //@ has - '//*[@class="sidebar-elems"]//h3[2]' 'Associated Types'
+ //@ has - '//*[@class="sidebar-elems"]//ul[@class="block associatedtype"]/li/a[@href="#associatedtype.Y"]' 'Y'
+ pub type Y = u8;
+}
+
+//@ has 'foo/trait.Foo.html'
+pub trait Foo {
+ //@ has - '//*[@class="sidebar-elems"]//h3[5]' 'Required Methods'
+ //@ has - '//*[@class="sidebar-elems"]//ul[@class="block"][5]/li/a[@href="#tymethod.yeay"]' 'yeay'
+ fn yeay();
+ //@ has - '//*[@class="sidebar-elems"]//h3[6]' 'Provided Methods'
+ //@ has - '//*[@class="sidebar-elems"]//ul[@class="block"][6]/li/a[@href="#method.boo"]' 'boo'
+ fn boo() {}
+ //@ has - '//*[@class="sidebar-elems"]//h3[1]' 'Required Associated Constants'
+ //@ has - '//*[@class="sidebar-elems"]//ul[@class="block"][1]/li/a[@href="#associatedconstant.W"]' 'W'
+ const W: u32;
+ //@ has - '//*[@class="sidebar-elems"]//h3[2]' 'Provided Associated Constants'
+ //@ has - '//*[@class="sidebar-elems"]//ul[@class="block"][2]/li/a[@href="#associatedconstant.U"]' 'U'
+ const U: u32 = 0;
+ //@ has - '//*[@class="sidebar-elems"]//h3[3]' 'Required Associated Types'
+ //@ has - '//*[@class="sidebar-elems"]//ul[@class="block"][3]/li/a[@href="#associatedtype.Z"]' 'Z'
+ type Z;
+ //@ has - '//*[@class="sidebar-elems"]//h3[4]' 'Provided Associated Types'
+ //@ has - '//*[@class="sidebar-elems"]//ul[@class="block"][4]/li/a[@href="#associatedtype.T"]' 'T'
+ type T = u32;
+}
diff --git a/tests/ui-fulldeps/internal-lints/query_completeness.rs b/tests/ui-fulldeps/internal-lints/query_completeness.rs
new file mode 100644
index 0000000000000..50b0fb4c3fc02
--- /dev/null
+++ b/tests/ui-fulldeps/internal-lints/query_completeness.rs
@@ -0,0 +1,16 @@
+//@ compile-flags: -Z unstable-options
+// #[cfg(bootstrap)]: We can stop ignoring next beta bump; afterward this ALWAYS should run.
+//@ ignore-stage1 (requires matching sysroot built with in-tree compiler)
+#![feature(rustc_private)]
+#![deny(rustc::untracked_query_information)]
+
+extern crate rustc_data_structures;
+
+use rustc_data_structures::steal::Steal;
+
+fn use_steal(x: Steal<()>) {
+ let _ = x.is_stolen();
+ //~^ ERROR `is_stolen` accesses information that is not tracked by the query system
+}
+
+fn main() {}
diff --git a/tests/ui-fulldeps/internal-lints/query_completeness.stderr b/tests/ui-fulldeps/internal-lints/query_completeness.stderr
new file mode 100644
index 0000000000000..35bb867f40e8f
--- /dev/null
+++ b/tests/ui-fulldeps/internal-lints/query_completeness.stderr
@@ -0,0 +1,15 @@
+error: `is_stolen` accesses information that is not tracked by the query system
+ --> $DIR/query_completeness.rs:12:15
+ |
+LL | let _ = x.is_stolen();
+ | ^^^^^^^^^
+ |
+ = note: if you believe this case to be fine, allow this lint and add a comment explaining your rationale
+note: the lint level is defined here
+ --> $DIR/query_completeness.rs:5:9
+ |
+LL | #![deny(rustc::untracked_query_information)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/triagebot.toml b/triagebot.toml
index 1afcad7d1315c..f379f8cc7af50 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -914,6 +914,7 @@ cc = ["@kobzol"]
warn_non_default_branch = true
contributing_url = "https://rustc-dev-guide.rust-lang.org/getting-started.html"
users_on_vacation = [
+ "fmease",
"jhpratt",
"joboet",
"jyn514",