test backup

Gowee · Gowee · commit 847471759e42 · 2025-01-15T17:47:07.000+08:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/src/inferrer/optimizer.rs b/src/inferrer/optimizer.rs
@@ -58,6 +58,34 @@ impl Optimizer {
                 // when TypeArenaWithDSU is dropped
             }
         }
+        // drop(ufarena);
+        
+//         let sets = schema.arena.find_disjoint_sets(|a, b| {
+// if let (Some(a), Some(b)) = (a.as_union(), b.as_union()) {
+//                 self.to_merge_same_unions && (a.types == b.types)
+//             } else {
+//                 // TODO: merge same array?
+//                 false
+//             }
+//         });
+//         for (leader, mut set) in sets.into_iter() {
+//             if ufarena.get(leader).map(|r#type| {
+//                 self.to_merge_same_unions && r#type.is_union()
+//             }) == Some(true)
+//             {
+//                 set.insert(leader); // leader in disjoint set is now a follower
+
+//                 let compact_set = set
+//                     .iter()
+//                     .cloned()
+//                     .filter(|&r#type| ufarena.contains(r#type))
+//                     .collect::<Vec<ArenaIndex>>();
+//                 // unioned is now the new leader
+//                 let _leader = union(&mut ufarena, compact_set);
+//                 // References to non-representative AreneIndex will be replaced automatically
+//                 // when TypeArenaWithDSU is dropped
+//             }
+//         }
         // Although unioner always keeps the first map slot intact, there is no guarantee that
         // root would always be the first map in types to be unioned. So update it if necessary.
         schema.root = ufarena.find_representative(schema.root).unwrap();
