Use null type argument vector instead of vector of Dynamic for a generic raw

runtime/vm/class_finalizer.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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 368 matching lines @@
   if (factory_signature_class.NumTypeParameters() > 0) {
     ResolveAndFinalizeUpperBounds(factory_signature_class);
     const TypeArguments& expected_type_parameters =
         TypeArguments::Handle(factory_signature_class.type_parameters());
     const TypeArguments& actual_type_parameters =
         TypeArguments::Handle(factory_class.type_parameters());
     const TypeArguments& expected_type_parameter_bounds =
         TypeArguments::Handle(factory_signature_class.type_parameter_bounds());
     const TypeArguments& actual_type_parameter_bounds =
         TypeArguments::Handle(factory_class.type_parameter_bounds());
-    if (!AbstractTypeArguments::AreEqual(expected_type_parameters,
-                                         actual_type_parameters) ||
+    if (!TypeArguments::AreIdenticalTypeParameters(expected_type_parameters,
+                                                   actual_type_parameters) ||
         !AbstractTypeArguments::AreEqual(expected_type_parameter_bounds,
                                          actual_type_parameter_bounds)) {
       const String& interface_name = String::Handle(interface.Name());
       const String& factory_name = String::Handle(factory_class.Name());
       const Script& script = Script::Handle(interface.script());
       ReportError(script, unresolved_factory_class.token_index(),
                   "mismatch in number, names, or bounds of type parameters "
                   "between default clause of interface '%s' and actual factory "
                   "class '%s'",
                   interface_name.ToCString(),
                   factory_name.ToCString());
     }
   }
   // Verify that the type parameters of the factory class and of the interface
   // have identical names.
   const TypeArguments& interface_type_parameters =
       TypeArguments::Handle(interface.type_parameters());
   const TypeArguments& factory_type_parameters =
       TypeArguments::Handle(factory_class.type_parameters());
-  if (!AbstractTypeArguments::AreEqual(interface_type_parameters,
-                                       factory_type_parameters)) {
+  if (!TypeArguments::AreIdenticalTypeParameters(interface_type_parameters,
+                                                 factory_type_parameters)) {
     const String& interface_name = String::Handle(interface.Name());
     const String& factory_name = String::Handle(factory_class.Name());
     const Script& script = Script::Handle(interface.script());
     ReportError(script, unresolved_factory_class.token_index(),
                 "mismatch in number or names of type parameters between "
                 "interface '%s' and default factory class '%s'",
                 interface_name.ToCString(),
                 factory_name.ToCString());
   }
 }
@@ skipping 47 matching lines @@
     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);
       ResolveType(cls, type_argument, finalization);
     }
   }
 }
 
 
