Reorganize InheritedRefenenceContributor to serve angular completion

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/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 119 matching lines @@
 
   /**
    * 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].
+   * 
+   * Optionally, start the search from within [entryPoint] instead of using
+   * the [compilationUnit], which is useful for analyzing ASTs that have no
+   * [compilationUnit] such as dart expressions within angular templates.
    */
   factory CompletionTarget.forOffset(
-      CompilationUnit compilationUnit, int offset) {
+      CompilationUnit compilationUnit, int offset, {AstNode entryPoint}) {
     // The precise algorithm is as follows.  We perform a depth-first search of
     // all edges in the parse tree (both those that point to AST nodes and
     // those that point to tokens), visiting parents before children.  The
     // first edge which points to an entity satisfying either _isCandidateToken
     // or _isCandidateNode is the completion target.  If no edge is found that
     // satisfies these two predicates, then we set the completion target entity
-    // to null and the containingNode to the compilationUnit.
+    // to null and the containingNode to the entryPoint.
     //
     // Note that if a token is not a candidate target, then none of the tokens
     // that precede it are candidate targets either.  Therefore any entity
     // whose last token is not a candidate target can be skipped.  This lets us
     // prune the search to the point where no recursion is necessary; at each
     // step in the process we know exactly which child node we need to proceed
     // to.
-    AstNode containingNode = compilationUnit;
+    if (entryPoint == null) {
+      entryPoint = compilationUnit;
+    }

[Brian Wilkerson, 2016/12/09 17:15:19]

Or just "entryPoint ??= compilationUnit;" (in place of the 'if' statement).

+    AstNode containingNode = entryPoint;
     outerLoop: while (true) {
       if (containingNode is Comment) {
         // Comments are handled specially: we descend into any CommentReference
         // child node that contains the cursor offset.
         Comment comment = containingNode;
         for (CommentReference commentReference in comment.references) {
           if (commentReference.offset <= offset &&
               offset <= commentReference.end) {
             containingNode = commentReference;
             continue outerLoop;
@@ skipping 57 matching lines @@
           // 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));
+      // containingNode is still the entryPoint.
+      assert(identical(containingNode, entryPoint));
 
       // Since no completion target was found, we set the completion target
-      // entity to null and use the compilationUnit as the parent.
+      // entity to null and use the entryPoint as the parent.
       return new CompletionTarget._(
-          compilationUnit, offset, compilationUnit, null, false);
+          compilationUnit, offset, entryPoint, null, false);
     }
   }
 
   /**
    * Create a [CompletionTarget] holding the given [containingNode] and
    * [entity].
    */
   CompletionTarget._(this.unit, this.offset, AstNode containingNode,
       Object entity, this.isCommentText)
       : this.containingNode = containingNode,
@@ skipping 171 matching lines @@
       if (param.parameterKind == ParameterKind.NAMED) {
         // TODO(danrubel) handle named parameters
         return false;
       } else {
         return paramType is FunctionType || paramType is FunctionTypeAlias;
       }
     }
     return false;
   }
 }