import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion

/**
 * Type substitutor. Performs substitution of a type parameters inside a type to some fixed type.
 * Usually can be represented as a map from type parameter to it corresponding substitution.
 *
 * Example of a substitution:
 * ```
 * substitutor = { T -> Int, S -> Long }
 * substitute(Map<T, S>, substitutor) = Map<Int, Long>
 * ```
 *

    }

    /**
     * Perform single parameter substitution before logging the message of level
     * WARN according to the format outlined above.
     */
    @Override
    public void warn(String format, Object arg) {
        super.warn(format, arg);
        logLevelRecorder.record(Level.WARN);
    }

    /**
     * Perform double parameter substitution before logging the message of level

import org.jetbrains.kotlin.analysis.api.types.KaSubstitutor
import org.jetbrains.kotlin.analysis.api.types.KaType
import org.jetbrains.kotlin.fir.resolve.substitution.ChainedSubstitutor
import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutorByMap

internal abstract class AbstractKaFirSubstitutor<T : ConeSubstitutor>(
    val substitutor: T,

        settingsFile << """
            dependencyResolutionManagement {
                repositories.maven { url "${mavenRepo.uri}" }
            }
            includeBuild '.' // enable global substitution for this build
            include 'm1', 'm2', 'm3'
        """

        buildFile << """
            allprojects {
                group = 'org.test'
                version = '0.9'

 * The interceptors are substituted per-thread because other threads may be executing unrelated tests.
 */
abstract class TestInterceptorsSubstitution<T> {
    private final T substitution

    TestInterceptorsSubstitution(T substitution) {
        this.substitution = substitution
    }

    abstract T getCurrentInterceptorSet();
    abstract ThreadLocalInterceptorSet<T> decorateWithThreadLocalImpl(T original);

import org.gradle.internal.component.model.DependencyMetadata;

import javax.annotation.Nullable;

/**
 * A dependency substitution applicator is responsible for applying substitution rules to dependency metadata.
 * Substitution result may either be the same module (no substitution), a different module (target of the substitution
 * is going to be different) or a failure.
 */
public interface DependencySubstitutionApplicator {

	//
	//   func f[P, Q any](P, Q) {}
	//
	//   func _(s string) {
	//           f[int](s, s) // ERROR
	//   }
	//
	// With substitution, we get the error:
	//   "cannot use s (variable of type string) as int value in argument to f[int]"
	//
	// Without substitution we get the (worse) error:
	//   "type string of s does not match inferred type int for P"
	// even though the type int was provided (not inferred) for P.
	//

    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/substitutors/typeSubstitution"), Pattern.compile("^(.+)\\.kt$"), null, true);
  }

  @Test
  @TestMetadata("directSubstitution.kt")
  public void testDirectSubstitution() {
    runTest("analysis/analysis-api/testData/substitutors/typeSubstitution/directSubstitution.kt");
  }

  @Test
  @TestMetadata("emptySubstitution.kt")

        @Override
        public void execute(DependencySubstitution substitution) {
            super.execute(substitution);
            ModuleVersionSelector requested = componentSelectorConverter.getSelector(substitution.getRequested());
            DefaultDependencyResolveDetails details = instantiator.newInstance(DefaultDependencyResolveDetails.class, substitution, requested);
            delegate.execute(details);

            // to prevent the following [substituteTypeOr*] from proceeding to its own (recursive) substitution.
            if (type.hasRecursiveTypeArgument()) return type
            // Return `null` means we will use [fir.resolve.substitution.Substitutors]'s [substituteRecursive]
            // that literally substitutes type arguments recursively.
            return null
        }