Rollup of 13 pull requests

Cargo.lock

@@ -2562,7 +2562,6 @@ dependencies = [
  "ipc-channel",
  "libc",
  "libffi",
- "libffi-sys",
  "libloading",
  "measureme",
  "mio",

compiler/rustc_expand/src/mbe/diagnostics.rs

@@ -408,18 +408,22 @@ pub(super) fn emit_frag_parse_err(
             Err(err) => err.cancel(),
             Ok(_) => {
                 e.note(
-                    "the macro call doesn't expand to an expression, but it can expand to a statement",
+                    "the macro call doesn't expand to an expression, but it can expand to a \
+                     statement",
                 );
 
-                if parser.token == token::Semi {
-                    if let Ok(snippet) = parser.psess.source_map().span_to_snippet(site_span) {
-                        e.span_suggestion_verbose(
-                            site_span,
-                            "surround the macro invocation with `{}` to interpret the expansion as a statement",
-                            format!("{{ {snippet}; }}"),
-                            Applicability::MaybeIncorrect,
-                        );
-                    }
+                if parser.token == token::Semi
+                    || matches!(parser.token.kind, token::TokenKind::OpenInvisible(_))
+                {
+                    e.multipart_suggestion(
+                        "invoke the macro in a new block with a single statement to interpret the \
+                         expansion as a statement",
+                        vec![
+                            (site_span.shrink_to_lo(), "{ ".to_string()),
+                            (site_span.shrink_to_hi(), "; }".to_string()),
+                        ],
+                        Applicability::MaybeIncorrect,
+                    );
                 } else {
                     e.span_suggestion_verbose(
                         site_span.shrink_to_hi(),

compiler/rustc_parse/src/parser/expr.rs

@@ -1159,7 +1159,7 @@ impl<'a> Parser<'a> {
         let open_delim_span = self.token.span;
         self.bump(); // `[`
         let index = self.parse_expr()?;
-        self.suggest_missing_semicolon_before_array(prev_token.span, open_delim_span)?;
+        self.recover_from_missing_semicolon_before_array(prev_token.span, open_delim_span)?;
         self.expect(exp!(CloseBracket)).map_err(|mut err| {
             if prev_token.is_non_reserved_ident() {
                 err.span_suggestion_verbose(
@@ -2135,48 +2135,6 @@ impl<'a> Parser<'a> {
         }
     }
 
-    fn suggest_missing_semicolon_before_array(
-        &self,
-        prev_span: Span,
-        open_delim_span: Span,
-    ) -> PResult<'a, ()> {
-        if !self.may_recover() {
-            return Ok(());
-        }
-
-        if self.token == token::Comma {
-            if !self.psess.source_map().is_multiline(prev_span.until(self.token.span)) {
-                return Ok(());
-            }
-            let mut snapshot = self.create_snapshot_for_diagnostic();
-            snapshot.bump();
-            match snapshot.parse_seq_to_before_end(
-                exp!(CloseBracket),
-                SeqSep::trailing_allowed(exp!(Comma)),
-                |p| p.parse_expr(),
-            ) {
-                Ok(_)
-                    // When the close delim is `)`, `token.kind` is expected to be `token::CloseParen`,
-                    // but the actual `token.kind` is `token::CloseBracket`.
-                    // This is because the `token.kind` of the close delim is treated as the same as
-                    // that of the open delim in `TokenTreesReader::parse_token_tree`, even if the delimiters of them are different.
-                    // Therefore, `token.kind` should not be compared here.
-                    if snapshot
-                        .span_to_snippet(snapshot.token.span)
-                        .is_ok_and(|snippet| snippet == "]") =>
-                {
-                    return Err(self.dcx().create_err(crate::diagnostics::MissingSemicolonBeforeArray {
-                        open_delim: open_delim_span,
-                        semicolon: prev_span.shrink_to_hi(),
-                    }));
-                }
-                Ok(_) => (),
-                Err(err) => err.cancel(),
-            }
-        }
-        Ok(())
-    }
-
     /// Parses a block or unsafe block.
     pub(super) fn parse_expr_block(
         &mut self,

compiler/rustc_parse/src/parser/expr/diagnostics.rs

@@ -4,7 +4,7 @@ use rustc_ast_pretty::pprust;
 use rustc_errors::{Applicability, Diag, PResult};
 use rustc_span::{Span, Spanned, respan, sym};
 
-use crate::parser::Parser;
+use crate::parser::{Parser, SeqSep};
 use crate::{diagnostics, exp};
 
 impl<'a> Parser<'a> {
@@ -294,6 +294,60 @@ impl<'a> Parser<'a> {
             }
         }
     }
+
+    pub(super) fn recover_from_missing_semicolon_before_array(
+        &self,
+        prev_span: Span,
+        open_delim_span: Span,
+    ) -> PResult<'a, ()> {
+        if !self.may_recover()
+            || self.token != token::Comma
+            // Only make this suggestion if the `[` is not on the same line as the last token of
+            // the expression preceding it, which is a sign that it is not intended as an
+            // index expression.
+            || !self.psess.source_map().is_multiline(prev_span.until(open_delim_span))
+        {
+            return Ok(());
+        }
+
+        let mut snapshot = self.create_snapshot_for_diagnostic();
+        snapshot.bump();
+        match snapshot.parse_seq_to_before_end(
+            exp!(CloseBracket),
+            SeqSep::trailing_allowed(exp!(Comma)),
+            |p| p.parse_expr(),
+        ) {
+            Ok(_)
+                // When the close delim is `)`, `token.kind` is expected to be `token::CloseParen`,
+                // but the actual `token.kind` is `token::CloseBracket`. This is because the
+                // `token.kind` of the close delim is treated as the same as that of the open delim
+                // in `TokenTreesReader::parse_token_tree`, even if the delimiters of them are
+                // different. Therefore, `token.kind` should not be compared here.
+                if snapshot
+                    .span_to_snippet(snapshot.token.span)
+                    .is_ok_and(|snippet| snippet == "]") =>
+            {
+                // FIXME: This is way to assertive for a diagnostic with so many false positives!
+                //        Just `expect(Comma)` and modify the diagnostic with a note that says sth.
+                //        along the lines of "consider adding a `;` here if you meant the `[...]` to
+                //        denote an array instead of an index".
+                // FIXME: In most cases there certainly isn't a "missing `;`". E.g., if we're nested
+                //        in an expression like `(x[y, z])` or `match x[y, z] {}`. Requiring that
+                //        we're not under `Restriction::STMT_EXPR` isn't sufficient by the way since
+                //        we could still be part of a match arm body *and* it would prevent us from
+                //        suggesting a `;` in cases like `let x = y[z, w];`.
+                Err(self.dcx().create_err(crate::diagnostics::MissingSemicolonBeforeArray {
+                    open_delim: open_delim_span,
+                    semicolon: prev_span.shrink_to_hi(),
+                }))
+            }
+            Ok(_) => Ok(()),
+            Err(err) => {
+                err.cancel();
+                Ok(())
+            }
+        }
+    }
 }
 
 /// Whether this operator could be used to follow a complete statement expression unambiguously

compiler/rustc_resolve/src/late.rs

@@ -5144,10 +5144,17 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
         partial_res
     }
 
-    fn self_type_is_available(&mut self) -> bool {
+    fn self_type_is_available(&mut self) -> Option<DefId> {
         let binding = self
             .maybe_resolve_ident_in_lexical_scope(Ident::with_dummy_span(kw::SelfUpper), TypeNS);
-        if let Some(LateDecl::RibDef(res)) = binding { res != Res::Err } else { false }
+        if let Some(LateDecl::RibDef(
+            Res::SelfTyAlias { alias_to, .. } | Res::SelfTyParam { trait_: alias_to },
+        )) = binding
+        {
+            Some(alias_to)
+        } else {
+            None
+        }
     }
 
     fn self_value_is_available(&mut self, self_span: Span) -> bool {