Renaming type classes as discussed:

runtime/vm/code_generator_ia32.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/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/code_generator.h"
 
 #include "lib/error.h"
@@ skipping 773 matching lines @@
 
   // Generate type check.
   if (FLAG_enable_type_checks) {
     const RawFunction::Kind  kind = parsed_function().function().kind();
     // Implicit getters do not need a type check at return.
     if ((kind != RawFunction::kImplicitGetter) &&
         (kind != RawFunction::kConstImplicitGetter)) {
       GenerateAssertAssignable(
           node->id(),
           node->value()->token_index(),
-          Type::ZoneHandle(parsed_function().function().result_type()),
+          AbstractType::ZoneHandle(parsed_function().function().result_type()),
           String::ZoneHandle(String::NewSymbol("function result")));
     }
   }
   GenerateReturnEpilog();
 }
 
 
 void CodeGenerator::VisitLiteralNode(LiteralNode* node) {
   if (!IsResultNeeded(node)) return;
   const Object& literal = node->literal();
@@ skipping 221 matching lines @@
 
 
 void CodeGenerator::VisitStoreInstanceFieldNode(StoreInstanceFieldNode* node) {
   node->instance()->Visit(this);
   node->value()->Visit(this);
   MarkDeoptPoint(node->id(), node->token_index());
   __ popl(EAX);  // Value.
   if (FLAG_enable_type_checks) {
     GenerateAssertAssignable(node->id(),
                              node->value()->token_index(),
-                             Type::ZoneHandle(node->field().type()),
+                             AbstractType::ZoneHandle(node->field().type()),
                              String::ZoneHandle(node->field().name()));
   }
   __ popl(EDX);  // Instance.
   __ StoreIntoObject(EDX, FieldAddress(EDX, node->field().Offset()), EAX);
   if (IsResultNeeded(node)) {
     // The result is the input value.
     __ pushl(EAX);
   }
 }
 
@@ skipping 81 matching lines @@
 }
 
 
 void CodeGenerator::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
   node->value()->Visit(this);
   MarkDeoptPoint(node->id(), node->token_index());
   __ popl(EAX);  // Value.
   if (FLAG_enable_type_checks) {
     GenerateAssertAssignable(node->id(),
                              node->value()->token_index(),
-                             Type::ZoneHandle(node->field().type()),
+                             AbstractType::ZoneHandle(node->field().type()),
                              String::ZoneHandle(node->field().name()));
   }
   __ LoadObject(EDX, node->field());
   __ StoreIntoObject(EDX, FieldAddress(EDX, Field::value_offset()), EAX);
   if (IsResultNeeded(node)) {
     // The result is the input value.
     __ pushl(EAX);
   }
 }
 
@@ skipping 148 matching lines @@
     __ pushl(EAX);
     // It is not necessary to generate a type test of the assigned value here,
     // because the setter will check the type of its incoming arguments.
     GenerateStaticSetterCall(node->token_index(),
                              node->field_class(),
                              node->field_name());
   } else {
     if (FLAG_enable_type_checks) {
       GenerateAssertAssignable(node->id(),
                                node->token_index(),
-                               Type::ZoneHandle(node->field().type()),
+                               AbstractType::ZoneHandle(node->field().type()),
                                String::ZoneHandle(node->field().name()));
     }
     __ LoadObject(EDX, node->field());
     __ StoreIntoObject(EDX, FieldAddress(EDX, Field::value_offset()), EAX);
   }
 }
 
 
 void CodeGenerator::VisitIncrOpIndexedNode(IncrOpIndexedNode* node) {
   ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
@@ skipping 41 matching lines @@
 // - NULL -> return false.
 // - Smi -> compile time subtype check (only if dst class is not parameterized).
 // - Class equality (only if class is not parameterized).
 // Inputs:
 // - EAX: object.
 // Destroys ECX.
 // Returns:
 // - true or false on stack.
 void CodeGenerator::GenerateInstanceOf(intptr_t node_id,
                                        intptr_t token_index,
-                                       const Type& type,
+                                       const AbstractType& type,
                                        bool negate_result) {
   ASSERT(type.IsFinalized());
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
 
   // All instances are of a subtype of the Object type.
   const Type& object_type =
       Type::Handle(Isolate::Current()->object_store()->object_type());
   if (type.IsInstantiated() && object_type.IsSubtypeOf(type)) {
     __ PushObject(negate_result ? bool_false : bool_true);
@@ skipping 136 matching lines @@
 // - NULL -> return NULL.
 // - Smi -> compile time subtype check (only if dst class is not parameterized).
 // - Class equality (only if class is not parameterized).
 // Inputs:
 // - EAX: object.
 // Destroys ECX and EDX.
 // Returns:
 // - object in EAX for successful assignable check (or throws TypeError).
 void CodeGenerator::GenerateAssertAssignable(intptr_t node_id,
                                              intptr_t token_index,
-                                             const Type& dst_type,
+                                             const AbstractType& dst_type,
                                              const String& dst_name) {
   ASSERT(FLAG_enable_type_checks);
   ASSERT(token_index >= 0);
   ASSERT(!dst_type.IsNull());
   ASSERT(dst_type.IsFinalized());
 
   // Any expression is assignable to the Dynamic type and to the Object type.
   // Skip the test.
   if (dst_type.IsDynamicType() || dst_type.IsObjectType()) {
     return;
@@ skipping 714 matching lines @@
   }
   if (outer_function.IsFactory()) {
     instantiator_class = outer_function.signature_class();
   } else {
     instantiator_class = outer_function.owner();
   }
   if (instantiator_class.NumTypeParameters() == 0) {
     // The type arguments are compile time constants.
     TypeArguments& type_arguments = TypeArguments::ZoneHandle();
     // TODO(regis): Temporary type should be allocated in new gen heap.
-    Type& type = Type::Handle(
+    AbstractType& type = AbstractType::Handle(
         Type::NewParameterizedType(instantiator_class, type_arguments));
     String& errmsg = String::Handle();
     type = ClassFinalizer::FinalizeAndCanonicalizeType(type, &errmsg);
     if (!errmsg.IsNull()) {
       ErrorMsg(token_index, errmsg.ToCString());
     }
     type_arguments = type.arguments();
     __ PushObject(type_arguments);
   } else {
     ASSERT(parsed_function().instantiator() != NULL);
@@ skipping 470 matching lines @@
                         message_buffer, kMessageBufferSize,
                         format, args);
   va_end(args);
   Isolate::Current()->long_jump_base()->Jump(1, message_buffer);
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32