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.