Distinguish between malformed and malbounded types more efficiently using the

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/code_generator.h"
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
@@ skipping 268 matching lines @@
   const Function& target = Function::Handle(factory.RedirectionTarget());
   if (target.IsNull()) {
     Type& type = Type::Handle(factory.RedirectionType());
     if (!type.IsMalformed()) {
       const GrowableObjectArray& visited_factories =
           GrowableObjectArray::Handle(GrowableObjectArray::New());
       ResolveRedirectingFactoryTarget(cls, factory, visited_factories);
     }
     if (factory.is_const()) {
       type = factory.RedirectionType();
-      if (type.IsMalformed()) {
-        ReportError(Error::Handle(type.malformed_error()));
-      }
-      Error& error = Error::Handle();
-      if (type.IsMalboundedWithError(&error)) {
-        ReportError(error);
+      if (type.IsMalformedOrMalbounded()) {
+        ReportError(Error::Handle(type.error()));
       }
     }
   }
 }
 
 
 void ClassFinalizer::ResolveRedirectingFactoryTarget(
     const Class& cls,
     const Function& factory,
     const GrowableObjectArray& visited_factories) {
   ASSERT(factory.IsRedirectingFactory());
 
   // Check for redirection cycle.
   for (intptr_t i = 0; i < visited_factories.Length(); i++) {
     if (visited_factories.At(i) == factory.raw()) {
       // A redirection cycle is reported as a compile-time error.
       const Script& script = Script::Handle(cls.script());
       ReportError(Error::Handle(),  // No previous error.
                   script, factory.token_pos(),
                   "factory '%s' illegally redirects to itself",
                   String::Handle(factory.name()).ToCString());
     }
   }
   visited_factories.Add(factory);
 
   // Check if target is already resolved.
   Type& type = Type::Handle(factory.RedirectionType());
   Function& target = Function::Handle(factory.RedirectionTarget());
-  if (type.IsMalformed() || (type.IsResolved() && type.IsMalbounded())) {
+  if (type.IsMalformedOrMalbounded()) {
     // Already resolved to a malformed or malbounded type. Will throw on usage.
     ASSERT(target.IsNull());
     return;
   }
   if (!target.IsNull()) {
     // Already resolved.
     return;
   }
 
   // Target is not resolved yet.
   if (FLAG_trace_class_finalization) {
     OS::Print("Resolving redirecting factory: %s\n",
               String::Handle(factory.name()).ToCString());
   }
   ResolveType(cls, type, kCanonicalize);
   type ^= FinalizeType(cls, type, kCanonicalize);
   factory.SetRedirectionType(type);
-  if (type.IsMalformed() || type.IsMalbounded()) {
+  if (type.IsMalformedOrMalbounded()) {
     ASSERT(factory.RedirectionTarget() == Function::null());
     return;
   }
   ASSERT(!type.IsTypeParameter());  // Resolved in parser.
   if (type.IsDynamicType()) {
     // Replace the type with a malformed type and compile a throw when called.
     type = NewFinalizedMalformedType(
         Error::Handle(),  // No previous error.
         Script::Handle(cls.script()),
         factory.token_pos(),
@@ skipping 455 matching lines @@
   // The finalized type argument vector needs num_type_arguments types.
   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.
+    // Wrong number of type arguments. The type is mapped to the raw 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.
@@ skipping 84 matching lines @@
   // signature type, i.e. finalizing the result type and parameter types of the
   // signature function of this signature type.
   // We do this after marking this type as finalized in order to allow a
   // function type to refer to itself via its parameter types and result type.
   if (type_class.IsSignatureClass()) {
     // The class may be created while parsing a function body, after all
     // pending classes have already been finalized.
     FinalizeTypesInClass(type_class);
   }
 
-  // If a bound error occurred, return a BoundedType with a malformed bound.
-  // The malformed bound will be ignored in production mode.
+  // If a bound error occurred, mark the type as malbounded.
+  // The bound error will be ignored in production mode.
   if (!bound_error.IsNull()) {
     // No compile-time error during finalization.
     const String& parameterized_type_name = String::Handle(
         parameterized_type.UserVisibleName());
-    const Type& malformed_bound = Type::Handle(
-        NewFinalizedMalformedType(bound_error,
-                                  Script::Handle(cls.script()),
-                                  parameterized_type.token_pos(),
-                                  "type '%s' has an out of bound type argument",
-                                  parameterized_type_name.ToCString()));
+    FinalizeMalboundedType(bound_error,
+                           Script::Handle(cls.script()),
+                           parameterized_type,
+                           "type '%s' has an out of bound type argument",
+                           parameterized_type_name.ToCString());
 
     if (FLAG_trace_type_finalization) {
       OS::Print("Done finalizing malbounded type '%s' with bound error: %s\n",
                 String::Handle(parameterized_type.Name()).ToCString(),
                 bound_error.ToCString());
     }
 
-    return BoundedType::New(parameterized_type,
-                            malformed_bound,
-                            TypeParameter::Handle());
+    return parameterized_type.raw();;
   }
 
   if (FLAG_trace_type_finalization) {
     OS::Print("Done finalizing type '%s' with %" Pd " type args\n",
               String::Handle(parameterized_type.Name()).ToCString(),
               parameterized_type.arguments() == AbstractTypeArguments::null() ?
                   0 : num_type_arguments);
   }
 
   if (finalization >= kCanonicalize) {
@@ skipping 202 matching lines @@
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
     }
     if (field.is_static() && (field.is_const() || field.is_final()) &&
         (field.value() != Object::null()) &&
         (field.value() != Object::sentinel().raw())) {
       // The parser does not preset the value if the type is a type parameter or
       // is parameterized unless the value is null.
-      Error& malformed_error = Error::Handle();
-      if (type.IsMalformed()) {
-        malformed_error = type.malformed_error();
+      Error& error = Error::Handle();
+      if (type.IsMalformedOrMalbounded()) {
+        error = type.error();
       } else {
         ASSERT(type.IsInstantiated());
       }
       const Instance& const_value = Instance::Handle(field.value());
-      if (!malformed_error.IsNull() ||
+      if (!error.IsNull() ||
           (!type.IsDynamicType() &&
            !const_value.IsInstanceOf(type,
                                      AbstractTypeArguments::Handle(),
-                                     &malformed_error))) {
+                                     &error))) {
         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(),
+          ReportError(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",
                       name.ToCString(),
                       const_value_type_name.ToCString(),
                       type_name.ToCString());
         } else {
           // Do not report an error yet, even in checked mode, since the field
           // may not actually be used.
           // Also, we may be generating a snapshot in production mode that will
@@ skipping 1207 matching lines @@
   // are lifted.
   const bool cls_belongs_to_core_lib = cls.library() == Library::CoreLibrary();
 
   // Resolve and check the super type and interfaces of cls.
   visited->Add(cls_index);
   AbstractType& interface = AbstractType::Handle();
   Class& interface_class = Class::Handle();
 
   // Resolve super type. Failures lead to a longjmp.
   ResolveType(cls, super_type, kCanonicalizeWellFormed);
-  if (super_type.IsMalformed()) {
-    ReportError(Error::Handle(super_type.malformed_error()));
+  if (super_type.IsMalformedOrMalbounded()) {
+    ReportError(Error::Handle(super_type.error()));
   }
   if (super_type.IsDynamicType()) {
     const Script& script = Script::Handle(cls.script());
     ReportError(Error::Handle(),  // No previous error.
                 script, cls.token_pos(),
                 "class '%s' may not extend 'dynamic'",
                 String::Handle(cls.Name()).ToCString());
   }
   interface_class = super_type.type_class();
   if (interface_class.IsSignatureClass()) {
@@ skipping 56 matching lines @@
     }
   }
   // Now resolve the super interfaces of the super type.
   ResolveSuperTypeAndInterfaces(interface_class, visited);
 
   // Resolve interfaces. Failures lead to a longjmp.
   for (intptr_t i = 0; i < super_interfaces.Length(); i++) {
     interface ^= super_interfaces.At(i);
     ResolveType(cls, interface, kCanonicalizeWellFormed);
     ASSERT(!interface.IsTypeParameter());  // Should be detected by parser.
+    // A malbounded interface is only reported when involved in a type test.
     if (interface.IsMalformed()) {
-      ReportError(Error::Handle(interface.malformed_error()));
+      ReportError(Error::Handle(interface.error()));
     }
     if (interface.IsDynamicType()) {
       const Script& script = Script::Handle(cls.script());
       ReportError(Error::Handle(),  // No previous error.
                   script, cls.token_pos(),
                   "'dynamic' may not be used as interface");
     }
     interface_class = interface.type_class();
     if (interface_class.IsSignatureClass()) {
       const Script& script = Script::Handle(cls.script());
@@ skipping 112 matching lines @@
                                          const char* format,
                                          va_list args) {
   LanguageError& error = LanguageError::Handle(
       LanguageError::NewFormattedV(
           prev_error, script, type.token_pos(),
           LanguageError::kMalformedType, Heap::kOld,
           format, args));
   if (FLAG_error_on_bad_type) {
     ReportError(error);
   }
-  type.set_malformed_error(error);
+  type.set_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.
   } 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.
@@ skipping 26 matching lines @@
                                            const Script& script,
                                            const Type& type,
                                            const char* format, ...) {
   va_list args;
   va_start(args, format);
   ReportMalformedType(prev_error, script, type, format, args);
   va_end(args);
 }
 
 
+void ClassFinalizer::FinalizeMalboundedType(const Error& prev_error,
+                                            const Script& script,
+                                            const Type& type,
+                                            const char* format, ...) {
+  va_list args;
+  va_start(args, format);
+  LanguageError& error = LanguageError::Handle(
+      LanguageError::NewFormattedV(
+          prev_error, script, type.token_pos(),
+          LanguageError::kMalboundedType, Heap::kOld,
+          format, args));
+  va_end(args);
+  if (FLAG_error_on_bad_type) {
+    ReportError(error);
+  }
+  type.set_error(error);
+  if (!type.IsFinalized()) {
+    type.SetIsFinalized();
+    // Do not canonicalize malbounded types.
+  }
+}
+
+
 void ClassFinalizer::ReportError(const Error& error) {
   Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 
 void ClassFinalizer::ReportError(const Error& prev_error,
                                  const Script& script,
                                  intptr_t token_pos,
                                  const char* format, ...) {
@@ skipping 62 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