Ongoing renaming of type classes:

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<AbstractType*>& objs) {
-  TypeArray& a = TypeArray::Handle(TypeArray::New(objs.length()));
+static RawTypeArguments* NewTypeArguments(
+    const GrowableArray<AbstractType*>& objs) {
+  TypeArguments& a = TypeArguments::Handle(TypeArguments::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) {
   UnhandledException& excp = UnhandledException::Handle();
@@ skipping 1676 matching lines @@
     return ParseConstructor(func, default_parameter_values);
   }
 
   ASSERT(!func.IsConstructor());
   OpenFunctionBlock(func);  // Build local scope for function.
 
   ParamList params;
   // Static functions do not have a receiver.
   // An instance closure may capture and access the receiver, but via the
   // context and not via the first formal parameter.
-  // The first parameter of a factory is the TypeArguments vector of the type
-  // of the instance to be allocated. We name this hidden parameter 'this'.
+  // The first parameter of a factory is the AbstractTypeArguments vector of the
+  // type of the instance to be allocated. We name this hidden parameter 'this'.
   const bool has_receiver = !func.IsClosureFunction() &&
                             (!func.is_static() || func.IsFactory());
   const bool allow_explicit_default_values = true;
   if (has_receiver) {
     params.AddReceiver(token_index_);
   }
   ASSERT(CurrentToken() == Token::kLPAREN);
   ParseFormalParameterList(allow_explicit_default_values, &params);
 
   // The number of parameters and their type are not yet set in local functions,
@@ skipping 176 matching lines @@
              "'abstract' method only allowed in class definition");
   }
 
   if (members->FunctionNameExists(*method->name, method->kind)) {
     ErrorMsg(method->name_pos,
              "field or method '%s' already defined", method->name->ToCString());
   }
 
   // Parse the formal parameters.
   // The first parameter of factory methods is an implicit parameter called
-  // 'this' of type TypeArguments.
+  // 'this' of type AbstractTypeArguments.
   const bool has_this_param =
       !method->has_static || method->IsConstructor() || method->has_factory;
   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);
   }
@@ skipping 850 matching lines @@
     } 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));
+    const TypeArguments& extends_array =
+        TypeArguments::Handle(NewTypeArguments(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.
     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) {
+RawAbstractTypeArguments* Parser::ParseTypeArguments(
+    TypeResolution type_resolution) {
   if (CurrentToken() == Token::kLT) {
     GrowableArray<AbstractType*> types;
     do {
       ConsumeToken();
       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 NewTypeArguments(types);
   }
-  return TypeArray::null();
+  return TypeArguments::null();
 }
 
 
 // Parse and return an array of interface types.
 RawArray* Parser::ParseInterfaceList() {
   ASSERT((CurrentToken() == Token::kIMPLEMENTS) ||
          (CurrentToken() == Token::kEXTENDS));
   GrowableArray<AbstractType*> interfaces;
   do {
     ConsumeToken();
@@ skipping 823 matching lines @@
   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());
-    const TypeArguments& signature_type_arguments = TypeArguments::Handle(
-        signature_type.arguments());
+    const AbstractTypeArguments& signature_type_arguments =
+        AbstractTypeArguments::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()) {
         ErrorMsg(errmsg.ToCString());
       }
@@ skipping 2297 matching lines @@
     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()) {
+      if (!AbstractTypeArguments::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->IsType());
       // Replace unresolved class with resolved type class.
       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());
+  const AbstractTypeArguments& arguments =
+      AbstractTypeArguments::Handle(type->arguments());
   if (!arguments.IsNull()) {
     const intptr_t num_arguments = arguments.Length();
     for (intptr_t i = 0; i < num_arguments; i++) {
       AbstractType& type_argument = AbstractType::Handle(arguments.TypeAt(i));
       TryResolveTypeFromClass(type_pos, cls, &type_argument);
       arguments.SetTypeAt(i, type_argument);
     }
   }
 }
 
@@ skipping 155 matching lines @@
     if (!const_value.IsNull()) {
       const_value ^= const_value.Canonicalize();
     }
     field.set_value(const_value);
   }
 }
 
 
 RawInstance* Parser::EvaluateConstConstructorCall(
     const Class& type_class,
-    const TypeArguments& type_arguments,
+    const AbstractTypeArguments& type_arguments,
     const Function& constructor,
     ArgumentListNode* arguments) {
   // +2 for implicit receiver and construction phase arguments.
   GrowableArray<const Object*> arg_values(arguments->length() + 2);
   Instance& instance = Instance::Handle();
   if (!constructor.IsFactory()) {
     instance = Instance::New(type_class);
     if (!type_arguments.IsNull()) {
       // TODO(regis): Where should we check the constraints on type parameters?
       if (!type_arguments.IsInstantiated()) {
@@ skipping 306 matching lines @@
             ErrorMsg(type_pos, "type parameter '%s' cannot be parameterized",
                      String::Handle(type_parameter.Name()).ToCString());
           }
           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));
+  AbstractTypeArguments& type_arguments =
+      AbstractTypeArguments::Handle(ParseTypeArguments(type_resolution));
   Type& type = Type::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();
 }
 
 
 void Parser::CheckConstructorCallTypeArguments(
-    intptr_t pos, Function& constructor, const TypeArguments& type_arguments) {
+    intptr_t pos, Function& constructor,
+    const AbstractTypeArguments& type_arguments) {
   if (!type_arguments.IsNull()) {
     Class& signature_class = Class::Handle();
     if (constructor.IsFactory()) {
       signature_class = constructor.signature_class();
     } else {
       signature_class = constructor.owner();
     }
     ASSERT(!signature_class.IsNull());
     ASSERT(signature_class.is_finalized());
     // Do not report the expected vs. actual number of type arguments, because
     // the type argument vector is flattened and raw types are allowed.
     if (type_arguments.Length() != signature_class.NumTypeArguments()) {
       ErrorMsg(pos, "wrong number of type arguments passed to constructor");
     }
   }
 }
 
 
 // Parse "[" [ expr { "," expr } ["," ] "]".
 // Note: if the list literal is empty and the brackets have no whitespace
 // between them, the scanner recognizes the opening and closing bracket
 // as one token of type Token::kINDEX.
 AstNode* Parser::ParseListLiteral(intptr_t type_pos,
                                   bool is_const,
-                                  const TypeArguments& type_arguments) {
+                                  const AbstractTypeArguments& 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();
 
   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");
     }
     if (is_const && !element_type.IsInstantiated()) {
       ErrorMsg(type_pos,
                "the type argument of a constant list literal cannot include "
                "a type variable");
     }
   }
   ASSERT(type_arguments.IsNull() || (type_arguments.Length() == 1));
 
   // Parse the list elements. Note: there may be an optional extra
   // comma after the last element.
