Convert errors to notes for reveal_type(...)

Author: Michael0x2a

test-data/unit/check-enum.test

@@ -622,39 +622,39 @@ class Foo(Enum):
 
 x: Literal[Foo.A, Foo.B, Foo.C]
 if x is Foo.A:
-    reveal_type(x)  # E: Revealed type is 'Literal[__main__.Foo.A]'
+    reveal_type(x)  # N: Revealed type is 'Literal[__main__.Foo.A]'
 elif x is Foo.B:
-    reveal_type(x)  # E: Revealed type is 'Literal[__main__.Foo.B]'
+    reveal_type(x)  # N: Revealed type is 'Literal[__main__.Foo.B]'
 elif x is Foo.C:
-    reveal_type(x)  # E: Revealed type is 'Literal[__main__.Foo.C]'
+    reveal_type(x)  # N: Revealed type is 'Literal[__main__.Foo.C]'
 else:
     reveal_type(x)  # No output here: this branch is unreachable
 
 if Foo.A is x:
-    reveal_type(x)  # E: Revealed type is 'Literal[__main__.Foo.A]'
+    reveal_type(x)  # N: Revealed type is 'Literal[__main__.Foo.A]'
 elif Foo.B is x:
-    reveal_type(x)  # E: Revealed type is 'Literal[__main__.Foo.B]'
+    reveal_type(x)  # N: Revealed type is 'Literal[__main__.Foo.B]'
 elif Foo.C is x:
-    reveal_type(x)  # E: Revealed type is 'Literal[__main__.Foo.C]'
+    reveal_type(x)  # N: Revealed type is 'Literal[__main__.Foo.C]'
 else:
     reveal_type(x)  # No output here: this branch is unreachable
 
 y: Foo
 if y is Foo.A:
-    reveal_type(y)  # E: Revealed type is 'Literal[__main__.Foo.A]'
+    reveal_type(y)  # N: Revealed type is 'Literal[__main__.Foo.A]'
 elif y is Foo.B:
-    reveal_type(y)  # E: Revealed type is 'Literal[__main__.Foo.B]'
+    reveal_type(y)  # N: Revealed type is 'Literal[__main__.Foo.B]'
 elif y is Foo.C:
-    reveal_type(y)  # E: Revealed type is 'Literal[__main__.Foo.C]'
+    reveal_type(y)  # N: Revealed type is 'Literal[__main__.Foo.C]'
 else:
     reveal_type(y)  # No output here: this branch is unreachable
 
 if Foo.A is y:
-    reveal_type(y)  # E: Revealed type is 'Literal[__main__.Foo.A]'
+    reveal_type(y)  # N: Revealed type is 'Literal[__main__.Foo.A]'
 elif Foo.B is y:
-    reveal_type(y)  # E: Revealed type is 'Literal[__main__.Foo.B]'
+    reveal_type(y)  # N: Revealed type is 'Literal[__main__.Foo.B]'
 elif Foo.C is y:
-    reveal_type(y)  # E: Revealed type is 'Literal[__main__.Foo.C]'
+    reveal_type(y)  # N: Revealed type is 'Literal[__main__.Foo.C]'
 else:
     reveal_type(y)  # No output here: this branch is unreachable
 [builtins fixtures/bool.pyi]
@@ -675,45 +675,45 @@ y: Literal[Foo.A]
 z: Final = Foo.A
 
 if x is y:
-    reveal_type(x)  # E: Revealed type is 'Literal[__main__.Foo.A]'
-    reveal_type(y)  # E: Revealed type is 'Literal[__main__.Foo.A]'
+    reveal_type(x)  # N: Revealed type is 'Literal[__main__.Foo.A]'
+    reveal_type(y)  # N: Revealed type is 'Literal[__main__.Foo.A]'
 else:
-    reveal_type(x)  # E: Revealed type is 'Union[Literal[__main__.Foo.B], Literal[__main__.Foo.C]]'
-    reveal_type(y)  # E: Revealed type is 'Literal[__main__.Foo.A]'
+    reveal_type(x)  # N: Revealed type is 'Union[Literal[__main__.Foo.B], Literal[__main__.Foo.C]]'
+    reveal_type(y)  # N: Revealed type is 'Literal[__main__.Foo.A]'
 if y is x:
-    reveal_type(x)  # E: Revealed type is 'Literal[__main__.Foo.A]'
-    reveal_type(y)  # E: Revealed type is 'Literal[__main__.Foo.A]'
+    reveal_type(x)  # N: Revealed type is 'Literal[__main__.Foo.A]'
+    reveal_type(y)  # N: Revealed type is 'Literal[__main__.Foo.A]'
 else:
-    reveal_type(x)  # E: Revealed type is 'Union[Literal[__main__.Foo.B], Literal[__main__.Foo.C]]'
-    reveal_type(y)  # E: Revealed type is 'Literal[__main__.Foo.A]'
+    reveal_type(x)  # N: Revealed type is 'Union[Literal[__main__.Foo.B], Literal[__main__.Foo.C]]'
+    reveal_type(y)  # N: Revealed type is 'Literal[__main__.Foo.A]'
 
 if x is z:
