Lint to prefer x.isNotEmpty vs. !x.isEmpty (#143).

lib/src/ast.dart

 // Copyright (c) 2015, 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.
 
 /// Common AST helpers.
 library linter.src.ast;
 
 import 'package:analyzer/src/generated/ast.dart'
     show
         AssignmentExpression,
@@ skipping 13 matching lines @@
         FieldDeclaration,
         FunctionDeclaration,
         FunctionTypeAlias,
         MethodDeclaration,
         ReturnStatement,
         SimpleIdentifier,
         TopLevelVariableDeclaration,
         TypeParameter,
         VariableDeclaration;
 import 'package:analyzer/src/generated/element.dart'
-    show Element, ParameterElement, PropertyAccessorElement;
+    show
+        Element,
+        GeneralizingElementVisitor,
+        ParameterElement,
+        PropertyAccessorElement;
 import 'package:analyzer/src/generated/scanner.dart'
     show Keyword, KeywordToken, KeywordTokenWithComment, Token;
 import 'package:linter/src/util.dart';
 
+/// Returns direct children of [parent].
+List<Element> getChildren(Element parent, [String name]) {
+  List<Element> children = <Element>[];
+  visitChildren(parent, (Element element) {
+    if (name == null || element.displayName == name) {
+      children.add(element);
+    }
+  });
+  return children;
+}
+
 /// Returns the most specific AST node appropriate for associating errors.
 AstNode getNodeToAnnotate(Declaration node) {
   AstNode mostSpecific = _getNodeToAnnotate(node);
-  if (mostSpecific != null) {
-    return mostSpecific;
-  }
-  return node;
+  return mostSpecific ?? node;
 }
 
 /// Returns `true` if the keyword associated with this token is `final` or
 /// `const`.
 bool isFinalOrConst(Token token) =>
     isKeyword(token, Keyword.FINAL) || isKeyword(token, Keyword.CONST);
 
 /// Returns `true` if the keyword associated with the given [token] matches
 /// [keyword].
 bool isKeyword(Token token, Keyword keyword) =>
@@ skipping 68 matching lines @@
 
   return false;
 }
 
 /// Returns `true` if the given [id] is a valid Dart identifier.
 bool isValidDartIdentifier(String id) => !isKeyWord(id) && isIdentifier(id);
 
 /// Returns `true` if the keyword associated with this token is `var`.
 bool isVar(Token token) => isKeyword(token, Keyword.VAR);
 
+/// Uses [processor] to visit all of the children of [element].
+/// If [processor] returns `true`, then children of a child are visited too.
+void visitChildren(Element element, ElementProcessor processor) {
+  element.visitChildren(new _ElementVisitorAdapter(processor));
+}
+
 bool _checkForSimpleGetter(MethodDeclaration getter, Expression expression) {
   if (expression is SimpleIdentifier) {
     var staticElement = expression.staticElement;
     if (staticElement is PropertyAccessorElement) {
       Element getterElement = getter.element;
       // Skipping library level getters, test that the enclosing element is
       // the same
       if (staticElement.enclosingElement != null &&
           (staticElement.enclosingElement == getterElement.enclosingElement)) {
         return staticElement.isSynthetic && staticElement.variable.isPrivate;
@@ skipping 73 matching lines @@
     return node.name;
   }
   if (node is TypeParameter) {
     return node.name;
   }
   if (node is VariableDeclaration) {
     return node.name;
   }
   return null;
 }
+
+/// An [Element] processor function type.
+/// If `true` is returned, children of [element] will be visited.
+typedef bool ElementProcessor(Element element);
+
+/// A [GeneralizingElementVisitor] adapter for [ElementProcessor].
+class _ElementVisitorAdapter extends GeneralizingElementVisitor {
+  final ElementProcessor processor;
+  _ElementVisitorAdapter(this.processor);
+
+  @override
+  void visitElement(Element element) {
+    bool visitChildren = processor(element);
+    if (visitChildren == true) {
+      element.visitChildren(this);
+    }
+  }
+}