Update VM to handle malformed types according to revised spec (issues 9055,

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 329 matching lines @@
     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.
         cls,
         factory.token_pos(),
-        kResolveTypeParameters,  // No compile-time error.
         "factory may not redirect to 'dynamic'");
     factory.SetRedirectionType(type);
     ASSERT(factory.RedirectionTarget() == Function::null());
     return;
   }
   const Class& target_class = Class::Handle(type.type_class());
   String& target_class_name = String::Handle(target_class.Name());
   String& target_name = String::Handle(
       String::Concat(target_class_name, Symbols::Dot()));
   const String& identifier = String::Handle(factory.RedirectionIdentifier());
   if (!identifier.IsNull()) {
     target_name = String::Concat(target_name, identifier);
   }
 
   // Verify that the target constructor of the redirection exists.
   target = target_class.LookupConstructor(target_name);
   if (target.IsNull()) {
     target = target_class.LookupFactory(target_name);
   }
   if (target.IsNull()) {
     const String& user_visible_target_name =
         identifier.IsNull() ? target_class_name : target_name;
     // Replace the type with a malformed type and compile a throw when called.
     type = NewFinalizedMalformedType(
         Error::Handle(),  // No previous error.
         cls,
         factory.token_pos(),
-        kResolveTypeParameters,  // No compile-time error.
         "class '%s' has no constructor or factory named '%s'",
         target_class_name.ToCString(),
         user_visible_target_name.ToCString());
     factory.SetRedirectionType(type);
     ASSERT(factory.RedirectionTarget() == Function::null());
     return;
   }
 
   // Verify that the target is compatible with the redirecting factory.
   if (!target.HasCompatibleParametersWith(factory)) {
     type = NewFinalizedMalformedType(
         Error::Handle(),  // No previous error.
         cls,
         factory.token_pos(),
-        kResolveTypeParameters,  // No compile-time error.
         "constructor '%s' has incompatible parameters with "
         "redirecting factory '%s'",
         String::Handle(target.name()).ToCString(),
         String::Handle(factory.name()).ToCString());
     factory.SetRedirectionType(type);
     ASSERT(factory.RedirectionTarget() == Function::null());
     return;
   }
 
   // Verify that the target is const if the redirecting factory is const.
@@ skipping 26 matching lines @@
     // If the target type refers to type parameters, substitute them with the
     // type arguments of the redirection type.
     if (!target_type.IsInstantiated()) {
       const AbstractTypeArguments& type_args = AbstractTypeArguments::Handle(
           type.arguments());
       Error& malformed_error = Error::Handle();
       target_type ^= target_type.InstantiateFrom(type_args, &malformed_error);
       if (malformed_error.IsNull()) {
         target_type ^= FinalizeType(cls, target_type, kCanonicalize);
       } else {
-        FinalizeMalformedType(malformed_error,
-                              cls, target_type, kFinalize,
+        FinalizeMalformedType(malformed_error, cls, target_type,
                               "cannot resolve redirecting factory");
         target_target = Function::null();
       }
     }
   }
   factory.SetRedirectionType(target_type);
   factory.SetRedirectionTarget(target_target);
 }
 
 
 void ClassFinalizer::ResolveType(const Class& cls,
                                  const AbstractType& type,
                                  FinalizationKind finalization) {
   if (type.IsResolved() || type.IsFinalized()) {
-    if ((finalization == kCanonicalizeWellFormed) && type.IsMalformed()) {
-      ReportError(Error::Handle(type.malformed_error()));
-    }
     return;
   }
   if (FLAG_trace_type_finalization) {
     OS::Print("Resolve type '%s'\n", String::Handle(type.Name()).ToCString());
   }
 
   // Resolve the type class.
   if (!type.HasResolvedTypeClass()) {
     // Type parameters are always resolved in the parser in the correct
     // non-static scope or factory scope. That resolution scope is unknown here.
     // Being able to resolve a type parameter from class cls here would indicate
     // that the type parameter appeared in a static scope. Leaving the type as
     // unresolved is the correct thing to do.
 
     // Lookup the type class.
     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()) {
-      parameterized_type.set_type_class(type_class);
-    } else {
-      // The type class could not be resolved. The type is malformed.
-      FinalizeMalformedType(ambiguous_error,  // May be null.
-                            cls, parameterized_type, finalization,
-                            "cannot resolve class name '%s' from '%s'",
-                            String::Handle(unresolved_class.Name()).ToCString(),
-                            String::Handle(cls.Name()).ToCString());
+    if (type_class.IsNull()) {
+      if ((finalization == kCanonicalizeWellFormed) ||
+          FLAG_error_on_malformed_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.
+        parameterized_type.set_type_class(Class::Handle(
+            Object::dynamic_class()));
+        parameterized_type.set_arguments(
+            Object::null_abstract_type_arguments());
+      }
       return;
     }
+    parameterized_type.set_type_class(type_class);
   }
 
   // Resolve type arguments, if any.
   const AbstractTypeArguments& arguments =
       AbstractTypeArguments::Handle(type.arguments());
   if (!arguments.IsNull()) {
     intptr_t num_arguments = arguments.Length();
     AbstractType& type_argument = AbstractType::Handle();
     for (intptr_t i = 0; i < num_arguments; i++) {
       type_argument = arguments.TypeAt(i);
@@ skipping 198 matching lines @@
   }
 }
 
 
 RawAbstractType* ClassFinalizer::FinalizeType(const Class& cls,
                                               const AbstractType& type,
                                               FinalizationKind finalization) {
   if (type.IsFinalized()) {
     // Ensure type is canonical if canonicalization is requested, unless type is
     // malformed.
-    if (finalization >= kCanonicalize) {
-      if (type.IsMalformed()) {
-        if (finalization == kCanonicalizeWellFormed) {
-          ReportError(Error::Handle(type.malformed_error()));
-        }
-      } else {
-        return type.Canonicalize();
-      }
+    if ((finalization >= kCanonicalize) && !type.IsMalformed()) {
+      return type.Canonicalize();
     }
     return type.raw();
   }
   ASSERT(type.IsResolved());
   ASSERT(finalization >= kFinalize);
 
   if (FLAG_trace_type_finalization) {
     OS::Print("Finalize type '%s' for class '%s'\n",
               String::Handle(type.Name()).ToCString(),
               cls.ToCString());
@@ skipping 13 matching lines @@
                             parameterized_class.NumTypeParameters();
     type_parameter.set_index(type_parameter.index() + offset);
     type_parameter.set_is_finalized();
     // We do not canonicalize type parameters.
     return type_parameter.raw();
   }
 
   // At this point, we can only have a parameterized_type.
   const Type& parameterized_type = Type::Cast(type);
 
-  if (parameterized_type.IsBeingFinalized()) {
-    // Self reference detected. The type is malformed.
-    FinalizeMalformedType(
-        Error::Handle(),  // No previous error.
-        cls, parameterized_type, finalization,
-        "type '%s' illegally refers to itself",
-        String::Handle(parameterized_type.UserVisibleName()).ToCString());
-    return parameterized_type.raw();
-  }
+  // Types illegally referring to themselves should have been detected earlier.
+  ASSERT(!parameterized_type.IsBeingFinalized());
 
   // Mark type as being finalized in order to detect illegal self reference.
   parameterized_type.set_is_being_finalized();
 
   // The type class does not need to be finalized in order to finalize the type,
   // however, it must at least be resolved (this was done as part of resolving
   // the type itself, a precondition to calling FinalizeType).
   // Also, the interfaces of the type class must be resolved and the type
   // parameters of the type class must be finalized.
   Class& type_class = Class::Handle(parameterized_type.type_class());
   if (!type_class.is_type_finalized()) {
     FinalizeTypeParameters(type_class);
     ResolveUpperBounds(type_class);
   }
 
   // Finalize the current type arguments of the type, which are still the
   // parsed type arguments.
   AbstractTypeArguments& arguments =
       AbstractTypeArguments::Handle(parameterized_type.arguments());
   if (!arguments.IsNull()) {
     intptr_t num_arguments = arguments.Length();
     AbstractType& type_argument = AbstractType::Handle();
     for (intptr_t i = 0; i < num_arguments; i++) {
       type_argument = arguments.TypeAt(i);
       type_argument = FinalizeType(cls, type_argument, finalization);
       if (type_argument.IsMalformed()) {
-        // In production mode, malformed type arguments are mapped to dynamic.
-        // In checked mode, a type with malformed type arguments is malformed.
-        if (FLAG_enable_type_checks || FLAG_error_on_malformed_type) {
-          const Error& error = Error::Handle(type_argument.malformed_error());
-          const String& type_name =
-              String::Handle(parameterized_type.UserVisibleName());
-          FinalizeMalformedType(error, cls, parameterized_type, finalization,
-                                "type '%s' has malformed type argument",
-                                type_name.ToCString());
-          return parameterized_type.raw();
-        } else {
-          type_argument = Type::DynamicType();
-        }
+        // Malformed type arguments are mapped to dynamic.
+        type_argument = Type::DynamicType();
       }
       arguments.SetTypeAt(i, type_argument);
     }
   }
 
   // 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.
-    if (finalization >= kCanonicalizeExpression) {
+    if (FLAG_error_on_malformed_type) {
       const Script& script = Script::Handle(cls.script());
-      const String& type_name =
-          String::Handle(parameterized_type.UserVisibleName());
+      const String& type_class_name = String::Handle(type_class.Name());
       ReportError(script, parameterized_type.token_pos(),
-                  "wrong number of type arguments in type '%s'",
-                  type_name.ToCString());
+                  "wrong number of type arguments for class '%s'",
+                  type_class_name.ToCString());
     }
-    FinalizeMalformedType(
-        Error::Handle(),  // No previous error.
-        cls, parameterized_type, finalization,
-        "wrong number of type arguments in type '%s'",
-        String::Handle(parameterized_type.UserVisibleName()).ToCString());
-    return parameterized_type.raw();
+    // Make the type raw and continue without reporting any error.
+    // A static warning should have been reported.
+    arguments = AbstractTypeArguments::null();
+    parameterized_type.set_arguments(arguments);
   }
   // The full type argument vector consists of the type arguments of the
   // super types of type_class, which may be initialized from the parsed
   // type arguments, followed by the parsed type arguments.
   TypeArguments& full_arguments = TypeArguments::Handle();
   Error& bound_error = Error::Handle();
   if (num_type_arguments > 0) {
     // If no type arguments were parsed and if the super types do not prepend
     // type arguments to the vector, we can leave the vector as null.
     if (!arguments.IsNull() || (num_type_arguments > num_type_parameters)) {
@@ skipping 61 matching lines @@
   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 (!bound_error.IsNull()) {
     // No compile-time error during finalization.
-    FinalizationKind bound_finalization = kResolveTypeParameters;
-    if (FLAG_enable_type_checks || FLAG_error_on_malformed_type) {
-      bound_finalization = finalization;
-    }
     const String& parameterized_type_name = String::Handle(
         parameterized_type.UserVisibleName());
     const Type& malformed_bound = Type::Handle(
         NewFinalizedMalformedType(bound_error,
                                   cls,
                                   parameterized_type.token_pos(),
-                                  bound_finalization,
                                   "type '%s' has an out of bound type argument",
                                   parameterized_type_name.ToCString()));
     return BoundedType::New(parameterized_type,
                             malformed_bound,
                             TypeParameter::Handle());
   }
 
   if (finalization >= kCanonicalize) {
     return parameterized_type.Canonicalize();
   } else {
     return parameterized_type.raw();
   }
 }
 
 
 void ClassFinalizer::ResolveAndFinalizeSignature(const Class& cls,
                                                  const Function& function) {
   // Resolve result type.
   AbstractType& type = AbstractType::Handle(function.result_type());
   // It is not a compile time error if this name does not resolve to a class or
   // interface.
   ResolveType(cls, type, kCanonicalize);
   type = FinalizeType(cls, type, kCanonicalize);
-  // In production mode, a malformed result type is mapped to dynamic.
-  if (!FLAG_enable_type_checks && type.IsMalformed()) {
-    type = Type::DynamicType();
-  }
+  // A malformed result type is mapped to dynamic.
+  ASSERT(!type.IsMalformed());
   function.set_result_type(type);
   // Resolve formal parameter types.
   const intptr_t num_parameters = function.NumParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
     type = function.ParameterTypeAt(i);
     ResolveType(cls, type, kCanonicalize);
     type = FinalizeType(cls, type, kCanonicalize);
-    // In production mode, a malformed parameter type is mapped to dynamic.
-    if (!FLAG_enable_type_checks && type.IsMalformed()) {
-      type = Type::DynamicType();
-    }
+    // A malformed parameter type is mapped to dynamic.
+    ASSERT(!type.IsMalformed());
     function.SetParameterTypeAt(i, type);
   }
 }
 
 
 // Check if an instance field or method of same name exists
 // in any super class.
 static RawClass* FindSuperOwnerOfInstanceMember(const Class& cls,
                                                 const String& name) {
   Class& super_class = Class::Handle();
@@ skipping 898 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.IsDynamicType()) {
     const Script& script = Script::Handle(cls.script());
     ReportError(script, cls.token_pos(),
                 "class '%s' may not extend 'dynamic'",
                 String::Handle(cls.Name()).ToCString());
   }
 
   interface_class = super_type.type_class();
   // If cls belongs to core lib or to core lib's implementation, restrictions
   // about allowed interfaces are lifted.
@@ skipping 45 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.
+    if (interface.IsMalformed()) {
+      ReportError(Error::Handle(interface.malformed_error()));
+    }
     if (interface.IsDynamicType()) {
       const Script& script = Script::Handle(cls.script());
       ReportError(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());
       ReportError(script, cls.token_pos(),
                   "'%s' is used where an interface or class name is expected",
@@ skipping 91 matching lines @@
   for (intptr_t i = 0; i < len; i++) {
     field ^= fields_array.At(i);
     OS::Print("  %s\n", field.ToCString());
   }
 }
 
 // Either report an error or mark the type as malformed.
 void ClassFinalizer::ReportMalformedType(const Error& prev_error,
                                          const Class& cls,
                                          const Type& type,
-                                         FinalizationKind finalization,
                                          const char* format,
                                          va_list args) {
   LanguageError& error = LanguageError::Handle();
-  if (FLAG_enable_type_checks ||
-      !type.HasResolvedTypeClass() ||
-      (finalization == kCanonicalizeWellFormed) ||
-      FLAG_error_on_malformed_type) {
-    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 ((finalization == kCanonicalizeWellFormed) ||
-        FLAG_error_on_malformed_type) {
-      ReportError(error);
-    }
+  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);
   }
-  // In checked mode, always mark the type as malformed.
-  // In production mode, mark the type as malformed only if its type class is
-  // not resolved.
-  // In both mode, make the type raw, since it may not be possible to
+  if (FLAG_error_on_malformed_type) {
+    ReportError(error);
+  }
+  type.set_malformed_error(error);
+  // Make the type raw, since it may not be possible to
   // properly finalize its type arguments.
-  if (FLAG_enable_type_checks || !type.HasResolvedTypeClass()) {
-    type.set_malformed_error(error);
-  }
+  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.
     ASSERT(!prev_error.IsNull());
   }
 }
 
 
-RawType* ClassFinalizer::NewFinalizedMalformedType(
-    const Error& prev_error,
-    const Class& cls,
-    intptr_t type_pos,
-    FinalizationKind finalization,
-    const char* format, ...) {
+RawType* ClassFinalizer::NewFinalizedMalformedType(const Error& prev_error,
+                                                   const Class& cls,
+                                                   intptr_t type_pos,
+                                                   const char* format, ...) {
   va_list args;
   va_start(args, format);
   const UnresolvedClass& unresolved_class = UnresolvedClass::Handle(
       UnresolvedClass::New(LibraryPrefix::Handle(),
                            Symbols::Empty(),
                            type_pos));
   const Type& type = Type::Handle(
       Type::New(unresolved_class, TypeArguments::Handle(), type_pos));
-  ReportMalformedType(prev_error, cls, type, finalization, format, args);
+  ReportMalformedType(prev_error, cls, type, format, args);
   va_end(args);
   ASSERT(type.IsMalformed());
   ASSERT(type.IsFinalized());
   return type.raw();
 }
 
 
 void ClassFinalizer::FinalizeMalformedType(const Error& prev_error,
                                            const Class& cls,
                                            const Type& type,
-                                           FinalizationKind finalization,
                                            const char* format, ...) {
   va_list args;
   va_start(args, format);
-  ReportMalformedType(prev_error, cls, type, finalization, format, args);
+  ReportMalformedType(prev_error, cls, type, format, args);
   va_end(args);
 }
 
 
 void ClassFinalizer::ReportError(const Error& error) {
   Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 
@@ skipping 72 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