annotations:
        Anno
      $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Generic<T of <root>.Generic>
      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
      CONSTRUCTOR visibility:public <> () returnType:<root>.Generic<T of <root>.Generic> [primary]
        BLOCK_BODY
          DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in <root>.Ordinary'

                bar
                baz
                """
            )
        )
    }

    @Test
    fun `multiple generic extension targets`() {

        withBuildSrc {

            "src/main/kotlin" {
                withFile(
                    "types.kt",
                    """

                    package my

                doLast {
                    // Explicit SAM conversion
                    println(create("foo", NamedDomainObjectFactory<String> { it.toUpperCase() }))
                    // Explicit SAM conversion with generic type argument inference
                    println(create<String>("bar", NamedDomainObjectFactory { it.toUpperCase() }))
                    // Implicit SAM conversion

    if (descriptor is TypeAliasDescriptor) {
        descriptor = descriptor.classDescriptor
    }

    if (descriptor !is ClassDescriptor) {
        return null
    }

    // Generic non-array class literals are not supported in K1
    val typeArguments = descriptor.typeConstructor.parameters.map { StarProjectionImpl(it) }

(DIVVU x (MOVVconst [c])) && isPowerOfTwo64(c) => (SRLVconst [log64(c)] x)
(REMVU _ (MOVVconst [1])) => (MOVVconst [0])                       // mod
(REMVU x (MOVVconst [c])) && isPowerOfTwo64(c) => (ANDconst [c-1] x) // mod

// generic simplifications
(ADDV x (NEGV y)) => (SUBV x y)
(SUBV x x) => (MOVVconst [0])
(SUBV (MOVVconst [0]) x) => (NEGV x)
(AND x x) => x
(OR  x x) => x
(XOR x x) => (MOVVconst [0])

// remove redundant *const ops

(Select0 (DIVVU _ (MOVVconst [1]))) => (MOVVconst [0])                       // mod
(Select0 (DIVVU x (MOVVconst [c]))) && isPowerOfTwo64(c) => (ANDconst [c-1] x) // mod

// generic simplifications
(ADDV x (NEGV y)) => (SUBV x y)
(SUBV x x) => (MOVVconst [0])
(SUBV (MOVVconst [0]) x) => (NEGV x)
(AND x x) => x
(OR  x x) => x
(XOR x x) => (MOVVconst [0])

// remove redundant *const ops

                *23*
                *42*
                """
            )
        )
    }

    @Test
    @LeaksFileHandles("Kotlin Compiler Daemon working directory")
    fun `given generic extension types they can be accessed and configured`() {

        withDefaultSettingsIn("buildSrc")

        withFile(
            "buildSrc/build.gradle.kts",
            """

            plugins {

// 8 and 128 are magic constants, see runtime/mkduff.go
(Zero [s] {t} ptr mem)
	&& s%8 == 0 && s <= 8*128
	&& t.Alignment()%8 == 0 && !config.noDuffDevice =>
	(DUFFZERO [8 * (128 - s/8)] ptr mem)

// Generic zeroing uses a loop
(Zero [s] {t} ptr mem) =>
	(LoweredZero [t.Alignment()]
		ptr
		(ADD <ptr.Type> ptr (MOVDconst [s-moveSize(t.Alignment(), config)]))
		mem)

// Checks
(IsNonNil ...) => (SNEZ ...)

Preamble

The licenses for most software are designed to take away your freedom to
share and change it. By contrast, the GNU General Public License is
intended to guarantee your freedom to share and change free software--to
make sure the software is free for all its users. This General Public
License applies to most of the Free Software Foundation's software and
to any other program whose authors commit to using it. (Some other Free

# Gradle Javadoc Style Guide

## 1.1 Formatting

### 1.1.1 General form

The basic formatting of Javadoc blocks is as seen in this example:

```java
/**
 * Returns an Image object that can then be painted on the screen.
 * <p>
 * The url argument must specify an absolute {@link URL}. 
 * The name argument is a specifier that is relative to the url argument.
 * This method always returns immediately, whether or not the image exists. 
 *