externalFunctions = listOf(::newD),
    defaultImports = listOf(DefaultFqName("com.example", "newD"))
)


object SimpleAnalysisDemo {
    @JvmStatic
    fun main(args: Array<String>) {
        printResolutionResults(
            schema.resolve(
                """
                    val myB = b()

                    a = myB
                    val myD = newD("shared")

                    val c1 = c(1)

}


class C(var x: Int = 0) {
    @Builder
    fun d(newD: D): C {
        this.d = newD
        return this
    }

    @get:Restricted
    var d: D = D()

    @get:Restricted
    val y = "test"

    @Restricted
    fun f(y: String) = 0
}


class D {
    @get:Restricted
    var id: String = "none"
}

import org.gradle.internal.declarativedsl.demo.resolve


object AssignmentResolverDemo {
    @JvmStatic
    fun main(args: Array<String>) {
        val resolution = schema.resolve(
            """
            val myD = newD("shared")

            val c1 = c(1)
            c1.d = myD
            str = c1.d.id
            """.trimIndent()
        )
        printResolutionResults(resolution)
        printResolvedAssignments(resolution)

package com.example


fun Abc.body() {
    val myB = b()

    a = myB
    val myD = newD("shared")

    c(1) {
        x = f(y)
        d = myD
    }
    c(2) {
        x = f("another test")
        d = myD
    }
}


object Main {
    @JvmStatic
    fun main(args: Array<String>) {
        val receiver = Abc()
        receiver.body()

import kotlin.test.assertIs


object AssignmentResolverTest {
    @Test
    fun `resolves transitive property`() {
        assignmentTrace(
            schema.resolve(
                """
                val myD = newD("shared")
                val c1 = c(1)
                c1.d = myD
                str = c1.d.id
                """.trimIndent()
            )
        ).run {

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

package a0

type Builder[T any] struct{}

func (r Builder[T]) New1() T {
	var v T
	return v
}

func (r Builder[T]) New2() T {
	var v T
	return v
}

type IntBuilder struct{}

func (b IntBuilder) New() int {
	return Builder[int]{}.New2()

			t.Errorf("2nd unmarshal error: %v", err)
		}
		if !bytes.Equal(data, newData) {
			t.Errorf("%s: re-marshaled data differs from original: %v %v", k, data, newData)
		}
		if !reflect.DeepEqual(tc.orig, new1) {
			t.Errorf("%s: unmarshaled struct differs from original: %v %v", k, tc.orig, new1)
		}
		if !reflect.DeepEqual(new1, new2) {

	newN := n * 2                         // make it at most 50% full
	newN = 1 << sys.Len64(uint64(newN-1)) // round up to a power of 2

	// Allocate the new table.
	newSize := unsafe.Sizeof(abi.TypeAssertCache{}) + uintptr(newN-1)*unsafe.Sizeof(abi.TypeAssertCacheEntry{})
	newC := (*abi.TypeAssertCache)(mallocgc(newSize, nil, true))
	newC.Mask = uintptr(newN - 1)

	if err := DB.Exec("UPDATE named_users SET name1 = @name, name2 = @name2, name3 = @name", sql.Named("name", "jinzhu-new"), sql.Named("name2", "jinzhu-new2")).Error; err != nil {
		t.Errorf("failed to update with named arg")
	}

	namedUser.Name1 = "jinzhu-new"
	namedUser.Name2 = "jinzhu-new2"
	namedUser.Name3 = "jinzhu-new"

	var result5 NamedUser

	DB.Model(&product).Updates(map[string]interface{}{"Name": "Product New"})

	if product.Name != "Product New" || product.Price != 160 || product.Code != "L1212" {
		t.Errorf("invalid data after update, got %+v", product)
	}

	// Code changed, but not selected, price should not change
	DB.Model(&product).Select("Name", "Price").Updates(map[string]interface{}{"Name": "Product New2", "code": "L1213"})