import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.platform.jvm.isJvm

/**
 * Provides top-level names for classifiers and callables in given packages. Apart from names found in sources and binaries,
 * [DeclarationsInPackageProvider] also collects names for classifiers and callables generated by
 * [FirDeclarationGenerationExtension][org.jetbrains.kotlin.fir.extensions.FirDeclarationGenerationExtension]s.
 *

  }

  @Test
  @TestMetadata("callables.kt")
  public void testCallables() {
    runTest("analysis/analysis-api/testData/components/scopeProvider/packageScope/callables.kt");
  }

  @Test
  @TestMetadata("classes.kt")
  public void testClasses() {

            DeclaredMemberScopeKind.COMBINED -> combinedScope
        }
    }

    /**
     * Returns a declared member scope which contains both static and non-static callables, as well as all classifiers. Java classes need to
     * be handled specially, because [declaredMemberScope] doesn't handle Java enhancement properly.
     */

            }
            if (failure) {
                return results;
            }

            List<Callable<List<ProjectBuildingResult>>> callables = interimResults.stream()
                    .map(interimResult ->
                            (Callable<List<ProjectBuildingResult>>) () -> doBuild(projectIndex, interimResult))
                    .collect(Collectors.toList());

            try {

    return ClassLiteralResolutionResult(type.toKtType(analysisContext), classId)
}

internal val CallableMemberDescriptor.callableIdIfNotLocal: CallableId?
    get() = calculateCallableId(allowLocal = false)

internal fun CallableMemberDescriptor.calculateCallableId(allowLocal: Boolean): CallableId? {
    if (this is SyntheticJavaPropertyDescriptor) {
        return getMethod.calculateCallableId(allowLocal)?.copy(callableName = name)
    }

        val distinctCandidates = candidates.distinctBy { it.callableId }
        return distinctCandidates.singleOrNull()
            ?: errorWithAttachment("Expected all candidates to have same callableId but some of them but was different") {
                withEntry("callableIds", distinctCandidates.map { it.callableId.asSingleFqName() }.joinToString())
            }
    }

                        KtEnumEntryAnnotationValue(resolvedSymbol.callableId, sourcePsi, token)
                    }

                    else -> null
                }
            }

            is FirEnumEntryDeserializedAccessExpression -> {
                KtEnumEntryAnnotationValue(CallableId(enumClassId, enumEntryName), sourcePsi, token)
            }

            is FirGetClassCall -> {

                name = annotationParameterName,
                expression = KtArrayAnnotationValue(
                    values = map {
                        KtEnumEntryAnnotationValue(
                            callableId = CallableId(
                                classId = expectedEnumClassId,
                                callableName = Name.identifier(it),
                            ),
                            sourcePsi = null,

            Errors.NAMED_PARAMETER_NOT_FOUND,
            Errors.NAMED_ARGUMENTS_NOT_ALLOWED,
            Errors.VARARG_OUTSIDE_PARENTHESES,
            Errors.SPREAD_OF_NULLABLE,
            Errors.SPREAD_OF_LAMBDA_OR_CALLABLE_REFERENCE,
            Errors.MANY_LAMBDA_EXPRESSION_ARGUMENTS,
            Errors.UNEXPECTED_TRAILING_LAMBDA_ON_A_NEW_LINE,
            Errors.TOO_MANY_ARGUMENTS,

        Supplier<T> s = asSupplier(supplier);
        if (cache == null) {
            return s.get();
        } else {
            return cache.computeIfAbsent(groupId, artifactId, version, tag, s);
        }
    }

    private static <T> T cache(ModelCache cache, Source source, String tag, Callable<T> supplier) {