suggest keywords for switch statement and expressions

pkg/analysis_server/lib/src/services/completion/keyword_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.keyword;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol.dart';
 import 'package:analysis_server/src/services/completion/dart_completion_manager.dart';
@@ skipping 25 matching lines @@
  */
 class _KeywordVisitor extends GeneralizingAstVisitor {
   final DartCompletionRequest request;
   final Object entity;
 
   _KeywordVisitor(DartCompletionRequest request)
       : this.request = request,
         this.entity = request.target.entity;
 
   @override
+  visitArgumentList(ArgumentList node) {
+    if (entity == node.rightParenthesis ||
+        (entity is SimpleIdentifier && node.arguments.contains(entity))) {
+      _addExpressionKeywords(node);
+    }
+  }
+
+  @override
   visitBlock(Block node) {
     _addStatementKeywords(node);
   }
 
   @override
   visitClassDeclaration(ClassDeclaration node) {
     // Don't suggest class name
     if (entity == node.name) {
       return;
     }
@@ skipping 52 matching lines @@
           previousMember.functionExpression.body is EmptyFunctionBody) {
         _addSuggestion2(ASYNC, DART_RELEVANCE_HIGH);
       }
       _addCompilationUnitKeywords();
     }
   }
 
   @override
   visitExpressionFunctionBody(ExpressionFunctionBody node) {
     if (entity == node.expression) {
-      _addStatementKeywords(node);
+      _addExpressionKeywords(node);
     }
   }
 
   @override
   visitFormalParameterList(FormalParameterList node) {
     AstNode constructorDecl =
         node.getAncestor((p) => p is ConstructorDeclaration);
     if (constructorDecl != null) {
       _addSuggestions([Keyword.THIS]);
     }
@@ skipping 35 matching lines @@
     if (entity == node.body) {
       if (node.body is EmptyFunctionBody) {
         _addClassBodyKeywords();
         _addSuggestion2(ASYNC);
       } else {
         _addSuggestion2(ASYNC, DART_RELEVANCE_HIGH);
       }
     }
   }
 
+  @override
+  visitNamedExpression(NamedExpression node) {
+    if (entity is SimpleIdentifier && entity == node.expression) {
+      _addExpressionKeywords(node);
+    }
+  }
+
+  @override
+  visitNode(AstNode node) {
+    // ignored
+  }
+
+  @override
+  visitSwitchStatement(SwitchStatement node) {
+    if (entity == node.expression) {
+      _addExpressionKeywords(node);
+    } else if (entity == node.rightBracket) {
+      if (node.members.isEmpty) {
+        _addSuggestions([Keyword.CASE, Keyword.DEFAULT], DART_RELEVANCE_HIGH);
+      } else {
+        _addSuggestions([Keyword.CASE, Keyword.DEFAULT]);
+        _addStatementKeywords(node);
+      }
+    }
+    if (node.members.contains(entity)) {
+      if (entity == node.members.first) {
+        _addSuggestions([Keyword.CASE, Keyword.DEFAULT], DART_RELEVANCE_HIGH);
+      } else {
+        _addSuggestions([Keyword.CASE, Keyword.DEFAULT]);
+        _addStatementKeywords(node);
+      }
+    }
+  }
+
+  @override
+  visitVariableDeclaration(VariableDeclaration node) {
+    if (entity == node.initializer) {
+      _addExpressionKeywords(node);
+    }
+  }
+
   void _addClassBodyKeywords() {
     _addSuggestions([
       Keyword.CONST,
       Keyword.DYNAMIC,
       Keyword.FACTORY,
       Keyword.FINAL,
       Keyword.GET,
       Keyword.OPERATOR,
       Keyword.SET,
       Keyword.STATIC,
@@ skipping 21 matching lines @@
       Keyword.CLASS,
       Keyword.CONST,
       Keyword.DYNAMIC,
       Keyword.FINAL,
       Keyword.TYPEDEF,
       Keyword.VAR,
       Keyword.VOID
     ], DART_RELEVANCE_HIGH);
   }
 
+  void _addExpressionKeywords(AstNode node) {
+    _addSuggestions([Keyword.FALSE, Keyword.NEW, Keyword.NULL, Keyword.TRUE,]);
+    if (_inClassMemberBody(node)) {
+      _addSuggestions([Keyword.SUPER, Keyword.THIS,]);
+    }
+    if (_inAsyncMethodOrFunction(node)) {
+      _addSuggestion2(AWAIT);
+    }
+  }
+
   void _addImportDirectiveKeywords(ImportDirective node) {
     if (node.asKeyword == null) {
       _addSuggestion(Keyword.AS, DART_RELEVANCE_HIGH);
       if (node.deferredKeyword == null) {
         _addSuggestion(Keyword.DEFERRED, DART_RELEVANCE_HIGH);
       }
     }
   }
 
   void _addStatementKeywords(AstNode node) {
     if (_inClassMemberBody(node)) {
       _addSuggestions([Keyword.SUPER, Keyword.THIS,]);
     }
     if (_inAsyncMethodOrFunction(node)) {
       _addSuggestion2(AWAIT);
     }
     _addSuggestions([
       Keyword.ASSERT,
-      Keyword.CASE,
       Keyword.CONTINUE,
       Keyword.DO,
       Keyword.FINAL,
       Keyword.FOR,
       Keyword.IF,
       Keyword.NEW,
       Keyword.RETHROW,
       Keyword.RETURN,
       Keyword.SWITCH,
       Keyword.THROW,
@@ skipping 35 matching lines @@
         return false;
       }
       AstNode parent = body.parent;
       if (parent is ConstructorDeclaration || parent is MethodDeclaration) {
         return true;
       }
       node = parent;
     }
   }
 }