Fix clippy warnings (upcoming) (#9282)

# Description

Fixes the clippy warnings we're about to get hit with next time we
upgrade Rust.

The big one was shrinking ShellError and related under 128 bytes.

# User-Facing Changes

Shouldn't notice much difference. In theory, we could see a tiny perf
improvement, but I didn't notice one.

# Tests + Formatting
<!--
Don't forget to add tests that cover your changes.

Make sure you've run and fixed any issues with these commands:

- `cargo fmt --all -- --check` to check standard code formatting (`cargo
fmt --all` applies these changes)
- `cargo clippy --workspace -- -D warnings -D clippy::unwrap_used -A
clippy::needless_collect -A clippy::result_large_err` to check that
you're using the standard code style
- `cargo test --workspace` to check that all tests pass
- `cargo run -- crates/nu-std/tests/run.nu` to run the tests for the
standard library

> **Note**
> from `nushell` you can also use the `toolkit` as follows
> ```bash
> use toolkit.nu # or use an `env_change` hook to activate it
automatically
> toolkit check pr
> ```
-->

# After Submitting
<!-- If your PR had any user-facing changes, update [the
documentation](https://github.com/nushell/nushell.github.io) after the
PR is merged, if necessary. This will help us keep the docs up to date.
-->

crates/nu-cmd-dataframe/src/dataframe/values/nu_dataframe/between_values.rs

@@ -25,9 +25,9 @@ pub(super) fn between_dataframes(
         },
         _ => Err(ShellError::OperatorMismatch {
             op_span: operator.span,
-            lhs_ty: left.get_type(),
+            lhs_ty: left.get_type().to_string(),
             lhs_span: left.span()?,
-            rhs_ty: right.get_type(),
+            rhs_ty: right.get_type().to_string(),
             rhs_span: right.span()?,
         }),
     }
@@ -167,9 +167,9 @@ pub(super) fn compute_between_series(
         },
         _ => Err(ShellError::OperatorMismatch {
             op_span: operator.span,
-            lhs_ty: left.get_type(),
+            lhs_ty: left.get_type().to_string(),
             lhs_span: left.span()?,
-            rhs_ty: right.get_type(),
+            rhs_ty: right.get_type().to_string(),
             rhs_span: right.span()?,
         }),
     }
@@ -210,9 +210,9 @@ pub(super) fn compute_series_single_value(
     if !lhs.is_series() {
         return Err(ShellError::OperatorMismatch {
             op_span: operator.span,
-            lhs_ty: left.get_type(),
+            lhs_ty: left.get_type().to_string(),
             lhs_span: left.span()?,
-            rhs_ty: right.get_type(),
+            rhs_ty: right.get_type().to_string(),
             rhs_span: right.span()?,
         });
     }
@@ -231,9 +231,9 @@ pub(super) fn compute_series_single_value(
             Value::String { val, .. } => add_string_to_series(&lhs, val, lhs_span),
             _ => Err(ShellError::OperatorMismatch {
                 op_span: operator.span,
-                lhs_ty: left.get_type(),
+                lhs_ty: left.get_type().to_string(),
                 lhs_span: left.span()?,
-                rhs_ty: right.get_type(),
+                rhs_ty: right.get_type().to_string(),
                 rhs_span: right.span()?,
             }),
         },
@@ -246,9 +246,9 @@ pub(super) fn compute_series_single_value(
             }
             _ => Err(ShellError::OperatorMismatch {
                 op_span: operator.span,
-                lhs_ty: left.get_type(),
+                lhs_ty: left.get_type().to_string(),
                 lhs_span: left.span()?,
-                rhs_ty: right.get_type(),
+                rhs_ty: right.get_type().to_string(),
                 rhs_span: right.span()?,
             }),
         },
@@ -261,9 +261,9 @@ pub(super) fn compute_series_single_value(
             }
             _ => Err(ShellError::OperatorMismatch {
                 op_span: operator.span,
-                lhs_ty: left.get_type(),
+                lhs_ty: left.get_type().to_string(),
                 lhs_span: left.span()?,
-                rhs_ty: right.get_type(),
+                rhs_ty: right.get_type().to_string(),
                 rhs_span: right.span()?,
             }),
         },
@@ -284,9 +284,9 @@ pub(super) fn compute_series_single_value(
             }
             _ => Err(ShellError::OperatorMismatch {
                 op_span: operator.span,
-                lhs_ty: left.get_type(),
+                lhs_ty: left.get_type().to_string(),
                 lhs_span: left.span()?,
-                rhs_ty: right.get_type(),
+                rhs_ty: right.get_type().to_string(),
                 rhs_span: right.span()?,
             }),
         },
@@ -304,9 +304,9 @@ pub(super) fn compute_series_single_value(
             }
             _ => Err(ShellError::OperatorMismatch {
                 op_span: operator.span,
-                lhs_ty: left.get_type(),
+                lhs_ty: left.get_type().to_string(),
                 lhs_span: left.span()?,
-                rhs_ty: right.get_type(),
+                rhs_ty: right.get_type().to_string(),
                 rhs_span: right.span()?,
             }),
         },
