Improve type optimization reusing the type argument vector of the instantiator

runtime/vm/code_generator.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/code_generator.h"
 
 #include "vm/assembler.h"
 #include "vm/ast.h"
 #include "vm/bigint_operations.h"
 #include "vm/code_patcher.h"
@@ skipping 80 matching lines @@
 // Arg0: array length.
 // Arg1: array type arguments, i.e. vector of 1 type, the element type.
 // Return value: newly allocated array of length arg0.
 DEFINE_RUNTIME_ENTRY(AllocateArray, 2) {
   ASSERT(arguments.ArgCount() == kAllocateArrayRuntimeEntry.argument_count());
   const Smi& length = Smi::CheckedHandle(arguments.ArgAt(0));
   const Array& array = Array::Handle(Array::New(length.Value()));
   arguments.SetReturn(array);
   AbstractTypeArguments& element_type =
       AbstractTypeArguments::CheckedHandle(arguments.ArgAt(1));
-  // An Array is raw or takes only one type argument.
+  // An Array is raw or takes one type argument. However, its type argument
+  // vector may be longer than 1 due to a type optimization reusing the type
+  // argument vector of the instantiator.
   ASSERT(element_type.IsNull() ||
-         ((element_type.Length() == 1) && element_type.IsInstantiated()));
+         ((element_type.Length() >= 1) && element_type.IsInstantiated()));
   array.SetTypeArguments(element_type);  // May be null.
 }
 
 
 // Allocate a new object.
 // Arg0: class of the object that needs to be allocated.
 // Arg1: type arguments of the object that needs to be allocated.
 // Arg2: type arguments of the instantiator or kNoInstantiator.
 // Return value: newly allocated object.
 DEFINE_RUNTIME_ENTRY(AllocateObject, 3) {
   ASSERT(arguments.ArgCount() == kAllocateObjectRuntimeEntry.argument_count());
   const Class& cls = Class::CheckedHandle(arguments.ArgAt(0));
   const Instance& instance = Instance::Handle(Instance::New(cls));
   arguments.SetReturn(instance);
   if (!cls.HasTypeArguments()) {
     // No type arguments required for a non-parameterized type.
     ASSERT(Instance::CheckedHandle(arguments.ArgAt(1)).IsNull());
     return;
   }
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::CheckedHandle(arguments.ArgAt(1));
-  ASSERT(type_arguments.IsNull() ||
-         (type_arguments.Length() == cls.NumTypeArguments()));
   // If no instantiator is provided, set the type arguments and return.
   if (Object::Handle(arguments.ArgAt(2)).IsSmi()) {
     ASSERT(Smi::CheckedHandle(arguments.ArgAt(2)).Value() ==
            StubCode::kNoInstantiator);
+    // Unless null (for a raw type), the type argument vector may be longer than
+    // necessary due to a type optimization reusing the type argument vector of
+    // the instantiator.
+    ASSERT(type_arguments.IsNull() ||
+           (type_arguments.IsInstantiated() &&
+            (type_arguments.Length() >= cls.NumTypeArguments())));
     instance.SetTypeArguments(type_arguments);  // May be null.
     return;
   }
-  ASSERT(!type_arguments.IsInstantiated());
+  // A still uninstantiated type argument vector must have the correct length.
+  ASSERT(!type_arguments.IsInstantiated() &&
+         (type_arguments.Length() == cls.NumTypeArguments()));
   const AbstractTypeArguments& instantiator =
       AbstractTypeArguments::CheckedHandle(arguments.ArgAt(2));
   ASSERT(instantiator.IsNull() || instantiator.IsInstantiated());
-  if (instantiator.IsNull()) {
-    type_arguments =
-        InstantiatedTypeArguments::New(type_arguments, instantiator);
-  } else if (instantiator.IsTypeArguments()) {
-    // Code inlined in the caller should have optimized the case where the
-    // instantiator is a TypeArguments and can be used as type argument vector.
-    ASSERT(!type_arguments.IsUninstantiatedIdentity() ||
-           (instantiator.Length() != type_arguments.Length()));
-    type_arguments =
-        InstantiatedTypeArguments::New(type_arguments, instantiator);
-  } else {
-    // If possible, use the instantiator as the type argument vector.
-    if (type_arguments.IsUninstantiatedIdentity() &&
-        (instantiator.Length() == type_arguments.Length())) {
-      type_arguments = instantiator.raw();
-    } else {
-      type_arguments =
-          InstantiatedTypeArguments::New(type_arguments, instantiator);
-    }
-  }
-  ASSERT(type_arguments.IsInstantiated());
+  // Code inlined in the caller should have optimized the case where the
+  // instantiator can be reused as type argument vector.
+  ASSERT(instantiator.IsNull() || !type_arguments.IsUninstantiatedIdentity());
+  type_arguments = InstantiatedTypeArguments::New(type_arguments, instantiator);
   instance.SetTypeArguments(type_arguments);
 }
 
 
 // Helper returning the token position of the Dart caller.
 static intptr_t GetCallerLocation() {
   DartFrameIterator iterator;
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   return caller_frame->GetTokenPos();
 }
 
 
 // Allocate a new object of a generic type and check that the instantiated type
 // arguments are within the declared bounds or throw a dynamic type error.
 // Arg0: class of the object that needs to be allocated.
 // Arg1: type arguments of the object that needs to be allocated.
 // Arg2: type arguments of the instantiator or kNoInstantiator.
 // Return value: newly allocated object.
 DEFINE_RUNTIME_ENTRY(AllocateObjectWithBoundsCheck, 3) {
   ASSERT(FLAG_enable_type_checks);
   ASSERT(arguments.ArgCount() ==
          kAllocateObjectWithBoundsCheckRuntimeEntry.argument_count());
   const Class& cls = Class::CheckedHandle(arguments.ArgAt(0));
   const Instance& instance = Instance::Handle(Instance::New(cls));
   arguments.SetReturn(instance);
   ASSERT(cls.HasTypeArguments());
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::CheckedHandle(arguments.ArgAt(1));
-  ASSERT(type_arguments.IsNull() ||
-         (type_arguments.Length() == cls.NumTypeArguments()));
   if (Object::Handle(arguments.ArgAt(2)).IsSmi()) {
     ASSERT(Smi::CheckedHandle(arguments.ArgAt(2)).Value() ==
            StubCode::kNoInstantiator);
+    // Unless null (for a raw type), the type argument vector may be longer than
+    // necessary due to a type optimization reusing the type argument vector of
+    // the instantiator.
+    ASSERT(type_arguments.IsNull() ||
+           (type_arguments.IsInstantiated() &&
+            (type_arguments.Length() >= cls.NumTypeArguments())));
   } else {
-    ASSERT(!type_arguments.IsInstantiated());
+    // A still uninstantiated type argument vector must have the correct length.
+    ASSERT(!type_arguments.IsInstantiated() &&
+           (type_arguments.Length() == cls.NumTypeArguments()));
     const AbstractTypeArguments& instantiator =
         AbstractTypeArguments::CheckedHandle(arguments.ArgAt(2));
     ASSERT(instantiator.IsNull() || instantiator.IsInstantiated());
     Error& malformed_error = Error::Handle();
-    if (instantiator.IsNull()) {
-      type_arguments = type_arguments.InstantiateFrom(instantiator,
-                                                      &malformed_error);
-    } else if (instantiator.IsTypeArguments()) {
-      // Code inlined in the caller should have optimized the case where the
-      // instantiator is a TypeArguments and can be used as type argument
-      // vector.
-      ASSERT(!type_arguments.IsUninstantiatedIdentity() ||
-             (instantiator.Length() != type_arguments.Length()));
-      type_arguments = type_arguments.InstantiateFrom(instantiator,
-                                                      &malformed_error);
-    } else {
-      // If possible, use the instantiator as the type argument vector.
-      if (type_arguments.IsUninstantiatedIdentity() &&
-          (instantiator.Length() == type_arguments.Length())) {
-        type_arguments = instantiator.raw();
-      } else {
-        type_arguments = type_arguments.InstantiateFrom(instantiator,
-                                                        &malformed_error);
-      }
-    }
+    // Code inlined in the caller should have optimized the case where the
+    // instantiator can be reused as type argument vector.
+  ASSERT(instantiator.IsNull() || !type_arguments.IsUninstantiatedIdentity());
+    type_arguments = type_arguments.InstantiateFrom(instantiator,
+                                                    &malformed_error);
     if (!malformed_error.IsNull()) {
       // Throw a dynamic type error.
       const intptr_t location = GetCallerLocation();
       String& malformed_error_message =  String::Handle(
           String::New(malformed_error.ToErrorCString()));
       Exceptions::CreateAndThrowTypeError(
           location, Symbols::Empty(), Symbols::Empty(),
           Symbols::Empty(), malformed_error_message);
       UNREACHABLE();
     }
@@ skipping 10 matching lines @@
 DEFINE_RUNTIME_ENTRY(InstantiateTypeArguments, 2) {
   ASSERT(arguments.ArgCount() ==
          kInstantiateTypeArgumentsRuntimeEntry.argument_count());
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::CheckedHandle(arguments.ArgAt(0));
   const AbstractTypeArguments& instantiator =
       AbstractTypeArguments::CheckedHandle(arguments.ArgAt(1));
   ASSERT(!type_arguments.IsNull() && !type_arguments.IsInstantiated());
   ASSERT(instantiator.IsNull() || instantiator.IsInstantiated());
   // Code inlined in the caller should have optimized the case where the
-  // instantiator can be used as type argument vector.
-  ASSERT(instantiator.IsNull() ||
-         !type_arguments.IsUninstantiatedIdentity() ||
-         !instantiator.IsTypeArguments() ||
-         (instantiator.Length() != type_arguments.Length()));
+  // instantiator can be reused as type argument vector.
+  ASSERT(instantiator.IsNull() || !type_arguments.IsUninstantiatedIdentity());
   type_arguments = InstantiatedTypeArguments::New(type_arguments, instantiator);
   ASSERT(type_arguments.IsInstantiated());
   arguments.SetReturn(type_arguments);
 }
 
 
 // Allocate a new closure.
 // The type argument vector of a closure is always the vector of type parameters
 // of its signature class, i.e. an uninstantiated identity vector. Therefore,
 // the instantiator type arguments can be used as the instantiated closure type
@@ skipping 1452 matching lines @@
 //   Arg1: Value that is being stored.
 DEFINE_RUNTIME_ENTRY(UpdateFieldCid, 2) {
   ASSERT(arguments.ArgCount() == kUpdateFieldCidRuntimeEntry.argument_count());
   const Field& field = Field::CheckedHandle(arguments.ArgAt(0));
   const Object& value = Object::Handle(arguments.ArgAt(1));
 
   field.UpdateCid(Class::Handle(value.clazz()).id());
 }
 
 }  // namespace dart