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

// Issue 8745: comma-ok assignments should produce untyped bool as 2nd result.

package main

type mybool bool

func main() {
	var ok mybool
	_ = ok

	var i interface{}
	_, ok = i.(int)

	var m map[int]int
	_, ok = m[0]

	var c chan int
	_, ok = <-c

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

// Test that implicit conversions to interface type in a select/case
// clause are compiled correctly.

package main

import "fmt"

func main() { f[int]() }

func f[T any]() {
	ch := make(chan T)
	close(ch)

	var i, ok any
	select {
	case i, ok = <-ch:
	}

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

package runtime

func XTestSPWrite(t TestingT) {
	// Test that we can traceback from the stack check prologue of a function
	// that writes to SP. See #62326.

	// Start a goroutine to minimize the initial stack and ensure we grow the stack.
	done := make(chan bool)
	go func() {
		testSPWrite() // Defined in assembly
		done <- true

// compile

// Copyright 2009 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 main

type S struct {
	p *S;
	s []S;
	m map[int] S;
	c chan S;
	i interface { f(S); };
	f func(S) S;
}

func main() {
	var s S;
	s.p = &s;
	s.s = make([]S, 1);
	s.s[0] = s;
	s.m[0] = s;
	s.c <- s;
	s.i.f(s);

}

// XdsCache interface defines a store for caching XDS responses.
// All operations are thread safe.
type XdsCache interface {
	// Run starts a background thread to flush evicted indexes periodically.
	Run(stop <-chan struct{})
	// Add adds the given XdsCacheEntry with the value for the given pushContext to the cache.
	// If the cache has been updated to a newer push context, the write will be dropped silently.

// the stream is rejected. After the reply frame has been sent, replySent is closed.
type NewStreamHandler func(stream Stream, replySent <-chan struct{}) error

// NoOpNewStreamHandler is a stream handler that accepts a new stream and
// performs no other logic.
func NoOpNewStreamHandler(stream Stream, replySent <-chan struct{}) error { return nil }

// Dialer knows how to open a streaming connection to a server.
type Dialer interface {

	MeshWatcher       mesh.Watcher
	ServiceHandler    model.ServiceHandler
	ClusterID         cluster.ID
	WatchedNamespaces string
	DomainSuffix      string
	XDSUpdater        model.XDSUpdater
	Stop              chan struct{}
	SkipRun           bool
	ConfigCluster     bool
	SystemNamespace   string
}

type FakeController struct {
	*Controller
	Endpoints *model.EndpointIndex
}

func Test3() Foo { return make(tst3) }

type tst3 chan string

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

// Package sigchanyzer defines an Analyzer that detects
// misuse of unbuffered signal as argument to signal.Notify.
//
// # Analyzer sigchanyzer
//
// sigchanyzer: check for unbuffered channel of os.Signal
//
// This checker reports call expression of the form
//
//	signal.Notify(c <-chan os.Signal, sig ...os.Signal),
//

	defer imag(c) // ERROR "defer discards result of imag|is not used"
	defer len(x) // ERROR "defer discards result of len|is not used"
	defer make([]int, 1) // ERROR "defer discards result of make|is not used"
	defer make(chan bool) // ERROR "defer discards result of make|is not used"
	defer make(map[string]int) // ERROR "defer discards result of make|is not used"
	defer new(int) // ERROR "defer discards result of new|is not used"