pkg/analysis_server/lib/src/services/completion/keyword_contributor.dart - sdk.git - Git at Google

 // 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';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/scanner.dart';

 const ASYNC = 'async';
 const AWAIT = 'await';

 /**
  * A contributor for calculating `completion.getSuggestions` request results
  * for the local library in which the completion is requested.
  */
 class KeywordContributor extends DartCompletionContributor {
   @override
   bool computeFast(DartCompletionRequest request) {
     request.target.containingNode.accept(new _KeywordVisitor(request));
     return true;
   }

   @override
   Future<bool> computeFull(DartCompletionRequest request) {
     return new Future.value(false);
   }
 }

 /**
  * A vistor for generating keyword suggestions.
  */
 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) {
     if (entity is ExpressionStatement) {
       Expression expression = (entity as ExpressionStatement).expression;
       if (expression is SimpleIdentifier) {
         Token token = expression.token;
         Token previous = token.previous;
         if (previous.isSynthetic) {
           previous = previous.previous;
         }
         Token next = token.next;
         if (next.isSynthetic) {
           next = next.next;
         }
         if (previous.lexeme == ')' && next.lexeme == '{') {
           _addSuggestion2(ASYNC);
         }
       }
     }
     _addStatementKeywords(node);
     if (_inCatchClause(node)) {
       _addSuggestion(Keyword.RETHROW, DART_RELEVANCE_KEYWORD - 1);
     }
   }

   @override
   visitClassDeclaration(ClassDeclaration node) {
     // Don't suggest class name
     if (entity == node.name) {
       return;
     }
     if (entity == node.rightBracket) {
       _addClassBodyKeywords();
     } else if (entity is ClassMember) {
       _addClassBodyKeywords();
       int index = node.members.indexOf(entity);
       ClassMember previous = index > 0 ? node.members[index - 1] : null;
       if (previous is MethodDeclaration && previous.body is EmptyFunctionBody) {
         _addSuggestion2(ASYNC);
       }
     } else {
       _addClassDeclarationKeywords(node);
     }
   }

   @override
   visitCompilationUnit(CompilationUnit node) {
     var previousMember = null;
     for (var member in node.childEntities) {
       if (entity == member) {
         break;
       }
       previousMember = member;
     }
     if (previousMember is ClassDeclaration) {
       if (previousMember.leftBracket == null ||
           previousMember.leftBracket.isSynthetic) {
         // If the prior member is an unfinished class declaration
         // then the user is probably finishing that
         _addClassDeclarationKeywords(previousMember);
         return;
       }
     }
     if (previousMember is ImportDirective) {
       if (previousMember.semicolon == null ||
           previousMember.semicolon.isSynthetic) {
         // If the prior member is an unfinished import directive
         // then the user is probably finishing that
         _addImportDirectiveKeywords(previousMember);
         return;
       }
     }
     if (previousMember == null || previousMember is Directive) {
       if (previousMember == null &&
           !node.directives.any((d) => d is LibraryDirective)) {
         _addSuggestions([Keyword.LIBRARY], DART_RELEVANCE_HIGH);
       }
       _addSuggestions(
           [Keyword.IMPORT, Keyword.EXPORT, Keyword.PART], DART_RELEVANCE_HIGH);
     }
     if (entity == null || entity is Declaration) {
       if (previousMember is FunctionDeclaration &&
           previousMember.functionExpression is FunctionExpression &&
           previousMember.functionExpression.body is EmptyFunctionBody) {
         _addSuggestion2(ASYNC, relevance: DART_RELEVANCE_HIGH);
       }
       _addCompilationUnitKeywords();
     }
   }

   @override
   visitExpression(Expression node) {
     _addExpressionKeywords(node);
   }

   @override
   visitExpressionFunctionBody(ExpressionFunctionBody node) {
     if (entity == node.expression) {
       _addExpressionKeywords(node);
     }
   }

   @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.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);
     if (constructorDecl != null) {
       _addSuggestions([Keyword.THIS]);
     }
   }

   @override
   visitForStatement(ForStatement node) {
     if (entity == node.rightSeparator && entity.toString() != ';') {
       // Handle the degenerate case while typing - for (int x i^)
       _addSuggestion(Keyword.IN, DART_RELEVANCE_HIGH);
     }
   }

   @override
   visitFunctionExpression(FunctionExpression node) {
     if (entity == node.body) {
       if (!node.body.isAsynchronous) {
         _addSuggestion2(ASYNC, relevance: DART_RELEVANCE_HIGH);
       }
       if (node.body is EmptyFunctionBody &&
           node.parent is FunctionDeclaration &&
           node.parent.parent is CompilationUnit) {
         _addCompilationUnitKeywords();
       }
     }
   }

   @override
   visitIfStatement(IfStatement node) {
     if (entity == node.thenStatement) {
       _addStatementKeywords(node);
     } else if (entity == node.condition) {
       _addExpressionKeywords(node);
     }
   }

   @override
   visitImportDirective(ImportDirective node) {
     if (entity == node.asKeyword) {
       if (node.deferredKeyword == null) {
         _addSuggestion(Keyword.DEFERRED, DART_RELEVANCE_HIGH);
       }
     }
     // Handle degenerate case where import statement does not have a semicolon
     // and the cursor is in the uri string
     if ((entity == node.semicolon &&
             node.uri != null &&
             node.uri.offset + 1 != request.offset) ||
         node.combinators.contains(entity)) {
       _addImportDirectiveKeywords(node);
     }
   }

   @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);
       } else {
         _addSuggestion2(ASYNC, relevance: DART_RELEVANCE_HIGH);
       }
     }
   }

   @override
   visitMethodInvocation(MethodInvocation node) {
     if (entity == node.methodName) {
       // no keywords in '.' expression
     } else {
       super.visitMethodInvocation(node);
     }
   }

   @override
   visitNamedExpression(NamedExpression node) {
     if (entity is SimpleIdentifier && entity == node.expression) {
       _addExpressionKeywords(node);
     }
   }

   @override
   visitNode(AstNode node) {
     // ignored
   }

   @override
   visitPrefixedIdentifier(PrefixedIdentifier node) {
     if (entity != node.identifier) {
       _addExpressionKeywords(node);
     }
   }

   @override
   visitPropertyAccess(PropertyAccess node) {
     // suggestions before '.' but not after
     if (entity != node.propertyName) {
       super.visitPropertyAccess(node);
     }
   }

   @override
   visitReturnStatement(ReturnStatement node) {
     if (entity == node.expression) {
       _addExpressionKeywords(node);
     }
   }

   @override
   visitStringLiteral(StringLiteral 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,
       Keyword.VAR,
       Keyword.VOID
     ]);
   }

   void _addClassDeclarationKeywords(ClassDeclaration node) {
     // Very simplistic suggestion because analyzer will warn if
     // the extends / with / implements keywords are out of order
     if (node.extendsClause == null) {
       _addSuggestion(Keyword.EXTENDS, DART_RELEVANCE_HIGH);
     } else if (node.withClause == null) {
       _addSuggestion(Keyword.WITH, DART_RELEVANCE_HIGH);
     }
     if (node.implementsClause == null) {
       _addSuggestion(Keyword.IMPLEMENTS, DART_RELEVANCE_HIGH);
     }
   }

   void _addCompilationUnitKeywords() {
     _addSuggestions([
       Keyword.ABSTRACT,
       Keyword.CLASS,
       Keyword.CONST,
       Keyword.DYNAMIC,
       Keyword.FINAL,
       Keyword.TYPEDEF,
       Keyword.VAR,
       Keyword.VOID
     ], DART_RELEVANCE_HIGH);
   }

   void _addExpressionKeywords(AstNode node) {
     _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;
     bool hasAsKeyword = node.asKeyword != null;
     if (!hasAsKeyword) {
       _addSuggestion(Keyword.AS, DART_RELEVANCE_HIGH);
     }
     if (!hasDeferredKeyword) {
       if (!hasAsKeyword) {
         _addSuggestion2('deferred as', relevance: DART_RELEVANCE_HIGH);
       } else if (entity == node.asKeyword) {
         _addSuggestion(Keyword.DEFERRED, DART_RELEVANCE_HIGH);
       }
     }
     if (!hasDeferredKeyword || hasAsKeyword) {
       if (node.combinators.isEmpty) {
         _addSuggestion2('show', relevance: DART_RELEVANCE_HIGH);
         _addSuggestion2('hide', relevance: DART_RELEVANCE_HIGH);
       }
     }
   }

   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.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
     ]);
   }

   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));
   }

   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 _inCatchClause(Block node) =>
       node.getAncestor((p) => p is CatchClause) != null;

   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;
 }
	// 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';
	import 'package:analyzer/src/generated/ast.dart';
	import 'package:analyzer/src/generated/scanner.dart';

	const ASYNC = 'async';
	const AWAIT = 'await';

	/**
	* A contributor for calculating `completion.getSuggestions` request results
	* for the local library in which the completion is requested.
	*/
	class KeywordContributor extends DartCompletionContributor {
	@override
	bool computeFast(DartCompletionRequest request) {
	request.target.containingNode.accept(new _KeywordVisitor(request));
	return true;
	}

	@override
	Future<bool> computeFull(DartCompletionRequest request) {
	return new Future.value(false);
	}
	}

	/**
	* A vistor for generating keyword suggestions.
	*/
	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) {
	if (entity is ExpressionStatement) {
	Expression expression = (entity as ExpressionStatement).expression;
	if (expression is SimpleIdentifier) {
	Token token = expression.token;
	Token previous = token.previous;
	if (previous.isSynthetic) {
	previous = previous.previous;
	}
	Token next = token.next;
	if (next.isSynthetic) {
	next = next.next;
	}
	if (previous.lexeme == ')' && next.lexeme == '{') {
	_addSuggestion2(ASYNC);
	}
	}
	}
	_addStatementKeywords(node);
	if (_inCatchClause(node)) {
	_addSuggestion(Keyword.RETHROW, DART_RELEVANCE_KEYWORD - 1);
	}
	}

	@override
	visitClassDeclaration(ClassDeclaration node) {
	// Don't suggest class name
	if (entity == node.name) {
	return;
	}
	if (entity == node.rightBracket) {
	_addClassBodyKeywords();
	} else if (entity is ClassMember) {
	_addClassBodyKeywords();
	int index = node.members.indexOf(entity);
	ClassMember previous = index > 0 ? node.members[index - 1] : null;
	if (previous is MethodDeclaration && previous.body is EmptyFunctionBody) {
	_addSuggestion2(ASYNC);
	}
	} else {
	_addClassDeclarationKeywords(node);
	}
	}

	@override
	visitCompilationUnit(CompilationUnit node) {
	var previousMember = null;
	for (var member in node.childEntities) {
	if (entity == member) {
	break;
	}
	previousMember = member;
	}
	if (previousMember is ClassDeclaration) {
	if (previousMember.leftBracket == null \|\|
	previousMember.leftBracket.isSynthetic) {
	// If the prior member is an unfinished class declaration
	// then the user is probably finishing that
	_addClassDeclarationKeywords(previousMember);
	return;
	}
	}
	if (previousMember is ImportDirective) {
	if (previousMember.semicolon == null \|\|
	previousMember.semicolon.isSynthetic) {
	// If the prior member is an unfinished import directive
	// then the user is probably finishing that
	_addImportDirectiveKeywords(previousMember);
	return;
	}
	}
	if (previousMember == null \|\| previousMember is Directive) {
	if (previousMember == null &&
	!node.directives.any((d) => d is LibraryDirective)) {
	_addSuggestions([Keyword.LIBRARY], DART_RELEVANCE_HIGH);
	}
	_addSuggestions(
	[Keyword.IMPORT, Keyword.EXPORT, Keyword.PART], DART_RELEVANCE_HIGH);
	}
	if (entity == null \|\| entity is Declaration) {
	if (previousMember is FunctionDeclaration &&
	previousMember.functionExpression is FunctionExpression &&
	previousMember.functionExpression.body is EmptyFunctionBody) {
	_addSuggestion2(ASYNC, relevance: DART_RELEVANCE_HIGH);
	}
	_addCompilationUnitKeywords();
	}
	}

	@override
	visitExpression(Expression node) {
	_addExpressionKeywords(node);
	}

	@override
	visitExpressionFunctionBody(ExpressionFunctionBody node) {
	if (entity == node.expression) {
	_addExpressionKeywords(node);
	}
	}

	@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.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);
	if (constructorDecl != null) {
	_addSuggestions([Keyword.THIS]);
	}
	}

	@override
	visitForStatement(ForStatement node) {
	if (entity == node.rightSeparator && entity.toString() != ';') {
	// Handle the degenerate case while typing - for (int x i^)
	_addSuggestion(Keyword.IN, DART_RELEVANCE_HIGH);
	}
	}

	@override
	visitFunctionExpression(FunctionExpression node) {
	if (entity == node.body) {
	if (!node.body.isAsynchronous) {
	_addSuggestion2(ASYNC, relevance: DART_RELEVANCE_HIGH);
	}
	if (node.body is EmptyFunctionBody &&
	node.parent is FunctionDeclaration &&
	node.parent.parent is CompilationUnit) {
	_addCompilationUnitKeywords();
	}
	}
	}

	@override
	visitIfStatement(IfStatement node) {
	if (entity == node.thenStatement) {
	_addStatementKeywords(node);
	} else if (entity == node.condition) {
	_addExpressionKeywords(node);
	}
	}

	@override
	visitImportDirective(ImportDirective node) {
	if (entity == node.asKeyword) {
	if (node.deferredKeyword == null) {
	_addSuggestion(Keyword.DEFERRED, DART_RELEVANCE_HIGH);
	}
	}
	// Handle degenerate case where import statement does not have a semicolon
	// and the cursor is in the uri string
	if ((entity == node.semicolon &&
	node.uri != null &&
	node.uri.offset + 1 != request.offset) \|\|
	node.combinators.contains(entity)) {
	_addImportDirectiveKeywords(node);
	}
	}

	@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);
	} else {
	_addSuggestion2(ASYNC, relevance: DART_RELEVANCE_HIGH);
	}
	}
	}

	@override
	visitMethodInvocation(MethodInvocation node) {
	if (entity == node.methodName) {
	// no keywords in '.' expression
	} else {
	super.visitMethodInvocation(node);
	}
	}

	@override
	visitNamedExpression(NamedExpression node) {
	if (entity is SimpleIdentifier && entity == node.expression) {
	_addExpressionKeywords(node);
	}
	}

	@override
	visitNode(AstNode node) {
	// ignored
	}

	@override
	visitPrefixedIdentifier(PrefixedIdentifier node) {
	if (entity != node.identifier) {
	_addExpressionKeywords(node);
	}
	}

	@override
	visitPropertyAccess(PropertyAccess node) {
	// suggestions before '.' but not after
	if (entity != node.propertyName) {
	super.visitPropertyAccess(node);
	}
	}

	@override
	visitReturnStatement(ReturnStatement node) {
	if (entity == node.expression) {
	_addExpressionKeywords(node);
	}
	}

	@override
	visitStringLiteral(StringLiteral 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,
	Keyword.VAR,
	Keyword.VOID
	]);
	}

	void _addClassDeclarationKeywords(ClassDeclaration node) {
	// Very simplistic suggestion because analyzer will warn if
	// the extends / with / implements keywords are out of order
	if (node.extendsClause == null) {
	_addSuggestion(Keyword.EXTENDS, DART_RELEVANCE_HIGH);
	} else if (node.withClause == null) {
	_addSuggestion(Keyword.WITH, DART_RELEVANCE_HIGH);
	}
	if (node.implementsClause == null) {
	_addSuggestion(Keyword.IMPLEMENTS, DART_RELEVANCE_HIGH);
	}
	}

	void _addCompilationUnitKeywords() {
	_addSuggestions([
	Keyword.ABSTRACT,
	Keyword.CLASS,
	Keyword.CONST,
	Keyword.DYNAMIC,
	Keyword.FINAL,
	Keyword.TYPEDEF,
	Keyword.VAR,
	Keyword.VOID
	], DART_RELEVANCE_HIGH);
	}

	void _addExpressionKeywords(AstNode node) {
	_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;
	bool hasAsKeyword = node.asKeyword != null;
	if (!hasAsKeyword) {
	_addSuggestion(Keyword.AS, DART_RELEVANCE_HIGH);
	}
	if (!hasDeferredKeyword) {
	if (!hasAsKeyword) {
	_addSuggestion2('deferred as', relevance: DART_RELEVANCE_HIGH);
	} else if (entity == node.asKeyword) {
	_addSuggestion(Keyword.DEFERRED, DART_RELEVANCE_HIGH);
	}
	}
	if (!hasDeferredKeyword \|\| hasAsKeyword) {
	if (node.combinators.isEmpty) {
	_addSuggestion2('show', relevance: DART_RELEVANCE_HIGH);
	_addSuggestion2('hide', relevance: DART_RELEVANCE_HIGH);
	}
	}
	}

	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.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
	]);
	}

	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));
	}

	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 _inCatchClause(Block node) =>
	node.getAncestor((p) => p is CatchClause) != null;

	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;
	}