filter void methods when suggesting expression

pkg/analysis_server/lib/src/services/completion/local_computer.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 services.completion.computer.dart.local;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol.dart' as protocol show Element,
     ElementKind;
@@ skipping 41 matching lines @@
   static final TypeName NO_RETURN_TYPE = new TypeName(
       new SimpleIdentifier(new StringToken(TokenType.IDENTIFIER, '', 0)),
       null);
 
   static final TypeName STACKTRACE_TYPE = new TypeName(
       new SimpleIdentifier(new StringToken(TokenType.IDENTIFIER, 'StackTrace', 0)),
       null);
 
   final DartCompletionRequest request;
   bool typesOnly = false;
+  bool excludeVoidReturn;
 
-  _LocalVisitor(this.request);
+  _LocalVisitor(this.request) {
+    excludeVoidReturn = _computeExcludeVoidReturn(request.node);
+  }
 
   @override
   visitBlock(Block node) {
     node.statements.forEach((Statement stmt) {
       if (stmt.offset < request.offset) {
         if (stmt is LabeledStatement) {
           stmt.labels.forEach((Label label) {
 //            _addSuggestion(label.label, CompletionSuggestionKind.LABEL);
           });
         } else if (stmt is VariableDeclarationStatement) {
@@ skipping 231 matching lines @@
             false,
             isDeprecated || _isDeprecated(varDecl.metadata));
       }
     });
   }
 
   void _addFunctionSuggestion(FunctionDeclaration declaration) {
     if (typesOnly) {
       return;
     }
+    if (excludeVoidReturn && _isVoid(declaration.returnType)) {
+      return;
+    }
     CompletionSuggestion suggestion = _addSuggestion(
         declaration.name,
         CompletionSuggestionKind.FUNCTION,
         declaration.returnType,
         null);
     if (suggestion != null) {
       suggestion.element = _createElement(
           protocol.ElementKind.FUNCTION,
           declaration.name,
           declaration.returnType,
@@ skipping 21 matching lines @@
   void _addMethodSuggestion(ClassDeclaration node, MethodDeclaration classMbr) {
     if (typesOnly) {
       return;
     }
     protocol.ElementKind kind;
     CompletionSuggestionKind csKind;
     if (classMbr.isGetter) {
       kind = protocol.ElementKind.GETTER;
       csKind = CompletionSuggestionKind.GETTER;
     } else if (classMbr.isSetter) {
+      if (excludeVoidReturn) {
+        return;
+      }
       kind = protocol.ElementKind.SETTER;
       csKind = CompletionSuggestionKind.SETTER;
     } else {
+      if (excludeVoidReturn && _isVoid(classMbr.returnType)) {
+        return;
+      }
       kind = protocol.ElementKind.METHOD;
       csKind = CompletionSuggestionKind.METHOD;
     }
     CompletionSuggestion suggestion =
         _addSuggestion(classMbr.name, csKind, classMbr.returnType, node);
     suggestion.element = _createElement(
         kind,
         classMbr.name,
         classMbr.returnType,
         classMbr.isAbstract,
@@ skipping 92 matching lines @@
               protocol.ElementKind.TOP_LEVEL_VARIABLE,
               varDecl.name,
               varList.type,
               false,
               isDeprecated || _isDeprecated(varDecl.metadata));
         }
       });
     }
   }
 
+  bool _computeExcludeVoidReturn(AstNode node) {
+    if (node is Block) {
+      return false;
+    } else if (node is SimpleIdentifier) {
+      return node.parent is ExpressionStatement ? false : true;
+    } else {
+      return true;
+    }
+  }
+
   /**
    * Create a new protocol Element for inclusion in a completion suggestion.
    */
   protocol.Element _createElement(protocol.ElementKind kind,
       SimpleIdentifier id, TypeName returnType, bool isAbstract, bool isDeprecated) {
     String name = id.name;
     int flags = protocol.Element.makeFlags(
         isAbstract: isAbstract,
         isDeprecated: isDeprecated,
         isPrivate: Identifier.isPrivateName(name));
     return new protocol.Element(
         kind,
         name,
         flags,
         returnType: _nameForType(returnType));
   }
 
   /**
    * Return `true` if the @deprecated annotation is present
    */
   bool _isDeprecated(NodeList<Annotation> metadata) =>
       metadata != null &&
           metadata.any(
               (Annotation a) => a.name is SimpleIdentifier && a.name.name == 'deprecated');
 
+  bool _isVoid(TypeName returnType) {
+    if (returnType != null) {
+      Identifier id = returnType.name;
+      if (id != null && id.name == 'void') {
+        return true;
+      }
+    }
+    return false;
+  }
+
   /**
    * Return the name for the given type.
    */
   String _nameForType(TypeName type) {
     if (type == NO_RETURN_TYPE) {
       return null;
     }
     if (type == null) {
       return DYNAMIC;
     }
     Identifier id = type.name;
     if (id == null) {
       return DYNAMIC;
     }
     String name = id.name;
     if (name == null || name.length <= 0) {
       return DYNAMIC;
     }
     TypeArgumentList typeArgs = type.typeArguments;
     if (typeArgs != null) {
       //TODO (danrubel) include type arguments
     }
     return name;
   }
 }