Add named constructor name checking

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"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
 #include "vm/growable_array.h"
 #include "vm/longjump.h"
 #include "vm/native_entry.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/resolver.h"
 #include "vm/scopes.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
+DEFINE_FLAG(bool, constructor_name_check, false,
+            "Named constructors may not clash with other members");
 DEFINE_FLAG(bool, enable_asserts, false, "Enable assert statements.");
 DEFINE_FLAG(bool, enable_type_checks, false, "Enable type checks.");
 DEFINE_FLAG(bool, trace_parser, false, "Trace parser operations.");
 DEFINE_FLAG(bool, warning_as_error, false, "Treat warnings as errors.");
 DEFINE_FLAG(bool, silent_warnings, false, "Silence warnings.");
 DEFINE_FLAG(bool, warn_legacy_map_literal, false,
             "Warning on legacy map literal syntax (single type argument)");
 
 static void CheckedModeHandler(bool value) {
   FLAG_enable_asserts = value;
@@ skipping 438 matching lines @@
     has_final = false;
     has_const = false;
     has_static = false;
     has_var = false;
     has_factory = false;
     has_operator = false;
     type = NULL;
     name_pos = 0;
     name = NULL;
     redirect_name = NULL;
+    constructor_name = NULL;
     params.Clear();
     kind = RawFunction::kRegularFunction;
   }
   bool IsConstructor() const {
     return (kind == RawFunction::kConstructor) && !has_static;
   }
   bool IsFactory() const {
     return (kind == RawFunction::kConstructor) && has_static;
   }
   bool IsFactoryOrConstructor() const {
     return (kind == RawFunction::kConstructor);
   }
   bool IsGetter() const {
     return kind == RawFunction::kGetterFunction;
   }
   bool IsSetter() const {
     return kind == RawFunction::kSetterFunction;
   }
   bool has_abstract;
   bool has_external;
   bool has_final;
   bool has_const;
   bool has_static;
   bool has_var;
   bool has_factory;
   bool has_operator;
   const AbstractType* type;
   intptr_t name_pos;
   String* name;
-  String* redirect_name;  // For constructors: NULL or redirected constructor.
+  // For constructors: NULL or redirected constructor.
+  String* redirect_name;
+  // For constructors: NULL for unnamed constructor,
+  // identifier after classname for named constructors.
+  String* constructor_name;
   ParamList params;
   RawFunction::Kind kind;
 };
 
 
 class ClassDesc : public ValueObject {
  public:
   ClassDesc(const Class& cls,
             const String& cls_name,
             bool is_interface,
@@ skipping 1339 matching lines @@
   ASSERT(!func.IsFactory());
   ASSERT(!func.is_static());
   ASSERT(!func.IsLocalFunction());
   const Class& cls = Class::Handle(func.Owner());
   ASSERT(!cls.IsNull());
 
   if (CurrentToken() == Token::kCLASS) {
     // Special case: implicit constructor.
     // The parser adds an implicit default constructor when a class
     // does not have any explicit constructor or factory (see
-    // Parser::CheckConstructors). The token position of this implicit
+    // Parser::AddImplicitConstructor). The token position of this implicit
     // constructor points to the 'class' keyword, which is followed
     // by the name of the class (which is also the constructor name).
     // There is no source text to parse. We just build the
     // sequence node by hand.
     return MakeImplicitConstructor(func);
   }
 
   OpenFunctionBlock(func);
   ParamList params;
   const bool allow_explicit_default_values = true;
@@ skipping 975 matching lines @@
       member.name_pos = TokenPos();
       member.name = CurrentLiteral();
       ConsumeToken();
     }
     // 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();
-      const String* name = ExpectIdentifier("identifier expected");
-      ctor_suffix = String::Concat(ctor_suffix, *name);
+      member.constructor_name = ExpectIdentifier("identifier expected");
+      ctor_suffix = String::Concat(ctor_suffix, *member.constructor_name);
     }
     *member.name = String::Concat(*member.name, ctor_suffix);
     // Ensure that names are symbols.
     *member.name = Symbols::New(*member.name);
     if (member.type == NULL) {
       ASSERT(!member.has_factory);
       // The body of the constructor cannot modify the type arguments of the
       // constructed instance, which is passed in as a hidden parameter.
       // Therefore, there is no need to set the result type to be checked.
       member.type = &Type::ZoneHandle(Type::DynamicType());
@@ skipping 208 matching lines @@
 
   if (is_abstract || members.is_abstract()) {
     cls.set_is_abstract();
   }
 
   // Add an implicit constructor if no explicit constructor is present. No
   // implicit constructors are needed for patch classes.
   if (!members.has_constructor() && !is_patch) {
     AddImplicitConstructor(&members);
   }
-  CheckConstructorCycles(&members);
+  CheckConstructors(&members);
 
   Array& array = Array::Handle();
   array = Array::MakeArray(members.fields());
   cls.SetFields(array);
 
   // Creating a new array for functions marks the class as parsed.
   array = Array::MakeArray(members.functions());
   cls.SetFunctions(array);
 
   if (!is_patch) {
@@ skipping 37 matching lines @@
                            &Type::ZoneHandle(Type::SmiType()));
 
   AddFormalParamsToFunction(&params, ctor);
   // The body of the constructor cannot modify the type of the constructed
   // instance, which is passed in as the receiver.
   ctor.set_result_type(*((*params.parameters)[0].type));
   class_desc->AddFunction(ctor);
 }
 
 
-// Check for cycles in constructor redirection.
-void Parser::CheckConstructorCycles(ClassDesc* class_desc) {
+// Check for cycles in constructor redirection. Also check whether a
+// named constructor collides with the name of another class member.
+void Parser::CheckConstructors(ClassDesc* class_desc) {
   // Check for cycles in constructor redirection.
   const GrowableArray<MemberDesc>& members = class_desc->members();
   for (int i = 0; i < members.length(); i++) {
     MemberDesc* member = &members[i];
+
+    if (FLAG_constructor_name_check && member->constructor_name != NULL) {
+      if (class_desc->FunctionNameExists(
+          *member->constructor_name, member->kind)) {
+        ErrorMsg(member->name_pos,
+                 "Named constructor '%s' conflicts with method or field '%s'",
+                 member->name->ToCString(),
+                 member->constructor_name->ToCString());
+      }
+    }
+
     GrowableArray<MemberDesc*> ctors;
     while ((member != NULL) && (member->redirect_name != NULL)) {
       ASSERT(member->IsConstructor());
       // Check whether we have already seen this member.
       for (int i = 0; i < ctors.length(); i++) {
         if (ctors[i] == member) {
           ErrorMsg(member->name_pos,
                    "cyclic reference in constructor redirection");
         }
       }
@@ skipping 6213 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart