Auto merge of #149510 - matthiaskrgr:rollup-5rt6o7z, r=matthiaskrgr

Rollup of 9 pull requests

Successful merges:

 - #148690 (Implement `clamp_magnitude` method for primitive floats & signed integers)
 - #149102 (stabilize maybe_uninit_slice)
 - #149269 (cmse: do not calculate the layout of a type with infer types)
 - #149299 (Fudge infer vars in the cause code of `Obligation` intentionally)
 - #149344 (Don't suggest unwrap for Result in const)
 - #149358 (fix(parse): Limit frontmatter fences to 255 dashes )
 - #149445 (make assoc fn inherit const stability from inherent `const impl` blocks)
 - #149479 (Fix indent in E0591.md)
 - #149496 (Fix #148889: Add label rib when visiting delegation body)

r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

compiler/rustc_arena/src/lib.rs

@@ -10,13 +10,13 @@
 // tidy-alphabetical-start
 #![allow(clippy::mut_from_ref)] // Arena allocators are one place where this pattern is fine.
 #![allow(internal_features)]
+#![cfg_attr(bootstrap, feature(maybe_uninit_slice))]
 #![cfg_attr(test, feature(test))]
 #![deny(unsafe_op_in_unsafe_fn)]
 #![doc(test(no_crate_inject, attr(deny(warnings), allow(internal_features))))]
 #![feature(core_intrinsics)]
 #![feature(decl_macro)]
 #![feature(dropck_eyepatch)]
-#![feature(maybe_uninit_slice)]
 #![feature(never_type)]
 #![feature(rustc_attrs)]
 #![feature(unwrap_infallible)]

compiler/rustc_error_codes/src/error_codes/E0591.md

@@ -62,14 +62,14 @@ This pattern should be rewritten. There are a few possible ways to do this:
   and do the cast in the fn body (the preferred option)
 - cast the fn item of a fn pointer before calling transmute, as shown here:
 
-    ```
-    # extern "C" fn foo(_: Box<i32>) {}
-    # use std::mem::transmute;
-    # unsafe {
-    let f: extern "C" fn(*mut i32) = transmute(foo as extern "C" fn(_));
-    let f: extern "C" fn(*mut i32) = transmute(foo as usize); // works too
-    # }
-    ```
+```
+# extern "C" fn foo(_: Box<i32>) {}
+# use std::mem::transmute;
+# unsafe {
+let f: extern "C" fn(*mut i32) = transmute(foo as extern "C" fn(_));
+let f: extern "C" fn(*mut i32) = transmute(foo as usize); // works too
+# }
+```
 
 The same applies to transmutes to `*mut fn()`, which were observed in practice.
 Note though that use of this type is generally incorrect.

compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs

@@ -86,6 +86,11 @@ fn is_valid_cmse_inputs<'tcx>(
     let fn_sig = tcx.erase_and_anonymize_regions(fn_sig);
 
     for (ty, hir_ty) in fn_sig.inputs().iter().zip(fn_decl.inputs) {
+        if ty.has_infer_types() {
+            let err = LayoutError::Unknown(*ty);
+            return Err((hir_ty.span, tcx.arena.alloc(err)));
+        }
+
         let layout = tcx
             .layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(*ty))
             .map_err(|e| (hir_ty.span, e))?;
@@ -138,6 +143,11 @@ fn is_valid_cmse_output<'tcx>(
         return Ok(());
     }
 
+    if return_type.has_infer_types() {
+        let err = LayoutError::Unknown(return_type);
+        return Err(tcx.arena.alloc(err));
+    }
+
     let typing_env = ty::TypingEnv::fully_monomorphized();
     let layout = tcx.layout_of(typing_env.as_query_input(return_type))?;
 

compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs

@@ -2106,14 +2106,16 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             )),
         );
 
-        let (article, kind, variant, sugg_operator) =
-            if self.tcx.is_diagnostic_item(sym::Result, adt.did()) {
-                ("a", "Result", "Err", ret_ty_matches(sym::Result))
-            } else if self.tcx.is_diagnostic_item(sym::Option, adt.did()) {
-                ("an", "Option", "None", ret_ty_matches(sym::Option))
-            } else {
-                return false;
-            };
+        let (article, kind, variant, sugg_operator) = if self.tcx.is_diagnostic_item(sym::Result, adt.did())
+            // Do not suggest `.expect()` in const context where it's not available. rust-lang/rust#149316
+            && !self.tcx.hir_is_inside_const_context(expr.hir_id)
+        {
+            ("a", "Result", "Err", ret_ty_matches(sym::Result))
+        } else if self.tcx.is_diagnostic_item(sym::Option, adt.did()) {
+            ("an", "Option", "None", ret_ty_matches(sym::Option))
+        } else {
+            return false;
+        };
         if is_ctor || !self.may_coerce(args.type_at(0), expected) {
             return false;
         }

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -3041,14 +3041,16 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             tcx.def_span(pick.item.def_id),
                             format!("the method `{item_name}` exists on the type `{self_ty}`"),
                         );
