use(t3 == t3) // ERROR "struct|expected|cannot compare"
	use(t4 == t4) // ERROR "cannot be compared|non-comparable|cannot compare"

	// Slices, functions, and maps too.
	var x []int
	var f func()
	var m map[int]int
	use(x == x) // ERROR "slice can only be compared to nil|cannot compare"
	use(f == f) // ERROR "func can only be compared to nil|cannot compare"
	use(m == m) // ERROR "map can only be compared to nil|cannot compare"

	switch m {
	case nil:
	case m1: // ERROR "can only compare map m to nil|map can only be compared to nil|cannot compare"
	default:
	}

	var a, a1 []int
	switch a {
	case nil:
	case a1: // ERROR "can only compare slice a to nil|slice can only be compared to nil|cannot compare"
	default:
	}

	var f, f1 func()
	switch f {
	case nil:
	case f1: // ERROR "can only compare func f to nil|func can only be compared to nil|cannot compare"

	// issue #28164
	// testcase from issue
	_ = interface{}(nil) == [ /* ERROR "slice can only be compared to nil" */ ]int(nil)

	// related cases
	var e interface{}
	var s []int
	var x int
	_ = e == s // ERROR "slice can only be compared to nil"
	_ = s /* ERROR "slice can only be compared to nil" */ == e
	_ = e /* ERROR "operator < not defined on interface" */ < x

            while (true) {
                K previousProperty = previousEntry.getKey();
                K currentProperty = currentEntry.getKey();
                int compared = comparator.compare(previousProperty, currentProperty);
                if (compared < 0) {
                    if (!diffListener.removed(previousProperty)) {
                        return false;
                    }

	_ = b == b
	_ = a /* ERROR "[10]func() cannot be compared" */ == a
	_ = l /* ERROR "slice can only be compared to nil" */ == l
	_ = s /* ERROR "struct containing []byte cannot be compared" */ == s
	_ = p == p
	_ = f /* ERROR "func can only be compared to nil" */ == f
	_ = i == i
	_ = m /* ERROR "map can only be compared to nil" */ == m
	_ = c == c

	_ = b == nil /* ERROR "mismatched types" */

	things []string
}

type thing2 struct {
	things []thing1
}

func _() {
	var a1, b1 thing1
	_ = a1 /* ERROR "struct containing []string cannot be compared" */ == b1

	var a2, b2 thing2
	_ = a2 /* ERROR "struct containing []thing1 cannot be compared" */ == b2

 */

package org.gradle.api.tasks;

/**
 * Normalizes file input that represents a Java compile classpath.
 *
 * Compared to the default behavior this normalizer keeps the order of any root files,
 * but ignores the order and timestamps of files in directories and ZIP/JAR files.
 * Compared to {@link ClasspathNormalizer} this normalizer only snapshots the ABIs of class files,
 * and ignores any non-class resource.
 *

// Values are compared using ==.
func Equal[M1, M2 ~map[K]V, K, V comparable](m1 M1, m2 M2) bool {
	if len(m1) != len(m2) {
		return false
	}
	for k, v1 := range m1 {
		if v2, ok := m2[k]; !ok || v1 != v2 {
			return false
		}
	}
	return true
}

// EqualFunc is like Equal, but compares values using eq.
// Keys are still compared with ==.

	case a: // no follow-on error here
	}

	// this is ok because f can be compared to nil
	var f func()
	switch f {
	}

	switch f {
	case nil:
	}

	switch (func())(nil) {
	case nil:
	}

	switch (func())(nil) {
	case f /* ERRORx `invalid case f in switch on .* \(func can only be compared to nil\)` */ :
	}

	switch nil /* ERROR "use of untyped nil in switch expression" */ {
	}

        }
    }

    static <T> ChildMap<T> childMap(CaseSensitivity caseSensitivity, ChildMap.Entry<T> entry1, ChildMap.Entry<T> entry2) {
        int compared = PathUtil.getPathComparator(caseSensitivity).compare(entry1.getPath(), entry2.getPath());
        List<ChildMap.Entry<T>> sortedEntries = compared < 0
            ? ImmutableList.of(entry1, entry2)
            : ImmutableList.of(entry2, entry1);
        return childMapFromSorted(sortedEntries);