Adjust first arg logic accordingly

Author: ilevkivskyi

mypy/messages.py

@@ -3051,6 +3051,8 @@ def [T <: int] f(self, x: int, y: T) -> None
         # TODO: avoid different logic for incremental runs.
         first_arg = get_first_arg(tp)
 
+    if tp.is_type_obj():
+        skip_self = True
     if first_arg and not skip_self:
         if s:
             s = ", " + s

test-data/unit/check-classes.test

@@ -3492,8 +3492,8 @@ c.a # E: "C" has no attribute "a"
 C('', '')
 C('') # E: No overload variant of "C" matches argument type "str" \
       # N: Possible overload variants: \
-      # N:     def C(cls, foo: int) -> C \
-      # N:     def C(cls, x: str, y: str) -> C
+      # N:     def C(foo: int) -> C \
+      # N:     def C(x: str, y: str) -> C
 [builtins fixtures/__new__.pyi]
 
 
@@ -3922,8 +3922,8 @@ u = new(User)
 [out]
 tmp/foo.pyi:17: error: No overload variant of "User" matches argument type "str"
 tmp/foo.pyi:17: note: Possible overload variants:
-tmp/foo.pyi:17: note:     def User(self) -> U
-tmp/foo.pyi:17: note:     def User(self, arg: int) -> U
+tmp/foo.pyi:17: note:     def User() -> U
+tmp/foo.pyi:17: note:     def User(arg: int) -> U
 tmp/foo.pyi:18: error: Too many arguments for "foo" of "User"
 
 [case testTypeUsingTypeCInUpperBound]
@@ -8517,7 +8517,7 @@ class Child(Parent):
         return val
     def bar(self, val: str) -> str:  # E: Signature of "bar" incompatible with supertype "Parent" \
                                      # N:      Superclass: \
-                                     # N:          def bar(self) -> bar \
+                                     # N:          def bar() -> bar \
                                      # N:      Subclass: \
                                      # N:          def bar(self, val: str) -> str
         return val

test-data/unit/check-flags.test

@@ -2483,13 +2483,13 @@ cb(fn)
 x: int = ""  # E: Incompatible types in assignment (expression has type "str", variable has type "int")  [assignment]
 list(1)  # E: No overload variant of "list" matches argument type "int"  [call-overload] \
          # N: Possible overload variants: \
-         # N:     def [T] list(self) -> list[T] \
-         # N:     def [T] list(self, x: Iterable[T]) -> list[T] \
+         # N:     def [T] list() -> list[T] \
+         # N:     def [T] list(x: Iterable[T]) -> list[T] \
          # N: See https://mypy.rtfd.io/en/stable/_refs.html#code-call-overload for more info
 list(2)  # E: No overload variant of "list" matches argument type "int"  [call-overload] \
          # N: Possible overload variants: \
-         # N:     def [T] list(self) -> list[T] \
-         # N:     def [T] list(self, x: Iterable[T]) -> list[T]
+         # N:     def [T] list() -> list[T] \
+         # N:     def [T] list(x: Iterable[T]) -> list[T]
 [builtins fixtures/list.pyi]
 
 [case testNestedGenericInAliasDisallow]

test-data/unit/check-inference.test

@@ -1753,8 +1753,8 @@ def f(blocks: object):
     to_process = []
     to_process = list(blocks) # E: No overload variant of "list" matches argument type "object" \
                               # N: Possible overload variants: \
-                              # N:     def [T] list(self) -> list[T] \
-                              # N:     def [T] list(self, x: Iterable[T]) -> list[T]
+                              # N:     def [T] list() -> list[T] \
+                              # N:     def [T] list(x: Iterable[T]) -> list[T]
 [builtins fixtures/list.pyi]
 
 [case testInferListInitializedToEmptyAndAssigned]

test-data/unit/check-overloading.test

@@ -625,8 +625,8 @@ a = A(a)
 a = A(b)
 a = A(object()) # E: No overload variant of "A" matches argument type "object" \
                 # N: Possible overload variants: \
-                # N:     def A(self, a: A) -> A \
-                # N:     def A(self, b: B) -> A
+                # N:     def A(a: A) -> A \
+                # N:     def A(b: B) -> A
 
 class A:
   @overload

test-data/unit/check-python311.test

@@ -137,8 +137,8 @@ myclass2 = MyClass(float, float)
 reveal_type(myclass2)  # N: Revealed type is "__main__.MyClass[builtins.float, builtins.float]"
 myclass3 = MyClass(float, float, float)  # E: No overload variant of "MyClass" matches argument types "type[float]", "type[float]", "type[float]" \
                                          # N: Possible overload variants: \
-                                         # N:     def [T1, T2] MyClass(self) -> MyClass[None, None] \
-                                         # N:     def [T1, T2] MyClass(self, type[T1], /) -> MyClass[T1, None] \
+                                         # N:     def [T1, T2] MyClass() -> MyClass[None, None] \
+                                         # N:     def [T1, T2] MyClass(type[T1], /) -> MyClass[T1, None] \
                                          # N:     def [T1, T2] MyClass(type[T1], type[T2], /) -> MyClass[T1, T2]
 reveal_type(myclass3)  # N: Revealed type is "Any"
 [builtins fixtures/tuple.pyi]

test-data/unit/check-selftype.test

@@ -767,8 +767,8 @@ class SubP(P[T]):
 
 SubP('no')  # E: No overload variant of "SubP" matches argument type "str" \
             # N: Possible overload variants: \
-            # N:     def [T] SubP(self, use_str: Literal[True]) -> SubP[T] \
-            # N:     def [T] SubP(self, use_str: Literal[False]) -> SubP[T]
+            # N:     def [T] SubP(use_str: Literal[True]) -> SubP[T] \
+            # N:     def [T] SubP(use_str: Literal[False]) -> SubP[T]
 
 # This is a bit unfortunate: we don't have a way to map the overloaded __init__ to subtype.
 x = SubP(use_str=True)  # E: Need type annotation for "x"

test-data/unit/check-serialize.test

@@ -312,8 +312,8 @@ class A:
 [out2]
 tmp/a.py:2: error: No overload variant of "A" matches argument type "object"
 tmp/a.py:2: note: Possible overload variants:
-tmp/a.py:2: note:     def A(self, x: int) -> A
-tmp/a.py:2: note:     def A(self, x: str) -> A
+tmp/a.py:2: note:     def A(x: int) -> A
+tmp/a.py:2: note:     def A(x: str) -> A
 tmp/a.py:7: error: No overload variant of "__init__" of "A" matches argument type "object"
 tmp/a.py:7: note: Possible overload variants:
 tmp/a.py:7: note:     def __init__(self, x: int) -> None

test-data/unit/check-type-aliases.test

@@ -1347,8 +1347,8 @@ reveal_type(D())  # N: Revealed type is "builtins.dict[builtins.str, builtins.in
 reveal_type(D(x=1))  # N: Revealed type is "builtins.dict[builtins.str, builtins.int]"
 reveal_type(D(x="asdf"))  # E: No overload variant of "dict" matches argument type "str" \
                           # N: Possible overload variants: \
-                          # N:     def dict(self, **kwargs: int) -> dict[str, int] \
-                          # N:     def dict(self, arg: Iterable[tuple[str, int]], **kwargs: int) -> dict[str, int] \
+                          # N:     def dict(**kwargs: int) -> dict[str, int] \
+                          # N:     def dict(arg: Iterable[tuple[str, int]], **kwargs: int) -> dict[str, int] \
                           # N: Revealed type is "Any"
 [builtins fixtures/dict.pyi]
 

test-data/unit/fine-grained.test

@@ -7381,8 +7381,8 @@ class C:
 ==
 a.py:2: error: No overload variant of "B" matches argument type "int"
 a.py:2: note: Possible overload variants:
-a.py:2: note:     def B(self, x: str) -> B
-a.py:2: note:     def B(self, x: str, y: int) -> B
+a.py:2: note:     def B(x: str) -> B
+a.py:2: note:     def B(x: str, y: int) -> B
 
 [case testOverloadedToNormalMethodMetaclass]
 import a