fix exception and improve keyword completion

pkg/analysis_server/lib/src/services/completion/keyword_computer.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.computer.dart.keyword;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol.dart';
 import 'package:analysis_server/src/services/completion/dart_completion_manager.dart';
@@ skipping 17 matching lines @@
     return new Future.value(false);
   }
 }
 
 /**
  * A vistor for generating keyword suggestions.
  */
 class _KeywordVisitor extends GeneralizingAstVisitor {
   final DartCompletionRequest request;
 
+  /**
+   * The identifier visited or `null` if not visited.
+   */
+  SimpleIdentifier identifier;
+
   _KeywordVisitor(this.request);
 
   @override
   visitBlock(Block node) {
-    if (_isOffsetAfterNode(node)) {
-      node.parent.accept(this);
-    } else {
-      _addSuggestions(
-          [
-              Keyword.ASSERT,
-              Keyword.CASE,
-              Keyword.CONTINUE,
-              Keyword.DO,
-              Keyword.FACTORY,
-              Keyword.FINAL,
-              Keyword.FOR,
-              Keyword.IF,
-              Keyword.NEW,
-              Keyword.RETHROW,
-              Keyword.RETURN,
-              Keyword.SUPER,
-              Keyword.SWITCH,
-              Keyword.THIS,
-              Keyword.THROW,
-              Keyword.TRY,
-              Keyword.VAR,
-              Keyword.VOID,
-              Keyword.WHILE]);
-    }
+    _addSuggestions(
+        [
+            Keyword.ASSERT,
+            Keyword.CASE,
+            Keyword.CONTINUE,
+            Keyword.DO,
+            Keyword.FACTORY,
+            Keyword.FINAL,
+            Keyword.FOR,
+            Keyword.IF,
+            Keyword.NEW,
+            Keyword.RETHROW,
+            Keyword.RETURN,
+            Keyword.SUPER,
+            Keyword.SWITCH,
+            Keyword.THIS,
+            Keyword.THROW,
+            Keyword.TRY,
+            Keyword.VAR,
+            Keyword.VOID,
+            Keyword.WHILE]);
   }
 
   @override
   visitClassDeclaration(ClassDeclaration node) {
+    // Don't suggest class name
+    if (node.name == identifier) {
+      return;
+    }
     // Inside the class declaration { }
     if (request.offset > node.leftBracket.offset) {
       _addSuggestions(
           [
               Keyword.CONST,
               Keyword.DYNAMIC,
               Keyword.FACTORY,
               Keyword.FINAL,
               Keyword.GET,
               Keyword.OPERATOR,
               Keyword.SET,
               Keyword.STATIC,
               Keyword.VAR,
               Keyword.VOID]);
       return;
     }
-    // Very simplistic suggestion because analyzer will warn if
-    // the extends / with / implements keywords are out of order
-    if (node.extendsClause == null) {
-      _addSuggestion(Keyword.EXTENDS, COMPLETION_RELEVANCE_HIGH);
-    } else if (node.withClause == null) {
-      _addSuggestion(Keyword.WITH, COMPLETION_RELEVANCE_HIGH);
-    }
-    if (node.implementsClause == null) {
-      _addSuggestion(Keyword.IMPLEMENTS, COMPLETION_RELEVANCE_HIGH);
-    }
+    _addClassDeclarationKeywords(node);
   }
 
   @override
   visitCompilationUnit(CompilationUnit node) {
     Directive firstDirective;
     int endOfDirectives = 0;
     if (node.directives.length > 0) {
       firstDirective = node.directives[0];
       endOfDirectives = node.directives.last.end - 1;
     }
@@ skipping 40 matching lines @@
   }
 
   @override
   visitNode(AstNode node) {
     if (_isOffsetAfterNode(node)) {
       node.parent.accept(this);
     }
   }
 
   visitSimpleIdentifier(SimpleIdentifier node) {
-    AstNode parent = node.getAncestor((n) => n is TopLevelVariableDeclaration);
-    if (parent is TopLevelVariableDeclaration) {
-      if (parent.variables != null &&
-          parent.variables.type != null &&
-          parent.variables.type.name == node) {
-        AstNode unit = node.getAncestor((n) => n is CompilationUnit);
-        if (unit is CompilationUnit) {
-          visitCompilationUnit(unit);
+    identifier = node;
+    node.parent.accept(this);
+  }
+
+  void visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
+    if (identifier != null && node.beginToken == identifier.beginToken) {
+      AstNode unit = node.parent;
+      if (unit is CompilationUnit) {
+        CompilationUnitMember previous;
+        for (CompilationUnitMember member in unit.declarations) {
+          if (member == node && previous is ClassDeclaration) {
+            if (previous.endToken.isSynthetic) {
+              // Partial keywords (simple identifirs) that are part of a
+              // class declaration can be parsed
+              // as a TypeName in a TopLevelVariableDeclaration
+              _addClassDeclarationKeywords(previous);
+              return;
+            }
+          }
+          previous = member;
         }
+        // Partial keywords (simple identifiers) can be parsed
+        // as a TypeName in a TopLevelVariableDeclaration
+        unit.accept(this);
       }
     }
   }
 
+  void visitTypeName(TypeName node) {
+    node.parent.accept(this);
+  }
+
+  void visitVariableDeclarationList(VariableDeclarationList node) {
+    node.parent.accept(this);
+  }
+
+  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, COMPLETION_RELEVANCE_HIGH);
+    } else if (node.withClause == null) {
+      _addSuggestion(Keyword.WITH, COMPLETION_RELEVANCE_HIGH);
+    }
+    if (node.implementsClause == null) {
+      _addSuggestion(Keyword.IMPLEMENTS, COMPLETION_RELEVANCE_HIGH);
+    }
+  }
+
   void _addSuggestion(Keyword keyword, [int relevance =
       COMPLETION_RELEVANCE_DEFAULT]) {
     String completion = keyword.syntax;
     request.suggestions.add(
         new CompletionSuggestion(
             CompletionSuggestionKind.KEYWORD,
             relevance,
             completion,
             completion.length,
             0,
@@ skipping 13 matching lines @@
       Token token = node.endToken;
       if (token != null && !token.isSynthetic) {
         if (token.lexeme == ';' || token.lexeme == '}') {
           return true;
         }
       }
     }
     return false;
   }
 }