// report a hash collision. The linker can (and actually does)
// dedup the two symbols, by keeping the larger symbol. The dedup
// is not a requirement for correctness and not checked in this test.
// We do check the emitted symbol contents are correct, though.

package main

func main() {
	F([10]int{1, 2, 3, 4, 5, 6}, [20]int{1, 2, 3, 4, 5, 6})
}

//go:noinline

	// mutually recursive constraints
	T5 /* ERROR "invalid recursive type" */ [P T6[P]] interface{ int }
	T6[P T5[P]] interface{ int }
)

// verify that constraints are checked as expected
var (
	_ T1[int]
	_ T2[int, string]
	_ T3[int, string]
)

// test case from issue

type Eq /* ERROR "invalid recursive type" */ [a Eq[a]] interface {
	Equal(that a) bool

# Regression test for Issue #62663: we would filter out the toolchain and
# main modules from the build list incorrectly, leading to the workspace
# modules being checked for correct sums. Specifically this would happen when
# the module name sorted after the virtual 'go' version module name because
# it could not get chopped off when we removed the MainModules.Len() modules
# at the beginning of the build list and we would remove the go module instead.

go mod verify

//
// This check ensures that each method whose name matches one of several
// well-known interface methods from the standard library has the correct
// signature for that interface.
//
// Checked method names include:
//
//	Format GobEncode GobDecode MarshalJSON MarshalXML
//	Peek ReadByte ReadFrom ReadRune Scan Seek
//	UnmarshalJSON UnreadByte UnreadRune WriteByte
//	WriteTo

   * <ul>
   *   <li>All visible static methods are checked such that passing null for any parameter that's
   *       not annotated nullable (according to the rules of {@link NullPointerTester}) should throw
   *       {@link NullPointerException}.
   *   <li>If there is any visible constructor or visible static factory method declared by the
   *       class, all visible instance methods will be checked too using the instance created by

	checkId(16, tWireType)
	checkId(17, mustGetTypeInfo(reflect.TypeFor[arrayType]()).id)
	checkId(18, mustGetTypeInfo(reflect.TypeFor[CommonType]()).id)
	checkId(19, mustGetTypeInfo(reflect.TypeFor[sliceType]()).id)
	checkId(20, mustGetTypeInfo(reflect.TypeFor[structType]()).id)
	checkId(21, mustGetTypeInfo(reflect.TypeFor[fieldType]()).id)
	checkId(23, mustGetTypeInfo(reflect.TypeFor[mapType]()).id)

 */
@FunctionalInterface
public interface MavenPluginPrerequisitesChecker extends Consumer<PluginDescriptor> {
    /**
     *
     * @param pluginDescriptor
     * @throws IllegalStateException in case the checked prerequisites are not met
     */
    void accept(PluginDescriptor pluginDescriptor);

// Benchmark for accessing Value values.

package slog

import (
	"testing"
	"time"
)

// The "As" form is the slowest.
// The switch-panic and visitor times are almost the same.
// BenchmarkDispatch/switch-checked-8         	 8669427	       137.7 ns/op
// BenchmarkDispatch/As-8                     	 8212087	       145.3 ns/op
// BenchmarkDispatch/Visit-8                  	 8926146	       135.3 ns/op
func BenchmarkDispatch(b *testing.B) {

	"sync/atomic"
)

// Type-checking Named types is subtle, because they may be recursively
// defined, and because their full details may be spread across multiple
// declarations (via methods). For this reason they are type-checked lazily,
// to avoid information being accessed before it is complete.
//
// Conceptually, it is helpful to think of named types as having two distinct
// sets of information:

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs;


import java.io.IOException;


/**
 * Base for all checked exceptions used by this library
 * 
 * @author mbechler
 *
 */
public class CIFSException extends IOException {

    /**
     * 
     */