Clean up comments in error verifier

pkg/analyzer/lib/src/generated/error_verifier.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.error_verifier;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/static_type_analyzer.dart';
 
 import 'ast.dart';
 import 'constant.dart';
 import 'element.dart';
 import 'element_resolver.dart';
 import 'error.dart';
 import 'java_engine.dart';
 import 'parser.dart' show Parser, ParserErrorCode;
 import 'resolver.dart';
 import 'scanner.dart' as sc;
 import 'sdk.dart' show DartSdk, SdkLibrary;
 import 'utilities_dart.dart';
 
 /**
- * Instances of the class `ErrorVerifier` traverse an AST structure looking for additional
- * errors and warnings not covered by the parser and resolver.
+ * A visitor used to traverse an AST structure looking for additional errors and
+ * warnings not covered by the parser and resolver.
  */
 class ErrorVerifier extends RecursiveAstVisitor<Object> {
   /**
    * Static final string with value `"getter "` used in the construction of the
-   * [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE], and similar, error
-   * code messages.
+   * [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE], and
+   * similar, error code messages.
    *
    * See [_checkForNonAbstractClassInheritsAbstractMember].
    */
   static String _GETTER_SPACE = "getter ";
 
   /**
    * Static final string with value `"setter "` used in the construction of the
-   * [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE], and similar, error
-   * code messages.
+   * [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE], and
+   * similar, error code messages.
    *
    * See [_checkForNonAbstractClassInheritsAbstractMember].
    */
   static String _SETTER_SPACE = "setter ";
 
   /**
    * The error reporter by which errors will be reported.
    */
   final ErrorReporter _errorReporter;
 
@@ skipping 16 matching lines @@
    * The object providing access to the types defined by the language.
    */
   final TypeProvider _typeProvider;
 
   /**
    * The manager for the inheritance mappings.
    */
   final InheritanceManager _inheritanceManager;
 
   /**
-   * This is set to `true` iff the visitor is currently visiting children nodes of a
-   * [ConstructorDeclaration] and the constructor is 'const'.
+   * A flag indicating whether the visitor is currently within a constructor
+   * declaration that is 'const'.
    *
    * See [visitConstructorDeclaration].
    */
   bool _isEnclosingConstructorConst = false;
 
   /**
-   * A flag indicating whether we are currently within a function body marked as being asynchronous.
+   * A flag indicating whether we are currently within a function body marked as
+   * being asynchronous.
    */
   bool _inAsync = false;
 
   /**
-   * A flag indicating whether we are currently within a function body marked as being a generator.
+   * A flag indicating whether we are currently within a function body marked a
+   *  being a generator.
    */
   bool _inGenerator = false;
 
   /**
-   * This is set to `true` iff the visitor is currently visiting children nodes of a
-   * [CatchClause].
+   * A flag indicating whether the visitor is currently within a catch clause.
    *
    * See [visitCatchClause].
    */
   bool _isInCatchClause = false;
 
   /**
-   * This is set to `true` iff the visitor is currently visiting children nodes of an
-   * [Comment].
+   * A flag indicating whether the visitor is currently within a comment.
    */
   bool _isInComment = false;
 
   /**
-   * This is set to `true` iff the visitor is currently visiting children nodes of an
-   * [InstanceCreationExpression].
+   * A flag indicating whether the visitor is currently within an instance
+   * creation expression.
    */
   bool _isInConstInstanceCreation = false;
 
   /**
-   * This is set to `true` iff the visitor is currently visiting children nodes of a native
-   * [ClassDeclaration].
+   * A flag indicating whether the visitor is currently within a native class
+   * declaration.
    */
   bool _isInNativeClass = false;
 
   /**
-   * This is set to `true` iff the visitor is currently visiting a static variable
+   * A flag indicating whether the visitor is currently within a static variable
    * declaration.
    */
   bool _isInStaticVariableDeclaration = false;
 
   /**
-   * This is set to `true` iff the visitor is currently visiting an instance variable
-   * declaration.
+   * A flag indicating whether the visitor is currently within an instance
+   * variable declaration.
    */
   bool _isInInstanceVariableDeclaration = false;
 
   /**
-   * This is set to `true` iff the visitor is currently visiting an instance variable
-   * initializer.
+   * A flag indicating whether the visitor is currently within an instance
+   * variable initializer.
    */
   bool _isInInstanceVariableInitializer = false;
 
   /**
-   * This is set to `true` iff the visitor is currently visiting a
-   * [ConstructorInitializer].
+   * A flag indicating whether the visitor is currently within a constructor
+   * initializer.
    */
   bool _isInConstructorInitializer = false;
 
   /**
-   * This is set to `true` iff the visitor is currently visiting a
-   * [FunctionTypedFormalParameter].
+   * This is set to `true` iff the visitor is currently within a function typed
+   * formal parameter.
    */
   bool _isInFunctionTypedFormalParameter = false;
 
   /**
-   * This is set to `true` iff the visitor is currently visiting a static method. By "method"
-   * here getter, setter and operator declarations are also implied since they are all represented
-   * with a [MethodDeclaration] in the AST structure.
+   * A flag indicating whether the visitor is currently within a static method.
+   * By "method" here getter, setter and operator declarations are also implied
+   * since they are all represented with a [MethodDeclaration] in the AST
+   * structure.
    */
   bool _isInStaticMethod = false;
 
   /**
-   * This is set to `true` iff the visitor is currently visiting a factory constructor.
+   * A flag indicating whether the visitor is currently within a factory
+   * constructor.
    */
   bool _isInFactory = false;
 
   /**
-   * This is set to `true` iff the visitor is currently visiting code in the SDK.
+   * A flag indicating whether the visitor is currently within code in the SDK.
    */
   bool _isInSystemLibrary = false;
 
   /**
-   * A flag indicating whether the current library contains at least one import directive with a URI
-   * that uses the "dart-ext" scheme.
+   * A flag indicating whether the current library contains at least one import
+   * directive with a URI that uses the "dart-ext" scheme.
    */
   bool _hasExtUri = false;
 
   /**
-   * This is set to `false` on the entry of every [BlockFunctionBody], and is restored
-   * to the enclosing value on exit. The value is used in
-   * [checkForMixedReturns] to prevent both
-   * [StaticWarningCode.MIXED_RETURN_TYPES] and [StaticWarningCode.RETURN_WITHOUT_VALUE]
-   * from being generated in the same function body.
+   * This is set to `false` on the entry of every [BlockFunctionBody], and is
+   * restored to the enclosing value on exit. The value is used in
+   * [_checkForMixedReturns] to prevent both
+   * [StaticWarningCode.MIXED_RETURN_TYPES] and
+   * [StaticWarningCode.RETURN_WITHOUT_VALUE] from being generated in the same
+   * function body.
    */
   bool _hasReturnWithoutValue = false;
 
   /**
-   * The class containing the AST nodes being visited, or `null` if we are not in the scope of
-   * a class.
+   * The class containing the AST nodes being visited, or `null` if we are not
+   * in the scope of a class.
    */
   ClassElement _enclosingClass;
 
   /**
-   * The method or function that we are currently visiting, or `null` if we are not inside a
-   * method or function.
+   * The method or function that we are currently visiting, or `null` if we are
+   * not inside a method or function.
    */
   ExecutableElement _enclosingFunction;
 
   /**
-   * The return statements found in the method or function that we are currently visiting that have
-   * a return value.
+   * The return statements found in the method or function that we are currently
+   * visiting that have a return value.
    */
   List<ReturnStatement> _returnsWith = new List<ReturnStatement>();
 
   /**
-   * The return statements found in the method or function that we are currently visiting that do
-   * not have a return value.
+   * The return statements found in the method or function that we are currently
+   * visiting that do not have a return value.
    */
   List<ReturnStatement> _returnsWithout = new List<ReturnStatement>();
 
   /**
-   * This map is initialized when visiting the contents of a class declaration. If the visitor is
-   * not in an enclosing class declaration, then the map is set to `null`.
+   * This map is initialized when visiting the contents of a class declaration.
+   * If the visitor is not in an enclosing class declaration, then the map is
+   * set to `null`.
    *
    * When set the map maps the set of [FieldElement]s in the class to an
-   * [INIT_STATE.NOT_INIT] or [INIT_STATE.INIT_IN_DECLARATION]. <code>checkFor*</code>
-   * methods, specifically [checkForAllFinalInitializedErrorCodes],
-   * can make a copy of the map to compute error code states. <code>checkFor*</code> methods should
-   * only ever make a copy, or read from this map after it has been set in
-   * [visitClassDeclaration].
+   * [INIT_STATE.NOT_INIT] or [INIT_STATE.INIT_IN_DECLARATION]. The `checkFor*`
+   * methods, specifically [_checkForAllFinalInitializedErrorCodes], can make a
+   * copy of the map to compute error code states. The `checkFor*` methods
+   * should only ever make a copy, or read from this map after it has been set
+   * in [visitClassDeclaration].
    *
    * See [visitClassDeclaration], and [_checkForAllFinalInitializedErrorCodes].
    */
   HashMap<FieldElement, INIT_STATE> _initialFieldElementsMap;
 
   /**
-   * A table mapping name of the library to the export directive which export this library.
+   * A table mapping name of the library to the export directive which export
+   * this library.
    */
   HashMap<String, LibraryElement> _nameToExportElement =
       new HashMap<String, LibraryElement>();
 
   /**
-   * A table mapping name of the library to the import directive which import this library.
+   * A table mapping name of the library to the import directive which import
+   * this library.
    */
   HashMap<String, LibraryElement> _nameToImportElement =
       new HashMap<String, LibraryElement>();
 
   /**
    * A table mapping names to the exported elements.
    */
   HashMap<String, Element> _exportedElements = new HashMap<String, Element>();
 
   /**
    * A set of the names of the variable initializers we are visiting now.
    */
   HashSet<String> _namesForReferenceToDeclaredVariableInInitializer =
       new HashSet<String>();
 
   /**
-   * A list of types used by the [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS] and
-   * [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS] error codes.
+   * A list of types used by the [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]
+   * and [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS] error codes.
    */
   List<InterfaceType> _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT;
 
   /**
-   * Initialize the [ErrorVerifier] visitor.
+   * Initialize a newly created error verifier.
    */
   ErrorVerifier(this._errorReporter, this._currentLibrary, this._typeProvider,
       this._inheritanceManager) {
     this._isInSystemLibrary = _currentLibrary.source.isInSystemLibrary;
     this._hasExtUri = _currentLibrary.hasExtUri;
     _isEnclosingConstructorConst = false;
     _isInCatchClause = false;
     _isInStaticVariableDeclaration = false;
     _isInInstanceVariableDeclaration = false;
     _isInInstanceVariableInitializer = false;
@@ skipping 170 matching lines @@
       _isInNativeClass = false;
       _initialFieldElementsMap = null;
       _enclosingClass = outerClass;
     }
   }
 
   /**
    * Implementation of this method should be synchronized with
    * [visitClassDeclaration].
    */
-  visitClassDeclarationIncrementally(ClassDeclaration node) {
+  void visitClassDeclarationIncrementally(ClassDeclaration node) {
     _isInNativeClass = node.nativeClause != null;
     _enclosingClass = node.element;
     // initialize initialFieldElementsMap
     if (_enclosingClass != null) {
       List<FieldElement> fieldElements = _enclosingClass.fields;
       _initialFieldElementsMap = new HashMap<FieldElement, INIT_STATE>();
       for (FieldElement fieldElement in fieldElements) {
         if (!fieldElement.isSynthetic) {
           _initialFieldElementsMap[fieldElement] = fieldElement.initializer ==
               null ? INIT_STATE.NOT_INIT : INIT_STATE.INIT_IN_DECLARATION;
@@ skipping 630 matching lines @@
         errorCode = CompileTimeErrorCode.YIELD_EACH_IN_NON_GENERATOR;
       } else {
         errorCode = CompileTimeErrorCode.YIELD_IN_NON_GENERATOR;
       }
       _errorReporter.reportErrorForNode(errorCode, node);
     }
     return super.visitYieldStatement(node);
   }
 
   /**
-   * This verifies if the passed map literal has type arguments then there is exactly two.
+   * Verify that the given list of [typeArguments] contains exactly two
+   * elements.
    *
-   * @param typeArguments the type arguments, always non-`null`
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticTypeWarningCode.EXPECTED_TWO_MAP_TYPE_ARGUMENTS].
    */
   bool _checkExpectedTwoMapTypeArguments(TypeArgumentList typeArguments) {
     // check number of type arguments
     int num = typeArguments.arguments.length;
     if (num == 2) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
         StaticTypeWarningCode.EXPECTED_TWO_MAP_TYPE_ARGUMENTS, typeArguments,
         [num]);
     return true;
   }
 
   /**
-   * This verifies that the passed constructor declaration does not violate any of the error codes
-   * relating to the initialization of fields in the enclosing class.
+   * Verify that the given [constructor] declaration does not violate any of the
+   * error codes relating to the initialization of fields in the enclosing
+   * class.
    *
-   * @param node the [ConstructorDeclaration] to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [_initialFieldElementsMap],
-   * [StaticWarningCode.FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR],
-   * and [CompileTimeErrorCode.FINAL_INITIALIZED_MULTIPLE_TIMES].
+   * [StaticWarningCode.FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR], and
+   * [CompileTimeErrorCode.FINAL_INITIALIZED_MULTIPLE_TIMES].
    */
   bool _checkForAllFinalInitializedErrorCodes(ConstructorDeclaration node) {
     if (node.factoryKeyword != null ||
         node.redirectedConstructor != null ||
         node.externalKeyword != null) {
       return false;
     }
     // Ignore if native class.
     if (_isInNativeClass) {
       return false;
@@ skipping 113 matching lines @@
         ]);
       }
       analysisError.setProperty(
           ErrorProperty.NOT_INITIALIZED_FIELDS, notInitFinalFields);
       _errorReporter.reportError(analysisError);
     }
     return foundError;
   }
 
   /**
-   * This checks the passed executable element against override-error codes.
+   * Check the given [executableElement] against override-error codes. The
+   * [overriddenExecutable] is the element that the executable element is
+   * overriding. The [parameters] is the parameters of the executable element.
+   * The [errorNameTarget] is the node to report problems on.
    *
-   * @param executableElement a non-null [ExecutableElement] to evaluate
-   * @param overriddenExecutable the element that the executableElement is overriding
-   * @param parameters the parameters of the executable element
-   * @param errorNameTarget the node to report problems on
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC],
    * [CompileTimeErrorCode.INVALID_OVERRIDE_REQUIRED],
    * [CompileTimeErrorCode.INVALID_OVERRIDE_POSITIONAL],
    * [CompileTimeErrorCode.INVALID_OVERRIDE_NAMED],
    * [StaticWarningCode.INVALID_GETTER_OVERRIDE_RETURN_TYPE],
    * [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE],
    * [StaticWarningCode.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE],
    * [StaticWarningCode.INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE],
    * [StaticWarningCode.INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE],
    * [StaticWarningCode.INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE], and
@@ skipping 138 matching lines @@
             overridingType,
             overriddenType,
             overriddenExecutable.enclosingElement.displayName
           ]);
           return true;
         }
       }
     }
     // SWC.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES
     //
-    // Create three arrays: an array of the optional parameter ASTs
-    // (FormalParameters), an array of the optional parameters elements from our
-    // method, and finally an array of the optional parameter elements from the
+    // Create three lists: a list of the optional parameter ASTs
+    // (FormalParameters), a list of the optional parameters elements from our
+    // method, and finally a list of the optional parameter elements from the
     // method we are overriding.
     //
     bool foundError = false;
     List<AstNode> formalParameters = new List<AstNode>();
     List<ParameterElementImpl> parameterElts = new List<ParameterElementImpl>();
     List<ParameterElementImpl> overriddenParameterElts =
         new List<ParameterElementImpl>();
     List<ParameterElement> overriddenPEs = overriddenExecutable.parameters;
     for (int i = 0; i < parameters.length; i++) {
       ParameterElement parameter = parameters[i];
@@ skipping 87 matching lines @@
             ]);
             foundError = true;
           }
         }
       }
     }
     return foundError;
   }
 
   /**
-   * This checks the passed executable element against override-error codes. This method computes
-   * the passed executableElement is overriding and calls
-   * [checkForAllInvalidOverrideErrorCodes]
-   * when the [InheritanceManager] returns a [MultiplyInheritedExecutableElement], this
-   * method loops through the array in the [MultiplyInheritedExecutableElement].
-   *
-   * @param executableElement a non-null [ExecutableElement] to evaluate
-   * @param parameters the parameters of the executable element
-   * @param errorNameTarget the node to report problems on
-   * @return `true` if and only if an error code is generated on the passed node
+   * Check the given [executableElement] against override-error codes. This
+   * method computes the given executableElement is overriding and calls
+   * [_checkForAllInvalidOverrideErrorCodes] when the [InheritanceManager]
+   * returns a [MultiplyInheritedExecutableElement], this method loops through
+   * the list in the [MultiplyInheritedExecutableElement]. The [parameters] are
+   * the parameters of the executable element. The [errorNameTarget] is the node
+   * to report problems on.
    */
   bool _checkForAllInvalidOverrideErrorCodesForExecutable(
       ExecutableElement executableElement, List<ParameterElement> parameters,
       List<AstNode> parameterLocations, SimpleIdentifier errorNameTarget) {
     //
     // Compute the overridden executable from the InheritanceManager
     //
     List<ExecutableElement> overriddenExecutables = _inheritanceManager
         .lookupOverrides(_enclosingClass, executableElement.name);
     if (_checkForInstanceMethodNameCollidesWithSuperclassStatic(
         executableElement, errorNameTarget)) {
       return true;
     }
     for (ExecutableElement overriddenElement in overriddenExecutables) {
       if (_checkForAllInvalidOverrideErrorCodes(executableElement,
           overriddenElement, parameters, parameterLocations, errorNameTarget)) {
         return true;
       }
     }
     return false;
   }
 
   /**
-   * This checks the passed field declaration against override-error codes.
+   * Check the given [field] declaration against override-error codes.
    *
-   * @param node the [MethodDeclaration] to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [_checkForAllInvalidOverrideErrorCodes].
    */
   bool _checkForAllInvalidOverrideErrorCodesForField(FieldDeclaration node) {
     if (_enclosingClass == null || node.isStatic) {
       return false;
     }
     bool hasProblems = false;
     VariableDeclarationList fields = node.fields;
     for (VariableDeclaration field in fields.variables) {
       FieldElement element = field.element as FieldElement;
@@ skipping 13 matching lines @@
         if (_checkForAllInvalidOverrideErrorCodesForExecutable(
             setter, setter.parameters, <AstNode>[fieldName], fieldName)) {
           hasProblems = true;
         }
       }
     }
     return hasProblems;
   }
 
   /**
-   * This checks the passed method declaration against override-error codes.
+   * Check the given [method] declaration against override-error codes.
    *
-   * @param node the [MethodDeclaration] to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [_checkForAllInvalidOverrideErrorCodes].
    */
   bool _checkForAllInvalidOverrideErrorCodesForMethod(MethodDeclaration node) {
     if (_enclosingClass == null ||
         node.isStatic ||
         node.body is NativeFunctionBody) {
       return false;
     }
     ExecutableElement executableElement = node.element;
     if (executableElement == null) {
       return false;
     }
     SimpleIdentifier methodName = node.name;
     if (methodName.isSynthetic) {
       return false;
     }
     FormalParameterList formalParameterList = node.parameters;
     NodeList<FormalParameter> parameterList =
         formalParameterList != null ? formalParameterList.parameters : null;
     List<AstNode> parameters =
         parameterList != null ? new List.from(parameterList) : null;
     return _checkForAllInvalidOverrideErrorCodesForExecutable(executableElement,
         executableElement.parameters, parameters, methodName);
   }
 
   /**
-   * This verifies that all classes of the passed 'with' clause are valid.
+   * Verify that all classes of the given [withClause] are valid.
    *
-   * @param node the 'with' clause to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR],
    * [CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT], and
    * [CompileTimeErrorCode.MIXIN_REFERENCES_SUPER].
    */
   bool _checkForAllMixinErrorCodes(WithClause withClause) {
     if (withClause == null) {
       return false;
     }
     bool problemReported = false;
     for (TypeName mixinName in withClause.mixinTypes) {
@@ skipping 18 matching lines @@
         }
         if (_checkForMixinReferencesSuper(mixinName, mixinElement)) {
           problemReported = true;
         }
       }
     }
     return problemReported;
   }
 
   /**
-   * This checks error related to the redirected constructors.
+   * Check for errors related to the redirected constructors.
    *
-   * @param node the constructor declaration to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.REDIRECT_TO_INVALID_RETURN_TYPE],
    * [StaticWarningCode.REDIRECT_TO_INVALID_FUNCTION_TYPE], and
    * [StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR].
    */
   bool _checkForAllRedirectConstructorErrorCodes(ConstructorDeclaration node) {
     //
     // Prepare redirected constructor node
     //
     ConstructorName redirectedConstructor = node.redirectedConstructor;
     if (redirectedConstructor == null) {
@@ skipping 50 matching lines @@
     if (!redirectedType.isSubtypeOf(constructorType)) {
       _errorReporter.reportErrorForNode(
           StaticWarningCode.REDIRECT_TO_INVALID_FUNCTION_TYPE,
           redirectedConstructor, [redirectedType, constructorType]);
       return true;
     }
     return false;
   }
 
   /**
-   * This checks that the return statement of the form <i>return e;</i> is not in a generative
-   * constructor.
+   * Check that the return [statement] of the form <i>return e;</i> is not in a
+   * generative constructor.
    *
-   * This checks that return statements without expressions are not in a generative constructor and
-   * the return type is not assignable to `null`; that is, we don't have `return;` if
-   * the enclosing method has a return type.
+   * Check that return statements without expressions are not in a generative
+   * constructor and the return type is not assignable to `null`; that is, we
+   * don't have `return;` if the enclosing method has a return type.
    *
-   * This checks that the return type matches the type of the declared return type in the enclosing
-   * method or function.
+   * Check that the return type matches the type of the declared return type in
+   * the enclosing method or function.
    *
-   * @param node the return statement to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR],
    * [StaticWarningCode.RETURN_WITHOUT_VALUE], and
    * [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE].
    */
   bool _checkForAllReturnStatementErrorCodes(ReturnStatement node) {
     FunctionType functionType =
         _enclosingFunction == null ? null : _enclosingFunction.type;
     DartType expectedReturnType = functionType == null
         ? DynamicTypeImpl.instance
         : functionType.returnType;
@@ skipping 24 matching lines @@
     } else if (_inGenerator) {
       // RETURN_IN_GENERATOR
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.RETURN_IN_GENERATOR, node);
     }
     // RETURN_OF_INVALID_TYPE
     return _checkForReturnOfInvalidType(returnExpression, expectedReturnType);
   }
 
   /**
-   * This verifies that the export namespace of the passed export directive does not export any name
-   * already exported by other export directive.
+   * Verify that the export namespace of the given export [directive] does not
+   * export any name already exported by another export directive. The
+   * [exportElement] is the [ExportElement] retrieved from the node. If the
+   * element in the node was `null`, then this method is not called. The
+   * [exportedLibrary] is the library element containing the exported element.
    *
-   * @param node the export directive node to report problem on
-   * @param exportElement the [ExportElement] retrieved from the node, if the element in the
-   *          node was `null`, then this method is not called
-   * @param exportedLibrary the library element containing the exported element
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.AMBIGUOUS_EXPORT].
    */
   bool _checkForAmbiguousExport(ExportDirective node,
       ExportElement exportElement, LibraryElement exportedLibrary) {
     if (exportedLibrary == null) {
       return false;
     }
     // check exported names
     Namespace namespace =
         new NamespaceBuilder().createExportNamespaceForDirective(exportElement);
@@ skipping 10 matching lines @@
         ]);
         return true;
       } else {
         _exportedElements[name] = element;
       }
     }
     return false;
   }
 
   /**
-   * This verifies that the passed expression can be assigned to its corresponding parameters.
+   * Verify that the given [expression] can be assigned to its corresponding
+   * parameters. The [expectedStaticType] is the expected static type of the
+   * parameter. The [actualStaticType] is the actual static type of the
+   * argument. The [expectedPropagatedType] is the expected propagated type of
+   * the parameter, may be `null`. The [actualPropagatedType] is the expected
+   * propagated type of the parameter, may be `null`.
    *
-   * This method corresponds to BestPracticesVerifier.checkForArgumentTypeNotAssignable.
+   * This method corresponds to
+   * [BestPracticesVerifier.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 error code is generated on the passed node
    * See [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE],
    * [StaticWarningCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.MAP_KEY_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE],
    * [StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE], and
    * [StaticWarningCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE].
    */
   bool _checkForArgumentTypeNotAssignable(Expression expression,
       DartType expectedStaticType, DartType actualStaticType,
       ErrorCode errorCode) {
     //
     // Warning case: test static type information
     //
     if (actualStaticType != null && expectedStaticType != null) {
       if (!actualStaticType.isAssignableTo(expectedStaticType)) {
         _errorReporter.reportTypeErrorForNode(
             errorCode, expression, [actualStaticType, expectedStaticType]);
         return true;
       }
     }
     return false;
   }
 
   /**
-   * This verifies that the passed argument can be assigned to its corresponding parameter.
+   * Verify that the given [argument] can be assigned to its corresponding
+   * parameter.
    *
-   * This method corresponds to BestPracticesVerifier.checkForArgumentTypeNotAssignableForArgument.
+   * This method corresponds to
+   * [BestPracticesVerifier.checkForArgumentTypeNotAssignableForArgument].
    *
-   * @param argument the argument to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE].
    */
   bool _checkForArgumentTypeNotAssignableForArgument(Expression argument) {
     if (argument == null) {
       return false;
     }
     ParameterElement staticParameterElement = argument.staticParameterElement;
     DartType staticParameterType =
         staticParameterElement == null ? null : staticParameterElement.type;
     return _checkForArgumentTypeNotAssignableWithExpectedTypes(argument,
         staticParameterType, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
   }
 
   /**
-   * This verifies that the passed expression can be assigned to its corresponding parameters.
+   * Verify that the given [expression] can be assigned to its corresponding
+   * parameters. The [expectedStaticType] is the expected static type. The
+   * [expectedPropagatedType] is the expected propagated type, may be `null`.
    *
    * This method corresponds to
-   * BestPracticesVerifier.checkForArgumentTypeNotAssignableWithExpectedTypes.
+   * [BestPracticesVerifier.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 error code is generated on the passed node
    * See [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE],
    * [StaticWarningCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.MAP_KEY_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE],
    * [StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE], and
    * [StaticWarningCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE].
    */
   bool _checkForArgumentTypeNotAssignableWithExpectedTypes(
       Expression expression, DartType expectedStaticType,
       ErrorCode errorCode) => _checkForArgumentTypeNotAssignable(
           expression, expectedStaticType, getStaticType(expression), errorCode);
 
   /**
-   * This verifies that the passed arguments can be assigned to their corresponding parameters.
+   * Verify that the arguments in the given [argumentList] can be assigned to
+   * their corresponding parameters.
    *
-   * This method corresponds to BestPracticesVerifier.checkForArgumentTypesNotAssignableInList.
+   * This method corresponds to
+   * [BestPracticesVerifier.checkForArgumentTypesNotAssignableInList].
    *
-   * @param node the arguments to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.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;
   }
 
   /**
-   * Check that the static type of the given expression is assignable to the given type. If it
-   * isn't, report an error with the given error code.
-   *
-   * @param expression the expression being tested
-   * @param type the type that the expression must be assignable to
-   * @param errorCode the error code to be reported
-   * @param arguments the arguments to pass in when creating the error
-   * @return `true` if an error was reported
+   * Check that the static type of the given expression is assignable to the
+   * given type. If it isn't, report an error with the given error code. The
+   * [type] is the type that the expression must be assignable to. The
+   * [errorCode] is the error code to be reported. The [arguments] are the
+   * arguments to pass in when creating the error.
    */
   bool _checkForAssignability(Expression expression, InterfaceType type,
       ErrorCode errorCode, List<Object> arguments) {
     if (expression == null) {
       return false;
     }
     DartType expressionType = expression.staticType;
     if (expressionType == null) {
       return false;
     }
     if (expressionType.isAssignableTo(type)) {
       return false;
     }
     _errorReporter.reportErrorForNode(errorCode, expression, arguments);
     return true;
   }
 
   /**
-   * This verifies that the passed expression is not final.
+   * Verify that the given [expression] is not final.
    *
-   * @param node the expression to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.ASSIGNMENT_TO_CONST],
    * [StaticWarningCode.ASSIGNMENT_TO_FINAL], and
    * [StaticWarningCode.ASSIGNMENT_TO_METHOD].
    */
   bool _checkForAssignmentToFinal(Expression expression) {
     // prepare element
     Element element = null;
     AstNode highlightedNode = expression;
     if (expression is Identifier) {
       element = expression.staticElement;
@@ skipping 38 matching lines @@
     }
     if (element is MethodElement) {
       _errorReporter.reportErrorForNode(
           StaticWarningCode.ASSIGNMENT_TO_METHOD, expression);
       return true;
     }
     return false;
   }
 
   /**
-   * This verifies that the passed identifier is not a keyword, and generates the passed error code
-   * on the identifier if it is a keyword.
+   * Verify that the given [identifier] is not a keyword, and generates the
+   * given [errorCode] on the identifier if it is a keyword.
    *
-   * @param identifier the identifier to check to ensure that it is not a keyword
-   * @param errorCode if the passed identifier is a keyword then this error code is created on the
-   *          identifier, the error code will be one of
-   *          [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME],
-   *          [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_PARAMETER_NAME] or
-   *          [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME]
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME],
    * [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_PARAMETER_NAME], and
    * [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME].
    */
   bool _checkForBuiltInIdentifierAsName(
       SimpleIdentifier identifier, ErrorCode errorCode) {
     sc.Token token = identifier.token;
     if (token.type == sc.TokenType.KEYWORD) {
       _errorReporter.reportErrorForNode(
           errorCode, identifier, [identifier.name]);
       return true;
     }
     return false;
   }
 
   /**
-   * This verifies that the given switch case is terminated with 'break', 'continue', 'return' or
-   * 'throw'.
+   * Verify that the given [switchCase] is terminated with 'break', 'continue',
+   * 'return' or 'throw'.
    *
-   * @param node the switch case to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * see [StaticWarningCode.CASE_BLOCK_NOT_TERMINATED].
    */
   bool _checkForCaseBlockNotTerminated(SwitchCase node) {
     NodeList<Statement> statements = node.statements;
     if (statements.isEmpty) {
       // fall-through without statements at all
       AstNode parent = node.parent;
       if (parent is SwitchStatement) {
         SwitchStatement switchStatement = parent;
         NodeList<SwitchMember> members = switchStatement.members;
@@ skipping 19 matching lines @@
         }
       }
     }
     // report error
     _errorReporter.reportErrorForToken(
         StaticWarningCode.CASE_BLOCK_NOT_TERMINATED, node.keyword);
     return true;
   }
 
   /**
-   * This verifies that the switch cases in the given switch statement is terminated with 'break',
-   * 'continue', 'return' or 'throw'.
+   * Verify that the switch cases in the given switch [statement] are terminated
+   * with 'break', 'continue', 'return' or 'throw'.
    *
-   * @param node the switch statement containing the cases to be checked
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.CASE_BLOCK_NOT_TERMINATED].
    */
   bool _checkForCaseBlocksNotTerminated(SwitchStatement node) {
     bool foundError = false;
     NodeList<SwitchMember> members = node.members;
     int lastMember = members.length - 1;
     for (int i = 0; i < lastMember; i++) {
       SwitchMember member = members[i];
       if (member is SwitchCase && _checkForCaseBlockNotTerminated(member)) {
         foundError = true;
       }
     }
     return foundError;
   }
 
   /**
-   * This verifies that the passed method declaration is abstract only if the enclosing class is
-   * also abstract.
+   * Verify that the given [method] declaration is abstract only if the
+   * enclosing class is also abstract.
    *
-   * @param node the method declaration to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER].
    */
   bool _checkForConcreteClassWithAbstractMember(MethodDeclaration node) {
     if (node.isAbstract &&
         _enclosingClass != null &&
         !_enclosingClass.isAbstract) {
       SimpleIdentifier nameNode = node.name;
       String memberName = nameNode.name;
       ExecutableElement overriddenMember;
       if (node.isGetter) {
@@ skipping 12 matching lines @@
           memberName,
           _enclosingClass.displayName
         ]);
         return true;
       }
     }
     return false;
   }
 
   /**
-   * This verifies all possible conflicts of the constructor name with other constructors and
-   * members of the same class.
+   * Verify all possible conflicts of the given [constructor]'s name with other
+   * constructors and members of the same class. The [constructorElement] is the
+   * constructor's element.
    *
-   * @param node the constructor declaration to evaluate
-   * @param constructorElement the constructor element
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT],
    * [CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_NAME],
    * [CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD], and
    * [CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD].
    */
   bool _checkForConflictingConstructorNameAndMember(
       ConstructorDeclaration node, ConstructorElement constructorElement) {
     SimpleIdentifier constructorName = node.name;
     String name = constructorElement.name;
     ClassElement classElement = constructorElement.enclosingElement;
@@ skipping 32 matching lines @@
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD, node,
             [name]);
         return true;
       }
     }
     return false;
   }
 
   /**
-   * This verifies that the [enclosingClass] does not have a method and getter pair with the
-   * same name on, via inheritance.
+   * Verify that the [enclosingClass] does not have a method and getter pair
+   * with the same name on, via inheritance.
    *
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.CONFLICTING_GETTER_AND_METHOD], and
    * [CompileTimeErrorCode.CONFLICTING_METHOD_AND_GETTER].
    */
   bool _checkForConflictingGetterAndMethod() {
     if (_enclosingClass == null) {
       return false;
     }
     bool hasProblem = false;
     // method declared in the enclosing class vs. inherited getter
     for (MethodElement method in _enclosingClass.methods) {
@@ skipping 34 matching lines @@
         _enclosingClass.displayName,
         inherited.enclosingElement.displayName,
         name
       ]);
     }
     // done
     return hasProblem;
   }
 
   /**
-   * This verifies that the superclass of the [enclosingClass] does not declare accessible
-   * static members with the same name as the instance getters/setters declared in
-   * [enclosingClass].
+   * Verify that the superclass of the [enclosingClass] does not declare
+   * accessible static members with the same name as the instance
+   * getters/setters declared in [enclosingClass].
    *
-   * @param node the method declaration to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER], and
    * [StaticWarningCode.CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER].
    */
   bool _checkForConflictingInstanceGetterAndSuperclassMember() {
     if (_enclosingClass == null) {
       return false;
     }
     InterfaceType enclosingType = _enclosingClass.type;
     // check every accessor
     bool hasProblem = false;
@@ skipping 43 matching lines @@
         _errorReporter.reportErrorForElement(
             StaticWarningCode.CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER,
             accessor, [superElementType.displayName]);
       }
     }
     // done
     return hasProblem;
   }
 
   /**
-   * This verifies that the enclosing class does not have a setter with the same name as the passed
-   * instance method declaration.
+   * Verify that the enclosing class does not have a setter with the same name
+   * as the given instance method declaration.
    *
-   * TODO(jwren) add other "conflicting" error codes into algorithm/ data structure
+   * TODO(jwren) add other "conflicting" error codes into algorithm/ data
+   * structure.
    *
-   * @param node the method declaration to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.CONFLICTING_INSTANCE_METHOD_SETTER].
    */
   bool _checkForConflictingInstanceMethodSetter(ClassDeclaration node) {
     // Reference all of the class members in this class.
     NodeList<ClassMember> classMembers = node.members;
     if (classMembers.isEmpty) {
       return false;
     }
     // Create a HashMap to track conflicting members, and then loop through
     // members in the class to construct the HashMap, at the same time,
@@ skipping 70 matching lines @@
           } else {
             memberHashMap[name.name] = method;
           }
         }
       }
     }
     return foundError;
   }
 
   /**
-   * This verifies that the enclosing class does not have an instance member with the same name as
-   * the passed static getter method declaration.
+   * Verify that the enclosing class does not have an instance member with the
+   * same name as the given static [method] declaration.
    *
-   * @param node the method declaration to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER].
    */
   bool _checkForConflictingStaticGetterAndInstanceSetter(
       MethodDeclaration node) {
     if (!node.isStatic) {
       return false;
     }
     // prepare name
     SimpleIdentifier nameNode = node.name;
     if (nameNode == null) {
@@ skipping 19 matching lines @@
     ClassElement setterClass = setter.enclosingElement as ClassElement;
     InterfaceType setterType = setterClass.type;
     // report problem
     _errorReporter.reportErrorForNode(
         StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER,
         nameNode, [setterType.displayName]);
     return true;
   }
 
   /**
-   * This verifies that the enclosing class does not have an instance member with the same name as
-   * the passed static getter method declaration.
+   * Verify that the enclosing class does not have an instance member with the
+   * same name as the given static [method] declaration.
    *
-   * @param node the method declaration to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER].
    */
   bool _checkForConflictingStaticSetterAndInstanceMember(
       MethodDeclaration node) {
     if (!node.isStatic) {
       return false;
     }
     // prepare name
     SimpleIdentifier nameNode = node.name;
     if (nameNode == null) {
@@ skipping 25 matching lines @@
     ClassElement memberClass = member.enclosingElement as ClassElement;
     InterfaceType memberType = memberClass.type;
     // report problem
     _errorReporter.reportErrorForNode(
         StaticWarningCode.CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER,
         nameNode, [memberType.displayName]);
     return true;
   }
 
   /**
-   * This verifies all conflicts between type variable and enclosing class. TODO(scheglov)
+   * Verify all conflicts between type variable and enclosing class.
+   * TODO(scheglov)
    *
-   * @param node the class declaration to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_CLASS], and
    * [CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_MEMBER].
    */
   bool _checkForConflictingTypeVariableErrorCodes(ClassDeclaration node) {
     bool problemReported = false;
     for (TypeParameterElement typeParameter in _enclosingClass.typeParameters) {
       String name = typeParameter.name;
       // name is same as the name of the enclosing class
       if (_enclosingClass.name == name) {
         _errorReporter.reportErrorForOffset(
             CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_CLASS,
             typeParameter.nameOffset, name.length, [name]);
         problemReported = true;
       }
       // check members
       if (_enclosingClass.getMethod(name) != null ||
           _enclosingClass.getGetter(name) != null ||
           _enclosingClass.getSetter(name) != null) {
         _errorReporter.reportErrorForOffset(
             CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_MEMBER,
             typeParameter.nameOffset, name.length, [name]);
         problemReported = true;
       }
     }
     return problemReported;
   }
 
   /**
-   * This verifies that if the passed constructor declaration is 'const' then there are no
-   * invocations of non-'const' super constructors.
+   * Verify that if the given [constructor] declaration is 'const' then there
+   * are no invocations of non-'const' super constructors.
    *
-   * @param node the constructor declaration to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER].
    */
   bool _checkForConstConstructorWithNonConstSuper(ConstructorDeclaration node) {
     if (!_isEnclosingConstructorConst) {
       return false;
     }
     // OK, const factory, checked elsewhere
     if (node.factoryKeyword != null) {
       return false;
     }
@@ skipping 34 matching lines @@
       return false;
     }
     // default constructor is not 'const', report problem
     _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER,
         node.returnType, [supertype.displayName]);
     return true;
   }
 
   /**
-   * This verifies that if the passed constructor declaration is 'const' then there are no non-final
-   * instance variable.
+   * Verify that if the given constructor [declaration] is 'const' then there
+   * are no non-final instance variable. The [constructorElement] is the
+   * constructor element.
    *
-   * @param node the constructor declaration to evaluate
-   * @param constructorElement the constructor element
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD].
    */
   bool _checkForConstConstructorWithNonFinalField(
       ConstructorDeclaration node, ConstructorElement constructorElement) {
     if (!_isEnclosingConstructorConst) {
       return false;
     }
     // check if there is non-final field
     ClassElement classElement = constructorElement.enclosingElement;
     if (!classElement.hasNonFinalField) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD, node);
     return true;
   }
 
   /**
-   * This verifies that the passed 'const' instance creation expression is not creating a deferred
-   * type.
+   * Verify that the given 'const' instance creation [expression] is not
+   * creating a deferred type. The [constructorName] is the constructor name,
+   * always non-`null`. The [typeName] is the name of the type defining the
+   * constructor, always non-`null`.
    *
-   * @param node the instance creation expression to evaluate
-   * @param constructorName the constructor name, always non-`null`
-   * @param typeName the name of the type defining the constructor, always non-`null`
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.CONST_DEFERRED_CLASS].
    */
   bool _checkForConstDeferredClass(InstanceCreationExpression node,
       ConstructorName constructorName, TypeName typeName) {
     if (typeName.isDeferred) {
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.CONST_DEFERRED_CLASS, constructorName,
           [typeName.name.name]);
       return true;
     }
     return false;
   }
 
   /**
-   * This verifies that the passed throw expression is not enclosed in a 'const' constructor
-   * declaration.
+   * Verify that the given throw [expression] is not enclosed in a 'const'
+   * constructor declaration.
    *
-   * @param node the throw expression expression to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION].
    */
   bool _checkForConstEvalThrowsException(ThrowExpression node) {
     if (_isEnclosingConstructorConst) {
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION, node);
       return true;
     }
     return false;
   }
 
   /**
-   * This verifies that the passed normal formal parameter is not 'const'.
+   * Verify that the given normal formal [parameter] is not 'const'.
    *
-   * @param node the normal formal parameter to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.CONST_FORMAL_PARAMETER].
    */
   bool _checkForConstFormalParameter(NormalFormalParameter node) {
     if (node.isConst) {
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.CONST_FORMAL_PARAMETER, node);
       return true;
     }
     return false;
   }
 
   /**
-   * This verifies that the passed instance creation expression is not being invoked on an abstract
-   * class.
+   * Verify that the given instance creation [expression] is not being invoked
+   * on an abstract class. The [typeName] is the [TypeName] of the
+   * [ConstructorName] from the [InstanceCreationExpression], this is the AST
+   * node that the error is attached to. The [type] is the type being
+   * constructed with this [InstanceCreationExpression].
    *
-   * @param node the instance creation expression to evaluate
-   * @param typeName the [TypeName] of the [ConstructorName] from the
-   *          [InstanceCreationExpression], this is the AST node that the error is attached to
-   * @param type the type being constructed with this [InstanceCreationExpression]
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.CONST_WITH_ABSTRACT_CLASS], and
    * [StaticWarningCode.NEW_WITH_ABSTRACT_CLASS].
    */
   bool _checkForConstOrNewWithAbstractClass(
       InstanceCreationExpression node, TypeName typeName, InterfaceType type) {
     if (type.element.isAbstract) {
       ConstructorElement element = node.staticElement;
       if (element != null && !element.isFactory) {
         if ((node.keyword as sc.KeywordToken).keyword == sc.Keyword.CONST) {
           _errorReporter.reportErrorForNode(
               StaticWarningCode.CONST_WITH_ABSTRACT_CLASS, typeName);
         } else {
           _errorReporter.reportErrorForNode(
               StaticWarningCode.NEW_WITH_ABSTRACT_CLASS, typeName);
         }
         return true;
       }
     }
     return false;
   }
 
   /**
-   * This verifies that the passed instance creation expression is not being invoked on an enum.
+   * Verify that the given instance creation [expression] is not being invoked
+   * on an enum. The [typeName] is the [TypeName] of the [ConstructorName] from
+   * the [InstanceCreationExpression], this is the AST node that the error is
+   * attached to. The [type] is the type being constructed with this
+   * [InstanceCreationExpression].
    *
-   * @param node the instance creation expression to verify
-   * @param typeName the [TypeName] of the [ConstructorName] from the
-   *          [InstanceCreationExpression], this is the AST node that the error is attached to
-   * @param type the type being constructed with this [InstanceCreationExpression]
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.INSTANTIATE_ENUM].
    */
   bool _checkForConstOrNewWithEnum(
       InstanceCreationExpression node, TypeName typeName, InterfaceType type) {
     if (type.element.isEnum) {
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.INSTANTIATE_ENUM, typeName);
       return true;
     }
     return false;
   }
 
   /**
-   * This verifies that the passed 'const' instance creation expression is not being invoked on a
-   * constructor that is not 'const'.
+   * Verify that the given 'const' instance creation [expression] is not being
+   * invoked on a constructor that is not 'const'.
    *
-   * This method assumes that the instance creation was tested to be 'const' before being called.
+   * This method assumes that the instance creation was tested to be 'const'
+   * before being called.
    *
-   * @param node the instance creation expression to verify
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.CONST_WITH_NON_CONST].
    */
   bool _checkForConstWithNonConst(InstanceCreationExpression node) {
     ConstructorElement constructorElement = node.staticElement;
     if (constructorElement != null && !constructorElement.isConst) {
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.CONST_WITH_NON_CONST, node);
       return true;
     }
     return false;
   }
 
   /**
-   * This verifies that the passed type name does not reference any type parameters.
+   * Verify that the given [typeName] does not reference any type parameters.
    *
-   * @param typeName the type name to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS].
    */
   bool _checkForConstWithTypeParameters(TypeName typeName) {
     // something wrong with AST
     if (typeName == null) {
       return false;
     }
     Identifier name = typeName.name;
     if (name == null) {
       return false;
@@ skipping 12 matching lines @@
           hasError = true;
         }
       }
       return hasError;
     }
     // OK
     return false;
   }
 
   /**
-   * This verifies that if the passed 'const' instance creation expression is being invoked on the
-   * resolved constructor.
+   * Verify that if the given 'const' instance creation [expression] is being
+   * invoked on the resolved constructor. The [constructorName] is the
+   * constructor name, always non-`null`. The [typeName] is the name of the type
+   * defining the constructor, always non-`null`.
    *
-   * This method assumes that the instance creation was tested to be 'const' before being called.
+   * This method assumes that the instance creation was tested to be 'const'
+   * before being called.
    *
-   * @param node the instance creation expression to evaluate
-   * @param constructorName the constructor name, always non-`null`
-   * @param typeName the name of the type defining the constructor, always non-`null`
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR], and
    * [CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT].
    */
   bool _checkForConstWithUndefinedConstructor(InstanceCreationExpression node,
       ConstructorName constructorName, TypeName typeName) {
     // OK if resolved
     if (node.staticElement != null) {
       return false;
     }
     DartType type = typeName.type;
@@ skipping 15 matching lines @@
       ]);
     } else {
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT,
           constructorName, [className]);
     }
     return true;
   }
 
   /**
-   * This verifies that there are no default parameters in the passed function type alias.
+   * Verify that there are no default parameters in the given function type
+   * [alias].
    *
-   * @param node the function type alias to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS].
    */
   bool _checkForDefaultValueInFunctionTypeAlias(FunctionTypeAlias node) {
     bool result = false;
     FormalParameterList formalParameterList = node.parameters;
     NodeList<FormalParameter> parameters = formalParameterList.parameters;
     for (FormalParameter formalParameter in parameters) {
       if (formalParameter is DefaultFormalParameter) {
         DefaultFormalParameter defaultFormalParameter = formalParameter;
         if (defaultFormalParameter.defaultValue != null) {
           _errorReporter.reportErrorForNode(
               CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS, node);
           result = true;
         }
       }
     }
     return result;
   }
 
   /**
-   * This verifies that the given default formal parameter is not part of a function typed
-   * parameter.
+   * Verify that the given default formal [parameter] is not part of a function
+   * typed parameter.
    *
-   * @param node the default formal parameter to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER].
    */
   bool _checkForDefaultValueInFunctionTypedParameter(
       DefaultFormalParameter node) {
     // OK, not in a function typed parameter.
     if (!_isInFunctionTypedFormalParameter) {
       return false;
     }
     // OK, no default value.
     if (node.defaultValue == null) {
       return false;
     }
     // Report problem.
     _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER, node);
     return true;
   }
 
   /**
-   * This verifies that any deferred imports in the given compilation unit have a unique prefix.
+   * Verify that any deferred imports in the given compilation [unit] have a
+   * unique prefix.
    *
-   * @param node the compilation unit containing the imports to be checked
-   * @return `true` if an error was generated
    * See [CompileTimeErrorCode.SHARED_DEFERRED_PREFIX].
    */
   bool _checkForDeferredPrefixCollisions(CompilationUnit node) {
     bool foundError = false;
     NodeList<Directive> directives = node.directives;
     int count = directives.length;
     if (count > 0) {
       HashMap<PrefixElement, List<ImportDirective>> prefixToDirectivesMap =
           new HashMap<PrefixElement, List<ImportDirective>>();
       for (int i = 0; i < count; i++) {
@@ skipping 19 matching lines @@
       for (List<ImportDirective> imports in prefixToDirectivesMap.values) {
         if (_hasDeferredPrefixCollision(imports)) {
           foundError = true;
         }
       }
     }
     return foundError;
   }
 
   /**
-   * This verifies that the enclosing class does not have an instance member with the given name of
-   * the static member.
+   * Verify that the enclosing class does not have an instance member with the
+   * given name of the static member.
    *
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE].
    */
   bool _checkForDuplicateDefinitionInheritance() {
     if (_enclosingClass == null) {
       return false;
     }
     bool hasProblem = false;
     for (ExecutableElement member in _enclosingClass.methods) {
       if (member.isStatic && _checkForDuplicateDefinitionOfMember(member)) {
         hasProblem = true;
       }
     }
     for (ExecutableElement member in _enclosingClass.accessors) {
       if (member.isStatic && _checkForDuplicateDefinitionOfMember(member)) {
         hasProblem = true;
       }
     }
     return hasProblem;
   }
 
   /**
-   * This verifies that the enclosing class does not have an instance member with the given name of
-   * the static member.
+   * Verify that the enclosing class does not have an instance member with the
+   * given name of the [staticMember].
    *
-   * @param staticMember the static member to check conflict for
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE].
    */
   bool _checkForDuplicateDefinitionOfMember(ExecutableElement staticMember) {
     // prepare name
     String name = staticMember.name;
     if (name == null) {
       return false;
     }
     // try to find member
     ExecutableElement inheritedMember =
@@ skipping 15 matching lines @@
       displayName = enclosingElement.getExtendedDisplayName(null);
     }
     // report problem
     _errorReporter.reportErrorForOffset(
         CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE,
         staticMember.nameOffset, name.length, [name, displayName]);
     return true;
   }
 
   /**
-   * This verifies if the passed list literal has type arguments then there is exactly one.
+   * Verify that if the given list [literal] has type arguments then there is
+   * exactly one. The [typeArguments] are the type arguments.
    *
-   * @param node the list literal to evaluate
-   * @param typeArguments the type arguments, always non-`null`
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticTypeWarningCode.EXPECTED_ONE_LIST_TYPE_ARGUMENTS].
    */
   bool _checkForExpectedOneListTypeArgument(
       ListLiteral node, TypeArgumentList typeArguments) {
     // check number of type arguments
     int num = typeArguments.arguments.length;
     if (num == 1) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
         StaticTypeWarningCode.EXPECTED_ONE_LIST_TYPE_ARGUMENTS, typeArguments,
         [num]);
     return true;
   }
 
   /**
-   * This verifies the passed import has unique name among other exported libraries.
+   * Verify that the given export ([node]) has a unique name among other
+   * exported libraries. The [exportElement] is the [ExportElement] retrieved
+   * from the node, if the element in the node was `null`, then this method is
+   * not called. The [exportedLibrary] is the library element containing the
+   * exported element.
    *
-   * @param node the export directive to evaluate
-   * @param exportElement the [ExportElement] retrieved from the node, if the element in the
-   *          node was `null`, then this method is not called
-   * @param exportedLibrary the library element containing the exported element
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.EXPORT_DUPLICATED_LIBRARY_NAME].
    */
   bool _checkForExportDuplicateLibraryName(ExportDirective node,
       ExportElement exportElement, LibraryElement exportedLibrary) {
     if (exportedLibrary == null) {
       return false;
     }
     String name = exportedLibrary.name;
     // check if there is other exported library with the same name
     LibraryElement prevLibrary = _nameToExportElement[name];
@@ skipping 16 matching lines @@
         return true;
       }
     } else {
       _nameToExportElement[name] = exportedLibrary;
     }
     // OK
     return false;
   }
 
   /**
-   * Check that if the visiting library is not system, then any passed library should not be SDK
-   * internal library.
+   * Check that if the visiting library is not system, then any given library
+   * should not be SDK internal library. The [exportElement] is the
+   * [ExportElement] retrieved from the node, if the element in the node was
+   * `null`, then this method is not called.
    *
-   * @param node the export directive to evaluate
-   * @param exportElement the [ExportElement] retrieved from the node, if the element in the
-   *          node was `null`, then this method is not called
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.EXPORT_INTERNAL_LIBRARY].
    */
   bool _checkForExportInternalLibrary(
       ExportDirective node, ExportElement exportElement) {
     if (_isInSystemLibrary) {
       return false;
     }
     // should be private
     DartSdk sdk = _currentLibrary.context.sourceFactory.dartSdk;
     String uri = exportElement.uri;
     SdkLibrary sdkLibrary = sdk.getSdkLibrary(uri);
     if (sdkLibrary == null) {
       return false;
     }
     if (!sdkLibrary.isInternal) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.EXPORT_INTERNAL_LIBRARY, node, [node.uri]);
     return true;
   }
 
   /**
-   * This verifies that the passed extends clause does not extend a deferred class.
+   * Verify that the given extends [clause] does not extend a deferred class.
    *
-   * @param node the extends clause to test
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS].
    */
   bool _checkForExtendsDeferredClass(ExtendsClause node) {
     if (node == null) {
       return false;
     }
     return _checkForExtendsOrImplementsDeferredClass(
         node.superclass, CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS);
   }
 
   /**
-   * This verifies that the passed type alias does not extend a deferred class.
+   * Verify that the given type [alias] does not extend a deferred class.
    *
-   * @param node the extends clause to test
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS].
    */
   bool _checkForExtendsDeferredClassInTypeAlias(ClassTypeAlias node) {
     if (node == null) {
       return false;
     }
     return _checkForExtendsOrImplementsDeferredClass(
         node.superclass, CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS);
   }
 
   /**
-   * This verifies that the passed extends clause does not extend classes such as num or String.
+   * Verify that the given extends [clause] does not extend classes such as
+   * 'num' or 'String'.
    *
-   * @param node the extends clause to test
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS].
    */
   bool _checkForExtendsDisallowedClass(ExtendsClause node) {
     if (node == null) {
       return false;
     }
     return _checkForExtendsOrImplementsDisallowedClass(
         node.superclass, CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS);
   }
 
   /**
-   * This verifies that the passed type alias does not extend classes such as num or String.
+   * Verify that the given type [alias] does not extend classes such as 'num' or
+   * 'String'.
    *
-   * @param node the extends clause to test
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS].
    */
   bool _checkForExtendsDisallowedClassInTypeAlias(ClassTypeAlias node) {
     if (node == null) {
       return false;
     }
     return _checkForExtendsOrImplementsDisallowedClass(
         node.superclass, CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS);
   }
 
   /**
-   * This verifies that the passed type name does not extend, implement or mixin classes that are
-   * deferred.
+   * Verify that the given [typeName] does not extend, implement or mixin
+   * classes that are deferred.
    *
-   * @param node the type name to test
-   * @return `true` if and only if an error code is generated on the passed node
    * See [_checkForExtendsDeferredClass],
    * [_checkForExtendsDeferredClassInTypeAlias],
    * [_checkForImplementsDeferredClass],
    * [_checkForAllMixinErrorCodes],
    * [CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS],
    * [CompileTimeErrorCode.IMPLEMENTS_DEFERRED_CLASS], and
    * [CompileTimeErrorCode.MIXIN_DEFERRED_CLASS].
    */
   bool _checkForExtendsOrImplementsDeferredClass(
       TypeName typeName, ErrorCode errorCode) {
     if (typeName.isSynthetic) {
       return false;
     }
     if (typeName.isDeferred) {
       _errorReporter.reportErrorForNode(
           errorCode, typeName, [typeName.name.name]);
       return true;
     }
     return false;
   }
 
   /**
-   * This verifies that the passed type name does not extend, implement or mixin classes such as
-   * 'num' or 'String'.
+   * Verify that the given [typeName] does not extend, implement or mixin
+   * classes such as 'num' or 'String'.
    *
-   * @param node the type name to test
-   * @return `true` if and only if an error code is generated on the passed node
    * See [_checkForExtendsDisallowedClass],
    * [_checkForExtendsDisallowedClassInTypeAlias],
    * [_checkForImplementsDisallowedClass],
    * [_checkForAllMixinErrorCodes],
    * [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS],
    * [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS], and
    * [CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS].
    */
   bool _checkForExtendsOrImplementsDisallowedClass(
       TypeName typeName, ErrorCode errorCode) {
@@ skipping 26 matching lines @@
         // otherwise, report the error
         _errorReporter.reportErrorForNode(
             errorCode, typeName, [disallowedType.displayName]);
         return true;
       }
     }
     return false;
   }
 
   /**
-   * This verifies that the passed constructor field initializer has compatible field and
-   * initializer expression types.
+   * Verify that the given constructor field [initializer] has compatible field
+   * and initializer expression types. The [staticElement] is the static element
+   * from the name in the [ConstructorFieldInitializer].
    *
-   * @param node the constructor field initializer to test
-   * @param staticElement the static element from the name in the
-   *          [ConstructorFieldInitializer]
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE], and
    * [StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE].
    */
   bool _checkForFieldInitializerNotAssignable(
       ConstructorFieldInitializer node, Element staticElement) {
     // prepare field element
     if (staticElement is! FieldElement) {
       return false;
     }
     FieldElement fieldElement = staticElement as FieldElement;
@@ skipping 44 matching lines @@
 //          errorReporter.reportTypeErrorForNode(
 //              StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE,
 //              expression,
 //              propagatedType == null ? staticType : propagatedType,
 //              fieldType);
 //        }
 //        return true;
   }
 
   /**
-   * This verifies that the passed field formal parameter is in a constructor declaration.
+   * Verify that the given field formal [parameter] is in a constructor
+   * declaration.
    *
-   * @param node the field formal parameter to test
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR].
    */
   bool _checkForFieldInitializingFormalRedirectingConstructor(
       FieldFormalParameter node) {
     ConstructorDeclaration constructor =
         node.getAncestor((node) => node is ConstructorDeclaration);
     if (constructor == null) {
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR, node);
       return true;
@@ skipping 11 matching lines @@
             CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR,
             node);
         return true;
       }
     }
     // OK
     return false;
   }
 
   /**
-   * This verifies that the passed variable declaration list has only initialized variables if the
-   * list is final or const. This method is called by
-   * [checkForFinalNotInitializedInClass],
-   * [visitTopLevelVariableDeclaration] and
-   * [visitVariableDeclarationStatement].
+   * Verify that the given variable declaration [list] has only initialized
+   * variables if the list is final or const.
    *
-   * @param node the class declaration to test
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.CONST_NOT_INITIALIZED], and
    * [StaticWarningCode.FINAL_NOT_INITIALIZED].
    */
   bool _checkForFinalNotInitialized(VariableDeclarationList node) {
     if (_isInNativeClass) {
       return false;
     }
     bool foundError = false;
     if (!node.isSynthetic) {
       NodeList<VariableDeclaration> variables = node.variables;
       for (VariableDeclaration variable in variables) {
         if (variable.initializer == null) {
           if (node.isConst) {
             _errorReporter.reportErrorForNode(
                 CompileTimeErrorCode.CONST_NOT_INITIALIZED, variable.name,
                 [variable.name.name]);
           } else if (node.isFinal) {
             _errorReporter.reportErrorForNode(
                 StaticWarningCode.FINAL_NOT_INITIALIZED, variable.name,
                 [variable.name.name]);
           }
           foundError = true;
         }
       }
     }
     return foundError;
   }
 
   /**
-   * This verifies that final fields that are declared, without any constructors in the enclosing
-   * class, are initialized. Cases in which there is at least one constructor are handled at the end
-   * of [checkForAllFinalInitializedErrorCodes].
+   * Verify that final fields in the given clas [declaration] that are declared,
+   * without any constructors in the enclosing class, are initialized. Cases in
+   * which there is at least one constructor are handled at the end of
+   * [_checkForAllFinalInitializedErrorCodes].
    *
-   * @param node the class declaration to test
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.CONST_NOT_INITIALIZED], and
    * [StaticWarningCode.FINAL_NOT_INITIALIZED].
    */
   bool _checkForFinalNotInitializedInClass(ClassDeclaration node) {
     NodeList<ClassMember> classMembers = node.members;
     for (ClassMember classMember in classMembers) {
       if (classMember is ConstructorDeclaration) {
         return false;
       }
     }
@@ skipping 35 matching lines @@
     } else if (_enclosingFunction.isGenerator) {
       if (!_enclosingFunction.returnType
           .isAssignableTo(_typeProvider.iterableDynamicType)) {
         _errorReporter.reportErrorForNode(
             StaticTypeWarningCode.ILLEGAL_SYNC_GENERATOR_RETURN_TYPE, node);
       }
     }
   }
 
   /**
-   * This verifies that the passed implements clause does not implement classes that are deferred.
+   * Verify that the given implements [clause] does not implement classes that
+   * are deferred.
    *
-   * @param node the implements clause to test
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.IMPLEMENTS_DEFERRED_CLASS].
    */
   bool _checkForImplementsDeferredClass(ImplementsClause node) {
     if (node == null) {
       return false;
     }
     bool foundError = false;
     for (TypeName type in node.interfaces) {
       if (_checkForExtendsOrImplementsDeferredClass(
           type, CompileTimeErrorCode.IMPLEMENTS_DEFERRED_CLASS)) {
         foundError = true;
       }
     }
     return foundError;
   }
 
   /**
-   * This verifies that the passed implements clause does not implement classes such as 'num' or
-   * 'String'.
+   * Verify that the given implements [clause] does not implement classes such
+   * as 'num' or 'String'.
    *
-   * @param node the implements clause to test
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS].
    */
   bool _checkForImplementsDisallowedClass(ImplementsClause node) {
     if (node == null) {
       return false;
     }
     bool foundError = false;
     for (TypeName type in node.interfaces) {
       if (_checkForExtendsOrImplementsDisallowedClass(
           type, CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS)) {
         foundError = true;
       }
     }
     return foundError;
   }
 
   /**
-   * This verifies that if the passed identifier is part of constructor initializer, then it does
-   * not reference implicitly 'this' expression.
+   * Verify that if the given [identifier] is part of a constructor initializer,
+   * then it does not implicitly reference 'this' expression.
    *
-   * @param node the simple identifier to test
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER], and
    * [CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC].
    * TODO(scheglov) rename thid method
    */
   bool _checkForImplicitThisReferenceInInitializer(SimpleIdentifier node) {
     if (!_isInConstructorInitializer &&
         !_isInStaticMethod &&
         !_isInFactory &&
         !_isInInstanceVariableInitializer &&
         !_isInStaticVariableDeclaration) {
@@ skipping 48 matching lines @@
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_FACTORY, node);
     } else {
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER, node);
     }
     return true;
   }
 
   /**
-   * This verifies the passed import has unique name among other imported libraries.
+   * Verify that the given import [directive] has a unique name among other
+   * imported libraries. The [importElement] is the [ImportElement] retrieved
+   * from the node, if the element in the node was `null`, then this method is
+   * not called.
    *
-   * @param node the import directive to evaluate
-   * @param importElement the [ImportElement] retrieved from the node, if the element in the
-   *          node was `null`, then this method is not called
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.IMPORT_DUPLICATED_LIBRARY_NAME].
    */
   bool _checkForImportDuplicateLibraryName(
       ImportDirective node, ImportElement importElement) {
     // prepare imported library
     LibraryElement nodeLibrary = importElement.importedLibrary;
     if (nodeLibrary == null) {
       return false;
     }
     String name = nodeLibrary.name;
@@ skipping 18 matching lines @@
         return true;
       }
     } else {
       _nameToImportElement[name] = nodeLibrary;
     }
     // OK
     return false;
   }
 
   /**
-   * Check that if the visiting library is not system, then any passed library should not be SDK
-   * internal library.
+   * Check that if the visiting library is not system, then any given library
+   * should not be SDK internal library. The [importElement] is the
+   * [ImportElement] retrieved from the node, if the element in the node was
+   * `null`, then this method is not called
    *
-   * @param node the import directive to evaluate
-   * @param importElement the [ImportElement] retrieved from the node, if the element in the
-   *          node was `null`, then this method is not called
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY].
    */
   bool _checkForImportInternalLibrary(
       ImportDirective node, ImportElement importElement) {
     if (_isInSystemLibrary) {
       return false;
     }
     // should be private
     DartSdk sdk = _currentLibrary.context.sourceFactory.dartSdk;
     String uri = importElement.uri;
     SdkLibrary sdkLibrary = sdk.getSdkLibrary(uri);
     if (sdkLibrary == null) {
       return false;
     }
     if (!sdkLibrary.isInternal) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY, node, [node.uri]);
     return true;
   }
 
   /**
-   * For each class declaration, this method is called which verifies that all inherited members are
-   * inherited consistently.
+   * For each class declaration, this method is called which verifies that all
+   * inherited members are inherited consistently.
    *
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE].
    */
   bool _checkForInconsistentMethodInheritance() {
     // Ensure that the inheritance manager has a chance to generate all errors
     // we may care about, note that we ensure that the interfaces data since
     // there are no errors.
     _inheritanceManager.getMapOfMembersInheritedFromInterfaces(_enclosingClass);
     HashSet<AnalysisError> errors =
         _inheritanceManager.getErrors(_enclosingClass);
     if (errors == null || errors.isEmpty) {
       return false;
     }
     for (AnalysisError error in errors) {
       _errorReporter.reportError(error);
     }
     return true;
   }
 
   /**
-   * This checks the given "typeReference" is not a type reference and that then the "name" is
-   * reference to an instance member.
+   * Check that the given [typeReference] is not a type reference and that then
+   * the [name] is reference to an instance member.
    *
-   * @param typeReference the resolved [ClassElement] of the left hand side of the expression,
-   *          or `null`, aka, the class element of 'C' in 'C.x', see
-   *          [getTypeReference]
-   * @param name the accessed name to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER].
    */
   bool _checkForInstanceAccessToStaticMember(
       ClassElement typeReference, SimpleIdentifier name) {
     // OK, in comment
     if (_isInComment) {
       return false;
     }
     // OK, target is a type
     if (typeReference != null) {
@@ skipping 14 matching lines @@
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
         StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER, name,
         [name.name]);
     return true;
   }
 
   /**
-   * This checks whether the given [executableElement] collides with the name of a static
-   * method in one of its superclasses, and reports the appropriate warning if it does.
+   * Check whether the given [executableElement] collides with the name of a
+   * static method in one of its superclasses, and reports the appropriate
+   * warning if it does. The [errorNameTarget] is the node to report problems
+   * on.
    *
-   * @param executableElement the method to check.
-   * @param errorNameTarget the node to report problems on.
-   * @return `true` if and only if a warning was generated.
    * See [StaticTypeWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC].
    */
   bool _checkForInstanceMethodNameCollidesWithSuperclassStatic(
       ExecutableElement executableElement, SimpleIdentifier errorNameTarget) {
     String executableElementName = executableElement.name;
     if (executableElement is! PropertyAccessorElement &&
         !executableElement.isOperator) {
       HashSet<ClassElement> visitedClasses = new HashSet<ClassElement>();
       InterfaceType superclassType = _enclosingClass.supertype;
       ClassElement superclassElement =
@@ skipping 49 matching lines @@
         }
         superclassType = superclassElement.supertype;
         superclassElement =
             superclassType == null ? null : superclassType.element;
       }
     }
     return false;
   }
 
   /**
-   * This verifies that an 'int' can be assigned to the parameter corresponding to the given
-   * expression. This is used for prefix and postfix expressions where the argument value is
-   * implicit.
+   * Verify that an 'int' can be assigned to the parameter corresponding to the
+   * given [expression]. This is used for prefix and postfix expressions where
+   * the argument value is implicit.
    *
-   * @param argument the expression to which the operator is being applied
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE].
    */
   bool _checkForIntNotAssignable(Expression argument) {
     if (argument == null) {
       return false;
     }
     ParameterElement staticParameterElement = argument.staticParameterElement;
     DartType staticParameterType =
         staticParameterElement == null ? null : staticParameterElement.type;
     return _checkForArgumentTypeNotAssignable(argument, staticParameterType,
         _intType, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
   }
 
   /**
-   * This verifies that the passed [Annotation] isn't defined in a deferred library.
+   * Verify that the given [annotation] isn't defined in a deferred library.
    *
-   * @param node the [Annotation]
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.INVALID_ANNOTATION_FROM_DEFERRED_LIBRARY].
    */
   bool _checkForInvalidAnnotationFromDeferredLibrary(Annotation node) {
     Identifier nameIdentifier = node.name;
     if (nameIdentifier is PrefixedIdentifier) {
       if (nameIdentifier.isDeferred) {
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.INVALID_ANNOTATION_FROM_DEFERRED_LIBRARY,
             node.name);
         return true;
       }
     }
     return false;
   }
 
   /**
-   * This verifies that the passed left hand side and right hand side represent a valid assignment.
+   * Verify that the given left hand side ([lhs]) and right hand side ([rhs])
+   * represent a valid assignment.
    *
-   * @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 [StaticTypeWarningCode.INVALID_ASSIGNMENT].
    */
   bool _checkForInvalidAssignment(Expression lhs, Expression rhs) {
     if (lhs == null || rhs == null) {
       return false;
     }
     VariableElement leftVariableElement = getVariableElement(lhs);
     DartType leftType = (leftVariableElement == null)
         ? getStaticType(lhs)
         : leftVariableElement.type;
     DartType staticRightType = getStaticType(rhs);
     if (!staticRightType.isAssignableTo(leftType)) {
       _errorReporter.reportTypeErrorForNode(
           StaticTypeWarningCode.INVALID_ASSIGNMENT, rhs, [
         staticRightType,
         leftType
       ]);
       return true;
     }
     return false;
   }
 
   /**
-   * Given an assignment using a compound assignment operator, this verifies that the given
-   * assignment is valid.
+   * Given an [assignment] using a compound assignment operator, this verifies
+   * that the given assignment is valid. The [lhs] is the left hand side
+   * expression. The [rhs] is the right hand side expression.
    *
-   * @param node the assignment expression being tested
-   * @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 [StaticTypeWarningCode.INVALID_ASSIGNMENT].
    */
   bool _checkForInvalidCompoundAssignment(
       AssignmentExpression node, Expression lhs, Expression rhs) {
     if (lhs == null) {
       return false;
     }
     VariableElement leftVariableElement = getVariableElement(lhs);
     DartType leftType = (leftVariableElement == null)
         ? getStaticType(lhs)
         : leftVariableElement.type;
     MethodElement invokedMethod = node.staticElement;
     if (invokedMethod == null) {
       return false;
     }
     DartType rightType = invokedMethod.type.returnType;
     if (leftType == null || rightType == null) {
       return false;
     }
     if (!rightType.isAssignableTo(leftType)) {
       _errorReporter.reportTypeErrorForNode(
           StaticTypeWarningCode.INVALID_ASSIGNMENT, rhs, [rightType, leftType]);
       return true;
     }
     return false;
   }
 
   /**
-   * Check the given initializer to ensure that the field being initialized is a valid field.
-   *
-   * @param node the field initializer being checked
-   * @param fieldName the field name from the [ConstructorFieldInitializer]
-   * @param staticElement the static element from the name in the
-   *          [ConstructorFieldInitializer]
+   * Check the given [initializer] to ensure that the field being initialized is
+   * a valid field. The [fieldName] is the field name from the
+   * [ConstructorFieldInitializer]. The [staticElement] is the static element
+   * from the name in the [ConstructorFieldInitializer].
    */
   void _checkForInvalidField(ConstructorFieldInitializer node,
       SimpleIdentifier fieldName, Element staticElement) {
     if (staticElement is FieldElement) {
       FieldElement fieldElement = staticElement;
       if (fieldElement.isSynthetic) {
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTENT_FIELD, node,
             [fieldName]);
       } else if (fieldElement.isStatic) {
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD, node,
             [fieldName]);
       }
     } else {
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTENT_FIELD, node,
           [fieldName]);
       return;
     }
   }
 
   /**
-   * Check to see whether the given function body has a modifier associated with it, and report it
-   * as an error if it does.
-   *
-   * @param body the function body being checked
-   * @param errorCode the error code to be reported if a modifier is found
-   * @return `true` if an error was reported
+   * Check to see whether the given function [body] has a modifier associated
+   * with it, and report it as an error if it does.
    */
   bool _checkForInvalidModifierOnBody(
       FunctionBody body, CompileTimeErrorCode errorCode) {
     sc.Token keyword = body.keyword;
     if (keyword != null) {
       _errorReporter.reportErrorForToken(errorCode, keyword, [keyword.lexeme]);
       return true;
     }
     return false;
   }
 
   /**
-   * This verifies that the usage of the passed 'this' is valid.
+   * Verify that the usage of the given 'this' is valid.
    *
-   * @param node the 'this' expression to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS].
    */
   bool _checkForInvalidReferenceToThis(ThisExpression node) {
     if (!_isThisInValidContext(node)) {
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS, node);
       return true;
     }
     return false;
   }
 
   /**
-   * Checks to ensure that the passed [ListLiteral] or [MapLiteral] does not have a type
-   * parameter as a type argument.
-   *
-   * @param arguments a non-`null`, non-empty [TypeName] node list from the respective
-   *          [ListLiteral] or [MapLiteral]
-   * @param errorCode either [CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_LIST] or
-   *          [CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_MAP]
-   * @return `true` if and only if an error code is generated on the passed node
+   * Checks to ensure that the given list of type [arguments] does not have a
+   * type parameter as a type argument. The [errorCode] is either
+   * [CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_LIST] or
+   * [CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_MAP].
    */
   bool _checkForInvalidTypeArgumentInConstTypedLiteral(
       NodeList<TypeName> arguments, ErrorCode errorCode) {
     bool foundError = false;
     for (TypeName typeName in arguments) {
       if (typeName.type is TypeParameterType) {
         _errorReporter.reportErrorForNode(errorCode, typeName, [typeName.name]);
         foundError = true;
       }
     }
     return foundError;
   }
 
   /**
-   * This verifies that the elements given [ListLiteral] are subtypes of the specified element
-   * type.
+   * Verify that the elements given [ListLiteral] are subtypes of the specified
+   * element type. The [typeArguments] are the type arguments.
    *
-   * @param node the list literal to evaluate
-   * @param typeArguments the type arguments, always non-`null`
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE], and
    * [StaticWarningCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE].
    */
   bool _checkForListElementTypeNotAssignable(
       ListLiteral node, TypeArgumentList typeArguments) {
     NodeList<TypeName> typeNames = typeArguments.arguments;
     if (typeNames.length < 1) {
       return false;
     }
     DartType listElementType = typeNames[0].type;
@@ skipping 12 matching lines @@
       if (_checkForArgumentTypeNotAssignableWithExpectedTypes(element,
           listElementType,
           StaticWarningCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE)) {
         hasProblems = true;
       }
     }
     return hasProblems;
   }
 
   /**
-   * This verifies that the key/value of entries of the given [MapLiteral] are subtypes of the
-   * key/value types specified in the type arguments.
+   * Verify that the key/value of entries of the given map [literal] are
+   * subtypes of the key/value types specified in the type arguments. The
+   * [typeArguments] are the type arguments.
    *
-   * @param node the map literal to evaluate
-   * @param typeArguments the type arguments, always non-`null`
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.MAP_KEY_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE],
    * [StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE], and
    * [StaticWarningCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE].
    */
   bool _checkForMapTypeNotAssignable(
       MapLiteral node, TypeArgumentList typeArguments) {
     // Prepare maps key/value types.
     NodeList<TypeName> typeNames = typeArguments.arguments;
     if (typeNames.length < 2) {
@@ skipping 26 matching lines @@
       }
       if (_checkForArgumentTypeNotAssignableWithExpectedTypes(
           value, valueType, StaticWarningCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE)) {
         hasProblems = true;
       }
     }
     return hasProblems;
   }
 
   /**
-   * This verifies that the [enclosingClass] does not define members with the same name as
-   * the enclosing class.
+   * Verify that the [enclosingClass] does not define members with the same name
+   * as the enclosing class.
    *
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.MEMBER_WITH_CLASS_NAME].
    */
   bool _checkForMemberWithClassName() {
     if (_enclosingClass == null) {
       return false;
     }
     String className = _enclosingClass.name;
     if (className == null) {
       return false;
     }
     bool problemReported = false;
     // check accessors
     for (PropertyAccessorElement accessor in _enclosingClass.accessors) {
       if (className == accessor.name) {
         _errorReporter.reportErrorForOffset(
             CompileTimeErrorCode.MEMBER_WITH_CLASS_NAME, accessor.nameOffset,
             className.length);
         problemReported = true;
       }
     }
     // don't check methods, they would be constructors
     // done
     return problemReported;
   }
 
   /**
-   * Check to make sure that all similarly typed accessors are of the same type (including inherited
-   * accessors).
+   * Check to make sure that all similarly typed accessors are of the same type
+   * (including inherited accessors).
    *
-   * @param node the accessor currently being visited
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES], and
    * [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE].
    */
   bool _checkForMismatchedAccessorTypes(
       Declaration accessorDeclaration, String accessorTextName) {
     ExecutableElement accessorElement =
         accessorDeclaration.element as ExecutableElement;
     if (accessorElement is! PropertyAccessorElement) {
       return false;
     }
@@ skipping 69 matching lines @@
           setterType,
           getterType,
           enclosingClassForCounterpart.displayName
         ]);
       }
     }
     return false;
   }
 
   /**
-   * Check to make sure that switch statements whose static type is an enum type either have a
-   * default case or include all of the enum constants.
-   *
-   * @param statement the switch statement to check
-   * @return `true` if and only if an error code is generated on the passed node
+   * Check to make sure that the given switch [statement] whose static type is
+   * an enum type either have a default case or include all of the enum
+   * constants.
    */
   bool _checkForMissingEnumConstantInSwitch(SwitchStatement statement) {
     // TODO(brianwilkerson) This needs to be checked after constant values have
     // been computed.
     Expression expression = statement.expression;
     DartType expressionType = getStaticType(expression);
     if (expressionType == null) {
       return false;
     }
     Element expressionElement = expressionType.element;
@@ skipping 31 matching lines @@
     }
     for (int i = 0; i < nameCount; i++) {
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.MISSING_ENUM_CONSTANT_IN_SWITCH, statement,
           [constantNames[i]]);
     }
     return true;
   }
 
   /**
-   * This verifies that the given function body does not contain return statements that both have
-   * and do not have return values.
+   * Verify that the given function [body] does not contain return statements
+   * that both have and do not have return values.
    *
-   * @param node the function body being tested
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.MIXED_RETURN_TYPES].
    */
   bool _checkForMixedReturns(BlockFunctionBody node) {
     if (_hasReturnWithoutValue) {
       return false;
     }
     int withCount = _returnsWith.length;
     int withoutCount = _returnsWithout.length;
     if (withCount > 0 && withoutCount > 0) {
       for (int i = 0; i < withCount; i++) {
         _errorReporter.reportErrorForToken(StaticWarningCode.MIXED_RETURN_TYPES,
             _returnsWith[i].returnKeyword);
       }
       for (int i = 0; i < withoutCount; i++) {
         _errorReporter.reportErrorForToken(StaticWarningCode.MIXED_RETURN_TYPES,
             _returnsWithout[i].returnKeyword);
       }
       return true;
     }
     return false;
   }
 
   /**
-   * This verifies that the passed mixin does not have an explicitly declared constructor.
+   * Verify that the given mixin does not have an explicitly declared
+   * constructor. The [mixinName] is the node to report problem on. The
+   * [mixinElement] is the mixing to evaluate.
    *
-   * @param mixinName the node to report problem on
-   * @param mixinElement the mixing to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR].
    */
   bool _checkForMixinDeclaresConstructor(
       TypeName mixinName, ClassElement mixinElement) {
     for (ConstructorElement constructor in mixinElement.constructors) {
       if (!constructor.isSynthetic && !constructor.isFactory) {
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR, mixinName,
             [mixinElement.name]);
         return true;
       }
     }
     return false;
   }
 
   /**
-   * This verifies that the passed mixin has the 'Object' superclass.
+   * Verify that the given mixin has the 'Object' superclass. The [mixinName] is
+   * the node to report problem on. The [mixinElement] is the mixing to
+   * evaluate.
    *
-   * @param mixinName the node to report problem on
-   * @param mixinElement the mixing to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT].
    */
   bool _checkForMixinInheritsNotFromObject(
       TypeName mixinName, ClassElement mixinElement) {
     InterfaceType mixinSupertype = mixinElement.supertype;
     if (mixinSupertype != null) {
       if (!mixinSupertype.isObject ||
           !mixinElement.isTypedef && mixinElement.mixins.length != 0) {
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT, mixinName,
             [mixinElement.name]);
         return true;
       }
     }
     return false;
   }
 
   /**
-   * This verifies that the passed mixin does not reference 'super'.
+   * Verify that the given mixin does not reference 'super'. The [mixinName] is
+   * the node to report problem on. The [mixinElement] is the mixing to
+   * evaluate.
    *
-   * @param mixinName the node to report problem on
-   * @param mixinElement the mixing to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.MIXIN_REFERENCES_SUPER].
    */
   bool _checkForMixinReferencesSuper(
       TypeName mixinName, ClassElement mixinElement) {
     if (mixinElement.hasReferenceToSuper) {
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.MIXIN_REFERENCES_SUPER, mixinName,
           [mixinElement.name]);
     }
     return false;
   }
 
   /**
-   * This verifies that the passed constructor has at most one 'super' initializer.
+   * Verify that the given [constructor] has at most one 'super' initializer.
    *
-   * @param node the constructor declaration to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.MULTIPLE_SUPER_INITIALIZERS].
    */
   bool _checkForMultipleSuperInitializers(ConstructorDeclaration node) {
     int numSuperInitializers = 0;
     for (ConstructorInitializer initializer in node.initializers) {
       if (initializer is SuperConstructorInvocation) {
         numSuperInitializers++;
         if (numSuperInitializers > 1) {
           _errorReporter.reportErrorForNode(
               CompileTimeErrorCode.MULTIPLE_SUPER_INITIALIZERS, initializer);
         }
       }
     }
     return numSuperInitializers > 0;
   }
 
   /**
-   * Checks to ensure that native function bodies can only in SDK code.
+   * Checks to ensure that the given native function [body] is in SDK code.
    *
-   * @param node the native function body to test
-   * @return `true` if and only if an error code is generated on the passed node
    * See [ParserErrorCode.NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE].
    */
   bool _checkForNativeFunctionBodyInNonSDKCode(NativeFunctionBody node) {
     if (!_isInSystemLibrary && !_hasExtUri) {
       _errorReporter.reportErrorForNode(
           ParserErrorCode.NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE, node);
       return true;
     }
     return false;
   }
 
   /**
-   * This verifies that the passed 'new' instance creation expression invokes existing constructor.
+   * Verify that the given instance creation [expression] invokes an existing
+   * constructor. The [constructorName] is the constructor name. The [typeName]
+   * is the name of the type defining the constructor.
    *
-   * This method assumes that the instance creation was tested to be 'new' before being called.
+   * This method assumes that the instance creation was tested to be 'new'
+   * before being called.
    *
-   * @param node the instance creation expression to evaluate
-   * @param constructorName the constructor name, always non-`null`
-   * @param typeName the name of the type defining the constructor, always non-`null`
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR].
    */
   bool _checkForNewWithUndefinedConstructor(InstanceCreationExpression node,
       ConstructorName constructorName, TypeName typeName) {
     // OK if resolved
     if (node.staticElement != null) {
       return false;
     }
     DartType type = typeName.type;
     if (type is InterfaceType) {
@@ skipping 15 matching lines @@
       ]);
     } else {
       _errorReporter.reportErrorForNode(
           StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT,
           constructorName, [className]);
     }
     return true;
   }
 
   /**
-   * This checks that if the passed class declaration implicitly calls default constructor of its
-   * superclass, there should be such default constructor - implicit or explicit.
+   * Check that if the given class [declaration] implicitly calls default
+   * constructor of its superclass, there should be such default constructor -
+   * implicit or explicit.
    *
-   * @param node the [ClassDeclaration] to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT].
    */
   bool _checkForNoDefaultSuperConstructorImplicit(ClassDeclaration node) {
     // do nothing if mixin errors have already been reported for this class.
     ClassElementImpl enclosingClass = _enclosingClass;
     if (enclosingClass.mixinErrorsReported) {
       return false;
     }
     // do nothing if there is explicit constructor
     List<ConstructorElement> constructors = _enclosingClass.constructors;
@@ skipping 23 matching lines @@
       }
     }
     // report problem
     _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT, node.name,
         [superType.displayName]);
     return true;
   }
 
   /**
-   * This checks that passed class declaration overrides all members required by its superclasses
-   * and interfaces.
+   * Check that the given class declaration overrides all members required by
+   * its superclasses and interfaces. The [classNameNode] is the
+   * [SimpleIdentifier] to be used if there is a violation, this is either the
+   * named from the [ClassDeclaration] or from the [ClassTypeAlias].
    *
-   * @param classNameNode the [SimpleIdentifier] to be used if there is a violation, this is
-   *          either the named from the [ClassDeclaration] or from the [ClassTypeAlias].
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE],
    * [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO],
    * [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE],
    * [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR], and
    * [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS].
    */
   bool _checkForNonAbstractClassInheritsAbstractMember(
       SimpleIdentifier classNameNode) {
     if (_enclosingClass.isAbstract) {
       return false;
@@ skipping 152 matching lines @@
         stringMembersArray.length - 4
       ]);
     }
     analysisError.setProperty(
         ErrorProperty.UNIMPLEMENTED_METHODS, missingOverridesArray);
     _errorReporter.reportError(analysisError);
     return true;
   }
 
   /**
-   * Checks to ensure that the expressions that need to be of type bool, are. Otherwise an error is
-   * reported on the expression.
+   * Check to ensure that the [condition] is of type bool, are. Otherwise an
+   * error is reported on the expression.
    *
-   * @param condition the conditional expression to test
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticTypeWarningCode.NON_BOOL_CONDITION].
    */
   bool _checkForNonBoolCondition(Expression condition) {
     DartType conditionType = getStaticType(condition);
     if (conditionType != null && !conditionType.isAssignableTo(_boolType)) {
       _errorReporter.reportErrorForNode(
           StaticTypeWarningCode.NON_BOOL_CONDITION, condition);
       return true;
     }
     return false;
   }
 
   /**
-   * This verifies that the passed assert statement has either a 'bool' or '() -> bool' input.
+   * Verify that the given assert [statement] has either a 'bool' or
+   * '() -> bool' input.
    *
-   * @param node the assert statement to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticTypeWarningCode.NON_BOOL_EXPRESSION].
    */
   bool _checkForNonBoolExpression(AssertStatement node) {
     Expression expression = node.condition;
     DartType type = getStaticType(expression);
     if (type is InterfaceType) {
       if (!type.isAssignableTo(_boolType)) {
         _errorReporter.reportErrorForNode(
             StaticTypeWarningCode.NON_BOOL_EXPRESSION, expression);
         return true;
       }
     } else if (type is FunctionType) {
       FunctionType functionType = type;
       if (functionType.typeArguments.length == 0 &&
           !functionType.returnType.isAssignableTo(_boolType)) {
         _errorReporter.reportErrorForNode(
             StaticTypeWarningCode.NON_BOOL_EXPRESSION, expression);
         return true;
       }
     }
     return false;
   }
 
   /**
-   * Checks to ensure that the given expression is assignable to bool.
+   * Checks to ensure that the given [expression] is assignable to bool.
    *
-   * @param expression the expression expression to test
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticTypeWarningCode.NON_BOOL_NEGATION_EXPRESSION].
    */
   bool _checkForNonBoolNegationExpression(Expression expression) {
     DartType conditionType = getStaticType(expression);
     if (conditionType != null && !conditionType.isAssignableTo(_boolType)) {
       _errorReporter.reportErrorForNode(
           StaticTypeWarningCode.NON_BOOL_NEGATION_EXPRESSION, expression);
       return true;
     }
     return false;
   }
 
   /**
-   * This verifies the passed map literal either:
+   * Verify the given map [literal] either:
    * * has `const modifier`
    * * has explicit type arguments
    * * is not start of the statement
    *
-   * @param node the map literal to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.NON_CONST_MAP_AS_EXPRESSION_STATEMENT].
    */
   bool _checkForNonConstMapAsExpressionStatement(MapLiteral node) {
     // "const"
     if (node.constKeyword != null) {
       return false;
     }
     // has type arguments
     if (node.typeArguments != null) {
       return false;
     }
     // prepare statement
     Statement statement =
         node.getAncestor((node) => node is ExpressionStatement);
     if (statement == null) {
       return false;
     }
     // OK, statement does not start with map
     if (!identical(statement.beginToken, node.beginToken)) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.NON_CONST_MAP_AS_EXPRESSION_STATEMENT, node);
     return true;
   }
 
   /**
-   * This verifies the passed method declaration of operator `[]=`, has `void` return
-   * type.
+   * Verify that the given method [declaration] of operator `[]=`, has `void`
+   * return type.
    *
-   * @param node the method declaration to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.NON_VOID_RETURN_FOR_OPERATOR].
    */
   bool _checkForNonVoidReturnTypeForOperator(MethodDeclaration node) {
     // check that []= operator
     SimpleIdentifier name = node.name;
     if (name.name != "[]=") {
       return false;
     }
     // check return type
     TypeName typeName = node.returnType;
     if (typeName != null) {
       DartType type = typeName.type;
       if (type != null && !type.isVoid) {
         _errorReporter.reportErrorForNode(
             StaticWarningCode.NON_VOID_RETURN_FOR_OPERATOR, typeName);
       }
     }
     // no warning
     return false;
   }
 
   /**
-   * This verifies the passed setter has no return type or the `void` return type.
+   * Verify the given setter has no return type or the `void` return type.
    *
-   * @param typeName the type name to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.NON_VOID_RETURN_FOR_SETTER].
    */
   bool _checkForNonVoidReturnTypeForSetter(TypeName typeName) {
     if (typeName != null) {
       DartType type = typeName.type;
       if (type != null && !type.isVoid) {
         _errorReporter.reportErrorForNode(
             StaticWarningCode.NON_VOID_RETURN_FOR_SETTER, typeName);
       }
     }
     return false;
   }
 
   /**
-   * This verifies the passed operator-method declaration, does not have an optional parameter.
+   * Verify the given operator-method [declaration], does not have an optional
+   * parameter. This method assumes that the method declaration was tested to be
+   * an operator declaration before being called.
    *
-   * This method assumes that the method declaration was tested to be an operator declaration before
-   * being called.
-   *
-   * @param node the method declaration to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.OPTIONAL_PARAMETER_IN_OPERATOR].
    */
   bool _checkForOptionalParameterInOperator(MethodDeclaration node) {
     FormalParameterList parameterList = node.parameters;
     if (parameterList == null) {
       return false;
     }
     bool foundError = false;
     NodeList<FormalParameter> formalParameters = parameterList.parameters;
     for (FormalParameter formalParameter in formalParameters) {
       if (formalParameter.kind.isOptional) {
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.OPTIONAL_PARAMETER_IN_OPERATOR,
             formalParameter);
         foundError = true;
       }
     }
     return foundError;
   }
 
   /**
-   * This checks for named optional parameters that begin with '_'.
+   * Check that the given named optional [parameter] does not begin with '_'.
    *
-   * @param node the default formal parameter to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER].
    */
   bool _checkForPrivateOptionalParameter(FormalParameter node) {
     // should be named parameter
     if (node.kind != ParameterKind.NAMED) {
       return false;
     }
     // name should start with '_'
     SimpleIdentifier name = node.identifier;
     if (name.isSynthetic || !StringUtilities.startsWithChar(name.name, 0x5F)) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER, node);
     return true;
   }
 
   /**
-   * This checks if the passed constructor declaration is the redirecting generative constructor and
-   * references itself directly or indirectly.
+   * Check whether the given constructor [declaration] is the redirecting
+   * generative constructor and references itself directly or indirectly. The
+   * [constructorElement] is the constructor element.
    *
-   * @param node the constructor declaration to evaluate
-   * @param constructorElement the constructor element
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.RECURSIVE_CONSTRUCTOR_REDIRECT].
    */
   bool _checkForRecursiveConstructorRedirect(
       ConstructorDeclaration node, ConstructorElement constructorElement) {
     // we check generative constructor here
     if (node.factoryKeyword != null) {
       return false;
     }
     // try to find redirecting constructor invocation and analyzer it for
     // recursion
     for (ConstructorInitializer initializer in node.initializers) {
       if (initializer is RedirectingConstructorInvocation) {
         // OK if no cycle
         if (!_hasRedirectingFactoryConstructorCycle(constructorElement)) {
           return false;
         }
         // report error
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.RECURSIVE_CONSTRUCTOR_REDIRECT, initializer);
         return true;
       }
     }
     // OK, no redirecting constructor invocation
     return false;
   }
 
   /**
-   * This checks if the passed constructor declaration has redirected constructor and references
-   * itself directly or indirectly.
+   * Check whether the given constructor [declaration] has redirected
+   * constructor and references itself directly or indirectly. The
+   * [constructorElement] is the constructor element.
    *
-   * @param node the constructor declaration to evaluate
-   * @param constructorElement the constructor element
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT].
    */
   bool _checkForRecursiveFactoryRedirect(
       ConstructorDeclaration node, ConstructorElement constructorElement) {
     // prepare redirected constructor
     ConstructorName redirectedConstructorNode = node.redirectedConstructor;
     if (redirectedConstructorNode == null) {
       return false;
     }
     // OK if no cycle
     if (!_hasRedirectingFactoryConstructorCycle(constructorElement)) {
       return false;
     }
     // report error
     _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT,
         redirectedConstructorNode);
     return true;
   }
 
   /**
-   * This checks the class declaration is not a superinterface to itself.
+   * Check that the class [element] is not a superinterface to itself.
    *
-   * @param classElt the class element to test
-   * @return `true` if and only if an error code is generated on the passed element
    * See [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE],
    * [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS], and
    * [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS].
    */
   bool _checkForRecursiveInterfaceInheritance(ClassElement classElt) {
     if (classElt == null) {
       return false;
     }
     return _safeCheckForRecursiveInterfaceInheritance(
         classElt, new List<ClassElement>());
   }
 
   /**
-   * This checks the passed constructor declaration has a valid combination of redirected
-   * constructor invocation(s), super constructor invocations and field initializers.
+   * Check that the given constructor [declaration] has a valid combination of
+   * redirected constructor invocation(s), super constructor invocations and
+   * field initializers.
    *
-   * @param node the constructor declaration to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.DEFAULT_VALUE_IN_REDIRECTING_FACTORY_CONSTRUCTOR],
    * [CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR],
    * [CompileTimeErrorCode.MULTIPLE_REDIRECTING_CONSTRUCTOR_INVOCATIONS],
    * [CompileTimeErrorCode.SUPER_IN_REDIRECTING_CONSTRUCTOR], and
    * [CompileTimeErrorCode.REDIRECT_GENERATIVE_TO_NON_GENERATIVE_CONSTRUCTOR].
    */
   bool _checkForRedirectingConstructorErrorCodes(ConstructorDeclaration node) {
     bool errorReported = false;
     //
     // Check for default values in the parameters
@@ skipping 58 matching lines @@
               initializer);
           errorReported = true;
         }
       }
     }
     // done
     return errorReported;
   }
 
   /**
-   * This checks if the passed constructor declaration has redirected constructor and references
-   * itself directly or indirectly.
+   * Check whether the given constructor [declaration] has redirected
+   * constructor and references itself directly or indirectly. The
+   * [constructorElement] is the constructor element.
    *
-   * @param node the constructor declaration to evaluate
-   * @param constructorElement the constructor element
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.REDIRECT_TO_NON_CONST_CONSTRUCTOR].
    */
   bool _checkForRedirectToNonConstConstructor(
       ConstructorDeclaration node, ConstructorElement constructorElement) {
     // prepare redirected constructor
     ConstructorName redirectedConstructorNode = node.redirectedConstructor;
     if (redirectedConstructorNode == null) {
       return false;
     }
     // prepare element
@@ skipping 15 matching lines @@
       return false;
     }
     // report error
     _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.REDIRECT_TO_NON_CONST_CONSTRUCTOR,
         redirectedConstructorNode);
     return true;
   }
 
   /**
-   * This checks that the rethrow is inside of a catch clause.
+   * Check that the given rethrow [expression] is inside of a catch clause.
    *
-   * @param node the rethrow expression to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.RETHROW_OUTSIDE_CATCH].
    */
   bool _checkForRethrowOutsideCatch(RethrowExpression node) {
     if (!_isInCatchClause) {
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.RETHROW_OUTSIDE_CATCH, node);
       return true;
     }
     return false;
   }
 
   /**
-   * This checks that if the the given constructor declaration is generative, then it does not have
-   * an expression function body.
+   * Check that if the the given constructor [declaration] is generative, then
+   * it does not have an expression function body.
    *
-   * @param node the constructor to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR].
    */
   bool _checkForReturnInGenerativeConstructor(ConstructorDeclaration node) {
     // ignore factory
     if (node.factoryKeyword != null) {
       return false;
     }
     // block body (with possible return statement) is checked elsewhere
     FunctionBody body = node.body;
     if (body is! ExpressionFunctionBody) {
       return false;
     }
     // report error
     _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR, body);
     return true;
   }
 
   /**
-   * This checks that a type mis-match between the return type and the expressed return type by the
-   * enclosing method or function.
+   * Check that a type mis-match between the type of the [returnExpression] and
+   * the [expectedReturnType] by the enclosing method or function.
    *
-   * This method is called both by [checkForAllReturnStatementErrorCodes]
+   * This method is called both by [_checkForAllReturnStatementErrorCodes]
    * and [visitExpressionFunctionBody].
    *
-   * @param returnExpression the returned expression to evaluate
-   * @param expectedReturnType the expressed return type by the enclosing method or function
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE].
    */
   bool _checkForReturnOfInvalidType(
       Expression returnExpression, DartType expectedReturnType) {
     if (_enclosingFunction == null) {
       return false;
     }
     if (_inGenerator) {
       // "return expression;" is disallowed in generators, but this is checked
       // elsewhere.  Bare "return" is always allowed in generators regardless
@@ skipping 35 matching lines @@
 //        errorReporter.reportTypeErrorForNode(
 //            StaticTypeWarningCode.RETURN_OF_INVALID_TYPE,
 //            returnExpression,
 //            staticReturnType,
 //            expectedReturnType,
 //            enclosingFunction.getDisplayName());
 //        return true;
   }
 
   /**
-   * This checks the given "typeReference" and that the "name" is not the reference to an instance
-   * member.
+   * Check the given [typeReference] and that the [name] is not the reference to
+   * an instance member.
    *
-   * @param typeReference the resolved [ClassElement] of the left hand side of the expression,
-   *          or `null`, aka, the class element of 'C' in 'C.x', see
-   *          [getTypeReference]
-   * @param name the accessed name to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER].
    */
   bool _checkForStaticAccessToInstanceMember(
       ClassElement typeReference, SimpleIdentifier name) {
     // OK, target is not a type
     if (typeReference == null) {
       return false;
     }
     // prepare member Element
     Element element = name.staticElement;
     if (element is! ExecutableElement) {
       return false;
     }
     ExecutableElement memberElement = element as ExecutableElement;
     // OK, static
     if (memberElement.isStatic) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
         StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER, name, [name.name]);
     return true;
   }
 
   /**
-   * This checks that the type of the passed 'switch' expression is assignable to the type of the
-   * 'case' members.
+   * Check that the type of the expression in the given 'switch' [statement] is
+   * assignable to the type of the 'case' members.
    *
-   * @param node the 'switch' statement to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.SWITCH_EXPRESSION_NOT_ASSIGNABLE].
    */
   bool _checkForSwitchExpressionNotAssignable(SwitchStatement node) {
     // prepare 'switch' expression type
     Expression expression = node.expression;
     DartType expressionType = getStaticType(expression);
     if (expressionType == null) {
       return false;
     }
     // compare with type of the first 'case'
@@ skipping 15 matching lines @@
           StaticWarningCode.SWITCH_EXPRESSION_NOT_ASSIGNABLE, expression, [
         expressionType,
         caseType
       ]);
       return true;
     }
     return false;
   }
 
   /**
-   * This verifies that the passed function type alias does not reference itself directly.
+   * Verify that the given function type [alias] does not reference itself
+   * directly.
    *
-   * @param node the function type alias to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF].
    */
   bool _checkForTypeAliasCannotReferenceItself_function(
       FunctionTypeAlias node) {
     FunctionTypeAliasElement element = node.element;
     if (!_hasTypedefSelfReference(element)) {
       return false;
     }
     _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF, node);
     return true;
   }
 
   /**
-   * This verifies that the passed type name is not a deferred type.
+   * Verify that the given type [name] is not a deferred type.
    *
-   * @param expression the expression to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS].
    */
   bool _checkForTypeAnnotationDeferredClass(TypeName node) {
     if (node != null && node.isDeferred) {
       _errorReporter.reportErrorForNode(
           StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS, node, [node.name]);
     }
     return false;
   }
 
   /**
-   * This verifies that the type arguments in the passed type name are all within their bounds.
+   * Verify that the type arguments in the given type [name] are all within
+   * their bounds.
    *
-   * @param node the [TypeName] to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS].
    */
   bool _checkForTypeArgumentNotMatchingBounds(TypeName node) {
     if (node.typeArguments == null) {
       return false;
     }
     // prepare Type
     DartType type = node.type;
     if (type == null) {
       return false;
@@ skipping 32 matching lines @@
           _errorReporter.reportTypeErrorForNode(
               errorCode, argTypeName, [argType, boundType]);
           foundError = true;
         }
       }
     }
     return foundError;
   }
 
   /**
-   * This checks that if the passed type name is a type parameter being used to define a static
-   * member.
+   * Check whether the given type [name] is a type parameter being used to
+   * define a static member.
    *
-   * @param node the type name to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC].
    */
   bool _checkForTypeParameterReferencedByStatic(TypeName node) {
     if (_isInStaticMethod || _isInStaticVariableDeclaration) {
       DartType type = node.type;
       if (type is TypeParameterType) {
         _errorReporter.reportErrorForNode(
             StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC, node);
         return true;
       }
     }
     return false;
   }
 
   /**
-   * This checks that if the passed type parameter is a supertype of its bound.
+   * Check whether the given type [parameter] is a supertype of its bound.
    *
-   * @param node the type parameter to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticTypeWarningCode.TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND].
    */
   bool _checkForTypeParameterSupertypeOfItsBound(TypeParameter node) {
     TypeParameterElement element = node.element;
     // prepare bound
     DartType bound = element.bound;
     if (bound == null) {
       return false;
     }
     // OK, type parameter is not supertype of its bound
     if (!bound.isMoreSpecificThan(element.type)) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
         StaticTypeWarningCode.TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND, node,
         [element.displayName]);
     return true;
   }
 
   /**
-   * This checks that if the passed generative constructor has neither an explicit super constructor
-   * invocation nor a redirecting constructor invocation, that the superclass has a default
-   * generative constructor.
+   * Check that if the given generative [constructor] has neither an explicit
+   * super constructor invocation nor a redirecting constructor invocation, that
+   * the superclass has a default generative constructor.
    *
-   * @param node the constructor declaration to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT],
    * [CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR], and
    * [StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT].
    */
   bool _checkForUndefinedConstructorInInitializerImplicit(
       ConstructorDeclaration node) {
     if (_enclosingClass == null) {
       return false;
     }
     // do nothing if mixin errors have already been reported for this class.
@@ skipping 52 matching lines @@
       }
       return false;
     }
     _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT,
         node.returnType, [superElement.name]);
     return true;
   }
 
   /**
-   * This checks that if the given name is a reference to a static member it is defined in the
-   * enclosing class rather than in a superclass.
+   * Check that if the given [name] is a reference to a static member it is
+   * defined in the enclosing class rather than in a superclass.
    *
-   * @param name the name to be evaluated
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticTypeWarningCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER].
    */
   bool _checkForUnqualifiedReferenceToNonLocalStaticMember(
       SimpleIdentifier name) {
     Element element = name.staticElement;
     if (element == null || element is TypeParameterElement) {
       return false;
     }
     Element enclosingElement = element.enclosingElement;
     if (enclosingElement is! ClassElement) {
@@ skipping 54 matching lines @@
         }
       }
     }
 //        else {
 //        // TODO(jwren) Report error, constructor initializer variable is a top level element
 //        // (Either here or in ErrorVerifier.checkForAllFinalInitializedErrorCodes)
 //        }
   }
 
   /**
-   * This verifies that the given getter does not have a return type of 'void'.
+   * Verify that the given [getter] does not have a return type of 'void'.
    *
-   * @param node the method declaration to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.VOID_RETURN_FOR_GETTER].
    */
   bool _checkForVoidReturnType(MethodDeclaration node) {
     TypeName returnType = node.returnType;
     if (returnType == null || returnType.name.name != "void") {
       return false;
     }
     _errorReporter.reportErrorForNode(
         StaticWarningCode.VOID_RETURN_FOR_GETTER, returnType);
     return true;
   }
 
   /**
-   * This verifies the passed operator-method declaration, has correct number of parameters.
+   * Verify the given operator-method [declaration], has correct number of
+   * parameters.
    *
-   * This method assumes that the method declaration was tested to be an operator declaration before
-   * being called.
+   * This method assumes that the method declaration was tested to be an
+   * operator declaration before being called.
    *
-   * @param node the method declaration to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR].
    */
   bool _checkForWrongNumberOfParametersForOperator(MethodDeclaration node) {
     // prepare number of parameters
     FormalParameterList parameterList = node.parameters;
     if (parameterList == null) {
       return false;
     }
     int numParameters = parameterList.parameters.length;
     // prepare operator name
@@ skipping 37 matching lines @@
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR_MINUS,
           nameNode, [numParameters]);
       return true;
     }
     // OK
     return false;
   }
 
   /**
-   * This verifies if the passed setter parameter list have only one required parameter.
+   * Verify that the given setter [parameterList] has only one required
+   * parameter. The [setterName] is the name of the setter to report problems
+   * on.
    *
-   * This method assumes that the method declaration was tested to be a setter before being called.
+   * This method assumes that the method declaration was tested to be a setter
+   * before being called.
    *
-   * @param setterName the name of the setter to report problems on
-   * @param parameterList the parameter list to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER].
    */
   bool _checkForWrongNumberOfParametersForSetter(
       SimpleIdentifier setterName, FormalParameterList parameterList) {
     if (setterName == null) {
       return false;
     }
     if (parameterList == null) {
       return false;
     }
@@ skipping 56 matching lines @@
           impliedReturnType,
           requiredReturnType
         ]);
         return true;
       }
     }
     return false;
   }
 
   /**
-   * This verifies that if the given class declaration implements the class Function that it has a
-   * concrete implementation of the call method.
+   * Verify that if the given class [declaration] implements the class Function
+   * that it has a concrete implementation of the call method.
    *
-   * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.FUNCTION_WITHOUT_CALL].
    */
   bool _checkImplementsFunctionWithoutCall(ClassDeclaration node) {
     if (node.isAbstract) {
       return false;
     }
     ClassElement classElement = node.element;
     if (classElement == null) {
       return false;
     }
@@ skipping 12 matching lines @@
         callMethod is! MethodElement ||
         (callMethod as MethodElement).isAbstract) {
       _errorReporter.reportErrorForNode(
           StaticWarningCode.FUNCTION_WITHOUT_CALL, node.name);
       return true;
     }
     return false;
   }
 
   /**
-   * This verifies that the given class declaration does not have the same class in the 'extends'
-   * and 'implements' clauses.
+   * Verify that the given class [declaration] does not have the same class in
+   * the 'extends' and 'implements' clauses.
    *
-   * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.IMPLEMENTS_SUPER_CLASS].
    */
   bool _checkImplementsSuperClass(ClassDeclaration node) {
     // prepare super type
     InterfaceType superType = _enclosingClass.supertype;
     if (superType == null) {
       return false;
     }
     // prepare interfaces
     ImplementsClause implementsClause = node.implementsClause;
@@ skipping 28 matching lines @@
     DartType staticReturnType = getStaticType(returnExpression);
     if (staticReturnType != null && _enclosingFunction.isAsynchronous) {
       return _typeProvider.futureType.substitute4(<DartType>[
         StaticTypeAnalyzer.flattenFutures(_typeProvider, staticReturnType)
       ]);
     }
     return staticReturnType;
   }
 
   /**
-   * Return the error code that should be used when the given class references itself directly.
-   *
-   * @param classElt the class that references itself
-   * @return the error code that should be used
+   * Return the error code that should be used when the given class [element]
+   * references itself directly.
    */
   ErrorCode _getBaseCaseErrorCode(ClassElement classElt) {
     InterfaceType supertype = classElt.supertype;
     if (supertype != null && _enclosingClass == supertype.element) {
       return CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS;
     }
     List<InterfaceType> mixins = classElt.mixins;
     for (int i = 0; i < mixins.length; i++) {
       if (_enclosingClass == mixins[i].element) {
         return CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_WITH;
       }
     }
     return CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS;
   }
 
   /**
-   * Given an expression in a switch case whose value is expected to be an enum constant, return the
-   * name of the constant.
-   *
-   * @param expression the expression from the switch case
-   * @return the name of the constant referenced by the expression
+   * Given an [expression] in a switch case whose value is expected to be an
+   * enum constant, return the name of the constant.
    */
   String _getConstantName(Expression expression) {
     // TODO(brianwilkerson) Convert this to return the element representing the
     // constant.
     if (expression is SimpleIdentifier) {
       return expression.name;
     } else if (expression is PrefixedIdentifier) {
       return expression.identifier.name;
     } else if (expression is PropertyAccess) {
       return expression.propertyName.name;
     }
     return null;
   }
 
   /**
-   * Returns the Type (return type) for a given getter.
-   *
-   * @param propertyAccessorElement
-   * @return The type of the given getter.
+   * Return the return type of the given [getter].
    */
   DartType _getGetterType(PropertyAccessorElement propertyAccessorElement) {
     FunctionType functionType = propertyAccessorElement.type;
     if (functionType != null) {
       return functionType.returnType;
     } else {
       return null;
     }
   }
 
   /**
-   * Returns the Type (first and only parameter) for a given setter.
-   *
-   * @param propertyAccessorElement
-   * @return The type of the given setter.
+   * Return the type of the first and only parameter of the given [setter].
    */
   DartType _getSetterType(PropertyAccessorElement propertyAccessorElement) {
     // Get the parameters for MethodDeclaration or FunctionDeclaration
     List<ParameterElement> setterParameters =
         propertyAccessorElement.parameters;
     // If there are no setter parameters, return no type.
     if (setterParameters.length == 0) {
       return null;
     }
     return setterParameters[0].type;
   }
 
   /**
-   * Given a list of directives that have the same prefix, generate an error if there is more than
-   * one import and any of those imports is deferred.
+   * Given a list of [directives] that have the same prefix, generate an error
+   * if there is more than one import and any of those imports is deferred.
    *
-   * @param directives the list of directives that have the same prefix
-   * @return `true` if an error was generated
    * See [CompileTimeErrorCode.SHARED_DEFERRED_PREFIX].
    */
   bool _hasDeferredPrefixCollision(List<ImportDirective> directives) {
     bool foundError = false;
     int count = directives.length;
     if (count > 1) {
       for (int i = 0; i < count; i++) {
         sc.Token deferredToken = directives[i].deferredKeyword;
         if (deferredToken != null) {
           _errorReporter.reportErrorForToken(
               CompileTimeErrorCode.SHARED_DEFERRED_PREFIX, deferredToken);
           foundError = true;
         }
       }
     }
     return foundError;
   }
 
   /**
-   * @return `true` if the given constructor redirects to itself, directly or indirectly
+   * Return `true` if the given [constructor] redirects to itself, directly or
+   * indirectly.
    */
   bool _hasRedirectingFactoryConstructorCycle(ConstructorElement element) {
     Set<ConstructorElement> constructors = new HashSet<ConstructorElement>();
     ConstructorElement current = element;
     while (current != null) {
       if (constructors.contains(current)) {
         return identical(current, element);
       }
       constructors.add(current);
       current = current.redirectedConstructor;
       if (current is ConstructorMember) {
         current = (current as ConstructorMember).baseElement;
       }
     }
     return false;
   }
 
   /**
-   * @return <code>true</code> if given [Element] has direct or indirect reference to itself
-   *         from anywhere except [ClassElement] or type parameter bounds.
+   * Return `true` if the given [element] has direct or indirect reference to
+   * itself from anywhere except a class element or type parameter bounds.
    */
   bool _hasTypedefSelfReference(Element target) {
     Set<Element> checked = new HashSet<Element>();
     List<Element> toCheck = new List<Element>();
     GeneralizingElementVisitor_ErrorVerifier_hasTypedefSelfReference elementVisitor =
         new GeneralizingElementVisitor_ErrorVerifier_hasTypedefSelfReference(
             toCheck);
     toCheck.add(target);
     bool firstIteration = true;
     while (true) {
@@ skipping 31 matching lines @@
       return true;
     } else if (type is InterfaceType) {
       MethodElement callMethod =
           type.lookUpMethod(FunctionElement.CALL_METHOD_NAME, _currentLibrary);
       return callMethod != null;
     }
     return false;
   }
 
   /**
-   * Return `true` iff the passed [ClassElement] has a method, getter or setter that
-   * matches the name of the passed [ExecutableElement] in either the class itself, or one of
-   * its' mixins that is concrete.
+   * Return `true` iff the given class [element] has a method, getter or setter
+   * that matches the name of the given executable [element] in either the class
+   * itself, or one of its' mixins that is concrete.
    *
-   * By "match", only the name of the member is tested to match, it does not have to equal or be a
-   * subtype of the passed executable element, this is due to the specific use where this method is
-   * used in [checkForNonAbstractClassInheritsAbstractMember].
-   *
-   * @param executableElt the executable to search for in the passed class element
-   * @param classElt the class method to search through the members of
-   * @return `true` iff the passed member is found in the passed class element
+   * By "match", only the name of the member is tested to match, it does not
+   * have to equal or be a subtype of the given executable element, this is due
+   * to the specific use where this method is used in
+   * [_checkForNonAbstractClassInheritsAbstractMember].
    */
   bool _isMemberInClassOrMixin(
       ExecutableElement executableElt, ClassElement classElt) {
     ExecutableElement foundElt = null;
     String executableName = executableElt.name;
     if (executableElt is MethodElement) {
       foundElt = classElt.getMethod(executableName);
       if (foundElt != null && !(foundElt as MethodElement).isAbstract) {
         return true;
       }
@@ skipping 25 matching lines @@
       }
       if (foundElt != null &&
           !(foundElt as PropertyAccessorElement).isAbstract) {
         return true;
       }
     }
     return false;
   }
 
   /**
-   * @param node the 'this' expression to analyze
-   * @return `true` if the given 'this' expression is in the valid context
+   * Return `true` if the given 'this' [expression] is in a valid context.
    */
   bool _isThisInValidContext(ThisExpression node) {
     for (AstNode n = node; n != null; n = n.parent) {
       if (n is CompilationUnit) {
         return false;
       }
       if (n is ConstructorDeclaration) {
         return n.factoryKeyword == null;
       }
       if (n is ConstructorInitializer) {
         return false;
       }
       if (n is MethodDeclaration) {
         return !n.isStatic;
       }
     }
     return false;
   }
 
   /**
-   * Return `true` if the given identifier is in a location where it is allowed to resolve to
-   * a static member of a supertype.
-   *
-   * @param node the node being tested
-   * @return `true` if the given identifier is in a location where it is allowed to resolve to
-   *         a static member of a supertype
+   * Return `true` if the given [identifier] is in a location where it is
+   * allowed to resolve to a static member of a supertype.
    */
   bool _isUnqualifiedReferenceToNonLocalStaticMemberAllowed(
       SimpleIdentifier node) {
     if (node.inDeclarationContext()) {
       return true;
     }
     AstNode parent = node.parent;
     if (parent is ConstructorName ||
         parent is MethodInvocation ||
         parent is PropertyAccess ||
@@ skipping 12 matching lines @@
         return true;
       }
     }
     return false;
   }
 
   bool _isUserDefinedObject(EvaluationResultImpl result) => result == null ||
       (result.value != null && result.value.isUserDefinedObject);
 
   /**
-   * This checks the class declaration is not a superinterface to itself.
+   * Check that the given class [element] is not a superinterface to itself. The
+   * [path] is a list containing the potentially cyclic implements path.
    *
-   * @param classElt the class element to test
-   * @param path a list containing the potentially cyclic implements path
-   * @return `true` if and only if an error code is generated on the passed element
    * See [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE],
    * [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS],
-   * [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS], and
-   * [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_WITH].
+   * [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS],
+   * and [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_WITH].
    */
   bool _safeCheckForRecursiveInterfaceInheritance(
       ClassElement classElt, List<ClassElement> path) {
     // Detect error condition.
     int size = path.length;
     // If this is not the base case (size > 0), and the enclosing class is the
-    // passed class element then an error an error.
+    // given class element then an error an error.
     if (size > 0 && _enclosingClass == classElt) {
       String enclosingClassName = _enclosingClass.displayName;
       if (size > 1) {
         // Construct a string showing the cyclic implements path:
         // "A, B, C, D, A"
         String separator = ", ";
         StringBuffer buffer = new StringBuffer();
         for (int i = 0; i < size; i++) {
           buffer.write(path[i].displayName);
           buffer.write(separator);
@@ skipping 37 matching lines @@
     for (InterfaceType mixinType in mixinTypes) {
       if (_safeCheckForRecursiveInterfaceInheritance(mixinType.element, path)) {
         return true;
       }
     }
     path.removeAt(path.length - 1);
     return false;
   }
 
   /**
-   * Return the static type of the given expression that is to be used for type analysis.
-   *
-   * @param expression the expression whose type is to be returned
-   * @return the static type of the given expression
+   * Return the static type of the given [expression] that is to be used for
+   * type analysis.
    */
   static DartType getStaticType(Expression expression) {
     DartType type = expression.staticType;
     if (type == null) {
       // TODO(brianwilkerson) This should never happen.
       return DynamicTypeImpl.instance;
     }
     return type;
   }
 
   /**
-   * Return the variable element represented by the given expression, or `null` if there is no
-   * such element.
-   *
-   * @param expression the expression whose element is to be returned
-   * @return the variable element represented by the expression
+   * Return the variable element represented by the given [expression], or
+   * `null` if there is no such element.
    */
   static VariableElement getVariableElement(Expression expression) {
     if (expression is Identifier) {
       Element element = expression.staticElement;
       if (element is VariableElement) {
         return element;
       }
     }
     return null;
   }
@@ skipping 38 matching lines @@
     toCheck.add(type.element);
     // type arguments
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       for (DartType typeArgument in interfaceType.typeArguments) {
         _addTypeToCheck(typeArgument);
       }
     }
   }
 }