Add LiteralType and stub methods to type visitors (#5934)

This diff adds a 'LiteralType' class to types.py and adds a
corresponding stub method to all of the type visitors.

Most of these stub methods just throw a 'NotImplementedError',
though I did pencil in a few implementations that looked obvious.

The reason I'm doing this now instead of later is because I want
to start by getting these kind of big, gross, multi-file changes
out of the way early and try and have any subsequent pull requests
be more focused.

I also want to formally confirm that the correct approach here
*is* to create a new 'LiteralType' class before I start on the
rest of the implementation work. (Other possible approaches would
be to tack on some extra attribute to 'Instance', or make
'LiteralType' a subclass of 'Instance'.)

No tests, sorry. My plan is to work on modifying the parsing
and semantic analysis steps next before returning back to these
the unimplemented methods and add tests then --  here's the
tracking issue for these TODOs:
#5935

Tests shouldn't be necessary, in any case: everything I added
just now is basically dead code.

Author: Michael0x2a

mypy/constraints.py

@@ -5,7 +5,7 @@
 from mypy.types import (
     CallableType, Type, TypeVisitor, UnboundType, AnyType, NoneTyp, TypeVarType, Instance,
     TupleType, TypedDictType, UnionType, Overloaded, ErasedType, PartialType, DeletedType,
-    UninhabitedType, TypeType, TypeVarId, TypeQuery, is_named_instance, TypeOfAny
+    UninhabitedType, TypeType, TypeVarId, TypeQuery, is_named_instance, TypeOfAny, LiteralType,
 )
 from mypy.maptype import map_instance_to_supertype
 from mypy import nodes
@@ -473,6 +473,9 @@ def visit_typeddict_type(self, template: TypedDictType) -> List[Constraint]:
         else:
             return []
 
+    def visit_literal_type(self, template: LiteralType) -> List[Constraint]:
+        raise NotImplementedError()
+
     def visit_union_type(self, template: UnionType) -> List[Constraint]:
         assert False, ("Unexpected UnionType in ConstraintBuilderVisitor"
                        " (should have been handled in infer_constraints)")

mypy/erasetype.py

@@ -3,7 +3,7 @@
 from mypy.types import (
     Type, TypeVisitor, UnboundType, AnyType, NoneTyp, TypeVarId, Instance, TypeVarType,
     CallableType, TupleType, TypedDictType, UnionType, Overloaded, ErasedType, PartialType,
-    DeletedType, TypeTranslator, UninhabitedType, TypeType, TypeOfAny
+    DeletedType, TypeTranslator, UninhabitedType, TypeType, TypeOfAny, LiteralType,
 )
 from mypy.nodes import ARG_STAR, ARG_STAR2
 
@@ -78,6 +78,12 @@ def visit_tuple_type(self, t: TupleType) -> Type:
     def visit_typeddict_type(self, t: TypedDictType) -> Type:
         return t.fallback.accept(self)
 
+    def visit_literal_type(self, t: LiteralType) -> Type:
+        # The fallback for literal types should always be either
+        # something like int or str, or an enum class -- types that
+        # don't contain any TypeVars. So there's no need to visit it.
+        return t
+
     def visit_union_type(self, t: UnionType) -> Type:
         erased_items = [erase_type(item) for item in t.items]
         return UnionType.make_simplified_union(erased_items)

mypy/expandtype.py

@@ -4,7 +4,7 @@
     Type, Instance, CallableType, TypeVisitor, UnboundType, AnyType,
     NoneTyp, TypeVarType, Overloaded, TupleType, TypedDictType, UnionType,
     ErasedType, PartialType, DeletedType, UninhabitedType, TypeType, TypeVarId,
-    FunctionLike, TypeVarDef
+    FunctionLike, TypeVarDef, LiteralType,
 )
 
 
@@ -111,6 +111,10 @@ def visit_tuple_type(self, t: TupleType) -> Type:
     def visit_typeddict_type(self, t: TypedDictType) -> Type:
         return t.copy_modified(item_types=self.expand_types(t.items.values()))
 
+    def visit_literal_type(self, t: LiteralType) -> Type:
+        # TODO: Verify this implementation is correct
+        return t
+
     def visit_union_type(self, t: UnionType) -> Type:
         # After substituting for type variables in t.items,
         # some of the resulting types might be subtypes of others.

mypy/fixup.py

@@ -9,7 +9,7 @@
 )
 from mypy.types import (
     CallableType, Instance, Overloaded, TupleType, TypedDictType,
-    TypeVarType, UnboundType, UnionType, TypeVisitor,
+    TypeVarType, UnboundType, UnionType, TypeVisitor, LiteralType,
     TypeType, NOT_READY
 )
 from mypy.visitor import NodeVisitor
@@ -206,6 +206,9 @@ def visit_typeddict_type(self, tdt: TypedDictType) -> None:
         if tdt.fallback is not None:
             tdt.fallback.accept(self)
 
+    def visit_literal_type(self, lt: LiteralType) -> None:
+        lt.fallback.accept(self)
+
     def visit_type_var(self, tvt: TypeVarType) -> None:
         if tvt.values:
             for vt in tvt.values:

mypy/indirection.py

@@ -90,6 +90,9 @@ def visit_tuple_type(self, t: types.TupleType) -> Set[str]:
     def visit_typeddict_type(self, t: types.TypedDictType) -> Set[str]:
         return self._visit(t.items.values()) | self._visit(t.fallback)
 
