Auto merge of #144934 - samueltardieu:rollup-25jvb9g, r=samueltardieu

Rollup of 17 pull requests

Successful merges:

 - rust-lang/rust#144467 (rustdoc template font links only emit `crossorigin` when needed)
 - rust-lang/rust#144548 (Rehome 21 `tests/ui/issues/` tests to other subdirectories under `tests/ui/`)
 - rust-lang/rust#144741 (fix: Error on illegal `[const]`s inside blocks within legal positions)
 - rust-lang/rust#144776 (`Printer` cleanups)
 - rust-lang/rust#144779 (Implement debugging output of the bootstrap Step graph into a DOT file)
 - rust-lang/rust#144813 (Add a tidy check to prevent adding UI tests directly under `tests/ui/`)
 - rust-lang/rust#144817 (Properly reject tail calls to `&FnPtr` or `&FnDef`)
 - rust-lang/rust#144852 (Rename `rust_panic_without_hook` to `resume_unwind` )
 - rust-lang/rust#144866 (Remove `SHOULD_EMIT_LINTS` in favor of `should_emit`)
 - rust-lang/rust#144867 (Use `as_array` in PartialEq for arrays)
 - rust-lang/rust#144872 (Document Poisoning in `LazyCell` and `LazyLock`)
 - rust-lang/rust#144877 (coverage: Various small cleanups)
 - rust-lang/rust#144887 (`rust-analyzer` subtree update)
 - rust-lang/rust#144890 (Add `InterpCx::project_fields`)
 - rust-lang/rust#144894 (Delete `tests/ui/threads-sendsync/tcp-stress.rs`)
 - rust-lang/rust#144905 (rustc-dev-guide subtree update)
 - rust-lang/rust#144920 (Dont print arg span in MIR dump for tail call)

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

Author: bors

.github/workflows/rustc-pull.yml

@@ -11,10 +11,11 @@ jobs:
     if: github.repository == 'rust-lang/rust-analyzer'
     uses: rust-lang/josh-sync/.github/workflows/rustc-pull.yml@main
     with:
+      github-app-id: ${{ vars.APP_CLIENT_ID }}
       zulip-stream-id: 185405
       zulip-bot-email:  "[email protected]"
       pr-base-branch: master
       branch-name: rustc-pull
     secrets:
       zulip-api-token: ${{ secrets.ZULIP_API_TOKEN }}
-      token: ${{ secrets.GITHUB_TOKEN }}
+      github-app-secret: ${{ secrets.APP_PRIVATE_KEY }}

Cargo.lock

@@ -206,6 +206,7 @@ impl EditionedFileId {
 
 #[salsa_macros::input(debug)]
 pub struct FileText {
+    #[returns(ref)]
     pub text: Arc<str>,
     pub file_id: vfs::FileId,
 }
@@ -357,7 +358,7 @@ fn parse(db: &dyn RootQueryDb, file_id: EditionedFileId) -> Parse<ast::SourceFil
     let _p = tracing::info_span!("parse", ?file_id).entered();
     let (file_id, edition) = file_id.unpack(db.as_dyn_database());
     let text = db.file_text(file_id).text(db);
-    ast::SourceFile::parse(&text, edition)
+    ast::SourceFile::parse(text, edition)
 }
 
 fn parse_errors(db: &dyn RootQueryDb, file_id: EditionedFileId) -> Option<&[SyntaxError]> {

crates/base-db/src/lib.rs

@@ -134,10 +134,10 @@ fn next_cfg_expr<S: Copy>(it: &mut tt::iter::TtIter<'_, S>) -> Option<CfgExpr> {
     };
 
     // Eat comma separator
-    if let Some(TtElement::Leaf(tt::Leaf::Punct(punct))) = it.peek() {
-        if punct.char == ',' {
-            it.next();
-        }
+    if let Some(TtElement::Leaf(tt::Leaf::Punct(punct))) = it.peek()
+        && punct.char == ','
+    {
+        it.next();
     }
     Some(ret)
 }

crates/cfg/src/cfg_expr.rs

@@ -377,10 +377,10 @@ fn parse_repr_tt(tt: &crate::tt::TopSubtree) -> Option<ReprOptions> {
                 let mut align = None;
                 if let Some(TtElement::Subtree(_, mut tt_iter)) = tts.peek() {
                     tts.next();
-                    if let Some(TtElement::Leaf(tt::Leaf::Literal(lit))) = tt_iter.next() {
-                        if let Ok(a) = lit.symbol.as_str().parse() {
-                            align = Align::from_bytes(a).ok();
-                        }
+                    if let Some(TtElement::Leaf(tt::Leaf::Literal(lit))) = tt_iter.next()
+                        && let Ok(a) = lit.symbol.as_str().parse()
+                    {
+                        align = Align::from_bytes(a).ok();
                     }
                 }
                 ReprOptions { align, ..Default::default() }

crates/hir-def/src/attr.rs

@@ -1487,13 +1487,13 @@ impl ExprCollector<'_> {
             ast::Expr::UnderscoreExpr(_) => self.alloc_pat_from_expr(Pat::Wild, syntax_ptr),
             ast::Expr::ParenExpr(e) => {
                 // We special-case `(..)` for consistency with patterns.
-                if let Some(ast::Expr::RangeExpr(range)) = e.expr() {
-                    if range.is_range_full() {
-                        return Some(self.alloc_pat_from_expr(
-                            Pat::Tuple { args: Box::default(), ellipsis: Some(0) },
-                            syntax_ptr,
-                        ));
-                    }
+                if let Some(ast::Expr::RangeExpr(range)) = e.expr()
+                    && range.is_range_full()
+                {
+                    return Some(self.alloc_pat_from_expr(
+                        Pat::Tuple { args: Box::default(), ellipsis: Some(0) },
+                        syntax_ptr,
+                    ));
                 }
                 return e.expr().and_then(|expr| self.maybe_collect_expr_as_pat(&expr));
             }
@@ -2569,19 +2569,18 @@ impl ExprCollector<'_> {
                     }
                 }
                 RibKind::MacroDef(macro_id) => {
-                    if let Some((parent_ctx, label_macro_id)) = hygiene_info {
-                        if label_macro_id == **macro_id {
-                            // A macro is allowed to refer to labels from before its declaration.
-                            // Therefore, if we got to the rib of its declaration, give up its hygiene
-                            // and use its parent expansion.
-
-                            hygiene_id =
-                                HygieneId::new(parent_ctx.opaque_and_semitransparent(self.db));
-                            hygiene_info = parent_ctx.outer_expn(self.db).map(|expansion| {
-                                let expansion = self.db.lookup_intern_macro_call(expansion.into());
-                                (parent_ctx.parent(self.db), expansion.def)
-                            });
-                        }
+                    if let Some((parent_ctx, label_macro_id)) = hygiene_info
+                        && label_macro_id == **macro_id
+                    {
+                        // A macro is allowed to refer to labels from before its declaration.
+                        // Therefore, if we got to the rib of its declaration, give up its hygiene
+                        // and use its parent expansion.
+
+                        hygiene_id = HygieneId::new(parent_ctx.opaque_and_semitransparent(self.db));
+                        hygiene_info = parent_ctx.outer_expn(self.db).map(|expansion| {
+                            let expansion = self.db.lookup_intern_macro_call(expansion.into());
+                            (parent_ctx.parent(self.db), expansion.def)
+                        });
                     }
                 }
                 _ => {}

crates/hir-def/src/expr_store/lower.rs

@@ -259,10 +259,10 @@ impl ExprCollector<'_> {
                                     }
                                 };
 
-                                if let Some(operand_idx) = operand_idx {
-                                    if let Some(position_span) = to_span(arg.position_span) {
-                                        mappings.push((position_span, operand_idx));
-                                    }
+                                if let Some(operand_idx) = operand_idx
+                                    && let Some(position_span) = to_span(arg.position_span)
+                                {
+                                    mappings.push((position_span, operand_idx));
                                 }
                             }
                         }

crates/hir-def/src/expr_store/lower/asm.rs

@@ -211,16 +211,17 @@ pub(super) fn lower_path(
     // Basically, even in rustc it is quite hacky:
     // https://github.com/rust-lang/rust/blob/614f273e9388ddd7804d5cbc80b8865068a3744e/src/librustc_resolve/macros.rs#L456
     // We follow what it did anyway :)
-    if segments.len() == 1 && kind == PathKind::Plain {
-        if let Some(_macro_call) = path.syntax().parent().and_then(ast::MacroCall::cast) {
-            let syn_ctxt = collector.expander.ctx_for_range(path.segment()?.syntax().text_range());
-            if let Some(macro_call_id) = syn_ctxt.outer_expn(collector.db) {
-                if collector.db.lookup_intern_macro_call(macro_call_id.into()).def.local_inner {
-                    kind = match resolve_crate_root(collector.db, syn_ctxt) {
-                        Some(crate_root) => PathKind::DollarCrate(crate_root),
-                        None => PathKind::Crate,
-                    }
-                }
+    if segments.len() == 1
+        && kind == PathKind::Plain
+        && let Some(_macro_call) = path.syntax().parent().and_then(ast::MacroCall::cast)
+    {
+        let syn_ctxt = collector.expander.ctx_for_range(path.segment()?.syntax().text_range());
+        if let Some(macro_call_id) = syn_ctxt.outer_expn(collector.db)
+            && collector.db.lookup_intern_macro_call(macro_call_id.into()).def.local_inner
+        {
+            kind = match resolve_crate_root(collector.db, syn_ctxt) {
+                Some(crate_root) => PathKind::DollarCrate(crate_root),
+                None => PathKind::Crate,
             }
         }
     }

crates/hir-def/src/expr_store/lower/path.rs

@@ -900,14 +900,12 @@ impl Printer<'_> {
                         let field_name = arg.name.display(self.db, edition).to_string();
 
                         let mut same_name = false;
-                        if let Pat::Bind { id, subpat: None } = &self.store[arg.pat] {
-                            if let Binding { name, mode: BindingAnnotation::Unannotated, .. } =
+                        if let Pat::Bind { id, subpat: None } = &self.store[arg.pat]
+                            && let Binding { name, mode: BindingAnnotation::Unannotated, .. } =
                                 &self.store.assert_expr_only().bindings[*id]
-                            {
-                                if name.as_str() == field_name {
-                                    same_name = true;
-                                }
-                            }
+                            && name.as_str() == field_name
+                        {
+                            same_name = true;
                         }
 
                         w!(p, "{}", field_name);