[ty] extend special-cased numbers diagnostic to invalid-argument-type errors

crates/ty_python_semantic/resources/mdtest/diagnostics/invalid_argument_type.md

@@ -244,3 +244,16 @@ def f[T: Foo](x: T) -> T:
     needs_a_foo(x)  # error: [invalid-argument-type]
     return x
 ```
+
+## Numbers special case
+
+```py
+from numbers import Number
+
+def f(x: Number): ...
+
+f(5)  # error: [invalid-argument-type] "Argument to function `f` is incorrect: Expected `Number`, found `Literal[5]`"
+
+def g(x: float):
+    f(x)  # error: [invalid-argument-type] "Argument to function `f` is incorrect: Expected `Number`, found `int | float`"
+```

crates/ty_python_semantic/resources/mdtest/snapshots/invalid_argument_typ…_-_Invalid_argument_typ…_-_Numbers_special_case_(6d84dc3231c49ace).snap

@@ -0,0 +1,77 @@
+---
+source: crates/ty_test/src/lib.rs
+expression: snapshot
+---
+
+---
+mdtest name: invalid_argument_type.md - Invalid argument type diagnostics - Numbers special case
+mdtest path: crates/ty_python_semantic/resources/mdtest/diagnostics/invalid_argument_type.md
+---
+
+# Python source files
+
+## mdtest_snippet.py
+
+```
+1 | from numbers import Number
+2 | 
+3 | def f(x: Number): ...
+4 | 
+5 | f(5)  # error: [invalid-argument-type] "Argument to function `f` is incorrect: Expected `Number`, found `Literal[5]`"
+6 | 
+7 | def g(x: float):
+8 |     f(x)  # error: [invalid-argument-type] "Argument to function `f` is incorrect: Expected `Number`, found `int | float`"
+```
+
+# Diagnostics
+
+```
+error[invalid-argument-type]: Argument to function `f` is incorrect
+ --> src/mdtest_snippet.py:5:3
+  |
+3 | def f(x: Number): ...
+4 |
+5 | f(5)  # error: [invalid-argument-type] "Argument to function `f` is incorrect: Expected `Number`, found `Literal[5]`"
+  |   ^ Expected `Number`, found `Literal[5]`
+6 |
+7 | def g(x: float):
+  |
+info: Function defined here
+ --> src/mdtest_snippet.py:3:5
+  |
+1 | from numbers import Number
+2 |
+3 | def f(x: Number): ...
+  |     ^ --------- Parameter declared here
+4 |
+5 | f(5)  # error: [invalid-argument-type] "Argument to function `f` is incorrect: Expected `Number`, found `Literal[5]`"
+  |
+info: Types from the `numbers` module aren't supported for static type checking
+help: Consider using a protocol instead, such as `typing.SupportsFloat`
+info: rule `invalid-argument-type` is enabled by default
+
+```
+
+```
+error[invalid-argument-type]: Argument to function `f` is incorrect
+ --> src/mdtest_snippet.py:8:7
+  |
+7 | def g(x: float):
+8 |     f(x)  # error: [invalid-argument-type] "Argument to function `f` is incorrect: Expected `Number`, found `int | float`"
+  |       ^ Expected `Number`, found `int | float`
+  |
+info: Function defined here
+ --> src/mdtest_snippet.py:3:5
+  |
+1 | from numbers import Number
+2 |
+3 | def f(x: Number): ...
+  |     ^ --------- Parameter declared here
+4 |
+5 | f(5)  # error: [invalid-argument-type] "Argument to function `f` is incorrect: Expected `Number`, found `Literal[5]`"
+  |
+info: Types from the `numbers` module aren't supported for static type checking
+help: Consider using a protocol instead, such as `typing.SupportsFloat`
+info: rule `invalid-argument-type` is enabled by default
+
+```

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

@@ -30,6 +30,7 @@ use crate::types::diagnostic::{
     CALL_NON_CALLABLE, CALL_TOP_CALLABLE, CONFLICTING_ARGUMENT_FORMS, INVALID_ARGUMENT_TYPE,
     INVALID_DATACLASS, MISSING_ARGUMENT, NO_MATCHING_OVERLOAD, PARAMETER_ALREADY_ASSIGNED,
     POSITIONAL_ONLY_PARAMETER_AS_KWARG, TOO_MANY_POSITIONAL_ARGUMENTS, UNKNOWN_ARGUMENT,
+    note_numbers_module_not_supported,
 };
 use crate::types::enums::is_enum_class;
 use crate::types::function::{
@@ -4515,6 +4516,21 @@ impl<'db> BindingError<'db> {
                 if let Some(union_diag) = union_diag {
                     union_diag.add_union_context(context.db(), &mut diag);
                 }
+
+                // If the type comes from first-party code, the user may have some control over
+                // the parameter annotation; provide additional context to help them fix it.
+                if callable_ty
+                    .definition(context.db())
+                    .and_then(|definition| definition.file(context.db()))
+                    .is_some_and(|file| context.db().should_check_file(file))
+                {
+                    note_numbers_module_not_supported(
+                        context.db(),
+                        &mut diag,
+                        *expected_ty,
+                        *provided_ty,
+                    );
+                }
             }
 
             Self::InvalidKeyType {

crates/ty_python_semantic/src/types/definition.rs

@@ -1,6 +1,6 @@
 use crate::Db;
 use crate::semantic_index::definition::Definition;
-use ruff_db::files::FileRange;
+use ruff_db::files::{File, FileRange};
 use ruff_db::parsed::parsed_module;
 use ruff_db::source::source_text;
 use ruff_text_size::{TextLen, TextRange};
@@ -56,4 +56,17 @@ impl TypeDefinition<'_> {
             }
         }
     }
+
+    pub(super) fn file(&self, db: &dyn Db) -> Option<File> {
+        match self {
+            Self::Module(module) => module.file(db),
+            Self::StaticClass(definition)
+            | Self::DynamicClass(definition)
+            | Self::Function(definition)
+            | Self::TypeVar(definition)
+            | Self::TypeAlias(definition)
+            | Self::SpecialForm(definition)
+            | Self::NewType(definition) => Some(definition.file(db)),
+        }
+    }
 }

crates/ty_python_semantic/src/types/diagnostic.rs

@@ -31,7 +31,9 @@ use crate::types::{
     ProtocolInstanceType, SpecialFormType, SubclassOfInner, Type, TypeContext, binding_type,
     protocol_class::ProtocolClass,
 };
-use crate::types::{DataclassFlags, KnownInstanceType, MemberLookupPolicy, TypeVarInstance};
+use crate::types::{
+    DataclassFlags, KnownInstanceType, MemberLookupPolicy, TypeVarInstance, UnionType,
+};
 use crate::{Db, DisplaySettings, FxIndexMap, Program, declare_lint};
 use itertools::Itertools;
 use ruff_db::{
@@ -2937,6 +2939,35 @@ fn report_invalid_assignment_with_message<'db, 'ctx: 'db, T: Ranged>(
     Some(diag)
 }
 
+pub(super) fn note_numbers_module_not_supported<'db>(
+    db: &'db dyn Db,
+    diag: &mut Diagnostic,
+    target_ty: Type<'db>,
+    value_ty: Type<'db>,
+) {
+    const BUILTIN_NUMBERS: [KnownClass; 3] =
+        [KnownClass::Int, KnownClass::Float, KnownClass::Complex];
+
+    if let Type::NominalInstance(target_instance) = target_ty {
+        let file = target_instance.class(db).class_literal(db).file(db);
+        if let Some(module) = file_to_module(db, file)
+            && module.is_known(db, KnownModule::Numbers)
+        {
+            let is_numeric = value_ty.is_subtype_of(
+                db,
+                UnionType::from_elements(db, BUILTIN_NUMBERS.iter().map(|cls| cls.to_instance(db))),
+            );
+
+            if is_numeric {
+                diag.info(
+                    "Types from the `numbers` module aren't supported for static type checking",
+                );
+                diag.help("Consider using a protocol instead, such as `typing.SupportsFloat`");
+            }
+        }
+    }
+}
+
 pub(super) fn report_invalid_assignment<'db>(
     context: &InferContext<'db, '_>,
     target_node: AnyNodeRef,
@@ -3020,24 +3051,7 @@ pub(super) fn report_invalid_assignment<'db>(
     }
 
     // special case message
-    if let Type::NominalInstance(target_instance) = target_ty {
-        let db = context.db();
-        let file = target_instance.class(db).class_literal(db).file(db);
-        if let Some(module) = file_to_module(db, file)
-            && module.is_known(db, KnownModule::Numbers)
-        {
-            let is_numeric = [KnownClass::Int, KnownClass::Float, KnownClass::Complex]
-                .iter()
-                .any(|numeric| value_ty.is_subtype_of(db, numeric.to_instance(db)));
-
-            if is_numeric {
-                diag.info(
-                    "Types from the `numbers` module aren't supported for static type checking",
-                );
-                diag.help("Consider using a protocol instead, such as `typing.SupportsFloat`");
-            }
-        }
-    }
+    note_numbers_module_not_supported(context.db(), &mut diag, target_ty, value_ty);
 }
 
 pub(super) fn report_invalid_attribute_assignment(