Fix bad optimization prematurely marking types as instantiated (issue 8710).

runtime/vm/object.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 729 matching lines @@
   RegisterClass(cls, Symbols::Bool(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = object_store->array_class();  // Was allocated above.
   RegisterPrivateClass(cls, Symbols::ObjectArray(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
   // We cannot use NewNonParameterizedType(cls), because Array is parameterized.
   type ^= Type::New(Object::Handle(cls.raw()),
                     TypeArguments::Handle(),
                     Scanner::kDummyTokenIndex);
-  type.set_is_finalized_instantiated();
+  type.SetIsFinalized();
   type ^= type.Canonicalize();
   object_store->set_array_type(type);
 
   cls = object_store->growable_object_array_class();  // Was allocated above.
   RegisterPrivateClass(cls, Symbols::GrowableObjectArray(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<ImmutableArray>();
   object_store->set_immutable_array_class(cls);
   cls.set_type_arguments_field_offset(Array::type_arguments_offset());
@@ skipping 7960 matching lines @@
   if (IsNull()) {
     return Type::NullType();
   }
   const Class& cls = Class::Handle(clazz());
   AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
   if (cls.HasTypeArguments()) {
     type_arguments = GetTypeArguments();
   }
   const Type& type = Type::Handle(
       Type::New(cls, type_arguments, Scanner::kDummyTokenIndex));
-  type.set_is_finalized_instantiated();
+  type.SetIsFinalized();
   return type.raw();
 }
 
 
 RawAbstractTypeArguments* Instance::GetTypeArguments() const {
   const Class& cls = Class::Handle(clazz());
   intptr_t field_offset = cls.type_arguments_field_offset();
   ASSERT(field_offset != Class::kNoTypeArguments);
   AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
   type_arguments ^= *FieldAddrAtOffset(field_offset);
@@ skipping 542 matching lines @@
 }
 
 
 RawType* Type::NewNonParameterizedType(const Class& type_class) {
   ASSERT(!type_class.HasTypeArguments());
   const TypeArguments& no_type_arguments = TypeArguments::Handle();
   Type& type = Type::Handle();
   type ^= Type::New(Object::Handle(type_class.raw()),
                     no_type_arguments,
                     Scanner::kDummyTokenIndex);
-  type.set_is_finalized_instantiated();
+  type.SetIsFinalized();
   type ^= type.Canonicalize();
   return type.raw();
 }
 
 
-void Type::set_is_finalized_instantiated() const {
+void Type::SetIsFinalized() const {
   ASSERT(!IsFinalized());
-  set_type_state(RawType::kFinalizedInstantiated);
-}
-
-
-void Type::set_is_finalized_uninstantiated() const {
-  ASSERT(!IsFinalized());
-  set_type_state(RawType::kFinalizedUninstantiated);
+  if (IsInstantiated()) {
+    set_type_state(RawType::kFinalizedInstantiated);
+  } else {
+    set_type_state(RawType::kFinalizedUninstantiated);
+  }
 }
 
 
 void Type::set_is_being_finalized() const {
   ASSERT(!IsFinalized() && !IsBeingFinalized());
   set_type_state(RawType::kBeingFinalized);
 }
 
 
 bool Type::IsMalformed() const {
@@ skipping 93 matching lines @@
   ASSERT(!IsInstantiated());
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::Handle(arguments());
   type_arguments = type_arguments.InstantiateFrom(instantiator_type_arguments);
   const Class& cls = Class::Handle(type_class());
   ASSERT(cls.is_finalized());
   Type& instantiated_type = Type::Handle(
       Type::New(cls, type_arguments, token_pos()));
   ASSERT(type_arguments.IsNull() ||
          (type_arguments.Length() == cls.NumTypeArguments()));
-  instantiated_type.set_is_finalized_instantiated();
+  instantiated_type.SetIsFinalized();
   return instantiated_type.raw();
 }
 
 
 bool Type::Equals(const Instance& other) const {
   if (raw() == other.raw()) {
     return true;
   }
   if (!other.IsType()) {
     return false;
@@ skipping 3675 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart