Ongoing renaming of type classes:

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 92 matching lines @@
 // Allocation of a fixed length array of given element type.
 // Arg0: array length.
 // Arg1: array element type.
 // Arg2: type arguments of the instantiator.
 // Return value: newly allocated array of length arg0.
 DEFINE_RUNTIME_ENTRY(AllocateArray, 3) {
   ASSERT(arguments.Count() == kAllocateArrayRuntimeEntry.argument_count());
   const Smi& length = Smi::CheckedHandle(arguments.At(0));
   const Array& array = Array::Handle(Array::New(length.Value()));
   arguments.SetReturn(array);
-  TypeArguments& element_type = TypeArguments::CheckedHandle(arguments.At(1));
+  AbstractTypeArguments& element_type =
+      AbstractTypeArguments::CheckedHandle(arguments.At(1));
   if (element_type.IsNull()) {
     // No instantiator required for a raw type.
-    ASSERT(TypeArguments::CheckedHandle(arguments.At(2)).IsNull());
+    ASSERT(AbstractTypeArguments::CheckedHandle(arguments.At(2)).IsNull());
     return;
   }
   // An Array takes only one type argument.
   ASSERT(element_type.Length() == 1);
-  const TypeArguments& instantiator =
-      TypeArguments::CheckedHandle(arguments.At(2));
+  const AbstractTypeArguments& instantiator =
+      AbstractTypeArguments::CheckedHandle(arguments.At(2));
   if (instantiator.IsNull()) {
     // Either the type element is instantiated (use it), or the instantiator is
     // of a raw type and we cannot instantiate the element type (leave as null).
     if (element_type.IsInstantiated()) {
       array.SetTypeArguments(element_type);
     }
     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 TypeArray, since the virtual
-    // call to Length() handles other cases that are harder to inline.
+    // 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 = TypeArguments::NewInstantiatedTypeArguments(element_type,
-                                                               instantiator);
+    element_type =
+        AbstractTypeArguments::NewInstantiatedTypeArguments(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.
 DEFINE_RUNTIME_ENTRY(AllocateObject, 3) {
   ASSERT(arguments.Count() == kAllocateObjectRuntimeEntry.argument_count());
   const Class& cls = Class::CheckedHandle(arguments.At(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.At(1)).IsNull());
     return;
   }
-  TypeArguments& type_arguments = TypeArguments::CheckedHandle(arguments.At(1));
+  AbstractTypeArguments& type_arguments =
+      AbstractTypeArguments::CheckedHandle(arguments.At(1));
   if (type_arguments.IsNull()) {
     // No instantiator is required for a raw type.
     ASSERT(Instance::CheckedHandle(arguments.At(2)).IsNull());
     return;
   }
   ASSERT(type_arguments.Length() == cls.NumTypeArguments());
-  const TypeArguments& instantiator =
-      TypeArguments::CheckedHandle(arguments.At(2));
+  const AbstractTypeArguments& instantiator =
+      AbstractTypeArguments::CheckedHandle(arguments.At(2));
   if (instantiator.IsNull()) {
     // Either the type argument vector is instantiated (use it), or the
     // instantiator is of a raw type and we cannot instantiate the type argument
     // vector (leave it as null).
     if (type_arguments.IsInstantiated()) {
       instance.SetTypeArguments(type_arguments);
     }
     return;
   }
   ASSERT(!type_arguments.IsInstantiated());
   // If possible, use the instantiator as the type argument vector.
-  if (instantiator.IsTypeArray()) {
+  if (instantiator.IsTypeArguments()) {
     // Code inlined in the caller should have optimized the case where the
-    // instantiator is a TypeArray and can be used as type argument vector.
+    // instantiator is a TypeArguments and can be used as type argument vector.
     ASSERT(!type_arguments.IsUninstantiatedIdentity() ||
            (instantiator.Length() != type_arguments.Length()));
-    type_arguments = TypeArguments::NewInstantiatedTypeArguments(type_arguments,
-                                                                 instantiator);
+    type_arguments =
+        AbstractTypeArguments::NewInstantiatedTypeArguments(type_arguments,
+                                                            instantiator);
   } else {
     if (type_arguments.IsUninstantiatedIdentity() &&
         (instantiator.Length() == type_arguments.Length())) {
       type_arguments = instantiator.raw();
     } else {
       type_arguments =
-          TypeArguments::NewInstantiatedTypeArguments(type_arguments,
-                                                      instantiator);
+          AbstractTypeArguments::NewInstantiatedTypeArguments(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());
-  TypeArguments& type_arguments = TypeArguments::CheckedHandle(arguments.At(0));
-  const TypeArguments& instantiator =
-      TypeArguments::CheckedHandle(arguments.At(1));
+  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.IsTypeArray() ||
+         !instantiator.IsTypeArguments() ||
          (instantiator.Length() != type_arguments.Length()));
-  type_arguments = TypeArguments::NewInstantiatedTypeArguments(type_arguments,
-                                                               instantiator);
+  type_arguments =
+      AbstractTypeArguments::NewInstantiatedTypeArguments(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());
   const Function& function = Function::CheckedHandle(arguments.At(0));
   ASSERT(function.IsClosureFunction() && !function.IsImplicitClosureFunction());
-  const TypeArguments& type_arguments =
-      TypeArguments::CheckedHandle(arguments.At(1));
+  const AbstractTypeArguments& type_arguments =
+      AbstractTypeArguments::CheckedHandle(arguments.At(1));
   ASSERT(type_arguments.IsNull() || type_arguments.IsInstantiated());
   // The current context was saved in the Isolate structure when entering the
   // runtime.
   const Context& context = Context::Handle(isolate->top_context());
   ASSERT(!context.IsNull());
   const Closure& closure = Closure::Handle(Closure::New(function, context));
   closure.SetTypeArguments(type_arguments);
   arguments.SetReturn(closure);
 }
 
 
 // Allocate a new implicit static closure.
 // Arg0: local function.
 // Return value: newly allocated closure.
 DEFINE_RUNTIME_ENTRY(AllocateImplicitStaticClosure, 1) {
   ASSERT(arguments.Count() ==
          kAllocateImplicitStaticClosureRuntimeEntry.argument_count());
   ObjectStore* object_store = isolate->object_store();
   ASSERT(object_store != NULL);
   const Function& function = Function::CheckedHandle(arguments.At(0));
+  ASSERT(!function.IsNull());
   ASSERT(function.IsImplicitStaticClosureFunction());
   const Context& context = Context::Handle(object_store->empty_context());
   arguments.SetReturn(Closure::Handle(Closure::New(function, context)));
 }
 
 
 // Allocate a new implicit instance closure.
 // Arg0: local function.
 // Arg1: receiver object.
 // Arg2: type arguments of the closure.
 // Return value: newly allocated closure.
 DEFINE_RUNTIME_ENTRY(AllocateImplicitInstanceClosure, 3) {
   ASSERT(arguments.Count() ==
          kAllocateImplicitInstanceClosureRuntimeEntry.argument_count());
   const Function& function = Function::CheckedHandle(arguments.At(0));
   ASSERT(function.IsImplicitInstanceClosureFunction());
   const Instance& receiver = Instance::CheckedHandle(arguments.At(1));
-  const TypeArguments& type_arguments =
-      TypeArguments::CheckedHandle(arguments.At(2));
+  const AbstractTypeArguments& type_arguments =
+      AbstractTypeArguments::CheckedHandle(arguments.At(2));
   ASSERT(type_arguments.IsNull() || type_arguments.IsInstantiated());
   Context& context = Context::Handle();
   context = Context::New(1);
   context.SetAt(0, receiver);
   const Closure& closure = Closure::Handle(Closure::New(function, context));
   closure.SetTypeArguments(type_arguments);
   arguments.SetReturn(closure);
 }
 
 
@@ skipping 28 matching lines @@
 // Check that the given instance is an instance of the given type.
 // Tested instance may not be null, because the null test is inlined.
 // Arg0: instance being checked.
 // Arg1: type.
 // Arg2: type arguments of the instantiator of the type.
 // Return value: true or false.
 DEFINE_RUNTIME_ENTRY(Instanceof, 3) {
   ASSERT(arguments.Count() == kInstanceofRuntimeEntry.argument_count());
   const Instance& instance = Instance::CheckedHandle(arguments.At(0));
   const AbstractType& type = AbstractType::CheckedHandle(arguments.At(1));
-  const TypeArguments& type_instantiator =
-      TypeArguments::CheckedHandle(arguments.At(2));
+  const AbstractTypeArguments& type_instantiator =
+      AbstractTypeArguments::CheckedHandle(arguments.At(2));
   ASSERT(type.IsFinalized());
   const Bool& result = Bool::Handle(
       instance.IsInstanceOf(type, type_instantiator) ?
       Bool::True() : Bool::False());
   if (FLAG_trace_type_checks) {
     const Type& instance_type = Type::Handle(instance.GetType());
     ASSERT(instance_type.IsInstantiated());
     if (type.IsInstantiated()) {
       OS::Print("InstanceOf: '%s' %s '%s'\n",
                 String::Handle(instance_type.Name()).ToCString(),
@@ skipping 269 matching lines @@
     arguments.SetReturn(closure);
     return;
   }
   Function& implicit_closure_function =
       Function::Handle(function.ImplicitClosureFunction());
   // Create a closure object for the implicit closure function.
   const Context& context = Context::Handle(Context::New(1));
   context.SetAt(0, receiver);
   closure = Closure::New(implicit_closure_function, context);
   if (receiver_class.HasTypeArguments()) {
-    const TypeArguments& type_arguments =
-        TypeArguments::Handle(receiver.GetTypeArguments());
+    const AbstractTypeArguments& type_arguments =
+        AbstractTypeArguments::Handle(receiver.GetTypeArguments());
     closure.SetTypeArguments(type_arguments);
   }
   arguments.SetReturn(closure);
 }
 
 
 // Resolve an implicit closure by invoking getter and checking if the return
 // value from getter is a closure.
 // Arg0: receiver object.
 // Arg1: ic-data array.
@@ skipping 406 matching lines @@
       }
     }
   }
   // The cache is null terminated, therefore the loop above should never
   // terminate by itself.
   UNREACHABLE();
   return Code::null();
 }
 
 }  // namespace dart