It's a hard failure if return types cannot match.

Remove unused CanAssignArray method.

Test: test.py
Bug: 28313047
Change-Id: I5b172b65d262f81a85a899e169c248a722d1e4cf
diff --git a/runtime/verifier/method_verifier.cc b/runtime/verifier/method_verifier.cc
index 5238963..e577226 100644
--- a/runtime/verifier/method_verifier.cc
+++ b/runtime/verifier/method_verifier.cc
@@ -2179,21 +2179,8 @@
               Fail(VERIFY_ERROR_UNRESOLVED_TYPE_CHECK)
                   << " can't resolve returned type '" << return_type << "' or '" << reg_type << "'";
             } else {
-              bool soft_error = false;
-              // Check whether arrays are involved. They will show a valid class status, even
-              // if their components are erroneous.
-              if (reg_type.IsArrayTypes() && return_type.IsArrayTypes()) {
-                return_type.CanAssignArray(reg_type, reg_types_, class_loader_, this, &soft_error);
-                if (soft_error) {
-                  Fail(VERIFY_ERROR_BAD_CLASS_SOFT) << "array with erroneous component type: "
-                        << reg_type << " vs " << return_type;
-                }
-              }
-
-              if (!soft_error) {
-                Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "returning '" << reg_type
-                    << "', but expected from declaration '" << return_type << "'";
-              }
+              Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "returning '" << reg_type
+                  << "', but expected from declaration '" << return_type << "'";
             }
           }
         }
diff --git a/runtime/verifier/reg_type.cc b/runtime/verifier/reg_type.cc
index 5af2d4b..5d2db03 100644
--- a/runtime/verifier/reg_type.cc
+++ b/runtime/verifier/reg_type.cc
@@ -1032,53 +1032,6 @@
   return os;
 }
 
-bool RegType::CanAssignArray(const RegType& src,
-                             RegTypeCache& reg_types,
-                             Handle<mirror::ClassLoader> class_loader,
-                             MethodVerifier* verifier,
-                             bool* soft_error) const {
-  if (!IsArrayTypes() || !src.IsArrayTypes()) {
-    *soft_error = false;
-    return false;
-  }
-
-  if (IsUnresolvedMergedReference() || src.IsUnresolvedMergedReference()) {
-    // An unresolved array type means that it's an array of some reference type. Reference arrays
-    // can never be assigned to primitive-type arrays, and vice versa. So it is a soft error if
-    // both arrays are reference arrays, otherwise a hard error.
-    *soft_error = IsObjectArrayTypes() && src.IsObjectArrayTypes();
-    return false;
-  }
-
-  const RegType& cmp1 = reg_types.GetComponentType(*this, class_loader.Get());
-  const RegType& cmp2 = reg_types.GetComponentType(src, class_loader.Get());
-
-  if (cmp1.IsAssignableFrom(cmp2, verifier)) {
-    return true;
-  }
-  if (cmp1.IsUnresolvedTypes()) {
-    if (cmp2.IsIntegralTypes() || cmp2.IsFloatTypes() || cmp2.IsArrayTypes()) {
-      *soft_error = false;
-      return false;
-    }
-    *soft_error = true;
-    return false;
-  }
-  if (cmp2.IsUnresolvedTypes()) {
-    if (cmp1.IsIntegralTypes() || cmp1.IsFloatTypes() || cmp1.IsArrayTypes()) {
-      *soft_error = false;
-      return false;
-    }
-    *soft_error = true;
-    return false;
-  }
-  if (!cmp1.IsArrayTypes() || !cmp2.IsArrayTypes()) {
-    *soft_error = false;
-    return false;
-  }
-  return cmp1.CanAssignArray(cmp2, reg_types, class_loader, verifier, soft_error);
-}
-
 const NullType* NullType::CreateInstance(ObjPtr<mirror::Class> klass,
                                          const std::string_view& descriptor,
                                          uint16_t cache_id) {
diff --git a/runtime/verifier/reg_type.h b/runtime/verifier/reg_type.h
index e8a7a80..965bbaf 100644
--- a/runtime/verifier/reg_type.h
+++ b/runtime/verifier/reg_type.h
@@ -219,20 +219,6 @@
   bool IsAssignableFrom(const RegType& src, MethodVerifier* verifier) const
       REQUIRES_SHARED(Locks::mutator_lock_);
 
-  // Can this array type potentially be assigned by src.
-  // This function is necessary as array types are valid even if their components types are not,
-  // e.g., when they component type could not be resolved. The function will return true iff the
-  // types are assignable. It will return false otherwise. In case of return=false, soft_error
-  // will be set to true iff the assignment test failure should be treated as a soft-error, i.e.,
-  // when both array types have the same 'depth' and the 'final' component types may be assignable
-  // (both are reference types).
-  bool CanAssignArray(const RegType& src,
-                      RegTypeCache& reg_types,
-                      Handle<mirror::ClassLoader> class_loader,
-                      MethodVerifier* verifier,
-                      bool* soft_error) const
-      REQUIRES_SHARED(Locks::mutator_lock_);
-
   // Can this type be assigned by src? Variant of IsAssignableFrom that doesn't
   // allow assignment to
   // an interface from an Object.