steep 0.39.0 → 0.40.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33c89b6005654ebdc947af336b1c7fa47e02c45c480d27b9f4ef0ab6d3403dd1
-  data.tar.gz: be7b7812e1ba321b91680884fccc55fd57dd5836c89bf7817624b72706490d6e
+  metadata.gz: 725a6432404ca94fa643ba89ed2028d7b3923ece4031512ebea88ebbdc4fd01e
+  data.tar.gz: 957a95acbda38474f1a796f829f8cf098b69484a8ddf42bd39e2c2be935a961e
 SHA512:
-  metadata.gz: 36945eb5fe4a04061c87bc76488c65ef2b009fcdb8279fd542a1249a10a223cd9571371f333e4ec29870a66dd120c4d9e65d572a9d3c90d56dba5c2c1dd95761
-  data.tar.gz: d9c2e56878f06d71edeb9a10b275c19afd7ba42b1af16ef01ef890ca3791ad4f92f903f7679fcf77b310638b0d0f5fced596e094ec225ff2f567e0f063bfc527
+  metadata.gz: 363a04610a81d4652541c9e5856705f7317a8b4e92a2074dc460b5f34e19f8eb5bfd080826c3a61a41414668d22d0352e4b300d1ce09c659243ef8c06492fc22
+  data.tar.gz: 33b8d47d5290acea68f1f07ee74a6129ad0a2568fff2ddc783b7910f2ed55ae2d6d6b6f0b1b90b8dea773bfab0c9cc7ccc70723ab5aee75db3e3a0f997b93fe9

data/.github/workflows/ruby.yml

@@ -16,7 +16,7 @@ jobs:
         - 2.7.0-bionic
         task:
         - test
-        - smoke
+        - test:output
         - build
     container:
       image: rubylang/ruby:${{ matrix.container_tag }}

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## master
 
