fix false-positive in raise..from

Summary:
fixes #1405

We had special-casing for None already, but did not handle when it appears in a union.

Reviewed By: kinto0

Differential Revision: D85674425

fbshipit-source-id: 258c1c35afe0b3858ecc9519e569788940b44997

Author: yangdanny97

crates/pyrefly_config/src/error_kind.rs

@@ -117,6 +117,8 @@ pub enum ErrorKind {
     /// A subclass method incorrectly changes the name of a positional parameter while overriding
     /// a method of a parent class.
     BadParamNameOverride,
+    /// Invalid exception or cause in `raise` statement.
+    BadRaise,
     /// Attempting to return a value that does not match the function's return type.
     /// Can also arise when returning values from generators.
     BadReturn,

pyrefly/lib/alt/solve.rs

@@ -799,22 +799,25 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         errors: &ErrorCollector,
     ) {
         let actual_type = self.expr_infer(x, errors);
-        if allow_none && actual_type.is_none() {
-            return;
-        }
         let base_exception_class = self.stdlib.base_exception();
         let base_exception_class_type = Type::ClassDef(base_exception_class.class_object().dupe());
         let base_exception_type = base_exception_class.clone().to_type();
-        let expected_types = vec![base_exception_type, base_exception_class_type];
+        let mut expected_types = vec![base_exception_type, base_exception_class_type];
+        let mut expected = "`BaseException`";
+        if allow_none {
+            expected_types.push(Type::None);
+            expected = "`BaseException` or `None`"
+        }
         if !self.is_subset_eq(&actual_type, &Type::Union(expected_types)) {
             self.error(
                 errors,
                 range,
-                ErrorInfo::Kind(ErrorKind::InvalidInheritance),
+                ErrorInfo::Kind(ErrorKind::BadRaise),
                 format!(
-                    "Expression `{}` has type `{}` which does not derive from BaseException",
+                    "Expression `{}` has type `{}`, expected {}",
                     self.module().display(x),
                     self.for_display(actual_type),
+                    expected,
                 ),
             );
         }

pyrefly/lib/test/simple.rs

@@ -422,17 +422,18 @@ assert_type(0 if derp() else 1, Literal[0] | Literal[1])
 testcase!(
     test_raise,
     r#"
-def test_raise() -> None:
+def test_raise(exception_or_none: BaseException | None) -> None:
     raise
-    raise None  # E: does not derive from BaseException
+    raise None  # E: expected `BaseException`
     raise BaseException
     raise BaseException()
-    raise 42  # E: does not derive from BaseException
+    raise 42  # E: expected `BaseException`
     raise BaseException from None
     raise BaseException() from None
     raise BaseException() from BaseException
     raise BaseException() from BaseException()
-    raise BaseException() from 42   # E: does not derive from BaseException
+    raise BaseException() from 42   # E: expected `BaseException` or `None`
+    raise BaseException() from exception_or_none
 "#,
 );
 

website/docs/error-kinds.mdx

@@ -272,6 +272,19 @@ def f(base: Base):
 f(Sub())  # oops!
 ```
 
+## bad-raise
+
+In a `raise` statement of the form `raise x from y`, `x` must be an exception, and `y` must be an exception or `None`.
+
+```python
+def bad_raise() -> None:
+  raise Exception()  # ok
+  raise 1  # error
+  raise Exception() from None # ok
+  raise Exception() from Exception() # ok
+  raise Exception() from 1 # error
+```
+
 ## bad-return
 
 Arises when a function does not return a value that is compatible with the function's return type annotation.