-    reveal_type(x)  # E: Revealed type is 'Literal[__main__.Foo.A]'
-    reveal_type(z)  # E: Revealed type is '__main__.Foo'
+    reveal_type(x)  # N: Revealed type is 'Literal[__main__.Foo.A]'
+    reveal_type(z)  # N: Revealed type is '__main__.Foo'
     accepts_foo_a(z)
 else:
-    reveal_type(x)  # E: Revealed type is 'Union[Literal[__main__.Foo.B], Literal[__main__.Foo.C]]'
-    reveal_type(z)  # E: Revealed type is '__main__.Foo'
+    reveal_type(x)  # N: Revealed type is 'Union[Literal[__main__.Foo.B], Literal[__main__.Foo.C]]'
+    reveal_type(z)  # N: Revealed type is '__main__.Foo'
     accepts_foo_a(z)
 if z is x:
-    reveal_type(x)  # E: Revealed type is 'Literal[__main__.Foo.A]'
-    reveal_type(z)  # E: Revealed type is '__main__.Foo'
+    reveal_type(x)  # N: Revealed type is 'Literal[__main__.Foo.A]'
+    reveal_type(z)  # N: Revealed type is '__main__.Foo'
     accepts_foo_a(z)
 else:
-    reveal_type(x)  # E: Revealed type is 'Union[Literal[__main__.Foo.B], Literal[__main__.Foo.C]]'
-    reveal_type(z)  # E: Revealed type is '__main__.Foo'
+    reveal_type(x)  # N: Revealed type is 'Union[Literal[__main__.Foo.B], Literal[__main__.Foo.C]]'
+    reveal_type(z)  # N: Revealed type is '__main__.Foo'
     accepts_foo_a(z)
 
 if y is z:
-    reveal_type(y)  # E: Revealed type is 'Literal[__main__.Foo.A]'
-    reveal_type(z)  # E: Revealed type is '__main__.Foo'
+    reveal_type(y)  # N: Revealed type is 'Literal[__main__.Foo.A]'
+    reveal_type(z)  # N: Revealed type is '__main__.Foo'
     accepts_foo_a(z)
 else:
     reveal_type(y)  # No output: this branch is unreachable
     reveal_type(z)  # No output: this branch is unreachable
 if z is y:
-    reveal_type(y)  # E: Revealed type is 'Literal[__main__.Foo.A]'
-    reveal_type(z)  # E: Revealed type is '__main__.Foo'
+    reveal_type(y)  # N: Revealed type is 'Literal[__main__.Foo.A]'
+    reveal_type(z)  # N: Revealed type is '__main__.Foo'
     accepts_foo_a(z)
 else:
     reveal_type(y)  # No output: this branch is unreachable
@@ -735,18 +735,18 @@ z: Literal[Foo.B, Foo.C]
 
 # For the sake of simplicity, no narrowing is done when the narrower type is a Union.
 if x is y:
-    reveal_type(x)  # E: Revealed type is '__main__.Foo'
-    reveal_type(y)  # E: Revealed type is 'Union[Literal[__main__.Foo.A], Literal[__main__.Foo.B]]'
+    reveal_type(x)  # N: Revealed type is '__main__.Foo'
+    reveal_type(y)  # N: Revealed type is 'Union[Literal[__main__.Foo.A], Literal[__main__.Foo.B]]'
 else:
-    reveal_type(x)  # E: Revealed type is '__main__.Foo'
-    reveal_type(y)  # E: Revealed type is 'Union[Literal[__main__.Foo.A], Literal[__main__.Foo.B]]'
+    reveal_type(x)  # N: Revealed type is '__main__.Foo'
+    reveal_type(y)  # N: Revealed type is 'Union[Literal[__main__.Foo.A], Literal[__main__.Foo.B]]'
 
 if y is z:
-    reveal_type(y)  # E: Revealed type is 'Union[Literal[__main__.Foo.A], Literal[__main__.Foo.B]]'
-    reveal_type(z)  # E: Revealed type is 'Union[Literal[__main__.Foo.B], Literal[__main__.Foo.C]]'
+    reveal_type(y)  # N: Revealed type is 'Union[Literal[__main__.Foo.A], Literal[__main__.Foo.B]]'
+    reveal_type(z)  # N: Revealed type is 'Union[Literal[__main__.Foo.B], Literal[__main__.Foo.C]]'
 else:
-    reveal_type(y)  # E: Revealed type is 'Union[Literal[__main__.Foo.A], Literal[__main__.Foo.B]]'
-    reveal_type(z)  # E: Revealed type is 'Union[Literal[__main__.Foo.B], Literal[__main__.Foo.C]]'
+    reveal_type(y)  # N: Revealed type is 'Union[Literal[__main__.Foo.A], Literal[__main__.Foo.B]]'
+    reveal_type(z)  # N: Revealed type is 'Union[Literal[__main__.Foo.B], Literal[__main__.Foo.C]]'
 [builtins fixtures/bool.pyi]
 
 [case testEnumReachabilityWithNone]
