make scope always the last parameter

Author: AlexWaygood

crates/red_knot_python_semantic/src/symbol.rs

@@ -165,8 +165,8 @@ pub(crate) type LookupResult<'db> = Result<TypeAndQualifiers<'db>, LookupError<'
 /// `scope`.
 pub(crate) fn symbol<'db>(
     db: &'db dyn Db,
-    scope: ScopeId<'db>,
     name: &str,
+    scope: ScopeId<'db>,
 ) -> SymbolAndQualifiers<'db> {
     symbol_impl(db, scope, name, RequiresExplicitReExport::No)
 }
@@ -175,8 +175,8 @@ pub(crate) fn symbol<'db>(
 /// `scope`.
 pub(crate) fn class_symbol<'db>(
     db: &'db dyn Db,
-    scope: ScopeId<'db>,
     name: &str,
+    scope: ScopeId<'db>,
 ) -> SymbolAndQualifiers<'db> {
     symbol_table(db, scope)
         .symbol_id_by_name(name)
@@ -356,8 +356,8 @@ fn core_module_scope(db: &dyn Db, core_module: KnownModule) -> Option<ScopeId<'_
 /// The type will be a union if there are multiple bindings with different types.
 pub(super) fn symbol_from_bindings<'db>(
     db: &'db dyn Db,
-    scope: ScopeId<'db>,
     bindings_with_constraints: BindingWithConstraintsIterator<'_, 'db>,
+    scope: ScopeId<'db>,
 ) -> Symbol<'db> {
     symbol_from_bindings_impl(
         db,

crates/red_knot_python_semantic/src/types/class.rs

@@ -401,8 +401,7 @@ impl<'db> Class<'db> {
     /// directly. Use [`Class::class_member`] if you require a method that will
     /// traverse through the MRO until it finds the member.
     pub(super) fn own_class_member(self, db: &'db dyn Db, name: &str) -> SymbolAndQualifiers<'db> {
-        let body_scope = self.body_scope(db);
-        class_symbol(db, body_scope, name)
+        class_symbol(db, name, self.body_scope(db))
     }
 
     /// Returns the `name` attribute of an instance of this class.
@@ -469,8 +468,8 @@ impl<'db> Class<'db> {
     /// "implicitly" defined in a method of the class that corresponds to `class_body_scope`.
     fn implicit_instance_attribute(
         db: &'db dyn Db,
-        class_body_scope: ScopeId<'db>,
         name: &str,
+        class_body_scope: ScopeId<'db>,
     ) -> Option<Type<'db>> {
         // If we do not see any declarations of an attribute, neither in the class body nor in
         // any method, we build a union of `Unknown` with the inferred types of all bindings of
@@ -571,14 +570,14 @@ impl<'db> Class<'db> {
                     // The attribute is declared in the class body.
 
                     let bindings = use_def.public_bindings(symbol_id);
-                    let inferred = symbol_from_bindings(db, body_scope, bindings);
+                    let inferred = symbol_from_bindings(db, bindings, body_scope);
                     let has_binding = !inferred.is_unbound();
 
                     if has_binding {
                         // The attribute is declared and bound in the class body.
 
                         if let Some(implicit_ty) =
-                            Self::implicit_instance_attribute(db, body_scope, name)
+                            Self::implicit_instance_attribute(db, name, body_scope)
                         {
                             if declaredness == Boundness::Bound {
                                 // If a symbol is definitely declared, and we see
@@ -612,7 +611,7 @@ impl<'db> Class<'db> {
                             declared.with_qualifiers(qualifiers)
                         } else {
                             if let Some(implicit_ty) =
-                                Self::implicit_instance_attribute(db, body_scope, name)
+                                Self::implicit_instance_attribute(db, name, body_scope)
                             {
                                 Symbol::Type(
                                     UnionType::from_elements(db, [declared_ty, implicit_ty]),
@@ -633,7 +632,7 @@ impl<'db> Class<'db> {
                     // The attribute is not *declared* in the class body. It could still be declared/bound
                     // in a method.
 
-                    Self::implicit_instance_attribute(db, body_scope, name)
+                    Self::implicit_instance_attribute(db, name, body_scope)
                         .map_or(Symbol::Unbound, Symbol::bound)
                         .into()
                 }
@@ -646,7 +645,7 @@ impl<'db> Class<'db> {
             // This attribute is neither declared nor bound in the class body.
             // It could still be implicitly defined in a method.
 
-            Self::implicit_instance_attribute(db, body_scope, name)
+            Self::implicit_instance_attribute(db, name, body_scope)
                 .map_or(Symbol::Unbound, Symbol::bound)
                 .into()
         }

crates/red_knot_python_semantic/src/types/infer.rs

@@ -1058,7 +1058,7 @@ impl<'db> TypeInferenceBuilder<'db> {
         let use_def = self.index.use_def_map(declaration.file_scope(self.db()));
         let prior_bindings = use_def.bindings_at_declaration(declaration);
         // unbound_ty is Never because for this check we don't care about unbound
-        let inferred_ty = symbol_from_bindings(self.db(), self.scope(), prior_bindings)
+        let inferred_ty = symbol_from_bindings(self.db(), prior_bindings, self.scope())
             .ignore_possibly_unbound()
             .unwrap_or(Type::Never);
         let ty = if inferred_ty.is_assignable_to(self.db(), ty.inner_type()) {
@@ -4181,7 +4181,7 @@ impl<'db> TypeInferenceBuilder<'db> {
         // If we're inferring types of deferred expressions, always treat them as public symbols
         let (local_scope_symbol, report_unresolved_usage) = if self.is_deferred() {
             let symbol = if let Some(symbol_id) = symbol_table.symbol_id_by_name(symbol_name) {
-                symbol_from_bindings(db, self.scope(), use_def.public_bindings(symbol_id))
+                symbol_from_bindings(db, use_def.public_bindings(symbol_id), self.scope())
             } else {
                 assert!(
                     self.deferred_state.in_string_annotation(),
@@ -4193,7 +4193,7 @@ impl<'db> TypeInferenceBuilder<'db> {
             (symbol, true)
         } else {
             let use_id = name_node.scoped_use_id(db, scope);
-            let symbol = symbol_from_bindings(db, self.scope(), use_def.bindings_at_use(use_id));
+            let symbol = symbol_from_bindings(db, use_def.bindings_at_use(use_id), self.scope());
             let report_unresolved_usage = use_def.is_symbol_use_reachable(db, use_id);
             (symbol, report_unresolved_usage)
         };
@@ -4258,7 +4258,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                         file_scope_id,
                     ) {
                         EagerBindingsResult::Found(bindings) => {
-                            return symbol_from_bindings(db, self.scope(), bindings).into();
+                            return symbol_from_bindings(db, bindings, self.scope()).into();
                         }
                         // There are no visible bindings here.
                         // Don't fall back to non-eager symbol resolution.
@@ -4280,7 +4280,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     // runtime, it is the scope that creates the cell for our closure.) If the name
                     // isn't bound in that scope, we should get an unbound name, not continue
                     // falling back to other scopes / globals / builtins.
-                    return symbol(db, enclosing_scope_id, symbol_name);
+                    return symbol(db, symbol_name, enclosing_scope_id);
                 }
             }
 
@@ -4299,7 +4299,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                             file_scope_id,
                         ) {
                             EagerBindingsResult::Found(bindings) => {
-                                return symbol_from_bindings(db, self.scope(), bindings).into();
+                                return symbol_from_bindings(db, bindings, self.scope()).into();
                             }
                             // There are no visible bindings here.
                             EagerBindingsResult::NotFound => {
@@ -7455,7 +7455,7 @@ mod tests {
             assert_eq!(scope.name(db), *expected_scope_name);
         }
 
-        symbol(db, scope, symbol_name).symbol
+        symbol(db, symbol_name, scope).symbol
     }
 
     #[track_caller]