<component name="ProjectRunConfigurationManager">
  <configuration default="false" name="Generate standard library sources" type="GradleRunConfiguration" factoryName="Gradle" folderName="Stdlib">
    <ExternalSystemSettings>
      <option name="executionName" />
      <option name="externalProjectPath" value="$PROJECT_DIR$/libraries/tools/kotlin-stdlib-gen" />
      <option name="externalSystemIdString" value="GRADLE" />
      <option name="scriptParameters" value="" />

        is SamConstructorDescriptor -> return KtSymbolOrigin.SAM_CONSTRUCTOR
        is JavaClassDescriptor, is JavaCallableMemberDescriptor -> return KtSymbolOrigin.JAVA
        is DeserializedDescriptor -> return KtSymbolOrigin.LIBRARY
        is EnumEntrySyntheticClassDescriptor -> return containingDeclaration.getSymbolOrigin(analysisContext)
        is CallableMemberDescriptor -> when (kind) {

## Supported Versions

Security updates are applied to the latest feature release (1.x) of the compiler, standard library, and build plugins.

A fix will be shipped with the next incremental (1.x.y) or bug fix release (1.x.yz).

All fixes are also applied to the master branch to be included in all upcoming releases.

## Reporting a Vulnerability

        }

        TODO(symbol::class.java.name)
    }

    private fun getFakeContainingKtModule(descriptor: DescriptorWithContainerSource): KtModule {
        val library = when (val containerSource = descriptor.containerSource) {
            is JvmPackagePartSource -> containerSource.knownJvmBinaryClass?.containingLibrary

  public void testJavaClass() {
    runTest("analysis/analysis-api/testData/components/scopeProvider/packageScope/javaClass.kt");
  }

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

  @Test
  @TestMetadata("simple.kt")
  public void testSimple() {

        get() = withValidityAssertion { analysisContext.resolveSession.getFileAnnotations(file) }

    override val origin: KtSymbolOrigin
        get() = withValidityAssertion { if (file.isCompiled) KtSymbolOrigin.LIBRARY else KtSymbolOrigin.SOURCE }

    override fun createPointer(): KtSymbolPointer<KtFileSymbol> = withValidityAssertion {

            val virtualFile = PsiUtilCore.getVirtualFile(psi)
            return if (virtualFile != null) {
                analysisContext.getOrigin(virtualFile)
            } else {
                KtSymbolOrigin.LIBRARY
            }
        }

    override fun hashCode(): Int {
        return packageName.hashCode()
    }

    override fun equals(other: Any?): Boolean {

                    // Implicit lambda parameter doesn't have a source PSI.
                    descriptor.source.getPsi() == null &&
                    // But, that could be the case for a declaration from Library. Double-check the slice in the binding context
                    (descriptor.containingDeclaration.source.getPsi() as? KtFunctionLiteral)?.let { parentLambda ->

Some handy links:

 * [Kotlin Site](https://kotlinlang.org/)
 * [Getting Started Guide](https://kotlinlang.org/docs/tutorials/getting-started.html)
 * [Try Kotlin](https://play.kotlinlang.org/)
 * [Kotlin Standard Library](https://kotlinlang.org/api/latest/jvm/stdlib/index.html)
 * [Issue Tracker](https://youtrack.jetbrains.com/issues/KT)
 * [Kotlin YouTube Channel](https://www.youtube.com/channel/UCP7uiEZIqci43m22KDl0sNw)

    get() = calculateCallableId(allowLocal = false)

internal val KtElement.ktSymbolOrigin: KtSymbolOrigin
    get() {
        return if (containingKtFile.isCompiled) {
            KtSymbolOrigin.LIBRARY
        } else {
            KtSymbolOrigin.SOURCE
        }
    }

internal fun KtDeclaration.calculateCallableId(allowLocal: Boolean): CallableId? {
    val selfName = this.name ?: return null