anchor.diff:      }
     }
   
  -  /**
  -   * This verifies that the passed left hand side and right hand side represent a valid assignment.
  -   *
  -   * This method corresponds to ErrorVerifier.checkForInvalidAssignment.
  -   *
  -   * @param lhs the left hand side expression
  -   * @param rhs the right hand side expression
  -   * @return `true` if and only if an error code is generated on the passed node
  -   * See [HintCode.INVALID_ASSIGNMENT].
  -   */
  +  /// This verifies that the passed left hand side and right hand side represent
  +  /// a valid assignment.
  +  ///
  +  /// This method corresponds to ErrorVerifier.checkForInvalidAssignment.
  +  ///
  +  /// @param lhs the left hand side expression
  +  /// @param rhs the right hand side expression
  +  /// @return `true` if and only if an error code is generated on the passed
  +  ///         node
  +  /// See [HintCode.INVALID_ASSIGNMENT].
     bool _checkForInvalidAssignment(Expression lhs, Expression rhs) {
       if (lhs == null || rhs == null) {
         return false;
  
positive.code:     return null;
    }
  
    /**
     * Visit the given statement after it's scope has been created. This replaces the normal call to
     * the inherited visit method so that ResolverVisitor can intervene when type propagation is
     * enabled.
     *
     * @param node the statement to be visited
     */
    void visitForEachStatementInScope(ForEachStatement node) {
      //
      // We visit the iterator before the loop variable because the loop variable
  
negative.code:         .toList());
    }
  
    /// If it is appropriate to do so, override the current type of the static
    /// element associated with the given expression with the given type.
    /// Generally speaking, it is appropriate if the given type is more specific
    /// than the current type.
    ///
    /// @param expression the expression used to access the static element whose
    ///        types might be overridden
    /// @param potentialType the potential type of the elements
    /// @param allowPrecisionLoss see @{code overrideVariable} docs
    void overrideExpression(Expression expression, DartType potentialType,
        bool allowPrecisionLoss, bool setExpressionType) {
      // TODO(brianwilkerson) Remove this method.
    }
  
    /// If it is appropriate to do so, override the current type of the given
    /// element with the given type.
    ///
    /// @param element the element whose type might be overridden
    /// @param potentialType the potential type of the element
    /// @param allowPrecisionLoss true if `potentialType` is allowed to be less
    ///        precise than the current best type
    ///
    /// Return a new better [DartType], or `null` if [potentialType] is not better
    /// than the current [element] type.
    DartType overrideVariable(VariableElement element, DartType potentialType,
        bool allowPrecisionLoss) {
      // TODO(scheglov) type propagation for instance/top-level fields
  