Ongoing renaming of type classes:

runtime/vm/parser.h

 // 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.
 
 #ifndef VM_PARSER_H_
 #define VM_PARSER_H_
 
 #include "include/dart_api.h"
 
 #include "vm/ast.h"
@@ skipping 149 matching lines @@
   void SkipPrimary();
   void SkipCompoundLiteral();
   void SkipNewOperator();
   void SkipActualParameters();
   void SkipMapLiteral();
   void SkipListLiteral();
   void SkipFunctionLiteral();
   void SkipStringLiteral();
 
   void CheckConstructorCallTypeArguments(
-    intptr_t pos, Function& constructor, const TypeArguments& type_arguments);
+    intptr_t pos,
+    Function& constructor,
+    const AbstractTypeArguments& type_arguments);
 
   // Reports error message at location of current token.
   void ErrorMsg(const char* msg, ...);
   void ErrorMsg(intptr_t token_index, const char* msg, ...);
   void Warning(const char* msg, ...);
   void Warning(intptr_t token_index, const char* msg, ...);
   void Unimplemented(const char* msg);
 
   const Instance& EvaluateConstExpr(AstNode* expr);
   void RunStaticFieldInitializer(const Field& field);
-  RawInstance* EvaluateConstConstructorCall(const Class& type_class,
-                                            const TypeArguments& type_arguments,
-                                            const Function& constructor,
-                                            ArgumentListNode* arguments);
+  RawInstance* EvaluateConstConstructorCall(
+      const Class& type_class,
+      const AbstractTypeArguments& type_arguments,
+      const Function& constructor,
+      ArgumentListNode* arguments);
   AstNode* FoldConstExpr(intptr_t expr_pos, AstNode* expr);
 
   // Support for parsing of scripts.
   void ParseTopLevel();
   void ParseClassDefinition(GrowableArray<const Class*>* classes);
   void ParseInterfaceDefinition(GrowableArray<const Class*>* classes);
   void ParseFunctionTypeAlias(GrowableArray<const Class*>* classes);
   void ParseTopLevelVariable(TopLevel* top_level);
   void ParseTopLevelFunction(TopLevel* top_level);
   void ParseTopLevelAccessor(TopLevel* top_level);
@@ skipping 10 matching lines @@
   void TryResolveTypeFromClass(intptr_t type_pos,
                                const Class& cls,
                                AbstractType* type);
   enum TypeResolution {
     kDoNotResolve,  // Type resolution is postponed.
     kCanResolve,  // Type resolution is optional.
     kMustResolve  // Type resolution is required.
   };
   RawAbstractType* ParseType(TypeResolution type_resolution);
   void ParseTypeParameters(const Class& cls);
-  RawTypeArguments* ParseTypeArguments(TypeResolution type_resolution);
+  RawAbstractTypeArguments* ParseTypeArguments(TypeResolution type_resolution);
   void ParseQualIdent(QualIdent* qual_ident);
   void ParseMethodOrConstructor(ClassDesc* members, MemberDesc* method);
   void ParseFieldDefinition(ClassDesc* members, MemberDesc* field);
   void ParseClassMemberDefinition(ClassDesc* members);
   void ParseFormalParameter(bool allow_explicit_default_value,
                             ParamList* params);
   void ParseFormalParameters(bool allow_explicit_default_values,
                              ParamList* params);
   void ParseFormalParameterList(bool allow_explicit_default_values,
                                 ParamList* params);
@@ skipping 113 matching lines @@
   AstNode* ParseExpr(bool require_compiletime_const);
   AstNode* ParseExprList();
   AstNode* ParseConditionalExpr();
   AstNode* ParseUnaryExpr();
   AstNode* ParsePostfixExpr();
   AstNode* ParsePrimary();
   AstNode* ParseStringLiteral();
   AstNode* ParseCompoundLiteral();
   AstNode* ParseListLiteral(intptr_t type_pos,
                             bool is_const,
-                            const TypeArguments& type_arguments);
+                            const AbstractTypeArguments& type_arguments);
   AstNode* ParseMapLiteral(intptr_t type_pos,
                            bool is_const,
-                           const TypeArguments& type_arguments);
+                           const AbstractTypeArguments& type_arguments);
   AstNode* ParseNewOperator();
 
   // An implicit argument, if non-null, is prepended to the returned list.
   ArgumentListNode* ParseActualParameters(ArgumentListNode* implicit_arguments,
                                           bool require_const);
   AstNode* ParseStaticCall(const Class& cls,
                            const String& method_name,
                            intptr_t ident_pos);
   AstNode* ParseInstanceCall(AstNode* receiver, const String& method_name);
   AstNode* ParseClosureCall(AstNode* closure);
@@ skipping 83 matching lines @@
   // code at all points in the try block where an exit from the block is
   // done using 'return', 'break' or 'continue' statements.
   TryBlocks* try_blocks_list_;
 
   DISALLOW_COPY_AND_ASSIGN(Parser);
 };
 
 }  // namespace dart
 
 #endif  // VM_PARSER_H_