Implement eager instantiation and canonicalization of type arguments at run

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 384 matching lines @@
   // of the redirection chain.
   ResolveRedirectingFactoryTarget(target_class, target, visited_factories);
   Type& target_type = Type::Handle(target.RedirectionType());
   Function& target_target = Function::Handle(target.RedirectionTarget());
   if (target_target.IsNull()) {
     ASSERT(target_type.IsMalformed());
   } else {
     // 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());
+      const TypeArguments& type_args = TypeArguments::Handle(type.arguments());
       Error& bound_error = Error::Handle();
       target_type ^= target_type.InstantiateFrom(type_args, &bound_error);
       if (bound_error.IsNull()) {
         target_type ^= FinalizeType(cls, target_type, kCanonicalize);
       } else {
         ASSERT(target_type.IsInstantiated() && type_args.IsInstantiated());
         const Script& script = Script::Handle(target_class.script());
         FinalizeMalformedType(bound_error, script, target_type,
                               "cannot resolve redirecting factory");
         target_target = Function::null();
@@ skipping 37 matching lines @@
           parameterized_type,
           "cannot resolve class '%s' from '%s'",
           String::Handle(unresolved_class.Name()).ToCString(),
           String::Handle(cls.Name()).ToCString());
       return;
     }
     parameterized_type.set_type_class(type_class);
   }
 
   // Resolve type arguments, if any.
-  const AbstractTypeArguments& arguments =
-      AbstractTypeArguments::Handle(type.arguments());
+  const TypeArguments& arguments = TypeArguments::Handle(type.arguments());
   if (!arguments.IsNull()) {
     const 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);
     }
   }
 }
 
