Auto merge of #155292 - JonathanBrouwer:rollup-AJQWqfn, r=JonathanBrouwer

Rollup of 7 pull requests

Successful merges:

 - #154049 (delegation: Track more precise spans for glob delegations)
 - #155134 (Replace custom trim_ascii_start with the standard library method)
 - #155235 (add the `fma4` x86 target feature)
 - #155218 (coroutines: Skip the closure signature annotation check for tainted bodies)
 - #155274 (limit duplicate-profiler-builtins test to targets that can do dynamic linking)
 - #155276 (`#[rustc_must_match_exhaustively]` detect let else)
 - #155281 (Revert "allow `windows-gnu` targets to embed gdb visualizer scripts")

Author: bors

compiler/rustc_ast/src/ast.rs

@@ -3901,12 +3901,17 @@ pub struct Delegation {
     pub from_glob: bool,
 }
 
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
+pub enum DelegationSuffixes {
+    List(ThinVec<(Ident, Option<Ident>)>),
+    Glob(Span),
+}
+
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct DelegationMac {
     pub qself: Option<Box<QSelf>>,
     pub prefix: Path,
-    // Some for list delegation, and None for glob delegation.
-    pub suffixes: Option<ThinVec<(Ident, Option<Ident>)>>,
+    pub suffixes: DelegationSuffixes,
     pub body: Option<Box<Block>>,
 }
 

compiler/rustc_ast/src/visit.rs

@@ -430,6 +430,7 @@ macro_rules! common_visitor_and_walkers {
             Defaultness,
             Delegation,
             DelegationMac,
+            DelegationSuffixes,
             DelimArgs,
             DelimSpan,
             EnumDef,

compiler/rustc_ast_pretty/src/pprust/state/item.rs

@@ -444,7 +444,10 @@ impl<'a> State<'a> {
                 &item.vis,
                 &deleg.qself,
                 &deleg.prefix,
-                deleg.suffixes.as_ref().map_or(DelegationKind::Glob, |s| DelegationKind::List(s)),
+                match &deleg.suffixes {
+                    ast::DelegationSuffixes::List(s) => DelegationKind::List(s),
+                    ast::DelegationSuffixes::Glob(_) => DelegationKind::Glob,
+                },
                 &deleg.body,
             ),
         }
@@ -651,7 +654,10 @@ impl<'a> State<'a> {
                 vis,
                 &deleg.qself,
                 &deleg.prefix,
-                deleg.suffixes.as_ref().map_or(DelegationKind::Glob, |s| DelegationKind::List(s)),
+                match &deleg.suffixes {
+                    ast::DelegationSuffixes::List(s) => DelegationKind::List(s),
+                    ast::DelegationSuffixes::Glob(_) => DelegationKind::Glob,
+                },
                 &deleg.body,
             ),
         }

compiler/rustc_borrowck/src/type_check/input_output.rs

@@ -32,6 +32,15 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             return;
         }
 
+        // If the MIR body was constructed via `construct_error` (because an
+        // earlier pass like match checking failed), its args may not match
+        // the user-provided signature (e.g. a coroutine with too many
+        // parameters). Bail out as this can cause panic,
+        // see <https://github.com/rust-lang/rust/issues/139570>.
+        if self.body.tainted_by_errors.is_some() {
+            return;
+        }
+
         let user_provided_poly_sig = self.tcx().closure_user_provided_sig(mir_def_id);
 
         // Instantiate the canonicalized variables from user-provided signature

compiler/rustc_errors/src/markdown/parse.rs

@@ -252,7 +252,7 @@ fn parse_heading(buf: &[u8]) -> ParseResult<'_> {
 fn parse_unordered_li(buf: &[u8]) -> Parsed<'_> {
     let (txt, rest) = get_indented_section(&buf[2..]);
     let ctx = Context { .. };
-    let stream = parse_recursive(trim_ascii_start(txt), ctx);
+    let stream = parse_recursive(txt.trim_ascii_start(), ctx);
     (MdTree::UnorderedListItem(stream), rest)
 }
 
@@ -261,7 +261,7 @@ fn parse_ordered_li(buf: &[u8]) -> Parsed<'_> {
     let (num, pos) = ord_list_start(buf).unwrap(); // success tested in caller
     let (txt, rest) = get_indented_section(&buf[pos..]);
     let ctx = Context { .. };
-    let stream = parse_recursive(trim_ascii_start(txt), ctx);
+    let stream = parse_recursive(txt.trim_ascii_start(), ctx);
     (MdTree::OrderedListItem(num, stream), rest)
 }
 
@@ -578,12 +578,6 @@ fn trim_extra_ws(mut txt: &str) -> &str {
     &txt[..txt.len() - end_ws]
 }
 
-/// If there is more than one whitespace char at start, trim the extras
-fn trim_ascii_start(buf: &[u8]) -> &[u8] {
-    let count = buf.iter().take_while(|ch| ch.is_ascii_whitespace()).count();
-    &buf[count..]
-}
-
 #[cfg(test)]
 #[path = "tests/parse.rs"]
 mod tests;

compiler/rustc_errors/src/markdown/tests/parse.rs

@@ -377,3 +377,24 @@ fn test_codeblock_trailing_whitespace() {
     assert_eq!(t, MdTree::CodeBlock { txt: "code\n```abc\nrest", lang: Some("rust") });
     assert_eq!(r, b"");
 }
