More cleanup related to malformed and malbounded types.

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"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, error_on_bad_override, false,
             "Report error for bad overrides.");
-DEFINE_FLAG(bool, error_on_malformed_type, false,
+DEFINE_FLAG(bool, error_on_bad_type, false,
             "Report error for malformed types.");
 DEFINE_FLAG(bool, print_classes, false, "Prints details about loaded classes.");
 DEFINE_FLAG(bool, trace_class_finalization, false, "Trace class finalization.");
 DEFINE_FLAG(bool, trace_type_finalization, false, "Trace type finalization.");
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, use_cha);
 
 bool ClassFinalizer::AllClassesFinalized() {
   ObjectStore* object_store = Isolate::Current()->object_store();
   const GrowableObjectArray& classes =
@@ skipping 438 matching lines @@
     const UnresolvedClass& unresolved_class =
         UnresolvedClass::Handle(type.unresolved_class());
     Error& ambiguous_error = Error::Handle();
     const Class& type_class =
         Class::Handle(ResolveClass(cls, unresolved_class, &ambiguous_error));
 
     // Replace unresolved class with resolved type class.
     const Type& parameterized_type = Type::Cast(type);
     if (type_class.IsNull()) {
       if ((finalization == kCanonicalizeWellFormed) ||
-          FLAG_error_on_malformed_type) {
+          FLAG_error_on_bad_type) {
         // The type class could not be resolved. The type is malformed.
         FinalizeMalformedType(
             ambiguous_error,  // May be null.
             cls,
             parameterized_type,
             "cannot resolve class '%s' from '%s'",
             String::Handle(unresolved_class.Name()).ToCString(),
             String::Handle(cls.Name()).ToCString());
       } else {
         // Map the malformed type to dynamic and ignore type arguments.
@@ skipping 301 matching lines @@
   const intptr_t num_type_arguments = type_class.NumTypeArguments();
   // The type class has num_type_parameters type parameters.
   const intptr_t num_type_parameters = type_class.NumTypeParameters();
 
   // Initialize the type argument vector.
   // Check the number of parsed type arguments, if any.
   // Specifying no type arguments indicates a raw type, which is not an error.
   // However, type parameter bounds are checked below, even for a raw type.
   if (!arguments.IsNull() && (arguments.Length() != num_type_parameters)) {
     // Wrong number of type arguments. The type is malformed.
-    if (FLAG_error_on_malformed_type) {
+    if (FLAG_error_on_bad_type) {
       const Script& script = Script::Handle(cls.script());
       const String& type_class_name = String::Handle(type_class.Name());
       ReportError(Error::Handle(),  // No previous error.
                   script, parameterized_type.token_pos(),
                   "wrong number of type arguments for class '%s'",
                   type_class_name.ToCString());
     }
     // Make the type raw and continue without reporting any error.
     // A static warning should have been reported.
     arguments = AbstractTypeArguments::null();
@@ skipping 323 matching lines @@
         malformed_error = type.malformed_error();
       } else {
         ASSERT(type.IsInstantiated());
       }
       const Instance& const_value = Instance::Handle(field.value());
       if (!malformed_error.IsNull() ||
           (!type.IsDynamicType() &&
            !const_value.IsInstanceOf(type,
                                      AbstractTypeArguments::Handle(),
                                      &malformed_error))) {
-        if (FLAG_error_on_malformed_type) {
+        if (FLAG_error_on_bad_type) {
           const AbstractType& const_value_type = AbstractType::Handle(
               const_value.GetType());
           const String& const_value_type_name = String::Handle(
               const_value_type.UserVisibleName());
           const String& type_name = String::Handle(type.UserVisibleName());
           const Script& script = Script::Handle(cls.script());
           ReportError(malformed_error, script, field.token_pos(),
                       "error initializing static %s field '%s': "
                       "type '%s' is not a subtype of type '%s'",
                       field.is_const() ? "const" : "final",
@@ skipping 1023 matching lines @@
                                          va_list args) {
   LanguageError& error = LanguageError::Handle();
   const Script& script = Script::Handle(cls.script());
   if (prev_error.IsNull()) {
     error ^= Parser::FormatError(
         script, type.token_pos(), "Error", format, args);
   } else {
     error ^= Parser::FormatErrorWithAppend(
         prev_error, script, type.token_pos(), "Error", format, args);
   }
-  if (FLAG_error_on_malformed_type) {
+  if (FLAG_error_on_bad_type) {
     ReportError(error);
   }
   type.set_malformed_error(error);
   // Make the type raw, since it may not be possible to
   // properly finalize its type arguments.
   type.set_type_class(Class::Handle(Object::dynamic_class()));
   type.set_arguments(Object::null_abstract_type_arguments());
   if (!type.IsFinalized()) {
     type.SetIsFinalized();
     // Do not canonicalize malformed types, since they may not be resolved.
@@ skipping 123 matching lines @@
   expected_name ^= String::New("_offset");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
   field ^= fields_array.At(2);
   ASSERT(field.Offset() == TypedDataView::length_offset());
   name ^= field.name();
   ASSERT(name.Equals("length"));
 #endif
 }
 
 }  // namespace dart