chanWg <- true
		go func(i int) {
			data[i] = 42
			<-chanWg
		}(i)
	}
	for i := 0; i < cap(chanWg); i++ {
		chanWg <- true
	}
	for i := 0; i < N; i++ {
		_ = data[i]
	}
}

// Test that sender synchronizes with receiver even if the sender was blocked.
func TestNoRaceBlockedSendSync(t *testing.T) {
	c := make(chan *int, 1)
	c <- nil
	go func() {
		i := 42
		c <- &i
	}()

func Ranger[T any]() (*Sender[T], *Receiver[T]) {
	c := make(chan T)
	d := make(chan bool)
	s := &Sender[T]{values: c, done: d}
	r := &Receiver[T]{values: c, done: d}
	runtime.SetFinalizer(r, r.finalize)
	return s, r
}

// A sender is used to send values to a Receiver.
type Sender[T any] struct {
	values chan<- T
	done <-chan bool
}

// Send sends a value to the receiver. It returns whether any more

func Ranger[T any]() (*Sender[T], *Receiver[T]) {
	c := make(chan T)
	d := make(chan bool)
	s := &Sender[T]{values: c, done: d}
	r := &Receiver[T]{values: c, done: d}
	runtime.SetFinalizer(r, r.finalize)
	return s, r
}

// A sender is used to send values to a Receiver.
type Sender[T any] struct {
	values chan<- T
	done   <-chan bool
}

// Send sends a value to the receiver. It returns whether any more

func Ranger[T any]() (*Sender[T], *Receiver[T]) {
	c := make(chan T)
	d := make(chan bool)
	s := &Sender[T]{values: c, done: d}
	r := &Receiver[T]{values: c, done: d}
	runtime.SetFinalizer(r, r.finalize)
	return s, r
}

// A sender is used to send values to a Receiver.
type Sender[T any] struct {
	values chan<- T
	done <-chan bool
}

// Send sends a value to the receiver. It returns whether any more

// 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 chanbug
var C chan<- (chan int)
var D chan<- func()
var E func() chan int

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.execution.history.changes;

public interface Change {
    String getMessage();

 * limitations under the License.
 */

package org.gradle.nativeplatform.toolchain;

import org.gradle.api.Incubating;

/**
 * The <a href="http://clang.llvm.org">Clang</a> tool chain.
 */
@Incubating
public interface Clang extends GccCompatibleToolChain {

# Run manually to reformat a file:
# clang-format -i --style=file <file>
BasedOnStyle: Google

    id: informal-change
    attributes:
      label: "Informal Change"
      description: "Please also describe the change informally, as in a class teaching Go."
    validations:
      required: false

  - type: textarea
    id: go-backwards-compatiblity
    attributes:
      label: Is this change backward compatible?

const W = 2    // channel buffering
var h [N]int   // marking of send/recv

func r(c chan int, m int) {
	for {
		select {
		case r := <-c:
			if h[r] != 1 {
				println("r",
					"m=", m,
					"r=", r,
					"h=", h[r])
				panic("fail")
			}
			h[r] = 2
		}
	}
}

func s(c chan int) {
	for n := 0; n < N; n++ {
		r := n
		if h[r] != 0 {
			println("s")
			panic("fail")
		}