herb 0.10.1 → 0.11.1

data/sig/herb/parser_options.rbs

@@ -2,51 +2,85 @@
 
 module Herb
   class ParserOptions
-    attr_reader strict: bool
-
-    attr_reader track_whitespace: bool
+    attr_reader action_view_helpers: bool
 
     attr_reader analyze: bool
 
-    attr_reader action_view_helpers: bool
+    attr_reader arena_stats: bool
 
-    attr_reader transform_conditionals: bool
+    attr_reader dot_notation_tags: bool
 
-    attr_reader render_nodes: bool
+    attr_reader erb_openers: Array[String]
 
-    attr_reader strict_locals: bool
+    attr_reader herb_directives: bool
 
-    attr_reader prism_program: bool
+    attr_reader html: bool
+
+    attr_reader iteration_nodes: bool
+
+    attr_reader max_errors: Integer?
 
     attr_reader prism_nodes: bool
 
     attr_reader prism_nodes_deep: bool
 
-    DEFAULT_STRICT: bool
+    attr_reader prism_program: bool
 
-    DEFAULT_TRACK_WHITESPACE: bool
+    attr_reader render_nodes: bool
 
-    DEFAULT_ANALYZE: bool
+    attr_reader strict: bool
+
+    attr_reader strict_locals: bool
+
+    attr_reader timeout: Numeric
+
+    attr_reader track_locations: bool
+
+    attr_reader track_whitespace: bool
+
+    attr_reader transform_conditionals: bool
 
     DEFAULT_ACTION_VIEW_HELPERS: bool
 
-    DEFAULT_TRANSFORM_CONDITIONALS: bool
+    DEFAULT_ANALYZE: bool
 
-    DEFAULT_RENDER_NODES: bool
+    DEFAULT_CAPTURE_ARENA_STATS: bool
 
-    DEFAULT_STRICT_LOCALS: bool
+    DEFAULT_DOT_NOTATION_TAGS: bool
 
-    DEFAULT_PRISM_PROGRAM: bool
+    DEFAULT_HERB_DIRECTIVES: bool
+
+    DEFAULT_HTML: bool
+
+    DEFAULT_ITERATION_NODES: bool
+
+    DEFAULT_MAX_ERRORS: Integer
 
     DEFAULT_PRISM_NODES: bool
 
     DEFAULT_PRISM_NODES_DEEP: bool
 
-    # : (?strict: bool, ?track_whitespace: bool, ?analyze: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?render_nodes: bool, ?strict_locals: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool) -> void
-    def initialize: (?strict: bool, ?track_whitespace: bool, ?analyze: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?render_nodes: bool, ?strict_locals: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool) -> void
+    DEFAULT_PRISM_PROGRAM: bool
+
+    DEFAULT_RENDER_NODES: bool
+
+    DEFAULT_STRICT: bool
+
+    DEFAULT_STRICT_LOCALS: bool
+
+    DEFAULT_TIMEOUT: Numeric
+
+    DEFAULT_TRACK_LOCATIONS: bool
+
+    DEFAULT_TRACK_WHITESPACE: bool
+
+    DEFAULT_TRANSFORM_CONDITIONALS: bool
+
+    # : (?action_view_helpers: bool, ?analyze: bool, ?arena_stats: bool, ?dot_notation_tags: bool, ?erb_openers: Array[String], ?herb_directives: bool, ?html: bool, ?iteration_nodes: bool, ?max_errors: Integer?, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?render_nodes: bool, ?strict: bool, ?strict_locals: bool, ?timeout: Numeric, ?track_locations: bool, ?track_whitespace: bool, ?transform_conditionals: bool) -> void
+    def initialize: (?action_view_helpers: bool, ?analyze: bool, ?arena_stats: bool, ?dot_notation_tags: bool, ?erb_openers: Array[String], ?herb_directives: bool, ?html: bool, ?iteration_nodes: bool, ?max_errors: Integer?, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?render_nodes: bool, ?strict: bool, ?strict_locals: bool, ?timeout: Numeric, ?track_locations: bool, ?track_whitespace: bool, ?transform_conditionals: bool) -> void
 
-    # : () -> Hash[Symbol, bool]
-    def to_h: () -> Hash[Symbol, bool]
+    # : () -> Hash[Symbol, (bool | Numeric | Array[String] | nil)]
+    def to_h: () -> Hash[Symbol, bool | Numeric | Array[String] | nil]
 
     # : () -> String
     def inspect: () -> String

