fe10Annotations.hasAnnotation(classId.asSingleFqName())
    }

    override fun get(classId: ClassId): List<KaAnnotation> = withValidityAssertion {
        if (classId in ignoredAnnotations) return@withValidityAssertion emptyList()

        fe10Annotations.mapIndexedNotNull { index, annotation ->
            if (annotation.classIdForAnnotation != classId) {
                return@mapIndexedNotNull null
            }

        return false
    }

    override fun get(classId: ClassId): List<KaAnnotation> = withValidityAssertion {
        return emptyList()
    }

    override val classIds: Set<ClassId>
        get() = withValidityAssertion { emptySet() }

            is ErrorType -> return emptySet()
            is CapturedType, is NewCapturedType -> return constructor.supertypes.flatMapTo(mutableSetOf()) { it.collectLowerBounds() }
            is SimpleType -> {
                val typeParameterDescriptor = TypeUtils.getTypeParameterDescriptorOrNull(this)
                if (typeParameterDescriptor != null) {
                    return emptySet()
                }

            val constraint = readBoolean()
            LocalComponentDependencyMetadata(
                selector,
                null,
                emptyList(),
                emptyList(),
                false,
                false,
                true,
                constraint,
                false,
                null
            )
        }
    }

          }
        };
    assertFailure(tester);
  }

  public void testSimilarException() {
    List<Integer> emptyList = emptyList();
    IteratorTester<Integer> tester =
        new IteratorTester<Integer>(
            1, MODIFIABLE, emptyList, IteratorTester.KnownOrder.KNOWN_ORDER) {
          @Override
          protected Iterator<Integer> newTargetIterator() {

          }
        };
    assertFailure(tester);
  }

  public void testSimilarException() {
    List<Integer> emptyList = emptyList();
    IteratorTester<Integer> tester =
        new IteratorTester<Integer>(
            1, MODIFIABLE, emptyList, IteratorTester.KnownOrder.KNOWN_ORDER) {
          @Override
          protected Iterator<Integer> newTargetIterator() {

        val ktValueArgumentList = ktValueArgument.parent as? KtValueArgumentList ?: return emptyList()
        val ktCallExpression = ktValueArgumentList.parent as? KtCallElement ?: return emptyList()

        val firCall = ktCallExpression.getOrBuildFir(analysisSession.firResolveSession)?.unwrapSafeCall() as? FirCall ?: return emptyList()

            }

            val resolutionScope = unwrappedPsi.getResolutionScope(this) ?: return emptyList()
            val call = unwrappedPsi.getCall(this)?.let {
                if (it is CallTransformer.CallForImplicitInvoke) it.outerCall else it
            } ?: return emptyList()
            val dataFlowInfo = getDataFlowInfoBefore(unwrappedPsi)

        val fir = element.getOrBuildFir(firResolveSession) ?: return emptyList()
        return when (fir) {
            is FirFunctionCall -> fir.getCandidateSymbols().map { it.fir.buildSymbol(firSymbolBuilder) }
            is FirResolvedNamedReference -> listOf(fir.resolvedSymbol.buildSymbol(firSymbolBuilder))
            else -> emptyList()
        }
    }

        check(this is KaFirSession)
        val property = (expression.parent as? KtElement)?.getOrBuildFirSafe<FirProperty>(firResolveSession) ?: return emptyList()
        if (property.delegate == null) return emptyList()
        val getValueSymbol = (property.getter?.singleStatementOfType<FirReturnExpression>()?.result as? FirFunctionCall)?.getCalleeSymbol()