next step toward completion plugin API

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 68 matching lines @@
  *
  * If the file is empty, or the cursor is after all the text in the file, then
  * there may be no edge in the parse tree which is appropriate to act as the
  * completion target; in this case, [entity] is set to null and
  * [containingNode] is set to the CompilationUnit.
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class CompletionTarget {
   /**
+   * The compilation unit in which the completion is occurring.
+   */
+  final CompilationUnit unit;
+
+  /**
    * The context in which the completion is occurring.  This is the AST node
    * which is a direct parent of [entity].
    */
   final AstNode containingNode;
 
   /**
    * The entity which the completed text will replace (or which will be
    * displaced once the completed text is inserted).  This may be an AstNode or
    * a Token, or it may be null if the cursor is after all tokens in the file.
    *
@@ skipping 50 matching lines @@
             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);
+              return new CompletionTarget._(
+                  compilationUnit, containingNode, commentToken, true);
             }
             // Target found.
-            return new CompletionTarget._(containingNode, entity, false);
+            return new CompletionTarget._(
+                compilationUnit, 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 preceding comment
             Token commentToken =
                 _getContainingCommentToken(entity.beginToken, offset);
             if (commentToken != null) {
               entity = commentToken;
               // 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);
+                    compilationUnit, compilationUnit, commentToken, true);
               }
             }
-            return new CompletionTarget._(containingNode, entity, false);
+            return new CompletionTarget._(
+                compilationUnit, 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, false);
+      return new CompletionTarget._(
+          compilationUnit, compilationUnit, null, false);
     }
   }
 
   /**
    * Create a [CompletionTarget] holding the given [containingNode] and
    * [entity].
    */
-  CompletionTarget._(AstNode containingNode, Object entity, this.isCommentText)
+  CompletionTarget._(
+      this.unit, 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 132 matching lines @@
       if (param.parameterKind == ParameterKind.NAMED) {
         // TODO(danrubel) handle named parameters
         return false;
       } else {
         return paramType is FunctionType || paramType is FunctionTypeAlias;
       }
     }
     return false;
   }
 }