herb 0.7.4-aarch64-linux-gnu → 0.8.0-aarch64-linux-gnu

data/lib/herb/errors.rb

@@ -42,13 +42,15 @@ module Herb
         to_hash.to_json(state)
       end
 
-      #: (?Integer) -> String
-      def tree_inspect(_indent = 0)
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         raise NotImplementedError
       end
     end
 
     class UnexpectedError < Error
+      include Colors
+
       attr_reader :description #: String
       attr_reader :expected #: String
       attr_reader :found #: String
@@ -76,15 +78,15 @@ module Herb
         }) #: Herb::serialized_unexpected_error
       end
 
-      #: (?Integer) -> String
-      def tree_inspect(indent = 0)
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         output = +""
 
-        output += %(@ #{error_name} #{location.tree_inspect}\n)
-        output += %(├── message: #{message.inspect}\n)
-        output += %(├── description: #{description.inspect}\n)
-        output += %(├── expected: #{expected.inspect}\n)
-        output += %(└── found: #{found.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")
+        output += white("└── found: #{green(found.inspect)}\n")
         output += %(\n)
 
         output.gsub(/^/, "    " * indent)
@@ -92,6 +94,8 @@ module Herb
     end
 
     class UnexpectedTokenError < Error
+      include Colors
+
       attr_reader :expected_type #: String
       attr_reader :found #: Herb::Token
 
@@ -116,14 +120,16 @@ module Herb
         }) #: Herb::serialized_unexpected_token_error
       end
 
-      #: (?Integer) -> String
-      def tree_inspect(indent = 0)
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         output = +""
 
-        output += %(@ #{error_name} #{location.tree_inspect}\n)
-        output += %(├── message: #{message.inspect}\n)
-        output += %(├── expected_type: #{expected_type.inspect}\n)
-        output += %(└── found: #{found ? found.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: ")
+        output += found ? found.tree_inspect : magenta("∅")
+        output += "\n"
         output += %(\n)
 
         output.gsub(/^/, "    " * indent)
@@ -131,6 +137,8 @@ module Herb
     end
 
     class MissingOpeningTagError < Error
+      include Colors
+
       attr_reader :closing_tag #: Herb::Token
 
       #: (String, Location, String, Herb::Token) -> void
@@ -152,13 +160,15 @@ module Herb
         }) #: Herb::serialized_missing_opening_tag_error
       end
 
-      #: (?Integer) -> String
-      def tree_inspect(indent = 0)
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         output = +""
 
-        output += %(@ #{error_name} #{location.tree_inspect}\n)
-        output += %(├── message: #{message.inspect}\n)
-        output += %(└── closing_tag: #{closing_tag ? closing_tag.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("∅")
+        output += "\n"
         output += %(\n)
 
         output.gsub(/^/, "    " * indent)
@@ -166,6 +176,8 @@ module Herb
     end
 
     class MissingClosingTagError < Error
+      include Colors
+
       attr_reader :opening_tag #: Herb::Token
 
       #: (String, Location, String, Herb::Token) -> void
@@ -187,13 +199,15 @@ module Herb
         }) #: Herb::serialized_missing_closing_tag_error
       end
 
-      #: (?Integer) -> String
-      def tree_inspect(indent = 0)
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         output = +""
 
-        output += %(@ #{error_name} #{location.tree_inspect}\n)
-        output += %(├── message: #{message.inspect}\n)
-        output += %(└── opening_tag: #{opening_tag ? opening_tag.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("∅")
+        output += "\n"
         output += %(\n)
 
         output.gsub(/^/, "    " * indent)
@@ -201,6 +215,8 @@ module Herb
     end
 
     class TagNamesMismatchError < Error
+      include Colors
+
       attr_reader :opening_tag #: Herb::Token
       attr_reader :closing_tag #: Herb::Token
 
@@ -225,14 +241,18 @@ module Herb
         }) #: Herb::serialized_tag_names_mismatch_error
       end
 
-      #: (?Integer) -> String
-      def tree_inspect(indent = 0)
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         output = +""
 
-        output += %(@ #{error_name} #{location.tree_inspect}\n)
-        output += %(├── message: #{message.inspect}\n)
-        output += %(├── opening_tag: #{opening_tag ? opening_tag.tree_inspect : "∅"}\n)
-        output += %(└── closing_tag: #{closing_tag ? closing_tag.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("∅")
+        output += "\n"
+        output += white("└── closing_tag: ")
+        output += closing_tag ? closing_tag.tree_inspect : magenta("∅")
+        output += "\n"
         output += %(\n)
 
         output.gsub(/^/, "    " * indent)
@@ -240,6 +260,8 @@ module Herb
     end
 
     class QuotesMismatchError < Error
+      include Colors
+
       attr_reader :opening_quote #: Herb::Token
       attr_reader :closing_quote #: Herb::Token
 
@@ -264,14 +286,18 @@ module Herb
         }) #: Herb::serialized_quotes_mismatch_error
       end
 
-      #: (?Integer) -> String
-      def tree_inspect(indent = 0)
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         output = +""
 
-        output += %(@ #{error_name} #{location.tree_inspect}\n)
-        output += %(├── message: #{message.inspect}\n)
-        output += %(├── opening_quote: #{opening_quote ? opening_quote.tree_inspect : "∅"}\n)
-        output += %(└── closing_quote: #{closing_quote ? closing_quote.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_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)
@@ -279,6 +305,8 @@ module Herb
     end
 
     class VoidElementClosingTagError < Error
+      include Colors
+
       attr_reader :tag_name #: Herb::Token
       attr_reader :expected #: String
       attr_reader :found #: String
@@ -306,15 +334,17 @@ module Herb
         }) #: Herb::serialized_void_element_closing_tag_error
       end
 
-      #: (?Integer) -> String
-      def tree_inspect(indent = 0)
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         output = +""
 
-        output += %(@ #{error_name} #{location.tree_inspect}\n)
-        output += %(├── message: #{message.inspect}\n)
-        output += %(├── tag_name: #{tag_name ? tag_name.tree_inspect : "∅"}\n)
-        output += %(├── expected: #{expected.inspect}\n)
-        output += %(└── found: #{found.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("∅")
+        output += "\n"
+        output += white("├── expected: #{green(expected.inspect)}\n")
+        output += white("└── found: #{green(found.inspect)}\n")
         output += %(\n)
 
         output.gsub(/^/, "    " * indent)
@@ -322,6 +352,8 @@ module Herb
     end
 
     class UnclosedElementError < Error
+      include Colors
+
       attr_reader :opening_tag #: Herb::Token
 
       #: (String, Location, String, Herb::Token) -> void
@@ -343,13 +375,15 @@ module Herb
         }) #: Herb::serialized_unclosed_element_error
       end
 
-      #: (?Integer) -> String
-      def tree_inspect(indent = 0)
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         output = +""
 
-        output += %(@ #{error_name} #{location.tree_inspect}\n)
-        output += %(├── message: #{message.inspect}\n)
-        output += %(└── opening_tag: #{opening_tag ? opening_tag.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("∅")
+        output += "\n"
         output += %(\n)
 
         output.gsub(/^/, "    " * indent)
@@ -357,6 +391,8 @@ module Herb
     end
 
     class RubyParseError < Error
+      include Colors
+
       attr_reader :error_message #: String
       attr_reader :diagnostic_id #: String
       attr_reader :level #: String
@@ -384,15 +420,89 @@ module Herb
         }) #: Herb::serialized_ruby_parse_error
       end
 
-      #: (?Integer) -> String
-      def tree_inspect(indent = 0)
+      #: (?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("├── error_message: #{green(error_message.inspect)}\n")
+        output += white("├── diagnostic_id: #{green(diagnostic_id.inspect)}\n")
+        output += white("└── level: #{green(level.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class ERBControlFlowScopeError < Error
+      include Colors
+
+      attr_reader :keyword #: String
+
+      #: (String, Location, String, String) -> void
+      def initialize(type, location, message, keyword)
+        super(type, location, message)
+
+        @keyword = keyword
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_erb_control_flow_scope_error
+      def to_hash
+        super.merge({
+          keyword: keyword,
+        }) #: Herb::serialized_erb_control_flow_scope_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("└── keyword: #{green(keyword.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class MissingERBEndTagError < Error
+      include Colors
+
+      attr_reader :keyword #: String
+
+      #: (String, Location, String, String) -> void
+      def initialize(type, location, message, keyword)
+        super(type, location, message)
+
+        @keyword = keyword
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_missingerb_end_tag_error
+      def to_hash
+        super.merge({
+          keyword: keyword,
+        }) #: Herb::serialized_missingerb_end_tag_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         output = +""
 
-        output += %(@ #{error_name} #{location.tree_inspect}\n)
-        output += %(├── message: #{message.inspect}\n)
-        output += %(├── error_message: #{error_message.inspect}\n)
-        output += %(├── diagnostic_id: #{diagnostic_id.inspect}\n)
-        output += %(└── level: #{level.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)
 
         output.gsub(/^/, "    " * indent)

data/lib/herb/location.rb

@@ -40,12 +40,12 @@ module Herb
 
     #: () -> String
     def tree_inspect
-      %((location: #{start.tree_inspect}-#{self.end.tree_inspect}))
+      "#{start.tree_inspect}-#{self.end.tree_inspect}"
     end
 
     #: () -> String
     def inspect
-      %(#<Herb::Location #{tree_inspect}>)
+      %(#<Herb::Location (location: #{tree_inspect})>)
     end
   end
 end

data/lib/herb/project.rb

@@ -30,7 +30,7 @@ module Herb
     end
 
     def glob
-      "**/*.html.erb"
+      "**/*.{html,rhtml,html.erb,html+*.erb,turbo_stream.erb}"
     end
 
     def full_path_glob
@@ -78,19 +78,23 @@ module Herb
         failed_files = []
         timeout_files = []
         error_files = []
+        compilation_failed_files = []
         error_outputs = {}
         file_contents = {}
         parse_errors = {}
+        compilation_errors = {}
 
         files.each_with_index do |file_path, index|
           total_failed = failed_files.count
           total_timeout = timeout_files.count
           total_errors = error_files.count
+          total_compilation_failed = compilation_failed_files.count
 
-          lines_to_clear = 6 + total_failed + total_timeout + total_errors
+          lines_to_clear = 6 + total_failed + total_timeout + total_errors + total_compilation_failed
           lines_to_clear += 3 if total_failed.positive?
           lines_to_clear += 3 if total_timeout.positive?
           lines_to_clear += 3 if total_errors.positive?
+          lines_to_clear += 3 if total_compilation_failed.positive?
 
           lines_to_clear.times { print "\e[1A\e[K" } if index.positive? && interactive?
 
@@ -129,6 +133,13 @@ module Herb
               error_files.each { |file| puts "  - #{file}" }
               puts
             end
+
+            if compilation_failed_files.any?
+              puts
+              puts "Files with compilation errors:"
+              compilation_failed_files.each { |file| puts "  - #{file}" }
+              puts
+            end
           end
 
           begin
@@ -173,7 +184,33 @@ module Herb
               case $CHILD_STATUS.exitstatus
               when 0
                 log.puts "✅ Parsed #{file_path} successfully"
-                successful_files << file_path
+
+                begin
+                  Herb::Engine.new(file_content, filename: file_path, escape: true)
+
+                  log.puts "✅ Compiled #{file_path} successfully"
+                  successful_files << file_path
+                rescue Herb::Engine::CompilationError => e
+                  log.puts "❌ Compilation failed for #{file_path}"
+
+                  compilation_failed_files << file_path
+                  compilation_errors[file_path] = {
+                    error: e.message,
+                    backtrace: e.backtrace&.first(10) || [],
+                  }
+
+                  file_contents[file_path] = file_content
+                rescue StandardError => e
+                  log.puts "❌ Unexpected compilation error for #{file_path}: #{e.class}: #{e.message}"
+
+                  compilation_failed_files << file_path
+                  compilation_errors[file_path] = {
+                    error: "#{e.class}: #{e.message}",
+                    backtrace: e.backtrace&.first(10) || [],
+                  }
+
+                  file_contents[file_path] = file_content
+                end
               when 2
                 message = "⚠️ Parsing #{file_path} completed with errors"
                 log.puts message
@@ -248,8 +285,11 @@ module Herb
         summary = [
           heading("Summary"),
           "Total files: #{files.count}",
-          "✅ Successful: #{successful_files.count} (#{percentage(successful_files.count, files.count)}%)",
-          "❌ Failed: #{failed_files.count} (#{percentage(failed_files.count, files.count)}%)",
+          "✅ Successful (parsed & compiled): #{successful_files.count} (#{percentage(successful_files.count,
+                                                                                      files.count)}%)",
+          "❌ Compilation errors: #{compilation_failed_files.count} (#{percentage(compilation_failed_files.count,
+                                                                                  files.count)}%)",
+          "❌ Failed to parse: #{failed_files.count} (#{percentage(failed_files.count, files.count)}%)",
           "⚠️ Parse errors: #{error_files.count} (#{percentage(error_files.count, files.count)}%)",
           "⏱️ Timed out: #{timeout_files.count} (#{percentage(timeout_files.count, files.count)}%)"
         ]
@@ -289,7 +329,17 @@ module Herb
           end
         end
 
-        problem_files = failed_files + timeout_files + error_files
+        if compilation_failed_files.any?
+          log.puts "\n#{heading("Files with compilation errors")}"
+          puts "\nFiles with compilation errors:"
+
+          compilation_failed_files.each do |f|
+            log.puts f
+            puts "  - #{f}"
+          end
+        end
+
+        problem_files = failed_files + timeout_files + error_files + compilation_failed_files
 
         if problem_files.any?
           log.puts "\n#{heading("FILE CONTENTS AND DETAILS")}"
@@ -331,28 +381,43 @@ module Herb
               end
             end
 
-            next unless parse_errors[file]
+            if parse_errors[file]
+              if parse_errors[file][:stdout].strip.length.positive?
+                log.puts "\n#{heading("STANDARD OUTPUT")}"
+                log.puts "```"
+                log.puts parse_errors[file][:stdout]
+                log.puts "```"
+              end
 
-            if parse_errors[file][:stdout].strip.length.positive?
-              log.puts "\n#{heading("STANDARD OUTPUT")}"
-              log.puts "```"
-              log.puts parse_errors[file][:stdout]
-              log.puts "```"
-            end
+              if parse_errors[file][:stderr].strip.length.positive?
+                log.puts "\n#{heading("ERROR OUTPUT")}"
+                log.puts "```"
+                log.puts parse_errors[file][:stderr]
+                log.puts "```"
+              end
 
-            if parse_errors[file][:stderr].strip.length.positive?
-              log.puts "\n#{heading("ERROR OUTPUT")}"
-              log.puts "```"
-              log.puts parse_errors[file][:stderr]
-              log.puts "```"
+              if parse_errors[file][:ast]
+                log.puts "\n#{heading("AST")}"
+                log.puts "```"
+                log.puts parse_errors[file][:ast]
+                log.puts "```"
+                log.puts
+              end
             end
 
-            next unless parse_errors[file][:ast]
+            next unless compilation_errors[file]
 
-            log.puts "\n#{heading("AST")}"
+            log.puts "\n#{heading("COMPILATION ERROR")}"
             log.puts "```"
-            log.puts parse_errors[file][:ast]
+            log.puts compilation_errors[file][:error]
             log.puts "```"
+
+            if compilation_errors[file][:backtrace].any?
+              log.puts "\n#{heading("BACKTRACE")}"
+              log.puts "```"
+              log.puts compilation_errors[file][:backtrace].join("\n")
+              log.puts "```"
+            end
             log.puts
           end
         end

data/lib/herb/token.rb

@@ -3,6 +3,8 @@
 
 module Herb
   class Token
+    include Colors
+
     attr_reader :value #: String
     attr_reader :range #: Range
     attr_reader :location #: Location
@@ -33,7 +35,7 @@ module Herb
 
     #: () -> String
     def tree_inspect
-      %("#{value.force_encoding("utf-8")}" #{location.tree_inspect})
+      "#{green("\"#{value.force_encoding("utf-8")}\"")} #{dimmed("(location: #{location.tree_inspect})")}"
     end
 
     #: () -> String
@@ -45,9 +47,19 @@ module Herb
       end
     end
 
+    #: () -> String
+    def colorize_range
+      white("[") + cyan(range.from.to_s) + white(", ") + cyan(range.to.to_s) + white("]")
+    end
+
+    #: (Position) -> String
+    def colorize_position(position)
+      white("(") + cyan(position.line.to_s) + white(":") + cyan(position.column.to_s) + white(")")
+    end
+
     #: () -> String
     def inspect
-      %(#<Herb::Token type="#{type}" value=#{value_inspect} range=#{range.tree_inspect} start=#{location.start.tree_inspect} end=#{location.end.tree_inspect}>)
+      "#{white("#<")}#{bold(yellow("Herb::Token"))} #{white("type=")}#{bright_magenta("\"#{type}\"")} #{white("value=")}#{green(value_inspect)} #{white("range=")}#{colorize_range} #{white("start=")}#{colorize_position(location.start)} #{white("end=")}#{colorize_position(location.end)}#{white(">")}"
     end
   end
 end

data/lib/herb/version.rb

@@ -2,5 +2,5 @@
 # typed: true
 
 module Herb
-  VERSION = "0.7.4"
+  VERSION = "0.8.0"
 end

data/lib/herb.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 # typed: false
 
+require_relative "herb/colors"
 require_relative "herb/range"
 require_relative "herb/position"
 require_relative "herb/location"

data/sig/herb/ast/helpers.rbs

@@ -11,6 +11,9 @@ module Herb
 
       # : (String) -> bool
       def erb_output?: (String) -> bool
+
+      # : (Herb::AST::ERBContentNode) -> bool
+      def inline_ruby_comment?: (Herb::AST::ERBContentNode) -> bool
     end
   end
 end

data/sig/herb/ast/node.rbs

@@ -27,11 +27,18 @@ module Herb
       # : (?prefix: String) -> String
       def inspect_errors: (?prefix: String) -> String
 
-      # : (Array[Herb::AST::Node|Herb::Errors::Error], ?item_name: String, ?prefix: String) -> String
-      def inspect_array: (Array[Herb::AST::Node | Herb::Errors::Error], ?item_name: String, ?prefix: String) -> String
-
-      # : (?Integer) -> String
-      def tree_inspect: (?Integer) -> String
+      # : (
+      # |   Array[Herb::AST::Node|Herb::Errors::Error],
+      # |   ?item_name: String,
+      # |   ?prefix: String,
+      # |   ?indent: Integer,
+      # |   ?depth: Integer,
+      # |   ?depth_limit: Integer
+      # | ) -> String
+      def inspect_array: (untyped array, ?item_name: untyped, ?prefix: untyped, ?indent: untyped, ?depth: untyped, ?depth_limit: untyped) -> untyped
+
+      # : (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
 
       # : (Visitor) -> void
       def accept: (Visitor) -> void