data/sig/herb/position.rbs

@@ -3,6 +3,8 @@
 module Herb
   # : type serialized_position = { line: Integer, column: Integer }
   class Position
+    include Comparable
+
     attr_reader line: Integer
 
     attr_reader column: Integer
@@ -16,9 +18,18 @@ module Herb
     # : (Integer, Integer) -> Position
     def self.from: (Integer, Integer) -> Position
 
+    # : () -> Position
+    def self.zero: () -> Position
+
+    # : (untyped) -> Integer?
+    def <=>: (untyped) -> Integer?
+
     # : () -> serialized_position
     def to_hash: () -> serialized_position
 
+    # : () -> serialized_position
+    def to_one_based: () -> serialized_position
+
     # : (?untyped) -> String
     def to_json: (?untyped) -> String
 

data/sig/herb/range.rbs

@@ -16,6 +16,9 @@ module Herb
     # : (Integer, Integer) -> Range
     def self.from: (Integer, Integer) -> Range
 
+    # : () -> Range
+    def self.zero: () -> Range
+
     # : () -> serialized_range
     def to_a: () -> serialized_range
 

data/sig/herb/ruby_program.rbs

@@ -0,0 +1,51 @@
+# Generated from lib/herb/ruby_program.rb with RBS::Inline
+
+module Herb
+  # Answers what Ruby a span of a template holds, out of the one Prism program the parser built
+  # for the whole document. `extract_ruby` blanks the HTML in place, so a Prism byte offset and a
+  # template byte offset are the same number, which is what lets a `Herb::Location` address Ruby.
+  #
+  #     program = Herb::RubyProgram.for(document)
+  #     program.resolve(node.content.location)&.nodes #=> [#<Prism::CallNode>]
+  #
+  # The document has to have been parsed with the `prism_program` parser option, and `for` answers
+  # `nil` when it was not. `Herb::Locate` is the same question asked of the HTML tree, and
+  # `Herb::Analysis::RubyLocalsIndex::OffsetTable` walks the other way, from a Prism offset back
+  # to a `Herb::Location`.
+  class RubyProgram
+    class Resolved < Data
+      attr_reader nodes(): Array[untyped]
+
+      attr_reader offset(): Integer
+
+      attr_reader source(): String
+
+      def self.new: (Array[untyped] nodes, Integer offset, String source) -> instance
+                  | (nodes: Array[untyped], offset: Integer, source: String) -> instance
+
+      def self.members: () -> [ :nodes, :offset, :source ]
+
+      def members: () -> [ :nodes, :offset, :source ]
+    end
+
+    # : (untyped) -> RubyProgram?
+    def self.for: (untyped) -> RubyProgram?
+
+    # : (String, untyped) -> void
+    def initialize: (String, untyped) -> void
+
+    # : (Herb::Location?) -> Resolved?
+    def resolve: (Herb::Location?) -> Resolved?
+
+    private
+
+    # : (untyped) -> Array[untyped]
+    def flatten: (untyped) -> Array[untyped]
+
+    # : (Integer, Integer) -> Array[untyped]
+    def enclosed: (Integer, Integer) -> Array[untyped]
+
+    # : (untyped) -> Integer?
+    def offset_of: (untyped) -> Integer?
+  end
+end

data/sig/herb/source_path.rbs

@@ -0,0 +1,132 @@
+# Generated from lib/herb/source_path.rb with RBS::Inline
+
+module Herb
+  # A path, and optionally where in it something is.
+  #
+  #     Herb::SourcePath.new("app/views/posts/_card.html.erb", line: 8, column: 2).to_s
+  #     #=> "app/views/posts/_card.html.erb:8:3"
+  #
+  #     Herb::SourcePath.parse("app/views/posts/_card.html.erb:8:3").position
+  #     #=> #<Herb::Position (8:2)>
+  #
+  # `path:line:column` is what an editor linkifies, what a terminal makes clickable, and what
+  # `data-herb-source` holds. Herb wrote it by hand in five places and they did not agree, because
+  # the column the parser reports is 0-based and the column an editor shows is 1-based. Everything
+  # that reads or writes one of these strings goes through here so that conversion happens once.
+  #
+  # A part that is not known is left out, so a path on its own stays a path:
+  #
+  #     Herb::SourcePath.new("index.html.erb").to_s        #=> "index.html.erb"
+  #     Herb::SourcePath.new("index.html.erb", line: 8).to_s #=> "index.html.erb:8"
+  #
+  # A scheme is optional too, and turns the same reference into something an editor opens:
+  #
+  #     Herb::SourcePath.new(path, line: 8, column: 2, scheme: "vscode").to_s
+  #     #=> "vscode://file/app/views/posts/_card.html.erb:8:3"
+  #
+  # A project turns the same reference into either form. A stamp and a diagnostic show the relative
+  # path, and an editor scheme needs the absolute one:
+  #
+  #     reference = Herb::SourcePath.at(path, position, project_path: Rails.root)
+  #
+  #     reference.relative.to_s                    #=> "app/views/posts/_card.html.erb:8:3"
+  #     reference.absolute.with_scheme("vscode").to_s
+  #     #=> "vscode://file/Users/marco/blog/app/views/posts/_card.html.erb:8:3"
+  #
+  # Neither is guessed. `to_s` writes the path it was handed, so a caller says which one it wants.
+  # An editor scheme names a file from the root, so call `absolute` before putting one on.
+  #
+  # Lines count from one and columns count from zero, which is what the parser reports and what
+  # `Herb::Position` carries. Only `to_s` and `parse` speak the 1-based column an editor shows.
+  class SourcePath
+    PATTERN: Regexp
+
+    FILE_SCHEME_SEPARATOR: String
+
+    attr_reader path: Pathname
+
+    attr_reader project_path: Pathname?
+
+    attr_reader line: Integer?
+
+    attr_reader column: Integer?
+
+    attr_reader scheme: String?
+
+    # : ((String | Pathname), ?project_path: (String | Pathname)?, ?line: Integer?, ?column: Integer?, ?scheme: String?) -> void
+    def initialize: (String | Pathname, ?project_path: (String | Pathname)?, ?line: Integer?, ?column: Integer?, ?scheme: String?) -> void
+
+    # : ((String | Pathname), Herb::Position?, ?project_path: (String | Pathname)?, ?scheme: String?) -> SourcePath
+    def self.at: (String | Pathname, Herb::Position?, ?project_path: (String | Pathname)?, ?scheme: String?) -> SourcePath
+
+    # : ((String | Pathname)) -> Pathname
+    def self.coerce: (String | Pathname) -> Pathname
+
+    # : (String, ?project_path: (String | Pathname)?) -> SourcePath?
+    def self.parse: (String, ?project_path: (String | Pathname)?) -> SourcePath?
+
+    # : (String?) -> Integer?
+    def self.reported_column: (String?) -> Integer?
+
+    # : () -> Herb::Position?
+    def position: () -> Herb::Position?
+
+    # : () -> bool
+    def position?: () -> bool
+
+    # : ((String | Pathname)) -> SourcePath
+    def with_path: (String | Pathname) -> SourcePath
+
+    # : ((String | Pathname)?) -> SourcePath
+    def with_project_path: ((String | Pathname)?) -> SourcePath
+
+    # : () -> bool
+    def absolute?: () -> bool
+
+    # : () -> Pathname
+    def absolute_path: () -> Pathname
+
+    # : () -> Pathname
+    def relative_path: () -> Pathname
+
+    # : () -> SourcePath
+    def absolute: () -> SourcePath
+
+    # : () -> SourcePath
+    def relative: () -> SourcePath
+
+    # : (Herb::Position?) -> SourcePath
+    def with_position: (Herb::Position?) -> SourcePath
+
+    # : (String?) -> SourcePath
+    def with_scheme: (String?) -> SourcePath
+
+    # : () -> String
+    def to_s: () -> String
+
+    # : () -> Pathname
+    def to_pathname: () -> Pathname
+
+    # : (untyped) -> bool
+    def ==: (untyped) -> bool
+
+    alias eql? ==
+
+    # : () -> Integer
+    def hash: () -> Integer
+
+    # : () -> String
+    def inspect: () -> String
+
+    private
+
+    # : () -> String
+    def prefix: () -> String
+
+    # : () -> String
+    def written_path: () -> String
+
+    # : () -> String
+    def suffix: () -> String
+  end
+end

data/sig/herb/token.rbs

@@ -18,6 +18,9 @@ module Herb
 
     attr_reader type: String
 
+    # : (String | Symbol, String, ?location: Location, ?range: Range) -> Token
+    def self.from: (String | Symbol, String, ?location: Location, ?range: Range) -> Token
+
     # : (String, Range, Location, String) -> void
     def initialize: (String, Range, Location, String) -> void
 
@@ -36,8 +39,8 @@ module Herb
     # : () -> String
     def colorize_range: () -> String
 
-    # : (Position) -> String
-    def colorize_position: (Position) -> String
+    # : (Position?) -> String
+    def colorize_position: (Position?) -> String
 
     # : () -> String
     def inspect: () -> String

data/sig/herb/visitor/context/origin.rbs

@@ -0,0 +1,51 @@
+# Generated from lib/herb/visitor/context/origin.rb with RBS::Inline
+
+module Herb
+  class Visitor
+    class Context
+      # Which nodes hold content that was written somewhere other than the file being compiled.
+      #
+      # A visitor that splices one template into another leaves a tree that no longer answers "where
+      # was this written" by itself, and the node it wraps the splice in is one nobody wrote at all.
+      # Both matter to anything reporting a position back to a developer, and neither is visible from
+      # the node alone.
+      #
+      #     origin.authored(wrapper, "app/views/posts/_card.html.erb", from: render_node)
+      #
+      #     origin.of(wrapper).file #=> "app/views/posts/_card.html.erb"
+      #     origin.of(wrapper).from #=> the `render` tag it replaced
+      #
+      # What is recorded is the node holding the content rather than each node of it, because what
+      # was moved is the partial and not each node of the partial. Recording the nodes themselves
+      # would leave nothing saying which of them belong together, and a partial spliced into the
+      # middle of another would split the one around it in two.
+      #
+      # Only nodes that hold content from elsewhere are recorded, so an untouched tree costs nothing.
+      # This lives on the compile rather than on a visitor, because the visitor that needs the answer
+      # is never the one that knows it.
+      class Origin
+        class Entry < Data
+          attr_reader file(): untyped
+
+          attr_reader from(): untyped
+
+          def self.new: (untyped file, untyped from) -> instance
+                      | (file: untyped, from: untyped) -> instance
+
+          def self.members: () -> [ :file, :from ]
+
+          def members: () -> [ :file, :from ]
+        end
+
+        # : () -> void
+        def initialize: () -> void
+
+        # : (Herb::AST::Node, String, ?from: Herb::AST::Node?) -> void
+        def authored: (Herb::AST::Node, String, ?from: Herb::AST::Node?) -> void
+
+        # : (Herb::AST::Node) -> Entry?
+        def of: (Herb::AST::Node) -> Entry?
+      end
+    end
+  end
+end

data/sig/herb/visitor/context/replacements.rbs

@@ -0,0 +1,39 @@
+# Generated from lib/herb/visitor/context/replacements.rb with RBS::Inline
+
+module Herb
+  class Visitor
+    class Context
+      # Which nodes stand in the tree where another node stood when the compile began.
+      #
+      # A visitor that rewrites an ERB tag builds a fresh node for it and puts that where the old
+      # one was. Any other visitor that recorded something about the old node by identity is then
+      # holding a key nothing in the tree matches, and its `finish` walks a tree it no longer
+      # recognizes. The rewriter knows what it swapped and the recorder knows what it recorded, so
+      # the answer has to live on the compile, where both can reach it.
+      #
+      #     replacements.record(tag, wrapped)
+      #
+      #     replacements.original_of(wrapped) #=> tag
+      #
+      # A chain collapses as it is recorded, so a node replaced twice still answers with the node
+      # the compile started from. Only replaced nodes are recorded, so an untouched tree costs
+      # nothing.
+      class Replacements
+        # : () -> void
+        def initialize: () -> void
+
+        # : (Herb::AST::Node, Herb::AST::Node) -> void
+        def record: (Herb::AST::Node, Herb::AST::Node) -> void
+
+        # : (Herb::AST::Node) -> Herb::AST::Node
+        def original_of: (Herb::AST::Node) -> Herb::AST::Node
+
+        # : () -> bool
+        def any?: () -> bool
+
+        # : () { (Herb::AST::Node, Herb::AST::Node) -> void } -> void
+        def each: () { (Herb::AST::Node, Herb::AST::Node) -> void } -> void
+      end
+    end
+  end
+end

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