Clean up references in 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:collection';
 import "dart:math" as math;
 
 import 'java_core.dart';
@@ skipping 816 matching lines @@
     _checkForInvalidAssignment(node.name, node.initializer);
     return super.visitVariableDeclaration(node);
   }
 
   /**
    * Check for the passed is expression for the unnecessary type check hint codes as well as null
    * checks expressed using an is expression.
    *
    * @param node the is expression to check
    * @return `true` if and only if a hint code is generated on the passed node
-   * @see HintCode#TYPE_CHECK_IS_NOT_NULL
-   * @see HintCode#TYPE_CHECK_IS_NULL
-   * @see HintCode#UNNECESSARY_TYPE_CHECK_TRUE
-   * @see HintCode#UNNECESSARY_TYPE_CHECK_FALSE
+   * See [HintCode.TYPE_CHECK_IS_NOT_NULL], [HintCode.TYPE_CHECK_IS_NULL],
+   * [HintCode.UNNECESSARY_TYPE_CHECK_TRUE], and
+   * [HintCode.UNNECESSARY_TYPE_CHECK_FALSE].
    */
   bool _checkAllTypeChecks(IsExpression node) {
     Expression expression = node.expression;
     TypeName typeName = node.type;
     DartType lhsType = expression.staticType;
     DartType rhsType = typeName.type;
     if (lhsType == null || rhsType == null) {
       return false;
     }
     String rhsNameStr = typeName.name.name;
@@ skipping 43 matching lines @@
    * TODO (jwren) In the ErrorVerifier there are other warnings that we could have a corresponding
    * hint for: see other callers of ErrorVerifier.checkForArgumentTypeNotAssignable(..).
    *
    * @param expression the expression to evaluate
    * @param expectedStaticType the expected static type of the parameter
    * @param actualStaticType the actual static type of the argument
    * @param expectedPropagatedType the expected propagated type of the parameter, may be
    *          `null`
    * @param actualPropagatedType the expected propagated type of the parameter, may be `null`
    * @return `true` if and only if an hint code is generated on the passed node
-   * @see HintCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
+   * See [HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE].
    */
   bool _checkForArgumentTypeNotAssignable(Expression expression, DartType expectedStaticType, DartType actualStaticType, DartType expectedPropagatedType, DartType actualPropagatedType, ErrorCode hintCode) {
     //
     // Warning case: test static type information
     //
     if (actualStaticType != null && expectedStaticType != null) {
       if (!actualStaticType.isAssignableTo(expectedStaticType)) {
         // A warning was created in the ErrorVerifier, return false, don't create a hint when a
         // warning has already been created.
         return false;
@@ skipping 14 matching lines @@
     return false;
   }
 
   /**
    * This verifies that the passed argument can be assigned to its corresponding parameter.
    *
    * This method corresponds to ErrorCode.checkForArgumentTypeNotAssignableForArgument.
    *
    * @param argument the argument to evaluate
    * @return `true` if and only if an hint code is generated on the passed node
-   * @see HintCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
+   * See [HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE].
    */
   bool _checkForArgumentTypeNotAssignableForArgument(Expression argument) {
     if (argument == null) {
       return false;
     }
     ParameterElement staticParameterElement = argument.staticParameterElement;
     DartType staticParameterType = staticParameterElement == null ? null : staticParameterElement.type;
     ParameterElement propagatedParameterElement = argument.propagatedParameterElement;
     DartType propagatedParameterType = propagatedParameterElement == null ? null : propagatedParameterElement.type;
     return _checkForArgumentTypeNotAssignableWithExpectedTypes(argument, staticParameterType, propagatedParameterType, HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
   }
 
   /**
    * This verifies that the passed expression can be assigned to its corresponding parameters.
    *
    * This method corresponds to ErrorCode.checkForArgumentTypeNotAssignableWithExpectedTypes.
    *
    * @param expression the expression to evaluate
    * @param expectedStaticType the expected static type
    * @param expectedPropagatedType the expected propagated type, may be `null`
    * @return `true` if and only if an hint code is generated on the passed node
-   * @see HintCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
+   * See [HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE].
    */
   bool _checkForArgumentTypeNotAssignableWithExpectedTypes(Expression expression, DartType expectedStaticType, DartType expectedPropagatedType, ErrorCode errorCode) => _checkForArgumentTypeNotAssignable(expression, expectedStaticType, expression.staticType, expectedPropagatedType, expression.propagatedType, errorCode);
 
   /**
    * This verifies that the passed arguments can be assigned to their corresponding parameters.
    *
    * This method corresponds to ErrorCode.checkForArgumentTypesNotAssignableInList.
    *
    * @param node the arguments to evaluate
    * @return `true` if and only if an hint code is generated on the passed node
-   * @see HintCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
+   * See [HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE].
    */
   bool _checkForArgumentTypesNotAssignableInList(ArgumentList argumentList) {
     if (argumentList == null) {
       return false;
     }
     bool problemReported = false;
     for (Expression argument in argumentList.arguments) {
       if (_checkForArgumentTypeNotAssignableForArgument(argument)) {
         problemReported = true;
       }
     }
     return problemReported;
   }
 
   /**
    * Given some [Element], look at the associated metadata and report the use of the member if
    * it is declared as deprecated.
    *
    * @param element some element to check for deprecated use of
    * @param node the node use for the location of the error
    * @return `true` if and only if a hint code is generated on the passed node
-   * @see HintCode#DEPRECATED_MEMBER_USE
+   * See [HintCode.DEPRECATED_MEMBER_USE].
    */
   bool _checkForDeprecatedMemberUse(Element element, AstNode node) {
     if (element != null && element.isDeprecated) {
       String displayName = element.displayName;
       if (element is ConstructorElement) {
         // TODO(jwren) We should modify ConstructorElement.getDisplayName(), or have the logic
         // centralized elsewhere, instead of doing this logic here.
         ConstructorElement constructorElement = element;
         displayName = constructorElement.enclosingElement.displayName;
         if (!constructorElement.displayName.isEmpty) {
@@ skipping 11 matching lines @@
    * if the node is not in a declaration context.
    *
    * Also, if the identifier is a constructor name in a constructor invocation, then calls to the
    * deprecated constructor will be caught by
    * [visitInstanceCreationExpression] and
    * [visitSuperConstructorInvocation], and can be ignored by
    * this visit method.
    *
    * @param identifier some simple identifier to check for deprecated use of
    * @return `true` if and only if a hint code is generated on the passed node
-   * @see HintCode#DEPRECATED_MEMBER_USE
+   * See [HintCode.DEPRECATED_MEMBER_USE].
    */
   bool _checkForDeprecatedMemberUseAtIdentifier(SimpleIdentifier identifier) {
     if (identifier.inDeclarationContext()) {
       return false;
     }
     AstNode parent = identifier.parent;
     if ((parent is ConstructorName && identical(identifier, parent.name)) || (parent is SuperConstructorInvocation && identical(identifier, parent.constructorName)) || parent is HideCombinator) {
       return false;
     }
     return _checkForDeprecatedMemberUse(identifier.bestElement, identifier);
   }
 
   /**
-   * Check for the passed binary expression for the [HintCode#DIVISION_OPTIMIZATION].
+   * Check for the passed binary expression for the [HintCode.DIVISION_OPTIMIZATION].
    *
    * @param node the binary expression to check
    * @return `true` if and only if a hint code is generated on the passed node
-   * @see HintCode#DIVISION_OPTIMIZATION
+   * See [HintCode.DIVISION_OPTIMIZATION].
    */
   bool _checkForDivisionOptimizationHint(BinaryExpression node) {
     // Return if the operator is not '/'
     if (node.operator.type != sc.TokenType.SLASH) {
       return false;
     }
     // Return if the '/' operator is not defined in core, or if we don't know its static or propagated type
     MethodElement methodElement = node.bestElement;
     if (methodElement == null) {
       return false;
@@ skipping 17 matching lines @@
   }
 
   /**
    * This verifies that the passed left hand side and right hand side represent a valid assignment.
    *
    * This method corresponds to ErrorVerifier.checkForInvalidAssignment.
    *
    * @param lhs the left hand side expression
    * @param rhs the right hand side expression
    * @return `true` if and only if an error code is generated on the passed node
-   * @see HintCode#INVALID_ASSIGNMENT
+   * See [HintCode.INVALID_ASSIGNMENT].
    */
   bool _checkForInvalidAssignment(Expression lhs, Expression rhs) {
     if (lhs == null || rhs == null) {
       return false;
     }
     VariableElement leftVariableElement = ErrorVerifier.getVariableElement(lhs);
     DartType leftType = (leftVariableElement == null) ? ErrorVerifier.getStaticType(lhs) : leftVariableElement.type;
     DartType staticRightType = ErrorVerifier.getStaticType(rhs);
     if (!staticRightType.isAssignableTo(leftType)) {
       // The warning was generated on this rhs
@@ skipping 10 matching lines @@
     return false;
   }
 
   /**
    * Check that the imported library does not define a loadLibrary function. The import has already
    * been determined to be deferred when this is called.
    *
    * @param node the import directive to evaluate
    * @param importElement the [ImportElement] retrieved from the node
    * @return `true` if and only if an error code is generated on the passed node
-   * @see CompileTimeErrorCode#IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION
+   * See [CompileTimeErrorCode.IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION].
    */
   bool _checkForLoadLibraryFunction(ImportDirective node, ImportElement importElement) {
     LibraryElement importedLibrary = importElement.importedLibrary;
     if (importedLibrary == null) {
       return false;
     }
     if (importedLibrary.hasLoadLibraryFunction) {
       _errorReporter.reportErrorForNode(HintCode.IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION, node, [importedLibrary.name]);
       return true;
     }
     return false;
   }
 
   /**
    * Generate a hint for functions or methods that have a return type, but do not have a return
    * statement on all branches. At the end of blocks with no return, Dart implicitly returns
    * `null`, avoiding these implicit returns is considered a best practice.
    *
    * @param node the binary expression to check
    * @param body the function body
    * @return `true` if and only if a hint code is generated on the passed node
-   * @see HintCode#MISSING_RETURN
+   * See [HintCode.MISSING_RETURN].
    */
   bool _checkForMissingReturn(TypeName returnType, FunctionBody body) {
     // Check that the method or function has a return type, and a function body
     if (returnType == null || body == null) {
       return false;
     }
     // Check that the body is a BlockFunctionBody
     if (body is! BlockFunctionBody) {
       return false;
     }
     // Check that the type is resolvable, and is not "void"
     DartType returnTypeType = returnType.type;
     if (returnTypeType == null || returnTypeType.isVoid) {
       return false;
     }
     // Check the block for a return statement, if not, create the hint
     BlockFunctionBody blockFunctionBody = body as BlockFunctionBody;
     if (!blockFunctionBody.accept(new ExitDetector())) {
       _errorReporter.reportErrorForNode(HintCode.MISSING_RETURN, returnType, [returnTypeType.displayName]);
       return true;
     }
     return false;
   }
 
   /**
    * Check for the passed class declaration for the
-   * [HintCode#OVERRIDE_EQUALS_BUT_NOT_HASH_CODE] hint code.
+   * [HintCode.OVERRIDE_EQUALS_BUT_NOT_HASH_CODE] hint code.
    *
    * @param node the class declaration to check
    * @return `true` if and only if a hint code is generated on the passed node
-   * @see HintCode#OVERRIDE_EQUALS_BUT_NOT_HASH_CODE
+   * See [HintCode.OVERRIDE_EQUALS_BUT_NOT_HASH_CODE].
    */
   bool _checkForOverrideEqualsButNotHashCode(ClassDeclaration node) {
     ClassElement classElement = node.element;
     if (classElement == null) {
       return false;
     }
     MethodElement equalsOperatorMethodElement = classElement.getMethod(sc.TokenType.EQ_EQ.lexeme);
     if (equalsOperatorMethodElement != null) {
       PropertyAccessorElement hashCodeElement = classElement.getGetter(_HASHCODE_GETTER_NAME);
       if (hashCodeElement == null) {
         _errorReporter.reportErrorForNode(HintCode.OVERRIDE_EQUALS_BUT_NOT_HASH_CODE, node.name, [classElement.displayName]);
         return true;
       }
     }
     return false;
   }
 
   /**
-   * Check for the passed as expression for the [HintCode#UNNECESSARY_CAST] hint code.
+   * Check for the passed as expression for the [HintCode.UNNECESSARY_CAST] hint code.
    *
    * @param node the as expression to check
    * @return `true` if and only if a hint code is generated on the passed node
-   * @see HintCode#UNNECESSARY_CAST
+   * See [HintCode.UNNECESSARY_CAST].
    */
   bool _checkForUnnecessaryCast(AsExpression node) {
     Expression expression = node.expression;
     TypeName typeName = node.type;
     DartType lhsType = expression.staticType;
     DartType rhsType = typeName.type;
     // TODO(jwren) After dartbug.com/13732, revisit this, we should be able to remove the
     // !(x instanceof TypeParameterType) checks.
     if (lhsType != null && rhsType != null && !lhsType.isDynamic && !rhsType.isDynamic && lhsType is! TypeParameterType && rhsType is! TypeParameterType && lhsType.isMoreSpecificThan(rhsType)) {
       _errorReporter.reportErrorForNode(HintCode.UNNECESSARY_CAST, node, []);
       return true;
     }
     return false;
   }
 
   /**
    * Check for situations where the result of a method or function is used, when it returns 'void'.
    *
    * TODO(jwren) Many other situations of use could be covered. We currently cover the cases var x =
    * m() and x = m(), but we could also cover cases such as m().x, m()[k], a + m(), f(m()), return
    * m().
    *
    * @param node expression on the RHS of some assignment
    * @return `true` if and only if a hint code is generated on the passed node
-   * @see HintCode#USE_OF_VOID_RESULT
+   * See [HintCode.USE_OF_VOID_RESULT].
    */
   bool _checkForUseOfVoidResult(Expression expression) {
     if (expression == null || expression is! MethodInvocation) {
       return false;
     }
     MethodInvocation methodInvocation = expression as MethodInvocation;
     if (identical(methodInvocation.staticType, VoidTypeImpl.instance)) {
       SimpleIdentifier methodName = methodInvocation.methodName;
       _errorReporter.reportErrorForNode(HintCode.USE_OF_VOID_RESULT, methodName, [methodName.name]);
       return true;
@@ skipping 320 matching lines @@
     return null;
   }
 
   /**
    * This verifies that the passed switch statement does not have a case expression with the
    * operator '==' overridden.
    *
    * @param node the switch statement to evaluate
    * @param type the common type of all 'case' expressions
    * @return `true` if and only if an error code is generated on the passed node
-   * @see CompileTimeErrorCode#CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS
+   * See [CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS].
    */
   bool _checkForCaseExpressionTypeImplementsEquals(SwitchStatement node, DartType type) {
     if (!_implementsEqualsWhenNotAllowed(type)) {
       return false;
     }
     // report error
     _errorReporter.reportErrorForToken(CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS, node.keyword, [type.displayName]);
     return true;
   }
 
@@ skipping 270 matching lines @@
         }
         return new DartObjectImpl(type is InterfaceType ? type : ConstantVerifier_this._typeProvider.objectType, GenericState.UNKNOWN_VALUE);
       }
     }
     return super.visitSimpleIdentifier(node);
   }
 }
 
 /**
  * Instances of the class `Dart2JSVerifier` traverse an AST structure looking for hints for
- * code that will be compiled to JS, such as [HintCode#IS_DOUBLE].
+ * code that will be compiled to JS, such as [HintCode.IS_DOUBLE].
  */
 class Dart2JSVerifier extends RecursiveAstVisitor<Object> {
   /**
    * The error reporter by which errors will be reported.
    */
   final ErrorReporter _errorReporter;
 
   /**
    * The name of the `double` type.
    */
@@ skipping 11 matching lines @@
     _checkForIsDoubleHints(node);
     return super.visitIsExpression(node);
   }
 
   /**
    * Check for instances of `x is double`, `x is int`, `x is! double` and
    * `x is! int`.
    *
    * @param node the is expression to check
    * @return `true` if and only if a hint code is generated on the passed node
-   * @see HintCode#IS_DOUBLE
-   * @see HintCode#IS_INT
-   * @see HintCode#IS_NOT_DOUBLE
-   * @see HintCode#IS_NOT_INT
+   * See [HintCode.IS_DOUBLE],
+   * [HintCode.IS_INT],
+   * [HintCode.IS_NOT_DOUBLE], and
+   * [HintCode.IS_NOT_INT].
    */
   bool _checkForIsDoubleHints(IsExpression node) {
     TypeName typeName = node.type;
     DartType type = typeName.type;
     if (type != null && type.element != null) {
       Element element = type.element;
       String typeNameStr = element.name;
       LibraryElement libraryElement = element.library;
       //      if (typeNameStr.equals(INT_TYPE_NAME) && libraryElement != null
       //          && libraryElement.isDartCore()) {
@@ skipping 38 matching lines @@
       _errorReporter.reportErrorForElement(
           HintCode.UNUSED_LOCAL_VARIABLE,
           element,
           [element.displayName]);
     }
   }
 }
 
 /**
  * Instances of the class `DeadCodeVerifier` traverse an AST structure looking for cases of
- * [HintCode#DEAD_CODE].
+ * [HintCode.DEAD_CODE].
  */
 class DeadCodeVerifier extends RecursiveAstVisitor<Object> {
   /**
    * The error reporter by which errors will be reported.
    */
   final ErrorReporter _errorReporter;
 
   /**
    * Create a new instance of the [DeadCodeVerifier].
    *
@@ skipping 218 matching lines @@
         Statement lastStatement = statements[size - 1];
         int offset = nextStatement.offset;
         int length = lastStatement.end - offset;
         _errorReporter.reportErrorForOffset(HintCode.DEAD_CODE, offset, length, []);
         return;
       }
     }
   }
 
   /**
-   * Given some [Expression], this method returns [ValidResult#RESULT_TRUE] if it is
-   * `true`, [ValidResult#RESULT_FALSE] if it is `false`, or `null` if the
+   * Given some [Expression], this method returns [ValidResult.RESULT_TRUE] if it is
+   * `true`, [ValidResult.RESULT_FALSE] if it is `false`, or `null` if the
    * expression is not a constant boolean value.
    *
    * @param expression the expression to evaluate
-   * @return [ValidResult#RESULT_TRUE] if it is `true`, [ValidResult#RESULT_FALSE]
+   * @return [ValidResult.RESULT_TRUE] if it is `true`, [ValidResult.RESULT_FALSE]
    *         if it is `false`, or `null` if the expression is not a constant boolean
    *         value
    */
   EvaluationResultImpl _getConstantBooleanValue(Expression expression) {
     if (expression is BooleanLiteral) {
       if (expression.value) {
         return new EvaluationResultImpl.con1(new DartObjectImpl(null, BoolState.from(true)));
       } else {
         return new EvaluationResultImpl.con1(new DartObjectImpl(null, BoolState.from(false)));
       }
@@ skipping 3170 matching lines @@
     DeclarationMatcher_this._allElements.add(element);
     DeclarationMatcher_this._unmatchedElements.add(element);
     return super.visitElement(element);
   }
 }
 
 /**
  * Instances of the class `HintGenerator` traverse a library's worth of dart code at a time to
  * generate hints over the set of sources.
  *
- * @see HintCode
+ * See [HintCode].
  */
 class HintGenerator {
   final List<CompilationUnit> _compilationUnits;
 
   final AnalysisContext _context;
 
   final AnalysisErrorListener _errorListener;
 
   ImportsVerifier _importsVerifier;
 
@@ skipping 454 matching lines @@
         types[i] = dynamic;
       }
     }
     return types;
   }
 }
 
 /**
  * Instances of the class `ImportsVerifier` visit all of the referenced libraries in the
  * source code verifying that all of the imports are used, otherwise a
- * [HintCode#UNUSED_IMPORT] is generated with
+ * [HintCode.UNUSED_IMPORT] is generated with
  * [generateUnusedImportHints].
  *
  * While this class does not yet have support for an "Organize Imports" action, this logic built up
  * in this class could be used for such an action in the future.
  */
 class ImportsVerifier extends RecursiveAstVisitor<Object> {
   /**
    * This is set to `true` if the current compilation unit which is being visited is the
    * defining compilation unit for the library, its value can be set with
    * [setInDefiningCompilationUnit].
    */
   bool _inDefiningCompilationUnit = false;
 
   /**
    * The current library.
    */
   LibraryElement _currentLibrary;
 
   /**
    * A list of [ImportDirective]s that the current library imports, as identifiers are visited
    * by this visitor and an import has been identified as being used by the library, the
    * [ImportDirective] is removed from this list. After all the sources in the library have
    * been evaluated, this list represents the set of unused imports.
    *
-   * @see ImportsVerifier#generateUnusedImportErrors(ErrorReporter)
+   * See [ImportsVerifier.generateUnusedImportErrors].
    */
   List<ImportDirective> _unusedImports;
 
   /**
    * After the list of [unusedImports] has been computed, this list is a proper subset of the
    * unused imports that are listed more than once.
    */
   List<ImportDirective> _duplicateImports;
 
   /**
@@ skipping 38 matching lines @@
     this._currentLibrary = library;
     this._unusedImports = new List<ImportDirective>();
     this._duplicateImports = new List<ImportDirective>();
     this._libraryMap = new HashMap<LibraryElement, List<ImportDirective>>();
     this._namespaceMap = new HashMap<ImportDirective, Namespace>();
     this._prefixElementMap = new HashMap<PrefixElement, List<ImportDirective>>();
   }
 
   /**
    * Any time after the defining compilation unit has been visited by this visitor, this method can
-   * be called to report an [HintCode#DUPLICATE_IMPORT] hint for each of the import directives
+   * be called to report an [HintCode.DUPLICATE_IMPORT] hint for each of the import directives
    * in the [duplicateImports] list.
    *
-   * @param errorReporter the error reporter to report the set of [HintCode#DUPLICATE_IMPORT]
+   * @param errorReporter the error reporter to report the set of [HintCode.DUPLICATE_IMPORT]
    *          hints to
    */
   void generateDuplicateImportHints(ErrorReporter errorReporter) {
     for (ImportDirective duplicateImport in _duplicateImports) {
       errorReporter.reportErrorForNode(HintCode.DUPLICATE_IMPORT, duplicateImport.uri, []);
     }
   }
 
   /**
    * After all of the compilation units have been visited by this visitor, this method can be called
-   * to report an [HintCode#UNUSED_IMPORT] hint for each of the import directives in the
+   * to report an [HintCode.UNUSED_IMPORT] hint for each of the import directives in the
    * [unusedImports] list.
    *
-   * @param errorReporter the error reporter to report the set of [HintCode#UNUSED_IMPORT]
+   * @param errorReporter the error reporter to report the set of [HintCode.UNUSED_IMPORT]
    *          hints to
    */
   void generateUnusedImportHints(ErrorReporter errorReporter) {
     for (ImportDirective unusedImport in _unusedImports) {
       // Check that the import isn't dart:core
       ImportElement importElement = unusedImport.element;
       if (importElement != null) {
         LibraryElement libraryElement = importElement.importedLibrary;
         if (libraryElement != null && libraryElement.isDartCore) {
           continue;
@@ skipping 298 matching lines @@
       throw new AnalysisException("Cannot resolve node: element model changed");
     }
     _resolveTypes(node, scope);
     _resolveVariables(node, scope);
     _resolveReferences(node, scope);
   }
 
   /**
    * Return `true` if the given node can be resolved independently of any other nodes.
    *
-   * <b>Note:</b> This method needs to be kept in sync with [ScopeBuilder#scopeForAstNode].
+   * <b>Note:</b> This method needs to be kept in sync with [ScopeBuilder.scopeForAstNode].
    *
    * @param node the node being tested
    * @return `true` if the given node can be resolved independently of any other nodes
    */
   bool _canBeResolved(AstNode node) => node is ClassDeclaration || node is ClassTypeAlias || node is CompilationUnit || node is ConstructorDeclaration || node is FunctionDeclaration || node is FunctionTypeAlias || node is MethodDeclaration;
 
   /**
    * Return `true` if the portion of the element model defined by the given node has changed.
    *
    * @param node the node defining the portion of the element model being tested
@@ skipping 181 matching lines @@
       if (parameterElement.parameterKind == parameterKind) {
         parameterCount++;
       }
     }
     return parameterCount;
   }
 
   /**
    * Given some [ExecutableElement] return the number of positional parameters.
    *
-   * Note: by positional we mean [ParameterKind#REQUIRED] or [ParameterKind#POSITIONAL].
+   * Note: by positional we mean [ParameterKind.REQUIRED] or [ParameterKind.POSITIONAL].
    */
   static int _getNumOfPositionalParameters(ExecutableElement executableElement) => _getNumOfParameters(executableElement, ParameterKind.REQUIRED) + _getNumOfParameters(executableElement, ParameterKind.POSITIONAL);
 
   /**
    * Given some [ExecutableElement] return the number of required parameters.
    */
   static int _getNumOfRequiredParameters(ExecutableElement executableElement) => _getNumOfParameters(executableElement, ParameterKind.REQUIRED);
 
   /**
    * Given some [ExecutableElement] returns `true` if it is an abstract member of a
@@ skipping 555 matching lines @@
     List<PropertyAccessorElement> accessors = type.accessors;
     for (PropertyAccessorElement accessor in accessors) {
       if (accessor.isAccessibleIn(_library) && !accessor.isStatic && (doIncludeAbstract || !accessor.isAbstract)) {
         map.put(accessor.name, accessor);
       }
     }
   }
 
   /**
    * This method is used to report errors on when they are found computing inheritance information.
-   * See [ErrorVerifier#checkForInconsistentMethodInheritance] to see where these generated
+   * See [ErrorVerifier.checkForInconsistentMethodInheritance] to see where these generated
    * error codes are reported back into the analysis engine.
    *
    * @param classElt the location of the source for which the exception occurred
    * @param offset the offset of the location of the error
    * @param length the length of the location of the error
    * @param errorCode the error code to be associated with this error
    * @param arguments the arguments used to build the error message
    */
   void _reportError(ClassElement classElt, int offset, int length, ErrorCode errorCode, List<Object> arguments) {
     HashSet<AnalysisError> errorSet = _errorsInClassElement[classElt];
@@ skipping 3134 matching lines @@
   }
 
   /**
    * This verifies that the passed file import directive is not contained in a source inside a
    * package "lib" directory hierarchy referencing a source outside that package "lib" directory
    * hierarchy.
    *
    * @param uriLiteral the import URL (not `null`)
    * @param path the file path being verified (not `null`)
    * @return `true` if and only if an error code is generated on the passed node
-   * @see PubSuggestionCode.FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE
+   * See [PubSuggestionCode.FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE].
    */
   bool _checkForFileImportInsideLibReferencesFileOutside(StringLiteral uriLiteral, String path) {
     Source source = _getSource(uriLiteral);
     String fullName = _getSourceFullName(source);
     if (fullName != null) {
       int pathIndex = 0;
       int fullNameIndex = fullName.length;
       while (pathIndex < path.length && StringUtilities.startsWith3(path, pathIndex, 0x2E, 0x2E, 0x2F)) {
         fullNameIndex = JavaString.lastIndexOf(fullName, '/', fullNameIndex);
         if (fullNameIndex < 4) {
@@ skipping 16 matching lines @@
   }
 
   /**
    * This verifies that the passed file import directive is not contained in a source outside a
    * package "lib" directory hierarchy referencing a source inside that package "lib" directory
    * hierarchy.
    *
    * @param uriLiteral the import URL (not `null`)
    * @param path the file path being verified (not `null`)
    * @return `true` if and only if an error code is generated on the passed node
-   * @see PubSuggestionCode.FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE
+   * See [PubSuggestionCode.FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE].
    */
   bool _checkForFileImportOutsideLibReferencesFileInside(StringLiteral uriLiteral, String path) {
     if (StringUtilities.startsWith4(path, 0, 0x6C, 0x69, 0x62, 0x2F)) {
       if (_checkForFileImportOutsideLibReferencesFileInsideAtIndex(uriLiteral, path, 0)) {
         return true;
       }
     }
     int pathIndex = StringUtilities.indexOf5(path, 0, 0x2F, 0x6C, 0x69, 0x62, 0x2F);
     while (pathIndex != -1) {
       if (_checkForFileImportOutsideLibReferencesFileInsideAtIndex(uriLiteral, path, pathIndex + 1)) {
@@ skipping 22 matching lines @@
     }
     return false;
   }
 
   /**
    * This verifies that the passed package import directive does not contain ".."
    *
    * @param uriLiteral the import URL (not `null`)
    * @param path the path to be validated (not `null`)
    * @return `true` if and only if an error code is generated on the passed node
-   * @see PubSuggestionCode.PACKAGE_IMPORT_CONTAINS_DOT_DOT
+   * See [PubSuggestionCode.PACKAGE_IMPORT_CONTAINS_DOT_DOT].
    */
   bool _checkForPackageImportContainsDotDot(StringLiteral uriLiteral, String path) {
     if (StringUtilities.startsWith3(path, 0, 0x2E, 0x2E, 0x2F) || StringUtilities.indexOf4(path, 0, 0x2F, 0x2E, 0x2E, 0x2F) >= 0) {
       // Package import should not to contain ".."
       _errorReporter.reportErrorForNode(HintCode.PACKAGE_IMPORT_CONTAINS_DOT_DOT, uriLiteral, []);
       return true;
     }
     return false;
   }
 
@@ skipping 10 matching lines @@
       CompilationUnitElement element = unit.element;
       if (element != null) {
         source = element.source;
       }
     }
     return source;
   }
 
   /**
    * Answer the full name of the given source. The returned value will have all
-   * [File#separatorChar] replace by '/'.
+   * [File.separatorChar] replace by '/'.
    *
    * @param source the source
    * @return the full name or `null` if it could not be determined
    */
   String _getSourceFullName(Source source) {
     if (source != null) {
       String fullName = source.fullName;
       if (fullName != null) {
         return fullName.replaceAll(r'\', '/');
       }
@@ skipping 2052 matching lines @@
    * given listener.
    *
    * @param errorListener the listener to which analysis errors will be reported
    */
   ScopeBuilder(this._errorListener);
 
   /**
    * Return the scope in which the given AST structure should be resolved.
    *
    * <b>Note:</b> This method needs to be kept in sync with
-   * [IncrementalResolver#canBeResolved].
+   * [IncrementalResolver.canBeResolved].
    *
    * @param node the root of the AST structure to be resolved
    * @return the scope in which the given AST structure should be resolved
    * @throws AnalysisException if the AST structure has not been resolved or is not part of a
    *           [CompilationUnit]
    */
   Scope _scopeForAstNode(AstNode node) {
     if (node is CompilationUnit) {
       return _scopeForCompilationUnit(node);
     }
@@ skipping 3139 matching lines @@
   /**
    * Return the tag that has the given identifier, or {@code null} if there is no such tag (the
    * identifier is not defined).
    *
    * @return the tag that has the given identifier
    */
   String getTagWithId(String identifier) {
     return idToTagMap[identifier];
   }
 }