anchor.diff:    ExpectedCompletion.specialCompletionString(
         this._entity, this._completionString, this._kind, this._elementKind);
   
  +  String get completion => _completionString ?? _entity.toString();
  +
  +  protocol.ElementKind get elementKind => _elementKind;
  +
  +  protocol.CompletionSuggestionKind get kind => _kind;
  +
  +  int get offset => _entity.offset;
  +
     SyntacticEntity get syntacticEntity => _entity;
  -
  -  String get completion => _completionString ?? _entity.toString();
  -
  -  int get offset => _entity.offset;
  -
  -  protocol.CompletionSuggestionKind get kind => _kind;
  -
  -  protocol.ElementKind get elementKind => _elementKind;
   
     bool matches(protocol.CompletionSuggestion completionSuggestion) {
       if (completionSuggestion.completion == completion) {
  
positive.code:     }
      return super.visitSimpleIdentifier(node);
    }
  }
  
  class ExpectedCompletion {
  
negative.code:     }
    }
  
    safelyRecordKeywordCompletion(SyntacticEntity entity) {
      safelyRecordEntity(entity, kind: protocol.CompletionSuggestionKind.KEYWORD);
    }
  
    @override
    visitAsExpression(AsExpression node) {
      safelyRecordKeywordCompletion(node.asOperator);
      return super.visitAsExpression(node);
    }
  
    @override
    visitAwaitExpression(AwaitExpression node) {
      safelyRecordKeywordCompletion(node.awaitKeyword);
      return super.visitAwaitExpression(node);
    }
  
    @override
    visitBlockFunctionBody(BlockFunctionBody node) {
      // 'async' | 'async' '*' | 'sync' '*':
      safelyRecordKeywordCompletion(node.keyword);
      return super.visitBlockFunctionBody(node);
    }
  
    @override
    visitBooleanLiteral(BooleanLiteral node) {
      // 'false' | 'true'
      safelyRecordKeywordCompletion(node.literal);
      return super.visitBooleanLiteral(node);
    }
  
    @override
    visitBreakStatement(BreakStatement node) {
      safelyRecordKeywordCompletion(node.breakKeyword);
      return super.visitBreakStatement(node);
    }
  
    @override
    visitCatchClause(CatchClause node) {
      // Should we 'catch', it won't be suggested when it already exists as a
      // keyword in the file?
      safelyRecordKeywordCompletion(node.catchKeyword);
      safelyRecordKeywordCompletion(node.onKeyword);
      return super.visitCatchClause(node);
    }
  
    @override
    visitClassDeclaration(ClassDeclaration node) {
      safelyRecordKeywordCompletion(node.abstractKeyword);
      safelyRecordKeywordCompletion(node.classKeyword);
      return super.visitClassDeclaration(node);
    }
  
    @override
    visitClassTypeAlias(ClassTypeAlias node) {
      safelyRecordKeywordCompletion(node.abstractKeyword);
      safelyRecordKeywordCompletion(node.typedefKeyword);
      return super.visitClassTypeAlias(node);
    }
  
    @override
    visitConfiguration(Configuration node) {
      safelyRecordKeywordCompletion(node.ifKeyword);
      return super.visitConfiguration(node);
    }
  
    @override
    visitConstructorDeclaration(ConstructorDeclaration node) {
      safelyRecordKeywordCompletion(node.externalKeyword);
      safelyRecordKeywordCompletion(node.constKeyword);
      safelyRecordKeywordCompletion(node.factoryKeyword);
      return super.visitConstructorDeclaration(node);
    }
  
    @override
    visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
      safelyRecordKeywordCompletion(node.thisKeyword);
      return super.visitConstructorFieldInitializer(node);
    }
  
    @override
    visitContinueStatement(ContinueStatement node) {
      safelyRecordKeywordCompletion(node.continueKeyword);
      return super.visitContinueStatement(node);
    }
  
    @override
    visitDeclaredIdentifier(DeclaredIdentifier node) {
      // 'final', 'const' or 'var'
      safelyRecordKeywordCompletion(node.keyword);
      return super.visitDeclaredIdentifier(node);
    }
  
    @override
    visitDoStatement(DoStatement node) {
      safelyRecordKeywordCompletion(node.doKeyword);
      safelyRecordKeywordCompletion(node.whileKeyword);
      return super.visitDoStatement(node);
    }
  
    @override
    visitEnumDeclaration(EnumDeclaration node) {
      safelyRecordKeywordCompletion(node.enumKeyword);
      return super.visitEnumDeclaration(node);
    }
  
    @override
    visitExportDirective(ExportDirective node) {
      safelyRecordKeywordCompletion(node.keyword);
      return super.visitExportDirective(node);
    }
  
    @override
    visitExpressionFunctionBody(ExpressionFunctionBody node) {
      safelyRecordKeywordCompletion(node.keyword);
      return super.visitExpressionFunctionBody(node);
    }
  
    @override
    visitExtendsClause(ExtendsClause node) {
      safelyRecordKeywordCompletion(node.extendsKeyword);
      return super.visitExtendsClause(node);
    }
  
    @override
    visitExtensionDeclaration(ExtensionDeclaration node) {
      safelyRecordKeywordCompletion(node.extensionKeyword);
      safelyRecordKeywordCompletion(node.onKeyword);
      return super.visitExtensionDeclaration(node);
    }
  
    @override
    visitExtensionOverride(ExtensionOverride node) {
      node.visitChildren(this);
      return null;
    }
  
    @override
    visitFieldDeclaration(FieldDeclaration node) {
      safelyRecordKeywordCompletion(node.covariantKeyword);
      safelyRecordKeywordCompletion(node.staticKeyword);
      return super.visitFieldDeclaration(node);
    }
  
    @override
    visitFieldFormalParameter(FieldFormalParameter node) {
      // 'final', 'const' or 'var'
      safelyRecordKeywordCompletion(node.keyword);
      safelyRecordKeywordCompletion(node.thisKeyword);
      return super.visitFieldFormalParameter(node);
    }
  
    @override
    visitForEachPartsWithDeclaration(ForEachPartsWithDeclaration node) {
      safelyRecordKeywordCompletion(node.inKeyword);
      return super.visitForEachPartsWithDeclaration(node);
    }
  
    @override
    visitForEachPartsWithIdentifier(ForEachPartsWithIdentifier node) {
      safelyRecordKeywordCompletion(node.inKeyword);
      return super.visitForEachPartsWithIdentifier(node);
    }
  
    @override
    visitForElement(ForElement node) {
      safelyRecordKeywordCompletion(node.awaitKeyword);
      safelyRecordKeywordCompletion(node.forKeyword);
      return super.visitForElement(node);
    }
  
    @override
    visitForStatement(ForStatement node) {
      safelyRecordKeywordCompletion(node.awaitKeyword);
      safelyRecordKeywordCompletion(node.forKeyword);
      return super.visitForStatement(node);
    }
  
    @override
    visitFunctionDeclaration(FunctionDeclaration node) {
      safelyRecordKeywordCompletion(node.externalKeyword);
      // 'get' or 'set':
      safelyRecordKeywordCompletion(node.propertyKeyword);
      return super.visitFunctionDeclaration(node);
    }
  
    @override
    visitFunctionTypeAlias(FunctionTypeAlias node) {
      safelyRecordKeywordCompletion(node.typedefKeyword);
      return super.visitFunctionTypeAlias(node);
    }
  
    @override
    visitGenericFunctionType(GenericFunctionType node) {
      safelyRecordKeywordCompletion(node.functionKeyword);
      return super.visitGenericFunctionType(node);
    }
  
    @override
    visitGenericTypeAlias(GenericTypeAlias node) {
      safelyRecordKeywordCompletion(node.typedefKeyword);
      return super.visitGenericTypeAlias(node);
    }
  
    @override
    visitHideCombinator(HideCombinator node) {
      safelyRecordKeywordCompletion(node.keyword);
      return super.visitHideCombinator(node);
    }
  
    @override
    visitIfElement(IfElement node) {
      safelyRecordKeywordCompletion(node.ifKeyword);
      safelyRecordKeywordCompletion(node.elseKeyword);
      return super.visitIfElement(node);
    }
  
    @override
    visitIfStatement(IfStatement node) {
      safelyRecordKeywordCompletion(node.ifKeyword);
      safelyRecordKeywordCompletion(node.elseKeyword);
      return super.visitIfStatement(node);
    }
  
    @override
    visitImplementsClause(ImplementsClause node) {
      safelyRecordKeywordCompletion(node.implementsKeyword);
      return super.visitImplementsClause(node);
    }
  
    @override
  