@herb-tools/core 0.9.0 → 0.9.1

package/dist/types/ast-utils.d.ts

@@ -69,7 +69,7 @@ export declare function hasStaticAttributeName(attributeNameNode: HTMLAttributeN
 /**
  * Checks if an HTML attribute name node has dynamic content (contains ERB)
  */
-export declare function hasDynamicAttributeName(attributeNameNode: HTMLAttributeNameNode): boolean;
+export declare function hasDynamicAttributeNameNode(attributeNameNode: HTMLAttributeNameNode): boolean;
 /**
  * Gets the static string value of an HTML attribute name node
  * Returns null if the attribute name contains dynamic content (ERB)
@@ -151,9 +151,8 @@ export declare function getAttribute(node: HTMLElementNode | HTMLOpenTagNode | n
 export declare function hasAttribute(node: HTMLElementNode | HTMLOpenTagNode | null | undefined, attributeName: string): boolean;
 /**
  * Checks if an attribute has a dynamic (ERB-containing) name.
- * Accepts an HTMLAttributeNode (wraps the core HTMLAttributeNameNode-level check).
  */
-export declare function hasDynamicAttributeNameOnAttribute(attributeNode: HTMLAttributeNode): boolean;
+export declare function hasDynamicAttributeName(attributeNode: HTMLAttributeNode): boolean;
 /**
  * Gets the combined string representation of an attribute name (including ERB syntax).
  * Accepts an HTMLAttributeNode (wraps the core HTMLAttributeNameNode-level check).

package/dist/types/diagnostic.d.ts

@@ -1,5 +1,6 @@
 import { Location, SerializedLocation } from "./location.js";
 export type DiagnosticSeverity = "error" | "warning" | "info" | "hint";
+export type DiagnosticTag = "unnecessary" | "deprecated";
 /**
  * Base interface for all diagnostic information in Herb tooling.
  * This includes parser errors, lexer errors, lint offenses, and any other
@@ -26,6 +27,10 @@ export interface Diagnostic {
      * Optional source that generated this diagnostic (e.g., "parser", "linter", "lexer")
      */
     source?: string;
+    /**
+     * Optional diagnostic tags for additional metadata (e.g., "unnecessary", "deprecated")
+     */
+    tags?: DiagnosticTag[];
 }
 /**
  * Serialized form of a Diagnostic for JSON representation
@@ -36,6 +41,7 @@ export interface SerializedDiagnostic {
     severity: DiagnosticSeverity;
     code?: string;
     source?: string;
+    tags?: DiagnosticTag[];
 }
 export type MonacoSeverity = "error" | "warning" | "info";
 /**

package/dist/types/errors.d.ts

@@ -2,7 +2,7 @@ import { Location, SerializedLocation } from "./location.js";
 import { Position, SerializedPosition } from "./position.js";
 import { Token, SerializedToken } from "./token.js";
 import { Diagnostic, MonacoDiagnostic } from "./diagnostic.js";
-export type HerbErrorType = "UNEXPECTED_ERROR" | "UNEXPECTED_TOKEN_ERROR" | "MISSING_OPENING_TAG_ERROR" | "MISSING_CLOSING_TAG_ERROR" | "TAG_NAMES_MISMATCH_ERROR" | "VOID_ELEMENT_CLOSING_TAG_ERROR" | "UNCLOSED_ELEMENT_ERROR" | "RUBY_PARSE_ERROR" | "ERB_CONTROL_FLOW_SCOPE_ERROR" | "MISSING_ERB_END_TAG_ERROR" | "ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR" | "ERB_CASE_WITH_CONDITIONS_ERROR" | "CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR" | "CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR" | "INVALID_COMMENT_CLOSING_TAG_ERROR" | "OMITTED_CLOSING_TAG_ERROR" | "UNCLOSED_OPEN_TAG_ERROR" | "UNCLOSED_CLOSE_TAG_ERROR" | "UNCLOSED_QUOTE_ERROR" | "MISSING_ATTRIBUTE_VALUE_ERROR" | "UNCLOSED_ERB_TAG_ERROR" | "STRAY_ERB_CLOSING_TAG_ERROR" | "NESTED_ERB_TAG_ERROR";
+export type HerbErrorType = "UNEXPECTED_ERROR" | "UNEXPECTED_TOKEN_ERROR" | "MISSING_OPENING_TAG_ERROR" | "MISSING_CLOSING_TAG_ERROR" | "TAG_NAMES_MISMATCH_ERROR" | "VOID_ELEMENT_CLOSING_TAG_ERROR" | "UNCLOSED_ELEMENT_ERROR" | "RUBY_PARSE_ERROR" | "ERB_CONTROL_FLOW_SCOPE_ERROR" | "MISSING_ERB_END_TAG_ERROR" | "ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR" | "ERB_CASE_WITH_CONDITIONS_ERROR" | "CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR" | "CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR" | "INVALID_COMMENT_CLOSING_TAG_ERROR" | "OMITTED_CLOSING_TAG_ERROR" | "UNCLOSED_OPEN_TAG_ERROR" | "UNCLOSED_CLOSE_TAG_ERROR" | "UNCLOSED_QUOTE_ERROR" | "MISSING_ATTRIBUTE_VALUE_ERROR" | "UNCLOSED_ERB_TAG_ERROR" | "STRAY_ERB_CLOSING_TAG_ERROR" | "NESTED_ERB_TAG_ERROR" | "RENDER_AMBIGUOUS_LOCALS_ERROR" | "RENDER_MISSING_LOCALS_ERROR" | "RENDER_NO_ARGUMENTS_ERROR" | "RENDER_CONFLICTING_PARTIAL_ERROR" | "RENDER_INVALID_AS_OPTION_ERROR" | "RENDER_OBJECT_AND_COLLECTION_ERROR" | "RENDER_LAYOUT_WITHOUT_BLOCK_ERROR";
 export type SerializedErrorType = string;
 export interface SerializedHerbError {
     type: string;
@@ -527,4 +527,144 @@ export declare class NestedERBTagError extends HerbError {
     toMonacoDiagnostic(): MonacoDiagnostic;
     treeInspect(): string;
 }
+export interface SerializedRenderAmbiguousLocalsError {
+    type: "RENDER_AMBIGUOUS_LOCALS_ERROR";
+    message: string;
+    location: SerializedLocation;
+    partial: string;
+}
+export interface RenderAmbiguousLocalsErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    partial: string;
+}
+export declare class RenderAmbiguousLocalsError extends HerbError {
+    readonly partial: string;
+    static from(data: SerializedRenderAmbiguousLocalsError): RenderAmbiguousLocalsError;
+    constructor(props: RenderAmbiguousLocalsErrorProps);
+    toJSON(): SerializedRenderAmbiguousLocalsError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedRenderMissingLocalsError {
+    type: "RENDER_MISSING_LOCALS_ERROR";
+    message: string;
+    location: SerializedLocation;
+    partial: string;
+    keywords: string;
+}
+export interface RenderMissingLocalsErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    partial: string;
+    keywords: string;
+}
+export declare class RenderMissingLocalsError extends HerbError {
+    readonly partial: string;
+    readonly keywords: string;
+    static from(data: SerializedRenderMissingLocalsError): RenderMissingLocalsError;
+    constructor(props: RenderMissingLocalsErrorProps);
+    toJSON(): SerializedRenderMissingLocalsError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedRenderNoArgumentsError {
+    type: "RENDER_NO_ARGUMENTS_ERROR";
+    message: string;
+    location: SerializedLocation;
+}
+export interface RenderNoArgumentsErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+}
+export declare class RenderNoArgumentsError extends HerbError {
+    static from(data: SerializedRenderNoArgumentsError): RenderNoArgumentsError;
+    constructor(props: RenderNoArgumentsErrorProps);
+    toJSON(): SerializedRenderNoArgumentsError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedRenderConflictingPartialError {
+    type: "RENDER_CONFLICTING_PARTIAL_ERROR";
+    message: string;
+    location: SerializedLocation;
+    positional_partial: string;
+    keyword_partial: string;
+}
+export interface RenderConflictingPartialErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    positional_partial: string;
+    keyword_partial: string;
+}
+export declare class RenderConflictingPartialError extends HerbError {
+    readonly positional_partial: string;
+    readonly keyword_partial: string;
+    static from(data: SerializedRenderConflictingPartialError): RenderConflictingPartialError;
+    constructor(props: RenderConflictingPartialErrorProps);
+    toJSON(): SerializedRenderConflictingPartialError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedRenderInvalidAsOptionError {
+    type: "RENDER_INVALID_AS_OPTION_ERROR";
+    message: string;
+    location: SerializedLocation;
+    as_value: string;
+}
+export interface RenderInvalidAsOptionErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    as_value: string;
+}
+export declare class RenderInvalidAsOptionError extends HerbError {
+    readonly as_value: string;
+    static from(data: SerializedRenderInvalidAsOptionError): RenderInvalidAsOptionError;
+    constructor(props: RenderInvalidAsOptionErrorProps);
+    toJSON(): SerializedRenderInvalidAsOptionError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedRenderObjectAndCollectionError {
+    type: "RENDER_OBJECT_AND_COLLECTION_ERROR";
+    message: string;
+    location: SerializedLocation;
+}
+export interface RenderObjectAndCollectionErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+}
+export declare class RenderObjectAndCollectionError extends HerbError {
+    static from(data: SerializedRenderObjectAndCollectionError): RenderObjectAndCollectionError;
+    constructor(props: RenderObjectAndCollectionErrorProps);
+    toJSON(): SerializedRenderObjectAndCollectionError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedRenderLayoutWithoutBlockError {
+    type: "RENDER_LAYOUT_WITHOUT_BLOCK_ERROR";
+    message: string;
+    location: SerializedLocation;
+    layout: string;
+}
+export interface RenderLayoutWithoutBlockErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    layout: string;
+}
+export declare class RenderLayoutWithoutBlockError extends HerbError {
+    readonly layout: string;
+    static from(data: SerializedRenderLayoutWithoutBlockError): RenderLayoutWithoutBlockError;
+    constructor(props: RenderLayoutWithoutBlockErrorProps);
+    toJSON(): SerializedRenderLayoutWithoutBlockError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
 export declare function fromSerializedError(error: SerializedHerbError): HerbError;

package/dist/types/node-type-guards.d.ts

@@ -1,7 +1,7 @@
 import type { Node, NodeType, ERBNode } from "./nodes.js";
 import { Token } from "./token.js";
 import { ParseResult } from "./parse-result.js";
-import { DocumentNode, LiteralNode, HTMLOpenTagNode, HTMLConditionalOpenTagNode, HTMLCloseTagNode, HTMLOmittedCloseTagNode, HTMLVirtualCloseTagNode, HTMLElementNode, HTMLConditionalElementNode, HTMLAttributeValueNode, HTMLAttributeNameNode, HTMLAttributeNode, RubyLiteralNode, RubyHTMLAttributesSplatNode, ERBOpenTagNode, HTMLTextNode, HTMLCommentNode, HTMLDoctypeNode, XMLDeclarationNode, CDATANode, WhitespaceNode, ERBContentNode, ERBEndNode, ERBElseNode, ERBIfNode, ERBBlockNode, ERBWhenNode, ERBCaseNode, ERBCaseMatchNode, ERBWhileNode, ERBUntilNode, ERBForNode, ERBRescueNode, ERBEnsureNode, ERBBeginNode, ERBUnlessNode, ERBYieldNode, ERBInNode } from "./nodes.js";
+import { DocumentNode, LiteralNode, HTMLOpenTagNode, HTMLConditionalOpenTagNode, HTMLCloseTagNode, HTMLOmittedCloseTagNode, HTMLVirtualCloseTagNode, HTMLElementNode, HTMLConditionalElementNode, HTMLAttributeValueNode, HTMLAttributeNameNode, HTMLAttributeNode, RubyLiteralNode, RubyHTMLAttributesSplatNode, ERBOpenTagNode, HTMLTextNode, HTMLCommentNode, HTMLDoctypeNode, XMLDeclarationNode, CDATANode, WhitespaceNode, ERBContentNode, ERBEndNode, ERBElseNode, ERBIfNode, ERBBlockNode, ERBWhenNode, ERBCaseNode, ERBCaseMatchNode, ERBWhileNode, ERBUntilNode, ERBForNode, ERBRescueNode, ERBEnsureNode, ERBBeginNode, ERBUnlessNode, RubyRenderLocalNode, ERBRenderNode, ERBYieldNode, ERBInNode } from "./nodes.js";
 /**
  * Type guard functions for AST nodes.
  * These functions provide type checking by combining both instanceof
@@ -152,6 +152,14 @@ export declare function isERBBeginNode(node: Node | null | undefined): node is E
  * Checks if a node is a ERBUnlessNode
  */
 export declare function isERBUnlessNode(node: Node | null | undefined): node is ERBUnlessNode;
+/**
+ * Checks if a node is a RubyRenderLocalNode
+ */
+export declare function isRubyRenderLocalNode(node: Node | null | undefined): node is RubyRenderLocalNode;
+/**
+ * Checks if a node is a ERBRenderNode
+ */
+export declare function isERBRenderNode(node: Node | null | undefined): node is ERBRenderNode;
 /**
  * Checks if a node is a ERBYieldNode
  */
@@ -230,6 +238,8 @@ type NodeTypeToClass = {
     "AST_ERB_ENSURE_NODE": ERBEnsureNode;
     "AST_ERB_BEGIN_NODE": ERBBeginNode;
     "AST_ERB_UNLESS_NODE": ERBUnlessNode;
+    "AST_RUBY_RENDER_LOCAL_NODE": RubyRenderLocalNode;
+    "AST_ERB_RENDER_NODE": ERBRenderNode;
     "AST_ERB_YIELD_NODE": ERBYieldNode;
     "AST_ERB_IN_NODE": ERBInNode;
 };
@@ -486,6 +496,14 @@ export declare function filterERBBeginNodes(nodes: Node[]): ERBBeginNode[];
  * Filters an array of nodes to only include ERBUnlessNode nodes
  */
 export declare function filterERBUnlessNodes(nodes: Node[]): ERBUnlessNode[];
+/**
+ * Filters an array of nodes to only include RubyRenderLocalNode nodes
+ */
+export declare function filterRubyRenderLocalNodes(nodes: Node[]): RubyRenderLocalNode[];
+/**
+ * Filters an array of nodes to only include ERBRenderNode nodes
+ */
+export declare function filterERBRenderNodes(nodes: Node[]): ERBRenderNode[];
 /**
  * Filters an array of nodes to only include ERBYieldNode nodes
  */

package/dist/types/nodes.d.ts

@@ -1160,6 +1160,115 @@ export declare class ERBUnlessNode extends Node {
     toJSON(): SerializedERBUnlessNode;
     treeInspect(): string;
 }
+export interface SerializedRubyRenderLocalNode extends SerializedNode {
+    type: "AST_RUBY_RENDER_LOCAL_NODE";
+    name: SerializedToken | null;
+    value: SerializedRubyLiteralNode | null;
+}
+export interface RubyRenderLocalNodeProps extends Omit<BaseNodeProps, 'type'> {
+    type: "AST_RUBY_RENDER_LOCAL_NODE";
+    name: Token | null;
+    value: RubyLiteralNode | null;
+}
+export declare class RubyRenderLocalNode extends Node {
+    readonly type: "AST_RUBY_RENDER_LOCAL_NODE";
+    readonly name: Token | null;
+    readonly value: RubyLiteralNode | null;
+    static get type(): NodeType;
+    static from(data: SerializedRubyRenderLocalNode): RubyRenderLocalNode;
+    constructor(props: RubyRenderLocalNodeProps);
+    accept(visitor: Visitor): void;
+    childNodes(): (Node | null | undefined)[];
+    compactChildNodes(): Node[];
+    recursiveErrors(): HerbError[];
+    toJSON(): SerializedRubyRenderLocalNode;
+    treeInspect(): string;
+}
+export interface SerializedERBRenderNode extends SerializedNode {
+    type: "AST_ERB_RENDER_NODE";
+    tag_opening: SerializedToken | null;
+    content: SerializedToken | null;
+    tag_closing: SerializedToken | null;
+    prism_node: number[] | null;
+    partial: SerializedToken | null;
+    template_path: SerializedToken | null;
+    layout: SerializedToken | null;
+    file: SerializedToken | null;
+    inline_template: SerializedToken | null;
+    body: SerializedToken | null;
+    plain: SerializedToken | null;
+    html: SerializedToken | null;
+    renderable: SerializedToken | null;
+    collection: SerializedToken | null;
+    object: SerializedToken | null;
+    as_name: SerializedToken | null;
+    spacer_template: SerializedToken | null;
+    formats: SerializedToken | null;
+    variants: SerializedToken | null;
+    handlers: SerializedToken | null;
+    content_type: SerializedToken | null;
+    locals: SerializedNode[];
+}
+export interface ERBRenderNodeProps extends Omit<BaseNodeProps, 'type'> {
+    type: "AST_ERB_RENDER_NODE";
+    tag_opening: Token | null;
+    content: Token | null;
+    tag_closing: Token | null;
+    prism_node: Uint8Array | null;
+    partial: Token | null;
+    template_path: Token | null;
+    layout: Token | null;
+    file: Token | null;
+    inline_template: Token | null;
+    body: Token | null;
+    plain: Token | null;
+    html: Token | null;
+    renderable: Token | null;
+    collection: Token | null;
+    object: Token | null;
+    as_name: Token | null;
+    spacer_template: Token | null;
+    formats: Token | null;
+    variants: Token | null;
+    handlers: Token | null;
+    content_type: Token | null;
+    locals: any[];
+}
+export declare class ERBRenderNode extends Node {
+    readonly type: "AST_ERB_RENDER_NODE";
+    readonly tag_opening: Token | null;
+    readonly content: Token | null;
+    readonly tag_closing: Token | null;
+    readonly prism_node: Uint8Array | null;
+    readonly partial: Token | null;
+    readonly template_path: Token | null;
+    readonly layout: Token | null;
+    readonly file: Token | null;
+    readonly inline_template: Token | null;
+    readonly body: Token | null;
+    readonly plain: Token | null;
+    readonly html: Token | null;
+    readonly renderable: Token | null;
+    readonly collection: Token | null;
+    readonly object: Token | null;
+    readonly as_name: Token | null;
+    readonly spacer_template: Token | null;
+    readonly formats: Token | null;
+    readonly variants: Token | null;
+    readonly handlers: Token | null;
+    readonly content_type: Token | null;
+    readonly locals: Node[];
+    static get type(): NodeType;
+    static from(data: SerializedERBRenderNode): ERBRenderNode;
+    constructor(props: ERBRenderNodeProps);
+    accept(visitor: Visitor): void;
+    childNodes(): (Node | null | undefined)[];
+    compactChildNodes(): Node[];
+    get prismNode(): PrismNode | null;
+    recursiveErrors(): HerbError[];
+    toJSON(): SerializedERBRenderNode;
+    treeInspect(): string;
+}
 export interface SerializedERBYieldNode extends SerializedNode {
     type: "AST_ERB_YIELD_NODE";
     tag_opening: SerializedToken | null;
@@ -1220,7 +1329,7 @@ export declare class ERBInNode extends Node {
     toJSON(): SerializedERBInNode;
     treeInspect(): string;
 }
-export type ConcreteNode = DocumentNode | LiteralNode | HTMLOpenTagNode | HTMLConditionalOpenTagNode | HTMLCloseTagNode | HTMLOmittedCloseTagNode | HTMLVirtualCloseTagNode | HTMLElementNode | HTMLConditionalElementNode | HTMLAttributeValueNode | HTMLAttributeNameNode | HTMLAttributeNode | RubyLiteralNode | RubyHTMLAttributesSplatNode | ERBOpenTagNode | HTMLTextNode | HTMLCommentNode | HTMLDoctypeNode | XMLDeclarationNode | CDATANode | WhitespaceNode | ERBContentNode | ERBEndNode | ERBElseNode | ERBIfNode | ERBBlockNode | ERBWhenNode | ERBCaseNode | ERBCaseMatchNode | ERBWhileNode | ERBUntilNode | ERBForNode | ERBRescueNode | ERBEnsureNode | ERBBeginNode | ERBUnlessNode | ERBYieldNode | ERBInNode;
+export type ConcreteNode = DocumentNode | LiteralNode | HTMLOpenTagNode | HTMLConditionalOpenTagNode | HTMLCloseTagNode | HTMLOmittedCloseTagNode | HTMLVirtualCloseTagNode | HTMLElementNode | HTMLConditionalElementNode | HTMLAttributeValueNode | HTMLAttributeNameNode | HTMLAttributeNode | RubyLiteralNode | RubyHTMLAttributesSplatNode | ERBOpenTagNode | HTMLTextNode | HTMLCommentNode | HTMLDoctypeNode | XMLDeclarationNode | CDATANode | WhitespaceNode | ERBContentNode | ERBEndNode | ERBElseNode | ERBIfNode | ERBBlockNode | ERBWhenNode | ERBCaseNode | ERBCaseMatchNode | ERBWhileNode | ERBUntilNode | ERBForNode | ERBRescueNode | ERBEnsureNode | ERBBeginNode | ERBUnlessNode | RubyRenderLocalNode | ERBRenderNode | ERBYieldNode | ERBInNode;
 export declare function fromSerializedNode(node: SerializedDocumentNode): DocumentNode;
 export declare function fromSerializedNode(node: SerializedLiteralNode): LiteralNode;
 export declare function fromSerializedNode(node: SerializedHTMLOpenTagNode): HTMLOpenTagNode;
@@ -1257,10 +1366,12 @@ export declare function fromSerializedNode(node: SerializedERBRescueNode): ERBRe
 export declare function fromSerializedNode(node: SerializedERBEnsureNode): ERBEnsureNode;
 export declare function fromSerializedNode(node: SerializedERBBeginNode): ERBBeginNode;
 export declare function fromSerializedNode(node: SerializedERBUnlessNode): ERBUnlessNode;
+export declare function fromSerializedNode(node: SerializedRubyRenderLocalNode): RubyRenderLocalNode;
+export declare function fromSerializedNode(node: SerializedERBRenderNode): ERBRenderNode;
 export declare function fromSerializedNode(node: SerializedERBYieldNode): ERBYieldNode;
 export declare function fromSerializedNode(node: SerializedERBInNode): ERBInNode;
 export declare function fromSerializedNode(node: SerializedNode): Node;
-export type NodeType = "AST_DOCUMENT_NODE" | "AST_LITERAL_NODE" | "AST_HTML_OPEN_TAG_NODE" | "AST_HTML_CONDITIONAL_OPEN_TAG_NODE" | "AST_HTML_CLOSE_TAG_NODE" | "AST_HTML_OMITTED_CLOSE_TAG_NODE" | "AST_HTML_VIRTUAL_CLOSE_TAG_NODE" | "AST_HTML_ELEMENT_NODE" | "AST_HTML_CONDITIONAL_ELEMENT_NODE" | "AST_HTML_ATTRIBUTE_VALUE_NODE" | "AST_HTML_ATTRIBUTE_NAME_NODE" | "AST_HTML_ATTRIBUTE_NODE" | "AST_RUBY_LITERAL_NODE" | "AST_RUBY_HTML_ATTRIBUTES_SPLAT_NODE" | "AST_ERB_OPEN_TAG_NODE" | "AST_HTML_TEXT_NODE" | "AST_HTML_COMMENT_NODE" | "AST_HTML_DOCTYPE_NODE" | "AST_XML_DECLARATION_NODE" | "AST_CDATA_NODE" | "AST_WHITESPACE_NODE" | "AST_ERB_CONTENT_NODE" | "AST_ERB_END_NODE" | "AST_ERB_ELSE_NODE" | "AST_ERB_IF_NODE" | "AST_ERB_BLOCK_NODE" | "AST_ERB_WHEN_NODE" | "AST_ERB_CASE_NODE" | "AST_ERB_CASE_MATCH_NODE" | "AST_ERB_WHILE_NODE" | "AST_ERB_UNTIL_NODE" | "AST_ERB_FOR_NODE" | "AST_ERB_RESCUE_NODE" | "AST_ERB_ENSURE_NODE" | "AST_ERB_BEGIN_NODE" | "AST_ERB_UNLESS_NODE" | "AST_ERB_YIELD_NODE" | "AST_ERB_IN_NODE";
+export type NodeType = "AST_DOCUMENT_NODE" | "AST_LITERAL_NODE" | "AST_HTML_OPEN_TAG_NODE" | "AST_HTML_CONDITIONAL_OPEN_TAG_NODE" | "AST_HTML_CLOSE_TAG_NODE" | "AST_HTML_OMITTED_CLOSE_TAG_NODE" | "AST_HTML_VIRTUAL_CLOSE_TAG_NODE" | "AST_HTML_ELEMENT_NODE" | "AST_HTML_CONDITIONAL_ELEMENT_NODE" | "AST_HTML_ATTRIBUTE_VALUE_NODE" | "AST_HTML_ATTRIBUTE_NAME_NODE" | "AST_HTML_ATTRIBUTE_NODE" | "AST_RUBY_LITERAL_NODE" | "AST_RUBY_HTML_ATTRIBUTES_SPLAT_NODE" | "AST_ERB_OPEN_TAG_NODE" | "AST_HTML_TEXT_NODE" | "AST_HTML_COMMENT_NODE" | "AST_HTML_DOCTYPE_NODE" | "AST_XML_DECLARATION_NODE" | "AST_CDATA_NODE" | "AST_WHITESPACE_NODE" | "AST_ERB_CONTENT_NODE" | "AST_ERB_END_NODE" | "AST_ERB_ELSE_NODE" | "AST_ERB_IF_NODE" | "AST_ERB_BLOCK_NODE" | "AST_ERB_WHEN_NODE" | "AST_ERB_CASE_NODE" | "AST_ERB_CASE_MATCH_NODE" | "AST_ERB_WHILE_NODE" | "AST_ERB_UNTIL_NODE" | "AST_ERB_FOR_NODE" | "AST_ERB_RESCUE_NODE" | "AST_ERB_ENSURE_NODE" | "AST_ERB_BEGIN_NODE" | "AST_ERB_UNLESS_NODE" | "AST_RUBY_RENDER_LOCAL_NODE" | "AST_ERB_RENDER_NODE" | "AST_ERB_YIELD_NODE" | "AST_ERB_IN_NODE";
 export type ERBNodeType = Extract<NodeType, `AST_ERB_${string}`>;
-export type ERBNode = ERBOpenTagNode | ERBContentNode | ERBEndNode | ERBElseNode | ERBIfNode | ERBBlockNode | ERBWhenNode | ERBCaseNode | ERBCaseMatchNode | ERBWhileNode | ERBUntilNode | ERBForNode | ERBRescueNode | ERBEnsureNode | ERBBeginNode | ERBUnlessNode | ERBYieldNode | ERBInNode;
-export declare const ERBNodeClasses: (typeof ERBOpenTagNode | typeof ERBContentNode | typeof ERBEndNode | typeof ERBElseNode | typeof ERBIfNode | typeof ERBBlockNode | typeof ERBWhenNode | typeof ERBCaseNode | typeof ERBCaseMatchNode | typeof ERBWhileNode | typeof ERBUntilNode | typeof ERBForNode | typeof ERBRescueNode | typeof ERBEnsureNode | typeof ERBBeginNode | typeof ERBUnlessNode | typeof ERBYieldNode | typeof ERBInNode)[];
+export type ERBNode = ERBOpenTagNode | ERBContentNode | ERBEndNode | ERBElseNode | ERBIfNode | ERBBlockNode | ERBWhenNode | ERBCaseNode | ERBCaseMatchNode | ERBWhileNode | ERBUntilNode | ERBForNode | ERBRescueNode | ERBEnsureNode | ERBBeginNode | ERBUnlessNode | ERBRenderNode | ERBYieldNode | ERBInNode;
+export declare const ERBNodeClasses: (typeof ERBOpenTagNode | typeof ERBContentNode | typeof ERBEndNode | typeof ERBElseNode | typeof ERBIfNode | typeof ERBBlockNode | typeof ERBWhenNode | typeof ERBCaseNode | typeof ERBCaseMatchNode | typeof ERBWhileNode | typeof ERBUntilNode | typeof ERBForNode | typeof ERBRescueNode | typeof ERBEnsureNode | typeof ERBBeginNode | typeof ERBUnlessNode | typeof ERBRenderNode | typeof ERBYieldNode | typeof ERBInNode)[];

package/dist/types/parser-options.d.ts

@@ -3,6 +3,7 @@ export interface ParseOptions {
     analyze?: boolean;
     strict?: boolean;
     action_view_helpers?: boolean;
+    render_nodes?: boolean;
     prism_nodes?: boolean;
     prism_nodes_deep?: boolean;
     prism_program?: boolean;
@@ -21,6 +22,8 @@ export declare class ParserOptions {
     readonly analyze: boolean;
     /** Whether ActionView tag helper transformation was enabled during parsing. */
     readonly action_view_helpers: boolean;
+    /** Whether ActionView render call detection was enabled during parsing. */
+    readonly render_nodes: boolean;
     /** Whether Prism node serialization was enabled during parsing. */
     readonly prism_nodes: boolean;
     /** Whether deep Prism node serialization was enabled during parsing. */

package/dist/types/visitor.d.ts

@@ -1,4 +1,4 @@
-import { Node, ERBNode, DocumentNode, LiteralNode, HTMLOpenTagNode, HTMLConditionalOpenTagNode, HTMLCloseTagNode, HTMLOmittedCloseTagNode, HTMLVirtualCloseTagNode, HTMLElementNode, HTMLConditionalElementNode, HTMLAttributeValueNode, HTMLAttributeNameNode, HTMLAttributeNode, RubyLiteralNode, RubyHTMLAttributesSplatNode, ERBOpenTagNode, HTMLTextNode, HTMLCommentNode, HTMLDoctypeNode, XMLDeclarationNode, CDATANode, WhitespaceNode, ERBContentNode, ERBEndNode, ERBElseNode, ERBIfNode, ERBBlockNode, ERBWhenNode, ERBCaseNode, ERBCaseMatchNode, ERBWhileNode, ERBUntilNode, ERBForNode, ERBRescueNode, ERBEnsureNode, ERBBeginNode, ERBUnlessNode, ERBYieldNode, ERBInNode } from "./nodes.js";
+import { Node, ERBNode, DocumentNode, LiteralNode, HTMLOpenTagNode, HTMLConditionalOpenTagNode, HTMLCloseTagNode, HTMLOmittedCloseTagNode, HTMLVirtualCloseTagNode, HTMLElementNode, HTMLConditionalElementNode, HTMLAttributeValueNode, HTMLAttributeNameNode, HTMLAttributeNode, RubyLiteralNode, RubyHTMLAttributesSplatNode, ERBOpenTagNode, HTMLTextNode, HTMLCommentNode, HTMLDoctypeNode, XMLDeclarationNode, CDATANode, WhitespaceNode, ERBContentNode, ERBEndNode, ERBElseNode, ERBIfNode, ERBBlockNode, ERBWhenNode, ERBCaseNode, ERBCaseMatchNode, ERBWhileNode, ERBUntilNode, ERBForNode, ERBRescueNode, ERBEnsureNode, ERBBeginNode, ERBUnlessNode, RubyRenderLocalNode, ERBRenderNode, ERBYieldNode, ERBInNode } from "./nodes.js";
 /**
  * Interface that enforces all node visit methods are implemented
  * This ensures that any class implementing IVisitor must have a visit method for every node type
@@ -43,6 +43,8 @@ export interface IVisitor {
     visitERBEnsureNode(node: ERBEnsureNode): void;
     visitERBBeginNode(node: ERBBeginNode): void;
     visitERBUnlessNode(node: ERBUnlessNode): void;
+    visitRubyRenderLocalNode(node: RubyRenderLocalNode): void;
+    visitERBRenderNode(node: ERBRenderNode): void;
     visitERBYieldNode(node: ERBYieldNode): void;
     visitERBInNode(node: ERBInNode): void;
     visitNode(node: Node): void;
@@ -90,6 +92,8 @@ export declare class Visitor implements IVisitor {
     visitERBEnsureNode(node: ERBEnsureNode): void;
     visitERBBeginNode(node: ERBBeginNode): void;
     visitERBUnlessNode(node: ERBUnlessNode): void;
+    visitRubyRenderLocalNode(node: RubyRenderLocalNode): void;
+    visitERBRenderNode(node: ERBRenderNode): void;
     visitERBYieldNode(node: ERBYieldNode): void;
     visitERBInNode(node: ERBInNode): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@herb-tools/core",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "Core module exporting shared interfaces, AST node definitions, and common utilities for Herb",
   "license": "MIT",
   "homepage": "https://herb-tools.dev",

package/src/ast-utils.ts

@@ -188,7 +188,7 @@ export function hasStaticAttributeName(attributeNameNode: HTMLAttributeNameNode)
 /**
  * Checks if an HTML attribute name node has dynamic content (contains ERB)
  */
-export function hasDynamicAttributeName(attributeNameNode: HTMLAttributeNameNode): boolean {
+export function hasDynamicAttributeNameNode(attributeNameNode: HTMLAttributeNameNode): boolean {
   if (!attributeNameNode.children) {
     return false
   }
@@ -383,12 +383,11 @@ export function hasAttribute(node: HTMLElementNode | HTMLOpenTagNode | null | un
 
 /**
  * Checks if an attribute has a dynamic (ERB-containing) name.
- * Accepts an HTMLAttributeNode (wraps the core HTMLAttributeNameNode-level check).
  */
-export function hasDynamicAttributeNameOnAttribute(attributeNode: HTMLAttributeNode): boolean {
+export function hasDynamicAttributeName(attributeNode: HTMLAttributeNode): boolean {
   if (!isHTMLAttributeNameNode(attributeNode.name)) return false
 
-  return hasDynamicAttributeName(attributeNode.name)
+  return hasDynamicAttributeNameNode(attributeNode.name)
 }
 
 /**

package/src/diagnostic.ts

@@ -1,6 +1,7 @@
 import { Location, SerializedLocation } from "./location.js"
 
 export type DiagnosticSeverity = "error" | "warning" | "info" | "hint"
+export type DiagnosticTag = "unnecessary" | "deprecated"
 
 /**
  * Base interface for all diagnostic information in Herb tooling.
@@ -32,6 +33,11 @@ export interface Diagnostic {
    * Optional source that generated this diagnostic (e.g., "parser", "linter", "lexer")
    */
   source?: string
+
+  /**
+   * Optional diagnostic tags for additional metadata (e.g., "unnecessary", "deprecated")
+   */
+  tags?: DiagnosticTag[]
 }
 
 /**
@@ -43,6 +49,7 @@ export interface SerializedDiagnostic {
   severity: DiagnosticSeverity
   code?: string
   source?: string
+  tags?: DiagnosticTag[]
 }
 
 export type MonacoSeverity = "error" | "warning" | "info"