rephrase message

Author: elazarg

mypy/checker.py

@@ -742,10 +742,10 @@ def is_implicit_any(t: Type) -> bool:
                 for arg in item.arguments:
                     init = arg.initialization_statement
                     if init:
-                        fmt = 'Incompatible default argument for parameter "{}"'
+                        fmt = 'Incompatible default initializer for argument "{}"'
                         self.check_simple_assignment(
                             self.expr_checker.accept(init.lvalues[0]), init.rvalue, arg,
-                            fmt.format(arg.variable.name()), 'parameter', 'initializer')
+                            fmt.format(arg.variable.name()), 'argument', 'initializer')
 
             # Type check body in a new scope.
             with self.binder.top_frame_context():

test-data/unit/check-functions.test

@@ -388,7 +388,7 @@ class A: pass
 
 [case testDefaultArgumentExpressions2]
 import typing
-def f(x: 'A' = B()) -> None: # E: Incompatible default argument for parameter "x" (initializer has type "B", parameter has type "A")
+def f(x: 'A' = B()) -> None: # E: Incompatible default initializer for argument "x" (initializer has type "B", argument has type "A")
     b = x # type: B      # E: Incompatible types in assignment (expression has type "A", variable has type "B")
     a = x # type: A
 
@@ -398,7 +398,7 @@ class A: pass
 
 [case testDefaultArgumentsWithSubtypes]
 import typing
-def f(x: 'B' = A()) -> None: # E: Incompatible default argument for parameter "x" (initializer has type "A", parameter has type "B")
+def f(x: 'B' = A()) -> None: # E: Incompatible default initializer for argument "x" (initializer has type "A", argument has type "B")
     pass
 def g(x: 'A' = B()) -> None:
     pass
@@ -409,7 +409,7 @@ class B(A): pass
 
 [case testMultipleDefaultArgumentExpressions]
 import typing
-def f(x: 'A' = B(), y: 'B' = B()) -> None: # E: Incompatible default argument for parameter "x" (initializer has type "B", parameter has type "A")
+def f(x: 'A' = B(), y: 'B' = B()) -> None: # E: Incompatible default initializer for argument "x" (initializer has type "B", argument has type "A")
     pass
 def h(x: 'A' = A(), y: 'B' = B()) -> None:
     pass
@@ -420,7 +420,7 @@ class B: pass
 
 [case testMultipleDefaultArgumentExpressions2]
 import typing
-def g(x: 'A' = A(), y: 'B' = A()) -> None: # E: Incompatible default argument for parameter "y" (initializer has type "A", parameter has type "B")
+def g(x: 'A' = A(), y: 'B' = A()) -> None: # E: Incompatible default initializer for argument "y" (initializer has type "A", argument has type "B")
     pass
 
 class A: pass

test-data/unit/check-inference.test

@@ -1119,7 +1119,7 @@ from typing import Callable
 def f(a: Callable[..., None] = lambda *a, **k: None):
     pass
 
-def g(a: Callable[..., None] = lambda *a, **k: 1):  # E: Incompatible default argument for parameter "a" (initializer has type Callable[[VarArg(Any), KwArg(Any)], int], parameter has type Callable[..., None])
+def g(a: Callable[..., None] = lambda *a, **k: 1):  # E: Incompatible default initializer for argument "a" (initializer has type Callable[[VarArg(Any), KwArg(Any)], int], argument has type Callable[..., None])
     pass
 [builtins fixtures/dict.pyi]
 

test-data/unit/check-modules.test

@@ -475,11 +475,11 @@ def f(x: int = ...) -> None: pass
 [file m.pyi]
 def g(x: int = '') -> None: pass
 [out]
-tmp/m.pyi:1: error: Incompatible default argument for parameter "x" (initializer has type "str", parameter has type "int")
-main:2: error: Incompatible default argument for parameter "x" (initializer has type "ellipsis", parameter has type "int")
+tmp/m.pyi:1: error: Incompatible default initializer for argument "x" (initializer has type "str", argument has type "int")
+main:2: error: Incompatible default initializer for argument "x" (initializer has type "ellipsis", argument has type "int")
 
 [case testEllipsisDefaultArgValueInNonStub]
-def f(x: int = ...) -> None: pass # E: Incompatible default argument for parameter "x" (initializer has type "ellipsis", parameter has type "int")
+def f(x: int = ...) -> None: pass # E: Incompatible default initializer for argument "x" (initializer has type "ellipsis", argument has type "int")
 [out]
 
 [case testStarImportOverlapping]

test-data/unit/check-optional.test

@@ -127,7 +127,7 @@ f(None)
 
 [case testNoInferOptionalFromDefaultNone]
 # flags: --no-implicit-optional
-def f(x: int = None) -> None:  # E: Incompatible default argument for parameter "x" (initializer has type None, parameter has type "int")
+def f(x: int = None) -> None:  # E: Incompatible default initializer for argument "x" (initializer has type None, argument has type "int")
   pass
 [out]
 
@@ -140,7 +140,7 @@ f(None)
 
 [case testNoInferOptionalFromDefaultNoneComment]
 # flags: --no-implicit-optional
-def f(x=None):  # E: Incompatible default argument for parameter "x" (initializer has type None, parameter has type "int")
+def f(x=None):  # E: Incompatible default initializer for argument "x" (initializer has type None, argument has type "int")
   # type: (int) -> None
   pass
 [out]