-  ArrayNode* list = new ArrayNode(token_index_, TypeArguments::ZoneHandle());
+  ArrayNode* list =
+      new ArrayNode(token_index_, TypeArguments::ZoneHandle());
   if (!is_empty_literal) {
     const bool saved_mode = SetAllowFunctionLiterals(true);
     const String& dst_name = String::ZoneHandle(
         String::NewSymbol("list literal element"));
     while (CurrentToken() != Token::kRBRACK) {
       const intptr_t element_pos = token_index_;
       AstNode* element = ParseExpr(is_const);
       if (FLAG_enable_type_checks &&
           !is_const &&
           !element_type.IsDynamicType()) {
@@ skipping 92 matching lines @@
       }
     }
   }
   pairs->AddElement(key);
   pairs->AddElement(value);
 }
 
 
 AstNode* Parser::ParseMapLiteral(intptr_t type_pos,
                                  bool is_const,
-                                 const TypeArguments& type_arguments) {
+                                 const AbstractTypeArguments& type_arguments) {
   TRACE_PARSER("ParseMapLiteral");
   ASSERT(type_pos >= 0);
   ASSERT(CurrentToken() == Token::kLBRACE);
   const intptr_t literal_pos = token_index_;
   ConsumeToken();
 
   AbstractType& value_type = Type::ZoneHandle(Type::DynamicType());
-  TypeArguments& map_type_arguments =
-      TypeArguments::ZoneHandle(type_arguments.raw());
+  AbstractTypeArguments& map_type_arguments =
+      AbstractTypeArguments::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
       // type String.
       if (map_type_arguments.Length() != 2) {
         ErrorMsg(type_pos,
                  "a map literal takes one type argument specifying "
                  "the value type");
       }
       if (!value_type.IsStringInterface()) {
         ErrorMsg(type_pos,
                  "the key type of a map literal is implicitly 'String'");
       }
       Warning(type_pos,
               "a map literal takes one type argument specifying "
               "the value type");
       value_type = map_type_arguments.TypeAt(1);
     } else {
-      TypeArray& type_array = TypeArray::Handle(TypeArray::New(2));
+      TypeArguments& type_array = TypeArguments::Handle(TypeArguments::New(2));
       type_array.SetTypeAt(0, Type::Handle(Type::StringInterface()));
       type_array.SetTypeAt(1, value_type);
       map_type_arguments = type_array.raw();
     }
     if (is_const && !value_type.IsInstantiated()) {
       ErrorMsg(type_pos,
                "the type argument of a constant map literal cannot include "
                "a type variable");
     }
   }
@@ skipping 124 matching lines @@
 }
 
 
 AstNode* Parser::ParseCompoundLiteral() {
   bool is_const = false;
   if (CurrentToken() == Token::kCONST) {
     is_const = true;
     ConsumeToken();
   }
   const intptr_t type_pos = token_index_;
-  TypeArguments& type_arguments =
-      TypeArguments::ZoneHandle(ParseTypeArguments(kMustResolve));
+  AbstractTypeArguments& type_arguments =
+      AbstractTypeArguments::ZoneHandle(ParseTypeArguments(kMustResolve));
   AstNode* primary = NULL;
   if ((CurrentToken() == Token::kLBRACK) ||
       (CurrentToken() == Token::kINDEX)) {
     primary = ParseListLiteral(type_pos, is_const, type_arguments);
   } else if (CurrentToken() == Token::kLBRACE) {
     primary = ParseMapLiteral(type_pos, is_const, type_arguments);
   } else {
     ErrorMsg("unexpected token %s", Token::Str(CurrentToken()));
   }
   return primary;
@@ skipping 59 matching lines @@
     type_parameter = scope_class.LookupTypeParameter(*type_name.ident);
     if (!type_parameter.IsNull()) {
       ErrorMsg(type_pos, "type parameter '%s' cannot be instantiated",
                String::Handle(type_parameter.Name()).ToCString());
     }
   }
   Class& type_class = Class::ZoneHandle();
   type_class ^= LookupTypeClass(type_name, kMustResolve);
   String& type_class_name = String::Handle();
   type_class_name = type_class.Name();
-  TypeArguments& type_arguments = TypeArguments::ZoneHandle();
+  AbstractTypeArguments& type_arguments = AbstractTypeArguments::ZoneHandle();
   // Type arguments are not allowed after the optional constructor name.
   if (named_constructor == NULL) {
     type_arguments = ParseTypeArguments(kMustResolve);
   }
   if ((named_constructor == NULL) && (CurrentToken() == Token::kPERIOD)) {
     ConsumeToken();
     named_constructor = ExpectIdentifier("name of constructor expected");
   }
 
   // Parse constructor parameters.
@@ skipping 563 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart