Canonicalize TypeArguments.

runtime/vm/code_generator.cc

 // Copyright (c) 2011, 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/code_index_table.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
@@ skipping 119 matching lines @@
     }
     return;
   }
   ASSERT(!element_type.IsInstantiated());
   // If possible, use the instantiator as the type argument vector.
   if (element_type.IsUninstantiatedIdentity() && (instantiator.Length() == 1)) {
     // No need to check that the instantiator is a TypeArguments, since the
     // virtual call to Length() handles other cases that are harder to inline.
     element_type = instantiator.raw();
   } else {
-    element_type =
-        AbstractTypeArguments::NewInstantiatedTypeArguments(element_type,
-                                                            instantiator);
+    element_type = InstantiatedTypeArguments::New(element_type, instantiator);
   }
   array.SetTypeArguments(element_type);
 }
 
 
 // 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.
 // Return value: newly allocated object.
@@ skipping 27 matching lines @@
     return;
   }
   ASSERT(!type_arguments.IsInstantiated());
   // If possible, use the instantiator as the type argument vector.
   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 =
-        AbstractTypeArguments::NewInstantiatedTypeArguments(type_arguments,
-                                                            instantiator);
+        InstantiatedTypeArguments::New(type_arguments, instantiator);
   } else {
     if (type_arguments.IsUninstantiatedIdentity() &&
         (instantiator.Length() == type_arguments.Length())) {
       type_arguments = instantiator.raw();
     } else {
       type_arguments =
-          AbstractTypeArguments::NewInstantiatedTypeArguments(type_arguments,
-                                                              instantiator);
+          InstantiatedTypeArguments::New(type_arguments, instantiator);
     }
   }
   instance.SetTypeArguments(type_arguments);
 }
 
 
 // Instantiate type arguments.
 // Arg0: uninstantiated type arguments.
 // Arg1: instantiator type arguments.
 // Return value: instantiated type arguments.
 DEFINE_RUNTIME_ENTRY(InstantiateTypeArguments, 2) {
   ASSERT(arguments.Count() ==
          kInstantiateTypeArgumentsRuntimeEntry.argument_count());
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::CheckedHandle(arguments.At(0));
   const AbstractTypeArguments& instantiator =
       AbstractTypeArguments::CheckedHandle(arguments.At(1));
   ASSERT(!type_arguments.IsNull() &&
          !type_arguments.IsInstantiated() &&
          !instantiator.IsNull());
   // Code inlined in the caller should have optimized the case where the
   // instantiator can be used as type argument vector.
   ASSERT(!type_arguments.IsUninstantiatedIdentity() ||
          !instantiator.IsTypeArguments() ||
          (instantiator.Length() != type_arguments.Length()));
-  type_arguments =
-      AbstractTypeArguments::NewInstantiatedTypeArguments(type_arguments,
-                                                          instantiator);
+  type_arguments = InstantiatedTypeArguments::New(type_arguments, instantiator);
   arguments.SetReturn(type_arguments);
 }
 
 
 // Allocate a new closure.
 // Arg0: local function.
 // Arg1: type arguments of the closure.
 // Return value: newly allocated closure.
 DEFINE_RUNTIME_ENTRY(AllocateClosure, 2) {
   ASSERT(arguments.Count() == kAllocateClosureRuntimeEntry.argument_count());
@@ skipping 809 matching lines @@
       }
     }
   }
   // The cache is null terminated, therefore the loop above should never
   // terminate by itself.
   UNREACHABLE();
   return Code::null();
 }
 
 }  // namespace dart