Remove old way to warn on returned None's

ddfisher · ddfisher · commit 193470309503 · 2017-03-18T17:49:10.000-07:00
diff --git a/mypy/checker.py b/mypy/checker.py
@@ -409,7 +409,7 @@ def get_generator_receive_type(self, return_type: Type, is_coroutine: bool) -> T
         else:
             # `return_type` is a supertype of Generator, so callers won't be able to send it
             # values.  IOW, tc is None.
-            return NoneTyp(is_ret_type=True)
+            return NoneTyp()
 
     def get_generator_return_type(self, return_type: Type, is_coroutine: bool) -> Type:
         """Given the declared return type of a generator (t), return the type it returns (tr)."""
@@ -1543,10 +1543,7 @@ def is_definition(self, s: Lvalue) -> bool:
     def infer_variable_type(self, name: Var, lvalue: Lvalue,
                             init_type: Type, context: Context) -> None:
         """Infer the type of initialized variables from initializer type."""
-        if self.is_unusable_type(init_type):
-            self.check_usable_type(init_type, context)
-            self.set_inference_error_fallback_type(name, lvalue, init_type, context)
-        elif isinstance(init_type, DeletedType):
+        if isinstance(init_type, DeletedType):
             self.msg.deleted_as_rvalue(init_type, context)
         elif not is_valid_inferred_type(init_type):
             # We cannot use the type of the initialization expression for full type
@@ -1815,7 +1812,6 @@ def visit_if_stmt(self, s: IfStmt) -> None:
         with self.binder.frame_context(can_skip=False, fall_through=0):
             for e, b in zip(s.expr, s.body):
                 t = self.expr_checker.accept(e)
-                self.check_usable_type(t, e)
 
                 if isinstance(t, DeletedType):
                     self.msg.deleted_as_rvalue(t, s)
@@ -2055,8 +2051,6 @@ def analyze_async_iterable_item_type(self, expr: Expression) -> Type:
         echk = self.expr_checker
         iterable = echk.accept(expr)
 
