// FILE: util11.kt
package my.pack

fun Any.myExt() {}

// FILE: util12.kt
package my.pack

val Any.myExt: Int get() = 10

// MODULE: dep2
// FILE: util21.kt
package my.pack

fun Any.myExt2() {}

// FILE: util22.kt
package my.pack

val Any.myExt2: Int get() = 10

// MODULE: main(dep1, dep2)
// FILE: usage.kt
package usage

import my.pack.myExt
import my.pack.myExt2

fun test(a: Any) {

// operation.

type myInt1 int
type myInt2 int

func _[T interface{ myInt1|myInt2; ~int }]() T { return T(0) }
func _[T interface{ ~int; myInt1|myInt2 }]() T { return T(0) }

// Here the intersections are empty - there's no type that's in the type set of T.
func _[T interface{ myInt1|myInt2; int }]() T { return T(0 /* ERROR "cannot convert" */ ) }
func _[T interface{ int; myInt1|myInt2 }]() T { return T(0 /* ERROR "cannot convert" */ ) }

                myExt.prop.get()
            }
        }

        task wrongRuntimeValueType {
            def myExt = project.extensions.getByType(MyExtension)
            doLast {
                myExt.prop = ['key': 123]
                myExt.prop.get()
            }
        }

        task wrongPropertyTypeDsl {
            def myExt = project.extensions.getByType(MyExtension)

			},
			expect: []string{`299 myagent "mytext"`},
		},
		{
			name: "multiple",
			args: []args{
				{agent: "", text: "mytext1"},
				{agent: "", text: "mytext2"},
				{agent: "", text: "mytext3"},
			},
			expect: []string{
				`299 - "mytext1"`,
				`299 - "mytext2"`,
				`299 - "mytext3"`,
			},
		},

		{
			name:   "invalid agent",
			args:   []args{{agent: "my agent", text: "mytext"}},
			expect: nil,

            tasks.register("mytask") {
                extensions.create("myext", MyExtension)
                myext.prop = "foobar"
                doLast {
                    println("myext.prop = " + myext.prop.get())
                }
            }
        """

        expect:
        succeeds("mytask")
        outputContains("myext.prop = foobar")
    }

type myT1 struct {
	localT
}

type myT2 struct {
	localT
	lib.T
}

type myT3 struct {
	lib.T
	localT
}

func main() {
	var i localI

	i = new(localT)
	if i.m() != "main.localT.m" {
		println("BUG: localT:", i.m(), "called")
	}

	i = new(myT1)
	if i.m() != "main.localT.m" {
		println("BUG: myT1:", i.m(), "called")
	}

	i = new(myT2)
	if i.m() != "main.localT.m" {

                Provider<String> getFoo() {
                    return other
                }
            }

            extensions.create("myext", MyExtension)
            myext {
                conventionMapping.map("foo", { project.provider { "foobar" } })
                other.convention("other")
            }
        """

        expect:
        runAndFail 'help'

                output = layout.buildDirectory.dir("producer")
            }

            def myExt = extensions.create("myExt", MyExt)
            myExt.artifactDir = producer.flatMap { it.output }

            tasks.register("consumer", Consumer) {
               fileNames = myExt.artifactDir.map {
                  it.asFileTree.collect { it.absolutePath }
               }.orElse([ "else" ])
            }

		makeInput: func() any {
			type (
				MyInt1 int
				MyInt2 int
				myInt  int
				s2     struct {
					MyInt2
					myInt
				}
				s1 struct {
					MyInt1
					myInt
					s2
				}
				S struct {
					s1
					myInt
				}
			)
			return S{s1{1, 2, s2{3, 4}}, 6}
		},
		want: `{"MyInt1":1,"MyInt2":3}`,
	}, {