Incremental resolution of updated DartDoc comments.

pkg/analyzer/lib/src/generated/resolver.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 engine.resolver;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'ast.dart';
@@ skipping 11059 matching lines @@
    * The object keeping track of which elements have had their types overridden.
    */
   TypeOverrideManager _overrideManager = new TypeOverrideManager();
 
   /**
    * The object keeping track of which elements have had their types promoted.
    */
   TypePromotionManager _promoteManager = new TypePromotionManager();
 
   /**
+   * A comment before a function should be resolved in the context of the
+   * function. But when we incrementally resolve a comment, we don't want to
+   * resolve the whole function.
+   *
+   * So, this flag is set to `true`, when just context of the function should
+   * be built and the comment resolved.
+   */
+  bool resolveOnlyCommentInFunctionBody = false;
+
+  /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
   ResolverVisitor.con1(Library library, Source source,
       TypeProvider typeProvider)
       : super.con1(library, source, typeProvider) {
     this._inheritanceManager = library.inheritanceManager;
@@ skipping 409 matching lines @@
   Object visitCommentReference(CommentReference node) {
     //
     // We do not visit the identifier because it needs to be visited in the
     // context of the reference.
     //
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
 
+  /**
+   * Prepares this [ResolverVisitor] to using it for incremental resolution.
+   */
+  void initForIncrementalResolution() {
+    _overrideManager.enterScope();
+  }
+
   @override
   Object visitCompilationUnit(CompilationUnit node) {
     //
     // TODO(brianwilkerson) The goal of the code below is to visit the
     // declarations in such an order that we can infer type information for
     // top-level variables before we visit references to them. This is better
     // than making no effort, but still doesn't completely satisfy that goal
     // (consider for example "final var a = b; final var b = 0;"; we'll infer a
     // type of 'int' for 'b', but not for 'a' because of the order of the
     // visits). Ideally we would create a dependency graph, but that would
@@ skipping 133 matching lines @@
       _overrideManager.exitScope();
     }
     // TODO(brianwilkerson) If the loop can only be exited because the condition
     // is false, then propagateFalseState(node.getCondition());
     return null;
   }
 
   @override
   Object visitEmptyFunctionBody(EmptyFunctionBody node) {
     safelyVisit(_commentBeforeFunction);
+    if (resolveOnlyCommentInFunctionBody) {
+      return null;
+    }
     return super.visitEmptyFunctionBody(node);
   }
 
   @override
   Object visitEnumDeclaration(EnumDeclaration node) {
     //
     // Resolve the metadata in the library scope.
     //
     if (node.metadata != null) {
       node.metadata.accept(this);
     }
     //
     // There is nothing else to do because everything else was resolved by the
     // element builder.
     //
     return null;
   }
 
   @override
   Object visitExpressionFunctionBody(ExpressionFunctionBody node) {
     safelyVisit(_commentBeforeFunction);
+    if (resolveOnlyCommentInFunctionBody) {
+      return null;
+    }
     _overrideManager.enterScope();
     try {
       super.visitExpressionFunctionBody(node);
     } finally {
       _overrideManager.exitScope();
     }
     return null;
   }
 
   @override
@@ skipping 4593 matching lines @@
    * library.
    */
   final HashSet<String> members = new HashSet<String>();
 
   /**
    * Names of resolved or unresolved class members that are read in the
    * library.
    */
   final HashSet<String> readMembers = new HashSet<String>();
 }