Range improvements

[thetechnick]

Fixes a range of range compare issues and improves error messages.

[erdii]

Found some issues. Here's a set of reproducers / regression tests to discuss.

./review_regression_test.go:

package semver

import (
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

// Bug: compactAndValidateLogicalAND merges adjacent ranges as a union
// (1-2 && 2-3 → 1-3) when AND semantics require intersection.
func TestANDCompaction_Check(t *testing.T) {
	t.Parallel()

	// Adjacent AND must not be compacted into a single Range.
	c, err := NewConstraint("1 - 2 && 2 - 3")
	require.NoError(t, err)
	oic := c.(*originalInputConstraint)
	_, isSingleRange := oic.Constraint.(*Range)
	assert.False(t, isSingleRange,
		"adjacent AND should not compact to a single Range (union); AND means intersection")

	tests := []struct {
		name       string
		constraint string
		version    string
		expected   bool
	}{
		// Adjacent ranges [1,2] ∩ [2,3] = {2.0.0}
		{"adjacent AND matches at boundary", "1 - 2 && 2 - 3", "2.0.0", true},
		{"adjacent AND rejects left-only version", "1 - 2 && 2 - 3", "1.5.0", false},
		{"adjacent AND rejects right-only version", "1 - 2 && 2 - 3", "2.5.0", false},
		{"adjacent AND rejects left boundary", "1 - 2 && 2 - 3", "1.0.0", false},
		{"adjacent AND rejects right boundary", "1 - 2 && 2 - 3", "3.0.0", false},
		{"adjacent AND rejects below both", "1 - 2 && 2 - 3", "0.5.0", false},
		{"adjacent AND rejects above both", "1 - 2 && 2 - 3", "3.5.0", false},

		// Overlapping ranges [1,3] ∩ [2,4] = [2,3]
		{"overlapping AND matches intersection start", "1.0.0 - 3.0.0 && 2.0.0 - 4.0.0", "2.0.0", true},
		{"overlapping AND matches intersection mid", "1.0.0 - 3.0.0 && 2.0.0 - 4.0.0", "2.5.0", true},
		{"overlapping AND matches intersection end", "1.0.0 - 3.0.0 && 2.0.0 - 4.0.0", "3.0.0", true},
		{"overlapping AND rejects left-only", "1.0.0 - 3.0.0 && 2.0.0 - 4.0.0", "1.5.0", false},
		{"overlapping AND rejects right-only", "1.0.0 - 3.0.0 && 2.0.0 - 4.0.0", "3.5.0", false},

		// Same range AND'd with itself
		{"identical AND matches inside", "1.0.0 - 2.0.0 && 1.0.0 - 2.0.0", "1.5.0", true},
		{"identical AND rejects outside", "1.0.0 - 2.0.0 && 1.0.0 - 2.0.0", "2.5.0", false},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			c, err := NewConstraint(tt.constraint)
			require.NoError(t, err)
			assert.Equal(t, tt.expected, c.Check(MustNewVersion(tt.version)))
		})
	}
}

// Bug: Contains() returns wrong results after union-based AND compaction.
func TestANDCompaction_Contains(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name     string
		rA       string
		rB       string
		expected bool
	}{
		{
			// [1,2] ∩ [2,3] = {2.0.0}, which does not contain [1,3].
			name:     "adjacent AND does not contain full union range",
			rA:       "2 - 3 && 1 - 2",
			rB:       "1 - 3",
			expected: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			assert.Equal(t, tt.expected,
				MustNewConstraint(tt.rA).Contains(MustNewConstraint(tt.rB)))
		})
	}
}

// Bug: not.Contains uses !other.Contains(&not.Range) which produces wrong
// results for not-vs-not comparisons. Also, and.coversConstraint falls back
// to String() comparison which breaks when semantically equivalent constraints
// have different string representations (e.g. !=2 vs !=2.0.0).
func TestNotContains(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name     string
		rA       string
		rB       string
		expected bool
	}{
		{
			// !=2 excludes all 2.x.x, !=2.0.0 excludes only 2.0.0.
			// (1-5 && !=2) is more restrictive — it should not contain (1-5 && !=2.0.0).
			name:     "wider exclusion does not contain narrower exclusion",
			rA:       "1 - 5 && !=2",
			rB:       "1 - 5 && !=2.0.0",
			expected: false,
		},
		{
			// Every version allowed by (1-5 && !=2) is also allowed by (1-5 && !=2.0.0).
			name:     "narrower exclusion contains wider exclusion",
			rA:       "1 - 5 && !=2.0.0",
			rB:       "1 - 5 && !=2",
			expected: true,
		},
		{
			// !=2.0.0 allows all versions except 2.0.0; !=2 allows all except 2.x.x.
			// Every version in !=2 is also in !=2.0.0.
			name:     "narrow not contains wide not",
			rA:       "!=2.0.0",
			rB:       "!=2",
			expected: true,
		},
		{
			// !=2.0.0 allows 2.1.0, but !=2 does not.
			name:     "wide not does not contain narrow not",
			rA:       "!=2",
			rB:       "!=2.0.0",
			expected: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			assert.Equal(t, tt.expected,
				MustNewConstraint(tt.rA).Contains(MustNewConstraint(tt.rB)))
		})
	}
}

// Bug: or.Contains checks each branch independently and misses cases where
// overlapping or adjacent branches together cover the queried constraint.
func TestORContains_OverlappingBranches(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name     string
		rA       string
		rB       string
		expected bool
	}{
		{
			// [1,3] ∪ [2,5] = [1,5], which contains [1,5].
			name:     "overlapping OR branches cover full range",
			rA:       "1 - 3 || 2 - 5",
			rB:       "1 - 5",
			expected: true,
		},
		{
			// [1,2] ∪ [2,3] = [1,3], which contains [1,3].
			name:     "adjacent OR branches cover full range",
			rA:       "1 - 2 || 2 - 3",
			rB:       "1 - 3",
			expected: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			assert.Equal(t, tt.expected,
				MustNewConstraint(tt.rA).Contains(MustNewConstraint(tt.rB)))
		})
	}
}

// Bug: over-constrained error messages have doubled position prefix
// ("col 16: AND col 16: ...") due to wrapping in parse() + validateNotOverConstrained.
func TestOverConstrainedErrorFormat(t *testing.T) {
	t.Parallel()

	_, err := NewConstraint("2 - 3 && 5 - 6 && 1 - 2")
	require.Error(t, err)
	assert.NotRegexp(t, `col \d+: AND col \d+:`, err.Error(),
		"error should not have doubled position prefix")
}