package kotlin.reflect.jvm.internal.impl.resolve.scopes;

import com.google.android.gms.measurement.api.AppMeasurementSdk;
import defpackage.cr4;
import defpackage.hu;
import defpackage.ik2;
import defpackage.kp6;
import defpackage.pk2;
import defpackage.pq6;
import defpackage.sq3;
import defpackage.uz1;
import defpackage.vx8;
import defpackage.y41;
import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import kotlin.reflect.jvm.internal.impl.descriptors.ClassifierDescriptor;
import kotlin.reflect.jvm.internal.impl.descriptors.ClassifierDescriptorWithTypeParameters;
import kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptor;
import kotlin.reflect.jvm.internal.impl.descriptors.MemberDescriptor;
import kotlin.reflect.jvm.internal.impl.descriptors.PropertyDescriptor;
import kotlin.reflect.jvm.internal.impl.descriptors.SimpleFunctionDescriptor;
import kotlin.reflect.jvm.internal.impl.incremental.components.LookupLocation;
import kotlin.reflect.jvm.internal.impl.name.Name;
import kotlin.reflect.jvm.internal.impl.resolve.scopes.MemberScope;
import kotlin.reflect.jvm.internal.impl.util.collectionUtils.ScopeUtilsKt;
import kotlin.reflect.jvm.internal.impl.utils.SmartList;

/* JADX INFO: loaded from: classes3.dex */
@vx8
public final class ChainedMemberScope implements MemberScope {

    @kp6
    public static final Companion Companion = new Companion(null);

    @kp6
    private final String debugName;

    @kp6
    private final MemberScope[] scopes;

    @vx8
    public static final class Companion {
        public /* synthetic */ Companion(uz1 uz1Var) {
            this();
        }

        @kp6
        public final MemberScope create(@kp6 String str, @kp6 Iterable<? extends MemberScope> iterable) {
            cr4.g(str, "debugName");
            cr4.g(iterable, "scopes");
            SmartList smartList = new SmartList();
            for (MemberScope memberScope : iterable) {
                if (memberScope != MemberScope.Empty.INSTANCE) {
                    if (memberScope instanceof ChainedMemberScope) {
                        y41.j(smartList, ((ChainedMemberScope) memberScope).scopes);
                    } else {
                        smartList.add(memberScope);
                    }
                }
            }
            return createOrSingle$descriptors(str, smartList);
        }

        @kp6
        public final MemberScope createOrSingle$descriptors(@kp6 String str, @kp6 List<? extends MemberScope> list) {
            cr4.g(str, "debugName");
            cr4.g(list, "scopes");
            int size = list.size();
            return size != 0 ? size != 1 ? new ChainedMemberScope(str, (MemberScope[]) list.toArray(new MemberScope[0]), null) : list.get(0) : MemberScope.Empty.INSTANCE;
        }

        private Companion() {
        }
    }

    public /* synthetic */ ChainedMemberScope(String str, MemberScope[] memberScopeArr, uz1 uz1Var) {
        this(str, memberScopeArr);
    }

    @Override // kotlin.reflect.jvm.internal.impl.resolve.scopes.MemberScope
    @pq6
    public Set<Name> getClassifierNames() {
        MemberScope[] memberScopeArr = this.scopes;
        cr4.g(memberScopeArr, "<this>");
        return MemberScopeKt.flatMapClassifierNamesOrNull(memberScopeArr.length == 0 ? ik2.a : new hu(memberScopeArr));
    }

    @Override // kotlin.reflect.jvm.internal.impl.resolve.scopes.ResolutionScope
    @pq6
    /* JADX INFO: renamed from: getContributedClassifier */
    public ClassifierDescriptor mo172getContributedClassifier(@kp6 Name name, @kp6 LookupLocation lookupLocation) {
        cr4.g(name, AppMeasurementSdk.ConditionalUserProperty.NAME);
        cr4.g(lookupLocation, "location");
        ClassifierDescriptor classifierDescriptor = null;
        for (MemberScope memberScope : this.scopes) {
            ClassifierDescriptor classifierDescriptorMo172getContributedClassifier = memberScope.mo172getContributedClassifier(name, lookupLocation);
            if (classifierDescriptorMo172getContributedClassifier != null) {
                if (!(classifierDescriptorMo172getContributedClassifier instanceof ClassifierDescriptorWithTypeParameters) || !((MemberDescriptor) classifierDescriptorMo172getContributedClassifier).isExpect()) {
                    return classifierDescriptorMo172getContributedClassifier;
                }
                if (classifierDescriptor == null) {
                    classifierDescriptor = classifierDescriptorMo172getContributedClassifier;
                }
            }
        }
        return classifierDescriptor;
    }

