Fix various inheritance bugs

runtime/vm/class_finalizer.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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 937 matching lines @@
     type = FinalizeType(cls, type, kCanonicalize);
     // In production mode, a malformed parameter type is mapped to dynamic.
     if (!FLAG_enable_type_checks && type.IsMalformed()) {
       type = Type::DynamicType();
     }
     function.SetParameterTypeAt(i, type);
   }
 }
 
 
+// Check if an instance field or method of same name exists
+// in any super class.
 static RawClass* FindSuperOwnerOfInstanceMember(const Class& cls,
                                                 const String& name) {
   Class& super_class = Class::Handle();
   Function& function = Function::Handle();
   Field& field = Field::Handle();
   super_class = cls.SuperClass();
   while (!super_class.IsNull()) {
-    // Check if an instance member of same name exists in any super class.
     function = super_class.LookupFunction(name);
     if (!function.IsNull() && !function.is_static()) {
       return super_class.raw();
     }
     field = super_class.LookupField(name);
     if (!field.IsNull() && !field.is_static()) {
       return super_class.raw();
     }
     super_class = super_class.SuperClass();
   }
   return Class::null();
 }
 
 
+// Check if an instance method of same name exists in any super class.
 static RawClass* FindSuperOwnerOfFunction(const Class& cls,
                                           const String& name) {
   Class& super_class = Class::Handle();
   Function& function = Function::Handle();
   super_class = cls.SuperClass();
   while (!super_class.IsNull()) {
-    // Check if a function of same name exists in any super class.
     function = super_class.LookupFunction(name);
     if (!function.IsNull() && !function.is_static()) {
       return super_class.raw();
     }
     super_class = super_class.SuperClass();
   }
   return Class::null();
 }
 
 
@@ skipping 19 matching lines @@
 }
 
 
 void ClassFinalizer::ResolveAndFinalizeMemberTypes(const Class& cls) {
   // Note that getters and setters are explicitly listed as such in the list of
   // functions of a class, so we do not need to consider fields as implicitly
   // generating getters and setters.
   // The only compile errors we report are therefore:
   // - a getter having the same name as a method (but not a getter) in a super
   //   class or in a subclass.
-  // - a setter having the same name as a method (but not a setter) in a super
-  //   class or in a subclass.
   // - a static field, instance field, or static method (but not an instance
   //   method) having the same name as an instance member in a super class.
 
   // Resolve type of fields and check for conflicts in super classes.
   Array& array = Array::Handle(cls.fields());
   Field& field = Field::Handle();
   AbstractType& type = AbstractType::Handle();
   String& name = String::Handle();
   Class& super_class = Class::Handle();
   intptr_t num_fields = array.Length();
   for (intptr_t i = 0; i < num_fields; i++) {
     field ^= array.At(i);
     type = field.type();
     ResolveType(cls, type, kCanonicalize);
     type = FinalizeType(cls, type, kCanonicalize);
     field.set_type(type);
     name = field.name();
-    super_class = FindSuperOwnerOfInstanceMember(cls, name);
-    if (!super_class.IsNull()) {
-      const String& class_name = String::Handle(cls.Name());
-      const String& super_class_name = String::Handle(super_class.Name());
-      const Script& script = Script::Handle(cls.script());
-      ReportError(script, field.token_pos(),
-                  "field '%s' of class '%s' conflicts with instance "
-                  "member '%s' of super class '%s'",
-                  name.ToCString(),
-                  class_name.ToCString(),
-                  name.ToCString(),
-                  super_class_name.ToCString());
+    if (field.is_static()) {
+      super_class = FindSuperOwnerOfInstanceMember(cls, name);
+      if (!super_class.IsNull()) {
+        const String& class_name = String::Handle(cls.Name());
+        const String& super_class_name = String::Handle(super_class.Name());
+        const Script& script = Script::Handle(cls.script());
+        ReportError(script, field.token_pos(),
+                    "static field '%s' of class '%s' conflicts with "
+                    "instance member '%s' of super class '%s'",
+                    name.ToCString(),
+                    class_name.ToCString(),
+                    name.ToCString(),
+                    super_class_name.ToCString());
+      }
+    } else {
+      // Instance field. Check whether the field overrides a method
+      // (but not getter).
+      super_class = FindSuperOwnerOfFunction(cls, name);
+      if (!super_class.IsNull()) {
+        const String& class_name = String::Handle(cls.Name());
+        const String& super_class_name = String::Handle(super_class.Name());
+        const Script& script = Script::Handle(cls.script());
+        ReportError(script, field.token_pos(),
+                    "field '%s' of class '%s' conflicts with method '%s' "
+                    "of super class '%s'",
+                    name.ToCString(),
+                    class_name.ToCString(),
+                    name.ToCString(),
+                    super_class_name.ToCString());
+      }
     }
   }
   // Collect interfaces, super interfaces, and super classes of this class.
   const GrowableObjectArray& interfaces =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   CollectInterfaces(cls, interfaces);
   // Include superclasses in list of interfaces and super interfaces.
   super_class = cls.SuperClass();
   while (!super_class.IsNull()) {
     interfaces.Add(super_class);
@@ skipping 57 matching lines @@
         const String& super_class_name = String::Handle(super_class.Name());
         const Script& script = Script::Handle(cls.script());
         ReportError(script, function.token_pos(),
                     "getter '%s' of class '%s' conflicts with "
                     "function '%s' of super class '%s'",
                     name.ToCString(),
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
-    } else if (function.IsSetterFunction()) {
-      name = Field::NameFromSetter(function_name);
-      super_class = FindSuperOwnerOfFunction(cls, name);
-      if (!super_class.IsNull()) {
-        const String& class_name = String::Handle(cls.Name());
-        const String& super_class_name = String::Handle(super_class.Name());
-        const Script& script = Script::Handle(cls.script());
-        ReportError(script, function.token_pos(),
-                    "setter '%s' of class '%s' conflicts with "
-                    "function '%s' of super class '%s'",
-                    name.ToCString(),
-                    class_name.ToCString(),
-                    name.ToCString(),
-                    super_class_name.ToCString());
-      }
-    } else {
+    } else if (!function.IsSetterFunction()) {
+      // A function cannot conflict with a setter, since they cannot
+      // have the same name. Thus, we do not need to check setters.
       name = Field::GetterName(function_name);
       super_class = FindSuperOwnerOfFunction(cls, name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(cls.Name());
         const String& super_class_name = String::Handle(super_class.Name());
         const Script& script = Script::Handle(cls.script());
         ReportError(script, function.token_pos(),
                     "function '%s' of class '%s' conflicts with "
                     "getter '%s' of super class '%s'",
                     function_name.ToCString(),
                     class_name.ToCString(),
                     function_name.ToCString(),
                     super_class_name.ToCString());
       }
-      name = Field::SetterName(function_name);
-      super_class = FindSuperOwnerOfFunction(cls, name);
-      if (!super_class.IsNull()) {
-        const String& class_name = String::Handle(cls.Name());
-        const String& super_class_name = String::Handle(super_class.Name());
-        const Script& script = Script::Handle(cls.script());
-        ReportError(script, function.token_pos(),
-                    "function '%s' of class '%s' conflicts with "
-                    "setter '%s' of super class '%s'",
-                    function_name.ToCString(),
-                    class_name.ToCString(),
-                    function_name.ToCString(),
-                    super_class_name.ToCString());
-      }
     }
   }
 }
 
 
 void ClassFinalizer::FinalizeClass(const Class& cls) {
   if (cls.is_finalized()) {
     return;
   }
   if (FLAG_trace_class_finalization) {
@@ skipping 410 matching lines @@
 void ClassFinalizer::ReportError(const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
       Parser::FormatError(Script::Handle(), -1, "Error", format, args));
   va_end(args);
   ReportError(error);
 }
 
 }  // namespace dart