herb 0.8.10-arm-linux-gnu → 0.9.1-arm-linux-gnu

data/lib/herb/errors.rb

@@ -5,13 +5,18 @@
 # modified manually. See /home/runner/work/herb/herb/templates/lib/herb/errors.rb.erb
 
 module Herb
+  #: type serialized_error = {
+  #|  type: String,
+  #|  location: serialized_location?,
+  #|  message: String
+  #| }
   module Errors
     class Error
       attr_reader :type #: String
-      attr_reader :location #: Location
+      attr_reader :location #: Location?
       attr_reader :message #: String
 
-      #: (String, Location, String) -> void
+      #: (String, Location?, String) -> void
       def initialize(type, location, message)
         @type = type
         @location = location
@@ -51,11 +56,16 @@ module Herb
     class UnexpectedError < Error
       include Colors
 
-      attr_reader :description #: String
-      attr_reader :expected #: String
-      attr_reader :found #: String
+      #|  description: String?,
+      #|  expected: String?,
+      #|  found: String?,
+      #| }
 
-      #: (String, Location, String, String, String, String) -> void
+      attr_reader :description #: String?
+      attr_reader :expected #: String?
+      attr_reader :found #: String?
+
+      #: (String, Location?, String, String, String, String) -> void
       def initialize(type, location, message, description, expected, found)
         super(type, location, message)
         @description = description
@@ -81,7 +91,7 @@ module Herb
       def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         output = +""
 
-        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location.tree_inspect})\n")}")
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
         output += white("├── message: #{green(message.inspect)}\n")
         output += white("├── description: #{green(description.inspect)}\n")
         output += white("├── expected: #{green(expected.inspect)}\n")
@@ -95,10 +105,14 @@ module Herb
     class UnexpectedTokenError < Error
       include Colors
 
-      attr_reader :expected_type #: String
-      attr_reader :found #: Herb::Token
+      #|  expected_type: String?,
+      #|  found: Herb::Token?,
+      #| }
+
+      attr_reader :expected_type #: String?
+      attr_reader :found #: Herb::Token?
 
-      #: (String, Location, String, String, Herb::Token) -> void
+      #: (String, Location?, String, String, Herb::Token) -> void
       def initialize(type, location, message, expected_type, found)
         super(type, location, message)
         @expected_type = expected_type
@@ -122,7 +136,7 @@ module Herb
       def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         output = +""
 
-        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location.tree_inspect})\n")}")
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
         output += white("├── message: #{green(message.inspect)}\n")
         output += white("├── expected_type: #{green(expected_type.inspect)}\n")
         output += white("└── found: ")
@@ -137,9 +151,12 @@ module Herb
     class MissingOpeningTagError < Error
       include Colors
 
-      attr_reader :closing_tag #: Herb::Token
+      #|  closing_tag: Herb::Token?,
+      #| }
 
-      #: (String, Location, String, Herb::Token) -> void
+      attr_reader :closing_tag #: Herb::Token?
+
+      #: (String, Location?, String, Herb::Token) -> void
       def initialize(type, location, message, closing_tag)
         super(type, location, message)
         @closing_tag = closing_tag
@@ -161,7 +178,7 @@ module Herb
       def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         output = +""
 
-        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location.tree_inspect})\n")}")
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
         output += white("├── message: #{green(message.inspect)}\n")
         output += white("└── closing_tag: ")
         output += closing_tag ? closing_tag.tree_inspect : magenta("∅")
@@ -175,9 +192,12 @@ module Herb
     class MissingClosingTagError < Error
       include Colors
 
-      attr_reader :opening_tag #: Herb::Token
+      #|  opening_tag: Herb::Token?,
+      #| }
+
+      attr_reader :opening_tag #: Herb::Token?
 
-      #: (String, Location, String, Herb::Token) -> void
+      #: (String, Location?, String, Herb::Token) -> void
       def initialize(type, location, message, opening_tag)
         super(type, location, message)
         @opening_tag = opening_tag
@@ -199,7 +219,7 @@ module Herb
       def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         output = +""
 
