herb 0.10.4 → 0.11.0

data/sig/herb/visitor/context.rbs

@@ -0,0 +1,83 @@
+# Generated from lib/herb/visitor/context.rb with RBS::Inline
+
+module Herb
+  class Visitor
+    # Per-template information the engine hands to the visitors it runs before compilation.
+    #
+    # Alongside the template path, it carries the options the engine was built with, and any
+    # additional keys the caller wants to pass through to its own visitors:
+    #
+    #     Herb::Engine.new(source, filename: path, context: { theme: "dark" }, visitors: [MyVisitor.new])
+    #
+    #     class MyVisitor < Herb::Visitor
+    #       include Herb::Visitor::ContextAware
+    #
+    #       def visit_html_element_node(node)
+    #         context.relative_file_path #=> "app/views/users/show.html.erb"
+    #         context.options[:escape]   #=> true
+    #         context[:theme]            #=> "dark"
+    #
+    #         super
+    #       end
+    #     end
+    class Context
+      UNKNOWN_FILE_PATH: String
+
+      attr_reader file_path: Pathname?
+
+      attr_reader options: Hash[Symbol, untyped]
+
+      attr_reader data: Hash[Symbol, untyped]
+
+      # : (?file_path: (String | Pathname)?, ?project_path: (String | Pathname)?, ?options: Hash[Symbol, untyped], ?resolver: untyped, **untyped) -> void
+      def initialize: (?file_path: (String | Pathname)?, ?project_path: (String | Pathname)?, ?options: Hash[Symbol, untyped], ?resolver: untyped, **untyped) -> void
+
+      # : (Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
+      def self.with_records: (Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
+
+      # : () -> Pathname
+      def project_path: () -> Pathname
+
+      # : () -> String
+      def relative_file_path: () -> String
+
+      # : () -> untyped
+      def resolver: () -> untyped
+
+      # : () -> Herb::Visitor::Context::Origin
+      def origin: () -> Herb::Visitor::Context::Origin
+
+      # : () -> Herb::Visitor::Context::Replacements
+      def replacements: () -> Herb::Visitor::Context::Replacements
+
+      # : (Symbol) -> untyped
+      def []: (Symbol) -> untyped
+
+      # : (Symbol) -> bool
+      def key?: (Symbol) -> bool
+
+      # : (Symbol, ?untyped) -> untyped
+      def fetch: (Symbol, ?untyped) -> untyped
+
+      # : (**untyped) -> Herb::Visitor::Context
+      def merge: (**untyped) -> Herb::Visitor::Context
+
+      # : () -> Hash[Symbol, untyped]
+      def to_hash: () -> Hash[Symbol, untyped]
+
+      alias to_h to_hash
+
+      # : () -> String
+      def inspect: () -> String
+
+      # : ((String | Pathname)?) -> Pathname?
+      def self.coerce_file_path: ((String | Pathname)?) -> Pathname?
+
+      # : ((String | Pathname)?) -> Pathname
+      def self.coerce_project_path: ((String | Pathname)?) -> Pathname
+
+      # : (Pathname?, Pathname) -> String
+      def self.derive_relative_file_path: (Pathname?, Pathname) -> String
+    end
+  end
+end

data/sig/herb/visitor/context_aware.rbs

@@ -0,0 +1,32 @@
+# Generated from lib/herb/visitor/context_aware.rb with RBS::Inline
+
+module Herb
+  class Visitor
+    # Opt-in for visitors that want the template information the engine was built with.
+    #
+    # `Herb::Visitor` is generated and holds no state, so a visitor asks for a context by
+    # including this module. The engine then hands it one before it walks the AST:
+    #
+    #     class MyVisitor < Herb::Visitor
+    #       include Herb::Visitor::ContextAware
+    #     end
+    #
+    #     Herb::Engine.new(source, filename: path, visitors: [MyVisitor.new])
+    #
+    # A context passed by the caller always wins over the one the engine supplies, so a
+    # visitor can also be used on its own, without an engine.
+    module ContextAware
+      # : () -> Herb::Visitor::Context
+      def context: () -> Herb::Visitor::Context
+
+      # : (Herb::Visitor::Context) -> void
+      def context=: (Herb::Visitor::Context) -> void
+
+      # : (Herb::Visitor::Context) -> void
+      def inherit_context: (Herb::Visitor::Context) -> void
+
+      # : () -> Herb::Visitor::Context::Origin
+      def origin: () -> Herb::Visitor::Context::Origin
+    end
+  end
+end

data/sig/herb/visitor/diagnostics.rbs

@@ -0,0 +1,82 @@
+# Generated from lib/herb/visitor/diagnostics.rb with RBS::Inline
+
+module Herb
+  class Visitor
+    # Opt-in for visitors that find something worth telling the developer about.
+    #
+    # A visitor records what it finds and keeps walking. The engine collects from every visitor
+    # afterwards and decides what to do with the result. That split is what lets a visitor that
+    # rewrites the tree also report, which a base class reserved for read-only validators could
+    # never do:
+    #
+    #     class MyVisitor < Herb::Visitor
+    #       include Herb::Visitor::ContextAware
+    #       include Herb::Visitor::Diagnostics
+    #
+    #       def visit_html_element_node(node)
+    #         warning("This element is suspicious.", node.location, code: "SuspiciousElement")
+    #
+    #         super
+    #       end
+    #     end
+    module Diagnostics
+      include Kernel
+
+      # : (?fatal: bool, **untyped) -> void
+      def initialize: (?fatal: bool, **untyped) -> void
+
+      # : () -> bool
+      def fatal?: () -> bool
+
+      # : (untyped) -> void
+      def self.included: (untyped) -> void
+
+      # : () -> Array[Herb::Diagnostic]
+      def diagnostics: () -> Array[Herb::Diagnostic]
+
+      # : (String, Herb::Location?, ?code: String?, ?suggestion: String?, ?docs_url: String?, ?template: String?, ?error_class: Class?) -> Herb::Diagnostic
+      def error: (String, Herb::Location?, ?code: String?, ?suggestion: String?, ?docs_url: String?, ?template: String?, ?error_class: Class?) -> Herb::Diagnostic
+
+      # : (String, Herb::Location?, ?code: String?, ?suggestion: String?, ?docs_url: String?, ?template: String?) -> Herb::Diagnostic
+      def warning: (String, Herb::Location?, ?code: String?, ?suggestion: String?, ?docs_url: String?, ?template: String?) -> Herb::Diagnostic
+
+      # : (String, Herb::Location?, ?code: String?, ?suggestion: String?, ?docs_url: String?, ?template: String?) -> Herb::Diagnostic
+      def info: (String, Herb::Location?, ?code: String?, ?suggestion: String?, ?docs_url: String?, ?template: String?) -> Herb::Diagnostic
+
+      # : (String, Herb::Location?, ?code: String?, ?suggestion: String?, ?docs_url: String?, ?template: String?) -> Herb::Diagnostic
+      def hint: (String, Herb::Location?, ?code: String?, ?suggestion: String?, ?docs_url: String?, ?template: String?) -> Herb::Diagnostic
+
+      # : () -> Array[Herb::Diagnostic]
+      def errors: () -> Array[Herb::Diagnostic]
+
+      # : () -> Array[Herb::Diagnostic]
+      def warnings: () -> Array[Herb::Diagnostic]
+
+      # : () -> bool
+      def errors?: () -> bool
+
+      # : () -> bool
+      def warnings?: () -> bool
+
+      # : () -> void
+      def clear_diagnostics: () -> void
+
+      # : (?Symbol?) -> Integer
+      def diagnostic_count: (?Symbol?) -> Integer
+
+      private
+
+      # : (String, Herb::Location?, Symbol, ?code: String?, ?suggestion: String?, ?docs_url: String?, ?template: String?, ?error_class: Class?) -> Herb::Diagnostic
+      def add_diagnostic: (String, Herb::Location?, Symbol, ?code: String?, ?suggestion: String?, ?docs_url: String?, ?template: String?, ?error_class: Class?) -> Herb::Diagnostic
+
+      # : () -> String
+      def diagnostic_origin: () -> String
+
+      # : () -> Hash[Symbol, untyped]
+      def diagnostic_data: () -> Hash[Symbol, untyped]
+
+      # : () -> String
+      def diagnostic_template: () -> String
+    end
+  end
+end

data/sig/herb/visitor/experimental.rbs

@@ -0,0 +1,23 @@
+# Generated from lib/herb/visitor/experimental.rb with RBS::Inline
+
+module Herb
+  class Visitor
+    # Says once, for the life of a process, that a visitor is not settled yet.
+    #
+    #     class ComponentVisitor < Visitor
+    #       extend Experimental
+    #
+    #       experimental "The Component-Transform Visitor is experimental. Its output and API may change."
+    #     end
+    #
+    # The notice goes out when the first one is built, so a host that never reaches for the visitor
+    # never hears about it.
+    module Experimental
+      # : (String) -> void
+      def experimental: (String) -> void
+
+      # : (*untyped, **untyped) ?{ (?) -> untyped } -> untyped
+      def new: (*untyped, **untyped) ?{ (?) -> untyped } -> untyped
+    end
+  end
+end

data/sig/herb/visitor/parser_option_requirements.rbs

@@ -0,0 +1,76 @@
+# Generated from lib/herb/visitor/parser_option_requirements.rb with RBS::Inline
+
+module Herb
+  class Visitor
+    # Lets a visitor declare the parser options the AST it is handed has to carry, so that
+    # whoever parses can satisfy them before visiting.
+    #
+    #     class PrismProgramVisitor < Herb::Visitor
+    #       required_parser_option prism_program: true
+    #       recommended_parser_option strict: false
+    #     end
+    #
+    # A required option is one the visitor cannot work without, and a recommended one is a soft
+    # requirement it only works better with. `Herb::Visitor.parser_options_for` resolves both for
+    # a set of visitors, raising on a conflicting requirement and warning on a conflicting
+    # recommendation.
+    #
+    # `Herb::Visitor` includes this, so every visitor has it. Anything else that is passed to
+    # `Herb::Engine` as a visitor can include it too.
+    module ParserOptionRequirements
+      # : (untyped) -> void
+      def self.included: (untyped) -> void
+
+      module ClassMethods
+        # : (**untyped) -> void
+        def required_parser_option: (**untyped) -> void
+
+        # : (**untyped) -> void
+        def recommended_parser_option: (**untyped) -> void
+
+        # : () -> Hash[Symbol, untyped]
+        def required_parser_options: () -> Hash[Symbol, untyped]
+
+        # : () -> Hash[Symbol, untyped]
+        def recommended_parser_options: () -> Hash[Symbol, untyped]
+
+        # : (untyped) -> void
+        def inherited: (untyped) -> void
+
+        # : (Array[untyped], ?Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
+        def parser_options_for: (Array[untyped], ?Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
+
+        private
+
+        # : (Array[untyped], Hash[Symbol, untyped]) -> void
+        def apply_required_parser_options: (Array[untyped], Hash[Symbol, untyped]) -> void
+
+        # : (Array[untyped], Hash[Symbol, untyped]) -> void
+        def apply_recommended_parser_options: (Array[untyped], Hash[Symbol, untyped]) -> void
+
+        # : (Symbol) -> Hash[Symbol, untyped]
+        def declared_parser_options: (Symbol) -> Hash[Symbol, untyped]
+
+        # : (Array[untyped], Symbol) { (untyped, Symbol, untyped) -> void } -> void
+        def each_declared_parser_option: (Array[untyped], Symbol) { (untyped, Symbol, untyped) -> void } -> void
+
+        # : (untyped) -> String
+        def describe: (untyped) -> String
+      end
+
+      # : () -> Hash[Symbol, untyped]
+      def required_parser_options: () -> Hash[Symbol, untyped]
+
+      # : () -> Hash[Symbol, untyped]
+      def recommended_parser_options: () -> Hash[Symbol, untyped]
+
+      # : (untyped) -> untyped
+      def self.class_of: (untyped) -> untyped
+
+      private
+
+      # : () -> untyped
+      def declaring_class: () -> untyped
+    end
+  end
+end

data/sig/herb/visitor/stack.rbs

@@ -0,0 +1,91 @@
+# Generated from lib/herb/visitor/stack.rb with RBS::Inline
+
+module Herb
+  class Visitor
+    # The ordered list of passes the engine runs over a template before it compiles.
+    #
+    # Order is part of the contract rather than an implementation detail. A pass that injects nodes
+    # has to run after one that assigns positions to the nodes already there, and a pass that
+    # annotates the final tree has to run last. An array expresses that only by luck, so this adds
+    # the vocabulary to say it:
+    #
+    #     stack.insert_after(Herb::Engine::Slots::Visitor, MyVisitor.new)
+    #
+    # @rbs inherits Array[untyped]
+    class Stack < Array[untyped]
+      class UnknownVisitorError < ArgumentError
+      end
+
+      class OrderError < ArgumentError
+      end
+
+      DESCRIPTION_LIMIT: Integer
+
+      # : (untyped) -> Stack
+      def self.build: (untyped) -> Stack
+
+      # : (untyped) -> Stack
+      def self.arrange: (untyped) -> Stack
+
+      # : () -> Stack
+      def arrange: () -> Stack
+
+      # : () -> Array[String]
+      def descriptions: () -> Array[String]
+
+      # : () -> void
+      def validate_order!: () -> void
+
+      private
+
+      # : (untyped, Integer) -> void
+      def validate_inlining!: (untyped, Integer) -> void
+
+      # : (untyped, Integer) -> void
+      def validate_style_blocks!: (untyped, Integer) -> void
+
+      # : (untyped, Integer) -> void
+      def validate_reading!: (untyped, Integer) -> void
+
+      # : (untyped, Symbol) -> bool
+      def answers?: (untyped, Symbol) -> bool
+
+      # : (untyped, untyped) -> bool
+      def precedes?: (untyped, untyped) -> bool
+
+      # : (Array[untyped]) -> String
+      def unsatisfiable_message: (Array[untyped]) -> String
+
+      # : (untyped, Array[untyped]) -> bool
+      def blocked?: (untyped, Array[untyped]) -> bool
+
+      # : (untyped, Array[untyped]) -> bool
+      def blocking?: (untyped, Array[untyped]) -> bool
+
+      public
+
+      # : (untyped) -> Stack
+      def use: (untyped) -> Stack
+
+      # Takes an index, the way `Array#insert` does, or a visitor class to place against.
+      # : ((Integer | Module), *untyped) -> Stack
+      def insert: (Integer | Module, *untyped) -> Stack
+
+      alias insert_before insert
+
+      # : ((Integer | Module), *untyped) -> Stack
+      def insert_after: (Integer | Module, *untyped) -> Stack
+
+      # : (Module) -> bool
+      def include_visitor?: (Module) -> bool
+
+      private
+
+      # : ((Integer | Module)) -> Integer
+      def position_of: (Integer | Module) -> Integer
+
+      # : (Module) -> Integer
+      def index_of: (Module) -> Integer
+    end
+  end
+end

data/sig/herb/visitor.rbs

@@ -4,6 +4,10 @@ module Herb
   class Visitor
     include AST::Helpers
 
+    include ParserOptionRequirements
+
+    extend Herb::Visitor::ParserOptionRequirements::ClassMethods
+
     # : (Herb::AST::Node?) -> void
     def visit: (Herb::AST::Node?) -> void
 
@@ -76,6 +80,9 @@ module Herb
     # : (Herb::AST::XMLDeclarationNode) -> void
     def visit_xml_declaration_node: (Herb::AST::XMLDeclarationNode) -> void
 
+    # : (Herb::AST::XMLProcessingInstructionNode) -> void
+    def visit_xml_processing_instruction_node: (Herb::AST::XMLProcessingInstructionNode) -> void
+
     # : (Herb::AST::CDATANode) -> void
     def visit_cdata_node: (Herb::AST::CDATANode) -> void
 
@@ -97,6 +104,9 @@ module Herb
     # : (Herb::AST::ERBBlockNode) -> void
     def visit_erb_block_node: (Herb::AST::ERBBlockNode) -> void
 
+    # : (Herb::AST::ERBIterationBlockNode) -> void
+    def visit_erb_iteration_block_node: (Herb::AST::ERBIterationBlockNode) -> void
+
     # : (Herb::AST::ERBWhenNode) -> void
     def visit_erb_when_node: (Herb::AST::ERBWhenNode) -> void
 
@@ -147,5 +157,17 @@ module Herb
 
     # : (Herb::AST::ERBInNode) -> void
     def visit_erb_in_node: (Herb::AST::ERBInNode) -> void
+
+    # : (Herb::AST::HerbDirectiveNode) -> void
+    def visit_herb_directive_node: (Herb::AST::HerbDirectiveNode) -> void
+
+    # : (Herb::AST::HerbStateDeclarationNode) -> void
+    def visit_herb_state_declaration_node: (Herb::AST::HerbStateDeclarationNode) -> void
+
+    # : (Herb::AST::HerbStateDirectiveNode) -> void
+    def visit_herb_state_directive_node: (Herb::AST::HerbStateDirectiveNode) -> void
+
+    # : (Herb::AST::ERBCommentNode) -> void
+    def visit_erb_comment_node: (Herb::AST::ERBCommentNode) -> void
   end
 end

data/sig/herb/warnings.rbs

@@ -29,5 +29,15 @@ module Herb
       # : (?untyped) -> String
       def to_json: (?untyped) -> String
     end
+
+    # TODO: move to `config.yml` so they are in line with the way errors are defined and generated.
+    class UnkeyedCollectionWarning < Warning
+      attr_reader expression: String?
+
+      attr_reader tag_name: String?
+
+      # : (Location, ?String?, ?tag_name: String?) -> void
+      def initialize: (Location, ?String?, ?tag_name: String?) -> void
+    end
   end
 end

data/sig/herb.rbs

@@ -1,28 +1,45 @@
 # Generated from lib/herb.rb with RBS::Inline
 
 module Herb
-  PARTIAL_EXTENSIONS: untyped
+  # : (String input, ?track_whitespace: bool, ?track_locations: bool, ?analyze: bool, ?strict: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?dot_notation_tags: bool, ?render_nodes: bool, ?strict_locals: bool, ?herb_directives: bool, ?iteration_nodes: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?html: bool, ?erb_openers: Array[String], ?arena_stats: bool) -> ParseResult
+  def self.parse: (String input, ?track_whitespace: bool, ?track_locations: bool, ?analyze: bool, ?strict: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?dot_notation_tags: bool, ?render_nodes: bool, ?strict_locals: bool, ?herb_directives: bool, ?iteration_nodes: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?html: bool, ?erb_openers: Array[String], ?arena_stats: bool) -> ParseResult
 
-  PARTIAL_GLOB_PATTERN: ::String
-end
+  # : (String input, ?erb_openers: Array[String], ?arena_stats: bool) -> LexResult
+  def self.lex: (String input, ?erb_openers: Array[String], ?arena_stats: bool) -> LexResult
+
+  # : (String source, ?semicolons: bool, ?comments: bool, ?preserve_positions: bool, ?custom_tags: bool, ?erb_openers: Array[String]) -> String
+  def self.extract_ruby: (String source, ?semicolons: bool, ?comments: bool, ?preserve_positions: bool, ?custom_tags: bool, ?erb_openers: Array[String]) -> String
+
+  # : (String source) -> String
+  def self.extract_html: (String source) -> String
+
+  # : (String old_source, String new_source, ?track_whitespace_changes: bool) -> Herb::Diff::Result
+  def self.diff: (String old_source, String new_source, ?track_whitespace_changes: bool) -> Herb::Diff::Result
+
+  # : (?arena_stats: bool) -> untyped
+  def self.arena_stats: (?arena_stats: bool) -> untyped
+
+  # : (String source) -> untyped
+  def self.leak_check: (String source) -> untyped
+
+  # : () -> String
+  def self.version: () -> String
 
-module Herb
   # : (String path, ?arena_stats: bool) -> LexResult
   def self.lex_file: (String path, ?arena_stats: bool) -> LexResult
 
-  # : (String path, ?track_whitespace: bool, ?analyze: bool, ?strict: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?strict_locals: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?arena_stats: bool) -> ParseResult
-  def self.parse_file: (String path, ?track_whitespace: bool, ?analyze: bool, ?strict: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?strict_locals: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?arena_stats: bool) -> ParseResult
+  # : (String path, ?track_whitespace: bool, ?track_locations: bool, ?analyze: bool, ?strict: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?strict_locals: bool, ?herb_directives: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?arena_stats: bool) -> ParseResult
+  def self.parse_file: (String path, ?track_whitespace: bool, ?track_locations: bool, ?analyze: bool, ?strict: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?strict_locals: bool, ?herb_directives: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?arena_stats: bool) -> ParseResult
 
   # : (String source) -> Prism::ParseResult
   def self.parse_ruby: (String source) -> Prism::ParseResult
 
+  # : () -> Array[String]
+  def self.default_erb_openings: () -> Array[String]
+
   def self.configuration: (?untyped project_path) -> untyped
 
   def self.configure: (?untyped project_path) -> untyped
 
   def self.reset_configuration!: () -> untyped
-
-  def self.dev_server_port: (?untyped project_path) -> untyped
-
-  def self.ensure_installed: () ?{ (?) -> untyped } -> untyped
 end

data/sig/serialized_ast_errors.rbs

@@ -2,7 +2,7 @@
 # typed: true
 
 # NOTE: This file is generated by the templates/template.rb script and should not be
-# modified manually. See /home/runner/work/herb/herb/templates/sig/serialized_ast_errors.rbs.erb
+# modified manually. See templates/sig/serialized_ast_errors.rbs.erb
 
 module Herb
   type serialized_unexpected_error = serialized_error & {
@@ -59,6 +59,9 @@ module Herb
   type serialized_erb_case_with_conditions_error = serialized_error & {
   }
 
+  type serialized_erb_case_inline_pattern_match_error = serialized_error & {
+  }
+
   type serialized_conditional_element_multiple_tags_error = serialized_error & {
     line: Integer,
     column: Integer,
@@ -74,6 +77,15 @@ module Herb
     close_column: Integer,
   }
 
+  type serialized_unclosed_comment_error = serialized_error & {
+    comment_start: Herb::Token,
+  }
+
+  type serialized_nested_comment_error = serialized_error & {
+    comment_start: Herb::Token,
+    nested_start: Herb::Token,
+  }
+
   type serialized_invalid_comment_closing_tag_error = serialized_error & {
     closing_tag: Herb::Token,
   }
@@ -91,6 +103,10 @@ module Herb
     tag_name: Herb::Token,
   }
 
+  type serialized_end_tag_with_trailing_solidus_error = serialized_error & {
+    tag_name: Herb::Token,
+  }
+
   type serialized_unclosed_quote_error = serialized_error & {
     opening_quote: Herb::Token,
   }
@@ -99,10 +115,35 @@ module Herb
     attribute_name: String,
   }
 
+  type serialized_missing_whitespace_between_attributes_error = serialized_error & {
+    found: Herb::Token,
+  }
+
+  type serialized_unexpected_character_in_attribute_name_error = serialized_error & {
+    character: Herb::Token,
+  }
+
+  type serialized_unexpected_character_in_unquoted_attribute_value_error = serialized_error & {
+    character: Herb::Token,
+  }
+
+  type serialized_unexpected_equals_sign_before_attribute_name_error = serialized_error & {
+    equals: Herb::Token,
+  }
+
+  type serialized_unexpected_solidus_in_tag_error = serialized_error & {
+    solidus: Herb::Token,
+  }
+
   type serialized_unclosed_erb_tag_error = serialized_error & {
     opening_tag: Herb::Token,
   }
 
+  type serialized_malformed_erb_closing_tag_error = serialized_error & {
+    opening_tag: Herb::Token,
+    closing_tag: Herb::Token,
+  }
+
   type serialized_stray_erb_closing_tag_error = serialized_error & {
   }
 
@@ -159,6 +200,22 @@ module Herb
   type serialized_strict_locals_duplicate_declaration_error = serialized_error & {
   }
 
+  type serialized_herb_state_missing_parenthesis_error = serialized_error & {
+    rest: String,
+  }
+
+  type serialized_herb_state_non_canonical_directive_error = serialized_error & {
+    found: String,
+    expected: String,
+  }
+
+  type serialized_herb_state_invalid_parameter_error = serialized_error & {
+    parameter: String,
+  }
+
+  type serialized_herb_state_duplicate_declaration_error = serialized_error & {
+  }
+
   type serialized_void_element_content_error = serialized_error & {
     tag_name: Herb::Token,
     helper_name: String,