@herb-tools/core 0.8.10 → 0.9.1

package/src/errors.ts

@@ -1,7 +1,8 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.10/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"
 import { Token, SerializedToken } from "./token.js"
 import { Diagnostic, MonacoDiagnostic } from "./diagnostic.js"
 
@@ -11,14 +12,31 @@ export type HerbErrorType =
   | "MISSING_OPENING_TAG_ERROR"
   | "MISSING_CLOSING_TAG_ERROR"
   | "TAG_NAMES_MISMATCH_ERROR"
-  | "QUOTES_MISMATCH_ERROR"
   | "VOID_ELEMENT_CLOSING_TAG_ERROR"
   | "UNCLOSED_ELEMENT_ERROR"
   | "RUBY_PARSE_ERROR"
   | "ERB_CONTROL_FLOW_SCOPE_ERROR"
-  | "MISSINGERB_END_TAG_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
 
@@ -402,75 +420,6 @@ export class TagNamesMismatchError extends HerbError {
   }
 }
 
-export interface SerializedQuotesMismatchError {
-  type: "QUOTES_MISMATCH_ERROR";
-  message: string;
-  location: SerializedLocation;
-  opening_quote: SerializedToken | null;
-  closing_quote: SerializedToken | null;
-}
-
-export interface QuotesMismatchErrorProps {
-  type: string;
-  message: string;
-  location: Location;
-  opening_quote: Token | null;
-  closing_quote: Token | null;
-}
-
-export class QuotesMismatchError extends HerbError {
-  readonly opening_quote: Token | null;
-  readonly closing_quote: Token | null;
-
-  static from(data: SerializedQuotesMismatchError): QuotesMismatchError {
-    return new QuotesMismatchError({
-      type: data.type,
-      message: data.message,
-      location: Location.from(data.location),
-      opening_quote: data.opening_quote ? Token.from(data.opening_quote) : null,
-      closing_quote: data.closing_quote ? Token.from(data.closing_quote) : null,
-    })
-  }
-
-  constructor(props: QuotesMismatchErrorProps) {
-    super(props.type, props.message, props.location);
-
-    this.opening_quote = props.opening_quote;
-    this.closing_quote = props.closing_quote;
-  }
-
-  toJSON(): SerializedQuotesMismatchError {
-    return {
-      ...super.toJSON(),
-      type: "QUOTES_MISMATCH_ERROR",
-      opening_quote: this.opening_quote ? this.opening_quote.toJSON() : null,
-      closing_quote: this.closing_quote ? this.closing_quote.toJSON() : null,
-    };
-  }
-
-  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 += `@ QuotesMismatchError ${this.location.treeInspectWithLabel()}\n`;
-    output += `├── message: "${this.message}"\n`;
-    output += `├── opening_quote: ${this.opening_quote ? this.opening_quote.treeInspect() : "∅"}\n`;
-    output += `└── closing_quote: ${this.closing_quote ? this.closing_quote.treeInspect() : "∅"}\n`;
-
-    return output;
-  }
-}
-
 export interface SerializedVoidElementClosingTagError {
   type: "VOID_ELEMENT_CLOSING_TAG_ERROR";
   message: string;
@@ -748,7 +697,7 @@ export class ERBControlFlowScopeError extends HerbError {
 }
 
 export interface SerializedMissingERBEndTagError {
-  type: "MISSINGERB_END_TAG_ERROR";
+  type: "MISSING_ERB_END_TAG_ERROR";
   message: string;
   location: SerializedLocation;
   keyword: string;
@@ -782,7 +731,7 @@ export class MissingERBEndTagError extends HerbError {
   toJSON(): SerializedMissingERBEndTagError {
     return {
       ...super.toJSON(),
-      type: "MISSINGERB_END_TAG_ERROR",
+      type: "MISSING_ERB_END_TAG_ERROR",
       keyword: this.keyword,
     };
   }
@@ -919,6 +868,1185 @@ export class ERBCaseWithConditionsError extends HerbError {
   }
 }
 
+export interface SerializedConditionalElementMultipleTagsError {
+  type: "CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR";
+  message: string;
+  location: SerializedLocation;
+  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:0x000000011e9df368 @name="line", @options={kind: nil}>
+  column: any; // #<Herb::Template::SizeTField:0x000000011e9df160 @name="column", @options={kind: nil}>
+}
+
+export class ConditionalElementMultipleTagsError extends HerbError {
+  readonly line: any;
+  readonly column: any;
+
+  static from(data: SerializedConditionalElementMultipleTagsError): ConditionalElementMultipleTagsError {
+    return new ConditionalElementMultipleTagsError({
+      type: data.type,
+      message: data.message,
+      location: Location.from(data.location),
+      line: data.line,
+      column: data.column,
+    })
+  }
+
+  constructor(props: ConditionalElementMultipleTagsErrorProps) {
+    super(props.type, props.message, props.location);
+
+    this.line = props.line;
+    this.column = props.column;
+  }
+
+  toJSON(): SerializedConditionalElementMultipleTagsError {
+    return {
+      ...super.toJSON(),
+      type: "CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR",
+      line: this.line,
+      column: this.column,
+    };
+  }
+
+  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 += `@ ConditionalElementMultipleTagsError ${this.location.treeInspectWithLabel()}\n`;
+    output += `├── message: "${this.message}"\n`;
+    output += `├── line: ${JSON.stringify(this.line)}\n`;
+    output += `└── column: ${JSON.stringify(this.column)}\n`;
+
+    return output;
+  }
+}
+
+export interface SerializedConditionalElementConditionMismatchError {
+  type: "CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR";
+  message: string;
+  location: SerializedLocation;
+  tag_name: string;
+  open_condition: string;
+  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:0x000000011e9deaf8 @name="close_line", @options={kind: nil}>
+  close_column: any; // #<Herb::Template::SizeTField:0x000000011e9de990 @name="close_column", @options={kind: nil}>
+}
+
+export interface ConditionalElementConditionMismatchErrorProps {
+  type: string;
+  message: string;
+  location: Location;
+  tag_name: string;
+  open_condition: string;
+  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: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 {
+  readonly tag_name: string;
+  readonly open_condition: string;
+  readonly open_line: any;
+  readonly open_column: any;
+  readonly close_condition: string;
+  readonly close_line: any;
+  readonly close_column: any;
+
+  static from(data: SerializedConditionalElementConditionMismatchError): ConditionalElementConditionMismatchError {
+    return new ConditionalElementConditionMismatchError({
+      type: data.type,
+      message: data.message,
+      location: Location.from(data.location),
+      tag_name: data.tag_name,
+      open_condition: data.open_condition,
+      open_line: data.open_line,
+      open_column: data.open_column,
+      close_condition: data.close_condition,
+      close_line: data.close_line,
+      close_column: data.close_column,
+    })
+  }
+
+  constructor(props: ConditionalElementConditionMismatchErrorProps) {
+    super(props.type, props.message, props.location);
+
+    this.tag_name = props.tag_name;
+    this.open_condition = props.open_condition;
+    this.open_line = props.open_line;
+    this.open_column = props.open_column;
+    this.close_condition = props.close_condition;
+    this.close_line = props.close_line;
+    this.close_column = props.close_column;
+  }
+
+  toJSON(): SerializedConditionalElementConditionMismatchError {
+    return {
+      ...super.toJSON(),
+      type: "CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR",
+      tag_name: this.tag_name,
+      open_condition: this.open_condition,
+      open_line: this.open_line,
+      open_column: this.open_column,
+      close_condition: this.close_condition,
+      close_line: this.close_line,
+      close_column: this.close_column,
+    };
+  }
+
+  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 += `@ ConditionalElementConditionMismatchError ${this.location.treeInspectWithLabel()}\n`;
+    output += `├── message: "${this.message}"\n`;
+    output += `├── tag_name: ${JSON.stringify(this.tag_name)}\n`;
+    output += `├── open_condition: ${JSON.stringify(this.open_condition)}\n`;
+    output += `├── open_line: ${JSON.stringify(this.open_line)}\n`;
+    output += `├── open_column: ${JSON.stringify(this.open_column)}\n`;
+    output += `├── close_condition: ${JSON.stringify(this.close_condition)}\n`;
+    output += `├── close_line: ${JSON.stringify(this.close_line)}\n`;
+    output += `└── close_column: ${JSON.stringify(this.close_column)}\n`;
+
+    return output;
+  }
+}
+
+export interface SerializedInvalidCommentClosingTagError {
+  type: "INVALID_COMMENT_CLOSING_TAG_ERROR";
+  message: string;
+  location: SerializedLocation;
+  closing_tag: SerializedToken | null;
+}
+
+export interface InvalidCommentClosingTagErrorProps {
+  type: string;
+  message: string;
+  location: Location;
+  closing_tag: Token | null;
+}
+
+export class InvalidCommentClosingTagError extends HerbError {
+  readonly closing_tag: Token | null;
+
+  static from(data: SerializedInvalidCommentClosingTagError): InvalidCommentClosingTagError {
+    return new InvalidCommentClosingTagError({
+      type: data.type,
+      message: data.message,
+      location: Location.from(data.location),
+      closing_tag: data.closing_tag ? Token.from(data.closing_tag) : null,
+    })
+  }
+
+  constructor(props: InvalidCommentClosingTagErrorProps) {
+    super(props.type, props.message, props.location);
+
+    this.closing_tag = props.closing_tag;
+  }
+
+  toJSON(): SerializedInvalidCommentClosingTagError {
+    return {
+      ...super.toJSON(),
+      type: "INVALID_COMMENT_CLOSING_TAG_ERROR",
+      closing_tag: this.closing_tag ? this.closing_tag.toJSON() : null,
+    };
+  }
+
+  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 += `@ InvalidCommentClosingTagError ${this.location.treeInspectWithLabel()}\n`;
+    output += `├── message: "${this.message}"\n`;
+    output += `└── closing_tag: ${this.closing_tag ? this.closing_tag.treeInspect() : "∅"}\n`;
+
+    return output;
+  }
+}
+
+export interface SerializedOmittedClosingTagError {
+  type: "OMITTED_CLOSING_TAG_ERROR";
+  message: string;
+  location: SerializedLocation;
+  opening_tag: SerializedToken | null;
+  insertion_point: SerializedPosition;
+}
+
+export interface OmittedClosingTagErrorProps {
+  type: string;
+  message: string;
+  location: Location;
+  opening_tag: Token | null;
+  insertion_point: Position;
+}
+
+export class OmittedClosingTagError extends HerbError {
+  readonly opening_tag: Token | null;
+  readonly insertion_point: Position;
+
+  static from(data: SerializedOmittedClosingTagError): OmittedClosingTagError {
+    return new OmittedClosingTagError({
+      type: data.type,
+      message: data.message,
+      location: Location.from(data.location),
+      opening_tag: data.opening_tag ? Token.from(data.opening_tag) : null,
+      insertion_point: Position.from(data.insertion_point),
+    })
+  }
+
+  constructor(props: OmittedClosingTagErrorProps) {
+    super(props.type, props.message, props.location);
+
+    this.opening_tag = props.opening_tag;
+    this.insertion_point = props.insertion_point;
+  }
+
+  toJSON(): SerializedOmittedClosingTagError {
+    return {
+      ...super.toJSON(),
+      type: "OMITTED_CLOSING_TAG_ERROR",
+      opening_tag: this.opening_tag ? this.opening_tag.toJSON() : null,
+      insertion_point: this.insertion_point.toJSON(),
+    };
+  }
+
+  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 += `@ OmittedClosingTagError ${this.location.treeInspectWithLabel()}\n`;
+    output += `├── message: "${this.message}"\n`;
+    output += `├── opening_tag: ${this.opening_tag ? this.opening_tag.treeInspect() : "∅"}\n`;
+    output += `└── insertion_point: (${this.insertion_point.line}:${this.insertion_point.column})\n`;
+
+    return output;
+  }
+}
+
+export interface SerializedUnclosedOpenTagError {
+  type: "UNCLOSED_OPEN_TAG_ERROR";
+  message: string;
+  location: SerializedLocation;
+  tag_name: SerializedToken | null;
+}
+
+export interface UnclosedOpenTagErrorProps {
+  type: string;
+  message: string;
+  location: Location;
+  tag_name: Token | null;
+}
+
+export class UnclosedOpenTagError extends HerbError {
+  readonly tag_name: Token | null;
+
+  static from(data: SerializedUnclosedOpenTagError): UnclosedOpenTagError {
+    return new UnclosedOpenTagError({
+      type: data.type,
+      message: data.message,
+      location: Location.from(data.location),
+      tag_name: data.tag_name ? Token.from(data.tag_name) : null,
+    })
+  }
+
+  constructor(props: UnclosedOpenTagErrorProps) {
+    super(props.type, props.message, props.location);
+
+    this.tag_name = props.tag_name;
+  }
+
+  toJSON(): SerializedUnclosedOpenTagError {
+    return {
+      ...super.toJSON(),
+      type: "UNCLOSED_OPEN_TAG_ERROR",
+      tag_name: this.tag_name ? this.tag_name.toJSON() : null,
+    };
+  }
+
+  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 += `@ UnclosedOpenTagError ${this.location.treeInspectWithLabel()}\n`;
+    output += `├── message: "${this.message}"\n`;
+    output += `└── tag_name: ${this.tag_name ? this.tag_name.treeInspect() : "∅"}\n`;
+
+    return output;
+  }
+}
+
+export interface SerializedUnclosedCloseTagError {
+  type: "UNCLOSED_CLOSE_TAG_ERROR";
+  message: string;
+  location: SerializedLocation;
+  tag_name: SerializedToken | null;
+}
+
+export interface UnclosedCloseTagErrorProps {
+  type: string;
+  message: string;
+  location: Location;
+  tag_name: Token | null;
+}
+
+export class UnclosedCloseTagError extends HerbError {
+  readonly tag_name: Token | null;
+
+  static from(data: SerializedUnclosedCloseTagError): UnclosedCloseTagError {
+    return new UnclosedCloseTagError({
+      type: data.type,
+      message: data.message,
+      location: Location.from(data.location),
+      tag_name: data.tag_name ? Token.from(data.tag_name) : null,
+    })
+  }
+
+  constructor(props: UnclosedCloseTagErrorProps) {
+    super(props.type, props.message, props.location);
+
+    this.tag_name = props.tag_name;
+  }
+
+  toJSON(): SerializedUnclosedCloseTagError {
+    return {
+      ...super.toJSON(),
+      type: "UNCLOSED_CLOSE_TAG_ERROR",
+      tag_name: this.tag_name ? this.tag_name.toJSON() : null,
+    };
+  }
+
+  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 += `@ UnclosedCloseTagError ${this.location.treeInspectWithLabel()}\n`;
+    output += `├── message: "${this.message}"\n`;
+    output += `└── tag_name: ${this.tag_name ? this.tag_name.treeInspect() : "∅"}\n`;
+
+    return output;
+  }
+}
+
+export interface SerializedUnclosedQuoteError {
+  type: "UNCLOSED_QUOTE_ERROR";
+  message: string;
+  location: SerializedLocation;
+  opening_quote: SerializedToken | null;
+}
+
+export interface UnclosedQuoteErrorProps {
+  type: string;
+  message: string;
+  location: Location;
+  opening_quote: Token | null;
+}
+
+export class UnclosedQuoteError extends HerbError {
+  readonly opening_quote: Token | null;
+
+  static from(data: SerializedUnclosedQuoteError): UnclosedQuoteError {
+    return new UnclosedQuoteError({
+      type: data.type,
+      message: data.message,
+      location: Location.from(data.location),
+      opening_quote: data.opening_quote ? Token.from(data.opening_quote) : null,
+    })
+  }
+
+  constructor(props: UnclosedQuoteErrorProps) {
+    super(props.type, props.message, props.location);
+
+    this.opening_quote = props.opening_quote;
+  }
+
+  toJSON(): SerializedUnclosedQuoteError {
+    return {
+      ...super.toJSON(),
+      type: "UNCLOSED_QUOTE_ERROR",
+      opening_quote: this.opening_quote ? this.opening_quote.toJSON() : null,
+    };
+  }
+
+  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 += `@ UnclosedQuoteError ${this.location.treeInspectWithLabel()}\n`;
+    output += `├── message: "${this.message}"\n`;
+    output += `└── opening_quote: ${this.opening_quote ? this.opening_quote.treeInspect() : "∅"}\n`;
+
+    return output;
+  }
+}
+
+export interface SerializedMissingAttributeValueError {
+  type: "MISSING_ATTRIBUTE_VALUE_ERROR";
+  message: string;
+  location: SerializedLocation;
+  attribute_name: string;
+}
+
+export interface MissingAttributeValueErrorProps {
+  type: string;
+  message: string;
+  location: Location;
+  attribute_name: string;
+}
+
+export class MissingAttributeValueError extends HerbError {
+  readonly attribute_name: string;
+
+  static from(data: SerializedMissingAttributeValueError): MissingAttributeValueError {
+    return new MissingAttributeValueError({
+      type: data.type,
+      message: data.message,
+      location: Location.from(data.location),
+      attribute_name: data.attribute_name,
+    })
+  }
+
+  constructor(props: MissingAttributeValueErrorProps) {
+    super(props.type, props.message, props.location);
+
+    this.attribute_name = props.attribute_name;
+  }
+
+  toJSON(): SerializedMissingAttributeValueError {
+    return {
+      ...super.toJSON(),
+      type: "MISSING_ATTRIBUTE_VALUE_ERROR",
+      attribute_name: this.attribute_name,
+    };
+  }
+
+  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 += `@ MissingAttributeValueError ${this.location.treeInspectWithLabel()}\n`;
+    output += `├── message: "${this.message}"\n`;
+    output += `└── attribute_name: ${JSON.stringify(this.attribute_name)}\n`;
+
+    return output;
+  }
+}
+
+export interface SerializedUnclosedERBTagError {
+  type: "UNCLOSED_ERB_TAG_ERROR";
+  message: string;
+  location: SerializedLocation;
+  opening_tag: SerializedToken | null;
+}
+
+export interface UnclosedERBTagErrorProps {
+  type: string;
+  message: string;
+  location: Location;
+  opening_tag: Token | null;
+}
+
+export class UnclosedERBTagError extends HerbError {
+  readonly opening_tag: Token | null;
+
+  static from(data: SerializedUnclosedERBTagError): UnclosedERBTagError {
+    return new UnclosedERBTagError({
+      type: data.type,
+      message: data.message,
+      location: Location.from(data.location),
+      opening_tag: data.opening_tag ? Token.from(data.opening_tag) : null,
+    })
+  }
+
+  constructor(props: UnclosedERBTagErrorProps) {
+    super(props.type, props.message, props.location);
+
+    this.opening_tag = props.opening_tag;
+  }
+
+  toJSON(): SerializedUnclosedERBTagError {
+    return {
+      ...super.toJSON(),
+      type: "UNCLOSED_ERB_TAG_ERROR",
+      opening_tag: this.opening_tag ? this.opening_tag.toJSON() : null,
+    };
+  }
+
+  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 += `@ UnclosedERBTagError ${this.location.treeInspectWithLabel()}\n`;
+    output += `├── message: "${this.message}"\n`;
+    output += `└── opening_tag: ${this.opening_tag ? this.opening_tag.treeInspect() : "∅"}\n`;
+
+    return output;
+  }
+}
+
+export interface SerializedStrayERBClosingTagError {
+  type: "STRAY_ERB_CLOSING_TAG_ERROR";
+  message: string;
+  location: SerializedLocation;
+}
+
+export interface StrayERBClosingTagErrorProps {
+  type: string;
+  message: string;
+  location: Location;
+}
+
+export class StrayERBClosingTagError extends HerbError {
+
+  static from(data: SerializedStrayERBClosingTagError): StrayERBClosingTagError {
+    return new StrayERBClosingTagError({
+      type: data.type,
+      message: data.message,
+      location: Location.from(data.location),
+    })
+  }
+
+  constructor(props: StrayERBClosingTagErrorProps) {
+    super(props.type, props.message, props.location);
+
+  }
+
+  toJSON(): SerializedStrayERBClosingTagError {
+    return {
+      ...super.toJSON(),
+      type: "STRAY_ERB_CLOSING_TAG_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 += `@ StrayERBClosingTagError ${this.location.treeInspectWithLabel()}\n`;
+    output += `└── message: "${this.message}"\n`;
+
+    return output;
+  }
+}
+
+export interface SerializedNestedERBTagError {
+  type: "NESTED_ERB_TAG_ERROR";
+  message: string;
+  location: SerializedLocation;
+  opening_tag: SerializedToken | null;
+  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 {
+  type: string;
+  message: string;
+  location: Location;
+  opening_tag: Token | null;
+  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 {
+  readonly opening_tag: Token | null;
+  readonly nested_tag_line: any;
+  readonly nested_tag_column: any;
+
+  static from(data: SerializedNestedERBTagError): NestedERBTagError {
+    return new NestedERBTagError({
+      type: data.type,
+      message: data.message,
+      location: Location.from(data.location),
+      opening_tag: data.opening_tag ? Token.from(data.opening_tag) : null,
+      nested_tag_line: data.nested_tag_line,
+      nested_tag_column: data.nested_tag_column,
+    })
+  }
+
+  constructor(props: NestedERBTagErrorProps) {
+    super(props.type, props.message, props.location);
+
+    this.opening_tag = props.opening_tag;
+    this.nested_tag_line = props.nested_tag_line;
+    this.nested_tag_column = props.nested_tag_column;
+  }
+
+  toJSON(): SerializedNestedERBTagError {
+    return {
+      ...super.toJSON(),
+      type: "NESTED_ERB_TAG_ERROR",
+      opening_tag: this.opening_tag ? this.opening_tag.toJSON() : null,
+      nested_tag_line: this.nested_tag_line,
+      nested_tag_column: this.nested_tag_column,
+    };
+  }
+
+  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 += `@ NestedERBTagError ${this.location.treeInspectWithLabel()}\n`;
+    output += `├── message: "${this.message}"\n`;
+    output += `├── opening_tag: ${this.opening_tag ? this.opening_tag.treeInspect() : "∅"}\n`;
+    output += `├── nested_tag_line: ${JSON.stringify(this.nested_tag_line)}\n`;
+    output += `└── nested_tag_column: ${JSON.stringify(this.nested_tag_column)}\n`;
+
+    return output;
+  }
+}
+
+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) {
@@ -927,14 +2055,31 @@ export function fromSerializedError(error: SerializedHerbError): HerbError {
     case "MISSING_OPENING_TAG_ERROR": return MissingOpeningTagError.from(error as SerializedMissingOpeningTagError);
     case "MISSING_CLOSING_TAG_ERROR": return MissingClosingTagError.from(error as SerializedMissingClosingTagError);
     case "TAG_NAMES_MISMATCH_ERROR": return TagNamesMismatchError.from(error as SerializedTagNamesMismatchError);
-    case "QUOTES_MISMATCH_ERROR": return QuotesMismatchError.from(error as SerializedQuotesMismatchError);
     case "VOID_ELEMENT_CLOSING_TAG_ERROR": return VoidElementClosingTagError.from(error as SerializedVoidElementClosingTagError);
     case "UNCLOSED_ELEMENT_ERROR": return UnclosedElementError.from(error as SerializedUnclosedElementError);
     case "RUBY_PARSE_ERROR": return RubyParseError.from(error as SerializedRubyParseError);
     case "ERB_CONTROL_FLOW_SCOPE_ERROR": return ERBControlFlowScopeError.from(error as SerializedERBControlFlowScopeError);
-    case "MISSINGERB_END_TAG_ERROR": return MissingERBEndTagError.from(error as SerializedMissingERBEndTagError);
+    case "MISSING_ERB_END_TAG_ERROR": return MissingERBEndTagError.from(error as SerializedMissingERBEndTagError);
     case "ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR": return ERBMultipleBlocksInTagError.from(error as SerializedERBMultipleBlocksInTagError);
     case "ERB_CASE_WITH_CONDITIONS_ERROR": return ERBCaseWithConditionsError.from(error as SerializedERBCaseWithConditionsError);
+    case "CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR": return ConditionalElementMultipleTagsError.from(error as SerializedConditionalElementMultipleTagsError);
+    case "CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR": return ConditionalElementConditionMismatchError.from(error as SerializedConditionalElementConditionMismatchError);
+    case "INVALID_COMMENT_CLOSING_TAG_ERROR": return InvalidCommentClosingTagError.from(error as SerializedInvalidCommentClosingTagError);
+    case "OMITTED_CLOSING_TAG_ERROR": return OmittedClosingTagError.from(error as SerializedOmittedClosingTagError);
+    case "UNCLOSED_OPEN_TAG_ERROR": return UnclosedOpenTagError.from(error as SerializedUnclosedOpenTagError);
+    case "UNCLOSED_CLOSE_TAG_ERROR": return UnclosedCloseTagError.from(error as SerializedUnclosedCloseTagError);
+    case "UNCLOSED_QUOTE_ERROR": return UnclosedQuoteError.from(error as SerializedUnclosedQuoteError);
+    case "MISSING_ATTRIBUTE_VALUE_ERROR": return MissingAttributeValueError.from(error as SerializedMissingAttributeValueError);
+    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}`);