more copy changes

Author: hauntsaninja

docs/source/error_code_list2.rst

@@ -216,17 +216,18 @@ mypy generates an error if it thinks that an expression is redundant.
         [i for i in range(x) if isinstance(i, int)]
 
 
-Check that expression is not implicitly true in boolean context [implicit-bool]
+Check that expression is not implicitly true in boolean context [truthy-bool]
 --------------------------------------------------------------------------------
 
 Warn when an expression whose type does not implement __bool__ or __len__ is used in boolean context
-since it would always evaluate as true.
+since it could always evaluate to true (if one also assumes that no subtype implements __bool__ or
+__len__).
 
 .. code-block:: python
 
     class Foo:
       pass
     foo = Foo()
-    # Error: "foo" has type "Foo" which does not implement __bool__ or __len__ so it will always be true in boolean context
+    # Error: "foo" has type "Foo" which does not implement __bool__ or __len__ so it could always be true in boolean context
     if foo:
        ...

mypy/checker.py

@@ -4026,22 +4026,22 @@ def format_expr_type() -> str:
 
         if isinstance(t, FunctionLike):
             self.msg.fail(
-                f'Function "{t}" will always be true in boolean context', expr,
-                code=codes.IMPLICIT_BOOL,
+                f'Function "{t}" could always be true in boolean context', expr,
+                code=codes.TRUTHY_BOOL,
             )
         elif isinstance(t, UnionType):
             self.msg.fail(
                 f"{format_expr_type()} of which no members implement __bool__ or __len__ "
-                "so it will always be true in boolean context",
+                "so it could always be true in boolean context",
                 expr,
-                code=codes.IMPLICIT_BOOL,
+                code=codes.TRUTHY_BOOL,
             )
         else:
             self.msg.fail(
                 f'{format_expr_type()} which does not implement __bool__ or __len__ '
-                'so it will always be true in boolean context',
+                'so it could always be true in boolean context',
                 expr,
-                code=codes.IMPLICIT_BOOL,
+                code=codes.TRUTHY_BOOL,
             )
 
     def find_type_equals_check(self, node: ComparisonExpr, expr_indices: List[int]

mypy/errorcodes.py

@@ -122,9 +122,9 @@ def __str__(self) -> str:
 REDUNDANT_EXPR: Final = ErrorCode(
     "redundant-expr", "Warn about redundant expressions", "General", default_enabled=False
 )
-IMPLICIT_BOOL: Final = ErrorCode(
-    'implicit-bool',
-    "Warn about potential use of implicit bool (that always returns true)",
+TRUTHY_BOOL: Final = ErrorCode(
+    'truthy-bool',
+    "Warn about expressions that could always evaluate to true in boolean contexts",
     'General',
     default_enabled=False
 )

test-data/unit/check-errorcodes.test

@@ -808,14 +808,14 @@ from typing_extensions import TypedDict
 Foo = TypedDict("Bar", {})  # E: First argument "Bar" to TypedDict() does not match variable name "Foo"  [name-match]
 [builtins fixtures/dict.pyi]
 [case testImplicitBool]
-# flags: --enable-error-code implicit-bool
+# flags: --enable-error-code truthy-bool
 from typing import List, Union
 
 class Foo:
     pass
 
 foo = Foo()
-if foo:  # E: "__main__.foo" has type "__main__.Foo" which does not implement __bool__ or __len__ so it will always be true in boolean context  [implicit-bool]
+if foo:  # E: "__main__.foo" has type "__main__.Foo" which does not implement __bool__ or __len__ so it could always be true in boolean context  [truthy-bool]
     pass
 
 zero = 0
@@ -839,14 +839,14 @@ if good_union:
     pass
 
 bad_union: Union[Foo, object] = Foo()
-if bad_union:  # E: "__main__.bad_union" has type "Union[__main__.Foo, builtins.object]" of which no members implement __bool__ or __len__ so it will always be true in boolean context  [implicit-bool]
+if bad_union:  # E: "__main__.bad_union" has type "Union[__main__.Foo, builtins.object]" of which no members implement __bool__ or __len__ so it could always be true in boolean context  [truthy-bool]
     pass
 
 def f():
     pass
-if f:  # E: Function "def () -> Any" will always be true in boolean context  [implicit-bool]
+if f:  # E: Function "def () -> Any" could always be true in boolean context  [truthy-bool]
     pass
-conditional_result = 'foo' if f else 'bar'  # E: Function "def () -> Any" will always be true in boolean context  [implicit-bool]
+conditional_result = 'foo' if f else 'bar'  # E: Function "def () -> Any" could always be true in boolean context  [truthy-bool]
 
 lst: List[int] = []
 if lst: