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

package copylock

import "sync"

func BadFunc() {
	var x *sync.Mutex
	p := x
	var y sync.Mutex
	p = &y
	*p = *x // ERROR "assignment copies lock value to \*p: sync.Mutex"

                    recurseDeeper(it)
                    appendLine()
                }
                appendIndented(")")
            }

            is Assignment -> {
                append("Assignment [${source()}] (\n")
                appendNextIndented("lhs = ")
                recurseDeeper(current.lhs)
                appendLine()
                appendNextIndented("rhs = ")

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Marks interface that works with overloaded Kotlin assignment.
 *
 * @since 8.1
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface SupportsKotlinAssignmentOverloading {

// run

// Copyright 2016 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.

// Gccgo incorrectly rejected an assignment to multiple instances of
// the same variable.

package main

var a int

func F() {
	a, a, a = 1, 2, 3
}

func main() {
	F()
	if a != 3 {
		panic(a)
	}

// (they are element types of the func type and therefore must
// be identical to match).
// The result is an error from type inference, rather than an
// error from an assignment mismatch.

// compile

// 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.

// Issue 54638: composite literal assignment with
// alignment > PtrSize causes ICE.

package p

import "sync/atomic"

type S struct{ l any }

type T struct {
	H any
	a [14]int64
	f func()
	x atomic.Int64
}

//go:noinline
func (T) M(any) {}

// run

// Copyright 2013 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 4620: map indexes are not evaluated before assignment of other elements

package main

import "fmt"

func main() {
	m := map[int]int{0:1}
	i := 0
	i, m[i] = 1, 2
	if m[0] != 2 {
		fmt.Println(m)
		panic("m[i] != 2")
	}

// RUN: tf-opt -tf-simple-device-assignment='default-device=gpu' %s | FileCheck %s

// CHECK-LABEL: func @device_test
func.func @device_test(%arg0: tensor<3x1xf32>) -> (tensor<3x3xf32>) {

  // CHECK: device = "gpu"
  %0 = "tf.Const"() {value = dense<[[1.0, 2.0, 3.0]]> : tensor<1x3xf32>} : () -> tensor<1x3xf32>
  // CHECK: device = "gpu"

import org.gradle.api.file.ConfigurableFileCollection;
import org.gradle.api.provider.Property;
import org.gradle.internal.instantiation.generator.AsmBackedClassGenerator;

/**
 * An interface used to support lazy assignment for types like {@link Property} and {@link ConfigurableFileCollection} in Groovy DSL.
 * Call to this interface is generated via {@link AsmBackedClassGenerator}.
 */
public interface LazyGroovySupport {

    /**

// run

// 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.

// Issue 52953: miscompilation for composite literal assignment
// when LHS is address-taken.

package main

type T struct {
	Field1 bool
}

func main() {
	var ret T
	ret.Field1 = true
	var v *bool = &ret.Field1
	ret = T{Field1: *v}
	check(ret.Field1)