fix(solver): enforce nominal subtyping for NewType wrappers (#3081)

pyrefly/lib/alt/class/class_metadata.rs

@@ -1109,6 +1109,12 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 // The alias body is `type[T]` for bare aliases and `Annotated[T]` for Annotated aliases;
                 // we must handle both.
                 match &ty {
+                    Type::Type(box Type::ClassType(cls))
+                        if cls.class_object() == self.stdlib.builtins_type().class_object()
+                            && let Some(subscript_base_expr) = BaseClassExpr::from_expr(slice) =>
+                    {
+                        self.base_class_expr_infer_for_metadata(&subscript_base_expr, errors)
+                    }
                     Type::Forall(forall)
                         if forall.tparams.len() == 1
                             && let Forallable::TypeAlias(type_alias) = &forall.body
@@ -1179,6 +1185,28 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     }
                 }
             }
+            Type::None if is_new_type => {
+                let base_cls = self.stdlib.none_type().class_object();
+                let metadata = self.get_metadata_for_class(base_cls);
+                BaseClassParseResult::Parsed({
+                    ParsedBaseClass {
+                        class_object: base_cls.dupe(),
+                        range,
+                        metadata,
+                    }
+                })
+            }
+            Type::Type(box Type::None) if is_new_type => {
+                let base_cls = self.stdlib.none_type().class_object();
+                let metadata = self.get_metadata_for_class(base_cls);
+                BaseClassParseResult::Parsed({
+                    ParsedBaseClass {
+                        class_object: base_cls.dupe(),
+                        range,
+                        metadata,
+                    }
+                })
+            }
             Type::Type(box Type::Any(_)) => {
                 // `type[Any]` is equivalent to `type` or `Type`
                 let type_obj = self.stdlib.builtins_type().class_object();
@@ -1337,8 +1365,10 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     range,
                     metadata,
                 }) => {
-                    if metadata.is_final()
-                        || (metadata.is_enum() && !self.get_enum_members(&class_object).is_empty())
+                    if !is_new_type
+                        && (metadata.is_final()
+                            || (metadata.is_enum()
+                                && !self.get_enum_members(&class_object).is_empty()))
                     {
                         self.error(
                             errors,

pyrefly/lib/test/new_type.rs

@@ -163,6 +163,39 @@ Foo.mro()  # E: Object of class `object` has no attribute `mro`
     "#,
 );
 
+testcase!(
+    test_newtype_none_is_nominal,
+    r#"
+from typing import NewType
+from types import NoneType
+
+NewNoneType = NewType("NewNoneType", NoneType)
+NewNone = NewNoneType(None)
+
+def test(x: int | NewNoneType) -> None:
+    pass
+
+test(None)  # E: Argument `None` is not assignable to parameter `x` with type `NewNoneType | int` in function `test`
+test(NewNone)
+test(1)
+    "#,
+);
+
+testcase!(
+    test_newtype_type_none_is_nominal,
+    r#"
+from typing import NewType
+
+NewNoneType = NewType("NewNoneType", type[None])
+
+def test(x: int | NewNoneType) -> None:
+    pass
+
+test(None)  # E: Argument `None` is not assignable to parameter `x` with type `NewNoneType | int` in function `test`
+test(1)
+    "#,
+);
+
 testcase!(
     test_tuple,
     r#"