+void ClassFinalizer::FinalizeTypeParameters(const Class& cls) {
+  const TypeArguments& type_parameters =
+      TypeArguments::Handle(cls.type_parameters());
+  if (!type_parameters.IsNull()) {
+    TypeParameter& type_parameter = TypeParameter::Handle();
+    intptr_t num_types = type_parameters.Length();
+    for (intptr_t i = 0; i < num_types; i++) {
+      type_parameter ^= type_parameters.TypeAt(i);
+      type_parameter ^= FinalizeType(cls, type_parameter, kFinalizeWellFormed);
+      type_parameters.SetTypeAt(i, type_parameter);
+    }
+  }
+}
+
+
 // Finalize the type argument vector 'arguments' of the type defined by the
 // class 'cls' parameterized with the type arguments 'cls_args'.
 // The vector 'cls_args' is already initialized as a subvector at the correct
 // position in the passed in 'arguments' vector.
 // The subvector 'cls_args' has length cls.NumTypeParameters() and starts at
 // offset cls.NumTypeArguments() - cls.NumTypeParameters() of the 'arguments'
 // vector.
 // Example:
 //   Declared: class C<K, V> extends B<V> { ... }
 //             class B<T> extends A<int> { ... }
 //   Input:    C<String, double> expressed as
 //             cls = C, arguments = [null, null, String, double],
 //             i.e. cls_args = [String, double], offset = 2, length = 2.
 //   Output:   arguments = [int, double, String, double]
 void ClassFinalizer::FinalizeTypeArguments(
     const Class& cls,
     const AbstractTypeArguments& arguments,
     FinalizationKind finalization) {
   ASSERT(arguments.Length() >= cls.NumTypeArguments());
+  if (!cls.is_finalized()) {
+    FinalizeTypeParameters(cls);
+  }
   Type& super_type = Type::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     super_type ^= FinalizeType(cls, super_type, finalization);
     cls.set_super_type(super_type);
     const Class& super_class = Class::Handle(super_type.type_class());
     const AbstractTypeArguments& super_type_args =
         AbstractTypeArguments::Handle(super_type.arguments());
     const intptr_t num_super_type_params = super_class.NumTypeParameters();
     const intptr_t offset = super_class.NumTypeArguments();
     const intptr_t super_offset = offset - num_super_type_params;
     ASSERT(offset == (cls.NumTypeArguments() - cls.NumTypeParameters()));
-    AbstractType& super_type_arg = AbstractType::Handle();
+    AbstractType& super_type_arg = AbstractType::Handle(Type::DynamicType());
     for (intptr_t i = 0; i < num_super_type_params; i++) {
-      super_type_arg = super_type_args.TypeAt(super_offset + i);
-      if (!super_type_arg.IsInstantiated()) {
-        super_type_arg = super_type_arg.InstantiateFrom(arguments);
+      if (!super_type_args.IsNull()) {
+        super_type_arg = super_type_args.TypeAt(super_offset + i);
+        if (!super_type_arg.IsInstantiated()) {
+          super_type_arg = super_type_arg.InstantiateFrom(arguments);
+        }
+        super_type_arg = super_type_arg.Canonicalize();
       }
-      super_type_arg = super_type_arg.Canonicalize();
       arguments.SetTypeAt(super_offset + i, super_type_arg);
     }
     FinalizeTypeArguments(super_class, arguments, finalization);
   }
 }
 
 
 RawAbstractType* ClassFinalizer::FinalizeType(const Class& cls,
                                               const AbstractType& type,
                                               FinalizationKind finalization) {
   if (type.IsFinalized()) {
     return type.raw();
   }
   ASSERT(type.IsResolved());
   ASSERT((finalization == kFinalize) || (finalization == kFinalizeWellFormed));
 
   if (FLAG_trace_type_finalization) {
     OS::Print("Finalize type '%s'\n", String::Handle(type.Name()).ToCString());
   }
 
   if (type.IsTypeParameter()) {
-    ASSERT(!cls.IsNull());
     TypeParameter& type_parameter = TypeParameter::Handle();
     type_parameter ^= type.raw();
+    const Class& parameterized_class =
+        Class::Handle(type_parameter.parameterized_class());
+    ASSERT(!parameterized_class.IsNull());
     // The index must reflect the position of this type parameter in the type
-    // arguments vector of the enclosing class. The offset to add is the number
-    // of type arguments in the super type, which is equal to the difference in
-    // number of type arguments and type parameters of the enclosing class.
-    const intptr_t offset = cls.NumTypeArguments() - cls.NumTypeParameters();
+    // arguments vector of its parameterized class. The offset to add is the
+    // number of type arguments in the super type, which is equal to the
+    // difference in number of type arguments and type parameters of the
+    // parameterized class.
+    const intptr_t offset = parameterized_class.NumTypeArguments() -
+                            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.
   Type& parameterized_type = Type::Handle();
   parameterized_type ^= type.raw();
 
@@ skipping 21 matching lines @@
       type_argument = FinalizeType(cls, type_argument, finalization);
       arguments.SetTypeAt(i, type_argument);
     }
   }
 
   // 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) and the upper
   // bounds of its type parameters must be finalized (done here).
   Class& type_class = Class::Handle(parameterized_type.type_class());
+  if (!type_class.is_finalized()) {
+    FinalizeTypeParameters(type_class);
+  }
 
   // If the type class is a signature class, we are finalizing its signature
   // type, thereby finalizing the result type and parameter types of its
   // signature function.
   // Do this before marking this type as finalized in order to detect cycles.
   if (type_class.IsSignatureClass()) {
     // Signature classes are finalized upon creation.
     ASSERT(type_class.is_finalized());
     // Resolve and finalize the result and parameter types of the signature
     // function of this signature class.
@@ skipping 22 matching lines @@
         Error::Handle(),  // No previous error.
         cls, parameterized_type, finalization,
         "wrong number of type arguments in type '%s'",
         String::Handle(parameterized_type.Name()).ToCString());
     return parameterized_type.raw();
   }
   // 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.
   if (num_type_arguments > 0) {
-    TypeArguments& full_arguments = TypeArguments::Handle(
-        TypeArguments::New(num_type_arguments));
-    // Copy the parsed type arguments at the correct offset in the full type
-    // argument vector.
-    const intptr_t offset = num_type_arguments - num_type_parameters;
-    AbstractType& type = AbstractType::Handle(Type::DynamicType());
-    for (intptr_t i = 0; i < num_type_parameters; i++) {
-      // If no type parameters were provided, a raw type is desired, so we
-      // create a vector of DynamicType.
-      if (!arguments.IsNull()) {
-        type = arguments.TypeAt(i);
+    TypeArguments& full_arguments = TypeArguments::Handle();
+    // 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)) {
+      full_arguments = TypeArguments::New(num_type_arguments);
+      // Copy the parsed type arguments at the correct offset in the full type
+      // argument vector.
+      const intptr_t offset = num_type_arguments - num_type_parameters;
+      AbstractType& type_arg = AbstractType::Handle(Type::DynamicType());
+      for (intptr_t i = 0; i < num_type_parameters; i++) {
+        // If no type parameters were provided, a raw type is desired, so we
+        // create a vector of DynamicType.
+        if (!arguments.IsNull()) {
+          type_arg = arguments.TypeAt(i);
+        }
+        ASSERT(type_arg.IsFinalized());  // Index of type parameter is adjusted.
+        full_arguments.SetTypeAt(offset + i, type_arg);
       }
-      full_arguments.SetTypeAt(offset + i, type);
+      if (type_class.IsSignatureClass()) {
+        const Function& signature_fun =
+            Function::Handle(type_class.signature_function());
+        ASSERT(!signature_fun.is_static());
+        const Class& sig_fun_owner = Class::Handle(signature_fun.owner());
+        FinalizeTypeArguments(sig_fun_owner, full_arguments, finalization);
+      } else {
+        FinalizeTypeArguments(type_class, full_arguments, finalization);
+      }
+      if (full_arguments.IsRaw(num_type_arguments)) {
+        // The parameterized_type is raw. Set its argument vector to null, which
+        // is more efficient in type tests.
+        full_arguments = TypeArguments::null();
+      } else {
+        // FinalizeTypeArguments can modify 'full_arguments',
+        // canonicalize afterwards.
+        full_arguments ^= full_arguments.Canonicalize();
+      }
+      parameterized_type.set_arguments(full_arguments);
+    } else {
+      ASSERT(full_arguments.IsNull());  // Use null vector for raw type.
     }
-    if (type_class.IsSignatureClass()) {
-      const Function& signature_fun =
-          Function::Handle(type_class.signature_function());
-      ASSERT(!signature_fun.is_static());
-      const Class& signature_fun_owner = Class::Handle(signature_fun.owner());
-      FinalizeTypeArguments(signature_fun_owner, full_arguments, finalization);
-    } else {
-      FinalizeTypeArguments(type_class, full_arguments, finalization);
-    }
-    // FinalizeTypeArguments can modify 'full_arguments',
-    // canonicalize afterwards.
-    full_arguments ^= full_arguments.Canonicalize();
-    parameterized_type.set_arguments(full_arguments);
-
     // Mark the type as finalized.
     parameterized_type.set_is_finalized();
 
     // 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.IsInstantiated()) {
+    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.
       if (!full_arguments.IsWithinBoundsOf(type_class,
                                            full_arguments,
                                            &malformed_error)) {
         ASSERT(!malformed_error.IsNull());
         // The type argument vector of the type is not within bounds. The type
         // is malformed. Prepend malformed_error to new malformed type error in
         // order to report both locations.
@@ skipping 262 matching lines @@
   if (!IsSuperCycleFree(cls)) {
     const String& name = String::Handle(cls.Name());
     const Script& script = Script::Handle(cls.script());
     ReportError(script, cls.token_index(),
                 "class '%s' has a cycle in its superclass relationship",
                 name.ToCString());
   }
   const GrowableObjectArray& visited =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   ResolveInterfaces(cls, visited);
+  // Finalize super class.
+  const Class& super_class = Class::Handle(cls.SuperClass());
+  if (!super_class.IsNull()) {
+    FinalizeClass(super_class, generating_snapshot);
+  }
+  // Finalize type parameters before finalizing the super type.
+  FinalizeTypeParameters(cls);
+  // Finalize super type.
   Type& super_type = Type::Handle(cls.super_type());
   if (!super_type.IsNull()) {
-    const Class& super_class = Class::Handle(super_type.type_class());
-    // Finalize super class and super type.
-    FinalizeClass(super_class, generating_snapshot);
     super_type ^= FinalizeType(cls, super_type, kFinalizeWellFormed);
     cls.set_super_type(super_type);
   }
+  // Finalize factory class, if any.
   if (cls.is_interface()) {
     if (cls.HasFactoryClass()) {
       const Class& factory_class = Class::Handle(cls.FactoryClass());
-      // Finalize factory class.
       if (!factory_class.is_finalized()) {
         FinalizeClass(factory_class, generating_snapshot);
         // Finalizing the factory class may indirectly finalize this interface.
         if (cls.is_finalized()) {
           return;
         }
       }
     }
   }
   // Finalize interface types (but not necessarily interface classes).
@@ skipping 292 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