class ValueArray1 {
 public:
  explicit ValueArray1(T1 v1) : v1_(v1) {}

  template <typename T>
  operator ParamGenerator<T>() const { return ValuesIn(&v1_, &v1_ + 1); }

 private:
  // No implementation - assignment is unsupported.
  void operator=(const ValueArray1& other);

  const T1 v1_;
};

template <typename T1, typename T2>
class ValueArray2 {
 public:
  ValueArray2(T1 v1, T2 v2) : v1_(v1), v2_(v2) {}

object ConventionsResolutionProcessor {
    fun process(resolutionResult: ResolutionResult): Map<String, SoftwareTypeConventionResolutionResults> {
        val assignments = resolutionResult.assignments.groupBy { assignment ->
            getSoftwareType(assignment.lhs.receiverObject).function.simpleName
        }
        val additions = resolutionResult.additions.groupBy { addition ->
            getSoftwareType(addition.container).function.simpleName
        }

package main

func main() {
	c := make(chan int);
	ok := false;
	var i int;
	
	i, ok = <-c;  // works
	_, _ = i, ok;
	
	ca := new([2]chan int);
	i, ok = <-(ca[0]);  // fails: c.go:11: bad shape across assignment - cr=1 cl=2
	_, _ = i, ok;

  }

  @Test
  @TestMetadata("assignment.kt")
  public void testAssignment() {
    runTest("analysis/analysis-api/testData/components/expressionInfoProvider/readWriteAccess/assignment.kt");
  }

  @Test
  @TestMetadata("assignmentPlusEq.kt")
  public void testAssignmentPlusEq() {

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

// Issue 3899: 8g incorrectly thinks a variable is
// "set and not used" and elides an assignment, causing
// variables to end up with wrong data.
//
// The reason is a miscalculation of variable width.

package main

func bar(f func()) {
	f()
}

func foo() {
	f := func() {}
	if f == nil {

// using the sync/atomic package.
//
// # Analyzer atomic
//
// atomic: check for common mistakes using the sync/atomic package
//
// The atomic checker looks for assignment statements of the form:
//
//	x = atomic.AddUint64(&x, 1)
//
// which are not atomic.

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

package p

func f[P ~*T, T any]() {
	var p P
	var tp *T
	tp = p // this assignment is valid
	_ = tp

                    )
                )
            )""".trimIndent()
        parse(code).assert(expected)
    }

    @Test
    fun `missing assignment in one of a series of assignments`() {
        val code = """
            val a = 1
            val b = 2
            val c 3
            val d = 4
            val e = 5
        """.trimIndent()

        "max-line-length": {
            "options": [160]
        },
        "arrow-parens": false,
        "new-parens": true,
        "no-arg": true,
        "no-bitwise": true,
        "no-conditional-assignment": true,
        "no-consecutive-blank-lines": true,
        "no-console": {
            "severity": "warning",
            "options": ["debug", "info", "log", "time", "timeEnd", "trace"]
        },

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