-                        let (article, kind, variant, question) =
-                            if tcx.is_diagnostic_item(sym::Result, kind.did()) {
-                                ("a", "Result", "Err", ret_ty_matches(sym::Result))
-                            } else if tcx.is_diagnostic_item(sym::Option, kind.did()) {
-                                ("an", "Option", "None", ret_ty_matches(sym::Option))
-                            } else {
-                                return;
-                            };
+                        let (article, kind, variant, question) = if tcx.is_diagnostic_item(sym::Result, kind.did())
+                            // Do not suggest `.expect()` in const context where it's not available. rust-lang/rust#149316
+                            && !tcx.hir_is_inside_const_context(expr.hir_id)
+                        {
+                            ("a", "Result", "Err", ret_ty_matches(sym::Result))
+                        } else if tcx.is_diagnostic_item(sym::Option, kind.did()) {
+                            ("an", "Option", "None", ret_ty_matches(sym::Option))
+                        } else {
+                            return;
+                        };
                         if question {
                             err.span_suggestion_verbose(
                                 expr.span.shrink_to_hi(),

compiler/rustc_infer/src/traits/mod.rs

@@ -37,6 +37,8 @@ use crate::infer::InferCtxt;
 #[derive(Clone, TypeFoldable, TypeVisitable)]
 pub struct Obligation<'tcx, T> {
     /// The reason we have to prove this thing.
+    /// FIXME: we shouldn't ignore the cause but instead change the affected visitors
+    /// to only visit predicates manually.
     #[type_foldable(identity)]
     #[type_visitable(ignore)]
     pub cause: ObligationCause<'tcx>,

compiler/rustc_parse/messages.ftl

@@ -347,6 +347,7 @@ parse_frontmatter_invalid_opening_preceding_whitespace = invalid preceding white
 parse_frontmatter_length_mismatch = frontmatter close does not match the opening
     .label_opening = the opening here has {$len_opening} dashes...
     .label_close = ...while the close has {$len_close} dashes
+parse_frontmatter_too_many_dashes = too many `-` symbols: frontmatter openings may be delimited by up to 255 `-` symbols, but found {$len_opening}
 parse_frontmatter_unclosed = unclosed frontmatter
     .note = frontmatter opening here was not closed
 

compiler/rustc_parse/src/errors.rs

@@ -822,6 +822,12 @@ pub(crate) struct FrontmatterLengthMismatch {
     pub len_close: usize,
 }
 
+#[derive(Diagnostic)]
+#[diag(parse_frontmatter_too_many_dashes)]
+pub(crate) struct FrontmatterTooManyDashes {
+    pub len_opening: usize,
+}
+
 #[derive(Diagnostic)]
 #[diag(parse_leading_plus_not_supported)]
 pub(crate) struct LeadingPlusNotSupported {

compiler/rustc_parse/src/lexer/mod.rs

@@ -665,6 +665,11 @@ impl<'psess, 'src> Lexer<'psess, 'src> {
             });
         }
 
+        // Only up to 255 `-`s are allowed in code fences
+        if u8::try_from(len_opening).is_err() {
+            self.dcx().emit_err(errors::FrontmatterTooManyDashes { len_opening });
+        }
+
         if !rest.trim_matches(is_horizontal_whitespace).is_empty() {
             let span = self.mk_sp(last_line_start_pos, self.pos);
             self.dcx().emit_err(errors::FrontmatterExtraCharactersAfterClose { span });

compiler/rustc_passes/src/stability.rs

@@ -54,7 +54,7 @@ fn inherit_const_stability(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
     match def_kind {
         DefKind::AssocFn | DefKind::AssocTy | DefKind::AssocConst => {
             match tcx.def_kind(tcx.local_parent(def_id)) {
-                DefKind::Impl { of_trait: true } => true,
+                DefKind::Impl { .. } => true,
                 _ => false,
             }
         }