Auto merge of #150228 - matthiaskrgr:rollup-ymp54q0, r=matthiaskrgr

Rollup of 11 pull requests

Successful merges:

 - #146377 (Don't strip shebang in expr-ctxt `include!(…)`)
 - #149812 (Add const default for OnceCell and OnceLock)
 - #149882 (miri: add -Zbinary-dep-depinfo to dependency builds)
 - #150009 (Enable llvm-libunwind by default for Hexagon targets)
 - #150035 (fix docustring on fetch_or)
 - #150082 (tests/ui/traits/fmt-pointer-trait.rs: Add HRTB fn pointer case)
 - #150160 (Fix ICE (#149980) for invalid EII in statement position)
 - #150184 (mir_build: Use the same length type for `TestableCase::Slice` and `TestKind::Len`)
 - #150185 ([rustdoc] Add missing close tags in extern crate reexports)
 - #150191 (change non-canonical clone impl to {*self}, fix some doc comments)
 - #150203 (Drop the From derive macro from the v1 prelude)

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

Author: bors

compiler/rustc_builtin_macros/src/eii.rs

@@ -60,12 +60,18 @@ fn eii_(
 ) -> Vec<Annotatable> {
     let eii_attr_span = ecx.with_def_site_ctxt(eii_attr_span);
 
-    let (item, stmt) = if let Annotatable::Item(item) = item {
-        (item, false)
+    let (item, wrap_item): (_, &dyn Fn(_) -> _) = if let Annotatable::Item(item) = item {
+        (item, &Annotatable::Item)
     } else if let Annotatable::Stmt(ref stmt) = item
         && let StmtKind::Item(ref item) = stmt.kind
     {
-        (item.clone(), true)
+        (item.clone(), &|item| {
+            Annotatable::Stmt(Box::new(Stmt {
+                id: DUMMY_NODE_ID,
+                kind: StmtKind::Item(item),
+                span: eii_attr_span,
+            }))
+        })
     } else {
         ecx.dcx().emit_err(EiiSharedMacroExpectedFunction {
             span: eii_attr_span,
@@ -74,23 +80,25 @@ fn eii_(
         return vec![item];
     };
 
-    let orig_item = item.clone();
-
-    let item = *item;
-
-    let ast::Item { attrs, id: _, span: _, vis, kind: ItemKind::Fn(func), tokens: _ } = item else {
+    let ast::Item { attrs, id: _, span: _, vis, kind: ItemKind::Fn(func), tokens: _ } =
+        item.as_ref()
+    else {
         ecx.dcx().emit_err(EiiSharedMacroExpectedFunction {
             span: eii_attr_span,
             name: path_to_string(&meta_item.path),
         });
-        return vec![Annotatable::Item(Box::new(item))];
+        return vec![wrap_item(item)];
     };
+    // only clone what we need
+    let attrs = attrs.clone();
+    let func = (**func).clone();
+    let vis = vis.clone();
 
     let attrs_from_decl =
         filter_attrs_for_multiple_eii_attr(ecx, attrs, eii_attr_span, &meta_item.path);
 
     let Ok(macro_name) = name_for_impl_macro(ecx, &func, &meta_item) else {
-        return vec![Annotatable::Item(orig_item)];
+        return vec![wrap_item(item)];
     };
 
     // span of the declaring item without attributes
@@ -115,7 +123,7 @@ fn eii_(
         ecx,
         eii_attr_span,
         item_span,
-        *func,
+        func,
         vis,
         &attrs_from_decl,
     )));
@@ -128,20 +136,7 @@ fn eii_(
         decl_span,
     )));
 
-    if stmt {
-        return_items
-            .into_iter()
-            .map(|i| {
-                Annotatable::Stmt(Box::new(Stmt {
-                    id: DUMMY_NODE_ID,
-                    kind: StmtKind::Item(i),
-                    span: eii_attr_span,
-                }))
-            })
-            .collect()
-    } else {
-        return_items.into_iter().map(|i| Annotatable::Item(i)).collect()
-    }
+    return_items.into_iter().map(wrap_item).collect()
 }
 
 /// Decide on the name of the macro that can be used to implement the EII.

compiler/rustc_builtin_macros/src/source_util.rs

@@ -144,9 +144,7 @@ pub(crate) fn expand_include<'cx>(
             let mut p = unwrap_or_emit_fatal(new_parser_from_file(
                 self.psess,
                 &self.path,
-                // Don't strip frontmatter for backward compatibility, `---` may be the start of a
-                // manifold negation. FIXME: Ideally, we wouldn't strip shebangs here either.
-                StripTokens::Shebang,
+                StripTokens::Nothing,
                 Some(self.span),
             ));
             let expr = parse_expr(&mut p).ok()?;

compiler/rustc_graphviz/src/lib.rs

@@ -416,7 +416,7 @@ impl<'a> Id<'a> {
 /// it in the generated .dot file. They can also provide more
 /// elaborate (and non-unique) label text that is used in the graphviz
 /// rendered output.
-
+///
 /// The graph instance is responsible for providing the DOT compatible
 /// identifiers for the nodes and (optionally) rendered labels for the nodes and
 /// edges, as well as an identifier for the graph itself.

compiler/rustc_middle/src/ty/context.rs

@@ -2654,7 +2654,7 @@ struct InternedInSet<'tcx, T: ?Sized + PointeeSized>(&'tcx T);
 
 impl<'tcx, T: 'tcx + ?Sized + PointeeSized> Clone for InternedInSet<'tcx, T> {
     fn clone(&self) -> Self {
-        InternedInSet(self.0)
+        *self
     }
 }
 

compiler/rustc_mir_build/src/builder/matches/buckets.rs

@@ -218,7 +218,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 &TestKind::Len { len: test_len, op: BinOp::Eq },
                 &TestableCase::Slice { len, variable_length },
             ) => {
-                match (test_len.cmp(&(len as u64)), variable_length) {
+                match (test_len.cmp(&len), variable_length) {
                     (Ordering::Equal, false) => {
                         // on true, min_len = len = $actual_length,
                         // on false, len != $actual_length
@@ -251,7 +251,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 &TestableCase::Slice { len, variable_length },
             ) => {
                 // the test is `$actual_len >= test_len`
-                match (test_len.cmp(&(len as u64)), variable_length) {
+                match (test_len.cmp(&len), variable_length) {
                     (Ordering::Equal, true) => {
                         // $actual_len >= test_len = pat_len,
                         // so we can match.

compiler/rustc_mir_build/src/builder/matches/match_pair.rs

@@ -256,7 +256,7 @@ impl<'tcx> MatchPairTree<'tcx> {
                     None
                 } else {
                     Some(TestableCase::Slice {
-                        len: prefix.len() + suffix.len(),
+                        len: u64::try_from(prefix.len() + suffix.len()).unwrap(),
                         variable_length: slice.is_some(),
                     })
                 }

compiler/rustc_mir_build/src/builder/matches/mod.rs

@@ -1264,7 +1264,7 @@ enum TestableCase<'tcx> {
     Variant { adt_def: ty::AdtDef<'tcx>, variant_index: VariantIdx },
     Constant { value: ty::Value<'tcx> },
     Range(Arc<PatRange<'tcx>>),
-    Slice { len: usize, variable_length: bool },
+    Slice { len: u64, variable_length: bool },
     Deref { temp: Place<'tcx>, mutability: Mutability },
     Never,
     Or { pats: Box<[FlatPat<'tcx>]> },

compiler/rustc_mir_build/src/builder/matches/test.rs

@@ -47,7 +47,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
             TestableCase::Slice { len, variable_length } => {
                 let op = if variable_length { BinOp::Ge } else { BinOp::Eq };
-                TestKind::Len { len: len as u64, op }
+                TestKind::Len { len, op }
             }
 
             TestableCase::Deref { temp, mutability } => TestKind::Deref { temp, mutability },

compiler/rustc_pattern_analysis/src/lib.rs

@@ -141,7 +141,7 @@ pub struct MatchArm<'p, Cx: PatCx> {
 
 impl<'p, Cx: PatCx> Clone for MatchArm<'p, Cx> {
     fn clone(&self) -> Self {
-        Self { pat: self.pat, has_guard: self.has_guard, arm_data: self.arm_data }
+        *self
     }
 }
 

compiler/rustc_pattern_analysis/src/pat.rs

@@ -174,10 +174,7 @@ pub(crate) enum PatOrWild<'p, Cx: PatCx> {
 
 impl<'p, Cx: PatCx> Clone for PatOrWild<'p, Cx> {
     fn clone(&self) -> Self {
-        match self {
-            PatOrWild::Wild => PatOrWild::Wild,
-            PatOrWild::Pat(pat) => PatOrWild::Pat(pat),
-        }
+        *self
     }
 }