import java.lang.annotation.Target;

/**
 * Attached to a listener interface to indicate which scope its events are generated in.
 *
 * <p>Events generated in a particular scope are visible to listeners in the same scope and ancestor scopes.
 * Events are not visible to listeners in descendent scopes.
 *
 * <p>This annotation is used primarily to indicate to developers the scopes where this listener are available. There is also

 * Services are lifecycled with their scope, and stopped/closed when the scope is closed.
 * <p>
 * Services are visible to other services in the same scope and descendent scopes.
 * Services are not visible to services in ancestor scopes.
 * <p>
 * When a service is defined in multiple scopes, the highest scope determines the visibility.
 * The additional instances of the service in lower scopes "override" the instance from the parent

<component name="ProjectDictionaryState">
  <dictionary name="Nikolay.Krasko">
    <words>
      <w>accessors</w>
      <w>codeowners</w>
      <w>coroutines</w>
      <w>crossinline</w>
      <w>fqname</w>
      <w>goto</w>
      <w>gradle</w>
      <w>infos</w>
      <w>intrinsics</w>
      <w>kdoc</w>
      <w>lateinit</w>
      <w>memoize</w>
      <w>memoized</w>
      <w>multiline</w>
      <w>navigatable</w>

            file("project-b/src/main/kotlin/my-plugin-b.gradle.kts"),
            [dependencyB] as Set,
            [dependencyA] as Set
        )
    }

    def "implicit imports include type-safe accessors packages"() {

        given:
        withDefaultSettings()
        withBuildScript("""
            plugins {
                `kotlin-dsl`
            }

            $repositoriesBlock

}

func newCachingAuthorizer(in authorizer.Authorizer) authorizer.Authorizer {
	return &cachingAuthorizer{
		authorizer: in,
		decisions:  make(map[string]authzResult),
	}
}

// The attribute accessors known to cache key construction. If this fails to compile, the cache
// implementation may need to be updated.
var _ authorizer.Attributes = (interface {
	GetUser() user.Info
	GetVerb() string
	IsReadOnly() bool

	return t[x.ID].parent
}

// IsAncestorEq reports whether x is an ancestor of or equal to y.
func (t SparseTree) IsAncestorEq(x, y *Block) bool {
	if x == y {
		return true
	}
	xx := &t[x.ID]
	yy := &t[y.ID]
	return xx.entry <= yy.entry && yy.exit <= xx.exit
}

// isAncestor reports whether x is a strict ancestor of y.
func (t SparseTree) isAncestor(x, y *Block) bool {
	if x == y {
		return false

@LeaksFileHandles("Kotlin Compiler Daemon working directory")
class PrecompiledScriptPluginAccessorDeprecationWarningsTest : AbstractPrecompiledScriptPluginTest() {

    @Test
    fun `generated type-safe accessors suppress deprecation warnings`() {
        // `java-gradle-plugin` adds deprecated task `ValidateTaskProperties`
        givenPrecompiledKotlinScript(
            "java-project.gradle.kts",
            """

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.kotlin.dsl.accessors

import org.gradle.api.reflect.TypeOf
import org.gradle.kotlin.dsl.internal.sharedruntime.codegen.primitiveTypeStrings


internal
fun kotlinTypeStringFor(type: TypeOf<*>): String = type.run {
    when {

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.kotlin.dsl.accessors

import org.gradle.api.plugins.ExtensionAware

import org.gradle.kotlin.dsl.extra


internal
inline fun <reified T : Any> ExtensionAware.getOrCreateProperty(
    property: String,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import gradlebuild.basics.accessors.kotlinMainSourceSet
import gradlebuild.kotlindsl.generator.tasks.GenerateKotlinDslPluginsExtensions

plugins {
    java
}

val generatedSourcesDir = layout.buildDirectory.dir("generated-sources/kotlin")