diff --git a/internal/vm/builtins.go b/internal/vm/builtins.go index 19310cc1..143badd7 100644 --- a/internal/vm/builtins.go +++ b/internal/vm/builtins.go @@ -4226,6 +4226,14 @@ func (vm *VM) bootstrap() { }) vm.cRange.define("member?", rangeCover) vm.cRange.define("===", rangeCover) + // Range#overlap?(other) reports whether the two ranges share any element. + vm.cRange.define("overlap?", func(vm *VM, self object.Value, args []object.Value, _ *Proc) object.Value { + o, ok := args[0].(*object.Range) + if !ok { + raise("TypeError", "wrong argument type %s (expected Range)", vm.classOf(args[0]).name) + } + return object.Bool(rangeOverlap(self.(*object.Range), o)) + }) vm.cRange.define("min", func(vm *VM, self object.Value, args []object.Value, blk *Proc) object.Value { r := self.(*object.Range) if len(args) > 0 { // min(n): the n smallest (the range is ascending) diff --git a/internal/vm/range_edges.go b/internal/vm/range_edges.go index c8fd807a..bd27a6b0 100644 --- a/internal/vm/range_edges.go +++ b/internal/vm/range_edges.go @@ -230,3 +230,43 @@ func rangeSizeFloatEnd(lo, hf float64, excl bool) object.Value { } return object.IntValue(int64(math.Floor(diff)) + 1) } + +// rangeOverlap implements Range#overlap? — whether self and o share at least one +// element. It mirrors MRI's range_overlap: the ranges are disjoint when one's +// end is below the other's begin (touching ends count only when both endpoints +// are inclusive), and an empty (backward, or same-endpoint exclusive) range +// overlaps nothing. A nil bound is treated as an infinity. Incomparable bounds +// report no overlap. +func rangeOverlap(self, o *object.Range) bool { + // self.end below o.begin, or o.end below self.begin → disjoint. + if !object.IsNil(self.Hi) && !object.IsNil(o.Lo) { + c, ok := rangeCmp(self.Hi, o.Lo) + if !ok || c < 0 || (c == 0 && (self.Exclusive || o.Exclusive)) { + return false + } + } + if !object.IsNil(o.Hi) && !object.IsNil(self.Lo) { + c, ok := rangeCmp(o.Hi, self.Lo) + if !ok || c < 0 || (c == 0 && (self.Exclusive || o.Exclusive)) { + return false + } + } + // Either range being empty (begin past end, or equal with an exclusive end) + // means it holds no elements, so nothing overlaps it. + if rangeIsEmpty(self) || rangeIsEmpty(o) { + return false + } + return true +} + +// rangeIsEmpty reports whether a bounded range holds no elements: its begin lies +// past its end, or the two coincide with an exclusive end. An unbounded range is +// never empty. +func rangeIsEmpty(r *object.Range) bool { + if object.IsNil(r.Lo) || object.IsNil(r.Hi) { + return false + } + // A valid range always has comparable bounds, so rangeCmp reports a result. + c, _ := rangeCmp(r.Lo, r.Hi) + return c > 0 || (c == 0 && r.Exclusive) +} diff --git a/internal/vm/range_edges_test.go b/internal/vm/range_edges_test.go index ef78e3cb..7c4e2bcd 100644 --- a/internal/vm/range_edges_test.go +++ b/internal/vm/range_edges_test.go @@ -166,3 +166,34 @@ func TestRangeReverseEachErrors(t *testing.T) { }) } } + +// TestRangeOverlap covers Range#overlap? — shared-element detection with +// inclusive/exclusive ends, unbounded sides, empty/backward ranges and the +// non-Range TypeError. Asserted against MRI Ruby 4.0.6. +func TestRangeOverlap(t *testing.T) { + cases := []struct{ src, want string }{ + {`p (1..5).overlap?(3..7)`, "true\n"}, + {`p (1..5).overlap?(6..8)`, "false\n"}, + {`p (1..5).overlap?(5..8)`, "true\n"}, // inclusive ends touch + {`p (1...5).overlap?(5..8)`, "false\n"}, // exclusive end just misses + {`p (1..5).overlap?(10..)`, "false\n"}, // endless other, disjoint + {`p (..5).overlap?(3..)`, "true\n"}, // beginless meets endless + {`p (1..3).overlap?(4..2)`, "false\n"}, // backward (empty) other + {`p (1..5).overlap?(5..1)`, "false\n"}, // empty other touching self's end + {`p (1...1).overlap?(0..2)`, "false\n"}, // empty self + {`p ("a".."c").overlap?("b".."d")`, "true\n"}, + {`p (1.0..2.0).overlap?(1.5..3.0)`, "true\n"}, + {`p (1..5).overlap?("a".."z")`, "false\n"}, // incomparable bounds + {`p ("a".."z").overlap?(1..5)`, "false\n"}, + {`p (1..).overlap?("a".."z")`, "false\n"}, // endless self, incomparable + } + for _, c := range cases { + if got := eval(t, c.src); got != c.want { + t.Errorf("src=%q got=%q want=%q", c.src, got, c.want) + } + } + if err := runErr(t, `(1..5).overlap?(3)`); err == nil || + !strings.Contains(err.Error(), "wrong argument type Integer (expected Range)") { + t.Errorf("overlap?(non-Range): err=%v", err) + } +} diff --git a/scripts/conformance/rubyspec/FLOOR b/scripts/conformance/rubyspec/FLOOR index 064f584f..d32ab209 100644 --- a/scripts/conformance/rubyspec/FLOOR +++ b/scripts/conformance/rubyspec/FLOOR @@ -1 +1 @@ -15790 +15800