Improve nomenclature of new AnalysisContext async method.

pkg/analyzer/lib/src/generated/engine.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine;
 
 import "dart:math" as math;
@@ skipping 531 matching lines @@
    *
    * @param source the source whose line information is to be returned
    * @return the line information for the given source
    * @throws AnalysisException if the line information could not be determined because the analysis
    *           could not be performed
    * See [getLineInfo].
    */
   LineInfo computeLineInfo(Source source);
 
   /**
+   * Return a future which will be completed with the fully resolved AST for a
+   * single compilation unit within the given library, once that AST is up to
+   * date.
+   *
+   * If the resolved AST can't be computed for some reason, the future will be
+   * completed with an error.  One possible error is AnalysisNotScheduledError,
+   * which means that the resolved AST can't be computed because the given
+   * source file is not scheduled to be analyzed within the context of the
+   * given library.
+   */
+  CancelableFuture<CompilationUnit>
+      computeResolvedCompilationUnitAsync(Source source, Source librarySource);
+
+  /**
    * Notifies the context that the client is going to stop using this context.
    */
   void dispose();
 
   /**
    * Return `true` if the given source exists.
    *
    * This method should be used rather than the method [Source.exists] because contexts can
    * have local overrides of the content of a source that the source is not aware of and a source
    * with local content is considered to exist even if there is no file on disk.
@@ skipping 180 matching lines @@
    * @param unitSource the source of the compilation unit
    * @param librarySource the source of the defining compilation unit of the library containing the
    *          compilation unit
    * @return a fully resolved AST for the compilation unit
    * See [resolveCompilationUnit].
    */
   CompilationUnit getResolvedCompilationUnit2(Source unitSource,
       Source librarySource);
 
   /**
-   * Return a future which will be completed with the fully resolved AST for a
-   * single compilation unit within the given library, once that AST is up to
-   * date.
-   *
-   * If the resolved AST can't be computed for some reason, the future will be
-   * completed with an error.  One possible error is AnalysisNotScheduledError,
-   * which means that the resolved AST can't be computed because the given
-   * source file is not scheduled to be analyzed within the context of the
-   * given library.
-   */
-  CancelableFuture<CompilationUnit>
-      getResolvedCompilationUnitFuture(Source source, Source librarySource);
-
-  /**
    * Return a fully resolved HTML unit, or `null` if the resolved unit is not already
    * computed.
    *
    * @param htmlSource the source of the HTML unit
    * @return a fully resolved HTML unit
    * See [resolveHtmlUnit].
    */
   ht.HtmlUnit getResolvedHtmlUnit(Source htmlSource);
 
   /**
@@ skipping 955 matching lines @@
     dartEntry = _cacheDartParseData(source, dartEntry, DartEntry.PARSED_UNIT);
     CompilationUnit unit = dartEntry.resolvableCompilationUnit;
     if (unit == null) {
       throw new AnalysisException(
           "Internal error: computeResolvableCompilationUnit could not parse ${source.fullName}",
           new CaughtException(dartEntry.exception, null));
     }
     return unit;
   }
 
+  @override
+  CancelableFuture<CompilationUnit>
+      computeResolvedCompilationUnitAsync(Source unitSource, Source librarySource) {
+    return new _AnalysisFutureHelper<CompilationUnit>(
+        this).computeAsync(unitSource, (SourceEntry sourceEntry) {
+      if (sourceEntry is DartEntry) {
+        if (sourceEntry.getStateInLibrary(
+            DartEntry.RESOLVED_UNIT,
+            librarySource) ==
+            CacheState.ERROR) {
+          throw sourceEntry.exception;
+        }
+        return sourceEntry.getValueInLibrary(
+            DartEntry.RESOLVED_UNIT,
+            librarySource);
+      }
+      throw new AnalysisNotScheduledError();
+    });
+  }
+
   /**
    * Create an analysis cache based on the given source factory.
    *
    * @param factory the source factory containing the information needed to create the cache
    * @return the cache that was created
    */
   AnalysisCache createCacheFromSourceFactory(SourceFactory factory) {
     if (factory == null) {
       return new AnalysisCache(<CachePartition>[_privatePartition]);
     }
@@ skipping 324 matching lines @@
     SourceEntry sourceEntry = getReadableSourceEntryOrNull(unitSource);
     if (sourceEntry is DartEntry) {
       return sourceEntry.getValueInLibrary(
           DartEntry.RESOLVED_UNIT,
           librarySource);
     }
     return null;
   }
 
   @override
-  CancelableFuture<CompilationUnit>
-      getResolvedCompilationUnitFuture(Source unitSource, Source librarySource) {
-    return new _AnalysisFutureHelper<CompilationUnit>(
-        this).getFuture(unitSource, (SourceEntry sourceEntry) {
-      if (sourceEntry is DartEntry) {
-        if (sourceEntry.getStateInLibrary(
-            DartEntry.RESOLVED_UNIT,
-            librarySource) ==
-            CacheState.ERROR) {
-          throw sourceEntry.exception;
-        }
-        return sourceEntry.getValueInLibrary(
-            DartEntry.RESOLVED_UNIT,
-            librarySource);
-      }
-      throw new AnalysisNotScheduledError();
-    });
-  }
-
-  @override
   ht.HtmlUnit getResolvedHtmlUnit(Source htmlSource) {
     SourceEntry sourceEntry = getReadableSourceEntryOrNull(htmlSource);
     if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       return htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT);
     }
     return null;
   }
 
   @override
@@ skipping 12230 matching lines @@
    * exception, the future will fail with that exception.
    *
    * If the [computeValue] still returns null after there is no further
    * analysis to be done for [source], then the future will be completed with
    * the error AnalysisNotScheduledError.
    *
    * Since [computeValue] will be called while the state of analysis is being
    * updated, it should be free of side effects so that it doesn't cause
    * reentrant changes to the analysis state.
    */
-  CancelableFuture<T> getFuture(Source source, T
+  CancelableFuture<T> computeAsync(Source source, T
       computeValue(SourceEntry sourceEntry)) {
     SourceEntry sourceEntry = _context.getReadableSourceEntryOrNull(source);
     if (sourceEntry == null) {
       return new CancelableFuture.error(new AnalysisNotScheduledError());
     }
     PendingFuture pendingFuture =
         new PendingFuture<T>(_context, source, computeValue);
     if (!pendingFuture.evaluate(sourceEntry)) {
       _context._pendingFutureSources.putIfAbsent(
           source,
@@ skipping 48 matching lines @@
 
   @override
   Object visitPolymerTagDartElement(PolymerTagDartElement element) {
     if (element.name == PolymerHtmlUnitBuilder_this._elementName) {
       throw new PolymerHtmlUnitBuilder_FoundTagDartElementError(
           element as PolymerTagDartElementImpl);
     }
     return null;
   }
 }