make proper subtyping require last_known_value subtyping

Author: randolf-scholz

mypy/subtypes.py

@@ -549,6 +549,13 @@ def visit_instance(self, left: Instance) -> bool:
                     assert isinstance(erased, Instance)
                     t = erased
                 nominal = True
+                if self.proper_subtype and right.last_known_value is not None:
+                    if left.last_known_value is None:
+                        # E.g. str is not a proper subtype of Literal["x"]?
+                        nominal = False
+                    else:
+                        # E.g. Literal[A]? <: Literal[B]? requires A <: B
+                        nominal &= self._is_subtype(left.last_known_value, right.last_known_value)
                 if right.type.has_type_var_tuple_type:
                     # For variadic instances we simply find the correct type argument mappings,
                     # all the heavy lifting is done by the tuple subtyping.

mypy/test/testsubtypes.py

@@ -304,7 +304,7 @@ def test_literal(self) -> None:
         self.assert_subtype(str1_inst, str1)
         self.assert_subtype(str1_inst, str1_inst)
 
-        # second operand is a different literal
+        # other operand is a different literal
         # "x"  ≲ "y"  -> NO
         # "x"  ≲ "y"? -> YES
         # "x"? ≲ "y"  -> NO
@@ -315,17 +315,17 @@ def test_literal(self) -> None:
         self.assert_subtype(str1_inst, str2_inst)
 
         # check proper subtyping
-        # second operand is the fallback type
+        # other operand is the fallback type
         # "x"  <: str  -> YES
         # str  <: "x"  -> NO
         # "x"? <: str  -> YES
-        # str  <: "x"? -> YES
+        # str  <: "x"? -> NO
         self.assert_proper_subtype(str1, str_type)
         self.assert_not_proper_subtype(str_type, str1)
         self.assert_proper_subtype(str1_inst, str_type)
-        self.assert_proper_subtype(str_type, str1_inst)
+        self.assert_not_proper_subtype(str_type, str1_inst)
 
-        # second operand is the same literal
+        # other operand is the same literal
         # "x"  <: "x"  -> YES
         # "x"  <: "x"? -> YES
         # "x"? <: "x"  -> NO
@@ -335,15 +335,15 @@ def test_literal(self) -> None:
         self.assert_not_proper_subtype(str1_inst, str1)
         self.assert_proper_subtype(str1_inst, str1_inst)
 
-        # second operand is a different literal
-        # "x"  ≲ "y"  -> NO
-        # "x"  ≲ "y"? -> NO
-        # "x"? ≲ "y"  -> NO
-        # "x"? ≲ "y"? -> YES
+        # other operand is a different literal
+        # "x"  <: "y"  -> NO
+        # "x"  <: "y"? -> NO
+        # "x"? <: "y"  -> NO
+        # "x"? <: "y"? -> NO
         self.assert_not_proper_subtype(str1, str2)
         self.assert_not_proper_subtype(str1, str2_inst)
         self.assert_not_proper_subtype(str1_inst, str2)
-        self.assert_proper_subtype(str1_inst, str2_inst)
+        self.assert_not_proper_subtype(str1_inst, str2_inst)
 
     # IDEA: Maybe add these test cases (they are tested pretty well in type
     #       checker tests already):