+## 0.40.0 (2021-01-31)
+
+* Report progress with dots ([#287](https://github.com/soutaro/steep/pull/287))
+* Diagnostics message improvements ([#297](https://github.com/soutaro/steep/pull/297), [#301](https://github.com/soutaro/steep/pull/301))
+* Fix error on implicit `to_proc` syntax when `untyped` is yielded ([#291](https://github.com/soutaro/steep/pull/291))
+
 ## 0.39.0 (2020-12-25)
 
 * Update RBS to 1.0.0 ([#282](https://github.com/soutaro/steep/pull/282))

data/Rakefile

@@ -9,6 +9,9 @@ end
 
 task :default => :test
 
-task :smoke do
-  sh "bundle", "exec", "bin/smoke_runner.rb", *Dir.glob("smoke/*")
+namespace :test do
+  desc "Run output test"
+  task :output do
+    sh "ruby", "bin/output_test.rb"
+  end
 end

data/bin/output_rebaseline.rb

@@ -0,0 +1,49 @@
+require "pathname"
+require "yaml"
+require "open3"
+require "tempfile"
+
+if ARGV.empty?
+  test_dirs = (Pathname(__dir__) + "../smoke").children
+else
+  test_dirs = ARGV.map {|p| Pathname.pwd + p }
+end
+
+test_dirs.each do |dir|
+  test = dir + "test.yaml"
+
+  if test.file?
+    content = YAML.load_file(test)
+  else
+    content = { "test" => {} }
+  end
+
+  puts "Rebaselining #{dir}..."
+
+  command = content["command"] || "steep check"
+  puts "  command: #{command}"
+
+  output, _ = Open3.capture2(command, chdir: dir.to_s)
+
+  diagnostics = output.split(/\n\n/).each.with_object({}) do |message, hash|
+    if message =~ /\A([^:]+):\d+:\d+:/
+      path = $1
+      hash[path] ||= { "diagnostics" => [] }
+      hash[path]["diagnostics"] << message.chomp + "\n"
+    end
+  end
+
+  content["test"].each_key do |path|
+    unless diagnostics.key?(path)
+      diagnostics[path] = { "diagnostics" => [] }
+    end
+  end
+
+  content["test"] = diagnostics.keys.sort.each.with_object({}) do |key, hash|
+    hash[key] = diagnostics[key]
+  end
+
+  test.open("w") do |io|
+    YAML.dump(content, io, header: false)
+  end
+end

data/bin/output_test.rb

@@ -0,0 +1,93 @@
+require "pathname"
+require "yaml"
+require "open3"
+require "tempfile"
+require "optparse"
+
+OptionParser.new do |opts|
+  opts.on("--verbose", "-v") { @verbose = true }
+end.parse!(ARGV)
+
+if ARGV.empty?
+  test_dirs = (Pathname(__dir__) + "../smoke").children
+else
+  test_dirs = ARGV.map {|p| Pathname.pwd + p }
+end
+
+success = true
+
+test_dirs.each do |dir|
+  test = dir + "test.yaml"
+
+  next unless test.file?
+
+  puts "Running test #{dir}..."
+
+  content = YAML.load_file(test)
+
+  command = content["command"] || "steep check"
+  puts "  command: #{command}"
+
+  output, _ = Open3.capture2(command, chdir: dir.to_s)
+
+  if @verbose
+    puts "  Raw output:"
+    output.split(/\n/).each do |line|
+      puts "  > #{line.chomp}"
+    end
+  end
+
+  diagnostics = output.split(/\n\n/).each.with_object({}) do |d, hash|
+    if d =~ /\A([^:]+):\d+:\d+:/
+      path = $1
+      hash[path] ||= []
+      hash[path] << (d.chomp + "\n")
+    end
+  end
+
+  content["test"].each do |path, test|
+    puts "  Checking: #{path}..."
+
+    fail_expected = test["fail"] || false
+
+    expected_diagnostics = test["diagnostics"]
+    reported_diagnostics = (diagnostics[path] || [])
+
+    puts "    # of expected: #{expected_diagnostics.size}, # of reported: #{reported_diagnostics.size}"
+
+    unexpected_diagnostics = reported_diagnostics.reject {|d| expected_diagnostics.include?(d) }
+    missing_diagnostics = expected_diagnostics.reject {|d| reported_diagnostics.include?(d) }
+
+    unexpected_diagnostics.each do |d|
+      puts "    Unexpected diagnostics:"
+      d.split(/\n/).each do |line|
+        puts "      + #{line.chomp}"
+      end
+    end
+
+    missing_diagnostics.each do |d|
+      puts "    Missing diagnostics:"
+      d.split(/\n/).each do |line|
+        puts "      - #{line.chomp}"
+      end
+    end
+
+    if unexpected_diagnostics.empty? && missing_diagnostics.empty?
+      puts "    👍"
+    else
+      if fail_expected
+        puts "    🚨 (expected failure)"
+      else
+        puts "    🚨"
+        success = false
+      end
+    end
+  end
+end
+
+if success
+  puts "All tests ok! 👏"
+else
+  puts "Errors detected! 🤮"
+  exit 1
+end

data/lib/steep.rb

@@ -42,6 +42,8 @@ require "steep/ast/annotation/collection"
 require "steep/ast/builtin"
 require "steep/ast/types/factory"
 
+require "steep/range_extension"
+
 require "steep/interface/function"
 require "steep/interface/block"
 require "steep/interface/method_type"
@@ -56,12 +58,14 @@ require "steep/subtyping/constraints"
 require "steep/subtyping/variable_variance"
 require "steep/subtyping/variable_occurrence"
 
-require "steep/signature/errors"
+require "steep/diagnostic/helper"
+require "steep/diagnostic/ruby"
+require "steep/diagnostic/signature"
+require "steep/diagnostic/lsp_formatter"
 require "steep/signature/validator"
 require "steep/source"
 require "steep/annotation_parser"
 require "steep/typing"
-require "steep/errors"
 require "steep/module_helper"
 require "steep/type_construction"
 require "steep/type_inference/context"
@@ -97,6 +101,7 @@ require "steep/project/dsl"
 require "steep/project/file_loader"
 require "steep/project/hover_content"
 require "steep/project/completion_provider"
+require "steep/project/stats_calculator"
 require "steep/drivers/utils/driver_helper"
 require "steep/drivers/check"
 require "steep/drivers/stats"
@@ -104,12 +109,12 @@ require "steep/drivers/validate"
 require "steep/drivers/annotations"
 require "steep/drivers/watch"
 require "steep/drivers/langserver"
-require "steep/drivers/signature_error_printer"
 require "steep/drivers/trace_printer"
 require "steep/drivers/print_project"
 require "steep/drivers/init"
 require "steep/drivers/vendor"
 require "steep/drivers/worker"
+require "steep/drivers/diagnostic_printer"
 
 if ENV["NO_COLOR"]
   Rainbow.enabled = false

data/lib/steep/cli.rb

@@ -83,7 +83,6 @@ module Steep
           opts.banner = "Usage: steep check [options] [sources]"
 
           opts.on("--steepfile=PATH") {|path| check.steepfile = Pathname(path) }
-          opts.on("--dump-all-types") { check.dump_all_types = true }
           handle_logging_options opts
         end.parse!(argv)
 
@@ -184,6 +183,7 @@ module Steep
           opts.on("--signature") { command.worker_type = :signature }
           opts.on("--steepfile=PATH") {|path| command.steepfile = Pathname(path) }
           opts.on("--name=NAME") {|name| command.worker_name = name }
+          opts.on("--delay-shutdown") { command.delay_shutdown = true }
         end.parse!(argv)
       end.run
     end

data/lib/steep/diagnostic/helper.rb

@@ -0,0 +1,17 @@
+module Steep
+  module Diagnostic
+    module Helper
+      def error_name
+        self.class.name.split(/::/).last
+      end
+
+      def full_message
+        if detail = detail_lines
+          "#{header_line}\n#{detail}"
+        else
+          "#{header_line}"
+        end
+      end
+    end
+  end
+end

data/lib/steep/diagnostic/lsp_formatter.rb

@@ -0,0 +1,16 @@
+module Steep
+  module Diagnostic
+    class LSPFormatter
+      LSP = LanguageServer::Protocol
+
+      def format(diagnostic)
+        LSP::Interface::Diagnostic.new(
+          message: diagnostic.full_message,
+          code: diagnostic.diagnostic_code,
+          severity: LSP::Constant::DiagnosticSeverity::ERROR,
+          range: diagnostic.location.as_lsp_range
+        ).to_hash
+      end
+    end
+  end
+end

data/lib/steep/diagnostic/ruby.rb

@@ -0,0 +1,623 @@
+module Steep
+  module Diagnostic
+    module Ruby
+      class Base
+        include Helper
+
+        attr_reader :node
+        attr_reader :location
+
+        def initialize(node:, location: node.location.expression)
+          @node = node
+          @location = location
+        end
+
+        def header_line
+          error_name
+        end
+
+        def detail_lines
+          nil
+        end
+
+        def diagnostic_code
+          "Ruby::#{error_name}"
+        end
+      end
+
+      module ResultPrinter
+        def print_result_to(io, level: 1)
+          printer = Drivers::TracePrinter.new(io)
+          printer.print result.trace, level: level
+        end
+
+        def trace_lines
+          StringIO.new.tap do |io|
+            print_result_to(io)
+          end.string.chomp
+        end
+
+        def detail_lines
+          StringIO.new.tap do |io|
+            print_result_to(io)
+          end.string.chomp
+        end
+      end
+
+      class IncompatibleAssignment < Base
+        attr_reader :lhs_type
+        attr_reader :rhs_type
+        attr_reader :result
+
+        include ResultPrinter
+
+        def initialize(node:, lhs_type:, rhs_type:, result:)
+          super(node: node)
+          @lhs_type = lhs_type
+          @rhs_type = rhs_type
+          @result = result
+        end
+
+        def header_line
+          element = case node.type
+                    when :ivasgn, :lvasgn, :gvasgn, :cvasgn
+                      "a variable"
+                    when :casgn
+                      "a constant"
+                    else
+                      "an expression"
+                    end
+          "Cannot assign a value of type `#{rhs_type}` to #{element} of type `#{lhs_type}`"
+        end
+      end
+
+      class IncompatibleArguments < Base
+        attr_reader :node
+        attr_reader :method_name
+        attr_reader :receiver_type
+        attr_reader :method_types
+
+        def initialize(node:, method_name:, receiver_type:, method_types:)
+          location = case node.type
+                     when :send
+                       node.loc.selector
+                     when :block
+                       node.children[0].yield_self do |node|
+                         node.loc.selector
+                       end
+                     when :super
+                       node.loc.expression
+                     else
+                       Steep.logger.error { "Unexpected node given: #{node.type} (IncompatibleArguments#initialize)"}
+                       node.loc.expression
+                     end
+          super(node: node, location: location)
+          @receiver_type = receiver_type
+          @method_types = method_types
+          @method_name = method_name
+        end
+
+        def header_line
+          "Cannot find method `#{method_name}` of type `#{receiver_type}` with compatible arity"
+        end
+
+        def detail_lines
+          StringIO.new.tap do |io|
+            io.puts "Method types:"
+            first_type, *rest_types = method_types
+            defn = "  def #{method_name}"
+            io.puts "#{defn}: #{first_type}"
+            rest_types.each do |method_type|
+              io.puts "#{" " * defn.size}| #{method_type}"
+            end
+          end.string.chomp
+        end
+      end
+
+      class UnresolvedOverloading < Base
+        attr_reader :node
+        attr_reader :receiver_type
+        attr_reader :method_name
+        attr_reader :method_types
+
+        def initialize(node:, receiver_type:, method_name:, method_types:)
+          super node: node
+          @receiver_type = receiver_type
+          @method_name = method_name
+          @method_types = method_types
+        end
+
+        def header_line
+          "Cannot find compatible overloading of method `#{method_name}` of type `#{receiver_type}`"
+        end
+
+        def detail_lines
+          StringIO.new.tap do |io|
+            io.puts "Method types:"
+            first_type, *rest_types = method_types
+            defn = "  def #{method_name}"
+            io.puts "#{defn}: #{first_type}"
+            rest_types.each do |method_type|
+              io.puts "#{" " * defn.size}| #{method_type}"
+            end
+          end.string.chomp
+        end
+      end
+
+      class ArgumentTypeMismatch < Base
+        attr_reader :node
+        attr_reader :expected
+        attr_reader :actual
+        attr_reader :receiver_type
+        attr_reader :result
+
+        include ResultPrinter
+
+        def initialize(node:, receiver_type:, expected:, actual:, result:)
+          super(node: node)
+          @receiver_type = receiver_type
+          @expected = expected
+          @actual = actual
+          @result = result
+        end
+
+        def header_line
+          "Cannot pass a value of type `#{actual}` as an argument of type `#{expected}`"
+        end
+      end
+
+      class NoMethod < Base
+        attr_reader :type
+        attr_reader :method
+
+        def initialize(node:, type:, method:)
+          loc = case node.type
+                when :send
+                  node.loc.selector
+                when :block
+                  node.children[0].loc.selector
+                else
+                  node.loc.expression
+                end
+          super(node: node, location: loc)
+          @type = type
+          @method = method
+        end
+
+        def header_line
+          "Type `#{type}` does not have method `#{method}`"
+        end
+      end
+
+      class ReturnTypeMismatch < Base
+        attr_reader :expected
+        attr_reader :actual
+        attr_reader :result
+
+        include ResultPrinter
+
+        def initialize(node:, expected:, actual:, result:)
+          super(node: node)
+          @expected = expected
+          @actual = actual
+          @result = result
+        end
+
+        def header_line
+          "The method cannot return a value of type `#{actual}` because declared as type `#{expected}`"
+        end
+      end
+
+      class UnexpectedBlockGiven < Base
+        attr_reader :method_type
+
+        def initialize(node:, method_type:)
+          loc = node.loc.begin.join(node.loc.end)
+          super(node: node, location: loc)
+          @method_type = method_type
+        end
+
+        def header_line
+          "The method cannot be called with a block"
+        end
+
+        def to_s
+          format_message "method_type=#{method_type}"
+        end
+      end
+
+      class RequiredBlockMissing < Base
+        attr_reader :method_type
+
+        def initialize(node:, method_type:)
+          super(node: node, location: node.loc.selector)
+          @method_type = method_type
+        end
+
+        def header_line
+          "The method cannot be called without a block"
+        end
+      end
+
+      class BlockTypeMismatch < Base
+        attr_reader :expected
+        attr_reader :actual
+        attr_reader :result
+
+        include ResultPrinter
+
+        def initialize(node:, expected:, actual:, result:)
+          super(node: node)
+          @expected = expected
+          @actual = actual
+          @result = result
+        end
+
+        def header_line
+          "Cannot pass a value of type `#{actual}` as a block-pass-argument of type `#{expected}`"
+        end
+      end
+
+      class BlockBodyTypeMismatch < Base
+        attr_reader :expected
+        attr_reader :actual
+        attr_reader :result
+
+        include ResultPrinter
+
+        def initialize(node:, expected:, actual:, result:)
+          super(node: node, location: node.loc.begin.join(node.loc.end))
+          @expected = expected
+          @actual = actual
+          @result = result
+        end
+
+        def header_line
+          "Cannot allow block body have type `#{actual}` because declared as type `#{expected}`"
+        end
+      end
+
+      class BreakTypeMismatch < Base
+        attr_reader :expected
+        attr_reader :actual
+        attr_reader :result
+
+        include ResultPrinter
+
+        def initialize(node:, expected:, actual:, result:)
+          super(node: node)
+          @expected = expected
+          @actual = actual
+          @result = result
+        end
+
+        def header_line
+          "Cannot break with a value of type `#{actual}` because type `#{expected}` is assumed"
+        end
+      end
+
+      class UnexpectedJump < Base
+        def header_line
+          "Cannot jump from here"
+        end
+      end
+
+      class UnexpectedJumpValue < Base
+        def header_line
+          "The value given to #{node.type} will be ignored"
+        end
+      end
+
+      class MethodArityMismatch < Base
+        attr_reader :method_type
+
+        def initialize(node:, method_type:)
+          args = case node.type
+                 when :def
+                   node.children[1]
+                 when :defs
+                   node.children[2]
+                 end
+          super(node: node, location: args&.loc&.expression || node.loc.name)
+          @method_type = method_type
+        end
+
+        def header_line
+          "Method parameters are incompatible with declaration `#{method_type}`"
+        end
+      end
+
+      class IncompatibleMethodTypeAnnotation < Base
+        attr_reader :interface_method
+        attr_reader :annotation_method
+        attr_reader :result
+
+        include ResultPrinter
+
+        def initialize(node:, interface_method:, annotation_method:, result:)
+          raise
+          super(node: node)
+          @interface_method = interface_method
+          @annotation_method = annotation_method
+          @result = result
+        end
+      end
+
+      class MethodReturnTypeAnnotationMismatch < Base
+        attr_reader :method_type
+        attr_reader :annotation_type
+        attr_reader :result
+
+        include ResultPrinter
+
+        def initialize(node:, method_type:, annotation_type:, result:)
+          super(node: node)
+          @method_type = method_type
+          @annotation_type = annotation_type
+          @result = result
+        end
+
+        def header_line
+          "Annotation `@type return` specifies type `#{annotation_type}` where declared as type `#{method_type}`"
+        end
+      end
+
+      class MethodBodyTypeMismatch < Base
+        attr_reader :expected
+        attr_reader :actual
+        attr_reader :result
+
+        include ResultPrinter
+
+        def initialize(node:, expected:, actual:, result:)
+          super(node: node)
+          @expected = expected
+          @actual = actual
+          @result = result
+        end
+
+        def header_line
+          "Cannot allow method body have type `#{actual}` because declared as type `#{expected}`"
+        end
+      end
+
+      class UnexpectedYield < Base
+        def header_line
+          "No block given for `yield`"
+        end
+      end
+
+      class UnexpectedSuper < Base
+        attr_reader :method
+
+        def initialize(node:, method:)
+          super(node: node)
+          @method = method
+        end
+
+        def to_s
+          format_message "method=#{method}"
+        end
+      end
+
+      class MethodDefinitionMissing < Base
+        attr_reader :module_name
+        attr_reader :kind
+        attr_reader :missing_method
+
+        def initialize(node:, module_name:, kind:, missing_method:)
+          super(node: node, location: node.children[0].loc.expression)
+          @module_name = module_name
+          @kind = kind
+          @missing_method = missing_method
+        end
+
+        def header_line
+          method_name = case kind
+                        when :module
+                          ".#{missing_method}"
+                        when :instance
+                          "##{missing_method}"
+                        end
+          "Cannot find implementation of method `#{module_name}#{method_name}`"
+        end
+      end
+
+      class UnexpectedDynamicMethod < Base
+        attr_reader :module_name
+        attr_reader :method_name
+
+        def initialize(node:, module_name:, method_name:)
+          super(node: node, location: node.children[0].loc.expression)
+          @module_name = module_name
+          @method_name = method_name
+        end
+
+        def header_line
+          "@dynamic annotation contains unknown method name `#{method_name}`"
+        end
+      end
+
+      class UnknownConstantAssigned < Base
+        attr_reader :context
+        attr_reader :name
+
+        def initialize(node:, context:, name:)
+          const = node.children[0]
+          loc = if const
+                  const.loc.expression.join(node.loc.name)
+                else
+                  node.loc.name
+                end
+          super(node: node, location: loc)
+          @context = context
+          @name = name
+        end
+
+        def header_line
+          "Cannot find the declaration of constant `#{name}`"
+        end
+      end
+
+      class FallbackAny < Base
+        def initialize(node:)
+          super(node: node)
+        end
+
+        def header_line
+          "Cannot detect the type of the expression"
+        end
+      end
+
+      class UnsatisfiableConstraint < Base
+        attr_reader :method_type
+        attr_reader :var
+        attr_reader :sub_type
+        attr_reader :super_type
+        attr_reader :result
+
+        def initialize(node:, method_type:, var:, sub_type:, super_type:, result:)
+          super(node: node)
+          @method_type = method_type
+          @var = var
+          @sub_type = sub_type
+          @super_type = super_type
+          @result = result
+        end
+
+        include ResultPrinter
+
+        def header_line
+          "Unsatisfiable constraint `#{sub_type} <: #{var} <: #{super_type}` is generated through #{method_type}"
+        end
+      end
+
+      class IncompatibleAnnotation < Base
+        attr_reader :var_name
+        attr_reader :result
+        attr_reader :relation
+
+        def initialize(node:, var_name:, result:, relation:)
+          super(node: node)
+          @var_name = var_name
+          @result = result
+          @relation = relation
+        end
+
+        include ResultPrinter
+
+        def header_line
+          "Type annotation about `#{var_name}` is incompatible since #{relation} doesn't hold"
+        end
+      end
+
+      class IncompatibleTypeCase < Base
+        attr_reader :var_name
+        attr_reader :result
+        attr_reader :relation
+
+        def initialize(node:, var_name:, result:, relation:)
+          super(node: node)
+          @var_name = var_name
+          @result = result
+          @relation = relation
+        end
+
+        include ResultPrinter
+
+        def header_line
+          "Type annotation for branch about `#{var_name}` is incompatible since #{relation} doesn't hold"
+        end
+      end
+
+      class ElseOnExhaustiveCase < Base
+        attr_reader :type
+
+        def initialize(node:, type:)
+          super(node: node)
+          @type = type
+        end
+
+        def header_line
+          "The branch is unreachable because the condition is exhaustive"
+        end
+      end
+
+      class UnexpectedSplat < Base
+        attr_reader :type
+
+        def initialize(node:, type:)
+          super(node: node)
+          @type = type
+        end
+
+        def header_line
+          "Hash splat is given with object other than `Hash[X, Y]`"
+        end
+      end
+
+      class UnexpectedKeyword < Base
+        attr_reader :unexpected_keywords
+
+        def initialize(node:, unexpected_keywords:)
+          super(node: node)
+          @unexpected_keywords = unexpected_keywords
+        end
+
+        def header_line
+          keywords = unexpected_keywords.sort.map {|x| "`#{x}`" }
+          "Cannot specify unexpected keyword arguments: #{keywords.join(", ")}"
+        end
+      end
+
+      class MissingKeyword < Base
+        attr_reader :missing_keywords
+
+        def initialize(node:, missing_keywords:)
+          super(node: node)
+          @missing_keywords = missing_keywords
+        end
+
+        def header_line
+          keywords = missing_keywords.sort.map {|x| "`#{x}`" }
+          "Cannot omit required keywords: #{keywords.join(", ")}"
+        end
+      end
+
+      class UnsupportedSyntax < Base
+        attr_reader :message
+
+        def initialize(node:, message: nil)
+          super(node: node)
+          @message = message
+        end
+
+        def header_line
+          if message
+            message
+          else
+            "Syntax `#{node.type}` is not supported in Steep"
+          end
+        end
+      end
+
+      class UnexpectedError < Base
+        attr_reader :message
+        attr_reader :error
+
+        def initialize(node:, error:)
+          super(node: node)
+          @error = error
+        end
+
+        def header_line
+          "UnexpectedError: #{error.message}"
+        end
+
+        def detail_lines
+          error.backtrace.join("\n")
+        end
+      end
+    end
+  end
+end