Version 0.8.10.9

dart/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 458 matching lines @@
         for (FieldElement fieldElement : fieldElements) {
           if (!fieldElement.isSynthetic()) {
             initialFieldElementsMap.put(fieldElement, fieldElement.getInitializer() == null
                 ? INIT_STATE.NOT_INIT : INIT_STATE.INIT_IN_DECLARATION);
           }
         }
       }
       checkForFinalNotInitialized(node);
       checkForDuplicateDefinitionInheritance();
       checkForConflictingGetterAndMethod();
+      checkForConflictingInstanceGetterAndSuperclassMember();
       checkImplementsSuperClass(node);
       checkImplementsFunctionWithoutCall(node);
       return super.visitClassDeclaration(node);
     } finally {
       isInNativeClass = false;
       initialFieldElementsMap = null;
       enclosingClass = outerClass;
     }
   }
 
@@ skipping 292 matching lines @@
     try {
       isInStaticMethod = node.isStatic();
       enclosingFunction = node.getElement();
       SimpleIdentifier identifier = node.getName();
       String methodName = "";
       if (identifier != null) {
         methodName = identifier.getName();
       }
       if (node.isSetter() || node.isGetter()) {
         checkForMismatchedAccessorTypes(node, methodName);
-        checkForConflictingInstanceGetterAndSuperclassMember(node);
       }
       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);
@@ skipping 1387 matching lines @@
           name.length(),
           enclosingClass.getDisplayName(),
           inherited.getEnclosingElement().getDisplayName(),
           name);
     }
     // done
     return hasProblem;
   }
 
   /**
-   * This verifies that the superclass of the enclosing class does not declare accessible static
-   * member with the same name as the passed instance getter/setter method declaration.
+   * This verifies that the superclass of the {@link #enclosingClass} does not declare accessible
+   * static members with the same name as the instance getters/setters declared in
+   * {@link #enclosingClass}.
    * 
    * @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_GETTER_AND_SUPERCLASS_MEMBER
    * @see StaticWarningCode#CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER
    */
-  private boolean checkForConflictingInstanceGetterAndSuperclassMember(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
+  private boolean checkForConflictingInstanceGetterAndSuperclassMember() {
     if (enclosingClass == null) {
       return false;
     }
     InterfaceType enclosingType = enclosingClass.getType();
-    // try to find super element
-    ExecutableElement superElement;
-    superElement = enclosingType.lookUpGetterInSuperclass(name, currentLibrary);
-    if (superElement == null) {
-      superElement = enclosingType.lookUpSetterInSuperclass(name, currentLibrary);
+    // check every accessor
+    boolean hasProblem = false;
+    for (PropertyAccessorElement accessor : enclosingClass.getAccessors()) {
+      // we analyze instance accessors here
+      if (accessor.isStatic()) {
+        continue;
+      }
+      // prepare accessor properties
+      String name = accessor.getDisplayName();
+      boolean getter = accessor.isGetter();
+      // if non-final variable, ignore setter - we alreay reported problem for getter
+      if (accessor.isSetter() && accessor.isSynthetic()) {
+        continue;
+      }
+      // try to find super element
+      ExecutableElement superElement;
+      superElement = enclosingType.lookUpGetterInSuperclass(name, currentLibrary);
+      if (superElement == null) {
+        superElement = enclosingType.lookUpSetterInSuperclass(name, currentLibrary);
+      }
+      if (superElement == null) {
+        superElement = enclosingType.lookUpMethodInSuperclass(name, currentLibrary);
+      }
+      if (superElement == null) {
+        continue;
+      }
+      // OK, not static
+      if (!superElement.isStatic()) {
+        continue;
+      }
+      // prepare "super" type to report its name
+      ClassElement superElementClass = (ClassElement) superElement.getEnclosingElement();
+      InterfaceType superElementType = superElementClass.getType();
+      // report problem
+      hasProblem = true;
+      if (getter) {
+        errorReporter.reportError(
+            StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER,
+            accessor,
+            superElementType.getDisplayName());
+      } else {
+        errorReporter.reportError(
+            StaticWarningCode.CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER,
+            accessor,
+            superElementType.getDisplayName());
+      }
     }
-    if (superElement == null) {
-      superElement = enclosingType.lookUpMethodInSuperclass(name, currentLibrary);
-    }
-    if (superElement == null) {
-      return false;
-    }
-    // OK, not static
-    if (!superElement.isStatic()) {
-      return false;
-    }
-    // prepare "super" type to report its name
-    ClassElement superElementClass = (ClassElement) superElement.getEnclosingElement();
-    InterfaceType superElementType = superElementClass.getType();
-    // report problem
-    if (node.isGetter()) {
-      errorReporter.reportError(
-          StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER,
-          nameNode,
-          superElementType.getDisplayName());
-    } else {
-      errorReporter.reportError(
-          StaticWarningCode.CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER,
-          nameNode,
-          superElementType.getDisplayName());
-    }
-    return true;
+    // done
+    return hasProblem;
   }
 
   /**
    * 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
    */
@@ skipping 3137 matching lines @@
       if (superClassElt != null) {
         return memberHasConcreteMethodImplementationInSuperclassChain(
             superClassElt,
             methodName,
             superclassChain);
       }
     }
     return false;
   }
 }