@@ skipping 48 matching lines @@
 //             cls = C, arguments = [dynamic, String, double],
 //             num_uninitialized_arguments = 1,
 //             i.e. cls_args = [String, double], offset = 1, length = 2.
 //   Output:   arguments = [int, String, double]
 //
 // It is too early to canonicalize the type arguments of the vector, because
 // several type argument vectors may be mutually recursive and finalized at the
 // same time. Canonicalization happens when pending types are processed.
 void ClassFinalizer::FinalizeTypeArguments(
     const Class& cls,
-    const AbstractTypeArguments& arguments,
+    const TypeArguments& arguments,
     intptr_t num_uninitialized_arguments,
     Error* bound_error,
     GrowableObjectArray* pending_types) {
   ASSERT(arguments.Length() >= cls.NumTypeArguments());
   if (!cls.is_type_finalized()) {
     FinalizeTypeParameters(cls, pending_types);
     ResolveUpperBounds(cls);
   }
   AbstractType& super_type = AbstractType::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     const Class& super_class = Class::Handle(super_type.type_class());
     const intptr_t num_super_type_params = super_class.NumTypeParameters();
     const intptr_t num_super_type_args = super_class.NumTypeArguments();
     ASSERT(num_super_type_args ==
            (cls.NumTypeArguments() - cls.NumOwnTypeArguments()));
     if (!super_type.IsFinalized() && !super_type.IsBeingFinalized()) {
       super_type ^= FinalizeType(
           cls, super_type, kFinalize, pending_types);
       cls.set_super_type(super_type);
     }
-    AbstractTypeArguments& super_type_args = AbstractTypeArguments::Handle(
+    TypeArguments& super_type_args = TypeArguments::Handle(
         super_type.arguments());
     // Offset of super type's type parameters in cls' type argument vector.
     const intptr_t super_offset = num_super_type_args - num_super_type_params;
     AbstractType& super_type_arg = AbstractType::Handle(Type::DynamicType());
     for (intptr_t i = super_offset; i < num_uninitialized_arguments; i++) {
       if (!super_type_args.IsNull()) {
         super_type_arg = super_type_args.TypeAt(i);
         if (!super_type_arg.IsFinalized()) {
           super_type_arg ^= FinalizeType(
               cls, super_type_arg, kFinalize, pending_types);
@@ skipping 21 matching lines @@
                           bound_error, pending_types);
   }
 }
 
 
 // Check the type argument vector 'arguments' against the corresponding bounds
 // of the type parameters of class 'cls' and, recursively, of its superclasses.
 // Replace a type argument that cannot be checked at compile time by a
 // BoundedType, thereby postponing the bound check to run time.
 // Return a bound error if a type argument is not within bound at compile time.
-void ClassFinalizer::CheckTypeArgumentBounds(
-    const Class& cls,
-    const AbstractTypeArguments& arguments,
-    Error* bound_error) {
+void ClassFinalizer::CheckTypeArgumentBounds(const Class& cls,
+                                             const TypeArguments& arguments,
+                                             Error* bound_error) {
   if (!cls.is_type_finalized()) {
     FinalizeUpperBounds(cls);
   }
   // Note that when finalizing a type, we need to verify the bounds in both
   // production mode and checked mode, because the finalized type may be written
   // to a snapshot. It would be wrong to ignore bounds when generating the
   // snapshot in production mode and then use the unchecked type in checked mode
   // after reading it from the snapshot.
   // However, we do not immediately report a bound error, which would be wrong
   // in production mode, but simply postpone the bound checking to runtime.
@@ skipping 72 matching lines @@
   AbstractType& super_type = AbstractType::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     const Class& super_class = Class::Handle(super_type.type_class());
     CheckTypeArgumentBounds(super_class, arguments, bound_error);
   }
 }
 
 
 void ClassFinalizer::CheckTypeBounds(const Class& cls, const Type& type) {
   ASSERT(type.IsFinalized());
-  AbstractTypeArguments& arguments =
-      AbstractTypeArguments::Handle(type.arguments());
+  TypeArguments& arguments = TypeArguments::Handle(type.arguments());
   if (arguments.IsNull()) {
     return;
   }
   Class& owner_class = Class::Handle();
   Class& type_class = Class::Handle(type.type_class());
   if (type_class.IsSignatureClass()) {
     const Function& signature_fun =
         Function::Handle(type_class.signature_function());
     ASSERT(!signature_fun.is_static());
     owner_class = signature_fun.Owner();
@@ skipping 118 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.
-  AbstractTypeArguments& arguments =
-      AbstractTypeArguments::Handle(parameterized_type.arguments());
+  TypeArguments& arguments =
+      TypeArguments::Handle(parameterized_type.arguments());
   if (!arguments.IsNull() && (arguments.Length() != num_type_parameters)) {
     // 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.
-    arguments = AbstractTypeArguments::null();
+    arguments = TypeArguments::null();
     parameterized_type.set_arguments(arguments);
   }
 
   // The full type argument vector consists of the type arguments of the
   // super types of type_class, which are 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
@@ skipping 98 matching lines @@
   // 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 (FLAG_trace_type_finalization) {
     OS::Print("Done finalizing type '%s' with %" Pd " type args: %s\n",
               String::Handle(parameterized_type.Name()).ToCString(),
-              parameterized_type.arguments() == AbstractTypeArguments::null() ?
+              parameterized_type.arguments() == TypeArguments::null() ?
                   0 : num_type_arguments,
               parameterized_type.ToCString());
   }
 
   if (finalization >= kCanonicalize) {
     return parameterized_type.Canonicalize();
   } else {
     return parameterized_type.raw();
   }
 }
@@ skipping 66 matching lines @@
   }
   return Class::null();
 }
 
 
 // Resolve the upper bounds of the type parameters of class cls.
 void ClassFinalizer::ResolveUpperBounds(const Class& cls) {
   const intptr_t num_type_params = cls.NumTypeParameters();
   TypeParameter& type_param = TypeParameter::Handle();
   AbstractType& bound = AbstractType::Handle();
-  const AbstractTypeArguments& type_params =
-      AbstractTypeArguments::Handle(cls.type_parameters());
+  const TypeArguments& type_params =
+      TypeArguments::Handle(cls.type_parameters());
   ASSERT((type_params.IsNull() && (num_type_params == 0)) ||
          (type_params.Length() == num_type_params));
   // In a first pass, resolve all bounds. This guarantees that finalization
   // of mutually referencing bounds will not encounter an unresolved bound.
   for (intptr_t i = 0; i < num_type_params; i++) {
     type_param ^= type_params.TypeAt(i);
     bound = type_param.bound();
     ResolveType(cls, bound);
   }
 }
 
 
 // Finalize the upper bounds of the type parameters of class cls.
 void ClassFinalizer::FinalizeUpperBounds(const Class& cls) {
   const intptr_t num_type_params = cls.NumTypeParameters();
   TypeParameter& type_param = TypeParameter::Handle();
   AbstractType& bound = AbstractType::Handle();
-  const AbstractTypeArguments& type_params =
-      AbstractTypeArguments::Handle(cls.type_parameters());
+  const TypeArguments& type_params =
+      TypeArguments::Handle(cls.type_parameters());
   ASSERT((type_params.IsNull() && (num_type_params == 0)) ||
          (type_params.Length() == num_type_params));
   for (intptr_t i = 0; i < num_type_params; i++) {
     type_param ^= type_params.TypeAt(i);
     bound = type_param.bound();
     if (bound.IsFinalized() || bound.IsBeingFinalized()) {
       // A bound involved in F-bounded quantification may form a cycle.
       continue;
     }
     bound = FinalizeType(cls, bound, kCanonicalize);
@@ skipping 100 matching lines @@
       Error& error = Error::Handle();
       if (type.IsMalformedOrMalbounded()) {
         error = type.error();
       } else {
         ASSERT(type.IsInstantiated());
       }
       const Instance& const_value = Instance::Handle(field.value());
       if (!error.IsNull() ||
           (!type.IsDynamicType() &&
            !const_value.IsInstanceOf(type,
-                                     AbstractTypeArguments::Handle(),
+                                     Object::null_type_arguments(),
                                      &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(error, script, field.token_pos(),
                       "error initializing static %s field '%s': "
@@ skipping 174 matching lines @@
 // Example:
 //   class S<T> { }
 //   class M<T> { }
 //   class C<E> extends S<E> with M<List<E>> { }
 // results in
 //   class S&M<T`, T> extends S<T`> implements M<T> { } // mixin == M<T>
 //   class C<E> extends S&M<E, List<E>> { }
 // CloneMixinAppTypeParameters decorates class S&M with type parameters T` and
 // T, and use them as type arguments in S<T`> and M<T>.
 void ClassFinalizer::CloneMixinAppTypeParameters(const Class& mixin_app_class) {
-  ASSERT(mixin_app_class.type_parameters() == AbstractTypeArguments::null());
+  ASSERT(mixin_app_class.type_parameters() == TypeArguments::null());
   Isolate* isolate = Isolate::Current();
   const AbstractType& super_type = AbstractType::Handle(isolate,
       mixin_app_class.super_type());
   ASSERT(super_type.IsResolved());
   const Class& super_class = Class::Handle(isolate, super_type.type_class());
   const intptr_t num_super_type_params = super_class.NumTypeParameters();
   const Type& mixin_type = Type::Handle(isolate, mixin_app_class.mixin());
   const Class& mixin_class = Class::Handle(isolate, mixin_type.type_class());
   const intptr_t num_mixin_type_params = mixin_class.NumTypeParameters();
   // The mixin class cannot be Object and this was checked earlier.
@@ skipping 257 matching lines @@
     // CloneMixinAppTypeParameters on the inserted class, as long as the super
     // type class is set properly.
     inserted_class.set_super_type(super_type);  // Super class only is used.
 
     // The mixin type and interface type must also be set before calling
     // CloneMixinAppTypeParameters.
     // After FinalizeTypesInClass, they will refer to the type parameters of
     // the mixin class typedef.
     const Type& generic_mixin_type = Type::Handle(isolate,
         Type::New(Class::Handle(isolate, aliased_mixin_type.type_class()),
-                  Object::null_abstract_type_arguments(),
+                  Object::null_type_arguments(),
                   aliased_mixin_type.token_pos()));
     inserted_class.set_mixin(generic_mixin_type);
     // The interface will be set in CloneMixinAppTypeParameters.
   }
 
   // Finalize the types and call CloneMixinAppTypeParameters.
   FinalizeTypesInClass(inserted_class);
 
   // The super type of this mixin application class must point to the
   // inserted class. The super type arguments are the concatenation of the
@@ skipping 29 matching lines @@
   const Class& aliased_mixin_type_class = Class::Handle(isolate,
       aliased_mixin_type.type_class());
   const intptr_t num_aliased_mixin_type_params =
       aliased_mixin_type_class.NumTypeParameters();
   const intptr_t num_aliased_mixin_type_args =
       aliased_mixin_type_class.NumTypeArguments();
   offset = num_aliased_mixin_type_args - num_aliased_mixin_type_params;
   ASSERT(inserted_class.NumTypeParameters() ==
          (num_super_type_params + num_aliased_mixin_type_params));
   // The aliased_mixin_type may be raw.
-  const AbstractTypeArguments& mixin_class_super_type_args =
-      AbstractTypeArguments::Handle(isolate,
+  const TypeArguments& mixin_class_super_type_args =
+      TypeArguments::Handle(isolate,
           AbstractType::Handle(isolate, mixin_class.super_type()).arguments());
   TypeArguments& new_mixin_type_args = TypeArguments::Handle(isolate);
   if ((num_aliased_mixin_type_params > 0) &&
       !mixin_class_super_type_args.IsNull()) {
     new_mixin_type_args = TypeArguments::New(num_aliased_mixin_type_params);
     for (intptr_t i = 0; i < num_aliased_mixin_type_params; i++) {
       type = mixin_class_super_type_args.TypeAt(offset + i);
       new_mixin_type_args.SetTypeAt(i, type);
     }
   }
@@ skipping 488 matching lines @@
     GrowableArray<intptr_t>* visited) {
   ASSERT(visited != NULL);
   ResolveType(cls, type);
   if (type.IsType() && !type.IsMalformed()) {
     const Class& type_class = Class::Handle(type.type_class());
     if (!type_class.is_type_finalized() &&
         type_class.IsSignatureClass() &&
         !IsAliasCycleFree(type_class, visited)) {
       return false;
     }
-    const AbstractTypeArguments& type_args = AbstractTypeArguments::Handle(
-        type.arguments());
+    const TypeArguments& type_args = TypeArguments::Handle(type.arguments());
     if (!type_args.IsNull()) {
       AbstractType& type_arg = AbstractType::Handle();
       for (intptr_t i = 0; i < type_args.Length(); i++) {
         type_arg = type_args.TypeAt(i);
         if (!IsTypeCycleFree(cls, type_arg, visited)) {
           return false;
         }
       }
     }
   }
@@ skipping 15 matching lines @@
     }
   }
 
   // Visit the bounds, result type, and parameter types of this signature type.
   visited->Add(cls.id());
   AbstractType& type = AbstractType::Handle();
 
   // Check the bounds of this signature type.
   const intptr_t num_type_params = cls.NumTypeParameters();
   TypeParameter& type_param = TypeParameter::Handle();
-  const AbstractTypeArguments& type_params =
-      AbstractTypeArguments::Handle(cls.type_parameters());
+  const TypeArguments& type_params =
+      TypeArguments::Handle(cls.type_parameters());
   ASSERT((type_params.IsNull() && (num_type_params == 0)) ||
          (type_params.Length() == num_type_params));
   for (intptr_t i = 0; i < num_type_params; i++) {
     type_param ^= type_params.TypeAt(i);
     type = type_param.bound();
     if (!IsTypeCycleFree(cls, type, visited)) {
       return false;
     }
   }
   // Check the result type of the function of this signature type.
@@ skipping 46 matching lines @@
   return true;
 }
 
 
 void ClassFinalizer::CollectTypeArguments(
     const Class& cls,
     const Type& type,
     const GrowableObjectArray& collected_args) {
   ASSERT(type.HasResolvedTypeClass());
   Class& type_class = Class::Handle(type.type_class());
-  AbstractTypeArguments& type_args =
-      AbstractTypeArguments::Handle(type.arguments());
+  TypeArguments& type_args = TypeArguments::Handle(type.arguments());
   const intptr_t num_type_parameters = type_class.NumTypeParameters();
   const intptr_t num_type_arguments =
       type_args.IsNull() ? 0 : type_args.Length();
   AbstractType& arg = AbstractType::Handle();
   if (num_type_arguments > 0) {
     if (num_type_arguments == num_type_parameters) {
       for (intptr_t i = 0; i < num_type_arguments; i++) {
         arg = type_args.TypeAt(i);
         arg = arg.CloneUnfinalized();
         ASSERT(!arg.IsBeingFinalized());
@@ skipping 93 matching lines @@
                                           mixin_type_class_name);
     mixin_app_class = library.LookupLocalClass(mixin_app_class_name);
     if (mixin_app_class.IsNull()) {
       mixin_app_class_name = Symbols::New(mixin_app_class_name);
       mixin_app_class = Class::New(mixin_app_class_name,
                                    script,
                                    mixin_type.token_pos());
       mixin_app_class.set_super_type(mixin_super_type);
       mixin_type_class = mixin_type.type_class();
       generic_mixin_type = Type::New(mixin_type_class,
-                                     Object::null_abstract_type_arguments(),
+                                     Object::null_type_arguments(),
                                      mixin_type.token_pos());
       mixin_app_class.set_mixin(generic_mixin_type);
       mixin_app_class.set_is_synthesized_class();
       library.AddClass(mixin_app_class);
 
       // No need to add the new class to pending_classes, since it will be
       // processed via the super_type chain of a pending class.
 
       if (FLAG_trace_class_finalization) {
         OS::Print("Creating mixin application %s\n",
                   mixin_app_class.ToCString());
       }
     }
     // This mixin application class becomes the type class of the super type of
     // the next mixin application class. It is however too early to provide the
     // correct super type arguments. We use the raw type for now.
     mixin_super_type = Type::New(mixin_app_class,
-                                 Object::null_abstract_type_arguments(),
+                                 Object::null_type_arguments(),
                                  mixin_type.token_pos());
   }
   AbstractType& type_arg = AbstractType::Handle();
   const TypeArguments& mixin_app_args =
     TypeArguments::Handle(TypeArguments::New(type_args.Length()));
   for (intptr_t i = 0; i < type_args.Length(); i++) {
     type_arg ^= type_args.At(i);
     mixin_app_args.SetTypeAt(i, type_arg);
   }
   if (FLAG_trace_class_finalization) {
@@ skipping 272 matching lines @@
           prev_error, script, type.token_pos(),
           LanguageError::kMalformedType, Heap::kOld,
           format, args));
   if (FLAG_error_on_bad_type) {
     ReportError(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());
+  type.set_arguments(Object::null_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());
   }
 }
 
@@ skipping 127 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