// we want full Array<out T> type for parity with FIR implementation
                        bindingContext[BindingContext.VALUE_PARAMETER, declaration]?.returnType
                    } else {
                        bindingContext[BindingContext.TYPE, typeReference]
                    } ?: ErrorUtils.createErrorType(ErrorTypeKind.RETURN_TYPE, typeReference.text)

  }

  public void testFalseRecursiveType_mappingOnTheSameDeclarationNotUsed() {
    Type returnType =
        genericReturnType(WithFalseRecursiveType.class, "keyShouldNotResolveToStringList");
    TypeToken<?> keyType =
        TypeToken.of(returnType).resolveType(WithFalseRecursiveType.class.getTypeParameters()[0]);
    assertEquals("java.util.List<V>", keyType.getType().toString());
  }

) : KtVariableLikeSignature<S>() {
    override val token: KtLifetimeToken get() = backingSymbol.token
    override val symbol: S get() = withValidityAssertion { backingSymbol }
    override val returnType: KtType get() = withValidityAssertion { backingReturnType }
    override val receiverType: KtType? get() = withValidityAssertion { backingReceiverType }

    ): Any? {
      val callArgs = args ?: arrayOf<Any?>()
      val methodName = method.name
      val returnType = method.returnType
      if (methodName == "supports" && Boolean::class.javaPrimitiveType == returnType) {
        return true // ALPN is supported.
      } else if (methodName == "unsupported" && Void.TYPE == returnType) {
        this.unsupported = true // Peer doesn't support ALPN.
        return null

    override val annotationsList: KtAnnotationsList
        get() = withValidityAssertion {
            KtFirAnnotationListForDeclaration.create(firSymbol, builder)
        }

    override val returnType: KtType get() = withValidityAssertion { firSymbol.returnType(analysisSession.firSymbolBuilder) }
    override val receiverParameter: KtReceiverParameterSymbol? get() = withValidityAssertion { firSymbol.receiver(builder) }

            symbol,
            substitutor.substitute(returnType),
            receiverType?.let { substitutor.substitute(it) },
            valueParameters.map { valueParameter ->
                KtFe10VariableLikeSignature<KtValueParameterSymbol>(
                    valueParameter.symbol,
                    substitutor.substitute(valueParameter.returnType),

private
fun ApiTypeProvider.Context.apiTypeUsageForReturnType(delegate: MethodNode, returnType: TypeSignatureVisitor?) =
    apiTypeUsageFor(
        returnType?.binaryName ?: Type.getReturnType(delegate.desc).className,
        delegate.visibleAnnotations.has<Nullable>(),
        returnType?.variance ?: Variance.INVARIANT,
        returnType?.typeArguments ?: emptyList()
    )


private

            get() = withValidityAssertion { false }

        override val name: Name
            get() = withValidityAssertion { Name.identifier("value") }

        override val returnType: KtType
            get() = withValidityAssertion { descriptor?.returnType?.toKtType(analysisContext) ?: createErrorType() }

        override val origin: KtSymbolOrigin
            get() = withValidityAssertion { propertyPsi.ktSymbolOrigin }

            ?.let(::KtFe10PsiDefaultBackingFieldSymbolPointer)
            ?: KtFe10NeverRestoringSymbolPointer()
    }

    override val returnType: KtType
        get() = withValidityAssertion { owningProperty.returnType }

    override val token: KtLifetimeToken
        get() = owningProperty.token

    override val annotationsList: KtAnnotationsList
        get() = withValidityAssertion {

    override val annotationsList: KtAnnotationsList
        get() = withValidityAssertion {
            KtFirAnnotationListForDeclaration.create(firSymbol, builder)
        }

    override val returnType: KtType get() = withValidityAssertion { firSymbol.returnType(builder) }

    override val owningProperty: KtKotlinPropertySymbol
        get() = withValidityAssertion {