Remove short-circuiting logic here, it is safe to check truthiness of any stmt - there are no error reports. Make MYPY_* vs ALWAYS_* consistent.

Author: sterliakov

mypy/reachability.py

@@ -128,28 +128,31 @@ def infer_condition_value(expr: Expression, options: Options) -> int:
     elif isinstance(expr, MemberExpr):
         name = expr.name
     elif isinstance(expr, OpExpr) and expr.op in ("and", "or"):
-        # This is a bit frivolous with MYPY_* vs ALWAYS_* returns: for example, here
-        # `MYPY_TRUE or ALWAYS_TRUE` will be `MYPY_TRUE`, while
-        # `ALWAYS_TRUE or MYPY_TRUE` will be `ALWAYS_TRUE`. This literally never
-        # makes any difference in consuming code, so short-circuiting here is probably
-        # good enough as it allows referencing platform-dependent variables in
-        # statement parts that will not be executed.
+        if expr.op not in ("or", "and"):
+            return TRUTH_VALUE_UNKNOWN
+
         left = infer_condition_value(expr.left, options)
-        if (left in (ALWAYS_TRUE, MYPY_TRUE) and expr.op == "or") or (
-            left in (ALWAYS_FALSE, MYPY_FALSE) and expr.op == "and"
-        ):
-            # Either `True or <other>` or `False and <other>`: `<other>` doesn't matter
-            return left
         right = infer_condition_value(expr.right, options)
-        if (right in (ALWAYS_TRUE, MYPY_TRUE) and expr.op == "or") or (
-            right in (ALWAYS_FALSE, MYPY_FALSE) and expr.op == "and"
-        ):
-            # Either `<other> or True` or `<other> and False`: `<other>` doesn't matter
-            return right
-        # Now we have `True and True`, `False or False` or smth indeterminate.
-        if TRUTH_VALUE_UNKNOWN in (left, right) or expr.op not in ("or", "and"):
-            return TRUTH_VALUE_UNKNOWN
-        return left
+        results = {left, right}
+        if expr.op == "or":
+            if ALWAYS_TRUE in results:
+                return ALWAYS_TRUE
+            elif MYPY_TRUE in results:
+                return MYPY_TRUE
+            elif left == right == MYPY_FALSE:
+                return MYPY_FALSE
+            elif results <= {ALWAYS_FALSE, MYPY_FALSE}:
+                return ALWAYS_FALSE
+        elif expr.op == "and":
+            if ALWAYS_FALSE in results:
+                return ALWAYS_FALSE
+            elif MYPY_FALSE in results:
+                return MYPY_FALSE
+            elif left == right == ALWAYS_TRUE:
+                return ALWAYS_TRUE
+            elif results <= {ALWAYS_TRUE, MYPY_TRUE}:
+                return MYPY_TRUE
+        return TRUTH_VALUE_UNKNOWN
     else:
         result = consider_sys_version_info(expr, pyversion)
         if result == TRUTH_VALUE_UNKNOWN:

test-data/unit/check-unreachable-code.test

@@ -550,6 +550,32 @@ reveal_type(unary_minus) # N: Revealed type is "Union[Literal[0], builtins.str]"
 reveal_type(binary_minus) # N: Revealed type is "Union[Literal[0], builtins.str]"
 [builtins fixtures/ops.pyi]
 
+[case testMypyFalseValuesInBinaryOps_no_empty]
+# flags: --platform linux
+import sys
+from typing import TYPE_CHECKING
+
+MYPY = 0
+
+if TYPE_CHECKING and sys.platform == 'linux':
+    def foo1() -> int: ...
+if sys.platform == 'linux' and TYPE_CHECKING:
+    def foo2() -> int: ...
+if MYPY and sys.platform == 'linux':
+    def foo3() -> int: ...
+if sys.platform == 'linux' and MYPY:
+    def foo4() -> int: ...
+
+if TYPE_CHECKING or sys.platform == 'linux':
+    def bar1() -> int: ...  # E: Missing return statement
+if sys.platform == 'linux' or TYPE_CHECKING:
+    def bar2() -> int: ...  # E: Missing return statement
+if MYPY or sys.platform == 'linux':
+    def bar3() -> int: ...  # E: Missing return statement
+if sys.platform == 'linux' or MYPY:
+    def bar4() -> int: ...  # E: Missing return statement
+[builtins fixtures/ops.pyi]
+
 [case testShortCircuitAndWithConditionalAssignment]
 # flags: --platform linux
 import sys