More complete class interval computation

Summary:
Changes the class interval computation to support internal classes deriving from external classes. Specifically, as documented in the comments:

```
  // Theoretically, all classes are rooted in java.lang.Object. In practice,
  // internal classes inheriting from external classes will not be reachable
  // from Object. Treat the class hierarchy as a forest of trees, with roots
  // being either direct children of Object or internal classes deriving
  // directly from external classes.
```

Previously, internal classes that derived from external classes had no intervals (top).

Reviewed By: anwesht

Differential Revision: D71085091

fbshipit-source-id: 156d790af70bf5b7c0383a70997c385d1d34c01b

Author: Yuh Shin Ong

source/ClassIntervals.cpp

@@ -32,13 +32,16 @@ void dfs_on_hierarchy(
   mt_assert(children != class_hierarchy.end());
 
   for (const auto* child : children->second) {
+    mt_assert(
+        dfs_order <
+        std::numeric_limits<int32_t>::max()); // Ensure no overflows.
     ++dfs_order;
-    mt_assert(dfs_order > 0); // Ensure no overflows.
     dfs_on_hierarchy(class_hierarchy, child, dfs_order, result);
   }
 
+  mt_assert(
+      dfs_order < std::numeric_limits<int32_t>::max()); // Ensure no overflows.
   ++dfs_order;
-  mt_assert(dfs_order > 0); // Ensure no overflows.
 
   // Each node should only be visited once since multiple inheritance is not
   // supported by Java/Kotlin.
@@ -53,22 +56,50 @@ ClassIntervals::ClassIntervals(
     const Options& options,
     const DexStoresVector& stores)
     : top_(Interval::top()) {
+  // Theoretically, all classes are rooted in java.lang.Object. In practice,
+  // internal classes inheriting from external classes will not be reachable
+  // from Object. Treat the class hierarchy as a forest of trees, with roots
+  // being either direct children of Object or internal classes deriving
+  // directly from external classes.
   ClassHierarchy class_hierarchy;
+  const auto* object_root = type::java_lang_Object();
+
+  // Use a deterministic ordering for the roots so that integration tests always
+  // return the same interval for the same class.
+  std::set<const DexType*, dextypes_comparator> roots;
+
   for (const auto& scope : DexStoreClassesIterator(stores)) {
     auto store_hierarchy = build_type_hierarchy(scope);
     for (const auto& [parent, children] : store_hierarchy) {
-      class_hierarchy[parent].insert(children.begin(), children.end());
+      if (parent == object_root) {
+        roots.insert(children.begin(), children.end());
+      } else {
+        const auto* parent_class = type_class(parent);
+        if (parent_class == nullptr) {
+          // DexType exists but not DexClass, this is an external class.
+          continue;
+        }
+
+        class_hierarchy[parent].insert(children.begin(), children.end());
+
+        const auto* super_class = type_class(parent_class->get_super_class());
+        if (super_class == nullptr) {
+          // DexClass does not exist for for the super class. This is a root
+          // (derives directly from an external class).
+          roots.insert(parent_class->get_type());
+        }
+      }
     }
   }
 
-  // Assuming the code is known, all classes will be rooted in java.lang.Object.
-  // Optimization: Divide the single hierarchy into multiple, with roots at
-  // direct children of Object, then compute in parallel. Need to make sure
-  // dfs_order does not intersect between different trees.
-  const auto* root = type::java_lang_Object();
-
   std::int32_t dfs_order = MIN_INTERVAL;
-  dfs_on_hierarchy(class_hierarchy, root, dfs_order, class_intervals_);
+  for (const auto* root : roots) {
+    dfs_on_hierarchy(class_hierarchy, root, dfs_order, class_intervals_);
+    mt_assert(
+        dfs_order <
+        std::numeric_limits<int32_t>::max()); // Ensure no overflows.
+    ++dfs_order;
+  }
 
   if (options.dump_class_intervals()) {
     auto class_intervals_path = options.class_intervals_output_path();

source/ClassIntervals.h

@@ -60,7 +60,8 @@ class ClassIntervals final {
   /**
    * Returns the most precisely known interval of the given type.
    * This is generally the computed type, but can be the open interval, such as
-   * when class interval computation is disabled, or for non-class types.
+   * when class interval computation is disabled, or for non-class types, or
+   * java.lang.Object.
    */
   const Interval& get_interval(const DexType* type) const;
 

source/tests/ClassIntervalsTest.cpp

@@ -37,17 +37,16 @@ TEST_F(ClassIntervalsTest, IntervalComputation) {
   Scope scope;
 
   // Construct simple class hierarchy, rooted in BaseA and BaseB.
-  // Note that Object() is still the root of everything.
 
-  // BaseA -> DerivedA1
-  //       -> DerivedA2
+  // BaseA [0,5] -> DerivedA1 [1,2]
+  //             -> DerivedA2 [3,4]
   const auto* a = marianatrench::redex::create_class(scope, "LBaseA;");
   const auto* a1 =
       marianatrench::redex::create_class(scope, "LDerivedA1;", a->get_type());
   const auto* a2 =
       marianatrench::redex::create_class(scope, "LDerivedA2;", a->get_type());
 
-  // BaseB -> DerivedB1 -> DerivedB1_1
+  // BaseB [6,11] -> DerivedB1 [7,10] -> DerivedB1_1 [8,9]
   const auto* b = marianatrench::redex::create_class(scope, "LBaseB;");
   const auto* b1 =
       marianatrench::redex::create_class(scope, "LDerivedB1;", b->get_type());
@@ -57,26 +56,26 @@ TEST_F(ClassIntervalsTest, IntervalComputation) {
   auto context = test_context(scope);
 
   auto interval_a = context.class_intervals->get_interval(a->get_type());
-  EXPECT_EQ(ClassIntervals::Interval::finite(1, 6), interval_a);
+  EXPECT_EQ(ClassIntervals::Interval::finite(0, 5), interval_a);
 
   auto interval_a1 = context.class_intervals->get_interval(a1->get_type());
-  EXPECT_EQ(ClassIntervals::Interval::finite(2, 3), interval_a1);
+  EXPECT_EQ(ClassIntervals::Interval::finite(1, 2), interval_a1);
 
   auto interval_a2 = context.class_intervals->get_interval(a2->get_type());
-  EXPECT_EQ(ClassIntervals::Interval::finite(4, 5), interval_a2);
+  EXPECT_EQ(ClassIntervals::Interval::finite(3, 4), interval_a2);
 
   auto interval_b = context.class_intervals->get_interval(b->get_type());
-  EXPECT_EQ(ClassIntervals::Interval::finite(7, 12), interval_b);
+  EXPECT_EQ(ClassIntervals::Interval::finite(6, 11), interval_b);
 
   auto interval_b1 = context.class_intervals->get_interval(b1->get_type());
-  EXPECT_EQ(ClassIntervals::Interval::finite(8, 11), interval_b1);
+  EXPECT_EQ(ClassIntervals::Interval::finite(7, 10), interval_b1);
 
   auto interval_b1_1 = context.class_intervals->get_interval(b1_1->get_type());
-  EXPECT_EQ(ClassIntervals::Interval::finite(9, 10), interval_b1_1);
+  EXPECT_EQ(ClassIntervals::Interval::finite(8, 9), interval_b1_1);
 
   auto interval_object =
       context.class_intervals->get_interval(type::java_lang_Object());
-  EXPECT_EQ(ClassIntervals::Interval::finite(0, 13), interval_object);
+  EXPECT_EQ(ClassIntervals::Interval::top(), interval_object);
 }
 
 TEST_F(ClassIntervalsTest, ClassIntervalSerializationDeserialization) {