Merge branch 'rust-lang:main' into unconstrained-parameter-fix

Author: TomtheCoder2

.github/workflows/post-merge.yml

@@ -6,7 +6,7 @@ name: Post merge analysis
 on:
   push:
     branches:
-      - master
+      - main
 
 jobs:
   analysis:

.mailmap

@@ -139,7 +139,6 @@ Christian Poveda <[email protected]> <[email protected].
 Christian Poveda <[email protected]> <[email protected]>
 Christian Vallentin <[email protected]>
 Christoffer Buchholz <[email protected]>
-Christopher Durham <[email protected]>
 Clark Gaebel <[email protected]> <[email protected]>
 Clement Miao <[email protected]>
 Clément Renault <[email protected]>
@@ -148,6 +147,7 @@ Clinton Ryan <[email protected]>
 Taylor Cramer <[email protected]> <[email protected]>
 ember arlynx <[email protected]> <[email protected]>
 Crazycolorz5 <[email protected]>
+Crystal Durham <[email protected]>
 csmoe <[email protected]>
 Cyryl Płotnicki <[email protected]>
 Damien Schoof <[email protected]>

bootstrap.example.toml

@@ -320,7 +320,7 @@
 #build.npm = "npm"
 
 # Python interpreter to use for various tasks throughout the build, notably
-# rustdoc tests, the lldb python interpreter, and some dist bits and pieces.
+# rustdoc tests, and some dist bits and pieces.
 #
 # Defaults to the Python interpreter used to execute x.py.
 #build.python = "python"

compiler/rustc_ast/src/ast.rs

