# v2.0.0+incompatible by tag+incompatible
go get ...test@v2.0.0+incompatible
go list -m all
stdout '^github.com/rsc/legacytest v2\.0\.0\+incompatible$'

# v2.0.0+incompatible by tag
go get ...test@v2.0.0
go list -m all
stdout '^github.com/rsc/legacytest v2\.0\.0\+incompatible$'

# v2.0.0+incompatible by hash (back on master)
go get ...test@d7ae1e4
go list -m all
stdout '^github.com/rsc/legacytest v2\.0\.0\+incompatible$'

		"{m(); comparable}":             "{comparable; func (p.T).m()}",
		"{m1(); comparable; m2() int }": "{comparable; func (p.T).m1(); func (p.T).m2() int}",
		"{comparable; error}":           "{comparable; func (error).Error() string}",

		"{m(); comparable; int|float32|string}": "{func (p.T).m(); int | float32 | string}",
		"{m1(); int; m2(); comparable }":        "{func (p.T).m1(); func (p.T).m2(); int}",

# (But asking for exactly v2.0.0+incompatible should still succeed.)
go list -m github.com/russross/blackfriday@v2.0.0+incompatible
stdout '^github.com/russross/blackfriday v2\.0\.0\+incompatible$'


# However, if the latest compatible version does not include a go.mod file,
# +incompatible versions should still be listed, as they may still reflect the
# intent of the module author.

// Module lazy requires example.com/retract/incompatible v1.0.0.
//
// When viewed from the outside it also has a transitive dependency
// on v2.0.0+incompatible, but in lazy mode that transitive dependency
// is pruned out.
module example.net/lazy

go 1.17

exclude example.com/retract/incompatible v2.0.0+incompatible

require (
	example.com/retract/incompatible v1.0.0
	example.net/requireincompatible v0.1.0
)

    checkNotNull(left); // for GWT
    checkNotNull(right);
    return ((Comparable<Object>) left).compareTo(right);
  }

  @Override
  public <S extends Comparable<?>> Ordering<@Nullable S> nullsFirst() {
    Ordering<@Nullable Comparable<?>> result = nullsFirst;
    if (result == null) {
      result = nullsFirst = super.<Comparable<?>>nullsFirst();
    }
    return (Ordering<@Nullable S>) result;

// implicit conversions merit scrutiny
var s string
var bad1 string = 1  // ERROR "conver|incompatible|invalid|cannot"
var bad2 = s + 1     // ERROR "conver|incompatible|invalid|cannot"
var bad3 = s + 'a'   // ERROR "conver|incompatible|invalid|cannot"
var bad4 = "a" + 1   // ERROR "literals|incompatible|convert|invalid"
var bad5 = "a" + 'a' // ERROR "literals|incompatible|convert|invalid"

var bad6 int = 1.5       // ERROR "convert|truncate"

	c7 = c1 == c2 // ERROR "mismatched types|incompatible types"
	c8 = c2 == c6 // ERROR "mismatched types|incompatible types"
	c9 = c1 == c6 // ERROR "mismatched types|incompatible types"
	_ = c2 && (x < y)
	_ = c2 && (1 < 2)
	_ = c1 && c2 // ERROR "mismatched types|incompatible types"
	_ = c2 && c6 // ERROR "mismatched types|incompatible types"
	_ = c1 && c6 // ERROR "mismatched types|incompatible types"

func (*T) Mp() {}

var _ = []int{
	T.Mv,    // ERROR "cannot use T\.Mv|incompatible type"
	(*T).Mv, // ERROR "cannot use \(\*T\)\.Mv|incompatible type"
	(*T).Mp, // ERROR "cannot use \(\*T\)\.Mp|incompatible type"

	time.Time.GobEncode,    // ERROR "cannot use time\.Time\.GobEncode|incompatible type"
	(*time.Time).GobEncode, // ERROR "cannot use \(\*time\.Time\)\.GobEncode|incompatible type"

var x3 = b && b2    // ERROR "mismatched types B and B2|incompatible types"
var x4 = x1 && b2   // ERROR "mismatched types B and B2|incompatible types"
var x5 = x2 && b2   // ERROR "mismatched types B and B2|incompatible types"
var x6 = b2 && x1   // ERROR "mismatched types B2 and B|incompatible types"
var x7 = b2 && x2   // ERROR "mismatched types B2 and B|incompatible types"

// license that can be found in the LICENSE file.

package p

func f[_ comparable]() {}
func g[_ interface{interface{comparable; ~int|~string}}]() {}

func _[P comparable,
        Q interface{ comparable; ~int|~string },
        R any,                               // not comparable
        S interface{ comparable; ~func() },  // not comparable
]() {
        _ = f[int]
        _ = f[P]
        _ = f[Q]