package kotlin.reflect.jvm.internal.impl.renderer; import androidx.media3.exoplayer.rtsp.SessionDescription; import com.google.android.gms.measurement.api.AppMeasurementSdk; import defpackage.cr4; import defpackage.e6a; import defpackage.ik2; import defpackage.io6; import defpackage.j65; import defpackage.km8; import defpackage.kp6; import defpackage.n41; import defpackage.n89; import defpackage.pq6; import defpackage.qq3; import defpackage.sq3; import defpackage.v65; import defpackage.vw2; import defpackage.vx8; import defpackage.vy0; import defpackage.y41; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; import kotlin.reflect.jvm.internal.impl.builtins.FunctionTypesKt; import kotlin.reflect.jvm.internal.impl.builtins.KotlinBuiltIns; import kotlin.reflect.jvm.internal.impl.builtins.StandardNames; import kotlin.reflect.jvm.internal.impl.descriptors.CallableDescriptor; import kotlin.reflect.jvm.internal.impl.descriptors.CallableMemberDescriptor; import kotlin.reflect.jvm.internal.impl.descriptors.ClassConstructorDescriptor; import kotlin.reflect.jvm.internal.impl.descriptors.ClassDescriptor; import kotlin.reflect.jvm.internal.impl.descriptors.ClassKind; import kotlin.reflect.jvm.internal.impl.descriptors.ClassifierDescriptor; import kotlin.reflect.jvm.internal.impl.descriptors.ClassifierDescriptorWithTypeParameters; import kotlin.reflect.jvm.internal.impl.descriptors.ConstructorDescriptor; import kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptor; import kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptorVisitor; import kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptorWithSource; import kotlin.reflect.jvm.internal.impl.descriptors.DescriptorVisibilities; import kotlin.reflect.jvm.internal.impl.descriptors.DescriptorVisibility; import kotlin.reflect.jvm.internal.impl.descriptors.FieldDescriptor; import kotlin.reflect.jvm.internal.impl.descriptors.FunctionDescriptor; import kotlin.reflect.jvm.internal.impl.descriptors.MemberDescriptor; import kotlin.reflect.jvm.internal.impl.descriptors.Modality; import kotlin.reflect.jvm.internal.impl.descriptors.ModuleDescriptor; import kotlin.reflect.jvm.internal.impl.descriptors.NotFoundClasses; import kotlin.reflect.jvm.internal.impl.descriptors.PackageFragmentDescriptor; import kotlin.reflect.jvm.internal.impl.descriptors.PackageViewDescriptor; import kotlin.reflect.jvm.internal.impl.descriptors.PossiblyInnerType; import kotlin.reflect.jvm.internal.impl.descriptors.PropertyAccessorDescriptor; import kotlin.reflect.jvm.internal.impl.descriptors.PropertyDescriptor; import kotlin.reflect.jvm.internal.impl.descriptors.PropertyGetterDescriptor; import kotlin.reflect.jvm.internal.impl.descriptors.PropertySetterDescriptor; import kotlin.reflect.jvm.internal.impl.descriptors.ReceiverParameterDescriptor; import kotlin.reflect.jvm.internal.impl.descriptors.TypeAliasDescriptor; import kotlin.reflect.jvm.internal.impl.descriptors.TypeParameterDescriptor; import kotlin.reflect.jvm.internal.impl.descriptors.TypeParameterUtilsKt; import kotlin.reflect.jvm.internal.impl.descriptors.ValueParameterDescriptor; import kotlin.reflect.jvm.internal.impl.descriptors.VariableDescriptor; import kotlin.reflect.jvm.internal.impl.descriptors.annotations.Annotated; import kotlin.reflect.jvm.internal.impl.descriptors.annotations.AnnotationDescriptor; import kotlin.reflect.jvm.internal.impl.descriptors.annotations.AnnotationUseSiteTarget; import kotlin.reflect.jvm.internal.impl.name.FqName; import kotlin.reflect.jvm.internal.impl.name.FqNameUnsafe; import kotlin.reflect.jvm.internal.impl.name.Name; import kotlin.reflect.jvm.internal.impl.name.SpecialNames; import kotlin.reflect.jvm.internal.impl.renderer.DescriptorRenderer; import kotlin.reflect.jvm.internal.impl.resolve.DescriptorUtils; import kotlin.reflect.jvm.internal.impl.resolve.constants.AnnotationValue; import kotlin.reflect.jvm.internal.impl.resolve.constants.ArrayValue; import kotlin.reflect.jvm.internal.impl.resolve.constants.ConstantValue; import kotlin.reflect.jvm.internal.impl.resolve.constants.KClassValue; import kotlin.reflect.jvm.internal.impl.resolve.descriptorUtil.DescriptorUtilsKt; import kotlin.reflect.jvm.internal.impl.types.AbbreviatedType; import kotlin.reflect.jvm.internal.impl.types.DefinitelyNotNullType; import kotlin.reflect.jvm.internal.impl.types.FlexibleType; import kotlin.reflect.jvm.internal.impl.types.IntersectionTypeConstructor; import kotlin.reflect.jvm.internal.impl.types.KotlinType; import kotlin.reflect.jvm.internal.impl.types.KotlinTypeKt; import kotlin.reflect.jvm.internal.impl.types.SimpleType; import kotlin.reflect.jvm.internal.impl.types.SpecialTypesKt; import kotlin.reflect.jvm.internal.impl.types.StubTypeForBuilderInference; import kotlin.reflect.jvm.internal.impl.types.TypeConstructor; import kotlin.reflect.jvm.internal.impl.types.TypeProjection; import kotlin.reflect.jvm.internal.impl.types.TypeUtils; import kotlin.reflect.jvm.internal.impl.types.UnwrappedType; import kotlin.reflect.jvm.internal.impl.types.Variance; import kotlin.reflect.jvm.internal.impl.types.WrappedType; import kotlin.reflect.jvm.internal.impl.types.error.ErrorType; import kotlin.reflect.jvm.internal.impl.types.error.ErrorTypeConstructor; import kotlin.reflect.jvm.internal.impl.types.error.ErrorUtils; import kotlin.reflect.jvm.internal.impl.types.typeUtil.TypeUtilsKt; import kotlin.reflect.jvm.internal.impl.util.capitalizeDecapitalize.CapitalizeDecapitalizeKt; /* JADX INFO: loaded from: classes3.dex */ @vx8 public final class DescriptorRendererImpl extends DescriptorRenderer implements DescriptorRendererOptions { @kp6 private final j65 functionTypeAnnotationsRenderer$delegate; @kp6 private final DescriptorRendererOptionsImpl options; public final class RenderDeclarationDescriptorVisitor implements DeclarationDescriptorVisitor { public /* synthetic */ class WhenMappings { public static final /* synthetic */ int[] $EnumSwitchMapping$0; static { int[] iArr = new int[PropertyAccessorRenderingPolicy.values().length]; try { iArr[PropertyAccessorRenderingPolicy.PRETTY.ordinal()] = 1; } catch (NoSuchFieldError unused) { } try { iArr[PropertyAccessorRenderingPolicy.DEBUG.ordinal()] = 2; } catch (NoSuchFieldError unused2) { } try { iArr[PropertyAccessorRenderingPolicy.NONE.ordinal()] = 3; } catch (NoSuchFieldError unused3) { } $EnumSwitchMapping$0 = iArr; } } public RenderDeclarationDescriptorVisitor() { } private final void visitPropertyAccessorDescriptor(PropertyAccessorDescriptor propertyAccessorDescriptor, StringBuilder sb, String str) { int i = WhenMappings.$EnumSwitchMapping$0[DescriptorRendererImpl.this.getPropertyAccessorRenderingPolicy().ordinal()]; if (i != 1) { if (i == 2) { visitFunctionDescriptor2((FunctionDescriptor) propertyAccessorDescriptor, sb); return; } else { if (i != 3) { throw new io6(); } return; } } DescriptorRendererImpl.this.renderAccessorModifiers(propertyAccessorDescriptor, sb); sb.append(str + " for "); DescriptorRendererImpl descriptorRendererImpl = DescriptorRendererImpl.this; PropertyDescriptor correspondingProperty = propertyAccessorDescriptor.getCorrespondingProperty(); cr4.f(correspondingProperty, "getCorrespondingProperty(...)"); descriptorRendererImpl.renderProperty(correspondingProperty, sb); } @Override // kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptorVisitor public /* bridge */ /* synthetic */ e6a visitClassDescriptor(ClassDescriptor classDescriptor, StringBuilder sb) { visitClassDescriptor2(classDescriptor, sb); return e6a.a; } @Override // kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptorVisitor public /* bridge */ /* synthetic */ e6a visitConstructorDescriptor(ConstructorDescriptor constructorDescriptor, StringBuilder sb) { visitConstructorDescriptor2(constructorDescriptor, sb); return e6a.a; } @Override // kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptorVisitor public /* bridge */ /* synthetic */ e6a visitFunctionDescriptor(FunctionDescriptor functionDescriptor, StringBuilder sb) { visitFunctionDescriptor2(functionDescriptor, sb); return e6a.a; } @Override // kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptorVisitor public /* bridge */ /* synthetic */ e6a visitModuleDeclaration(ModuleDescriptor moduleDescriptor, StringBuilder sb) { visitModuleDeclaration2(moduleDescriptor, sb); return e6a.a; } @Override // kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptorVisitor public /* bridge */ /* synthetic */ e6a visitPackageFragmentDescriptor(PackageFragmentDescriptor packageFragmentDescriptor, StringBuilder sb) { visitPackageFragmentDescriptor2(packageFragmentDescriptor, sb); return e6a.a; } @Override // kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptorVisitor public /* bridge */ /* synthetic */ e6a visitPackageViewDescriptor(PackageViewDescriptor packageViewDescriptor, StringBuilder sb) { visitPackageViewDescriptor2(packageViewDescriptor, sb); return e6a.a; } @Override // kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptorVisitor public /* bridge */ /* synthetic */ e6a visitPropertyDescriptor(PropertyDescriptor propertyDescriptor, StringBuilder sb) { visitPropertyDescriptor2(propertyDescriptor, sb); return e6a.a; } @Override // kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptorVisitor public /* bridge */ /* synthetic */ e6a visitPropertyGetterDescriptor(PropertyGetterDescriptor propertyGetterDescriptor, StringBuilder sb) { visitPropertyGetterDescriptor2(propertyGetterDescriptor, sb); return e6a.a; } @Override // kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptorVisitor public /* bridge */ /* synthetic */ e6a visitPropertySetterDescriptor(PropertySetterDescriptor propertySetterDescriptor, StringBuilder sb) { visitPropertySetterDescriptor2(propertySetterDescriptor, sb); return e6a.a; } @Override // kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptorVisitor public /* bridge */ /* synthetic */ e6a visitReceiverParameterDescriptor(ReceiverParameterDescriptor receiverParameterDescriptor, StringBuilder sb) { visitReceiverParameterDescriptor2(receiverParameterDescriptor, sb); return e6a.a; } @Override // kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptorVisitor public /* bridge */ /* synthetic */ e6a visitTypeAliasDescriptor(TypeAliasDescriptor typeAliasDescriptor, StringBuilder sb) { visitTypeAliasDescriptor2(typeAliasDescriptor, sb); return e6a.a; } @Override // kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptorVisitor public /* bridge */ /* synthetic */ e6a visitTypeParameterDescriptor(TypeParameterDescriptor typeParameterDescriptor, StringBuilder sb) { visitTypeParameterDescriptor2(typeParameterDescriptor, sb); return e6a.a; } @Override // kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptorVisitor public /* bridge */ /* synthetic */ e6a visitValueParameterDescriptor(ValueParameterDescriptor valueParameterDescriptor, StringBuilder sb) { visitValueParameterDescriptor2(valueParameterDescriptor, sb); return e6a.a; } /* JADX INFO: renamed from: visitClassDescriptor, reason: avoid collision after fix types in other method */ public void visitClassDescriptor2(@kp6 ClassDescriptor classDescriptor, @kp6 StringBuilder sb) { cr4.g(classDescriptor, "descriptor"); cr4.g(sb, "builder"); DescriptorRendererImpl.this.renderClass(classDescriptor, sb); } /* JADX INFO: renamed from: visitConstructorDescriptor, reason: avoid collision after fix types in other method */ public void visitConstructorDescriptor2(@kp6 ConstructorDescriptor constructorDescriptor, @kp6 StringBuilder sb) { cr4.g(constructorDescriptor, "constructorDescriptor"); cr4.g(sb, "builder"); DescriptorRendererImpl.this.renderConstructor(constructorDescriptor, sb); } /* JADX INFO: renamed from: visitFunctionDescriptor, reason: avoid collision after fix types in other method */ public void visitFunctionDescriptor2(@kp6 FunctionDescriptor functionDescriptor, @kp6 StringBuilder sb) { cr4.g(functionDescriptor, "descriptor"); cr4.g(sb, "builder"); DescriptorRendererImpl.this.renderFunction(functionDescriptor, sb); } /* JADX INFO: renamed from: visitModuleDeclaration, reason: avoid collision after fix types in other method */ public void visitModuleDeclaration2(@kp6 ModuleDescriptor moduleDescriptor, @kp6 StringBuilder sb) { cr4.g(moduleDescriptor, "descriptor"); cr4.g(sb, "builder"); DescriptorRendererImpl.this.renderName(moduleDescriptor, sb, true); } /* JADX INFO: renamed from: visitPackageFragmentDescriptor, reason: avoid collision after fix types in other method */ public void visitPackageFragmentDescriptor2(@kp6 PackageFragmentDescriptor packageFragmentDescriptor, @kp6 StringBuilder sb) { cr4.g(packageFragmentDescriptor, "descriptor"); cr4.g(sb, "builder"); DescriptorRendererImpl.this.renderPackageFragment(packageFragmentDescriptor, sb); } /* JADX INFO: renamed from: visitPackageViewDescriptor, reason: avoid collision after fix types in other method */ public void visitPackageViewDescriptor2(@kp6 PackageViewDescriptor packageViewDescriptor, @kp6 StringBuilder sb) { cr4.g(packageViewDescriptor, "descriptor"); cr4.g(sb, "builder"); DescriptorRendererImpl.this.renderPackageView(packageViewDescriptor, sb); } /* JADX INFO: renamed from: visitPropertyDescriptor, reason: avoid collision after fix types in other method */ public void visitPropertyDescriptor2(@kp6 PropertyDescriptor propertyDescriptor, @kp6 StringBuilder sb) { cr4.g(propertyDescriptor, "descriptor"); cr4.g(sb, "builder"); DescriptorRendererImpl.this.renderProperty(propertyDescriptor, sb); } /* JADX INFO: renamed from: visitPropertyGetterDescriptor, reason: avoid collision after fix types in other method */ public void visitPropertyGetterDescriptor2(@kp6 PropertyGetterDescriptor propertyGetterDescriptor, @kp6 StringBuilder sb) { cr4.g(propertyGetterDescriptor, "descriptor"); cr4.g(sb, "builder"); visitPropertyAccessorDescriptor(propertyGetterDescriptor, sb, "getter"); } /* JADX INFO: renamed from: visitPropertySetterDescriptor, reason: avoid collision after fix types in other method */ public void visitPropertySetterDescriptor2(@kp6 PropertySetterDescriptor propertySetterDescriptor, @kp6 StringBuilder sb) { cr4.g(propertySetterDescriptor, "descriptor"); cr4.g(sb, "builder"); visitPropertyAccessorDescriptor(propertySetterDescriptor, sb, "setter"); } /* JADX INFO: renamed from: visitReceiverParameterDescriptor, reason: avoid collision after fix types in other method */ public void visitReceiverParameterDescriptor2(@kp6 ReceiverParameterDescriptor receiverParameterDescriptor, @kp6 StringBuilder sb) { cr4.g(receiverParameterDescriptor, "descriptor"); cr4.g(sb, "builder"); sb.append(receiverParameterDescriptor.getName()); } /* JADX INFO: renamed from: visitTypeAliasDescriptor, reason: avoid collision after fix types in other method */ public void visitTypeAliasDescriptor2(@kp6 TypeAliasDescriptor typeAliasDescriptor, @kp6 StringBuilder sb) { cr4.g(typeAliasDescriptor, "descriptor"); cr4.g(sb, "builder"); DescriptorRendererImpl.this.renderTypeAlias(typeAliasDescriptor, sb); } /* JADX INFO: renamed from: visitTypeParameterDescriptor, reason: avoid collision after fix types in other method */ public void visitTypeParameterDescriptor2(@kp6 TypeParameterDescriptor typeParameterDescriptor, @kp6 StringBuilder sb) { cr4.g(typeParameterDescriptor, "descriptor"); cr4.g(sb, "builder"); DescriptorRendererImpl.this.renderTypeParameter(typeParameterDescriptor, sb, true); } /* JADX INFO: renamed from: visitValueParameterDescriptor, reason: avoid collision after fix types in other method */ public void visitValueParameterDescriptor2(@kp6 ValueParameterDescriptor valueParameterDescriptor, @kp6 StringBuilder sb) { cr4.g(valueParameterDescriptor, "descriptor"); cr4.g(sb, "builder"); DescriptorRendererImpl.this.renderValueParameter(valueParameterDescriptor, true, sb, true); } } public /* synthetic */ class WhenMappings { public static final /* synthetic */ int[] $EnumSwitchMapping$0; public static final /* synthetic */ int[] $EnumSwitchMapping$1; static { int[] iArr = new int[RenderingFormat.values().length]; try { iArr[RenderingFormat.PLAIN.ordinal()] = 1; } catch (NoSuchFieldError unused) { } try { iArr[RenderingFormat.HTML.ordinal()] = 2; } catch (NoSuchFieldError unused2) { } $EnumSwitchMapping$0 = iArr; int[] iArr2 = new int[ParameterNameRenderingPolicy.values().length]; try { iArr2[ParameterNameRenderingPolicy.ALL.ordinal()] = 1; } catch (NoSuchFieldError unused3) { } try { iArr2[ParameterNameRenderingPolicy.ONLY_NON_SYNTHESIZED.ordinal()] = 2; } catch (NoSuchFieldError unused4) { } try { iArr2[ParameterNameRenderingPolicy.NONE.ordinal()] = 3; } catch (NoSuchFieldError unused5) { } $EnumSwitchMapping$1 = iArr2; } } public DescriptorRendererImpl(@kp6 DescriptorRendererOptionsImpl descriptorRendererOptionsImpl) { cr4.g(descriptorRendererOptionsImpl, "options"); this.options = descriptorRendererOptionsImpl; descriptorRendererOptionsImpl.isLocked(); this.functionTypeAnnotationsRenderer$delegate = v65.a(new qq3(this) { // from class: kotlin.reflect.jvm.internal.impl.renderer.DescriptorRendererImpl$$Lambda$0 private final DescriptorRendererImpl arg$0; { this.arg$0 = this; } @Override // defpackage.qq3 public Object invoke() { return DescriptorRendererImpl.functionTypeAnnotationsRenderer_delegate$lambda$1(this.arg$0); } }); } private final void appendDefinedIn(StringBuilder sb, DeclarationDescriptor declarationDescriptor) { DeclarationDescriptor containingDeclaration; String name; if ((declarationDescriptor instanceof PackageFragmentDescriptor) || (declarationDescriptor instanceof PackageViewDescriptor) || (containingDeclaration = declarationDescriptor.getContainingDeclaration()) == null || (containingDeclaration instanceof ModuleDescriptor)) { return; } sb.append(" "); sb.append(renderMessage("defined in")); sb.append(" "); FqNameUnsafe fqName = DescriptorUtils.getFqName(containingDeclaration); cr4.f(fqName, "getFqName(...)"); sb.append(fqName.isRoot() ? "root package" : renderFqName(fqName)); if (getWithSourceFileForTopLevel() && (containingDeclaration instanceof PackageFragmentDescriptor) && (declarationDescriptor instanceof DeclarationDescriptorWithSource) && (name = ((DeclarationDescriptorWithSource) declarationDescriptor).getSource().getContainingFile().getName()) != null) { sb.append(" "); sb.append(renderMessage("in file")); sb.append(" "); sb.append(name); } } private final void appendTypeProjections(StringBuilder sb, List list) { y41.ah(list, sb, ", ", null, null, new sq3(this) { // from class: kotlin.reflect.jvm.internal.impl.renderer.DescriptorRendererImpl$$Lambda$2 private final DescriptorRendererImpl arg$0; { this.arg$0 = this; } @Override // defpackage.sq3 public Object invoke(Object obj) { return DescriptorRendererImpl.appendTypeProjections$lambda$10(this.arg$0, (TypeProjection) obj); } }, 60); } /* JADX INFO: Access modifiers changed from: private */ public static final CharSequence appendTypeProjections$lambda$10(DescriptorRendererImpl descriptorRendererImpl, TypeProjection typeProjection) { cr4.g(typeProjection, "it"); if (typeProjection.isStarProjection()) { return "*"; } KotlinType type = typeProjection.getType(); cr4.f(type, "getType(...)"); String strRenderType = descriptorRendererImpl.renderType(type); if (typeProjection.getProjectionKind() == Variance.INVARIANT) { return strRenderType; } return typeProjection.getProjectionKind() + ' ' + strRenderType; } private final String arrow() { int i = WhenMappings.$EnumSwitchMapping$0[getTextFormat().ordinal()]; if (i == 1) { return escape("->"); } if (i == 2) { return "→"; } throw new io6(); } private final String escape(String str) { return getTextFormat().escape(str); } /* JADX INFO: Access modifiers changed from: private */ public static final DescriptorRendererImpl functionTypeAnnotationsRenderer_delegate$lambda$1(DescriptorRendererImpl descriptorRendererImpl) { DescriptorRenderer descriptorRendererWithOptions = descriptorRendererImpl.withOptions(new sq3() { // from class: kotlin.reflect.jvm.internal.impl.renderer.DescriptorRendererImpl$$Lambda$5 @Override // defpackage.sq3 public Object invoke(Object obj) { return DescriptorRendererImpl.functionTypeAnnotationsRenderer_delegate$lambda$1$lambda$0((DescriptorRendererOptions) obj); } }); cr4.e(descriptorRendererWithOptions, "null cannot be cast to non-null type org.jetbrains.kotlin.renderer.DescriptorRendererImpl"); return (DescriptorRendererImpl) descriptorRendererWithOptions; } /* JADX INFO: Access modifiers changed from: private */ public static final e6a functionTypeAnnotationsRenderer_delegate$lambda$1$lambda$0(DescriptorRendererOptions descriptorRendererOptions) { cr4.g(descriptorRendererOptions, "$this$withOptions"); descriptorRendererOptions.setExcludedTypeAnnotationClasses(km8.f(descriptorRendererOptions.getExcludedTypeAnnotationClasses(), y41.an(StandardNames.FqNames.extensionFunctionType, StandardNames.FqNames.contextFunctionTypeParams))); return e6a.a; } private final DescriptorRendererImpl getFunctionTypeAnnotationsRenderer() { return (DescriptorRendererImpl) this.functionTypeAnnotationsRenderer$delegate.getValue(); } private final String gt() { return escape(">"); } private final boolean hasModifiersOrAnnotations(KotlinType kotlinType) { return FunctionTypesKt.isSuspendFunctionType(kotlinType) || !kotlinType.getAnnotations().isEmpty(); } private final Modality implicitModalityWithoutExtensions(MemberDescriptor memberDescriptor) { if (memberDescriptor instanceof ClassDescriptor) { return ((ClassDescriptor) memberDescriptor).getKind() == ClassKind.INTERFACE ? Modality.ABSTRACT : Modality.FINAL; } DeclarationDescriptor containingDeclaration = memberDescriptor.getContainingDeclaration(); ClassDescriptor classDescriptor = containingDeclaration instanceof ClassDescriptor ? (ClassDescriptor) containingDeclaration : null; if (classDescriptor != null && (memberDescriptor instanceof CallableMemberDescriptor)) { CallableMemberDescriptor callableMemberDescriptor = (CallableMemberDescriptor) memberDescriptor; Collection overriddenDescriptors = callableMemberDescriptor.getOverriddenDescriptors(); cr4.f(overriddenDescriptors, "getOverriddenDescriptors(...)"); if (!overriddenDescriptors.isEmpty() && classDescriptor.getModality() != Modality.FINAL) { return Modality.OPEN; } if (classDescriptor.getKind() != ClassKind.INTERFACE || cr4.b(callableMemberDescriptor.getVisibility(), DescriptorVisibilities.PRIVATE)) { return Modality.FINAL; } Modality modality = callableMemberDescriptor.getModality(); Modality modality2 = Modality.ABSTRACT; return modality == modality2 ? modality2 : Modality.OPEN; } return Modality.FINAL; } private final boolean isParameterName(AnnotationDescriptor annotationDescriptor) { return cr4.b(annotationDescriptor.getFqName(), StandardNames.FqNames.parameterName); } private final String lt() { return escape("<"); } private final boolean overridesSomething(CallableMemberDescriptor callableMemberDescriptor) { return !callableMemberDescriptor.getOverriddenDescriptors().isEmpty(); } private final void renderAbbreviatedTypeComment(StringBuilder sb, AbbreviatedType abbreviatedType) { RenderingFormat textFormat = getTextFormat(); RenderingFormat renderingFormat = RenderingFormat.HTML; if (textFormat == renderingFormat) { sb.append(""); } sb.append(" /* "); sb.append("from: "); renderNormalizedTypeAsIs(sb, abbreviatedType.getAbbreviation()); sb.append(" */"); if (getTextFormat() == renderingFormat) { sb.append(""); } } /* JADX INFO: Access modifiers changed from: private */ public final void renderAccessorModifiers(PropertyAccessorDescriptor propertyAccessorDescriptor, StringBuilder sb) { renderMemberModifiers(propertyAccessorDescriptor, sb); } private final void renderAdditionalModifiers(FunctionDescriptor functionDescriptor, StringBuilder sb) { boolean z; boolean z2 = false; if (functionDescriptor.isOperator()) { Collection overriddenDescriptors = functionDescriptor.getOverriddenDescriptors(); cr4.f(overriddenDescriptors, "getOverriddenDescriptors(...)"); Collection collection = overriddenDescriptors; if (!collection.isEmpty()) { Iterator it = collection.iterator(); while (true) { if (!it.hasNext()) { break; } else if (((FunctionDescriptor) it.next()).isOperator()) { if (getAlwaysRenderModifiers()) { break; } } } z = false; } z = true; } else { z = false; } if (functionDescriptor.isInfix()) { Collection overriddenDescriptors2 = functionDescriptor.getOverriddenDescriptors(); cr4.f(overriddenDescriptors2, "getOverriddenDescriptors(...)"); Collection collection2 = overriddenDescriptors2; if (collection2.isEmpty()) { z2 = true; } else { Iterator it2 = collection2.iterator(); while (true) { if (!it2.hasNext()) { break; } else if (((FunctionDescriptor) it2.next()).isInfix()) { if (getAlwaysRenderModifiers()) { break; } } } } } renderModifier(sb, functionDescriptor.isTailrec(), "tailrec"); renderSuspendModifier(functionDescriptor, sb); renderModifier(sb, functionDescriptor.isInline(), "inline"); renderModifier(sb, z2, "infix"); renderModifier(sb, z, "operator"); } private final List renderAndSortAnnotationArguments(AnnotationDescriptor annotationDescriptor) { ClassConstructorDescriptor classConstructorDescriptorMo164getUnsubstitutedPrimaryConstructor; List valueParameters; Map> allValueArguments = annotationDescriptor.getAllValueArguments(); List list = null; ClassDescriptor annotationClass = getRenderDefaultAnnotationArguments() ? DescriptorUtilsKt.getAnnotationClass(annotationDescriptor) : null; if (annotationClass != null && (classConstructorDescriptorMo164getUnsubstitutedPrimaryConstructor = annotationClass.mo164getUnsubstitutedPrimaryConstructor()) != null && (valueParameters = classConstructorDescriptorMo164getUnsubstitutedPrimaryConstructor.getValueParameters()) != null) { ArrayList arrayList = new ArrayList(); for (Object obj : valueParameters) { if (((ValueParameterDescriptor) obj).declaresDefaultValue()) { arrayList.add(obj); } } ArrayList arrayList2 = new ArrayList(y41.p(arrayList, 10)); Iterator it = arrayList.iterator(); while (it.hasNext()) { arrayList2.add(((ValueParameterDescriptor) it.next()).getName()); } list = arrayList2; } if (list == null) { list = ik2.a; } ArrayList arrayList3 = new ArrayList(); for (Object obj2 : list) { if (!allValueArguments.containsKey((Name) obj2)) { arrayList3.add(obj2); } } ArrayList arrayList4 = new ArrayList(y41.p(arrayList3, 10)); Iterator it2 = arrayList3.iterator(); while (it2.hasNext()) { arrayList4.add(((Name) it2.next()).asString() + " = ..."); } Set>> setEntrySet = allValueArguments.entrySet(); ArrayList arrayList5 = new ArrayList(y41.p(setEntrySet, 10)); Iterator it3 = setEntrySet.iterator(); while (it3.hasNext()) { Map.Entry entry = (Map.Entry) it3.next(); Name name = (Name) entry.getKey(); ConstantValue constantValue = (ConstantValue) entry.getValue(); StringBuilder sb = new StringBuilder(); sb.append(name.asString()); sb.append(" = "); sb.append(!list.contains(name) ? renderConstant(constantValue) : "..."); arrayList5.add(sb.toString()); } return y41.bi(y41.au(arrayList5, arrayList4)); } private final void renderAnnotations(StringBuilder sb, Annotated annotated, AnnotationUseSiteTarget annotationUseSiteTarget) { if (getModifiers().contains(DescriptorRendererModifier.ANNOTATIONS)) { Set excludedTypeAnnotationClasses = annotated instanceof KotlinType ? getExcludedTypeAnnotationClasses() : getExcludedAnnotationClasses(); sq3 annotationFilter = getAnnotationFilter(); for (AnnotationDescriptor annotationDescriptor : annotated.getAnnotations()) { if (!y41.q(excludedTypeAnnotationClasses, annotationDescriptor.getFqName()) && !isParameterName(annotationDescriptor) && (annotationFilter == null || ((Boolean) annotationFilter.invoke(annotationDescriptor)).booleanValue())) { sb.append(renderAnnotation(annotationDescriptor, annotationUseSiteTarget)); if (getEachAnnotationOnNewLine()) { sb.append('\n'); } else { sb.append(" "); } } } } } public static /* synthetic */ void renderAnnotations$default(DescriptorRendererImpl descriptorRendererImpl, StringBuilder sb, Annotated annotated, AnnotationUseSiteTarget annotationUseSiteTarget, int i, Object obj) { if ((i & 2) != 0) { annotationUseSiteTarget = null; } descriptorRendererImpl.renderAnnotations(sb, annotated, annotationUseSiteTarget); } private final void renderCapturedTypeParametersIfRequired(ClassifierDescriptorWithTypeParameters classifierDescriptorWithTypeParameters, StringBuilder sb) { List declaredTypeParameters = classifierDescriptorWithTypeParameters.getDeclaredTypeParameters(); cr4.f(declaredTypeParameters, "getDeclaredTypeParameters(...)"); List parameters = classifierDescriptorWithTypeParameters.getTypeConstructor().getParameters(); cr4.f(parameters, "getParameters(...)"); if (getVerbose() && classifierDescriptorWithTypeParameters.isInner() && parameters.size() > declaredTypeParameters.size()) { sb.append(" /*captured type parameters: "); renderTypeParameterList(sb, parameters.subList(declaredTypeParameters.size(), parameters.size())); sb.append("*/"); } } /* JADX INFO: Access modifiers changed from: private */ public final void renderClass(ClassDescriptor classDescriptor, StringBuilder sb) { ClassConstructorDescriptor classConstructorDescriptorMo164getUnsubstitutedPrimaryConstructor; boolean z = classDescriptor.getKind() == ClassKind.ENUM_ENTRY; if (!getStartFromName()) { List contextReceivers = classDescriptor.getContextReceivers(); cr4.f(contextReceivers, "getContextReceivers(...)"); renderContextReceivers(contextReceivers, sb); renderAnnotations$default(this, sb, classDescriptor, null, 2, null); if (!z) { DescriptorVisibility visibility = classDescriptor.getVisibility(); cr4.f(visibility, "getVisibility(...)"); renderVisibility(visibility, sb); } if ((classDescriptor.getKind() != ClassKind.INTERFACE || classDescriptor.getModality() != Modality.ABSTRACT) && (!classDescriptor.getKind().isSingleton() || classDescriptor.getModality() != Modality.FINAL)) { Modality modality = classDescriptor.getModality(); cr4.f(modality, "getModality(...)"); renderModality(modality, sb, implicitModalityWithoutExtensions(classDescriptor)); } renderMemberModifiers(classDescriptor, sb); renderModifier(sb, getModifiers().contains(DescriptorRendererModifier.INNER) && classDescriptor.isInner(), "inner"); renderModifier(sb, getModifiers().contains(DescriptorRendererModifier.DATA) && classDescriptor.isData(), "data"); renderModifier(sb, getModifiers().contains(DescriptorRendererModifier.INLINE) && classDescriptor.isInline(), "inline"); renderModifier(sb, getModifiers().contains(DescriptorRendererModifier.VALUE) && classDescriptor.isValue(), AppMeasurementSdk.ConditionalUserProperty.VALUE); renderModifier(sb, getModifiers().contains(DescriptorRendererModifier.FUN) && classDescriptor.isFun(), "fun"); renderClassKindPrefix(classDescriptor, sb); } if (DescriptorUtils.isCompanionObject(classDescriptor)) { renderCompanionObjectName(classDescriptor, sb); } else { if (!getStartFromName()) { renderSpaceIfNeeded(sb); } renderName(classDescriptor, sb, true); } if (z) { return; } List declaredTypeParameters = classDescriptor.getDeclaredTypeParameters(); cr4.f(declaredTypeParameters, "getDeclaredTypeParameters(...)"); renderTypeParameters(declaredTypeParameters, sb, false); renderCapturedTypeParametersIfRequired(classDescriptor, sb); if (!classDescriptor.getKind().isSingleton() && getClassWithPrimaryConstructor() && (classConstructorDescriptorMo164getUnsubstitutedPrimaryConstructor = classDescriptor.mo164getUnsubstitutedPrimaryConstructor()) != null) { sb.append(" "); renderAnnotations$default(this, sb, classConstructorDescriptorMo164getUnsubstitutedPrimaryConstructor, null, 2, null); DescriptorVisibility visibility2 = classConstructorDescriptorMo164getUnsubstitutedPrimaryConstructor.getVisibility(); cr4.f(visibility2, "getVisibility(...)"); renderVisibility(visibility2, sb); sb.append(renderKeyword("constructor")); List valueParameters = classConstructorDescriptorMo164getUnsubstitutedPrimaryConstructor.getValueParameters(); cr4.f(valueParameters, "getValueParameters(...)"); renderValueParameters(valueParameters, classConstructorDescriptorMo164getUnsubstitutedPrimaryConstructor.hasSynthesizedParameterNames(), sb); } renderSuperTypes(classDescriptor, sb); renderWhereSuffix(declaredTypeParameters, sb); } private final void renderClassKindPrefix(ClassDescriptor classDescriptor, StringBuilder sb) { sb.append(renderKeyword(DescriptorRenderer.Companion.getClassifierKindPrefix(classDescriptor))); } private final void renderCompanionObjectName(DeclarationDescriptor declarationDescriptor, StringBuilder sb) { if (getRenderCompanionObjectName()) { if (getStartFromName()) { sb.append("companion object"); } renderSpaceIfNeeded(sb); DeclarationDescriptor containingDeclaration = declarationDescriptor.getContainingDeclaration(); if (containingDeclaration != null) { sb.append("of "); Name name = containingDeclaration.getName(); cr4.f(name, "getName(...)"); sb.append(renderName(name, false)); } } if (getVerbose() || !cr4.b(declarationDescriptor.getName(), SpecialNames.DEFAULT_NAME_FOR_COMPANION_OBJECT)) { if (!getStartFromName()) { renderSpaceIfNeeded(sb); } Name name2 = declarationDescriptor.getName(); cr4.f(name2, "getName(...)"); sb.append(renderName(name2, true)); } } private final String renderConstant(ConstantValue constantValue) { sq3, String> propertyConstantRenderer = this.options.getPropertyConstantRenderer(); if (propertyConstantRenderer != null) { return (String) propertyConstantRenderer.invoke(constantValue); } if (constantValue instanceof ArrayValue) { List> value = ((ArrayValue) constantValue).getValue(); ArrayList arrayList = new ArrayList(); Iterator it = value.iterator(); while (it.hasNext()) { String strRenderConstant = renderConstant((ConstantValue) it.next()); if (strRenderConstant != null) { arrayList.add(strRenderConstant); } } return y41.ai(arrayList, ", ", "{", "}", null, 56); } if (constantValue instanceof AnnotationValue) { return n89.ai(DescriptorRenderer.renderAnnotation$default(this, ((AnnotationValue) constantValue).getValue(), null, 2, null), "@"); } if (!(constantValue instanceof KClassValue)) { return constantValue.toString(); } KClassValue.Value value2 = ((KClassValue) constantValue).getValue(); if (value2 instanceof KClassValue.Value.LocalClass) { return ((KClassValue.Value.LocalClass) value2).getType() + "::class"; } if (!(value2 instanceof KClassValue.Value.NormalClass)) { throw new io6(); } KClassValue.Value.NormalClass normalClass = (KClassValue.Value.NormalClass) value2; String strAsString = normalClass.getClassId().asSingleFqName().asString(); int arrayDimensions = normalClass.getArrayDimensions(); for (int i = 0; i < arrayDimensions; i++) { strAsString = n41.g('>', "kotlin.Array<", strAsString); } return vw2.k(strAsString, "::class"); } /* JADX INFO: Access modifiers changed from: private */ /* JADX WARN: Removed duplicated region for block: B:9:0x0030 */ /* Code decompiled incorrectly, please refer to instructions dump. */ public final void renderConstructor(ConstructorDescriptor constructorDescriptor, StringBuilder sb) { boolean z; ClassConstructorDescriptor classConstructorDescriptorMo164getUnsubstitutedPrimaryConstructor; renderAnnotations$default(this, sb, constructorDescriptor, null, 2, null); if (this.options.getRenderDefaultVisibility() || constructorDescriptor.getConstructedClass().getModality() != Modality.SEALED) { DescriptorVisibility visibility = constructorDescriptor.getVisibility(); cr4.f(visibility, "getVisibility(...)"); z = renderVisibility(visibility, sb); } renderMemberKind(constructorDescriptor, sb); boolean z2 = getRenderConstructorKeyword() || !constructorDescriptor.isPrimary() || z; if (z2) { sb.append(renderKeyword("constructor")); } ClassifierDescriptorWithTypeParameters containingDeclaration = constructorDescriptor.getContainingDeclaration(); cr4.f(containingDeclaration, "getContainingDeclaration(...)"); if (getSecondaryConstructorsAsPrimary()) { if (z2) { sb.append(" "); } renderName(containingDeclaration, sb, true); List typeParameters = constructorDescriptor.getTypeParameters(); cr4.f(typeParameters, "getTypeParameters(...)"); renderTypeParameters(typeParameters, sb, false); } List valueParameters = constructorDescriptor.getValueParameters(); cr4.f(valueParameters, "getValueParameters(...)"); renderValueParameters(valueParameters, constructorDescriptor.hasSynthesizedParameterNames(), sb); if (getRenderConstructorDelegation() && !constructorDescriptor.isPrimary() && (containingDeclaration instanceof ClassDescriptor) && (classConstructorDescriptorMo164getUnsubstitutedPrimaryConstructor = ((ClassDescriptor) containingDeclaration).mo164getUnsubstitutedPrimaryConstructor()) != null) { List valueParameters2 = classConstructorDescriptorMo164getUnsubstitutedPrimaryConstructor.getValueParameters(); cr4.f(valueParameters2, "getValueParameters(...)"); ArrayList arrayList = new ArrayList(); for (Object obj : valueParameters2) { ValueParameterDescriptor valueParameterDescriptor = (ValueParameterDescriptor) obj; if (!valueParameterDescriptor.declaresDefaultValue() && valueParameterDescriptor.getVarargElementType() == null) { arrayList.add(obj); } } if (!arrayList.isEmpty()) { sb.append(" : "); sb.append(renderKeyword("this")); sb.append(y41.ai(arrayList, ", ", "(", ")", new sq3() { // from class: kotlin.reflect.jvm.internal.impl.renderer.DescriptorRendererImpl$$Lambda$3 @Override // defpackage.sq3 public Object invoke(Object obj2) { return DescriptorRendererImpl.renderConstructor$lambda$26((ValueParameterDescriptor) obj2); } }, 24)); } } if (getSecondaryConstructorsAsPrimary()) { List typeParameters2 = constructorDescriptor.getTypeParameters(); cr4.f(typeParameters2, "getTypeParameters(...)"); renderWhereSuffix(typeParameters2, sb); } } /* JADX INFO: Access modifiers changed from: private */ public static final CharSequence renderConstructor$lambda$26(ValueParameterDescriptor valueParameterDescriptor) { return ""; } private final void renderContextReceivers(List list, StringBuilder sb) { if (list.isEmpty()) { return; } sb.append("context("); int i = 0; for (ReceiverParameterDescriptor receiverParameterDescriptor : list) { int i2 = i + 1; renderAnnotations(sb, receiverParameterDescriptor, AnnotationUseSiteTarget.RECEIVER); KotlinType type = receiverParameterDescriptor.getType(); cr4.f(type, "getType(...)"); sb.append(renderForReceiver(type)); if (i == y41.ae(list)) { sb.append(") "); } else { sb.append(", "); } i = i2; } } private final void renderDefaultType(StringBuilder sb, KotlinType kotlinType) { renderAnnotations$default(this, sb, kotlinType, null, 2, null); DefinitelyNotNullType definitelyNotNullType = kotlinType instanceof DefinitelyNotNullType ? (DefinitelyNotNullType) kotlinType : null; SimpleType original = definitelyNotNullType != null ? definitelyNotNullType.getOriginal() : null; if (KotlinTypeKt.isError(kotlinType)) { if (TypeUtilsKt.isUnresolvedType(kotlinType) && getPresentableUnresolvedTypes()) { sb.append(renderError(ErrorUtils.INSTANCE.unresolvedTypeAsItIs(kotlinType))); } else { if (!(kotlinType instanceof ErrorType) || getInformativeErrorType()) { sb.append(kotlinType.getConstructor().toString()); } else { sb.append(((ErrorType) kotlinType).getDebugMessage()); } sb.append(renderTypeArguments(kotlinType.getArguments())); } } else if (kotlinType instanceof StubTypeForBuilderInference) { sb.append(((StubTypeForBuilderInference) kotlinType).getOriginalTypeVariable().toString()); } else if (original instanceof StubTypeForBuilderInference) { sb.append(((StubTypeForBuilderInference) original).getOriginalTypeVariable().toString()); } else { renderTypeConstructorAndArguments$default(this, sb, kotlinType, null, 2, null); } if (kotlinType.isMarkedNullable()) { sb.append("?"); } if (SpecialTypesKt.isDefinitelyNotNullType(kotlinType)) { sb.append(" & Any"); } } private final String renderError(String str) { int i = WhenMappings.$EnumSwitchMapping$0[getTextFormat().ordinal()]; if (i == 1) { return str; } if (i == 2) { return vw2.ab("", str, ""); } throw new io6(); } private final void renderExpandedTypeComment(StringBuilder sb, AbbreviatedType abbreviatedType) { RenderingFormat textFormat = getTextFormat(); RenderingFormat renderingFormat = RenderingFormat.HTML; if (textFormat == renderingFormat) { sb.append(""); } sb.append(" /* "); sb.append("= "); renderNormalizedTypeAsIs(sb, abbreviatedType.getExpandedType()); sb.append(" */"); if (getTextFormat() == renderingFormat) { sb.append(""); } } private final String renderForReceiver(KotlinType kotlinType) { String strRenderType = renderType(kotlinType); return ((!shouldRenderAsPrettyFunctionType(kotlinType) || TypeUtils.isNullableType(kotlinType)) && !(kotlinType instanceof DefinitelyNotNullType)) ? strRenderType : n41.g(')', "(", strRenderType); } /* JADX INFO: Access modifiers changed from: private */ public final void renderFunction(FunctionDescriptor functionDescriptor, StringBuilder sb) { FunctionDescriptor functionDescriptor2; StringBuilder sb2; if (getStartFromName()) { functionDescriptor2 = functionDescriptor; sb2 = sb; } else { if (getStartFromDeclarationKeyword()) { functionDescriptor2 = functionDescriptor; sb2 = sb; } else { List contextReceiverParameters = functionDescriptor.getContextReceiverParameters(); cr4.f(contextReceiverParameters, "getContextReceiverParameters(...)"); renderContextReceivers(contextReceiverParameters, sb); functionDescriptor2 = functionDescriptor; sb2 = sb; renderAnnotations$default(this, sb2, functionDescriptor2, null, 2, null); DescriptorVisibility visibility = functionDescriptor2.getVisibility(); cr4.f(visibility, "getVisibility(...)"); renderVisibility(visibility, sb2); renderModalityForCallable(functionDescriptor2, sb2); if (getIncludeAdditionalModifiers()) { renderMemberModifiers(functionDescriptor2, sb2); } renderOverride(functionDescriptor2, sb2); if (getIncludeAdditionalModifiers()) { renderAdditionalModifiers(functionDescriptor2, sb2); } else { renderSuspendModifier(functionDescriptor2, sb2); } renderMemberKind(functionDescriptor2, sb2); if (getVerbose()) { if (functionDescriptor2.isHiddenToOvercomeSignatureClash()) { sb2.append("/*isHiddenToOvercomeSignatureClash*/ "); } if (functionDescriptor2.isHiddenForResolutionEverywhereBesideSupercalls()) { sb2.append("/*isHiddenForResolutionEverywhereBesideSupercalls*/ "); } } } sb2.append(renderKeyword("fun")); sb2.append(" "); List typeParameters = functionDescriptor2.getTypeParameters(); cr4.f(typeParameters, "getTypeParameters(...)"); renderTypeParameters(typeParameters, sb2, true); renderReceiver(functionDescriptor2, sb2); } renderName(functionDescriptor2, sb2, true); List valueParameters = functionDescriptor2.getValueParameters(); cr4.f(valueParameters, "getValueParameters(...)"); renderValueParameters(valueParameters, functionDescriptor2.hasSynthesizedParameterNames(), sb2); renderReceiverAfterName(functionDescriptor2, sb2); KotlinType returnType = functionDescriptor2.getReturnType(); if (!getWithoutReturnType() && (getUnitReturnType() || returnType == null || !KotlinBuiltIns.isUnit(returnType))) { sb2.append(": "); sb2.append(returnType == null ? "[NULL]" : renderType(returnType)); } List typeParameters2 = functionDescriptor2.getTypeParameters(); cr4.f(typeParameters2, "getTypeParameters(...)"); renderWhereSuffix(typeParameters2, sb2); } private final void renderFunctionType(StringBuilder sb, KotlinType kotlinType) { Name nameExtractParameterNameFromFunctionTypeArgument; int length = sb.length(); renderAnnotations$default(getFunctionTypeAnnotationsRenderer(), sb, kotlinType, null, 2, null); boolean z = sb.length() != length; KotlinType receiverTypeFromFunctionType = FunctionTypesKt.getReceiverTypeFromFunctionType(kotlinType); List contextReceiverTypesFromFunctionType = FunctionTypesKt.getContextReceiverTypesFromFunctionType(kotlinType); boolean zIsSuspendFunctionType = FunctionTypesKt.isSuspendFunctionType(kotlinType); boolean zIsMarkedNullable = kotlinType.isMarkedNullable(); boolean z2 = zIsMarkedNullable || (z && receiverTypeFromFunctionType != null); if (z2) { if (zIsSuspendFunctionType) { sb.insert(length, '('); } else { if (z) { vy0.c(n89.ac(sb)); if (sb.charAt(n89.x(sb) - 1) != ')') { sb.insert(n89.x(sb), "()"); } } sb.append("("); } } if (!contextReceiverTypesFromFunctionType.isEmpty()) { sb.append("context("); Iterator it = contextReceiverTypesFromFunctionType.subList(0, y41.ae(contextReceiverTypesFromFunctionType)).iterator(); while (it.hasNext()) { renderNormalizedType(sb, it.next()); sb.append(", "); } renderNormalizedType(sb, (KotlinType) y41.ak(contextReceiverTypesFromFunctionType)); sb.append(") "); } renderModifier(sb, zIsSuspendFunctionType, "suspend"); if (receiverTypeFromFunctionType != null) { boolean z3 = (shouldRenderAsPrettyFunctionType(receiverTypeFromFunctionType) && !receiverTypeFromFunctionType.isMarkedNullable()) || hasModifiersOrAnnotations(receiverTypeFromFunctionType) || (receiverTypeFromFunctionType instanceof DefinitelyNotNullType); if (z3) { sb.append("("); } renderNormalizedType(sb, receiverTypeFromFunctionType); if (z3) { sb.append(")"); } sb.append("."); } sb.append("("); if (!FunctionTypesKt.isBuiltinExtensionFunctionalType(kotlinType) || kotlinType.getArguments().size() > 1) { int i = 0; for (TypeProjection typeProjection : FunctionTypesKt.getValueParameterTypesFromFunctionType(kotlinType)) { int i2 = i + 1; if (i > 0) { sb.append(", "); } if (getParameterNamesInFunctionalTypes()) { KotlinType type = typeProjection.getType(); cr4.f(type, "getType(...)"); nameExtractParameterNameFromFunctionTypeArgument = FunctionTypesKt.extractParameterNameFromFunctionTypeArgument(type); } else { nameExtractParameterNameFromFunctionTypeArgument = null; } if (nameExtractParameterNameFromFunctionTypeArgument != null) { sb.append(renderName(nameExtractParameterNameFromFunctionTypeArgument, false)); sb.append(": "); } sb.append(renderTypeProjection(typeProjection)); i = i2; } } else { sb.append("???"); } sb.append(") "); sb.append(arrow()); sb.append(" "); renderNormalizedType(sb, FunctionTypesKt.getReturnTypeFromFunctionType(kotlinType)); if (z2) { sb.append(")"); } if (zIsMarkedNullable) { sb.append("?"); } } private final void renderInitializer(VariableDescriptor variableDescriptor, StringBuilder sb) { ConstantValue constantValueMo166getCompileTimeInitializer; String strRenderConstant; if (!getIncludePropertyConstant() || (constantValueMo166getCompileTimeInitializer = variableDescriptor.mo166getCompileTimeInitializer()) == null || (strRenderConstant = renderConstant(constantValueMo166getCompileTimeInitializer)) == null) { return; } sb.append(" = "); sb.append(escape(strRenderConstant)); } private final String renderKeyword(String str) { int i = WhenMappings.$EnumSwitchMapping$0[getTextFormat().ordinal()]; if (i != 1) { if (i != 2) { throw new io6(); } if (!getBoldOnlyForNamesInHtml()) { return vw2.ab("", str, ""); } } return str; } private final void renderMemberKind(CallableMemberDescriptor callableMemberDescriptor, StringBuilder sb) { if (getModifiers().contains(DescriptorRendererModifier.MEMBER_KIND) && getVerbose() && callableMemberDescriptor.getKind() != CallableMemberDescriptor.Kind.DECLARATION) { sb.append("/*"); sb.append(CapitalizeDecapitalizeKt.toLowerCaseAsciiOnly(callableMemberDescriptor.getKind().name())); sb.append("*/ "); } } private final void renderMemberModifiers(MemberDescriptor memberDescriptor, StringBuilder sb) { renderModifier(sb, memberDescriptor.isExternal(), "external"); boolean z = false; renderModifier(sb, getModifiers().contains(DescriptorRendererModifier.EXPECT) && memberDescriptor.isExpect(), "expect"); if (getModifiers().contains(DescriptorRendererModifier.ACTUAL) && memberDescriptor.isActual()) { z = true; } renderModifier(sb, z, "actual"); } private final void renderModality(Modality modality, StringBuilder sb, Modality modality2) { if (getRenderDefaultModality() || modality != modality2) { renderModifier(sb, getModifiers().contains(DescriptorRendererModifier.MODALITY), CapitalizeDecapitalizeKt.toLowerCaseAsciiOnly(modality.name())); } } private final void renderModalityForCallable(CallableMemberDescriptor callableMemberDescriptor, StringBuilder sb) { if (DescriptorUtils.isTopLevelDeclaration(callableMemberDescriptor) && callableMemberDescriptor.getModality() == Modality.FINAL) { return; } if (getOverrideRenderingPolicy() == OverrideRenderingPolicy.RENDER_OVERRIDE && callableMemberDescriptor.getModality() == Modality.OPEN && overridesSomething(callableMemberDescriptor)) { return; } Modality modality = callableMemberDescriptor.getModality(); cr4.f(modality, "getModality(...)"); renderModality(modality, sb, implicitModalityWithoutExtensions(callableMemberDescriptor)); } private final void renderModifier(StringBuilder sb, boolean z, String str) { if (z) { sb.append(renderKeyword(str)); sb.append(" "); } } private final void renderNormalizedType(StringBuilder sb, KotlinType kotlinType) { UnwrappedType unwrappedTypeUnwrap = kotlinType.unwrap(); AbbreviatedType abbreviatedType = unwrappedTypeUnwrap instanceof AbbreviatedType ? (AbbreviatedType) unwrappedTypeUnwrap : null; if (abbreviatedType == null) { renderNormalizedTypeAsIs(sb, kotlinType); return; } if (getRenderTypeExpansions()) { renderNormalizedTypeAsIs(sb, abbreviatedType.getExpandedType()); if (getRenderAbbreviatedTypeComments()) { renderAbbreviatedTypeComment(sb, abbreviatedType); return; } return; } renderNormalizedTypeAsIs(sb, abbreviatedType.getAbbreviation()); if (getRenderUnabbreviatedType()) { renderExpandedTypeComment(sb, abbreviatedType); } } private final void renderNormalizedTypeAsIs(StringBuilder sb, KotlinType kotlinType) { if ((kotlinType instanceof WrappedType) && getDebugMode() && !((WrappedType) kotlinType).isComputed()) { sb.append(""); return; } UnwrappedType unwrappedTypeUnwrap = kotlinType.unwrap(); if (unwrappedTypeUnwrap instanceof FlexibleType) { sb.append(((FlexibleType) unwrappedTypeUnwrap).render(this, this)); } else { if (!(unwrappedTypeUnwrap instanceof SimpleType)) { throw new io6(); } renderSimpleType(sb, (SimpleType) unwrappedTypeUnwrap); } } private final void renderOverride(CallableMemberDescriptor callableMemberDescriptor, StringBuilder sb) { if (getModifiers().contains(DescriptorRendererModifier.OVERRIDE) && overridesSomething(callableMemberDescriptor) && getOverrideRenderingPolicy() != OverrideRenderingPolicy.RENDER_OPEN) { renderModifier(sb, true, "override"); if (getVerbose()) { sb.append("/*"); sb.append(callableMemberDescriptor.getOverriddenDescriptors().size()); sb.append("*/ "); } } } /* JADX INFO: Access modifiers changed from: private */ public final void renderPackageFragment(PackageFragmentDescriptor packageFragmentDescriptor, StringBuilder sb) { renderPackageHeader(packageFragmentDescriptor.getFqName(), "package-fragment", sb); if (getDebugMode()) { sb.append(" in "); renderName(packageFragmentDescriptor.getContainingDeclaration(), sb, false); } } private final void renderPackageHeader(FqName fqName, String str, StringBuilder sb) { sb.append(renderKeyword(str)); String strRenderFqName = renderFqName(fqName.toUnsafe()); if (strRenderFqName.length() > 0) { sb.append(" "); sb.append(strRenderFqName); } } /* JADX INFO: Access modifiers changed from: private */ public final void renderPackageView(PackageViewDescriptor packageViewDescriptor, StringBuilder sb) { renderPackageHeader(packageViewDescriptor.getFqName(), "package", sb); if (getDebugMode()) { sb.append(" in context of "); renderName(packageViewDescriptor.getModule(), sb, false); } } private final void renderPossiblyInnerType(StringBuilder sb, PossiblyInnerType possiblyInnerType) { PossiblyInnerType outerType = possiblyInnerType.getOuterType(); if (outerType != null) { renderPossiblyInnerType(sb, outerType); sb.append('.'); Name name = possiblyInnerType.getClassifierDescriptor().getName(); cr4.f(name, "getName(...)"); sb.append(renderName(name, false)); } else { TypeConstructor typeConstructor = possiblyInnerType.getClassifierDescriptor().getTypeConstructor(); cr4.f(typeConstructor, "getTypeConstructor(...)"); sb.append(renderTypeConstructor(typeConstructor)); } sb.append(renderTypeArguments(possiblyInnerType.getArguments())); } /* JADX INFO: Access modifiers changed from: private */ public final void renderProperty(PropertyDescriptor propertyDescriptor, StringBuilder sb) { PropertyDescriptor propertyDescriptor2; StringBuilder sb2; if (getStartFromName()) { propertyDescriptor2 = propertyDescriptor; sb2 = sb; } else { if (!getStartFromDeclarationKeyword()) { List contextReceiverParameters = propertyDescriptor.getContextReceiverParameters(); cr4.f(contextReceiverParameters, "getContextReceiverParameters(...)"); renderContextReceivers(contextReceiverParameters, sb); renderPropertyAnnotations(propertyDescriptor, sb); DescriptorVisibility visibility = propertyDescriptor.getVisibility(); cr4.f(visibility, "getVisibility(...)"); renderVisibility(visibility, sb); boolean z = false; renderModifier(sb, getModifiers().contains(DescriptorRendererModifier.CONST) && propertyDescriptor.isConst(), "const"); renderMemberModifiers(propertyDescriptor, sb); renderModalityForCallable(propertyDescriptor, sb); renderOverride(propertyDescriptor, sb); if (getModifiers().contains(DescriptorRendererModifier.LATEINIT) && propertyDescriptor.isLateInit()) { z = true; } renderModifier(sb, z, "lateinit"); renderMemberKind(propertyDescriptor, sb); } propertyDescriptor2 = propertyDescriptor; sb2 = sb; renderValVarPrefix$default(this, propertyDescriptor2, sb2, false, 4, null); List typeParameters = propertyDescriptor2.getTypeParameters(); cr4.f(typeParameters, "getTypeParameters(...)"); renderTypeParameters(typeParameters, sb2, true); renderReceiver(propertyDescriptor2, sb2); } renderName(propertyDescriptor2, sb2, true); sb2.append(": "); KotlinType type = propertyDescriptor2.getType(); cr4.f(type, "getType(...)"); sb2.append(renderType(type)); renderReceiverAfterName(propertyDescriptor2, sb2); renderInitializer(propertyDescriptor2, sb2); List typeParameters2 = propertyDescriptor2.getTypeParameters(); cr4.f(typeParameters2, "getTypeParameters(...)"); renderWhereSuffix(typeParameters2, sb2); } private final void renderPropertyAnnotations(PropertyDescriptor propertyDescriptor, StringBuilder sb) { if (getModifiers().contains(DescriptorRendererModifier.ANNOTATIONS)) { renderAnnotations$default(this, sb, propertyDescriptor, null, 2, null); FieldDescriptor backingField = propertyDescriptor.getBackingField(); if (backingField != null) { renderAnnotations(sb, backingField, AnnotationUseSiteTarget.FIELD); } FieldDescriptor delegateField = propertyDescriptor.getDelegateField(); if (delegateField != null) { renderAnnotations(sb, delegateField, AnnotationUseSiteTarget.PROPERTY_DELEGATE_FIELD); } if (getPropertyAccessorRenderingPolicy() == PropertyAccessorRenderingPolicy.NONE) { PropertyGetterDescriptor getter = propertyDescriptor.getGetter(); if (getter != null) { renderAnnotations(sb, getter, AnnotationUseSiteTarget.PROPERTY_GETTER); } PropertySetterDescriptor setter = propertyDescriptor.getSetter(); if (setter != null) { renderAnnotations(sb, setter, AnnotationUseSiteTarget.PROPERTY_SETTER); List valueParameters = setter.getValueParameters(); cr4.f(valueParameters, "getValueParameters(...)"); ValueParameterDescriptor valueParameterDescriptor = (ValueParameterDescriptor) y41.bd(valueParameters); cr4.d(valueParameterDescriptor); renderAnnotations(sb, valueParameterDescriptor, AnnotationUseSiteTarget.SETTER_PARAMETER); } } } } private final void renderReceiver(CallableDescriptor callableDescriptor, StringBuilder sb) { ReceiverParameterDescriptor extensionReceiverParameter = callableDescriptor.getExtensionReceiverParameter(); if (extensionReceiverParameter != null) { renderAnnotations(sb, extensionReceiverParameter, AnnotationUseSiteTarget.RECEIVER); KotlinType type = extensionReceiverParameter.getType(); cr4.f(type, "getType(...)"); sb.append(renderForReceiver(type)); sb.append("."); } } private final void renderReceiverAfterName(CallableDescriptor callableDescriptor, StringBuilder sb) { ReceiverParameterDescriptor extensionReceiverParameter; if (getReceiverAfterName() && (extensionReceiverParameter = callableDescriptor.getExtensionReceiverParameter()) != null) { sb.append(" on "); KotlinType type = extensionReceiverParameter.getType(); cr4.f(type, "getType(...)"); sb.append(renderType(type)); } } private final void renderSimpleType(StringBuilder sb, SimpleType simpleType) { if (cr4.b(simpleType, TypeUtils.CANNOT_INFER_FUNCTION_PARAM_TYPE) || TypeUtils.isDontCarePlaceholder(simpleType)) { sb.append("???"); return; } if (ErrorUtils.isUninferredTypeVariable(simpleType)) { if (!getUninferredTypeParameterAsName()) { sb.append("???"); return; } TypeConstructor constructor = simpleType.getConstructor(); cr4.e(constructor, "null cannot be cast to non-null type org.jetbrains.kotlin.types.error.ErrorTypeConstructor"); sb.append(renderError(((ErrorTypeConstructor) constructor).getParam(0))); return; } if (KotlinTypeKt.isError(simpleType)) { renderDefaultType(sb, simpleType); } else if (shouldRenderAsPrettyFunctionType(simpleType)) { renderFunctionType(sb, simpleType); } else { renderDefaultType(sb, simpleType); } } private final void renderSpaceIfNeeded(StringBuilder sb) { int length = sb.length(); if (length == 0 || sb.charAt(length - 1) != ' ') { sb.append(' '); } } private final void renderSuperTypes(ClassDescriptor classDescriptor, StringBuilder sb) { if (getWithoutSuperTypes() || KotlinBuiltIns.isNothing(classDescriptor.getDefaultType())) { return; } Collection collectionMo171getSupertypes = classDescriptor.getTypeConstructor().mo171getSupertypes(); cr4.f(collectionMo171getSupertypes, "getSupertypes(...)"); if (collectionMo171getSupertypes.isEmpty()) { return; } if (collectionMo171getSupertypes.size() == 1 && KotlinBuiltIns.isAnyOrNullableAny(collectionMo171getSupertypes.iterator().next())) { return; } renderSpaceIfNeeded(sb); sb.append(": "); y41.ah(collectionMo171getSupertypes, sb, ", ", null, null, new sq3(this) { // from class: kotlin.reflect.jvm.internal.impl.renderer.DescriptorRendererImpl$$Lambda$4 private final DescriptorRendererImpl arg$0; { this.arg$0 = this; } @Override // defpackage.sq3 public Object invoke(Object obj) { return DescriptorRendererImpl.renderSuperTypes$lambda$36(this.arg$0, (KotlinType) obj); } }, 60); } /* JADX INFO: Access modifiers changed from: private */ public static final CharSequence renderSuperTypes$lambda$36(DescriptorRendererImpl descriptorRendererImpl, KotlinType kotlinType) { cr4.d(kotlinType); return descriptorRendererImpl.renderType(kotlinType); } private final void renderSuspendModifier(FunctionDescriptor functionDescriptor, StringBuilder sb) { renderModifier(sb, functionDescriptor.isSuspend(), "suspend"); } /* JADX INFO: Access modifiers changed from: private */ public final void renderTypeAlias(TypeAliasDescriptor typeAliasDescriptor, StringBuilder sb) { renderAnnotations$default(this, sb, typeAliasDescriptor, null, 2, null); DescriptorVisibility visibility = typeAliasDescriptor.getVisibility(); cr4.f(visibility, "getVisibility(...)"); renderVisibility(visibility, sb); renderMemberModifiers(typeAliasDescriptor, sb); sb.append(renderKeyword("typealias")); sb.append(" "); renderName(typeAliasDescriptor, sb, true); List declaredTypeParameters = typeAliasDescriptor.getDeclaredTypeParameters(); cr4.f(declaredTypeParameters, "getDeclaredTypeParameters(...)"); renderTypeParameters(declaredTypeParameters, sb, false); renderCapturedTypeParametersIfRequired(typeAliasDescriptor, sb); sb.append(" = "); sb.append(renderType(typeAliasDescriptor.getUnderlyingType())); } /* JADX INFO: Access modifiers changed from: private */ public static final Object renderTypeConstructor$lambda$8(KotlinType kotlinType) { cr4.g(kotlinType, "it"); return kotlinType instanceof StubTypeForBuilderInference ? ((StubTypeForBuilderInference) kotlinType).getOriginalTypeVariable() : kotlinType; } private final void renderTypeConstructorAndArguments(StringBuilder sb, KotlinType kotlinType, TypeConstructor typeConstructor) { PossiblyInnerType possiblyInnerTypeBuildPossiblyInnerType = TypeParameterUtilsKt.buildPossiblyInnerType(kotlinType); if (possiblyInnerTypeBuildPossiblyInnerType != null) { renderPossiblyInnerType(sb, possiblyInnerTypeBuildPossiblyInnerType); } else { sb.append(renderTypeConstructor(typeConstructor)); sb.append(renderTypeArguments(kotlinType.getArguments())); } } public static /* synthetic */ void renderTypeConstructorAndArguments$default(DescriptorRendererImpl descriptorRendererImpl, StringBuilder sb, KotlinType kotlinType, TypeConstructor typeConstructor, int i, Object obj) { if ((i & 2) != 0) { typeConstructor = kotlinType.getConstructor(); } descriptorRendererImpl.renderTypeConstructorAndArguments(sb, kotlinType, typeConstructor); } /* JADX INFO: Access modifiers changed from: private */ public final void renderTypeParameter(TypeParameterDescriptor typeParameterDescriptor, StringBuilder sb, boolean z) { if (z) { sb.append(lt()); } if (getVerbose()) { sb.append("/*"); sb.append(typeParameterDescriptor.getIndex()); sb.append("*/ "); } renderModifier(sb, typeParameterDescriptor.isReified(), "reified"); String label = typeParameterDescriptor.getVariance().getLabel(); boolean z2 = true; renderModifier(sb, label.length() > 0, label); renderAnnotations$default(this, sb, typeParameterDescriptor, null, 2, null); renderName(typeParameterDescriptor, sb, z); int size = typeParameterDescriptor.getUpperBounds().size(); if ((size > 1 && !z) || size == 1) { KotlinType next = typeParameterDescriptor.getUpperBounds().iterator().next(); if (!KotlinBuiltIns.isDefaultBound(next)) { sb.append(" : "); cr4.d(next); sb.append(renderType(next)); } } else if (z) { for (KotlinType kotlinType : typeParameterDescriptor.getUpperBounds()) { if (!KotlinBuiltIns.isDefaultBound(kotlinType)) { if (z2) { sb.append(" : "); } else { sb.append(" & "); } cr4.d(kotlinType); sb.append(renderType(kotlinType)); z2 = false; } } } if (z) { sb.append(gt()); } } private final void renderTypeParameterList(StringBuilder sb, List list) { Iterator it = list.iterator(); while (it.hasNext()) { renderTypeParameter(it.next(), sb, false); if (it.hasNext()) { sb.append(", "); } } } private final void renderTypeParameters(List list, StringBuilder sb, boolean z) { if (getWithoutTypeParameters() || list.isEmpty()) { return; } sb.append(lt()); renderTypeParameterList(sb, list); sb.append(gt()); if (z) { sb.append(" "); } } private final void renderValVarPrefix(VariableDescriptor variableDescriptor, StringBuilder sb, boolean z) { if (z || !(variableDescriptor instanceof ValueParameterDescriptor)) { sb.append(renderKeyword(variableDescriptor.isVar() ? "var" : "val")); sb.append(" "); } } public static /* synthetic */ void renderValVarPrefix$default(DescriptorRendererImpl descriptorRendererImpl, VariableDescriptor variableDescriptor, StringBuilder sb, boolean z, int i, Object obj) { if ((i & 4) != 0) { z = false; } descriptorRendererImpl.renderValVarPrefix(variableDescriptor, sb, z); } /* JADX INFO: Access modifiers changed from: private */ /* JADX WARN: Removed duplicated region for block: B:17:0x0060 */ /* Code decompiled incorrectly, please refer to instructions dump. */ public final void renderValueParameter(ValueParameterDescriptor valueParameterDescriptor, boolean z, StringBuilder sb, boolean z2) { boolean z3; if (z2) { sb.append(renderKeyword("value-parameter")); sb.append(" "); } if (getVerbose()) { sb.append("/*"); sb.append(valueParameterDescriptor.getIndex()); sb.append("*/ "); } renderAnnotations$default(this, sb, valueParameterDescriptor, null, 2, null); renderModifier(sb, valueParameterDescriptor.isCrossinline(), "crossinline"); renderModifier(sb, valueParameterDescriptor.isNoinline(), "noinline"); boolean z4 = false; if (getRenderPrimaryConstructorParametersAsProperties()) { CallableDescriptor containingDeclaration = valueParameterDescriptor.getContainingDeclaration(); ClassConstructorDescriptor classConstructorDescriptor = containingDeclaration instanceof ClassConstructorDescriptor ? (ClassConstructorDescriptor) containingDeclaration : null; z3 = classConstructorDescriptor != null && classConstructorDescriptor.isPrimary(); } if (z3) { renderModifier(sb, getActualPropertiesInPrimaryConstructor(), "actual"); } renderVariable(valueParameterDescriptor, z, sb, z2, z3); if (getDefaultParameterValueRenderer() != null) { if (getDebugMode() ? valueParameterDescriptor.declaresDefaultValue() : DescriptorUtilsKt.declaresOrInheritsDefaultValue(valueParameterDescriptor)) { z4 = true; } } if (z4) { StringBuilder sb2 = new StringBuilder(" = "); sq3 defaultParameterValueRenderer = getDefaultParameterValueRenderer(); cr4.d(defaultParameterValueRenderer); sb2.append((String) defaultParameterValueRenderer.invoke(valueParameterDescriptor)); sb.append(sb2.toString()); } } private final void renderValueParameters(Collection collection, boolean z, StringBuilder sb) { boolean zShouldRenderParameterNames = shouldRenderParameterNames(z); int size = collection.size(); getValueParametersHandler().appendBeforeValueParameters(size, sb); int i = 0; for (ValueParameterDescriptor valueParameterDescriptor : collection) { getValueParametersHandler().appendBeforeValueParameter(valueParameterDescriptor, i, size, sb); renderValueParameter(valueParameterDescriptor, zShouldRenderParameterNames, sb, false); getValueParametersHandler().appendAfterValueParameter(valueParameterDescriptor, i, size, sb); i++; } getValueParametersHandler().appendAfterValueParameters(size, sb); } private final void renderVariable(VariableDescriptor variableDescriptor, boolean z, StringBuilder sb, boolean z2, boolean z3) { KotlinType type = variableDescriptor.getType(); cr4.f(type, "getType(...)"); ValueParameterDescriptor valueParameterDescriptor = variableDescriptor instanceof ValueParameterDescriptor ? (ValueParameterDescriptor) variableDescriptor : null; KotlinType varargElementType = valueParameterDescriptor != null ? valueParameterDescriptor.getVarargElementType() : null; KotlinType kotlinType = varargElementType == null ? type : varargElementType; renderModifier(sb, varargElementType != null, "vararg"); if (z3 || (z2 && !getStartFromName())) { renderValVarPrefix(variableDescriptor, sb, z3); } if (z) { renderName(variableDescriptor, sb, z2); sb.append(": "); } sb.append(renderType(kotlinType)); renderInitializer(variableDescriptor, sb); if (!getVerbose() || varargElementType == null) { return; } sb.append(" /*"); sb.append(renderType(type)); sb.append("*/"); } private final boolean renderVisibility(DescriptorVisibility descriptorVisibility, StringBuilder sb) { if (!getModifiers().contains(DescriptorRendererModifier.VISIBILITY)) { return false; } if (getNormalizedVisibilities()) { descriptorVisibility = descriptorVisibility.normalize(); } if (!getRenderDefaultVisibility() && cr4.b(descriptorVisibility, DescriptorVisibilities.DEFAULT_VISIBILITY)) { return false; } sb.append(renderKeyword(descriptorVisibility.getInternalDisplayName())); sb.append(" "); return true; } private final void renderWhereSuffix(List list, StringBuilder sb) { if (getWithoutTypeParameters()) { return; } ArrayList arrayList = new ArrayList(0); for (TypeParameterDescriptor typeParameterDescriptor : list) { List upperBounds = typeParameterDescriptor.getUpperBounds(); cr4.f(upperBounds, "getUpperBounds(...)"); for (KotlinType kotlinType : y41.u(upperBounds, 1)) { StringBuilder sb2 = new StringBuilder(); Name name = typeParameterDescriptor.getName(); cr4.f(name, "getName(...)"); sb2.append(renderName(name, false)); sb2.append(" : "); cr4.d(kotlinType); sb2.append(renderType(kotlinType)); arrayList.add(sb2.toString()); } } if (arrayList.isEmpty()) { return; } sb.append(" "); sb.append(renderKeyword("where")); sb.append(" "); y41.ah(arrayList, sb, ", ", null, null, null, 124); } private final boolean shouldRenderAsPrettyFunctionType(KotlinType kotlinType) { if (!FunctionTypesKt.isBuiltinFunctionalType(kotlinType)) { return false; } List arguments = kotlinType.getArguments(); if ((arguments instanceof Collection) && arguments.isEmpty()) { return true; } Iterator it = arguments.iterator(); while (it.hasNext()) { if (((TypeProjection) it.next()).isStarProjection()) { return false; } } return true; } private final boolean shouldRenderParameterNames(boolean z) { int i = WhenMappings.$EnumSwitchMapping$1[getParameterNameRenderingPolicy().ordinal()]; if (i == 1) { return true; } if (i == 2) { return !z; } if (i == 3) { return false; } throw new io6(); } public boolean getActualPropertiesInPrimaryConstructor() { return this.options.getActualPropertiesInPrimaryConstructor(); } public boolean getAlwaysRenderModifiers() { return this.options.getAlwaysRenderModifiers(); } @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRendererOptions @kp6 public AnnotationArgumentsRenderingPolicy getAnnotationArgumentsRenderingPolicy() { return this.options.getAnnotationArgumentsRenderingPolicy(); } @pq6 public sq3 getAnnotationFilter() { return this.options.getAnnotationFilter(); } public boolean getBoldOnlyForNamesInHtml() { return this.options.getBoldOnlyForNamesInHtml(); } public boolean getClassWithPrimaryConstructor() { return this.options.getClassWithPrimaryConstructor(); } @kp6 public ClassifierNamePolicy getClassifierNamePolicy() { return this.options.getClassifierNamePolicy(); } @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRendererOptions public boolean getDebugMode() { return this.options.getDebugMode(); } @pq6 public sq3 getDefaultParameterValueRenderer() { return this.options.getDefaultParameterValueRenderer(); } public boolean getEachAnnotationOnNewLine() { return this.options.getEachAnnotationOnNewLine(); } @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRendererOptions public boolean getEnhancedTypes() { return this.options.getEnhancedTypes(); } @kp6 public Set getExcludedAnnotationClasses() { return this.options.getExcludedAnnotationClasses(); } @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRendererOptions @kp6 public Set getExcludedTypeAnnotationClasses() { return this.options.getExcludedTypeAnnotationClasses(); } public boolean getIncludeAdditionalModifiers() { return this.options.getIncludeAdditionalModifiers(); } public boolean getIncludeAnnotationArguments() { return this.options.getIncludeAnnotationArguments(); } public boolean getIncludeEmptyAnnotationArguments() { return this.options.getIncludeEmptyAnnotationArguments(); } public boolean getIncludePropertyConstant() { return this.options.getIncludePropertyConstant(); } public boolean getInformativeErrorType() { return this.options.getInformativeErrorType(); } @kp6 public Set getModifiers() { return this.options.getModifiers(); } public boolean getNormalizedVisibilities() { return this.options.getNormalizedVisibilities(); } @kp6 public final DescriptorRendererOptionsImpl getOptions() { return this.options; } @kp6 public OverrideRenderingPolicy getOverrideRenderingPolicy() { return this.options.getOverrideRenderingPolicy(); } @kp6 public ParameterNameRenderingPolicy getParameterNameRenderingPolicy() { return this.options.getParameterNameRenderingPolicy(); } public boolean getParameterNamesInFunctionalTypes() { return this.options.getParameterNamesInFunctionalTypes(); } public boolean getPresentableUnresolvedTypes() { return this.options.getPresentableUnresolvedTypes(); } @kp6 public PropertyAccessorRenderingPolicy getPropertyAccessorRenderingPolicy() { return this.options.getPropertyAccessorRenderingPolicy(); } public boolean getReceiverAfterName() { return this.options.getReceiverAfterName(); } public boolean getRenderAbbreviatedTypeComments() { return this.options.getRenderAbbreviatedTypeComments(); } public boolean getRenderCompanionObjectName() { return this.options.getRenderCompanionObjectName(); } public boolean getRenderConstructorDelegation() { return this.options.getRenderConstructorDelegation(); } public boolean getRenderConstructorKeyword() { return this.options.getRenderConstructorKeyword(); } public boolean getRenderDefaultAnnotationArguments() { return this.options.getRenderDefaultAnnotationArguments(); } public boolean getRenderDefaultModality() { return this.options.getRenderDefaultModality(); } public boolean getRenderDefaultVisibility() { return this.options.getRenderDefaultVisibility(); } public boolean getRenderPrimaryConstructorParametersAsProperties() { return this.options.getRenderPrimaryConstructorParametersAsProperties(); } public boolean getRenderTypeExpansions() { return this.options.getRenderTypeExpansions(); } public boolean getRenderUnabbreviatedType() { return this.options.getRenderUnabbreviatedType(); } public boolean getSecondaryConstructorsAsPrimary() { return this.options.getSecondaryConstructorsAsPrimary(); } public boolean getStartFromDeclarationKeyword() { return this.options.getStartFromDeclarationKeyword(); } public boolean getStartFromName() { return this.options.getStartFromName(); } @kp6 public RenderingFormat getTextFormat() { return this.options.getTextFormat(); } @kp6 public sq3 getTypeNormalizer() { return this.options.getTypeNormalizer(); } public boolean getUninferredTypeParameterAsName() { return this.options.getUninferredTypeParameterAsName(); } public boolean getUnitReturnType() { return this.options.getUnitReturnType(); } @kp6 public DescriptorRenderer.ValueParametersHandler getValueParametersHandler() { return this.options.getValueParametersHandler(); } public boolean getVerbose() { return this.options.getVerbose(); } public boolean getWithDefinedIn() { return this.options.getWithDefinedIn(); } public boolean getWithSourceFileForTopLevel() { return this.options.getWithSourceFileForTopLevel(); } public boolean getWithoutReturnType() { return this.options.getWithoutReturnType(); } public boolean getWithoutSuperTypes() { return this.options.getWithoutSuperTypes(); } public boolean getWithoutTypeParameters() { return this.options.getWithoutTypeParameters(); } @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRenderer @kp6 public String render(@kp6 DeclarationDescriptor declarationDescriptor) { cr4.g(declarationDescriptor, "declarationDescriptor"); StringBuilder sb = new StringBuilder(); declarationDescriptor.accept(new RenderDeclarationDescriptorVisitor(), sb); if (getWithDefinedIn()) { appendDefinedIn(sb, declarationDescriptor); } return sb.toString(); } @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRenderer @kp6 public String renderAnnotation(@kp6 AnnotationDescriptor annotationDescriptor, @pq6 AnnotationUseSiteTarget annotationUseSiteTarget) { cr4.g(annotationDescriptor, "annotation"); StringBuilder sb = new StringBuilder(); sb.append('@'); if (annotationUseSiteTarget != null) { sb.append(annotationUseSiteTarget.getRenderName() + ':'); } KotlinType type = annotationDescriptor.getType(); sb.append(renderType(type)); if (getIncludeAnnotationArguments()) { List listRenderAndSortAnnotationArguments = renderAndSortAnnotationArguments(annotationDescriptor); if (getIncludeEmptyAnnotationArguments() || !listRenderAndSortAnnotationArguments.isEmpty()) { y41.ah(listRenderAndSortAnnotationArguments, sb, ", ", "(", ")", null, 112); } } if (getVerbose() && (KotlinTypeKt.isError(type) || (type.getConstructor().mo170getDeclarationDescriptor() instanceof NotFoundClasses.MockClassDescriptor))) { sb.append(" /* annotation class not found */"); } return sb.toString(); } @kp6 public String renderClassifierName(@kp6 ClassifierDescriptor classifierDescriptor) { cr4.g(classifierDescriptor, "klass"); return ErrorUtils.isError(classifierDescriptor) ? classifierDescriptor.getTypeConstructor().toString() : getClassifierNamePolicy().renderClassifier(classifierDescriptor, this); } @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRenderer @kp6 public String renderFlexibleType(@kp6 String str, @kp6 String str2, @kp6 KotlinBuiltIns kotlinBuiltIns) { cr4.g(str, "lowerRendered"); cr4.g(str2, "upperRendered"); cr4.g(kotlinBuiltIns, "builtIns"); if (RenderingUtilsKt.typeStringsDifferOnlyInNullability(str, str2)) { return n89.ar(str2, "(", false) ? vw2.ab("(", str, ")!") : str.concat("!"); } ClassifierNamePolicy classifierNamePolicy = getClassifierNamePolicy(); ClassDescriptor collection = kotlinBuiltIns.getCollection(); cr4.f(collection, "getCollection(...)"); String strAz = n89.az(classifierNamePolicy.renderClassifier(collection, this), "Collection"); String strReplacePrefixesInTypeRepresentations = RenderingUtilsKt.replacePrefixesInTypeRepresentations(str, strAz.concat("Mutable"), str2, strAz, strAz.concat("(Mutable)")); if (strReplacePrefixesInTypeRepresentations != null) { return strReplacePrefixesInTypeRepresentations; } String strReplacePrefixesInTypeRepresentations2 = RenderingUtilsKt.replacePrefixesInTypeRepresentations(str, strAz.concat("MutableMap.MutableEntry"), str2, strAz.concat("Map.Entry"), strAz.concat("(Mutable)Map.(Mutable)Entry")); if (strReplacePrefixesInTypeRepresentations2 != null) { return strReplacePrefixesInTypeRepresentations2; } ClassifierNamePolicy classifierNamePolicy2 = getClassifierNamePolicy(); ClassDescriptor array = kotlinBuiltIns.getArray(); cr4.f(array, "getArray(...)"); String strAz2 = n89.az(classifierNamePolicy2.renderClassifier(array, this), "Array"); StringBuilder sbQ = vw2.q(strAz2); sbQ.append(escape("Array<")); String string = sbQ.toString(); StringBuilder sbQ2 = vw2.q(strAz2); sbQ2.append(escape("Array", str, ""); } throw new io6(); } @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRenderer @kp6 public String renderName(@kp6 Name name, boolean z) { cr4.g(name, AppMeasurementSdk.ConditionalUserProperty.NAME); String strEscape = escape(RenderingUtilsKt.render(name)); return (getBoldOnlyForNamesInHtml() && getTextFormat() == RenderingFormat.HTML && z) ? vw2.ab("", strEscape, "") : strEscape; } @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRenderer @kp6 public String renderType(@kp6 KotlinType kotlinType) { cr4.g(kotlinType, SessionDescription.ATTR_TYPE); StringBuilder sb = new StringBuilder(); renderNormalizedType(sb, (KotlinType) getTypeNormalizer().invoke(kotlinType)); return sb.toString(); } @kp6 public String renderTypeArguments(@kp6 List list) { cr4.g(list, "typeArguments"); if (list.isEmpty()) { return ""; } StringBuilder sb = new StringBuilder(); sb.append(lt()); appendTypeProjections(sb, list); sb.append(gt()); return sb.toString(); } @kp6 public String renderTypeConstructor(@kp6 TypeConstructor typeConstructor) { cr4.g(typeConstructor, "typeConstructor"); ClassifierDescriptor classifierDescriptorMo170getDeclarationDescriptor = typeConstructor.mo170getDeclarationDescriptor(); if ((classifierDescriptorMo170getDeclarationDescriptor instanceof TypeParameterDescriptor) || (classifierDescriptorMo170getDeclarationDescriptor instanceof ClassDescriptor) || (classifierDescriptorMo170getDeclarationDescriptor instanceof TypeAliasDescriptor)) { return renderClassifierName(classifierDescriptorMo170getDeclarationDescriptor); } if (classifierDescriptorMo170getDeclarationDescriptor == null) { return typeConstructor instanceof IntersectionTypeConstructor ? ((IntersectionTypeConstructor) typeConstructor).makeDebugNameForIntersectionType(new sq3() { // from class: kotlin.reflect.jvm.internal.impl.renderer.DescriptorRendererImpl$$Lambda$1 @Override // defpackage.sq3 public Object invoke(Object obj) { return DescriptorRendererImpl.renderTypeConstructor$lambda$8((KotlinType) obj); } }) : typeConstructor.toString(); } throw new IllegalStateException(("Unexpected classifier: " + classifierDescriptorMo170getDeclarationDescriptor.getClass()).toString()); } @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRenderer @kp6 public String renderTypeProjection(@kp6 TypeProjection typeProjection) { cr4.g(typeProjection, "typeProjection"); StringBuilder sb = new StringBuilder(); appendTypeProjections(sb, y41.am(typeProjection)); return sb.toString(); } @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRendererOptions public void setAnnotationArgumentsRenderingPolicy(@kp6 AnnotationArgumentsRenderingPolicy annotationArgumentsRenderingPolicy) { cr4.g(annotationArgumentsRenderingPolicy, ""); this.options.setAnnotationArgumentsRenderingPolicy(annotationArgumentsRenderingPolicy); } @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRendererOptions public void setClassifierNamePolicy(@kp6 ClassifierNamePolicy classifierNamePolicy) { cr4.g(classifierNamePolicy, ""); this.options.setClassifierNamePolicy(classifierNamePolicy); } @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRendererOptions public void setDebugMode(boolean z) { this.options.setDebugMode(z); } @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRendererOptions public void setExcludedTypeAnnotationClasses(@kp6 Set set) { cr4.g(set, ""); this.options.setExcludedTypeAnnotationClasses(set); } @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRendererOptions public void setModifiers(@kp6 Set set) { cr4.g(set, ""); this.options.setModifiers(set); } @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRendererOptions public void setParameterNameRenderingPolicy(@kp6 ParameterNameRenderingPolicy parameterNameRenderingPolicy) { cr4.g(parameterNameRenderingPolicy, ""); this.options.setParameterNameRenderingPolicy(parameterNameRenderingPolicy); } @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRendererOptions public void setReceiverAfterName(boolean z) { this.options.setReceiverAfterName(z); } @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRendererOptions public void setRenderCompanionObjectName(boolean z) { this.options.setRenderCompanionObjectName(z); } @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRendererOptions public void setStartFromName(boolean z) { this.options.setStartFromName(z); } @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRendererOptions public void setTextFormat(@kp6 RenderingFormat renderingFormat) { cr4.g(renderingFormat, ""); this.options.setTextFormat(renderingFormat); } @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRendererOptions public void setVerbose(boolean z) { this.options.setVerbose(z); } @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRendererOptions public void setWithDefinedIn(boolean z) { this.options.setWithDefinedIn(z); } @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRendererOptions public void setWithoutSuperTypes(boolean z) { this.options.setWithoutSuperTypes(z); } @Override // kotlin.reflect.jvm.internal.impl.renderer.DescriptorRendererOptions public void setWithoutTypeParameters(boolean z) { this.options.setWithoutTypeParameters(z); } private final String renderFqName(List list) { return escape(RenderingUtilsKt.renderFqName(list)); } /* JADX INFO: Access modifiers changed from: private */ public final void renderName(DeclarationDescriptor declarationDescriptor, StringBuilder sb, boolean z) { Name name = declarationDescriptor.getName(); cr4.f(name, "getName(...)"); sb.append(renderName(name, z)); } }