package kotlin.reflect.jvm.internal;

import defpackage.ek7;
import defpackage.gk7;
import defpackage.i01;
import defpackage.ik7;
import defpackage.kw7;
import defpackage.mf6;
import defpackage.of6;
import defpackage.pr0;
import defpackage.qf6;
import defpackage.tr3;
import defpackage.u55;
import defpackage.wr3;
import java.util.Collections;
import java.util.List;
import kotlin.reflect.KCallable;
import kotlin.reflect.KClass;
import kotlin.reflect.KClassifier;
import kotlin.reflect.KDeclarationContainer;
import kotlin.reflect.KFunction;
import kotlin.reflect.KMutableProperty0;
import kotlin.reflect.KMutableProperty1;
import kotlin.reflect.KMutableProperty2;
import kotlin.reflect.KProperty0;
import kotlin.reflect.KProperty1;
import kotlin.reflect.KProperty2;
import kotlin.reflect.KType;
import kotlin.reflect.KTypeParameter;
import kotlin.reflect.KTypeProjection;
import kotlin.reflect.KVariance;
import kotlin.reflect.full.KClassifiers;
import kotlin.reflect.jvm.ReflectLambdaKt;

/* JADX INFO: loaded from: classes3.dex */
public class ReflectionFactoryImpl extends kw7 {
    public static void clearCaches() {
        CachesKt.clearCaches();
        ModuleByClassLoaderKt.clearModuleByClassLoaderCache();
    }

    private static KDeclarationContainerImpl getOwner(pr0 pr0Var) {
        KDeclarationContainer owner = pr0Var.getOwner();
        return owner instanceof KDeclarationContainerImpl ? (KDeclarationContainerImpl) owner : EmptyContainerForLocal.INSTANCE;
    }

    public KClass createKotlinClass(Class cls) {
        return new KClassImpl(cls);
    }

    @Override // defpackage.kw7
    public KFunction function(wr3 wr3Var) {
        return new KFunctionImpl(getOwner(wr3Var), wr3Var.getName(), wr3Var.getSignature(), wr3Var.getBoundReceiver());
    }

    @Override // defpackage.kw7
    public KClass getOrCreateKotlinClass(Class cls) {
        return CachesKt.getOrCreateKotlinClass(cls);
    }

    @Override // defpackage.kw7
    public KDeclarationContainer getOrCreateKotlinPackage(Class cls, String str) {
        return CachesKt.getOrCreateKotlinPackage(cls);
    }

    @Override // defpackage.kw7
    public KType mutableCollectionType(KType kType) {
        return TypeOfImplKt.createMutableCollectionKType(kType);
    }

    @Override // defpackage.kw7
    public KMutableProperty0 mutableProperty0(mf6 mf6Var) {
        return new KMutableProperty0Impl(getOwner(mf6Var), mf6Var.getName(), mf6Var.getSignature(), mf6Var.getBoundReceiver());
    }

    @Override // defpackage.kw7
    public KMutableProperty1 mutableProperty1(of6 of6Var) {
        return new KMutableProperty1Impl(getOwner(of6Var), of6Var.getName(), of6Var.getSignature(), of6Var.getBoundReceiver());
    }

    @Override // defpackage.kw7
    public KMutableProperty2 mutableProperty2(qf6 qf6Var) {
        return new KMutableProperty2Impl(getOwner(qf6Var), qf6Var.getName(), qf6Var.getSignature());
    }

    public KType nothingType(KType kType) {
        return TypeOfImplKt.createNothingType(kType);
    }

    public KType platformType(KType kType, KType kType2) {
        return TypeOfImplKt.createPlatformKType(kType, kType2);
    }

    @Override // defpackage.kw7
    public KProperty0 property0(ek7 ek7Var) {
        return new KProperty0Impl(getOwner(ek7Var), ek7Var.getName(), ek7Var.getSignature(), ek7Var.getBoundReceiver());
    }

    @Override // defpackage.kw7
    public KProperty1 property1(gk7 gk7Var) {
        return new KProperty1Impl(getOwner(gk7Var), gk7Var.getName(), gk7Var.getSignature(), gk7Var.getBoundReceiver());
    }

    @Override // defpackage.kw7
    public KProperty2 property2(ik7 ik7Var) {
        return new KProperty2Impl(getOwner(ik7Var), ik7Var.getName(), ik7Var.getSignature());
    }

    @Override // defpackage.kw7
    public String renderLambdaToString(u55 u55Var) {
        return renderLambdaToString((tr3) u55Var);
    }

    @Override // defpackage.kw7
    public void setUpperBounds(KTypeParameter kTypeParameter, List<KType> list) {
    }

    @Override // defpackage.kw7
    public KType typeOf(KClassifier kClassifier, List<KTypeProjection> list, boolean z) {
        return kClassifier instanceof i01 ? CachesKt.getOrCreateKType(((i01) kClassifier).getA(), list, z) : KClassifiers.createType(kClassifier, list, z, Collections.EMPTY_LIST);
    }

    @Override // defpackage.kw7
    public KTypeParameter typeParameter(Object obj, String str, KVariance kVariance, boolean z) {
        List<KTypeParameter> typeParameters;
        if (obj instanceof KClass) {
            typeParameters = ((KClass) obj).getTypeParameters();
        } else {
            if (!(obj instanceof KCallable)) {
                throw new IllegalArgumentException("Type parameter container must be a class or a callable: " + obj);
            }
            typeParameters = ((KCallable) obj).getTypeParameters();
        }
        for (KTypeParameter kTypeParameter : typeParameters) {
            if (kTypeParameter.getName().equals(str)) {
                return kTypeParameter;
            }
        }
        throw new IllegalArgumentException("Type parameter " + str + " is not found in container: " + obj);
    }

    public KClass createKotlinClass(Class cls, String str) {
        return new KClassImpl(cls);
    }

    public KClass getOrCreateKotlinClass(Class cls, String str) {
        return CachesKt.getOrCreateKotlinClass(cls);
    }

    @Override // defpackage.kw7
    public String renderLambdaToString(tr3 tr3Var) {
        KFunctionImpl kFunctionImplAsKFunctionImpl;
        KFunction kFunctionReflect = ReflectLambdaKt.reflect(tr3Var);
        return (kFunctionReflect == null || (kFunctionImplAsKFunctionImpl = UtilKt.asKFunctionImpl(kFunctionReflect)) == null) ? super.renderLambdaToString(tr3Var) : ReflectionObjectRenderer.INSTANCE.renderLambda(kFunctionImplAsKFunctionImpl.getDescriptor());
    }
}