@@ -761,19 +761,19 @@ class Foo(Enum):
 
 x: Optional[Foo]
 if x:
-    reveal_type(x)  # E: Revealed type is '__main__.Foo'
+    reveal_type(x)  # N: Revealed type is '__main__.Foo'
 else:
-    reveal_type(x)  # E: Revealed type is 'Union[__main__.Foo, None]'
+    reveal_type(x)  # N: Revealed type is 'Union[__main__.Foo, None]'
 
 if x is not None:
-    reveal_type(x)  # E: Revealed type is '__main__.Foo'
+    reveal_type(x)  # N: Revealed type is '__main__.Foo'
 else:
-    reveal_type(x)  # E: Revealed type is 'None'
+    reveal_type(x)  # N: Revealed type is 'None'
 
 if x is Foo.A:
-    reveal_type(x)  # E: Revealed type is 'Literal[__main__.Foo.A]'
+    reveal_type(x)  # N: Revealed type is 'Literal[__main__.Foo.A]'
 else:
-    reveal_type(x)  # E: Revealed type is 'Union[Literal[__main__.Foo.B], Literal[__main__.Foo.C], None]'
+    reveal_type(x)  # N: Revealed type is 'Union[Literal[__main__.Foo.B], Literal[__main__.Foo.C], None]'
 [builtins fixtures/bool.pyi]
 
 [case testEnumReachabilityWithMultipleEnums]
@@ -790,21 +790,21 @@ class Bar(Enum):
 
 x1: Union[Foo, Bar]
 if x1 is Foo.A:
-    reveal_type(x1)  # E: Revealed type is 'Literal[__main__.Foo.A]'
+    reveal_type(x1)  # N: Revealed type is 'Literal[__main__.Foo.A]'
 else:
-    reveal_type(x1)  # E: Revealed type is 'Union[Literal[__main__.Foo.B], __main__.Bar]'
+    reveal_type(x1)  # N: Revealed type is 'Union[Literal[__main__.Foo.B], __main__.Bar]'
 
 x2: Union[Foo, Bar]
 if x2 is Bar.A:
-    reveal_type(x2)  # E: Revealed type is 'Literal[__main__.Bar.A]'
+    reveal_type(x2)  # N: Revealed type is 'Literal[__main__.Bar.A]'
 else:
-    reveal_type(x2)  # E: Revealed type is 'Union[__main__.Foo, Literal[__main__.Bar.B]]'
+    reveal_type(x2)  # N: Revealed type is 'Union[__main__.Foo, Literal[__main__.Bar.B]]'
 
 x3: Union[Foo, Bar]
 if x3 is Foo.A or x3 is Bar.A:
-    reveal_type(x3)  # E: Revealed type is 'Union[Literal[__main__.Foo.A], Literal[__main__.Bar.A]]'
+    reveal_type(x3)  # N: Revealed type is 'Union[Literal[__main__.Foo.A], Literal[__main__.Bar.A]]'
 else:
-    reveal_type(x3)  # E: Revealed type is 'Union[Literal[__main__.Foo.B], Literal[__main__.Bar.B]]'
+    reveal_type(x3)  # N: Revealed type is 'Union[Literal[__main__.Foo.B], Literal[__main__.Bar.B]]'
 
 [builtins fixtures/bool.pyi]
 
@@ -823,13 +823,13 @@ def func(x: Union[int, None, Empty] = _empty) -> int:
                         # E: Unsupported left operand type for + ("Empty") \
                         # N: Left operand is of type "Union[int, None, Empty]"
     if x is _empty:
-        reveal_type(x)  # E: Revealed type is 'Literal[__main__.Empty.token]'
+        reveal_type(x)  # N: Revealed type is 'Literal[__main__.Empty.token]'
         return 0
     elif x is None:
-        reveal_type(x)  # E: Revealed type is 'None'
+        reveal_type(x)  # N: Revealed type is 'None'
         return 1
     else:  # At this point typechecker knows that x can only have type int
-        reveal_type(x)  # E: Revealed type is 'builtins.int'
+        reveal_type(x)  # N: Revealed type is 'builtins.int'
         return x + 2
 [builtins fixtures/primitives.pyi]
 
@@ -843,14 +843,14 @@ class Reason(Enum):
 
 def process(response: Union[str, Reason] = '') -> str:
     if response is Reason.timeout:
-        reveal_type(response)  # E: Revealed type is 'Literal[__main__.Reason.timeout]'
+        reveal_type(response)  # N: Revealed type is 'Literal[__main__.Reason.timeout]'
         return 'TIMEOUT'
     elif response is Reason.error:
-        reveal_type(response)  # E: Revealed type is 'Literal[__main__.Reason.error]'
+        reveal_type(response)  # N: Revealed type is 'Literal[__main__.Reason.error]'
         return 'ERROR'
     else:
         # response can be only str, all other possible values exhausted
-        reveal_type(response)  # E: Revealed type is 'builtins.str'
+        reveal_type(response)  # N: Revealed type is 'builtins.str'
         return 'PROCESSED: ' + response
 
 [builtins fixtures/primitives.pyi]