}

    @Override
    public void add(String name, Object extension) {
        if (extension instanceof Class) {
            create(name, (Class<?>) extension);
        } else {
            addWithDefaultPublicType(name, extension);
        }
    }

    @Override
    public <T> void add(Class<T> publicType, String name, T extension) {
        add(typeOf(publicType), name, extension);
    }

    @Override

 * @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) {

      if (byteCount > length) writeContinuationFrames(streamId, byteCount - length)
    }
  }

  @Throws(IOException::class)
  fun flush() {
    this.withLock {
      if (closed) throw IOException("closed")
      sink.flush()
    }
  }

  @Throws(IOException::class)
  fun rstStream(
    streamId: Int,
    errorCode: ErrorCode,
  ) {
    this.withLock {

            return false;
        }
    }

    private boolean isInnerClass(Class<?> klass) {
        return klass.getEnclosingClass() != null && !Modifier.isStatic(klass.getModifiers());
    }

    private Class<?> loadClass(String className) {
        try {
            return Class.forName(className, false, junitClassLoader);
        } catch (ClassNotFoundException e) {

            import org.gradle.api.provider.ListProperty;
            import org.gradle.api.provider.Property;
            import ${SoftwareType.class.name};

            public abstract class RestrictedPlugin implements Plugin<Project> {
                @SoftwareType(name = "restricted", modelPublicType = Extension.class)
                public abstract Extension getRestricted();

                @Override

}

/**
 * A delegated call to constructors. For example
 * ```
 * open class SuperClass(i: Int)
 * class SubClass1: SuperClass(1) // a call to constructor of `SuperClass` with single argument `1`
 * class SubClass2 : SuperClass {
 *   constructor(i: Int): super(i) {} // a call to constructor of `SuperClass` with single argument `i`

        then:
        javaClassFile("compile/test/Person.class").exists()
        javaClassFile("compile/test/Person2.class").exists()
    }

    @Issue("https://github.com/gradle/gradle/issues/5750")
    def "include narrows down source files to compile"() {
        given:
        goodCode()

        and:
        file('src/main/java/Bar.java') << 'class Bar {}'
        buildFile << 'compileJava.include "**/Person*.java"'

        }
    }

    private abstract class RegistrationHierarchyVisitor<S> implements TypeVisitor<S> {
        @Override
        public TypeVisitResult visitType(Class<? super S> type) {
            if (!baseInterface.getConcreteClass().isAssignableFrom(type)) {
                return TypeVisitResult.CONTINUE;
            }

            return instantiator.newInstance(DefaultPluginManagementSpec.class, pluginRepositoryHandlerProvider, internalPluginResolutionStrategy, fileResolver, buildIncluder);
        }
    }

    private static class BuildScopeServices implements ServiceRegistrationProvider {
        void configure(ServiceRegistration registration) {
            registration.add(PluginResolverFactory.class);

  //                 suite.addTest((TestSuite) suiteOrClass);
  //             else if (suiteOrClass instanceof Class)
  //                 suite.addTest(new TestSuite((Class<?>) suiteOrClass));
  //             else
  //                 throw new ClassCastException("not a test suite or class");
  //         }
  //         return suite;
  //     }

  //     /**