diff --git a/src/verifier/method_verifier.cc b/src/verifier/method_verifier.cc
index 6338659..efdd6f6 100644
--- a/src/verifier/method_verifier.cc
+++ b/src/verifier/method_verifier.cc
@@ -2882,8 +2882,7 @@
   }
 }
 
-void MethodVerifier::VerifyNewArray(const Instruction* inst, bool is_filled,
-                                    bool is_range) {
+void MethodVerifier::VerifyNewArray(const Instruction* inst, bool is_filled, bool is_range) {
   uint32_t type_idx;
   if (!is_filled) {
     DCHECK_EQ(inst->Opcode(), Instruction::NEW_ARRAY);
@@ -2906,7 +2905,8 @@
       /* make sure "size" register is valid type */
       work_line_->VerifyRegisterType(inst->VRegB_22c(), reg_types_.Integer());
       /* set register type to array class */
-      work_line_->SetRegisterType(inst->VRegA_22c(), res_type);
+      const RegType& precise_type = reg_types_.FromUninitialized(res_type);
+      work_line_->SetRegisterType(inst->VRegA_22c(), precise_type);
     } else {
       // Verify each register. If "arg_count" is bad, VerifyRegisterType() will run off the end of
       // the list and fail. It's legal, if silly, for arg_count to be zero.
@@ -2924,7 +2924,8 @@
         }
       }
       // filled-array result goes into "result" register
-      work_line_->SetResultRegisterType(res_type);
+      const RegType& precise_type = reg_types_.FromUninitialized(res_type);
+      work_line_->SetResultRegisterType(precise_type);
     }
   }
 }
diff --git a/src/verifier/reg_type_cache.cc b/src/verifier/reg_type_cache.cc
index ce3e6f6..6013250 100644
--- a/src/verifier/reg_type_cache.cc
+++ b/src/verifier/reg_type_cache.cc
@@ -377,7 +377,6 @@
     entry = new UnresolvedReferenceType(descriptor.c_str(), entries_.size());
   } else {
     mirror::Class* klass = uninit_type.GetClass();
-    DCHECK(!klass->IsArrayClass());
     if(uninit_type.IsUninitializedThisReference() && !klass->IsFinal()) {
       // For uninitialized "this reference" look for reference types that are not precise.
       for (size_t i = primitive_count_; i < entries_.size(); i++) {
@@ -387,32 +386,18 @@
         }
       }
       entry = new ReferenceType(klass, "", entries_.size());
-    } else {
-      if (klass->IsFinal()) {
-        if (klass->IsInstantiable()) {
-          for (size_t i = primitive_count_; i < entries_.size(); i++) {
-            RegType* cur_entry = entries_[i];
-            if (cur_entry->IsPreciseReference() && cur_entry->GetClass() == klass) {
-              return *cur_entry;
-            }
-          }
-          // Precise type was not found , create one !
-          entry = new PreciseReferenceType(klass, "", entries_.size());
-        } else {
-          return Conflict();
+    } else if (klass->IsInstantiable()) {
+      // We're uninitialized because of allocation, look or create a precise type as allocations
+      // may only create objects of that type.
+      for (size_t i = primitive_count_; i < entries_.size(); i++) {
+        RegType* cur_entry = entries_[i];
+        if (cur_entry->IsPreciseReference() && cur_entry->GetClass() == klass) {
+          return *cur_entry;
         }
-      } else {
-        // Not a final class, create an imprecise reference. Look up if we have it in the cache
-        // first.
-        for (size_t i = primitive_count_; i < entries_.size(); i++) {
-          RegType* cur_entry = entries_[i];
-          if (cur_entry->IsReference() && !(cur_entry->IsPrecise()) &&
-              cur_entry->GetClass() == klass) {
-            return *cur_entry;
-          }
-        }
-        entry = new ReferenceType(klass, "", entries_.size());
       }
+      entry = new PreciseReferenceType(klass, uninit_type.GetDescriptor(), entries_.size());
+    } else {
+      return Conflict();
     }
  }
   entries_.push_back(entry);
@@ -447,8 +432,7 @@
     mirror::Class* klass = type.GetClass();
     for (size_t i = primitive_count_; i < entries_.size(); i++) {
       RegType* cur_entry = entries_[i];
-      if (cur_entry->IsUninitializedThisReference() &&
-          cur_entry->GetClass() == klass) {
+      if (cur_entry->IsUninitializedThisReference() && cur_entry->GetClass() == klass) {
         return *cur_entry;
       }
     }