withEntry("value", value) { value.toString() }
                        }
                    },
                    builder.token
                )
            )
            else -> errorWithAttachment("Can't convert ${returnsEffect::class} to the Analysis API")  {
                withEntry("value", value) { value.toString() }
            }
        }

            is KtConstantAnnotationValue -> {
                printer.append(value.constantValue.constantValueKind.asString)
                    .append("(")
                    .append(value.constantValue.value.toString())
                    .append(")")
            }

            is KtUnsupportedAnnotationValue -> {
                printer.append(KtUnsupportedAnnotationValue::class.java.simpleName)
            }

                else -> {
                    val errorType =
                        ErrorUtils.createErrorType(ErrorTypeKind.UNRESOLVED_CLASS_TYPE, typeConstructor, typeDeclaration.toString())
                    KtFe10ClassErrorType(errorType, analysisContext)
                }
            }

        }
        else -> error("Unexpected type $this")
    }
}

        else -> errorWithAttachment("FirScope ${this::class}` is expected to be one of FirNestedClassifierScope and FirClassUseSiteMemberScope to get ClassId") {
            withEntry("firScope", this@correspondingClassIdIfExists) { it.toString() }
        }
    }

    private fun ClassId.idWithoutCompanion() = if (shortClassName == SpecialNames.DEFAULT_NAME_FOR_COMPANION_OBJECT) outerClassId else this

  }

  @Test
  @TestMetadata("libraryDataClass_toString.kt")
  public void testLibraryDataClass_toString() {
    runTest("analysis/analysis-api/testData/symbols/symbolByReference/libraryDataClass_toString.kt");
  }

  @Test
  @TestMetadata("libraryMemberProperty.kt")
  public void testLibraryMemberProperty() {

            }
        } ?: TODO(descriptor::class.java.name)
        val libraryPath = Paths.get(library)
        return object : KtLibraryModule {
            override val libraryName: String = libraryPath.fileName.toString().substringBeforeLast(".")
            override val librarySources: KtLibrarySourceModule? = null
            override fun getBinaryRoots(): Collection<Path> = listOf(libraryPath)

  }

  @Test
  @TestMetadata("string_toString.kt")
  public void testString_toString() {
    runTest("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate/string_toString.kt");
  }

  @Test
  @TestMetadata("string_trimIndent.kt")
  public void testString_trimIndent() {

        val kotlinType = (getSymbolDescriptor(symbol) as? ClassDescriptor)?.defaultType
            ?: ErrorUtils.createErrorType(ErrorTypeKind.UNRESOLVED_CLASS_TYPE, symbol.nameOrAnonymous.toString())
        return kotlinType.toKtType(analysisContext)
    }

    override fun commonSuperType(types: Collection<KtType>): KtType {
        val kotlinTypes = types.map { (it as KtFe10Type).fe10Type }

            if (classifier is FirRegularClassSymbol && classifier.fir.isDeclared()) {
                processor(classifier, substitutor)
            }
        }
    }

    override fun toString(): String = "Declared member scope for $delegate with owning class `${owner.classId}`"

            is FirPackageMemberScope -> createPackageScope(firScope.fqName)
            is FirContainingNamesAwareScope -> KtFirDelegatingNamesAwareScope(firScope, builder)
            else -> TODO(firScope::class.toString())
        }
    }

    private fun getScopeKind(firScope: FirScope, indexInTower: Int): KtScopeKind = when (firScope) {
        is FirNameAwareOnlyCallablesScope -> getScopeKind(firScope.delegate, indexInTower)