test_error_highlight.rb

require "test/unit"

require "error_highlight"
require "did_you_mean"
require "tempfile"

class ErrorHighlightTest < Test::Unit::TestCase
  ErrorHighlight::DefaultFormatter.max_snippet_width = 80

  class DummyFormatter
    def self.message_for(corrections)
      ""
    end
  end

  def setup
    if defined?(DidYouMean)
      @did_you_mean_old_formatter = DidYouMean.formatter
      DidYouMean.formatter = DummyFormatter
    end
  end

  def teardown
    if defined?(DidYouMean)
      DidYouMean.formatter = @did_you_mean_old_formatter
    end
  end

  begin
    method_not_exist
  rescue NameError
    if $!.message.include?("`")
      def preprocess(msg)
        msg
      end
    else
      def preprocess(msg)
        msg.sub("`", "'")
      end
    end
  end

  if Exception.method_defined?(:detailed_message)
    def assert_error_message(klass, expected_msg, &blk)
      omit unless klass < ErrorHighlight::CoreExt
      err = assert_raise(klass, &blk)
      unless klass == ArgumentError && err.message =~ /\A(?:wrong number of arguments|missing keyword[s]?|unknown keyword[s]?|no keywords accepted)\b/
        spot = ErrorHighlight.spot(err)
        if spot
          assert_kind_of(Integer, spot[:first_lineno])
          assert_kind_of(Integer, spot[:first_column])
          assert_kind_of(Integer, spot[:last_lineno])
          assert_kind_of(Integer, spot[:last_column])
          assert_kind_of(String, spot[:snippet])
          assert_kind_of(Array, spot[:script_lines])
        end
      end
      assert_equal(preprocess(expected_msg).chomp, err.detailed_message(highlight: false).sub(/ \((?:NoMethod|Name)Error\)/, ""))
    end
  else
    def assert_error_message(klass, expected_msg, &blk)
      omit unless klass < ErrorHighlight::CoreExt
      err = assert_raise(klass, &blk)
      assert_equal(preprocess(expected_msg).chomp, err.message)
    end
  end

  if begin; 1.time; rescue; $!.message.end_with?("an instance of Integer"); end
    # new message format
    NEW_MESSAGE_FORMAT = true
    NIL_RECV_MESSAGE = "nil"
    ONE_RECV_MESSAGE = "an instance of Integer"
  else
    NEW_MESSAGE_FORMAT = false
    NIL_RECV_MESSAGE = "nil:NilClass"
    ONE_RECV_MESSAGE = "1:Integer"
  end

  def test_CALL_noarg_1
    assert_error_message(NoMethodError, <<~END) do
undefined method `foo' for #{ NIL_RECV_MESSAGE }

      nil.foo + 1
         ^^^^
    END

      nil.foo + 1
    end
  end

  def test_CALL_noarg_2
    assert_error_message(NoMethodError, <<~END) do
undefined method `foo' for #{ NIL_RECV_MESSAGE }

        .foo + 1
        ^^^^
    END

      nil
        .foo + 1
    end
  end

  def test_CALL_noarg_3
    assert_error_message(NoMethodError, <<~END) do
undefined method `foo' for #{ NIL_RECV_MESSAGE }

        foo + 1
        ^^^
    END

      nil.
        foo + 1
    end
  end

  def test_CALL_noarg_4
    assert_error_message(NoMethodError, <<~END) do
undefined method `foo' for #{ NIL_RECV_MESSAGE }

      (nil).foo + 1
           ^^^^
    END

      (nil).foo + 1
    end
  end

  def test_CALL_arg_1
    assert_error_message(NoMethodError, <<~END) do
undefined method `foo' for #{ NIL_RECV_MESSAGE }

      nil.foo (42)
         ^^^^
    END

      nil.foo (42)
    end
  end

  def test_CALL_arg_2
    assert_error_message(NoMethodError, <<~END) do
undefined method `foo' for #{ NIL_RECV_MESSAGE }

        .foo (
        ^^^^
    END

      nil
        .foo (
          42
        )
    end
  end

  def test_CALL_arg_3
    assert_error_message(NoMethodError, <<~END) do
undefined method `foo' for #{ NIL_RECV_MESSAGE }

        foo (
        ^^^
    END

      nil.
        foo (
          42
        )
    end
  end

  def test_CALL_arg_4
    assert_error_message(NoMethodError, <<~END) do
undefined method `foo' for #{ NIL_RECV_MESSAGE }

      nil.foo(42)
         ^^^^
    END

      nil.foo(42)
    end
  end

  def test_CALL_arg_5
    assert_error_message(NoMethodError, <<~END) do
undefined method `foo' for #{ NIL_RECV_MESSAGE }

        .foo(
        ^^^^
    END

      nil
        .foo(
          42
        )
    end
  end

  def test_CALL_arg_6
    assert_error_message(NoMethodError, <<~END) do
undefined method `foo' for #{ NIL_RECV_MESSAGE }

        foo(
        ^^^
    END

      nil.
        foo(
          42
        )
    end
  end

  def test_CALL_arg_7
    assert_error_message(ArgumentError, <<~END) do
tried to create Proc object without a block (ArgumentError)
    END

      Proc.new
    end
  end

  def test_QCALL_1
    assert_error_message(NoMethodError, <<~END) do
undefined method `foo' for #{ ONE_RECV_MESSAGE }

      1&.foo
       ^^^^^
    END

      1&.foo
    end
  end

  def test_QCALL_2
    assert_error_message(NoMethodError, <<~END) do
undefined method `foo' for #{ ONE_RECV_MESSAGE }

      1&.foo(42)
       ^^^^^
    END

      1&.foo(42)
    end
  end

  def test_CALL_aref_1
    assert_error_message(NoMethodError, <<~END) do
undefined method `[]' for #{ NIL_RECV_MESSAGE }

      nil [ ]
          ^^^
    END

      nil [ ]
    end
  end

  def test_CALL_aref_2
    assert_error_message(NoMethodError, <<~END) do
undefined method `[]' for #{ NIL_RECV_MESSAGE }

      nil [0]
          ^^^
    END

      nil [0]
    end
  end

  def test_CALL_aref_3
    assert_error_message(NoMethodError, <<~END) do
undefined method `[]' for #{ NIL_RECV_MESSAGE }
    END

      nil [
        0
      ]
    end
  end

  def test_CALL_aref_4
    v = Object.new
    recv = NEW_MESSAGE_FORMAT ? "an instance of Object" : v.inspect
    assert_error_message(NoMethodError, <<~END) do
undefined method `[]' for #{ recv }

      v &.[](0)
        ^^^^
    END

      v &.[](0)
    end
  end

  def test_CALL_aref_5
    assert_error_message(NoMethodError, <<~END) do
undefined method `[]' for #{ NIL_RECV_MESSAGE }

      (nil)[ ]
           ^^^
    END

      (nil)[ ]
    end
  end

  def test_CALL_aset
    assert_error_message(NoMethodError, <<~END) do
undefined method `[]=' for #{ NIL_RECV_MESSAGE }

      nil.[]=
         ^^^^
    END

      nil.[]=
    end
  end

  def test_CALL_op_asgn
    v = nil
    assert_error_message(NoMethodError, <<~END) do
undefined method `+' for #{ NIL_RECV_MESSAGE }

      v += 42
        ^
    END

      v += 42
    end
  end

  def test_CALL_special_call_1
    assert_error_message(NoMethodError, <<~END) do
undefined method `call' for #{ NIL_RECV_MESSAGE }
    END

      nil.()
    end
  end

  def test_CALL_special_call_2
    assert_error_message(NoMethodError, <<~END) do
undefined method `call' for #{ NIL_RECV_MESSAGE }
    END

      nil.(42)
    end
  end

  def test_CALL_send
    assert_error_message(NoMethodError, <<~END) do
undefined method `foo' for #{ NIL_RECV_MESSAGE }

      nil.send(:foo, 42)
         ^^^^^
    END

      nil.send(:foo, 42)
    end
  end

  def test_ATTRASGN_1
    assert_error_message(NoMethodError, <<~END) do
undefined method `[]=' for #{ NIL_RECV_MESSAGE }

      nil [ ] = 42
          ^^^^^
    END

      nil [ ] = 42
    end
  end

  def test_ATTRASGN_2
    assert_error_message(NoMethodError, <<~END) do
undefined method `[]=' for #{ NIL_RECV_MESSAGE }

      nil [0] = 42
          ^^^^^
    END

      nil [0] = 42
    end
  end

  def test_ATTRASGN_3
    assert_error_message(NoMethodError, <<~END) do
undefined method `foo=' for #{ NIL_RECV_MESSAGE }

      nil.foo = 42
         ^^^^^^
    END

      nil.foo = 42
    end
  end

  def test_ATTRASGN_4
    assert_error_message(NoMethodError, <<~END) do
undefined method `[]=' for #{ NIL_RECV_MESSAGE }

      (nil)[0] = 42
           ^^^^^
    END

      (nil)[0] = 42
    end
  end

  def test_ATTRASGN_5
    assert_error_message(NoMethodError, <<~END) do
undefined method `foo=' for #{ NIL_RECV_MESSAGE }

      (nil).foo = 42
           ^^^^^^
    END

      (nil).foo = 42
    end
  end

  def test_OPCALL_binary_1
    assert_error_message(NoMethodError, <<~END) do
undefined method `+' for #{ NIL_RECV_MESSAGE }

      nil + 42
          ^
    END

      nil + 42
    end
  end

  def test_OPCALL_binary_2
    assert_error_message(NoMethodError, <<~END) do
undefined method `+' for #{ NIL_RECV_MESSAGE }

      nil + # comment
          ^
    END

      nil + # comment
        42
    end
  end

  def test_OPCALL_binary_3
    assert_error_message(NoMethodError, <<~END) do
undefined method `+' for #{ NIL_RECV_MESSAGE }

      (nil) + 42
            ^
    END

      (nil) + 42
    end
  end

  def test_OPCALL_unary_1
    assert_error_message(NoMethodError, <<~END) do
undefined method `+@' for #{ NIL_RECV_MESSAGE }

      + nil
      ^
    END

      + nil
    end
  end

  def test_OPCALL_unary_2
    assert_error_message(NoMethodError, <<~END) do
undefined method `+@' for #{ NIL_RECV_MESSAGE }

      +(nil)
      ^
    END

      +(nil)
    end
  end

  def test_FCALL_1
    assert_error_message(NoMethodError, <<~END) do
undefined method `foo' for #{ NIL_RECV_MESSAGE }

      nil.instance_eval { foo() }
                          ^^^
    END

      nil.instance_eval { foo() }
    end
  end

  def test_FCALL_2
    assert_error_message(NoMethodError, <<~END) do
undefined method `foo' for #{ NIL_RECV_MESSAGE }

      nil.instance_eval { foo(42) }
                          ^^^
    END

      nil.instance_eval { foo(42) }
    end
  end

  def test_VCALL_2
    assert_error_message(NameError, <<~END) do
undefined local variable or method `foo' for #{ NIL_RECV_MESSAGE }

      nil.instance_eval { foo }
                          ^^^
    END

      nil.instance_eval { foo }
    end
  end

  def test_OP_ASGN1_aref_1
    v = nil

    assert_error_message(NoMethodError, <<~END) do
undefined method `[]' for #{ NIL_RECV_MESSAGE }

      v [0] += 42
        ^^^
    END

      v [0] += 42
    end
  end

  def test_OP_ASGN1_aref_2
    v = nil

    assert_error_message(NoMethodError, <<~END) do
undefined method `[]' for #{ NIL_RECV_MESSAGE }

      v [0] += # comment
        ^^^
    END

      v [0] += # comment
        42
    end
  end

  def test_OP_ASGN1_aref_3
    v = nil

    assert_error_message(NoMethodError, <<~END) do
undefined method `[]' for #{ NIL_RECV_MESSAGE }
    END

      v [
        0
      ] += # comment
        42
    end
  end

  def test_OP_ASGN1_aref_4
    v = nil

    assert_error_message(NoMethodError, <<~END) do
undefined method `[]' for #{ NIL_RECV_MESSAGE }

      (v)[0] += 42
         ^^^
    END

      (v)[0] += 42
    end
  end

  def test_OP_ASGN1_op_1
    v = Object.new
    def v.[](x); nil; end

    assert_error_message(NoMethodError, <<~END) do
undefined method `+' for #{ NIL_RECV_MESSAGE }

      v [0] += 42
            ^
    END

      v [0] += 42
    end
  end

  def test_OP_ASGN1_op_2
    v = Object.new
    def v.[](x); nil; end

    assert_error_message(NoMethodError, <<~END) do
undefined method `+' for #{ NIL_RECV_MESSAGE }

      v [0 ] += # comment
             ^
    END

      v [0 ] += # comment
        42
    end
  end

  def test_OP_ASGN1_op_3
    v = Object.new
    def v.[](x); nil; end

    assert_error_message(NoMethodError, <<~END) do
undefined method `+' for #{ NIL_RECV_MESSAGE }
    END

      v [
        0
      ] +=
        42
    end
  end

  def test_OP_ASGN1_op_4
    v = Object.new
    def v.[](x); nil; end

    assert_error_message(NoMethodError, <<~END) do
undefined method `+' for #{ NIL_RECV_MESSAGE }

      (v)[0] += 42
             ^
    END

      (v)[0] += 42
    end
  end

  def test_OP_ASGN1_aset_1
    v = Object.new
    def v.[](x); 1; end

    assert_error_message(NoMethodError, <<~END) do
undefined method `[]=' for #{ v.inspect }

      v [0] += 42
        ^^^^^^
    END

      v [0] += 42
    end
  end

  def test_OP_ASGN1_aset_2
    v = Object.new
    def v.[](x); 1; end

    assert_error_message(NoMethodError, <<~END) do
undefined method `[]=' for #{ v.inspect }

      v [0] += # comment
        ^^^^^^
    END

      v [0] += # comment
        42
    end
  end

  def test_OP_ASGN1_aset_3
    v = Object.new
    def v.[](x); 1; end

    assert_error_message(NoMethodError, <<~END) do
undefined method `[]=' for #{ v.inspect }
    END

      v [
        0
      ] +=
        42
    end
  end

  def test_OP_ASGN1_aset_4
    v = Object.new
    def v.[](x); 1; end

    assert_error_message(NoMethodError, <<~END) do
undefined method `[]=' for #{ v.inspect }

      (v)[0] += 42
         ^^^^^^
    END

      (v)[0] += 42
    end
  end

  def test_OP_ASGN2_read_1
    v = nil

    assert_error_message(NoMethodError, <<~END) do
undefined method `foo' for #{ NIL_RECV_MESSAGE }

      v.foo += 42
       ^^^^
    END

      v.foo += 42
    end
  end

  def test_OP_ASGN2_read_2
    v = nil

    assert_error_message(NoMethodError, <<~END) do
undefined method `foo' for #{ NIL_RECV_MESSAGE }

      v.foo += # comment
       ^^^^
    END

      v.foo += # comment
        42
    end
  end

  def test_OP_ASGN2_read_3
    v = nil

    assert_error_message(NoMethodError, <<~END) do
undefined method `foo' for #{ NIL_RECV_MESSAGE }

      (v).foo += 42
         ^^^^
    END

      (v).foo += 42
    end
  end

  def test_OP_ASGN2_op_1
    v = Object.new
    def v.foo; nil; end

    assert_error_message(NoMethodError, <<~END) do
undefined method `+' for #{ NIL_RECV_MESSAGE }

      v.foo += 42
            ^
    END

      v.foo += 42
    end
  end

  def test_OP_ASGN2_op_2
    v = Object.new
    def v.foo; nil; end

    assert_error_message(NoMethodError, <<~END) do
undefined method `+' for #{ NIL_RECV_MESSAGE }

      v.foo += # comment
            ^
    END

      v.foo += # comment
        42
    end
  end

  def test_OP_ASGN2_op_3
    v = Object.new
    def v.foo; nil; end

    assert_error_message(NoMethodError, <<~END) do
undefined method `+' for #{ NIL_RECV_MESSAGE }

      (v).foo += 42
              ^
    END

      (v).foo += 42
    end
  end

  def test_OP_ASGN2_write_1
    v = Object.new
    def v.foo; 1; end

    assert_error_message(NoMethodError, <<~END) do
undefined method `foo=' for #{ v.inspect }

      v.foo += 42
       ^^^^^^^
    END

      v.foo += 42
    end
  end

  def test_OP_ASGN2_write_2
    v = Object.new
    def v.foo; 1; end

    assert_error_message(NoMethodError, <<~END) do
undefined method `foo=' for #{ v.inspect }

      v.foo += # comment
       ^^^^^^^
    END

      v.foo += # comment
        42
    end
  end

  def test_OP_ASGN2_write_3
    v = Object.new
    def v.foo; 1; end

    assert_error_message(NoMethodError, <<~END) do
undefined method `foo=' for #{ v.inspect }

      (v).foo += 42
         ^^^^^^^
    END

      (v).foo += 42
    end
  end

  def test_CONST
    assert_error_message(NameError, <<~END) do
uninitialized constant ErrorHighlightTest::NotDefined

      1 + NotDefined + 1
          ^^^^^^^^^^
    END

      1 + NotDefined + 1
    end
  end

  def test_COLON2_1
    assert_error_message(NameError, <<~END) do
uninitialized constant ErrorHighlightTest::NotDefined

      ErrorHighlightTest::NotDefined
                        ^^^^^^^^^^^^
    END

      ErrorHighlightTest::NotDefined
    end
  end

  def test_COLON2_2
    assert_error_message(NameError, <<~END) do
uninitialized constant ErrorHighlightTest::NotDefined

        NotDefined
        ^^^^^^^^^^
    END

      ErrorHighlightTest::
        NotDefined
    end
  end

  def test_COLON2_3
    assert_error_message(NameError, <<~END) do
uninitialized constant ErrorHighlightTest::NotDefined

      ErrorHighlightTest::NotDefined::Foo
                        ^^^^^^^^^^^^
    END

      ErrorHighlightTest::NotDefined::Foo
    end
  end

  def test_COLON2_4
    assert_error_message(NameError, <<~END) do
uninitialized constant ErrorHighlightTest::NotDefined

      ::ErrorHighlightTest::NotDefined::Foo
                          ^^^^^^^^^^^^
    END

      ::ErrorHighlightTest::NotDefined::Foo
    end
  end

  def test_COLON2_5
    # Unfortunately, we cannot identify which `NotDefined` caused the NameError
    assert_error_message(NameError, <<~END) do
uninitialized constant ErrorHighlightTest::NotDefined
    END

      ErrorHighlightTest::NotDefined::NotDefined
    end
  end

  def test_COLON3
    assert_error_message(NameError, <<~END) do
uninitialized constant NotDefined

      ::NotDefined
      ^^^^^^^^^^^^
    END

      ::NotDefined
    end
  end

  module OP_CDECL_TEST
    Nil = nil
  end

  def test_OP_CDECL_read_1
    assert_error_message(NameError, <<~END) do
uninitialized constant ErrorHighlightTest::OP_CDECL_TEST::NotDefined

      OP_CDECL_TEST::NotDefined += 1
                   ^^^^^^^^^^^^
    END

      OP_CDECL_TEST::NotDefined += 1
    end
  end

  def test_OP_CDECL_read_2
    assert_error_message(NameError, <<~END) do
uninitialized constant ErrorHighlightTest::OP_CDECL_TEST::NotDefined

      OP_CDECL_TEST::NotDefined += # comment
                   ^^^^^^^^^^^^
    END

      OP_CDECL_TEST::NotDefined += # comment
        1
    end
  end

  def test_OP_CDECL_read_3
    assert_error_message(NameError, <<~END) do
uninitialized constant ErrorHighlightTest::OP_CDECL_TEST::NotDefined
    END

      OP_CDECL_TEST::
        NotDefined += 1
    end
  end

  def test_OP_CDECL_op_1
    assert_error_message(NoMethodError, <<~END) do
undefined method `+' for #{ NIL_RECV_MESSAGE }

      OP_CDECL_TEST::Nil += 1
                         ^
    END

      OP_CDECL_TEST::Nil += 1
    end
  end

  def test_OP_CDECL_op_2
    assert_error_message(NoMethodError, <<~END) do
undefined method `+' for #{ NIL_RECV_MESSAGE }

      OP_CDECL_TEST::Nil += # comment
                         ^
    END

      OP_CDECL_TEST::Nil += # comment
        1
    end
  end

  def test_OP_CDECL_op_3
    assert_error_message(NoMethodError, <<~END) do
undefined method `+' for #{ NIL_RECV_MESSAGE }

        Nil += 1
            ^
    END

      OP_CDECL_TEST::
        Nil += 1
    end
  end

  def test_OP_CDECL_toplevel_1
    assert_error_message(NameError, <<~END) do
uninitialized constant NotDefined

      ::NotDefined += 1
      ^^^^^^^^^^^^
    END

      ::NotDefined += 1
    end
  end

  def test_OP_CDECL_toplevel_2
    recv = NEW_MESSAGE_FORMAT ? "class ErrorHighlightTest" : "ErrorHighlightTest:Class"
    assert_error_message(NoMethodError, <<~END) do
undefined method `+' for #{ recv }

      ::ErrorHighlightTest += 1
                           ^
    END

      ::ErrorHighlightTest += 1
    end
  end

  def test_explicit_raise_name_error
    assert_error_message(NameError, <<~END) do
NameError

      raise NameError
      ^^^^^
    END

      raise NameError
    end
  end

  def test_explicit_raise_no_method_error
    assert_error_message(NoMethodError, <<~END) do
NoMethodError

      raise NoMethodError
      ^^^^^
    END

      raise NoMethodError
    end
  end

  def test_const_get
    assert_error_message(NameError, <<~END) do
uninitialized constant ErrorHighlightTest::NotDefined

      ErrorHighlightTest.const_get(:NotDefined)
                        ^^^^^^^^^^
    END

      ErrorHighlightTest.const_get(:NotDefined)
    end
  end

  def test_local_variable_get
    b = binding
    assert_error_message(NameError, <<~END) do
local variable `foo' is not defined for #{ b.inspect }

      b.local_variable_get(:foo)
       ^^^^^^^^^^^^^^^^^^^
    END

      b.local_variable_get(:foo)
    end
  end

  def test_multibyte
    assert_error_message(NoMethodError, <<~END) do
undefined method `あいうえお' for #{ NIL_RECV_MESSAGE }
    END

      nil.あいうえお
    end
  end

  def test_args_CALL_1
    assert_error_message(TypeError, <<~END) do
nil can't be coerced into Integer (TypeError)

      1.+(nil)
          ^^^
    END

      1.+(nil)
    end
  end

  OF_NIL_INTO_INTEGER = RUBY_VERSION < "4.1." ? "from nil to integer" : "of nil into Integer"
  def test_args_CALL_2
    v = []
    assert_error_message(TypeError, <<~END) do
no implicit conversion #{OF_NIL_INTO_INTEGER} (TypeError)

      v[nil]
        ^^^
    END

      v[nil]
    end
  end

  def test_args_ATTRASGN_1
    v = method(:raise).to_proc
    recv = NEW_MESSAGE_FORMAT ? "an instance of Proc" : v.inspect
    assert_error_message(NoMethodError, <<~END) do
undefined method `[]=' for #{ recv }

      v [ ] = 1
        ^^^^^
    END

      v [ ] = 1
    end
  end

  def test_args_ATTRASGN_2
    v = []
    assert_error_message(TypeError, <<~END) do
no implicit conversion #{OF_NIL_INTO_INTEGER} (TypeError)

      v [nil] = 1
         ^^^^^^^^
    END

      v [nil] = 1
    end
  end

  def test_args_ATTRASGN_3
    assert_error_message(TypeError, <<~END) do
no implicit conversion of String into Integer (TypeError)

      $stdin.lineno = "str"
                      ^^^^^
    END

      $stdin.lineno = "str"
    end
  end

  def test_args_OPCALL
    assert_error_message(TypeError, <<~END) do
nil can't be coerced into Integer (TypeError)

      1 + nil
          ^^^
    END

      1 + nil
    end
  end

  def test_args_FCALL_1
    assert_error_message(TypeError, <<~END) do
no implicit conversion of Symbol into String (TypeError)

      "str".instance_eval { gsub("foo", :sym) }
                                 ^^^^^^^^^^^
    END

      "str".instance_eval { gsub("foo", :sym) }
    end
  end

  def test_args_FCALL_2
    assert_error_message(TypeError, <<~END) do
no implicit conversion of Symbol into String (TypeError)

      "str".instance_eval { gsub "foo", :sym }
                                 ^^^^^^^^^^^
    END

      "str".instance_eval { gsub "foo", :sym }
    end
  end

  def test_args_OP_ASGN1_aref_1
    v = []

    assert_error_message(TypeError, <<~END) do
no implicit conversion #{OF_NIL_INTO_INTEGER} (TypeError)

      v [nil] += 42
         ^^^^^^^^^^
    END

      v [nil] += 42
    end
  end

  def test_args_OP_ASGN1_aref_2
    v = method(:raise).to_proc

    assert_error_message(ArgumentError, <<~END) do
ArgumentError (ArgumentError)

      v [ArgumentError] += 42
         ^^^^^^^^^^^^^^^^^^^^
    END

      v [ArgumentError] += 42
    end
  end

  def test_args_OP_ASGN1_op
    v = [1]

    assert_error_message(TypeError, <<~END) do
nil can't be coerced into Integer (TypeError)

      v [0] += nil
         ^^^^^^^^^
    END

      v [0] += nil
    end
  end

  def test_args_OP_ASGN2
    v = Object.new
    def v.foo; 1; end

    assert_error_message(TypeError, <<~END) do
nil can't be coerced into Integer (TypeError)

      v.foo += nil
               ^^^
    END

      v.foo += nil
    end
  end

  def test_custom_formatter
    custom_formatter = Object.new
    def custom_formatter.message_for(spot)
      "\n\n" + spot.except(:script_lines).inspect
    end

    original_formatter, ErrorHighlight.formatter = ErrorHighlight.formatter, custom_formatter

    assert_error_message(NoMethodError, <<~END) do
undefined method `time' for #{ ONE_RECV_MESSAGE }

#{{ first_lineno: __LINE__ + 3, first_column: 7, last_lineno: __LINE__ + 3, last_column: 12, snippet: "      1.time {}\n" }.inspect}
    END

      1.time {}
    end

  ensure
    ErrorHighlight.formatter = original_formatter
  end

  def test_hard_tabs
    Tempfile.create(["error_highlight_test", ".rb"], binmode: true) do |tmp|
      tmp << "\t \t1.time {}\n"
      tmp.close

      assert_error_message(NoMethodError, <<~END.gsub("_", "\t")) do
undefined method `time' for #{ ONE_RECV_MESSAGE }

_ _1.time {}
_ _ ^^^^^
    END

        load tmp.path
      end
    end
  end

  def test_no_final_newline
    Tempfile.create(["error_highlight_test", ".rb"], binmode: true) do |tmp|
      tmp << "1.time {}"
      tmp.close

      assert_error_message(NoMethodError, <<~END) do
undefined method `time' for #{ ONE_RECV_MESSAGE }

1.time {}
 ^^^^^
    END

        load tmp.path
      end
    end
  end

  def test_errors_on_small_terminal_window_at_the_end
    assert_error_message(NoMethodError, <<~END) do
undefined method `time' for #{ ONE_RECV_MESSAGE }

...0000000000000000000000000000000000000000000000000000000000000000 + 1.time {}
                                                                       ^^^^^
    END

    100000000000000000000000000000000000000000000000000000000000000000000000000000 + 1.time {}
    end
  end

  def test_errors_on_small_terminal_window_at_the_beginning
    assert_error_message(NoMethodError, <<~END) do
undefined method `time' for #{ ONE_RECV_MESSAGE }

      1.time { 10000000000000000000000000000000000000000000000000000000000000...
       ^^^^^
    END

      1.time { 100000000000000000000000000000000000000000000000000000000000000000000000000000 }

    end
  end

  def test_errors_on_small_terminal_window_at_the_middle_near_beginning
    assert_error_message(NoMethodError, <<~END) do
undefined method `time' for #{ ONE_RECV_MESSAGE }

    100000000000000000000000000000000000000 + 1.time { 1000000000000000000000...
                                               ^^^^^
    END

    100000000000000000000000000000000000000 + 1.time { 100000000000000000000000000000000000000 }
    end
  end

  def test_errors_on_small_terminal_window_at_the_middle
    assert_error_message(NoMethodError, <<~END) do
undefined method `time' for #{ ONE_RECV_MESSAGE }

...000000000000000000000000000000000 + 1.time { 10000000000000000000000000000...
                                        ^^^^^
    END

    10000000000000000000000000000000000000000000000000000000000000000000000 + 1.time { 1000000000000000000000000000000 }
    end
  end

  def test_errors_on_extremely_small_terminal_window
    custom_max_width = 30
    original_max_width = ErrorHighlight::DefaultFormatter.max_snippet_width

    ErrorHighlight::DefaultFormatter.max_snippet_width = custom_max_width

    assert_error_message(NoMethodError, <<~END) do
undefined method `time' for #{ ONE_RECV_MESSAGE }

...00000000 + 1.time { 1000...
               ^^^^^
    END

      100000000000000 + 1.time { 100000000000000 }
    end
  ensure
    ErrorHighlight::DefaultFormatter.max_snippet_width = original_max_width
  end

  def test_errors_on_terminal_window_smaller_than_min_width
    custom_max_width = 5
    original_max_width = ErrorHighlight::DefaultFormatter.max_snippet_width
    min_snippet_width = ErrorHighlight::DefaultFormatter::MIN_SNIPPET_WIDTH

    warning = nil
    original_warn = Warning.instance_method(:warn)
    Warning.class_eval do
      remove_method(:warn)
      define_method(:warn) {|str| warning = str}
    end
    begin
      ErrorHighlight::DefaultFormatter.max_snippet_width = custom_max_width
    ensure
      Warning.class_eval do
        remove_method(:warn)
        define_method(:warn, original_warn)
      end
    end
    assert_match "'max_snippet_width' adjusted to minimum value of #{min_snippet_width}", warning

    assert_error_message(NoMethodError, <<~END) do
undefined method `time' for #{ ONE_RECV_MESSAGE }

...000 + 1.time {...
          ^^^^^
    END

    100000000000000 + 1.time { 100000000000000 }
    end
  ensure
    ErrorHighlight::DefaultFormatter.max_snippet_width = original_max_width
  end

  def test_errors_on_terminal_window_when_truncation_is_disabled
    custom_max_width = nil
    original_max_width = ErrorHighlight::DefaultFormatter.max_snippet_width

    ErrorHighlight::DefaultFormatter.max_snippet_width = custom_max_width

    assert_error_message(NoMethodError, <<~END) do
undefined method `time' for #{ ONE_RECV_MESSAGE }

      10000000000000000000000000000000000000000000000000000000000000000000000 + 1.time { 1000000000000000000000000000000 }
                                                                                 ^^^^^
    END

      10000000000000000000000000000000000000000000000000000000000000000000000 + 1.time { 1000000000000000000000000000000 }
    end
  ensure
    ErrorHighlight::DefaultFormatter.max_snippet_width = original_max_width
  end

  def test_errors_on_small_terminal_window_when_larger_than_viewport
    assert_error_message(NoMethodError, <<~END) do
undefined method `timessssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss!' for #{ ONE_RECV_MESSAGE }

      1.timesssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss...
       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    END

      1.timessssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss!
    end
  end

  def test_errors_on_small_terminal_window_when_exact_size_of_viewport
    assert_error_message(NoMethodError, <<~END) do
undefined method `timessssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss!' for #{ ONE_RECV_MESSAGE }

      1.timessssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss!...
       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    END

      1.timessssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss! * 1000
    end
  end

  def test_simulate_funcallv_from_embedded_ruby
    assert_error_message(NoMethodError, <<~END) do
undefined method `foo' for #{ NIL_RECV_MESSAGE }
    END

      nil.foo + 1
    rescue NoMethodError => exc
      def exc.backtrace_locations = []
      raise
    end
  end

  begin
    ->{}.call(1)
  rescue ArgumentError => exc
    MethodDefLocationSupported =
      RubyVM::AbstractSyntaxTree.respond_to?(:node_id_for_backtrace_location) &&
      RubyVM::AbstractSyntaxTree.node_id_for_backtrace_location(exc.backtrace_locations.first)
  end

  def process_callee_snippet(str)
    return str if MethodDefLocationSupported

    str.sub(/\n +\|.*\n +\^+\n\z/, "")
  end

  WRONG_NUMBER_OF_ARGUMENTS_LINENO = __LINE__ + 1
  def wrong_number_of_arguments_test(x, y)
    x + y
  end

  def test_wrong_number_of_arguments_for_method
    lineno = __LINE__
    assert_error_message(ArgumentError, process_callee_snippet(<<~END)) do
wrong number of arguments (given 1, expected 2) (ArgumentError)

    caller: #{ __FILE__ }:#{ lineno + 12 }
    |       wrong_number_of_arguments_test(1)
            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    callee: #{ __FILE__ }:#{ WRONG_NUMBER_OF_ARGUMENTS_LINENO }
    |   def wrong_number_of_arguments_test(x, y)
            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    END

      wrong_number_of_arguments_test(1)
    end
  end

  KEYWORD_TEST_LINENO = __LINE__ + 1
  def keyword_test(kw1:, kw2:, kw3:)
    kw1 + kw2 + kw3
  end

  def test_missing_keyword
    lineno = __LINE__
    assert_error_message(ArgumentError, process_callee_snippet(<<~END)) do
missing keyword: :kw3 (ArgumentError)

    caller: #{ __FILE__ }:#{ lineno + 12 }
    |       keyword_test(kw1: 1, kw2: 2)
            ^^^^^^^^^^^^
    callee: #{ __FILE__ }:#{ KEYWORD_TEST_LINENO }
    |   def keyword_test(kw1:, kw2:, kw3:)
            ^^^^^^^^^^^^
    END

      keyword_test(kw1: 1, kw2: 2)
    end
  end

  def test_missing_keywords # multiple missing keywords
    lineno = __LINE__
    assert_error_message(ArgumentError, process_callee_snippet(<<~END)) do
missing keywords: :kw2, :kw3 (ArgumentError)

    caller: #{ __FILE__ }:#{ lineno + 12 }
    |       keyword_test(kw1: 1)
            ^^^^^^^^^^^^
    callee: #{ __FILE__ }:#{ KEYWORD_TEST_LINENO }
    |   def keyword_test(kw1:, kw2:, kw3:)
            ^^^^^^^^^^^^
    END

      keyword_test(kw1: 1)
    end
  end

  def test_unknown_keyword
    lineno = __LINE__
    assert_error_message(ArgumentError, process_callee_snippet(<<~END)) do
unknown keyword: :kw4 (ArgumentError)

    caller: #{ __FILE__ }:#{ lineno + 12 }
    |       keyword_test(kw1: 1, kw2: 2, kw3: 3, kw4: 4)
            ^^^^^^^^^^^^
    callee: #{ __FILE__ }:#{ KEYWORD_TEST_LINENO }
    |   def keyword_test(kw1:, kw2:, kw3:)
            ^^^^^^^^^^^^
    END

      keyword_test(kw1: 1, kw2: 2, kw3: 3, kw4: 4)
    end
  end

  def test_unknown_keywords
    lineno = __LINE__
    assert_error_message(ArgumentError, process_callee_snippet(<<~END)) do
unknown keywords: :kw4, :kw5 (ArgumentError)

    caller: #{ __FILE__ }:#{ lineno + 12 }
    |       keyword_test(kw1: 1, kw2: 2, kw3: 3, kw4: 4, kw5: 5)
            ^^^^^^^^^^^^
    callee: #{ __FILE__ }:#{ KEYWORD_TEST_LINENO }
    |   def keyword_test(kw1:, kw2:, kw3:)
            ^^^^^^^^^^^^
    END

      keyword_test(kw1: 1, kw2: 2, kw3: 3, kw4: 4, kw5: 5)
    end
  end

  WRONG_NUBMER_OF_ARGUMENTS_TEST2_LINENO = __LINE__ + 1
  def wrong_number_of_arguments_test2(
    long_argument_name_x,
    long_argument_name_y,
    long_argument_name_z
  )
    long_argument_name_x + long_argument_name_y + long_argument_name_z
  end

  def test_wrong_number_of_arguments_for_method2
    lineno = __LINE__
    assert_error_message(ArgumentError, process_callee_snippet(<<~END)) do
wrong number of arguments (given 1, expected 3) (ArgumentError)

    caller: #{ __FILE__ }:#{ lineno + 12 }
    |       wrong_number_of_arguments_test2(1)
            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    callee: #{ __FILE__ }:#{ WRONG_NUBMER_OF_ARGUMENTS_TEST2_LINENO }
    |   def wrong_number_of_arguments_test2(
            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    END

      wrong_number_of_arguments_test2(1)
    end
  end

  def test_wrong_number_of_arguments_for_lambda_literal
    v = -> {}
    lineno = __LINE__
    assert_error_message(ArgumentError, process_callee_snippet(<<~END)) do
wrong number of arguments (given 1, expected 0) (ArgumentError)

    caller: #{ __FILE__ }:#{ lineno + 12 }
    |       v.call(1)
             ^^^^^
    callee: #{ __FILE__ }:#{ lineno - 1 }
    |     v = -> {}
              ^^
    END

      v.call(1)
    end
  end

  def test_wrong_number_of_arguments_for_lambda_method
    v = lambda { }
    lineno = __LINE__
    assert_error_message(ArgumentError, process_callee_snippet(<<~END)) do
wrong number of arguments (given 1, expected 0) (ArgumentError)

    caller: #{ __FILE__ }:#{ lineno + 12 }
    |       v.call(1)
             ^^^^^
    callee: #{ __FILE__ }:#{ lineno - 1 }
    |     v = lambda { }
                     ^
    END

      v.call(1)
    end
  end

  DEFINE_METHOD_TEST_LINENO = __LINE__ + 1
  define_method :define_method_test do |x, y|
    x + y
  end

  def test_wrong_number_of_arguments_for_define_method
    lineno = __LINE__
    assert_error_message(ArgumentError, process_callee_snippet(<<~END)) do
wrong number of arguments (given 1, expected 2) (ArgumentError)

    caller: #{ __FILE__ }:#{ lineno + 12 }
    |       define_method_test(1)
            ^^^^^^^^^^^^^^^^^^
    callee: #{ __FILE__ }:#{ DEFINE_METHOD_TEST_LINENO }
    |   define_method :define_method_test do |x, y|
                                          ^^
    END

      define_method_test(1)
    end
  end

  def test_spoofed_filename
    Tempfile.create(["error_highlight_test", ".rb"], binmode: true) do |tmp|
      tmp << "module Dummy\nend\n"
      tmp.close

      recv = NEW_MESSAGE_FORMAT ? "an instance of String" : '"dummy":String'
      assert_error_message(NameError, <<~END) do
        undefined local variable or method `foo' for #{ recv }
      END

        "dummy".instance_eval do
          eval <<-END, nil, tmp.path
            foo
          END
        end
      end
    end
  end

  def raise_name_error
    1.time
  end

  def test_spot_with_backtrace_location
    lineno = __LINE__
    begin
      raise_name_error
    rescue NameError => exc
    end

    spot = ErrorHighlight.spot(exc).except(:script_lines)
    assert_equal(lineno - 4, spot[:first_lineno])
    assert_equal(lineno - 4, spot[:last_lineno])
    assert_equal(5, spot[:first_column])
    assert_equal(10, spot[:last_column])
    assert_equal("    1.time\n", spot[:snippet])

    spot = ErrorHighlight.spot(exc, backtrace_location: exc.backtrace_locations[1]).except(:script_lines)
    assert_equal(lineno + 2, spot[:first_lineno])
    assert_equal(lineno + 2, spot[:last_lineno])
    assert_equal(6, spot[:first_column])
    assert_equal(22, spot[:last_column])
    assert_equal("      raise_name_error\n", spot[:snippet])
  end

  def test_spot_with_node
    omit unless RubyVM::AbstractSyntaxTree.respond_to?(:node_id_for_backtrace_location)

    # We can't revisit instruction sequences to find node ids if the prism
    # compiler was used instead of the parse.y compiler. In that case, we'll
    # omit some tests.
    omit if RubyVM::InstructionSequence.compile("").to_a[4][:parser] == :prism

    begin
      raise_name_error
    rescue NameError => exc
    end

    bl = exc.backtrace_locations.first
    expected_spot = ErrorHighlight.spot(exc, backtrace_location: bl)
    ast = RubyVM::AbstractSyntaxTree.parse_file(__FILE__, keep_script_lines: true)
    node_id = RubyVM::AbstractSyntaxTree.node_id_for_backtrace_location(bl)
    node = find_node_by_id(ast, node_id)
    actual_spot = ErrorHighlight.spot(node)

    assert_equal expected_spot, actual_spot
  end

  module SingletonMethodWithSpacing
    LINENO = __LINE__ + 1
    def self . baz(x:)
      x
    end
  end

  def test_singleton_method_with_spacing_missing_keyword
    lineno = __LINE__
    assert_error_message(ArgumentError, process_callee_snippet(<<~END)) do
missing keyword: :x (ArgumentError)

    caller: #{ __FILE__ }:#{ lineno + 12 }
    |       SingletonMethodWithSpacing.baz
                                      ^^^^
    callee: #{ __FILE__ }:#{ SingletonMethodWithSpacing::LINENO }
    |     def self . baz(x:)
                   ^^^^^
    END

      SingletonMethodWithSpacing.baz
    end
  end

  module SingletonMethodMultipleKwargs
    LINENO = __LINE__ + 1
    def self.run(shop_id:, param1:)
      shop_id + param1
    end
  end

  def test_singleton_method_multiple_missing_keywords
    lineno = __LINE__
    assert_error_message(ArgumentError, process_callee_snippet(<<~END)) do
missing keywords: :shop_id, :param1 (ArgumentError)

    caller: #{ __FILE__ }:#{ lineno + 12 }
    |       SingletonMethodMultipleKwargs.run
                                         ^^^^
    callee: #{ __FILE__ }:#{ SingletonMethodMultipleKwargs::LINENO }
    |     def self.run(shop_id:, param1:)
                  ^^^^
    END

      SingletonMethodMultipleKwargs.run
    end
  end

  def assert_isolation_error_message(expected_msg, &blk)
    omit unless Exception.method_defined?(:detailed_message)
    err = assert_raise(Ractor::IsolationError, &blk)
    spot = ErrorHighlight.spot(err)
    if spot
      assert_kind_of(Integer, spot[:first_lineno])
      assert_kind_of(Integer, spot[:first_column])
      assert_kind_of(Integer, spot[:last_lineno])
      assert_kind_of(Integer, spot[:last_column])
      assert_kind_of(String, spot[:snippet])
      assert_kind_of(Array, spot[:script_lines])
    end
    assert_equal(expected_msg.chomp, err.detailed_message(highlight: false))
  end

  def test_isolation_error_outer_variable_highlighted
    err = assert_raise(Ractor::IsolationError) do
      channel = 123
      Ractor.new(channel) do
        channel + 1
      end
    end
    spot = ErrorHighlight.spot(err)
    assert_not_nil spot
    assert_equal "channel", spot[:snippet][spot[:first_column]...spot[:last_column]]
  end

  def test_isolation_error_multiple_outer_variables
    err = assert_raise(Ractor::IsolationError) do
      a = 1
      b = 2
      Ractor.new { a + b }
    end
    spot = ErrorHighlight.spot(err)
    assert_not_nil spot
    # Should highlight one of the outer variables (first found in the block)
    highlighted = spot[:snippet][spot[:first_column]...spot[:last_column]]
    assert_include ["a", "b"], highlighted
  end

  def test_isolation_error_yield_highlighted
    err = assert_raise(Ractor::IsolationError) do
      Ractor.new { yield }
    end
    spot = ErrorHighlight.spot(err)
    assert_not_nil spot
    assert_equal "yield", spot[:snippet][spot[:first_column]...spot[:last_column]]
  end

  def test_isolation_error_shareable_proc_unshareable
    err = assert_raise(Ractor::IsolationError) do
      foo = []
      Ractor.shareable_proc { foo }
    end
    spot = ErrorHighlight.spot(err)
    assert_not_nil spot
    assert_equal "foo", spot[:snippet][spot[:first_column]...spot[:last_column]]
  end

  def test_isolation_error_shareable_proc_reassigned
    err = assert_raise(Ractor::IsolationError) do
      x = 123
      Ractor.shareable_proc { x }
      x = 456
    end
    spot = ErrorHighlight.spot(err)
    assert_not_nil spot
    assert_equal "x", spot[:snippet][spot[:first_column]...spot[:last_column]]
  end

  def test_isolation_error_detailed_message_includes_snippet
    err = assert_raise(Ractor::IsolationError) do
      channel = 123
      Ractor.new(channel) do
        channel + 1
      end
    end
    msg = err.detailed_message(highlight: false)
    assert_match(/channel/, msg)
    assert_match(/\^{7}/, msg)
  end

  def test_isolation_error_without_outer_variables_falls_back
    err = assert_raise(Ractor::IsolationError) do
      raise Ractor::IsolationError, "some isolation error"
    end
    assert_equal [], err.outer_variables
    assert_equal false, err.yield_called
    # Should fall back to the default Spotter path (highlights "raise")
    spot = ErrorHighlight.spot(err)
    assert_not_nil spot
    assert_equal "raise", spot[:snippet][spot[:first_column]...spot[:last_column]]
  end

  private

  def find_node_by_id(node, node_id)
    return node if node.node_id == node_id

    node.children.each do |child|
      next unless child.is_a?(RubyVM::AbstractSyntaxTree::Node)
      found = find_node_by_id(child, node_id)
      return found if found
    end

    return false
  end
end