improve keyword suggestions - fixes #24016

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 139 matching lines @@
   }
 
   @override
   visitForEachStatement(ForEachStatement node) {
     if (entity == node.inKeyword) {
       Token previous = node.inKeyword.previous;
       if (previous is SyntheticStringToken && previous.lexeme == 'in') {
         previous = previous.previous;
       }
       if (previous != null && previous.type == TokenType.EQ) {
-        _addSuggestions(
-            [Keyword.FALSE, Keyword.NEW, Keyword.NULL, Keyword.TRUE]);
+        _addSuggestions([
+          Keyword.CONST,
+          Keyword.FALSE,
+          Keyword.NEW,
+          Keyword.NULL,
+          Keyword.TRUE
+        ]);
       } else {
         _addSuggestion(Keyword.IN, DART_RELEVANCE_HIGH);
       }
     }
   }
 
   @override
   visitFormalParameterList(FormalParameterList node) {
     AstNode constructorDecl =
         node.getAncestor((p) => p is ConstructorDeclaration);
@@ skipping 53 matching lines @@
   @override
   visitInstanceCreationExpression(InstanceCreationExpression node) {
     if (entity == node.constructorName) {
       // no keywords in 'new ^' expression
     } else {
       super.visitInstanceCreationExpression(node);
     }
   }
 
   @override
+  visitIsExpression(IsExpression node) {
+    if (entity == node.isOperator) {
+      _addSuggestion(Keyword.IS, DART_RELEVANCE_HIGH);
+    } else {
+      _addExpressionKeywords(node);
+    }
+  }
+
+  @override
   visitLibraryIdentifier(LibraryIdentifier node) {
     // no suggestions
   }
 
   @override
   visitMethodDeclaration(MethodDeclaration node) {
     if (entity == node.body) {
       if (node.body is EmptyFunctionBody) {
         _addClassBodyKeywords();
         _addSuggestion2(ASYNC);
@@ skipping 115 matching lines @@
       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,]);
+    _addSuggestions([
+      Keyword.CONST,
+      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) {
     bool hasDeferredKeyword = node.deferredKeyword != null;
@@ skipping 16 matching lines @@
     }
   }
 
   void _addStatementKeywords(AstNode node) {
     if (_inClassMemberBody(node)) {
       _addSuggestions([Keyword.SUPER, Keyword.THIS,]);
     }
     if (_inAsyncMethodOrFunction(node)) {
       _addSuggestion2(AWAIT);
     }
+    if (_inLoop(node)) {
+      _addSuggestions([Keyword.BREAK, Keyword.CONTINUE]);
+    }
+    if (_inSwitch(node)) {
+      _addSuggestions([Keyword.BREAK]);
+    }
     _addSuggestions([
       Keyword.ASSERT,
-      Keyword.CONTINUE,
+      Keyword.CONST,
       Keyword.DO,
       Keyword.FINAL,
       Keyword.FOR,
       Keyword.IF,
       Keyword.NEW,
       Keyword.RETURN,
       Keyword.SWITCH,
       Keyword.THROW,
       Keyword.TRY,
       Keyword.VAR,
       Keyword.VOID,
       Keyword.WHILE
     ]);
     _addSuggestion(Keyword.RETHROW, DART_RELEVANCE_KEYWORD - 1);
   }
 
   void _addSuggestion(Keyword keyword,
       [int relevance = DART_RELEVANCE_KEYWORD]) {
     _addSuggestion2(keyword.syntax, relevance: relevance);
   }
 
   void _addSuggestion2(String completion,
       {int offset, int relevance: DART_RELEVANCE_KEYWORD}) {
     if (offset == null) {
       offset = completion.length;
     }
     request.addSuggestion(new CompletionSuggestion(
-        CompletionSuggestionKind.KEYWORD, relevance, completion, offset, 0,
-        false, false));
+        CompletionSuggestionKind.KEYWORD,
+        relevance,
+        completion,
+        offset,
+        0,
+        false,
+        false));
   }
 
   void _addSuggestions(List<Keyword> keywords,
       [int relevance = DART_RELEVANCE_KEYWORD]) {
     keywords.forEach((Keyword keyword) {
       _addSuggestion(keyword, relevance);
     });
   }
 
   bool _inAsyncMethodOrFunction(AstNode node) {
     FunctionBody body = node.getAncestor((n) => n is FunctionBody);
     return body != null && body.isAsynchronous;
   }
 
   bool _inClassMemberBody(AstNode node) {
     while (true) {
       AstNode body = node.getAncestor((n) => n is FunctionBody);
       if (body == null) {
         return false;
       }
       AstNode parent = body.parent;
       if (parent is ConstructorDeclaration || parent is MethodDeclaration) {
         return true;
       }
       node = parent;
     }
   }
+
+  bool _inDoLoop(AstNode node) =>
+      node.getAncestor((p) => p is DoStatement) != null;
+
+  bool _inForLoop(AstNode node) =>
+      node.getAncestor((p) => p is ForStatement || p is ForEachStatement) !=
+          null;
+
+  bool _inLoop(AstNode node) =>
+      _inDoLoop(node) || _inForLoop(node) || _inWhileLoop(node);
+
+  bool _inSwitch(AstNode node) =>
+      node.getAncestor((p) => p is SwitchStatement) != null;
+
+  bool _inWhileLoop(AstNode node) =>
+      node.getAncestor((p) => p is WhileStatement) != null;
 }