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_;
};

$range i 2..n
$for i [[
$range j 1..i

template <$for j, [[typename T$j]]>
class ValueArray$i {
 public:

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_;
};

$range i 2..n
$for i [[
$range j 1..i

template <$for j, [[typename T$j]]>
class ValueArray$i {
 public:

 */

package org.gradle.buildinit.plugins.internal;

import org.gradle.api.Action;

import javax.annotation.Nullable;

public interface ScriptBlockBuilder {
    /**
     * Adds a property assignment statement to this block
     */
    void propertyAssignment(@Nullable String comment, String propertyName, Object propertyValue, boolean assignOperator);

    /**
     * Adds a method invocation statement to this block

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

package P

const a = 0;

func f(a int) {
	a = 0;
}

/*
bug161.go:8: operation LITERAL not allowed in assignment context

type T2[P any] struct {
	f struct {
		g P
	}
}

var x1 T1[struct{ g int }]
var x2 T2[int]

func _() {
	// This assignment is invalid because the types of x1, x2 are T1(...)
	// and T2(...) respectively, which are two different defined types.
	x1 = x2 // ERROR "assignment"

	// This assignment is valid because the types of x1.f and x2.f are
	// both struct { g int }; the type parameters act like type aliases

// This file contains tests for the atomic checker.

package atomic

import "sync/atomic"

func AtomicTests() {
	x := uint64(1)
	x = atomic.AddUint64(&x, 1) // ERROR "direct assignment to atomic value"

}

func _[P struct{ x int }]() {
	var x struct{ x int }
	type A = P
	var _ A = x // assignment must be valid
}

func _[P struct{ x int }]() {
	type A = P
	var x A
	var _ struct{ x int } = x // assignment must be valid
}

func _[P []int | struct{}]() {
	type A = []int
	var a A
	var p P

// Verify that we get "use of .(type) outside type switch"
// before any other (misleading) errors. Test case from issue.

package p

func f(i interface{}) {
	if x, ok := i.(type); ok { // ERROR "assignment mismatch|outside type switch"
		_ = x
	}

package main

const c = 1;

func main() {
	c := 0;
	_ = c;
}

/*
bug144.go:8: left side of := must be a name
bug144.go:8: operation LITERAL not allowed in assignment context
bug144.go:8: illegal types for operand: AS
	ideal
	int

  }

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

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