anchor.diff:      reporter.io.writeHr();
     }
   
  -  void reportEachWithRemoved(String attributeName, DiffNode attribute) {
  +  void reportRemovedProperties(String attributeName, DiffNode attribute) {
       if (!attribute.hasRemoved)
         return;
   
       reporter.io.writeln('The $link $category has removed $attributeName:\n');
       shouldHr = true;
   
  -    attribute.forEachRemoved((_, v) =>
  -        reporter.io.writeln(attributeAttributeListItem(attributeName, v)));
  +    attribute.forEachRemoved((_, property) =>
  +        reporter.io.writeln(propertyListItem(attributeName, property)));
   
       reporter.io.writeln('');
       reporter.erase(attribute.removed);
     }
   
  -  void reportEachWithAdded(String attributeName, DiffNode attribute) {
  +  void reportAddedProperties(String attributeName, DiffNode attribute) {
       if (!attribute.hasAdded)
         return;
   
  
positive.code:       }
        reporter.io.writeHr();
      });
      reporter.erase(attributeAttribute.changed);
  
      if (attributeAttribute.containsKey('type')) {
        String key = 'type';
        List<String> oldNew = attributeAttribute[key]['0'].changed['outer'];
        // This is so ugly because we are so deep, but an example would be:
        // The foo method's value parameter's type has changed from int to bool.
        reporter.io.writeln(
            'The [$method](#) ${category}\'s [${attributeAttributeName}](#) '
            '${singularize(attributeName)}\'s $key has changed from '
            '`${oldNew[0]}` to `${oldNew[1]}`');
        reporter.io.writeHr();
        if (reporter.shouldErase) {
          attributeAttribute.node.remove('type');
        }
      }
  
      if (attributeAttribute.containsKey('functionDeclaration')) {
        DiffNode declaration = attributeAttribute.node['functionDeclaration'];
        if (declaration.changed.containsKey('return')) {
          List<List<Map>> oldNew = declaration.changed['return'];
          // This is so ugly because we are so deep, but an example would be:
          // The foo method's callback parameter's return type has changed from
          // Object to String.
          reporter.io.writeln(
              'The [$method](#) ${category}\'s [${attributeAttributeName}](#) '
              '${singularize(attributeName)}\'s return type has ${changedType(oldNew)}');
          reporter.io.writeHr();
          if (reporter.shouldErase) {
  
negative.code: /// Reporter for changes in a method's attributes.
  ///
  /// This reporter can iterate over attributes with their own added, deleted, or
  /// changed properties, and iterate over shallow attributes (such as `return`)
  /// to list changes.
  ///
  /// Definitions that might help:
  ///
  /// * There are 5 method categories: constructor, method, getter, setter, and
  ///   operator.
  /// * Each method has attributes, such as "parameters" and "annotations"
  /// * Each method attribute, or member thereof, might have properties.
  ///   E.g. Each member of the "parameters" attribute (each parameter) has
  ///   properties such as "name", and "type".
  ///
  /// It is unexpected to find any new or removed attributes themselves (a method
  /// should never be missing the "parameters" attribute, or suddenly gain the
  