Handle 'while True', 'assert False'

Author: rwbarton

mypy/checker.py

@@ -246,7 +246,9 @@ def accept_loop(self, body: Node, else_body: Node = None, *,
                 _, else_map = find_isinstance_check(
                     exit_condition, self.type_map, self.typing_mode_weak()
                 )
-                if else_map:
+                if else_map is None:
+                    self.binder.unreachable()
+                else:
                     for var, type in else_map.items():
                         self.binder.push(var, type)
             if else_body:
@@ -1500,7 +1502,9 @@ def visit_assert_stmt(self, s: AssertStmt) -> Type:
             self.typing_mode_weak()
         )
 
-        if true_map:
+        if true_map is None:
+            self.binder.unreachable()
+        else:
             for var, type in true_map.items():
                 self.binder.push(var, type)
 
@@ -2183,6 +2187,16 @@ def conditional_type_map(expr: Node,
             return {}, {}
 
 
+def is_true_literal(n: Node) -> bool:
+    return (refers_to_fullname(n, 'builtins.True')
+            or isinstance(n, IntExpr) and n.value == 1)
+
+
+def is_false_literal(n: Node) -> bool:
+    return (refers_to_fullname(n, 'builtins.False')
+            or isinstance(n, IntExpr) and n.value == 0)
+
+
 def is_literal_none(n: Node) -> bool:
     return isinstance(n, NameExpr) and n.fullname == 'builtins.None'
 
@@ -2246,7 +2260,11 @@ def find_isinstance_check(node: Node,
 
     Guaranteed to not return None, None. (But may return {}, {})
     """
-    if isinstance(node, CallExpr):
+    if is_true_literal(node):
+        return {}, None
+    elif is_false_literal(node):
+        return None, {}
+    elif isinstance(node, CallExpr):
         if refers_to_fullname(node.callee, 'builtins.isinstance'):
             expr = node.args[0]
             if expr.literal == LITERAL_TYPE:

test-data/unit/check-isinstance.test

@@ -985,6 +985,89 @@ while bool():
     x + 'a'
 [builtins fixtures/isinstance.py]
 
+[case testUnreachableWhileTrue]
+def f(x: int) -> None:
+    while True:
+        if x:
+            return
+    1()
+[builtins fixtures/bool.py]
+
+[case testUnreachableAssertFalse]
+def f() -> None:
+    assert False
+    1()
+[builtins fixtures/bool.py]
+
+[case testUnreachableAssertFalse2]
+# flags: fast-parser
+def f() -> None:
+    # The old parser doesn't understand the syntax below
+    assert False, "hi"
+    1()
+[builtins fixtures/bool.py]
+
+[case testUnreachableReturnOrAssertFalse]
+def f(x: int) -> int:
+    if x:
+        return x
+    else:
+        assert False
+    1()
+[builtins fixtures/bool.py]
+
+[case testUnreachableTryExcept]
+def f() -> None:
+    try:
+        f()
+        return
+    except BaseException:
+        return
+    1()
+[builtins fixtures/exception.py]
+
+[case testUnreachableTryExceptElse]
+def f() -> None:
+    try:
+        f()
+    except BaseException:
+        return
+    else:
+        return
+    1()
+[builtins fixtures/exception.py]
+
+[case testUnreachableTryReturnFinally1]
+def f() -> None:
+    try:
+        return
+    finally:
+        pass
+    1()
+
+[case testUnreachableTryReturnFinally2]
+def f() -> None:
+    try:
+        pass
+    finally:
+        return
+    1()
+
+[case testUnreachableTryReturnExceptRaise]
+def f() -> None:
+    try:
+        return
+    except:
+        raise
+    1()
+
+[case testUnreachableReturnLambda]
+from typing import Callable
+def g(t: Callable[[int], int]) -> int: pass
+def f() -> int:
+    return g(lambda x: x)
+    1()
+
 [case testIsinstanceAnd]
 class A:
     pass

test-data/unit/check-modules.test

@@ -812,6 +812,17 @@ from a import x
 x = 0
 [out]
 
+[case testIfFalseImport]
+if False:
+    import a
+def f(x: 'a.A') -> int:
+    return x.f()
+[file a.py]
+class A:
+    def f(self) -> int:
+        return 0
+[builtins fixtures/bool.py]
+
 
 -- Test stability under import cycles
 -- ----------------------------------