}

  @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() {

            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)

        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 }

        require(this is TypeConstructor)
        val declaration = declarationDescriptor
            ?: return ErrorUtils.createErrorType(ErrorTypeKind.UNRESOLVED_DECLARATION, this.toString())
        return declaration.defaultType
    }

    override fun TypeConstructorMarker.isScript(): Boolean {
        require(this is TypeConstructor)
        return declarationDescriptor is ScriptDescriptor
    }

        }
    }

    return null
}


internal fun KtFe10Symbol.createErrorType(): KtType {
    val type = ErrorUtils.createErrorType(ErrorTypeKind.UNAVAILABLE_TYPE_FOR_DECLARATION, psi.toString())
    return KtFe10ClassErrorType(type, analysisContext)

        val signatureWriter = BothSignatureWriter(BothSignatureWriter.Mode.SKIP_CHECKS)
        typeMapper.mapType(type, mode, signatureWriter)

        val canonicalSignature = signatureWriter.toString()
        require(!canonicalSignature.contains(SpecialNames.ANONYMOUS_STRING))

        if (canonicalSignature.contains("L<error>")) return null

            type.isULong -> KtConstantValue.KtUnsignedLongConstantValue((value as Number).toLong().toULong(), expression)
            type.isString -> KtConstantValue.KtStringConstantValue(value.toString(), expression)
            type.isFloat -> KtConstantValue.KtFloatConstantValue((value as Number).toFloat(), expression)
            type.isDouble -> KtConstantValue.KtDoubleConstantValue((value as Number).toDouble(), expression)

        val value = cache.getOrPut(key, calculation)
        return value as? S
            ?: errorWithAttachment("Cannot cast ${value::class} to ${S::class}") {
                withEntry("value", value.toString())
            }
    }
}

internal fun FirElement.buildSymbol(builder: KtSymbolByFirBuilder) =
    (this as? FirDeclaration)?.symbol?.let(builder::buildSymbol)