fix name load usage also

Author: abhijeetbodas2001

crates/ty_python_semantic/resources/mdtest/dataclass_transform.md

@@ -281,12 +281,10 @@ class D1:
 class D2:
     x: str
 
-# TODO: these should not be errors
-D1("a")  # error: [too-many-positional-arguments]
+D1("a")
 D2("a")
 
-# TODO: these should be invalid-argument-type errors
-D1(1.2)  # error: [too-many-positional-arguments]
+D1(1.2)  # error: [invalid-argument-type]
 D2(1.2)  # error: [invalid-argument-type]
 ```
 

crates/ty_python_semantic/src/types/call/bind.rs

@@ -811,7 +811,7 @@ impl<'db> Bindings<'db> {
                                     .overloads
                                     .iter()
                                     .for_each(&mut handle_dataclass_transformer_params);
-                            };
+                            }
 
                             handle_dataclass_transformer_params(&function_type);
                         }

crates/ty_python_semantic/src/types/infer.rs

@@ -2099,6 +2099,17 @@ impl<'db> TypeInferenceBuilder<'db> {
             }
 
             if let Type::FunctionLiteral(f) = decorator_ty {
+                // We do not yet detect or flag `@dataclass_transformer` applied to more than one
+                // overload, or an overload and the implementation both. Nevertheless, this is not
+                // allowed. We do not try to treat the offenders intelligently -- just use the
+                // params of the last seen usage of `@dataclass_transformer`
+                if let Some(overloaded) = f.to_overloaded(self.db()) {
+                    overloaded.overloads.iter().for_each(|overload| {
+                        if let Some(params) = overload.dataclass_transformer_params(self.db()) {
+                            dataclass_params = Some(params.into());
+                        }
+                    });
+                }
                 if let Some(params) = f.dataclass_transformer_params(self.db()) {
                     dataclass_params = Some(params.into());
                     continue;