Merge branch 'optional-types'

Closes #477.

Author: JukkaL

lib-typing/2.7/test_typing.py

@@ -4,7 +4,7 @@
 
 from typing import (
     List, Dict, Set, Tuple, Pattern, Match, Any, Callable, Generic,
-    _Protocol, Sized, Iterable, Iterator, Sequence,
+    _Protocol, Sized, Iterable, Iterator, Sequence, Union, Optional,
     AbstractSet, Mapping, BinaryIO, TextIO, SupportsInt, SupportsFloat,
     SupportsAbs, Reversible, Undefined, AnyStr, annotations, builtinclass,
     cast, disjointclass, ducktype, forwardref, overload, typevar
@@ -455,6 +455,11 @@ def h(x): pass
             @overload
             def h(x): pass
 
+    def test_optional(self):
+        # TODO: This test actually isn't very useful right now, but it will make sense
+        #       once Union is modified to keep track of the given type arguments.
+        self.assertEqual(Optional[int], Union[int, None])
+
 
 class Dummy(object):
     u"""Dummy class defined in module scope"""

lib-typing/2.7/typing.py

@@ -20,6 +20,7 @@
     'List',
     'Match',
     'NamedTuple',
+    'Optional',
     'Pattern',
     'Set',
     'Tuple',
@@ -164,9 +165,18 @@ def __getitem__(self, typeargs):
 
 def union(x): return x
 
+
 Union = TypeAlias(union)
 
 
+class _Optional:
+    def __getitem__(self, typearg):
+        return Union[typearg, None]
+
+
+Optional = _Optional()
+
+
 def NamedTuple(typename, fields):
     return collections.namedtuple(typename,
                                   (name for name, type in fields))

lib-typing/3.2/test_typing.py

@@ -3,7 +3,7 @@
 
 from typing import (
     List, Dict, Set, Tuple, Pattern, Match, Any, Callable, Generic,
-    _Protocol, Sized, Iterable, Iterator, Sequence,
+    _Protocol, Sized, Iterable, Iterator, Sequence, Union, Optional,
     AbstractSet, Mapping, BinaryIO, TextIO, SupportsInt, SupportsFloat,
     SupportsAbs, SupportsRound, Reversible, Undefined, AnyStr, builtinclass,
     cast, disjointclass, ducktype, forwardref, overload, typevar
@@ -460,6 +460,11 @@ def h(x: int) -> None: pass
             @overload
             def h(x: str) -> None: pass
 
+    def test_optional(self):
+        # TODO: This test actually isn't very useful right now, but it will make sense
+        #       once Union is modified to keep track of the given type arguments.
+        self.assertEqual(Optional[int], Union[int, None])
+
 
 class Dummy:
     """Dummy class defined in module scope"""

lib-typing/3.2/typing.py

@@ -20,6 +20,7 @@
     'List',
     'Match',
     'NamedTuple',
+    'Optional',
     'Pattern',
     'Set',
     'Tuple',
@@ -168,6 +169,14 @@ def union(x): return x
 Union = TypeAlias(union)
 
 
+class _Optional:
+    def __getitem__(self, typearg):
+        return Union[typearg, None]
+
+
+Optional = _Optional()
+
+
 def NamedTuple(typename, fields):
     return collections.namedtuple(typename,
                                   (name for name, type in fields))

mypy/test/data/check-unions.test

@@ -103,3 +103,10 @@ from typing import Union
 def f() -> Union[int, None]: pass
 x = 1
 x = f()
+
+[case testOptional]
+from typing import Optional
+def f(x: Optional[int]) -> None: pass
+f(1)
+f(None)
+f('') # E: Argument 1 to "f" has incompatible type "str"; expected "int"

mypy/test/data/lib-stub/typing.py

@@ -8,6 +8,7 @@
 Undefined = object()
 Any = object()
 Union = object()
+Optional = object()
 typevar = object()
 Generic = object()
 Tuple = object()

mypy/test/data/python2eval.test

@@ -350,3 +350,11 @@ f([0, 0, 1, 1, 1])
 [out]
 2
 3
+
+[case testOptional_python2]
+from typing import Optional
+def f(): # type: () -> Optional[int]
+    pass
+x = f()
+y = 1
+y = x

mypy/test/data/pythoneval.test

@@ -986,3 +986,10 @@ class E(A, B[T], Generic[T]): pass
 class F(B[T], A, Generic[T]): pass
 def f(e: E[int], f: F[int]) -> None: pass
 [out]
+
+[case testOptional]
+from typing import Optional
+def f() -> Optional[int]: pass
+x = f()
+y = 1
+y = x

mypy/test/data/semanal-types.test

@@ -1522,3 +1522,20 @@ MypyFile:1(
     def (x: builtins.int)
     Block:2(
       PassStmt:2())))
+
+[case testOptionalTypes]
+from typing import Optional
+x = 1  # type: Optional[int]
+[out]
+MypyFile:1(
+  ImportFrom:1(typing, [Optional : Optional])
+  AssignmentStmt:2(
+    NameExpr(x [__main__.x])
+    IntExpr(1)
+    builtins.int))
+
+[case testInvalidOptionalType]
+from typing import Optional
+x = 1  # type: Optional[int, str]  # E: Optional[...] must have exactly one type argument
+y = 1  # type: Optional[x]  # E: Invalid type "__main__.x"
+[out]

mypy/typeanal.py

@@ -70,6 +70,7 @@ def __init__(self,
     def visit_unbound_type(self, t: UnboundType) -> Type:
         sym = self.lookup(t.name, t)
         if sym is not None:
+            fullname = sym.node.fullname()
             if sym.kind == TVAR:
                 if len(t.args) > 0:
                     self.fail('Type variable "{}" used with arguments'.format(
@@ -81,18 +82,24 @@ def visit_unbound_type(self, t: UnboundType) -> Type:
                 values = cast(TypeVarExpr, sym.node).values
                 return TypeVar(t.name, sym.tvar_id, values, self.builtin_type('builtins.object'),
                                t.line, rep)
-            elif sym.node.fullname() == 'builtins.None':
+            elif fullname == 'builtins.None':
                 return Void()
-            elif sym.node.fullname() == 'typing.Any':
+            elif fullname == 'typing.Any':
                 return AnyType()
-            elif sym.node.fullname() == 'typing.Tuple':
+            elif fullname == 'typing.Tuple':
                 return TupleType(self.anal_array(t.args),
                                  self.builtin_type('builtins.tuple'))
-            elif sym.node.fullname() == 'typing.Union':
+            elif fullname == 'typing.Union':
                 items = self.anal_array(t.args)
                 items = [item for item in items if not isinstance(item, Void)]
                 return UnionType.make_union(items)
-            elif sym.node.fullname() == 'typing.Callable':
+            elif fullname == 'typing.Optional':
+                if len(t.args) != 1:
+                    self.fail('Optional[...] must have exactly one type argument', t)
+                items = self.anal_array(t.args)
+                # Currently Optional[t] is just an alias for t.
+                return items[0]
+            elif fullname == 'typing.Callable':
                 return self.analyze_function_type(t)
             elif sym.kind == TYPE_ALIAS:
                 # TODO: Generic type aliases.
@@ -109,7 +116,6 @@ def visit_unbound_type(self, t: UnboundType) -> Type:
                                  Instance(info, [], t.line),
                                  t.line, t.repr)
             else:
-
                 # Analyze arguments and construct Instance type. The
                 # number of type arguments and their values are
                 # checked only later, since we do not always know the