Renaming type classes as discussed:

runtime/vm/parser.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/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 66 matching lines @@
 template<typename T>
 static RawArray* NewArray(const GrowableArray<T*>& objs) {
   Array& a = Array::Handle(Array::New(objs.length(), Heap::kOld));
   for (int i = 0; i < objs.length(); i++) {
     a.SetAt(i, *objs[i]);
   }
   return a.raw();
 }
 
 
-static RawTypeArray* NewTypeArray(const GrowableArray<Type*>& objs) {
+static RawTypeArray* NewTypeArray(const GrowableArray<AbstractType*>& objs) {
   TypeArray& a = TypeArray::Handle(TypeArray::New(objs.length()));
   for (int i = 0; i < objs.length(); i++) {
     a.SetTypeAt(i, *objs[i]);
   }
   return a.raw();
 }
 
 
 static ThrowNode* CreateEvalConstConstructorThrow(intptr_t token_pos,
                                                   const Instance& instance) {
@@ skipping 187 matching lines @@
 
 
 struct ParamDesc {
   ParamDesc()
       : type(NULL),
         name_pos(0),
         name(NULL),
         default_value(NULL),
         is_final(false),
         is_field_initializer(false) { }
-  const Type* type;
+  const AbstractType* type;
   intptr_t name_pos;
   const String* name;
   const Object* default_value;  // NULL if not an optional parameter.
   bool is_final;
   bool is_field_initializer;
 };
 
 
 struct ParamList {
   ParamList() {
     Clear();
   }
 
   void Clear() {
     num_fixed_parameters = 0;
     num_optional_parameters = 0;
     has_named_optional_parameters = false;
     has_field_initializer = false;
     implicitly_final = false;
     this->parameters = new ZoneGrowableArray<ParamDesc>();
   }
 
   void AddFinalParameter(intptr_t name_pos,
                          const char* name,
-                         const Type* type) {
+                         const AbstractType* type) {
     this->num_fixed_parameters++;
     ParamDesc param;
     param.name_pos = name_pos;
     param.name = &String::ZoneHandle(String::NewSymbol(name));
     param.is_final = true;
     param.type = type;
     this->parameters->Add(param);
   }
 
   void AddReceiver(intptr_t name_pos) {
@@ skipping 49 matching lines @@
   }
   bool IsSetter() const {
     return kind == RawFunction::kSetterFunction;
   }
   bool has_abstract;
   bool has_final;
   bool has_const;
   bool has_static;
   bool has_var;
   bool has_factory;
-  const Type* type;
+  const AbstractType* type;
   intptr_t name_pos;
   String* name;
   String* redirect_name;  // For constructors: NULL or redirected constructor.
   ParamList params;
   RawFunction::Kind kind;
 };
 
 
 class ClassDesc : public ValueObject {
  public:
@@ skipping 207 matching lines @@
     CompilerStats::parser_timer.Stop();
   }
   isolate->set_ast_node_id(prev_ast_node_id);
 }
 
 
 SequenceNode* Parser::ParseStaticConstGetter(const Function& func) {
   ParamList params;
   ASSERT(func.num_fixed_parameters() == 0);  // static.
   ASSERT(func.num_optional_parameters() == 0);
-  ASSERT(Type::Handle(func.result_type()).IsResolved());
+  ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   // Static const fields must have an initializer.
   ExpectToken(Token::kIDENT);
   ExpectToken(Token::kASSIGN);
 
   // We don't want to use ParseConstExpr() here because we don't want
@@ skipping 15 matching lines @@
 // Create AstNodes for an implicit instance getter method:
 //   LoadLocalNode 0 ('this');
 //   LoadInstanceFieldNode (field_name);
 //   ReturnNode (field's value);
 SequenceNode* Parser::ParseInstanceGetter(const Function& func) {
   TRACE_PARSER("ParseInstanceGetter");
   ParamList params;
   params.AddReceiver(token_index_);
   ASSERT(func.num_fixed_parameters() == 1);  // receiver.
   ASSERT(func.num_optional_parameters() == 0);
-  ASSERT(Type::Handle(func.result_type()).IsResolved());
+  ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   // Receiver is local 0.
   LocalVariable* receiver = current_block_->scope->VariableAt(0);
   LoadLocalNode* load_receiver = new LoadLocalNode(token_index_, *receiver);
   // token_index_ is the function's token position which points to the name of
   // the field;
@@ skipping 18 matching lines @@
 //   SetInstanceField (field_name);
 //   ReturnNode (void);
 SequenceNode* Parser::ParseInstanceSetter(const Function& func) {
   TRACE_PARSER("ParseInstanceSetter");
   // token_index_ is the function's token position which points to the name of
   // the field; we can use it to form the field_name.
   const String& field_name = *CurrentLiteral();
   const Class& field_class = Class::ZoneHandle(func.owner());
   const Field& field =
       Field::ZoneHandle(field_class.LookupInstanceField(field_name));
-  const Type& field_type = Type::ZoneHandle(field.type());
+  const AbstractType& field_type = AbstractType::ZoneHandle(field.type());
 
   ParamList params;
   params.AddReceiver(token_index_);
   params.AddFinalParameter(token_index_, "value", &field_type);
   ASSERT(func.num_fixed_parameters() == 2);  // receiver, value.
   ASSERT(func.num_optional_parameters() == 0);
-  ASSERT(Type::Handle(func.result_type()).IsVoidType());
+  ASSERT(AbstractType::Handle(func.result_type()).IsVoidType());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   LoadLocalNode* receiver =
       new LoadLocalNode(token_index_, *current_block_->scope->VariableAt(0));
   LoadLocalNode* value =
       new LoadLocalNode(token_index_, *current_block_->scope->VariableAt(1));
 
@@ skipping 92 matching lines @@
     }
     // We have not seen a parameter type yet, so we check if the next
     // identifier could represent a type before parsing it.
     Token::Kind follower = LookaheadToken(1);
     // We have an identifier followed by a 'follower' token.
     // We either parse a type or assume that no type is specified.
     if ((follower == Token::kLT) ||  // Parameterized type.
         (follower == Token::kPERIOD) ||  // Qualified class name of type.
         (follower == Token::kIDENT) ||  // Parameter name following a type.
         (follower == Token::kTHIS)) {  // Field parameter following a type.
-      parameter.type = &Type::ZoneHandle(
+      parameter.type = &AbstractType::ZoneHandle(
           ParseType(is_top_level_ ? kCanResolve : kMustResolve));
     } else {
       parameter.type = &Type::ZoneHandle(Type::DynamicType());
     }
   }
   if (!this_seen && (CurrentToken() == Token::kTHIS)) {
     ConsumeToken();
     ExpectToken(Token::kPERIOD);
     this_seen = true;
     parameter.is_field_initializer = true;
   }
   // At this point, we must see an identifier for the parameter name.
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("parameter name expected");
   }
   parameter.name = CurrentLiteral();
   parameter.name_pos = token_index_;
   ConsumeToken();
   if (parameter.is_field_initializer) {
     params->has_field_initializer = true;
   }
 
   if (CurrentToken() == Token::kLPAREN) {
     // This parameter is probably a closure. If we saw the keyword 'var'
     // or 'final', a closure is not legal here and we ignore the
     // opening parens.
     if (!var_seen && !parameter.is_final) {
       // The parsed parameter type is actually the function result type.
-      const Type& result_type = Type::Handle(parameter.type->raw());
+      const AbstractType& result_type =
+          AbstractType::Handle(parameter.type->raw());
 
       // Finish parsing the function type parameter.
       ParamList func_params;
       const bool no_explicit_default_values = false;
       ParseFormalParameterList(no_explicit_default_values, &func_params);
 
       // The field 'is_static' has no meaning for signature functions.
       const Function& signature_function = Function::Handle(
           Function::New(*parameter.name,
                         RawFunction::kSignatureFunction,
@@ skipping 12 matching lines @@
       if (signature_class.IsNull()) {
         signature_class = Class::NewSignatureClass(signature,
                                                    signature_function,
                                                    script_);
         // Record the function signature class in the current library.
         library_.AddClass(signature_class);
       } else {
         signature_function.set_signature_class(signature_class);
       }
       ASSERT(signature_function.signature_class() == signature_class.raw());
-      Type& signature_type = Type::ZoneHandle(signature_class.SignatureType());
+      AbstractType& signature_type =
+          AbstractType::ZoneHandle(signature_class.SignatureType());
       if (!is_top_level_ && !signature_type.IsFinalized()) {
         String& errmsg = String::Handle();
         signature_type =
             ClassFinalizer::FinalizeAndCanonicalizeType(signature_type,
                                                         &errmsg);
         if (!errmsg.IsNull()) {
           ErrorMsg(errmsg.ToCString());
         }
       }
       // The type of the parameter is now the signature type.
@@ skipping 655 matching lines @@
   OpenFunctionBlock(func);
   ParamList params;
   const bool allow_explicit_default_values = true;
   ASSERT(CurrentToken() == Token::kLPAREN);
 
   // Add implicit receiver parameter which is passed the allocated
   // but uninitialized instance to construct.
   params.AddReceiver(token_index_);
 
   // Add implicit parameter for construction phase.
-  params.AddFinalParameter(token_index_, kPhaseParameterName,
-                           &Type::ZoneHandle(Type::DynamicType()));
+  params.AddFinalParameter(
+      token_index_,
+      kPhaseParameterName,
+      &Type::ZoneHandle(Type::DynamicType()));
 
   if (func.is_const()) {
     params.SetImplicitlyFinal();
   }
   ParseFormalParameterList(allow_explicit_default_values, &params);
 
   SetupDefaultsForOptionalParams(&params, default_parameter_values);
-  ASSERT(Type::Handle(func.result_type()).IsResolved());
+  ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
   ASSERT(func.NumberOfParameters() == params.parameters->length());
 
   // Initialize instance fields that have an explicit initializer expression.
   // This has to be done before code for field initializer parameters
   // is generated.
   // NB: the instance field initializers have to be compiled before
   // the parameters are added to the scope, so that a parameter
   // name cannot shadow a name used in the field initializer expression.
   GrowableArray<FieldInitExpression> initializers;
   ParseInitializedInstanceFields(cls, &initializers);
@@ skipping 218 matching lines @@
   }
   ASSERT(CurrentToken() == Token::kLPAREN);
   ParseFormalParameterList(allow_explicit_default_values, &params);
 
   // The number of parameters and their type are not yet set in local functions,
   // since they are not 'top-level' parsed.
   if (func.IsLocalFunction()) {
     AddFormalParamsToFunction(&params, func);
   }
   SetupDefaultsForOptionalParams(&params, default_parameter_values);
-  ASSERT(Type::Handle(func.result_type()).IsResolved());
+  ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
   ASSERT(func.NumberOfParameters() == params.parameters->length());
 
   // Check whether the function has any field initializer formal parameters,
   // which are not allowed in non-constructor functions.
   if (params.has_field_initializer) {
     for (int i = 0; i < params.parameters->length(); i++) {
       ParamDesc& param = (*params.parameters)[i];
       if (param.is_field_initializer) {
         ErrorMsg(param.name_pos,
                  "field initializer only allowed in constructors");
@@ skipping 173 matching lines @@
   const bool are_implicitly_final = method->has_const;
   const bool allow_explicit_default_values =
       (!method->has_abstract && !members->is_interface());
   const intptr_t formal_param_pos = token_index_;
   method->params.Clear();
   if (has_this_param) {
     method->params.AddReceiver(formal_param_pos);
   }
   // Constructors have an implicit parameter for the construction phase.
   if (method->IsConstructor()) {
-    method->params.AddFinalParameter(token_index_, kPhaseParameterName,
-                                     &Type::ZoneHandle(Type::DynamicType()));
+    method->params.AddFinalParameter(
+        token_index_,
+        kPhaseParameterName,
+        &Type::ZoneHandle(Type::DynamicType()));
   }
   if (are_implicitly_final) {
     method->params.SetImplicitlyFinal();
   }
   ParseFormalParameterList(allow_explicit_default_values, &method->params);
   if (method->IsGetter() || method->IsSetter()) {
     int expected_num_parameters = 0;
     if (method->IsGetter()) {
       expected_num_parameters = (method->has_static) ? 0 : 1;
       method->name = &String::ZoneHandle(Field::GetterName(*method->name));
@@ skipping 294 matching lines @@
       // We have an identifier followed by a 'follower' token.
       // We either parse a type or assume that no type is specified.
       if ((follower == Token::kLT) ||  // Parameterized type.
           (follower == Token::kGET) ||  // Getter following a type.
           (follower == Token::kSET) ||  // Setter following a type.
           (follower == Token::kOPERATOR) ||  // Operator following a type.
           (follower == Token::kIDENT)  ||  // Member name following a type.
           ((follower == Token::kPERIOD) &&    // Qualified class name of type,
            (LookaheadToken(3) != Token::kLPAREN))) {  // but not a named constr.
         ASSERT(is_top_level_);
-        member.type = &Type::ZoneHandle(ParseType(kCanResolve));
+        member.type = &AbstractType::ZoneHandle(ParseType(kCanResolve));
       }
     }
   }
   // Optionally parse a (possibly named) constructor name or factory.
   if ((CurrentToken() == Token::kIDENT) &&
       (CurrentLiteral()->Equals(members->class_name()) || member.has_factory)) {
     member.name = CurrentLiteral();
     member.name_pos = this->token_index_;
     ConsumeToken();
     // Resolution of the factory result type is always postponed until class
@@ skipping 141 matching lines @@
                class_name.ToCString());
     } else if (cls.functions() != Array::Empty()) {
       ErrorMsg(classname_pos, "class '%s' is already defined",
                class_name.ToCString());
     }
   }
   ASSERT(!cls.IsNull());
   ASSERT(cls.functions() == Array::Empty());
   set_current_class(cls);
   ParseTypeParameters(cls);
-  Type& super_type = Type::Handle();
+  AbstractType& super_type = AbstractType::Handle();
   if (CurrentToken() == Token::kEXTENDS) {
     ConsumeToken();
     super_type = ParseType(kCanResolve);
     if (super_type.IsInterfaceType()) {
       ErrorMsg("class '%s' may implement, but cannot extend interface '%s'",
                class_name.ToCString(),
                String::Handle(super_type.Name()).ToCString());
     }
   } else {
     // No extends clause: Implicitly extend Object.
@@ skipping 40 matching lines @@
     Function& ctor = Function::ZoneHandle(
         Function::New(ctor_name,
                       RawFunction::kConstructor,
                       /* is_static = */ false,
                       /* is_const = */ false,
                       class_desc->token_pos()));
     ParamList params;
     // Add implicit 'this' parameter.
     params.AddReceiver(token_index_);
     // Add implicit parameter for construction phase.
-    params.AddFinalParameter(token_index_, kPhaseParameterName,
-                             &Type::ZoneHandle(Type::DynamicType()));
+    params.AddFinalParameter(
+        token_index_,
+        kPhaseParameterName,
+        &Type::ZoneHandle(Type::DynamicType()));
 
     AddFormalParamsToFunction(&params, ctor);
     // The body of the constructor cannot modify the type arguments of the
     // constructed instance, which is passed in as a hidden parameter.
     // Therefore, there is no need to set the result type to be checked.
-    const Type& result_type = Type::ZoneHandle(Type::DynamicType());
+    const AbstractType& result_type = Type::ZoneHandle(Type::DynamicType());
     ctor.set_result_type(result_type);
     class_desc->AddFunction(&ctor);
   }
 
   // Check for cycles in constructor redirection.
   const GrowableArray<MemberDesc>& members = class_desc->members();
   for (int i = 0; i < members.length(); i++) {
     MemberDesc* member = &members[i];
     GrowableArray<MemberDesc*> ctors;
     while ((member != NULL) && (member->redirect_name != NULL)) {
@@ skipping 37 matching lines @@
   }
   SetPosition(saved_pos);
   return is_alias_name;
 }
 
 
 void Parser::ParseFunctionTypeAlias(GrowableArray<const Class*>* classes) {
   TRACE_PARSER("ParseFunctionTypeAlias");
   ExpectToken(Token::kTYPEDEF);
 
-  Type& result_type = Type::Handle(Type::DynamicType());
+  AbstractType& result_type = Type::Handle(Type::DynamicType());
   const intptr_t result_type_pos = token_index_;
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else if (!IsFunctionTypeAliasName()) {
     result_type = ParseType(kDoNotResolve);  // No owner class yet.
   }
 
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("function alias name expected");
@@ skipping 204 matching lines @@
     }
     SkipTypeArguments();
   }
 }
 
 
 void Parser::ParseTypeParameters(const Class& cls) {
   if (CurrentToken() == Token::kLT) {
     const intptr_t type_pos = token_index_;
     GrowableArray<String*> type_parameters;
-    GrowableArray<Type*> type_parameter_extends;
+    GrowableArray<AbstractType*> type_parameter_extends;
     do {
       ConsumeToken();
       if (CurrentToken() != Token::kIDENT) {
         ErrorMsg("type parameter name expected");
       }
       String& type_parameter_name = *CurrentLiteral();
       ConsumeToken();
-      Type& type_extends = Type::ZoneHandle(Type::DynamicType());
+      AbstractType& type_extends = Type::ZoneHandle(Type::DynamicType());
       if (CurrentToken() == Token::kEXTENDS) {
         ConsumeToken();
         type_extends = ParseType(kCanResolve);
       }
       type_parameters.Add(&type_parameter_name);
       type_parameter_extends.Add(&type_extends);
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) ||
         (token == Token::kSAR) ||
         (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
       ErrorMsg("right angle bracket expected");
     }
     cls.set_type_parameters(Array::Handle(NewArray<String>(type_parameters)));
     const TypeArray& extends_array =
         TypeArray::Handle(NewTypeArray(type_parameter_extends));
     cls.set_type_parameter_extends(extends_array);
     // Try to resolve the upper bounds, which will at least resolve the
     // referenced type parameters.
-    Type& type_extends = Type::Handle();
+    AbstractType& type_extends = AbstractType::Handle();
     const intptr_t num_types = extends_array.Length();
     for (intptr_t i = 0; i < num_types; i++) {
       type_extends = extends_array.TypeAt(i);
       TryResolveTypeFromClass(type_pos, cls, &type_extends);
       extends_array.SetTypeAt(i, type_extends);
     }
   }
 }
 
 
 RawTypeArguments* Parser::ParseTypeArguments(TypeResolution type_resolution) {
   if (CurrentToken() == Token::kLT) {
-    GrowableArray<Type*> types;
+    GrowableArray<AbstractType*> types;
     do {
       ConsumeToken();
-      Type& type = Type::ZoneHandle(ParseType(type_resolution));
+      AbstractType& type = AbstractType::ZoneHandle(ParseType(type_resolution));
       types.Add(&type);
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) ||
         (token == Token::kSAR) ||
         (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
       ErrorMsg("right angle bracket expected");
     }
     return NewTypeArray(types);
   }
   return TypeArray::null();
 }
 
 
 // Parse and return an array of interface types.
 RawArray* Parser::ParseInterfaceList() {
   ASSERT((CurrentToken() == Token::kIMPLEMENTS) ||
          (CurrentToken() == Token::kEXTENDS));
-  GrowableArray<Type*> interfaces;
+  GrowableArray<AbstractType*> interfaces;
   do {
     ConsumeToken();
-    Type& interface = Type::ZoneHandle(ParseType(kCanResolve));
+    AbstractType& interface = AbstractType::ZoneHandle(ParseType(kCanResolve));
     interfaces.Add(&interface);
   } while (CurrentToken() == Token::kCOMMA);
-  return NewArray<Type>(interfaces);
+  return NewArray<AbstractType>(interfaces);
 }
 
 
 void Parser::AddInterfaces(intptr_t interfaces_pos,
                            const Class& cls,
                            const Array& interfaces) {
-  GrowableArray<Type*> all_interfaces;
+  GrowableArray<AbstractType*> all_interfaces;
   // First get all the interfaces already implemented by class.
   Array& cls_interfaces = Array::Handle(cls.interfaces());
   for (intptr_t i = 0; i < cls_interfaces.Length(); i++) {
-    Type& interface = Type::ZoneHandle();
+    AbstractType& interface = AbstractType::ZoneHandle();
     interface ^= cls_interfaces.At(i);
     all_interfaces.Add(&interface);
   }
   // Now add the new interfaces.
-  Type& conflicting = Type::Handle();
+  AbstractType& conflicting = AbstractType::Handle();
   for (intptr_t i = 0; i < interfaces.Length(); i++) {
-    Type& interface = Type::ZoneHandle();
+    AbstractType& interface = AbstractType::ZoneHandle();
     interface ^= interfaces.At(i);
     if (!ClassFinalizer::AddInterfaceIfUnique(&all_interfaces,
                                               &interface,
                                               &conflicting)) {
       ASSERT(!conflicting.IsNull());
       ErrorMsg(interfaces_pos,
                "interface '%s' conflicts with interface '%s'",
                String::Handle(interface.Name()).ToCString(),
                String::Handle(conflicting.Name()).ToCString());
     }
   }
-  cls_interfaces = NewArray<Type>(all_interfaces);
+  cls_interfaces = NewArray<AbstractType>(all_interfaces);
   cls.set_interfaces(cls_interfaces);
 }
 
 
 void Parser::ParseTopLevelVariable(TopLevel* top_level) {
   const bool is_final = (CurrentToken() == Token::kFINAL);
   const bool is_static = true;
-  const Type& type = Type::ZoneHandle(
+  const AbstractType& type = AbstractType::ZoneHandle(
       ParseFinalVarOrType(kIsMandatory, kCanResolve));
 
   while (true) {
     const intptr_t name_pos = token_index_;
     String& var_name = *ExpectIdentifier("variable name expected");
 
     if (library_.LookupObject(var_name) != Object::null()) {
       ErrorMsg(name_pos, "'%s' is already defined", var_name.ToCString());
     }
     String& accessor_name = String::Handle(Field::GetterName(var_name));
@@ skipping 34 matching lines @@
       ConsumeToken();
       break;
     } else {
       ExpectSemicolon();  // Reports error.
     }
   }
 }
 
 
 void Parser::ParseTopLevelFunction(TopLevel* top_level) {
-  Type& result_type = Type::Handle(Type::DynamicType());
+  AbstractType& result_type = Type::Handle(Type::DynamicType());
   const bool is_static = true;
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else {
     // Parse optional type.
     if ((CurrentToken() == Token::kIDENT) &&
         (LookaheadToken(1) != Token::kLPAREN)) {
       result_type = ParseType(kCanResolve);
     }
@@ skipping 39 matching lines @@
                     is_static, false, function_pos));
   func.set_result_type(result_type);
   AddFormalParamsToFunction(&params, func);
   top_level->functions.Add(&func);
   library_.AddObject(func, func_name);
 }
 
 
 void Parser::ParseTopLevelAccessor(TopLevel* top_level) {
   const bool is_static = true;
-  Type& result_type = Type::Handle();
+  AbstractType& result_type = AbstractType::Handle();
   bool is_getter = (CurrentToken() == Token::kGET);
   if (CurrentToken() == Token::kGET ||
       CurrentToken() == Token::kSET) {
     ConsumeToken();
     result_type = Type::DynamicType();
   } else {
     if (CurrentToken() == Token::kVOID) {
       ConsumeToken();
       result_type = Type::VoidType();
     } else {
@@ skipping 439 matching lines @@
 
 
 AstNode* Parser::CallGetter(intptr_t token_index,
                             AstNode* object,
                             const String& name) {
   return new InstanceGetterNode(token_index_, object, name);
 }
 
 
 // Returns ast nodes of the variable initialization.
-AstNode* Parser::ParseVariableDeclaration(const Type& type, bool is_final) {
+AstNode* Parser::ParseVariableDeclaration(
+    const AbstractType& type, bool is_final) {
   TRACE_PARSER("ParseVariableDeclaration");
   ASSERT(CurrentToken() == Token::kIDENT);
   const intptr_t ident_pos = token_index_;
   LocalVariable* variable =
       new LocalVariable(ident_pos, *CurrentLiteral(), type);
   ASSERT(current_block_ != NULL);
   ASSERT(current_block_->scope != NULL);
   ConsumeToken();  // Variable identifier.
   AstNode* initialization = NULL;
   if (CurrentToken() == Token::kASSIGN) {
@@ skipping 20 matching lines @@
   }
   return initialization;
 }
 
 
 // Parses ('var' | 'final' [type] | type).
 // The presence of 'final' must be detected and remembered before the call.
 // If type_specification is kIsOptional, and no type can be parsed, then return
 // the DynamicType.
 // If a type is parsed, it is resolved (or not) according to type_resolution.
-RawType* Parser::ParseFinalVarOrType(TypeSpecification type_specification,
-                                     TypeResolution type_resolution) {
+RawAbstractType* Parser::ParseFinalVarOrType(
+    TypeSpecification type_specification, TypeResolution type_resolution) {
   if (CurrentToken() == Token::kVAR) {
     ConsumeToken();
     return Type::DynamicType();
   }
   if (CurrentToken() == Token::kFINAL) {
     ConsumeToken();
     type_specification = kIsOptional;
   }
   if (CurrentToken() != Token::kIDENT) {
     if (type_specification == kIsOptional) {
@@ skipping 16 matching lines @@
   return ParseType(type_resolution);
 }
 
 
 // Returns ast nodes of the variable initialization, or NULL if variables
 // are not initialized. If several variables are declared and initialized,
 // the individual initializers are collected in a sequence node.
 AstNode* Parser::ParseVariableDeclarationList() {
   TRACE_PARSER("ParseVariableDeclarationList");
   bool is_final = (CurrentToken() == Token::kFINAL);
-  const Type& type = Type::ZoneHandle(
+  const AbstractType& type = AbstractType::ZoneHandle(
       ParseFinalVarOrType(kIsMandatory, kMustResolve));
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("identifier expected");
   }
 
   AstNode* initializers = ParseVariableDeclaration(type, is_final);
   while (CurrentToken() == Token::kCOMMA) {
     ConsumeToken();
     if (CurrentToken() != Token::kIDENT) {
       ErrorMsg("identifier expected after comma");
@@ skipping 11 matching lines @@
         initializers = sequence;
       }
     }
   }
   return initializers;
 }
 
 
 AstNode* Parser::ParseFunctionStatement(bool is_literal) {
   TRACE_PARSER("ParseFunctionStatement");
-  Type& result_type = Type::Handle();
+  AbstractType& result_type = AbstractType::Handle();
   const String* variable_name = NULL;
   const String* function_name = NULL;
 
   result_type = Type::DynamicType();
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else if ((CurrentToken() == Token::kIDENT) &&
              (LookaheadToken(1) != Token::kLPAREN)) {
     result_type = ParseType(kMustResolve);
@@ skipping 21 matching lines @@
                                    current_function(),
                                    token_index_));
   function.set_result_type(result_type);
 
   // The function type does not need to be determined at compile time, unless
   // the closure is assigned to a function variable and type checks are enabled.
   // At run time, the function type is derived from the signature class of the
   // closure function and from the type arguments of the instantiator.
 
   LocalVariable* function_variable = NULL;
-  ParameterizedType& function_type = ParameterizedType::ZoneHandle();
+  Type& function_type = Type::ZoneHandle();
   if (variable_name != NULL) {
     // Since the function type depends on the signature of the closure function,
     // it cannot be determined before the formal parameter list of the closure
     // function is parsed. Therefore, we set the function type to a new
     // parameterized type to be patched after the actual type is known.
     // We temporarily use the class of the Function interface.
     const Class& unknown_signature_class = Class::Handle(
         Type::Handle(Type::FunctionInterface()).type_class());
-    function_type = ParameterizedType::New(unknown_signature_class,
-                                           TypeArguments::Handle());
+    function_type = Type::New(unknown_signature_class,
+                              TypeArguments::Handle());
     function_type.set_is_finalized();  // No real finalization needed.
 
     // Add the function variable to the scope before parsing the function in
     // order to allow self reference from inside the function.
     function_variable = new LocalVariable(ident_pos,
                                           *variable_name,
                                           function_type);
     function_variable->set_is_final();
     ASSERT(current_block_ != NULL);
     ASSERT(current_block_->scope != NULL);
@@ skipping 31 matching lines @@
   // Make sure that the instantiator is captured.
   if ((signature_class.NumTypeParameters() > 0) &&
       (current_block_->scope->function_level() > 0)) {
     CaptureReceiver();
   }
 
   if (variable_name != NULL) {
     // Patch the function type now that the signature is known.
     // We need to create a new type for proper finalization, since the existing
     // type is already marked as finalized.
-    Type& signature_type = Type::Handle(signature_class.SignatureType());
+    AbstractType& signature_type =
+        AbstractType::Handle(signature_class.SignatureType());
     const TypeArguments& signature_type_arguments = TypeArguments::Handle(
         signature_type.arguments());
 
     // Since the signature type is cached by the signature class, it may have
     // been finalized already.
     if (!signature_type.IsFinalized()) {
       String& errmsg = String::Handle();
       signature_type =
           ClassFinalizer::FinalizeAndCanonicalizeType(signature_type, &errmsg);
       if (!errmsg.IsNull()) {
@@ skipping 538 matching lines @@
                                      SourceLabel* label) {
   bool is_final = (CurrentToken() == Token::kFINAL);
   const String* loop_var_name = NULL;
   LocalVariable* loop_var = NULL;
   intptr_t loop_var_pos = 0;
   if (LookaheadToken(1) == Token::kIN) {
     loop_var_pos = token_index_;
     loop_var_name = ExpectIdentifier("variable name expected");
   } else {
     // The case without a type is handled above, so require a type here.
-    const Type& type = Type::ZoneHandle(
+    const AbstractType& type = AbstractType::ZoneHandle(
         ParseFinalVarOrType(kIsMandatory, kMustResolve));
     loop_var_pos = token_index_;
     loop_var_name = ExpectIdentifier("variable name expected");
     loop_var = new LocalVariable(loop_var_pos, *loop_var_name, type);
     if (is_final) {
       loop_var->set_is_final();
     }
   }
   ExpectToken(Token::kIN);
   const intptr_t collection_pos = token_index_;
   AstNode* collection_expr = ParseExpr(kAllowConst);
   ExpectToken(Token::kRPAREN);
 
   OpenBlock();  // Implicit block around while loop.
 
   // Generate implicit iterator variable and add to scope.
   const String& iterator_name =
       String::ZoneHandle(String::NewSymbol(":for-in-iter"));
   // We could set the type of the implicit iterator variable to Iterator<T>
   // where T is the type of the for loop variable. However, the type error
   // would refer to the compiler generated iterator and could confuse the user.
   // It is better to leave the iterator untyped and postpone the type error
   // until the loop variable is assigned to.
-  const Type& iterator_type = Type::ZoneHandle(Type::DynamicType());
+  const AbstractType& iterator_type = Type::ZoneHandle(Type::DynamicType());
   LocalVariable* iterator_var =
       new LocalVariable(collection_pos, iterator_name, iterator_type);
   current_block_->scope->AddVariable(iterator_var);
 
   // Generate initialization of iterator variable.
   const String& iterator_method_name =
       String::ZoneHandle(String::NewSymbol(kGetIteratorName));
   ArgumentListNode* no_args = new ArgumentListNode(collection_pos);
   AstNode* get_iterator = new InstanceCallNode(
       collection_pos, collection_expr, iterator_method_name, no_args);
@@ skipping 207 matching lines @@
                                        assert_throw,
                                        current_block_->scope),
                     NULL);
 }
 
 
 struct CatchParamDesc {
   CatchParamDesc()
       : token_index(0), type(NULL), var(NULL), is_final(false) { }
   intptr_t token_index;
-  const Type* type;
+  const AbstractType* type;
   const String* var;
   bool is_final;
 };
 
 
 // Parse the parameter specified in the catch clause.
 void Parser::ParseCatchParameter(CatchParamDesc* catch_param) {
   TRACE_PARSER("ParseCatchParameter");
   ASSERT(catch_param != NULL);
   catch_param->is_final = (CurrentToken() == Token::kFINAL);
-  catch_param->type = &Type::ZoneHandle(
+  catch_param->type = &AbstractType::ZoneHandle(
       ParseFinalVarOrType(kIsMandatory, kMustResolve));
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("identifier expected");
   }
   catch_param->token_index = token_index_;
   catch_param->var = CurrentLiteral();
   ConsumeToken();
 }
 
 
@@ skipping 710 matching lines @@
       AstNode* right_operand = NULL;
       if (op_kind != Token::kIS) {
         right_operand = ParseBinaryExpr(current_preced + 1);
       } else {
         // For 'is' we expect the right operand to be a type.
         if (CurrentToken() == Token::kNOT) {
           ConsumeToken();
           op_kind = Token::kISNOT;
         }
         const intptr_t type_pos = token_index_;
-        const Type& type = Type::ZoneHandle(ParseType(kMustResolve));
+        const AbstractType& type =
+            AbstractType::ZoneHandle(ParseType(kMustResolve));
         if (!type.IsInstantiated() &&
             (current_block_->scope->function_level() > 0)) {
           // Make sure that the instantiator is captured.
           CaptureReceiver();
         }
         right_operand = new TypeNode(type_pos, type);
       }
       if (Token::IsRelationalOperator(op_kind)
           || Token::IsInstanceofOperator(op_kind)
           || Token::IsEqualityOperator(op_kind)) {
@@ skipping 731 matching lines @@
   return postfix_expr;
 }
 
 
 // Try to resolve the given type and its type arguments from the given class.
 // Not all involved type classes may get resolved yet, but at least the type
 // parameters of the given class will get resolved, thereby relieving the class
 // finalizer from resolving type parameters out of context.
 void Parser::TryResolveTypeFromClass(intptr_t type_pos,
                                      const Class& cls,
-                                     Type* type) {
+                                     AbstractType* type) {
   ASSERT(type != NULL);
   // Resolve class.
   if (!type->HasResolvedTypeClass()) {
     const UnresolvedClass& unresolved_class =
         UnresolvedClass::Handle(type->unresolved_class());
     const String& unresolved_class_name =
         String::Handle(unresolved_class.ident());
     // First check if the type is a type parameter of the given class.
     const TypeParameter& type_parameter = TypeParameter::Handle(
         cls.LookupTypeParameter(unresolved_class_name));
     if (!type_parameter.IsNull()) {
       // A type parameter cannot be parameterized, so report an error if type
       // arguments have previously been parsed.
       if (!TypeArguments::Handle(type->arguments()).IsNull()) {
         ErrorMsg(type_pos, "type parameter '%s' cannot be parameterized",
                  type_parameter.ToCString());
       }
       *type = type_parameter.raw();
       return;
     }
     const Class& resolved_type_class =
         Class::Handle(LookupClass(unresolved_class_name));
     if (!resolved_type_class.IsNull()) {
       Object& type_class = Object::Handle(resolved_type_class.raw());
-      ASSERT(type->IsParameterizedType());
+      ASSERT(type->IsType());
       // Replace unresolved class with resolved type class.
-      ParameterizedType& parameterized_type = ParameterizedType::Handle();
+      Type& parameterized_type = Type::Handle();
       parameterized_type ^= type->raw();
       parameterized_type.set_type_class(type_class);
     }
   }
   // Resolve type arguments, if any.
   const TypeArguments& arguments = TypeArguments::Handle(type->arguments());
   if (!arguments.IsNull()) {
     const intptr_t num_arguments = arguments.Length();
     for (intptr_t i = 0; i < num_arguments; i++) {
-      Type& type_argument = Type::Handle(arguments.TypeAt(i));
+      AbstractType& type_argument = AbstractType::Handle(arguments.TypeAt(i));
       TryResolveTypeFromClass(type_pos, cls, &type_argument);
       arguments.SetTypeAt(i, type_argument);
     }
   }
 }
 
 
 // Return class for type name. If the name cannot be resolved (yet), give an
 // error (if type_resolution == kMustResolve) or return the unresolved name.
 RawObject* Parser::LookupTypeClass(const QualIdent& type_name,
@@ skipping 50 matching lines @@
 
 
 // If type parameters are currently in scope, return their declaring class,
 // otherwise return null.
 RawClass* Parser::TypeParametersScopeClass() {
   // Type parameters cannot be referred to from a static function, except from
   // a constructor or from a factory.
   // A constructor is considered as non-static by the compiler.
   if (is_top_level_) {
     if ((current_member_ != NULL) && current_member_->has_factory) {
-      const Type& factory_result_type = *current_member_->type;
+      const AbstractType& factory_result_type = *current_member_->type;
       ASSERT(!factory_result_type.IsNull());
       const UnresolvedClass& unresolved_factory_class =
           UnresolvedClass::Handle(factory_result_type.unresolved_class());
       // TODO(regis): For now, and until the core lib is fixed, we accept a
       // factory method with missing list of type parameters and use the
       // list of the enclosing class.
       // See bug 5408808.
       // Therefore, we temporarily return the current class instead of the
       // factory signature class if the latter one does not declare any type
       // parameters.
@@ skipping 171 matching lines @@
       return true;
     }
 
     // Now check if a getter/setter method exists for it in which case
     // it is still a field.
     const String& getter_name = String::Handle(Field::GetterName(ident));
     func = cls.LookupDynamicFunction(getter_name);
     if (!func.IsNull()) {
       if (node != NULL) {
         CheckInstanceFieldAccess(ident_pos, ident);
-        ASSERT(Type::Handle(func.result_type()).IsResolved());
+        ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
         *node = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
       }
       return true;
     }
     func = cls.LookupStaticFunction(getter_name);
     if (!func.IsNull()) {
       if (node != NULL) {
-        ASSERT(Type::Handle(func.result_type()).IsResolved());
+        ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
         *node = new StaticGetterNode(ident_pos,
                                      Class::ZoneHandle(cls.raw()),
                                      ident);
       }
       return true;
     }
     const String& setter_name = String::Handle(Field::SetterName(ident));
     func = cls.LookupDynamicFunction(setter_name);
     if (!func.IsNull()) {
       if (node != NULL) {
         // We create a getter node even though a getter doesn't exist as
         // it could be followed by an assignment which will convert it to
         // a setter node. If there is no assignment we will get an error
         // when we try to invoke the getter.
         CheckInstanceFieldAccess(ident_pos, ident);
-        ASSERT(Type::Handle(func.result_type()).IsResolved());
+        ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
         *node = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
       }
       return true;
     }
     func = cls.LookupStaticFunction(setter_name);
     if (!func.IsNull()) {
       if (node != NULL) {
         // We create a getter node even though a getter doesn't exist as
         // it could be followed by an assignment which will convert it to
         // a setter node. If there is no assignment we will get an error
@@ skipping 75 matching lines @@
     if (resolve_locally) {
       obj = lib.LookupLocalObject(accessor_name);
     } else {
       obj = lib.LookupObject(accessor_name);
     }
   }
   if (!obj.IsNull()) {
     ASSERT(obj.IsFunction());
     func ^= obj.raw();
     ASSERT(func.is_static());
-    ASSERT(Type::Handle(func.result_type()).IsResolved());
+    ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
     return new StaticGetterNode(qual_ident.ident_pos,
                                 Class::ZoneHandle(func.owner()),
                                 *qual_ident.ident);
   }
   if (qual_ident.qualifier != NULL) {
     // This is an unresolved prefixed primary identifier, need to report
     // an error.
     ErrorMsg(qual_ident.ident_pos, "identifier '%s.%s' cannot be resolved",
              (qual_ident.qualifier)->ToCString(),
              (qual_ident.ident)->ToCString());
@@ skipping 50 matching lines @@
     }
   }
   return var_or_field;
 }
 
 
 // Parses type = [ident "."] ident ["<" type { "," type } ">"].
 // Returns the class object if the type can be resolved. Otherwise, either give
 // an error if type resolution was required, or return the unresolved name as a
 // string object.
-RawType* Parser::ParseType(TypeResolution type_resolution) {
+RawAbstractType* Parser::ParseType(TypeResolution type_resolution) {
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("type name expected");
   }
   QualIdent type_name;
   const intptr_t type_pos = token_index_;
   ParseQualIdent(&type_name);
   if (type_name.is_local_scope_ident) {
     ErrorMsg(type_pos, "using '%s' in this context is invalid",
              type_name.ident->ToCString());
   }
@@ skipping 26 matching lines @@
           }
           return type_parameter.raw();
         }
       }
     }
     // Try to resolve the type class.
     type_class = LookupTypeClass(type_name, type_resolution);
   }
   TypeArguments& type_arguments =
       TypeArguments::Handle(ParseTypeArguments(type_resolution));
-  Type& type = Type::Handle(
+  AbstractType& type = AbstractType::Handle(
       Type::NewParameterizedType(type_class, type_arguments));
   if (type_resolution == kMustResolve) {
     ASSERT(type_class.IsClass());  // Must be resolved.
     String& errmsg = String::Handle();
     type = ClassFinalizer::FinalizeAndCanonicalizeType(type, &errmsg);
     if (!errmsg.IsNull()) {
       ErrorMsg(errmsg.ToCString());
     }
   }
   return type.raw();
@@ skipping 27 matching lines @@
 AstNode* Parser::ParseListLiteral(intptr_t type_pos,
                                   bool is_const,
                                   const TypeArguments& type_arguments) {
   TRACE_PARSER("ParseListLiteral");
   ASSERT(type_pos >= 0);
   ASSERT(CurrentToken() == Token::kLBRACK || CurrentToken() == Token::kINDEX);
   const intptr_t literal_pos = token_index_;
   bool is_empty_literal = CurrentToken() == Token::kINDEX;
   ConsumeToken();
 
-  Type& element_type = Type::ZoneHandle(Type::DynamicType());
+  AbstractType& element_type = Type::ZoneHandle(Type::DynamicType());
   // If no type argument vector is provided, leave it as null, which is
   // equivalent to using Dynamic as the type argument for the element type.
   if (!type_arguments.IsNull()) {
     ASSERT(type_arguments.Length() > 0);
     // List literals take a single type argument.
     element_type = type_arguments.TypeAt(0);
     if (type_arguments.Length() != 1) {
       ErrorMsg(type_pos,
                "a list literal takes one type argument specifying "
                "the element type");
@@ skipping 121 matching lines @@
 
 AstNode* Parser::ParseMapLiteral(intptr_t type_pos,
                                  bool is_const,
                                  const TypeArguments& type_arguments) {
   TRACE_PARSER("ParseMapLiteral");
   ASSERT(type_pos >= 0);
   ASSERT(CurrentToken() == Token::kLBRACE);
   const intptr_t literal_pos = token_index_;
   ConsumeToken();
 
-  Type& value_type = Type::ZoneHandle(Type::DynamicType());
+  AbstractType& value_type = Type::ZoneHandle(Type::DynamicType());
   TypeArguments& map_type_arguments =
       TypeArguments::ZoneHandle(type_arguments.raw());
   // If no type argument vector is provided, leave it as null, which is
   // equivalent to using Dynamic as the type argument for the value type.
   if (!map_type_arguments.IsNull()) {
     ASSERT(map_type_arguments.Length() > 0);
     // Map literals take a single type argument.
     value_type = map_type_arguments.TypeAt(0);
     if (map_type_arguments.Length() > 1) {
       // We temporarily accept two type arguments, as long as the first one is
@@ skipping 333 matching lines @@
   // argument vector to be passed.
   {
     Class& signature_class = Class::Handle();
     if (constructor.IsFactory()) {
       signature_class = constructor.signature_class();
     } else {
       signature_class = constructor.owner();
       ASSERT(signature_class.raw() == type_class.raw());
     }
     // TODO(regis): Temporary type should be allocated in new gen heap.
-    Type& type = Type::Handle(
+    AbstractType& type = Type::Handle(
         Type::NewParameterizedType(signature_class, type_arguments));
     String& errmsg = String::Handle();
     type = ClassFinalizer::FinalizeAndCanonicalizeType(type, &errmsg);
     if (!errmsg.IsNull()) {
       ErrorMsg(errmsg.ToCString());
     }
     // The type argument vector may have been expanded with the type arguments
     // of the super type when finalizing the type.
     type_arguments = type.arguments();
   }
@@ skipping 461 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart