Linter: Implement actionview-no-void-element-content rule (#1456)

This pull request implements a new `actionview-no-void-element-content`
based on the new error introduced in #1454.

Because the `parser-no-errors` rule doesn't define `action_view_helpers:
true` it doesn't pick up and report the new `VoidElementContentError`.

So this rule parses the document with `action_view_helpers: true` and
surfaces the `VoidElementContentError` errors that way:

<img width="2227" height="548" alt="CleanShot 2026-03-22 at 13 47 02@2x"
src="https://github.com/user-attachments/assets/ee7d761e-838c-46cb-bccc-0c26f0ebbda0"
/>

Ideally in the future we could infer `action_view_helpers: true` somehow
and pass it along to the `parser-no-errors` rule.

Either by checking if you are running this in a ActionView-enabled
project, or by having a setting in `config.yml` like `framework:
"actionview"` or similar (related #1359).

Additionally, it improves the `VoidElementContentError` error message
and the location reporting.

Author: marcoroth

config.yml

@@ -460,15 +460,18 @@ errors:
 
     - name: VoidElementContentError
       message:
-        template: "Void element `%s` cannot have content. `%s` does not accept positional arguments."
+        template: "Void element `%s` cannot have content. `%s` does not accept a positional argument for content."
         arguments:
           - tag_name->value
-          - tag_name->value
+          - helper_name
 
       fields:
         - name: tag_name
           type: token
 
+        - name: helper_name
+          type: string
+
     - name: DotNotationCasingError
       message:
         template: "Dot-notation component tags require the first segment to start with an uppercase letter. `%s` does not start with an uppercase letter."

javascript/packages/linter/src/linter.ts

@@ -419,10 +419,10 @@ export class Linter {
       const parserOptions = this.isParserRuleClass(ruleClass) ? (rule as ParserRule).parserOptions : {}
       const parseResult = this.parseCache.get(source, parserOptions)
 
-      // Skip parser rules whose parse result has errors (parser-no-errors handled above)
+      // Skip parser rules whose parse result has errors (unless the rule consumes parser errors)
       // Skip lexer/source rules when the default parse has errors
       if (this.isParserRuleClass(ruleClass)) {
-        if (parseResult.recursiveErrors().length > 0) continue
+        if (parseResult.recursiveErrors().length > 0 && !ruleClass.consumesParserErrors) continue
       } else if (hasParserErrors) {
         continue
       }

javascript/packages/linter/src/rules.ts

@@ -2,6 +2,7 @@ import type { RuleClass } from "./types.js"
 
 import { ActionViewNoSilentHelperRule } from "./rules/actionview-no-silent-helper.js"
 import { ActionViewNoSilentRenderRule } from "./rules/actionview-no-silent-render.js"
+import { ActionViewNoVoidElementContentRule } from "./rules/actionview-no-void-element-content.js"
 
 import { ERBCommentSyntax } from "./rules/erb-comment-syntax.js";
 import { ERBNoCaseNodeChildrenRule } from "./rules/erb-no-case-node-children.js"
@@ -89,6 +90,7 @@ import { TurboPermanentRequireIdRule } from "./rules/turbo-permanent-require-id.
 export const rules: RuleClass[] = [
   ActionViewNoSilentHelperRule,
   ActionViewNoSilentRenderRule,
+  ActionViewNoVoidElementContentRule,
 
   ERBCommentSyntax,
   ERBNoCaseNodeChildrenRule,

javascript/packages/linter/src/rules/actionview-no-void-element-content.ts

@@ -0,0 +1,29 @@
+import { ParserRule } from "../types.js"
+
+import type { LintOffense, FullRuleConfig } from "../types.js"
+import type { ParseResult, ParserOptions } from "@herb-tools/core"
+
+export class ActionViewNoVoidElementContentRule extends ParserRule {
+  static ruleName = "actionview-no-void-element-content"
+  static introducedIn = this.version("unreleased")
+  static consumesParserErrors = true
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  get parserOptions(): Partial<ParserOptions> {
+    return {
+      action_view_helpers: true,
+    }
+  }
+
+  check(result: ParseResult): LintOffense[] {
+    return result.recursiveErrors()
+      .filter(error => error.type === "VOID_ELEMENT_CONTENT_ERROR")
+      .map(error => this.herbErrorToLintOffense(error))
+  }
+}

javascript/packages/linter/src/rules/index.ts

@@ -5,6 +5,7 @@ export * from "./herb-disable-comment-base.js"
 
 export * from "./actionview-no-silent-helper.js"
 export * from "./actionview-no-silent-render.js"
+export * from "./actionview-no-void-element-content.js"
 
 export * from "./erb-comment-syntax.js"
 export * from "./erb-no-case-node-children.js"

javascript/packages/linter/src/rules/parser-no-errors.ts

@@ -20,14 +20,10 @@ export class ParserNoErrorsRule extends ParserRule {
     )
   }
 
-  private herbErrorToLintOffense(error: HerbError): LintOffense {
+  protected herbErrorToLintOffense(error: HerbError): LintOffense {
     return {
+      ...super.herbErrorToLintOffense(error),
       message: `${error.message} (\`${error.type}\`)`,
-      location: error.location,
-      severity: error.severity,
-      rule: this.ruleName,
-      code: this.ruleName,
-      source: "linter"
     }
   }
 }

javascript/packages/linter/src/types.ts

@@ -1,6 +1,6 @@
 import { Diagnostic, LexResult, ParseResult, Location } from "@herb-tools/core"
 
-import type { DiagnosticTag } from "@herb-tools/core"
+import type { DiagnosticTag, HerbError } from "@herb-tools/core"
 import type { rules } from "./rules.js"
 import type { Node, ParserOptions } from "@herb-tools/core"
 import type { RuleConfig } from "@herb-tools/config"
@@ -106,6 +106,8 @@ export abstract class ParserRule<TAutofixContext extends BaseAutofixContext = Ba
   static unsafeAutocorrectable = false
   /** Indicates whether the source should be re-indented after autofix. Defaults to false. */
   static reindentAfterAutofix = false
+  /** Indicates whether this rule consumes parser errors (like parser-no-errors). Rules with this flag are not skipped when parse results contain errors. */
+  static consumesParserErrors = false
 
   get ruleName(): string {
     return (this.constructor as typeof ParserRule).ruleName
@@ -132,6 +134,17 @@ export abstract class ParserRule<TAutofixContext extends BaseAutofixContext = Ba
     }
   }
 
+  protected herbErrorToLintOffense(error: HerbError): LintOffense {
+    return {
+      message: error.message,
+      location: error.location,
+      severity: error.severity,
+      rule: this.ruleName,
+      code: this.ruleName,
+      source: "linter"
+    }
+  }
+
   abstract check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<TAutofixContext>[]
 
   /**
@@ -314,6 +327,7 @@ export type ParserRuleClass = (new () => ParserRule) & {
   ruleName: string
   introducedIn: RuleVersion
   reindentAfterAutofix?: boolean
+  consumesParserErrors?: boolean
 }
 
 export type LexerRuleClass = LexerRuleConstructor

javascript/packages/linter/test/__snapshots__/cli.test.ts.snap

@@ -75,7 +75,7 @@ export function createLinterTest(rules: RuleClass | RuleClass[], configOverride?
   const ruleClasses = Array.isArray(rules) ? rules : [rules]
   const primaryRuleClass = ruleClasses[0]
   const ruleInstance = new primaryRuleClass()
-  const isParserNoErrorsRule = primaryRuleClass.ruleName === "parser-no-errors"
+  const isParserNoErrorsRule = primaryRuleClass.ruleName === "parser-no-errors" || ('consumesParserErrors' in primaryRuleClass && primaryRuleClass.consumesParserErrors)
   const ruleParserOptions = ruleInstance instanceof ParserRule ? ruleInstance.parserOptions : {}
   const parseCache = new ParseCache(Herb)
   const ruleConfigOverride = configOverride