Consistent names for variables

astral-sh · Jan 20, 2025 · fb64180 · fb64180
1 parent 7b159ab
commit fb64180
Show file tree

Hide file tree

Showing 2 changed files with 6 additions and 6 deletions.
diff --git a/crates/red_knot_python_semantic/src/types.rs b/crates/red_knot_python_semantic/src/types.rs
@@ -4103,9 +4103,9 @@ impl<'db> Class<'db> {
                 }
                 Ok(SymbolAndQualifiers(Symbol::Unbound, qualifiers)) => {
                     let bindings = use_def.public_bindings(symbol);
-                    let inferred_ty = symbol_from_bindings(db, bindings);
+                    let inferred = symbol_from_bindings(db, bindings);
 
-                    match inferred_ty {
+                    match inferred {
                         Symbol::Type(ty, _) => SymbolAndQualifiers(
                             Symbol::Type(
                                 UnionType::from_elements(db, [Type::unknown(), ty]),

diff --git a/crates/red_knot_python_semantic/src/types/infer.rs b/crates/red_knot_python_semantic/src/types/infer.rs
@@ -3311,7 +3311,7 @@ impl<'db> TypeInferenceBuilder<'db> {
         let use_def = self.index.use_def_map(file_scope_id);
 
         // If we're inferring types of deferred expressions, always treat them as public symbols
-        let bindings_ty = if self.is_deferred() {
+        let inferred = if self.is_deferred() {
             if let Some(symbol) = self.index.symbol_table(file_scope_id).symbol_id_by_name(id) {
                 symbol_from_bindings(self.db(), use_def.public_bindings(symbol))
             } else {
@@ -3326,7 +3326,7 @@ impl<'db> TypeInferenceBuilder<'db> {
             symbol_from_bindings(self.db(), use_def.bindings_at_use(use_id))
         };
 
-        if let Symbol::Type(ty, Boundness::Bound) = bindings_ty {
+        if let Symbol::Type(ty, Boundness::Bound) = inferred {
             ty
         } else {
             match self.lookup_name(name) {
@@ -3335,12 +3335,12 @@ impl<'db> TypeInferenceBuilder<'db> {
                         report_possibly_unresolved_reference(&self.context, name);
                     }
 
-                    bindings_ty
+                    inferred
                         .ignore_possibly_unbound()
                         .map(|ty| UnionType::from_elements(self.db(), [ty, looked_up_ty]))
                         .unwrap_or(looked_up_ty)
                 }
-                Symbol::Unbound => match bindings_ty {
+                Symbol::Unbound => match inferred {
                     Symbol::Type(ty, Boundness::PossiblyUnbound) => {
                         report_possibly_unresolved_reference(&self.context, name);
                         ty