Check that class member names do not conflict with type parameters

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 "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 513 matching lines @@
     has_static = false;
     has_var = false;
     has_factory = false;
     has_operator = false;
     metadata_pos = -1;
     operator_token = Token::kILLEGAL;
     type = NULL;
     name_pos = 0;
     name = NULL;
     redirect_name = NULL;
-    constructor_name = NULL;
+    dict_name = NULL;
     params.Clear();
     kind = RawFunction::kRegularFunction;
+    field_ = NULL;
   }
   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;
   }
+  const char* ToCString() const {
+    if (field_ != NULL) {
+      return "field";
+    } else if (IsConstructor()) {
+      return "constructor";
+    } else if (IsFactory()) {
+      return "factory";
+    } else if (IsGetter()) {
+      return "getter";
+    } else if (IsSetter()) {
+      return "setter";
+    }
+    return "method";
+  }
+  String* DictName() const {
+    return (dict_name  != NULL) ? dict_name : name;
+  }
   bool has_abstract;
   bool has_external;
   bool has_final;
   bool has_const;
   bool has_static;
   bool has_var;
   bool has_factory;
   bool has_operator;
   intptr_t metadata_pos;
   Token::Kind operator_token;
   const AbstractType* type;
   intptr_t name_pos;
   intptr_t decl_begin_pos;
   String* name;
   // For constructors: NULL or name of redirected to constructor.
   String* redirect_name;
+  // dict_name is the name used for the class namespace, if it
+  // differs from 'name'.
   // For constructors: NULL for unnamed constructor,
   // identifier after classname for named constructors.
-  String* constructor_name;
+  // For getters and setters: unmangled name.
+  String* dict_name;
   ParamList params;
   RawFunction::Kind kind;
+  // NULL for functions, field object for static or instance fields.
+  Field* field_;
 };
 
 
 class ClassDesc : public ValueObject {
  public:
   ClassDesc(const Class& cls,
             const String& cls_name,
             bool is_interface,
             intptr_t token_pos)
       : clazz_(cls),
         class_name_(cls_name),
         token_pos_(token_pos),
         functions_(GrowableObjectArray::Handle(GrowableObjectArray::New())),
         fields_(GrowableObjectArray::Handle(GrowableObjectArray::New())) {
   }
 
-  // Parameter 'name' is the unmangled name, i.e. without the setter
-  // name mangling.
-  bool FunctionNameExists(const String& name, RawFunction::Kind kind) const {
-    // First check if a function or field of same name exists.
-    if ((kind != RawFunction::kSetterFunction) && FunctionExists(name)) {
-      return true;
-    }
-    // Now check whether there is a field and whether its implicit getter
-    // or setter collides with the name.
-    Field* field = LookupField(name);
-    if (field != NULL) {
-      if (kind == RawFunction::kSetterFunction) {
-        // It's ok to have an implicit getter, it does not collide with
-        // this setter function.
-        if (!field->is_final()) {
-          return true;
-        }
-      } else {
-        // The implicit getter of the field collides with the name.
-        return true;
-      }
-    }
-
-    String& accessor_name = String::Handle();
-    if (kind == RawFunction::kSetterFunction) {
-      // Check if a setter function of same name exists.
-      accessor_name = Field::SetterName(name);
-      if (FunctionExists(accessor_name)) {
-        return true;
-      }
-    } else {
-      // Check if a getter function of same name exists.
-      accessor_name = Field::GetterName(name);
-      if (FunctionExists(accessor_name)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  bool FieldNameExists(const String& name, bool check_setter) const {
-    // First check if a function or field of same name exists.
-    if (FunctionExists(name) || FieldExists(name)) {
-      return true;
-    }
-    // Now check if a getter/setter function of same name exists.
-    String& getter_name = String::Handle(Field::GetterName(name));
-    if (FunctionExists(getter_name)) {
-      return true;
-    }
-    if (check_setter) {
-      String& setter_name = String::Handle(Field::SetterName(name));
-      if (FunctionExists(setter_name)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
   void AddFunction(const Function& function) {
-    ASSERT(!FunctionExists(String::Handle(function.name())));
     functions_.Add(function);
   }
 
   const GrowableObjectArray& functions() const {
     return functions_;
   }
 
   void AddField(const Field& field) {
-    ASSERT(!FieldExists(String::Handle(field.name())));
     fields_.Add(field);
   }
 
   const GrowableObjectArray& fields() const {
     return fields_;
   }
 
   const Class& clazz() const {
     return clazz_;
   }
@@ skipping 28 matching lines @@
   MemberDesc* LookupMember(const String& name) const {
     for (int i = 0; i < members_.length(); i++) {
       if (name.Equals(*members_[i].name)) {
         return &members_[i];
       }
     }
     return NULL;
   }
 
  private:
-  Field* LookupField(const String& name) const {
-    String& test_name = String::Handle();
-    Field& field = Field::Handle();
-    for (int i = 0; i < fields_.Length(); i++) {
-      field ^= fields_.At(i);
-      test_name = field.name();
-      if (name.Equals(test_name)) {
-        return &field;
-      }
-    }
-    return NULL;
-  }
-
-  bool FieldExists(const String& name) const {
-    return LookupField(name) != NULL;
-  }
-
-  Function* LookupFunction(const String& name) const {
-    String& test_name = String::Handle();
-    Function& func = Function::Handle();
-    for (int i = 0; i < functions_.Length(); i++) {
-      func ^= functions_.At(i);
-      test_name = func.name();
-      if (name.Equals(test_name)) {
-        return &func;
-      }
-    }
-    return NULL;
-  }
-
-  bool FunctionExists(const String& name) const {
-    return LookupFunction(name) != NULL;
-  }
-
   const Class& clazz_;
   const String& class_name_;
   intptr_t token_pos_;   // Token index of "class" keyword.
   GrowableObjectArray& functions_;
   GrowableObjectArray& fields_;
   GrowableArray<MemberDesc> members_;
 };
 
 
 struct TopLevel {
@@ skipping 2315 matching lines @@
     if ((method->operator_token == Token::kSUB) &&
        (method->params.num_fixed_parameters == 1)) {
       // Patch up name for unary operator - so it does not clash with the
       // name for binary operator -.
       method->operator_token = Token::kNEGATE;
       *method->name = Symbols::New(Token::Str(Token::kNEGATE));
     }
     CheckOperatorArity(*method);
   }
 
-  if (members->FunctionNameExists(*method->name, method->kind)) {
-    ErrorMsg(method->name_pos,
-             "field or method '%s' already defined", method->name->ToCString());
-  }
-
   // Mangle the name for getter and setter functions and check function
   // arity.
   if (method->IsGetter() || method->IsSetter()) {
     int expected_num_parameters = 0;
     if (method->IsGetter()) {
       expected_num_parameters = (method->has_static) ? 0 : 1;
+      method->dict_name = method->name;
       method->name = &String::ZoneHandle(Field::GetterSymbol(*method->name));
     } else {
       ASSERT(method->IsSetter());
       expected_num_parameters = (method->has_static) ? 1 : 2;
+      method->dict_name =
+          &String::ZoneHandle(String::Concat(*method->name, Symbols::Equals()));
       method->name = &String::ZoneHandle(Field::SetterSymbol(*method->name));
     }
     if ((method->params.num_fixed_parameters != expected_num_parameters) ||
         (method->params.num_optional_parameters != 0)) {
       ErrorMsg(method->name_pos, "illegal %s parameters",
                method->IsGetter() ? "getter" : "setter");
     }
   }
 
   // Parse redirecting factory constructor.
@@ skipping 207 matching lines @@
   }
   if (field->has_external) {
     ErrorMsg("keyword 'external' not allowed in field declaration");
   }
   if (field->has_factory) {
     ErrorMsg("keyword 'factory' not allowed in field declaration");
   }
   if (!field->has_static && field->has_const) {
     ErrorMsg(field->name_pos, "instance field may not be 'const'");
   }
-  if (members->FieldNameExists(*field->name, !field->has_final)) {
-    ErrorMsg(field->name_pos,
-             "field or method '%s' already defined", field->name->ToCString());
-  }
   Function& getter = Function::Handle();
   Function& setter = Function::Handle();
-  Field& class_field = Field::Handle();
+  Field& class_field = Field::ZoneHandle();
   Instance& init_value = Instance::Handle();
   while (true) {
     bool has_initializer = CurrentToken() == Token::kASSIGN;
     bool has_simple_literal = false;
     if (has_initializer) {
       ConsumeToken();
       init_value = Object::sentinel().raw();
       // For static const fields and static final non-const fields, the
       // initialization expression will be parsed through the
       // kImplicitStaticFinalGetter method invocation/compilation.
@@ skipping 27 matching lines @@
     // Create the field object.
     class_field = Field::New(*field->name,
                              field->has_static,
                              field->has_final,
                              field->has_const,
                              current_class(),
                              field->name_pos);
     class_field.set_type(*field->type);
     class_field.set_has_initializer(has_initializer);
     members->AddField(class_field);
+    field->field_ = &class_field;
     if (field->metadata_pos >= 0) {
       library_.AddFieldMetadata(class_field, field->metadata_pos);
     }
 
     // For static final fields (this includes static const fields), set value to
     // "uninitialized" and create a kImplicitStaticFinalGetter getter method.
     if (field->has_static && has_initializer) {
       class_field.set_value(init_value);
       if (!has_simple_literal) {
         String& getter_name = String::Handle(Field::GetterSymbol(*field->name));
@@ skipping 73 matching lines @@
       member.params.has_optional_positional_parameters ||
       member.params.has_optional_named_parameters ||
       (member.params.num_fixed_parameters != expected_num_parameters)) {
     // Subtract receiver when reporting number of expected arguments.
     ErrorMsg(member.name_pos, "operator %s expects %" Pd " argument(s)",
         member.name->ToCString(), (expected_num_parameters - 1));
   }
 }
 
 
+void Parser::CheckMemberNameConflict(ClassDesc* members,
+                                     MemberDesc* member) {
+  const String& name = *member->DictName();
+  if (name.Equals(members->class_name())) {
+    ErrorMsg(member->name_pos,
+             "%s '%s' conflicts with class name",
+             member->ToCString(),
+             name.ToCString());
+  }
+  if (members->clazz().LookupTypeParameter(name) != TypeParameter::null()) {
+    ErrorMsg(member->name_pos,
+             "%s '%s' conflicts with type parameter",
+             member->ToCString(),
+             name.ToCString());
+  }
+  for (int i = 0; i < members->members().length(); i++) {
+    MemberDesc* existing_member = &members->members()[i];
+    if (name.Equals(*existing_member->DictName())) {
+      ErrorMsg(member->name_pos,
+               "%s '%s' conflicts with previously declared %s",
+               member->ToCString(),
+               name.ToCString(),
+               existing_member->ToCString());
+    }
+  }
+}
+
+
 void Parser::ParseClassMemberDefinition(ClassDesc* members,
                                         intptr_t metadata_pos) {
   TRACE_PARSER("ParseClassMemberDefinition");
   MemberDesc member;
   current_member_ = &member;
   member.metadata_pos = metadata_pos;
   member.decl_begin_pos = TokenPos();
   if ((CurrentToken() == Token::kEXTERNAL) &&
       (LookaheadToken(1) != Token::kLPAREN)) {
     ConsumeToken();
@@ skipping 96 matching lines @@
         result_type_class,
         TypeArguments::Handle(current_class().type_parameters()),
         member.name_pos));
 
     // We must be dealing with a constructor or named constructor.
     member.kind = RawFunction::kConstructor;
     *member.name = String::Concat(*member.name, Symbols::Dot());
     if (CurrentToken() == Token::kPERIOD) {
       // Named constructor.
       ConsumeToken();
-      member.constructor_name = ExpectIdentifier("identifier expected");
-      *member.name = String::Concat(*member.name, *member.constructor_name);
+      member.dict_name = ExpectIdentifier("identifier expected");
+      *member.name = String::Concat(*member.name, *member.dict_name);
     }
     // Ensure that names are symbols.
     *member.name = Symbols::New(*member.name);
 
     if (CurrentToken() != Token::kLPAREN) {
       ErrorMsg("left parenthesis expected");
     }
   } else if ((CurrentToken() == Token::kGET) && !member.has_var &&
              (LookaheadToken(1) != Token::kLPAREN) &&
              (LookaheadToken(1) != Token::kASSIGN) &&
@@ skipping 42 matching lines @@
     ConsumeToken();
   } else if (IsIdentifier()) {
     member.name = CurrentLiteral();
     member.name_pos = TokenPos();
     ConsumeToken();
   } else {
     ErrorMsg("identifier expected");
   }
 
   ASSERT(member.name != NULL);
-  if (member.kind != RawFunction::kConstructor) {
-    if (member.name->Equals(members->class_name())) {
-      ErrorMsg(member.name_pos,
-               "class member must not have the same name as its class");
-    }
-  }
-
   if (CurrentToken() == Token::kLPAREN || member.IsGetter()) {
     // Constructor or method.
     if (member.type == NULL) {
       member.type = &Type::ZoneHandle(Type::DynamicType());
     }
     ASSERT(member.IsFactory() == member.has_factory);
     ParseMethodOrConstructor(members, &member);
   } else if (CurrentToken() ==  Token::kSEMICOLON ||
              CurrentToken() == Token::kCOMMA ||
              CurrentToken() == Token::kASSIGN) {
     // Field definition.
     if (member.has_const) {
       // const fields are implicitly final.
       member.has_final = true;
     }
     if (member.type == NULL) {
       if (member.has_final) {
         member.type = &Type::ZoneHandle(Type::DynamicType());
       } else {
         ErrorMsg("missing 'var', 'final', 'const' or type"
                  " in field declaration");
       }
     }
     ParseFieldDefinition(members, &member);
   } else {
     UnexpectedToken();
   }
   current_member_ = NULL;
+  CheckMemberNameConflict(members, &member);
   members->AddMember(member);
 }
 
 
 void Parser::ParseClassDeclaration(const GrowableObjectArray& pending_classes,
                                    intptr_t metadata_pos) {
   TRACE_PARSER("ParseClassDeclaration");
   bool is_patch = false;
   bool is_abstract = false;
   if (is_patch_source() &&
@@ skipping 247 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(*receiver_type);
   cls.AddFunction(ctor);
 }
 
 
-// Check for cycles in constructor redirection. Also check whether a
-// named constructor collides with the name of another class member.
+// Check for cycles in constructor redirection.
 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 (member->constructor_name != NULL) {
-      // Check whether constructor name conflicts with a member name.
-      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());
-      }
+    if (member->redirect_name == NULL) {
+      continue;
     }
-
     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 6642 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart