anchor.diff:    }
   
     @override
  +  void visitNamedExpression(NamedExpression node) {
  +    _runSubscriptions(node, registry._forNamedExpression);
  +    super.visitNamedExpression(node);
  +  }
  +
  +  @override
  +  void visitNullLiteral(NullLiteral node) {
  +    _runSubscriptions(node, registry._forNullLiteral);
  +    super.visitNullLiteral(node);
  +  }
  +
  +  @override
     void visitParenthesizedExpression(ParenthesizedExpression node) {
       _runSubscriptions(node, registry._forParenthesizedExpression);
       super.visitParenthesizedExpression(node);
     }
   
     @override
  +  void visitPartDirective(PartDirective node) {
  +    _runSubscriptions(node, registry._forPartDirective);
  +    super.visitPartDirective(node);
  +  }
  +
  +  @override
  +  void visitPartOfDirective(PartOfDirective node) {
  +    _runSubscriptions(node, registry._forPartOfDirective);
  +    super.visitPartOfDirective(node);
  +  }
  +
  +  @override
  +  void visitPostfixExpression(PostfixExpression node) {
  +    _runSubscriptions(node, registry._forPostfixExpression);
  +    super.visitPostfixExpression(node);
  +  }
  +
  +  @override
  +  void visitPrefixedIdentifier(PrefixedIdentifier node) {
  +    _runSubscriptions(node, registry._forPrefixedIdentifier);
  +    super.visitPrefixedIdentifier(node);
  +  }
  +
  +  @override
  +  void visitPrefixExpression(PrefixExpression node) {
  +    _runSubscriptions(node, registry._forPrefixExpression);
  +    super.visitPrefixExpression(node);
  +  }
  +
  +  @override
  +  void visitPropertyAccess(PropertyAccess node) {
  +    _runSubscriptions(node, registry._forPropertyAccess);
  +    super.visitPropertyAccess(node);
  +  }
  +
  +  @override
  +  void visitRedirectingConstructorInvocation(
  +      RedirectingConstructorInvocation node) {
  +    _runSubscriptions(node, registry._forRedirectingConstructorInvocation);
  +    super.visitRedirectingConstructorInvocation(node);
  +  }
  +
  +  @override
  +  void visitRethrowExpression(RethrowExpression node) {
  +    _runSubscriptions(node, registry._forRethrowExpression);
  +    super.visitRethrowExpression(node);
  +  }
  +
  +  @override
     void visitReturnStatement(ReturnStatement node) {
       _runSubscriptions(node, registry._forReturnStatement);
       super.visitReturnStatement(node);
     }
   
     @override
  +  void visitShowCombinator(ShowCombinator node) {
  +    _runSubscriptions(node, registry._forShowCombinator);
  +    super.visitShowCombinator(node);
  +  }
  +
  +  @override
     void visitSimpleFormalParameter(SimpleFormalParameter node) {
       _runSubscriptions(node, registry._forSimpleFormalParameter);
       super.visitSimpleFormalParameter(node);
  
positive.code:     _forMethodInvocation.add(new _Subscription(linter, f, _getTimer(linter)));
    }
  
    void addParenthesizedExpression(
        LintRule linter, void Function(ParenthesizedExpression) f) {
      _forParenthesizedExpression
          .add(new _Subscription(linter, f, _getTimer(linter)));
    }
  
    void addReturnStatement(LintRule linter, void Function(ReturnStatement) f) {
      _forReturnStatement.add(new _Subscription(linter, f, _getTimer(linter)));
    }
  
    void addSimpleFormalParameter(
  
negative.code:     _forEnumDeclaration.add(new _Subscription(linter, f, _getTimer(linter)));
    }
  
    void addExportDirective(LintRule linter, void Function(ExportDirective) f) {
      _forExportDirective.add(new _Subscription(linter, f, _getTimer(linter)));
    }
  
    void addExpressionFunctionBody(
        LintRule linter, void Function(ExpressionFunctionBody) f) {
      _forExpressionFunctionBody
          .add(new _Subscription(linter, f, _getTimer(linter)));
    }
  
    void addExpressionStatement(
        LintRule linter, void Function(ExpressionStatement) f) {
      _forExpressionStatement
          .add(new _Subscription(linter, f, _getTimer(linter)));
    }
  
    void addExtendsClause(LintRule linter, void Function(ExtendsClause) f) {
      _forExtendsClause.add(new _Subscription(linter, f, _getTimer(linter)));
    }
  
    void addFieldDeclaration(LintRule linter, void Function(FieldDeclaration) f) {
      _forFieldDeclaration.add(new _Subscription(linter, f, _getTimer(linter)));
    }
  