Merge branch 'rust-lang:main' into doc/location-caller-updated

Author: Paladynee

.gitignore

@@ -48,7 +48,7 @@ no_llvm_build
 /llvm/
 /mingw-build/
 /build
-/build-rust-analyzer/
+/build-rust-analyzer
 /dist/
 /unicode-downloads
 /target

Cargo.lock

@@ -1288,7 +1288,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "778e2ac28f6c47af28e4907f13ffd1e1ddbd400980a9abd7c8df189bf578a5ad"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -2154,7 +2154,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "07033963ba89ebaf1584d767badaa2e8fcec21aedea6b8c0346d487d49c28667"
 dependencies = [
  "cfg-if",
- "windows-targets 0.52.6",
+ "windows-targets 0.53.3",
 ]
 
 [[package]]
@@ -4905,7 +4905,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -5273,9 +5273,9 @@ dependencies = [
 
 [[package]]
 name = "stringdex"
-version = "0.0.2"
+version = "0.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18b3bd4f10d15ef859c40291769f0d85209de6b0f1c30713ff9cdf45ac43ea36"
+checksum = "556a6126952cb2f5150057c98a77cc6c771027dea2825bf7fa03d3d638b0a4f8"
 dependencies = [
  "stacker",
 ]

bootstrap.example.toml

@@ -59,7 +59,10 @@
 # toolchain or changing LLVM locally, you probably want to leave this enabled.
 #
 # Set this to `true` to download if CI llvm available otherwise it builds
-# from `src/llvm-project`.
+# from `src/llvm-project`. If you set it to `true`, it's safe and time-saving to run
+# `git submodule deinit src/llvm-project` to avoid git updating the llvm-project submodule
+# when building compiler locally.
+#
 #
 # Set this to `"if-unchanged"` to download only if the llvm-project has not
 # been modified. You can also use this if you are unsure whether you're on a

compiler/rustc_abi/src/extern_abi.rs

@@ -276,6 +276,51 @@ impl ExternAbi {
             _ => CVariadicStatus::NotSupported,
         }
     }
+
+    /// Returns whether the ABI supports guaranteed tail calls.
+    #[cfg(feature = "nightly")]
+    pub fn supports_guaranteed_tail_call(self) -> bool {
+        match self {
+            Self::CmseNonSecureCall | Self::CmseNonSecureEntry => {
+                // See https://godbolt.org/z/9jhdeqErv. The CMSE calling conventions clear registers
+                // before returning, and hence cannot guarantee a tail call.
+                false
+            }
+            Self::AvrInterrupt
+            | Self::AvrNonBlockingInterrupt
+            | Self::Msp430Interrupt
+            | Self::RiscvInterruptM
+            | Self::RiscvInterruptS
+            | Self::X86Interrupt => {
+                // See https://godbolt.org/z/Edfjnxxcq. Interrupts cannot be called directly.
+                false
+            }
+            Self::GpuKernel | Self::PtxKernel => {
+                // See https://godbolt.org/z/jq5TE5jK1.
+                false
+            }
+            Self::Custom => {
+                // This ABI does not support calls at all (except via assembly).
+                false
+            }
+            Self::C { .. }
+            | Self::System { .. }
+            | Self::Rust
+            | Self::RustCall
+            | Self::RustCold
+            | Self::RustInvalid
+            | Self::Unadjusted
+            | Self::EfiApi
+            | Self::Aapcs { .. }
+            | Self::Cdecl { .. }
+            | Self::Stdcall { .. }
+            | Self::Fastcall { .. }
+            | Self::Thiscall { .. }
+            | Self::Vectorcall { .. }
+            | Self::SysV64 { .. }
+            | Self::Win64 { .. } => true,
+        }
+    }
 }
 
 pub fn all_names() -> Vec<&'static str> {

compiler/rustc_ast/src/visit.rs

