Fixing rules

Author: edmondop

pyrefly/lib/alt/call.rs

@@ -66,6 +66,8 @@ pub enum CallTarget {
     BoundMethod(Type, TargetWithTParams<Function>),
     /// A class object.
     Class(ClassType),
+    /// A class object called via type[Self] (returns Self instead of ClassType).
+    SelfClass(ClassType),
     /// A TypedDict.
     TypedDict(TypedDict),
     /// An overloaded function.
@@ -141,9 +143,12 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             Type::ClassDef(cls) => {
                 self.as_call_target_impl(Type::type_form(self.instantiate(&cls)), quantified)
             }
-            Type::Type(box Type::ClassType(cls)) | Type::Type(box Type::SelfType(cls)) => {
+            Type::Type(box Type::ClassType(cls)) => {
                 Some(CallTarget::Class(cls))
             }
+            Type::Type(box Type::SelfType(cls)) => {
+                Some(CallTarget::SelfClass(cls))
+            }
             Type::Type(box Type::Tuple(tuple)) => {
                 Some(CallTarget::Class(self.erase_tuple_type(tuple)))
             }
@@ -633,6 +638,45 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 };
                 self.construct_class(cls, args, keywords, range, errors, context, hint)
             }
+            CallTarget::SelfClass(cls) => {
+                if cls.has_qname("typing", "Any") {
+                    return self.error(
+                        errors,
+                        range,
+                        ErrorInfo::new(ErrorKind::BadInstantiation, context),
+                        format!("`{}` can not be instantiated", cls.name()),
+                    );
+                }
+                if self
+                    .get_metadata_for_class(cls.class_object())
+                    .is_protocol()
+                {
+                    self.error(
+                        errors,
+                        range,
+                        ErrorInfo::new(ErrorKind::BadInstantiation, context),
+                        format!(
+                            "Cannot instantiate `{}` because it is a protocol",
+                            cls.name()
+                        ),
+                    );
+                }
+                if cls.has_qname("builtins", "bool") {
+                    match self.first_arg_type(args, errors) {
+                        None => (),
+                        Some(ty) => self.check_dunder_bool_is_callable(&ty, range, errors),
+                    }
+                };
+                // Call construct_class but wrap result in SelfType
+                let result = self.construct_class(cls.clone(), args, keywords, range, errors, context, hint);
+                // If construct_class returned a ClassType matching our class, convert it to SelfType
+                match &result {
+                    Type::ClassType(result_cls) if result_cls.class_object() == cls.class_object() => {
+                        Type::SelfType(result_cls.clone())
+                    }
+                    _ => result, // Keep other return types as-is (e.g., from custom __new__)
+                }
+            }
             CallTarget::TypedDict(td) => {
                 self.construct_typed_dict(td, args, keywords, range, errors, context, hint)
             }

pyrefly/lib/alt/solve.rs

@@ -2679,27 +2679,6 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                             &|| TypeCheckContext::of_kind(TypeCheckKind::TypeGuardReturn);
                         self.expr(expr, hint.as_ref().map(|t| (t, tcc)), errors)
                     } else {
-                        if let Some(Type::SelfType(want_class)) = hint.as_ref()
-                            && !self.type_order().is_final(want_class.class_object())
-                        {
-                            let expr_type = self.expr(expr, None, errors);
-                            if let Type::ClassType(got_class) = &expr_type
-                                && got_class.class_object() == want_class.class_object()
-                            {
-                                self.error(
-                                            errors,
-                                            expr.range(),
-                                            ErrorInfo::Kind(ErrorKind::BadReturn),
-                                            format!(
-                                                "Returned type `{}` is not assignable to declared return type `Self@{}`",
-                                                got_class.class_object().name(),
-                                                want_class.class_object().name()
-                                            ),
-                                        );
-                            }
-                            return expr_type;
-                        }
-
                         let tcc: &dyn Fn() -> TypeCheckContext =
                             &|| TypeCheckContext::of_kind(TypeCheckKind::ExplicitFunctionReturn);
                         self.expr(expr, hint.as_ref().map(|t| (t, tcc)), errors)

pyrefly/lib/solver/subset.rs

@@ -1002,11 +1002,23 @@ impl<'a, Ans: LookupAnswer> Subset<'a, Ans> {
             {
                 self.is_subset_eq(&got, want)
             }
-            (Type::ClassType(got), Type::SelfType(want)) => ok_or(
-                self.type_order
-                    .has_superclass(got.class_object(), want.class_object()),
-                SubsetError::Other,
-            ),
+            (Type::ClassType(got), Type::SelfType(want)) => {
+                let has_superclass = self.type_order
+                    .has_superclass(got.class_object(), want.class_object());
+                // Only apply the finality check when:
+                // 1. The classes are the same
+                // 2. Both have no type arguments (i.e., they're the exact same bare type)
+                // This ensures NonFinalClass is not assignable to Self@NonFinalClass,
+                // but allows partial[int, str] to be assignable to Self@partial
+                let is_same_bare_class = got.class_object() == want.class_object()
+                    && got.targs().is_empty()
+                    && want.targs().is_empty();
+                let is_final = self.type_order.is_final(got.class_object());
+                ok_or(
+                    has_superclass && (!is_same_bare_class || is_final),
+                    SubsetError::Other,
+                )
+            },
             (Type::Type(box Type::ClassType(got)), Type::SelfType(want)) => ok_or(
                 self.type_order.has_metaclass(got.class_object(), want),
                 SubsetError::Other,