Enforce rule in vm that factory name must match enclosing class name.

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 2957 matching lines @@
         // supported yet).
         member.type = &AbstractType::ZoneHandle(
             ParseType(ClassFinalizer::kTryResolve));
       }
     }
   }
 
   // Optionally parse a (possibly named) constructor name or factory.
   if (IsIdentifier() &&
       (CurrentLiteral()->Equals(members->class_name()) || member.has_factory)) {
+    member.name_pos = TokenPos();
+    member.name = CurrentLiteral();  // Unqualified identifier.
+    ConsumeToken();
     if (member.has_factory) {
-      // TODO(regis): Simplify this code once the core library is fixed.
-      // See issue 6641.
-      // Per specification, the name of the factory must be the name of the
-      // immediately enclosing class.
-
-      // The factory name may be qualified.
-      QualIdent factory_name;
-      ParseQualIdent(&factory_name);
-      member.name_pos = factory_name.ident_pos;
-      member.name = factory_name.ident;  // Unqualified identifier.
-      // The class of the factory result type is specified by the factory name.
-      LibraryPrefix& lib_prefix = LibraryPrefix::Handle();
-      if (factory_name.lib_prefix != NULL) {
-        lib_prefix = factory_name.lib_prefix->raw();
+      // The factory name may be qualified, but the first identifier must match
+      // the name of the immediately enclosing class.
+      if (!member.name->Equals(members->class_name())) {
+        ErrorMsg(member.name_pos, "factory name must be '%s'",
+                 members->class_name().ToCString());
       }
       const Object& result_type_class = Object::Handle(
-          UnresolvedClass::New(lib_prefix,
-                               *factory_name.ident,
-                               factory_name.ident_pos));
+          UnresolvedClass::New(LibraryPrefix::Handle(),
+                               *member.name,
+                               member.name_pos));
       // The type arguments of the result type are set during finalization.
       member.type = &Type::ZoneHandle(Type::New(result_type_class,
                                                 TypeArguments::Handle(),
-                                                factory_name.ident_pos));
-    } else {
-      if (member.has_static) {
-        ErrorMsg("constructor cannot be static");
-      }
-      member.name_pos = TokenPos();
-      member.name = CurrentLiteral();
-      ConsumeToken();
+                                                member.name_pos));
+    } else if (member.has_static) {
+      ErrorMsg(member.name_pos, "constructor cannot be static");
     }
     // We must be dealing with a constructor or named constructor.
     member.kind = RawFunction::kConstructor;
     String& ctor_suffix = String::ZoneHandle(Symbols::Dot());
     if (CurrentToken() == Token::kPERIOD) {
       // Named constructor.
       ConsumeToken();
       member.constructor_name = ExpectIdentifier("identifier expected");
       ctor_suffix = String::Concat(ctor_suffix, *member.constructor_name);
     }
@@ skipping 5977 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& factory_class_name = String::Handle(Symbols::MapImplementation());
+    String& factory_class_name = String::Handle(Symbols::Map());
     const Class& factory_class =
         Class::Handle(LookupCoreClass(factory_class_name));
     ASSERT(!factory_class.IsNull());
     const String& factory_method_name =
         String::Handle(Symbols::MapLiteralFactory());
     const Function& factory_method = Function::ZoneHandle(
         factory_class.LookupFactory(factory_method_name));
     ASSERT(!factory_method.IsNull());
     if (!map_type_arguments.IsNull() &&
         !map_type_arguments.IsInstantiated() &&
@@ skipping 1012 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart