Auto merge of rust-lang#148241 - matthiaskrgr:rollup-4lsapc2, r=matthiaskrgr

Rollup of 5 pull requests

Successful merges:

 - rust-lang#144444 (Contract variable declarations)
 - rust-lang#147281 (Make diagnostics clearer for binop-related errors in foreign crates)
 - rust-lang#148131 (Skip parameter attribute deduction for MIR with `spread_arg`)
 - rust-lang#148224 (bootstrap: `ensure(doc::Std)` no longer opens a browser)
 - rust-lang#148226 (Bootstrap update)

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

Author: bors

compiler/rustc_ast/src/ast.rs

@@ -3680,6 +3680,9 @@ pub struct TraitImplHeader {
 
 #[derive(Clone, Encodable, Decodable, Debug, Default, Walkable)]
 pub struct FnContract {
+    /// Declarations of variables accessible both in the `requires` and
+    /// `ensures` clauses.
+    pub declarations: ThinVec<Stmt>,
     pub requires: Option<Box<Expr>>,
     pub ensures: Option<Box<Expr>>,
 }

compiler/rustc_ast_lowering/src/block.rs

@@ -27,7 +27,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         hir::Block { hir_id, stmts, expr, rules, span: self.lower_span(b.span), targeted_by_break }
     }
 
-    fn lower_stmts(
+    pub(super) fn lower_stmts(
         &mut self,
         mut ast_stmts: &[Stmt],
     ) -> (&'hir [hir::Stmt<'hir>], Option<&'hir hir::Expr<'hir>>) {

compiler/rustc_ast_lowering/src/contract.rs

@@ -18,6 +18,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         body: impl FnOnce(&mut Self) -> rustc_hir::Expr<'hir>,
         contract: &rustc_ast::FnContract,
     ) -> rustc_hir::Expr<'hir> {
+        // The order in which things are lowered is important! I.e to
+        // refer to variables in contract_decls from postcond/precond,
+        // we must lower it first!
+        let contract_decls = self.lower_stmts(&contract.declarations).0;
+
         match (&contract.requires, &contract.ensures) {
             (Some(req), Some(ens)) => {
                 // Lower the fn contract, which turns:
@@ -27,6 +32,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 // into:
                 //
                 // let __postcond = if contract_checks {
+                //     CONTRACT_DECLARATIONS;
                 //     contract_check_requires(PRECOND);
                 //     Some(|ret_val| POSTCOND)
                 // } else {
@@ -45,8 +51,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 let precond = self.lower_precond(req);
                 let postcond_checker = self.lower_postcond_checker(ens);
 
-                let contract_check =
-                    self.lower_contract_check_with_postcond(Some(precond), postcond_checker);
+                let contract_check = self.lower_contract_check_with_postcond(
+                    contract_decls,
+                    Some(precond),
+                    postcond_checker,
+                );
 
                 let wrapped_body =
                     self.wrap_body_with_contract_check(body, contract_check, postcond_checker.span);
@@ -68,15 +77,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 //     let ret = { body };
                 //
                 //     if contract_checks {
+                //         CONTRACT_DECLARATIONS;
                 //         contract_check_ensures(__postcond, ret)
                 //     } else {
                 //         ret
                 //     }
                 // }
-
                 let postcond_checker = self.lower_postcond_checker(ens);
                 let contract_check =
-                    self.lower_contract_check_with_postcond(None, postcond_checker);
+                    self.lower_contract_check_with_postcond(contract_decls, None, postcond_checker);
 
                 let wrapped_body =
                     self.wrap_body_with_contract_check(body, contract_check, postcond_checker.span);
@@ -91,12 +100,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 //
                 // {
                 //      if contracts_checks {
+                //          CONTRACT_DECLARATIONS;
                 //          contract_requires(PRECOND);
                 //      }
                 //      body
                 // }
                 let precond = self.lower_precond(req);
-                let precond_check = self.lower_contract_check_just_precond(precond);
+                let precond_check = self.lower_contract_check_just_precond(contract_decls, precond);
 
                 let body = self.arena.alloc(body(self));
 
@@ -145,9 +155,12 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
     fn lower_contract_check_just_precond(
         &mut self,
+        contract_decls: &'hir [rustc_hir::Stmt<'hir>],
         precond: rustc_hir::Stmt<'hir>,
     ) -> rustc_hir::Stmt<'hir> {
-        let stmts = self.arena.alloc_from_iter([precond].into_iter());
+        let stmts = self
+            .arena
+            .alloc_from_iter(contract_decls.into_iter().map(|d| *d).chain([precond].into_iter()));
 
         let then_block_stmts = self.block_all(precond.span, stmts, None);
         let then_block = self.arena.alloc(self.expr_block(&then_block_stmts));
@@ -164,10 +177,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
     fn lower_contract_check_with_postcond(
         &mut self,
+        contract_decls: &'hir [rustc_hir::Stmt<'hir>],
         precond: Option<rustc_hir::Stmt<'hir>>,
         postcond_checker: &'hir rustc_hir::Expr<'hir>,
     ) -> &'hir rustc_hir::Expr<'hir> {
-        let stmts = self.arena.alloc_from_iter(precond.into_iter());
+        let stmts = self
+            .arena
+            .alloc_from_iter(contract_decls.into_iter().map(|d| *d).chain(precond.into_iter()));
         let span = match precond {
             Some(precond) => precond.span,
             None => postcond_checker.span,

compiler/rustc_builtin_macros/src/contracts.rs

@@ -17,7 +17,7 @@ impl AttrProcMacro for ExpandRequires {
         annotation: TokenStream,
         annotated: TokenStream,
     ) -> Result<TokenStream, ErrorGuaranteed> {
-        expand_requires_tts(ecx, span, annotation, annotated)
+        expand_contract_clause_tts(ecx, span, annotation, annotated, kw::ContractRequires)
     }
 }
 
@@ -29,7 +29,7 @@ impl AttrProcMacro for ExpandEnsures {
         annotation: TokenStream,
         annotated: TokenStream,
     ) -> Result<TokenStream, ErrorGuaranteed> {
-        expand_ensures_tts(ecx, span, annotation, annotated)
+        expand_contract_clause_tts(ecx, span, annotation, annotated, kw::ContractEnsures)
     }
 }
 
@@ -130,42 +130,17 @@ fn expand_contract_clause(
     Ok(new_tts)
 }
 
-fn expand_requires_tts(
+fn expand_contract_clause_tts(
     ecx: &mut ExtCtxt<'_>,
     attr_span: Span,
     annotation: TokenStream,
     annotated: TokenStream,
+    clause_keyword: rustc_span::Symbol,
 ) -> Result<TokenStream, ErrorGuaranteed> {
     let feature_span = ecx.with_def_site_ctxt(attr_span);
     expand_contract_clause(ecx, attr_span, annotated, |new_tts| {
         new_tts.push_tree(TokenTree::Token(
-            token::Token::from_ast_ident(Ident::new(kw::ContractRequires, feature_span)),
-            Spacing::Joint,
-        ));
-        new_tts.push_tree(TokenTree::Token(
-            token::Token::new(token::TokenKind::OrOr, attr_span),
-            Spacing::Alone,
-        ));
-        new_tts.push_tree(TokenTree::Delimited(
-            DelimSpan::from_single(attr_span),
-            DelimSpacing::new(Spacing::JointHidden, Spacing::JointHidden),
-            token::Delimiter::Brace,
-            annotation,
-        ));
-        Ok(())
-    })
-}
-
-fn expand_ensures_tts(
-    ecx: &mut ExtCtxt<'_>,
-    attr_span: Span,
-    annotation: TokenStream,
-    annotated: TokenStream,
-) -> Result<TokenStream, ErrorGuaranteed> {
-    let feature_span = ecx.with_def_site_ctxt(attr_span);
-    expand_contract_clause(ecx, attr_span, annotated, |new_tts| {
-        new_tts.push_tree(TokenTree::Token(
-            token::Token::from_ast_ident(Ident::new(kw::ContractEnsures, feature_span)),
+            token::Token::from_ast_ident(Ident::new(clause_keyword, feature_span)),
             Spacing::Joint,
         ));
         new_tts.push_tree(TokenTree::Delimited(

compiler/rustc_feature/src/removed.rs

@@ -102,9 +102,9 @@ declare_features! (
     /// Allows deriving traits as per `SmartPointer` specification
     (removed, derive_smart_pointer, "1.84.0", Some(123430), Some("replaced by `CoercePointee`"), 131284),
     /// Tells rustdoc to automatically generate `#[doc(cfg(...))]`.
-    (removed, doc_auto_cfg, "CURRENT_RUSTC_VERSION", Some(43781), Some("merged into `doc_cfg`"), 138907),
+    (removed, doc_auto_cfg, "1.92.0", Some(43781), Some("merged into `doc_cfg`"), 138907),
     /// Allows `#[doc(cfg_hide(...))]`.
-    (removed, doc_cfg_hide, "CURRENT_RUSTC_VERSION", Some(43781), Some("merged into `doc_cfg`"), 138907),
+    (removed, doc_cfg_hide, "1.92.0", Some(43781), Some("merged into `doc_cfg`"), 138907),
     /// Allows using `#[doc(keyword = "...")]`.
     (removed, doc_keyword, "1.58.0", Some(51315),
      Some("merged into `#![feature(rustdoc_internals)]`"), 90420),

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -3046,46 +3046,20 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
 
         foreign_preds.sort_by_key(|pred: &&ty::TraitPredicate<'_>| pred.trait_ref.to_string());
-        let foreign_def_ids = foreign_preds
-            .iter()
-            .filter_map(|pred| match pred.self_ty().kind() {
-                ty::Adt(def, _) => Some(def.did()),
-                _ => None,
-            })
-            .collect::<FxIndexSet<_>>();
-        let mut foreign_spans: MultiSpan = foreign_def_ids
-            .iter()
-            .filter_map(|def_id| {
-                let span = self.tcx.def_span(*def_id);
-                if span.is_dummy() { None } else { Some(span) }
-            })
-            .collect::<Vec<_>>()
-            .into();
-        for pred in &foreign_preds {
-            if let ty::Adt(def, _) = pred.self_ty().kind() {
-                foreign_spans.push_span_label(
-                    self.tcx.def_span(def.did()),
-                    format!("not implement `{}`", pred.trait_ref.print_trait_sugared()),
-                );
+
+        for pred in foreign_preds {
+            let ty = pred.self_ty();
+            let ty::Adt(def, _) = ty.kind() else { continue };
+            let span = self.tcx.def_span(def.did());
+            if span.is_dummy() {
+                continue;
             }
-        }
-        if foreign_spans.primary_span().is_some() {
-            let msg = if let [foreign_pred] = foreign_preds.as_slice() {
-                format!(
-                    "the foreign item type `{}` doesn't implement `{}`",
-                    foreign_pred.self_ty(),
-                    foreign_pred.trait_ref.print_trait_sugared()
-                )
-            } else {
-                format!(
-                    "the foreign item type{} {} implement required trait{} for this \
-                     operation to be valid",
-                    pluralize!(foreign_def_ids.len()),
-                    if foreign_def_ids.len() > 1 { "don't" } else { "doesn't" },
-                    pluralize!(foreign_preds.len()),
-                )
-            };
-            err.span_note(foreign_spans, msg);
+            let mut mspan: MultiSpan = span.into();
+            mspan.push_span_label(span, format!("`{ty}` is defined in another crate"));
+            err.span_note(
+                mspan,
+                format!("`{ty}` does not implement `{}`", pred.trait_ref.print_trait_sugared()),
+            );
         }
 
         let preds: Vec<_> = errors

compiler/rustc_index/src/idx.rs

@@ -135,7 +135,7 @@ impl<I: Idx, T> IntoSliceIdx<I, [T]> for core::range::RangeInclusive<I> {
     }
 }
 
-#[cfg(all(feature = "nightly", not(bootstrap)))]
+#[cfg(feature = "nightly")]
 impl<I: Idx, T> IntoSliceIdx<I, [T]> for core::range::RangeToInclusive<I> {
     type Output = core::range::RangeToInclusive<usize>;
     #[inline]

compiler/rustc_index/src/lib.rs

@@ -1,6 +1,5 @@
 // tidy-alphabetical-start
 #![cfg_attr(all(feature = "nightly", test), feature(stmt_expr_attributes))]
-#![cfg_attr(bootstrap, feature(new_zeroed_alloc))]
 #![cfg_attr(feature = "nightly", allow(internal_features))]
 #![cfg_attr(feature = "nightly", feature(extend_one, step_trait, test))]
 #![cfg_attr(feature = "nightly", feature(new_range_api))]

compiler/rustc_mir_transform/src/deduce_param_attrs.rs

@@ -195,6 +195,11 @@ pub(super) fn deduced_param_attrs<'tcx>(
 
     // Grab the optimized MIR. Analyze it to determine which arguments have been mutated.
     let body: &Body<'tcx> = tcx.optimized_mir(def_id);
+    // Arguments spread at ABI level are currently unsupported.
+    if body.spread_arg.is_some() {
+        return &[];
+    }
+
     let mut deduce = DeduceParamAttrs::new(body);
     deduce.visit_body(body);
     tracing::trace!(?deduce.usage);

compiler/rustc_parse/src/parser/expr.rs

@@ -4036,6 +4036,30 @@ impl<'a> Parser<'a> {
         self.mk_expr(span, ExprKind::Err(guar))
     }
 
+    pub(crate) fn mk_unit_expr(&self, span: Span) -> Box<Expr> {
+        self.mk_expr(span, ExprKind::Tup(Default::default()))
+    }
+
+    pub(crate) fn mk_closure_expr(&self, span: Span, body: Box<Expr>) -> Box<Expr> {
+        self.mk_expr(
+            span,
+            ast::ExprKind::Closure(Box::new(ast::Closure {
+                binder: rustc_ast::ClosureBinder::NotPresent,
+                constness: rustc_ast::Const::No,
+                movability: rustc_ast::Movability::Movable,
+                capture_clause: rustc_ast::CaptureBy::Ref,
+                coroutine_kind: None,
+                fn_decl: Box::new(rustc_ast::FnDecl {
+                    inputs: Default::default(),
+                    output: rustc_ast::FnRetTy::Default(span),
+                }),
+                fn_arg_span: span,
+                fn_decl_span: span,
+                body,
+            })),
+        )
+    }
+
     /// Create expression span ensuring the span of the parent node
     /// is larger than the span of lhs and rhs, including the attributes.
     fn mk_expr_sp(&self, lhs: &Box<Expr>, lhs_span: Span, op_span: Span, rhs_span: Span) -> Span {