Revert "Re-enable property tests on fully static types"

This reverts commit 1a992f537c97289454dc9f8ecf3c17746b221947.

Author: carljm

crates/ty_python_semantic/src/types/property_tests.rs

@@ -50,19 +50,9 @@ macro_rules! type_property_test {
             $property
         }
     };
-    ($test_name:ident, $db:ident, forall fully_static_types $($types:ident),+ . $property:expr) => {
-        #[quickcheck_macros::quickcheck]
-        #[ignore]
-        fn $test_name($($types: crate::types::property_tests::type_generation::FullyStaticTy),+) -> bool {
-            let $db = &crate::types::property_tests::setup::get_cached_db();
-            $(let $types = $types.into_type($db);)+
-
-            $property
-        }
-    };
     // A property test with a logical implication.
-    ($name:ident, $db:ident, forall $typekind:ident $($types:ident),+ . $premise:expr => $conclusion:expr) => {
-        type_property_test!($name, $db, forall $typekind $($types),+ . !($premise) || ($conclusion));
+    ($name:ident, $db:ident, forall types $($types:ident),+ . $premise:expr => $conclusion:expr) => {
+        type_property_test!($name, $db, forall types $($types),+ . !($premise) || ($conclusion));
     };
 }
 
@@ -172,18 +162,6 @@ mod stable {
         all_type_pairs_are_assignable_to_their_union, db,
         forall types s, t. s.is_assignable_to(db, union(db, [s, t])) && t.is_assignable_to(db, union(db, [s, t]))
     );
-
-    // A fully static type `T` is a subtype of itself.
-    type_property_test!(
-        subtype_of_is_reflexive_for_fully_static_types, db,
-        forall fully_static_types t. t.is_subtype_of(db, t)
-    );
-
-    // For any two fully static types, each type in the pair must be a subtype of their union.
-    type_property_test!(
-        all_fully_static_type_pairs_are_subtype_of_their_union, db,
-        forall fully_static_types s, t. s.is_subtype_of(db, union(db, [s, t])) && t.is_subtype_of(db, union(db, [s, t]))
-    );
 }
 
 /// This module contains property tests that currently lead to many false positives.