@@ -325,9 +325,9 @@ pub(super) fn compute_series_single_value(
             ),
             _ => Err(ShellError::OperatorMismatch {
                 op_span: operator.span,
-                lhs_ty: left.get_type(),
+                lhs_ty: left.get_type().to_string(),
                 lhs_span: left.span()?,
-                rhs_ty: right.get_type(),
+                rhs_ty: right.get_type().to_string(),
                 rhs_span: right.span()?,
             }),
         },
@@ -341,9 +341,9 @@ pub(super) fn compute_series_single_value(
             }
             _ => Err(ShellError::OperatorMismatch {
                 op_span: operator.span,
-                lhs_ty: left.get_type(),
+                lhs_ty: left.get_type().to_string(),
                 lhs_span: left.span()?,
-                rhs_ty: right.get_type(),
+                rhs_ty: right.get_type().to_string(),
                 rhs_span: right.span()?,
             }),
         },
@@ -357,9 +357,9 @@ pub(super) fn compute_series_single_value(
             }
             _ => Err(ShellError::OperatorMismatch {
                 op_span: operator.span,
-                lhs_ty: left.get_type(),
+                lhs_ty: left.get_type().to_string(),
                 lhs_span: left.span()?,
-                rhs_ty: right.get_type(),
+                rhs_ty: right.get_type().to_string(),
                 rhs_span: right.span()?,
             }),
         },
@@ -373,9 +373,9 @@ pub(super) fn compute_series_single_value(
             }
             _ => Err(ShellError::OperatorMismatch {
                 op_span: operator.span,
-                lhs_ty: left.get_type(),
+                lhs_ty: left.get_type().to_string(),
                 lhs_span: left.span()?,
-                rhs_ty: right.get_type(),
+                rhs_ty: right.get_type().to_string(),
                 rhs_span: right.span()?,
             }),
         },
@@ -389,9 +389,9 @@ pub(super) fn compute_series_single_value(
             }
             _ => Err(ShellError::OperatorMismatch {
                 op_span: operator.span,
-                lhs_ty: left.get_type(),
+                lhs_ty: left.get_type().to_string(),
                 lhs_span: left.span()?,
-                rhs_ty: right.get_type(),
+                rhs_ty: right.get_type().to_string(),
                 rhs_span: right.span()?,
             }),
         },
@@ -400,9 +400,9 @@ pub(super) fn compute_series_single_value(
             Value::String { val, .. } => contains_series_pat(&lhs, val, lhs_span),
             _ => Err(ShellError::OperatorMismatch {
                 op_span: operator.span,
-                lhs_ty: left.get_type(),
+                lhs_ty: left.get_type().to_string(),
                 lhs_span: left.span()?,
-                rhs_ty: right.get_type(),
+                rhs_ty: right.get_type().to_string(),
                 rhs_span: right.span()?,
             }),
         },
@@ -413,9 +413,9 @@ pub(super) fn compute_series_single_value(
             }
             _ => Err(ShellError::OperatorMismatch {
                 op_span: operator.span,
-                lhs_ty: left.get_type(),
+                lhs_ty: left.get_type().to_string(),
                 lhs_span: left.span()?,
-                rhs_ty: right.get_type(),
+                rhs_ty: right.get_type().to_string(),
                 rhs_span: right.span()?,
             }),
         },
@@ -426,17 +426,17 @@ pub(super) fn compute_series_single_value(
             }
             _ => Err(ShellError::OperatorMismatch {
                 op_span: operator.span,
-                lhs_ty: left.get_type(),
+                lhs_ty: left.get_type().to_string(),
                 lhs_span: left.span()?,
-                rhs_ty: right.get_type(),
+                rhs_ty: right.get_type().to_string(),
                 rhs_span: right.span()?,
             }),
         },
         _ => Err(ShellError::OperatorMismatch {
             op_span: operator.span,
-            lhs_ty: left.get_type(),
+            lhs_ty: left.get_type().to_string(),
             lhs_span: left.span()?,
-            rhs_ty: right.get_type(),
+            rhs_ty: right.get_type().to_string(),
             rhs_span: right.span()?,
         }),
     }

crates/nu-cmd-dataframe/src/dataframe/values/nu_expression/custom_value.rs

@@ -126,9 +126,9 @@ fn with_operator(
             .into_value(lhs_span)),
         _ => Err(ShellError::OperatorMismatch {
             op_span,
-            lhs_ty: Type::Custom(left.typetag_name().into()),
+            lhs_ty: Type::Custom(left.typetag_name().into()).to_string(),
             lhs_span,
-            rhs_ty: Type::Custom(right.typetag_name().into()),
+            rhs_ty: Type::Custom(right.typetag_name().into()).to_string(),
             rhs_span,
         }),
     }