Fix finalization of recursive type graph with bounds (issue 25389).

runtime/vm/parser.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/parser.h"
 #include "vm/flags.h"
 
 #ifndef DART_PRECOMPILED
 
 #include "lib/invocation_mirror.h"
@@ skipping 12661 matching lines @@
     ExpectToken(Token::kRBRACK);
     SetAllowFunctionLiterals(saved_mode);
   }
 
   if (is_const) {
     // Allocate and initialize the const list at compile time.
     Array& const_list = Array::ZoneHandle(Z,
         Array::New(element_list.length(), Heap::kOld));
     const_list.SetTypeArguments(
         TypeArguments::Handle(Z, list_type_arguments.Canonicalize()));
-    Error& malformed_error = Error::Handle(Z);
+    Error& bound_error = Error::Handle(Z);
     for (int i = 0; i < element_list.length(); i++) {
       AstNode* elem = element_list[i];
       // Arguments have been evaluated to a literal value already.
       ASSERT(elem->IsLiteralNode());
       ASSERT(!is_top_level_);  // We cannot check unresolved types.
       if (I->flags().type_checks() &&
           !element_type.IsDynamicType() &&
           (!elem->AsLiteralNode()->literal().IsNull() &&
            !elem->AsLiteralNode()->literal().IsInstanceOf(
                element_type,
                TypeArguments::Handle(Z),
-               &malformed_error))) {
-        // If the failure is due to a malformed type error, display it instead.
-        if (!malformed_error.IsNull()) {
-          ReportError(malformed_error);
+               &bound_error))) {
+        // If the failure is due to a bound error, display it instead.
+        if (!bound_error.IsNull()) {
+          ReportError(bound_error);
         } else {
           ReportError(elem->AsLiteralNode()->token_pos(),
                       "list literal element at index %d must be "
                       "a constant of type '%s'",
                       i,
                       String::Handle(Z,
                           element_type.UserVisibleName()).ToCString());
         }
       }
       const_list.SetAt(i, elem->AsLiteralNode()->literal());
@@ skipping 190 matching lines @@
 
   if (is_const) {
     // Create the key-value pair array, canonicalize it and then create
     // the immutable map object with it. This all happens at compile time.
     // The resulting immutable map object is returned as a literal.
 
     // First, create the canonicalized key-value pair array.
     Array& key_value_array =
         Array::ZoneHandle(Z, Array::New(kv_pairs_list.length(), Heap::kOld));
     AbstractType& arg_type = Type::Handle(Z);
-    Error& malformed_error = Error::Handle(Z);
+    Error& bound_error = Error::Handle(Z);
     for (int i = 0; i < kv_pairs_list.length(); i++) {
       AstNode* arg = kv_pairs_list[i];
       // Arguments have been evaluated to a literal value already.
       ASSERT(arg->IsLiteralNode());
       ASSERT(!is_top_level_);  // We cannot check unresolved types.
       if (I->flags().type_checks()) {
         if ((i % 2) == 0) {
           // Check key type.
           arg_type = key_type.raw();
         } else {
           // Check value type.
           arg_type = value_type.raw();
         }
         if (!arg_type.IsDynamicType() &&
             (!arg->AsLiteralNode()->literal().IsNull() &&
              !arg->AsLiteralNode()->literal().IsInstanceOf(
                  arg_type,
                  Object::null_type_arguments(),
-                 &malformed_error))) {
-          // If the failure is due to a malformed type error, display it.
-          if (!malformed_error.IsNull()) {
-            ReportError(malformed_error);
+                 &bound_error))) {
+          // If the failure is due to a bound error, display it.
+          if (!bound_error.IsNull()) {
+            ReportError(bound_error);
           } else {
             ReportError(arg->AsLiteralNode()->token_pos(),
                         "map literal %s at index %d must be "
                         "a constant of type '%s'",
                         ((i % 2) == 0) ? "key" : "value",
                         i >> 1,
                         String::Handle(Z,
                                        arg_type.UserVisibleName()).ToCString());
           }
         }
@@ skipping 593 matching lines @@
         ReportErrors(Error::Cast(constructor_result),
                      script_, new_pos,
                      "error while evaluating const constructor");
       }
       const_instance ^= constructor_result.raw();
       CacheConstantValue(new_pos, const_instance);
     }
     new_object = new(Z) LiteralNode(new_pos, const_instance);
     if (!type_bound.IsNull()) {
       ASSERT(!type_bound.IsMalformed());
-      Error& malformed_error = Error::Handle(Z);
+      Error& bound_error = Error::Handle(Z);
       ASSERT(!is_top_level_);  // We cannot check unresolved types.
       if (!const_instance.IsInstanceOf(type_bound,
                                        TypeArguments::Handle(Z),
-                                       &malformed_error)) {
+                                       &bound_error)) {
         type_bound = ClassFinalizer::NewFinalizedMalformedType(
-            malformed_error,
+            bound_error,
             script_,
             new_pos,
             "const factory result is not an instance of '%s'",
             String::Handle(Z, type_bound.UserVisibleName()).ToCString());
         new_object = ThrowTypeError(new_pos, type_bound);
       }
       type_bound = AbstractType::null();
     }
   } else {
     CheckConstructorCallTypeArguments(new_pos, constructor, type_arguments);
@@ skipping 835 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED