Issue 13241. Report StaticWarningCode.CONFLICTING_INSTANCE_METHOD_SETTER.

editor/tools/plugins/com.google.dart.engine/src/com/google/dart/engine/internal/verifier/ErrorVerifier.java

 /*
  * Copyright (c) 2013, the Dart project authors.
  * 
  * Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
  * in compliance with the License. You may obtain a copy of the License at
  * 
  * http://www.eclipse.org/legal/epl-v10.html
  * 
  * Unless required by applicable law or agreed to in writing, software distributed under the License
  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
@@ skipping 796 matching lines @@
       if (node.isGetter()) {
         checkForConflictingStaticGetterAndInstanceSetter(node);
       } else if (node.isSetter()) {
         checkForWrongNumberOfParametersForSetter(node.getName(), node.getParameters());
         checkForNonVoidReturnTypeForSetter(node.getReturnType());
         checkForConflictingStaticSetterAndInstanceMember(node);
       } else if (node.isOperator()) {
         checkForOptionalParameterInOperator(node);
         checkForWrongNumberOfParametersForOperator(node);
         checkForNonVoidReturnTypeForOperator(node);
+      } else {
+        checkForConflictingInstanceMethodSetter(node);
       }
       checkForConcreteClassWithAbstractMember(node);
       checkForAllInvalidOverrideErrorCodes(node);
       return super.visitMethodDeclaration(node);
     } finally {
       enclosingFunction = previousFunction;
       isInStaticMethod = false;
     }
   }
 
@@ skipping 1428 matching lines @@
     } else {
       errorReporter.reportError(
           StaticWarningCode.CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER,
           nameNode,
           superElementType.getDisplayName());
     }
     return true;
   }
 
   /**
+   * This verifies that the enclosing class does not have a setter with the same name as the passed
+   * instance method declaration.
+   * 
+   * @param node the method declaration to evaluate
+   * @return {@code true} if and only if an error code is generated on the passed node
+   * @see StaticWarningCode#CONFLICTING_INSTANCE_METHOD_SETTER
+   */
+  private boolean checkForConflictingInstanceMethodSetter(MethodDeclaration node) {
+    if (node.isStatic()) {
+      return false;
+    }
+    // prepare name
+    SimpleIdentifier nameNode = node.getName();
+    if (nameNode == null) {
+      return false;
+    }
+    String name = nameNode.getName();
+    // prepare enclosing type
+    if (enclosingClass == null) {
+      return false;
+    }
+    InterfaceType enclosingType = enclosingClass.getType();
+    // try to find setter
+    ExecutableElement setter = enclosingType.lookUpSetter(name, currentLibrary);

[Brian Wilkerson, 2013/11/02 15:19:38]

Should this be using the InheritanceManager to do the look-up? In other words,
does this also need to handle setters defined by interfaces?

[scheglov, 2013/11/02 20:32:00]

Yes, we need to use InheritanceManager.
Fixed.

+    if (setter == null) {
+      return false;
+    }
+    // already reported as INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC
+    if (setter.isStatic()) {
+      return false;
+    }
+    // report problem
+    errorReporter.reportError(
+        StaticWarningCode.CONFLICTING_INSTANCE_METHOD_SETTER,
+        nameNode,
+        enclosingType.getDisplayName(),
+        name);
+    return true;
+  }
+
+  /**
    * This verifies that the enclosing class does not have an instance member with the same name as
    * the passed static getter method declaration.
    * 
    * @param node the method declaration to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER
    */
   private boolean checkForConflictingStaticGetterAndInstanceSetter(MethodDeclaration node) {
     if (!node.isStatic()) {
       return false;
@@ skipping 3132 matching lines @@
       if (superClassElt != null) {
         return memberHasConcreteMethodImplementationInSuperclassChain(
             superClassElt,
             methodName,
             superclassChain);
       }
     }
     return false;
   }
 }