Auto merge of #155223 - teor2345:fndef-refactor, r=mati865

Refactor FnDecl and FnSig non-type fields into a new wrapper type





#### Why this Refactor?

This PR is part of an initial cleanup for the [arg splat experiment](rust-lang/rust#153629), but it's a useful refactor by itself.

It refactors the non-type fields of `FnDecl`, `FnSig`, and `FnHeader` into a new packed wrapper types, based on this comment in the `splat` experiment PR:
rust-lang/rust#153697 (comment)

It also refactors some common `FnSig` creation settings into their own methods. I did this instead of creating a struct with defaults.

#### Relationship to `splat` Experiment

I don't think we can use functional struct updates (`..default()`) to create `FnDecl` and `FnSig`, because we need the bit-packing for the `splat` experiment.

Bit-packing will avoid breaking "type is small" assertions for commonly used types when `splat` is added.
This PR packs these types:
- ExternAbi: enum + `unwind` variants (38) -> 6 bits
- ImplicitSelfKind: enum variants (5) -> 3 bits
- lifetime_elision_allowed, safety, c_variadic: bool -> 1 bit

#### Minor Changes

Fixes some typos, and applies rustfmt to clippy files that got skipped somehow.

Author: bors

crates/hir-ty/src/infer/closure.rs

@@ -164,13 +164,7 @@ impl<'db> InferenceContext<'_, 'db> {
                 let coroutine_captures_by_ref_ty = Ty::new_fn_ptr(
                     interner,
                     Binder::bind_with_vars(
-                        interner.mk_fn_sig(
-                            [],
-                            self.types.types.unit,
-                            false,
-                            Safety::Safe,
-                            FnAbi::Rust,
-                        ),
+                        interner.mk_fn_sig_safe_rust_abi([], self.types.types.unit),
                         self.types.coroutine_captures_by_ref_bound_var_kinds,
                     ),
                 );
@@ -484,13 +478,8 @@ impl<'db> InferenceContext<'_, 'db> {
         let ret_param_ty = projection.skip_binder().term.expect_type();
         debug!(?ret_param_ty);
 
-        let sig = projection.rebind(self.interner().mk_fn_sig(
-            input_tys,
-            ret_param_ty,
-            false,
-            Safety::Safe,
-            FnAbi::Rust,
-        ));
+        let sig =
+            projection.rebind(self.interner().mk_fn_sig_safe_rust_abi(input_tys, ret_param_ty));
 
         Some(sig)
     }
@@ -572,13 +561,8 @@ impl<'db> InferenceContext<'_, 'db> {
         // that does not misuse a `FnSig` type, but that can be done separately.
         let return_ty = return_ty.unwrap_or_else(|| self.table.next_ty_var());
 
-        let sig = projection.rebind(self.interner().mk_fn_sig(
-            input_tys,
-            return_ty,
-            false,
-            Safety::Safe,
-            FnAbi::Rust,
-        ));
+        let sig =
+            projection.rebind(self.interner().mk_fn_sig_safe_rust_abi(input_tys, return_ty));
 
         Some(sig)
     }

crates/hir-ty/src/next_solver/interner.rs

@@ -2358,6 +2358,22 @@ impl<'db> DbInterner<'db> {
             abi,
         }
     }
+
+    /// `mk_fn_sig`, but with a safe Rust ABI, and no C-variadic argument.
+    pub fn mk_fn_sig_safe_rust_abi<I>(self, inputs: I, output: Ty<'db>) -> FnSig<'db>
+    where
+        I: IntoIterator<Item = Ty<'db>>,
+    {
+        FnSig {
+            inputs_and_output: Tys::new_from_iter(
+                self,
+                inputs.into_iter().chain(std::iter::once(output)),
+            ),
+            c_variadic: false,
+            safety: Safety::Safe,
+            abi: FnAbi::Rust,
+        }
+    }
 }
 
 fn predicates_of(db: &dyn HirDatabase, def_id: SolverDefId) -> &GenericPredicates {