-        self.check_usable_type(iterable, expr)
-
         self.check_subtype(iterable,
                            self.named_generic_type('typing.AsyncIterable',
                                                    [AnyType()]),
@@ -2074,7 +2068,6 @@ def analyze_iterable_item_type(self, expr: Expression) -> Type:
         echk = self.expr_checker
         iterable = echk.accept(expr)
 
-        self.check_usable_type(iterable, expr)
         if isinstance(iterable, TupleType):
             joined = UninhabitedType()  # type: Type
             for item in iterable.items:
@@ -2242,21 +2235,18 @@ def check_subtype(self, subtype: Type, supertype: Type, context: Context,
         if is_subtype(subtype, supertype):
             return True
         else:
-            if self.is_unusable_type(subtype):
-                self.msg.does_not_return_value(subtype, context)
-            else:
-                if self.should_suppress_optional_error([subtype]):
-                    return False
-                extra_info = []  # type: List[str]
-                if subtype_label is not None or supertype_label is not None:
-                    subtype_str, supertype_str = self.msg.format_distinctly(subtype, supertype)
-                    if subtype_label is not None:
-                        extra_info.append(subtype_label + ' ' + subtype_str)
-                    if supertype_label is not None:
-                        extra_info.append(supertype_label + ' ' + supertype_str)
-                if extra_info:
-                    msg += ' (' + ', '.join(extra_info) + ')'
-                self.fail(msg, context)
+            if self.should_suppress_optional_error([subtype]):
+                return False
+            extra_info = []  # type: List[str]
+            if subtype_label is not None or supertype_label is not None:
+                subtype_str, supertype_str = self.msg.format_distinctly(subtype, supertype)
+                if subtype_label is not None:
+                    extra_info.append(subtype_label + ' ' + subtype_str)
+                if supertype_label is not None:
+                    extra_info.append(supertype_label + ' ' + supertype_str)
+            if extra_info:
+                msg += ' (' + ', '.join(extra_info) + ')'
+            self.fail(msg, context)
             return False
 
     def contains_none(self, t: Type) -> bool:
@@ -2376,18 +2366,6 @@ def find_partial_types(self, var: Var) -> Optional[Dict[Var, Context]]:
                 return partial_types
         return None
 
-    def is_unusable_type(self, typ: Type) -> bool:
-        """Is this type an unusable type?
-
-        The unusable type is NoneTyp(is_ret_type=True).
-        """
-        return isinstance(typ, NoneTyp) and typ.is_ret_type
-
-    def check_usable_type(self, typ: Type, context: Context) -> None:
-        """Generate an error if the type is not a usable type."""
-        if self.is_unusable_type(typ):
-            self.msg.does_not_return_value(typ, context)
-
     def temp_node(self, t: Type, context: Context = None) -> TempNode:
         """Create a temporary node with the given, fixed type."""
         temp = TempNode(t)
diff --git a/mypy/checkexpr.py b/mypy/checkexpr.py
@@ -194,6 +194,7 @@ def visit_call_expr(self, e: CallExpr, allow_none_return: bool = False) -> Type:
             self.chk.binder.unreachable()
         if not allow_none_return and isinstance(ret_type, NoneTyp):
             self.chk.msg.does_not_return_value(callee_type, e)
+            return AnyType(implicit=True)
         return ret_type
 
     def check_typeddict_call(self, callee: TypedDictType,
@@ -835,9 +836,7 @@ def check_arg(self, caller_type: Type, original_caller_type: Type,
                   callee_type: Type, n: int, m: int, callee: CallableType,
                   context: Context, messages: MessageBuilder) -> None:
         """Check the type of a single argument in a call."""
-        if self.chk.is_unusable_type(caller_type):
-            messages.does_not_return_value(caller_type, context)
-        elif isinstance(caller_type, DeletedType):
+        if isinstance(caller_type, DeletedType):
             messages.deleted_as_rvalue(caller_type, context)
         elif not is_subtype(caller_type, callee_type):
             if self.chk.should_suppress_optional_error([caller_type, callee_type]):
@@ -1191,7 +1190,6 @@ def visit_comparison_expr(self, e: ComparisonExpr) -> Type:
             if result is None:
                 result = sub_result
             else:
-                self.check_usable_type(sub_result, e)
                 result = join.join_types(result, sub_result)
 
         return result
@@ -1342,9 +1340,6 @@ def check_boolean_op(self, e: OpExpr, context: Context) -> Type:
 
         right_type = self.analyze_cond_branch(right_map, e.right, left_type)
 
-        self.check_usable_type(left_type, context)
-        self.check_usable_type(right_type, context)
-
         if right_map is None:
             # The boolean expression is statically known to be the left value
             assert left_map is not None  # find_isinstance_check guarantees this
@@ -1384,7 +1379,6 @@ def visit_unary_expr(self, e: UnaryExpr) -> Type:
         operand_type = self.accept(e.expr)
         op = e.op
         if op == 'not':
-            self.check_usable_type(operand_type, e)
             result = self.bool_type()  # type: Type
         elif op == '-':
             method_type = self.analyze_external_member_access('__neg__',
@@ -1678,7 +1672,6 @@ def visit_tuple_expr(self, e: TupleExpr) -> Type:
                 # context?  Counterargument: Why would anyone write
                 # (1, *(2, 3)) instead of (1, 2, 3) except in a test?
                 tt = self.accept(item.expr)
-                self.check_usable_type(tt, e)
                 if isinstance(tt, TupleType):
                     items.extend(tt.items)
                     j += len(tt.items)
@@ -1692,7 +1685,6 @@ def visit_tuple_expr(self, e: TupleExpr) -> Type:
                 else:
                     tt = self.accept(item, type_context_items[j])
                     j += 1
-                self.check_usable_type(tt, e)
                 items.append(tt)
         fallback_item = join.join_type_list(items)
         return TupleType(items, self.chk.named_generic_type('builtins.tuple', [fallback_item]))
@@ -1953,7 +1945,6 @@ def check_for_comp(self, e: Union[GeneratorExpr, DictionaryComprehension]) -> No
 
     def visit_conditional_expr(self, e: ConditionalExpr) -> Type:
         cond_type = self.accept(e.cond)
-        self.check_usable_type(cond_type, e)
         if self.chk.options.strict_boolean:
             is_bool = (isinstance(cond_type, Instance)
                 and cond_type.type.fullname() == 'builtins.bool')
@@ -2033,10 +2024,6 @@ def accept(self,
         else:
             return typ
 
-    def check_usable_type(self, typ: Type, context: Context) -> None:
-        """Generate an error if type is not a usable type."""
-        self.chk.check_usable_type(typ, context)
-
     def named_type(self, name: str) -> Instance:
         """Return an instance type with type given by the name and no type
         arguments. Alias for TypeChecker.named_type.
@@ -2182,7 +2169,7 @@ def visit_yield_from_expr(self, e: YieldFromExpr) -> Type:
             if isinstance(actual_item_type, AnyType):
                 return AnyType()
             else:
-                return NoneTyp(is_ret_type=True)
+                return NoneTyp()
 
     def visit_temp_node(self, e: TempNode) -> Type:
         return e.type
diff --git a/mypy/erasetype.py b/mypy/erasetype.py
@@ -63,7 +63,7 @@ def visit_type_var(self, t: TypeVarType) -> Type:
 
     def visit_callable_type(self, t: CallableType) -> Type:
         # We must preserve the fallback type for overload resolution to work.
-        ret_type = NoneTyp(is_ret_type=True)  # type: Type
+        ret_type = NoneTyp()  # type: Type
         return CallableType([], [], [], ret_type, t.fallback)
 
     def visit_overloaded(self, t: Overloaded) -> Type:
diff --git a/mypy/fastparse.py b/mypy/fastparse.py
@@ -342,9 +342,6 @@ def do_func_def(self, n: Union[ast3.FunctionDef, ast3.AsyncFunctionDef],
         for arg, arg_type in zip(args, arg_types):
             self.set_type_optional(arg_type, arg.initializer)
 
-        if isinstance(return_type, UnboundType):
-            return_type.is_ret_type = True
-
         func_type = None
         if any(arg_types) or return_type:
             if len(arg_types) != 1 and any(isinstance(t, EllipsisType) for t in arg_types):
diff --git a/mypy/fastparse2.py b/mypy/fastparse2.py
@@ -327,9 +327,6 @@ def visit_FunctionDef(self, n: ast27.FunctionDef) -> Statement:
         for arg, arg_type in zip(args, arg_types):
             self.set_type_optional(arg_type, arg.initializer)
 
-        if isinstance(return_type, UnboundType):
-            return_type.is_ret_type = True
-
         func_type = None
         if any(arg_types) or return_type:
             if len(arg_types) != 1 and any(isinstance(t, EllipsisType) for t in arg_types):
diff --git a/mypy/messages.py b/mypy/messages.py
@@ -372,8 +372,6 @@ def has_no_attr(self, typ: Type, member: str, context: Context) -> Type:
         if (isinstance(typ, Instance) and
                 typ.type.has_readable_member(member)):
             self.fail('Member "{}" is not assignable'.format(member), context)
-        elif self.check_unusable_type(typ, context):
-            pass
         elif member == '__contains__':
             self.fail('Unsupported right operand type for in ({})'.format(
                 self.format(typ)), context)
@@ -438,9 +436,6 @@ def unsupported_operand_types(self, op: str, left_type: Any,
 
         Types can be Type objects or strings.
         """
-        if (self.check_unusable_type(left_type, context) or
-                self.check_unusable_type(right_type, context)):
-            return
         left_str = ''
         if isinstance(left_type, str):
             left_str = left_type
@@ -462,13 +457,12 @@ def unsupported_operand_types(self, op: str, left_type: Any,
 
     def unsupported_left_operand(self, op: str, typ: Type,
                                  context: Context) -> None:
-        if not self.check_unusable_type(typ, context):
-            if self.disable_type_names:
-                msg = 'Unsupported left operand type for {} (some union)'.format(op)
-            else:
-                msg = 'Unsupported left operand type for {} ({})'.format(
-                    op, self.format(typ))
-            self.fail(msg, context)
+        if self.disable_type_names:
+            msg = 'Unsupported left operand type for {} (some union)'.format(op)
+        else:
+            msg = 'Unsupported left operand type for {} ({})'.format(
+                op, self.format(typ))
+        self.fail(msg, context)
 
     def not_callable(self, typ: Type, context: Context) -> Type:
         self.fail('{} not callable'.format(self.format(typ)), context)
@@ -738,17 +732,6 @@ def invalid_keyword_var_arg(self, typ: Type, context: Context) -> None:
     def undefined_in_superclass(self, member: str, context: Context) -> None:
         self.fail('"{}" undefined in superclass'.format(member), context)
 
-    def check_unusable_type(self, typ: Type, context: Context) -> bool:
-        """If type is a type which is not meant to be used (like
-        NoneTyp(is_ret_type=True)), report an error such as '.. does not
-        return a value' and return True. Otherwise, return False.
-        """
-        if isinstance(typ, NoneTyp) and typ.is_ret_type:
-            self.does_not_return_value(typ, context)
-            return True
-        else:
-            return False
-
     def too_few_string_formatting_arguments(self, context: Context) -> None:
         self.fail('Not enough arguments for format string', context)
 
diff --git a/mypy/test/testtypes.py b/mypy/test/testtypes.py
@@ -45,7 +45,7 @@ def test_callable_type(self) -> None:
                          AnyType(), self.function)
         assert_equal(str(c), 'def (X?, Y?) -> Any')
 
-        c2 = CallableType([], [], [], NoneTyp(is_ret_type=True), None)
+        c2 = CallableType([], [], [], NoneTyp(), None)
         assert_equal(str(c2), 'def ()')
 
     def test_callable_type_with_default_args(self) -> None:
@@ -87,7 +87,7 @@ def test_generic_function_type(self) -> None:
 
         v = [TypeVarDef('Y', -1, None, self.fx.o),
              TypeVarDef('X', -2, None, self.fx.o)]
-        c2 = CallableType([], [], [], NoneTyp(is_ret_type=True), self.function, name=None, variables=v)
+        c2 = CallableType([], [], [], NoneTyp(), self.function, name=None, variables=v)
         assert_equal(str(c2), 'def [Y, X] ()')
 
 
diff --git a/mypy/typeanal.py b/mypy/typeanal.py
@@ -128,7 +128,7 @@ def visit_unbound_type(self, t: UnboundType) -> Type:
                 assert sym.tvar_def is not None
                 return TypeVarType(sym.tvar_def, t.line)
             elif fullname == 'builtins.None':
-                return NoneTyp(is_ret_type=t.is_ret_type)
+                return NoneTyp()
             elif fullname == 'typing.Any':
                 return AnyType()
             elif fullname == 'typing.Tuple':
diff --git a/mypy/types.py b/mypy/types.py
@@ -188,8 +188,6 @@ class UnboundType(Type):
     args = None  # type: List[Type]
     # should this type be wrapped in an Optional?
     optional = False
-    # is this type a return type?
-    is_ret_type = False
 
     # special case for X[()]
     empty_tuple_index = False
@@ -200,14 +198,12 @@ def __init__(self,
                  line: int = -1,
                  column: int = -1,
                  optional: bool = False,
-                 is_ret_type: bool = False,
                  empty_tuple_index: bool = False) -> None:
         if not args:
             args = []
         self.name = name
         self.args = args
         self.optional = optional
-        self.is_ret_type = is_ret_type
         self.empty_tuple_index = empty_tuple_index
         super().__init__(line, column)
 
@@ -319,29 +315,24 @@ def deserialize(cls, data: JsonDict) -> 'UninhabitedType':
 class NoneTyp(Type):
     """The type of 'None'.
 
-    This type can be written by users as 'None'. When used as a return type,
-    `is_ret_type` is set to true, which signifies the result should not be
-    used.
+    This type can be written by users as 'None'.
     """
 
     can_be_true = False
 
-    def __init__(self, is_ret_type: bool = False, line: int = -1, column: int = -1) -> None:
+    def __init__(self, line: int = -1, column: int = -1) -> None:
         super().__init__(line, column)
-        self.is_ret_type = is_ret_type
 
     def accept(self, visitor: 'TypeVisitor[T]') -> T:
         return visitor.visit_none_type(self)
 
     def serialize(self) -> JsonDict:
-        return {'.class': 'NoneTyp',
-                'is_ret_type': self.is_ret_type,
-                }
+        return {'.class': 'NoneTyp'}
 
     @classmethod
     def deserialize(cls, data: JsonDict) -> 'NoneTyp':
         assert data['.class'] == 'NoneTyp'
-        return NoneTyp(is_ret_type=data['is_ret_type'])
+        return NoneTyp()
 
 
 class ErasedType(Type):
