Rollup of 11 pull requests

RELEASES.md

@@ -67,6 +67,8 @@ Stabilized APIs
 - [`Atomic<T>::get_mut_slice`](https://doc.rust-lang.org/stable/core/sync/atomic/struct.Atomic.html#method.get_mut_slice)
 - [`Atomic<T>::from_mut_slice`](https://doc.rust-lang.org/stable/core/sync/atomic/struct.Atomic.html#method.from_mut_slice)
 - [`std::range::legacy`](https://doc.rust-lang.org/stable/std/range/legacy/index.html)
+- [`bool::ok_or`](https://doc.rust-lang.org/stable/std/primitive.bool.html#method.ok_or)
+- [`bool::ok_or_else`](https://doc.rust-lang.org/stable/std/primitive.bool.html#method.ok_or_else)
 
 
 <a id="1.98.0-Compatibility-Notes"></a>

compiler/rustc_arena/src/lib.rs

@@ -13,7 +13,7 @@
 #![cfg_attr(bootstrap, feature(never_type))]
 #![cfg_attr(test, feature(test))]
 #![deny(unsafe_op_in_unsafe_fn)]
-#![doc(test(no_crate_inject, attr(deny(warnings), allow(internal_features))))]
+#![doc(test(no_crate_inject, attr(deny(warnings))))]
 #![feature(decl_macro)]
 #![feature(dropck_eyepatch)]
 #![feature(rustc_attrs)]

compiler/rustc_ast/src/lib.rs

@@ -5,7 +5,7 @@
 //! This API is completely unstable and subject to change.
 
 // tidy-alphabetical-start
-#![doc(test(attr(deny(warnings), allow(internal_features))))]
+#![doc(test(attr(deny(warnings))))]
 #![feature(associated_type_defaults)]
 #![feature(deref_patterns)]
 #![feature(iter_order_by)]

compiler/rustc_builtin_macros/src/contracts.rs

@@ -137,6 +137,21 @@ fn expand_contract_clause_tts(
     annotated: TokenStream,
     clause_keyword: rustc_span::Symbol,
 ) -> Result<TokenStream, ErrorGuaranteed> {
+    if annotation.is_empty() {
+        let (name, example) = if clause_keyword == kw::ContractRequires {
+            ("requires", "condition")
+        } else {
+            ("ensures", "|result: &T| condition")
+        };
+        ecx.sess.dcx().span_err(
+            attr_span,
+            format!("`{name}` attribute requires an argument, e.g., `#[{name}({example})]`"),
+        );
+        // Returning `Err` would replace it with a dummy fragment and cause cascading name-resolution errors.
+        // Instead, we return the original token stream so that there is no later noises.
+        return Ok(annotated);
+    }
+
     let feature_span = ecx.with_def_site_ctxt(attr_span);
     expand_contract_clause(ecx, attr_span, annotated, |new_tts| {
         new_tts.push(TokenTree::Token(

compiler/rustc_graphviz/src/lib.rs

@@ -270,7 +270,7 @@
 //! * [DOT language](https://www.graphviz.org/doc/info/lang.html)
 
 // tidy-alphabetical-start
-#![doc(test(attr(allow(unused_variables), deny(warnings), allow(internal_features))))]
+#![doc(test(attr(allow(unused_variables), deny(warnings))))]
 // tidy-alphabetical-end
 
 use std::borrow::Cow;

compiler/rustc_lint_defs/src/builtin.rs

@@ -823,7 +823,7 @@ declare_lint! {
     ///
     /// ### Example
     ///
-    /// ```rust
+    /// ```rust,compile_fail
     /// #![deny(dead_code_pub_in_binary)]
     ///
     /// pub fn unused_pub_fn() {}
@@ -1132,9 +1132,9 @@ declare_lint! {
     ///
     /// ### Example
     ///
-    /// ```rust
+    /// ```rust,compile_fail
     /// #![deny(warnings)]
-    /// fn foo() {}
+    /// struct non_standard_name;
     /// ```
     ///
     /// {{produces}}

compiler/rustc_parse_format/src/lib.rs

@@ -8,7 +8,7 @@
 // We want to be able to build this crate with a stable compiler,
 // so no `#![feature]` attributes should be added.
 #![deny(unstable_features)]
-#![doc(test(attr(deny(warnings), allow(internal_features))))]
+#![doc(test(attr(deny(warnings))))]
 // tidy-alphabetical-end
 
 use std::ops::Range;

compiler/rustc_public/src/lib.rs

@@ -43,7 +43,7 @@
 //! For more information, see <https://github.com/rust-lang/rustc_public>.
 
 #![allow(rustc::usage_of_ty_tykind)]
-#![doc(test(attr(allow(unused_variables), deny(warnings), allow(internal_features))))]
+#![doc(test(attr(allow(unused_variables), deny(warnings))))]
 #![feature(sized_hierarchy)]
 
 use std::fmt::Debug;

compiler/rustc_public_bridge/src/lib.rs

@@ -13,7 +13,7 @@
 
 // tidy-alphabetical-start
 #![allow(rustc::usage_of_ty_tykind)]
-#![doc(test(attr(allow(unused_variables), deny(warnings), allow(internal_features))))]
+#![doc(test(attr(allow(unused_variables), deny(warnings))))]
 #![feature(trait_alias)]
 // tidy-alphabetical-end
 

compiler/rustc_serialize/src/lib.rs

@@ -4,7 +4,7 @@
 #![allow(internal_features)]
 #![allow(rustc::internal)]
 #![cfg_attr(bootstrap, feature(never_type))]
-#![doc(test(attr(allow(unused_variables), deny(warnings), allow(internal_features))))]
+#![doc(test(attr(allow(unused_variables), deny(warnings))))]
 #![feature(core_intrinsics)]
 #![feature(min_specialization)]
 #![feature(nonzero_internals)]

compiler/rustc_session/src/config.rs

@@ -3647,11 +3647,14 @@ pub enum Polonius {
 
 impl Default for Polonius {
     fn default() -> Self {
-        if option_env!("CFG_DEFAULT_POLONIUS_NEXT").is_some() { Self::Next } else { Self::Off }
+        Self::DEFAULT
     }
 }
 
 impl Polonius {
+    pub(crate) const DEFAULT: Self =
+        if option_env!("CFG_DEFAULT_POLONIUS_NEXT").is_some() { Self::Next } else { Self::Off };
+
     /// Returns whether the legacy version of polonius is enabled
     pub fn is_legacy_enabled(&self) -> bool {
         matches!(self, Polonius::Legacy)

compiler/rustc_session/src/options.rs

@@ -510,7 +510,7 @@ macro_rules! options {
                 $( { TARGET_MODIFIER: $tmod_variant:ident } )?
                 $( { MITIGATION: $mitigation_variant:ident } )?
                 ,
-                $desc:literal
+                $desc:expr
                 $(, removed: $removed:ident )?
             ),
         )*
@@ -2350,6 +2350,12 @@ options! {
     // - src/doc/rustc/src/codegen-options/index.md
 }
 
+const POLONIUS_HELP: &str = match Polonius::DEFAULT {
+    Polonius::Off => "enable polonius-based borrow-checker (default: no)",
+    Polonius::Next => "enable polonius-based borrow-checker (default: next)",
+    Polonius::Legacy => panic!("Polonius::Legacy is not a valid default value"),
+};
+
 options! {
     UnstableOptions, UnstableOptionsTargetModifiers, Z_OPTIONS, dbopts, "Z", "unstable",
 
@@ -2750,7 +2756,7 @@ options! {
         `vt-ptr-type-discrimination - incorporate type discrimination in authenticated vtable pointers
         Example: `-Zpointer-authentication=+calls,-init-fini`."),
     polonius: Polonius = (Polonius::default(), parse_polonius, [TRACKED],
-        "enable polonius-based borrow-checker (default: no)"),
+        POLONIUS_HELP),
     pre_link_arg: (/* redirected to pre_link_args */) = ((), parse_string_push, [UNTRACKED],
         "a single extra argument to prepend the linker invocation (can be used several times)"),
     pre_link_args: Vec<String> = (Vec::new(), parse_list, [UNTRACKED],

compiler/rustc_target/src/asm/loongarch.rs

@@ -53,7 +53,7 @@ impl LoongArchInlineAsmRegClass {
             (Self::vreg, _) => {
                 if allow_experimental_reg {
                     types! {
-                        lsx: F16, F32, F64,
+                        lsx: I128, F16, F32, F64,
                             VecI8(16), VecI16(8), VecI32(4), VecI64(2), VecF32(4), VecF64(2);
                     }
                 } else {
@@ -63,7 +63,7 @@ impl LoongArchInlineAsmRegClass {
             (Self::xreg, _) => {
                 if allow_experimental_reg {
                     types! {
-                        lasx: F16, F32, F64,
+                        lasx: I128, F16, F32, F64,
                             VecI8(16), VecI16(8), VecI32(4), VecI64(2), VecF32(4), VecF64(2),
                             VecI8(32), VecI16(16), VecI32(8), VecI64(4), VecF32(8), VecF64(4);
                     }

compiler/rustc_traits/src/normalize_projection_ty.rs

@@ -59,12 +59,6 @@ fn normalize_canonicalized_projection<'tcx>(
                 0,
                 &mut obligations,
             );
-            obligations.extend(const_arg_has_type_obligation(
-                tcx,
-                param_env,
-                normalized_term,
-                goal,
-            ));
             ocx.register_obligations(obligations);
             // #112047: With projections and opaques, we are able to create opaques that
             // are recursive (given some generic parameters of the opaque's type variables).
@@ -147,12 +141,6 @@ fn normalize_canonicalized_inherent_projection<'tcx>(
                 0,
                 &mut obligations,
             );
-            obligations.extend(const_arg_has_type_obligation(
-                tcx,
-                param_env,
-                normalized_term,
-                goal,
-            ));
             ocx.register_obligations(obligations);
 
             Ok(NormalizationResult { normalized_term })

library/std/src/sys/fs/uefi.rs

@@ -360,12 +360,7 @@ impl File {
         let off = match pos {
             SeekFrom::Start(p) => p,
             SeekFrom::End(p) => {
-                // Seeking to position 0xFFFFFFFFFFFFFFFF causes the current position to be set to the end of the file.
-                if p == 0 {
-                    0xFFFFFFFFFFFFFFFF
-                } else {
-                    self.file_attr()?.size().checked_add_signed(p).ok_or(NEG_OFF_ERR)?
-                }
+                self.file_attr()?.size().checked_add_signed(p).ok_or(NEG_OFF_ERR)?
             }
             SeekFrom::Current(p) => self.tell()?.checked_add_signed(p).ok_or(NEG_OFF_ERR)?,
         };

src/bootstrap/src/bin/rustdoc.rs

@@ -65,7 +65,10 @@ fn main() {
     if let Some(crate_name) = parse_value_from_args(&args, "--crate-name") {
         // Add rust logo and set html root for all rustc crates.
         if crate_name.starts_with("rustc_") {
-            cmd.arg("-Ainternal_features")
+            // We use `-Zcrate-attr=allow` instead of `-A` to force rustdoc to forward this flag to
+            // the actual doctests. Otherwise those tests all receive the
+            // `feature(rustdoc_internals)` without receiving the `-A` which leads to errors.
+            cmd.arg("-Zcrate-attr=allow(internal_features)")
                 .arg("-Zcrate-attr=doc(rust_logo)")
                 .arg("-Zcrate-attr=doc(html_root_url = \"https://doc.rust-lang.org/nightly/nightly-rustc/\")");
 

src/bootstrap/src/utils/helpers.rs

@@ -141,11 +141,8 @@ pub fn libdir(target: TargetSelection) -> &'static str {
 /// Adds a list of lookup paths to `cmd`'s dynamic library lookup path.
 /// If the dylib_path_var is already set for this cmd, the old value will be overwritten!
 pub fn add_dylib_path(path: Vec<PathBuf>, cmd: &mut BootstrapCommand) {
-    let mut list = dylib_path();
-    for path in path {
-        list.insert(0, path);
-    }
-    cmd.env(dylib_path_var(), t!(env::join_paths(list)));
+    let paths = path.into_iter().chain(dylib_path());
+    cmd.env(dylib_path_var(), t!(env::join_paths(paths)));
 }
 
 pub struct TimeIt(bool, Instant);

src/doc/unstable-book/src/language-features/asm-experimental-reg.md

@@ -19,8 +19,8 @@ This tracks support for additional registers in architectures where inline assem
 
 | Architecture | Register class | Target feature | Allowed types |
 | ------------ | -------------- | -------------- | ------------- |
-| LoongArch | `vreg` | `lsx` | `f32`, `f64`, <br> `i8x16`, `i16x8`, `i32x4`, `i64x2`, `f32x4`, `f64x2` |
-| LoongArch | `xreg` | `lasx` | `f32`, `f64`, <br> `i8x16`, `i16x8`, `i32x4`, `i64x2`, `f32x4`, `f64x2`, <br> `i8x32`, `i16x16`, `i32x8`, `i64x4`, `f32x8`, `f64x4` |
+| LoongArch | `vreg` | `lsx` | `i128`, `f32`, `f64`, <br> `i8x16`, `i16x8`, `i32x4`, `i64x2`, `f32x4`, `f64x2` |
+| LoongArch | `xreg` | `lasx` | `i128`, `f32`, `f64`, <br> `i8x16`, `i16x8`, `i32x4`, `i64x2`, `f32x4`, `f64x2`, <br> `i8x32`, `i16x16`, `i32x8`, `i64x4`, `f32x8`, `f64x4` |
 
 ## Register aliases
 

src/librustdoc/clean/inline.rs

@@ -250,17 +250,21 @@ pub(crate) fn get_item_path(tcx: TyCtxt<'_>, def_id: DefId, kind: ItemType) -> V
     if let ItemType::Macro = kind {
         // Check to see if it is a macro 2.0 or built-in macro
         // More information in <https://rust-lang.github.io/rfcs/1584-macros.html>.
-        if matches!(
-            CStore::from_tcx(tcx).load_macro_untracked(tcx, def_id),
-            LoadedMacro::MacroDef { def, .. } if !def.macro_rules
-        ) {
-            once(crate_name).chain(relative).collect()
+        let is_macro_2_0_or_builtin = if let Some(local_def_id) = def_id.as_local() {
+            let (_, macro_def, _) = tcx.hir_expect_item(local_def_id).expect_macro();
+            !macro_def.macro_rules
         } else {
-            vec![crate_name, *relative.last().expect("relative was empty")]
+            matches!(
+                CStore::from_tcx(tcx).load_macro_untracked(tcx, def_id),
+                LoadedMacro::MacroDef { def, .. } if !def.macro_rules
+            )
+        };
+        if !is_macro_2_0_or_builtin {
+            return vec![crate_name, *relative.last().expect("relative was empty")];
         }
-    } else {
-        once(crate_name).chain(relative).collect()
     }
+
+    once(crate_name).chain(relative).collect()
 }
 
 /// Record an external fully qualified name in the external_paths cache.

tests/run-make/rustc-help/polonius-help.stdout

@@ -0,0 +1 @@
+    -Z                                      polonius=val -- enable polonius-based borrow-checker (default: next)

tests/run-make/rustc-help/rmake.rs

@@ -22,6 +22,12 @@ fn main() {
     // Check that all help options can be invoked at once
     let codegen_help = bare_rustc().arg("-Chelp").run().stdout_utf8();
     let unstable_help = bare_rustc().arg("-Zhelp").run().stdout_utf8();
+    let polonius_help =
+        format!("{}\n", unstable_help.lines().find(|line| line.contains("polonius=val")).unwrap());
+    diff()
+        .expected_file("polonius-help.stdout")
+        .actual_text("rustc -Zhelp (polonius)", &polonius_help)
+        .run();
     let lints_help = bare_rustc().arg("-Whelp").run().stdout_utf8();
     let expected_all = format!("{help}{codegen_help}{unstable_help}{lints_help}");
     let all_help = bare_rustc().args(["--help", "-Chelp", "-Zhelp", "-Whelp"]).run().stdout_utf8();

tests/rustdoc-html/auxiliary/generated_macro.rs

@@ -0,0 +1,17 @@
+//@ no-prefer-dynamic
+
+#![crate_type = "proc-macro"]
+
+use std::str::FromStr;
+
+extern crate proc_macro;
+
+#[proc_macro_derive(MyDeriveMacro)]
+pub fn derive_my_derive_macro(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    proc_macro::TokenStream::from_str("
+        #[macro_export]
+        macro_rules! my_generated_macro {
+            ($my_macro_parameter: expr) => {};
+        }
+    ").unwrap()
+}

tests/rustdoc-html/generated_macro.rs

@@ -0,0 +1,16 @@
+// This test ensures that the macro generated by the proc macro has the correct
+// "item-decl" code block.
+// Regression test for <https://github.com/rust-lang/rust/issues/79289>.
+
+//@ aux-build:generated_macro.rs
+
+#![crate_name = "foo"]
+
+extern crate generated_macro;
+
+//@ has 'foo/macro.my_generated_macro.html'
+//@ matches - '//*[@class="rust item-decl"]/code' \
+// 'macro_rules! my_generated_macro \{\s+\(\$my_macro_parameter:expr\) => \{ ... \};\s+\}'
+
+#[derive(generated_macro::MyDeriveMacro)]
+struct MyStruct {}

tests/rustdoc-ui/lints/redundant-explicit-links-ice.fixed

@@ -0,0 +1,13 @@
+// Regression test for <https://github.com/rust-lang/rust/issues/161837>.
+
+//@ run-rustfix
+
+#![deny(rustdoc::redundant_explicit_links)]
+
+//! [queue]
+//~^ ERROR redundant explicit link target
+
+#[macro_export]
+macro_rules! queue {
+    () => {};
+}

tests/rustdoc-ui/lints/redundant-explicit-links-ice.rs

@@ -0,0 +1,13 @@
+// Regression test for <https://github.com/rust-lang/rust/issues/161837>.
+
+//@ run-rustfix
+
+#![deny(rustdoc::redundant_explicit_links)]
+
+//! [queue](macro.queue.html)
+//~^ ERROR redundant explicit link target
+
+#[macro_export]
+macro_rules! queue {
+    () => {};
+}

tests/rustdoc-ui/lints/redundant-explicit-links-ice.stderr

@@ -0,0 +1,23 @@
+error: redundant explicit link target
+  --> $DIR/redundant-explicit-links-ice.rs:7:13
+   |
+LL | //! [queue](macro.queue.html)
+   |      -----  ^^^^^^^^^^^^^^^^ explicit target is redundant
+   |      |
+   |      because label contains path that resolves to same destination
+   |
+   = note: when a link's destination is not specified,
+           the label is used to resolve intra-doc links
+note: the lint level is defined here
+  --> $DIR/redundant-explicit-links-ice.rs:5:9
+   |
+LL | #![deny(rustdoc::redundant_explicit_links)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: remove explicit link target
+   |
+LL - //! [queue](macro.queue.html)
+LL + //! [queue]
+   |
+
+error: aborting due to 1 previous error
+