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

runtime/vm/class_finalizer.cc

 // Copyright (c) 2013, 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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 753 matching lines @@
       }
       parameterized_type.set_arguments(full_arguments);
     } else {
       ASSERT(full_arguments.IsNull());  // Use null vector for raw type.
     }
   }
 
   // Self referencing types may get finalized indirectly.
   if (!parameterized_type.IsFinalized()) {
     // Mark the type as finalized.
-    if (parameterized_type.IsInstantiated()) {
-      parameterized_type.set_is_finalized_instantiated();
-    } else {
-      parameterized_type.set_is_finalized_uninstantiated();
-    }
+    parameterized_type.SetIsFinalized();
   }
 
   // Upper bounds of the finalized type arguments are only verified in checked
   // mode, since bound errors are never reported by the vm in production mode.
   if (FLAG_enable_type_checks &&
       !full_arguments.IsNull() &&
       full_arguments.IsInstantiated()) {
     ResolveAndFinalizeUpperBounds(type_class);
     Error& malformed_error = Error::Handle();
     // Pass the full type argument vector as the bounds instantiator.
@@ skipping 836 matching lines @@
       // We do not want an unresolved class to end up in a snapshot.
       type.set_type_class(Object::Handle(Object::null_class()));
     }
   } else {
      // In production mode, do not mark the type with a resolved type class as
      // malformed, but make it raw.
     type.set_arguments(AbstractTypeArguments::Handle());
   }
   ASSERT(type.HasResolvedTypeClass());
   if (!type.IsFinalized()) {
-    type.set_is_finalized_instantiated();
+    type.SetIsFinalized();
     // Do not canonicalize malformed types, since they may not be resolved.
   } else {
     // The only case where the malformed type was already finalized is when its
     // type arguments are not within bounds. In that case, we have a prev_error.
     ASSERT(!prev_error.IsNull());
   }
 }
 
 
 RawType* ClassFinalizer::NewFinalizedMalformedType(
@@ skipping 50 matching lines @@
 void ClassFinalizer::ReportError(const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
       Parser::FormatError(Script::Handle(), -1, "Error", format, args));
   va_end(args);
   ReportError(error);
 }
 
 }  // namespace dart