-        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location.tree_inspect})\n")}")
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
         output += white("├── message: #{green(message.inspect)}\n")
         output += white("└── opening_tag: ")
         output += opening_tag ? opening_tag.tree_inspect : magenta("∅")
@@ -213,10 +233,14 @@ module Herb
     class TagNamesMismatchError < Error
       include Colors
 
-      attr_reader :opening_tag #: Herb::Token
-      attr_reader :closing_tag #: Herb::Token
+      #|  opening_tag: Herb::Token?,
+      #|  closing_tag: Herb::Token?,
+      #| }
 
-      #: (String, Location, String, Herb::Token, Herb::Token) -> void
+      attr_reader :opening_tag #: Herb::Token?
+      attr_reader :closing_tag #: Herb::Token?
+
+      #: (String, Location?, String, Herb::Token, Herb::Token) -> void
       def initialize(type, location, message, opening_tag, closing_tag)
         super(type, location, message)
         @opening_tag = opening_tag
@@ -240,7 +264,7 @@ module Herb
       def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         output = +""
 
-        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location.tree_inspect})\n")}")
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
         output += white("├── message: #{green(message.inspect)}\n")
         output += white("├── opening_tag: ")
         output += opening_tag ? opening_tag.tree_inspect : magenta("∅")
@@ -254,58 +278,19 @@ module Herb
       end
     end
 
-    class QuotesMismatchError < Error
-      include Colors
-
-      attr_reader :opening_quote #: Herb::Token
-      attr_reader :closing_quote #: Herb::Token
-
-      #: (String, Location, String, Herb::Token, Herb::Token) -> void
-      def initialize(type, location, message, opening_quote, closing_quote)
-        super(type, location, message)
-        @opening_quote = opening_quote
-        @closing_quote = closing_quote
-      end
-
-      #: () -> String
-      def inspect
-        tree_inspect.rstrip.gsub(/\s+$/, "")
-      end
-
-      #: () -> serialized_quotes_mismatch_error
-      def to_hash
-        super.merge(
-          opening_quote: opening_quote,
-          closing_quote: closing_quote
-        ) #: Herb::serialized_quotes_mismatch_error
-      end
-
-      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
-      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
-        output = +""
-
-        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location.tree_inspect})\n")}")
-        output += white("├── message: #{green(message.inspect)}\n")
-        output += white("├── opening_quote: ")
-        output += opening_quote ? opening_quote.tree_inspect : magenta("∅")
-        output += "\n"
-        output += white("└── closing_quote: ")
-        output += closing_quote ? closing_quote.tree_inspect : magenta("∅")
-        output += "\n"
-        output += %(\n)
-
-        output.gsub(/^/, "    " * indent)
-      end
-    end
-
     class VoidElementClosingTagError < Error
       include Colors
 
-      attr_reader :tag_name #: Herb::Token
-      attr_reader :expected #: String
-      attr_reader :found #: String
+      #|  tag_name: Herb::Token?,
+      #|  expected: String?,
+      #|  found: String?,
+      #| }
+
+      attr_reader :tag_name #: Herb::Token?
+      attr_reader :expected #: String?
+      attr_reader :found #: String?
 
-      #: (String, Location, String, Herb::Token, String, String) -> void
+      #: (String, Location?, String, Herb::Token, String, String) -> void
       def initialize(type, location, message, tag_name, expected, found)
         super(type, location, message)
         @tag_name = tag_name
@@ -331,7 +316,7 @@ module Herb
       def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         output = +""
 
-        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location.tree_inspect})\n")}")
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
         output += white("├── message: #{green(message.inspect)}\n")
         output += white("├── tag_name: ")
         output += tag_name ? tag_name.tree_inspect : magenta("∅")
@@ -347,9 +332,12 @@ module Herb
     class UnclosedElementError < Error
       include Colors
 
-      attr_reader :opening_tag #: Herb::Token
+      #|  opening_tag: Herb::Token?,
+      #| }
 
-      #: (String, Location, String, Herb::Token) -> void
+      attr_reader :opening_tag #: Herb::Token?
+
+      #: (String, Location?, String, Herb::Token) -> void
       def initialize(type, location, message, opening_tag)
         super(type, location, message)
         @opening_tag = opening_tag
@@ -371,7 +359,7 @@ module Herb
       def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         output = +""
 
-        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location.tree_inspect})\n")}")
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
         output += white("├── message: #{green(message.inspect)}\n")
         output += white("└── opening_tag: ")
         output += opening_tag ? opening_tag.tree_inspect : magenta("∅")
@@ -385,11 +373,16 @@ module Herb
     class RubyParseError < Error
       include Colors
 
-      attr_reader :error_message #: String
-      attr_reader :diagnostic_id #: String
-      attr_reader :level #: String
+      #|  error_message: String?,
+      #|  diagnostic_id: String?,
+      #|  level: String?,
+      #| }
+
+      attr_reader :error_message #: String?
+      attr_reader :diagnostic_id #: String?
+      attr_reader :level #: String?
 
-      #: (String, Location, String, String, String, String) -> void
+      #: (String, Location?, String, String, String, String) -> void
       def initialize(type, location, message, error_message, diagnostic_id, level)
         super(type, location, message)
         @error_message = error_message
@@ -415,7 +408,7 @@ module Herb
       def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         output = +""
 
-        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location.tree_inspect})\n")}")
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
         output += white("├── message: #{green(message.inspect)}\n")
         output += white("├── error_message: #{green(error_message.inspect)}\n")
         output += white("├── diagnostic_id: #{green(diagnostic_id.inspect)}\n")
@@ -429,9 +422,12 @@ module Herb
     class ERBControlFlowScopeError < Error
       include Colors
 
-      attr_reader :keyword #: String
+      #|  keyword: String?,
+      #| }
 
-      #: (String, Location, String, String) -> void
+      attr_reader :keyword #: String?
+
+      #: (String, Location?, String, String) -> void
       def initialize(type, location, message, keyword)
         super(type, location, message)
         @keyword = keyword
@@ -453,7 +449,7 @@ module Herb
       def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         output = +""
 
-        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location.tree_inspect})\n")}")
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
         output += white("├── message: #{green(message.inspect)}\n")
         output += white("└── keyword: #{green(keyword.inspect)}\n")
         output += %(\n)
@@ -465,9 +461,12 @@ module Herb
     class MissingERBEndTagError < Error
       include Colors
 
-      attr_reader :keyword #: String
+      #|  keyword: String?,
+      #| }
+
+      attr_reader :keyword #: String?
 
-      #: (String, Location, String, String) -> void
+      #: (String, Location?, String, String) -> void
       def initialize(type, location, message, keyword)
         super(type, location, message)
         @keyword = keyword
@@ -478,18 +477,18 @@ module Herb
         tree_inspect.rstrip.gsub(/\s+$/, "")
       end
 
-      #: () -> serialized_missingerb_end_tag_error
+      #: () -> serialized_missing_erb_end_tag_error
       def to_hash
         super.merge(
           keyword: keyword
-        ) #: Herb::serialized_missingerb_end_tag_error
+        ) #: Herb::serialized_missing_erb_end_tag_error
       end
 
       #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
       def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         output = +""
 
-        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location.tree_inspect})\n")}")
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
         output += white("├── message: #{green(message.inspect)}\n")
         output += white("└── keyword: #{green(keyword.inspect)}\n")
         output += %(\n)
@@ -510,7 +509,7 @@ module Herb
       def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         output = +""
 
-        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location.tree_inspect})\n")}")
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
         output += white("└── message: #{green(message.inspect)}\n")
         output += %(\n)
 
@@ -530,7 +529,7 @@ module Herb
       def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         output = +""
 
-        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location.tree_inspect})\n")}")
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
         output += white("└── message: #{green(message.inspect)}\n")
         output += %(\n)
 
@@ -538,5 +537,726 @@ module Herb
       end
     end
 
+    class ConditionalElementMultipleTagsError < Error
+      include Colors
+
+      #|  line: Integer?,
+      #|  column: Integer?,
+      #| }
+
+      attr_reader :line #: Integer?
+      attr_reader :column #: Integer?
+
+      #: (String, Location?, String, Integer, Integer) -> void
+      def initialize(type, location, message, line, column)
+        super(type, location, message)
+        @line = line
+        @column = column
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_conditional_element_multiple_tags_error
+      def to_hash
+        super.merge(
+          line: line,
+          column: column
+        ) #: Herb::serialized_conditional_element_multiple_tags_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("├── line: #{green(line.inspect)}\n")
+        output += white("└── column: #{green(column.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class ConditionalElementConditionMismatchError < Error
+      include Colors
+
+      #|  tag_name: String?,
+      #|  open_condition: String?,
+      #|  open_line: Integer?,
+      #|  open_column: Integer?,
+      #|  close_condition: String?,
+      #|  close_line: Integer?,
+      #|  close_column: Integer?,
+      #| }
+
+      attr_reader :tag_name #: String?
+      attr_reader :open_condition #: String?
+      attr_reader :open_line #: Integer?
+      attr_reader :open_column #: Integer?
+      attr_reader :close_condition #: String?
+      attr_reader :close_line #: Integer?
+      attr_reader :close_column #: Integer?
+
+      #: (String, Location?, String, String, String, Integer, Integer, String, Integer, Integer) -> void
+      def initialize(type, location, message, tag_name, open_condition, open_line, open_column, close_condition, close_line, close_column)
+        super(type, location, message)
+        @tag_name = tag_name
+        @open_condition = open_condition
+        @open_line = open_line
+        @open_column = open_column
+        @close_condition = close_condition
+        @close_line = close_line
+        @close_column = close_column
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_conditional_element_condition_mismatch_error
+      def to_hash
+        super.merge(
+          tag_name: tag_name,
+          open_condition: open_condition,
+          open_line: open_line,
+          open_column: open_column,
+          close_condition: close_condition,
+          close_line: close_line,
+          close_column: close_column
+        ) #: Herb::serialized_conditional_element_condition_mismatch_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("├── tag_name: #{green(tag_name.inspect)}\n")
+        output += white("├── open_condition: #{green(open_condition.inspect)}\n")
+        output += white("├── open_line: #{green(open_line.inspect)}\n")
+        output += white("├── open_column: #{green(open_column.inspect)}\n")
+        output += white("├── close_condition: #{green(close_condition.inspect)}\n")
+        output += white("├── close_line: #{green(close_line.inspect)}\n")
+        output += white("└── close_column: #{green(close_column.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class InvalidCommentClosingTagError < Error
+      include Colors
+
+      #|  closing_tag: Herb::Token?,
+      #| }
+
+      attr_reader :closing_tag #: Herb::Token?
+
+      #: (String, Location?, String, Herb::Token) -> void
+      def initialize(type, location, message, closing_tag)
+        super(type, location, message)
+        @closing_tag = closing_tag
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_invalid_comment_closing_tag_error
+      def to_hash
+        super.merge(
+          closing_tag: closing_tag
+        ) #: Herb::serialized_invalid_comment_closing_tag_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("└── closing_tag: ")
+        output += closing_tag ? closing_tag.tree_inspect : magenta("∅")
+        output += "\n"
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class OmittedClosingTagError < Error
+      include Colors
+
+      #|  opening_tag: Herb::Token?,
+      #|  insertion_point: Herb::Position?,
+      #| }
+
+      attr_reader :opening_tag #: Herb::Token?
+      attr_reader :insertion_point #: Herb::Position?
+
+      #: (String, Location?, String, Herb::Token, Herb::Position) -> void
+      def initialize(type, location, message, opening_tag, insertion_point)
+        super(type, location, message)
+        @opening_tag = opening_tag
+        @insertion_point = insertion_point
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_omitted_closing_tag_error
+      def to_hash
+        super.merge(
+          opening_tag: opening_tag,
+          insertion_point: insertion_point
+        ) #: Herb::serialized_omitted_closing_tag_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("├── opening_tag: ")
+        output += opening_tag ? opening_tag.tree_inspect : magenta("∅")
+        output += "\n"
+        output += white("└── insertion_point: ")
+        output += insertion_point ? insertion_point.tree_inspect : magenta("∅")
+        output += "\n"
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class UnclosedOpenTagError < Error
+      include Colors
+
+      #|  tag_name: Herb::Token?,
+      #| }
+
+      attr_reader :tag_name #: Herb::Token?
+
+      #: (String, Location?, String, Herb::Token) -> void
+      def initialize(type, location, message, tag_name)
+        super(type, location, message)
+        @tag_name = tag_name
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_unclosed_open_tag_error
+      def to_hash
+        super.merge(
+          tag_name: tag_name
+        ) #: Herb::serialized_unclosed_open_tag_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("└── tag_name: ")
+        output += tag_name ? tag_name.tree_inspect : magenta("∅")
+        output += "\n"
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class UnclosedCloseTagError < Error
+      include Colors
+
+      #|  tag_name: Herb::Token?,
+      #| }
+
+      attr_reader :tag_name #: Herb::Token?
+
+      #: (String, Location?, String, Herb::Token) -> void
+      def initialize(type, location, message, tag_name)
+        super(type, location, message)
+        @tag_name = tag_name
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_unclosed_close_tag_error
+      def to_hash
+        super.merge(
+          tag_name: tag_name
+        ) #: Herb::serialized_unclosed_close_tag_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("└── tag_name: ")
+        output += tag_name ? tag_name.tree_inspect : magenta("∅")
+        output += "\n"
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class UnclosedQuoteError < Error
+      include Colors
+
+      #|  opening_quote: Herb::Token?,
+      #| }
+
+      attr_reader :opening_quote #: Herb::Token?
+
+      #: (String, Location?, String, Herb::Token) -> void
+      def initialize(type, location, message, opening_quote)
+        super(type, location, message)
+        @opening_quote = opening_quote
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_unclosed_quote_error
+      def to_hash
+        super.merge(
+          opening_quote: opening_quote
+        ) #: Herb::serialized_unclosed_quote_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("└── opening_quote: ")
+        output += opening_quote ? opening_quote.tree_inspect : magenta("∅")
+        output += "\n"
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class MissingAttributeValueError < Error
+      include Colors
+
+      #|  attribute_name: String?,
+      #| }
+
+      attr_reader :attribute_name #: String?
+
+      #: (String, Location?, String, String) -> void
+      def initialize(type, location, message, attribute_name)
+        super(type, location, message)
+        @attribute_name = attribute_name
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_missing_attribute_value_error
+      def to_hash
+        super.merge(
+          attribute_name: attribute_name
+        ) #: Herb::serialized_missing_attribute_value_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("└── attribute_name: #{green(attribute_name.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class UnclosedERBTagError < Error
+      include Colors
+
+      #|  opening_tag: Herb::Token?,
+      #| }
+
+      attr_reader :opening_tag #: Herb::Token?
+
+      #: (String, Location?, String, Herb::Token) -> void
+      def initialize(type, location, message, opening_tag)
+        super(type, location, message)
+        @opening_tag = opening_tag
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_unclosed_erb_tag_error
+      def to_hash
+        super.merge(
+          opening_tag: opening_tag
+        ) #: Herb::serialized_unclosed_erb_tag_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("└── opening_tag: ")
+        output += opening_tag ? opening_tag.tree_inspect : magenta("∅")
+        output += "\n"
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class StrayERBClosingTagError < Error
+      include Colors
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("└── message: #{green(message.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class NestedERBTagError < Error
+      include Colors
+
+      #|  opening_tag: Herb::Token?,
+      #|  nested_tag_line: Integer?,
+      #|  nested_tag_column: Integer?,
+      #| }
+
+      attr_reader :opening_tag #: Herb::Token?
+      attr_reader :nested_tag_line #: Integer?
+      attr_reader :nested_tag_column #: Integer?
+
+      #: (String, Location?, String, Herb::Token, Integer, Integer) -> void
+      def initialize(type, location, message, opening_tag, nested_tag_line, nested_tag_column)
+        super(type, location, message)
+        @opening_tag = opening_tag
+        @nested_tag_line = nested_tag_line
+        @nested_tag_column = nested_tag_column
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_nested_erb_tag_error
+      def to_hash
+        super.merge(
+          opening_tag: opening_tag,
+          nested_tag_line: nested_tag_line,
+          nested_tag_column: nested_tag_column
+        ) #: Herb::serialized_nested_erb_tag_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("├── opening_tag: ")
+        output += opening_tag ? opening_tag.tree_inspect : magenta("∅")
+        output += "\n"
+        output += white("├── nested_tag_line: #{green(nested_tag_line.inspect)}\n")
+        output += white("└── nested_tag_column: #{green(nested_tag_column.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class RenderAmbiguousLocalsError < Error
+      include Colors
+
+      #|  partial: String?,
+      #| }
+
+      attr_reader :partial #: String?
+
+      #: (String, Location?, String, String) -> void
+      def initialize(type, location, message, partial)
+        super(type, location, message)
+        @partial = partial
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_render_ambiguous_locals_error
+      def to_hash
+        super.merge(
+          partial: partial
+        ) #: Herb::serialized_render_ambiguous_locals_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("└── partial: #{green(partial.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class RenderMissingLocalsError < Error
+      include Colors
+
+      #|  partial: String?,
+      #|  keywords: String?,
+      #| }
+
+      attr_reader :partial #: String?
+      attr_reader :keywords #: String?
+
+      #: (String, Location?, String, String, String) -> void
+      def initialize(type, location, message, partial, keywords)
+        super(type, location, message)
+        @partial = partial
+        @keywords = keywords
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_render_missing_locals_error
+      def to_hash
+        super.merge(
+          partial: partial,
+          keywords: keywords
+        ) #: Herb::serialized_render_missing_locals_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("├── partial: #{green(partial.inspect)}\n")
+        output += white("└── keywords: #{green(keywords.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class RenderNoArgumentsError < Error
+      include Colors
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("└── message: #{green(message.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class RenderConflictingPartialError < Error
+      include Colors
+
+      #|  positional_partial: String?,
+      #|  keyword_partial: String?,
+      #| }
+
+      attr_reader :positional_partial #: String?
+      attr_reader :keyword_partial #: String?
+
+      #: (String, Location?, String, String, String) -> void
+      def initialize(type, location, message, positional_partial, keyword_partial)
+        super(type, location, message)
+        @positional_partial = positional_partial
+        @keyword_partial = keyword_partial
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_render_conflicting_partial_error
+      def to_hash
+        super.merge(
+          positional_partial: positional_partial,
+          keyword_partial: keyword_partial
+        ) #: Herb::serialized_render_conflicting_partial_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("├── positional_partial: #{green(positional_partial.inspect)}\n")
+        output += white("└── keyword_partial: #{green(keyword_partial.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class RenderInvalidAsOptionError < Error
+      include Colors
+
+      #|  as_value: String?,
+      #| }
+
+      attr_reader :as_value #: String?
+
+      #: (String, Location?, String, String) -> void
+      def initialize(type, location, message, as_value)
+        super(type, location, message)
+        @as_value = as_value
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_render_invalid_as_option_error
+      def to_hash
+        super.merge(
+          as_value: as_value
+        ) #: Herb::serialized_render_invalid_as_option_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("└── as_value: #{green(as_value.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class RenderObjectAndCollectionError < Error
+      include Colors
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("└── message: #{green(message.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class RenderLayoutWithoutBlockError < Error
+      include Colors
+
+      #|  layout: String?,
+      #| }
+
+      attr_reader :layout #: String?
+
+      #: (String, Location?, String, String) -> void
+      def initialize(type, location, message, layout)
+        super(type, location, message)
+        @layout = layout
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_render_layout_without_block_error
+      def to_hash
+        super.merge(
+          layout: layout
+        ) #: Herb::serialized_render_layout_without_block_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("└── layout: #{green(layout.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
   end
 end