Remove private class helping the parser to construct literal lists and maps.

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 8758 matching lines @@
                    String::Handle(element_type.UserVisibleName()).ToCString());
         }
       }
       const_list.SetAt(i, elem->AsLiteralNode()->literal());
     }
     const_list ^= const_list.Canonicalize();
     const_list.MakeImmutable();
     return new LiteralNode(literal_pos, const_list);
   } else {
     // Factory call at runtime.
-    String& list_literal_factory_class_name = String::Handle(
-        Symbols::ListLiteralFactoryClass());
-    const Class& list_literal_factory_class =
-        Class::Handle(LookupCoreClass(list_literal_factory_class_name));
-    ASSERT(!list_literal_factory_class.IsNull());
+    String& list_class_name = String::Handle(Symbols::ListImplementation());
+    const Class& list_class = Class::Handle(LookupCoreClass(list_class_name));
+    ASSERT(!list_class.IsNull());
     const String& list_literal_factory_name =
         String::Handle(Symbols::ListLiteralFactory());
     const Function& list_literal_factory = Function::ZoneHandle(
-        list_literal_factory_class.LookupFactory(list_literal_factory_name));
+        list_class.LookupFactory(list_literal_factory_name));
     ASSERT(!list_literal_factory.IsNull());
     if (!type_arguments.IsNull() &&
         !type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureInstantiator();
     }
     ArgumentListNode* factory_param = new ArgumentListNode(literal_pos);
     factory_param->Add(list);
     AbstractTypeArguments& canonical_type_arguments =
@@ skipping 196 matching lines @@
                                      constr_args));
     if (constructor_result.IsUnhandledException()) {
       return GenerateRethrow(literal_pos, constructor_result);
     } else {
       const Instance& const_instance = Instance::Cast(constructor_result);
       return new LiteralNode(literal_pos,
                              Instance::ZoneHandle(const_instance.raw()));
     }
   } else {
     // Factory call at runtime.
-    String& map_literal_factory_class_name = String::Handle(
-        Symbols::MapLiteralFactoryClass());
-    const Class& map_literal_factory_class =
-        Class::Handle(LookupCoreClass(map_literal_factory_class_name));
-    ASSERT(!map_literal_factory_class.IsNull());
+    String& map_class_name = String::Handle(Symbols::MapImplementation());
+    const Class& map_class = Class::Handle(LookupCoreClass(map_class_name));
+    ASSERT(!map_class.IsNull());
     const String& map_literal_factory_name =
         String::Handle(Symbols::MapLiteralFactory());
     const Function& map_literal_factory = Function::ZoneHandle(
-        map_literal_factory_class.LookupFactory(map_literal_factory_name));
+        map_class.LookupFactory(map_literal_factory_name));
     ASSERT(!map_literal_factory.IsNull());
     if (!map_type_arguments.IsNull() &&
         !map_type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureInstantiator();
     }
     ArgumentListNode* factory_param = new ArgumentListNode(literal_pos);
     factory_param->Add(kv_pairs);
     return CreateConstructorCallNode(literal_pos,
@@ skipping 990 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart