Disable completion in comment text.

pkg/analysis_server/lib/src/provisional/completion/dart/completion_target.dart

 // Copyright (c) 2015, 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 analysis_server.src.provisional.completion.dart.completion_target;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
@@ skipping 85 matching lines @@
    *
    * Usually, the entity won't be the first child of the [containingNode] (this
    * is a consequence of placing the completion target as high in the tree as
    * possible).  However, there is one exception: when the cursor is inside of
    * a multi-character token which is not a keyword or identifier (e.g. a
    * comment, or a token like "+=", the entity will be always be the token.
    */
   final Object entity;
 
   /**
+   * The [entity] is a comment token, which is either not a documentation
+   * comment or the position is not in a [CommentReference].
+   */
+  final bool isCommentText;
+
+  /**
    * If the target is an argument in an [ArgumentList], then this is the index
    * of the argument in the list, otherwise this is `null`.
    */
   final int argIndex;
 
   /**
    * Compute the appropriate [CompletionTarget] for the given [offset] within
    * the [compilationUnit].
    */
   factory CompletionTarget.forOffset(
@@ skipping 22 matching lines @@
           if (commentReference.offset <= offset &&
               offset <= commentReference.end) {
             containingNode = commentReference;
             continue outerLoop;
           }
         }
       }
       for (var entity in containingNode.childEntities) {
         if (entity is Token) {
           if (_isCandidateToken(entity, offset)) {
+            // Try to replace with a comment token.
+            Token commentToken = _getContainingCommentToken(entity, offset);
+            if (commentToken != null) {
+              return new CompletionTarget._(containingNode, commentToken, true);
+            }
             // Target found.
-            return new CompletionTarget._(containingNode, entity);
+            return new CompletionTarget._(containingNode, entity, false);
           } else {
             // Since entity is a token, we don't need to look inside it; just
             // proceed to the next entity.
             continue;
           }
         } else if (entity is AstNode) {
           // If the last token in the node isn't a candidate target, then
           // neither the node nor any of its descendants can possibly be the
           // completion target, so we can skip the node entirely.
           if (!_isCandidateToken(entity.endToken, offset)) {
             continue;
           }
 
           // If the node is a candidate target, then we are done.
           if (_isCandidateNode(entity, offset)) {
-            // Check to see if the offset is in a preceeding comment
-            Token commentToken = _getContainingCommentToken(entity, offset);
+            // Check to see if the offset is in a preceding comment
+            Token commentToken =
+                _getContainingCommentToken(entity.beginToken, offset);
             if (commentToken != null) {
               entity = commentToken;
-              // If the preceeding comment is dartdoc token then update
-              // the containing node to be the dartdoc comment
+              // If the preceding comment is dartdoc token, then update
+              // the containing node to be the dartdoc comment.
+              // Otherwise completion is not required.
               Comment docComment =
                   _getContainingDocComment(containingNode, commentToken);
               if (docComment != null) {
                 containingNode = docComment;
+              } else {
+                return new CompletionTarget._(
+                    compilationUnit, commentToken, true);
               }
             }
-            return new CompletionTarget._(containingNode, entity);
+            return new CompletionTarget._(containingNode, entity, false);
           }
 
           // Otherwise, the completion target is somewhere inside the entity,
           // so we need to jump to the start of the outer loop to examine its
           // contents.
           containingNode = entity;
           continue outerLoop;
         } else {
           // Unexpected entity found (all entities in a parse tree should be
           // AST nodes or tokens).
           assert(false);
         }
       }
 
       // No completion target found.  It should only be possible to reach here
       // the first time through the outer loop (since we only jump to the start
       // of the outer loop after determining that the completion target is
       // inside an entity).  We can check that assumption by verifying that
       // containingNode is still the compilationUnit.
       assert(identical(containingNode, compilationUnit));
 
       // Since no completion target was found, we set the completion target
       // entity to null and use the compilationUnit as the parent.
-      return new CompletionTarget._(compilationUnit, null);
+      return new CompletionTarget._(compilationUnit, null, false);
     }
   }
 
   /**
    * Create a [CompletionTarget] holding the given [containingNode] and
    * [entity].
    */
-  CompletionTarget._(AstNode containingNode, Object entity)
+  CompletionTarget._(AstNode containingNode, Object entity, this.isCommentText)
       : this.containingNode = containingNode,
         this.entity = entity,
         this.argIndex = _computeArgIndex(containingNode, entity);
 
   /**
    * Return `true` if the target is a functional argument in an argument list.
    * The target [AstNode] hierarchy *must* be resolved for this to work.
    */
   bool isFunctionalArgument() {
     if (argIndex == null) {
@@ skipping 25 matching lines @@
           return _isFunctionalParameter(methodElem.parameters, argIndex);
         } else if (methodElem is FunctionElement) {
           return _isFunctionalParameter(methodElem.parameters, argIndex);
         }
       }
     }
     return false;
   }
 
   /**
-   * Determine if the offset is contained in a preceeding comment token
+   * Determine if the offset is contained in a preceding comment token
    * and return that token, otherwise return `null`.
    */
-  static Token _getContainingCommentToken(AstNode node, int offset) {
-    if (offset >= node.offset) {
-      return null;
-    }
-    Token token = node.beginToken;
+  static Token _getContainingCommentToken(Token token, int offset) {
     if (token == null) {
       return null;
     }
+    if (offset >= token.offset) {
+      return null;
+    }
     token = token.precedingComments;
     while (token != null) {
       if (offset <= token.offset) {
         return null;
       }
       if (offset <= token.end) {
         if (token.type == TokenType.SINGLE_LINE_COMMENT || offset < token.end) {
           return token;
         }
       }
@@ skipping 77 matching lines @@
       if (param.parameterKind == ParameterKind.NAMED) {
         // TODO(danrubel) handle named parameters
         return false;
       } else {
         return paramType is FunctionType || paramType is FunctionTypeAlias;
       }
     }
     return false;
   }
 }