@herb-tools/core 0.9.0 → 0.9.1

package/src/errors.ts

@@ -1,5 +1,5 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-0.9.0/templates/javascript/packages/core/src/errors.ts.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.9.1/templates/javascript/packages/core/src/errors.ts.erb
 
 import { Location, SerializedLocation } from "./location.js"
 import { Position, SerializedPosition } from "./position.js"
@@ -30,6 +30,13 @@ export type HerbErrorType =
   | "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
 
@@ -865,16 +872,16 @@ export interface SerializedConditionalElementMultipleTagsError {
   type: "CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR";
   message: string;
   location: SerializedLocation;
-  line: any; // #<Herb::Template::SizeTField:0x0000000121f362c8 @name="line", @options={kind: nil}>
-  column: any; // #<Herb::Template::SizeTField:0x0000000121f362a0 @name="column", @options={kind: nil}>
+  line: any; // #<Herb::Template::SizeTField:0x000000011e9df368 @name="line", @options={kind: nil}>
+  column: any; // #<Herb::Template::SizeTField:0x000000011e9df160 @name="column", @options={kind: nil}>
 }
 
 export interface ConditionalElementMultipleTagsErrorProps {
   type: string;
   message: string;
   location: Location;
-  line: any; // #<Herb::Template::SizeTField:0x0000000121f362c8 @name="line", @options={kind: nil}>
-  column: any; // #<Herb::Template::SizeTField:0x0000000121f362a0 @name="column", @options={kind: nil}>
+  line: any; // #<Herb::Template::SizeTField:0x000000011e9df368 @name="line", @options={kind: nil}>
+  column: any; // #<Herb::Template::SizeTField:0x000000011e9df160 @name="column", @options={kind: nil}>
 }
 
 export class ConditionalElementMultipleTagsError extends HerbError {
@@ -936,11 +943,11 @@ export interface SerializedConditionalElementConditionMismatchError {
   location: SerializedLocation;
   tag_name: string;
   open_condition: string;
-  open_line: any; // #<Herb::Template::SizeTField:0x0000000121f35c38 @name="open_line", @options={kind: nil}>
-  open_column: any; // #<Herb::Template::SizeTField:0x0000000121f35c10 @name="open_column", @options={kind: nil}>
+  open_line: any; // #<Herb::Template::SizeTField:0x000000011e9deb70 @name="open_line", @options={kind: nil}>
+  open_column: any; // #<Herb::Template::SizeTField:0x000000011e9deb48 @name="open_column", @options={kind: nil}>
   close_condition: string;
-  close_line: any; // #<Herb::Template::SizeTField:0x0000000121f35b70 @name="close_line", @options={kind: nil}>
-  close_column: any; // #<Herb::Template::SizeTField:0x0000000121f35b48 @name="close_column", @options={kind: nil}>
+  close_line: any; // #<Herb::Template::SizeTField:0x000000011e9deaf8 @name="close_line", @options={kind: nil}>
+  close_column: any; // #<Herb::Template::SizeTField:0x000000011e9de990 @name="close_column", @options={kind: nil}>
 }
 
 export interface ConditionalElementConditionMismatchErrorProps {
@@ -949,11 +956,11 @@ export interface ConditionalElementConditionMismatchErrorProps {
   location: Location;
   tag_name: string;
   open_condition: string;
-  open_line: any; // #<Herb::Template::SizeTField:0x0000000121f35c38 @name="open_line", @options={kind: nil}>
-  open_column: any; // #<Herb::Template::SizeTField:0x0000000121f35c10 @name="open_column", @options={kind: nil}>
+  open_line: any; // #<Herb::Template::SizeTField:0x000000011e9deb70 @name="open_line", @options={kind: nil}>
+  open_column: any; // #<Herb::Template::SizeTField:0x000000011e9deb48 @name="open_column", @options={kind: nil}>
   close_condition: string;
-  close_line: any; // #<Herb::Template::SizeTField:0x0000000121f35b70 @name="close_line", @options={kind: nil}>
-  close_column: any; // #<Herb::Template::SizeTField:0x0000000121f35b48 @name="close_column", @options={kind: nil}>
+  close_line: any; // #<Herb::Template::SizeTField:0x000000011e9deaf8 @name="close_line", @options={kind: nil}>
+  close_column: any; // #<Herb::Template::SizeTField:0x000000011e9de990 @name="close_column", @options={kind: nil}>
 }
 
 export class ConditionalElementConditionMismatchError extends HerbError {
@@ -1535,8 +1542,8 @@ export interface SerializedNestedERBTagError {
   message: string;
   location: SerializedLocation;
   opening_tag: SerializedToken | null;
-  nested_tag_line: any; // #<Herb::Template::SizeTField:0x0000000121f30760 @name="nested_tag_line", @options={kind: nil}>
-  nested_tag_column: any; // #<Herb::Template::SizeTField:0x0000000121f306e8 @name="nested_tag_column", @options={kind: nil}>
+  nested_tag_line: any; // #<Herb::Template::SizeTField:0x000000011e9dac00 @name="nested_tag_line", @options={kind: nil}>
+  nested_tag_column: any; // #<Herb::Template::SizeTField:0x000000011e9dab60 @name="nested_tag_column", @options={kind: nil}>
 }
 
 export interface NestedERBTagErrorProps {
@@ -1544,8 +1551,8 @@ export interface NestedERBTagErrorProps {
   message: string;
   location: Location;
   opening_tag: Token | null;
-  nested_tag_line: any; // #<Herb::Template::SizeTField:0x0000000121f30760 @name="nested_tag_line", @options={kind: nil}>
-  nested_tag_column: any; // #<Herb::Template::SizeTField:0x0000000121f306e8 @name="nested_tag_column", @options={kind: nil}>
+  nested_tag_line: any; // #<Herb::Template::SizeTField:0x000000011e9dac00 @name="nested_tag_line", @options={kind: nil}>
+  nested_tag_column: any; // #<Herb::Template::SizeTField:0x000000011e9dab60 @name="nested_tag_column", @options={kind: nil}>
 }
 
 export class NestedERBTagError extends HerbError {
@@ -1606,6 +1613,440 @@ export class NestedERBTagError extends HerbError {
   }
 }
 
+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 class RenderAmbiguousLocalsError extends HerbError {
+  readonly partial: string;
+
+  static from(data: SerializedRenderAmbiguousLocalsError): RenderAmbiguousLocalsError {
+    return new RenderAmbiguousLocalsError({
+      type: data.type,
+      message: data.message,
+      location: Location.from(data.location),
+      partial: data.partial,
+    })
+  }
+
+  constructor(props: RenderAmbiguousLocalsErrorProps) {
+    super(props.type, props.message, props.location);
+
+    this.partial = props.partial;
+  }
+
+  toJSON(): SerializedRenderAmbiguousLocalsError {
+    return {
+      ...super.toJSON(),
+      type: "RENDER_AMBIGUOUS_LOCALS_ERROR",
+      partial: this.partial,
+    };
+  }
+
+  toMonacoDiagnostic(): MonacoDiagnostic {
+    return {
+      line: this.location.start.line,
+      column: this.location.start.column,
+      endLine: this.location.end.line,
+      endColumn: this.location.end.column,
+      message: this.message,
+      severity: 'error'
+    }
+  }
+
+  treeInspect(): string {
+    let output = "";
+
+    output += `@ RenderAmbiguousLocalsError ${this.location.treeInspectWithLabel()}\n`;
+    output += `├── message: "${this.message}"\n`;
+    output += `└── partial: ${JSON.stringify(this.partial)}\n`;
+
+    return output;
+  }
+}
+
+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 class RenderMissingLocalsError extends HerbError {
+  readonly partial: string;
+  readonly keywords: string;
+
+  static from(data: SerializedRenderMissingLocalsError): RenderMissingLocalsError {
+    return new RenderMissingLocalsError({
+      type: data.type,
+      message: data.message,
+      location: Location.from(data.location),
+      partial: data.partial,
+      keywords: data.keywords,
+    })
+  }
+
+  constructor(props: RenderMissingLocalsErrorProps) {
+    super(props.type, props.message, props.location);
+
+    this.partial = props.partial;
+    this.keywords = props.keywords;
+  }
+
+  toJSON(): SerializedRenderMissingLocalsError {
+    return {
+      ...super.toJSON(),
+      type: "RENDER_MISSING_LOCALS_ERROR",
+      partial: this.partial,
+      keywords: this.keywords,
+    };
+  }
+
+  toMonacoDiagnostic(): MonacoDiagnostic {
+    return {
+      line: this.location.start.line,
+      column: this.location.start.column,
+      endLine: this.location.end.line,
+      endColumn: this.location.end.column,
+      message: this.message,
+      severity: 'error'
+    }
+  }
+
+  treeInspect(): string {
+    let output = "";
+
+    output += `@ RenderMissingLocalsError ${this.location.treeInspectWithLabel()}\n`;
+    output += `├── message: "${this.message}"\n`;
+    output += `├── partial: ${JSON.stringify(this.partial)}\n`;
+    output += `└── keywords: ${JSON.stringify(this.keywords)}\n`;
+
+    return output;
+  }
+}
+
+export interface SerializedRenderNoArgumentsError {
+  type: "RENDER_NO_ARGUMENTS_ERROR";
+  message: string;
+  location: SerializedLocation;
+}
+
+export interface RenderNoArgumentsErrorProps {
+  type: string;
+  message: string;
+  location: Location;
+}
+
+export class RenderNoArgumentsError extends HerbError {
+
+  static from(data: SerializedRenderNoArgumentsError): RenderNoArgumentsError {
+    return new RenderNoArgumentsError({
+      type: data.type,
+      message: data.message,
+      location: Location.from(data.location),
+    })
+  }
+
+  constructor(props: RenderNoArgumentsErrorProps) {
+    super(props.type, props.message, props.location);
+
+  }
+
+  toJSON(): SerializedRenderNoArgumentsError {
+    return {
+      ...super.toJSON(),
+      type: "RENDER_NO_ARGUMENTS_ERROR",
+    };
+  }
+
+  toMonacoDiagnostic(): MonacoDiagnostic {
+    return {
+      line: this.location.start.line,
+      column: this.location.start.column,
+      endLine: this.location.end.line,
+      endColumn: this.location.end.column,
+      message: this.message,
+      severity: 'error'
+    }
+  }
+
+  treeInspect(): string {
+    let output = "";
+
+    output += `@ RenderNoArgumentsError ${this.location.treeInspectWithLabel()}\n`;
+    output += `└── message: "${this.message}"\n`;
+
+    return output;
+  }
+}
+
+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 class RenderConflictingPartialError extends HerbError {
+  readonly positional_partial: string;
+  readonly keyword_partial: string;
+
+  static from(data: SerializedRenderConflictingPartialError): RenderConflictingPartialError {
+    return new RenderConflictingPartialError({
+      type: data.type,
+      message: data.message,
+      location: Location.from(data.location),
+      positional_partial: data.positional_partial,
+      keyword_partial: data.keyword_partial,
+    })
+  }
+
+  constructor(props: RenderConflictingPartialErrorProps) {
+    super(props.type, props.message, props.location);
+
+    this.positional_partial = props.positional_partial;
+    this.keyword_partial = props.keyword_partial;
+  }
+
+  toJSON(): SerializedRenderConflictingPartialError {
+    return {
+      ...super.toJSON(),
+      type: "RENDER_CONFLICTING_PARTIAL_ERROR",
+      positional_partial: this.positional_partial,
+      keyword_partial: this.keyword_partial,
+    };
+  }
+
+  toMonacoDiagnostic(): MonacoDiagnostic {
+    return {
+      line: this.location.start.line,
+      column: this.location.start.column,
+      endLine: this.location.end.line,
+      endColumn: this.location.end.column,
+      message: this.message,
+      severity: 'error'
+    }
+  }
+
+  treeInspect(): string {
+    let output = "";
+
+    output += `@ RenderConflictingPartialError ${this.location.treeInspectWithLabel()}\n`;
+    output += `├── message: "${this.message}"\n`;
+    output += `├── positional_partial: ${JSON.stringify(this.positional_partial)}\n`;
+    output += `└── keyword_partial: ${JSON.stringify(this.keyword_partial)}\n`;
+
+    return output;
+  }
+}
+
+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 class RenderInvalidAsOptionError extends HerbError {
+  readonly as_value: string;
+
+  static from(data: SerializedRenderInvalidAsOptionError): RenderInvalidAsOptionError {
+    return new RenderInvalidAsOptionError({
+      type: data.type,
+      message: data.message,
+      location: Location.from(data.location),
+      as_value: data.as_value,
+    })
+  }
+
+  constructor(props: RenderInvalidAsOptionErrorProps) {
+    super(props.type, props.message, props.location);
+
+    this.as_value = props.as_value;
+  }
+
+  toJSON(): SerializedRenderInvalidAsOptionError {
+    return {
+      ...super.toJSON(),
+      type: "RENDER_INVALID_AS_OPTION_ERROR",
+      as_value: this.as_value,
+    };
+  }
+
+  toMonacoDiagnostic(): MonacoDiagnostic {
+    return {
+      line: this.location.start.line,
+      column: this.location.start.column,
+      endLine: this.location.end.line,
+      endColumn: this.location.end.column,
+      message: this.message,
+      severity: 'error'
+    }
+  }
+
+  treeInspect(): string {
+    let output = "";
+
+    output += `@ RenderInvalidAsOptionError ${this.location.treeInspectWithLabel()}\n`;
+    output += `├── message: "${this.message}"\n`;
+    output += `└── as_value: ${JSON.stringify(this.as_value)}\n`;
+
+    return output;
+  }
+}
+
+export interface SerializedRenderObjectAndCollectionError {
+  type: "RENDER_OBJECT_AND_COLLECTION_ERROR";
+  message: string;
+  location: SerializedLocation;
+}
+
+export interface RenderObjectAndCollectionErrorProps {
+  type: string;
+  message: string;
+  location: Location;
+}
+
+export class RenderObjectAndCollectionError extends HerbError {
+
+  static from(data: SerializedRenderObjectAndCollectionError): RenderObjectAndCollectionError {
+    return new RenderObjectAndCollectionError({
+      type: data.type,
+      message: data.message,
+      location: Location.from(data.location),
+    })
+  }
+
+  constructor(props: RenderObjectAndCollectionErrorProps) {
+    super(props.type, props.message, props.location);
+
+  }
+
+  toJSON(): SerializedRenderObjectAndCollectionError {
+    return {
+      ...super.toJSON(),
+      type: "RENDER_OBJECT_AND_COLLECTION_ERROR",
+    };
+  }
+
+  toMonacoDiagnostic(): MonacoDiagnostic {
+    return {
+      line: this.location.start.line,
+      column: this.location.start.column,
+      endLine: this.location.end.line,
+      endColumn: this.location.end.column,
+      message: this.message,
+      severity: 'error'
+    }
+  }
+
+  treeInspect(): string {
+    let output = "";
+
+    output += `@ RenderObjectAndCollectionError ${this.location.treeInspectWithLabel()}\n`;
+    output += `└── message: "${this.message}"\n`;
+
+    return output;
+  }
+}
+
+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 class RenderLayoutWithoutBlockError extends HerbError {
+  readonly layout: string;
+
+  static from(data: SerializedRenderLayoutWithoutBlockError): RenderLayoutWithoutBlockError {
+    return new RenderLayoutWithoutBlockError({
+      type: data.type,
+      message: data.message,
+      location: Location.from(data.location),
+      layout: data.layout,
+    })
+  }
+
+  constructor(props: RenderLayoutWithoutBlockErrorProps) {
+    super(props.type, props.message, props.location);
+
+    this.layout = props.layout;
+  }
+
+  toJSON(): SerializedRenderLayoutWithoutBlockError {
+    return {
+      ...super.toJSON(),
+      type: "RENDER_LAYOUT_WITHOUT_BLOCK_ERROR",
+      layout: this.layout,
+    };
+  }
+
+  toMonacoDiagnostic(): MonacoDiagnostic {
+    return {
+      line: this.location.start.line,
+      column: this.location.start.column,
+      endLine: this.location.end.line,
+      endColumn: this.location.end.column,
+      message: this.message,
+      severity: 'error'
+    }
+  }
+
+  treeInspect(): string {
+    let output = "";
+
+    output += `@ RenderLayoutWithoutBlockError ${this.location.treeInspectWithLabel()}\n`;
+    output += `├── message: "${this.message}"\n`;
+    output += `└── layout: ${JSON.stringify(this.layout)}\n`;
+
+    return output;
+  }
+}
+
 
 export function fromSerializedError(error: SerializedHerbError): HerbError {
   switch (error.type) {
@@ -1632,6 +2073,13 @@ export function fromSerializedError(error: SerializedHerbError): HerbError {
     case "UNCLOSED_ERB_TAG_ERROR": return UnclosedERBTagError.from(error as SerializedUnclosedERBTagError);
     case "STRAY_ERB_CLOSING_TAG_ERROR": return StrayERBClosingTagError.from(error as SerializedStrayERBClosingTagError);
     case "NESTED_ERB_TAG_ERROR": return NestedERBTagError.from(error as SerializedNestedERBTagError);
+    case "RENDER_AMBIGUOUS_LOCALS_ERROR": return RenderAmbiguousLocalsError.from(error as SerializedRenderAmbiguousLocalsError);
+    case "RENDER_MISSING_LOCALS_ERROR": return RenderMissingLocalsError.from(error as SerializedRenderMissingLocalsError);
+    case "RENDER_NO_ARGUMENTS_ERROR": return RenderNoArgumentsError.from(error as SerializedRenderNoArgumentsError);
+    case "RENDER_CONFLICTING_PARTIAL_ERROR": return RenderConflictingPartialError.from(error as SerializedRenderConflictingPartialError);
+    case "RENDER_INVALID_AS_OPTION_ERROR": return RenderInvalidAsOptionError.from(error as SerializedRenderInvalidAsOptionError);
+    case "RENDER_OBJECT_AND_COLLECTION_ERROR": return RenderObjectAndCollectionError.from(error as SerializedRenderObjectAndCollectionError);
+    case "RENDER_LAYOUT_WITHOUT_BLOCK_ERROR": return RenderLayoutWithoutBlockError.from(error as SerializedRenderLayoutWithoutBlockError);
 
     default:
       throw new Error(`Unknown node type: ${error.type}`);

package/src/node-type-guards.ts

@@ -1,5 +1,5 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-0.9.0/templates/javascript/packages/core/src/node-type-guards.ts.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.9.1/templates/javascript/packages/core/src/node-type-guards.ts.erb
 
 import type { Node, NodeType, ERBNode } from "./nodes.js"
 
@@ -43,6 +43,8 @@ import {
   ERBEnsureNode,
   ERBBeginNode,
   ERBUnlessNode,
+  RubyRenderLocalNode,
+  ERBRenderNode,
   ERBYieldNode,
   ERBInNode,
 } from "./nodes.js"
@@ -378,6 +380,24 @@ export function isERBUnlessNode(node: Node | null | undefined): node is ERBUnle
   return node instanceof ERBUnlessNode || node.type === "AST_ERB_UNLESS_NODE" || (node.constructor as any).type === "AST_ERB_UNLESS_NODE"
 }
 
+/**
+ * Checks if a node is a RubyRenderLocalNode
+ */
+export function isRubyRenderLocalNode(node: Node | null | undefined): node is RubyRenderLocalNode {
+  if (!node) return false
+
+  return node instanceof RubyRenderLocalNode || node.type === "AST_RUBY_RENDER_LOCAL_NODE" || (node.constructor as any).type === "AST_RUBY_RENDER_LOCAL_NODE"
+}
+
+/**
+ * Checks if a node is a ERBRenderNode
+ */
+export function isERBRenderNode(node: Node | null | undefined): node is ERBRenderNode {
+  if (!node) return false
+
+  return node instanceof ERBRenderNode || node.type === "AST_ERB_RENDER_NODE" || (node.constructor as any).type === "AST_ERB_RENDER_NODE"
+}
+
 /**
  * Checks if a node is a ERBYieldNode
  */
@@ -439,6 +459,7 @@ export function isERBNode(node: Node): node is ERBNode {
          isERBEnsureNode(node) ||
          isERBBeginNode(node) ||
          isERBUnlessNode(node) ||
+         isERBRenderNode(node) ||
          isERBYieldNode(node) ||
          isERBInNode(node)
 }
@@ -490,6 +511,8 @@ export const NODE_TYPE_GUARDS = new Map<new (...args: any[]) => Node, (node: Nod
   [ERBEnsureNode, isERBEnsureNode],
   [ERBBeginNode, isERBBeginNode],
   [ERBUnlessNode, isERBUnlessNode],
+  [RubyRenderLocalNode, isRubyRenderLocalNode],
+  [ERBRenderNode, isERBRenderNode],
   [ERBYieldNode, isERBYieldNode],
   [ERBInNode, isERBInNode],
 ])
@@ -541,6 +564,8 @@ export const AST_TYPE_GUARDS = new Map<NodeType, (node: Node) => boolean>([
   ["AST_ERB_ENSURE_NODE", isERBEnsureNode],
   ["AST_ERB_BEGIN_NODE", isERBBeginNode],
   ["AST_ERB_UNLESS_NODE", isERBUnlessNode],
+  ["AST_RUBY_RENDER_LOCAL_NODE", isRubyRenderLocalNode],
+  ["AST_ERB_RENDER_NODE", isERBRenderNode],
   ["AST_ERB_YIELD_NODE", isERBYieldNode],
   ["AST_ERB_IN_NODE", isERBInNode],
 ])
@@ -582,6 +607,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;
 }
@@ -1069,6 +1096,20 @@ export function filterERBUnlessNodes(nodes: Node[]): ERBUnlessNode[] {
   return nodes.filter(isERBUnlessNode) as ERBUnlessNode[]
 }
 
+/**
+ * Filters an array of nodes to only include RubyRenderLocalNode nodes
+ */
+export function filterRubyRenderLocalNodes(nodes: Node[]): RubyRenderLocalNode[] {
+  return nodes.filter(isRubyRenderLocalNode) as RubyRenderLocalNode[]
+}
+
+/**
+ * Filters an array of nodes to only include ERBRenderNode nodes
+ */
+export function filterERBRenderNodes(nodes: Node[]): ERBRenderNode[] {
+  return nodes.filter(isERBRenderNode) as ERBRenderNode[]
+}
+
 /**
  * Filters an array of nodes to only include ERBYieldNode nodes
  */