@@ -120,6 +148,7 @@ pub struct TypeArenaWithDSU<'a> {
 
 impl<'a> TypeArenaWithDSU<'a> {
     fn from_type_arena(arena: &'a mut TypeArena) -> Self {
+        dbg!(arena.len());
         let imap: Bimap<usize, ArenaIndex> =
             Bimap::from_hash_map(arena.iter().map(|(index, _)| index).enumerate().collect());
 
@@ -189,7 +218,7 @@ impl<'a> TypeArenaWithDSU<'a> {
         for r#type in dangling_types.into_iter() {
             // TODO: Should these all removed during unioning?
             println!("removed dangling: {:?}", r#type);
-            assert!(self.arena.remove(r#type).is_none());
+            // debug_assert!(self.arena.remove(r#type).is_none());
         }
     }
 
@@ -237,21 +266,29 @@ impl<'a> ITypeArena for TypeArenaWithDSU<'a> {
         // Note: It is not removed from DSU. So just ignore non-existing types when iterating DSU.
         //       As get/get_mut wraps DSU internally, unioner won't get panicked.
         DerefMut::deref_mut(self).remove(i)
+        // DerefMut::deref_mut(self).get(i).cloned()
     }
 
     /// Remove the type denoted by the index i and union i into j in the DSU
     fn remove_in_favor_of(&mut self, i: ArenaIndex, j: ArenaIndex) -> Option<Type> {
+        dbg!(i,j, self.imap.len(), self.arena.len());
+
         self.dsu.union(
             *self.imap.get_rev(&i).unwrap(),
             *self.imap.get_rev(&j).unwrap(),
         );
-        DerefMut::deref_mut(self).remove(i)
+        // DerefMut::deref_mut(self).remove(i)
+        DerefMut::deref_mut(self).get(i).cloned()
     }
 
     #[inline(always)]
     fn insert(&mut self, value: Type) -> ArenaIndex {
         // Note: The DSU is not updated.
-        DerefMut::deref_mut(self).insert(value)
+        debug_assert_eq!(self.dsu.len(), self.imap.len());
+        let i = self.dsu.alloc();
+        let arni = DerefMut::deref_mut(self).insert(value);
+        self.imap.insert(i, arni);
+        arni
     }
 
     #[inline(always)]
diff --git a/src/inferrer/unioner.rs b/src/inferrer/unioner.rs
@@ -44,7 +44,11 @@ impl<'a, T: ITypeArena> UnionerClosure<'a, T> {
         // TODO: keep first_array?
 
         // Expand any nested unions. Due to borrow issues, collecting is inevitable
-        let types: Vec<ArenaIndex> = types
+        let mut types: Vec<ArenaIndex> = types.into_iter().collect();
+        let mut changed = true;
+        while changed {
+            changed = false;
+            types = types
             .into_iter()
             .flat_map(|r#type| {
                 // dbg!(r#type);
@@ -54,10 +58,12 @@ impl<'a, T: ITypeArena> UnionerClosure<'a, T> {
                     .expect("The type should be present in the arena during unioning")
                 {
                     Type::Union(_) => {
+                        changed = true;
                         let Union { name_hints, types } = if let Some(first_union) = first_union {
-                            self.arena
+                            dbg!(r#type, first_union);
+                            dbg!(self.arena
                                 .remove_in_favor_of(r#type, first_union)
-                                .unwrap()
+                                .unwrap())
                                 .into_union()
                                 .unwrap() // remove & expand the union
                         } else {
@@ -75,6 +81,7 @@ impl<'a, T: ITypeArena> UnionerClosure<'a, T> {
             .collect::<HashSet<_>>()
             .into_iter()
             .collect();
+        }
         for r#type in types {
             // dbg!(r#type, self.arena.get(r#type));
             match *self.arena.get(r#type).unwrap() {
@@ -111,6 +118,7 @@ impl<'a, T: ITypeArena> UnionerClosure<'a, T> {
                     arrays.push(inner);
                 }
                 Type::Union(_) => unreachable!(), // union should have been expanded above
+                Type::Undetermined => unreachable!(),
                 _ => {
                     // O.W. it is a primitive type. Then just add it to the union as is.
                     // Note: SPECIAL CASE:
@@ -162,6 +170,7 @@ impl<'a, T: ITypeArena> UnionerClosure<'a, T> {
                 // TODO: should slot be removed from arena here?
                 unioned.insert(self.arena.get_index_of_primitive(Type::Any)); // Any
             } else {
+                dbg!(map_count);
                 let slot = first_map.unwrap();
                 *self.arena.get_mut(slot).unwrap() = Type::Map(Map {
                     name_hints: map_name_hints,
diff --git a/src/main.rs b/src/main.rs
@@ -1,3 +1,26 @@
+use serde_json::Value;
+
+use json2pyi::inferrer::*;
+use json2pyi::target::{
+    Indentation, PythonClass, PythonKind, PythonTypedDict, Quote, TargetGenerator,
+};
+
 fn main() {
-    println!("Hello, world!");
+    let data = include_str!("../tests/data/issue8.json");
+    let v: Value = serde_json::from_str(data).unwrap();
+
+    let mut schema = infer_from_json(&v, None);
+    dbg!("BUMP1");
+    Optimizer {
+        to_merge_similar_datatypes: true,
+        to_merge_same_unions: true,
+    }
+    .optimize(&mut schema);
+    dbg!("BUMP2");
+    let _output = PythonClass {
+        kind: PythonKind::Dataclass,
+        to_generate_type_alias_for_union: false,
+        indentation: Indentation::Space(4),
+    }
+    .generate(&schema);
 }
diff --git a/src/schema/mod.rs b/src/schema/mod.rs
@@ -37,8 +37,9 @@ pub enum Type {
     UUID,
     Null,
     Missing,
-    #[default]
     Any,
+    #[default]
+    Undetermined,
 }
 
 pub struct TopdownIter<'a> {
diff --git a/src/target/python_class.rs b/src/target/python_class.rs
@@ -283,6 +283,7 @@ impl<'i, 'c> Display for Contexted<&'i Type, Context<'c>> {
             Type::Null => write!(f, "None"),
             Type::Missing => write!(f, "Missing"),
             Type::Any => write!(f, "Any"),
+            Type::Undetermined => unreachable!()
         }
     }
 }
diff --git a/src/target/python_inline.rs b/src/target/python_inline.rs
@@ -272,6 +272,7 @@ impl<'c> Display for Contexted<ArenaIndex, Context<'c>> {
             Type::Null => write!(f, "None"),
             Type::Missing => write!(f, "Missing"),
             Type::Any => write!(f, "Any"),
+            Type::Undetermined => unreachable!()
         }
     }
 }
diff --git a/src/tests.rs b/src/tests.rs
@@ -70,3 +70,43 @@ fn test_tree_recursion() {
     }
     .generate(&schema);
 }
+
+#[test]
+fn test_issue8_1() {
+    let data = include_str!("../tests/data/issue8.json");
+    let v: Value = serde_json::from_str(data).unwrap();
+
+    let mut schema = infer_from_json(&v, None);
+    dbg!("BUMP1");
+    Optimizer {
+        to_merge_similar_datatypes: true,
+        to_merge_same_unions: true,
+    }
+    .optimize(&mut schema);
+    dbg!("BUMP2");
+    let _output = PythonClass {
+        kind: PythonKind::Dataclass,
+        to_generate_type_alias_for_union: false,
+        indentation: Indentation::Space(4),
+    }
+    .generate(&schema);
+}
+
+#[test]
+fn test_issue8_2() {
+    let data = include_str!("../tests/data/issue8-2.json");
+    let v: Value = serde_json::from_str(data).unwrap();
+
+    let mut schema = infer_from_json(&v, None);
+    Optimizer {
+        to_merge_similar_datatypes: true,
+        to_merge_same_unions: true,
+    }
+    .optimize(&mut schema);
+    let _output = PythonClass {
+        kind: PythonKind::Dataclass,
+        to_generate_type_alias_for_union: false,
+        indentation: Indentation::Space(4),
+    }
+    .generate(&schema);
+}

Original file line number	Diff line number	Diff line change
`@@ -283,6 +283,7 @@ impl<'i, 'c> Display for Contexted<&'i Type, Context<'c>> {`
`283`	`283`	`Type::Null => write!(f, "None"),`
`284`	`284`	`Type::Missing => write!(f, "Missing"),`
`285`	`285`	`Type::Any => write!(f, "Any"),`
	`286`	`+ Type::Undetermined => unreachable!()`
`286`	`287`	`}`
`287`	`288`	`}`
`288`	`289`	`}`
Original file line number	Diff line number	Diff line change
`@@ -272,6 +272,7 @@ impl<'c> Display for Contexted<ArenaIndex, Context<'c>> {`
`272`	`272`	`Type::Null => write!(f, "None"),`
`273`	`273`	`Type::Missing => write!(f, "Missing"),`
`274`	`274`	`Type::Any => write!(f, "Any"),`
	`275`	`+ Type::Undetermined => unreachable!()`
`275`	`276`	`}`
`276`	`277`	`}`
`277`	`278`	`}`