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:

}

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

  }

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

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

  }

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

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

  }

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

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

    public object Read : KaSimpleVariableAccess()

    public class Write(
        /**
         * [KtExpression] that represents the new value that should be assigned to this variable. Or null if the assignment is incomplete
         * and misses the new value.
         */
        public val value: KtExpression?,
    ) : KaSimpleVariableAccess()

  }

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

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

)

// Various more complex expressions
var (
	u1 = x /* ERROR "not an interface" */ .(int)
	u2 = iface.([]int)
	u3 = iface.(a /* ERROR "not a type" */ )
	u4, ok = iface.(int)
	u5, ok2, ok3 = iface /* ERROR "assignment mismatch" */ .(int)
)

// Constant expression initializations
var (
	v1 = 1 /* ERROR "mismatched types untyped int and untyped string" */ + "foo"
	v2 = c + 255
	v3 = c + 256 /* ERROR "overflows" */

            assertIs<ObjectOrigin.ConstantOrigin>(valueOrigin)
            assertEquals("shared", valueOrigin.literal.value)
        }
    }

    @Test
    fun `reports assignment pointing to unassigned property`() {
        assignmentTrace(
            schema.resolve(
                """
                val c1 = c(1) { }
                val c2 = c(2) { }
                c2.d = c1.d

                        } else {
                            // We should never come across a situation where an assignment already exists that is in a higher generation,
                            // but if we do, just pull the emergency stop handle as this is indicative of a bug rather than a user error.
                            error("Unexpected assignment in higher generation")
                        }
                    }