@SuppressWarnings("unchecked") Class<T> clazz = (Class<T>) instance.getClass();
        return of(clazz);
    }

    public static ModelType<?> of(Type type) {
        return Simple.typed(type);
    }

    /**
     * Returns true if this type represents a class.
     */
    public boolean isClass() {
        return wrapper instanceof ClassTypeWrapper;
    }

2.1-lifecycle-refactor-class-diagram.png...

    @Override
    public <P extends Plugin> P addImperativePlugin(PluginImplementation<P> plugin) {
        doApply(plugin);
        Class<? extends P> pluginClass = plugin.asClass();
        return pluginClass.cast(instances.get(pluginClass));
    }

    @Override
    public <P extends Plugin> P addImperativePlugin(Class<P> type) {
        return addImperativePlugin(pluginRegistry.inspect(type));
    }

            assert jar.getJarEntry('org/gradle/MyClass.class')
            assert jar.getJarEntry('java/lang/String.class')
            assert jar.getJarEntry('javax/inject/Inject.class')
            assert jar.getJarEntry('groovy/util/XmlSlurper.class')
            assert jar.getJarEntry('groovyjarjarantlr/TokenStream.class')
            assert jar.getJarEntry('net/rubygrapefruit/platform/FileInfo.class')

import org.gradle.declarative.dsl.model.annotations.Restricted


class MyClass {
    @get:Restricted
    lateinit var my: MyClass
}


class TopLevel {
    @Adding
    fun my1(): MyClass = MyClass()

    @Adding
    fun my2(): MyClass = MyClass()

    @Adding
    fun my(configure: MyClass.() -> Unit) = MyClass().also(configure)

        assertWatchableHierarchies([ImmutableSet.of(consumer, includedBuild)] * expectedWatchableCount)
        when:
        includedBuild.file("src/main/java/NewClass.java")  << "public class NewClass {}"
        withWatchFs().run("assemble")
        then:
        executedAndNotSkipped(":includedBuild:jar")
    }

    def "works with GradleBuild task"() {

 * @since 3.5
 */
public abstract class TypeOf<T> {

    /**
     * Creates an instance of {@literal TypeOf} for the given {@literal Class}.
     *
     * @param type the {@literal Class}
     * @param <T> the parameterized type of the given {@literal Class}
     * @return the {@literal TypeOf} that captures the generic type of the given {@literal Class}
     */
    public static <T> TypeOf<T> typeOf(Class<T> type) {

  @Nested
  @TestMetadata("analysis/analysis-api/testData/components/resolver/singleByPsi/arrayAccess")
  @TestDataPath("$PROJECT_ROOT")
  public class ArrayAccess {
    @Test
    public void testAllFilesPresentInArrayAccess() {
      KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/resolver/singleByPsi/arrayAccess"), Pattern.compile("^(.+)\\.kts$"), null, true);
    }

    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/dataFlowInfoProvider/exitPointSnapshot"), Pattern.compile("^(.+)\\.kts$"), null, true);
  }

  @Nested
  @TestMetadata("analysis/analysis-api/testData/components/dataFlowInfoProvider/exitPointSnapshot/controlFlow")
  @TestDataPath("$PROJECT_ROOT")
  public class ControlFlow {
    @Test

    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/dataFlowInfoProvider/exitPointSnapshot"), Pattern.compile("^(.+)\\.kts$"), null, true);
  }

  @Nested
  @TestMetadata("analysis/analysis-api/testData/components/dataFlowInfoProvider/exitPointSnapshot/controlFlow")
  @TestDataPath("$PROJECT_ROOT")
  public class ControlFlow {
    @Test