@@ -198,6 +176,22 @@ mod flaky {
 
     use super::{intersection, union};
 
+    // --- These only apply to fully static types; need a way to generate fully-static types only.
+
+    // A type `T` is a subtype of itself.
+    type_property_test!(
+        subtype_of_is_reflexive, db,
+        forall types t. t.is_subtype_of(db, t)
+    );
+
+    // For any two types, each type in the pair must be a subtype of their union.
+    type_property_test!(
+        all_type_pairs_are_subtype_of_their_union, db,
+        forall types s, t. s.is_subtype_of(db, union(db, [s, t])) && t.is_subtype_of(db, union(db, [s, t]))
+    );
+
+    // ---
+
     // Negating `T` twice is equivalent to `T`.
     type_property_test!(
         double_negation_is_identity, db,

crates/ty_python_semantic/src/types/property_tests/type_generation.rs

@@ -200,31 +200,16 @@ impl Ty {
     }
 }
 
-#[derive(Debug, Clone, PartialEq)]
-pub(crate) struct FullyStaticTy(Ty);
-
-impl FullyStaticTy {
-    pub(crate) fn into_type(self, db: &TestDb) -> Type<'_> {
-        self.0.into_type(db)
-    }
-}
-
-fn arbitrary_core_type(g: &mut Gen, fully_static: bool) -> Ty {
+fn arbitrary_core_type(g: &mut Gen) -> Ty {
     // We could select a random integer here, but this would make it much less
     // likely to explore interesting edge cases:
     let int_lit = Ty::IntLiteral(*g.choose(&[-2, -1, 0, 1, 2]).unwrap());
     let bool_lit = Ty::BooleanLiteral(bool::arbitrary(g));
-
-    // Update this if new non-fully-static types are added below.
-    let fully_static_index = 3;
-    let types = &[
-        Ty::Any,
-        Ty::Unknown,
-        Ty::SubclassOfAny,
-        // Add fully static types below, dynamic types above.
-        // Update `fully_static_index` above if adding new dynamic types!
+    g.choose(&[
         Ty::Never,
+        Ty::Unknown,
         Ty::None,
+        Ty::Any,
         int_lit,
         bool_lit,
         Ty::StringLiteral(""),
@@ -249,6 +234,7 @@ fn arbitrary_core_type(g: &mut Gen, fully_static: bool) -> Ty {
         Ty::BuiltinInstance("type"),
         Ty::AbcInstance("ABC"),
         Ty::AbcInstance("ABCMeta"),
+        Ty::SubclassOfAny,
         Ty::SubclassOfBuiltinClass("object"),
         Ty::SubclassOfBuiltinClass("str"),
         Ty::SubclassOfBuiltinClass("type"),
@@ -268,59 +254,54 @@ fn arbitrary_core_type(g: &mut Gen, fully_static: bool) -> Ty {
             class: "int",
             method: "bit_length",
         },
-    ];
-    let types = if fully_static {
-        &types[fully_static_index..]
-    } else {
-        types
-    };
-    g.choose(types).unwrap().clone()
+    ])
+    .unwrap()
+    .clone()
 }
 
 /// Constructs an arbitrary type.
 ///
 /// The `size` parameter controls the depth of the type tree. For example,
 /// a simple type like `int` has a size of 0, `Union[int, str]` has a size
 /// of 1, `tuple[int, Union[str, bytes]]` has a size of 2, etc.
-///
-/// The `fully_static` parameter, if `true`, limits generation to fully static types.
-fn arbitrary_type(g: &mut Gen, size: u32, fully_static: bool) -> Ty {
+fn arbitrary_type(g: &mut Gen, size: u32) -> Ty {
     if size == 0 {
-        arbitrary_core_type(g, fully_static)
+        arbitrary_core_type(g)
     } else {
         match u32::arbitrary(g) % 5 {
-            0 => arbitrary_core_type(g, fully_static),
+            0 => arbitrary_core_type(g),
             1 => Ty::Union(
                 (0..*g.choose(&[2, 3]).unwrap())
-                    .map(|_| arbitrary_type(g, size - 1, fully_static))
+                    .map(|_| arbitrary_type(g, size - 1))
                     .collect(),
             ),
             2 => Ty::Tuple(
                 (0..*g.choose(&[0, 1, 2]).unwrap())
-                    .map(|_| arbitrary_type(g, size - 1, fully_static))
+                    .map(|_| arbitrary_type(g, size - 1))
                     .collect(),
             ),
             3 => Ty::Intersection {
                 pos: (0..*g.choose(&[0, 1, 2]).unwrap())
-                    .map(|_| arbitrary_type(g, size - 1, fully_static))
+                    .map(|_| arbitrary_type(g, size - 1))
                     .collect(),
                 neg: (0..*g.choose(&[0, 1, 2]).unwrap())
-                    .map(|_| arbitrary_type(g, size - 1, fully_static))
+                    .map(|_| arbitrary_type(g, size - 1))
                     .collect(),
             },
             4 => Ty::Callable {
                 params: match u32::arbitrary(g) % 2 {
-                    0 if !fully_static => CallableParams::GradualForm,
-                    _ => CallableParams::List(arbitrary_parameter_list(g, size, fully_static)),
+                    0 => CallableParams::GradualForm,
+                    1 => CallableParams::List(arbitrary_parameter_list(g, size)),
+                    _ => unreachable!(),
                 },
-                returns: arbitrary_annotation(g, size - 1, fully_static).map(Box::new),
+                returns: arbitrary_optional_type(g, size - 1).map(Box::new),
             },
             _ => unreachable!(),
         }
     }
 }
 
-fn arbitrary_parameter_list(g: &mut Gen, size: u32, fully_static: bool) -> Vec<Param> {
+fn arbitrary_parameter_list(g: &mut Gen, size: u32) -> Vec<Param> {
     let mut params: Vec<Param> = vec![];
     let mut used_names = HashSet::new();
 
@@ -372,31 +353,22 @@ fn arbitrary_parameter_list(g: &mut Gen, size: u32, fully_static: bool) -> Vec<P
         params.push(Param {
             kind: next_kind,
             name,
-            annotated_ty: arbitrary_annotation(g, size, fully_static),
+            annotated_ty: arbitrary_optional_type(g, size),
             default_ty: if matches!(next_kind, ParamKind::Variadic | ParamKind::KeywordVariadic) {
                 None
             } else {
-                arbitrary_optional_type(g, size, fully_static)
+                arbitrary_optional_type(g, size)
             },
         });
     }
 
     params
 }
 
-/// An arbitrary optional type, always `Some` if fully static.
-fn arbitrary_annotation(g: &mut Gen, size: u32, fully_static: bool) -> Option<Ty> {
-    if fully_static {
-        Some(arbitrary_type(g, size, true))
-    } else {
-        arbitrary_optional_type(g, size, false)
-    }
-}
-
-fn arbitrary_optional_type(g: &mut Gen, size: u32, fully_static: bool) -> Option<Ty> {
+fn arbitrary_optional_type(g: &mut Gen, size: u32) -> Option<Ty> {
     match u32::arbitrary(g) % 2 {
         0 => None,
-        1 => Some(arbitrary_type(g, size, fully_static)),
+        1 => Some(arbitrary_type(g, size)),
         _ => unreachable!(),
     }
 }
@@ -416,7 +388,7 @@ fn arbitrary_optional_name(g: &mut Gen) -> Option<Name> {
 impl Arbitrary for Ty {
     fn arbitrary(g: &mut Gen) -> Ty {
         const MAX_SIZE: u32 = 2;
-        arbitrary_type(g, MAX_SIZE, false)
+        arbitrary_type(g, MAX_SIZE)
     }
 
     fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
@@ -480,17 +452,6 @@ impl Arbitrary for Ty {
     }
 }
 
-impl Arbitrary for FullyStaticTy {
-    fn arbitrary(g: &mut Gen) -> FullyStaticTy {
-        const MAX_SIZE: u32 = 2;
-        FullyStaticTy(arbitrary_type(g, MAX_SIZE, true))
-    }
-
-    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
-        Box::new(self.0.shrink().map(FullyStaticTy))
-    }
-}
-
 pub(crate) fn intersection<'db>(
     db: &'db TestDb,
     tys: impl IntoIterator<Item = Type<'db>>,