@@ -645,8 +645,9 @@ macro_rules! common_visitor_and_walkers {
             fn visit_fn(
                 &mut self,
                 fk: FnKind<$($lt)? $(${ignore($mut)} '_)?>,
+                _: &AttrVec,
                 _: Span,
-                _: NodeId
+                _: NodeId,
             ) -> Self::Result {
                 walk_fn(self, fk)
             }
@@ -740,6 +741,7 @@ macro_rules! common_visitor_and_walkers {
             type Ctxt;
             fn walk<$($lt,)? V: $Visitor$(<$lt>)?>(
                 &$($lt)? $($mut)? self,
+                attrs: &AttrVec,
                 span: Span,
                 id: NodeId,
                 visibility: &$($lt)? $($mut)? Visibility,
@@ -773,7 +775,7 @@ macro_rules! common_visitor_and_walkers {
         ) -> V::Result {
             let Item { attrs, id, kind, vis, span, tokens: _ } = item;
             visit_visitable!($($mut)? visitor, id, attrs, vis);
-            try_visit!(kind.walk(*span, *id, vis, ctxt, visitor));
+            try_visit!(kind.walk(attrs, *span, *id, vis, ctxt, visitor));
             visit_visitable!($($mut)? visitor, span);
             V::Result::output()
         }
@@ -799,6 +801,7 @@ macro_rules! common_visitor_and_walkers {
             type Ctxt = ();
             fn walk<$($lt,)? V: $Visitor$(<$lt>)?>(
                 &$($lt)? $($mut)? self,
+                attrs: &AttrVec,
                 span: Span,
                 id: NodeId,
                 visibility: &$($lt)? $($mut)? Visibility,
@@ -808,7 +811,7 @@ macro_rules! common_visitor_and_walkers {
                 match self {
                     ItemKind::Fn(func) => {
                         let kind = FnKind::Fn(FnCtxt::Free, visibility, &$($mut)? *func);
-                        try_visit!(vis.visit_fn(kind, span, id));
+                        try_visit!(vis.visit_fn(kind, attrs, span, id));
                     }
                     ItemKind::ExternCrate(orig_name, ident) =>
                         visit_visitable!($($mut)? vis, orig_name, ident),
@@ -856,6 +859,7 @@ macro_rules! common_visitor_and_walkers {
             type Ctxt = AssocCtxt;
             fn walk<$($lt,)? V: $Visitor$(<$lt>)?>(
                 &$($lt)? $($mut)? self,
+                attrs: &AttrVec,
                 span: Span,
                 id: NodeId,
                 visibility: &$($lt)? $($mut)? Visibility,
@@ -867,7 +871,7 @@ macro_rules! common_visitor_and_walkers {
                         visit_visitable!($($mut)? vis, item),
                     AssocItemKind::Fn(func) => {
                         let kind = FnKind::Fn(FnCtxt::Assoc(ctxt), visibility, &$($mut)? *func);
-                        try_visit!(vis.visit_fn(kind, span, id))
+                        try_visit!(vis.visit_fn(kind, attrs, span, id))
                     }
                     AssocItemKind::Type(alias) =>
                         visit_visitable!($($mut)? vis, alias),
@@ -886,6 +890,7 @@ macro_rules! common_visitor_and_walkers {
             type Ctxt = ();
             fn walk<$($lt,)? V: $Visitor$(<$lt>)?>(
                 &$($lt)? $($mut)? self,
+                attrs: &AttrVec,
                 span: Span,
                 id: NodeId,
                 visibility: &$($lt)? $($mut)? Visibility,
@@ -897,7 +902,7 @@ macro_rules! common_visitor_and_walkers {
                         visit_visitable!($($mut)? vis, item),
                     ForeignItemKind::Fn(func) => {
                         let kind = FnKind::Fn(FnCtxt::Foreign, visibility, &$($mut)?*func);
-                        try_visit!(vis.visit_fn(kind, span, id))
+                        try_visit!(vis.visit_fn(kind, attrs, span, id))
                     }
                     ForeignItemKind::TyAlias(alias) =>
                         visit_visitable!($($mut)? vis, alias),
@@ -999,7 +1004,7 @@ macro_rules! common_visitor_and_walkers {
                 }) => {
                     visit_visitable!($($mut)? vis, constness, movability, capture_clause);
                     let kind = FnKind::Closure(binder, coroutine_kind, fn_decl, body);
-                    try_visit!(vis.visit_fn(kind, *span, *id));
+                    try_visit!(vis.visit_fn(kind, attrs, *span, *id));
                     visit_visitable!($($mut)? vis, fn_decl_span, fn_arg_span);
                 }
                 ExprKind::Block(block, opt_label) =>

compiler/rustc_ast_lowering/src/expr.rs

@@ -13,7 +13,7 @@ use rustc_middle::span_bug;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::errors::report_lit_error;
 use rustc_span::source_map::{Spanned, respan};
-use rustc_span::{DUMMY_SP, DesugaringKind, Ident, Span, Symbol, sym};
+use rustc_span::{ByteSymbol, DUMMY_SP, DesugaringKind, Ident, Span, Symbol, sym};
 use thin_vec::{ThinVec, thin_vec};
 use visit::{Visitor, walk_expr};
 
@@ -924,7 +924,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     arena_vec![self; new_unchecked, get_context],
                 ),
             };
-            self.arena.alloc(self.expr_unsafe(call))
+            self.arena.alloc(self.expr_unsafe(span, call))
         };
 
         // `::std::task::Poll::Ready(result) => break result`
@@ -1771,8 +1771,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let pat = self.lower_pat(pat);
         let for_span =
             self.mark_span_with_reason(DesugaringKind::ForLoop, self.lower_span(e.span), None);
-        let head_span = self.mark_span_with_reason(DesugaringKind::ForLoop, head.span, None);
-        let pat_span = self.mark_span_with_reason(DesugaringKind::ForLoop, pat.span, None);
+        let for_ctxt = for_span.ctxt();
+
+        // Try to point both the head and pat spans to their position in the for loop
+        // rather than inside a macro.
+        let head_span =
+            head.span.find_ancestor_in_same_ctxt(e.span).unwrap_or(head.span).with_ctxt(for_ctxt);
+        let pat_span =
+            pat.span.find_ancestor_in_same_ctxt(e.span).unwrap_or(pat.span).with_ctxt(for_ctxt);
 
         let loop_hir_id = self.lower_node_id(e.id);
         let label = self.lower_label(opt_label, e.id, loop_hir_id);
@@ -1826,7 +1832,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         arena_vec![self; iter],
                     ));
                     // `unsafe { ... }`
-                    let iter = self.arena.alloc(self.expr_unsafe(iter));
+                    let iter = self.arena.alloc(self.expr_unsafe(head_span, iter));
                     let kind = self.make_lowered_await(head_span, iter, FutureKind::AsyncIterator);
                     self.arena.alloc(hir::Expr { hir_id: self.next_id(), kind, span: head_span })
                 }
@@ -1881,7 +1887,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     arena_vec![self; iter],
                 ));
                 // `unsafe { ... }`
-                let iter = self.arena.alloc(self.expr_unsafe(iter));
+                let iter = self.arena.alloc(self.expr_unsafe(head_span, iter));
                 let inner_match_expr = self.arena.alloc(self.expr_match(
                     for_span,
                     iter,
@@ -1923,7 +1929,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     ///     ControlFlow::Break(residual) =>
     ///         #[allow(unreachable_code)]
     ///         // If there is an enclosing `try {...}`:
-    ///         break 'catch_target Try::from_residual(residual),
+    ///         break 'catch_target Residual::into_try_type(residual),
     ///         // Otherwise:
     ///         return Try::from_residual(residual),
     /// }
@@ -1973,7 +1979,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
             let (residual_local, residual_local_nid) = self.pat_ident(try_span, residual_ident);
             let residual_expr = self.expr_ident_mut(try_span, residual_ident, residual_local_nid);
             let from_residual_expr = self.wrap_in_try_constructor(
-                hir::LangItem::TryTraitFromResidual,
+                if self.catch_scope.is_some() {
+                    hir::LangItem::ResidualIntoTryType
+                } else {
+                    hir::LangItem::TryTraitFromResidual
+                },
                 try_span,
                 self.arena.alloc(residual_expr),
                 unstable_span,
@@ -2097,30 +2107,18 @@ impl<'hir> LoweringContext<'_, 'hir> {
         self.arena.alloc(self.expr(sp, hir::ExprKind::Tup(&[])))
     }
 
-    fn expr_uint(&mut self, sp: Span, ty: ast::UintTy, value: u128) -> hir::Expr<'hir> {
+    pub(super) fn expr_str(&mut self, sp: Span, value: Symbol) -> hir::Expr<'hir> {
         let lit = hir::Lit {
             span: self.lower_span(sp),
-            node: ast::LitKind::Int(value.into(), ast::LitIntType::Unsigned(ty)),
+            node: ast::LitKind::Str(value, ast::StrStyle::Cooked),
         };
         self.expr(sp, hir::ExprKind::Lit(lit))
     }
 
-    pub(super) fn expr_usize(&mut self, sp: Span, value: usize) -> hir::Expr<'hir> {
-        self.expr_uint(sp, ast::UintTy::Usize, value as u128)
-    }
-
-    pub(super) fn expr_u32(&mut self, sp: Span, value: u32) -> hir::Expr<'hir> {
-        self.expr_uint(sp, ast::UintTy::U32, value as u128)
-    }
-
-    pub(super) fn expr_u16(&mut self, sp: Span, value: u16) -> hir::Expr<'hir> {
-        self.expr_uint(sp, ast::UintTy::U16, value as u128)
-    }
-
-    pub(super) fn expr_str(&mut self, sp: Span, value: Symbol) -> hir::Expr<'hir> {
+    pub(super) fn expr_byte_str(&mut self, sp: Span, value: ByteSymbol) -> hir::Expr<'hir> {
         let lit = hir::Lit {
             span: self.lower_span(sp),
-            node: ast::LitKind::Str(value, ast::StrStyle::Cooked),
+            node: ast::LitKind::ByteStr(value, ast::StrStyle::Cooked),
         };
         self.expr(sp, hir::ExprKind::Lit(lit))
     }
@@ -2256,9 +2254,12 @@ impl<'hir> LoweringContext<'_, 'hir> {
         self.expr(span, expr_path)
     }
 
-    fn expr_unsafe(&mut self, expr: &'hir hir::Expr<'hir>) -> hir::Expr<'hir> {
+    pub(super) fn expr_unsafe(
+        &mut self,
+        span: Span,
+        expr: &'hir hir::Expr<'hir>,
+    ) -> hir::Expr<'hir> {
         let hir_id = self.next_id();
-        let span = expr.span;
         self.expr(
             span,
             hir::ExprKind::Block(
@@ -2296,15 +2297,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
         self.arena.alloc(self.expr_block(b))
     }
 
-    pub(super) fn expr_array_ref(
-        &mut self,
-        span: Span,
-        elements: &'hir [hir::Expr<'hir>],
-    ) -> hir::Expr<'hir> {
-        let array = self.arena.alloc(self.expr(span, hir::ExprKind::Array(elements)));
-        self.expr_ref(span, array)
-    }
-
     pub(super) fn expr_ref(&mut self, span: Span, expr: &'hir hir::Expr<'hir>) -> hir::Expr<'hir> {
         self.expr(span, hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Not, expr))
     }