    @Override // kotlin.reflect.jvm.internal.impl.resolve.scopes.ResolutionScope
    @kp6
    public Collection<DeclarationDescriptor> getContributedDescriptors(@kp6 DescriptorKindFilter descriptorKindFilter, @kp6 sq3<? super Name, Boolean> sq3Var) {
        cr4.g(descriptorKindFilter, "kindFilter");
        cr4.g(sq3Var, "nameFilter");
        MemberScope[] memberScopeArr = this.scopes;
        int length = memberScopeArr.length;
        if (length == 0) {
            return ik2.a;
        }
        if (length == 1) {
            return memberScopeArr[0].getContributedDescriptors(descriptorKindFilter, sq3Var);
        }
        Collection<DeclarationDescriptor> collectionConcat = null;
        for (MemberScope memberScope : memberScopeArr) {
            collectionConcat = ScopeUtilsKt.concat(collectionConcat, memberScope.getContributedDescriptors(descriptorKindFilter, sq3Var));
        }
        return collectionConcat == null ? pk2.a : collectionConcat;
    }

    @Override // kotlin.reflect.jvm.internal.impl.resolve.scopes.MemberScope, kotlin.reflect.jvm.internal.impl.resolve.scopes.ResolutionScope
    @kp6
    public Collection<SimpleFunctionDescriptor> getContributedFunctions(@kp6 Name name, @kp6 LookupLocation lookupLocation) {
        cr4.g(name, AppMeasurementSdk.ConditionalUserProperty.NAME);
        cr4.g(lookupLocation, "location");
        MemberScope[] memberScopeArr = this.scopes;
        int length = memberScopeArr.length;
        if (length == 0) {
            return ik2.a;
        }
        if (length == 1) {
            return memberScopeArr[0].getContributedFunctions(name, lookupLocation);
        }
        Collection<SimpleFunctionDescriptor> collectionConcat = null;
        for (MemberScope memberScope : memberScopeArr) {
            collectionConcat = ScopeUtilsKt.concat(collectionConcat, memberScope.getContributedFunctions(name, lookupLocation));
        }
        return collectionConcat == null ? pk2.a : collectionConcat;
    }

    @Override // kotlin.reflect.jvm.internal.impl.resolve.scopes.MemberScope
    @kp6
    public Collection<PropertyDescriptor> getContributedVariables(@kp6 Name name, @kp6 LookupLocation lookupLocation) {
        cr4.g(name, AppMeasurementSdk.ConditionalUserProperty.NAME);
        cr4.g(lookupLocation, "location");
        MemberScope[] memberScopeArr = this.scopes;
        int length = memberScopeArr.length;
        if (length == 0) {
            return ik2.a;
        }
        if (length == 1) {
            return memberScopeArr[0].getContributedVariables(name, lookupLocation);
        }
        Collection<PropertyDescriptor> collectionConcat = null;
        for (MemberScope memberScope : memberScopeArr) {
            collectionConcat = ScopeUtilsKt.concat(collectionConcat, memberScope.getContributedVariables(name, lookupLocation));
        }
        return collectionConcat == null ? pk2.a : collectionConcat;
    }

    @Override // kotlin.reflect.jvm.internal.impl.resolve.scopes.MemberScope
    @kp6
    public Set<Name> getFunctionNames() {
        MemberScope[] memberScopeArr = this.scopes;
        LinkedHashSet linkedHashSet = new LinkedHashSet();
        for (MemberScope memberScope : memberScopeArr) {
            y41.i(memberScope.getFunctionNames(), linkedHashSet);
        }
        return linkedHashSet;
    }

    @Override // kotlin.reflect.jvm.internal.impl.resolve.scopes.MemberScope
    @kp6
    public Set<Name> getVariableNames() {
        MemberScope[] memberScopeArr = this.scopes;
        LinkedHashSet linkedHashSet = new LinkedHashSet();
        for (MemberScope memberScope : memberScopeArr) {
            y41.i(memberScope.getVariableNames(), linkedHashSet);
        }
        return linkedHashSet;
    }

    @Override // kotlin.reflect.jvm.internal.impl.resolve.scopes.ResolutionScope
    /* JADX INFO: renamed from: recordLookup */
    public void mo176recordLookup(@kp6 Name name, @kp6 LookupLocation lookupLocation) {
        cr4.g(name, AppMeasurementSdk.ConditionalUserProperty.NAME);
        cr4.g(lookupLocation, "location");
        for (MemberScope memberScope : this.scopes) {
            memberScope.mo176recordLookup(name, lookupLocation);
        }
    }

    @kp6
    public String toString() {
        return this.debugName;
    }

    private ChainedMemberScope(String str, MemberScope[] memberScopeArr) {
        this.debugName = str;
        this.scopes = memberScopeArr;
    }
}