Clean up references in comments

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:collection';
@@ skipping 318 matching lines @@
    * Return an array containing all of the errors associated with the given source. If the errors
    * are not already known then the source will be analyzed in order to determine the errors
    * associated with it.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source whose errors are to be returned
    * @return all of the errors associated with the given source
    * @throws AnalysisException if the errors could not be determined because the analysis could not
    *           be performed
-   * @see #getErrors(Source)
+   * See [getErrors].
    */
   List<AnalysisError> computeErrors(Source source);
 
   /**
    * Return the element model corresponding to the HTML file defined by the given source. If the
    * element model does not yet exist it will be created. The process of creating an element model
    * for an HTML file can be long-running, depending on the size of the file and the number of
    * libraries that are defined in it (via script tags) that also need to have a model built for
    * them.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source defining the HTML file whose element model is to be returned
    * @return the element model corresponding to the HTML file defined by the given source
    * @throws AnalysisException if the element model could not be determined because the analysis
    *           could not be performed
-   * @see #getHtmlElement(Source)
+   * See [getHtmlElement].
    */
   HtmlElement computeHtmlElement(Source source);
 
   /**
    * Return the kind of the given source, computing it's kind if it is not already known. Return
    * [SourceKind.UNKNOWN] if the source is not contained in this context.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source whose kind is to be returned
    * @return the kind of the given source
-   * @see #getKindOf(Source)
+   * See [getKindOf].
    */
   SourceKind computeKindOf(Source source);
 
   /**
    * Return the element model corresponding to the library defined by the given source. If the
    * element model does not yet exist it will be created. The process of creating an element model
    * for a library can long-running, depending on the size of the library and the number of
    * libraries that are imported into it that also need to have a model built for them.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source defining the library whose element model is to be returned
    * @return the element model corresponding to the library defined by the given source
    * @throws AnalysisException if the element model could not be determined because the analysis
    *           could not be performed
-   * @see #getLibraryElement(Source)
+   * See [getLibraryElement].
    */
   LibraryElement computeLibraryElement(Source source);
 
   /**
    * Return the line information for the given source, or `null` if the source is not of a
    * recognized kind (neither a Dart nor HTML file). If the line information was not previously
    * known it will be created. The line information is used to map offsets from the beginning of the
    * source to line and column pairs.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @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(Source)
+   * See [getLineInfo].
    */
   LineInfo computeLineInfo(Source source);
 
   /**
    * Notifies the context that the client is going to stop using this context.
    */
   void dispose();
 
   /**
    * Return `true` if the given source exists.
@@ skipping 70 matching lines @@
   Element getElement(ElementLocation location);
 
   /**
    * Return an analysis error info containing the array of all of the errors and the line info
    * associated with the given source. The array of errors will be empty if the source is not known
    * to this context or if there are no errors in the source. The errors contained in the array can
    * be incomplete.
    *
    * @param source the source whose errors are to be returned
    * @return all of the errors associated with the given source and the line info
-   * @see #computeErrors(Source)
+   * See [computeErrors].
    */
   AnalysisErrorInfo getErrors(Source source);
 
   /**
    * Return the element model corresponding to the HTML file defined by the given source, or
    * `null` if the source does not represent an HTML file, the element representing the file
    * has not yet been created, or the analysis of the HTML file failed for some reason.
    *
    * @param source the source defining the HTML file whose element model is to be returned
    * @return the element model corresponding to the HTML file defined by the given source
-   * @see #computeHtmlElement(Source)
+   * See [computeHtmlElement].
    */
   HtmlElement getHtmlElement(Source source);
 
   /**
    * Return the sources for the HTML files that reference the given compilation unit. If the source
    * does not represent a Dart source or is not known to this context, the returned array will be
    * empty. The contents of the array can be incomplete.
    *
    * @param source the source referenced by the returned HTML files
    * @return the sources for the HTML files that reference the given compilation unit
    */
   List<Source> getHtmlFilesReferencing(Source source);
 
   /**
    * Return an array containing all of the sources known to this context that represent HTML files.
    * The contents of the array can be incomplete.
    *
    * @return the sources known to this context that represent HTML files
    */
   List<Source> get htmlSources;
 
   /**
    * Return the kind of the given source, or `null` if the kind is not known to this context.
    *
    * @param source the source whose kind is to be returned
    * @return the kind of the given source
-   * @see #computeKindOf(Source)
+   * See [computeKindOf].
    */
   SourceKind getKindOf(Source source);
 
   /**
    * Return an array containing all of the sources known to this context that represent the defining
    * compilation unit of a library that can be run within a browser. The sources that are returned
    * represent libraries that have a 'main' method and are either referenced by an HTML file or
    * import, directly or indirectly, a client-only library. The contents of the array can be
    * incomplete.
    *
@@ skipping 64 matching lines @@
    */
   List<Source> get librarySources;
 
   /**
    * Return the line information for the given source, or `null` if the line information is
    * not known. The line information is used to map offsets from the beginning of the source to line
    * and column pairs.
    *
    * @param source the source whose line information is to be returned
    * @return the line information for the given source
-   * @see #computeLineInfo(Source)
+   * See [computeLineInfo].
    */
   LineInfo getLineInfo(Source source);
 
   /**
    * Return the modification stamp for the given source. A modification stamp is a non-negative
    * integer with the property that if the contents of the source have not been modified since the
    * last time the modification stamp was accessed then the same value will be returned, but if the
    * contents of the source have been modified one or more times (even if the net change is zero)
    * the stamps will be different.
    *
@@ skipping 14 matching lines @@
    */
   List<Source> get refactoringUnsafeSources;
 
   /**
    * Return a fully resolved AST for a single compilation unit within the given library, or
    * `null` if the resolved AST is not already computed.
    *
    * @param unitSource the source of the compilation unit
    * @param library the library containing the compilation unit
    * @return a fully resolved AST for the compilation unit
-   * @see #resolveCompilationUnit(Source, LibraryElement)
+   * See [resolveCompilationUnit].
    */
   CompilationUnit getResolvedCompilationUnit(Source unitSource, LibraryElement library);
 
   /**
    * Return a fully resolved AST for a single compilation unit within the given library, or
    * `null` if the resolved AST is not already computed.
    *
    * @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(Source, Source)
+   * See [resolveCompilationUnit].
    */
   CompilationUnit getResolvedCompilationUnit2(Source unitSource, 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(Source)
+   * See [resolveHtmlUnit].
    */
   ht.HtmlUnit getResolvedHtmlUnit(Source htmlSource);
 
   /**
    * Return the source factory used to create the sources that can be analyzed in this context.
    *
    * @return the source factory used to create the sources that can be analyzed in this context
    */
   SourceFactory get sourceFactory;
 
@@ skipping 77 matching lines @@
   /**
    * Parse and resolve a single source within the given context to produce a fully resolved AST.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param unitSource the source to be parsed and resolved
    * @param library the library containing the source to be resolved
    * @return the result of resolving the AST structure representing the content of the source in the
    *         context of the given library
    * @throws AnalysisException if the analysis could not be performed
-   * @see #getResolvedCompilationUnit(Source, LibraryElement)
+   * See [getResolvedCompilationUnit].
    */
   CompilationUnit resolveCompilationUnit(Source unitSource, LibraryElement library);
 
   /**
    * Parse and resolve a single source within the given context to produce a fully resolved AST.
    * Return the resolved AST structure, or `null` if the source could not be either parsed or
    * resolved.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param unitSource the source to be parsed and resolved
    * @param librarySource the source of the defining compilation unit of the library containing the
    *          source to be resolved
    * @return the result of resolving the AST structure representing the content of the source in the
    *         context of the given library
    * @throws AnalysisException if the analysis could not be performed
-   * @see #getResolvedCompilationUnit(Source, Source)
+   * See [getResolvedCompilationUnit].
    */
   CompilationUnit resolveCompilationUnit2(Source unitSource, Source librarySource);
 
   /**
    * Parse and resolve a single source within the given context to produce a fully resolved AST.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param htmlSource the source to be parsed and resolved
    * @return the result of resolving the AST structure representing the content of the source
@@ skipping 1395 matching lines @@
       Source source = iterator.key;
       if (container.contains(source)) {
         sources.add(source);
       }
     }
   }
 
   /**
    * Given a source for a Dart file and the library that contains it, return a cache entry in which
    * the state of the data represented by the given descriptor is either [CacheState.VALID] or
-   * [CacheState#ERROR]. This method assumes that the data can be produced by generating hints
+   * [CacheStateERROR]. This method assumes that the data can be produced by generating hints
    * for the library if the data is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be parsed
@@ skipping 7034 matching lines @@
     _writeStateOn(buffer, "angularErrors", ANGULAR_ERRORS);
     _writeStateOn(buffer, "polymerBuildErrors", POLYMER_BUILD_ERRORS);
     _writeStateOn(buffer, "polymerResolutionErrors", POLYMER_RESOLUTION_ERRORS);
   }
 }
 
 /**
  * Instances of the class `IncrementalAnalysisCache` hold information used to perform
  * incremental analysis.
  *
- * @see AnalysisContextImpl.setChangedContents(Source, String, int, int, int)
+ * See [AnalysisContextImpl.setChangedContents].
  */
 class IncrementalAnalysisCache {
   /**
    * Determine if the incremental analysis result can be cached for the next incremental analysis.
    *
    * @param cache the prior incremental analysis cache
    * @param unit the incrementally updated compilation unit
    * @return the cache used for incremental analysis or `null` if incremental analysis results
    *         cannot be cached for the next incremental analysis
    */
@@ skipping 4292 matching lines @@
     _index++;
     if (_index >= _manager._workQueues[_queueIndex].length) {
       _index = 0;
       _queueIndex++;
       while (_queueIndex < _manager._workQueues.length && _manager._workQueues[_queueIndex].isEmpty) {
         _queueIndex++;
       }
     }
   }
 }