Clean up references in comments

pkg/analyzer/lib/src/generated/element.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.element;
 
 import 'dart:collection';
@@ skipping 3858 matching lines @@
       int currentChar = component.codeUnitAt(i);
       if (currentChar == _SEPARATOR_CHAR) {
         buffer.writeCharCode(_SEPARATOR_CHAR);
       }
       buffer.writeCharCode(currentChar);
     }
   }
 }
 
 /**
- * The class `ElementPair` is a pair of [Element]s. [Object#equals] and
- * [Object#hashCode] so this class can be used in hashed data structures.
+ * The class `ElementPair` is a pair of [Element]s. [Object.==] and
+ * [Object.hashCode] so this class can be used in hashed data structures.
  */
 class ElementPair {
   /**
    * The first [Element]
    */
   final Element _first;
 
   /**
    * The second [Element]
    */
@@ skipping 2343 matching lines @@
   }
 
   @override
   String get identifier => source.encoding;
 }
 
 /**
  * The interface `HtmlScriptElement` defines the behavior of elements representing a script
  * tag in an HTML file.
  *
- * @see EmbeddedHtmlScriptElement
- * @see ExternalHtmlScriptElement
+ * See [EmbeddedHtmlScriptElement], and [ExternalHtmlScriptElement],
  */
 abstract class HtmlScriptElement implements Element {
 }
 
 /**
  * Instances of the class `HtmlScriptElementImpl` implement an [HtmlScriptElement].
  */
 abstract class HtmlScriptElementImpl extends ElementImpl implements HtmlScriptElement {
   /**
    * An empty array of HTML script elements.
@@ skipping 425 matching lines @@
  * representing the type introduced by either a class or an interface, or a reference to such a
  * type.
  */
 class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
   /**
    * This method computes the longest inheritance path from some passed [Type] to Object.
    *
    * @param type the [Type] to compute the longest inheritance path of from the passed
    *          [Type] to Object
    * @return the computed longest inheritance path to Object
-   * @see InterfaceType#getLeastUpperBound(Type)
+   * See [InterfaceType.getLeastUpperBound].
    */
   static int computeLongestInheritancePathToObject(InterfaceType type) => _computeLongestInheritancePathToObject(type, 0, new HashSet<ClassElement>());
 
   /**
    * Returns the set of all superinterfaces of the passed [Type].
    *
    * @param type the [Type] to compute the set of superinterfaces of
    * @return the [Set] of superinterfaces of the passed [Type]
-   * @see #getLeastUpperBound(Type)
+   * See [getLeastUpperBound].
    */
   static Set<InterfaceType> computeSuperinterfaceSet(InterfaceType type) => _computeSuperinterfaceSet(type, new HashSet<InterfaceType>());
 
   /**
    * This method computes the longest inheritance path from some passed [Type] to Object. This
    * method calls itself recursively, callers should use the public method
    * [computeLongestInheritancePathToObject].
    *
    * @param type the [Type] to compute the longest inheritance path of from the passed
    *          [Type] to Object
    * @param depth a field used recursively
    * @param visitedClasses the classes that have already been visited
    * @return the computed longest inheritance path to Object
-   * @see #computeLongestInheritancePathToObject(Type)
-   * @see #getLeastUpperBound(Type)
+   * See [computeLongestInheritancePathToObject], and [getLeastUpperBound].
    */
   static int _computeLongestInheritancePathToObject(InterfaceType type, int depth, HashSet<ClassElement> visitedClasses) {
     ClassElement classElement = type.element;
     // Object case
     if (classElement.supertype == null || visitedClasses.contains(classElement)) {
       return depth;
     }
     int longestPath = 1;
     try {
       visitedClasses.add(classElement);
@@ skipping 22 matching lines @@
     return longestPath;
   }
 
   /**
    * Returns the set of all superinterfaces of the passed [Type]. This is a recursive method,
    * callers should call the public [computeSuperinterfaceSet].
    *
    * @param type the [Type] to compute the set of superinterfaces of
    * @param set a [HashSet] used recursively by this method
    * @return the [Set] of superinterfaces of the passed [Type]
-   * @see #computeSuperinterfaceSet(Type)
-   * @see #getLeastUpperBound(Type)
+   * See [computeSuperinterfaceSet], and [getLeastUpperBound].
    */
   static Set<InterfaceType> _computeSuperinterfaceSet(InterfaceType type, HashSet<InterfaceType> set) {
     Element element = type.element;
     if (element != null) {
       List<InterfaceType> superinterfaces = type.interfaces;
       for (InterfaceType superinterface in superinterfaces) {
         if (set.add(superinterface)) {
           _computeSuperinterfaceSet(superinterface, set);
         }
       }
@@ skipping 5011 matching lines @@
     if (type is UnionType) {
       return (type as UnionTypeImpl).internalUnionTypeIsSuperTypeOf(this, visitedTypePairs);
     }
     // The only subtype relations that pertain to void are therefore:
     // void <: void (by reflexivity)
     // bottom <: void (as bottom is a subtype of all types).
     // void <: dynamic (as dynamic is a supertype of all types)
     return identical(type, this) || type.isDynamic;
   }
 }