Rename NoneTyp to NoneType (#6719)

Every other type gets an e in its name. Might as well fix this one.
Keeps a NoneTyp alias to NoneType to avoid breaking external plugins.

Author: msullivan

mypy/binder.py

@@ -6,7 +6,7 @@
 if MYPY:
     from typing import DefaultDict
 
-from mypy.types import Type, AnyType, PartialType, UnionType, TypeOfAny, NoneTyp
+from mypy.types import Type, AnyType, PartialType, UnionType, TypeOfAny, NoneType
 from mypy.subtypes import is_subtype
 from mypy.join import join_simple
 from mypy.sametypes import is_same_type
@@ -276,10 +276,10 @@ def assign_type(self, expr: Expression,
         # (See discussion in #3526)
         elif (isinstance(type, AnyType)
               and isinstance(declared_type, UnionType)
-              and any(isinstance(item, NoneTyp) for item in declared_type.items)
-              and isinstance(self.most_recent_enclosing_type(expr, NoneTyp()), NoneTyp)):
+              and any(isinstance(item, NoneType) for item in declared_type.items)
+              and isinstance(self.most_recent_enclosing_type(expr, NoneType()), NoneType)):
             # Replace any Nones in the union type with Any
-            new_items = [type if isinstance(item, NoneTyp) else item
+            new_items = [type if isinstance(item, NoneType) else item
                          for item in declared_type.items]
             self.put(expr, UnionType(new_items))
         elif (isinstance(type, AnyType)

mypy/checker.py

@@ -30,7 +30,7 @@
 from mypy.typeanal import has_any_from_unimported_type, check_for_explicit_any
 from mypy.types import (
     Type, AnyType, CallableType, FunctionLike, Overloaded, TupleType, TypedDictType,
-    Instance, NoneTyp, strip_type, TypeType, TypeOfAny,
+    Instance, NoneType, strip_type, TypeType, TypeOfAny,
     UnionType, TypeVarId, TypeVarType, PartialType, DeletedType, UninhabitedType, TypeVarDef,
     true_only, false_only, function_type, is_named_instance, union_items, TypeQuery, LiteralType,
     is_optional, remove_optional
@@ -668,7 +668,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()
+            return NoneType()
 
     def get_coroutine_return_type(self, return_type: Type) -> Type:
         if isinstance(return_type, AnyType):
@@ -799,7 +799,7 @@ def check_func_def(self, defn: FuncItem, typ: CallableType, name: Optional[str])
                     fdef = item
                     # Check if __init__ has an invalid, non-None return type.
                     if (fdef.info and fdef.name() in ('__init__', '__init_subclass__') and
-                            not isinstance(typ.ret_type, NoneTyp) and
+                            not isinstance(typ.ret_type, NoneType) and
                             not self.dynamic_funcs[-1]):
                         self.fail(message_registry.MUST_HAVE_NONE_RETURN_TYPE.format(fdef.name()),
                                   item)
@@ -845,7 +845,7 @@ def check_func_def(self, defn: FuncItem, typ: CallableType, name: Optional[str])
                     if (self.options.python_version[0] == 2 and
                             isinstance(typ.ret_type, Instance) and
                             typ.ret_type.type.fullname() == 'typing.Generator'):
-                        if not isinstance(typ.ret_type.args[2], (NoneTyp, AnyType)):
+                        if not isinstance(typ.ret_type.args[2], (NoneType, AnyType)):
                             self.fail(message_registry.INVALID_GENERATOR_RETURN_ITEM_TYPE, typ)
 
                 # Fix the type if decorated with `@types.coroutine` or `@asyncio.coroutine`.
@@ -944,7 +944,7 @@ def check_func_def(self, defn: FuncItem, typ: CallableType, name: Optional[str])
                 else:
                     return_type = self.return_types[-1]
 
-                if (not isinstance(return_type, (NoneTyp, AnyType))
+                if (not isinstance(return_type, (NoneType, AnyType))
                         and not self.is_trivial_body(defn.body)):
                     # Control flow fell off the end of a function that was
                     # declared to return a non-None type and is not
@@ -1253,7 +1253,7 @@ def check_setattr_method(self, typ: Type, context: Context) -> None:
                                     AnyType(TypeOfAny.special_form)],
                                    [nodes.ARG_POS, nodes.ARG_POS, nodes.ARG_POS],
                                    [None, None, None],
-                                   NoneTyp(),
+                                   NoneType(),
                                    self.named_type('builtins.function'))
         if not is_subtype(typ, method_type):
             self.msg.invalid_signature_for_special_method(typ, context, '__setattr__')
@@ -1812,7 +1812,7 @@ def check_assignment(self, lvalue: Lvalue, rvalue: Expression, infer_lvalue_type
                 if isinstance(lvalue_type, PartialType) and lvalue_type.type is None:
                     # Try to infer a proper type for a variable with a partial None type.
                     rvalue_type = self.expr_checker.accept(rvalue)
-                    if isinstance(rvalue_type, NoneTyp):
+                    if isinstance(rvalue_type, NoneType):
                         # This doesn't actually provide any additional information -- multiple
                         # None initializers preserve the partial None type.
                         return
@@ -1823,7 +1823,7 @@ def check_assignment(self, lvalue: Lvalue, rvalue: Expression, infer_lvalue_type
                         if partial_types is not None:
                             if not self.current_node_deferred:
                                 inferred_type = UnionType.make_simplified_union(
-                                    [rvalue_type, NoneTyp()])
+                                    [rvalue_type, NoneType()])
                                 self.set_inferred_type(var, lvalue, inferred_type)
                             else:
                                 var.type = None
@@ -2483,15 +2483,15 @@ def infer_variable_type(self, name: Var, lvalue: Lvalue,
             self.set_inferred_type(name, lvalue, init_type)
 
     def infer_partial_type(self, name: Var, lvalue: Lvalue, init_type: Type) -> bool:
-        if isinstance(init_type, NoneTyp):
+        if isinstance(init_type, NoneType):
             partial_type = PartialType(None, name, [init_type])
         elif isinstance(init_type, Instance):
             fullname = init_type.type.fullname()
             if (isinstance(lvalue, (NameExpr, MemberExpr)) and
                     (fullname == 'builtins.list' or
                      fullname == 'builtins.set' or
                      fullname == 'builtins.dict') and
-                    all(isinstance(t, (NoneTyp, UninhabitedType)) for t in init_type.args)):
+                    all(isinstance(t, (NoneType, UninhabitedType)) for t in init_type.args)):
                 partial_type = PartialType(init_type.type, name, init_type.args)
             else:
                 return False
@@ -2643,7 +2643,7 @@ def check_indexed_assignment(self, lvalue: IndexExpr,
                 arg_types=[self.named_type('builtins.str'), item_type],
                 arg_kinds=[ARG_POS, ARG_POS],
                 arg_names=[None, None],
-                ret_type=NoneTyp(),
+                ret_type=NoneType(),
                 fallback=self.named_type('builtins.function')
             )  # type: Type
         else:
@@ -2707,7 +2707,7 @@ def check_return_stmt(self, s: ReturnStmt) -> None:
 
             if s.expr:
                 is_lambda = isinstance(self.scope.top_function(), LambdaExpr)
-                declared_none_return = isinstance(return_type, NoneTyp)
+                declared_none_return = isinstance(return_type, NoneType)
                 declared_any_return = isinstance(return_type, AnyType)
 
                 # This controls whether or not we allow a function call that
@@ -2742,7 +2742,7 @@ def check_return_stmt(self, s: ReturnStmt) -> None:
                 if declared_none_return:
                     # Lambdas are allowed to have None returns.
                     # Functions returning a value of type None are allowed to have a None return.
-                    if is_lambda or isinstance(typ, NoneTyp):
+                    if is_lambda or isinstance(typ, NoneType):
                         return
                     self.fail(message_registry.NO_RETURN_VALUE_EXPECTED, s)
                 else:
@@ -2760,7 +2760,7 @@ def check_return_stmt(self, s: ReturnStmt) -> None:
                         isinstance(return_type, AnyType)):
                     return
 
-                if isinstance(return_type, (NoneTyp, AnyType)):
+                if isinstance(return_type, (NoneType, AnyType)):
                     return
 
                 if self.in_checked_function():
@@ -2870,7 +2870,7 @@ def type_check_raise(self, e: Expression, s: RaiseStmt,
             return
         expected_type = self.named_type('builtins.BaseException')  # type: Type
         if optional:
-            expected_type = UnionType([expected_type, NoneTyp()])
+            expected_type = UnionType([expected_type, NoneType()])
         self.check_subtype(typ, expected_type, s, message_registry.INVALID_EXCEPTION)
 
     def visit_try_stmt(self, s: TryStmt) -> None:
@@ -3191,7 +3191,7 @@ def visit_print_stmt(self, s: PrintStmt) -> None:
             self.expr_checker.accept(arg)
         if s.target:
             target_type = self.expr_checker.accept(s.target)
-            if not isinstance(target_type, NoneTyp):
+            if not isinstance(target_type, NoneType):
                 # TODO: Also verify the type of 'write'.
                 self.expr_checker.analyze_external_member_access('write', target_type, s.target)
 
@@ -3435,7 +3435,7 @@ def find_isinstance_check(self, node: Expression
                         # two elements in node.operands, and at least one of them
                         # should represent a None.
                         vartype = type_map[expr]
-                        none_typ = [TypeRange(NoneTyp(), is_upper_bound=False)]
+                        none_typ = [TypeRange(NoneType(), is_upper_bound=False)]
                         if_vars, else_vars = conditional_type_map(expr, vartype, none_typ)
                         break
 
@@ -3549,7 +3549,7 @@ def check_subtype(self, subtype: Type, supertype: Type, context: Context,
 
     def contains_none(self, t: Type) -> bool:
         return (
-            isinstance(t, NoneTyp) or
+            isinstance(t, NoneType) or
             (isinstance(t, UnionType) and any(self.contains_none(ut) for ut in t.items)) or
             (isinstance(t, TupleType) and any(self.contains_none(tt) for tt in t.items)) or
             (isinstance(t, Instance) and bool(t.args)
@@ -3687,7 +3687,7 @@ def enter_partial_types(self, *, is_function: bool = False,
                         and isinstance(var.type, PartialType)
                         and var.type.type is None
                         and not permissive):
-                    var.type = NoneTyp()
+                    var.type = NoneType()
                 else:
                     if var not in self.partial_reported and not permissive:
                         self.msg.need_annotation_for_var(var, context)
@@ -3706,7 +3706,7 @@ def handle_partial_var_type(
             # 'None' partial type. It has a well-defined type. In an lvalue context
             # we want to preserve the knowledge of it being a partial type.
             if not is_lvalue:
-                return NoneTyp()
+                return NoneType()
             else:
                 return typ
         else:
@@ -3729,7 +3729,7 @@ def fixup_partial_type(self, typ: Type) -> Type:
         if not isinstance(typ, PartialType):
             return typ
         if typ.type is None:
-            return UnionType.make_union([AnyType(TypeOfAny.unannotated), NoneTyp()])
+            return UnionType.make_union([AnyType(TypeOfAny.unannotated), NoneType()])
         else:
             return Instance(
                 typ.type,
@@ -4227,8 +4227,8 @@ def is_valid_inferred_type(typ: Type) -> bool:
     invalid.  When doing strict Optional checking, only None and types that are
     incompletely defined (i.e. contain UninhabitedType) are invalid.
     """
-    if isinstance(typ, (NoneTyp, UninhabitedType)):
-        # With strict Optional checking, we *may* eventually infer NoneTyp when
+    if isinstance(typ, (NoneType, UninhabitedType)):
+        # With strict Optional checking, we *may* eventually infer NoneType when
         # the initializer is None, but we only do that if we can't infer a
         # specific Optional type.  This resolution happens in
         # leave_partial_types when we pop a partial types scope.

mypy/checkexpr.py

@@ -16,7 +16,7 @@
     has_any_from_unimported_type, check_for_explicit_any, set_any_tvars, expand_type_alias
 )
 from mypy.types import (
-    Type, AnyType, CallableType, Overloaded, NoneTyp, TypeVarDef,
+    Type, AnyType, CallableType, Overloaded, NoneType, TypeVarDef,
     TupleType, TypedDictType, Instance, TypeVarType, ErasedType, UnionType,
     PartialType, DeletedType, UninhabitedType, TypeType, TypeOfAny, LiteralType, LiteralValue,
     true_only, false_only, is_named_instance, function_type, callable_type, FunctionLike,
@@ -325,7 +325,7 @@ def visit_call_expr_inner(self, e: CallExpr, allow_none_return: bool = False) ->
         # Warn on calls to functions that always return None. The check
         # of ret_type is both a common-case optimization and prevents reporting
         # the error in dynamic functions (where it will be Any).
-        if (not allow_none_return and isinstance(ret_type, NoneTyp)
+        if (not allow_none_return and isinstance(ret_type, NoneType)
                 and self.always_returns_none(e.callee)):
             self.chk.msg.does_not_return_value(callee_type, e)
             return AnyType(TypeOfAny.from_error)
@@ -378,13 +378,13 @@ def defn_returns_none(self, defn: Optional[SymbolNode]) -> bool:
         """Check if `defn` can _only_ return None."""
         if isinstance(defn, FuncDef):
             return (isinstance(defn.type, CallableType) and
-                    isinstance(defn.type.ret_type, NoneTyp))
+                    isinstance(defn.type.ret_type, NoneType))
         if isinstance(defn, OverloadedFuncDef):
             return all(isinstance(item.type, CallableType) and
-                       isinstance(item.type.ret_type, NoneTyp) for item in defn.items)
+                       isinstance(item.type.ret_type, NoneType) for item in defn.items)
         if isinstance(defn, Var):
             if (not defn.is_inferred and isinstance(defn.type, CallableType) and
-                    isinstance(defn.type.ret_type, NoneTyp)):
+                    isinstance(defn.type.ret_type, NoneType)):
                 return True
             if isinstance(defn.type, Instance):
                 sym = defn.type.type.get('__call__')
@@ -854,7 +854,7 @@ def infer_arg_types_in_empty_context(self, args: List[Expression]) -> List[Type]
         for arg in args:
             arg_type = self.accept(arg)
             if has_erased_component(arg_type):
-                res.append(NoneTyp())
+                res.append(NoneType())
             else:
                 res.append(arg_type)
         return res
@@ -1010,7 +1010,7 @@ def infer_function_type_arguments(self, callee_type: CallableType,
                 #       correspondence with dict type variables. This is a marginal issue and
                 #       a little tricky to fix so it's left unfixed for now.
                 first_arg = inferred_args[0]
-                if isinstance(first_arg, (NoneTyp, UninhabitedType)):
+                if isinstance(first_arg, (NoneType, UninhabitedType)):
                     inferred_args[0] = self.named_type('builtins.str')
                 elif not first_arg or not is_subtype(self.named_type('builtins.str'), first_arg):
                     self.msg.fail(message_registry.KEYWORD_ARGUMENT_REQUIRES_STR_KEY_TYPE,
@@ -1045,7 +1045,7 @@ def infer_function_type_arguments_pass2(
         # that they are not applied yet below.
         inferred_args = list(old_inferred_args)
         for i, arg in enumerate(inferred_args):
-            if isinstance(arg, (NoneTyp, UninhabitedType)) or has_erased_component(arg):
+            if isinstance(arg, (NoneType, UninhabitedType)) or has_erased_component(arg):
                 inferred_args[i] = None
         callee_type = self.apply_generic_arguments(callee_type, inferred_args, context)
 
@@ -1991,7 +1991,7 @@ def dangerous_comparison(self, left: Type, right: Type) -> bool:
         """
         if not self.chk.options.strict_equality:
             return False
-        if isinstance(left, NoneTyp) or isinstance(right, NoneTyp):
+        if isinstance(left, NoneType) or isinstance(right, NoneType):
             return False
         if isinstance(left, UnionType) and isinstance(right, UnionType):
             left = remove_optional(left)
@@ -2602,7 +2602,7 @@ def visit_reveal_expr(self, expr: RevealExpr) -> Type:
                 } if expr.local_nodes is not None else {}
 
                 self.msg.reveal_locals(names_to_types, expr)
-            return NoneTyp()
+            return NoneType()
 
     def visit_type_application(self, tapp: TypeApplication) -> Type:
         """Type check a type application (expr[type, ...]).
@@ -2915,7 +2915,7 @@ def visit_lambda_expr(self, e: LambdaExpr) -> Type:
             if e.expr() not in self.chk.type_map:
                 self.accept(e.expr(), allow_none_return=True)
             ret_type = self.chk.type_map[e.expr()]
-            if isinstance(ret_type, NoneTyp):
+            if isinstance(ret_type, NoneType):
                 # For "lambda ...: None", just use type from the context.
                 # Important when the context is Callable[..., None] which
                 # really means Void. See #1425.
@@ -3102,11 +3102,11 @@ def visit_generator_expr(self, e: GeneratorExpr) -> Type:
         if any(e.is_async):
             typ = 'typing.AsyncGenerator'
             # received type is always None in async generator expressions
-            additional_args = [NoneTyp()]  # type: List[Type]
+            additional_args = [NoneType()]  # type: List[Type]
         else:
             typ = 'typing.Generator'
             # received type and returned type are None
-            additional_args = [NoneTyp(), NoneTyp()]
+            additional_args = [NoneType(), NoneType()]
         return self.check_generator_or_comprehension(e, typ, '<generator>',
                                                      additional_args=additional_args)
 
@@ -3357,7 +3357,7 @@ def visit_yield_expr(self, e: YieldExpr) -> Type:
         return_type = self.chk.return_types[-1]
         expected_item_type = self.chk.get_generator_yield_type(return_type, False)
         if e.expr is None:
-            if (not isinstance(expected_item_type, (NoneTyp, AnyType))
+            if (not isinstance(expected_item_type, (NoneType, AnyType))
                     and self.chk.in_checked_function()):
                 self.chk.fail(message_registry.YIELD_VALUE_EXPECTED, e)
         else:
@@ -3443,9 +3443,9 @@ def visit_yield_from_expr(self, e: YieldFromExpr, allow_none_return: bool = Fals
                 expr_type = AnyType(TypeOfAny.from_another_any, source_any=actual_item_type)
             else:
                 # Treat `Iterator[X]` as a shorthand for `Generator[X, None, Any]`.
-                expr_type = NoneTyp()
+                expr_type = NoneType()
 
-        if not allow_none_return and isinstance(expr_type, NoneTyp):
+        if not allow_none_return and isinstance(expr_type, NoneType):
             self.chk.msg.does_not_return_value(None, e)
         return expr_type