// compile

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 12536: compiler crashes while checking keys in a map literal for equality

package p

func main() {
	m1 := map[interface{}]interface{}{
		nil:  0,
		true: 1,
	}
	m2 := map[interface{}]interface{}{
		true: 1,
		nil:  0,
	}
	println(len(m1))

import java.net.URISyntaxException
import java.net.URL
import java.util.stream.Collectors

/**
 * Validates external plugins applied to a build, by checking property annotations
 * on work items like tasks and artifact transforms.
 * This is similar to [ValidatePlugins] but instead of checking the plugins *written in* the current build,
 * it checks the plugins *applied to* the current build.
 */
gradle.beforeProject {

	if err != nil {
		log.Fatal(err)
	}
	defer res.Body.Close()
}

func badHTTPGet() {
	res, err := http.Get("http://foo.com")
	defer res.Body.Close() // ERROR "using res before checking for errors"
	if err != nil {
		log.Fatal(err)
	}

// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

// Type checking the following code should not cause an infinite recursion.
func f[M map[K]int, K comparable](m M) {
        f(m)
}

// Equivalent code using mutual recursion.
func f1[M map[K]int, K comparable](m M) {
        f2(m)
}

// errorcheck

// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Checking that line number is correct in error message.

package main

type Cint int

func foobar(*Cint, Cint, Cint, *Cint)

func main() {
	a := Cint(1)

	foobar(
		&a,
		0,
		0,
		42, // ERROR ".*"
	)

[short] skip
[!git] skip

# golang.org/issue/33099: if an import path ends in a major-version suffix,
# ensure that 'direct' mode can resolve the package to the module.
# For a while, (*modfetch.codeRepo).Stat was not checking for a go.mod file,
# which would produce a hard error at the subsequent call to GoMod.

go get -v

-- go.mod --
module example.com
go 1.13

-- main.go --
package main

//  4. instantiated from a generic type
//
// In cases 1, 3, and 4, it is possible that the underlying type or methods of
// N may not be immediately available.
//  - During type-checking, we allocate N before type-checking its underlying
//    type or methods, so that we may resolve recursive references.
//  - When loading from export data, we may load its methods and underlying
//    type lazily using a provided load function.

// Package types2 declares the data types and implements
// the algorithms for type-checking of Go packages. Use
// Config.Check to invoke the type checker for a package.
// Alternatively, create a new type checker with NewChecker
// and invoke it incrementally by calling Checker.Files.
//
// Type-checking consists of several interdependent phases:
//

	if err == nil {
		syscall.Close(s)
		return true
	}
	if err != syscall.EPROTONOSUPPORT && err != syscall.EINVAL {
		// Something wrong with socket(), fall back to checking the kernel version.
		major, minor := KernelVersion()
		if runtime.GOOS == "illumos" {
			return major > 5 || (major == 5 && minor >= 11) // minimal requirement is SunOS 5.11
		}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

func main() {
	const fffd = "\uFFFD"

	// runtime.intstring used to convert int64 to rune without checking
	// for truncation.
	u := uint64(0x10001f4a9)
	big := string(u)
	if big != fffd {
		panic("big != bad")
	}

	// cmd/compile used to require integer constants to fit into an "int".
	const huge = string(1<<100)