Throw error at annotation time

Author: terror

pyrefly/lib/alt/solve.rs

@@ -4028,6 +4028,25 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 "Type variable bounds and constraints must be concrete".to_owned(),
             );
         }
+        if type_form_context == TypeFormContext::TypeArgumentForType {
+            if let Some(cls) = match &ty {
+                Type::ClassType(cls) | Type::SelfType(cls) => Some(cls.class_object().clone()),
+                Type::ClassDef(cls) => Some(cls.clone()),
+                _ => None,
+            } {
+                if self.get_metadata_for_class(&cls).is_new_type() {
+                    return self.error(
+                        errors,
+                        range,
+                        ErrorInfo::Kind(ErrorKind::InvalidAnnotation),
+                        format!(
+                            "NewType `{}` is not a class and cannot be used with `type` or `Type`",
+                            cls.name()
+                        ),
+                    );
+                }
+            }
+        }
         ty
     }
 

pyrefly/lib/solver/solver.rs

@@ -1247,8 +1247,6 @@ pub enum SubsetError {
     /// An invariant was violated - used for cases that should be unreachabile when - if there is ever a bug - we
     /// would prefer to not panic and get a text location for reproducing rather than just a crash report.
     InternalError(String),
-    /// `typing.NewType` objects are functions, not classes, so they cannot be used with `type` or `type[...]`
-    NewTypeIsNotClass(Name),
     /// Protocol class names cannot be assigned to `type[P]` when `P` is a protocol
     TypeOfProtocolNeedsConcreteClass(Name),
     // TODO(rechen): replace this with specific reasons
@@ -1278,9 +1276,6 @@ impl SubsetError {
             SubsetError::TypedDict(err) => Some(err.to_error_msg()),
             SubsetError::OpenTypedDict(err) => Some(err.to_error_msg()),
             SubsetError::InternalError(msg) => Some(format!("Pyrefly internal error: {msg}")),
-            SubsetError::NewTypeIsNotClass(name) => Some(format!(
-                "NewType `{name}` is not a class and cannot be used with `type` or `type[...]`"
-            )),
             SubsetError::TypeOfProtocolNeedsConcreteClass(want) => Some(format!(
                 "Only concrete classes may be assigned to `type[{want}]` because `{want}` is a protocol"
             )),

pyrefly/lib/solver/subset.rs

@@ -1153,16 +1153,6 @@ impl<'a, Ans: LookupAnswer> Subset<'a, Ans> {
                 self.type_order.has_superclass(got, want),
                 SubsetError::Other,
             ),
-            // Although the object created by a NewType call behaves like a class for type-checking
-            // purposes, it isn't one at runtime, so don't allow it to match `type`.
-            (Type::ClassDef(got), Type::Type(_)) if self.type_order.is_new_type(got) => {
-                Err(SubsetError::NewTypeIsNotClass(got.name().clone()))
-            }
-            (Type::ClassDef(got), Type::ClassType(want))
-                if self.type_order.is_new_type(got) && want.is_builtin("type") =>
-            {
-                Err(SubsetError::NewTypeIsNotClass(got.name().clone()))
-            }
             (Type::ClassDef(got), Type::Type(box Type::ClassType(want)))
                 if self.type_order.is_protocol(want.class_object())
                     && self.type_order.is_protocol(got) =>

pyrefly/lib/test/new_type.rs

@@ -139,15 +139,16 @@ y: type[Any] = Foo  # E: `type[Foo]` is not assignable to `type[Any]`
 testcase!(
     test_new_type_type_argument,
     r#"
-from typing import NewType
+from typing import NewType, Type
 
 Thing = NewType("Thing", int)
-ThingType = type[Thing]
+ThingType = type[Thing]  # E: NewType `Thing` is not a class and cannot be used with `type` or `Type`
+OtherThingType = Type[Thing]  # E: NewType `Thing` is not a class and cannot be used with `type` or `Type`
 
-mapping: dict[int, ThingType] = {1: Thing}  # E: NewType `Thing` is not a class
+mapping: dict[int, ThingType] = {1: Thing}
 
 def func(x: ThingType) -> None: ...
-func(Thing)  # E: NewType `Thing` is not a class
+func(Thing)
     "#,
 );