+
+#[test]
+fn test_list_item_leading_whitespace() {
+    // extra spaces after marker
+    let buf = "-   hello";
+    let (t, r) = parse_unordered_li(buf.as_bytes());
+    assert_eq!(t, MdTree::UnorderedListItem(vec![MdTree::PlainText("hello")].into()));
+    assert_eq!(r, b"");
+
+    // tab after the marker space
+    let buf = "- \thello";
+    let (t, r) = parse_unordered_li(buf.as_bytes());
+    assert_eq!(t, MdTree::UnorderedListItem(vec![MdTree::PlainText("hello")].into()));
+    assert_eq!(r, b"");
+
+    // ordered list
+    let buf = "1.   hello";
+    let (t, r) = parse_ordered_li(buf.as_bytes());
+    assert_eq!(t, MdTree::OrderedListItem(1, vec![MdTree::PlainText("hello")].into()));
+    assert_eq!(r, b"");
+}

compiler/rustc_expand/src/base.rs

@@ -1019,26 +1019,32 @@ impl SyntaxExtension {
     pub fn glob_delegation(
         trait_def_id: DefId,
         impl_def_id: LocalDefId,
+        star_span: Span,
         edition: Edition,
     ) -> SyntaxExtension {
         struct GlobDelegationExpanderImpl {
             trait_def_id: DefId,
             impl_def_id: LocalDefId,
+            star_span: Span,
         }
         impl GlobDelegationExpander for GlobDelegationExpanderImpl {
             fn expand(
                 &self,
                 ecx: &mut ExtCtxt<'_>,
             ) -> ExpandResult<Vec<(Ident, Option<Ident>)>, ()> {
-                match ecx.resolver.glob_delegation_suffixes(self.trait_def_id, self.impl_def_id) {
+                match ecx.resolver.glob_delegation_suffixes(
+                    self.trait_def_id,
+                    self.impl_def_id,
+                    self.star_span,
+                ) {
                     Ok(suffixes) => ExpandResult::Ready(suffixes),
                     Err(Indeterminate) if ecx.force_mode => ExpandResult::Ready(Vec::new()),
                     Err(Indeterminate) => ExpandResult::Retry(()),
                 }
             }
         }
 
-        let expander = GlobDelegationExpanderImpl { trait_def_id, impl_def_id };
+        let expander = GlobDelegationExpanderImpl { trait_def_id, impl_def_id, star_span };
         SyntaxExtension::default(SyntaxExtensionKind::GlobDelegation(Arc::new(expander)), edition)
     }
 
@@ -1170,6 +1176,7 @@ pub trait ResolverExpand {
         &self,
         trait_def_id: DefId,
         impl_def_id: LocalDefId,
+        star_span: Span,
     ) -> Result<Vec<(Ident, Option<Ident>)>, Indeterminate>;
 
     /// Record the name of an opaque `Ty::ImplTrait` pre-expansion so that it can be used

compiler/rustc_expand/src/expand.rs

@@ -8,9 +8,9 @@ use rustc_ast::tokenstream::TokenStream;
 use rustc_ast::visit::{self, AssocCtxt, Visitor, VisitorResult, try_visit, walk_list};
 use rustc_ast::{
     self as ast, AssocItemKind, AstNodeWrapper, AttrArgs, AttrItemKind, AttrStyle, AttrVec,
-    DUMMY_NODE_ID, EarlyParsedAttribute, ExprKind, ForeignItemKind, HasAttrs, HasNodeId, Inline,
-    ItemKind, MacStmtStyle, MetaItemInner, MetaItemKind, ModKind, NodeId, PatKind, StmtKind,
-    TyKind, token,
+    DUMMY_NODE_ID, DelegationSuffixes, EarlyParsedAttribute, ExprKind, ForeignItemKind, HasAttrs,
+    HasNodeId, Inline, ItemKind, MacStmtStyle, MetaItemInner, MetaItemKind, ModKind, NodeId,
+    PatKind, StmtKind, TyKind, token,
 };
 use rustc_ast_pretty::pprust;
 use rustc_attr_parsing::parser::AllowExprMetavar;
@@ -2401,7 +2401,7 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
                     res
                 }
                 None if let Some((deleg, item)) = node.delegation() => {
-                    let Some(suffixes) = &deleg.suffixes else {
+                    let DelegationSuffixes::List(suffixes) = &deleg.suffixes else {
                         let traitless_qself =
                             matches!(&deleg.qself, Some(qself) if qself.position == 0);
                         let (item, of_trait) = match node.to_annotatable() {

compiler/rustc_feature/src/unstable.rs

@@ -512,6 +512,8 @@ declare_features! (
     (incomplete, field_projections, "CURRENT_RUSTC_VERSION", Some(145383)),
     /// Allows marking trait functions as `final` to prevent overriding impls
     (unstable, final_associated_functions, "1.95.0", Some(131179)),
+    /// fma4 target feature on x86.
+    (unstable, fma4_target_feature, "CURRENT_RUSTC_VERSION", Some(155233)),
     /// Controlling the behavior of fmt::Debug
     (unstable, fmt_debug, "1.82.0", Some(129709)),
     /// Allows using `#[align(...)]` on function items

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -659,9 +659,16 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // being stalled on a coroutine.
         self.select_obligations_where_possible(|_| {});
 
-        let ty::TypingMode::Analysis { defining_opaque_types_and_generators } = self.typing_mode()
-        else {
-            bug!();
+        let defining_opaque_types_and_generators = match self.typing_mode() {
+            ty::TypingMode::Analysis { defining_opaque_types_and_generators } => {
+                defining_opaque_types_and_generators
+            }
+            ty::TypingMode::Coherence
+            | ty::TypingMode::Borrowck { .. }
+            | ty::TypingMode::PostBorrowckAnalysis { .. }
+            | ty::TypingMode::PostAnalysis => {
+                bug!()
+            }
         };
 
         if defining_opaque_types_and_generators