Merge libv1.

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 564 matching lines @@
             bool is_interface,
             intptr_t token_pos)
       : clazz_(cls),
         class_name_(cls_name),
         is_interface_(is_interface),
         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 (NameExists<Function>(functions_, name) ||
-        NameExists<Field>(fields_, name)) {
+    if ((kind != RawFunction::kSetterFunction) && FunctionExists(name)) {
       return true;
     }
-    String& accessor_name = String::Handle();
-    if (kind != RawFunction::kSetterFunction) {
-      // Check if a getter function of same name exists.
-      accessor_name = Field::GetterName(name);
-      if (NameExists<Function>(functions_, accessor_name)) {
+    // 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;
       }
     }
-    if (kind != RawFunction::kGetterFunction) {
+
+    String& accessor_name = String::Handle();
+    if (kind == RawFunction::kSetterFunction) {
       // Check if a setter function of same name exists.
       accessor_name = Field::SetterName(name);
-      if (NameExists<Function>(functions_, accessor_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) const {
+  bool FieldNameExists(const String& name, bool check_setter) const {
     // First check if a function or field of same name exists.
-    if (NameExists<Function>(functions_, name) ||
-        NameExists<Field>(fields_, name)) {
+    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));
-    String& setter_name = String::Handle(Field::SetterName(name));
-    if (NameExists<Function>(functions_, getter_name) ||
-        NameExists<Function>(functions_, setter_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(!NameExists<Function>(functions_, String::Handle(function.name())));
+    ASSERT(!FunctionExists(String::Handle(function.name())));
     functions_.Add(function);
   }
 
   const GrowableObjectArray& functions() const {
     return functions_;
   }
 
   void AddField(const Field& field) {
-    ASSERT(!NameExists<Field>(fields_, String::Handle(field.name())));
+    ASSERT(!FieldExists(String::Handle(field.name())));
     fields_.Add(field);
   }
 
   const GrowableObjectArray& fields() const {
     return fields_;
   }
 
   RawClass* clazz() const {
     return clazz_.raw();
   }
@@ skipping 32 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:
-  template<typename T>
-  bool NameExists(const GrowableObjectArray& list, const String& name) const {
+  Field* LookupField(const String& name) const {
     String& test_name = String::Handle();
-    T& obj = T::Handle();
-    for (int i = 0; i < list.Length(); i++) {
-      obj ^= list.At(i);
-      test_name = obj.name();
+    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 true;
+        return &field;
       }
     }
-    return false;
+    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_;
   const bool is_interface_;
   intptr_t token_pos_;   // Token index of "class" keyword.
   GrowableObjectArray& functions_;
   GrowableObjectArray& fields_;
   GrowableArray<MemberDesc> members_;
 };
@@ skipping 2021 matching lines @@
 void Parser::ParseFieldDefinition(ClassDesc* members, MemberDesc* field) {
   TRACE_PARSER("ParseFieldDefinition");
   // The parser has read the first field name and is now at the token
   // after the field name.
   ASSERT(CurrentToken() == Token::kSEMICOLON ||
          CurrentToken() == Token::kCOMMA ||
          CurrentToken() == Token::kASSIGN);
   ASSERT(field->type != NULL);
   ASSERT(field->name_pos > 0);
   ASSERT(current_member_ == field);
+  // All const fields are also final.
   ASSERT(!field->has_const || field->has_final);
 
   if (field->has_abstract) {
     ErrorMsg("keyword 'abstract' not allowed in field declaration");
   }
   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 (members->FieldNameExists(*field->name)) {
+  if (members->FieldNameExists(*field->name, !field->has_final)) {
     ErrorMsg(field->name_pos,
              "'%s' field/method already defined\n", field->name->ToCString());
   }
   Function& getter = Function::Handle();
   Function& setter = Function::Handle();
   Field& class_field = Field::Handle();
   Instance& init_value = Instance::Handle();
   while (true) {
     bool has_initializer = CurrentToken() == Token::kASSIGN;
     bool has_simple_literal = false;
@@ skipping 1096 matching lines @@
     String& var_name = *ExpectIdentifier("variable name expected");
 
     if (library_.LookupLocalObject(var_name) != Object::null()) {
       ErrorMsg(name_pos, "'%s' is already defined", var_name.ToCString());
     }
     String& accessor_name = String::Handle(Field::GetterName(var_name));
     if (library_.LookupLocalObject(accessor_name) != Object::null()) {
       ErrorMsg(name_pos, "getter for '%s' is already defined",
                var_name.ToCString());
     }
-    accessor_name = Field::SetterName(var_name);
-    if (library_.LookupLocalObject(accessor_name) != Object::null()) {
-      ErrorMsg(name_pos, "setter for '%s' is already defined",
-               var_name.ToCString());
+    // A const or final variable does not define an implicit setter,
+    // so we only check setters for non-final variables.
+    if (!is_final) {
+      accessor_name = Field::SetterName(var_name);
+      if (library_.LookupLocalObject(accessor_name) != Object::null()) {
+        ErrorMsg(name_pos, "setter for '%s' is already defined",
+                 var_name.ToCString());
+      }
     }
 
     field = Field::New(var_name, is_static, is_final, is_const,
                        current_class(), name_pos);
     field.set_type(type);
     field.set_value(Instance::Handle(Instance::null()));
     top_level->fields.Add(field);
     library_.AddObject(field, var_name);
     if (CurrentToken() == Token::kASSIGN) {
       ConsumeToken();
@@ skipping 67 matching lines @@
   if (found && !is_patch) {
     ErrorMsg(name_pos, "'%s' is already defined", func_name.ToCString());
   } else if (!found && is_patch) {
     ErrorMsg(name_pos, "missing '%s' cannot be patched", func_name.ToCString());
   }
   String& accessor_name = String::Handle(Field::GetterName(func_name));
   if (library_.LookupLocalObject(accessor_name) != Object::null()) {
     ErrorMsg(name_pos, "'%s' is already defined as getter",
              func_name.ToCString());
   }
-  accessor_name = Field::SetterName(func_name);
-  if (library_.LookupLocalObject(accessor_name) != Object::null()) {
-    ErrorMsg(name_pos, "'%s' is already defined as setter",
-             func_name.ToCString());
-  }
+  // A setter named x= may co-exist with a function named x, thus we do
+  // not need to check setters.
 
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("'(' expected");
   }
   const intptr_t function_pos = TokenPos();
   ParamList params;
   const bool allow_explicit_default_values = true;
   ParseFormalParameterList(allow_explicit_default_values, &params);
 
   intptr_t function_end_pos = function_pos;
@@ skipping 89 matching lines @@
   } else {
     expected_num_parameters = 1;
     accessor_name = Field::SetterSymbol(*field_name);
   }
   if ((params.num_fixed_parameters != expected_num_parameters) ||
       (params.num_optional_parameters != 0)) {
     ErrorMsg(name_pos, "illegal %s parameters",
              is_getter ? "getter" : "setter");
   }
 
-  if (library_.LookupLocalObject(*field_name) != Object::null()) {
+  if (is_getter && library_.LookupLocalObject(*field_name) != Object::null()) {
     ErrorMsg(name_pos, "'%s' is already defined in this library",
              field_name->ToCString());
   }
+  if (!is_getter) {
+    // Check whether there is a field with the same name that has an implicit
+    // setter.
+    const Field& field = Field::Handle(library_.LookupLocalField(*field_name));
+    if (!field.IsNull() && !field.is_final()) {
+      ErrorMsg(name_pos, "Variable '%s' is already defined in this library",
+               field_name->ToCString());
+    }
+  }
   bool found = library_.LookupLocalObject(accessor_name) != Object::null();
   if (found && !is_patch) {
     ErrorMsg(name_pos, "%s for '%s' is already defined",
              is_getter ? "getter" : "setter",
              field_name->ToCString());
   } else if (!found && is_patch) {
     ErrorMsg(name_pos, "missing %s for '%s' cannot be patched",
              is_getter ? "getter" : "setter",
              field_name->ToCString());
   }
@@ skipping 5813 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart