public abstract class KaSubtypingComponent : KaSessionComponent() {
    public abstract fun isEqualTo(first: KaType, second: KaType, errorTypePolicy: KaSubtypingErrorTypePolicy): Boolean
    public abstract fun isSubTypeOf(subType: KaType, superType: KaType, errorTypePolicy: KaSubtypingErrorTypePolicy): Boolean
}

public typealias KtSubtypingComponent = KaSubtypingComponent

public interface KaSubtypingComponentMixIn : KaSessionMixIn {

class SpecializedModelMapStrategyTest extends Specification {
    def store = new DefaultModelSchemaStore(DefaultModelSchemaExtractor.withDefaultStrategies())

    def "assembles schema for model map subtype"() {
        expect:
        def schema = store.getSchema(ModelType.of(SpecializedMap))
        schema instanceof SpecializedMapSchema
        schema.elementType == ModelType.of(String)

		clause := &clauses[i]
		for i := range accepted {
			accepts := &accepted[i]
			switch {
			case clause.Type == accepts.MediaTypeType && clause.SubType == accepts.MediaTypeSubType,
				clause.Type == accepts.MediaTypeType && clause.SubType == "*",
				clause.Type == "*" && clause.SubType == "*":
				if retVal, ret := acceptMediaTypeOptions(clause.Params, accepts, endpoint); ret {
					return retVal, true
				}
			}
		}
	}

   * Returns the value the specified class is mapped to, or {@code null} if no entry for this class
   * is present. This will only return a value that was bound to this specific class, not a value
   * that may have been bound to a subtype.
   *
   * <p>{@code getInstance(Foo.class)} is equivalent to {@code
   * getInstance(TypeToken.of(Foo.class))}.
   */
  @CheckForNull
  <T extends @NonNull B> T getInstance(Class<T> type);

  /**

   * Returns the value the specified class is mapped to, or {@code null} if no entry for this class
   * is present. This will only return a value that was bound to this specific class, not a value
   * that may have been bound to a subtype.
   *
   * <p>{@code getInstance(Foo.class)} is equivalent to {@code
   * getInstance(TypeToken.of(Foo.class))}.
   */
  @CheckForNull
  <T extends @NonNull B> T getInstance(Class<T> type);

  /**

            // error is unfortunate, but to properly type this, we'd need to be able to restrict `KotlinCompositeProvider<P>` to be a
            // subtype of `P`, which is not possible in Kotlin.
            @Suppress("UNCHECKED_CAST")
            when (provider) {
                is KotlinCompositeProvider<*> -> (provider as KotlinCompositeProvider<P>).providers

func (args *ReaderArgs) IsEmpty() bool {
	return !args.unmarshaled
}

// UnmarshalXML - decodes XML data.
func (args *ReaderArgs) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
	// Make subtype to avoid recursive UnmarshalXML().
	type subReaderArgs ReaderArgs
	parsedArgs := subReaderArgs{}
	if err := d.DecodeElement(&parsedArgs, &start); err != nil {
		return err
	}

	args.unmarshaled = true
	return nil

import org.gradle.api.Project;
import org.gradle.plugins.signing.signatory.Signatory;

/**
 * <p>Provides implementations of signatory implementations for a project.</p>
 *
 * @param <T> The specific {@link Signatory} subtype
 */
public interface BaseSignatoryProvider<T extends Signatory> {
    /**

 *
 * A composite provider should only contain providers of the same base type as the composite provider itself, so implementations of
 * [KotlinCompositeProvider] should always be a subtype of their type argument [P]. (This is not enforceable in the Kotlin type system.)
 */
public interface KotlinCompositeProvider<P : KotlinComposableProvider> : KotlinComposableProvider {
    public val providers: List<P>
}

import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import jnr.unixsocket.UnixSocket;
import jnr.unixsocket.UnixSocketAddress;
import jnr.unixsocket.UnixSocketChannel;

/**
 * Subtype UNIX socket for a higher-fidelity impersonation of TCP sockets. This is named "tunneling"
 * because it assumes the ultimate destination has a hostname and port.
 */
final class TunnelingUnixSocket extends UnixSocket {