rename error

Author: dcreager

crates/ty_python_semantic/src/types/tuple.rs

@@ -297,18 +297,18 @@ impl<'db> FixedLengthTuple<Type<'db>> {
         &self,
         db: &'db dyn Db,
         new_length: TupleLength,
-    ) -> Result<Tuple<Type<'db>>, TupleUnpackerError> {
+    ) -> Result<Tuple<Type<'db>>, ResizeTupleError> {
         match new_length {
             TupleLength::Fixed(new_length) => match self.len().cmp(&new_length) {
-                Ordering::Less => Err(TupleUnpackerError::TooFewValues),
-                Ordering::Greater => Err(TupleUnpackerError::TooManyValues),
+                Ordering::Less => Err(ResizeTupleError::TooFewValues),
+                Ordering::Greater => Err(ResizeTupleError::TooManyValues),
                 Ordering::Equal => Ok(Tuple::Fixed(self.clone())),
             },
 
             TupleLength::Variable(prefix, suffix) => {
                 // The number of rhs values that will be consumed by the starred target.
                 let Some(variable) = self.len().checked_sub(prefix + suffix) else {
-                    return Err(TupleUnpackerError::TooFewValues);
+                    return Err(ResizeTupleError::TooFewValues);
                 };
 
                 // Extract rhs values into the prefix, then into the starred target, then into the
@@ -600,13 +600,13 @@ impl<'db> VariableLengthTuple<Type<'db>> {
         &self,
         db: &'db dyn Db,
         new_length: TupleLength,
-    ) -> Result<Tuple<Type<'db>>, TupleUnpackerError> {
+    ) -> Result<Tuple<Type<'db>>, ResizeTupleError> {
         match new_length {
             TupleLength::Fixed(new_length) => {
                 // The number of elements that will get their value from our variable-length
                 // portion.
                 let Some(variable_count) = new_length.checked_sub(self.len().minimum()) else {
-                    return Err(TupleUnpackerError::TooManyValues);
+                    return Err(ResizeTupleError::TooManyValues);
                 };
                 Ok(Tuple::Fixed(FixedLengthTuple::from_elements(
                     (self.prefix_elements().copied())
@@ -970,7 +970,7 @@ impl<'db> Tuple<Type<'db>> {
         &self,
         db: &'db dyn Db,
         new_length: TupleLength,
-    ) -> Result<Self, TupleUnpackerError> {
+    ) -> Result<Self, ResizeTupleError> {
         match self {
             Tuple::Fixed(tuple) => tuple.resize(db, new_length),
             Tuple::Variable(tuple) => tuple.resize(db, new_length),
@@ -1194,7 +1194,7 @@ impl<'db> TupleUnpacker<'db> {
     pub(crate) fn unpack_tuple(
         &mut self,
         values: &Tuple<Type<'db>>,
-    ) -> Result<(), TupleUnpackerError> {
+    ) -> Result<(), ResizeTupleError> {
         let values = values.resize(self.db, self.targets.len())?;
         match (&mut self.targets, &values) {
             (Tuple::Fixed(targets), Tuple::Fixed(values)) => {
@@ -1252,7 +1252,7 @@ impl<'db> VariableLengthTuple<UnionBuilder<'db>> {
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub(crate) enum TupleUnpackerError {
+pub(crate) enum ResizeTupleError {
     TooFewValues,
     TooManyValues,
 }

crates/ty_python_semantic/src/types/unpacker.rs

@@ -8,7 +8,7 @@ use ruff_python_ast::{self as ast, AnyNodeRef};
 use crate::Db;
 use crate::semantic_index::ast_ids::{HasScopedExpressionId, ScopedExpressionId};
 use crate::semantic_index::place::ScopeId;
-use crate::types::tuple::{Tuple, TupleLength, TupleUnpacker, TupleUnpackerError};
+use crate::types::tuple::{ResizeTupleError, Tuple, TupleLength, TupleUnpacker};
 use crate::types::{Type, TypeCheckDiagnostics, infer_expression_types};
 use crate::unpack::{UnpackKind, UnpackValue};
 
@@ -159,7 +159,7 @@ impl<'db, 'ast> Unpacker<'db, 'ast> {
                         if let Some(builder) = self.context.report_lint(&INVALID_ASSIGNMENT, target)
                         {
                             match err {
-                                TupleUnpackerError::TooManyValues => {
+                                ResizeTupleError::TooManyValues => {
                                     let mut diag =
                                         builder.into_diagnostic("Too many values to unpack");
                                     diag.set_primary_message(format_args!(
@@ -170,7 +170,7 @@ impl<'db, 'ast> Unpacker<'db, 'ast> {
                                         format_args!("Got {}", tuple.len().display_minimum()),
                                     ));
                                 }
-                                TupleUnpackerError::TooFewValues => {
+                                ResizeTupleError::TooFewValues => {
                                     let mut diag =
                                         builder.into_diagnostic("Not enough values to unpack");
                                     diag.set_primary_message(format_args!(