Relax can delete class check for ifields on anonymous classes

Summary: The synthesized ifields of Kotlin lambda classes can be kept by overly conservative keep rules. It's not necessary to drop the majority of them from the merging targets because of that.

Reviewed By: wsanville

Differential Revision: D90085706

fbshipit-source-id: 089bb30b713345e5c5f01652b80111a20c7f94e8

Author: thezhangwei

libredex/TypeUtil.cpp

@@ -598,6 +598,14 @@ bool is_kotlin_non_capturing_lambda(const DexClass* cls) {
   return false;
 }
 
+bool is_kotlin_internal_type(const DexType* type) {
+  return type == type::kotlin_jvm_internal_Lambda() ||
+         type == type::kotlin_coroutines_jvm_internal_ContinuationImpl() ||
+         type ==
+             type::kotlin_coroutines_jvm_internal_RestrictedSuspendLambda() ||
+         type == type::kotlin_coroutines_jvm_internal_SuspendLambda();
+}
+
 bool is_min_sdk_acceptable_impl(const DexType* source_type,
                                 const DexType* cur_type,
                                 const DexType* target_type,

libredex/TypeUtil.h

@@ -291,6 +291,8 @@ bool is_kotlin_class(DexClass* cls);
 
 bool is_kotlin_function_interface(const DexType* type);
 
+bool is_kotlin_internal_type(const DexType* type);
+
 /*
  * Return true if the cls is kotlin non capturing lambda.
  */

libredex/WellKnownTypes.h

@@ -41,7 +41,13 @@
            "Ldalvik/annotation/optimization/NeverCompile;")              \
   FOR_EACH(dalvik_annotation_optimization_NeverInline,                   \
            "Ldalvik/annotation/optimization/NeverInline;")               \
-  FOR_EACH(kotlin_jvm_internal_Lambda, "Lkotlin/jvm/internal/Lambda;")
+  FOR_EACH(kotlin_jvm_internal_Lambda, "Lkotlin/jvm/internal/Lambda;")   \
+  FOR_EACH(kotlin_coroutines_jvm_internal_ContinuationImpl,              \
+           "Lkotlin/coroutines/jvm/internal/ContinuationImpl;")          \
+  FOR_EACH(kotlin_coroutines_jvm_internal_RestrictedSuspendLambda,       \
+           "Lkotlin/coroutines/jvm/internal/RestrictedSuspendLambda;")   \
+  FOR_EACH(kotlin_coroutines_jvm_internal_SuspendLambda,                 \
+           "Lkotlin/coroutines/jvm/internal/SuspendLambda;")
 
 #define PRIMITIVE_PSEUDO_TYPE_FIELDS                                       \
   FOR_EACH(Void_TYPE, "Ljava/lang/Void;.TYPE:Ljava/lang/Class;")           \

opt/class-merging/ModelSpecGenerator.cpp

@@ -28,7 +28,9 @@ namespace {
  * overly-conservative rules. So we loose the checking for the constructors of
  * anonymous classes.
  */
-bool can_delete_class(const DexClass* cls, bool is_anonymous_class) {
+bool can_delete_class(const DexClass* cls,
+                      bool is_anonymous_class,
+                      bool is_kotlin_internal_subtype) {
   if (!can_delete(cls)) {
     return false;
   }
@@ -38,15 +40,15 @@ bool can_delete_class(const DexClass* cls, bool is_anonymous_class) {
     return false;
   }
   const auto& dmethods = cls->get_dmethods();
-  if (std::any_of(dmethods.begin(), dmethods.end(),
-                  [&is_anonymous_class](const DexMethod* m) {
-                    return (!is_anonymous_class || !is_constructor(m)) &&
-                           !can_delete(m);
-                  })) {
+  if (!is_anonymous_class &&
+      std::any_of(dmethods.begin(), dmethods.end(), [](const DexMethod* m) {
+        return (!is_constructor(m)) && !can_delete(m);
+      })) {
     return false;
   }
   const auto& ifields = cls->get_ifields();
-  if (std::any_of(ifields.begin(), ifields.end(),
+  if (!is_kotlin_internal_subtype &&
+      std::any_of(ifields.begin(), ifields.end(),
                   [](const DexField* f) { return !can_delete(f); })) {
     return false;
   }
@@ -156,11 +158,12 @@ void find_all_mergeables_and_roots(const TypeSystem& type_system,
     if (!children.empty()) {
       continue;
     }
-    if (!can_delete_class(cls, is_anonymous_class)) {
+    auto* super_cls = cls->get_super_class();
+    bool is_kotlin_internal_type = type::is_kotlin_internal_type(super_cls);
+    if (!can_delete_class(cls, is_anonymous_class, is_kotlin_internal_type)) {
       continue;
     }
     auto* intfs = cls->get_interfaces();
-    auto* super_cls = cls->get_super_class();
     if (super_cls != type::java_lang_Object()) {
       parent_children[super_cls].push_back(cur_type);
     } else if (!intfs->empty()) {