@@ -648,9 +648,10 @@ impl Pat {
             PatKind::Path(qself, path) => TyKind::Path(qself.clone(), path.clone()),
             PatKind::MacCall(mac) => TyKind::MacCall(mac.clone()),
             // `&mut? P` can be reinterpreted as `&mut? T` where `T` is `P` reparsed as a type.
-            PatKind::Ref(pat, mutbl) => {
-                pat.to_ty().map(|ty| TyKind::Ref(None, MutTy { ty, mutbl: *mutbl }))?
-            }
+            PatKind::Ref(pat, pinned, mutbl) => pat.to_ty().map(|ty| match pinned {
+                Pinnedness::Not => TyKind::Ref(None, MutTy { ty, mutbl: *mutbl }),
+                Pinnedness::Pinned => TyKind::PinnedRef(None, MutTy { ty, mutbl: *mutbl }),
+            })?,
             // A slice/array pattern `[P]` can be reparsed as `[T]`, an unsized array,
             // when `P` can be reparsed as a type `T`.
             PatKind::Slice(pats) if let [pat] = pats.as_slice() => {
@@ -696,7 +697,7 @@ impl Pat {
             // Trivial wrappers over inner patterns.
             PatKind::Box(s)
             | PatKind::Deref(s)
-            | PatKind::Ref(s, _)
+            | PatKind::Ref(s, _, _)
             | PatKind::Paren(s)
             | PatKind::Guard(s, _) => s.walk(it),
 
@@ -717,7 +718,7 @@ impl Pat {
     /// Strip off all reference patterns (`&`, `&mut`) and return the inner pattern.
     pub fn peel_refs(&self) -> &Pat {
         let mut current = self;
-        while let PatKind::Ref(inner, _) = &current.kind {
+        while let PatKind::Ref(inner, _, _) = &current.kind {
             current = inner;
         }
         current
@@ -765,7 +766,9 @@ impl Pat {
             PatKind::Missing => unreachable!(),
             PatKind::Wild => Some("_".to_string()),
             PatKind::Ident(BindingMode::NONE, ident, None) => Some(format!("{ident}")),
-            PatKind::Ref(pat, mutbl) => pat.descr().map(|d| format!("&{}{d}", mutbl.prefix_str())),
+            PatKind::Ref(pat, pinned, mutbl) => {
+                pat.descr().map(|d| format!("&{}{d}", pinned.prefix_str(*mutbl)))
+            }
             _ => None,
         }
     }
@@ -913,7 +916,7 @@ pub enum PatKind {
     Deref(Box<Pat>),
 
     /// A reference pattern (e.g., `&mut (a, b)`).
-    Ref(Box<Pat>, Mutability),
+    Ref(Box<Pat>, Pinnedness, Mutability),
 
     /// A literal, const block or path.
     Expr(Box<Expr>),

compiler/rustc_ast_ir/src/lib.rs

@@ -317,4 +317,15 @@ impl Pinnedness {
     pub fn is_pinned(self) -> bool {
         matches!(self, Self::Pinned)
     }
+
+    /// Returns `""` (empty string), "mut", `"pin mut "` or `"pin const "` depending
+    /// on the pinnedness and mutability.
+    pub fn prefix_str(self, mutbl: Mutability) -> &'static str {
+        match (self, mutbl) {
+            (Pinnedness::Pinned, Mutability::Mut) => "pin mut ",
+            (Pinnedness::Pinned, Mutability::Not) => "pin const ",
+            (Pinnedness::Not, Mutability::Mut) => "mut ",
+            (Pinnedness::Not, Mutability::Not) => "",
+        }
+    }
 }

compiler/rustc_ast_lowering/src/index.rs

@@ -125,9 +125,9 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
 }
 
 impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
-    /// Because we want to track parent items and so forth, enable
-    /// deep walking so that we walk nested items in the context of
-    /// their outer items.
+    // Because we want to track parent items and so forth, enable
+    // deep walking so that we walk nested items in the context of
+    // their outer items.
 
     fn visit_nested_item(&mut self, item: ItemId) {
         debug!("visit_nested_item: {:?}", item);

compiler/rustc_ast_lowering/src/pat.rs

@@ -124,8 +124,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     PatKind::Deref(inner) => {
                         break hir::PatKind::Deref(self.lower_pat(inner));
                     }
-                    PatKind::Ref(inner, mutbl) => {
-                        break hir::PatKind::Ref(self.lower_pat(inner), *mutbl);
+                    PatKind::Ref(inner, pinned, mutbl) => {
+                        break hir::PatKind::Ref(self.lower_pat(inner), *pinned, *mutbl);
                     }
                     PatKind::Range(e1, e2, Spanned { node: end, .. }) => {
                         break hir::PatKind::Range(

compiler/rustc_ast_passes/messages.ftl

@@ -290,7 +290,7 @@ ast_passes_trait_fn_const =
         *[false] {""}
     }
     .make_impl_const_sugg = ... and declare the impl to be const instead
-    .make_trait_const_sugg = ... and declare the trait to be a `#[const_trait]` instead
+    .make_trait_const_sugg = ... and declare the trait to be const instead
 
 ast_passes_trait_object_single_bound = only a single explicit lifetime bound is permitted
 

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -48,7 +48,7 @@ enum SelfSemantic {
 }
 
 enum TraitOrTraitImpl {
-    Trait { span: Span, constness: Const },
+    Trait { vis: Span, constness: Const },
     TraitImpl { constness: Const, polarity: ImplPolarity, trait_ref_span: Span },
 }
 
@@ -109,10 +109,10 @@ impl<'a> AstValidator<'a> {
         self.outer_trait_or_trait_impl = old;
     }
 
-    fn with_in_trait(&mut self, span: Span, constness: Const, f: impl FnOnce(&mut Self)) {
+    fn with_in_trait(&mut self, vis: Span, constness: Const, f: impl FnOnce(&mut Self)) {
         let old = mem::replace(
             &mut self.outer_trait_or_trait_impl,
-            Some(TraitOrTraitImpl::Trait { span, constness }),
+            Some(TraitOrTraitImpl::Trait { vis, constness }),
         );
         f(self);
         self.outer_trait_or_trait_impl = old;
@@ -265,10 +265,12 @@ impl<'a> AstValidator<'a> {
             None
         };
 
+        let map = self.sess.source_map();
+
         let make_trait_const_sugg = if const_trait_impl
-            && let TraitOrTraitImpl::Trait { span, constness: ast::Const::No } = parent
+            && let &TraitOrTraitImpl::Trait { vis, constness: ast::Const::No } = parent
         {
-            Some(span.shrink_to_lo())
+            Some(map.span_extend_while_whitespace(vis).shrink_to_hi())
         } else {
             None
         };
@@ -279,7 +281,7 @@ impl<'a> AstValidator<'a> {
             in_impl: matches!(parent, TraitOrTraitImpl::TraitImpl { .. }),
             const_context_label: parent_constness,
             remove_const_sugg: (
-                self.sess.source_map().span_extend_while_whitespace(span),
+                map.span_extend_while_whitespace(span),
                 match parent_constness {
                     Some(_) => rustc_errors::Applicability::MachineApplicable,
                     None => rustc_errors::Applicability::MaybeIncorrect,
@@ -1165,13 +1167,6 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                 ..
             }) => {
                 self.visit_attrs_vis_ident(&item.attrs, &item.vis, ident);
-                // FIXME(const_trait_impl) remove this
-                let alt_const_trait_span =
-                    attr::find_by_name(&item.attrs, sym::const_trait).map(|attr| attr.span);
-                let constness = match (*constness, alt_const_trait_span) {
-                    (Const::Yes(span), _) | (Const::No, Some(span)) => Const::Yes(span),
-                    (Const::No, None) => Const::No,
-                };
                 if *is_auto == IsAuto::Yes {
                     // Auto traits cannot have generics, super traits nor contain items.
                     self.deny_generic_params(generics, ident.span);
@@ -1188,7 +1183,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                     this.visit_generics(generics);
                     walk_list!(this, visit_param_bound, bounds, BoundKind::SuperTraits)
                 });
-                self.with_in_trait(item.span, constness, |this| {
+                self.with_in_trait(item.vis.span, *constness, |this| {
                     walk_list!(this, visit_assoc_item, items, AssocCtxt::Trait);
                 });
             }

compiler/rustc_ast_passes/src/errors.rs

@@ -56,7 +56,7 @@ pub(crate) struct TraitFnConst {
     pub make_impl_const_sugg: Option<Span>,
     #[suggestion(
         ast_passes_make_trait_const_sugg,
-        code = "#[const_trait]\n",
+        code = "const ",
         applicability = "maybe-incorrect"
     )]
     pub make_trait_const_sugg: Option<Span>,