+    def visit_literal_type(self, t: types.LiteralType) -> Set[str]:
+        return self._visit(t.fallback)
+
     def visit_star_type(self, t: types.StarType) -> Set[str]:
         return set()
 

mypy/join.py

@@ -5,8 +5,8 @@
 
 from mypy.types import (
     Type, AnyType, NoneTyp, TypeVisitor, Instance, UnboundType, TypeVarType, CallableType,
-    TupleType, TypedDictType, ErasedType, UnionType, FunctionLike, Overloaded,
-    PartialType, DeletedType, UninhabitedType, TypeType, true_or_false, TypeOfAny
+    TupleType, TypedDictType, ErasedType, UnionType, FunctionLike, Overloaded, LiteralType,
+    PartialType, DeletedType, UninhabitedType, TypeType, true_or_false, TypeOfAny,
 )
 from mypy.maptype import map_instance_to_supertype
 from mypy.subtypes import (
@@ -267,6 +267,9 @@ def visit_typeddict_type(self, t: TypedDictType) -> Type:
         else:
             return self.default(self.s)
 
+    def visit_literal_type(self, t: LiteralType) -> Type:
+        raise NotImplementedError()
+
     def visit_partial_type(self, t: PartialType) -> Type:
         # We only have partial information so we can't decide the join result. We should
         # never get here.

mypy/meet.py

@@ -7,7 +7,7 @@
 from mypy.types import (
     Type, AnyType, TypeVisitor, UnboundType, NoneTyp, TypeVarType, Instance, CallableType,
     TupleType, TypedDictType, ErasedType, UnionType, PartialType, DeletedType,
-    UninhabitedType, TypeType, TypeOfAny, Overloaded, FunctionLike,
+    UninhabitedType, TypeType, TypeOfAny, Overloaded, FunctionLike, LiteralType,
 )
 from mypy.subtypes import (
     is_equivalent, is_subtype, is_protocol_implementation, is_callable_compatible,
@@ -520,6 +520,9 @@ def visit_typeddict_type(self, t: TypedDictType) -> Type:
         else:
             return self.default(self.s)
 
+    def visit_literal_type(self, t: LiteralType) -> Type:
+        raise NotImplementedError()
+
     def visit_partial_type(self, t: PartialType) -> Type:
         # We can't determine the meet of partial types. We should never get here.
         assert False, 'Internal error'

mypy/sametypes.py

@@ -3,7 +3,7 @@
 from mypy.types import (
     Type, UnboundType, AnyType, NoneTyp, TupleType, TypedDictType,
     UnionType, CallableType, TypeVarType, Instance, TypeVisitor, ErasedType,
-    Overloaded, PartialType, DeletedType, UninhabitedType, TypeType
+    Overloaded, PartialType, DeletedType, UninhabitedType, TypeType, LiteralType,
 )
 
 
@@ -114,6 +114,14 @@ def visit_typeddict_type(self, left: TypedDictType) -> bool:
         else:
             return False
 
+    def visit_literal_type(self, left: LiteralType) -> bool:
+        if isinstance(self.right, LiteralType):
+            if left.value != self.right.value:
+                return False
+            return is_same_type(left.fallback, self.right.fallback)
+        else:
+            return False
+
     def visit_union_type(self, left: UnionType) -> bool:
         if isinstance(self.right, UnionType):
             # Check that everything in left is in right

mypy/server/astdiff.py

@@ -59,7 +59,7 @@ class level -- these are handled at attribute level (say, 'mod.Cls.method'
 from mypy.types import (
     Type, TypeVisitor, UnboundType, AnyType, NoneTyp, UninhabitedType,
     ErasedType, DeletedType, Instance, TypeVarType, CallableType, TupleType, TypedDictType,
-    UnionType, Overloaded, PartialType, TypeType
+    UnionType, Overloaded, PartialType, TypeType, LiteralType,
 )
 from mypy.util import get_prefix
 
@@ -315,6 +315,9 @@ def visit_typeddict_type(self, typ: TypedDictType) -> SnapshotItem:
         required = tuple(sorted(typ.required_keys))
         return ('TypedDictType', items, required)
 
+    def visit_literal_type(self, typ: LiteralType) -> SnapshotItem:
+        return ('LiteralType', typ.value, snapshot_type(typ.fallback))
+
     def visit_union_type(self, typ: UnionType) -> SnapshotItem:
         # Sort and remove duplicates so that we can use equality to test for
         # equivalent union type snapshots.

mypy/server/astmerge.py

@@ -58,7 +58,7 @@
 from mypy.types import (
     Type, SyntheticTypeVisitor, Instance, AnyType, NoneTyp, CallableType, DeletedType, PartialType,
     TupleType, TypeType, TypeVarType, TypedDictType, UnboundType, UninhabitedType, UnionType,
-    Overloaded, TypeVarDef, TypeList, CallableArgument, EllipsisType, StarType
+    Overloaded, TypeVarDef, TypeList, CallableArgument, EllipsisType, StarType, LiteralType,
 )
 from mypy.util import get_prefix, replace_object_state
 from mypy.typestate import TypeState
@@ -391,6 +391,9 @@ def visit_typeddict_type(self, typ: TypedDictType) -> None:
             value_type.accept(self)
         typ.fallback.accept(self)
 
+    def visit_literal_type(self, typ: LiteralType) -> None:
+        typ.fallback.accept(self)
+
     def visit_unbound_type(self, typ: UnboundType) -> None:
         for arg in typ.args:
             arg.accept(self)