exclude instance suggestions in static context - fixes #22932

pkg/analysis_server/lib/src/services/completion/local_reference_contributor.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.contributor.dart.local;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol.dart' as protocol
     show Element, ElementKind;
 import 'package:analysis_server/src/protocol.dart' hide Element, ElementKind;
 import 'package:analysis_server/src/services/completion/dart_completion_manager.dart';
 import 'package:analysis_server/src/services/completion/local_declaration_visitor.dart';
 import 'package:analysis_server/src/services/completion/local_suggestion_builder.dart';
 import 'package:analysis_server/src/services/completion/optype.dart';
 import 'package:analyzer/src/generated/ast.dart';
-import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 
 /**
  * A contributor for calculating `completion.getSuggestions` request results
  * for the local library in which the completion is requested.
  */
 class LocalReferenceContributor extends DartCompletionContributor {
   @override
   bool computeFast(DartCompletionRequest request) {
     OpType optype = request.optype;
 
     // Collect suggestions from the specific child [AstNode] that contains
     // the completion offset and all of its parents recursively.
     if (!optype.isPrefixed) {
       if (optype.includeReturnValueSuggestions ||
           optype.includeTypeNameSuggestions ||
           optype.includeVoidReturnSuggestions) {
         _LocalVisitor localVisitor =
             new _LocalVisitor(request, request.offset, optype);
         localVisitor.visit(request.target.containingNode);
       }
       if (optype.includeStatementLabelSuggestions ||
           optype.includeCaseLabelSuggestions) {
-        _LabelVisitor labelVisitor = new _LabelVisitor(request,
+        _LabelVisitor labelVisitor = new _LabelVisitor(
+            request,
             optype.includeStatementLabelSuggestions,
             optype.includeCaseLabelSuggestions);
         labelVisitor.visit(request.target.containingNode);
       }
       if (optype.includeConstructorSuggestions) {
         new _ConstructorVisitor(request).visit(request.target.containingNode);
       }
     }
 
     // If target is an argument in an argument list
@@ skipping 129 matching lines @@
     if (paramCount > requiredParameterCount) {
       paramBuf.write(hasNamedParameters ? '}' : ']');
     }
     paramBuf.write(')');
     protocol.Element element = createElement(
         request.source, protocol.ElementKind.CONSTRUCTOR, elemId,
         parameters: paramBuf.toString());
     element.returnType = classDecl.name.name;
     CompletionSuggestion suggestion = new CompletionSuggestion(
         CompletionSuggestionKind.INVOCATION,
-        deprecated ? DART_RELEVANCE_LOW : DART_RELEVANCE_DEFAULT, completion,
-        completion.length, 0, deprecated, false,
+        deprecated ? DART_RELEVANCE_LOW : DART_RELEVANCE_DEFAULT,
+        completion,
+        completion.length,
+        0,
+        deprecated,
+        false,
         declaringType: classDecl.name.name,
         element: element,
         parameterNames: parameterNames,
         parameterTypes: parameterTypes,
         requiredParameterCount: requiredParameterCount,
         hasNamedParameters: hasNamedParameters);
     request.addSuggestion(suggestion);
     return suggestion;
   }
 
@@ skipping 115 matching lines @@
     // Labels are only accessible within the local function, so stop visiting
     // once we reach a function boundary.
     finished();
   }
 
   CompletionSuggestion _addSuggestion(SimpleIdentifier id) {
     if (id != null) {
       String completion = id.name;
       if (completion != null && completion.length > 0 && completion != '_') {
         CompletionSuggestion suggestion = new CompletionSuggestion(
-            CompletionSuggestionKind.IDENTIFIER, DART_RELEVANCE_DEFAULT,
-            completion, completion.length, 0, false, false);
+            CompletionSuggestionKind.IDENTIFIER,
+            DART_RELEVANCE_DEFAULT,
+            completion,
+            completion.length,
+            0,
+            false,
+            false);
         request.addSuggestion(suggestion);
         return suggestion;
       }
     }
     return null;
   }
 }
 
 /**
  * A visitor for collecting suggestions from the most specific child [AstNode]
  * that contains the completion offset to the [CompilationUnit].
  */
 class _LocalVisitor extends LocalDeclarationVisitor {
   final DartCompletionRequest request;
   final OpType optype;
 
-  _LocalVisitor(this.request, int offset, this.optype) : super(offset);
+  _LocalVisitor(this.request, int offset, this.optype) : super(offset) {
+    includeLocalInheritedTypes = !optype.inStaticMethodBody;
+  }
 
   @override
   void declaredClass(ClassDeclaration declaration) {
     if (optype.includeTypeNameSuggestions) {
       _addSuggestion(
           declaration.name, NO_RETURN_TYPE, protocol.ElementKind.CLASS,
           isAbstract: declaration.isAbstract,
           isDeprecated: isDeprecated(declaration));
     }
   }
@@ skipping 11 matching lines @@
   void declaredEnum(EnumDeclaration declaration) {
     if (optype.includeTypeNameSuggestions) {
       _addSuggestion(
           declaration.name, NO_RETURN_TYPE, protocol.ElementKind.ENUM,
           isDeprecated: isDeprecated(declaration));
     }
   }
 
   @override
   void declaredField(FieldDeclaration fieldDecl, VariableDeclaration varDecl) {
-    if (optype.includeReturnValueSuggestions) {
+    if (optype.includeReturnValueSuggestions &&
+        (!optype.inStaticMethodBody || fieldDecl.isStatic)) {
       CompletionSuggestion suggestion =
           createFieldSuggestion(request.source, fieldDecl, varDecl);
       if (suggestion != null) {
         request.addSuggestion(suggestion);
       }
     }
   }
 
   @override
   void declaredFunction(FunctionDeclaration declaration) {
@@ skipping 44 matching lines @@
   @override
   void declaredLocalVar(SimpleIdentifier id, TypeName typeName) {
     if (optype.includeReturnValueSuggestions) {
       _addSuggestion(id, typeName, protocol.ElementKind.LOCAL_VARIABLE,
           relevance: DART_RELEVANCE_LOCAL_VARIABLE);
     }
   }
 
   @override
   void declaredMethod(MethodDeclaration declaration) {
-    if (optype.includeReturnValueSuggestions ||
-        optype.includeVoidReturnSuggestions) {
+    if ((optype.includeReturnValueSuggestions ||
+            optype.includeVoidReturnSuggestions) &&
+        (!optype.inStaticMethodBody || declaration.isStatic)) {
       protocol.ElementKind elemKind;
       FormalParameterList param;
       TypeName typeName = declaration.returnType;
       int relevance = DART_RELEVANCE_DEFAULT;
       if (declaration.isGetter) {
         elemKind = protocol.ElementKind.GETTER;
         param = null;
         relevance = DART_RELEVANCE_LOCAL_ACCESSOR;
       } else if (declaration.isSetter) {
         if (!optype.includeVoidReturnSuggestions) {
@@ skipping 61 matching lines @@
       }
       if (type == null) {
         return 'dynamic';
       }
       Identifier typeId = type.name;
       if (typeId == null) {
         return 'dynamic';
       }
       return typeId.name;
     }).toList();
-    suggestion.requiredParameterCount = paramList.where(
-        (FormalParameter param) => param is! DefaultFormalParameter).length;
+    suggestion.requiredParameterCount = paramList
+        .where((FormalParameter param) => param is! DefaultFormalParameter)
+        .length;
     suggestion.hasNamedParameters = paramList
         .any((FormalParameter param) => param.kind == ParameterKind.NAMED);
   }
 
   void _addSuggestion(
       SimpleIdentifier id, TypeName typeName, protocol.ElementKind elemKind,
-      {bool isAbstract: false, bool isDeprecated: false,
-      ClassDeclaration classDecl, FormalParameterList param,
+      {bool isAbstract: false,
+      bool isDeprecated: false,
+      ClassDeclaration classDecl,
+      FormalParameterList param,
       int relevance: DART_RELEVANCE_DEFAULT}) {
     CompletionSuggestion suggestion = createSuggestion(
-        id, isDeprecated, relevance, typeName, classDecl: classDecl);
+        id, isDeprecated, relevance, typeName,
+        classDecl: classDecl);
     if (suggestion != null) {
       request.addSuggestion(suggestion);
       suggestion.element = createElement(request.source, elemKind, id,
           isAbstract: isAbstract,
           isDeprecated: isDeprecated,
           parameters: param != null ? param.toSource() : null,
           returnType: typeName);
       if ((elemKind == protocol.ElementKind.METHOD ||
               elemKind == protocol.ElementKind.FUNCTION) &&
           param != null) {
         _addParameterInfo(suggestion, param);
       }
     }
   }
 
   bool _isVoid(TypeName returnType) {
     if (returnType != null) {
       Identifier id = returnType.name;
       if (id != null && id.name == 'void') {
         return true;
       }
     }
     return false;
   }
 }