Clean up references in comments

pkg/analyzer/lib/src/generated/ast.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.ast;
 
 import 'dart:collection';
@@ skipping 512 matching lines @@
     _arguments.accept(visitor);
   }
 
   /**
    * If the given expression is a child of this list, and the AST structure has been resolved, and
    * the function being invoked is known based on propagated type information, and the expression
    * corresponds to one of the parameters of the function being invoked, then return the parameter
    * element representing the parameter to which the value of the given expression will be bound.
    * Otherwise, return `null`.
    *
-   * This method is only intended to be used by [Expression#getPropagatedParameterElement].
+   * This method is only intended to be used by [Expression.propagatedParameterElement].
    *
    * @param expression the expression corresponding to the parameter to be returned
    * @return the parameter element representing the parameter to which the value of the expression
    *         will be bound
    */
   ParameterElement getPropagatedParameterElementFor(Expression expression) {
     if (_correspondingPropagatedParameters == null) {
       // Either the AST structure has not been resolved or the invocation of which this list is a
       // part could not be resolved.
       return null;
     }
     int index = _arguments.indexOf(expression);
     if (index < 0) {
       // The expression isn't a child of this node.
       return null;
     }
     return _correspondingPropagatedParameters[index];
   }
 
   /**
    * If the given expression is a child of this list, and the AST structure has been resolved, and
    * the function being invoked is known based on static type information, and the expression
    * corresponds to one of the parameters of the function being invoked, then return the parameter
    * element representing the parameter to which the value of the given expression will be bound.
    * Otherwise, return `null`.
    *
-   * This method is only intended to be used by [Expression#getStaticParameterElement].
+   * This method is only intended to be used by [Expression.staticParameterElement].
    *
    * @param expression the expression corresponding to the parameter to be returned
    * @return the parameter element representing the parameter to which the value of the expression
    *         will be bound
    */
   ParameterElement getStaticParameterElementFor(Expression expression) {
     if (_correspondingStaticParameters == null) {
       // Either the AST structure has not been resolved or the invocation of which this list is a
       // part could not be resolved.
       return null;
@@ skipping 342 matching lines @@
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_leftHandSide, visitor);
     safelyVisitChild(_rightHandSide, visitor);
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on
    * propagated type information, then return the parameter element representing the parameter to
    * which the value of the right operand will be bound. Otherwise, return `null`.
    *
-   * This method is only intended to be used by [Expression#getPropagatedParameterElement].
+   * This method is only intended to be used by [Expression.propagatedParameterElement].
    *
    * @return the parameter element representing the parameter to which the value of the right
    *         operand will be bound
    */
   ParameterElement get propagatedParameterElementForRightHandSide {
     ExecutableElement executableElement = null;
     if (_propagatedElement != null) {
       executableElement = _propagatedElement;
     } else {
       if (_leftHandSide is Identifier) {
@@ skipping 19 matching lines @@
       return null;
     }
     return parameters[0];
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on static
    * type information, then return the parameter element representing the parameter to which the
    * value of the right operand will be bound. Otherwise, return `null`.
    *
-   * This method is only intended to be used by [Expression#getStaticParameterElement].
+   * This method is only intended to be used by [Expression.staticParameterElement].
    *
    * @return the parameter element representing the parameter to which the value of the right
    *         operand will be bound
    */
   ParameterElement get staticParameterElementForRightHandSide {
     ExecutableElement executableElement = null;
     if (_staticElement != null) {
       executableElement = _staticElement;
     } else {
       if (_leftHandSide is Identifier) {
@@ skipping 2349 matching lines @@
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_leftOperand, visitor);
     safelyVisitChild(_rightOperand, visitor);
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on
    * propagated type information, then return the parameter element representing the parameter to
    * which the value of the right operand will be bound. Otherwise, return `null`.
    *
-   * This method is only intended to be used by [Expression#getPropagatedParameterElement].
+   * This method is only intended to be used by [Expression.propagatedParameterElement].
    *
    * @return the parameter element representing the parameter to which the value of the right
    *         operand will be bound
    */
   ParameterElement get propagatedParameterElementForRightOperand {
     if (_propagatedElement == null) {
       return null;
     }
     List<ParameterElement> parameters = _propagatedElement.parameters;
     if (parameters.length < 1) {
       return null;
     }
     return parameters[0];
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on static
    * type information, then return the parameter element representing the parameter to which the
    * value of the right operand will be bound. Otherwise, return `null`.
    *
-   * This method is only intended to be used by [Expression#getStaticParameterElement].
+   * This method is only intended to be used by [Expression.staticParameterElement].
    *
    * @return the parameter element representing the parameter to which the value of the right
    *         operand will be bound
    */
   ParameterElement get staticParameterElementForRightOperand {
     if (_staticElement == null) {
       return null;
     }
     List<ParameterElement> parameters = _staticElement.parameters;
     if (parameters.length < 1) {
@@ skipping 2826 matching lines @@
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_parameter, visitor);
     safelyVisitChild(_defaultValue, visitor);
   }
 }
 
 /**
  * This recursive Ast visitor is used to run over [Expression]s to determine if the expression
  * is composed by at least one deferred [PrefixedIdentifier].
  *
- * @see PrefixedIdentifier#isDeferred()
+ * See [PrefixedIdentifier.isDeferred].
  */
 class DeferredLibraryReferenceDetector extends RecursiveAstVisitor<Object> {
   bool _result = false;
 
   /**
-   * Return the result, `true` if the visitor found a [PrefixedIdentifier] that returned
-   * `true` to the [PrefixedIdentifier#isDeferred] query.
-   *
-   * @return `true` if the visitor found a [PrefixedIdentifier] that returned
-   *         `true` to the [PrefixedIdentifier#isDeferred] query
+   * Return `true` if the visitor found a [PrefixedIdentifier] that returned
+   * `true` to the [PrefixedIdentifier.isDeferred] query.
    */
   bool get result => _result;
 
   @override
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     // If result is already true, skip.
     if (!_result) {
       // Set result to true if isDeferred() is true
       if (node.isDeferred) {
         _result = true;
@@ skipping 4214 matching lines @@
    */
   MethodElement get propagatedElement => _propagatedElement;
 
   /**
    * Return the expression used to compute the object being indexed. If this index expression is not
    * part of a cascade expression, then this is the same as [getTarget]. If this index
    * expression is part of a cascade expression, then the target expression stored with the cascade
    * expression is returned.
    *
    * @return the expression used to compute the object being indexed
-   * @see #getTarget()
+   * See [target].
    */
   Expression get realTarget {
     if (isCascaded) {
       AstNode ancestor = parent;
       while (ancestor is! CascadeExpression) {
         if (ancestor == null) {
           return _target;
         }
         ancestor = ancestor.parent;
       }
@@ skipping 17 matching lines @@
    *
    * @return the element associated with the operator
    */
   MethodElement get staticElement => _staticElement;
 
   /**
    * Return the expression used to compute the object being indexed, or `null` if this index
    * expression is part of a cascade expression.
    *
    * @return the expression used to compute the object being indexed
-   * @see #getRealTarget()
+   * See [realTarget].
    */
   Expression get target => _target;
 
   /**
    * Return `true` if this expression is computing a right-hand value.
    *
    * Note that [inGetterContext] and [inSetterContext] are not opposites, nor are
    * they mutually exclusive. In other words, it is possible for both methods to return `true`
    * when invoked on the same node.
    *
@@ skipping 104 matching lines @@
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_target, visitor);
     safelyVisitChild(_index, visitor);
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on
    * propagated type information, then return the parameter element representing the parameter to
    * which the value of the index expression will be bound. Otherwise, return `null`.
    *
-   * This method is only intended to be used by [Expression#getPropagatedParameterElement].
+   * This method is only intended to be used by [Expression.propagatedParameterElement].
    *
    * @return the parameter element representing the parameter to which the value of the index
    *         expression will be bound
    */
   ParameterElement get propagatedParameterElementForIndex {
     if (_propagatedElement == null) {
       return null;
     }
     List<ParameterElement> parameters = _propagatedElement.parameters;
     if (parameters.length < 1) {
       return null;
     }
     return parameters[0];
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on static
    * type information, then return the parameter element representing the parameter to which the
    * value of the index expression will be bound. Otherwise, return `null`.
    *
-   * This method is only intended to be used by [Expression#getStaticParameterElement].
+   * This method is only intended to be used by [Expression.staticParameterElement].
    *
    * @return the parameter element representing the parameter to which the value of the index
    *         expression will be bound
    */
   ParameterElement get staticParameterElementForIndex {
     if (_staticElement == null) {
       return null;
     }
     List<ParameterElement> parameters = _staticElement.parameters;
     if (parameters.length < 1) {
@@ skipping 1375 matching lines @@
   @override
   int get precedence => 15;
 
   /**
    * Return the expression used to compute the receiver of the invocation. If this invocation is not
    * part of a cascade expression, then this is the same as [getTarget]. If this invocation
    * is part of a cascade expression, then the target stored with the cascade expression is
    * returned.
    *
    * @return the expression used to compute the receiver of the invocation
-   * @see #getTarget()
+   * See [target].
    */
   Expression get realTarget {
     if (isCascaded) {
       AstNode ancestor = parent;
       while (ancestor is! CascadeExpression) {
         if (ancestor == null) {
           return _target;
         }
         ancestor = ancestor.parent;
       }
       return (ancestor as CascadeExpression).target;
     }
     return _target;
   }
 
   /**
    * Return the expression producing the object on which the method is defined, or `null` if
    * there is no target (that is, the target is implicitly `this`) or if this method
    * invocation is part of a cascade expression.
    *
    * @return the expression producing the object on which the method is defined
-   * @see #getRealTarget()
+   * See [realTarget].
    */
   Expression get target => _target;
 
   /**
    * Return `true` if this expression is cascaded. If it is, then the target of this
    * expression is not stored locally but is stored in the nearest ancestor that is a
    * [CascadeExpression].
    *
    * @return `true` if this expression is cascaded
    */
@@ skipping 2117 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_operand, visitor);
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on
    * propagated type information, then return the parameter element representing the parameter to
    * which the value of the operand will be bound. Otherwise, return `null`.
    *
-   * This method is only intended to be used by [Expression#getPropagatedParameterElement].
+   * This method is only intended to be used by [Expression.propagatedParameterElement].
    *
    * @return the parameter element representing the parameter to which the value of the right
    *         operand will be bound
    */
   ParameterElement get propagatedParameterElementForOperand {
     if (_propagatedElement == null) {
       return null;
     }
     List<ParameterElement> parameters = _propagatedElement.parameters;
     if (parameters.length < 1) {
       return null;
     }
     return parameters[0];
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on static
    * type information, then return the parameter element representing the parameter to which the
    * value of the operand will be bound. Otherwise, return `null`.
    *
-   * This method is only intended to be used by [Expression#getStaticParameterElement].
+   * This method is only intended to be used by [Expression.staticParameterElement].
    *
    * @return the parameter element representing the parameter to which the value of the right
    *         operand will be bound
    */
   ParameterElement get staticParameterElementForOperand {
     if (_staticElement == null) {
       return null;
     }
     List<ParameterElement> parameters = _staticElement.parameters;
     if (parameters.length < 1) {
@@ skipping 133 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_operand, visitor);
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on
    * propagated type information, then return the parameter element representing the parameter to
    * which the value of the operand will be bound. Otherwise, return `null`.
    *
-   * This method is only intended to be used by [Expression#getPropagatedParameterElement].
+   * This method is only intended to be used by [Expression.propagatedParameterElement].
    *
    * @return the parameter element representing the parameter to which the value of the right
    *         operand will be bound
    */
   ParameterElement get propagatedParameterElementForOperand {
     if (_propagatedElement == null) {
       return null;
     }
     List<ParameterElement> parameters = _propagatedElement.parameters;
     if (parameters.length < 1) {
       return null;
     }
     return parameters[0];
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on static
    * type information, then return the parameter element representing the parameter to which the
    * value of the operand will be bound. Otherwise, return `null`.
    *
-   * This method is only intended to be used by [Expression#getStaticParameterElement].
+   * This method is only intended to be used by [Expression.staticParameterElement].
    *
    * @return the parameter element representing the parameter to which the value of the right
    *         operand will be bound
    */
   ParameterElement get staticParameterElementForOperand {
     if (_staticElement == null) {
       return null;
     }
     List<ParameterElement> parameters = _staticElement.parameters;
     if (parameters.length < 1) {
@@ skipping 205 matching lines @@
    */
   SimpleIdentifier get propertyName => _propertyName;
 
   /**
    * Return the expression used to compute the receiver of the invocation. If this invocation is not
    * part of a cascade expression, then this is the same as [getTarget]. If this invocation
    * is part of a cascade expression, then the target stored with the cascade expression is
    * returned.
    *
    * @return the expression used to compute the receiver of the invocation
-   * @see #getTarget()
+   * See [target].
    */
   Expression get realTarget {
     if (isCascaded) {
       AstNode ancestor = parent;
       while (ancestor is! CascadeExpression) {
         if (ancestor == null) {
           return _target;
         }
         ancestor = ancestor.parent;
       }
       return (ancestor as CascadeExpression).target;
     }
     return _target;
   }
 
   /**
    * Return the expression computing the object defining the property being accessed, or
    * `null` if this property access is part of a cascade expression.
    *
    * @return the expression computing the object defining the property being accessed
-   * @see #getRealTarget()
+   * See [realTarget].
    */
   Expression get target => _target;
 
   @override
   bool get isAssignable => true;
 
   /**
    * Return `true` if this expression is cascaded. If it is, then the target of this
    * expression is not stored locally but is stored in the nearest ancestor that is a
    * [CascadeExpression].
@@ skipping 4925 matching lines @@
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_uri, visitor);
   }
 }
 
 /**
- * Validation codes returned by [UriBasedDirective#validate].
+ * Validation codes returned by [UriBasedDirective.validate].
  */
 class UriValidationCode extends Enum<UriValidationCode> {
   static const UriValidationCode INVALID_URI = const UriValidationCode('INVALID_URI', 0);
 
   static const UriValidationCode URI_WITH_INTERPOLATION = const UriValidationCode('URI_WITH_INTERPOLATION', 1);
 
   static const UriValidationCode URI_WITH_DART_EXT_SCHEME = const UriValidationCode('URI_WITH_DART_EXT_SCHEME', 2);
 
   static const List<UriValidationCode> values = const [
       INVALID_URI,
@@ skipping 674 matching lines @@
     _elements[index] = node;
   }
   void clear() {
     _elements = <E> [];
   }
   int get length => _elements.length;
   void set length(int value) {
     throw new UnsupportedError("Cannot resize NodeList.");
   }
 }