Report HintCode.UNUSED_FIELD

pkg/analyzer/lib/src/generated/resolver.dart

 // Copyright (c) 2014, 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.
 
 library engine.resolver;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'java_core.dart';
@@ skipping 15536 matching lines @@
    * Resolved, locally defined elements that are used or potentially can be
    * used.
    */
   final HashSet<Element> elements = new HashSet<Element>();
 
   /**
    * Names of resolved or unresolved class members that are referenced in the
    * library.
    */
   final HashSet<String> members = new HashSet<String>();
+
+  /**
+   * Names of resolved or unresolved class members that are read in the
+   * library.
+   */
+  final HashSet<String> readMembers = new HashSet<String>();
 }
 
 
 class _GatherUsedElementsVisitor extends RecursiveAstVisitor {
   final _UsedElements usedElements = new _UsedElements();
 
   final LibraryElement _enclosingLibrary;
   ClassElement _enclosingClass;
   ExecutableElement _enclosingExec;
 
@@ skipping 27 matching lines @@
       _enclosingExec = enclosingExecOld;
     }
   }
 
   @override
   visitSimpleIdentifier(SimpleIdentifier node) {
     if (node.inDeclarationContext()) {
       return;
     }
     Element element = node.staticElement;
+    bool isIdentifierRead = _isReadIdentifier(node);
     if (element is LocalVariableElement) {
-      AstNode parent = node.parent;
-      if (node.inGetterContext()) {
-        if (parent.parent is ExpressionStatement &&
-            (parent is PrefixExpression ||
-             parent is PostfixExpression ||
-             parent is AssignmentExpression && parent.leftHandSide == node)) {
-          // v++;
-          // ++v;
-          // v += 2;
-        } else {
-          _useElement(element);
-        }
-      }
-      if (parent is MethodInvocation && parent.methodName == node) {
+      if (isIdentifierRead) {
         _useElement(element);
       }
+//    } else if (element is PropertyAccessorElement &&
+//        element.isSynthetic &&
+//        element.isPrivate) {
+//      PropertyInducingElement variable = element.variable;
+//      if (node.inGetterContext()) {
+//        AstNode parent = node.parent;
+//        if (parent.parent is ExpressionStatement &&
+//            (parent is PrefixExpression ||
+//             parent is PostfixExpression ||
+//             parent is AssignmentExpression && parent.leftHandSide == node)) {
+//          // f++;
+//          // ++f;
+//          // f += 2;
+//        } else {
+//          _useElement(variable);
+//        }
+//      }
     } else {
       _useIdentifierElement(node);
       if (element == null ||
           element is! LocalElement && !identical(element, _enclosingExec)) {
         usedElements.members.add(node.name);
+        if (isIdentifierRead) {
+          usedElements.readMembers.add(node.name);
+        }
       }
     }
   }
 
   @override
   visitTypeName(TypeName node) {
     _useIdentifierElement(node.name);
   }
 
   /**
@@ skipping 33 matching lines @@
     if (element != null) {
       usedElements.elements.add(element);
     }
   }
 
   void _useStaticElement(SimpleIdentifier identifier) {
     if (identifier != null) {
       _useElement(identifier.staticElement);
     }
   }
+
+  static bool _isReadIdentifier(SimpleIdentifier node) {
+    // not reading at all
+    if (!node.inGetterContext()) {
+      return false;
+    }
+    // check if useless reading
+    AstNode parent = node.parent;
+    if (parent.parent is ExpressionStatement &&
+        (parent is PrefixExpression ||
+         parent is PostfixExpression ||
+         parent is AssignmentExpression && parent.leftHandSide == node)) {
+      // v++;
+      // ++v;
+      // v += 2;
+      return false;
+    }
+    // OK
+    return true;
+  }
 }
 
 
 /**
  * Instances of the class [_UnusedElementsVerifier] traverse an element
  * structure looking for cases of [HintCode.UNUSED_ELEMENT] and
  * [HintCode.UNUSED_LOCAL_VARIABLE].
  */
 class _UnusedElementsVerifier extends RecursiveElementVisitor {
   /**
@@ skipping 16 matching lines @@
     if (!_isUsedElement(element)) {
       _reportErrorForElement(
           HintCode.UNUSED_ELEMENT,
           element,
           [element.kind.displayName, element.displayName]);
     }
     super.visitClassElement(element);
   }
 
   @override
+  visitFieldElement(FieldElement element) {
+    if (!element.isSynthetic && !_isReadMember(element)) {
+      _reportErrorForElement(
+          HintCode.UNUSED_FIELD,
+          element,
+          [element.displayName]);
+    }
+    super.visitFieldElement(element);
+  }
+
+  @override
   visitLocalVariableElement(LocalVariableElement element) {
     if (!_isUsedElement(element)) {
       _reportErrorForElement(
           HintCode.UNUSED_LOCAL_VARIABLE,
           element,
           [element.displayName]);
     }
   }
 
   @override
@@ skipping 20 matching lines @@
 
   bool _isUsedElement(Element element) {
     if (element is! LocalVariableElement) {
       if (element.isPublic) {
         return true;
       }
     }
     return _usedElements.elements.contains(element);
   }
 
+  bool _isReadMember(Element element) {
+    if (element.isPublic) {
+      return true;
+    }
+    return _usedElements.readMembers.contains(element.displayName);
+  }
+
   bool _isUsedMember(Element element) {
     if (element.isPublic) {
       return true;
     }
     if (_usedElements.members.contains(element.displayName)) {
       return true;
     }
     return _usedElements.elements.contains(element);
   }
 
   void _reportErrorForElement(ErrorCode errorCode, Element element, List<Object> arguments) {
     if (element != null) {
       _errorListener.onError(
           new AnalysisError.con2(
               element.source,
               element.nameOffset,
               element.displayName.length,
               errorCode,
               arguments));
     }
   }
 }