Convert String and List to abstract classes.

runtime/vm/parser.cc

 // Copyright (c) 2012, 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 1297 matching lines @@
     const ArgumentListNode& function_args) {
   ASSERT(function_args.length() >= 1);  // The receiver is the first argument.
   const intptr_t args_pos = function_args.token_pos();
   ArgumentListNode* arguments = new ArgumentListNode(args_pos);
   arguments->Add(function_args.NodeAt(0));
   // The second argument is the original function name.
   // TODO(regis): This will change once mirrors are supported.
   arguments->Add(new LiteralNode(args_pos, function_name));
   // The third argument is an array containing the original function arguments.
   ArrayNode* args_array = new ArrayNode(
-      args_pos, Type::ZoneHandle(Type::ListInterface()));
+      args_pos, Type::ZoneHandle(Type::ListType()));
   for (intptr_t i = 1; i < function_args.length(); i++) {
     args_array->AddElement(function_args.NodeAt(i));
   }
   arguments->Add(args_array);
   return arguments;
 }
 
 
 AstNode* Parser::ParseSuperCall(const String& function_name) {
   TRACE_PARSER("ParseSuperCall");
@@ skipping 3710 matching lines @@
   bool no_check = type.IsDynamicType();
   if ((CurrentToken() == Token::kINTEGER) &&
       (no_check || type.IsIntType() || type.IsNumberType())) {
     *value = CurrentIntegerLiteral();
     return true;
   } else if ((CurrentToken() == Token::kDOUBLE) &&
       (no_check || type.IsDoubleType() || type.IsNumberType())) {
     *value = CurrentDoubleLiteral();
     return true;
   } else if ((CurrentToken() == Token::kSTRING) &&
-      (no_check || type.IsStringInterface())) {
+      (no_check || type.IsStringType())) {
     *value = CurrentLiteral()->raw();
     return true;
   } else if ((CurrentToken() == Token::kTRUE) &&
       (no_check || type.IsBoolType())) {
     *value = Bool::True();
     return true;
   } else if ((CurrentToken() == Token::kFALSE) &&
       (no_check || type.IsBoolType())) {
     *value = Bool::False();
     return true;
@@ skipping 3421 matching lines @@
                "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));
   const Class& list_class = Class::Handle(
-      Type::Handle(Type::ListInterface()).type_class());
+      Type::Handle(Type::ListType()).type_class());
   Type& type = Type::ZoneHandle(
       Type::New(list_class, type_arguments, type_pos));
   type ^= ClassFinalizer::FinalizeType(
       current_class(), type, ClassFinalizer::kCanonicalize);
   ArrayNode* list = new ArrayNode(TokenPos(), type);
 
   // Parse the list elements. Note: there may be an optional extra
   // comma after the last element.
   if (!is_empty_literal) {
     const bool saved_mode = SetAllowFunctionLiterals(true);
@@ skipping 144 matching lines @@
     // Map literals take two type arguments.
     if (map_type_arguments.Length() < 2) {
       // TODO(hausner): Remove legacy syntax support.
       // We temporarily accept a single type argument.
       if (FLAG_warn_legacy_map_literal) {
         Warning(type_pos,
                 "a map literal takes two type arguments specifying "
                 "the key type and the value type");
       }
       TypeArguments& type_array = TypeArguments::Handle(TypeArguments::New(2));
-      type_array.SetTypeAt(0, Type::Handle(Type::StringInterface()));
+      type_array.SetTypeAt(0, Type::Handle(Type::StringType()));
       type_array.SetTypeAt(1, value_type);
       map_type_arguments = type_array.raw();
     } else if (map_type_arguments.Length() > 2) {
       ErrorMsg(type_pos,
                "a map literal takes two type arguments specifying "
                "the key type and the value type");
     } else {
       const AbstractType& key_type =
           AbstractType::Handle(map_type_arguments.TypeAt(0));
       value_type = map_type_arguments.TypeAt(1);
-      if (!key_type.IsStringInterface()) {
+      if (!key_type.IsStringType()) {
         ErrorMsg(type_pos, "the key type of a map literal must be 'String'");
       }
     }
     if (is_const && !value_type.IsInstantiated()) {
       ErrorMsg(type_pos,
                "the type argument of a constant map literal cannot include "
                "a type variable");
     }
   }
   ASSERT(map_type_arguments.IsNull() || (map_type_arguments.Length() == 2));
   map_type_arguments ^= map_type_arguments.Canonicalize();
 
   // The kv_pair array is temporary and of element type Dynamic. It is passed
   // to the factory to initialize a properly typed map.
   ArrayNode* kv_pairs =
-      new ArrayNode(TokenPos(), Type::ZoneHandle(Type::ListInterface()));
+      new ArrayNode(TokenPos(), Type::ZoneHandle(Type::ListType()));
 
   // Parse the map entries. Note: there may be an optional extra
   // comma after the last entry.
   const String& dst_name = String::ZoneHandle(Symbols::ListLiteralElement());
   while (CurrentToken() != Token::kRBRACE) {
     AstNode* key = NULL;
     if (CurrentToken() == Token::kSTRING) {
       key = ParseStringLiteral();
     }
     if (key == NULL) {
@@ skipping 491 matching lines @@
       (l1_token != Token::kINTERPOL_VAR) &&
       (l1_token != Token::kINTERPOL_START)) {
     // Common case: no interpolation.
     primary = new LiteralNode(literal_start, *CurrentLiteral());
     ConsumeToken();
     return primary;
   }
   // String interpolation needed.
   bool is_compiletime_const = true;
   ArrayNode* values = new ArrayNode(TokenPos(),
-                                    Type::ZoneHandle(Type::ListInterface()));
+                                    Type::ZoneHandle(Type::ListType()));
   while (CurrentToken() == Token::kSTRING) {
     values->AddElement(new LiteralNode(TokenPos(), *CurrentLiteral()));
     ConsumeToken();
     while ((CurrentToken() == Token::kINTERPOL_VAR) ||
         (CurrentToken() == Token::kINTERPOL_START)) {
       AstNode* expr = NULL;
       const intptr_t expr_pos = TokenPos();
       if (CurrentToken() == Token::kINTERPOL_VAR) {
         expr = ResolveIdent(TokenPos(), *CurrentLiteral(), true);
         ConsumeToken();
@@ skipping 57 matching lines @@
   OS::SNPrint(name, 64, "%s_%"Pd"",
               Symbols::Name(Symbols::kSavedArgDescVarPrefix),
               owner_function.token_pos());
   const String& saved_args_desc_name = String::ZoneHandle(Symbols::New(name));
   LocalVariable* saved_args_desc_var = LookupLocalScope(saved_args_desc_name);
   if (saved_args_desc_var == NULL) {
     ASSERT(owner_scope != NULL);
     saved_args_desc_var =
         new LocalVariable(owner_function.token_pos(),
                           saved_args_desc_name,
-                          Type::ZoneHandle(Type::ListInterface()));
+                          Type::ZoneHandle(Type::ListType()));
     saved_args_desc_var->set_is_final();
     // The saved arguments descriptor variable must be added just after the
     // formal parameters. This simplifies the 2-step saving of a captured
     // arguments descriptor.
     // At this time, the owner scope should only contain formal parameters.
     ASSERT(owner_scope->num_variables() == owner_function.NumParameters());
     bool success = owner_scope->AddVariable(saved_args_desc_var);
     ASSERT(success);
     // Capture the saved argument descriptor variable if necessary.
     LocalVariable* local = LookupLocalScope(saved_args_desc_name);
@@ skipping 437 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart