dev_with_docstring.jsonl

{"signature":"abstract fun Canvas . drawDetection ( detection : T )","body":"abstract fun Canvas . drawDetection ( detection : T )","docstring":"/**\n * Draw given detection result on the [Canvas].\n */"}
{"signature":"open fun onDetectionSet ( detection : T ? )","body":"= Unit","docstring":"/**\n * Called when a new detection result is set.\n */"}
{"signature":"fun setDetection ( detection : T ? )","body":"{ <EOL> synchronized ( this ) { <EOL> _detection = detection <EOL> onDetectionSet ( detection ) <EOL> postInvalidate ( ) <EOL> } <EOL> }","docstring":"/**\n * Set current detection result or null if nothing was detected.\n */"}
{"signature":"protected open fun getDeclarationOriginFor ( file : KtFile ) : FirDeclarationOrigin","body":"{ <EOL> val virtualFile = file . virtualFile <EOL> return if ( virtualFile . extension == BuiltInSerializerProtocol . BUILTINS_FILE_EXTENSION ) { <EOL> FirDeclarationOrigin . BuiltIns <EOL> } else { <EOL> FirDeclarationOrigin . Library <EOL> } <EOL> }","docstring":"/**\n * Computes the origin for the declarations coming from [file].\n *\n * We assume that a stub Kotlin declaration might come only from Library or from BuiltIns.\n * We do the decision based upon the extension of the [file].\n *\n * This method is left open so the inheritors can provide more optimal/strict implementations.\n */"}
{"signature":"fun usage ( )","body":"{ }","docstring":"/**\n * [<caret_1>one.two.ext]\n * [one.<caret_2>two.ext]\n *\n * [<caret_3>Foo.ext]\n * [one.two.<caret_4>Foo.ext]\n *\n * [<caret_5>one.two.Foo.ext]\n * [one.<caret_6>two.Foo.ext]\n */"}
{"signature":"@ HtmlTagMarker <EOL> inline fun DATALIST . option ( classes : String ? = null , crossinline block : OPTION . ( ) -> Unit = { } ) : Unit","body":"= OPTION ( attributesMapOf ( \"<STR_LIT:class>\" , classes ) , consumer ) . visit ( block )","docstring":"/**\n * Selectable choice\n */"}
{"signature":"@ HtmlTagMarker <EOL> fun DATALIST . option ( classes : String ? = null , content : String = \"<STR_LIT>\" ) : Unit","body":"= OPTION ( attributesMapOf ( \"<STR_LIT:class>\" , classes ) , consumer ) . visit ( { + content } )","docstring":"/**\n * Selectable choice\n */"}
{"signature":"@ HtmlTagMarker <EOL> inline fun DETAILS . legend ( classes : String ? = null , crossinline block : LEGEND . ( ) -> Unit = { } ) : Unit","body":"= LEGEND ( attributesMapOf ( \"<STR_LIT:class>\" , classes ) , consumer ) . visit ( block )","docstring":"/**\n * Fieldset legend\n */"}
{"signature":"@ HtmlTagMarker <EOL> inline fun DL . dd ( classes : String ? = null , crossinline block : DD . ( ) -> Unit = { } ) : Unit","body":"= DD ( attributesMapOf ( \"<STR_LIT:class>\" , classes ) , consumer ) . visit ( block )","docstring":"/**\n * Definition description\n */"}
{"signature":"@ HtmlTagMarker <EOL> inline fun DL . dt ( classes : String ? = null , crossinline block : DT . ( ) -> Unit = { } ) : Unit","body":"= DT ( attributesMapOf ( \"<STR_LIT:class>\" , classes ) , consumer ) . visit ( block )","docstring":"/**\n * Definition term\n */"}
{"signature":"fun additionalTraining ( )","body":"{ <EOL> val ( train , test ) = fashionMnist ( ) <EOL> val jsonConfigFile = getJSONConfigFile ( ) <EOL> val model = Sequential . loadModelConfiguration ( jsonConfigFile ) <EOL> model . use { <EOL> it . compile ( optimizer = Adam ( ) , loss = Losses . SOFT_MAX_CROSS_ENTROPY_WITH_LOGITS , metric = Metrics . ACCURACY ) <EOL> it . logSummary ( ) <EOL> val hdfFile = getWeightsFile ( ) <EOL> it . loadWeights ( hdfFile ) <EOL> val accuracyBefore = it . evaluate ( dataset = test , batchSize = <NUM_LIT:100> ) . metrics [ Metrics . ACCURACY ] <EOL> println ( \"<STR_LIT>\" ) <EOL> it . fit ( dataset = train , validationRate = <NUM_LIT> , epochs = <NUM_LIT:1> , trainBatchSize = <NUM_LIT> , validationBatchSize = <NUM_LIT:100> ) <EOL> val accuracyAfterTraining = it . evaluate ( dataset = test , batchSize = <NUM_LIT:100> ) . metrics [ Metrics . ACCURACY ] <EOL> println ( \"<STR_LIT>\" ) <EOL> } <EOL> }","docstring":"/**\n * This example demonstrates the transfer learning concept:\n * - Weights are loaded from .h5 file, configuration is loaded from .json file.\n * - All model weights are not frozen, and can be changed during the training.\n * - No new layers are added.\n *\n * NOTE: Model and weights are resources in `examples` module.\n */"}
{"signature":"fun main ( ) : Unit","body":"= additionalTraining ( )","docstring":"/** */"}
{"signature":"actual fun < T > CoroutineScope . asyncWithDealy ( delay : Long , block : suspend ( ) -> T ) : Deferred < T >","body":"{ <EOL> TODO ( \"<STR_LIT:NotU+0020yetU+0020implemented>\" ) <EOL> }","docstring":"/**\n * JS actual implementation for `asyncWithDelay`\n */"}
{"signature":"public fun extractImages ( archivePath : String ) : Array < FloatArray >","body":"{ <EOL> val archiveStream = DataInputStream ( GZIPInputStream ( FileInputStream ( archivePath ) ) ) <EOL> val magic = archiveStream . readInt ( ) <EOL> require ( IMAGE_ARCHIVE_MAGIC == magic ) { \"<STR_LIT>\" } <EOL> val imageCount = archiveStream . readInt ( ) <EOL> val imageRows = archiveStream . readInt ( ) <EOL> val imageCols = archiveStream . readInt ( ) <EOL> println ( String . format ( \"<STR_LIT>\" , imageCount , imageRows , imageCols , archivePath ) ) <EOL> val imageBuffer = ByteArray ( imageRows * imageCols ) <EOL> val images = Array ( imageCount ) { <EOL> archiveStream . readFully ( imageBuffer ) <EOL> toNormalizedVector ( imageBuffer ) <EOL> } <EOL> return images <EOL> }","docstring":"/**\n * Extracts (Fashion) Mnist images from [archivePath].\n */"}
{"signature":"public fun extractLabels ( archivePath : String ) : FloatArray","body":"{ <EOL> val archiveStream = DataInputStream ( GZIPInputStream ( FileInputStream ( archivePath ) ) ) <EOL> val magic = archiveStream . readInt ( ) <EOL> require ( LABEL_ARCHIVE_MAGIC == magic ) { \"<STR_LIT>\" } <EOL> val labelCount = archiveStream . readInt ( ) <EOL> println ( String . format ( \"<STR_LIT>\" , labelCount , archivePath ) ) <EOL> val labelBuffer = ByteArray ( labelCount ) <EOL> archiveStream . readFully ( labelBuffer ) <EOL> val floats = FloatArray ( labelCount ) <EOL> for ( i in <NUM_LIT:0> until labelCount ) { <EOL> floats [ i ] = <EOL> OnHeapDataset . convertByteToFloat ( labelBuffer [ i ] ) <EOL> } <EOL> return floats <EOL> }","docstring":"/**\n * Extracts (Fashion) Mnist labels from [archivePath] with number of classes [numClasses].\n */"}
{"signature":"fun main ( ) : Unit","body":"= vgg11OnCifar10ExportImport ( )","docstring":"/** */"}
{"signature":"fun < T > List < T > . allPairs ( skipSamePairs : Boolean = true ) : Sequence < Pair < T , T > >","body":"= PairsSequence ( this , skipSamePairs )","docstring":"/**\n * Returns a sequence that consists of all possible pair of original list elements, does nothing with potential duplicates\n * @param skipSamePairs indicates whether it should produce pairs from the same element at both first and second positions\n */"}
{"signature":"public fun AnyCol . toArrowField ( mismatchSubscriber : ( ConvertingMismatch ) -> Unit = ignoreMismatchMessage ) : Field","body":"{ <EOL> val column = this <EOL> val columnType = column . type ( ) <EOL> val nullable = columnType . isMarkedNullable <EOL> return when { <EOL> columnType . isSubtypeOf ( typeOf < String ? > ( ) ) -> Field ( column . name ( ) , FieldType ( nullable , ArrowType . Utf8 ( ) , null ) , emptyList ( ) ) <EOL> columnType . isSubtypeOf ( typeOf < Boolean ? > ( ) ) -> Field ( column . name ( ) , FieldType ( nullable , ArrowType . Bool ( ) , null ) , emptyList ( ) ) <EOL> columnType . isSubtypeOf ( typeOf < Byte ? > ( ) ) -> Field ( column . name ( ) , FieldType ( nullable , ArrowType . Int ( <NUM_LIT:8> , true ) , null ) , emptyList ( ) ) <EOL> columnType . isSubtypeOf ( typeOf < Short ? > ( ) ) -> Field ( column . name ( ) , FieldType ( nullable , ArrowType . Int ( <NUM_LIT:16> , true ) , null ) , emptyList ( ) ) <EOL> columnType . isSubtypeOf ( typeOf < Int ? > ( ) ) -> Field ( column . name ( ) , FieldType ( nullable , ArrowType . Int ( <NUM_LIT> , true ) , null ) , emptyList ( ) ) <EOL> columnType . isSubtypeOf ( typeOf < Long ? > ( ) ) -> Field ( column . name ( ) , FieldType ( nullable , ArrowType . Int ( <NUM_LIT> , true ) , null ) , emptyList ( ) ) <EOL> columnType . isSubtypeOf ( typeOf < Float ? > ( ) ) -> Field ( column . name ( ) , FieldType ( nullable , ArrowType . FloatingPoint ( FloatingPointPrecision . SINGLE ) , null ) , emptyList ( ) ) <EOL> columnType . isSubtypeOf ( typeOf < Double ? > ( ) ) -> Field ( column . name ( ) , FieldType ( nullable , ArrowType . FloatingPoint ( FloatingPointPrecision . DOUBLE ) , null ) , emptyList ( ) ) <EOL> columnType . isSubtypeOf ( typeOf < LocalDate ? > ( ) ) || columnType . isSubtypeOf ( typeOf < kotlinx . datetime . LocalDate ? > ( ) ) -> Field ( column . name ( ) , FieldType ( nullable , ArrowType . Date ( DateUnit . DAY ) , null ) , emptyList ( ) ) <EOL> columnType . isSubtypeOf ( typeOf < LocalDateTime ? > ( ) ) || columnType . isSubtypeOf ( typeOf < kotlinx . datetime . LocalDateTime ? > ( ) ) -> Field ( column . name ( ) , FieldType ( nullable , ArrowType . Date ( DateUnit . MILLISECOND ) , null ) , emptyList ( ) ) <EOL> columnType . isSubtypeOf ( typeOf < LocalTime ? > ( ) ) -> Field ( column . name ( ) , FieldType ( nullable , ArrowType . Time ( TimeUnit . NANOSECOND , <NUM_LIT> ) , null ) , emptyList ( ) ) <EOL> else -> { <EOL> mismatchSubscriber ( ConvertingMismatch . SavedAsString ( column . name ( ) , column . typeClass . java ) ) <EOL> Field ( column . name ( ) , FieldType ( true , ArrowType . Utf8 ( ) , null ) , emptyList ( ) ) <EOL> } <EOL> } <EOL> }","docstring":"/**\n * Create Arrow [Field] (note: this is part of [Schema], does not contain data itself) that has the same\n * name, type and nullable as [this]\n */"}
{"signature":"public fun List < AnyCol > . toArrowSchema ( mismatchSubscriber : ( ConvertingMismatch ) -> Unit = ignoreMismatchMessage ) : Schema","body":"{ <EOL> val fields = this . map { it . toArrowField ( mismatchSubscriber ) } <EOL> return Schema ( fields ) <EOL> }","docstring":"/**\n * Create Arrow [Schema] matching [this] actual data.\n * Columns with not supported types will be interpreted as String\n */"}
{"signature":"fun lenetOnMnistExportImportToJSONWithAdamOptimizerState ( )","body":"{ <EOL> val ( train , test ) = mnist ( ) <EOL> val ( newTrain , validation ) = train . split ( <NUM_LIT> ) <EOL> val optimizer = Adam ( ) <EOL> lenet5 ( ) . use { <EOL> it . compile ( optimizer = optimizer , loss = Losses . SOFT_MAX_CROSS_ENTROPY_WITH_LOGITS , metric = Metrics . ACCURACY ) <EOL> it . logSummary ( ) <EOL> print ( it . kGraph ( ) ) <EOL> it . fit ( trainingDataset = newTrain , validationDataset = validation , epochs = EPOCHS , trainBatchSize = TRAINING_BATCH_SIZE , validationBatchSize = TEST_BATCH_SIZE ) <EOL> it . save ( modelDirectory = File ( PATH_TO_MODEL ) , saveOptimizerState = true , savingFormat = SavingFormat . JsonConfigCustomVariables ( ) , writingMode = WritingMode . OVERRIDE ) <EOL> val accuracy = it . evaluate ( dataset = test , batchSize = TEST_BATCH_SIZE ) . metrics [ Metrics . ACCURACY ] <EOL> println ( \"<STR_LIT>\" ) <EOL> } <EOL> val model = Sequential . loadModelConfiguration ( File ( \"<STR_LIT>\" ) ) <EOL> model . use { <EOL> it . layers . filterIsInstance < Conv2D > ( ) . forEach ( Layer :: freeze ) <EOL> it . compile ( optimizer = optimizer , loss = Losses . SOFT_MAX_CROSS_ENTROPY_WITH_LOGITS , metric = Metrics . ACCURACY ) <EOL> it . logSummary ( ) <EOL> print ( it . kGraph ( ) ) <EOL> it . loadWeights ( File ( PATH_TO_MODEL ) , loadOptimizerState = true ) <EOL> val accuracyBefore = it . evaluate ( dataset = test , batchSize = <NUM_LIT:100> ) . metrics [ Metrics . ACCURACY ] <EOL> println ( \"<STR_LIT>\" ) <EOL> it . fit ( dataset = train , validationRate = <NUM_LIT> , epochs = <NUM_LIT:1> , trainBatchSize = <NUM_LIT> , validationBatchSize = <NUM_LIT:100> ) <EOL> val accuracyAfterTraining = it . evaluate ( dataset = test , batchSize = <NUM_LIT:100> ) . metrics [ Metrics . ACCURACY ] <EOL> println ( \"<STR_LIT>\" ) <EOL> } <EOL> val model2 = Sequential . loadModelConfiguration ( File ( \"<STR_LIT>\" ) ) <EOL> model2 . use { <EOL> it . compile ( optimizer = optimizer , loss = Losses . SOFT_MAX_CROSS_ENTROPY_WITH_LOGITS , metric = Metrics . ACCURACY ) <EOL> it . logSummary ( ) <EOL> it . loadWeights ( File ( PATH_TO_MODEL ) , loadOptimizerState = false ) <EOL> val accuracyBefore = it . evaluate ( dataset = test , batchSize = <NUM_LIT:100> ) . metrics [ Metrics . ACCURACY ] <EOL> println ( \"<STR_LIT>\" ) <EOL> it . fit ( dataset = train , validationRate = <NUM_LIT> , epochs = <NUM_LIT:1> , trainBatchSize = <NUM_LIT> , validationBatchSize = <NUM_LIT:100> ) <EOL> val accuracyAfterTraining = it . evaluate ( dataset = test , batchSize = <NUM_LIT:100> ) . metrics [ Metrics . ACCURACY ] <EOL> println ( \"<STR_LIT>\" ) <EOL> } <EOL> }","docstring":"/**\n * This examples demonstrates model, model weights, and optimizer weights export and import back:\n * - Model is exported in Keras-style JSON format; weights are exported in custom (txt) format.\n * - Model is trained on Mnist dataset.\n * - It saves all the data to the project root directory.\n * - The first [Sequential] model is created via JSON configuration, weights, and optimizer state loading.\n * - After loading model is trained again with the same optimizer with frozen Conv2D layers. Only weights in Dense layers can be updated.\n * - The second [Sequential] model is created via JSON configuration and weights loading.\n * - After loading model is trained again with the same optimizer with frozen Conv2D layers. Only weights in Dense layers can be updated.\n * - Results of two training (with restored optimizer state and without) could be compared via accuracy comparison.\n */"}
{"signature":"fun main ( ) : Unit","body":"= lenetOnMnistExportImportToJSONWithAdamOptimizerState ( )","docstring":"/** */"}
{"signature":"public actual fun < T > setOf ( element : T ) : Set < T >","body":"= java . util . Collections . singleton ( element )","docstring":"/**\n * Returns a new read-only set containing only the specified object [element].\n *\n * The returned set is serializable.\n *\n * @sample samples.collections.Collections.Sets.singletonReadOnlySet\n */"}
{"signature":"public fun < T > sortedSetOf ( vararg elements : T ) : java . util . TreeSet < T >","body":"= elements . toCollection ( java . util . TreeSet < T > ( ) )","docstring":"/**\n * Returns a new [java.util.SortedSet] with the given elements.\n */"}
{"signature":"public fun < T > sortedSetOf ( comparator : Comparator < in T > , vararg elements : T ) : java . util . TreeSet < T >","body":"= elements . toCollection ( java . util . TreeSet < T > ( comparator ) )","docstring":"/**\n * Returns a new [java.util.SortedSet] with the given [comparator] and elements.\n */"}
{"signature":"fun < T : Number > sin ( x : KtNDArray < T > ) : KtNDArray < Double >","body":"= <EOL> callFunc ( nameMethod = arrayOf ( \"<STR_LIT>\" ) , args = arrayOf ( x ) , dtype = Double :: class )","docstring":"/**\n * Trigonometric sine, element-wise.\n */"}
{"signature":"fun < T : Number > cos ( x : KtNDArray < T > ) : KtNDArray < Double >","body":"= <EOL> callFunc ( nameMethod = arrayOf ( \"<STR_LIT>\" ) , args = arrayOf ( x ) , dtype = Double :: class )","docstring":"/**\n * Cosine element-wise.\n */"}
{"signature":"fun < T : Number > tan ( x : KtNDArray < T > ) : KtNDArray < Double >","body":"= <EOL> callFunc ( nameMethod = arrayOf ( \"<STR_LIT>\" ) , args = arrayOf ( x ) , dtype = Double :: class )","docstring":"/**\n * Compute tangent element-wise.\n */"}
{"signature":"fun < T : Number > arcsin ( x : KtNDArray < T > ) : KtNDArray < Double >","body":"= <EOL> callFunc ( nameMethod = arrayOf ( \"<STR_LIT>\" ) , args = arrayOf ( x ) , dtype = Double :: class )","docstring":"/**\n * Inverse sine, element-wise.\n */"}
{"signature":"fun < T : Number > arccos ( x : KtNDArray < T > ) : KtNDArray < Double >","body":"= <EOL> callFunc ( nameMethod = arrayOf ( \"<STR_LIT>\" ) , args = arrayOf ( x ) , dtype = Double :: class )","docstring":"/**\n * Trigonometric inverse cosine, element-wise.\n */"}
{"signature":"fun < T : Number > arctan ( x : KtNDArray < T > ) : KtNDArray < Double >","body":"= <EOL> callFunc ( nameMethod = arrayOf ( \"<STR_LIT>\" ) , args = arrayOf ( x ) , dtype = Double :: class )","docstring":"/**\n * Trigonometric inverse tangent, element-wise.\n */"}
{"signature":"fun < T : Number , E : Number > arctan2 ( x1 : KtNDArray < T > , x2 : KtNDArray < E > ) : KtNDArray < Double >","body":"= <EOL> callFunc ( nameMethod = arrayOf ( \"<STR_LIT>\" ) , args = arrayOf ( x1 , x2 ) , dtype = Double :: class )","docstring":"/**\n * Element-wise arc tangent of x1/x2 choosing the quadrant correctly.\n */"}
{"signature":"fun < T : Number > degrees ( x : KtNDArray < T > ) : KtNDArray < Double >","body":"= <EOL> callFunc ( nameMethod = arrayOf ( \"<STR_LIT>\" ) , args = arrayOf ( x ) , dtype = Double :: class )","docstring":"/**\n * Convert angles from radians to degrees.\n */"}
{"signature":"fun < T : Number > radians ( x : KtNDArray < T > ) : KtNDArray < Double >","body":"= <EOL> callFunc ( nameMethod = arrayOf ( \"<STR_LIT>\" ) , args = arrayOf ( x ) , dtype = Double :: class )","docstring":"/**\n * Convert angles from degrees to radians.\n */"}
{"signature":"fun < T : Number > unwrap ( p : KtNDArray < T > , discont : Double = PI , axis : Int = - <NUM_LIT:1> ) : KtNDArray < Double >","body":"= <EOL> callFunc ( nameMethod = arrayOf ( \"<STR_LIT>\" ) , args = arrayOf ( p , discont , axis ) )","docstring":"/**\n * Unwrap by changing deltas between values to 2*pi complement.\n */"}
{"signature":"fun < T : Number > deg2rad ( x : KtNDArray < T > ) : KtNDArray < Double >","body":"= <EOL> callFunc ( nameMethod = arrayOf ( \"<STR_LIT>\" ) , args = arrayOf ( x ) , dtype = Double :: class )","docstring":"/**\n * Convert angles from degrees to radians.\n */"}
{"signature":"fun < T : Number > rad2deg ( x : KtNDArray < T > ) : KtNDArray < Double >","body":"= <EOL> callFunc ( nameMethod = arrayOf ( \"<STR_LIT>\" ) , args = arrayOf ( x ) , dtype = Double :: class )","docstring":"/**\n * Convert angles from radians to degrees.\n */"}
{"signature":"private fun patchStackTrace ( node : TestNode , stackTrace : List < StackTraceElement > ? ) : List < StackTraceElement > ?","body":"= <EOL> stackTrace ? . map { <EOL> if ( it . className == node . classDisplayName ) StackTraceElement ( node . className , it . methodName , it . fileName , it . lineNumber ) else it <EOL> }","docstring":"/**\n * Required for org.gradle.api.internal.tasks.testing.logging.ShortExceptionFormatter.printException\n * In JS Stacktraces we have short class name, while filter using FQN\n * So, let replace short class name with FQN for current test\n */"}
{"signature":"private fun createReportingNode ( ) : TestDescriptorInternal","body":"{ <EOL> val parents = collectParents ( ) <EOL> val fullName = parents . reversed ( ) <EOL> . map { it . cleanName } <EOL> . filter { it . isNotBlank ( ) } <EOL> . joinToString ( \"<STR_LIT:.>\" ) <EOL> val reportingParent = parents . last ( ) as RootNode <EOL> this . reportingParent = reportingParent <EOL> descriptor = object : DefaultTestSuiteDescriptor ( id , fullName ) , LegacyTestDescriptorInternal { <EOL> override fun getDisplayName ( ) : String = fullNameWithoutRoot <EOL> override fun getClassName ( ) : String ? = fullNameWithoutRoot <EOL> override fun getOwnerBuildOperationId ( ) : Any ? = rootOperationId <EOL> override fun getParent ( ) : TestDescriptorInternal = reportingParent . descriptor <EOL> override fun toString ( ) : String = displayName <EOL> } <EOL> shouldReportComplete = true <EOL> check ( startedTs != <NUM_LIT:0L> ) <EOL> reportStarted ( startedTs ) <EOL> return descriptor ! ! <EOL> }","docstring":"/**\n * Called when first test in suite started\n */"}
{"signature":"public fun < DomainType : Comparable < DomainType > > PositionalMappingParametersContinuous < * > . continuous ( limits : ClosedRange < DomainType > , transform : PositionalTransform ? = null ) : PositionalContinuousScale < DomainType >","body":"= PositionalContinuousScale ( limits . start , limits . endInclusive , null , transform )","docstring":"/**\n * Creates a new continuous positional scale (with non-nullable domain).\n *\n * @param DomainType scale domain type.\n * @param limits [ClosedRange] defining the scale domain.\n * @param transform the transformation of scale.\n * @return new [PositionalContinuousScale] with given limits.\n */"}
{"signature":"public fun < DomainType : Comparable < DomainType > > Scale . Companion . continuousPos ( limits : ClosedRange < DomainType > , transform : PositionalTransform ? = null ) : PositionalContinuousScale < DomainType >","body":"= PositionalContinuousScale ( limits . start , limits . endInclusive , null , transform )","docstring":"/**\n * Creates a new continuous positional scale (with non-nullable domain).\n *\n * @param DomainType scale domain type.\n * @param limits [ClosedRange] defining the scale domain.\n * @param transform the transformation of scale.\n * @return new [PositionalContinuousScale] with given limits.\n */"}
{"signature":"public fun < DomainType : Comparable < DomainType > > PositionalMappingParametersContinuous < * > . continuous ( limits : ClosedRange < DomainType > , nullValue : DomainType ? = null , transform : PositionalTransform ? = null ) : PositionalContinuousScale < DomainType ? >","body":"= PositionalContinuousScale ( limits . start , limits . endInclusive , nullValue , transform )","docstring":"/**\n * Creates a new continuous positional scale (with nullable domain).\n *\n * @param DomainType scale domain type.\n * @param limits [ClosedRange] defining the scale domain.\n * @param nullValue value which null is mapped to.\n * @param transform the transformation of scale.\n * @return new [PositionalContinuousScale] with given limits.\n */"}
{"signature":"public fun < DomainType : Comparable < DomainType > > Scale . Companion . continuousPos ( limits : ClosedRange < DomainType > , nullValue : DomainType ? = null , transform : PositionalTransform ? = null ) : PositionalContinuousScale < DomainType ? >","body":"= PositionalContinuousScale ( limits . start , limits . endInclusive , nullValue , transform )","docstring":"/**\n * Creates a new continuous positional scale (with nullable domain).\n *\n * @param DomainType scale domain type.\n * @param limits [ClosedRange] defining the scale domain.\n * @param nullValue value which null is mapped to.\n * @param transform the transformation of scale.\n * @return new [PositionalContinuousScale] with given limits.\n */"}
{"signature":"public fun < DomainType > PositionalMappingParametersContinuous < * > . continuous ( min : DomainType ? = null , max : DomainType ? = null , transform : PositionalTransform ? = null ) : PositionalContinuousScale < DomainType >","body":"= PositionalContinuousScale ( min , max , null , transform )","docstring":"/**\n * Creates a new continuous positional scale (with non-nullable domain).\n *\n * @param DomainType scale domain type.\n * @param min scale domain minimum.\n * @param max scale domain maximum.\n * @param transform the transformation of scale.\n * @return new [PositionalContinuousScale] with given limits.\n */"}
{"signature":"public fun < DomainType > Scale . Companion . continuousPos ( min : DomainType ? = null , max : DomainType ? = null , transform : PositionalTransform ? = null ) : PositionalContinuousScale < DomainType >","body":"= PositionalContinuousScale ( min , max , null , transform )","docstring":"/**\n * Creates a new continuous positional scale (with non-nullable domain).\n *\n * @param DomainType scale domain type.\n * @param min scale domain minimum.\n * @param max scale domain maximum.\n * @param transform the transformation of scale.\n * @return new [PositionalContinuousScale] with given limits.\n */"}
{"signature":"public fun < DomainType > PositionalMappingParametersContinuous < * > . continuous ( min : DomainType ? = null , max : DomainType ? = null , nullValue : DomainType ? = null , transform : PositionalTransform ? = null ) : PositionalContinuousScale < DomainType ? >","body":"= PositionalContinuousScale ( min , max , nullValue , transform )","docstring":"/**\n * Creates a new continuous positional scale (with nullable domain).\n *\n * @param DomainType scale domain type.\n * @param min scale domain minimum.\n * @param max scale domain maximum.\n * @param nullValue value which null is mapped to.\n * @param transform the transformation of scale.\n * @return new [PositionalContinuousScale] with given limits.\n */"}
{"signature":"public fun < DomainType > Scale . Companion . continuousPos ( min : DomainType ? = null , max : DomainType ? = null , nullValue : DomainType ? = null , transform : PositionalTransform ? = null ) : PositionalContinuousScale < DomainType ? >","body":"= PositionalContinuousScale ( min , max , nullValue , transform )","docstring":"/**\n * Creates a new continuous positional scale (with nullable domain).\n *\n * @param DomainType scale domain type.\n * @param min scale domain minimum.\n * @param max scale domain maximum.\n * @param nullValue value which null is mapped to.\n * @param transform the transformation of scale.\n * @return new [PositionalContinuousScale] with given limits.\n */"}
{"signature":"public fun < DomainType > PositionalMappingParameters < * > . categorical ( categories : List < DomainType > ? = null , ) : PositionalCategoricalScale < DomainType >","body":"= PositionalCategoricalScale ( categories )","docstring":"/**\n * Creates a new categorical positional scale.\n *\n * @param DomainType scale domain type.\n * @param categories [List] defining the scale domain.\n * @return new [PositionalCategoricalScale] with given categories.\n */"}
{"signature":"public fun < DomainType > Scale . Companion . categoricalPos ( categories : List < DomainType > ? = null , ) : PositionalCategoricalScale < DomainType >","body":"= PositionalCategoricalScale ( categories )","docstring":"/**\n * Creates a new categorical positional scale.\n *\n * @param DomainType scale domain type.\n * @param categories [List] defining the scale domain.\n * @return new [PositionalCategoricalScale] with given categories.\n */"}
{"signature":"public fun < RangeType : Comparable < RangeType > , DomainType > NonPositionalMappingParametersContinuous < * , * > . continuous ( range : ClosedRange < RangeType > , nullValue : RangeType ? = null , transform : NonPositionalTransform ? = null ) : NonPositionalContinuousScale < DomainType , RangeType >","body":"= <EOL> NonPositionalContinuousScale ( null , null , range . start , range . endInclusive , nullValue , transform )","docstring":"/**\n * Creates a new continuous non-positional scale.\n *\n * @param DomainType scale domain type.\n * @param RangeType type of the scale range.\n * @param range [ClosedRange] defining the scale range.\n * @param nullValue value which null is mapped to.\n * @param transform scale transformation.\n * @return new [NonPositionalContinuousScale] with the given range.\n */"}
{"signature":"public fun < RangeType : Comparable < RangeType > , DomainType > Scale . Companion . continuous ( range : ClosedRange < RangeType > , nullValue : RangeType ? = null , transform : NonPositionalTransform ? = null ) : NonPositionalContinuousScale < DomainType , RangeType >","body":"= <EOL> NonPositionalContinuousScale ( null , null , range . start , range . endInclusive , nullValue , transform )","docstring":"/**\n * Creates a new continuous non-positional scale.\n *\n * @param DomainType scale domain type.\n * @param RangeType type of the scale range.\n * @param range [ClosedRange] defining the scale range.\n * @param nullValue value which null is mapped to.\n * @param transform scale transformation.\n * @return new [NonPositionalContinuousScale] with the given range.\n */"}
{"signature":"public fun < RangeType : Comparable < RangeType > , DomainType : Comparable < DomainType > > <EOL> NonPositionalMappingParametersContinuous < * , * > . continuous ( range : ClosedRange < RangeType > ? = null , domain : ClosedRange < DomainType > , nullValue : RangeType ? = null , transform : NonPositionalTransform ? = null ) : NonPositionalContinuousScale < DomainType , RangeType >","body":"= <EOL> NonPositionalContinuousScale ( domain . start , domain . endInclusive , range ? . start , range ? . endInclusive , nullValue , transform )","docstring":"/**\n * Creates a new continuous non-positional scale.\n *\n * @param DomainType scale domain type.\n * @param RangeType type of the scale range.\n * @param range [ClosedRange] defining the scale range.\n * @param domain [ClosedRange] defining the scale domain.\n * @param nullValue value which null is mapped to.\n * @param transform scale transformation.\n * @return new [NonPositionalContinuousScale] with the given domain and range.\n */"}
{"signature":"public fun < RangeType : Comparable < RangeType > , DomainType : Comparable < DomainType > > <EOL> Scale . Companion . continuous ( range : ClosedRange < RangeType > ? = null , domain : ClosedRange < DomainType > , nullValue : RangeType ? = null , transform : NonPositionalTransform ? = null ) : NonPositionalContinuousScale < DomainType , RangeType >","body":"= <EOL> NonPositionalContinuousScale ( domain . start , domain . endInclusive , range ? . start , range ? . endInclusive , nullValue , transform )","docstring":"/**\n * Creates a new continuous non-positional scale.\n *\n * @param DomainType scale domain type.\n * @param RangeType type of the scale range.\n * @param range [ClosedRange] defining the scale range.\n * @param domain [ClosedRange] defining the scale domain.\n * @param nullValue value which null is mapped to.\n * @param transform scale transformation.\n * @return new [NonPositionalContinuousScale] with the given domain and range.\n */"}
{"signature":"public fun < RangeType , DomainType > NonPositionalMappingParametersContinuous < * , * > . continuous ( rangeMin : RangeType ? = null , rangeMax : RangeType ? = null , domainMin : DomainType ? = null , domainMax : DomainType ? = null , nullValue : RangeType ? = null , transform : NonPositionalTransform ? = null ) : NonPositionalContinuousScale < DomainType , RangeType >","body":"= <EOL> NonPositionalContinuousScale ( domainMin , domainMax , rangeMin , rangeMax , nullValue , transform )","docstring":"/**\n * Creates a new continuous non-positional scale.\n *\n * @param DomainType scale domain type.\n * @param RangeType type of the scale range.\n * @param rangeMin scale range minimum.\n * @param rangeMax scale range maximum.\n * @param domainMin scale domain minimum.\n * @param domainMax scale domain maximum.\n * @param nullValue value which null is mapped to.\n * @param transform scale transformation.\n * @return new [NonPositionalContinuousScale] with the given domain and range.\n */"}
{"signature":"public fun < RangeType , DomainType > Scale . Companion . continuous ( rangeMin : RangeType ? = null , rangeMax : RangeType ? = null , domainMin : DomainType ? = null , domainMax : DomainType ? = null , nullValue : RangeType ? = null , transform : NonPositionalTransform ? = null ) : NonPositionalContinuousScale < DomainType , RangeType >","body":"= <EOL> NonPositionalContinuousScale ( domainMin , domainMax , rangeMin , rangeMax , nullValue , transform )","docstring":"/**\n * Creates a new continuous non-positional scale.\n *\n * @param DomainType scale domain type.\n * @param RangeType type of the scale range.\n * @param rangeMin scale range minimum.\n * @param rangeMax scale range maximum.\n * @param domainMin scale domain minimum.\n * @param domainMax scale domain maximum.\n * @param nullValue value which null is mapped to.\n * @param transform scale transformation.\n * @return new [NonPositionalContinuousScale] with the given domain and range.\n */"}
{"signature":"public inline fun < reified RangeType , reified DomainType > NonPositionalMappingParameters < * , * > . categorical ( range : List < RangeType > ? = null , domain : List < DomainType > ? = null , ) : NonPositionalCategoricalScale < DomainType , RangeType >","body":"= <EOL> NonPositionalCategoricalScale ( domain , range )","docstring":"/**\n * Creates a new categorical non-positional scale.\n *\n * @param DomainType scale domain type.\n * @param RangeType type of the scale range.\n * @param range [List] defining the scale range.\n * @param domain [List] defining the scale domain.\n * @return new [NonPositionalCategoricalScale] with given domain and range.\n */"}
{"signature":"public inline fun < reified RangeType , reified DomainType > Scale . Companion . categorical ( range : List < RangeType > ? = null , domain : List < DomainType > ? = null , ) : NonPositionalCategoricalScale < DomainType , RangeType >","body":"= <EOL> NonPositionalCategoricalScale ( domain , range )","docstring":"/**\n * Creates a new categorical non-positional scale.\n *\n * @param DomainType scale domain type.\n * @param RangeType type of the scale range.\n * @param range [List] defining the scale range.\n * @param domain [List] defining the scale domain.\n * @return new [NonPositionalCategoricalScale] with given domain and range.\n */"}
{"signature":"public fun < DomainType , RangeType > NonPositionalMappingParameters < * , * > . categorical ( vararg categoriesToValues : Pair < DomainType , RangeType > , ) : NonPositionalCategoricalScale < DomainType , RangeType >","body":"= <EOL> NonPositionalCategoricalScale ( categoriesToValues . map { it . first } , categoriesToValues . map { it . second } , )","docstring":"/**\n * Creates a new categorical non-positional scale.\n *\n * @param DomainType scale domain type.\n * @param RangeType type of the scale range.\n * @param categoriesToValues [List] of pairs of category to corresponding value.\n * @return new [NonPositionalCategoricalScale] by domain-to-range correspondence.\n */"}
{"signature":"public fun < DomainType , RangeType > Scale . Companion . categorical ( vararg categoriesToValues : Pair < DomainType , RangeType > , ) : NonPositionalCategoricalScale < DomainType , RangeType >","body":"= <EOL> NonPositionalCategoricalScale ( categoriesToValues . map { it . first } , categoriesToValues . map { it . second } , )","docstring":"/**\n * Creates a new categorical non-positional scale.\n *\n * @param DomainType scale domain type\n * @param RangeType type of the scale range\n * @param categoriesToValues [List] of pairs of category to corresponding value.\n * @return new [NonPositionalCategoricalScale] by domain-to-range correspondence.\n */"}
{"signature":"fun buildBalancedOrExpressionTree ( conditions : List < FirExpression > , lower : Int = <NUM_LIT:0> , upper : Int = conditions . lastIndex ) : FirExpression","body":"{ <EOL> val size = upper - lower + <NUM_LIT:1> <EOL> val middle = size / <NUM_LIT:2> + lower <EOL> if ( lower == upper ) { <EOL> return conditions [ middle ] <EOL> } <EOL> val leftNode = buildBalancedOrExpressionTree ( conditions , lower , middle - <NUM_LIT:1> ) <EOL> val rightNode = buildBalancedOrExpressionTree ( conditions , middle , upper ) <EOL> return leftNode . generateLazyLogicalOperation ( rightNode , isAnd = false , ( leftNode . source ? : rightNode . source ) ? . fakeElement ( KtFakeSourceElementKind . WhenCondition ) ) <EOL> }","docstring":"/**\n * Creates balanced tree of OR expressions for given set of conditions\n * We do so, to avoid too deep OR-expression structures, that can cause running out of stack while processing\n * [conditions] should contain at least one element, otherwise it will cause StackOverflow\n */"}
{"signature":"@ HtmlTagMarker <EOL> inline fun SELECT . option ( classes : String ? = null , crossinline block : OPTION . ( ) -> Unit = { } ) : Unit","body":"= OPTION ( attributesMapOf ( \"<STR_LIT:class>\" , classes ) , consumer ) . visit ( block )","docstring":"/**\n * Selectable choice\n */"}
{"signature":"@ HtmlTagMarker <EOL> fun SELECT . option ( classes : String ? = null , content : String = \"<STR_LIT>\" ) : Unit","body":"= OPTION ( attributesMapOf ( \"<STR_LIT:class>\" , classes ) , consumer ) . visit ( { + content } )","docstring":"/**\n * Selectable choice\n */"}
{"signature":"@ HtmlTagMarker <EOL> inline fun SELECT . optGroup ( label : String ? = null , classes : String ? = null , crossinline block : OPTGROUP . ( ) -> Unit = { } ) : Unit","body":"= OPTGROUP ( attributesMapOf ( \"<STR_LIT>\" , label , \"<STR_LIT:class>\" , classes ) , consumer ) . visit ( block )","docstring":"/**\n * Option group\n */"}
{"signature":"public fun < C > getCol ( accessor : ColumnReference < C > ) : ColumnWithPath < C > ?","body":"= <EOL> asColumnGroup ( ) . getColumnOrNull ( accessor ) ? . addPath ( path + accessor . path ( ) )","docstring":"/**\n * Casts this column to a [ColumnGroup] and returns a column with the specified [accessor] or null if it\n * can't be found.\n */"}
{"signature":"public fun getCol ( name : String ) : ColumnWithPath < Any ? > ?","body":"= <EOL> asColumnGroup ( ) . getColumnOrNull ( name ) ? . addParentPath ( path )","docstring":"/**\n * Casts this column to a [ColumnGroup] and returns a column with the specified [name] or null if it\n * can't be found.\n */"}
{"signature":"public fun getCol ( index : Int ) : ColumnWithPath < Any ? > ?","body":"= <EOL> asColumnGroup ( ) . getColumnOrNull ( index ) ? . addParentPath ( path )","docstring":"/**\n * Casts this column to a [ColumnGroup] and returns a column with the specified [index] or null if it\n * can't be found.\n */"}
{"signature":"public fun < C > getCol ( accessor : KProperty < C > ) : ColumnWithPath < C > ?","body":"= <EOL> asColumnGroup ( ) . getColumnOrNull ( accessor ) ? . addParentPath ( path )","docstring":"/**\n * Casts this column to a [ColumnGroup] and returns a column with the specified [accessor] or null if it\n * can't be found.\n */"}
{"signature":"public fun cols ( ) : List < ColumnWithPath < Any ? > >","body":"= <EOL> if ( isColumnGroup ( ) ) { <EOL> data . asColumnGroup ( ) . columns ( ) . map { it . addParentPath ( path ) } <EOL> } else { <EOL> emptyList ( ) <EOL> }","docstring":"/**\n * Returns all (\"children\") columns in this column if it's a group, else it returns an empty list.\n */"}
{"signature":"public fun KtExpression . evaluate ( mode : KtConstantEvaluationMode ) : KtConstantValue ?","body":"= <EOL> withValidityAssertion { analysisSession . compileTimeConstantProvider . evaluate ( this , mode ) }","docstring":"/**\n * Tries to evaluate the provided expression using the specified mode.\n * Returns a [KtConstantValue] if the expression evaluates to a compile-time constant, otherwise returns null..\n */"}
{"signature":"public fun KtExpression . evaluateAsAnnotationValue ( ) : KtAnnotationValue ?","body":"= <EOL> withValidityAssertion { analysisSession . compileTimeConstantProvider . evaluateAsAnnotationValue ( this ) }","docstring":"/**\n * Returns a [KtConstantValue] if the expression evaluates to a value that can be used as an annotation parameter value,\n * e.g. an array of constants, otherwise returns null.\n */"}
{"signature":"@ JvmStatic <EOL> fun newInstance ( param1 : String , param2 : String )","body":"= <EOL> DestinationFragment1 ( ) . apply { <EOL> arguments = Bundle ( ) . apply { <EOL> putString ( ARG_PARAM1 , param1 ) <EOL> putString ( ARG_PARAM2 , param2 ) <EOL> } <EOL> }","docstring":"/**\n * Use this factory method to create a new instance of\n * this fragment using the provided parameters.\n *\n * @param param1 Parameter 1.\n * @param param2 Parameter 2.\n * @return A new instance of fragment DestinationFragment1.\n */"}
{"signature":"abstract override fun hashCode ( ) : Int","body":"abstract override fun hashCode ( ) : Int","docstring":"/** Implementation must compute the hashcode from the source element. */"}
{"signature":"abstract override fun equals ( other : Any ? ) : Boolean","body":"abstract override fun equals ( other : Any ? ) : Boolean","docstring":"/** Elements of the same source should be considered equal. */"}
{"signature":"fun unwrapToKtPsiSourceElement ( ) : KtPsiSourceElement ?","body":"{ <EOL> if ( treeStructure !is KtPsiSourceElement . WrappedTreeStructure ) return null <EOL> val node = treeStructure . unwrap ( lighterASTNode ) <EOL> return node . psi ? . toKtPsiSourceElement ( kind ) <EOL> }","docstring":"/**\n * We can create a [KtLightSourceElement] from a [KtPsiSourceElement] by using [KtPsiSourceElement.lighterASTNode];\n * [unwrapToKtPsiSourceElement] allows to get original [KtPsiSourceElement] in such case.\n *\n * If it is `pure` [KtLightSourceElement], i.e, compiler created it in light tree mode, then return [unwrapToKtPsiSourceElement] `null`.\n * Otherwise, return some not-null result.\n */"}
{"signature":"expect fun < T > CoroutineScope . asyncWithDealy ( delay : Long , block : suspend ( ) -> T ) : Deferred < T >","body":"expect fun < T > CoroutineScope . asyncWithDealy ( delay : Long , block : suspend ( ) -> T ) : Deferred < T >","docstring":"/**\n * Common `expect` declaration\n */"}
{"signature":"fun CoroutineDispatcher . name ( ) : String","body":"= TODO ( \"<STR_LIT>\" )","docstring":"/**\n * Common coroutine extension\n */"}
{"signature":"private fun produceObjCFramework ( engine : PhaseEngine < PhaseContext > , config : KonanConfig , environment : KotlinCoreEnvironment )","body":"{ <EOL> val frontendOutput = engine . runFrontend ( config , environment ) ? : return <EOL> val objCExportedInterface = engine . runPhase ( ProduceObjCExportInterfacePhase , frontendOutput ) <EOL> engine . runPhase ( CreateObjCFrameworkPhase , CreateObjCFrameworkInput ( frontendOutput . moduleDescriptor , objCExportedInterface ) ) <EOL> if ( config . omitFrameworkBinary ) { <EOL> return <EOL> } <EOL> val ( psiToIrOutput , objCCodeSpec ) = engine . runPsiToIr ( frontendOutput , isProducingLibrary = false ) { <EOL> it . runPhase ( CreateObjCExportCodeSpecPhase , objCExportedInterface ) <EOL> } <EOL> require ( psiToIrOutput is PsiToIrOutput . ForBackend ) <EOL> val backendContext = createBackendContext ( config , frontendOutput , psiToIrOutput ) { <EOL> it . objCExportedInterface = objCExportedInterface <EOL> it . objCExportCodeSpec = objCCodeSpec <EOL> } <EOL> engine . runBackend ( backendContext , psiToIrOutput . irModule ) <EOL> }","docstring":"/**\n * Create an Objective-C framework which is a directory consisting of\n * - Objective-C header\n * - Info.plist\n * - Binary (if -Xomit-framework-binary is not passed).\n */"}
{"signature":"private fun produceBinary ( engine : PhaseEngine < PhaseContext > , config : KonanConfig , environment : KotlinCoreEnvironment )","body":"{ <EOL> val frontendOutput = engine . runFrontend ( config , environment ) ? : return <EOL> val psiToIrOutput = engine . runPsiToIr ( frontendOutput , isProducingLibrary = false ) <EOL> require ( psiToIrOutput is PsiToIrOutput . ForBackend ) <EOL> val backendContext = createBackendContext ( config , frontendOutput , psiToIrOutput ) <EOL> engine . runBackend ( backendContext , psiToIrOutput . irModule ) <EOL> }","docstring":"/**\n * Produce a single binary artifact.\n */"}
{"signature":"private fun produceBundle ( engine : PhaseEngine < PhaseContext > , config : KonanConfig , environment : KotlinCoreEnvironment )","body":"{ <EOL> require ( config . target . family . isAppleFamily ) <EOL> require ( config . produce == CompilerOutputKind . TEST_BUNDLE ) <EOL> val frontendOutput = engine . runFrontend ( config , environment ) ? : return <EOL> engine . runPhase ( CreateTestBundlePhase , frontendOutput ) <EOL> val psiToIrOutput = engine . runPsiToIr ( frontendOutput , isProducingLibrary = false ) <EOL> require ( psiToIrOutput is PsiToIrOutput . ForBackend ) <EOL> val backendContext = createBackendContext ( config , frontendOutput , psiToIrOutput ) <EOL> engine . runBackend ( backendContext , psiToIrOutput . irModule ) <EOL> }","docstring":"/**\n * Produce a bundle that is a directory with code and resources.\n * It consists of\n * - Info.plist\n * - Binary without an entry point.\n *\n * See https://developer.apple.com/library/archive/documentation/CoreFoundation/Conceptual/CFBundles/AboutBundles/AboutBundles.html\n */"}
{"signature":"override fun matches ( startIndex : Int , testString : CharSequence , matchResult : MatchResultImpl ) : Int","body":"{ <EOL> if ( children . isEmpty ( ) ) { <EOL> return - <NUM_LIT:1> <EOL> } <EOL> val oldStart = matchResult . getStart ( groupIndex ) <EOL> matchResult . setStart ( groupIndex , startIndex ) <EOL> children . forEach { <EOL> val shift = it . matches ( startIndex , testString , matchResult ) <EOL> if ( shift >= <NUM_LIT:0> ) { <EOL> return shift <EOL> } <EOL> } <EOL> matchResult . setStart ( groupIndex , oldStart ) <EOL> return - <NUM_LIT:1> <EOL> }","docstring":"/**\n * Returns startIndex+shift, the next position to match\n */"}
{"signature":"internal fun prepareKotlinNativeBundle ( project : Project , kotlinNativeBundleConfiguration : ConfigurableFileCollection , kotlinNativeVersion : String , bundleDir : File , reinstallFlag : Boolean , konanTargets : Set < KonanTarget > , overriddenKonanHome : String ? , )","body":"{ <EOL> if ( overriddenKonanHome != null ) { <EOL> project . logger . info ( \"<STR_LIT>\" ) <EOL> } else { <EOL> processToolchain ( bundleDir , project , reinstallFlag , kotlinNativeVersion , kotlinNativeBundleConfiguration ) <EOL> } <EOL> project . setupKotlinNativePlatformLibraries ( konanTargets ) <EOL> }","docstring":"/**\n * This function downloads and installs a Kotlin Native bundle if needed\n * and then prepares its platform libraries if needed.\n *\n * @param project The Gradle project object.\n * @param kotlinNativeBundleConfiguration Gradle configuration for Kotlin Native Bundle\n * @param kotlinNativeVersion The version of Kotlin/Native to install\n * @param bundleDir The directory to store the Kotlin/Native bundle.\n * @param reinstallFlag A flag indicating whether to reinstall the bundle.\n * @param konanTargets The set of KonanTarget objects representing the targets for the Kotlin/Native bundle.\n * @param overriddenKonanHome Overridden konan home if present.\n * @return kotlin native version if toolchain was used, path to konan home if konan home was used\n */"}
{"signature":"internal fun downloadNativeDependencies ( bundleDir : File , konanDataDir : String ? , konanTargets : Set < KonanTarget > , logger : Logger , ) : Set < String >","body":"{ <EOL> val requiredDependencies = mutableSetOf < String > ( ) <EOL> val distribution = Distribution ( bundleDir . absolutePath , konanDataDir = konanDataDir ) <EOL> konanTargets . forEach { konanTarget -> <EOL> if ( konanTarget . enabledOnCurrentHostForBinariesCompilation ( ) ) { <EOL> val konanPropertiesLoader = loadConfigurables ( konanTarget , distribution . properties , distribution . dependenciesDir , progressCallback = { url , currentBytes , totalBytes -> <EOL> logger . info ( \"<STR_LIT>\" ) <EOL> } ) as KonanPropertiesLoader <EOL> requiredDependencies . addAll ( konanPropertiesLoader . dependencies ) <EOL> konanPropertiesLoader . downloadDependencies ( DependencyExtractor ( ) ) <EOL> } <EOL> } <EOL> return requiredDependencies <EOL> }","docstring":"/**\n * Downloads native dependencies for Kotlin Native based on the provided configuration.\n * @return A set of required dependencies that were downloaded.\n */"}
{"signature":"public fun < T > yBegin ( column : ColumnReference < T > ) : PositionalMapping < T >","body":"{ <EOL> return addPositionalMapping < T > ( Y_BEGIN , column . name ( ) , null ) <EOL> }","docstring":"/**\n * Maps the `yBegin` aesthetic to a data column by [ColumnReference].\n *\n * @param column the data column to be mapped.\n * @return a [PositionalMapping] object representing the mapping.\n */"}
{"signature":"public fun < T > yBegin ( column : KProperty < T > ) : PositionalMapping < T >","body":"{ <EOL> return addPositionalMapping < T > ( Y_BEGIN , column . name , null ) <EOL> }","docstring":"/**\n * Maps the `yBegin` aesthetic to a data column by [KProperty].\n *\n * @param column the data column to be mapped.\n * @return a [PositionalMapping] object representing the mapping.\n */"}
{"signature":"public fun yBegin ( column : String ) : PositionalMapping < Any ? >","body":"{ <EOL> return addPositionalMapping ( Y_BEGIN , column , null ) <EOL> }","docstring":"/**\n * Maps the `yBegin` aesthetic to a data column by [String].\n *\n * @param column the data column to be mapped.\n * @return a [PositionalMapping] object representing the mapping.\n */"}
{"signature":"public fun < T > yBegin ( values : Iterable < T > ) : PositionalMapping < T >","body":"{ <EOL> return addPositionalMapping < T > ( Y_BEGIN , values . toList ( ) , null , null ) <EOL> }","docstring":"/**\n * Maps the `yBegin` aesthetic to iterable of values.\n *\n * @param values the iterable of values to be mapped.\n * @return a [PositionalMapping] object representing the mapping.\n */"}
{"signature":"public fun < T > yBegin ( values : DataColumn < T > ) : PositionalMapping < T >","body":"{ <EOL> return addPositionalMapping < T > ( Y_BEGIN , values , null ) <EOL> }","docstring":"/**\n * Maps the `yBegin` aesthetic to a data column.\n *\n * @param values the data column to be mapped.\n * @return a [PositionalMapping] object representing the mapping.\n */"}
{"signature":"private fun < T > Flow < T > . idScoped ( ) : Flow < T >","body":"= flow { <EOL> coroutineScope { <EOL> val channel = produce { <EOL> collect { send ( it ) } <EOL> } <EOL> channel . consumeEach { <EOL> emit ( it ) <EOL> } <EOL> } <EOL> }","docstring":"/**\n * This flow should be \"identity\" function with respect to cancellation.\n */"}
{"signature":"public fun KtExpression . getSmartCastInfo ( ) : KtSmartCastInfo ?","body":"= <EOL> withValidityAssertion { analysisSession . smartCastProvider . getSmartCastedInfo ( this ) }","docstring":"/**\n * Gets the smart-cast information of the given expression or null if the expression is not smart casted.\n */"}
{"signature":"public fun KtExpression . getImplicitReceiverSmartCast ( ) : Collection < KtImplicitReceiverSmartCast >","body":"= <EOL> withValidityAssertion { analysisSession . smartCastProvider . getImplicitReceiverSmartCast ( this ) }","docstring":"/**\n * Returns the list of implicit smart-casts which are required for the expression to be called. Includes only implicit\n * smart-casts:\n *\n * ```kt\n * if (this is String) {\n * this.substring() // 'this' receiver is explicit, so no implicit smart-cast here.\n *\n * smartcast() // 'this' receiver is implicit, therefore there is implicit smart-cast involved.\n * }\n * ```\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ ExperimentalUnsignedTypes <EOL> @ kotlin . internal . InlineOnly <EOL> public actual inline fun UIntArray . elementAt ( index : Int ) : UInt","body":"{ <EOL> return get ( index ) <EOL> }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ ExperimentalUnsignedTypes <EOL> @ kotlin . internal . InlineOnly <EOL> public actual inline fun ULongArray . elementAt ( index : Int ) : ULong","body":"{ <EOL> return get ( index ) <EOL> }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ ExperimentalUnsignedTypes <EOL> @ kotlin . internal . InlineOnly <EOL> public actual inline fun UByteArray . elementAt ( index : Int ) : UByte","body":"{ <EOL> return get ( index ) <EOL> }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ ExperimentalUnsignedTypes <EOL> @ kotlin . internal . InlineOnly <EOL> public actual inline fun UShortArray . elementAt ( index : Int ) : UShort","body":"{ <EOL> return get ( index ) <EOL> }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ ExperimentalUnsignedTypes <EOL> public actual fun UIntArray . asList ( ) : List < UInt >","body":"{ <EOL> return object : AbstractList < UInt > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : UInt ) : Boolean = this@asList . contains ( element ) <EOL> override fun get ( index : Int ) : UInt = this@asList [ index ] <EOL> override fun indexOf ( element : UInt ) : Int = this@asList . indexOf ( element ) <EOL> override fun lastIndexOf ( element : UInt ) : Int = this@asList . lastIndexOf ( element ) <EOL> } <EOL> }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ ExperimentalUnsignedTypes <EOL> public actual fun ULongArray . asList ( ) : List < ULong >","body":"{ <EOL> return object : AbstractList < ULong > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : ULong ) : Boolean = this@asList . contains ( element ) <EOL> override fun get ( index : Int ) : ULong = this@asList [ index ] <EOL> override fun indexOf ( element : ULong ) : Int = this@asList . indexOf ( element ) <EOL> override fun lastIndexOf ( element : ULong ) : Int = this@asList . lastIndexOf ( element ) <EOL> } <EOL> }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ ExperimentalUnsignedTypes <EOL> public actual fun UByteArray . asList ( ) : List < UByte >","body":"{ <EOL> return object : AbstractList < UByte > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : UByte ) : Boolean = this@asList . contains ( element ) <EOL> override fun get ( index : Int ) : UByte = this@asList [ index ] <EOL> override fun indexOf ( element : UByte ) : Int = this@asList . indexOf ( element ) <EOL> override fun lastIndexOf ( element : UByte ) : Int = this@asList . lastIndexOf ( element ) <EOL> } <EOL> }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ ExperimentalUnsignedTypes <EOL> public actual fun UShortArray . asList ( ) : List < UShort >","body":"{ <EOL> return object : AbstractList < UShort > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : UShort ) : Boolean = this@asList . contains ( element ) <EOL> override fun get ( index : Int ) : UShort = this@asList [ index ] <EOL> override fun indexOf ( element : UShort ) : Int = this@asList . indexOf ( element ) <EOL> override fun lastIndexOf ( element : UShort ) : Int = this@asList . lastIndexOf ( element ) <EOL> } <EOL> }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> @ ExperimentalUnsignedTypes <EOL> public infix fun UIntArray . contentEquals ( other : UIntArray ) : Boolean","body":"{ <EOL> return this . contentEquals ( other ) <EOL> }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> @ ExperimentalUnsignedTypes <EOL> public infix fun ULongArray . contentEquals ( other : ULongArray ) : Boolean","body":"{ <EOL> return this . contentEquals ( other ) <EOL> }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> @ ExperimentalUnsignedTypes <EOL> public infix fun UByteArray . contentEquals ( other : UByteArray ) : Boolean","body":"{ <EOL> return this . contentEquals ( other ) <EOL> }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> @ ExperimentalUnsignedTypes <EOL> public infix fun UShortArray . contentEquals ( other : UShortArray ) : Boolean","body":"{ <EOL> return this . contentEquals ( other ) <EOL> }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> @ ExperimentalUnsignedTypes <EOL> public fun UIntArray . contentHashCode ( ) : Int","body":"{ <EOL> return this . contentHashCode ( ) <EOL> }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> @ ExperimentalUnsignedTypes <EOL> public fun ULongArray . contentHashCode ( ) : Int","body":"{ <EOL> return this . contentHashCode ( ) <EOL> }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> @ ExperimentalUnsignedTypes <EOL> public fun UByteArray . contentHashCode ( ) : Int","body":"{ <EOL> return this . contentHashCode ( ) <EOL> }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> @ ExperimentalUnsignedTypes <EOL> public fun UShortArray . contentHashCode ( ) : Int","body":"{ <EOL> return this . contentHashCode ( ) <EOL> }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> @ ExperimentalUnsignedTypes <EOL> public fun UIntArray . contentToString ( ) : String","body":"{ <EOL> return this . contentToString ( ) <EOL> }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> @ ExperimentalUnsignedTypes <EOL> public fun ULongArray . contentToString ( ) : String","body":"{ <EOL> return this . contentToString ( ) <EOL> }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> @ ExperimentalUnsignedTypes <EOL> public fun UByteArray . contentToString ( ) : String","body":"{ <EOL> return this . contentToString ( ) <EOL> }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> @ ExperimentalUnsignedTypes <EOL> public fun UShortArray . contentToString ( ) : String","body":"{ <EOL> return this . contentToString ( ) <EOL> }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"}
{"signature":"@ JvmName ( \"<STR_LIT>\" ) <EOL> public fun LinAlg . plu ( mat : MultiArray < Float , D2 > ) : Triple < D2Array < Float > , D2Array < Float > , D2Array < Float > >","body":"= this . linAlgEx . pluF ( mat )","docstring":"/**\n * Returns PLU decomposition of the float matrix\n */"}
{"signature":"@ JvmName ( \"<STR_LIT>\" ) <EOL> public fun < T : Number > LinAlg . plu ( mat : MultiArray < T , D2 > ) : Triple < D2Array < Double > , D2Array < Double > , D2Array < Double > >","body":"= this . linAlgEx . plu ( mat )","docstring":"/**\n * Returns PLU decomposition of the numeric matrix\n */"}
{"signature":"@ JvmName ( \"<STR_LIT>\" ) <EOL> public fun < T : Complex > LinAlg . plu ( mat : MultiArray < T , D2 > ) : Triple < D2Array < T > , D2Array < T > , D2Array < T > >","body":"= this . linAlgEx . pluC ( mat )","docstring":"/**\n * Returns PLU decomposition of the complex matrix\n */"}
{"signature":"private fun resolveThrowsTag ( tag : ThrowingExceptionJavadocTag , currentElement : PsiDocComment , ) : List < DocumentationContent >","body":"{ <EOL> val closestDocsWithThrows = <EOL> ( currentElement . owner as? PsiMethod ) ? . let { method -> lowestMethodsWithTag ( method , tag ) } <EOL> . orEmpty ( ) . firstOrNull { <EOL> docCommentFinder . findClosestToElement ( it ) ? . hasTag ( tag ) == true <EOL> } ? : return emptyList ( ) <EOL> return docCommentFactory . fromElement ( closestDocsWithThrows ) <EOL> ? . resolveTag ( tag ) <EOL> ? : emptyList ( ) <EOL> }","docstring":"/**\n * Main resolution point for exception like tags\n *\n * This should be used only with [ThrowsJavadocTag] or [ExceptionJavadocTag] as their resolution path should be the same\n */"}
{"signature":"protected open fun modulesFromDeserializers ( deserializers : Collection < IrModuleDeserializer > , excludedModuleIds : Set < ResolvedDependencyId > ) : Map < ResolvedDependencyId , ResolvedDependency >","body":"{ <EOL> val modules : Map < ResolvedDependencyId , ModuleWithUninitializedDependencies > = deserializers . mapNotNull { deserializer -> <EOL> val moduleId = getUserVisibleModuleId ( deserializer ) <EOL> if ( moduleId in excludedModuleIds ) return@mapNotNull null <EOL> val module = ResolvedDependency ( id = moduleId , selectedVersion = ResolvedDependencyVersion . EMPTY , requestedVersionsByIncomingDependencies = hashMapOf ( ResolvedDependencyId . DEFAULT_SOURCE_CODE_MODULE_ID to ResolvedDependencyVersion . EMPTY ) , artifactPaths = hashSetOf ( ) ) <EOL> val outgoingDependencyIds = deserializer . moduleDependencies . map { getUserVisibleModuleId ( it ) } <EOL> moduleId to ModuleWithUninitializedDependencies ( module , outgoingDependencyIds ) <EOL> } . toMap ( ) <EOL> return modules . stampDependenciesWithRequestedVersionEqualToSelectedVersion ( ) <EOL> }","docstring":"/**\n * Load [ResolvedDependency]s that represent all libraries participating in the compilation. Includes external dependencies,\n * but without version and hierarchy information. Also includes the libraries that are not visible to the build system\n * (and therefore are missing in [ExternalDependenciesLoader.load]) but are provided by the compiler. For Kotlin/Native such\n * libraries are stdlib, endorsed and platform libraries.\n */"}
{"signature":"protected fun mergedModules ( deserializers : Collection < IrModuleDeserializer > ) : MutableMap < ResolvedDependencyId , ResolvedDependency >","body":"{ <EOL> val externalDependencyModulesByNames : Map < String , ResolvedDependency > = <EOL> hashMapOf < String , ResolvedDependency > ( ) . apply { <EOL> externalDependencyModules . forEach { externalDependency -> <EOL> externalDependency . id . uniqueNames . forEach { uniqueName -> <EOL> this [ uniqueName ] = externalDependency <EOL> } <EOL> } <EOL> } <EOL> fun findMatchingExternalDependencyModule ( moduleId : ResolvedDependencyId ) : ResolvedDependency ? = <EOL> moduleId . uniqueNames . firstNotNullOfOrNull { uniqueName -> externalDependencyModulesByNames [ uniqueName ] } <EOL> val artifactPathsToOriginModules : MutableMap < ResolvedDependencyArtifactPath , ResolvedDependency > = hashMapOf ( ) <EOL> externalDependencyModules . forEach { originModule -> <EOL> originModule . artifactPaths . forEach { artifactPath -> artifactPathsToOriginModules [ artifactPath ] = originModule } <EOL> } <EOL> val providedModules = mutableListOf < ResolvedDependency > ( ) <EOL> modulesFromDeserializers ( deserializers = deserializers , excludedModuleIds = setOf ( sourceCodeModuleId ) ) . forEach { ( moduleId , module ) -> <EOL> val externalDependencyModule = findMatchingExternalDependencyModule ( moduleId ) <EOL> if ( externalDependencyModule != null ) { <EOL> module . requestedVersionsByIncomingDependencies . forEach { ( incomingDependencyId , requestedVersion ) -> <EOL> val adjustedIncomingDependencyId = findMatchingExternalDependencyModule ( incomingDependencyId ) ? . id <EOL> ? : incomingDependencyId <EOL> if ( adjustedIncomingDependencyId !in externalDependencyModule . requestedVersionsByIncomingDependencies ) { <EOL> externalDependencyModule . requestedVersionsByIncomingDependencies [ adjustedIncomingDependencyId ] = requestedVersion <EOL> } <EOL> } <EOL> } else { <EOL> val originModuleVersion = module . artifactPaths . firstNotNullOfOrNull { artifactPathsToOriginModules [ it ] } ? . selectedVersion <EOL> if ( originModuleVersion != null ) { <EOL> module . selectedVersion = originModuleVersion <EOL> val incomingDependencyIdsToStampRequestedVersion = module . requestedVersionsByIncomingDependencies <EOL> . mapNotNull { ( incomingDependencyId , requestedVersion ) -> <EOL> if ( requestedVersion . isEmpty ( ) ) incomingDependencyId else null <EOL> } <EOL> incomingDependencyIdsToStampRequestedVersion . forEach { incomingDependencyId -> <EOL> module . requestedVersionsByIncomingDependencies [ incomingDependencyId ] = originModuleVersion <EOL> } <EOL> } else { <EOL> if ( module . requestedVersionsByIncomingDependencies . isEmpty ( ) ) { <EOL> module . requestedVersionsByIncomingDependencies [ sourceCodeModuleId ] = module . selectedVersion <EOL> } <EOL> } <EOL> module . requestedVersionsByIncomingDependencies . mapNotNull { ( incomingDependencyId , requestedVersion ) -> <EOL> val adjustedIncomingDependencyId = findMatchingExternalDependencyModule ( incomingDependencyId ) ? . id <EOL> ? : return@mapNotNull null <EOL> Triple ( incomingDependencyId , adjustedIncomingDependencyId , requestedVersion ) <EOL> } . forEach { ( incomingDependencyId , adjustedIncomingDependencyId , requestedVersion ) -> <EOL> module . requestedVersionsByIncomingDependencies . remove ( incomingDependencyId ) <EOL> module . requestedVersionsByIncomingDependencies [ adjustedIncomingDependencyId ] = requestedVersion <EOL> } <EOL> providedModules += module <EOL> } <EOL> } <EOL> return ( externalDependencyModules + providedModules ) . associateByTo ( hashMapOf ( ) ) { it . id } <EOL> }","docstring":"/**\n * The result of the merge of [ExternalDependenciesLoader.load] and [modulesFromDeserializers].\n */"}
{"signature":"fun getOrBuildFirFor ( element : KtElement ) : FirElement ?","body":"{ <EOL> return if ( element is KtFile && element !is KtCodeFragment ) { <EOL> getOrBuildFirForKtFile ( element ) <EOL> } else { <EOL> getFirForNonKtFileElement ( element ) <EOL> } <EOL> }","docstring":"/**\n * Returns a [FirElement] in its final resolved state.\n *\n * Note: that it isn't always [BODY_RESOLVE][FirResolvePhase.BODY_RESOLVE]\n * as not all declarations have types/bodies/etc. to resolve.\n *\n * For instance, [KtPackageDirective] has nothing to resolve,\n * so it will be returned as is ([FirPackageDirective][org.jetbrains.kotlin.fir.FirPackageDirective]),\n * with the [RAW_FIR][FirResolvePhase.RAW_FIR] phase.\n *\n * @return associated [FirElement] in final resolved state if it exists.\n *\n * @see getFirForElementInsideAnnotations\n * @see getFirForElementInsideTypes\n * @see getFirForElementInsideFileHeader\n */"}
{"signature":"internal fun getNonLocalContainingDeclaration ( elementsToCheck : Sequence < PsiElement > , predicate : ( KtDeclaration ) -> Boolean = { true } , ) : KtDeclaration ?","body":"{ <EOL> var candidate : KtDeclaration ? = null <EOL> fun propose ( declaration : KtDeclaration ) { <EOL> if ( candidate == null ) { <EOL> candidate = declaration <EOL> } <EOL> } <EOL> for ( parent in elementsToCheck ) { <EOL> candidate ? . let { notNullCandidate -> <EOL> if ( parent is KtEnumEntry || parent is KtCallableDeclaration && ! notNullCandidate . isPartOf ( parent ) || parent is KtAnonymousInitializer || parent is KtObjectLiteralExpression || parent is KtCallElement || parent is KtCodeFragment || parent is PsiErrorElement ) { <EOL> candidate = null <EOL> } <EOL> } <EOL> if ( candidate == null ) { <EOL> when ( parent ) { <EOL> is KtScript -> propose ( parent ) <EOL> is KtDestructuringDeclaration -> propose ( parent ) <EOL> is KtDestructuringDeclarationEntry -> propose ( parent ) <EOL> is KtScriptInitializer -> propose ( parent ) <EOL> is KtClassInitializer -> { <EOL> val container = parent . containingDeclaration <EOL> if ( ! container . isObjectLiteral ( ) && declarationCanBeLazilyResolved ( container ) && predicate ( parent ) ) { <EOL> propose ( parent ) <EOL> } <EOL> } <EOL> is KtDeclaration -> { <EOL> if ( ! parent . isAutonomousDeclaration ) { <EOL> if ( predicate ( parent ) ) { <EOL> propose ( parent ) <EOL> } <EOL> } <EOL> val isKindApplicable = when ( parent ) { <EOL> is KtClassOrObject -> ! parent . isObjectLiteral ( ) <EOL> is KtDeclarationWithBody , is KtProperty , is KtTypeAlias -> true <EOL> else -> false <EOL> } <EOL> if ( isKindApplicable && declarationCanBeLazilyResolved ( parent ) && predicate ( parent ) ) { <EOL> propose ( parent ) <EOL> } <EOL> } <EOL> } <EOL> } <EOL> } <EOL> return candidate <EOL> }","docstring":"/**\n * Returns the first non-local declaration from [elementsToCheck] that contains the given elements,\n * based on the specified predicate.\n *\n * The resulting declaration can be considered reachable at [RAW_FIR][FirResolvePhase.RAW_FIR] phase.\n *\n * @see org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure.FileStructure\n */"}
{"signature":"public open fun encodeElement ( descriptor : SerialDescriptor , index : Int ) : Boolean","body":"= true","docstring":"/**\n * Invoked before writing an element that is part of the structure to determine whether it should be encoded.\n * Element information can be obtained from the [descriptor] by the given [index].\n *\n * @return `true` if the value should be encoded, false otherwise\n */"}
{"signature":"public open fun encodeValue ( value : Any ) : Unit","body":"= <EOL> throw SerializationException ( \"<STR_LIT>\" )","docstring":"/**\n * Invoked to encode a value when specialized `encode*` method was not overridden.\n */"}
{"signature":"private fun createDelegateBody ( irField : IrField , delegatedFirDeclaration : FirCallableDeclaration , delegatedIrFunction : IrSimpleFunction , originalFirDeclaration : FirCallableDeclaration , originalFunctionSymbol : IrSimpleFunctionSymbol , isSetter : Boolean ) : IrBlockBody","body":"{ <EOL> val startOffset = SYNTHETIC_OFFSET <EOL> val endOffset = SYNTHETIC_OFFSET <EOL> val body = irFactory . createBlockBody ( startOffset , endOffset ) <EOL> val typeOrigin = when { <EOL> originalFirDeclaration is FirPropertyAccessor && originalFirDeclaration . isSetter -> ConversionTypeOrigin . SETTER <EOL> else -> ConversionTypeOrigin . DEFAULT <EOL> } <EOL> val callTypeCanBeNullable : Boolean <EOL> val callReturnType = when ( isSetter ) { <EOL> false -> { <EOL> val substitution = originalFirDeclaration . typeParameters . zip ( delegatedFirDeclaration . typeParameters ) <EOL> . map { ( original , delegated ) -> <EOL> original . symbol to delegated . symbol . defaultType <EOL> } . toMap ( ) <EOL> val substitutor = substitutorByMap ( substitution , session ) <EOL> val substitutedType = substitutor . substituteOrSelf ( originalFirDeclaration . returnTypeRef . coneType ) <EOL> callTypeCanBeNullable = Fir2IrImplicitCastInserter . typeCanBeEnhancedOrFlexibleNullable ( substitutedType , session ) <EOL> substitutedType . toIrType ( c , typeOrigin ) <EOL> } <EOL> true -> { <EOL> callTypeCanBeNullable = false <EOL> irBuiltIns . unitType <EOL> } <EOL> } <EOL> val irCall = IrCallImpl ( startOffset , endOffset , callReturnType , originalFunctionSymbol , originalFirDeclaration . typeParameters . size , originalFirDeclaration . numberOfIrValueParameters ( isSetter ) ) . apply { <EOL> val getField = IrGetFieldImpl ( startOffset , endOffset , irField . symbol , irField . type , IrGetValueImpl ( startOffset , endOffset , delegatedIrFunction . dispatchReceiverParameter ? . type ! ! , delegatedIrFunction . dispatchReceiverParameter ? . symbol ! ! <EOL> ) ) <EOL> val superFunctionDispatchReceiverType = originalFirDeclaration . dispatchReceiverType <EOL> val superFunctionDispatchReceiverLookupTag = ( superFunctionDispatchReceiverType as? ConeClassLikeType ) ? . lookupTag <EOL> val superFunctionParentSymbol = superFunctionDispatchReceiverLookupTag ? . let { classifierStorage . getIrClassSymbol ( it ) } <EOL> dispatchReceiver = if ( superFunctionParentSymbol == null || irField . type . isSubtypeOfClass ( superFunctionParentSymbol ) ) { <EOL> getField <EOL> } else { <EOL> Fir2IrImplicitCastInserter . implicitCastOrExpression ( getField , superFunctionDispatchReceiverType . toIrType ( c ) ) <EOL> } <EOL> extensionReceiver = <EOL> delegatedIrFunction . extensionReceiverParameter ? . let { extensionReceiver -> <EOL> IrGetValueImpl ( startOffset , endOffset , extensionReceiver . type , extensionReceiver . symbol ) <EOL> } <EOL> delegatedIrFunction . valueParameters . forEach { <EOL> putValueArgument ( it . index , IrGetValueImpl ( startOffset , endOffset , it . type , it . symbol ) ) <EOL> } <EOL> for ( index in originalFirDeclaration . typeParameters . indices ) { <EOL> putTypeArgument ( index , IrSimpleTypeImpl ( delegatedIrFunction . typeParameters [ index ] . symbol , hasQuestionMark = false , arguments = emptyList ( ) , annotations = emptyList ( ) ) ) <EOL> } <EOL> } <EOL> val resultType = delegatedIrFunction . returnType <EOL> val irCastOrCall = <EOL> if ( callTypeCanBeNullable && ! resultType . isNullable ( ) ) Fir2IrImplicitCastInserter . implicitNotNullCast ( irCall ) <EOL> else irCall <EOL> val originalDeclarationReturnType = originalFirDeclaration . returnTypeRef . coneType <EOL> if ( isSetter || originalDeclarationReturnType . isUnit || originalDeclarationReturnType . isNothing ) { <EOL> body . statements . add ( irCastOrCall ) <EOL> } else { <EOL> val irReturn = IrReturnImpl ( startOffset , endOffset , irBuiltIns . nothingType , delegatedIrFunction . symbol , irCastOrCall ) <EOL> body . statements . add ( irReturn ) <EOL> } <EOL> return body <EOL> }","docstring":"/**\n * interface Base {\n * fun foo(): String\n * }\n *\n * class Impl : Base {\n * override fun foo(): String { <-------------- [originalFirFunction], [originalFunctionSymbol]\n * return \"OK\"\n * }\n * }\n *\n * class Delegated(impl: Impl) : Base by impl {\n * private field delegate_xxx: Impl = impl <-------------- [irField]\n * generated override fun foo(): String <-------------- [delegateFunction]\n * }\n *\n */"}
{"signature":"public inline fun BarContext . background ( crossinline block : BackgroundStyle . ( ) -> Unit )","body":"{ <EOL> BackgroundStyle ( this ) . apply ( block ) <EOL> }","docstring":"/**\n * Sets background style for [bars][org.jetbrains.kotlinx.kandy.echarts.layers.bars].\n *\n * - [color][BackgroundStyle.color] - background [color][org.jetbrains.kotlinx.kandy.util.color.Color].\n * - [borderColor][BackgroundStyle.borderColor] -\n * background border [color][org.jetbrains.kotlinx.kandy.util.color.Color].\n * - [borderWidth][BackgroundStyle.borderWidth] - background border width.\n * By default `0`.\n * - [borderType][BackgroundStyle.borderType] - border [type][LineType].\n * By default `solid`.\n * - [borderRadius][BackgroundStyle.borderRadius] - background border radius.\n * By default `0`.\n * - [shadowBlur][BackgroundStyle.shadowBlur] - background shadow blur.\n * - [shadowColor][BackgroundStyle.shadowColor] -\n * background shadow [color][org.jetbrains.kotlinx.kandy.util.color.Color].\n * - [alpha][BackgroundStyle.alpha] - background opacity.\n *\n * ```kotlin\n * plot {\n * bars {\n * background {\n * color = Color.GREY\n * borderColor = Color.BLACK\n * borderWidth = 1.0\n * borderType = LineType.DASHED\n * borderRadius = 1.3\n * shadowBlur = 10.0\n * shadowColor = Color.GREEN\n * alpha = 0.7\n * }\n * }\n * }\n * ```\n *\n * @see org.jetbrains.kotlinx.kandy.echarts.layers.bars\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.5>\" ) <EOL> @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun UInt . countOneBits ( ) : Int","body":"= toInt ( ) . countOneBits ( )","docstring":"/**\n * Counts the number of set bits in the binary representation of this [UInt] number.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.5>\" ) <EOL> @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun UInt . countLeadingZeroBits ( ) : Int","body":"= toInt ( ) . countLeadingZeroBits ( )","docstring":"/**\n * Counts the number of consecutive most significant bits that are zero in the binary representation of this [UInt] number.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.5>\" ) <EOL> @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun UInt . countTrailingZeroBits ( ) : Int","body":"= toInt ( ) . countTrailingZeroBits ( )","docstring":"/**\n * Counts the number of consecutive least significant bits that are zero in the binary representation of this [UInt] number.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.5>\" ) <EOL> @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun UInt . takeHighestOneBit ( ) : UInt","body":"= toInt ( ) . takeHighestOneBit ( ) . toUInt ( )","docstring":"/**\n * Returns a number having a single bit set in the position of the most significant set bit of this [UInt] number,\n * or zero, if this number is zero.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.5>\" ) <EOL> @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun UInt . takeLowestOneBit ( ) : UInt","body":"= toInt ( ) . takeLowestOneBit ( ) . toUInt ( )","docstring":"/**\n * Returns a number having a single bit set in the position of the least significant set bit of this [UInt] number,\n * or zero, if this number is zero.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.6>\" ) <EOL> @ WasExperimental ( ExperimentalStdlibApi :: class , ExperimentalUnsignedTypes :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun UInt . rotateLeft ( bitCount : Int ) : UInt","body":"= toInt ( ) . rotateLeft ( bitCount ) . toUInt ( )","docstring":"/**\n * Rotates the binary representation of this [UInt] number left by the specified [bitCount] number of bits.\n * The most significant bits pushed out from the left side reenter the number as the least significant bits on the right side.\n *\n * Rotating the number left by a negative bit count is the same as rotating it right by the negated bit count:\n * `number.rotateLeft(-n) == number.rotateRight(n)`\n *\n * Rotating by a multiple of [UInt.SIZE_BITS] (32) returns the same number, or more generally\n * `number.rotateLeft(n) == number.rotateLeft(n % 32)`\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.6>\" ) <EOL> @ WasExperimental ( ExperimentalStdlibApi :: class , ExperimentalUnsignedTypes :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun UInt . rotateRight ( bitCount : Int ) : UInt","body":"= toInt ( ) . rotateRight ( bitCount ) . toUInt ( )","docstring":"/**\n * Rotates the binary representation of this [UInt] number right by the specified [bitCount] number of bits.\n * The least significant bits pushed out from the right side reenter the number as the most significant bits on the left side.\n *\n * Rotating the number right by a negative bit count is the same as rotating it left by the negated bit count:\n * `number.rotateRight(-n) == number.rotateLeft(n)`\n *\n * Rotating by a multiple of [UInt.SIZE_BITS] (32) returns the same number, or more generally\n * `number.rotateRight(n) == number.rotateRight(n % 32)`\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.5>\" ) <EOL> @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun ULong . countOneBits ( ) : Int","body":"= toLong ( ) . countOneBits ( )","docstring":"/**\n * Counts the number of set bits in the binary representation of this [ULong] number.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.5>\" ) <EOL> @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun ULong . countLeadingZeroBits ( ) : Int","body":"= toLong ( ) . countLeadingZeroBits ( )","docstring":"/**\n * Counts the number of consecutive most significant bits that are zero in the binary representation of this [ULong] number.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.5>\" ) <EOL> @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun ULong . countTrailingZeroBits ( ) : Int","body":"= toLong ( ) . countTrailingZeroBits ( )","docstring":"/**\n * Counts the number of consecutive least significant bits that are zero in the binary representation of this [ULong] number.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.5>\" ) <EOL> @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun ULong . takeHighestOneBit ( ) : ULong","body":"= toLong ( ) . takeHighestOneBit ( ) . toULong ( )","docstring":"/**\n * Returns a number having a single bit set in the position of the most significant set bit of this [ULong] number,\n * or zero, if this number is zero.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.5>\" ) <EOL> @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun ULong . takeLowestOneBit ( ) : ULong","body":"= toLong ( ) . takeLowestOneBit ( ) . toULong ( )","docstring":"/**\n * Returns a number having a single bit set in the position of the least significant set bit of this [ULong] number,\n * or zero, if this number is zero.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.6>\" ) <EOL> @ WasExperimental ( ExperimentalStdlibApi :: class , ExperimentalUnsignedTypes :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun ULong . rotateLeft ( bitCount : Int ) : ULong","body":"= toLong ( ) . rotateLeft ( bitCount ) . toULong ( )","docstring":"/**\n * Rotates the binary representation of this [ULong] number left by the specified [bitCount] number of bits.\n * The most significant bits pushed out from the left side reenter the number as the least significant bits on the right side.\n *\n * Rotating the number left by a negative bit count is the same as rotating it right by the negated bit count:\n * `number.rotateLeft(-n) == number.rotateRight(n)`\n *\n * Rotating by a multiple of [ULong.SIZE_BITS] (64) returns the same number, or more generally\n * `number.rotateLeft(n) == number.rotateLeft(n % 64)`\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.6>\" ) <EOL> @ WasExperimental ( ExperimentalStdlibApi :: class , ExperimentalUnsignedTypes :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun ULong . rotateRight ( bitCount : Int ) : ULong","body":"= toLong ( ) . rotateRight ( bitCount ) . toULong ( )","docstring":"/**\n * Rotates the binary representation of this [ULong] number right by the specified [bitCount] number of bits.\n * The least significant bits pushed out from the right side reenter the number as the most significant bits on the left side.\n *\n * Rotating the number right by a negative bit count is the same as rotating it left by the negated bit count:\n * `number.rotateRight(-n) == number.rotateLeft(n)`\n *\n * Rotating by a multiple of [ULong.SIZE_BITS] (64) returns the same number, or more generally\n * `number.rotateRight(n) == number.rotateRight(n % 64)`\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.5>\" ) <EOL> @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun UByte . countOneBits ( ) : Int","body":"= toUInt ( ) . countOneBits ( )","docstring":"/**\n * Counts the number of set bits in the binary representation of this [UByte] number.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.5>\" ) <EOL> @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun UByte . countLeadingZeroBits ( ) : Int","body":"= toByte ( ) . countLeadingZeroBits ( )","docstring":"/**\n * Counts the number of consecutive most significant bits that are zero in the binary representation of this [UByte] number.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.5>\" ) <EOL> @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun UByte . countTrailingZeroBits ( ) : Int","body":"= toByte ( ) . countTrailingZeroBits ( )","docstring":"/**\n * Counts the number of consecutive least significant bits that are zero in the binary representation of this [UByte] number.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.5>\" ) <EOL> @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun UByte . takeHighestOneBit ( ) : UByte","body":"= toInt ( ) . takeHighestOneBit ( ) . toUByte ( )","docstring":"/**\n * Returns a number having a single bit set in the position of the most significant set bit of this [UByte] number,\n * or zero, if this number is zero.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.5>\" ) <EOL> @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun UByte . takeLowestOneBit ( ) : UByte","body":"= toInt ( ) . takeLowestOneBit ( ) . toUByte ( )","docstring":"/**\n * Returns a number having a single bit set in the position of the least significant set bit of this [UByte] number,\n * or zero, if this number is zero.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.6>\" ) <EOL> @ WasExperimental ( ExperimentalStdlibApi :: class , ExperimentalUnsignedTypes :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun UByte . rotateLeft ( bitCount : Int ) : UByte","body":"= toByte ( ) . rotateLeft ( bitCount ) . toUByte ( )","docstring":"/**\n * Rotates the binary representation of this [UByte] number left by the specified [bitCount] number of bits.\n * The most significant bits pushed out from the left side reenter the number as the least significant bits on the right side.\n *\n * Rotating the number left by a negative bit count is the same as rotating it right by the negated bit count:\n * `number.rotateLeft(-n) == number.rotateRight(n)`\n *\n * Rotating by a multiple of [UByte.SIZE_BITS] (8) returns the same number, or more generally\n * `number.rotateLeft(n) == number.rotateLeft(n % 8)`\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.6>\" ) <EOL> @ WasExperimental ( ExperimentalStdlibApi :: class , ExperimentalUnsignedTypes :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun UByte . rotateRight ( bitCount : Int ) : UByte","body":"= toByte ( ) . rotateRight ( bitCount ) . toUByte ( )","docstring":"/**\n * Rotates the binary representation of this [UByte] number right by the specified [bitCount] number of bits.\n * The least significant bits pushed out from the right side reenter the number as the most significant bits on the left side.\n *\n * Rotating the number right by a negative bit count is the same as rotating it left by the negated bit count:\n * `number.rotateRight(-n) == number.rotateLeft(n)`\n *\n * Rotating by a multiple of [UByte.SIZE_BITS] (8) returns the same number, or more generally\n * `number.rotateRight(n) == number.rotateRight(n % 8)`\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.5>\" ) <EOL> @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun UShort . countOneBits ( ) : Int","body":"= toUInt ( ) . countOneBits ( )","docstring":"/**\n * Counts the number of set bits in the binary representation of this [UShort] number.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.5>\" ) <EOL> @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun UShort . countLeadingZeroBits ( ) : Int","body":"= toShort ( ) . countLeadingZeroBits ( )","docstring":"/**\n * Counts the number of consecutive most significant bits that are zero in the binary representation of this [UShort] number.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.5>\" ) <EOL> @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun UShort . countTrailingZeroBits ( ) : Int","body":"= toShort ( ) . countTrailingZeroBits ( )","docstring":"/**\n * Counts the number of consecutive least significant bits that are zero in the binary representation of this [UShort] number.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.5>\" ) <EOL> @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun UShort . takeHighestOneBit ( ) : UShort","body":"= toInt ( ) . takeHighestOneBit ( ) . toUShort ( )","docstring":"/**\n * Returns a number having a single bit set in the position of the most significant set bit of this [UShort] number,\n * or zero, if this number is zero.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.5>\" ) <EOL> @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun UShort . takeLowestOneBit ( ) : UShort","body":"= toInt ( ) . takeLowestOneBit ( ) . toUShort ( )","docstring":"/**\n * Returns a number having a single bit set in the position of the least significant set bit of this [UShort] number,\n * or zero, if this number is zero.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.6>\" ) <EOL> @ WasExperimental ( ExperimentalStdlibApi :: class , ExperimentalUnsignedTypes :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun UShort . rotateLeft ( bitCount : Int ) : UShort","body":"= toShort ( ) . rotateLeft ( bitCount ) . toUShort ( )","docstring":"/**\n * Rotates the binary representation of this [UShort] number left by the specified [bitCount] number of bits.\n * The most significant bits pushed out from the left side reenter the number as the least significant bits on the right side.\n *\n * Rotating the number left by a negative bit count is the same as rotating it right by the negated bit count:\n * `number.rotateLeft(-n) == number.rotateRight(n)`\n *\n * Rotating by a multiple of [UShort.SIZE_BITS] (16) returns the same number, or more generally\n * `number.rotateLeft(n) == number.rotateLeft(n % 16)`\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.6>\" ) <EOL> @ WasExperimental ( ExperimentalStdlibApi :: class , ExperimentalUnsignedTypes :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun UShort . rotateRight ( bitCount : Int ) : UShort","body":"= toShort ( ) . rotateRight ( bitCount ) . toUShort ( )","docstring":"/**\n * Rotates the binary representation of this [UShort] number right by the specified [bitCount] number of bits.\n * The least significant bits pushed out from the right side reenter the number as the most significant bits on the left side.\n *\n * Rotating the number right by a negative bit count is the same as rotating it left by the negated bit count:\n * `number.rotateRight(-n) == number.rotateLeft(n)`\n *\n * Rotating by a multiple of [UShort.SIZE_BITS] (16) returns the same number, or more generally\n * `number.rotateRight(n) == number.rotateRight(n % 16)`\n */"}
{"signature":"fun isValid ( ) : Boolean","body":"{ <EOL> return substitutor . isValid <EOL> }","docstring":"/**\n * Checks if the [ResolutionResult] is valid.\n *\n * The [PsiSubstitutor] which is contained inside [ResolutionResult] might become\n * invalidated as it contains [PsiType]s inside\n *\n * @return true if the substitutor is valid, false otherwise.\n */"}
{"signature":"private fun resolve ( ) : ResolutionResult","body":"{ <EOL> while ( true ) { <EOL> val snapshot = resolutionResult <EOL> @ Suppress ( \"<STR_LIT>\" ) <EOL> when { <EOL> snapshot != null && snapshot . isValid ( ) -> { <EOL> return snapshot <EOL> } <EOL> else -> { <EOL> val computedResult = computeResolveResult ( ) <EOL> if ( ! resolutionResultAtomicFieldUpdater . compareAndSet ( this , snapshot , computedResult ) ) { <EOL> continue <EOL> } <EOL> return computedResult <EOL> } <EOL> } <EOL> } <EOL> }","docstring":"/**\n * Resolves the current [JavaClassifierType]\n *\n * The code is thread safe and the logic is the following:\n * 1. Try to get a cached resolution result and return it if it's not invalidated\n * 2. Otherwise, resolve the current [JavaClassifierType], update the cache and return the result.\n *\n * @returns [ResolutionResult] to which the [JavaClassifierType] resovled\n */"}
{"signature":"fun FirFunctionSymbol < * > . getSingleMatchedExpectForActualOrNull ( ) : FirFunctionSymbol < * > ?","body":"= <EOL> ( this as FirBasedSymbol < * > ) . getSingleMatchedExpectForActualOrNull ( ) as? FirFunctionSymbol < * >","docstring":"/**\n * @see expectForActual\n */"}
{"signature":"fun FirBasedSymbol < * > . getSingleMatchedExpectForActualOrNull ( ) : FirBasedSymbol < * > ?","body":"= <EOL> expectForActual ? . get ( ExpectActualMatchingCompatibility . MatchedSuccessfully ) ? . singleOrNull ( )","docstring":"/**\n * @see expectForActual\n */"}
{"signature":"@ Test <EOL> fun `Java primitive annotations work` ( )","body":"{ <EOL> val writerPlugin = TestOutputWriterPlugin ( ) <EOL> val configuration = dokkaConfiguration { <EOL> sourceSets { <EOL> sourceSet { <EOL> sourceRoots = listOf ( \"<STR_LIT:src/>\" ) <EOL> externalDocumentationLinks = listOf ( DokkaConfiguration . ExternalDocumentationLink . jdk ( <NUM_LIT:8> ) , stdlibExternalDocumentationLink ) <EOL> } <EOL> } <EOL> } <EOL> testInline ( \"\"\"<STR_LIT>\"\"\" . trimMargin ( ) , configuration , pluginOverrides = listOf ( writerPlugin ) , cleanupOutput = true ) { <EOL> documentablesTransformationStage = { module -> <EOL> val type = module . packages . single ( ) <EOL> . classlikes . first { it . name == \"<STR_LIT>\" } <EOL> . functions . single ( ) <EOL> . type as GenericTypeConstructor <EOL> assertEquals ( Annotations . Annotation ( DRI ( \"<STR_LIT>\" , \"<STR_LIT:Hello>\" ) , emptyMap ( ) ) , type . extra [ Annotations ] ? . directAnnotations ? . values ? . single ( ) ? . single ( ) ) <EOL> assertEquals ( \"<STR_LIT>\" , type . dri . toString ( ) ) <EOL> } <EOL> } <EOL> }","docstring":"/**\n * Kotlin Int becomes java int. Java int cannot be annotated in source, but Kotlin Int can be.\n * This is paired with DefaultDescriptorToDocumentableTranslatorTest.`Java primitive annotations work`()\n *\n * This test currently does not do anything because Kotlin.Int currently becomes java.lang.Integer not primitive int\n */"}
{"signature":"internal fun < T > Stack < T > . push ( item : T )","body":"= add ( item )","docstring":"/**\n * Pushes item to [Stack]\n * @param item Item to be pushed\n */"}
{"signature":"internal fun < T > Stack < T > . pop ( ) : T ?","body":"= if ( isNotEmpty ( ) ) removeAt ( lastIndex ) else null","docstring":"/**\n * Pops (removes and return) last item from [Stack]\n * @return item Last item if [Stack] is not empty, null otherwise\n */"}
{"signature":"internal fun < T > Stack < T > . peek ( ) : T ?","body":"= if ( isNotEmpty ( ) ) this [ lastIndex ] else null","docstring":"/**\n * Peeks (return) last item from [Stack]\n * @return item Last item if [Stack] is not empty, null otherwise\n */"}
{"signature":"fun usage ( )","body":"{ }","docstring":"/**\n * [Receiver.<caret_2>ext]\n */"}
{"signature":"@ Test <EOL> fun testTheSameValueIsComputedFromDifferentThreads ( )","body":"{ <EOL> val valueWithPostCompute = ValueWithPostCompute ( key = <NUM_LIT:1> , calculate = { Thread . currentThread ( ) . name to Unit } , postCompute = { _ , _ , _ -> } ) <EOL> val results = ConcurrentLinkedQueue < String > ( ) <EOL> val threads = ( <NUM_LIT:0> .. <NUM_LIT:9> ) . map { threadIndex -> <EOL> thread ( name = \"<STR_LIT>\" , start = false ) { <EOL> results . offer ( valueWithPostCompute . getValue ( ) ) <EOL> } <EOL> } <EOL> threads . forEach { it . start ( ) } <EOL> threads . forEach { it . join ( ) } <EOL> val resultsList = results . toList ( ) <EOL> Assertions . assertEquals ( threads . size , results . size ) <EOL> Assertions . assertTrue ( resultsList . all { it == resultsList [ <NUM_LIT:0> ] } , \"<STR_LIT>\" ) <EOL> }","docstring":"/**\n * Tests the following scenario:\n * - thread `t1` access the cache and executes `calculate()` and then `postCompute()` under a lock hold\n * - while the lock hold by `t1`, `t2` tries to also access the value and waits for the lock to be released by `t1`\n * - t1: during the post compute, some recoverable (e.g., PCE) exception happens inside the `postCompute()` and exception is not saved in the cache and rethrown\n * - t1 releases the lock with the `value` set to `ValueIsNotComputed`\n * - t2 acquires the lock and should try to recalculate the value in this case\n */"}
{"signature":"@ Test <EOL> fun testPCEFromPostCompute ( )","body":"{ <EOL> for ( i in <NUM_LIT:1> .. <NUM_LIT:100> ) { <EOL> val t1CalledCalculate = CountDownLatch ( <NUM_LIT:1> ) <EOL> val t2AccessedTheCache = CountDownLatch ( <NUM_LIT:1> ) <EOL> val resultRef = AtomicReference < Any ? > ( null ) <EOL> val valueWithPostCompute = ValueWithPostCompute ( key = <NUM_LIT:1> , calculate = { <EOL> if ( Thread . currentThread ( ) . name == \"<STR_LIT>\" ) { <EOL> t1CalledCalculate . countDown ( ) <EOL> } <EOL> Thread . currentThread ( ) . name to Unit <EOL> } , postCompute = { _ , _ , _ -> <EOL> t2AccessedTheCache . await ( ) <EOL> if ( Thread . currentThread ( ) . name == \"<STR_LIT>\" ) { <EOL> throw ProcessCanceledException ( ) <EOL> } <EOL> } ) <EOL> val t1 = thread ( name = \"<STR_LIT>\" ) { <EOL> try { <EOL> valueWithPostCompute . getValue ( ) <EOL> } catch ( _ : ProcessCanceledException ) { <EOL> } <EOL> } <EOL> val t2 = thread ( name = \"<STR_LIT>\" ) { <EOL> t1CalledCalculate . await ( ) <EOL> t2AccessedTheCache . countDown ( ) <EOL> try { <EOL> resultRef . set ( valueWithPostCompute . getValue ( ) ) <EOL> } catch ( e : Throwable ) { <EOL> resultRef . set ( e ) <EOL> } <EOL> } <EOL> t2 . join ( ) <EOL> t1 . join ( ) <EOL> when ( val result = resultRef . get ( ) ) { <EOL> is Throwable -> throw result <EOL> else -> Assertions . assertEquals ( \"<STR_LIT>\" , result ) <EOL> } <EOL> } <EOL> }","docstring":"/**\n * Tests the following scenario:\n * - thread `t1` access the cache and executes `calculate()` and then `postCompute()` under a lock hold\n * - while the lock hold by `t1`, `t2` tries to also access the value and waits for the lock to be released by `t1`\n * - t1: during the post compute, some recoverable (e.g., PCE) exception happens inside the `postCompute()` and exception is not saved in the cache and rethrown\n * - t1 releases the lock with the `value` set to `ValueIsNotComputed`\n * - t2 acquires the lock and should try to recalculate the value in this case\n */"}
{"signature":"fun coroutineCreation ( ) : StackTraceElement","body":"= Exception ( ) . artificialFrame ( _CREATION :: class . java . simpleName )","docstring":"/**\n * Returns an artificial stack trace element denoting the boundary between coroutine creation and its execution.\n *\n * Appearance of this function in stack traces does not mean that it was called. Instead, it is used as a marker\n * that separates the part of the stack trace with the code executed in a coroutine from the stack trace of the code\n * that launched the coroutine.\n *\n * In earlier versions of kotlinx-coroutines, this was displayed as \"(Coroutine creation stacktrace)\", which caused\n * problems for tooling that processes stack traces: https://github.com/Kotlin/kotlinx.coroutines/issues/2291\n *\n * Note that presence of this marker in a stack trace implies that coroutine creation stack traces were enabled.\n */"}
{"signature":"fun coroutineBoundary ( ) : StackTraceElement","body":"= Exception ( ) . artificialFrame ( _BOUNDARY :: class . java . simpleName )","docstring":"/**\n * Returns an artificial stack trace element denoting a coroutine boundary.\n *\n * Appearance of this function in stack traces does not mean that it was called. Instead, when one coroutine invokes\n * another, this is used as a marker in the stack trace to denote where the execution of one coroutine ends and that\n * of another begins.\n *\n * In earlier versions of kotlinx-coroutines, this was displayed as \"(Coroutine boundary)\", which caused\n * problems for tooling that processes stack traces: https://github.com/Kotlin/kotlinx.coroutines/issues/2291\n */"}
{"signature":"private fun Throwable . artificialFrame ( name : String ) : StackTraceElement","body":"= <EOL> with ( stackTrace [ <NUM_LIT:0> ] ) { StackTraceElement ( ARTIFICIAL_FRAME_PACKAGE_NAME + \"<STR_LIT:.>\" + name , \"<STR_LIT:_>\" , fileName , lineNumber ) }","docstring":"/**\n * Forms an artificial stack frame with the given class name.\n *\n * It consists of the following parts:\n * 1. The package name, it seems, is needed for the IDE to detect stack trace elements reliably. It is `_COROUTINE` since\n * this is a valid identifier.\n * 2. Class names represents what type of artificial frame this is.\n * 3. The method name is `_`. The methods not being present in class definitions does not seem to affect navigation.\n */"}
{"signature":"public fun breaks ( breaks : List < DomainType > ? = null , format : String ? = null )","body":"{ <EOL> this . breaks = breaks <EOL> this . format = format <EOL> }","docstring":"/**\n * Sets legend breaks with formatting.\n *\n * @param breaks list of breaks.\n * @param format format string.\n */"}
{"signature":"public fun breaksLabeled ( vararg breaksToLabels : Pair < DomainType , String > )","body":"{ <EOL> breaks = breaksToLabels . map { it . first } <EOL> labels = breaksToLabels . map { it . second } <EOL> }","docstring":"/**\n * Sets legend breaks with labels.\n *\n * @param breaksToLabels list of breaks with corresponding labels.\n */"}
{"signature":"public fun breaksLabeled ( breaks : List < DomainType > , labels : List < String > )","body":"{ <EOL> this . breaks = breaks <EOL> this . labels = labels <EOL> }","docstring":"/**\n * Sets legend breaks with labels.\n *\n * @param breaks list of breaks.\n * @param labels list of corresponding labels.\n */"}
{"signature":"public operator fun iterator ( ) : ByteIterator","body":"{ <EOL> return ImmutableBlobIteratorImpl ( this ) <EOL> }","docstring":"/** Creates an iterator over the elements of the array. */"}
{"signature":"@ Suppress ( \"<STR_LIT:DEPRECATION>\" ) <EOL> @ Deprecated ( \"<STR_LIT>\" ) <EOL> @ DeprecatedSinceKotlin ( warningSince = \"<STR_LIT:1.9>\" ) <EOL> @ GCUnsafeCall ( \"<STR_LIT>\" ) <EOL> public external fun ImmutableBlob . toByteArray ( startIndex : Int = <NUM_LIT:0> , endIndex : Int = size ) : ByteArray","body":"@ Suppress ( \"<STR_LIT:DEPRECATION>\" ) <EOL> @ Deprecated ( \"<STR_LIT>\" ) <EOL> @ DeprecatedSinceKotlin ( warningSince = \"<STR_LIT:1.9>\" ) <EOL> @ GCUnsafeCall ( \"<STR_LIT>\" ) <EOL> public external fun ImmutableBlob . toByteArray ( startIndex : Int = <NUM_LIT:0> , endIndex : Int = size ) : ByteArray","docstring":"/**\n * Copies the data from this blob into a new [ByteArray].\n *\n * @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.\n * @param endIndex the end (exclusive) of the subrange to copy, size of this blob by default.\n */"}
{"signature":"@ Suppress ( \"<STR_LIT:DEPRECATION>\" ) <EOL> @ Deprecated ( \"<STR_LIT>\" ) <EOL> @ DeprecatedSinceKotlin ( warningSince = \"<STR_LIT:1.9>\" ) <EOL> @ ExperimentalUnsignedTypes <EOL> @ GCUnsafeCall ( \"<STR_LIT>\" ) <EOL> public external fun ImmutableBlob . toUByteArray ( startIndex : Int = <NUM_LIT:0> , endIndex : Int = size ) : UByteArray","body":"@ Suppress ( \"<STR_LIT:DEPRECATION>\" ) <EOL> @ Deprecated ( \"<STR_LIT>\" ) <EOL> @ DeprecatedSinceKotlin ( warningSince = \"<STR_LIT:1.9>\" ) <EOL> @ ExperimentalUnsignedTypes <EOL> @ GCUnsafeCall ( \"<STR_LIT>\" ) <EOL> public external fun ImmutableBlob . toUByteArray ( startIndex : Int = <NUM_LIT:0> , endIndex : Int = size ) : UByteArray","docstring":"/**\n * Copies the data from this blob into a new [UByteArray].\n *\n * @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.\n * @param endIndex the end (exclusive) of the subrange to copy, size of this blob by default.\n */"}
{"signature":"@ Suppress ( \"<STR_LIT:DEPRECATION>\" ) <EOL> @ Deprecated ( \"<STR_LIT>\" ) <EOL> @ DeprecatedSinceKotlin ( warningSince = \"<STR_LIT:1.9>\" ) <EOL> public fun ImmutableBlob . asCPointer ( offset : Int = <NUM_LIT:0> ) : CPointer < ByteVar >","body":"= <EOL> interpretCPointer < ByteVar > ( asCPointerImpl ( offset ) ) ! !","docstring":"/**\n * Returns stable C pointer to data at certain [offset], useful as a way to pass resource\n * to C APIs.\n *\n * `ImmutableBlob` is deprecated since Kotlin 1.9. It is recommended to use `ByteArray` instead.\n * To get a stable C pointer to `ByteArray` data the array needs to be pinned first.\n * ```\n * byteArray.usePinned {\n * val cpointer = it.addressOf(offset)\n * // use the stable C pointer\n * }\n * ```\n * @see kotlinx.cinterop.CPointer\n */"}
{"signature":"@ Suppress ( \"<STR_LIT:DEPRECATION>\" ) <EOL> @ Deprecated ( \"<STR_LIT>\" ) <EOL> @ DeprecatedSinceKotlin ( warningSince = \"<STR_LIT:1.9>\" ) <EOL> public fun ImmutableBlob . asUCPointer ( offset : Int = <NUM_LIT:0> ) : CPointer < UByteVar >","body":"= <EOL> interpretCPointer < UByteVar > ( asCPointerImpl ( offset ) ) ! !","docstring":"/**\n * Returns stable C pointer to data at certain [offset], useful as a way to pass resource\n * to C APIs.\n *\n * `ImmutableBlob` is deprecated since Kotlin 1.9. It is recommended to use `ByteArray` instead.\n * To get a stable C pointer to `ByteArray` data the array needs to be pinned first.\n * ```\n * byteArray.usePinned {\n * val cpointer = it.addressOf(offset)\n * // use the stable C pointer\n * }\n * ```\n * @see kotlinx.cinterop.CPointer\n */"}
{"signature":"@ Suppress ( \"<STR_LIT:DEPRECATION>\" ) <EOL> @ Deprecated ( \"<STR_LIT>\" , ReplaceWith ( \"<STR_LIT>\" ) ) <EOL> @ DeprecatedSinceKotlin ( warningSince = \"<STR_LIT:1.9>\" ) <EOL> @ TypedIntrinsic ( IntrinsicType . IMMUTABLE_BLOB ) <EOL> public external fun immutableBlobOf ( vararg elements : Short ) : ImmutableBlob","body":"@ Suppress ( \"<STR_LIT:DEPRECATION>\" ) <EOL> @ Deprecated ( \"<STR_LIT>\" , ReplaceWith ( \"<STR_LIT>\" ) ) <EOL> @ DeprecatedSinceKotlin ( warningSince = \"<STR_LIT:1.9>\" ) <EOL> @ TypedIntrinsic ( IntrinsicType . IMMUTABLE_BLOB ) <EOL> public external fun immutableBlobOf ( vararg elements : Short ) : ImmutableBlob","docstring":"/**\n * Creates [ImmutableBlob] out of compile-time constant data.\n *\n * This method accepts values of [Short] type in range `0x00..0xff`, other values are prohibited.\n *\n * One element still represent one byte in the output data.\n * This is the only way to create ImmutableBlob for now.\n */"}
{"signature":"public fun ColumnSet < * > . colGroups ( filter : Predicate < ColumnGroup < * > > = { true } ) : TransformableColumnSet < AnyRow >","body":"= <EOL> columnGroupsInternal ( filter )","docstring":"/**\n * @include [CommonColGroupsDocs]\n * @set [CommonColGroupsDocs.ExampleArg]\n *\n * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`(\"my\") }.`[colGroups][ColumnSet.colGroups]`() }`\n *\n * `// NOTE: This can be shortened to just:`\n *\n * `df.`[select][DataFrame.select]` { `[colGroups][ColumnsSelectionDsl.colGroups]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`(\"my\") } }`\n */"}
{"signature":"public fun ColumnsSelectionDsl < * > . colGroups ( filter : Predicate < ColumnGroup < * > > = { true } ) : TransformableColumnSet < AnyRow >","body":"= <EOL> asSingleColumn ( ) . columnGroupsInternal ( filter )","docstring":"/**\n * @include [CommonColGroupsDocs]\n * @set [CommonColGroupsDocs.ExampleArg]\n *\n * `df.`[select][DataFrame.select]` { `[colGroups][ColumnsSelectionDsl.colGroups]`() }`\n *\n * `df.`[select][DataFrame.select]` { `[colGroups][ColumnsSelectionDsl.colGroups]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`(\"my\") } }`\n */"}
{"signature":"public fun SingleColumn < DataRow < * > > . colGroups ( filter : Predicate < ColumnGroup < * > > = { true } ) : TransformableColumnSet < AnyRow >","body":"= <EOL> this . ensureIsColumnGroup ( ) . columnGroupsInternal ( filter )","docstring":"/**\n * @include [CommonColGroupsDocs]\n * @set [CommonColGroupsDocs.ExampleArg]\n *\n * `df.`[select][DataFrame.select]` { myColGroup.`[colGroups][SingleColumn.colGroups]`() }`\n *\n * `df.`[select][DataFrame.select]` { myColGroup.`[colGroups][SingleColumn.colGroups]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`(\"my\") } }`\n */"}
{"signature":"public fun String . colGroups ( filter : Predicate < ColumnGroup < * > > = { true } ) : TransformableColumnSet < AnyRow >","body":"= <EOL> columnGroup ( this ) . colGroups ( filter )","docstring":"/**\n * @include [CommonColGroupsDocs]\n * @set [CommonColGroupsDocs.ExampleArg]\n *\n * `df.`[select][DataFrame.select]` { \"myColGroup\".`[colGroups][String.colGroups]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`(\"my\") } }`\n *\n * `df.`[select][DataFrame.select]` { \"myColGroup\".`[colGroups][String.colGroups]`() }`\n */"}
{"signature":"public fun KProperty < * > . colGroups ( filter : Predicate < ColumnGroup < * > > = { true } ) : TransformableColumnSet < AnyRow >","body":"= <EOL> columnGroup ( this ) . colGroups ( filter )","docstring":"/**\n * @include [CommonColGroupsDocs]\n * @set [CommonColGroupsDocs.ExampleArg]\n *\n * `df.`[select][DataFrame.select]` { `[colGroup][ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[colGroups][SingleColumn.colGroups]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`(\"my\") } }`\n *\n * `df.`[select][DataFrame.select]` { DataSchemaType::myColGroup.`[colGroups][KProperty.colGroups]`() }`\n */"}
{"signature":"public fun ColumnPath . colGroups ( filter : Predicate < ColumnGroup < * > > = { true } ) : TransformableColumnSet < AnyRow >","body":"= <EOL> columnGroup ( this ) . colGroups ( filter )","docstring":"/**\n * @include [CommonColGroupsDocs]\n * @set [CommonColGroupsDocs.ExampleArg]\n *\n * `df.`[select][DataFrame.select]` { \"pathTo\"[\"myGroupCol\"].`[colGroups][ColumnPath.colGroups]`() }`\n */"}
{"signature":"@ Suppress ( \"<STR_LIT:UNCHECKED_CAST>\" ) <EOL> internal fun ColumnsResolver < * > . columnGroupsInternal ( filter : ( ColumnGroup < * > ) -> Boolean ) : TransformableColumnSet < AnyRow >","body":"= <EOL> colsInternal { it . isColumnGroup ( ) && filter ( it . asColumnGroup ( ) ) } as TransformableColumnSet < AnyRow >","docstring":"/**\n * Returns a TransformableColumnSet containing the column groups that satisfy the given filter.\n *\n * @param filter The filter function to apply on each column group. Must accept a ColumnGroup object and return a Boolean.\n * @return A [TransformableColumnSet] containing the column groups that satisfy the filter.\n */"}
{"signature":"internal fun IrStatementsBuilder < * > . createCacheableChildSerializersFactory ( cacheProperty : IrProperty ? , cacheableSerializers : List < Boolean > , containingClassProducer : ( ) -> IrClass ) : ( Int ) -> IrExpression ?","body":"{ <EOL> cacheProperty ? : return { null } <EOL> val variable = <EOL> irTemporary ( irInvoke ( irGetObject ( containingClassProducer ( ) ) , cacheProperty . getter ! ! . symbol ) , \"<STR_LIT>\" ) <EOL> return { index : Int -> <EOL> if ( cacheableSerializers [ index ] ) { <EOL> irInvoke ( irGet ( variable ) , compilerContext . arrayValueGetter . symbol , irInt ( index ) ) <EOL> } else { <EOL> null <EOL> } <EOL> } <EOL> }","docstring":"/**\n * Factory to getting cached serializers via variable.\n * Must be used only in one place because for each factory creates one variable.\n *\n * Class from [containingClassProducer] used only if [cacheProperty] is not null.\n */"}
{"signature":"fun normalizePath ( path : String ) : String","body":"{ <EOL> var start = <NUM_LIT:0> <EOL> var separator = false <EOL> if ( isWindows ) { <EOL> if ( path . startsWith ( \"<STR_LIT>\" ) ) { <EOL> start = <NUM_LIT:2> <EOL> separator = true <EOL> } else if ( path . startsWith ( \"<STR_LIT>\" ) ) { <EOL> return normalizeTail ( <NUM_LIT:0> , path , false ) <EOL> } <EOL> } <EOL> for ( i in start until path . length ) { <EOL> val c = path [ i ] <EOL> if ( c == '<CHAR_LIT:/>' ) { <EOL> if ( separator ) { <EOL> return normalizeTail ( i , path , true ) <EOL> } <EOL> separator = true <EOL> } else if ( c == '<CHAR_LIT:\\\\>' ) { <EOL> return normalizeTail ( i , path , separator ) <EOL> } else { <EOL> separator = false <EOL> } <EOL> } <EOL> return path <EOL> }","docstring":"/**\n * converts back slashes to forward slashes\n * removes double slashes inside the path, e.g. \"x/y//z\" => \"x/y/z\"\n *\n * Converted from com.intellij.openapi.util.io.FileUtil.normalize\n */"}
{"signature":"fun getFields ( llvm : CodegenLlvmHelpers ) : List < FieldInfo >","body":"= getFieldsInternal ( llvm ) . map { fieldInfo -> <EOL> val mappedField = fieldInfo . irField ? . let { context . mapping . lateInitFieldToNullableField [ it ] ? : it } <EOL> if ( mappedField == fieldInfo . irField ) <EOL> fieldInfo <EOL> else <EOL> mappedField ! ! . toFieldInfo ( llvm ) <EOL> }","docstring":"/**\n * All fields of the class instance.\n * The order respects the class hierarchy, i.e. a class [fields] contains superclass [fields] as a prefix.\n */"}
{"signature":"fun getDeclaredFields ( llvm : CodegenLlvmHelpers ) : List < FieldInfo >","body":"{ <EOL> val outerThisField = if ( irClass . isInner ) <EOL> context . innerClassesSupport . getOuterThisField ( irClass ) <EOL> else null <EOL> val moduleDeserializer = context . irLinker . getCachedDeclarationModuleDeserializer ( irClass ) <EOL> if ( moduleDeserializer != null ) <EOL> return moduleDeserializer . deserializeClassFields ( irClass , outerThisField ? . toFieldInfo ( llvm ) ) <EOL> val declarations = irClass . declarations . toMutableList ( ) <EOL> outerThisField ? . let { <EOL> if ( ! declarations . contains ( it ) ) <EOL> declarations += it <EOL> } <EOL> return declarations . mapNotNull { <EOL> when ( it ) { <EOL> is IrField -> it . takeIf { it . isReal && ! it . isStatic } ? . toFieldInfo ( llvm ) <EOL> is IrProperty -> it . takeIf { it . isReal } ? . backingField ? . takeIf { ! it . isStatic } ? . toFieldInfo ( llvm ) <EOL> else -> null <EOL> } <EOL> } <EOL> }","docstring":"/**\n * Fields declared in the class.\n */"}
{"signature":"fun IrSimpleFunction . getLoweredVersion ( )","body":"= when { <EOL> isSuspend -> this . getOrCreateFunctionWithContinuationStub ( context ) <EOL> else -> this <EOL> }","docstring":"/**\n * Normally, function should be already replaced. But if the function come from LazyIr, it can be not replaced.\n */"}
{"signature":"open fun generate ( )","body":"{ <EOL> val frameMapAtStart = codegen . frameMap . mark ( ) <EOL> prepareConfiguration ( ) <EOL> val hasElse = expression . elseExpression != null <EOL> defaultLabel = if ( hasElse || ! isStatement || isExhaustive ) elseLabel else endLabel <EOL> generateSubjectValue ( ) <EOL> generateSubjectValueToIndex ( ) <EOL> val beginLabel = Label ( ) <EOL> v . mark ( beginLabel ) <EOL> generateSwitchInstructionByTransitionsTable ( ) <EOL> generateEntries ( ) <EOL> if ( ! hasElse && ( ! isStatement || isExhaustive ) ) { <EOL> v . visitLabel ( elseLabel ) <EOL> codegen . putUnitInstanceOntoStackForNonExhaustiveWhen ( expression , isStatement ) <EOL> } <EOL> codegen . markLineNumber ( expression , isStatement ) <EOL> v . mark ( endLabel ) <EOL> frameMapAtStart . dropTo ( ) <EOL> subjectVariableDescriptor ? . let { <EOL> v . visitLocalVariable ( it . name . asString ( ) , subjectType . descriptor , null , beginLabel , endLabel , subjectLocal ) <EOL> } <EOL> }","docstring":"/**\n * Generates bytecode for entire when expression\n */"}
{"signature":"private fun prepareConfiguration ( )","body":"{ <EOL> for ( entry in expression . entries ) { <EOL> val entryLabel = Label ( ) <EOL> for ( constant in switchCodegenProvider . getConstantsFromEntry ( entry ) ) { <EOL> if ( constant is NullValue || constant == null ) continue <EOL> processConstant ( constant , entryLabel , entry ) <EOL> } <EOL> if ( entry . isElse ) { <EOL> elseLabel = entryLabel <EOL> } <EOL> entryLabels . add ( entryLabel ) <EOL> } <EOL> }","docstring":"/**\n * Sets up transitionsTable and maybe something else needed in a special case\n * Behaviour may be changed by overriding processConstant\n */"}
{"signature":"private fun generateSubjectValue ( )","body":"{ <EOL> if ( subjectVariable != null ) { <EOL> val mySubjectVariable = bindingContext [ BindingContext . VARIABLE , subjectVariable ] <EOL> ? : throw AssertionError ( \"<STR_LIT>\" ) <EOL> subjectLocal = codegen . frameMap . enter ( mySubjectVariable , subjectType ) <EOL> codegen . visitProperty ( subjectVariable , null ) <EOL> StackValue . local ( subjectLocal , subjectType , subjectKotlinType ) . put ( subjectType , subjectKotlinType , codegen . v ) <EOL> subjectVariableDescriptor = mySubjectVariable <EOL> } else { <EOL> codegen . gen ( subjectExpression , subjectType , subjectKotlinType ) <EOL> subjectVariableDescriptor = null <EOL> } <EOL> }","docstring":"/**\n * Generates subject value on top of the stack.\n * If the subject is a variable, it's stored and loaded.\n */"}
{"signature":"protected abstract fun generateSubjectValueToIndex ( )","body":"protected abstract fun generateSubjectValueToIndex ( )","docstring":"/**\n * Given a subject value on stack (after [generateSubjectValue]),\n * produces int value to be used in switch.\n */"}
{"signature":"public suspend fun < S , T : S > Flow < T > . reduce ( operation : suspend ( accumulator : S , value : T ) -> S ) : S","body":"{ <EOL> var accumulator : Any ? = NULL <EOL> collect { value -> <EOL> accumulator = if ( accumulator !== NULL ) { <EOL> @ Suppress ( \"<STR_LIT:UNCHECKED_CAST>\" ) <EOL> operation ( accumulator as S , value ) <EOL> } else { <EOL> value <EOL> } <EOL> } <EOL> if ( accumulator === NULL ) throw NoSuchElementException ( \"<STR_LIT>\" ) <EOL> @ Suppress ( \"<STR_LIT:UNCHECKED_CAST>\" ) <EOL> return accumulator as S <EOL> }","docstring":"/**\n * Accumulates value starting with the first element and applying [operation] to current accumulator value and each element.\n * Throws [NoSuchElementException] if flow was empty.\n */"}
{"signature":"public suspend inline fun < T , R > Flow < T > . fold ( initial : R , crossinline operation : suspend ( acc : R , value : T ) -> R ) : R","body":"{ <EOL> var accumulator = initial <EOL> collect { value -> <EOL> accumulator = operation ( accumulator , value ) <EOL> } <EOL> return accumulator <EOL> }","docstring":"/**\n * Accumulates value starting with [initial] value and applying [operation] current accumulator value and each element\n */"}
{"signature":"public suspend fun < T > Flow < T > . single ( ) : T","body":"{ <EOL> var result : Any ? = NULL <EOL> collect { value -> <EOL> require ( result === NULL ) { \"<STR_LIT>\" } <EOL> result = value <EOL> } <EOL> if ( result === NULL ) throw NoSuchElementException ( \"<STR_LIT>\" ) <EOL> return result as T <EOL> }","docstring":"/**\n * The terminal operator that awaits for one and only one value to be emitted.\n * Throws [NoSuchElementException] for empty flow and [IllegalArgumentException] for flow\n * that contains more than one element.\n */"}
{"signature":"public suspend fun < T > Flow < T > . singleOrNull ( ) : T ?","body":"{ <EOL> var result : Any ? = NULL <EOL> collectWhile { <EOL> if ( result === NULL ) { <EOL> result = it <EOL> true <EOL> } else { <EOL> result = NULL <EOL> false <EOL> } <EOL> } <EOL> return if ( result === NULL ) null else result as T <EOL> }","docstring":"/**\n * The terminal operator that awaits for one and only one value to be emitted.\n * Returns the single value or `null`, if the flow was empty or emitted more than one value.\n */"}
{"signature":"public suspend fun < T > Flow < T > . first ( ) : T","body":"{ <EOL> var result : Any ? = NULL <EOL> collectWhile { <EOL> result = it <EOL> false <EOL> } <EOL> if ( result === NULL ) throw NoSuchElementException ( \"<STR_LIT>\" ) <EOL> return result as T <EOL> }","docstring":"/**\n * The terminal operator that returns the first element emitted by the flow and then cancels flow's collection.\n * Throws [NoSuchElementException] if the flow was empty.\n */"}
{"signature":"public suspend fun < T > Flow < T > . first ( predicate : suspend ( T ) -> Boolean ) : T","body":"{ <EOL> var result : Any ? = NULL <EOL> collectWhile { <EOL> if ( predicate ( it ) ) { <EOL> result = it <EOL> false <EOL> } else { <EOL> true <EOL> } <EOL> } <EOL> if ( result === NULL ) throw NoSuchElementException ( \"<STR_LIT>\" ) <EOL> return result as T <EOL> }","docstring":"/**\n * The terminal operator that returns the first element emitted by the flow matching the given [predicate] and then cancels flow's collection.\n * Throws [NoSuchElementException] if the flow has not contained elements matching the [predicate].\n */"}
{"signature":"public suspend fun < T > Flow < T > . firstOrNull ( ) : T ?","body":"{ <EOL> var result : T ? = null <EOL> collectWhile { <EOL> result = it <EOL> false <EOL> } <EOL> return result <EOL> }","docstring":"/**\n * The terminal operator that returns the first element emitted by the flow and then cancels flow's collection.\n * Returns `null` if the flow was empty.\n */"}
{"signature":"public suspend fun < T > Flow < T > . firstOrNull ( predicate : suspend ( T ) -> Boolean ) : T ?","body":"{ <EOL> var result : T ? = null <EOL> collectWhile { <EOL> if ( predicate ( it ) ) { <EOL> result = it <EOL> false <EOL> } else { <EOL> true <EOL> } <EOL> } <EOL> return result <EOL> }","docstring":"/**\n * The terminal operator that returns the first element emitted by the flow matching the given [predicate] and then cancels flow's collection.\n * Returns `null` if the flow did not contain an element matching the [predicate].\n */"}
{"signature":"public suspend fun < T > Flow < T > . last ( ) : T","body":"{ <EOL> var result : Any ? = NULL <EOL> collect { <EOL> result = it <EOL> } <EOL> if ( result === NULL ) throw NoSuchElementException ( \"<STR_LIT>\" ) <EOL> return result as T <EOL> }","docstring":"/**\n * The terminal operator that returns the last element emitted by the flow.\n *\n * Throws [NoSuchElementException] if the flow was empty.\n */"}
{"signature":"public suspend fun < T > Flow < T > . lastOrNull ( ) : T ?","body":"{ <EOL> var result : T ? = null <EOL> collect { <EOL> result = it <EOL> } <EOL> return result <EOL> }","docstring":"/**\n * The terminal operator that returns the last element emitted by the flow or `null` if the flow was empty.\n */"}
{"signature":"public fun < T : Number , D : Dimension > MultiArray < T , D > . toSortedSet ( ) : java . util . SortedSet < T >","body":"{ <EOL> return toCollection ( java . util . TreeSet ( ) ) <EOL> }","docstring":"/**\n * Returns a [SortedSet][java.util.SortedSet] of all elements.\n */"}
{"signature":"public fun < T , D : Dimension > MultiArray < T , D > . toSortedSet ( comparator : Comparator < in T > ) : java . util . SortedSet < T >","body":"{ <EOL> return toCollection ( java . util . TreeSet ( comparator ) ) <EOL> }","docstring":"/**\n * Returns a [SortedSet][java.util.SortedSet] of all elements.\n *\n * Elements in the set returned are sorted according to the given [comparator].\n */"}
{"signature":"public abstract fun provideExtensionsFor ( module : KtModule ) : List < KtResolveExtension >","body":"public abstract fun provideExtensionsFor ( module : KtModule ) : List < KtResolveExtension >","docstring":"/**\n * Provides a list of [KtResolveExtension]s for a given [KtModule].\n *\n * Should not perform any heavy analysis and the generation of the actual files. All file generation should be performed only in [KtResolveExtensionFile.buildFileText].\n *\n * Implementations should consider caching the results, so the subsequent invocations should be performed instantly.\n *\n * Implementation cannot use the Kotlin resolve inside, as this function is called during session initialization, so Analysis API access is forbidden.\n */"}
{"signature":"internal expect fun ensurePlatformExceptionHandlerLoaded ( callback : CoroutineExceptionHandler )","body":"internal expect fun ensurePlatformExceptionHandlerLoaded ( callback : CoroutineExceptionHandler )","docstring":"/**\n * Ensures that the given [callback] is present in the [platformExceptionHandlers] list.\n */"}
{"signature":"internal expect fun propagateExceptionFinalResort ( exception : Throwable )","body":"internal expect fun propagateExceptionFinalResort ( exception : Throwable )","docstring":"/**\n * The platform-dependent global exception handler, used so that the exception is logged at least *somewhere*.\n */"}
{"signature":"internal fun handleUncaughtCoroutineException ( context : CoroutineContext , exception : Throwable )","body":"{ <EOL> for ( handler in platformExceptionHandlers ) { <EOL> try { <EOL> handler . handleException ( context , exception ) <EOL> } catch ( _ : ExceptionSuccessfullyProcessed ) { <EOL> return <EOL> } catch ( t : Throwable ) { <EOL> propagateExceptionFinalResort ( handlerException ( exception , t ) ) <EOL> } <EOL> } <EOL> try { <EOL> exception . addSuppressed ( DiagnosticCoroutineContextException ( context ) ) <EOL> } catch ( e : Throwable ) { <EOL> } <EOL> propagateExceptionFinalResort ( exception ) <EOL> }","docstring":"/**\n * Deal with exceptions that happened in coroutines and weren't programmatically dealt with.\n *\n * First, it notifies every [CoroutineExceptionHandler] in the [platformExceptionHandlers] list.\n * If one of them throws [ExceptionSuccessfullyProcessed], it means that that handler believes that the exception was\n * dealt with sufficiently well and doesn't need any further processing.\n * Otherwise, the platform-dependent global exception handler is also invoked.\n */"}
{"signature":"public fun getFloatArray ( result : R , index : Int ) : FloatArray","body":"public fun getFloatArray ( result : R , index : Int ) : FloatArray","docstring":"/**\n * Returns the output at [index] as a [FloatArray].\n */"}
{"signature":"public fun getLongArray ( result : R , index : Int ) : LongArray","body":"public fun getLongArray ( result : R , index : Int ) : LongArray","docstring":"/**\n * Returns the output at [index] as a [LongArray].\n */"}
{"signature":"abstract fun isVisible ( receiver : ReceiverValue ? , what : DeclarationDescriptorWithVisibility , from : DeclarationDescriptor , useSpecialRulesForPrivateSealedConstructors : Boolean ) : Boolean","body":"abstract fun isVisible ( receiver : ReceiverValue ? , what : DeclarationDescriptorWithVisibility , from : DeclarationDescriptor , useSpecialRulesForPrivateSealedConstructors : Boolean ) : Boolean","docstring":"/**\n * @param receiver can be used to determine callee accessibility for some special receiver value\n *\n * 'null'-value basically means that receiver is absent in current call\n *\n * In case if it's needed to perform basic checks ignoring ones considering receiver (e.g. when checks happen beyond any call),\n * special value Visibilities.ALWAYS_SUITABLE_RECEIVER should be used.\n * If it's needed to determine whether visibility accepts any receiver, Visibilities.IRRELEVANT_RECEIVER should be used.\n *\n * NB: Currently Visibilities.IRRELEVANT_RECEIVER has the same effect as 'null'\n *\n * Also it's important that implementation that take receiver into account do aware about these special values.\n */"}
{"signature":"abstract fun mustCheckInImports ( ) : Boolean","body":"abstract fun mustCheckInImports ( ) : Boolean","docstring":"/**\n * True, if it makes sense to check this visibility in imports and not import inaccessible declarations with such visibility.\n * Hint: return true, if this visibility can be checked on file's level.\n * Examples:\n * it returns false for PROTECTED because protected members of classes can be imported to be used in subclasses of their containers,\n * so when we are looking at the import, we don't know whether it is legal somewhere in this file or not.\n * it returns true for INTERNAL, because an internal declaration is either visible everywhere in a file, or invisible everywhere in the same file.\n * it returns true for PRIVATE, because there's no point in importing privates: they are inaccessible unless their short name is\n * already available without an import\n */"}
{"signature":"fun compareTo ( visibility : DescriptorVisibility ) : Int ?","body":"{ <EOL> return delegate . compareTo ( visibility . delegate ) <EOL> }","docstring":"/**\n * @return null if the answer is unknown\n */"}
{"signature":"fun convertExpression ( expression : LighterASTNode , errorReason : String ) : FirElement","body":"{ <EOL> return when ( expression . tokenType ) { <EOL> LAMBDA_EXPRESSION -> convertLambdaExpression ( expression ) <EOL> BINARY_EXPRESSION -> convertBinaryExpression ( expression ) <EOL> BINARY_WITH_TYPE -> convertBinaryWithTypeRHSExpression ( expression ) { <EOL> this . getOperationSymbol ( ) . toFirOperation ( ) <EOL> } <EOL> IS_EXPRESSION -> convertBinaryWithTypeRHSExpression ( expression ) { <EOL> if ( this == \"<STR_LIT>\" ) FirOperation . IS else FirOperation . NOT_IS <EOL> } <EOL> LABELED_EXPRESSION -> convertLabeledExpression ( expression ) <EOL> PREFIX_EXPRESSION , POSTFIX_EXPRESSION -> convertUnaryExpression ( expression ) <EOL> ANNOTATED_EXPRESSION -> convertAnnotatedExpression ( expression ) <EOL> CLASS_LITERAL_EXPRESSION -> convertClassLiteralExpression ( expression ) <EOL> CALLABLE_REFERENCE_EXPRESSION -> convertCallableReferenceExpression ( expression ) <EOL> in QUALIFIED_ACCESS -> convertQualifiedExpression ( expression ) <EOL> CALL_EXPRESSION -> convertCallExpression ( expression ) <EOL> WHEN -> convertWhenExpression ( expression ) <EOL> ARRAY_ACCESS_EXPRESSION -> convertArrayAccessExpression ( expression ) <EOL> COLLECTION_LITERAL_EXPRESSION -> convertCollectionLiteralExpression ( expression ) <EOL> STRING_TEMPLATE -> convertStringTemplate ( expression ) <EOL> is KtConstantExpressionElementType -> convertConstantExpression ( expression ) <EOL> REFERENCE_EXPRESSION -> convertSimpleNameExpression ( expression ) <EOL> DO_WHILE -> convertDoWhile ( expression ) <EOL> WHILE -> convertWhile ( expression ) <EOL> FOR -> convertFor ( expression ) <EOL> TRY -> convertTryExpression ( expression ) <EOL> IF -> convertIfExpression ( expression ) <EOL> BREAK , CONTINUE -> convertLoopJump ( expression ) <EOL> RETURN -> convertReturn ( expression ) <EOL> THROW -> convertThrow ( expression ) <EOL> PARENTHESIZED -> { <EOL> val content = expression . getExpressionInParentheses ( ) <EOL> context . forwardLabelUsagePermission ( expression , content ) <EOL> getAsFirExpression ( content , \"<STR_LIT>\" ) <EOL> } <EOL> PROPERTY_DELEGATE , INDICES , CONDITION , LOOP_RANGE -> <EOL> getAsFirExpression ( expression . getChildExpression ( ) , errorReason ) <EOL> THIS_EXPRESSION -> convertThisExpression ( expression ) <EOL> SUPER_EXPRESSION -> convertSuperExpression ( expression ) <EOL> OBJECT_LITERAL -> declarationBuilder . convertObjectLiteral ( expression ) <EOL> FUN -> declarationBuilder . convertFunctionDeclaration ( expression ) <EOL> DESTRUCTURING_DECLARATION -> declarationBuilder . convertDestructingDeclaration ( expression ) . toFirDestructingDeclaration ( this , baseModuleData ) <EOL> else -> buildErrorExpression ( expression . toFirSourceElement ( KtFakeSourceElementKind . ErrorTypeRef ) , ConeSimpleDiagnostic ( errorReason , DiagnosticKind . ExpressionExpected ) ) <EOL> } <EOL> }","docstring":"/***** EXPRESSIONS *****/"}
{"signature":"private fun convertLambdaExpression ( lambdaExpression : LighterASTNode ) : FirExpression","body":"{ <EOL> val valueParameterList = mutableListOf < ValueParameter > ( ) <EOL> var block : LighterASTNode ? = null <EOL> var hasArrow = false <EOL> val functionSymbol = FirAnonymousFunctionSymbol ( ) <EOL> lambdaExpression . getChildNodesByType ( FUNCTION_LITERAL ) . first ( ) . forEachChildren { <EOL> when ( it . tokenType ) { <EOL> VALUE_PARAMETER_LIST -> valueParameterList += declarationBuilder . convertValueParameters ( it , functionSymbol , ValueParameterDeclaration . LAMBDA ) <EOL> BLOCK -> block = it <EOL> ARROW -> hasArrow = true <EOL> } <EOL> } <EOL> val expressionSource = lambdaExpression . toFirSourceElement ( ) <EOL> val target : FirFunctionTarget <EOL> val anonymousFunction = buildAnonymousFunction { <EOL> source = expressionSource <EOL> moduleData = baseModuleData <EOL> origin = FirDeclarationOrigin . Source <EOL> returnTypeRef = implicitType <EOL> receiverParameter = expressionSource . asReceiverParameter ( ) <EOL> symbol = functionSymbol <EOL> isLambda = true <EOL> hasExplicitParameterList = hasArrow <EOL> label = context . getLastLabel ( lambdaExpression ) ? : context . calleeNamesForLambda . lastOrNull ( ) ? . let { <EOL> buildLabel { <EOL> source = expressionSource . fakeElement ( KtFakeSourceElementKind . GeneratedLambdaLabel ) <EOL> name = it . asString ( ) <EOL> } <EOL> } <EOL> target = FirFunctionTarget ( labelName = label ? . name , isLambda = true ) <EOL> context . firFunctionTargets += target <EOL> val destructuringStatements = mutableListOf < FirStatement > ( ) <EOL> for ( valueParameter in valueParameterList ) { <EOL> val multiDeclaration = valueParameter . destructuringDeclaration <EOL> valueParameters += if ( multiDeclaration != null ) { <EOL> val name = SpecialNames . DESTRUCT <EOL> val multiParameter = buildValueParameter { <EOL> source = valueParameter . firValueParameter . source <EOL> containingFunctionSymbol = functionSymbol <EOL> moduleData = baseModuleData <EOL> origin = FirDeclarationOrigin . Source <EOL> returnTypeRef = valueParameter . firValueParameter . returnTypeRef <EOL> this . name = name <EOL> symbol = FirValueParameterSymbol ( name ) <EOL> defaultValue = null <EOL> isCrossinline = false <EOL> isNoinline = false <EOL> isVararg = false <EOL> } <EOL> addDestructuringStatements ( destructuringStatements , baseModuleData , multiDeclaration , multiParameter , tmpVariable = false , forceLocal = true , ) <EOL> multiParameter <EOL> } else { <EOL> valueParameter . firValueParameter <EOL> } <EOL> } <EOL> body = withForcedLocalContext { <EOL> if ( block != null ) { <EOL> val kind = runIf ( destructuringStatements . isNotEmpty ( ) ) { <EOL> KtFakeSourceElementKind . LambdaDestructuringBlock <EOL> } <EOL> val bodyBlock = declarationBuilder . convertBlockExpressionWithoutBuilding ( block ! ! , kind ) . apply { <EOL> statements . firstOrNull ( ) ? . let { <EOL> if ( it . isContractBlockFirCheck ( ) ) { <EOL> this@buildAnonymousFunction . contractDescription = it . toLegacyRawContractDescription ( ) <EOL> statements [ <NUM_LIT:0> ] = FirContractCallBlock ( it ) <EOL> } <EOL> } <EOL> if ( statements . isEmpty ( ) ) { <EOL> statements . add ( buildReturnExpression { <EOL> source = expressionSource . fakeElement ( KtFakeSourceElementKind . ImplicitReturn . FromExpressionBody ) <EOL> this . target = target <EOL> result = buildUnitExpression { <EOL> source = expressionSource . fakeElement ( KtFakeSourceElementKind . ImplicitUnit . LambdaCoercion ) <EOL> } <EOL> } ) <EOL> } <EOL> } . build ( ) <EOL> if ( destructuringStatements . isNotEmpty ( ) ) { <EOL> buildBlock { <EOL> source = bodyBlock . source ? . realElement ( ) <EOL> statements . addAll ( destructuringStatements ) <EOL> statements . add ( bodyBlock ) <EOL> } <EOL> } else { <EOL> bodyBlock <EOL> } <EOL> } else { <EOL> buildSingleExpressionBlock ( buildErrorExpression ( null , ConeSyntaxDiagnostic ( \"<STR_LIT>\" ) ) ) <EOL> } <EOL> } <EOL> context . firFunctionTargets . removeLast ( ) <EOL> } . also { <EOL> target . bind ( it ) <EOL> } <EOL> return buildAnonymousFunctionExpression { <EOL> source = expressionSource <EOL> this . anonymousFunction = anonymousFunction <EOL> } <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseFunctionLiteral\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitLambdaExpression\n */"}
{"signature":"private fun convertBinaryExpression ( binaryExpression : LighterASTNode ) : FirStatement","body":"{ <EOL> var isLeftArgument = true <EOL> lateinit var operationTokenName : String <EOL> var leftArgNode : LighterASTNode ? = null <EOL> var rightArg : LighterASTNode ? = null <EOL> var operationReferenceSource : KtLightSourceElement ? = null <EOL> binaryExpression . forEachChildren { <EOL> when ( it . tokenType ) { <EOL> OPERATION_REFERENCE -> { <EOL> isLeftArgument = false <EOL> operationTokenName = it . asText <EOL> operationReferenceSource = it . toFirSourceElement ( ) <EOL> } <EOL> else -> if ( it . isExpression ( ) ) { <EOL> if ( isLeftArgument ) { <EOL> leftArgNode = it <EOL> } else { <EOL> rightArg = it <EOL> } <EOL> } <EOL> } <EOL> } <EOL> val baseSource = binaryExpression . toFirSourceElement ( ) <EOL> val operationToken = operationTokenName . getOperationSymbol ( ) <EOL> if ( operationToken == IDENTIFIER ) { <EOL> context . calleeNamesForLambda += operationTokenName . nameAsSafeName ( ) <EOL> } else { <EOL> context . calleeNamesForLambda += null <EOL> } <EOL> val rightArgAsFir = <EOL> if ( rightArg != null ) <EOL> getAsFirExpression < FirExpression > ( rightArg , \"<STR_LIT>\" ) <EOL> else <EOL> buildErrorExpression ( null , ConeSyntaxDiagnostic ( \"<STR_LIT>\" ) ) <EOL> val leftArgAsFir = getAsFirExpression < FirExpression > ( leftArgNode , \"<STR_LIT>\" ) <EOL> context . calleeNamesForLambda . removeLast ( ) <EOL> when ( operationToken ) { <EOL> ELVIS -> <EOL> return leftArgAsFir . generateNotNullOrOther ( rightArgAsFir , baseSource ) <EOL> ANDAND , OROR -> <EOL> return leftArgAsFir . generateLazyLogicalOperation ( rightArgAsFir , operationToken == ANDAND , baseSource ) <EOL> in OperatorConventions . IN_OPERATIONS -> <EOL> return rightArgAsFir . generateContainsOperation ( leftArgAsFir , operationToken == NOT_IN , baseSource , operationReferenceSource ) <EOL> in OperatorConventions . COMPARISON_OPERATIONS -> <EOL> return leftArgAsFir . generateComparisonExpression ( rightArgAsFir , operationToken , baseSource , operationReferenceSource ) <EOL> } <EOL> val conventionCallName = operationToken . toBinaryName ( ) <EOL> return if ( conventionCallName != null || operationToken == IDENTIFIER ) { <EOL> buildFunctionCall { <EOL> source = binaryExpression . toFirSourceElement ( ) <EOL> calleeReference = buildSimpleNamedReference { <EOL> source = operationReferenceSource ? : this@buildFunctionCall . source <EOL> name = conventionCallName ? : operationTokenName . nameAsSafeName ( ) <EOL> } <EOL> explicitReceiver = leftArgAsFir <EOL> argumentList = buildUnaryArgumentList ( rightArgAsFir ) <EOL> origin = if ( conventionCallName != null ) FirFunctionCallOrigin . Operator else FirFunctionCallOrigin . Infix <EOL> } <EOL> } else { <EOL> val firOperation = operationToken . toFirOperation ( ) <EOL> if ( firOperation in FirOperation . ASSIGNMENTS ) { <EOL> return leftArgNode . generateAssignment ( binaryExpression . toFirSourceElement ( ) , leftArgNode ? . toFirSourceElement ( ) , rightArgAsFir , firOperation , leftArgAsFir . annotations , rightArg , ) { <EOL> getAsFirExpression < FirExpression > ( this , \"<STR_LIT>\" , sourceWhenInvalidExpression = binaryExpression , isValidExpression = { ! it . isStatementLikeExpression || it . isArraySet } , ) <EOL> } <EOL> } else { <EOL> buildEqualityOperatorCall { <EOL> source = binaryExpression . toFirSourceElement ( ) <EOL> operation = firOperation <EOL> argumentList = buildBinaryArgumentList ( leftArgAsFir , rightArgAsFir ) <EOL> } <EOL> } <EOL> } <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseBinaryExpression\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitBinaryExpression\n */"}
{"signature":"private fun convertBinaryWithTypeRHSExpression ( binaryExpression : LighterASTNode , toFirOperation : String . ( ) -> FirOperation ) : FirTypeOperatorCall","body":"{ <EOL> lateinit var operationTokenName : String <EOL> var leftArgAsFir : FirExpression ? = null <EOL> lateinit var firType : FirTypeRef <EOL> binaryExpression . forEachChildren { <EOL> when ( it . tokenType ) { <EOL> OPERATION_REFERENCE -> operationTokenName = it . asText <EOL> TYPE_REFERENCE -> firType = declarationBuilder . convertType ( it ) <EOL> else -> if ( it . isExpression ( ) ) leftArgAsFir = getAsFirExpression ( it , \"<STR_LIT>\" ) <EOL> } <EOL> } <EOL> return buildTypeOperatorCall { <EOL> source = binaryExpression . toFirSourceElement ( ) <EOL> operation = operationTokenName . toFirOperation ( ) <EOL> conversionTypeRef = firType <EOL> argumentList = buildUnaryArgumentList ( leftArgAsFir ? : buildErrorExpression ( null , ConeSyntaxDiagnostic ( \"<STR_LIT>\" ) ) ) <EOL> } <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.Precedence.parseRightHandSide\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitBinaryWithTypeRHSExpression\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitIsExpression\n */"}
{"signature":"private fun convertLabeledExpression ( labeledExpression : LighterASTNode ) : FirElement","body":"{ <EOL> var firExpression : FirElement ? = null <EOL> var labelSource : KtSourceElement ? = null <EOL> var forbiddenLabelKind : ForbiddenLabelKind ? = null <EOL> val isRepetitiveLabel = labeledExpression . getLabeledExpression ( ) ? . tokenType == LABELED_EXPRESSION <EOL> labeledExpression . forEachChildren { <EOL> context . setNewLabelUserNode ( it ) <EOL> when ( it . tokenType ) { <EOL> LABEL_QUALIFIER -> { <EOL> val name = it . asText . dropLast ( <NUM_LIT:1> ) <EOL> labelSource = it . getChildNodesByType ( LABEL ) . single ( ) . toFirSourceElement ( ) <EOL> context . addNewLabel ( buildLabel ( name , labelSource ! ! ) ) <EOL> forbiddenLabelKind = getForbiddenLabelKind ( name , isRepetitiveLabel ) <EOL> } <EOL> BLOCK -> firExpression = declarationBuilder . convertBlock ( it ) <EOL> PROPERTY -> firExpression = declarationBuilder . convertPropertyDeclaration ( it ) <EOL> else -> if ( it . isExpression ( ) ) firExpression = getAsFirStatement ( it ) <EOL> } <EOL> } <EOL> context . dropLastLabel ( ) <EOL> return buildExpressionHandlingErrors ( firExpression , labeledExpression . toFirSourceElement ( ) , forbiddenLabelKind , labelSource ) <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseLabeledExpression\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitLabeledExpression\n */"}
{"signature":"private fun convertUnaryExpression ( unaryExpression : LighterASTNode ) : FirExpression","body":"{ <EOL> lateinit var operationTokenName : String <EOL> var argument : LighterASTNode ? = null <EOL> var operationReference : LighterASTNode ? = null <EOL> unaryExpression . forEachChildren { <EOL> when ( it . tokenType ) { <EOL> OPERATION_REFERENCE -> { <EOL> operationReference = it <EOL> operationTokenName = it . asText <EOL> } <EOL> else -> if ( it . isExpression ( ) ) argument = it <EOL> } <EOL> } <EOL> val operationToken = operationTokenName . getOperationSymbol ( ) <EOL> val conventionCallName = operationToken . toUnaryName ( ) <EOL> return when { <EOL> operationToken == EXCLEXCL -> { <EOL> buildCheckNotNullCall { <EOL> source = unaryExpression . toFirSourceElement ( ) <EOL> argumentList = buildUnaryArgumentList ( getAsFirExpression < FirExpression > ( argument , \"<STR_LIT>\" ) ) <EOL> } <EOL> } <EOL> conventionCallName != null -> { <EOL> if ( operationToken in OperatorConventions . INCREMENT_OPERATIONS ) { <EOL> return generateIncrementOrDecrementBlock ( unaryExpression , operationReference , argument , callName = conventionCallName , prefix = unaryExpression . tokenType == PREFIX_EXPRESSION ) { getAsFirExpression ( this ) } <EOL> } <EOL> val receiver = getAsFirExpression < FirExpression > ( argument , \"<STR_LIT>\" ) <EOL> convertUnaryPlusMinusCallOnIntegerLiteralIfNecessary ( unaryExpression , receiver , operationToken ) ? . let { return it } <EOL> buildFunctionCall { <EOL> source = unaryExpression . toFirSourceElement ( ) <EOL> calleeReference = buildSimpleNamedReference { <EOL> source = operationReference ? . toFirSourceElement ( ) ? : this@buildFunctionCall . source <EOL> name = conventionCallName <EOL> } <EOL> explicitReceiver = receiver <EOL> origin = FirFunctionCallOrigin . Operator <EOL> } <EOL> } <EOL> else -> throw IllegalStateException ( \"<STR_LIT>\" ) <EOL> } <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parsePostfixExpression\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parsePrefixExpression\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitUnaryExpression\n */"}
{"signature":"private fun convertAnnotatedExpression ( annotatedExpression : LighterASTNode ) : FirElement","body":"{ <EOL> var firExpression : FirElement ? = null <EOL> val firAnnotationList = mutableListOf < FirAnnotation > ( ) <EOL> annotatedExpression . forEachChildren { <EOL> when ( it . tokenType ) { <EOL> ANNOTATION -> firAnnotationList += declarationBuilder . convertAnnotation ( it ) <EOL> ANNOTATION_ENTRY -> firAnnotationList += declarationBuilder . convertAnnotationEntry ( it ) <EOL> BLOCK -> firExpression = declarationBuilder . convertBlockExpression ( it ) <EOL> else -> if ( it . isExpression ( ) ) { <EOL> context . forwardLabelUsagePermission ( annotatedExpression , it ) <EOL> firExpression = getAsFirStatement ( it ) <EOL> } <EOL> } <EOL> } <EOL> val result = firExpression ? : buildErrorExpression ( null , ConeNotAnnotationContainer ( \"<STR_LIT>\" ) ) <EOL> require ( result is FirAnnotationContainer ) <EOL> result . replaceAnnotations ( result . annotations . smartPlus ( firAnnotationList ) ) <EOL> return result <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parsePrefixExpression\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitAnnotatedExpression\n */"}
{"signature":"private fun convertClassLiteralExpression ( classLiteralExpression : LighterASTNode ) : FirExpression","body":"{ <EOL> var firReceiverExpression : FirExpression ? = null <EOL> classLiteralExpression . forEachChildren { <EOL> if ( it . isExpression ( ) ) firReceiverExpression = getAsFirExpression ( it , \"<STR_LIT>\" ) <EOL> } <EOL> val classLiteralSource = classLiteralExpression . toFirSourceElement ( ) <EOL> return buildGetClassCall { <EOL> source = classLiteralSource <EOL> argumentList = buildUnaryArgumentList ( firReceiverExpression ? : buildErrorExpression ( classLiteralSource , ConeUnsupportedClassLiteralsWithEmptyLhs ) ) <EOL> } <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseDoubleColonSuffix\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitClassLiteralExpression\n */"}
{"signature":"private fun convertCallableReferenceExpression ( callableReferenceExpression : LighterASTNode ) : FirExpression","body":"{ <EOL> var isReceiver = true <EOL> var hasQuestionMarkAtLHS = false <EOL> var firReceiverExpression : FirExpression ? = null <EOL> lateinit var namedReference : FirNamedReference <EOL> callableReferenceExpression . forEachChildren { <EOL> when ( it . tokenType ) { <EOL> COLONCOLON -> isReceiver = false <EOL> QUEST -> hasQuestionMarkAtLHS = true <EOL> else -> if ( it . isExpression ( ) ) { <EOL> if ( isReceiver ) { <EOL> firReceiverExpression = getAsFirExpression ( it , \"<STR_LIT>\" ) <EOL> } else { <EOL> namedReference = createSimpleNamedReference ( it . toFirSourceElement ( ) , it ) <EOL> } <EOL> } <EOL> } <EOL> } <EOL> return buildCallableReferenceAccess { <EOL> source = callableReferenceExpression . toFirSourceElement ( ) <EOL> calleeReference = namedReference <EOL> explicitReceiver = firReceiverExpression <EOL> this . hasQuestionMarkAtLHS = hasQuestionMarkAtLHS <EOL> } <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseDoubleColonSuffix\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitCallableReferenceExpression\n */"}
{"signature":"private fun convertQualifiedExpression ( dotQualifiedExpression : LighterASTNode ) : FirExpression","body":"{ <EOL> var isSelector = false <EOL> var isSafe = false <EOL> var firSelector : FirExpression ? = null <EOL> var firReceiver : FirExpression ? = null <EOL> dotQualifiedExpression . forEachChildren { <EOL> when ( val tokenType = it . tokenType ) { <EOL> DOT -> isSelector = true <EOL> SAFE_ACCESS -> { <EOL> isSafe = true <EOL> isSelector = true <EOL> } <EOL> else -> { <EOL> val isEffectiveSelector = isSelector && tokenType != TokenType . ERROR_ELEMENT <EOL> val firExpression = <EOL> getAsFirExpression < FirExpression > ( it , \"<STR_LIT>\" ) <EOL> if ( isEffectiveSelector ) { <EOL> val callExpressionCallee = if ( tokenType == CALL_EXPRESSION ) it . getFirstChildExpressionUnwrapped ( ) else null <EOL> firSelector = <EOL> if ( tokenType is KtNameReferenceExpressionElementType || ( tokenType == CALL_EXPRESSION && callExpressionCallee ? . tokenType != LAMBDA_EXPRESSION ) ) { <EOL> firExpression <EOL> } else { <EOL> buildErrorExpression { <EOL> source = callExpressionCallee ? . toFirSourceElement ( ) ? : it . toFirSourceElement ( ) <EOL> diagnostic = ConeSimpleDiagnostic ( \"<STR_LIT>\" , if ( callExpressionCallee == null ) DiagnosticKind . IllegalSelector else DiagnosticKind . NoReceiverAllowed ) <EOL> expression = firExpression <EOL> } <EOL> } <EOL> } else { <EOL> firReceiver = firExpression <EOL> } <EOL> } <EOL> } <EOL> } <EOL> var result = firSelector <EOL> ( firSelector as? FirQualifiedAccessExpression ) ? . let { <EOL> if ( isSafe ) { <EOL> @ OptIn ( FirImplementationDetail :: class ) <EOL> it . replaceSource ( dotQualifiedExpression . toFirSourceElement ( KtFakeSourceElementKind . DesugaredSafeCallExpression ) ) <EOL> return it . createSafeCall ( firReceiver ! ! , dotQualifiedExpression . toFirSourceElement ( ) ) <EOL> } <EOL> result = convertFirSelector ( it , dotQualifiedExpression . toFirSourceElement ( ) , firReceiver ! ! ) <EOL> } <EOL> val receiver = firReceiver <EOL> if ( receiver != null ) { <EOL> ( firSelector as? FirErrorExpression ) ? . let { errorExpression -> <EOL> return buildQualifiedErrorAccessExpression { <EOL> this . receiver = receiver <EOL> this . selector = errorExpression <EOL> source = dotQualifiedExpression . toFirSourceElement ( ) <EOL> diagnostic = ConeSyntaxDiagnostic ( \"<STR_LIT>\" ) <EOL> } <EOL> } <EOL> } <EOL> return result ? : buildErrorExpression { <EOL> source = dotQualifiedExpression . toFirSourceElement ( ) <EOL> diagnostic = ConeSyntaxDiagnostic ( \"<STR_LIT>\" ) <EOL> expression = firReceiver <EOL> } <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parsePostfixExpression\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitQualifiedExpression\n */"}
{"signature":"private fun convertCallExpression ( callSuffix : LighterASTNode ) : FirExpression","body":"{ <EOL> var name : String ? = null <EOL> val firTypeArguments = mutableListOf < FirTypeProjection > ( ) <EOL> val valueArguments = mutableListOf < LighterASTNode > ( ) <EOL> var additionalArgument : FirExpression ? = null <EOL> var hasArguments = false <EOL> var superNode : LighterASTNode ? = null <EOL> callSuffix . forEachChildren { child -> <EOL> fun process ( node : LighterASTNode ) { <EOL> when ( node . tokenType ) { <EOL> REFERENCE_EXPRESSION -> { <EOL> name = node . asText <EOL> } <EOL> SUPER_EXPRESSION -> { <EOL> superNode = node <EOL> } <EOL> PARENTHESIZED -> if ( node . tokenType != TokenType . ERROR_ELEMENT ) { <EOL> additionalArgument = getAsFirExpression ( node . getExpressionInParentheses ( ) , \"<STR_LIT>\" ) <EOL> } <EOL> TYPE_ARGUMENT_LIST -> { <EOL> firTypeArguments += declarationBuilder . convertTypeArguments ( node , allowedUnderscoredTypeArgument = true ) <EOL> } <EOL> VALUE_ARGUMENT_LIST , LAMBDA_ARGUMENT -> { <EOL> hasArguments = true <EOL> valueArguments += node <EOL> } <EOL> else -> if ( node . tokenType != TokenType . ERROR_ELEMENT ) { <EOL> additionalArgument = getAsFirExpression ( node , \"<STR_LIT>\" ) <EOL> } <EOL> } <EOL> } <EOL> process ( child ) <EOL> } <EOL> val source = callSuffix . toFirSourceElement ( ) <EOL> val ( calleeReference , explicitReceiver , isImplicitInvoke ) = when { <EOL> name != null -> CalleeAndReceiver ( buildSimpleNamedReference { <EOL> this . source = callSuffix . getFirstChildExpressionUnwrapped ( ) ? . toFirSourceElement ( ) ? : source <EOL> this . name = name . nameAsSafeName ( ) <EOL> } ) <EOL> superNode != null || ( additionalArgument as? FirResolvable ) ? . calleeReference is FirSuperReference -> { <EOL> CalleeAndReceiver ( buildErrorNamedReference { <EOL> this . source = superNode ? . toFirSourceElement ( ) ? : ( additionalArgument as? FirResolvable ) ? . calleeReference ? . source <EOL> diagnostic = ConeSimpleDiagnostic ( \"<STR_LIT>\" , DiagnosticKind . SuperNotAllowed ) <EOL> } ) <EOL> } <EOL> additionalArgument != null -> { <EOL> CalleeAndReceiver ( buildSimpleNamedReference { <EOL> this . source = source <EOL> this . name = OperatorNameConventions . INVOKE <EOL> } , additionalArgument ! ! , isImplicitInvoke = true ) <EOL> } <EOL> else -> CalleeAndReceiver ( buildErrorNamedReference { <EOL> this . source = source <EOL> diagnostic = ConeSyntaxDiagnostic ( \"<STR_LIT>\" ) <EOL> } ) <EOL> } <EOL> val builder : FirQualifiedAccessExpressionBuilder = if ( hasArguments ) { <EOL> val builder = if ( isImplicitInvoke ) FirImplicitInvokeCallBuilder ( ) else FirFunctionCallBuilder ( ) <EOL> builder . apply { <EOL> this . source = source <EOL> this . calleeReference = calleeReference <EOL> context . calleeNamesForLambda += calleeReference . name <EOL> this . extractArgumentsFrom ( valueArguments . flatMap { convertValueArguments ( it ) } ) <EOL> context . calleeNamesForLambda . removeLast ( ) <EOL> } <EOL> } else { <EOL> FirPropertyAccessExpressionBuilder ( ) . apply { <EOL> this . source = source <EOL> this . calleeReference = calleeReference <EOL> } <EOL> } <EOL> return builder . apply { <EOL> this . explicitReceiver = explicitReceiver <EOL> typeArguments += firTypeArguments <EOL> } . build ( ) <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseCallSuffix\n */"}
{"signature":"private fun convertStringTemplate ( stringTemplate : LighterASTNode ) : FirExpression","body":"{ <EOL> return stringTemplate . getChildrenAsArray ( ) . toInterpolatingCall ( stringTemplate ) { convertShortOrLongStringTemplate ( it ) } <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseStringTemplate\n */"}
{"signature":"private fun convertConstantExpression ( constantExpression : LighterASTNode ) : FirExpression","body":"{ <EOL> return generateConstantExpressionByLiteral ( constantExpression ) <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseLiteralConstant\n */"}
{"signature":"private fun convertWhenExpression ( whenExpression : LighterASTNode ) : FirExpression","body":"{ <EOL> var subjectExpression : FirExpression ? = null <EOL> var subjectVariable : FirVariable ? = null <EOL> val whenEntryNodes = mutableListOf < LighterASTNode > ( ) <EOL> val whenEntries = mutableListOf < WhenEntry > ( ) <EOL> whenExpression . forEachChildren { <EOL> when ( it . tokenType ) { <EOL> PROPERTY -> subjectVariable = ( declarationBuilder . convertPropertyDeclaration ( it ) as FirVariable ) . let { variable -> <EOL> buildProperty { <EOL> source = it . toFirSourceElement ( ) <EOL> origin = FirDeclarationOrigin . Source <EOL> moduleData = baseModuleData <EOL> returnTypeRef = variable . returnTypeRef <EOL> name = variable . name <EOL> initializer = variable . initializer <EOL> isVar = false <EOL> symbol = FirPropertySymbol ( variable . name ) <EOL> isLocal = true <EOL> status = FirDeclarationStatusImpl ( Visibilities . Local , Modality . FINAL ) <EOL> annotations += variable . annotations <EOL> } <EOL> } <EOL> DESTRUCTURING_DECLARATION -> subjectExpression = <EOL> getAsFirExpression ( it , \"<STR_LIT>\" ) <EOL> WHEN_ENTRY -> whenEntryNodes += it <EOL> else -> if ( it . isExpression ( ) ) subjectExpression = <EOL> getAsFirExpression ( it , \"<STR_LIT>\" ) <EOL> } <EOL> } <EOL> subjectExpression = subjectVariable ? . initializer ? : subjectExpression <EOL> val hasSubject = subjectExpression != null <EOL> @ OptIn ( FirContractViolation :: class ) <EOL> val subject = FirExpressionRef < FirWhenExpression > ( ) <EOL> var shouldBind = hasSubject <EOL> whenEntryNodes . mapTo ( whenEntries ) { <EOL> convertWhenEntry ( it , subject , hasSubject ) <EOL> } <EOL> return buildWhenExpression { <EOL> source = whenExpression . toFirSourceElement ( ) <EOL> this . subject = subjectExpression <EOL> this . subjectVariable = subjectVariable <EOL> usedAsExpression = whenExpression . usedAsExpression <EOL> for ( entry in whenEntries ) { <EOL> shouldBind = shouldBind || entry . shouldBindSubject <EOL> val branch = entry . firBlock <EOL> val entrySource = entry . node . toFirSourceElement ( ) <EOL> branches += if ( ! entry . isElse ) { <EOL> if ( hasSubject ) { <EOL> val firCondition = entry . toFirWhenCondition ( ) <EOL> buildWhenBranch { <EOL> source = entrySource <EOL> condition = firCondition <EOL> result = branch <EOL> } <EOL> } else { <EOL> val firCondition = entry . toFirWhenConditionWithoutSubject ( ) <EOL> buildWhenBranch { <EOL> source = entrySource <EOL> condition = firCondition <EOL> result = branch <EOL> } <EOL> } <EOL> } else { <EOL> buildWhenBranch { <EOL> source = entrySource <EOL> condition = buildElseIfTrueCondition ( ) <EOL> result = branch <EOL> } <EOL> } <EOL> } <EOL> } . also { <EOL> if ( shouldBind ) { <EOL> subject . bind ( it ) <EOL> } <EOL> } <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseWhen\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitWhenExpression\n */"}
{"signature":"private fun convertWhenEntry ( whenEntry : LighterASTNode , whenRefWithSubject : FirExpressionRef < FirWhenExpression > , hasSubject : Boolean , ) : WhenEntry","body":"{ <EOL> var isElse = false <EOL> var firBlock : FirBlock = buildEmptyExpressionBlock ( ) <EOL> val conditions = mutableListOf < FirExpression > ( ) <EOL> var shouldBindSubject = false <EOL> whenEntry . forEachChildren { <EOL> when ( it . tokenType ) { <EOL> WHEN_CONDITION_EXPRESSION -> conditions += convertWhenConditionExpression ( it , whenRefWithSubject . takeIf { hasSubject } ) <EOL> WHEN_CONDITION_IN_RANGE -> { <EOL> val ( condition , shouldBind ) = convertWhenConditionInRange ( it , whenRefWithSubject , hasSubject ) <EOL> conditions += condition <EOL> shouldBindSubject = shouldBindSubject || shouldBind <EOL> } <EOL> WHEN_CONDITION_IS_PATTERN -> { <EOL> val ( condition , shouldBind ) = convertWhenConditionIsPattern ( it , whenRefWithSubject , hasSubject ) <EOL> conditions += condition <EOL> shouldBindSubject = shouldBindSubject || shouldBind <EOL> } <EOL> ELSE_KEYWORD -> isElse = true <EOL> BLOCK -> firBlock = declarationBuilder . convertBlock ( it ) <EOL> else -> if ( it . isExpression ( ) ) firBlock = declarationBuilder . convertBlock ( it ) <EOL> } <EOL> } <EOL> return WhenEntry ( conditions , firBlock , whenEntry , isElse , shouldBindSubject ) <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseWhenEntry\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseWhenEntryNotElse\n */"}
{"signature":"private fun convertArrayAccessExpression ( arrayAccess : LighterASTNode ) : FirExpression","body":"{ <EOL> var firExpression : FirExpression ? = null <EOL> val indices : MutableList < FirExpression > = mutableListOf ( ) <EOL> arrayAccess . forEachChildren { <EOL> when ( it . tokenType ) { <EOL> INDICES -> indices += convertIndices ( it ) <EOL> else -> if ( it . isExpression ( ) ) firExpression = getAsFirExpression ( it , \"<STR_LIT>\" ) <EOL> } <EOL> } <EOL> val getArgument = context . arraySetArgument . remove ( arrayAccess ) <EOL> return buildFunctionCall { <EOL> val isGet = getArgument == null <EOL> source = ( if ( isGet ) arrayAccess else arrayAccess . getParent ( ) ! ! ) . toFirSourceElement ( ) <EOL> calleeReference = buildSimpleNamedReference { <EOL> source = arrayAccess . toFirSourceElement ( ) . fakeElement ( KtFakeSourceElementKind . ArrayAccessNameReference ) <EOL> name = if ( isGet ) OperatorNameConventions . GET else OperatorNameConventions . SET <EOL> } <EOL> explicitReceiver = <EOL> firExpression ? : buildErrorExpression ( null , ConeSyntaxDiagnostic ( \"<STR_LIT>\" ) ) <EOL> argumentList = buildArgumentList { <EOL> arguments += indices <EOL> getArgument ? . let { arguments += it } <EOL> } <EOL> origin = FirFunctionCallOrigin . Operator <EOL> } . pullUpSafeCallIfNecessary ( ) <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseArrayAccess\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitArrayAccessExpression\n */"}
{"signature":"private fun convertCollectionLiteralExpression ( expression : LighterASTNode ) : FirExpression","body":"{ <EOL> val firExpressionList = mutableListOf < FirExpression > ( ) <EOL> expression . forEachChildren { <EOL> if ( it . isExpression ( ) ) firExpressionList += getAsFirExpression < FirExpression > ( it , \"<STR_LIT>\" ) <EOL> } <EOL> return buildArrayLiteral { <EOL> source = expression . toFirSourceElement ( ) <EOL> argumentList = buildArgumentList { <EOL> arguments += firExpressionList <EOL> } <EOL> } <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseCollectionLiteralExpression\n */"}
{"signature":"private fun convertIndices ( indices : LighterASTNode ) : List < FirExpression >","body":"{ <EOL> val firExpressionList : MutableList < FirExpression > = mutableListOf ( ) <EOL> indices . forEachChildren { <EOL> if ( it . isExpression ( ) ) firExpressionList += getAsFirExpression < FirExpression > ( it , \"<STR_LIT>\" ) <EOL> } <EOL> return firExpressionList <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseAsCollectionLiteralExpression\n */"}
{"signature":"private fun convertSimpleNameExpression ( referenceExpression : LighterASTNode ) : FirQualifiedAccessExpression","body":"{ <EOL> val nameSource = referenceExpression . toFirSourceElement ( ) <EOL> val referenceSourceElement = if ( nameSource . kind is KtFakeSourceElementKind ) { <EOL> nameSource <EOL> } else { <EOL> nameSource . fakeElement ( KtFakeSourceElementKind . ReferenceInAtomicQualifiedAccess ) <EOL> } <EOL> return buildPropertyAccessExpression { <EOL> val rawText = referenceExpression . asText <EOL> if ( rawText . isUnderscore ) { <EOL> nonFatalDiagnostics . add ( ConeUnderscoreUsageWithoutBackticks ( nameSource ) ) <EOL> } <EOL> source = nameSource <EOL> calleeReference = createSimpleNamedReference ( referenceSourceElement , referenceExpression ) <EOL> } <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseSimpleNameExpression\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitSimpleNameExpression\n */"}
{"signature":"private fun convertDoWhile ( doWhileLoop : LighterASTNode ) : FirElement","body":"{ <EOL> var block : LighterASTNode ? = null <EOL> var firCondition : FirExpression ? = null <EOL> val target : FirLoopTarget <EOL> return FirDoWhileLoopBuilder ( ) . apply { <EOL> source = doWhileLoop . toFirSourceElement ( ) <EOL> target = prepareTarget ( doWhileLoop ) <EOL> doWhileLoop . forEachChildren { <EOL> when ( it . tokenType ) { <EOL> BODY -> block = it <EOL> CONDITION -> firCondition = getAsFirExpression ( it , \"<STR_LIT>\" ) <EOL> } <EOL> } <EOL> condition = <EOL> firCondition ? : buildErrorExpression ( null , ConeSyntaxDiagnostic ( \"<STR_LIT>\" ) ) <EOL> } . configure ( target ) { convertLoopBody ( block ) } <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseDoWhile\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitDoWhileExpression\n */"}
{"signature":"private fun convertWhile ( whileLoop : LighterASTNode ) : FirElement","body":"{ <EOL> var block : LighterASTNode ? = null <EOL> var firCondition : FirExpression ? = null <EOL> whileLoop . forEachChildren { <EOL> when ( it . tokenType ) { <EOL> BODY -> block = it <EOL> CONDITION -> firCondition = getAsFirExpression ( it , \"<STR_LIT>\" ) <EOL> } <EOL> } <EOL> val target : FirLoopTarget <EOL> return FirWhileLoopBuilder ( ) . apply { <EOL> source = whileLoop . toFirSourceElement ( ) <EOL> condition = <EOL> firCondition ? : buildErrorExpression ( null , ConeSyntaxDiagnostic ( \"<STR_LIT>\" ) ) <EOL> target = prepareTarget ( whileLoop ) <EOL> } . configure ( target ) { convertLoopBody ( block ) } <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseWhile\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitWhileExpression\n */"}
{"signature":"private fun convertFor ( forLoop : LighterASTNode ) : FirElement","body":"{ <EOL> var parameter : ValueParameter ? = null <EOL> var rangeExpression : FirExpression ? = null <EOL> var blockNode : LighterASTNode ? = null <EOL> forLoop . forEachChildren { <EOL> when ( it . tokenType ) { <EOL> VALUE_PARAMETER -> parameter = declarationBuilder . convertValueParameter ( it , null , ValueParameterDeclaration . FOR_LOOP ) <EOL> LOOP_RANGE -> rangeExpression = getAsFirExpression ( it , \"<STR_LIT>\" ) <EOL> BODY -> blockNode = it <EOL> } <EOL> } <EOL> val calculatedRangeExpression = <EOL> rangeExpression ? : buildErrorExpression ( null , ConeSyntaxDiagnostic ( \"<STR_LIT>\" ) ) <EOL> val fakeSource = forLoop . toFirSourceElement ( KtFakeSourceElementKind . DesugaredForLoop ) <EOL> val rangeSource = calculatedRangeExpression . source ? . fakeElement ( KtFakeSourceElementKind . DesugaredForLoop ) ? : fakeSource <EOL> val target : FirLoopTarget <EOL> return buildBlock { <EOL> source = fakeSource <EOL> val iteratorVal = generateTemporaryVariable ( baseModuleData , rangeSource , SpecialNames . ITERATOR , buildFunctionCall { <EOL> source = rangeSource <EOL> calleeReference = buildSimpleNamedReference { <EOL> source = rangeSource <EOL> name = OperatorNameConventions . ITERATOR <EOL> } <EOL> explicitReceiver = calculatedRangeExpression <EOL> origin = FirFunctionCallOrigin . Operator <EOL> } ) <EOL> statements += iteratorVal <EOL> statements += FirWhileLoopBuilder ( ) . apply { <EOL> source = fakeSource <EOL> condition = buildFunctionCall { <EOL> source = rangeSource <EOL> calleeReference = buildSimpleNamedReference { <EOL> source = rangeSource <EOL> name = OperatorNameConventions . HAS_NEXT <EOL> } <EOL> explicitReceiver = generateResolvedAccessExpression ( rangeSource , iteratorVal ) <EOL> origin = FirFunctionCallOrigin . Operator <EOL> } <EOL> target = prepareTarget ( forLoop ) <EOL> } . configure ( target ) { <EOL> buildBlock block @ { <EOL> source = blockNode ? . toFirSourceElement ( ) <EOL> val valueParameter = parameter ? : return@block <EOL> val multiDeclaration = valueParameter . destructuringDeclaration <EOL> val firLoopParameter = generateTemporaryVariable ( baseModuleData , valueParameter . source , if ( multiDeclaration != null ) SpecialNames . DESTRUCT else valueParameter . name , buildFunctionCall { <EOL> source = rangeSource <EOL> calleeReference = buildSimpleNamedReference { <EOL> source = rangeSource <EOL> name = OperatorNameConventions . NEXT <EOL> } <EOL> explicitReceiver = generateResolvedAccessExpression ( rangeSource , iteratorVal ) <EOL> origin = FirFunctionCallOrigin . Operator <EOL> } , valueParameter . returnTypeRef , extractedAnnotations = valueParameter . annotations ) <EOL> if ( multiDeclaration != null ) { <EOL> addDestructuringStatements ( statements , baseModuleData , multiDeclaration , firLoopParameter , tmpVariable = true , forceLocal = true , ) <EOL> } else { <EOL> statements . add ( firLoopParameter ) <EOL> } <EOL> statements += convertLoopBody ( blockNode ) <EOL> } <EOL> } <EOL> } <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseFor\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitForExpression\n */"}
{"signature":"private fun convertLoopBody ( body : LighterASTNode ? ) : FirBlock","body":"{ <EOL> return convertLoopOrIfBody ( body ) ? : buildEmptyExpressionBlock ( ) <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseLoopBody\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.toFirBlock\n */"}
{"signature":"private fun convertTryExpression ( tryExpression : LighterASTNode ) : FirExpression","body":"{ <EOL> lateinit var tryBlock : FirBlock <EOL> val catchClauses = mutableListOf < Triple < ValueParameter ? , FirBlock , KtLightSourceElement > > ( ) <EOL> var finallyBlock : FirBlock ? = null <EOL> tryExpression . forEachChildren { <EOL> when ( it . tokenType ) { <EOL> BLOCK -> tryBlock = declarationBuilder . convertBlock ( it ) <EOL> CATCH -> convertCatchClause ( it ) ? . also { oneClause -> catchClauses += oneClause } <EOL> FINALLY -> finallyBlock = convertFinally ( it ) <EOL> } <EOL> } <EOL> return buildTryExpression { <EOL> source = tryExpression . toFirSourceElement ( ) <EOL> this . tryBlock = tryBlock <EOL> this . finallyBlock = finallyBlock <EOL> for ( ( parameter , block , clauseSource ) in catchClauses ) { <EOL> if ( parameter == null ) continue <EOL> catches += buildCatch { <EOL> this . parameter = buildProperty { <EOL> source = parameter . source <EOL> moduleData = baseModuleData <EOL> origin = FirDeclarationOrigin . Source <EOL> returnTypeRef = parameter . returnTypeRef <EOL> isVar = false <EOL> status = FirResolvedDeclarationStatusImpl ( Visibilities . Local , Modality . FINAL , EffectiveVisibility . Local ) <EOL> isLocal = true <EOL> this . name = parameter . name <EOL> symbol = FirPropertySymbol ( CallableId ( name ) ) <EOL> annotations += parameter . annotations <EOL> } . also { <EOL> it . isCatchParameter = true <EOL> } <EOL> this . block = block <EOL> this . source = clauseSource <EOL> } <EOL> } <EOL> } <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseTry\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitTryExpression\n */"}
{"signature":"private fun convertCatchClause ( catchClause : LighterASTNode ) : Triple < ValueParameter ? , FirBlock , KtLightSourceElement > ?","body":"{ <EOL> var valueParameter : ValueParameter ? = null <EOL> var blockNode : LighterASTNode ? = null <EOL> catchClause . forEachChildren { <EOL> when ( it . tokenType ) { <EOL> VALUE_PARAMETER_LIST -> valueParameter = declarationBuilder . convertValueParameters ( it , FirAnonymousFunctionSymbol ( ) , ValueParameterDeclaration . CATCH ) <EOL> . firstOrNull ( ) ? : return null <EOL> BLOCK -> blockNode = it <EOL> } <EOL> } <EOL> return Triple ( valueParameter , declarationBuilder . convertBlock ( blockNode ) , catchClause . toFirSourceElement ( ) ) <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseTry\n */"}
{"signature":"private fun convertFinally ( finallyExpression : LighterASTNode ) : FirBlock","body":"{ <EOL> var blockNode : LighterASTNode ? = null <EOL> finallyExpression . forEachChildren { <EOL> when ( it . tokenType ) { <EOL> BLOCK -> blockNode = it <EOL> } <EOL> } <EOL> return declarationBuilder . convertBlock ( blockNode ) <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseTry\n */"}
{"signature":"private fun convertIfExpression ( ifExpression : LighterASTNode ) : FirExpression","body":"{ <EOL> return buildWhenExpression { <EOL> source = ifExpression . toFirSourceElement ( ) <EOL> with ( parseIfExpression ( ifExpression ) ) { <EOL> val trueBranch = convertLoopBody ( thenBlock ) <EOL> branches += buildWhenBranch { <EOL> source = firCondition ? . source <EOL> condition = firCondition ? : buildErrorExpression ( null , ConeSyntaxDiagnostic ( \"<STR_LIT>\" ) ) <EOL> result = trueBranch <EOL> } <EOL> if ( elseBlock != null ) { <EOL> val elseBranch = convertLoopOrIfBody ( elseBlock ) <EOL> if ( elseBranch != null ) { <EOL> branches += buildWhenBranch { <EOL> source = elseBlock . toFirSourceElement ( ) <EOL> condition = buildElseIfTrueCondition ( ) <EOL> result = elseBranch <EOL> } <EOL> } <EOL> } <EOL> } <EOL> usedAsExpression = ifExpression . usedAsExpression <EOL> } <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseIf\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitIfExpression\n */"}
{"signature":"private fun convertLoopJump ( jump : LighterASTNode ) : FirExpression","body":"{ <EOL> var isBreak = true <EOL> jump . forEachChildren { <EOL> when ( it . tokenType ) { <EOL> CONTINUE_KEYWORD -> isBreak = false <EOL> } <EOL> } <EOL> val jumpBuilder = if ( isBreak ) FirBreakExpressionBuilder ( ) else FirContinueExpressionBuilder ( ) <EOL> val sourceElement = jump . toFirSourceElement ( ) <EOL> return jumpBuilder . apply { <EOL> source = sourceElement <EOL> } . bindLabel ( jump ) . build ( ) <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseJump\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitBreakExpression\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitContinueExpression\n */"}
{"signature":"private fun convertReturn ( returnExpression : LighterASTNode ) : FirExpression","body":"{ <EOL> var labelName : String ? = null <EOL> var firExpression : FirExpression ? = null <EOL> returnExpression . forEachChildren { <EOL> when ( it . tokenType ) { <EOL> LABEL_QUALIFIER -> labelName = it . getAsStringWithoutBacktick ( ) . replace ( \"<STR_LIT:@>\" , \"<STR_LIT>\" ) <EOL> else -> if ( it . isExpression ( ) ) firExpression = getAsFirExpression ( it , \"<STR_LIT>\" ) <EOL> } <EOL> } <EOL> val calculatedFirExpression = firExpression ? : buildUnitExpression { <EOL> source = returnExpression . toFirSourceElement ( KtFakeSourceElementKind . ImplicitUnit . Return ) <EOL> } <EOL> return calculatedFirExpression . toReturn ( baseSource = returnExpression . toFirSourceElement ( ) , labelName = labelName , fromKtReturnExpression = true ) <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseReturn\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitReturnExpression\n */"}
{"signature":"private fun convertThrow ( throwExpression : LighterASTNode ) : FirExpression","body":"{ <EOL> var firExpression : FirExpression ? = null <EOL> throwExpression . forEachChildren { <EOL> if ( it . isExpression ( ) ) firExpression = getAsFirExpression ( it , \"<STR_LIT>\" ) <EOL> } <EOL> return buildThrowExpression { <EOL> source = throwExpression . toFirSourceElement ( ) <EOL> exception = firExpression ? : buildErrorExpression ( null , ConeSyntaxDiagnostic ( \"<STR_LIT>\" ) ) <EOL> } <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseThrow\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitThrowExpression\n */"}
{"signature":"private fun convertThisExpression ( thisExpression : LighterASTNode ) : FirQualifiedAccessExpression","body":"{ <EOL> val label : String ? = thisExpression . getLabelName ( ) <EOL> return buildThisReceiverExpression { <EOL> val sourceElement = thisExpression . toFirSourceElement ( ) <EOL> source = sourceElement <EOL> calleeReference = buildExplicitThisReference { <EOL> labelName = label <EOL> source = sourceElement . fakeElement ( KtFakeSourceElementKind . ReferenceInAtomicQualifiedAccess ) <EOL> } <EOL> } <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseThisExpression\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitThisExpression\n */"}
{"signature":"private fun convertSuperExpression ( superExpression : LighterASTNode ) : FirQualifiedAccessExpression","body":"{ <EOL> val label : String ? = superExpression . getLabelName ( ) <EOL> var superTypeRef : FirTypeRef = implicitType <EOL> superExpression . forEachChildren { <EOL> when ( it . tokenType ) { <EOL> TYPE_REFERENCE -> superTypeRef = declarationBuilder . convertType ( it ) <EOL> } <EOL> } <EOL> return buildPropertyAccessExpression { <EOL> val sourceElement = superExpression . toFirSourceElement ( ) <EOL> source = sourceElement <EOL> calleeReference = buildExplicitSuperReference { <EOL> labelName = label <EOL> this . superTypeRef = superTypeRef <EOL> source = sourceElement . fakeElement ( KtFakeSourceElementKind . ReferenceInAtomicQualifiedAccess ) <EOL> } <EOL> } <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseSuperExpression\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitSuperExpression\n */"}
{"signature":"fun convertValueArguments ( valueArguments : LighterASTNode ) : List < FirExpression >","body":"{ <EOL> return valueArguments . forEachChildrenReturnList { node , container -> <EOL> when ( node . tokenType ) { <EOL> VALUE_ARGUMENT -> container += convertValueArgument ( node ) <EOL> LAMBDA_EXPRESSION , <EOL> LABELED_EXPRESSION , <EOL> ANNOTATED_EXPRESSION , <EOL> -> container += getAsFirExpression < FirAnonymousFunctionExpression > ( node ) . apply { <EOL> @ OptIn ( RawFirApi :: class ) <EOL> replaceIsTrailingLambda ( newIsTrailingLambda = true ) <EOL> } <EOL> } <EOL> } <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseValueArgumentList\n */"}
{"signature":"private fun convertValueArgument ( valueArgument : LighterASTNode ) : FirExpression","body":"{ <EOL> var identifier : String ? = null <EOL> var isSpread = false <EOL> var firExpression : FirExpression ? = null <EOL> valueArgument . forEachChildren { <EOL> when ( it . tokenType ) { <EOL> VALUE_ARGUMENT_NAME -> identifier = it . asText <EOL> MUL -> isSpread = true <EOL> STRING_TEMPLATE -> firExpression = convertStringTemplate ( it ) <EOL> is KtConstantExpressionElementType -> firExpression = convertConstantExpression ( it ) <EOL> else -> if ( it . isExpression ( ) ) firExpression = getAsFirExpression ( it , \"<STR_LIT>\" ) <EOL> } <EOL> } <EOL> val calculatedFirExpression = <EOL> firExpression ? : buildErrorExpression ( null , ConeSyntaxDiagnostic ( \"<STR_LIT>\" ) ) <EOL> return when { <EOL> identifier != null -> buildNamedArgumentExpression { <EOL> source = valueArgument . toFirSourceElement ( ) <EOL> expression = calculatedFirExpression <EOL> this . isSpread = isSpread <EOL> name = identifier . nameAsSafeName ( ) <EOL> } <EOL> isSpread -> buildSpreadArgumentExpression { <EOL> source = valueArgument . toFirSourceElement ( ) <EOL> expression = calculatedFirExpression <EOL> } <EOL> else -> calculatedFirExpression <EOL> } <EOL> }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseValueArgument\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.toFirExpression(org.jetbrains.kotlin.psi.ValueArgument)\n */"}
{"signature":"fun excludeUnused ( headerName : String ? ) : Boolean","body":"fun excludeUnused ( headerName : String ? ) : Boolean","docstring":"/**\n * Whether unused declarations from given header should be excluded.\n *\n * @param headerName header path relative to the appropriate include path element (e.g. `time.h` or `curl/curl.h`),\n * or `null` for builtin declarations.\n */"}
{"signature":"fun excludeAll ( headerId : HeaderId ) : Boolean","body":"fun excludeAll ( headerId : HeaderId ) : Boolean","docstring":"/**\n * Whether all declarations from this header should be excluded.\n *\n * Note: the declarations from such headers can be actually present in the internal representation,\n * but not included into the root collections.\n */"}
{"signature":"fun buildNativeIndex ( library : NativeLibrary , verbose : Boolean ) : IndexerResult","body":"= buildNativeIndexImpl ( library , verbose )","docstring":"/**\n * Retrieves the definitions from given C header file using given compiler arguments (e.g. defines).\n */"}
{"signature":"public fun ColumnSet < * > . colsOfKind ( kind : ColumnKind , vararg others : ColumnKind , filter : ColumnFilter < * > = { true } , ) : TransformableColumnSet < * >","body":"= <EOL> columnsOfKindInternal ( kinds = headPlusArray ( kind , others ) . toSet ( ) , filter = filter )","docstring":"/**\n * @include [CommonColsOfKindDocs]\n * @set [CommonColsOfKindDocs.ExampleArg]\n *\n * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`(\"my\") }.`[colsOfKind][ColumnSet.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) }`\n *\n * `// NOTE: This can be shortened to just:`\n *\n * `df.`[select][DataFrame.select]` { `[colsOfKind][ColumnsSelectionDsl.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`(\"my\") } }`\n */"}
{"signature":"public fun ColumnsSelectionDsl < * > . colsOfKind ( kind : ColumnKind , vararg others : ColumnKind , filter : ColumnFilter < * > = { true } , ) : TransformableColumnSet < * >","body":"= <EOL> asSingleColumn ( ) . columnsOfKindInternal ( kinds = headPlusArray ( kind , others ) . toSet ( ) , filter = filter )","docstring":"/**\n * @include [CommonColsOfKindDocs]\n * @set [CommonColsOfKindDocs.ExampleArg]\n *\n * `df.`[select][DataFrame.select]` { `[colsOfKind][ColumnsSelectionDsl.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`(\"my\") } }`\n */"}
{"signature":"public fun SingleColumn < DataRow < * > > . colsOfKind ( kind : ColumnKind , vararg others : ColumnKind , filter : ColumnFilter < * > = { true } , ) : TransformableColumnSet < * >","body":"= <EOL> this . ensureIsColumnGroup ( ) . columnsOfKindInternal ( kinds = headPlusArray ( kind , others ) . toSet ( ) , filter = filter )","docstring":"/**\n * @include [CommonColsOfKindDocs]\n * @set [CommonColsOfKindDocs.ExampleArg]\n *\n * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOfKind][SingleColumn.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) }`\n */"}
{"signature":"public fun String . colsOfKind ( kind : ColumnKind , vararg others : ColumnKind , filter : ColumnFilter < * > = { true } , ) : TransformableColumnSet < * >","body":"= <EOL> columnGroup ( this ) . colsOfKind ( kind , * others , filter = filter )","docstring":"/**\n * @include [CommonColsOfKindDocs]\n * @set [CommonColsOfKindDocs.ExampleArg]\n *\n * `df.`[select][DataFrame.select]` { \"myColumnGroup\".`[colsOfKind][SingleColumn.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) }`\n */"}
{"signature":"public fun KProperty < * > . colsOfKind ( kind : ColumnKind , vararg others : ColumnKind , filter : ColumnFilter < * > = { true } , ) : TransformableColumnSet < * >","body":"= <EOL> columnGroup ( this ) . colsOfKind ( kind , * others , filter = filter )","docstring":"/**\n * @include [CommonColsOfKindDocs]\n * @set [CommonColsOfKindDocs.ExampleArg]\n *\n * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[colsOfKind][KProperty.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) }`\n */"}
{"signature":"public fun ColumnPath . colsOfKind ( kind : ColumnKind , vararg others : ColumnKind , filter : ColumnFilter < * > = { true } , ) : TransformableColumnSet < * >","body":"= <EOL> columnGroup ( this ) . colsOfKind ( kind , * others , filter = filter )","docstring":"/**\n * @include [CommonColsOfKindDocs]\n * @set [CommonColsOfKindDocs.ExampleArg]\n *\n * `df.`[select][DataFrame.select]` { \"pathTo\"[\"myColumnGroup\"].`[colsOfKind][ColumnPath.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) }`\n */"}
{"signature":"internal fun ColumnsResolver < * > . columnsOfKindInternal ( kinds : Set < ColumnKind > , filter : ColumnFilter < * > , ) : TransformableColumnSet < * >","body":"= colsInternal { <EOL> it . kind ( ) in kinds && filter ( it ) <EOL> }","docstring":"/**\n * Returns a TransformableColumnSet containing the columns of given kind(s) that satisfy the given filter.\n *\n * @param filter The filter function to apply on each column. Must accept a ColumnWithPath object and return a Boolean.\n * @return A [TransformableColumnSet] containing the columns of given kinds that satisfy the filter.\n */"}
{"signature":"fun Project . checkExpectedGradlePropertyValues ( )","body":"{ <EOL> val expectSuffix = \"<STR_LIT>\" <EOL> val expectKeys = properties . keys . filter { it . endsWith ( expectSuffix ) } <EOL> val issues = expectKeys . mapNotNull { expectKey -> <EOL> val actualKey = expectKey . removeSuffix ( expectSuffix ) <EOL> val expectedValue = properties [ expectKey ] ? . toString ( ) ? : return@mapNotNull null <EOL> if ( ! properties . containsKey ( actualKey ) ) <EOL> return@mapNotNull MissingProperty ( actualKey , expectedValue ) <EOL> val actualValue = properties [ actualKey ] . toString ( ) <EOL> if ( expectedValue != actualValue ) <EOL> return@mapNotNull UnexpectedPropertyValue ( actualKey , expectedValue , actualValue ) <EOL> null <EOL> } . toSet ( ) <EOL> if ( issues . isEmpty ( ) ) { <EOL> return <EOL> } <EOL> val unexpectedPropertyValues = issues . filterIsInstance < UnexpectedPropertyValue > ( ) <EOL> val missingProperties = issues . filterIsInstance < MissingProperty > ( ) <EOL> throw IllegalArgumentException ( buildString { <EOL> if ( unexpectedPropertyValues . isNotEmpty ( ) ) { <EOL> appendLine ( \"<STR_LIT>\" ) <EOL> unexpectedPropertyValues . forEach { issue -> <EOL> appendLine ( \"<STR_LIT>\" ) <EOL> } <EOL> } <EOL> if ( missingProperties . isNotEmpty ( ) ) { <EOL> if ( unexpectedPropertyValues . isNotEmpty ( ) ) appendLine ( ) <EOL> appendLine ( \"<STR_LIT>\" ) <EOL> missingProperties . forEach { issue -> <EOL> appendLine ( \"<STR_LIT>\" ) <EOL> } <EOL> } <EOL> } ) <EOL> }","docstring":"/**\n * Mechanism to warn developers when a given Gradle property does not match the developer's expectation.\n *\n * There may be some Gradle properties, that are defined in the project and will change over time (e.g. defaultSnapshotVersion).\n * Some developers (and QA) will need to be very clear about the value of this property.\n *\n * In order to get notified about the value of the property changing, it is possible to define the same property in\n * ~/.gradle/gradle.properties with a given `.kotlin_build.expected_value` suffix to ensure the value.\n *\n * e.g. if a developer set's\n *\n * `defaultSnapshotVersion.kotlin_build.expected_value=1.6.255-SNAPSHOT` and the value gets bumped to `2.0.255-SNAPSHOT` after pulling from master,\n * the developer will notice this during project configuration phase.\n */"}
{"signature":"public fun extensionReceiverType ( type : ConeKotlinType )","body":"{ <EOL> extensionReceiverType { type } <EOL> }","docstring":"/**\n * Sets [type] as extension receiver type of constructed property\n */"}
{"signature":"public fun extensionReceiverType ( typeProvider : ( List < FirTypeParameter > ) -> ConeKotlinType )","body":"{ <EOL> extensionReceiverTypeProvider = typeProvider <EOL> }","docstring":"/**\n * Sets type, provided by [typeProvider], as extension receiver type of constructed property\n *\n * Use this overload when extension receiver type uses type parameters of constructed property\n */"}
{"signature":"public fun setter ( visibility : Visibility )","body":"{ <EOL> setterVisibility = visibility <EOL> }","docstring":"/**\n * Declares [visibility] of property setter if property marked as var\n * If this function is not called then setter will have same visibility\n * as property itself\n */"}
{"signature":"public fun FirExtension . createMemberProperty ( owner : FirClassSymbol < * > , key : GeneratedDeclarationKey , name : Name , returnType : ConeKotlinType , isVal : Boolean = true , hasBackingField : Boolean = true , config : PropertyBuildingContext . ( ) -> Unit = { } ) : FirProperty","body":"{ <EOL> return createMemberProperty ( owner , key , name , { returnType } , isVal , hasBackingField , config ) <EOL> }","docstring":"/**\n * Creates a member property for [owner] class with [returnType] return type\n */"}
{"signature":"public fun FirExtension . createMemberProperty ( owner : FirClassSymbol < * > , key : GeneratedDeclarationKey , name : Name , returnTypeProvider : ( List < FirTypeParameterRef > ) -> ConeKotlinType , isVal : Boolean = true , hasBackingField : Boolean = true , config : PropertyBuildingContext . ( ) -> Unit = { } ) : FirProperty","body":"{ <EOL> val callableId = CallableId ( owner . classId , name ) <EOL> return PropertyBuildingContext ( session , key , owner , callableId , returnTypeProvider , isVal , hasBackingField ) . apply ( config ) . apply { <EOL> status { <EOL> isExpect = owner . isExpect <EOL> } <EOL> } . build ( ) <EOL> }","docstring":"/**\n * Creates a member property for [owner] class with return type provided by [returnTypeProvider]\n * Use this overload when those types use type parameters of constructed property\n */"}
{"signature":"@ ExperimentalTopLevelDeclarationsGenerationApi <EOL> public fun FirExtension . createTopLevelProperty ( key : GeneratedDeclarationKey , callableId : CallableId , returnType : ConeKotlinType , isVal : Boolean = true , hasBackingField : Boolean = true , config : PropertyBuildingContext . ( ) -> Unit = { } ) : FirProperty","body":"{ <EOL> return createTopLevelProperty ( key , callableId , { returnType } , isVal , hasBackingField , config ) <EOL> }","docstring":"/**\n * Creates a top-level property class with [returnType] return type\n *\n * If you create top-level extension property don't forget to set [hasBackingField] to false,\n * since such properties never have backing fields\n */"}
{"signature":"@ ExperimentalTopLevelDeclarationsGenerationApi <EOL> public fun FirExtension . createTopLevelProperty ( key : GeneratedDeclarationKey , callableId : CallableId , returnTypeProvider : ( List < FirTypeParameterRef > ) -> ConeKotlinType , isVal : Boolean = true , hasBackingField : Boolean = true , config : PropertyBuildingContext . ( ) -> Unit = { } ) : FirProperty","body":"{ <EOL> require ( callableId . classId == null ) <EOL> return PropertyBuildingContext ( session , key , owner = null , callableId , returnTypeProvider , isVal , hasBackingField ) . apply ( config ) . build ( ) <EOL> }","docstring":"/**\n * Creates a top-level property with return type provided by [returnTypeProvider]\n *\n * If you create top-level extension property don't forget to set [hasBackingField] to false,\n * since such properties never have backing fields\n *\n * Use this overload when those types use type parameters of constructed property\n */"}
{"signature":"private fun createWebpackConfig ( forNpmDependencies : Boolean = false )","body":"= KotlinWebpackConfig ( npmProjectDir = npmProjectDir , mode = mode , entry = if ( forNpmDependencies ) null else entry . get ( ) . asFile , output = output , outputPath = if ( forNpmDependencies ) null else outputDirectory . getOrNull ( ) ? . asFile , outputFileName = mainOutputFileName . get ( ) , configDirectory = configDirectory , rules = rules , devServer = devServerProperty . orNull , devtool = devtool , sourceMaps = sourceMaps , resolveFromModulesFirst = resolveFromModulesFirst , )","docstring":"/**\n * [forNpmDependencies] is used to avoid querying [outputDirectory] before task execution.\n * Otherwise, Gradle will fail the build.\n */"}
{"signature":"@ kotlin . internal . InlineOnly <EOL> public actual inline fun < T > Array < out T > . elementAt ( index : Int ) : T","body":"{ <EOL> return get ( index ) <EOL> }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"}
{"signature":"@ kotlin . internal . InlineOnly <EOL> public actual inline fun ByteArray . elementAt ( index : Int ) : Byte","body":"{ <EOL> return get ( index ) <EOL> }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"}
{"signature":"@ kotlin . internal . InlineOnly <EOL> public actual inline fun ShortArray . elementAt ( index : Int ) : Short","body":"{ <EOL> return get ( index ) <EOL> }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"}
{"signature":"@ kotlin . internal . InlineOnly <EOL> public actual inline fun IntArray . elementAt ( index : Int ) : Int","body":"{ <EOL> return get ( index ) <EOL> }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"}
{"signature":"@ kotlin . internal . InlineOnly <EOL> public actual inline fun LongArray . elementAt ( index : Int ) : Long","body":"{ <EOL> return get ( index ) <EOL> }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"}
{"signature":"@ kotlin . internal . InlineOnly <EOL> public actual inline fun FloatArray . elementAt ( index : Int ) : Float","body":"{ <EOL> return get ( index ) <EOL> }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"}
{"signature":"@ kotlin . internal . InlineOnly <EOL> public actual inline fun DoubleArray . elementAt ( index : Int ) : Double","body":"{ <EOL> return get ( index ) <EOL> }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"}
{"signature":"@ kotlin . internal . InlineOnly <EOL> public actual inline fun BooleanArray . elementAt ( index : Int ) : Boolean","body":"{ <EOL> return get ( index ) <EOL> }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"}
{"signature":"@ kotlin . internal . InlineOnly <EOL> public actual inline fun CharArray . elementAt ( index : Int ) : Char","body":"{ <EOL> return get ( index ) <EOL> }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"}
{"signature":"public actual fun < T > Array < out T > . asList ( ) : List < T >","body":"{ <EOL> return object : AbstractList < T > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : T ) : Boolean = this@asList . contains ( element ) <EOL> override fun get ( index : Int ) : T = this@asList [ index ] <EOL> override fun indexOf ( element : T ) : Int = this@asList . indexOf ( element ) <EOL> override fun lastIndexOf ( element : T ) : Int = this@asList . lastIndexOf ( element ) <EOL> } <EOL> }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"}
{"signature":"public actual fun ByteArray . asList ( ) : List < Byte >","body":"{ <EOL> return object : AbstractList < Byte > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : Byte ) : Boolean = this@asList . contains ( element ) <EOL> override fun get ( index : Int ) : Byte = this@asList [ index ] <EOL> override fun indexOf ( element : Byte ) : Int = this@asList . indexOf ( element ) <EOL> override fun lastIndexOf ( element : Byte ) : Int = this@asList . lastIndexOf ( element ) <EOL> } <EOL> }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"}
{"signature":"public actual fun ShortArray . asList ( ) : List < Short >","body":"{ <EOL> return object : AbstractList < Short > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : Short ) : Boolean = this@asList . contains ( element ) <EOL> override fun get ( index : Int ) : Short = this@asList [ index ] <EOL> override fun indexOf ( element : Short ) : Int = this@asList . indexOf ( element ) <EOL> override fun lastIndexOf ( element : Short ) : Int = this@asList . lastIndexOf ( element ) <EOL> } <EOL> }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"}
{"signature":"public actual fun IntArray . asList ( ) : List < Int >","body":"{ <EOL> return object : AbstractList < Int > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : Int ) : Boolean = this@asList . contains ( element ) <EOL> override fun get ( index : Int ) : Int = this@asList [ index ] <EOL> override fun indexOf ( element : Int ) : Int = this@asList . indexOf ( element ) <EOL> override fun lastIndexOf ( element : Int ) : Int = this@asList . lastIndexOf ( element ) <EOL> } <EOL> }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"}
{"signature":"public actual fun LongArray . asList ( ) : List < Long >","body":"{ <EOL> return object : AbstractList < Long > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : Long ) : Boolean = this@asList . contains ( element ) <EOL> override fun get ( index : Int ) : Long = this@asList [ index ] <EOL> override fun indexOf ( element : Long ) : Int = this@asList . indexOf ( element ) <EOL> override fun lastIndexOf ( element : Long ) : Int = this@asList . lastIndexOf ( element ) <EOL> } <EOL> }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"}
{"signature":"public actual fun FloatArray . asList ( ) : List < Float >","body":"{ <EOL> return object : AbstractList < Float > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : Float ) : Boolean = this@asList . any { it . toBits ( ) == element . toBits ( ) } <EOL> override fun get ( index : Int ) : Float = this@asList [ index ] <EOL> override fun indexOf ( element : Float ) : Int = this@asList . indexOfFirst { it . toBits ( ) == element . toBits ( ) } <EOL> override fun lastIndexOf ( element : Float ) : Int = this@asList . indexOfLast { it . toBits ( ) == element . toBits ( ) } <EOL> } <EOL> }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"}
{"signature":"public actual fun DoubleArray . asList ( ) : List < Double >","body":"{ <EOL> return object : AbstractList < Double > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : Double ) : Boolean = this@asList . any { it . toBits ( ) == element . toBits ( ) } <EOL> override fun get ( index : Int ) : Double = this@asList [ index ] <EOL> override fun indexOf ( element : Double ) : Int = this@asList . indexOfFirst { it . toBits ( ) == element . toBits ( ) } <EOL> override fun lastIndexOf ( element : Double ) : Int = this@asList . indexOfLast { it . toBits ( ) == element . toBits ( ) } <EOL> } <EOL> }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"}
{"signature":"public actual fun BooleanArray . asList ( ) : List < Boolean >","body":"{ <EOL> return object : AbstractList < Boolean > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : Boolean ) : Boolean = this@asList . contains ( element ) <EOL> override fun get ( index : Int ) : Boolean = this@asList [ index ] <EOL> override fun indexOf ( element : Boolean ) : Int = this@asList . indexOf ( element ) <EOL> override fun lastIndexOf ( element : Boolean ) : Int = this@asList . lastIndexOf ( element ) <EOL> } <EOL> }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"}
{"signature":"public actual fun CharArray . asList ( ) : List < Char >","body":"{ <EOL> return object : AbstractList < Char > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : Char ) : Boolean = this@asList . contains ( element ) <EOL> override fun get ( index : Int ) : Char = this@asList [ index ] <EOL> override fun indexOf ( element : Char ) : Int = this@asList . indexOf ( element ) <EOL> override fun lastIndexOf ( element : Char ) : Int = this@asList . lastIndexOf ( element ) <EOL> } <EOL> }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ kotlin . internal . LowPriorityInOverloadResolution <EOL> public actual infix fun < T > Array < out T > . contentDeepEquals ( other : Array < out T > ) : Boolean","body":"{ <EOL> return this . contentDeepEquals ( other ) <EOL> }","docstring":"/**\n * Checks if the two specified arrays are *deeply* equal to one another.\n * \n * Two arrays are considered deeply equal if they have the same size, and elements at corresponding indices are deeply equal.\n * That is, if two corresponding elements are nested arrays, they are also compared deeply.\n * Elements of other types are compared for equality using the [equals][Any.equals] function.\n * For floating point numbers, this means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.\n * \n * If any of the arrays contain themselves at any nesting level, the behavior is undefined.\n * \n * @param other the array to compare deeply with this array.\n * @return `true` if the two arrays are deeply equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.contentDeepEquals\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual infix fun < T > Array < out T > ? . contentDeepEquals ( other : Array < out T > ? ) : Boolean","body":"{ <EOL> return contentDeepEqualsImpl ( other ) <EOL> }","docstring":"/**\n * Checks if the two specified arrays are *deeply* equal to one another.\n * \n * Two arrays are considered deeply equal if they have the same size, and elements at corresponding indices are deeply equal.\n * That is, if two corresponding elements are nested arrays, they are also compared deeply.\n * Elements of other types are compared for equality using the [equals][Any.equals] function.\n * For floating point numbers, this means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.\n * \n * The arrays are also considered deeply equal if both are `null`.\n * \n * If any of the arrays contain themselves at any nesting level, the behavior is undefined.\n * \n * @param other the array to compare deeply with this array.\n * @return `true` if the two arrays are deeply equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.contentDeepEquals\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ kotlin . internal . LowPriorityInOverloadResolution <EOL> public actual fun < T > Array < out T > . contentDeepHashCode ( ) : Int","body":"{ <EOL> return this . contentDeepHashCode ( ) <EOL> }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n * Nested arrays are treated as lists too.\n * \n * If any of arrays contains itself on any nesting level the behavior is undefined.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual fun < T > Array < out T > ? . contentDeepHashCode ( ) : Int","body":"{ <EOL> return contentDeepHashCodeImpl ( ) <EOL> }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n * Nested arrays are treated as lists too.\n * \n * If any of arrays contains itself on any nesting level the behavior is undefined.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ kotlin . internal . LowPriorityInOverloadResolution <EOL> public actual fun < T > Array < out T > . contentDeepToString ( ) : String","body":"{ <EOL> return this . contentDeepToString ( ) <EOL> }","docstring":"/**\n * Returns a string representation of the contents of this array as if it is a [List].\n * Nested arrays are treated as lists too.\n * \n * If any of arrays contains itself on any nesting level that reference\n * is rendered as `\"[...]\"` to prevent recursion.\n * \n * @sample samples.collections.Arrays.ContentOperations.contentDeepToString\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual fun < T > Array < out T > ? . contentDeepToString ( ) : String","body":"{ <EOL> return contentDeepToStringImpl ( ) <EOL> }","docstring":"/**\n * Returns a string representation of the contents of this array as if it is a [List].\n * Nested arrays are treated as lists too.\n * \n * If any of arrays contains itself on any nesting level that reference\n * is rendered as `\"[...]\"` to prevent recursion.\n * \n * @sample samples.collections.Arrays.ContentOperations.contentDeepToString\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public infix fun < T > Array < out T > . contentEquals ( other : Array < out T > ) : Boolean","body":"{ <EOL> return this . contentEquals ( other ) <EOL> }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * Elements are compared for equality using the [equals][Any.equals] function.\n * For floating point numbers, this means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.\n * \n * If the arrays contain nested arrays, use [contentDeepEquals] to recursively compare their elements.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.arrayContentEquals\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public infix fun ByteArray . contentEquals ( other : ByteArray ) : Boolean","body":"{ <EOL> return this . contentEquals ( other ) <EOL> }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public infix fun ShortArray . contentEquals ( other : ShortArray ) : Boolean","body":"{ <EOL> return this . contentEquals ( other ) <EOL> }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public infix fun IntArray . contentEquals ( other : IntArray ) : Boolean","body":"{ <EOL> return this . contentEquals ( other ) <EOL> }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public infix fun LongArray . contentEquals ( other : LongArray ) : Boolean","body":"{ <EOL> return this . contentEquals ( other ) <EOL> }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public infix fun FloatArray . contentEquals ( other : FloatArray ) : Boolean","body":"{ <EOL> return this . contentEquals ( other ) <EOL> }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * Elements are compared for equality using the [equals][Any.equals] function.\n * This means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.doubleArrayContentEquals\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public infix fun DoubleArray . contentEquals ( other : DoubleArray ) : Boolean","body":"{ <EOL> return this . contentEquals ( other ) <EOL> }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * Elements are compared for equality using the [equals][Any.equals] function.\n * This means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.doubleArrayContentEquals\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public infix fun BooleanArray . contentEquals ( other : BooleanArray ) : Boolean","body":"{ <EOL> return this . contentEquals ( other ) <EOL> }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.booleanArrayContentEquals\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public infix fun CharArray . contentEquals ( other : CharArray ) : Boolean","body":"{ <EOL> return this . contentEquals ( other ) <EOL> }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.charArrayContentEquals\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual infix fun < T > Array < out T > ? . contentEquals ( other : Array < out T > ? ) : Boolean","body":"{ <EOL> if ( this === other ) return true <EOL> if ( this === null || other === null ) return false <EOL> if ( size != other . size ) return false <EOL> for ( i in indices ) { <EOL> if ( this [ i ] != other [ i ] ) return false <EOL> } <EOL> return true <EOL> }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * Elements are compared for equality using the [equals][Any.equals] function.\n * For floating point numbers, this means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.\n * \n * The arrays are also considered structurally equal if both are `null`.\n * \n * If the arrays contain nested arrays, use [contentDeepEquals] to recursively compare their elements.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.arrayContentEquals\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual infix fun ByteArray ? . contentEquals ( other : ByteArray ? ) : Boolean","body":"{ <EOL> if ( this === other ) return true <EOL> if ( this === null || other === null ) return false <EOL> if ( size != other . size ) return false <EOL> for ( i in indices ) { <EOL> if ( this [ i ] != other [ i ] ) return false <EOL> } <EOL> return true <EOL> }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * The arrays are also considered structurally equal if both are `null`.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual infix fun ShortArray ? . contentEquals ( other : ShortArray ? ) : Boolean","body":"{ <EOL> if ( this === other ) return true <EOL> if ( this === null || other === null ) return false <EOL> if ( size != other . size ) return false <EOL> for ( i in indices ) { <EOL> if ( this [ i ] != other [ i ] ) return false <EOL> } <EOL> return true <EOL> }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * The arrays are also considered structurally equal if both are `null`.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual infix fun IntArray ? . contentEquals ( other : IntArray ? ) : Boolean","body":"{ <EOL> if ( this === other ) return true <EOL> if ( this === null || other === null ) return false <EOL> if ( size != other . size ) return false <EOL> for ( i in indices ) { <EOL> if ( this [ i ] != other [ i ] ) return false <EOL> } <EOL> return true <EOL> }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * The arrays are also considered structurally equal if both are `null`.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual infix fun LongArray ? . contentEquals ( other : LongArray ? ) : Boolean","body":"{ <EOL> if ( this === other ) return true <EOL> if ( this === null || other === null ) return false <EOL> if ( size != other . size ) return false <EOL> for ( i in indices ) { <EOL> if ( this [ i ] != other [ i ] ) return false <EOL> } <EOL> return true <EOL> }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * The arrays are also considered structurally equal if both are `null`.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual infix fun FloatArray ? . contentEquals ( other : FloatArray ? ) : Boolean","body":"{ <EOL> if ( this === other ) return true <EOL> if ( this === null || other === null ) return false <EOL> if ( size != other . size ) return false <EOL> for ( i in indices ) { <EOL> if ( ! this [ i ] . equals ( other [ i ] ) ) return false <EOL> } <EOL> return true <EOL> }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * Elements are compared for equality using the [equals][Any.equals] function.\n * This means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.\n * \n * The arrays are also considered structurally equal if both are `null`.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.doubleArrayContentEquals\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual infix fun DoubleArray ? . contentEquals ( other : DoubleArray ? ) : Boolean","body":"{ <EOL> if ( this === other ) return true <EOL> if ( this === null || other === null ) return false <EOL> if ( size != other . size ) return false <EOL> for ( i in indices ) { <EOL> if ( ! this [ i ] . equals ( other [ i ] ) ) return false <EOL> } <EOL> return true <EOL> }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * Elements are compared for equality using the [equals][Any.equals] function.\n * This means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.\n * \n * The arrays are also considered structurally equal if both are `null`.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.doubleArrayContentEquals\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual infix fun BooleanArray ? . contentEquals ( other : BooleanArray ? ) : Boolean","body":"{ <EOL> if ( this === other ) return true <EOL> if ( this === null || other === null ) return false <EOL> if ( size != other . size ) return false <EOL> for ( i in indices ) { <EOL> if ( this [ i ] != other [ i ] ) return false <EOL> } <EOL> return true <EOL> }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * The arrays are also considered structurally equal if both are `null`.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.booleanArrayContentEquals\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual infix fun CharArray ? . contentEquals ( other : CharArray ? ) : Boolean","body":"{ <EOL> if ( this === other ) return true <EOL> if ( this === null || other === null ) return false <EOL> if ( size != other . size ) return false <EOL> for ( i in indices ) { <EOL> if ( this [ i ] != other [ i ] ) return false <EOL> } <EOL> return true <EOL> }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * The arrays are also considered structurally equal if both are `null`.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.charArrayContentEquals\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public fun < T > Array < out T > . contentHashCode ( ) : Int","body":"{ <EOL> return this . contentHashCode ( ) <EOL> }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public fun ByteArray . contentHashCode ( ) : Int","body":"{ <EOL> return this . contentHashCode ( ) <EOL> }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public fun ShortArray . contentHashCode ( ) : Int","body":"{ <EOL> return this . contentHashCode ( ) <EOL> }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public fun IntArray . contentHashCode ( ) : Int","body":"{ <EOL> return this . contentHashCode ( ) <EOL> }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public fun LongArray . contentHashCode ( ) : Int","body":"{ <EOL> return this . contentHashCode ( ) <EOL> }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public fun FloatArray . contentHashCode ( ) : Int","body":"{ <EOL> return this . contentHashCode ( ) <EOL> }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public fun DoubleArray . contentHashCode ( ) : Int","body":"{ <EOL> return this . contentHashCode ( ) <EOL> }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public fun BooleanArray . contentHashCode ( ) : Int","body":"{ <EOL> return this . contentHashCode ( ) <EOL> }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public fun CharArray . contentHashCode ( ) : Int","body":"{ <EOL> return this . contentHashCode ( ) <EOL> }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual fun < T > Array < out T > ? . contentHashCode ( ) : Int","body":"{ <EOL> if ( this === null ) return <NUM_LIT:0> <EOL> var result = <NUM_LIT:1> <EOL> for ( element in this ) <EOL> result = <NUM_LIT:31> * result + element . hashCode ( ) <EOL> return result <EOL> }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual fun ByteArray ? . contentHashCode ( ) : Int","body":"{ <EOL> if ( this === null ) return <NUM_LIT:0> <EOL> var result = <NUM_LIT:1> <EOL> for ( element in this ) <EOL> result = <NUM_LIT:31> * result + element . hashCode ( ) <EOL> return result <EOL> }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual fun ShortArray ? . contentHashCode ( ) : Int","body":"{ <EOL> if ( this === null ) return <NUM_LIT:0> <EOL> var result = <NUM_LIT:1> <EOL> for ( element in this ) <EOL> result = <NUM_LIT:31> * result + element . hashCode ( ) <EOL> return result <EOL> }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual fun IntArray ? . contentHashCode ( ) : Int","body":"{ <EOL> if ( this === null ) return <NUM_LIT:0> <EOL> var result = <NUM_LIT:1> <EOL> for ( element in this ) <EOL> result = <NUM_LIT:31> * result + element . hashCode ( ) <EOL> return result <EOL> }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual fun LongArray ? . contentHashCode ( ) : Int","body":"{ <EOL> if ( this === null ) return <NUM_LIT:0> <EOL> var result = <NUM_LIT:1> <EOL> for ( element in this ) <EOL> result = <NUM_LIT:31> * result + element . hashCode ( ) <EOL> return result <EOL> }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual fun FloatArray ? . contentHashCode ( ) : Int","body":"{ <EOL> if ( this === null ) return <NUM_LIT:0> <EOL> var result = <NUM_LIT:1> <EOL> for ( element in this ) <EOL> result = <NUM_LIT:31> * result + element . hashCode ( ) <EOL> return result <EOL> }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual fun DoubleArray ? . contentHashCode ( ) : Int","body":"{ <EOL> if ( this === null ) return <NUM_LIT:0> <EOL> var result = <NUM_LIT:1> <EOL> for ( element in this ) <EOL> result = <NUM_LIT:31> * result + element . hashCode ( ) <EOL> return result <EOL> }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual fun BooleanArray ? . contentHashCode ( ) : Int","body":"{ <EOL> if ( this === null ) return <NUM_LIT:0> <EOL> var result = <NUM_LIT:1> <EOL> for ( element in this ) <EOL> result = <NUM_LIT:31> * result + element . hashCode ( ) <EOL> return result <EOL> }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual fun CharArray ? . contentHashCode ( ) : Int","body":"{ <EOL> if ( this === null ) return <NUM_LIT:0> <EOL> var result = <NUM_LIT:1> <EOL> for ( element in this ) <EOL> result = <NUM_LIT:31> * result + element . hashCode ( ) <EOL> return result <EOL> }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public fun < T > Array < out T > . contentToString ( ) : String","body":"{ <EOL> return this . contentToString ( ) <EOL> }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public fun ByteArray . contentToString ( ) : String","body":"{ <EOL> return this . contentToString ( ) <EOL> }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public fun ShortArray . contentToString ( ) : String","body":"{ <EOL> return this . contentToString ( ) <EOL> }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public fun IntArray . contentToString ( ) : String","body":"{ <EOL> return this . contentToString ( ) <EOL> }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public fun LongArray . contentToString ( ) : String","body":"{ <EOL> return this . contentToString ( ) <EOL> }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public fun FloatArray . contentToString ( ) : String","body":"{ <EOL> return this . contentToString ( ) <EOL> }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public fun DoubleArray . contentToString ( ) : String","body":"{ <EOL> return this . contentToString ( ) <EOL> }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public fun BooleanArray . contentToString ( ) : String","body":"{ <EOL> return this . contentToString ( ) <EOL> }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" ) <EOL> @ SinceKotlin ( \"<STR_LIT:1.1>\" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = \"<STR_LIT:1.4>\" ) <EOL> public fun CharArray . contentToString ( ) : String","body":"{ <EOL> return this . contentToString ( ) <EOL> }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual fun < T > Array < out T > ? . contentToString ( ) : String","body":"{ <EOL> return this ? . joinToString ( \"<STR_LIT:U+002CU+0020>\" , \"<STR_LIT:[>\" , \"<STR_LIT:]>\" ) ? : \"<STR_LIT:null>\" <EOL> }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual fun ByteArray ? . contentToString ( ) : String","body":"{ <EOL> return this ? . joinToString ( \"<STR_LIT:U+002CU+0020>\" , \"<STR_LIT:[>\" , \"<STR_LIT:]>\" ) ? : \"<STR_LIT:null>\" <EOL> }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual fun ShortArray ? . contentToString ( ) : String","body":"{ <EOL> return this ? . joinToString ( \"<STR_LIT:U+002CU+0020>\" , \"<STR_LIT:[>\" , \"<STR_LIT:]>\" ) ? : \"<STR_LIT:null>\" <EOL> }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual fun IntArray ? . contentToString ( ) : String","body":"{ <EOL> return this ? . joinToString ( \"<STR_LIT:U+002CU+0020>\" , \"<STR_LIT:[>\" , \"<STR_LIT:]>\" ) ? : \"<STR_LIT:null>\" <EOL> }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual fun LongArray ? . contentToString ( ) : String","body":"{ <EOL> return this ? . joinToString ( \"<STR_LIT:U+002CU+0020>\" , \"<STR_LIT:[>\" , \"<STR_LIT:]>\" ) ? : \"<STR_LIT:null>\" <EOL> }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual fun FloatArray ? . contentToString ( ) : String","body":"{ <EOL> return this ? . joinToString ( \"<STR_LIT:U+002CU+0020>\" , \"<STR_LIT:[>\" , \"<STR_LIT:]>\" ) ? : \"<STR_LIT:null>\" <EOL> }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual fun DoubleArray ? . contentToString ( ) : String","body":"{ <EOL> return this ? . joinToString ( \"<STR_LIT:U+002CU+0020>\" , \"<STR_LIT:[>\" , \"<STR_LIT:]>\" ) ? : \"<STR_LIT:null>\" <EOL> }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual fun BooleanArray ? . contentToString ( ) : String","body":"{ <EOL> return this ? . joinToString ( \"<STR_LIT:U+002CU+0020>\" , \"<STR_LIT:[>\" , \"<STR_LIT:]>\" ) ? : \"<STR_LIT:null>\" <EOL> }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual fun CharArray ? . contentToString ( ) : String","body":"{ <EOL> return this ? . joinToString ( \"<STR_LIT:U+002CU+0020>\" , \"<STR_LIT:[>\" , \"<STR_LIT:]>\" ) ? : \"<STR_LIT:null>\" <EOL> }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun < T > Array < out T > . copyInto ( destination : Array < T > , destinationOffset : Int = <NUM_LIT:0> , startIndex : Int = <NUM_LIT:0> , endIndex : Int = size ) : Array < T >","body":"{ <EOL> @ Suppress ( \"<STR_LIT:UNCHECKED_CAST>\" ) <EOL> arrayCopy ( this as Array < Any ? > , startIndex , destination as Array < Any ? > , destinationOffset , endIndex - startIndex ) <EOL> return destination <EOL> }","docstring":"/**\n * Copies this array or its subrange into the [destination] array and returns that array.\n * \n * It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.\n * \n * @param destination the array to copy to.\n * @param destinationOffset the position in the [destination] array to copy to, 0 by default.\n * @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.\n * @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.\n * \n * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.\n * @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],\n * or when that index is out of the [destination] array indices range.\n * \n * @return the [destination] array.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun ByteArray . copyInto ( destination : ByteArray , destinationOffset : Int = <NUM_LIT:0> , startIndex : Int = <NUM_LIT:0> , endIndex : Int = size ) : ByteArray","body":"{ <EOL> arrayCopy ( this , startIndex , destination , destinationOffset , endIndex - startIndex ) <EOL> return destination <EOL> }","docstring":"/**\n * Copies this array or its subrange into the [destination] array and returns that array.\n * \n * It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.\n * \n * @param destination the array to copy to.\n * @param destinationOffset the position in the [destination] array to copy to, 0 by default.\n * @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.\n * @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.\n * \n * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.\n * @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],\n * or when that index is out of the [destination] array indices range.\n * \n * @return the [destination] array.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun ShortArray . copyInto ( destination : ShortArray , destinationOffset : Int = <NUM_LIT:0> , startIndex : Int = <NUM_LIT:0> , endIndex : Int = size ) : ShortArray","body":"{ <EOL> arrayCopy ( this , startIndex , destination , destinationOffset , endIndex - startIndex ) <EOL> return destination <EOL> }","docstring":"/**\n * Copies this array or its subrange into the [destination] array and returns that array.\n * \n * It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.\n * \n * @param destination the array to copy to.\n * @param destinationOffset the position in the [destination] array to copy to, 0 by default.\n * @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.\n * @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.\n * \n * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.\n * @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],\n * or when that index is out of the [destination] array indices range.\n * \n * @return the [destination] array.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun IntArray . copyInto ( destination : IntArray , destinationOffset : Int = <NUM_LIT:0> , startIndex : Int = <NUM_LIT:0> , endIndex : Int = size ) : IntArray","body":"{ <EOL> arrayCopy ( this , startIndex , destination , destinationOffset , endIndex - startIndex ) <EOL> return destination <EOL> }","docstring":"/**\n * Copies this array or its subrange into the [destination] array and returns that array.\n * \n * It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.\n * \n * @param destination the array to copy to.\n * @param destinationOffset the position in the [destination] array to copy to, 0 by default.\n * @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.\n * @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.\n * \n * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.\n * @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],\n * or when that index is out of the [destination] array indices range.\n * \n * @return the [destination] array.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun LongArray . copyInto ( destination : LongArray , destinationOffset : Int = <NUM_LIT:0> , startIndex : Int = <NUM_LIT:0> , endIndex : Int = size ) : LongArray","body":"{ <EOL> arrayCopy ( this , startIndex , destination , destinationOffset , endIndex - startIndex ) <EOL> return destination <EOL> }","docstring":"/**\n * Copies this array or its subrange into the [destination] array and returns that array.\n * \n * It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.\n * \n * @param destination the array to copy to.\n * @param destinationOffset the position in the [destination] array to copy to, 0 by default.\n * @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.\n * @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.\n * \n * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.\n * @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],\n * or when that index is out of the [destination] array indices range.\n * \n * @return the [destination] array.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun FloatArray . copyInto ( destination : FloatArray , destinationOffset : Int = <NUM_LIT:0> , startIndex : Int = <NUM_LIT:0> , endIndex : Int = size ) : FloatArray","body":"{ <EOL> arrayCopy ( this , startIndex , destination , destinationOffset , endIndex - startIndex ) <EOL> return destination <EOL> }","docstring":"/**\n * Copies this array or its subrange into the [destination] array and returns that array.\n * \n * It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.\n * \n * @param destination the array to copy to.\n * @param destinationOffset the position in the [destination] array to copy to, 0 by default.\n * @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.\n * @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.\n * \n * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.\n * @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],\n * or when that index is out of the [destination] array indices range.\n * \n * @return the [destination] array.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun DoubleArray . copyInto ( destination : DoubleArray , destinationOffset : Int = <NUM_LIT:0> , startIndex : Int = <NUM_LIT:0> , endIndex : Int = size ) : DoubleArray","body":"{ <EOL> arrayCopy ( this , startIndex , destination , destinationOffset , endIndex - startIndex ) <EOL> return destination <EOL> }","docstring":"/**\n * Copies this array or its subrange into the [destination] array and returns that array.\n * \n * It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.\n * \n * @param destination the array to copy to.\n * @param destinationOffset the position in the [destination] array to copy to, 0 by default.\n * @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.\n * @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.\n * \n * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.\n * @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],\n * or when that index is out of the [destination] array indices range.\n * \n * @return the [destination] array.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun BooleanArray . copyInto ( destination : BooleanArray , destinationOffset : Int = <NUM_LIT:0> , startIndex : Int = <NUM_LIT:0> , endIndex : Int = size ) : BooleanArray","body":"{ <EOL> arrayCopy ( this , startIndex , destination , destinationOffset , endIndex - startIndex ) <EOL> return destination <EOL> }","docstring":"/**\n * Copies this array or its subrange into the [destination] array and returns that array.\n * \n * It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.\n * \n * @param destination the array to copy to.\n * @param destinationOffset the position in the [destination] array to copy to, 0 by default.\n * @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.\n * @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.\n * \n * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.\n * @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],\n * or when that index is out of the [destination] array indices range.\n * \n * @return the [destination] array.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun CharArray . copyInto ( destination : CharArray , destinationOffset : Int = <NUM_LIT:0> , startIndex : Int = <NUM_LIT:0> , endIndex : Int = size ) : CharArray","body":"{ <EOL> arrayCopy ( this , startIndex , destination , destinationOffset , endIndex - startIndex ) <EOL> return destination <EOL> }","docstring":"/**\n * Copies this array or its subrange into the [destination] array and returns that array.\n * \n * It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.\n * \n * @param destination the array to copy to.\n * @param destinationOffset the position in the [destination] array to copy to, 0 by default.\n * @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.\n * @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.\n * \n * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.\n * @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],\n * or when that index is out of the [destination] array indices range.\n * \n * @return the [destination] array.\n */"}
{"signature":"public actual fun < T > Array < T > . copyOf ( ) : Array < T >","body":"{ <EOL> return this . copyOfUninitializedElements ( size ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.copyOf\n */"}
{"signature":"public actual fun ByteArray . copyOf ( ) : ByteArray","body":"{ <EOL> return this . copyOfUninitializedElements ( size ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.copyOf\n */"}
{"signature":"public actual fun ShortArray . copyOf ( ) : ShortArray","body":"{ <EOL> return this . copyOfUninitializedElements ( size ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.copyOf\n */"}
{"signature":"public actual fun IntArray . copyOf ( ) : IntArray","body":"{ <EOL> return this . copyOfUninitializedElements ( size ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.copyOf\n */"}
{"signature":"public actual fun LongArray . copyOf ( ) : LongArray","body":"{ <EOL> return this . copyOfUninitializedElements ( size ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.copyOf\n */"}
{"signature":"public actual fun FloatArray . copyOf ( ) : FloatArray","body":"{ <EOL> return this . copyOfUninitializedElements ( size ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.copyOf\n */"}
{"signature":"public actual fun DoubleArray . copyOf ( ) : DoubleArray","body":"{ <EOL> return this . copyOfUninitializedElements ( size ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.copyOf\n */"}
{"signature":"public actual fun BooleanArray . copyOf ( ) : BooleanArray","body":"{ <EOL> return this . copyOfUninitializedElements ( size ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.copyOf\n */"}
{"signature":"public actual fun CharArray . copyOf ( ) : CharArray","body":"{ <EOL> return this . copyOfUninitializedElements ( size ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.copyOf\n */"}
{"signature":"public actual fun ByteArray . copyOf ( newSize : Int ) : ByteArray","body":"{ <EOL> return this . copyOfUninitializedElements ( newSize ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array, resized to the given [newSize].\n * The copy is either truncated or padded at the end with zero values if necessary.\n * \n * - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].\n * - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with zero values.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf\n */"}
{"signature":"public actual fun ShortArray . copyOf ( newSize : Int ) : ShortArray","body":"{ <EOL> return this . copyOfUninitializedElements ( newSize ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array, resized to the given [newSize].\n * The copy is either truncated or padded at the end with zero values if necessary.\n * \n * - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].\n * - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with zero values.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf\n */"}
{"signature":"public actual fun IntArray . copyOf ( newSize : Int ) : IntArray","body":"{ <EOL> return this . copyOfUninitializedElements ( newSize ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array, resized to the given [newSize].\n * The copy is either truncated or padded at the end with zero values if necessary.\n * \n * - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].\n * - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with zero values.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf\n */"}
{"signature":"public actual fun LongArray . copyOf ( newSize : Int ) : LongArray","body":"{ <EOL> return this . copyOfUninitializedElements ( newSize ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array, resized to the given [newSize].\n * The copy is either truncated or padded at the end with zero values if necessary.\n * \n * - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].\n * - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with zero values.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf\n */"}
{"signature":"public actual fun FloatArray . copyOf ( newSize : Int ) : FloatArray","body":"{ <EOL> return this . copyOfUninitializedElements ( newSize ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array, resized to the given [newSize].\n * The copy is either truncated or padded at the end with zero values if necessary.\n * \n * - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].\n * - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with zero values.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf\n */"}
{"signature":"public actual fun DoubleArray . copyOf ( newSize : Int ) : DoubleArray","body":"{ <EOL> return this . copyOfUninitializedElements ( newSize ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array, resized to the given [newSize].\n * The copy is either truncated or padded at the end with zero values if necessary.\n * \n * - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].\n * - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with zero values.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf\n */"}
{"signature":"public actual fun BooleanArray . copyOf ( newSize : Int ) : BooleanArray","body":"{ <EOL> return this . copyOfUninitializedElements ( newSize ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array, resized to the given [newSize].\n * The copy is either truncated or padded at the end with `false` values if necessary.\n * \n * - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].\n * - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with `false` values.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf\n */"}
{"signature":"public actual fun CharArray . copyOf ( newSize : Int ) : CharArray","body":"{ <EOL> return this . copyOfUninitializedElements ( newSize ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array, resized to the given [newSize].\n * The copy is either truncated or padded at the end with null char (`\\u0000`) values if necessary.\n * \n * - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].\n * - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with null char (`\\u0000`) values.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf\n */"}
{"signature":"public actual fun < T > Array < T > . copyOf ( newSize : Int ) : Array < T ? >","body":"{ <EOL> return this . copyOfNulls ( newSize ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array, resized to the given [newSize].\n * The copy is either truncated or padded at the end with `null` values if necessary.\n * \n * - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].\n * - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with `null` values.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.resizingCopyOf\n */"}
{"signature":"public actual fun < T > Array < T > . copyOfRange ( fromIndex : Int , toIndex : Int ) : Array < T >","body":"{ <EOL> checkCopyOfRangeArguments ( fromIndex , toIndex , size ) <EOL> return copyOfUninitializedElements ( fromIndex , toIndex ) <EOL> }","docstring":"/**\n * Returns a new array which is a copy of the specified range of the original array.\n * \n * @param fromIndex the start of the range (inclusive) to copy.\n * @param toIndex the end of the range (exclusive) to copy.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"}
{"signature":"public actual fun ByteArray . copyOfRange ( fromIndex : Int , toIndex : Int ) : ByteArray","body":"{ <EOL> checkCopyOfRangeArguments ( fromIndex , toIndex , size ) <EOL> return copyOfUninitializedElements ( fromIndex , toIndex ) <EOL> }","docstring":"/**\n * Returns a new array which is a copy of the specified range of the original array.\n * \n * @param fromIndex the start of the range (inclusive) to copy.\n * @param toIndex the end of the range (exclusive) to copy.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"}
{"signature":"public actual fun ShortArray . copyOfRange ( fromIndex : Int , toIndex : Int ) : ShortArray","body":"{ <EOL> checkCopyOfRangeArguments ( fromIndex , toIndex , size ) <EOL> return copyOfUninitializedElements ( fromIndex , toIndex ) <EOL> }","docstring":"/**\n * Returns a new array which is a copy of the specified range of the original array.\n * \n * @param fromIndex the start of the range (inclusive) to copy.\n * @param toIndex the end of the range (exclusive) to copy.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"}
{"signature":"public actual fun IntArray . copyOfRange ( fromIndex : Int , toIndex : Int ) : IntArray","body":"{ <EOL> checkCopyOfRangeArguments ( fromIndex , toIndex , size ) <EOL> return copyOfUninitializedElements ( fromIndex , toIndex ) <EOL> }","docstring":"/**\n * Returns a new array which is a copy of the specified range of the original array.\n * \n * @param fromIndex the start of the range (inclusive) to copy.\n * @param toIndex the end of the range (exclusive) to copy.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"}
{"signature":"public actual fun LongArray . copyOfRange ( fromIndex : Int , toIndex : Int ) : LongArray","body":"{ <EOL> checkCopyOfRangeArguments ( fromIndex , toIndex , size ) <EOL> return copyOfUninitializedElements ( fromIndex , toIndex ) <EOL> }","docstring":"/**\n * Returns a new array which is a copy of the specified range of the original array.\n * \n * @param fromIndex the start of the range (inclusive) to copy.\n * @param toIndex the end of the range (exclusive) to copy.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"}
{"signature":"public actual fun FloatArray . copyOfRange ( fromIndex : Int , toIndex : Int ) : FloatArray","body":"{ <EOL> checkCopyOfRangeArguments ( fromIndex , toIndex , size ) <EOL> return copyOfUninitializedElements ( fromIndex , toIndex ) <EOL> }","docstring":"/**\n * Returns a new array which is a copy of the specified range of the original array.\n * \n * @param fromIndex the start of the range (inclusive) to copy.\n * @param toIndex the end of the range (exclusive) to copy.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"}
{"signature":"public actual fun DoubleArray . copyOfRange ( fromIndex : Int , toIndex : Int ) : DoubleArray","body":"{ <EOL> checkCopyOfRangeArguments ( fromIndex , toIndex , size ) <EOL> return copyOfUninitializedElements ( fromIndex , toIndex ) <EOL> }","docstring":"/**\n * Returns a new array which is a copy of the specified range of the original array.\n * \n * @param fromIndex the start of the range (inclusive) to copy.\n * @param toIndex the end of the range (exclusive) to copy.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"}
{"signature":"public actual fun BooleanArray . copyOfRange ( fromIndex : Int , toIndex : Int ) : BooleanArray","body":"{ <EOL> checkCopyOfRangeArguments ( fromIndex , toIndex , size ) <EOL> return copyOfUninitializedElements ( fromIndex , toIndex ) <EOL> }","docstring":"/**\n * Returns a new array which is a copy of the specified range of the original array.\n * \n * @param fromIndex the start of the range (inclusive) to copy.\n * @param toIndex the end of the range (exclusive) to copy.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"}
{"signature":"public actual fun CharArray . copyOfRange ( fromIndex : Int , toIndex : Int ) : CharArray","body":"{ <EOL> checkCopyOfRangeArguments ( fromIndex , toIndex , size ) <EOL> return copyOfUninitializedElements ( fromIndex , toIndex ) <EOL> }","docstring":"/**\n * Returns a new array which is a copy of the specified range of the original array.\n * \n * @param fromIndex the start of the range (inclusive) to copy.\n * @param toIndex the end of the range (exclusive) to copy.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"}
{"signature":"internal fun < T > Array < T > . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : Array < T >","body":"{ <EOL> val newSize = toIndex - fromIndex <EOL> if ( newSize < <NUM_LIT:0> ) { <EOL> throw IllegalArgumentException ( \"<STR_LIT>\" ) <EOL> } <EOL> val result = arrayOfUninitializedElements < T > ( newSize ) <EOL> this . copyInto ( result , <NUM_LIT:0> , fromIndex , toIndex . coerceAtMost ( size ) ) <EOL> return result <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array's range between [fromIndex] (inclusive)\n * and [toIndex] (exclusive) with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"}
{"signature":"internal fun ByteArray . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : ByteArray","body":"{ <EOL> val newSize = toIndex - fromIndex <EOL> if ( newSize < <NUM_LIT:0> ) { <EOL> throw IllegalArgumentException ( \"<STR_LIT>\" ) <EOL> } <EOL> val result = ByteArray ( newSize ) <EOL> this . copyInto ( result , <NUM_LIT:0> , fromIndex , toIndex . coerceAtMost ( size ) ) <EOL> return result <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array's range between [fromIndex] (inclusive)\n * and [toIndex] (exclusive) with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"}
{"signature":"internal fun ShortArray . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : ShortArray","body":"{ <EOL> val newSize = toIndex - fromIndex <EOL> if ( newSize < <NUM_LIT:0> ) { <EOL> throw IllegalArgumentException ( \"<STR_LIT>\" ) <EOL> } <EOL> val result = ShortArray ( newSize ) <EOL> this . copyInto ( result , <NUM_LIT:0> , fromIndex , toIndex . coerceAtMost ( size ) ) <EOL> return result <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array's range between [fromIndex] (inclusive)\n * and [toIndex] (exclusive) with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"}
{"signature":"internal fun IntArray . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : IntArray","body":"{ <EOL> val newSize = toIndex - fromIndex <EOL> if ( newSize < <NUM_LIT:0> ) { <EOL> throw IllegalArgumentException ( \"<STR_LIT>\" ) <EOL> } <EOL> val result = IntArray ( newSize ) <EOL> this . copyInto ( result , <NUM_LIT:0> , fromIndex , toIndex . coerceAtMost ( size ) ) <EOL> return result <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array's range between [fromIndex] (inclusive)\n * and [toIndex] (exclusive) with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"}
{"signature":"internal fun LongArray . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : LongArray","body":"{ <EOL> val newSize = toIndex - fromIndex <EOL> if ( newSize < <NUM_LIT:0> ) { <EOL> throw IllegalArgumentException ( \"<STR_LIT>\" ) <EOL> } <EOL> val result = LongArray ( newSize ) <EOL> this . copyInto ( result , <NUM_LIT:0> , fromIndex , toIndex . coerceAtMost ( size ) ) <EOL> return result <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array's range between [fromIndex] (inclusive)\n * and [toIndex] (exclusive) with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"}
{"signature":"internal fun FloatArray . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : FloatArray","body":"{ <EOL> val newSize = toIndex - fromIndex <EOL> if ( newSize < <NUM_LIT:0> ) { <EOL> throw IllegalArgumentException ( \"<STR_LIT>\" ) <EOL> } <EOL> val result = FloatArray ( newSize ) <EOL> this . copyInto ( result , <NUM_LIT:0> , fromIndex , toIndex . coerceAtMost ( size ) ) <EOL> return result <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array's range between [fromIndex] (inclusive)\n * and [toIndex] (exclusive) with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"}
{"signature":"internal fun DoubleArray . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : DoubleArray","body":"{ <EOL> val newSize = toIndex - fromIndex <EOL> if ( newSize < <NUM_LIT:0> ) { <EOL> throw IllegalArgumentException ( \"<STR_LIT>\" ) <EOL> } <EOL> val result = DoubleArray ( newSize ) <EOL> this . copyInto ( result , <NUM_LIT:0> , fromIndex , toIndex . coerceAtMost ( size ) ) <EOL> return result <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array's range between [fromIndex] (inclusive)\n * and [toIndex] (exclusive) with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"}
{"signature":"internal fun BooleanArray . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : BooleanArray","body":"{ <EOL> val newSize = toIndex - fromIndex <EOL> if ( newSize < <NUM_LIT:0> ) { <EOL> throw IllegalArgumentException ( \"<STR_LIT>\" ) <EOL> } <EOL> val result = BooleanArray ( newSize ) <EOL> this . copyInto ( result , <NUM_LIT:0> , fromIndex , toIndex . coerceAtMost ( size ) ) <EOL> return result <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array's range between [fromIndex] (inclusive)\n * and [toIndex] (exclusive) with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"}
{"signature":"internal fun CharArray . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : CharArray","body":"{ <EOL> val newSize = toIndex - fromIndex <EOL> if ( newSize < <NUM_LIT:0> ) { <EOL> throw IllegalArgumentException ( \"<STR_LIT>\" ) <EOL> } <EOL> val result = CharArray ( newSize ) <EOL> this . copyInto ( result , <NUM_LIT:0> , fromIndex , toIndex . coerceAtMost ( size ) ) <EOL> return result <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array's range between [fromIndex] (inclusive)\n * and [toIndex] (exclusive) with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"}
{"signature":"internal fun < T > Array < T > . copyOfUninitializedElements ( newSize : Int ) : Array < T >","body":"{ <EOL> return copyOfUninitializedElements ( <NUM_LIT:0> , newSize ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"}
{"signature":"internal fun ByteArray . copyOfUninitializedElements ( newSize : Int ) : ByteArray","body":"{ <EOL> return copyOfUninitializedElements ( <NUM_LIT:0> , newSize ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"}
{"signature":"internal fun ShortArray . copyOfUninitializedElements ( newSize : Int ) : ShortArray","body":"{ <EOL> return copyOfUninitializedElements ( <NUM_LIT:0> , newSize ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"}
{"signature":"internal fun IntArray . copyOfUninitializedElements ( newSize : Int ) : IntArray","body":"{ <EOL> return copyOfUninitializedElements ( <NUM_LIT:0> , newSize ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"}
{"signature":"internal fun LongArray . copyOfUninitializedElements ( newSize : Int ) : LongArray","body":"{ <EOL> return copyOfUninitializedElements ( <NUM_LIT:0> , newSize ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"}
{"signature":"internal fun FloatArray . copyOfUninitializedElements ( newSize : Int ) : FloatArray","body":"{ <EOL> return copyOfUninitializedElements ( <NUM_LIT:0> , newSize ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"}
{"signature":"internal fun DoubleArray . copyOfUninitializedElements ( newSize : Int ) : DoubleArray","body":"{ <EOL> return copyOfUninitializedElements ( <NUM_LIT:0> , newSize ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"}
{"signature":"internal fun BooleanArray . copyOfUninitializedElements ( newSize : Int ) : BooleanArray","body":"{ <EOL> return copyOfUninitializedElements ( <NUM_LIT:0> , newSize ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"}
{"signature":"internal fun CharArray . copyOfUninitializedElements ( newSize : Int ) : CharArray","body":"{ <EOL> return copyOfUninitializedElements ( <NUM_LIT:0> , newSize ) <EOL> }","docstring":"/**\n * Returns new array which is a copy of the original array with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun < T > Array < T > . fill ( element : T , fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit","body":"{ <EOL> arrayFill ( this , fromIndex , toIndex , element ) <EOL> }","docstring":"/**\n * Fills this array or its subrange with the specified [element] value.\n * \n * @param fromIndex the start of the range (inclusive) to fill, 0 by default.\n * @param toIndex the end of the range (exclusive) to fill, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun ByteArray . fill ( element : Byte , fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit","body":"{ <EOL> arrayFill ( this , fromIndex , toIndex , element ) <EOL> }","docstring":"/**\n * Fills this array or its subrange with the specified [element] value.\n * \n * @param fromIndex the start of the range (inclusive) to fill, 0 by default.\n * @param toIndex the end of the range (exclusive) to fill, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun ShortArray . fill ( element : Short , fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit","body":"{ <EOL> arrayFill ( this , fromIndex , toIndex , element ) <EOL> }","docstring":"/**\n * Fills this array or its subrange with the specified [element] value.\n * \n * @param fromIndex the start of the range (inclusive) to fill, 0 by default.\n * @param toIndex the end of the range (exclusive) to fill, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun IntArray . fill ( element : Int , fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit","body":"{ <EOL> arrayFill ( this , fromIndex , toIndex , element ) <EOL> }","docstring":"/**\n * Fills this array or its subrange with the specified [element] value.\n * \n * @param fromIndex the start of the range (inclusive) to fill, 0 by default.\n * @param toIndex the end of the range (exclusive) to fill, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun LongArray . fill ( element : Long , fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit","body":"{ <EOL> arrayFill ( this , fromIndex , toIndex , element ) <EOL> }","docstring":"/**\n * Fills this array or its subrange with the specified [element] value.\n * \n * @param fromIndex the start of the range (inclusive) to fill, 0 by default.\n * @param toIndex the end of the range (exclusive) to fill, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun FloatArray . fill ( element : Float , fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit","body":"{ <EOL> arrayFill ( this , fromIndex , toIndex , element ) <EOL> }","docstring":"/**\n * Fills this array or its subrange with the specified [element] value.\n * \n * @param fromIndex the start of the range (inclusive) to fill, 0 by default.\n * @param toIndex the end of the range (exclusive) to fill, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun DoubleArray . fill ( element : Double , fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit","body":"{ <EOL> arrayFill ( this , fromIndex , toIndex , element ) <EOL> }","docstring":"/**\n * Fills this array or its subrange with the specified [element] value.\n * \n * @param fromIndex the start of the range (inclusive) to fill, 0 by default.\n * @param toIndex the end of the range (exclusive) to fill, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun BooleanArray . fill ( element : Boolean , fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit","body":"{ <EOL> arrayFill ( this , fromIndex , toIndex , element ) <EOL> }","docstring":"/**\n * Fills this array or its subrange with the specified [element] value.\n * \n * @param fromIndex the start of the range (inclusive) to fill, 0 by default.\n * @param toIndex the end of the range (exclusive) to fill, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.3>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun CharArray . fill ( element : Char , fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit","body":"{ <EOL> arrayFill ( this , fromIndex , toIndex , element ) <EOL> }","docstring":"/**\n * Fills this array or its subrange with the specified [element] value.\n * \n * @param fromIndex the start of the range (inclusive) to fill, 0 by default.\n * @param toIndex the end of the range (exclusive) to fill, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"}
{"signature":"public actual operator fun < T > Array < T > . plus ( element : T ) : Array < T >","body":"{ <EOL> val index = size <EOL> val result = copyOfUninitializedElements ( index + <NUM_LIT:1> ) <EOL> result [ index ] = element <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then the given [element].\n */"}
{"signature":"public actual operator fun ByteArray . plus ( element : Byte ) : ByteArray","body":"{ <EOL> val index = size <EOL> val result = copyOfUninitializedElements ( index + <NUM_LIT:1> ) <EOL> result [ index ] = element <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then the given [element].\n */"}
{"signature":"public actual operator fun ShortArray . plus ( element : Short ) : ShortArray","body":"{ <EOL> val index = size <EOL> val result = copyOfUninitializedElements ( index + <NUM_LIT:1> ) <EOL> result [ index ] = element <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then the given [element].\n */"}
{"signature":"public actual operator fun IntArray . plus ( element : Int ) : IntArray","body":"{ <EOL> val index = size <EOL> val result = copyOfUninitializedElements ( index + <NUM_LIT:1> ) <EOL> result [ index ] = element <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then the given [element].\n */"}
{"signature":"public actual operator fun LongArray . plus ( element : Long ) : LongArray","body":"{ <EOL> val index = size <EOL> val result = copyOfUninitializedElements ( index + <NUM_LIT:1> ) <EOL> result [ index ] = element <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then the given [element].\n */"}
{"signature":"public actual operator fun FloatArray . plus ( element : Float ) : FloatArray","body":"{ <EOL> val index = size <EOL> val result = copyOfUninitializedElements ( index + <NUM_LIT:1> ) <EOL> result [ index ] = element <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then the given [element].\n */"}
{"signature":"public actual operator fun DoubleArray . plus ( element : Double ) : DoubleArray","body":"{ <EOL> val index = size <EOL> val result = copyOfUninitializedElements ( index + <NUM_LIT:1> ) <EOL> result [ index ] = element <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then the given [element].\n */"}
{"signature":"public actual operator fun BooleanArray . plus ( element : Boolean ) : BooleanArray","body":"{ <EOL> val index = size <EOL> val result = copyOfUninitializedElements ( index + <NUM_LIT:1> ) <EOL> result [ index ] = element <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then the given [element].\n */"}
{"signature":"public actual operator fun CharArray . plus ( element : Char ) : CharArray","body":"{ <EOL> val index = size <EOL> val result = copyOfUninitializedElements ( index + <NUM_LIT:1> ) <EOL> result [ index ] = element <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then the given [element].\n */"}
{"signature":"public actual operator fun < T > Array < T > . plus ( elements : Collection < T > ) : Array < T >","body":"{ <EOL> var index = size <EOL> val result = copyOfUninitializedElements ( index + elements . size ) <EOL> for ( element in elements ) result [ index ++ ] = element <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] collection.\n */"}
{"signature":"public actual operator fun ByteArray . plus ( elements : Collection < Byte > ) : ByteArray","body":"{ <EOL> var index = size <EOL> val result = copyOfUninitializedElements ( index + elements . size ) <EOL> for ( element in elements ) result [ index ++ ] = element <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] collection.\n */"}
{"signature":"public actual operator fun ShortArray . plus ( elements : Collection < Short > ) : ShortArray","body":"{ <EOL> var index = size <EOL> val result = copyOfUninitializedElements ( index + elements . size ) <EOL> for ( element in elements ) result [ index ++ ] = element <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] collection.\n */"}
{"signature":"public actual operator fun IntArray . plus ( elements : Collection < Int > ) : IntArray","body":"{ <EOL> var index = size <EOL> val result = copyOfUninitializedElements ( index + elements . size ) <EOL> for ( element in elements ) result [ index ++ ] = element <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] collection.\n */"}
{"signature":"public actual operator fun LongArray . plus ( elements : Collection < Long > ) : LongArray","body":"{ <EOL> var index = size <EOL> val result = copyOfUninitializedElements ( index + elements . size ) <EOL> for ( element in elements ) result [ index ++ ] = element <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] collection.\n */"}
{"signature":"public actual operator fun FloatArray . plus ( elements : Collection < Float > ) : FloatArray","body":"{ <EOL> var index = size <EOL> val result = copyOfUninitializedElements ( index + elements . size ) <EOL> for ( element in elements ) result [ index ++ ] = element <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] collection.\n */"}
{"signature":"public actual operator fun DoubleArray . plus ( elements : Collection < Double > ) : DoubleArray","body":"{ <EOL> var index = size <EOL> val result = copyOfUninitializedElements ( index + elements . size ) <EOL> for ( element in elements ) result [ index ++ ] = element <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] collection.\n */"}
{"signature":"public actual operator fun BooleanArray . plus ( elements : Collection < Boolean > ) : BooleanArray","body":"{ <EOL> var index = size <EOL> val result = copyOfUninitializedElements ( index + elements . size ) <EOL> for ( element in elements ) result [ index ++ ] = element <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] collection.\n */"}
{"signature":"public actual operator fun CharArray . plus ( elements : Collection < Char > ) : CharArray","body":"{ <EOL> var index = size <EOL> val result = copyOfUninitializedElements ( index + elements . size ) <EOL> for ( element in elements ) result [ index ++ ] = element <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] collection.\n */"}
{"signature":"public actual operator fun < T > Array < T > . plus ( elements : Array < out T > ) : Array < T >","body":"{ <EOL> val thisSize = size <EOL> val arraySize = elements . size <EOL> val result = copyOfUninitializedElements ( thisSize + arraySize ) <EOL> elements . copyInto ( result , thisSize ) <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] array.\n */"}
{"signature":"public actual operator fun ByteArray . plus ( elements : ByteArray ) : ByteArray","body":"{ <EOL> val thisSize = size <EOL> val arraySize = elements . size <EOL> val result = copyOfUninitializedElements ( thisSize + arraySize ) <EOL> elements . copyInto ( result , thisSize ) <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] array.\n */"}
{"signature":"public actual operator fun ShortArray . plus ( elements : ShortArray ) : ShortArray","body":"{ <EOL> val thisSize = size <EOL> val arraySize = elements . size <EOL> val result = copyOfUninitializedElements ( thisSize + arraySize ) <EOL> elements . copyInto ( result , thisSize ) <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] array.\n */"}
{"signature":"public actual operator fun IntArray . plus ( elements : IntArray ) : IntArray","body":"{ <EOL> val thisSize = size <EOL> val arraySize = elements . size <EOL> val result = copyOfUninitializedElements ( thisSize + arraySize ) <EOL> elements . copyInto ( result , thisSize ) <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] array.\n */"}
{"signature":"public actual operator fun LongArray . plus ( elements : LongArray ) : LongArray","body":"{ <EOL> val thisSize = size <EOL> val arraySize = elements . size <EOL> val result = copyOfUninitializedElements ( thisSize + arraySize ) <EOL> elements . copyInto ( result , thisSize ) <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] array.\n */"}
{"signature":"public actual operator fun FloatArray . plus ( elements : FloatArray ) : FloatArray","body":"{ <EOL> val thisSize = size <EOL> val arraySize = elements . size <EOL> val result = copyOfUninitializedElements ( thisSize + arraySize ) <EOL> elements . copyInto ( result , thisSize ) <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] array.\n */"}
{"signature":"public actual operator fun DoubleArray . plus ( elements : DoubleArray ) : DoubleArray","body":"{ <EOL> val thisSize = size <EOL> val arraySize = elements . size <EOL> val result = copyOfUninitializedElements ( thisSize + arraySize ) <EOL> elements . copyInto ( result , thisSize ) <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] array.\n */"}
{"signature":"public actual operator fun BooleanArray . plus ( elements : BooleanArray ) : BooleanArray","body":"{ <EOL> val thisSize = size <EOL> val arraySize = elements . size <EOL> val result = copyOfUninitializedElements ( thisSize + arraySize ) <EOL> elements . copyInto ( result , thisSize ) <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] array.\n */"}
{"signature":"public actual operator fun CharArray . plus ( elements : CharArray ) : CharArray","body":"{ <EOL> val thisSize = size <EOL> val arraySize = elements . size <EOL> val result = copyOfUninitializedElements ( thisSize + arraySize ) <EOL> elements . copyInto ( result , thisSize ) <EOL> return result <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] array.\n */"}
{"signature":"@ kotlin . internal . InlineOnly <EOL> public actual inline fun < T > Array < T > . plusElement ( element : T ) : Array < T >","body":"{ <EOL> return plus ( element ) <EOL> }","docstring":"/**\n * Returns an array containing all elements of the original array and then the given [element].\n */"}
{"signature":"public actual fun IntArray . sort ( ) : Unit","body":"{ <EOL> if ( size > <NUM_LIT:1> ) sortArray ( this , <NUM_LIT:0> , size ) <EOL> }","docstring":"/**\n * Sorts the array in-place.\n * \n * @sample samples.collections.Arrays.Sorting.sortArray\n */"}
{"signature":"public actual fun LongArray . sort ( ) : Unit","body":"{ <EOL> if ( size > <NUM_LIT:1> ) sortArray ( this , <NUM_LIT:0> , size ) <EOL> }","docstring":"/**\n * Sorts the array in-place.\n * \n * @sample samples.collections.Arrays.Sorting.sortArray\n */"}
{"signature":"public actual fun ByteArray . sort ( ) : Unit","body":"{ <EOL> if ( size > <NUM_LIT:1> ) sortArray ( this , <NUM_LIT:0> , size ) <EOL> }","docstring":"/**\n * Sorts the array in-place.\n * \n * @sample samples.collections.Arrays.Sorting.sortArray\n */"}
{"signature":"public actual fun ShortArray . sort ( ) : Unit","body":"{ <EOL> if ( size > <NUM_LIT:1> ) sortArray ( this , <NUM_LIT:0> , size ) <EOL> }","docstring":"/**\n * Sorts the array in-place.\n * \n * @sample samples.collections.Arrays.Sorting.sortArray\n */"}
{"signature":"public actual fun DoubleArray . sort ( ) : Unit","body":"{ <EOL> if ( size > <NUM_LIT:1> ) sortArray ( this , <NUM_LIT:0> , size ) <EOL> }","docstring":"/**\n * Sorts the array in-place.\n * \n * @sample samples.collections.Arrays.Sorting.sortArray\n */"}
{"signature":"public actual fun FloatArray . sort ( ) : Unit","body":"{ <EOL> if ( size > <NUM_LIT:1> ) sortArray ( this , <NUM_LIT:0> , size ) <EOL> }","docstring":"/**\n * Sorts the array in-place.\n * \n * @sample samples.collections.Arrays.Sorting.sortArray\n */"}
{"signature":"public actual fun CharArray . sort ( ) : Unit","body":"{ <EOL> if ( size > <NUM_LIT:1> ) sortArray ( this , <NUM_LIT:0> , size ) <EOL> }","docstring":"/**\n * Sorts the array in-place.\n * \n * @sample samples.collections.Arrays.Sorting.sortArray\n */"}
{"signature":"public actual fun < T : Comparable < T > > Array < out T > . sort ( ) : Unit","body":"{ <EOL> if ( size > <NUM_LIT:1> ) sortArray ( this , <NUM_LIT:0> , size ) <EOL> }","docstring":"/**\n * Sorts the array in-place according to the natural order of its elements.\n * \n * The sort is _stable_. It means that equal elements preserve their order relative to each other after sorting.\n * \n * @sample samples.collections.Arrays.Sorting.sortArrayOfComparable\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun < T : Comparable < T > > Array < out T > . sort ( fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit","body":"{ <EOL> AbstractList . checkRangeIndexes ( fromIndex , toIndex , size ) <EOL> sortArray ( this , fromIndex , toIndex ) <EOL> }","docstring":"/**\n * Sorts a range in the array in-place.\n * \n * The sort is _stable_. It means that equal elements preserve their order relative to each other after sorting.\n * \n * @param fromIndex the start of the range (inclusive) to sort, 0 by default.\n * @param toIndex the end of the range (exclusive) to sort, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n * \n * @sample samples.collections.Arrays.Sorting.sortRangeOfArrayOfComparable\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun ByteArray . sort ( fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit","body":"{ <EOL> AbstractList . checkRangeIndexes ( fromIndex , toIndex , size ) <EOL> sortArray ( this , fromIndex , toIndex ) <EOL> }","docstring":"/**\n * Sorts a range in the array in-place.\n * \n * @param fromIndex the start of the range (inclusive) to sort, 0 by default.\n * @param toIndex the end of the range (exclusive) to sort, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n * \n * @sample samples.collections.Arrays.Sorting.sortRangeOfArray\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun ShortArray . sort ( fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit","body":"{ <EOL> AbstractList . checkRangeIndexes ( fromIndex , toIndex , size ) <EOL> sortArray ( this , fromIndex , toIndex ) <EOL> }","docstring":"/**\n * Sorts a range in the array in-place.\n * \n * @param fromIndex the start of the range (inclusive) to sort, 0 by default.\n * @param toIndex the end of the range (exclusive) to sort, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n * \n * @sample samples.collections.Arrays.Sorting.sortRangeOfArray\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun IntArray . sort ( fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit","body":"{ <EOL> AbstractList . checkRangeIndexes ( fromIndex , toIndex , size ) <EOL> sortArray ( this , fromIndex , toIndex ) <EOL> }","docstring":"/**\n * Sorts a range in the array in-place.\n * \n * @param fromIndex the start of the range (inclusive) to sort, 0 by default.\n * @param toIndex the end of the range (exclusive) to sort, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n * \n * @sample samples.collections.Arrays.Sorting.sortRangeOfArray\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun LongArray . sort ( fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit","body":"{ <EOL> AbstractList . checkRangeIndexes ( fromIndex , toIndex , size ) <EOL> sortArray ( this , fromIndex , toIndex ) <EOL> }","docstring":"/**\n * Sorts a range in the array in-place.\n * \n * @param fromIndex the start of the range (inclusive) to sort, 0 by default.\n * @param toIndex the end of the range (exclusive) to sort, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n * \n * @sample samples.collections.Arrays.Sorting.sortRangeOfArray\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun FloatArray . sort ( fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit","body":"{ <EOL> AbstractList . checkRangeIndexes ( fromIndex , toIndex , size ) <EOL> sortArray ( this , fromIndex , toIndex ) <EOL> }","docstring":"/**\n * Sorts a range in the array in-place.\n * \n * @param fromIndex the start of the range (inclusive) to sort, 0 by default.\n * @param toIndex the end of the range (exclusive) to sort, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n * \n * @sample samples.collections.Arrays.Sorting.sortRangeOfArray\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun DoubleArray . sort ( fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit","body":"{ <EOL> AbstractList . checkRangeIndexes ( fromIndex , toIndex , size ) <EOL> sortArray ( this , fromIndex , toIndex ) <EOL> }","docstring":"/**\n * Sorts a range in the array in-place.\n * \n * @param fromIndex the start of the range (inclusive) to sort, 0 by default.\n * @param toIndex the end of the range (exclusive) to sort, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n * \n * @sample samples.collections.Arrays.Sorting.sortRangeOfArray\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun CharArray . sort ( fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit","body":"{ <EOL> AbstractList . checkRangeIndexes ( fromIndex , toIndex , size ) <EOL> sortArray ( this , fromIndex , toIndex ) <EOL> }","docstring":"/**\n * Sorts a range in the array in-place.\n * \n * @param fromIndex the start of the range (inclusive) to sort, 0 by default.\n * @param toIndex the end of the range (exclusive) to sort, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n * \n * @sample samples.collections.Arrays.Sorting.sortRangeOfArray\n */"}
{"signature":"public actual fun < T > Array < out T > . sortWith ( comparator : Comparator < in T > ) : Unit","body":"{ <EOL> if ( size > <NUM_LIT:1> ) sortArrayWith ( this , <NUM_LIT:0> , size , comparator ) <EOL> }","docstring":"/**\n * Sorts the array in-place according to the order specified by the given [comparator].\n * \n * The sort is _stable_. It means that equal elements preserve their order relative to each other after sorting.\n */"}
{"signature":"@ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun < T > Array < out T > . sortWith ( comparator : Comparator < in T > , fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit","body":"{ <EOL> AbstractList . checkRangeIndexes ( fromIndex , toIndex , size ) <EOL> sortArrayWith ( this , fromIndex , toIndex , comparator ) <EOL> }","docstring":"/**\n * Sorts a range in the array in-place with the given [comparator].\n * \n * The sort is _stable_. It means that equal elements preserve their order relative to each other after sorting.\n * \n * @param fromIndex the start of the range (inclusive) to sort, 0 by default.\n * @param toIndex the end of the range (exclusive) to sort, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"}
{"signature":"public actual fun ByteArray . toTypedArray ( ) : Array < Byte >","body":"{ <EOL> return Array ( size ) { index -> this [ index ] } <EOL> }","docstring":"/**\n * Returns a *typed* object array containing all of the elements of this primitive array.\n */"}
{"signature":"public actual fun ShortArray . toTypedArray ( ) : Array < Short >","body":"{ <EOL> return Array ( size ) { index -> this [ index ] } <EOL> }","docstring":"/**\n * Returns a *typed* object array containing all of the elements of this primitive array.\n */"}
{"signature":"public actual fun IntArray . toTypedArray ( ) : Array < Int >","body":"{ <EOL> return Array ( size ) { index -> this [ index ] } <EOL> }","docstring":"/**\n * Returns a *typed* object array containing all of the elements of this primitive array.\n */"}
{"signature":"public actual fun LongArray . toTypedArray ( ) : Array < Long >","body":"{ <EOL> return Array ( size ) { index -> this [ index ] } <EOL> }","docstring":"/**\n * Returns a *typed* object array containing all of the elements of this primitive array.\n */"}
{"signature":"public actual fun FloatArray . toTypedArray ( ) : Array < Float >","body":"{ <EOL> return Array ( size ) { index -> this [ index ] } <EOL> }","docstring":"/**\n * Returns a *typed* object array containing all of the elements of this primitive array.\n */"}
{"signature":"public actual fun DoubleArray . toTypedArray ( ) : Array < Double >","body":"{ <EOL> return Array ( size ) { index -> this [ index ] } <EOL> }","docstring":"/**\n * Returns a *typed* object array containing all of the elements of this primitive array.\n */"}
{"signature":"public actual fun BooleanArray . toTypedArray ( ) : Array < Boolean >","body":"{ <EOL> return Array ( size ) { index -> this [ index ] } <EOL> }","docstring":"/**\n * Returns a *typed* object array containing all of the elements of this primitive array.\n */"}
{"signature":"public actual fun CharArray . toTypedArray ( ) : Array < Char >","body":"{ <EOL> return Array ( size ) { index -> this [ index ] } <EOL> }","docstring":"/**\n * Returns a *typed* object array containing all of the elements of this primitive array.\n */"}
{"signature":"fun remember ( from : KotlinSourceSet , to : KotlinSourceSet )","body":"{ <EOL> if ( dontRemember ) return <EOL> rememberedEdges . add ( from to to ) <EOL> }","docstring":"/** Should be called from [KotlinSourceSet.dependsOn] method,\n * so depends on edges are tracked and can be distinguished when they added via [addDependsOnEdgeFromTemplate] */"}
{"signature":"private fun tryExpandExpectNestedClassActualizedViaTypealias ( expectNestedClassType : ConeClassLikeType , expectNestedClassSymbol : FirRegularClassSymbol , ) : ConeClassLikeType ?","body":"{ <EOL> val expectNestedClassId = expectNestedClassSymbol . classId <EOL> val expectOutermostClassId = expectNestedClassId . outermostClassId <EOL> val actualTypealiasSymbol = expectOutermostClassId . toSymbol ( actualSession ) as? FirTypeAliasSymbol ? : return null <EOL> val actualOutermostClassId = actualTypealiasSymbol . fullyExpandedClass ( actualSession ) ? . classId ? : return null <EOL> val actualNestedClassId = ClassId . fromString ( expectNestedClassId . asString ( ) . replaceFirst ( expectOutermostClassId . asString ( ) , actualOutermostClassId . asString ( ) ) ) <EOL> return actualNestedClassId . constructClassLikeType ( expectNestedClassType . typeArguments , expectNestedClassType . isNullable , expectNestedClassType . attributes ) <EOL> }","docstring":"/**\n * In case of `expect` nested classes actualized via typealias we can't simply find actual symbol by `expect` `ClassId`\n * (like we do for top-level classes), because `ClassId` is different.\n * For example, `expect` class `com/example/ExpectClass.Nested` may have actual with id `real/package/ActualTypeliasTarget.Nested`.\n * So, we first expand outermost class, and then construct `ClassId` for nested class.\n */"}
{"signature":"fun foo ( p : Int , p2 : Double ) : Short","body":"= <NUM_LIT:1>","docstring":"/**\n * Function foo description\n *\n * @param p first Integer to consume\n * @param p2 second Double to consume\n * @return Short, constant 1\n */"}
{"signature":"@ Test <EOL> fun sample ( )","body":"{ <EOL> val testProject = mixedJvmTestProject { <EOL> dokkaConfiguration { <EOL> moduleName = \"<STR_LIT>\" <EOL> jvmSourceSet { <EOL> } <EOL> } <EOL> kotlinSourceDirectory { <EOL> ktFile ( pathFromSrc = \"<STR_LIT>\" ) { <EOL> + \"<STR_LIT>\" <EOL> } <EOL> javaFile ( pathFromSrc = \"<STR_LIT>\" ) { <EOL> + \"\"\"<STR_LIT>\"\"\" <EOL> } <EOL> } <EOL> javaSourceDirectory { <EOL> ktFile ( pathFromSrc = \"<STR_LIT>\" ) { <EOL> + \"<STR_LIT>\" <EOL> } <EOL> javaFile ( pathFromSrc = \"<STR_LIT>\" ) { <EOL> + \"\"\"<STR_LIT>\"\"\" <EOL> } <EOL> } <EOL> } <EOL> val module = testProject . parse ( ) <EOL> assertEquals ( \"<STR_LIT>\" , module . name ) <EOL> assertEquals ( <NUM_LIT:1> , module . packages . size ) <EOL> val pckg = module . packages [ <NUM_LIT:0> ] <EOL> assertEquals ( \"<STR_LIT:test>\" , pckg . name ) <EOL> assertEquals ( <NUM_LIT:2> , pckg . classlikes . size ) <EOL> assertEquals ( <NUM_LIT:2> , pckg . functions . size ) <EOL> val firstClasslike = pckg . classlikes [ <NUM_LIT:0> ] <EOL> assertEquals ( \"<STR_LIT>\" , firstClasslike . name ) <EOL> val secondClasslike = pckg . classlikes [ <NUM_LIT:1> ] <EOL> assertEquals ( \"<STR_LIT>\" , secondClasslike . name ) <EOL> val functions = pckg . functions . sortedBy { it . name } <EOL> val firstFunction = functions [ <NUM_LIT:0> ] <EOL> assertEquals ( \"<STR_LIT:bar>\" , firstFunction . name ) <EOL> val secondFunction = functions [ <NUM_LIT:1> ] <EOL> assertEquals ( \"<STR_LIT:foo>\" , secondFunction . name ) <EOL> }","docstring":"/**\n * Used as a sample for [mixedJvmTestProject]\n */"}
{"signature":"fun < T > DataStreamWriter < T > . forEachBatch ( func : ( batch : Dataset < T > , batchId : Long ) -> Unit , ) : DataStreamWriter < T >","body":"= foreachBatch ( VoidFunction2 ( func ) )","docstring":"/**\n * :: Experimental ::\n *\n * (Scala-specific) Sets the output of the streaming query to be processed using the provided\n * function. This is supported only in the micro-batch execution modes (that is, when the\n * trigger is not continuous). In every micro-batch, the provided function will be called in\n * every micro-batch with (i) the output rows as a Dataset and (ii) the batch identifier.\n * The batchId can be used to deduplicate and transactionally write the output\n * (that is, the provided Dataset) to external systems. The output Dataset is guaranteed\n * to be exactly the same for the same batchId (assuming all operations are deterministic\n * in the query).\n *\n * @since 2.4.0\n */"}
{"signature":"public suspend fun < T > runInterruptible ( context : CoroutineContext = EmptyCoroutineContext , block : ( ) -> T ) : T","body":"= withContext ( context ) { <EOL> runInterruptibleInExpectedContext ( coroutineContext , block ) <EOL> }","docstring":"/**\n * Calls the specified [block] with a given coroutine context in\n * [an interruptible manner](https://docs.oracle.com/javase/tutorial/essential/concurrency/interrupt.html).\n * The blocking code block will be interrupted and this function will throw [CancellationException]\n * if the coroutine is cancelled.\n *\n * Example:\n *\n * ```\n * withTimeout(500L) { // Cancels coroutine on timeout\n * runInterruptible { // Throws CancellationException if interrupted\n * doSomethingBlocking() // Interrupted on coroutines cancellation\n * }\n * }\n * ```\n *\n * There is an optional [context] parameter to this function working just like [withContext].\n * It enables single-call conversion of interruptible Java methods into suspending functions.\n * With one call here we are moving the call to [Dispatchers.IO] and supporting interruption:\n *\n * ```\n * suspend fun <T> BlockingQueue<T>.awaitTake(): T =\n * runInterruptible(Dispatchers.IO) { queue.take() }\n * ```\n *\n * `runInterruptible` uses [withContext] as an underlying mechanism for switching context,\n * meaning that the supplied [block] is invoked in an [undispatched][CoroutineStart.UNDISPATCHED]\n * manner directly by the caller if [CoroutineDispatcher] from the current [coroutineContext][currentCoroutineContext]\n * is the same as the one supplied in [context].\n */"}
{"signature":"public fun < T > xBegin ( column : ColumnReference < T > ) : PositionalMapping < T >","body":"{ <EOL> return addPositionalMapping < T > ( X_BEGIN , column . name ( ) , null ) <EOL> }","docstring":"/**\n * Maps the `xBegin` aesthetic to a data column by [ColumnReference].\n *\n * @param column the data column to be mapped.\n * @return a [PositionalMapping] object representing the mapping.\n */"}
{"signature":"public fun < T > xBegin ( column : KProperty < T > ) : PositionalMapping < T >","body":"{ <EOL> return addPositionalMapping < T > ( X_BEGIN , column . name , null ) <EOL> }","docstring":"/**\n * Maps the `xBegin` aesthetic to a data column by [KProperty].\n *\n * @param column the data column to be mapped.\n * @return a [PositionalMapping] object representing the mapping.\n */"}
{"signature":"public fun xBegin ( column : String ) : PositionalMapping < Any ? >","body":"{ <EOL> return addPositionalMapping ( X_BEGIN , column , null ) <EOL> }","docstring":"/**\n * Maps the `xBegin` aesthetic to a data column by [String].\n *\n * @param column the data column to be mapped.\n * @return a [PositionalMapping] object representing the mapping.\n */"}
{"signature":"public fun < T > xBegin ( values : Iterable < T > ) : PositionalMapping < T >","body":"{ <EOL> return addPositionalMapping < T > ( X_BEGIN , values . toList ( ) , null , null ) <EOL> }","docstring":"/**\n * Maps the `xBegin` aesthetic to iterable of values.\n *\n * @param values the iterable of values to be mapped.\n * @return a [PositionalMapping] object representing the mapping.\n */"}
{"signature":"public fun < T > xBegin ( values : DataColumn < T > ) : PositionalMapping < T >","body":"{ <EOL> return addPositionalMapping < T > ( X_BEGIN , values , null ) <EOL> }","docstring":"/**\n * Maps the `xBegin` aesthetic to a data column.\n *\n * @param values the data column to be mapped.\n * @return a [PositionalMapping] object representing the mapping.\n */"}
{"signature":"public fun getLabel ( dataSource : D ) : Float","body":"public fun getLabel ( dataSource : D ) : Float","docstring":"/**\n * Returns a label for provided [dataSource].\n */"}
{"signature":"fun List < FirAnnotation > . computeTypeAttributes ( session : FirSession , predefined : List < ConeAttribute < * > > = emptyList ( ) , allowExtensionFunctionType : Boolean = true , shouldExpandTypeAliases : Boolean ) : ConeAttributes","body":"{ <EOL> if ( this . isEmpty ( ) ) { <EOL> if ( predefined . isEmpty ( ) ) return ConeAttributes . Empty <EOL> return ConeAttributes . create ( predefined ) <EOL> } <EOL> val attributes = mutableListOf < ConeAttribute < * > > ( ) <EOL> attributes += predefined <EOL> val customAnnotations = mutableListOf < FirAnnotation > ( ) <EOL> for ( annotation in this ) { <EOL> val classId = when ( shouldExpandTypeAliases ) { <EOL> true -> annotation . tryExpandClassId ( session ) <EOL> false -> annotation . resolvedType . classId <EOL> } <EOL> when ( classId ) { <EOL> CompilerConeAttributes . Exact . ANNOTATION_CLASS_ID -> attributes += CompilerConeAttributes . Exact <EOL> CompilerConeAttributes . NoInfer . ANNOTATION_CLASS_ID -> attributes += CompilerConeAttributes . NoInfer <EOL> CompilerConeAttributes . ExtensionFunctionType . ANNOTATION_CLASS_ID -> when { <EOL> allowExtensionFunctionType -> attributes += CompilerConeAttributes . ExtensionFunctionType <EOL> } <EOL> CompilerConeAttributes . ContextFunctionTypeParams . ANNOTATION_CLASS_ID -> <EOL> attributes += <EOL> CompilerConeAttributes . ContextFunctionTypeParams ( annotation . extractContextReceiversCount ( ) ? : <NUM_LIT:0> ) <EOL> CompilerConeAttributes . UnsafeVariance . ANNOTATION_CLASS_ID -> attributes += CompilerConeAttributes . UnsafeVariance <EOL> else -> { <EOL> val attributeFromPlugin = session . extensionService . typeAttributeExtensions . firstNotNullOfOrNull { <EOL> it . extractAttributeFromAnnotation ( annotation ) <EOL> } <EOL> if ( attributeFromPlugin != null ) { <EOL> attributes += attributeFromPlugin <EOL> } else { <EOL> customAnnotations += annotation <EOL> } <EOL> } <EOL> } <EOL> } <EOL> if ( customAnnotations . isNotEmpty ( ) ) { <EOL> attributes += CustomAnnotationTypeAttribute ( customAnnotations ) <EOL> } <EOL> return ConeAttributes . create ( attributes ) <EOL> }","docstring":"/**\n * [shouldExpandTypeAliases] should be set to `false` if this function is called during deserialization of some binary declaration\n * For details see KT-57876\n */"}
{"signature":"@ ExperimentalKotlinGradlePluginApi <EOL> fun compilerOptions ( configure : CO . ( ) -> Unit )","body":"{ <EOL> configure ( compilerOptions ) <EOL> }","docstring":"/**\n * Configures the [compilerOptions] with the provided configuration.\n */"}
{"signature":"@ ExperimentalKotlinGradlePluginApi <EOL> fun compilerOptions ( configure : Action < CO > )","body":"{ <EOL> configure . execute ( compilerOptions ) <EOL> }","docstring":"/**\n * Configures the [compilerOptions] with the provided configuration.\n */"}
{"signature":"@ TestOnly <EOL> public abstract fun publishGlobalModuleStateModification ( )","body":"@ TestOnly <EOL> public abstract fun publishGlobalModuleStateModification ( )","docstring":"/**\n * Publishes an event of global modification of the module state of all [KtModule]s.\n */"}
{"signature":"@ TestOnly <EOL> public abstract fun publishGlobalSourceModuleStateModification ( )","body":"@ TestOnly <EOL> public abstract fun publishGlobalSourceModuleStateModification ( )","docstring":"/**\n * Publishes an event of global modification of the module state of all source [KtModule]s.\n */"}
{"signature":"@ TestOnly <EOL> public abstract fun publishGlobalSourceOutOfBlockModification ( )","body":"@ TestOnly <EOL> public abstract fun publishGlobalSourceOutOfBlockModification ( )","docstring":"/**\n * Publishes an event of global out-of-block modification of all source [KtModule]s. The event does not invalidate module state like\n * [publishGlobalSourceModuleStateModification], so some module structure-specific caches might persist.\n */"}
{"signature":"public fun isOpenApiStr ( text : String ) : Boolean","body":"= try { <EOL> val parsed = OpenAPIParser ( ) . readContents ( text , null , null ) <EOL> parsed . openAPI ? . components ? . schemas != null <EOL> } catch ( e : Throwable ) { <EOL> logger . debug ( e ) { \"<STR_LIT>\" } <EOL> false <EOL> }","docstring":"/** Needs to have any type schemas to convert. */"}
{"signature":"public abstract fun getKtFiles ( ) : List < KtResolveExtensionFile >","body":"public abstract fun getKtFiles ( ) : List < KtResolveExtensionFile >","docstring":"/**\n * Get the list of files that should be generated for the module. Returned files should contain valid Kotlin code.\n *\n * If the content of these files becomes invalid (e.g., because the source declarations they were based on changed), the\n * [KtResolveExtension] must publish an out-of-block modification event via the Analysis API message bus:\n * [org.jetbrains.kotlin.analysis.providers.topics.KotlinTopics.MODULE_OUT_OF_BLOCK_MODIFICATION].\n *\n * To react to changes in Kotlin sources, [KtResolveExtension] may subscribe to Analysis API topics:\n * [org.jetbrains.kotlin.analysis.providers.topics.KotlinTopics]. If the [KtResolveExtension] both subscribes to and\n * publishes modification events, care needs to be taken that no cycles are introduced. In general, the [KtResolveExtension] should\n * never publish an event for a module A in a listener for the same module A.\n *\n * An out-of-block modification event for the [KtResolveExtension]'s associated module does not need to be published in response to an\n * out-of-block modification event for the same module, because the original event suffices for invalidation.\n *\n * @see KtResolveExtensionFile\n * @see KtResolveExtension\n */"}
{"signature":"public abstract fun getContainedPackages ( ) : Set < FqName >","body":"public abstract fun getContainedPackages ( ) : Set < FqName >","docstring":"/**\n * Returns the set of packages that are contained in the files provided by [getKtFiles].\n *\n * The returned package set should be a strict set of all file packages,\n * so `for-all pckg: pckg in getContainedPackages() <=> exists file: file in getKtFiles() && file.getFilePackageName() == pckg`\n *\n * @see KtResolveExtension\n */"}
{"signature":"public open fun getShadowedScope ( ) : GlobalSearchScope","body":"= GlobalSearchScope . EMPTY_SCOPE","docstring":"/**\n * Returns the scope of files that should be shadowed by the files provided by [getKtFiles].\n *\n * Any files in the module that are included in this scope will be removed from analysis results. This allows the files provided by\n * [getKtFiles] to cleanly replace those files from the module.\n *\n * If this resolve extension is being used to generate declarations that would normally be provided by sources generated by an external\n * build task, such as a resource compiler or annotation processor, the resolve extension should provide a scope here that covers those\n * externally generated sources. This will prevent collisions between the definitions provided by [getKtFiles] and those provided by the\n * (potentially stale) externally generated sources.\n */"}
{"signature":"@ kotlin . internal . InlineOnly <EOL> public inline fun < T > Lock . withLock ( action : ( ) -> T ) : T","body":"{ <EOL> contract { callsInPlace ( action , InvocationKind . EXACTLY_ONCE ) } <EOL> lock ( ) <EOL> try { <EOL> return action ( ) <EOL> } finally { <EOL> unlock ( ) <EOL> } <EOL> }","docstring":"/**\n * Executes the given [action] under this lock.\n * @return the return value of the action.\n */"}
{"signature":"@ kotlin . internal . InlineOnly <EOL> public inline fun < T > ReentrantReadWriteLock . read ( action : ( ) -> T ) : T","body":"{ <EOL> contract { callsInPlace ( action , InvocationKind . EXACTLY_ONCE ) } <EOL> val rl = readLock ( ) <EOL> rl . lock ( ) <EOL> try { <EOL> return action ( ) <EOL> } finally { <EOL> rl . unlock ( ) <EOL> } <EOL> }","docstring":"/**\n * Executes the given [action] under the read lock of this lock.\n * @return the return value of the action.\n */"}
{"signature":"@ kotlin . internal . InlineOnly <EOL> public inline fun < T > ReentrantReadWriteLock . write ( action : ( ) -> T ) : T","body":"{ <EOL> contract { callsInPlace ( action , InvocationKind . EXACTLY_ONCE ) } <EOL> val rl = readLock ( ) <EOL> val readCount = if ( writeHoldCount == <NUM_LIT:0> ) readHoldCount else <NUM_LIT:0> <EOL> repeat ( readCount ) { rl . unlock ( ) } <EOL> val wl = writeLock ( ) <EOL> wl . lock ( ) <EOL> try { <EOL> return action ( ) <EOL> } finally { <EOL> repeat ( readCount ) { rl . lock ( ) } <EOL> wl . unlock ( ) <EOL> } <EOL> }","docstring":"/**\n * Executes the given [action] under the write lock of this lock.\n *\n * The function does upgrade from read to write lock if needed, but this upgrade is not atomic\n * as such upgrade is not supported by [ReentrantReadWriteLock].\n * In order to do such upgrade this function first releases all read locks held by this thread,\n * then acquires write lock, and after releasing it acquires read locks back again.\n *\n * Therefore if the [action] inside write lock has been initiated by checking some condition,\n * the condition must be rechecked inside the [action] to avoid possible races.\n *\n * @return the return value of the action.\n */"}
{"signature":"public abstract fun hasAnnotation ( classId : ClassId , useSiteTargetFilter : AnnotationUseSiteTargetFilter = AnyAnnotationUseSiteTargetFilter , ) : Boolean","body":"public abstract fun hasAnnotation ( classId : ClassId , useSiteTargetFilter : AnnotationUseSiteTargetFilter = AnyAnnotationUseSiteTargetFilter , ) : Boolean","docstring":"/**\n * Checks if entity contains annotation with specified [classId] and filtered by [useSiteTargetFilter].\n *\n * The semantic is equivalent to\n * ```\n * annotationsList.hasAnnotation(classId, useSiteTargetFilter) == annotationsList.annotations.any {\n * it.classId == classId && useSiteTargetFilter.isAllowed(it.useSiteTarget)\n * }\n * ```\n * @param classId [ClassId] to search\n * @param useSiteTargetFilter specific [AnnotationUseSiteTargetFilter]\n */"}
{"signature":"public abstract fun annotationsByClassId ( classId : ClassId , useSiteTargetFilter : AnnotationUseSiteTargetFilter = AnyAnnotationUseSiteTargetFilter , ) : List < KtAnnotationApplicationWithArgumentsInfo >","body":"public abstract fun annotationsByClassId ( classId : ClassId , useSiteTargetFilter : AnnotationUseSiteTargetFilter = AnyAnnotationUseSiteTargetFilter , ) : List < KtAnnotationApplicationWithArgumentsInfo >","docstring":"/**\n * A list of annotations applied with specified [classId] and filtered by [useSiteTargetFilter].\n *\n * To check if annotation is present, please use [hasAnnotation].\n *\n * The semantic is equivalent to\n * ```\n * annotationsList.annotationsByClassId(classId) == annotationsList.annotations.filter {\n * it.classId == classId && useSiteTargetFilter.isAllowed(it.useSiteTarget)\n * }\n * ```\n *\n * @see KtAnnotationApplicationWithArgumentsInfo\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> @ Suppress ( \"<STR_LIT:FunctionName>\" , \"<STR_LIT>\" ) <EOL> public expect fun CancellationException ( message : String ? , cause : Throwable ? ) : CancellationException","body":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> @ Suppress ( \"<STR_LIT:FunctionName>\" , \"<STR_LIT>\" ) <EOL> public expect fun CancellationException ( message : String ? , cause : Throwable ? ) : CancellationException","docstring":"/**\n * Creates an instance of [CancellationException] with the given [message] and [cause].\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> @ Suppress ( \"<STR_LIT:FunctionName>\" , \"<STR_LIT>\" ) <EOL> public expect fun CancellationException ( cause : Throwable ? ) : CancellationException","body":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> @ Suppress ( \"<STR_LIT:FunctionName>\" , \"<STR_LIT>\" ) <EOL> public expect fun CancellationException ( cause : Throwable ? ) : CancellationException","docstring":"/**\n * Creates an instance of [CancellationException] with the given [cause].\n */"}
{"signature":"public fun map ( mapping : ( Float , Float ) -> Pair < Float , Float > ) : T","body":"public fun map ( mapping : ( Float , Float ) -> Pair < Float , Float > ) : T","docstring":"/**\n * Creates a new geometric shape of the same type by applying the provided [mapping]\n * to the coordinates of the current shape.\n */"}
{"signature":"public fun KtDeclarationSymbol . render ( renderer : KtDeclarationRenderer = KtDeclarationRendererForSource . WITH_QUALIFIED_NAMES ) : String","body":"= <EOL> withValidityAssertion { analysisSession . symbolDeclarationRendererProvider . renderDeclaration ( this , renderer ) }","docstring":"/**\n * Render symbol into the representable Kotlin string\n */"}
{"signature":"public fun KtType . render ( renderer : KtTypeRenderer = KtTypeRendererForSource . WITH_QUALIFIED_NAMES , position : Variance , ) : String","body":"= <EOL> withValidityAssertion { analysisSession . symbolDeclarationRendererProvider . renderType ( this , renderer , position ) }","docstring":"/**\n * Render kotlin type into the representable Kotlin type string\n */"}
{"signature":"public fun < C > String . colsOf ( type : KType , filter : ColumnFilter < C > = { true } , ) : ColumnSet < * >","body":"= columnGroup ( this ) . colsOf ( type , filter )","docstring":"/**\n * @include [CommonColsOfDocs]\n *\n * `df.`[select][DataFrame.select]` { \"myColumnGroup\".`[colsOf][String.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }`\n *\n * `df.`[select][DataFrame.select]` { \"myColumnGroup\".`[colsOf][String.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][DataColumn]`<`[Int][Int]`> -> it.`[size][DataColumn.size]` > 10 } }`\n *\n * @include [CommonColsOfDocs.FilterParam]\n * @include [CommonColsOfDocs.Return]\n */"}
{"signature":"public fun < C > KProperty < * > . colsOf ( type : KType , filter : ColumnFilter < C > = { true } , ) : ColumnSet < * >","body":"= columnGroup ( this ) . colsOf ( type , filter )","docstring":"/**\n * @include [CommonColsOfDocs]\n *\n * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[colsOf][KProperty.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }`\n *\n * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[colsOf][KProperty.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][DataColumn]`<`[Int][Int]`> -> it.`[size][DataColumn.size]` > 10 } }`\n *\n * @include [CommonColsOfDocs.FilterParam]\n * @include [CommonColsOfDocs.Return]\n */"}
{"signature":"public fun < C > ColumnPath . colsOf ( type : KType , filter : ColumnFilter < C > = { true } , ) : ColumnSet < * >","body":"= columnGroup ( this ) . colsOf ( type , filter )","docstring":"/**\n * @include [CommonColsOfDocs]\n *\n * `df.`[select][DataFrame.select]` { \"pathTo\"[\"myColumnGroup\"].`[colsOf][ColumnPath.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }`\n *\n * `df.`[select][DataFrame.select]` { \"pathTo\"[\"myColumnGroup\"].`[colsOf][ColumnPath.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][DataColumn]`<`[Int][Int]`> -> it.`[size][DataColumn.size]` > 10 } }`\n *\n * @include [CommonColsOfDocs.FilterParam]\n * @include [CommonColsOfDocs.Return]\n */"}
{"signature":"public fun < C > ColumnSet < * > . colsOf ( type : KType , filter : ColumnFilter < C > = { true } , ) : TransformableColumnSet < C >","body":"= colsOfInternal ( type , filter )","docstring":"/**\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs]\n *\n * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[colsOf][ColumnSet.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }`\n *\n * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[colsOf][ColumnSet.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][DataColumn]`<`[Int][Int]`> -> it.`[size][DataColumn.size]` > 10 } }`\n *\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.FilterParam]\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.Return]\n */"}
{"signature":"public inline fun < reified C > ColumnSet < * > . colsOf ( noinline filter : ColumnFilter < C > = { true } , ) : TransformableColumnSet < C >","body":"= colsOf ( typeOf < C > ( ) , filter )","docstring":"/**\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs]\n *\n * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[colsOf][ColumnSet.colsOf]`<`[Int][Int]`>() }`\n *\n * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[colsOf][ColumnSet.colsOf]`<`[Int][Int]`> { it.`[size][DataColumn.size]` > 10 } }`\n *\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.FilterParam]\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.Return]\n */"}
{"signature":"public fun < C > ColumnsSelectionDsl < * > . colsOf ( type : KType , filter : ColumnFilter < C > = { true } , ) : TransformableColumnSet < C >","body":"= asSingleColumn ( ) . colsOf ( type , filter )","docstring":"/**\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs]\n *\n * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }`\n *\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.FilterParam]\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.Return]\n */"}
{"signature":"public inline fun < reified C > ColumnsSelectionDsl < * > . colsOf ( noinline filter : ColumnFilter < C > = { true } , ) : TransformableColumnSet < C >","body":"= asSingleColumn ( ) . colsOf ( typeOf < C > ( ) , filter )","docstring":"/**\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs]\n *\n * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>() }`\n *\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.FilterParam]\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.Return]\n */"}
{"signature":"public fun < C > SingleColumn < DataRow < * > > . colsOf ( type : KType , filter : ColumnFilter < C > = { true } , ) : TransformableColumnSet < C >","body":"= ensureIsColumnGroup ( ) . colsOfInternal ( type , filter )","docstring":"/**\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs]\n *\n * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][DataColumn]`<`[Int][Int]`> -> it.`[size][DataColumn.size]` > 10 } }`\n *\n * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) }`\n *\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.FilterParam]\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.Return]\n */"}
{"signature":"public inline fun < reified C > SingleColumn < DataRow < * > > . colsOf ( noinline filter : ColumnFilter < C > = { true } , ) : TransformableColumnSet < C >","body":"= colsOf ( typeOf < C > ( ) , filter )","docstring":"/**\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs]\n *\n * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][SingleColumn.colsOf]`<`[Int][Int]`> { it.`[size][DataColumn.size]` > 10 } }`\n *\n * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>() }`\n *\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.FilterParam]\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.Return]\n */"}
{"signature":"@ Suppress ( \"<STR_LIT:UNCHECKED_CAST>\" ) <EOL> internal fun < C > ColumnsResolver < * > . colsOfInternal ( type : KType , filter : ColumnFilter < C > , ) : TransformableColumnSet < C >","body":"= <EOL> colsInternal { <EOL> it . isSubtypeOf ( type ) && filter ( it . cast ( ) ) <EOL> } as TransformableColumnSet < C >","docstring":"/**\n * If this [ColumnsResolver] is a [SingleColumn], it\n * returns a new [ColumnSet] containing the columns inside of this [SingleColumn] that\n * match the given [filter] and are the given [type].\n *\n * Else, it returns a new [ColumnSet] containing all columns in this [ColumnsResolver] that\n * match the given [filter] and are the given [type].\n */"}
{"signature":"public fun run ( )","body":"public fun run ( )","docstring":"/**\n * @suppress\n */"}
{"signature":"@ Suppress ( \"<STR_LIT:FunctionName>\" ) <EOL> public expect inline fun Runnable ( crossinline block : ( ) -> Unit ) : Runnable","body":"@ Suppress ( \"<STR_LIT:FunctionName>\" ) <EOL> public expect inline fun Runnable ( crossinline block : ( ) -> Unit ) : Runnable","docstring":"/**\n * Creates [Runnable] task instance.\n */"}
{"signature":"internal fun interpretUnaryFunction ( name : String , type : String , a : Any ? ) : Any ?","body":"{ <EOL> when ( name ) { <EOL> \"<STR_LIT:hashCode>\" -> when ( type ) { <EOL> \"<STR_LIT>\" -> return ( a as Boolean ) . hashCode ( ) <EOL> \"<STR_LIT>\" -> return ( a as Char ) . hashCode ( ) <EOL> \"<STR_LIT:kotlin.Byte>\" -> return ( a as Byte ) . hashCode ( ) <EOL> \"<STR_LIT:kotlin.Short>\" -> return ( a as Short ) . hashCode ( ) <EOL> \"<STR_LIT:kotlin.Int>\" -> return ( a as Int ) . hashCode ( ) <EOL> \"<STR_LIT>\" -> return ( a as Float ) . hashCode ( ) <EOL> \"<STR_LIT:kotlin.Long>\" -> return ( a as Long ) . hashCode ( ) <EOL> \"<STR_LIT>\" -> return ( a as Double ) . hashCode ( ) <EOL> \"<STR_LIT:kotlin.String>\" -> return ( a as String ) . hashCode ( ) <EOL> \"<STR_LIT:kotlin.Any>\" -> return ( a as Any ) . hashCode ( ) <EOL> } <EOL> \"<STR_LIT>\" -> when ( type ) { <EOL> \"<STR_LIT>\" -> return ( a as Boolean ) . not ( ) <EOL> } <EOL> \"<STR_LIT:toString>\" -> when ( type ) { <EOL> \"<STR_LIT>\" -> return ( a as Boolean ) . toString ( ) <EOL> \"<STR_LIT>\" -> return ( a as Char ) . toString ( ) <EOL> \"<STR_LIT:kotlin.Byte>\" -> return ( a as Byte ) . toString ( ) <EOL> \"<STR_LIT:kotlin.Short>\" -> return ( a as Short ) . toString ( ) <EOL> \"<STR_LIT:kotlin.Int>\" -> return ( a as Int ) . toString ( ) <EOL> \"<STR_LIT>\" -> return ( a as Float ) . toString ( ) <EOL> \"<STR_LIT:kotlin.Long>\" -> return ( a as Long ) . toString ( ) <EOL> \"<STR_LIT>\" -> return ( a as Double ) . toString ( ) <EOL> \"<STR_LIT:kotlin.String>\" -> return ( a as String ) . toString ( ) <EOL> \"<STR_LIT:kotlin.Any>\" -> return ( a as Any ) . toString ( ) <EOL> \"<STR_LIT:kotlin.Any?>\" -> return a ? . toString ( ) ? : \"<STR_LIT:null>\" <EOL> \"<STR_LIT>\" -> return Unit . toString ( ) <EOL> } <EOL> \"<STR_LIT>\" -> when ( type ) { <EOL> \"<STR_LIT>\" -> return ( a as Char ) . dec ( ) <EOL> \"<STR_LIT:kotlin.Byte>\" -> return ( a as Byte ) . dec ( ) <EOL> \"<STR_LIT:kotlin.Short>\" -> return ( a as Short ) . dec ( ) <EOL> \"<STR_LIT:kotlin.Int>\" -> return ( a as Int ) . dec ( ) <EOL> \"<STR_LIT>\" -> return ( a as Float ) . dec ( ) <EOL> \"<STR_LIT:kotlin.Long>\" -> return ( a as Long ) . dec ( ) <EOL> \"<STR_LIT>\" -> return ( a as Double ) . dec ( ) <EOL> } <EOL> \"<STR_LIT>\" -> when ( type ) { <EOL> \"<STR_LIT>\" -> return ( a as Char ) . inc ( ) <EOL> \"<STR_LIT:kotlin.Byte>\" -> return ( a as Byte ) . inc ( ) <EOL> \"<STR_LIT:kotlin.Short>\" -> return ( a as Short ) . inc ( ) <EOL> \"<STR_LIT:kotlin.Int>\" -> return ( a as Int ) . inc ( ) <EOL> \"<STR_LIT>\" -> return ( a as Float ) . inc ( ) <EOL> \"<STR_LIT:kotlin.Long>\" -> return ( a as Long ) . inc ( ) <EOL> \"<STR_LIT>\" -> return ( a as Double ) . inc ( ) <EOL> } <EOL> \"<STR_LIT>\" -> when ( type ) { <EOL> \"<STR_LIT>\" -> return ( a as Char ) . toByte ( ) <EOL> \"<STR_LIT:kotlin.Byte>\" -> return ( a as Byte ) . toByte ( ) <EOL> \"<STR_LIT:kotlin.Short>\" -> return ( a as Short ) . toByte ( ) <EOL> \"<STR_LIT:kotlin.Int>\" -> return ( a as Int ) . toByte ( ) <EOL> \"<STR_LIT>\" -> return ( a as Float ) . toByte ( ) <EOL> \"<STR_LIT:kotlin.Long>\" -> return ( a as Long ) . toByte ( ) <EOL> \"<STR_LIT>\" -> return ( a as Double ) . toByte ( ) <EOL> \"<STR_LIT>\" -> return ( a as Number ) . toByte ( ) <EOL> } <EOL> \"<STR_LIT>\" -> when ( type ) { <EOL> \"<STR_LIT>\" -> return ( a as Char ) . toChar ( ) <EOL> \"<STR_LIT:kotlin.Byte>\" -> return ( a as Byte ) . toChar ( ) <EOL> \"<STR_LIT:kotlin.Short>\" -> return ( a as Short ) . toChar ( ) <EOL> \"<STR_LIT:kotlin.Int>\" -> return ( a as Int ) . toChar ( ) <EOL> \"<STR_LIT>\" -> return ( a as Float ) . toChar ( ) <EOL> \"<STR_LIT:kotlin.Long>\" -> return ( a as Long ) . toChar ( ) <EOL> \"<STR_LIT>\" -> return ( a as Double ) . toChar ( ) <EOL> \"<STR_LIT>\" -> return ( a as Number ) . toChar ( ) <EOL> } <EOL> \"<STR_LIT>\" -> when ( type ) { <EOL> \"<STR_LIT>\" -> return ( a as Char ) . toDouble ( ) <EOL> \"<STR_LIT:kotlin.Byte>\" -> return ( a as Byte ) . toDouble ( ) <EOL> \"<STR_LIT:kotlin.Short>\" -> return ( a as Short ) . toDouble ( ) <EOL> \"<STR_LIT:kotlin.Int>\" -> return ( a as Int ) . toDouble ( ) <EOL> \"<STR_LIT>\" -> return ( a as Float ) . toDouble ( ) <EOL> \"<STR_LIT:kotlin.Long>\" -> return ( a as Long ) . toDouble ( ) <EOL> \"<STR_LIT>\" -> return ( a as Double ) . toDouble ( ) <EOL> \"<STR_LIT>\" -> return ( a as Number ) . toDouble ( ) <EOL> } <EOL> \"<STR_LIT>\" -> when ( type ) { <EOL> \"<STR_LIT>\" -> return ( a as Char ) . toFloat ( ) <EOL> \"<STR_LIT:kotlin.Byte>\" -> return ( a as Byte ) . toFloat ( ) <EOL> \"<STR_LIT:kotlin.Short>\" -> return ( a as Short ) . toFloat ( ) <EOL> \"<STR_LIT:kotlin.Int>\" -> return ( a as Int ) . toFloat ( ) <EOL> \"<STR_LIT>\" -> return ( a as Float ) . toFloat ( ) <EOL> \"<STR_LIT:kotlin.Long>\" -> return ( a as Long ) . toFloat ( ) <EOL> \"<STR_LIT>\" -> return ( a as Double ) . toFloat ( ) <EOL> \"<STR_LIT>\" -> return ( a as Number ) . toFloat ( ) <EOL> } <EOL> \"<STR_LIT>\" -> when ( type ) { <EOL> \"<STR_LIT>\" -> return ( a as Char ) . toInt ( ) <EOL> \"<STR_LIT:kotlin.Byte>\" -> return ( a as Byte ) . toInt ( ) <EOL> \"<STR_LIT:kotlin.Short>\" -> return ( a as Short ) . toInt ( ) <EOL> \"<STR_LIT:kotlin.Int>\" -> return ( a as Int ) . toInt ( ) <EOL> \"<STR_LIT>\" -> return ( a as Float ) . toInt ( ) <EOL> \"<STR_LIT:kotlin.Long>\" -> return ( a as Long ) . toInt ( ) <EOL> \"<STR_LIT>\" -> return ( a as Double ) . toInt ( ) <EOL> \"<STR_LIT>\" -> return ( a as Number ) . toInt ( ) <EOL> } <EOL> \"<STR_LIT>\" -> when ( type ) { <EOL> \"<STR_LIT>\" -> return ( a as Char ) . toLong ( ) <EOL> \"<STR_LIT:kotlin.Byte>\" -> return ( a as Byte ) . toLong ( ) <EOL> \"<STR_LIT:kotlin.Short>\" -> return ( a as Short ) . toLong ( ) <EOL> \"<STR_LIT:kotlin.Int>\" -> return ( a as Int ) . toLong ( ) <EOL> \"<STR_LIT>\" -> return ( a as Float ) . toLong ( ) <EOL> \"<STR_LIT:kotlin.Long>\" -> return ( a as Long ) . toLong ( ) <EOL> \"<STR_LIT>\" -> return ( a as Double ) . toLong ( ) <EOL> \"<STR_LIT>\" -> return ( a as Number ) . toLong ( ) <EOL> } <EOL> \"<STR_LIT>\" -> when ( type ) { <EOL> \"<STR_LIT>\" -> return ( a as Char ) . toShort ( ) <EOL> \"<STR_LIT:kotlin.Byte>\" -> return ( a as Byte ) . toShort ( ) <EOL> \"<STR_LIT:kotlin.Short>\" -> return ( a as Short ) . toShort ( ) <EOL> \"<STR_LIT:kotlin.Int>\" -> return ( a as Int ) . toShort ( ) <EOL> \"<STR_LIT>\" -> return ( a as Float ) . toShort ( ) <EOL> \"<STR_LIT:kotlin.Long>\" -> return ( a as Long ) . toShort ( ) <EOL> \"<STR_LIT>\" -> return ( a as Double ) . toShort ( ) <EOL> \"<STR_LIT>\" -> return ( a as Number ) . toShort ( ) <EOL> } <EOL> \"<STR_LIT>\" -> when ( type ) { <EOL> \"<STR_LIT:kotlin.Byte>\" -> return ( a as Byte ) . unaryMinus ( ) <EOL> \"<STR_LIT:kotlin.Short>\" -> return ( a as Short ) . unaryMinus ( ) <EOL> \"<STR_LIT:kotlin.Int>\" -> return ( a as Int ) . unaryMinus ( ) <EOL> \"<STR_LIT>\" -> return ( a as Float ) . unaryMinus ( ) <EOL> \"<STR_LIT:kotlin.Long>\" -> return ( a as Long ) . unaryMinus ( ) <EOL> \"<STR_LIT>\" -> return ( a as Double ) . unaryMinus ( ) <EOL> } <EOL> \"<STR_LIT>\" -> when ( type ) { <EOL> \"<STR_LIT:kotlin.Byte>\" -> return ( a as Byte ) . unaryPlus ( ) <EOL> \"<STR_LIT:kotlin.Short>\" -> return ( a as Short ) . unaryPlus ( ) <EOL> \"<STR_LIT:kotlin.Int>\" -> return ( a as Int ) . unaryPlus ( ) <EOL> \"<STR_LIT>\" -> return ( a as Float ) . unaryPlus ( ) <EOL> \"<STR_LIT:kotlin.Long>\" -> return ( a as Long ) . unaryPlus ( ) <EOL> \"<STR_LIT>\" -> return ( a as Double ) . unaryPlus ( ) <EOL> } <EOL> \"<STR_LIT>\" -> when ( type ) { <EOL> \"<STR_LIT:kotlin.Int>\" -> return ( a as Int ) . inv ( ) <EOL> \"<STR_LIT:kotlin.Long>\" -> return ( a as Long ) . inv ( ) <EOL> } <EOL> \"<STR_LIT>\" -> when ( type ) { <EOL> \"<STR_LIT:kotlin.String>\" -> return ( a as String ) . length <EOL> \"<STR_LIT>\" -> return ( a as CharSequence ) . length <EOL> } <EOL> \"<STR_LIT>\" -> when ( type ) { <EOL> \"<STR_LIT>\" -> return ( a as Throwable ) . cause <EOL> } <EOL> \"<STR_LIT:message>\" -> when ( type ) { <EOL> \"<STR_LIT>\" -> return ( a as Throwable ) . message <EOL> } <EOL> \"<STR_LIT>\" -> when ( type ) { <EOL> \"<STR_LIT>\" -> return ( a as BooleanArray ) . size <EOL> \"<STR_LIT>\" -> return ( a as CharArray ) . size <EOL> \"<STR_LIT>\" -> return ( a as ByteArray ) . size <EOL> \"<STR_LIT>\" -> return ( a as ShortArray ) . size <EOL> \"<STR_LIT>\" -> return ( a as IntArray ) . size <EOL> \"<STR_LIT>\" -> return ( a as FloatArray ) . size <EOL> \"<STR_LIT>\" -> return ( a as LongArray ) . size <EOL> \"<STR_LIT>\" -> return ( a as DoubleArray ) . size <EOL> \"<STR_LIT>\" -> return ( a as Array < Any ? > ) . size <EOL> } <EOL> \"<STR_LIT>\" -> when ( type ) { <EOL> \"<STR_LIT>\" -> return ( a as BooleanArray ) . iterator ( ) <EOL> \"<STR_LIT>\" -> return ( a as CharArray ) . iterator ( ) <EOL> \"<STR_LIT>\" -> return ( a as ByteArray ) . iterator ( ) <EOL> \"<STR_LIT>\" -> return ( a as ShortArray ) . iterator ( ) <EOL> \"<STR_LIT>\" -> return ( a as IntArray ) . iterator ( ) <EOL> \"<STR_LIT>\" -> return ( a as FloatArray ) . iterator ( ) <EOL> \"<STR_LIT>\" -> return ( a as LongArray ) . iterator ( ) <EOL> \"<STR_LIT>\" -> return ( a as DoubleArray ) . iterator ( ) <EOL> \"<STR_LIT>\" -> return ( a as Array < Any ? > ) . iterator ( ) <EOL> } <EOL> \"<STR_LIT>\" -> when ( type ) { <EOL> \"<STR_LIT>\" -> return a ! ! <EOL> } <EOL> \"<STR_LIT>\" -> when ( type ) { <EOL> \"<STR_LIT>\" -> return ( a as Char ) . code <EOL> } <EOL> } <EOL> throw InterpreterMethodNotFoundError ( \"<STR_LIT>\" ) <EOL> }","docstring":"/** This file is generated by `./gradlew generateInterpreterMap`. DO NOT MODIFY MANUALLY */"}
{"signature":"fun < T1 > Tuple1 < T1 > . splitAt0 ( ) : Tuple2 < EmptyTuple , Tuple1 < T1 > >","body":"= Tuple2 < EmptyTuple , Tuple1 < T1 > > ( EmptyTuple , Tuple1 < T1 > ( this . _1 ( ) ) )","docstring":"/**\n * Given a tuple `t(a1, ..., am)`, returns a [Tuple2] of the tuple `t(a1, ..., an)`\n * consisting of the first n elements, and the tuple `t(an+1, ..., am)` consisting\n * of the remaining elements.\n * Splitting at 0 or at n results in `t(t(), myTuple)` or `t(myTuple, t())` respectively.\n *\n * For example:\n * ```kotlin\n * t(1, 2, 3, 4, 5).splitAt2() == t(t(1, 2), t(3, 4, 5))\n * ```\n */"}
{"signature":"public operator fun String . rangeTo ( endInclusive : String ) : ColumnSet < * >","body":"= <EOL> toColumnAccessor ( ) . rangeTo ( endInclusive . toColumnAccessor ( ) )","docstring":"/**\n * @include [CommonRangeOfColumnsDocs]\n * {@set [CommonRangeOfColumnsDocs.Example] `\"fromColumn\"`[`..`][String.rangeTo]`\"toColumn\"`}\n */"}
{"signature":"public operator fun String . rangeTo ( endInclusive : KProperty < * > ) : ColumnSet < * >","body":"= <EOL> toColumnAccessor ( ) . rangeTo ( endInclusive . toColumnAccessor ( ) )","docstring":"/**\n * @include [CommonRangeOfColumnsDocs]\n * {@set [CommonRangeOfColumnsDocs.Example] `\"fromColumn\"`[`..`][String.rangeTo]`Type::toColumn`}\n */"}
{"signature":"public operator fun String . rangeTo ( endInclusive : AnyColumnReference ) : ColumnSet < * >","body":"= <EOL> toColumnAccessor ( ) . rangeTo ( endInclusive )","docstring":"/**\n * @include [CommonRangeOfColumnsDocs]\n * {@set [CommonRangeOfColumnsDocs.Example] `\"fromColumn\"`[`..`][String.rangeTo]`toColumn`}\n */"}
{"signature":"public operator fun KProperty < * > . rangeTo ( endInclusive : String ) : ColumnSet < * >","body":"= <EOL> toColumnAccessor ( ) . rangeTo ( endInclusive . toColumnAccessor ( ) )","docstring":"/**\n * @include [CommonRangeOfColumnsDocs]\n * {@set [CommonRangeOfColumnsDocs.Example] `Type::fromColumn`[`..`][KProperty.rangeTo]`\"toColumn\"`}\n */"}
{"signature":"public operator fun KProperty < * > . rangeTo ( endInclusive : KProperty < * > ) : ColumnSet < * >","body":"= <EOL> toColumnAccessor ( ) . rangeTo ( endInclusive . toColumnAccessor ( ) )","docstring":"/**\n * @include [CommonRangeOfColumnsDocs]\n * {@set [CommonRangeOfColumnsDocs.Example] `Type::fromColumn`[`..`][KProperty.rangeTo]`Type::toColumn`}\n */"}
{"signature":"public operator fun KProperty < * > . rangeTo ( endInclusive : AnyColumnReference ) : ColumnSet < * >","body":"= <EOL> toColumnAccessor ( ) . rangeTo ( endInclusive )","docstring":"/**\n * @include [CommonRangeOfColumnsDocs]\n * {@set [CommonRangeOfColumnsDocs.Example] `Type::fromColumn`[`..`][KProperty.rangeTo]`toColumn`}\n */"}
{"signature":"public operator fun AnyColumnReference . rangeTo ( endInclusive : String ) : ColumnSet < * >","body":"= <EOL> rangeTo ( endInclusive . toColumnAccessor ( ) )","docstring":"/**\n * @include [CommonRangeOfColumnsDocs]\n * {@set [CommonRangeOfColumnsDocs.Example] `fromColumn`[`..`][ColumnReference.rangeTo]`\"toColumn\"`}\n */"}
{"signature":"public operator fun AnyColumnReference . rangeTo ( endInclusive : KProperty < * > ) : ColumnSet < * >","body":"= <EOL> rangeTo ( endInclusive . toColumnAccessor ( ) )","docstring":"/**\n * @include [CommonRangeOfColumnsDocs]\n * {@set [CommonRangeOfColumnsDocs.Example] `fromColumn`[`..`][ColumnReference.rangeTo]`Type::toColumn`}\n */"}
{"signature":"public operator fun AnyColumnReference . rangeTo ( endInclusive : AnyColumnReference ) : ColumnSet < * >","body":"= <EOL> createColumnSet { context -> <EOL> val startPath = this@rangeTo . resolveSingle ( context ) ! ! . path <EOL> val endPath = endInclusive . resolveSingle ( context ) ! ! . path <EOL> val parentPath = startPath . parent ( ) <EOL> val parentEndPath = endPath . parent ( ) <EOL> require ( parentPath == parentEndPath ) { <EOL> \"<STR_LIT>\" <EOL> } <EOL> val parentCol = context . df . getColumnGroup ( parentPath ! ! ) <EOL> val startIndex = parentCol . getColumnIndex ( startPath . name ) <EOL> val endIndex = parentCol . getColumnIndex ( endPath . name ) <EOL> require ( startIndex <= endIndex ) { \"<STR_LIT>\" } <EOL> ( startIndex .. endIndex ) . map { <EOL> parentCol . getColumn ( it ) . let { <EOL> it . addPath ( parentPath + it . name ) <EOL> } <EOL> } <EOL> }","docstring":"/**\n * @include [CommonRangeOfColumnsDocs]\n * {@set [CommonRangeOfColumnsDocs.Example] `fromColumn`[`..`][ColumnReference.rangeTo]`toColumn`}\n */"}
{"signature":"fun attribute ( key : String , value : String )","body":"{ <EOL> attrs [ key ] = value <EOL> }","docstring":"/**\n * Appends an attribute to the generated podspec\n */"}
{"signature":"fun rawStatement ( statement : String )","body":"{ <EOL> statements . add ( statement ) <EOL> }","docstring":"/**\n * Appends a statement 'as is' to the end of the generated podspec\n */"}
{"signature":"@ Suppress ( \"<STR_LIT>\" ) <EOL> inline fun < reified T : NativePointed > interpretNullablePointed ( ptr : NativePtr ) : T ?","body":"{ <EOL> if ( ptr == nativeNullPtr ) { <EOL> return null <EOL> } else { <EOL> val result = nativeMemUtils . allocateInstance < T > ( ) <EOL> result . rawPtr = ptr <EOL> return result <EOL> } <EOL> }","docstring":"/**\n * Returns interpretation of entity with given pointer, or `null` if it is null.\n *\n * @param T must not be abstract\n */"}
{"signature":"fun < T : CPointed > interpretCPointer ( rawValue : NativePtr )","body":"= <EOL> if ( rawValue == nativeNullPtr ) { <EOL> null <EOL> } else { <EOL> CPointer < T > ( rawValue ) <EOL> }","docstring":"/**\n * Creates a [CPointer] from the raw pointer of [NativePtr].\n *\n * @return a [CPointer] representation, or `null` if the [rawValue] represents native `nullptr`.\n */"}
{"signature":"fun ConeClassifierLookupTag . toSymbol ( useSiteSession : FirSession ) : FirClassifierSymbol < * > ?","body":"= <EOL> when ( this ) { <EOL> is ConeClassLikeLookupTag -> toSymbol ( useSiteSession ) <EOL> is ConeClassifierLookupTagWithFixedSymbol -> this . symbol <EOL> else -> error ( \"<STR_LIT>\" ) <EOL> }","docstring":"/**\n * Main operation on the [ConeClassifierLookupTag]\n *\n * Lookups the tag into its target within the given [useSiteSession]\n *\n * The second step of type refinement, see `/docs/fir/k2_kmp.md`\n *\n * @see ConeClassifierLookupTag\n */"}
{"signature":"@ OptIn ( LookupTagInternals :: class ) <EOL> fun ConeClassLikeLookupTag . toSymbol ( useSiteSession : FirSession ) : FirClassLikeSymbol < * > ?","body":"{ <EOL> if ( this is ConeClassLookupTagWithFixedSymbol ) { <EOL> return this . symbol <EOL> } <EOL> ( this as? ConeClassLikeLookupTagImpl ) ? . boundSymbol ? . takeIf { it . first === useSiteSession } ? . let { return it . second } <EOL> return useSiteSession . symbolProvider . getClassLikeSymbolByClassId ( classId ) . also { <EOL> ( this as? ConeClassLikeLookupTagImpl ) ? . bindSymbolToLookupTag ( useSiteSession , it ) <EOL> } <EOL> }","docstring":"/**\n * @see toSymbol\n */"}
{"signature":"fun ConeClassLikeLookupTag . toClassSymbol ( session : FirSession ) : FirClassSymbol < * > ?","body":"= <EOL> toSymbol ( session ) as? FirClassSymbol < * >","docstring":"/**\n * @see toSymbol\n */"}
{"signature":"fun ConeClassLikeLookupTag . toFirRegularClassSymbol ( session : FirSession ) : FirRegularClassSymbol ?","body":"= <EOL> toSymbol ( session ) as? FirRegularClassSymbol","docstring":"/**\n * @see toSymbol\n */"}
{"signature":"public fun detectPoses ( image : I , confidence : Float = <NUM_LIT> ) : MultiPoseDetectionResult","body":"{ <EOL> val result = predict ( image ) <EOL> val filteredPoses = result . poses . filter { ( detectedObject , _ ) -> <EOL> detectedObject . probability > confidence <EOL> } <EOL> return MultiPoseDetectionResult ( filteredPoses ) <EOL> }","docstring":"/**\n * Detects poses for the given [image] with the given [confidence].\n * @param [confidence] confidence value to use\n */"}
{"signature":"@ InternalCoroutinesApi <EOL> public fun MainDispatcherFactory . tryCreateDispatcher ( factories : List < MainDispatcherFactory > ) : MainCoroutineDispatcher","body":"= <EOL> try { <EOL> createDispatcher ( factories ) <EOL> } catch ( cause : Throwable ) { <EOL> createMissingDispatcher ( cause , hintOnError ( ) ) <EOL> }","docstring":"/**\n * If anything goes wrong while trying to create main dispatcher (class not found,\n * initialization failed, etc), then replace the main dispatcher with a special\n * stub that throws an error message on any attempt to actually use it.\n *\n * @suppress internal API\n */"}
{"signature":"@ InternalCoroutinesApi <EOL> public fun MainCoroutineDispatcher . isMissing ( ) : Boolean","body":"= <EOL> this . immediate is MissingMainCoroutineDispatcher","docstring":"/** @suppress */"}
{"signature":"@ ExternalKotlinTargetApi <EOL> fun < T : DecoratedExternalKotlinTarget > ExternalKotlinTargetDescriptor ( configure : ExternalKotlinTargetDescriptorBuilder < T > . ( ) -> Unit , ) : ExternalKotlinTargetDescriptor < T >","body":"{ <EOL> return ExternalKotlinTargetDescriptorBuilder < T > ( ) . also ( configure ) . build ( ) <EOL> }","docstring":"/**\n * Creates a new [ExternalKotlinTargetDescriptor] using the builder pattern.\n * There are some required properties that have to be set.\n * Check [ExternalKotlinTargetDescriptorBuilder] for further details.\n *\n * * The following properties have to be specified:\n * * - [ExternalKotlinTargetDescriptorBuilder.targetName]\n * * - [ExternalKotlinTargetDescriptorBuilder.platformType]\n * * - [ExternalKotlinTargetDescriptorBuilder.targetFactory]\n *\n * Not providing a required/necessary property will throw [IllegalStateException]\n */"}
{"signature":"fun configure ( action : ( T ) -> Unit )","body":"{ <EOL> val configure = this . configure <EOL> if ( configure == null ) this . configure = action <EOL> else this . configure = { configure ( it ) ; action ( it ) } <EOL> }","docstring":"/**\n * Generic configuration that will be invoked when building the target.\n * This configuration is called right after creating the instance and before\n * publishing the target to all subscribers of `kotlin.targets.all {}`\n */"}
{"signature":"fun configureIdeImport ( action : IdeMultiplatformImport . ( ) -> Unit )","body":"{ <EOL> val configureIdeImport = this . configureIdeImport <EOL> if ( configureIdeImport == null ) this . configureIdeImport = action <EOL> else this . configureIdeImport = { configureIdeImport ( ) ; action ( ) } <EOL> }","docstring":"/**\n * Main entrance of configuring the ide import:\n * The [IdeMultiplatformImport] instance passed to this function shall\n * not be captured and used outside of this block.\n *\n * The [IdeMultiplatformImport] instance shall not be retrieved any other way than using this function.\n */"}
{"signature":"fun create ( prefix : String , suffix : String = \"<STR_LIT>\" ) : File","body":"= <EOL> File ( dir , \"<STR_LIT>\" )","docstring":"/**\n * Create file named {name}{suffix} inside temporary dir\n */"}
{"signature":"fun processClassifiersByNameWithSubstitutionFromBothLevelsConditionally ( name : Name , processor : ( FirClassifierSymbol < * > , ConeSubstitutor ) -> Boolean , )","body":"{ <EOL> var wasFoundAny = false <EOL> first . processClassifiersByNameWithSubstitution ( name ) { symbol , substitutor -> <EOL> wasFoundAny = processor ( symbol , substitutor ) <EOL> } <EOL> if ( ! wasFoundAny ) { <EOL> second . processClassifiersByNameWithSubstitution ( name , processor :: invoke ) <EOL> } <EOL> }","docstring":"/**\n * Starts by querying [first] and calling [processor] with the results.\n * If [processor] doesn't return `true` for any of them (or no symbols were found), also queries [second] and calls [processor].\n */"}
{"signature":"@ InternalDokkaApi <EOL> fun AbstractDokkaTask . buildJsonConfiguration ( prettyPrint : Boolean = true ) : String","body":"{ <EOL> val configuration = this . buildDokkaConfiguration ( ) <EOL> return if ( prettyPrint ) { <EOL> configuration . toPrettyJsonString ( ) <EOL> } else { <EOL> configuration . toCompactJsonString ( ) <EOL> } <EOL> }","docstring":"/**\n * Serializes [DokkaConfiguration] of this [AbstractDokkaTask] as json\n *\n * Should be used for short-term debugging only, no guarantees are given for the support of this API.\n *\n * Better alternative should be introduced as part of [#2873](https://github.com/Kotlin/dokka/issues/2873).\n */"}
{"signature":"internal fun loadSequentialModelConfiguration ( configuration : File , inputShape : IntArray ? = null ) : Sequential","body":"{ <EOL> val sequentialConfig = loadSerializedModel ( configuration ) <EOL> return deserializeSequentialModel ( sequentialConfig , inputShape ) <EOL> }","docstring":"/**\n * Loads a [Sequential] model from json file with model configuration.\n *\n * @param [configuration] File containing model configuration.\n * @return Non-compiled and non-trained Sequential model.\n */"}
{"signature":"internal fun loadSequentialModelLayers ( config : KerasModel ? , inputShape : IntArray ? = null ) : Pair < Input , List < Layer > >","body":"{ <EOL> val kerasLayers = config ! ! . config ! ! . layers ! ! <EOL> val input = createInputLayer ( kerasLayers . first ( ) , inputShape ) <EOL> val layers = kerasLayers . filter { ! it . class_name . equals ( LAYER_INPUT ) } . mapTo ( mutableListOf ( ) ) { <EOL> convertToLayer ( it ) <EOL> } <EOL> return Pair ( input , layers ) <EOL> }","docstring":"/**\n * Loads a [Sequential] model layers from json file with model configuration.\n *\n * NOTE: This method is useful in transfer learning, when you need to manipulate on layers before building the Sequential model.\n *\n * @param config Model configuration.\n * @return Pair of <input layer; list of layers>.\n */"}
{"signature":"internal fun loadFunctionalModelConfiguration ( configuration : File , inputShape : IntArray ? = null ) : Functional","body":"{ <EOL> val functionalConfig = loadSerializedModel ( configuration ) <EOL> return deserializeFunctionalModel ( functionalConfig , inputShape ) <EOL> }","docstring":"/**\n * Loads a [Sequential] model from json file with model configuration.\n *\n * @param [configuration] File containing model configuration.\n * @return Non-compiled and non-trained Sequential model.\n */"}
{"signature":"internal fun loadFunctionalModelLayers ( config : KerasModel ? , inputShape : IntArray ? = null ) : List < Layer >","body":"{ <EOL> val layers = mutableListOf < Layer > ( ) <EOL> val layersByNames = mutableMapOf < String , Layer > ( ) <EOL> val kerasLayers = config ! ! . config ! ! . layers ! ! <EOL> val input = createInputLayer ( kerasLayers . first ( ) , inputShape ) <EOL> layers . add ( input ) <EOL> layersByNames [ input . name ] = input <EOL> kerasLayers . forEach { <EOL> if ( ! it . class_name . equals ( LAYER_INPUT ) ) { <EOL> val layer = convertToLayer ( it , layersByNames ) <EOL> layers . add ( layer ) <EOL> layersByNames [ layer . name ] = layer <EOL> } <EOL> } <EOL> return layers <EOL> }","docstring":"/**\n * Loads a [Functional] model layers from json file with model configuration.\n *\n * NOTE: This method is useful in transfer learning, when you need to manipulate on layers before building the Functional model.\n *\n * @param config Model configuration.\n * @return Pair of <input layer; list of layers>.\n */"}
{"signature":"private fun createInputLayer ( layer : KerasLayer , inputShape : IntArray ? = null ) : Input","body":"{ <EOL> val inputLayerDims = if ( inputShape != null ) { <EOL> inputShape . map { it . toLong ( ) } . toLongArray ( ) <EOL> } else { <EOL> val batchInputShape = layer . config ! ! . batch_input_shape ! ! <EOL> batchInputShape . subList ( <NUM_LIT:1> , batchInputShape . size ) . map { it ! ! . toLong ( ) } . toLongArray ( ) <EOL> } <EOL> val inputLayerName = if ( layer . class_name . equals ( LAYER_INPUT ) ) layer . config ! ! . name ? : \"<STR_LIT>\" else \"<STR_LIT>\" <EOL> return Input ( * inputLayerDims , name = inputLayerName ) <EOL> }","docstring":"/**\n * The layer creator functions should be put below.\n */"}
{"signature":"protected fun incrementInductionVariable ( builder : DeclarationIrBuilder ) : IrStatement","body":"= with ( builder ) { <EOL> with ( headerInfo . progressionType ) { <EOL> val stepType = stepClass . defaultType <EOL> val plusFun = elementClass . defaultType . getClass ( ) ! ! . functions . single { <EOL> it . name == OperatorNameConventions . PLUS && <EOL> it . valueParameters . size == <NUM_LIT:1> && <EOL> it . valueParameters [ <NUM_LIT:0> ] . type == stepType <EOL> } <EOL> irSet ( inductionVariable . symbol , irCallOp ( plusFun . symbol , plusFun . returnType , irGet ( inductionVariable ) , stepExpression . shallowCopy ( ) , IrStatementOrigin . PLUSEQ ) , IrStatementOrigin . PLUSEQ ) <EOL> } <EOL> }","docstring":"/** Statement used to increment the induction variable. */"}
{"signature":"override fun < T > injectCoroutineContext ( publisher : Publisher < T > , coroutineContext : CoroutineContext ) : Publisher < T >","body":"{ <EOL> val reactorContext = coroutineContext [ ReactorContext ] ? . context ? : return publisher <EOL> return when ( publisher ) { <EOL> is Mono -> publisher . contextWrite ( reactorContext ) <EOL> is Flux -> publisher . contextWrite ( reactorContext ) <EOL> else -> publisher <EOL> } <EOL> }","docstring":"/**\n * Injects all values from the [ReactorContext] entry of the given coroutine context\n * into the downstream [Context] of Reactor's [Publisher] instances of [Mono] or [Flux].\n */"}
{"signature":"public abstract fun forward ( tf : Ops , input : Operand < Float > ) : Operand < Float >","body":"public abstract fun forward ( tf : Ops , input : Operand < Float > ) : Operand < Float >","docstring":"/**\n * Applies the activation functions to the [input] to produce the output.\n *\n * @param [tf] TensorFlow graph API for building operations.\n * @param [input] TensorFlow graph leaf node representing layer output before activation function.\n */"}
{"signature":"fun isAllowed ( qualifiedName : String ) : Boolean","body":"fun isAllowed ( qualifiedName : String ) : Boolean","docstring":"/**\n * @return **true** if an annotations with [qualifiedName] is allowed\n */"}
{"signature":"fun filtered ( annotations : Collection < PsiAnnotation > ) : Collection < PsiAnnotation >","body":"fun filtered ( annotations : Collection < PsiAnnotation > ) : Collection < PsiAnnotation >","docstring":"/**\n * @return a filtered collection where each annotation in a list has an allowed qualifier\n */"}
{"signature":"public expect inline fun < reified T > Array < out T > ? . orEmpty ( ) : Array < out T >","body":"public expect inline fun < reified T > Array < out T > ? . orEmpty ( ) : Array < out T >","docstring":"/**\n * Returns the array if it's not `null`, or an empty array otherwise.\n * @sample samples.collections.Arrays.Usage.arrayOrEmpty\n */"}
{"signature":"public expect inline fun < reified T > Collection < T > . toTypedArray ( ) : Array < T >","body":"public expect inline fun < reified T > Collection < T > . toTypedArray ( ) : Array < T >","docstring":"/**\n * Returns a *typed* array containing all the elements of this collection.\n *\n * Allocates an array of runtime type `T` having its size equal to the size of this collection\n * and populates the array with the elements of this collection.\n * @sample samples.collections.Collections.Collections.collectionToTypedArray\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.2>\" ) <EOL> public expect fun < T > MutableList < T > . fill ( value : T ) : Unit","body":"@ SinceKotlin ( \"<STR_LIT:1.2>\" ) <EOL> public expect fun < T > MutableList < T > . fill ( value : T ) : Unit","docstring":"/**\n * Fills the list with the provided [value].\n *\n * Each element in the list gets replaced with the [value].\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.2>\" ) <EOL> public expect fun < T > MutableList < T > . shuffle ( ) : Unit","body":"@ SinceKotlin ( \"<STR_LIT:1.2>\" ) <EOL> public expect fun < T > MutableList < T > . shuffle ( ) : Unit","docstring":"/**\n * Randomly shuffles elements in this list.\n *\n * See: https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#The_modern_algorithm\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.2>\" ) <EOL> public expect fun < T > Iterable < T > . shuffled ( ) : List < T >","body":"@ SinceKotlin ( \"<STR_LIT:1.2>\" ) <EOL> public expect fun < T > Iterable < T > . shuffled ( ) : List < T >","docstring":"/**\n * Returns a new list with the elements of this collection randomly shuffled.\n */"}
{"signature":"public expect fun < T : Comparable < T > > MutableList < T > . sort ( ) : Unit","body":"public expect fun < T : Comparable < T > > MutableList < T > . sort ( ) : Unit","docstring":"/**\n * Sorts elements in the list in-place according to their natural sort order.\n *\n * The sort is _stable_. It means that equal elements preserve their order relative to each other after sorting.\n *\n * @sample samples.collections.Collections.Sorting.sortMutableList\n */"}
{"signature":"public expect fun < T > MutableList < T > . sortWith ( comparator : Comparator < in T > ) : Unit","body":"public expect fun < T > MutableList < T > . sortWith ( comparator : Comparator < in T > ) : Unit","docstring":"/**\n * Sorts elements in the list in-place according to the order specified with [comparator].\n *\n * The sort is _stable_. It means that equal elements preserve their order relative to each other after sorting.\n *\n * @sample samples.collections.Collections.Sorting.sortMutableListWith\n */"}
{"signature":"fun filtersPlot ( conv2DLayer : Conv2D , plotFeature : PlotFeature = PlotFeature . GRAY , imageSize : Int = <NUM_LIT> , columns : Int = <NUM_LIT:8> ) : Figure","body":"{ <EOL> @ Suppress ( \"<STR_LIT:UNCHECKED_CAST>\" ) <EOL> val weights = conv2DLayer . weights . values . toTypedArray ( ) [ <NUM_LIT:0> ] as TensorImageData <EOL> val xyInOut = extractXYInputOutputAxeSizes ( weights , FILTER_LAYERS_PERMUTATION ) <EOL> val plots = cartesianProductIndices ( xyInOut [ <NUM_LIT:2> ] , xyInOut [ <NUM_LIT:3> ] ) . map { ( i , o ) -> <EOL> xyPlot ( xyInOut [ <NUM_LIT:0> ] , xyInOut [ <NUM_LIT:1> ] , plotFeature ) { x , y -> <EOL> weights [ y ] [ x ] [ i ] [ o ] <EOL> } <EOL> } <EOL> return columnPlot ( plots , columns , imageSize ) <EOL> }","docstring":"/**\n * Create a column plot of tile plots for weights of Conv2D layer filters.\n *\n * @param conv2DLayer which weights will be changed to tile plot\n * @param plotFeature filling colors of the created plot\n * @param imageSize size of width and height of single plot in px\n * @param columns number of columns in which the single filters plots are arranged\n * @return a figure representing the weights plots\n */"}
{"signature":"fun modelActivationOnLayersPlot ( model : TrainableModel , x : FloatData , plotFeature : PlotFeature = PlotFeature . GRAY , imageSize : Int = <NUM_LIT> , columns : Int = <NUM_LIT:8> , ) : List < Figure >","body":"{ <EOL> val activations = model . predictAndGetActivations ( x ) . second <EOL> @ Suppress ( \"<STR_LIT:UNCHECKED_CAST>\" ) <EOL> val activationArrays = activations . mapNotNull { it as? TensorImageData } <EOL> return activationArrays . map { weights -> <EOL> val xyInOut = extractXYInputOutputAxeSizes ( weights , ACTIVATION_LAYERS_PERMUTATION ) <EOL> val plots = cartesianProductIndices ( xyInOut [ <NUM_LIT:2> ] , xyInOut [ <NUM_LIT:3> ] ) . map { ( i , o ) -> <EOL> xyPlot ( xyInOut [ <NUM_LIT:0> ] , xyInOut [ <NUM_LIT:1> ] , plotFeature ) { x , y -> <EOL> weights [ i ] [ y ] [ x ] [ o ] <EOL> } <EOL> } <EOL> columnPlot ( plots , columns , imageSize ) <EOL> } <EOL> }","docstring":"/**\n * Create a list of columns plots for model activation on layers.\n * The model is evaluated on given input and the obtained activations arrays\n * of the following layers are converted into separated figures with columns\n * plots of the weights for the filters in [Conv2D] layers\n *\n * @param model that is evaluated to get the activations on its weights\n * @param x input for model evaluation\n * @param plotFeature filling colors of the created plot\n * @param imageSize size of width and height of single plot in px\n * @param columns number of columns in which the single filters plots are arranged\n * @return list of figures representing the activations plots for model evaluation\n */"}
{"signature":"@ Test <EOL> fun testMainIsJavaFx ( )","body":"{ <EOL> assertSame ( Dispatchers . Swing , Dispatchers . Main ) <EOL> }","docstring":"/** Tests that the Main dispatcher is in fact the JavaFx one. */"}
{"signature":"@ Suppress ( \"<STR_LIT>\" ) <EOL> fun FirDeclarationCollector < FirBasedSymbol < * > > . collectTopLevel ( file : FirFile , packageMemberScope : FirPackageMemberScope )","body":"{ <EOL> for ( ( declarationName , group ) in groupTopLevelByName ( file . declarations , context ) ) { <EOL> val groupHasClassLikesOrProperties = group . classLikes . isNotEmpty ( ) || group . properties . isNotEmpty ( ) <EOL> val groupHasSimpleFunctions = group . simpleFunctions . isNotEmpty ( ) <EOL> fun collect ( declarations : List < Pair < FirBasedSymbol < * > , String > > , conflictingSymbol : FirBasedSymbol < * > , conflictingPresentation : String ? = null , conflictingFile : FirFile ? = null , ) { <EOL> for ( ( declaration , declarationPresentation ) in declarations ) { <EOL> collectTopLevelConflict ( declaration , declarationPresentation , file , conflictingSymbol , conflictingPresentation , conflictingFile ) <EOL> session . lookupTracker ? . recordNameLookup ( declarationName , file . packageFqName . asString ( ) , declaration . source , file . source ) <EOL> } <EOL> } <EOL> fun collectFromClassifierSource ( conflictingSymbol : FirClassifierSymbol < * > , conflictingPresentation : String ? = null , conflictingFile : FirFile ? = null , ) { <EOL> collect ( group . classLikes , conflictingSymbol , conflictingPresentation , conflictingFile ) <EOL> collect ( group . properties , conflictingSymbol , conflictingPresentation , conflictingFile ) <EOL> if ( groupHasSimpleFunctions ) { <EOL> if ( conflictingSymbol !is FirClassLikeSymbol < * > ) { <EOL> return <EOL> } <EOL> conflictingSymbol . expandedClassWithConstructorsScope ( context ) ? . let { ( expandedClass , scopeWithConstructors ) -> <EOL> if ( expandedClass . classKind == ClassKind . OBJECT || expandedClass . classKind == ClassKind . ENUM_ENTRY ) { <EOL> return <EOL> } <EOL> scopeWithConstructors . processDeclaredConstructors { constructor -> <EOL> val ctorRepresentation = FirRedeclarationPresenter . represent ( constructor , conflictingSymbol ) <EOL> collect ( group . simpleFunctions , conflictingSymbol = constructor , conflictingPresentation = ctorRepresentation ) <EOL> } <EOL> } <EOL> } <EOL> } <EOL> if ( groupHasSimpleFunctions || group . constructors . isNotEmpty ( ) ) { <EOL> packageMemberScope . processFunctionsByName ( declarationName ) { <EOL> collect ( group . simpleFunctions , it ) <EOL> collect ( group . constructors , it ) <EOL> } <EOL> } <EOL> if ( groupHasClassLikesOrProperties || groupHasSimpleFunctions ) { <EOL> packageMemberScope . processClassifiersByNameWithSubstitution ( declarationName ) { symbol , _ -> <EOL> collectFromClassifierSource ( conflictingSymbol = symbol ) <EOL> } <EOL> session . nameConflictsTracker ? . let { it as? FirNameConflictsTracker } <EOL> ? . redeclaredClassifiers ? . get ( ClassId ( file . packageFqName , declarationName ) ) ? . forEach { <EOL> collectFromClassifierSource ( conflictingSymbol = it . classifier , conflictingFile = it . file ) <EOL> } <EOL> for ( ( classLike , representation ) in group . classLikes ) { <EOL> collectFromClassifierSource ( classLike , conflictingPresentation = representation , conflictingFile = file ) <EOL> } <EOL> } <EOL> if ( groupHasClassLikesOrProperties || group . extensionProperties . isNotEmpty ( ) ) { <EOL> packageMemberScope . processPropertiesByName ( declarationName ) { <EOL> collect ( group . classLikes , conflictingSymbol = it ) <EOL> collect ( group . properties , conflictingSymbol = it ) <EOL> collect ( group . extensionProperties , conflictingSymbol = it ) <EOL> } <EOL> } <EOL> } <EOL> }","docstring":"/**\n * To check top-level declarations for redeclarations, we check multiple sources (the packageMemberScope's properties, functions\n * and classifiers), redeclared classifiers from session.nameConflictsTracker and the file's declarations themselves.\n * To prevent inspecting the same source multiple times, we group the declarations in the file by name and subdivide them into\n * buckets (the properties of DeclarationGroup).\n *\n * Depending on the presence of declarations in the buckets, some checks can be omitted.\n * E.g., if there are no functions and no classes with constructors in the file, we don't need to inspect functions.\n *\n * #### Matrix of possible conflicts between \"sources\" and \"buckets\"\n *\n * | | simpleFunctions | constructors | classLikes | Properties | extensionProperties |\n * |-------------------------|-----------------|--------------|------------|------------|---------------------|\n * | functions | X | X | | | |\n * | classifiers | | | X | X | |\n * | constructors of classes | X | | | | |\n * | properties | | | X | X | X |\n */"}
{"signature":"fun checkForLocalRedeclarations ( elements : List < FirElement > , context : CheckerContext , reporter : DiagnosticReporter )","body":"{ <EOL> if ( elements . size <= <NUM_LIT:1> ) return <EOL> val multimap = ListMultimap < Name , FirBasedSymbol < * > > ( ) <EOL> for ( element in elements ) { <EOL> val name : Name ? <EOL> val symbol : FirBasedSymbol < * > ? <EOL> when ( element ) { <EOL> is FirVariable -> { <EOL> symbol = element . symbol <EOL> name = element . name <EOL> } <EOL> is FirOuterClassTypeParameterRef -> { <EOL> continue <EOL> } <EOL> is FirTypeParameterRef -> { <EOL> symbol = element . symbol <EOL> name = symbol . name <EOL> } <EOL> else -> { <EOL> symbol = null <EOL> name = null <EOL> } <EOL> } <EOL> if ( name ? . isSpecial == false ) { <EOL> multimap . put ( name , symbol ! ! ) <EOL> } <EOL> } <EOL> for ( key in multimap . keys ) { <EOL> val conflictingElements = multimap [ key ] <EOL> if ( conflictingElements . size > <NUM_LIT:1> ) { <EOL> for ( conflictingElement in conflictingElements ) { <EOL> reporter . reportOn ( conflictingElement . source , FirErrors . REDECLARATION , conflictingElements , context ) <EOL> } <EOL> } <EOL> } <EOL> }","docstring":"/** Checks for redeclarations of value and type parameters, and local variables. */"}
{"signature":"private fun resolveJvmSourceSets ( sourceSet : KotlinSourceSet ) : Iterable < IdeaKotlinDependency >","body":"{ <EOL> return IdeBinaryDependencyResolver ( binaryType = IdeaKotlinBinaryDependency . KOTLIN_COMPILE_BINARY_TYPE , artifactResolutionStrategy = IdeBinaryDependencyResolver . ArtifactResolutionStrategy . PlatformLikeSourceSet ( setupPlatformResolutionAttributes = { <EOL> sourceSet . internal . compilations . filter { it . platformType == KotlinPlatformType . jvm } <EOL> . map { compilation -> compilation . internal . configurations . compileDependencyConfiguration . attributes } <EOL> . map { attributes -> attributes . toMap ( ) . toList ( ) . toSet ( ) } <EOL> . reduceOrNull { acc , next -> acc intersect next } <EOL> . orEmpty ( ) <EOL> . forEach { ( key , value ) -> <EOL> @ Suppress ( \"<STR_LIT:UNCHECKED_CAST>\" ) <EOL> setAttributeProvider ( sourceSet . project , key as Attribute < Any > ) { value as Any } <EOL> } <EOL> } , componentFilter = { id -> id is ProjectComponentIdentifier } ) ) . resolve ( sourceSet ) <EOL> }","docstring":"/**\n * Pretend that this [sourceSet] is 'jvm' and resolve binaries.\n * #### Setting up attributes:\n * In order to set up the 'platform like' / 'jvm like' dependency resolution, this algorithm\n * will look at all 'jvm' based compilations, uses their 'compileDependencyConfiguration' as reference and\n * then uses the intersection of all available attributes\n *\n * #### componentFilter:\n * This resolver will just care about resolving project dependencies.\n * Therefore, a componentFilter is added to only resolve project dependencies.\n * We expect to resolve project artifact dependencies which can then be matched to the corresponding\n * SourceSets on IDE side.\n */"}
{"signature":"public fun < I , O > Operation < I , O > . onResult ( block : ( O ) -> Unit ) : Operation < I , O >","body":"{ <EOL> return PreprocessingPipeline ( this , object : Operation < O , O > { <EOL> override fun apply ( input : O ) : O { <EOL> block ( input ) <EOL> return input <EOL> } <EOL> override fun getOutputShape ( inputShape : TensorShape ) : TensorShape = inputShape <EOL> } ) <EOL> }","docstring":"/**\n * Convenience functions for executing custom logic after applying [Operation].\n * Could be useful for debugging purposes.\n */"}
{"signature":"public fun < I , M , O > Operation < I , M > . call ( operation : Operation < M , O > ) : Operation < I , O >","body":"{ <EOL> return PreprocessingPipeline ( this , operation ) <EOL> }","docstring":"/**\n * Applies provided [operation] to the preprocessing pipeline.\n */"}
{"signature":"internal actual fun String . nativeIndexOf ( ch : Char , fromIndex : Int ) : Int","body":"{ <EOL> for ( index in fromIndex . coerceAtLeast ( <NUM_LIT:0> ) .. this . lastIndex ) { <EOL> if ( ch == get ( index ) ) return index <EOL> } <EOL> return - <NUM_LIT:1> <EOL> }","docstring":"/**\n * Returns the index within this string of the first occurrence of the specified character, starting from the specified offset.\n */"}
{"signature":"internal actual fun String . nativeLastIndexOf ( ch : Char , fromIndex : Int ) : Int","body":"{ <EOL> for ( index in fromIndex . coerceAtMost ( this . lastIndex ) downTo <NUM_LIT:0> ) { <EOL> if ( ch == get ( index ) ) return index <EOL> } <EOL> return - <NUM_LIT:1> <EOL> }","docstring":"/**\n * Returns the index within this string of the last occurrence of the specified character.\n */"}
{"signature":"internal actual fun String . nativeIndexOf ( str : String , fromIndex : Int ) : Int","body":"{ <EOL> for ( index in fromIndex . coerceAtLeast ( <NUM_LIT:0> ) .. ( this . length - str . length ) ) { <EOL> if ( str . regionMatchesImpl ( <NUM_LIT:0> , this , index , str . length , false ) ) { <EOL> return index <EOL> } <EOL> } <EOL> return - <NUM_LIT:1> <EOL> }","docstring":"/**\n * Returns the index within this string of the first occurrence of the specified substring, starting from the specified offset.\n */"}
{"signature":"internal actual fun String . nativeLastIndexOf ( str : String , fromIndex : Int ) : Int","body":"{ <EOL> for ( index in fromIndex . coerceAtMost ( this . length - str . length ) downTo <NUM_LIT:0> ) { <EOL> if ( str . regionMatchesImpl ( <NUM_LIT:0> , this , index , str . length , false ) ) { <EOL> return index <EOL> } <EOL> } <EOL> return - <NUM_LIT:1> <EOL> }","docstring":"/**\n * Returns the index within this string of the last occurrence of the specified character, starting from the specified offset.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.2>\" ) <EOL> @ Deprecated ( \"<STR_LIT>\" , ReplaceWith ( \"<STR_LIT>\" ) ) <EOL> @ DeprecatedSinceKotlin ( warningSince = \"<STR_LIT:1.4>\" , errorSince = \"<STR_LIT:1.5>\" ) <EOL> public actual fun String ( chars : CharArray ) : String","body":"= <EOL> chars . concatToString ( )","docstring":"/**\n * Converts the characters in the specified array to a string.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.2>\" ) <EOL> @ Deprecated ( \"<STR_LIT>\" , ReplaceWith ( \"<STR_LIT>\" ) ) <EOL> @ DeprecatedSinceKotlin ( warningSince = \"<STR_LIT:1.4>\" , errorSince = \"<STR_LIT:1.5>\" ) <EOL> public actual fun String ( chars : CharArray , offset : Int , length : Int ) : String","body":"{ <EOL> if ( offset < <NUM_LIT:0> || length < <NUM_LIT:0> || offset + length > chars . size ) <EOL> throw IndexOutOfBoundsException ( ) <EOL> val copy = WasmCharArray ( length ) <EOL> copyWasmArray ( chars . storage , copy , offset , <NUM_LIT:0> , length ) <EOL> return copy . createString ( ) <EOL> }","docstring":"/**\n * Converts the characters from a portion of the specified array to a string.\n *\n * @throws IndexOutOfBoundsException if either [offset] or [length] are less than zero\n * or `offset + length` is out of [chars] array bounds.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual fun CharArray . concatToString ( ) : String","body":"{ <EOL> val thisStorage = this . storage <EOL> val thisLength = thisStorage . len ( ) <EOL> val copy = WasmCharArray ( thisLength ) <EOL> copyWasmArray ( this . storage , copy , <NUM_LIT:0> , <NUM_LIT:0> , thisLength ) <EOL> return copy . createString ( ) <EOL> }","docstring":"/**\n * Concatenates characters in this [CharArray] into a String.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun CharArray . concatToString ( startIndex : Int = <NUM_LIT:0> , endIndex : Int = this . size ) : String","body":"{ <EOL> AbstractList . checkBoundsIndexes ( startIndex , endIndex , this . size ) <EOL> val length = endIndex - startIndex <EOL> val copy = WasmCharArray ( length ) <EOL> copyWasmArray ( this . storage , copy , startIndex , <NUM_LIT:0> , length ) <EOL> return copy . createString ( ) <EOL> }","docstring":"/**\n * Concatenates characters in this [CharArray] or its subrange into a String.\n *\n * @param startIndex the beginning (inclusive) of the subrange of characters, 0 by default.\n * @param endIndex the end (exclusive) of the subrange of characters, size of this array by default.\n *\n * @throws IndexOutOfBoundsException if [startIndex] is less than zero or [endIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [startIndex] is greater than [endIndex].\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual fun String . toCharArray ( ) : CharArray","body":"{ <EOL> val thisChars = this . chars <EOL> val thisLength = thisChars . len ( ) <EOL> val newArray = CharArray ( thisLength ) <EOL> copyWasmArray ( thisChars , newArray . storage , <NUM_LIT:0> , <NUM_LIT:0> , thisLength ) <EOL> return newArray <EOL> }","docstring":"/**\n * Returns a [CharArray] containing characters of this string.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun String . toCharArray ( startIndex : Int = <NUM_LIT:0> , endIndex : Int = this . length ) : CharArray","body":"{ <EOL> AbstractList . checkBoundsIndexes ( startIndex , endIndex , length ) <EOL> val newLength = endIndex - startIndex <EOL> val newArray = CharArray ( newLength ) <EOL> copyWasmArray ( this . chars , newArray . storage , startIndex , <NUM_LIT:0> , newLength ) <EOL> return newArray <EOL> }","docstring":"/**\n * Returns a [CharArray] containing characters of this string or its substring.\n *\n * @param startIndex the beginning (inclusive) of the substring, 0 by default.\n * @param endIndex the end (exclusive) of the substring, length of this string by default.\n *\n * @throws IndexOutOfBoundsException if [startIndex] is less than zero or [endIndex] is greater than the length of this string.\n * @throws IllegalArgumentException if [startIndex] is greater than [endIndex].\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:2.0>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun String . toCharArray ( destination : CharArray , destinationOffset : Int = <NUM_LIT:0> , startIndex : Int = <NUM_LIT:0> , endIndex : Int = length ) : CharArray","body":"{ <EOL> AbstractList . checkBoundsIndexes ( startIndex , endIndex , length ) <EOL> val rangeSize = endIndex - startIndex <EOL> AbstractList . checkBoundsIndexes ( destinationOffset , destinationOffset + rangeSize , destination . size ) <EOL> copyWasmArray ( this . chars , destination . storage , startIndex , destinationOffset , rangeSize ) <EOL> return destination <EOL> }","docstring":"/**\n * Copies characters from this string into the [destination] character array and returns that array.\n *\n * @param destination the array to copy to.\n * @param destinationOffset the position in the array to copy to.\n * @param startIndex the start offset (inclusive) of the substring to copy.\n * @param endIndex the end offset (exclusive) of the substring to copy.\n *\n * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this string builder indices or when `startIndex > endIndex`.\n * @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],\n * or when that index is out of the [destination] array indices range.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual fun ByteArray . decodeToString ( ) : String","body":"{ <EOL> return decodeUtf8 ( this , <NUM_LIT:0> , size , false ) <EOL> }","docstring":"/**\n * Decodes a string from the bytes in UTF-8 encoding in this array.\n *\n * Malformed byte sequences are replaced by the replacement char `\\uFFFD`.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun ByteArray . decodeToString ( startIndex : Int = <NUM_LIT:0> , endIndex : Int = this . size , throwOnInvalidSequence : Boolean = false ) : String","body":"{ <EOL> AbstractList . checkBoundsIndexes ( startIndex , endIndex , this . size ) <EOL> return decodeUtf8 ( this , startIndex , endIndex , throwOnInvalidSequence ) <EOL> }","docstring":"/**\n * Decodes a string from the bytes in UTF-8 encoding in this array or its subrange.\n *\n * @param startIndex the beginning (inclusive) of the subrange to decode, 0 by default.\n * @param endIndex the end (exclusive) of the subrange to decode, size of this array by default.\n * @param throwOnInvalidSequence specifies whether to throw an exception on malformed byte sequence or replace it by the replacement char `\\uFFFD`.\n *\n * @throws IndexOutOfBoundsException if [startIndex] is less than zero or [endIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [startIndex] is greater than [endIndex].\n * @throws CharacterCodingException if the byte array contains malformed UTF-8 byte sequence and [throwOnInvalidSequence] is true.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public actual fun String . encodeToByteArray ( ) : ByteArray","body":"{ <EOL> return encodeUtf8 ( this , <NUM_LIT:0> , length , false ) <EOL> }","docstring":"/**\n * Encodes this string to an array of bytes in UTF-8 encoding.\n *\n * Any malformed char sequence is replaced by the replacement byte sequence.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun String . encodeToByteArray ( startIndex : Int = <NUM_LIT:0> , endIndex : Int = this . length , throwOnInvalidSequence : Boolean = false ) : ByteArray","body":"{ <EOL> AbstractList . checkBoundsIndexes ( startIndex , endIndex , length ) <EOL> return encodeUtf8 ( this , startIndex , endIndex , throwOnInvalidSequence ) <EOL> }","docstring":"/**\n * Encodes this string or its substring to an array of bytes in UTF-8 encoding.\n *\n * @param startIndex the beginning (inclusive) of the substring to encode, 0 by default.\n * @param endIndex the end (exclusive) of the substring to encode, length of this string by default.\n * @param throwOnInvalidSequence specifies whether to throw an exception on malformed char sequence or replace.\n *\n * @throws IndexOutOfBoundsException if [startIndex] is less than zero or [endIndex] is greater than the length of this string.\n * @throws IllegalArgumentException if [startIndex] is greater than [endIndex].\n * @throws CharacterCodingException if this string contains malformed char sequence and [throwOnInvalidSequence] is true.\n */"}
{"signature":"public actual fun String . substring ( startIndex : Int ) : String","body":"= <EOL> subSequence ( startIndex , this . length ) as String","docstring":"/**\n * Returns a substring of this string that starts at the specified [startIndex] and continues to the end of the string.\n */"}
{"signature":"public actual fun String . substring ( startIndex : Int , endIndex : Int ) : String","body":"= <EOL> subSequence ( startIndex , endIndex ) as String","docstring":"/**\n * Returns the substring of this string starting at the [startIndex] and ending right before the [endIndex].\n *\n * @param startIndex the start index (inclusive).\n * @param endIndex the end index (exclusive).\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" , ReplaceWith ( \"<STR_LIT>\" ) ) <EOL> @ DeprecatedSinceKotlin ( warningSince = \"<STR_LIT:1.5>\" ) <EOL> public actual fun String . toUpperCase ( ) : String","body":"= uppercase ( )","docstring":"/**\n * Returns a copy of this string converted to upper case using the rules of the default locale.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.5>\" ) <EOL> public actual fun String . uppercase ( ) : String","body":"= uppercaseImpl ( )","docstring":"/**\n * Returns a copy of this string converted to upper case using Unicode mapping rules of the invariant locale.\n *\n * This function supports one-to-many and many-to-one character mapping,\n * thus the length of the returned string can be different from the length of the original string.\n *\n * @sample samples.text.Strings.uppercase\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" , ReplaceWith ( \"<STR_LIT>\" ) ) <EOL> @ DeprecatedSinceKotlin ( warningSince = \"<STR_LIT:1.5>\" ) <EOL> public actual fun String . toLowerCase ( ) : String","body":"= lowercase ( )","docstring":"/**\n * Returns a copy of this string converted to lower case using the rules of the default locale.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.5>\" ) <EOL> public actual fun String . lowercase ( ) : String","body":"= lowercaseImpl ( )","docstring":"/**\n * Returns a copy of this string converted to lower case using Unicode mapping rules of the invariant locale.\n *\n * This function supports one-to-many and many-to-one character mapping,\n * thus the length of the returned string can be different from the length of the original string.\n *\n * @sample samples.text.Strings.lowercase\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" , ReplaceWith ( \"<STR_LIT>\" ) ) <EOL> @ DeprecatedSinceKotlin ( warningSince = \"<STR_LIT:1.5>\" ) <EOL> public actual fun String . capitalize ( ) : String","body":"= replaceFirstChar ( Char :: uppercaseChar )","docstring":"/**\n * Returns a copy of this string having its first letter titlecased using the rules of the default locale,\n * or the original string if it's empty or already starts with a title case letter.\n *\n * The title case of a character is usually the same as its upper case with several exceptions.\n * The particular list of characters with the special title case form depends on the underlying platform.\n *\n * @sample samples.text.Strings.capitalize\n */"}
{"signature":"@ Deprecated ( \"<STR_LIT>\" , ReplaceWith ( \"<STR_LIT>\" ) ) <EOL> @ DeprecatedSinceKotlin ( warningSince = \"<STR_LIT:1.5>\" ) <EOL> public actual fun String . decapitalize ( ) : String","body":"= replaceFirstChar ( Char :: lowercaseChar )","docstring":"/**\n * Returns a copy of this string having its first letter lowercased using the rules of the default locale,\n * or the original string if it's empty or already starts with a lower case letter.\n *\n * @sample samples.text.Strings.decapitalize\n */"}
{"signature":"public actual fun CharSequence . repeat ( n : Int ) : String","body":"{ <EOL> require ( n >= <NUM_LIT:0> ) { \"<STR_LIT>\" } <EOL> if ( isEmpty ( ) ) return \"<STR_LIT>\" <EOL> return when ( n ) { <EOL> <NUM_LIT:0> -> \"<STR_LIT>\" <EOL> <NUM_LIT:1> -> this . toString ( ) <EOL> else -> { <EOL> val sequence = this <EOL> buildString ( n * length ) { <EOL> repeat ( n ) { <EOL> append ( sequence ) <EOL> } <EOL> } <EOL> } <EOL> } <EOL> }","docstring":"/**\n * Returns a string containing this char sequence repeated [n] times.\n * @throws [IllegalArgumentException] when n < 0.\n * @sample samples.text.Strings.repeat\n */"}
{"signature":"@ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun String . replace ( oldChar : Char , newChar : Char , ignoreCase : Boolean = false ) : String","body":"{ <EOL> return buildString ( length ) { <EOL> this@replace . forEach { c -> <EOL> append ( if ( c . equals ( oldChar , ignoreCase ) ) newChar else c ) <EOL> } <EOL> } <EOL> }","docstring":"/**\n * Returns a new string with all occurrences of [oldChar] replaced with [newChar].\n */"}
{"signature":"@ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun String . replace ( oldValue : String , newValue : String , ignoreCase : Boolean = false ) : String","body":"{ <EOL> run { <EOL> var occurrenceIndex : Int = indexOf ( oldValue , <NUM_LIT:0> , ignoreCase ) <EOL> if ( occurrenceIndex < <NUM_LIT:0> ) return this <EOL> val oldValueLength = oldValue . length <EOL> val searchStep = oldValueLength . coerceAtLeast ( <NUM_LIT:1> ) <EOL> val newLengthHint = length - oldValueLength + newValue . length <EOL> if ( newLengthHint < <NUM_LIT:0> ) throw OutOfMemoryError ( ) <EOL> val stringBuilder = StringBuilder ( newLengthHint ) <EOL> var i = <NUM_LIT:0> <EOL> do { <EOL> stringBuilder . append ( this , i , occurrenceIndex ) . append ( newValue ) <EOL> i = occurrenceIndex + oldValueLength <EOL> if ( occurrenceIndex >= length ) break <EOL> occurrenceIndex = indexOf ( oldValue , occurrenceIndex + searchStep , ignoreCase ) <EOL> } while ( occurrenceIndex > <NUM_LIT:0> ) <EOL> return stringBuilder . append ( this , i , length ) . toString ( ) <EOL> } <EOL> }","docstring":"/**\n * Returns a new string obtained by replacing all occurrences of the [oldValue] substring in this string\n * with the specified [newValue] string.\n */"}
{"signature":"@ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun String . replaceFirst ( oldChar : Char , newChar : Char , ignoreCase : Boolean = false ) : String","body":"{ <EOL> val index = indexOf ( oldChar , ignoreCase = ignoreCase ) <EOL> return if ( index < <NUM_LIT:0> ) this else this . replaceRange ( index , index + <NUM_LIT:1> , newChar . toString ( ) ) <EOL> }","docstring":"/**\n * Returns a new string with the first occurrence of [oldChar] replaced with [newChar].\n */"}
{"signature":"@ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun String . replaceFirst ( oldValue : String , newValue : String , ignoreCase : Boolean = false ) : String","body":"{ <EOL> val index = indexOf ( oldValue , ignoreCase = ignoreCase ) <EOL> return if ( index < <NUM_LIT:0> ) this else this . replaceRange ( index , index + oldValue . length , newValue ) <EOL> }","docstring":"/**\n * Returns a new string obtained by replacing the first occurrence of the [oldValue] substring in this string\n * with the specified [newValue] string.\n */"}
{"signature":"@ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun String ? . equals ( other : String ? , ignoreCase : Boolean = false ) : Boolean","body":"{ <EOL> if ( this == null ) return other == null <EOL> if ( other == null ) return false <EOL> if ( ! ignoreCase ) return this == other <EOL> if ( this . length != other . length ) return false <EOL> for ( index in <NUM_LIT:0> until this . length ) { <EOL> val thisChar = this [ index ] <EOL> val otherChar = other [ index ] <EOL> if ( ! thisChar . equals ( otherChar , ignoreCase ) ) { <EOL> return false <EOL> } <EOL> } <EOL> return true <EOL> }","docstring":"/**\n * Returns `true` if this string is equal to [other], optionally ignoring character case.\n *\n * Two strings are considered to be equal if they have the same length and the same character at the same index.\n * If [ignoreCase] is true, the result of `Char.uppercaseChar().lowercaseChar()` on each character is compared.\n *\n * @param ignoreCase `true` to ignore character case when comparing strings. By default `false`.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.2>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun String . compareTo ( other : String , ignoreCase : Boolean = false ) : Int","body":"{ <EOL> if ( ignoreCase ) { <EOL> val n1 = this . length <EOL> val n2 = other . length <EOL> val min = minOf ( n1 , n2 ) <EOL> if ( min == <NUM_LIT:0> ) return n1 - n2 <EOL> for ( index in <NUM_LIT:0> until min ) { <EOL> var thisChar = this [ index ] <EOL> var otherChar = other [ index ] <EOL> if ( thisChar != otherChar ) { <EOL> thisChar = thisChar . uppercaseChar ( ) <EOL> otherChar = otherChar . uppercaseChar ( ) <EOL> if ( thisChar != otherChar ) { <EOL> thisChar = thisChar . lowercaseChar ( ) <EOL> otherChar = otherChar . lowercaseChar ( ) <EOL> if ( thisChar != otherChar ) { <EOL> return thisChar . compareTo ( otherChar ) <EOL> } <EOL> } <EOL> } <EOL> } <EOL> return n1 - n2 <EOL> } else { <EOL> return compareTo ( other ) <EOL> } <EOL> }","docstring":"/**\n * Compares two strings lexicographically, optionally ignoring case differences.\n *\n * If [ignoreCase] is true, the result of `Char.uppercaseChar().lowercaseChar()` on each character is compared.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.5>\" ) <EOL> public actual infix fun CharSequence ? . contentEquals ( other : CharSequence ? ) : Boolean","body":"= contentEqualsImpl ( other )","docstring":"/**\n * Returns `true` if the contents of this char sequence are equal to the contents of the specified [other],\n * i.e. both char sequences contain the same number of the same characters in the same order.\n *\n * @sample samples.text.Strings.contentEquals\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.5>\" ) <EOL> public actual fun CharSequence ? . contentEquals ( other : CharSequence ? , ignoreCase : Boolean ) : Boolean","body":"{ <EOL> return if ( ignoreCase ) <EOL> this . contentEqualsIgnoreCaseImpl ( other ) <EOL> else <EOL> this . contentEqualsImpl ( other ) <EOL> }","docstring":"/**\n * Returns `true` if the contents of this char sequence are equal to the contents of the specified [other], optionally ignoring case difference.\n *\n * @param ignoreCase `true` to ignore character case when comparing contents.\n *\n * @sample samples.text.Strings.contentEquals\n */"}
{"signature":"@ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun String . startsWith ( prefix : String , ignoreCase : Boolean = false ) : Boolean","body":"= <EOL> regionMatches ( <NUM_LIT:0> , prefix , <NUM_LIT:0> , prefix . length , ignoreCase )","docstring":"/**\n * Returns `true` if this string starts with the specified prefix.\n */"}
{"signature":"@ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun String . startsWith ( prefix : String , startIndex : Int , ignoreCase : Boolean = false ) : Boolean","body":"= <EOL> regionMatches ( startIndex , prefix , <NUM_LIT:0> , prefix . length , ignoreCase )","docstring":"/**\n * Returns `true` if a substring of this string starting at the specified offset [startIndex] starts with the specified prefix.\n */"}
{"signature":"@ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun String . endsWith ( suffix : String , ignoreCase : Boolean = false ) : Boolean","body":"= <EOL> regionMatches ( length - suffix . length , suffix , <NUM_LIT:0> , suffix . length , ignoreCase )","docstring":"/**\n * Returns `true` if this string ends with the specified suffix.\n */"}
{"signature":"public actual fun CharSequence . regionMatches ( thisOffset : Int , other : CharSequence , otherOffset : Int , length : Int , ignoreCase : Boolean ) : Boolean","body":"= regionMatchesImpl ( thisOffset , other , otherOffset , length , ignoreCase )","docstring":"/**\n * Returns `true` if the specified range in this char sequence is equal to the specified range in another char sequence.\n * @param thisOffset the start offset in this char sequence of the substring to compare.\n * @param other the string against a substring of which the comparison is performed.\n * @param otherOffset the start offset in the other char sequence of the substring to compare.\n * @param length the length of the substring to compare.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.9>\" ) <EOL> @ Suppress ( \"<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>\" ) <EOL> public actual fun String . regionMatches ( thisOffset : Int , other : String , otherOffset : Int , length : Int , ignoreCase : Boolean = false ) : Boolean","body":"= regionMatchesImpl ( thisOffset , other , otherOffset , length , ignoreCase )","docstring":"/**\n * Returns `true` if the specified range in this string is equal to the specified range in another string.\n * @param thisOffset the start offset in this string of the substring to compare.\n * @param other the string against a substring of which the comparison is performed.\n * @param otherOffset the start offset in the other string of the substring to compare.\n * @param length the length of the substring to compare.\n */"}
{"signature":"fun lenetWithEarlyStoppingCallback ( )","body":"{ <EOL> val ( train , test ) = mnist ( ) <EOL> lenet5Classic . use { <EOL> val earlyStopping = EarlyStopping ( monitor = EpochTrainingEvent :: valLossValue , minDelta = <NUM_LIT:0.0> , patience = <NUM_LIT:2> , verbose = true , mode = EarlyStoppingMode . AUTO , baseline = <NUM_LIT> , restoreBestWeights = false ) <EOL> it . compile ( optimizer = Adam ( clipGradient = ClipGradientByValue ( <NUM_LIT> ) ) , loss = Losses . SOFT_MAX_CROSS_ENTROPY_WITH_LOGITS , metric = Metrics . ACCURACY ) <EOL> it . logSummary ( ) <EOL> it . fit ( dataset = train , epochs = EPOCHS , batchSize = TRAINING_BATCH_SIZE , earlyStopping ) <EOL> val accuracy = it . evaluate ( dataset = test , batchSize = TEST_BATCH_SIZE ) . metrics [ Metrics . ACCURACY ] <EOL> println ( \"<STR_LIT>\" ) <EOL> } <EOL> }","docstring":"/**\n * This example shows how to do image classification from scratch using [lenet5Classic], without leveraging pre-trained weights or a pre-made model.\n * We demonstrate the workflow on the Mnist classification dataset.\n *\n * It includes:\n * - dataset loading from S3\n * - callback definition\n * - model compilation with [EarlyStopping] callback\n * - model summary\n * - model training\n * - model evaluation\n */"}
{"signature":"fun main ( ) : Unit","body":"= lenetWithEarlyStoppingCallback ( )","docstring":"/** */"}
{"signature":"fun append ( charCode : Int , categoryId : String ) : Boolean","body":"fun append ( charCode : Int , categoryId : String ) : Boolean","docstring":"/**\n * Appends the [charCode] to this range pattern.\n * Returns true if the [charCode] with the specified [categoryId] could be accommodated within this pattern.\n * Returns false otherwise.\n */"}
{"signature":"fun prepend ( charCode : Int , categoryId : String ) : Boolean","body":"fun prepend ( charCode : Int , categoryId : String ) : Boolean","docstring":"/**\n * Prepends the [charCode] to this range pattern.\n * Returns true if the [charCode] with the specified [categoryId] could be accommodated within this pattern.\n * Returns false otherwise.\n */"}
{"signature":"fun rangeStart ( ) : Int","body":"fun rangeStart ( ) : Int","docstring":"/**\n * Char code of the first char in this range.\n */"}
{"signature":"fun rangeEnd ( ) : Int","body":"fun rangeEnd ( ) : Int","docstring":"/**\n * Char code of the last char in this range.\n */"}
{"signature":"fun category ( ) : Int","body":"fun category ( ) : Int","docstring":"/**\n * An integer value that contains information about the category of each char in this range.\n */"}
{"signature":"fun categoryIdOf ( charCode : Int ) : String","body":"fun categoryIdOf ( charCode : Int ) : String","docstring":"/**\n * Returns category id of the char with the specified [charCode].\n * Throws an exception if the [charCode] is not in `rangeStart()..rangeEnd()`.\n */"}
{"signature":"operator fun Product . contains ( item : Any ? ) : Boolean","body":"= productIterator ( ) . contains ( item )","docstring":"/** Tests whether this iterator contains a given value as an element.\n * Note: may not terminate for infinite iterators.\n *\n * @param item the element to test.\n * @return `true` if this iterator produces some value that\n * is equal (as determined by `==`) to `elem`, `false` otherwise.\n * @note Reuse: After calling this method, one should discard the iterator it was called on.\n * Using it is undefined and subject to change.\n */"}
{"signature":"operator fun Product . iterator ( ) : Iterator < Any ? >","body":"= JavaConverters . asJavaIterator ( productIterator ( ) )","docstring":"/**\n * An iterator over all the elements of this product.\n * @return in the default implementation, an `Iterator<Any?>`\n */"}
{"signature":"fun Product . asIterable ( ) : Iterable < Any ? >","body":"= object : Iterable < Any ? > { <EOL> override fun iterator ( ) : Iterator < Any ? > = JavaConverters . asJavaIterator ( productIterator ( ) ) <EOL> }","docstring":"/**\n * Converts this product to an `Any?` iterable.\n */"}
{"signature":"@ Throws ( IndexOutOfBoundsException :: class ) <EOL> operator fun Product . get ( n : Int ) : Any ?","body":"= productElement ( n )","docstring":"/** The n'th element of this product, 0-based. In other words, for a\n * product `A(x,,1,,, ..., x,,k,,)`, returns `x,,(n+1),,` where `0 <= n < k`.\n *\n * @param n the index of the element to return\n * @throws IndexOutOfBoundsException\n * @return the element `n` elements after the first element\n */"}
{"signature":"fun Product . getOrNull ( n : Int ) : Any ?","body":"= if ( n in <NUM_LIT:0> until size ) productElement ( n ) else null","docstring":"/** The n'th element of this product, 0-based. In other words, for a\n * product `A(x,,1,,, ..., x,,k,,)`, returns `x,,(n+1),,` where `0 <= n < k`.\n *\n * @param n the index of the element to return\n * @return the element `n` elements after the first element, `null` if out of bounds\n */"}
{"signature":"@ Suppress ( \"<STR_LIT:UNCHECKED_CAST>\" ) <EOL> @ Throws ( IndexOutOfBoundsException :: class , ClassCastException :: class ) <EOL> inline fun < reified T > Product . getAs ( n : Int ) : T","body":"= productElement ( n ) as T","docstring":"/** The n'th element of this product, 0-based. In other words, for a\n * product `A(x,,1,,, ..., x,,k,,)`, returns `x,,(n+1),,` where `0 <= n < k`.\n * The result is cast to the given type [T].\n *\n * @param n the index of the element to return\n * @throws IndexOutOfBoundsException\n * @throws ClassCastException\n * @return the element `n` elements after the first element\n */"}
{"signature":"@ Suppress ( \"<STR_LIT:UNCHECKED_CAST>\" ) <EOL> inline fun < reified T > Product . getAsOrNull ( n : Int ) : T ?","body":"= getOrNull ( n ) as? T","docstring":"/** The n'th element of this product, 0-based. In other words, for a\n * product `A(x,,1,,, ..., x,,k,,)`, returns `x,,(n+1),,` where `0 <= n < k`.\n * The result is cast to the given type [T].\n *\n * @param n the index of the element to return\n * @return the element `n` elements after the first element, `null` if out of bounds or unable to be cast\n */"}
{"signature":"@ Throws ( IndexOutOfBoundsException :: class ) <EOL> operator fun Product . get ( indexRange : IntRange ) : List < Any ? >","body":"= indexRange . map ( :: get )","docstring":"/** The range of n'th elements of this product, 0-based. In other words, for a\n * product `A(x,,1,,, ..., x,,k,,)`, returns `x,,(n+1),,` where `0 <= n < k`.\n *\n * @param indexRange the indices of the elements to return\n * @throws IndexOutOfBoundsException\n * @return the elements in [indexRange]\n */"}
{"signature":"fun Product . getOrNull ( indexRange : IntRange ) : List < Any ? >","body":"= indexRange . map ( :: getOrNull )","docstring":"/** The range of n'th elements of this product, 0-based. In other words, for a\n * product `A(x,,1,,, ..., x,,k,,)`, returns `x,,(n+1),,` where `0 <= n < k`.\n *\n * @param indexRange the indices of the elements to return\n * @return the elements in [indexRange], `null` if out of bounds\n */"}
{"signature":"@ Throws ( IndexOutOfBoundsException :: class , ClassCastException :: class ) <EOL> inline fun < reified T > Product . getAs ( indexRange : IntRange ) : List < T >","body":"= indexRange . map ( :: getAs )","docstring":"/** The range of n'th elements of this product, 0-based. In other words, for a\n * product `A(x,,1,,, ..., x,,k,,)`, returns `x,,(n+1),,` where `0 <= n < k`.\n * The results are cast to the given type [T].\n *\n * @param indexRange the indices of the elements to return\n * @throws IndexOutOfBoundsException\n * @throws ClassCastException\n * @return the elements in [indexRange]\n */"}
{"signature":"inline fun < reified T > Product . getAsOrNull ( indexRange : IntRange ) : List < T ? >","body":"= indexRange . map ( :: getAsOrNull )","docstring":"/** The range of n'th elements of this product, 0-based. In other words, for a\n * product `A(x,,1,,, ..., x,,k,,)`, returns `x,,(n+1),,` where `0 <= n < k`.\n * The results are cast to the given type [T].\n *\n * @param indexRange the indices of the elements to return\n * @return the elements in [indexRange], `null` is out of bounds or unable to be cast\n */"}
{"signature":"fun getConstraintsContainedSpecifiedTypeVariable ( typeVariableConstructor : TypeConstructorMarker ) : Collection < Constraint >","body":"fun getConstraintsContainedSpecifiedTypeVariable ( typeVariableConstructor : TypeConstructorMarker ) : Collection < Constraint >","docstring":"/**\n * Only necessary for incorporation optimization\n */"}
{"signature":"@ Test <EOL> fun testResumingFromAnotherThread ( )","body":"= runTest { <EOL> suspendCancellableCoroutine < Unit > { cont -> <EOL> thread { <EOL> Thread . sleep ( <NUM_LIT:10> ) <EOL> cont . resume ( Unit ) <EOL> } <EOL> } <EOL> }","docstring":"/** Tests that resuming the coroutine of [runTest] asynchronously in reasonable time succeeds. */"}
{"signature":"@ Test <EOL> fun testStandardTestDispatcherIsConfined ( ) : Unit","body":"= runBlocking { <EOL> val scheduler = TestCoroutineScheduler ( ) <EOL> val initialThread = Thread . currentThread ( ) <EOL> val job = launch ( StandardTestDispatcher ( scheduler ) ) { <EOL> assertEquals ( initialThread , Thread . currentThread ( ) ) <EOL> withContext ( Dispatchers . IO ) { <EOL> val ioThread = Thread . currentThread ( ) <EOL> assertNotSame ( initialThread , ioThread ) <EOL> } <EOL> assertEquals ( initialThread , Thread . currentThread ( ) ) <EOL> } <EOL> scheduler . advanceUntilIdle ( ) <EOL> while ( job . isActive ) { <EOL> scheduler . receiveDispatchEvent ( ) <EOL> scheduler . advanceUntilIdle ( ) <EOL> } <EOL> }","docstring":"/** Tests that [StandardTestDispatcher] is not executed in-place but confined to the thread in which the\n * virtual time control happens. */"}
{"signature":"public fun thread ( start : Boolean = true , isDaemon : Boolean = false , contextClassLoader : ClassLoader ? = null , name : String ? = null , priority : Int = - <NUM_LIT:1> , block : ( ) -> Unit ) : Thread","body":"{ <EOL> val thread = object : Thread ( ) { <EOL> public override fun run ( ) { <EOL> block ( ) <EOL> } <EOL> } <EOL> if ( isDaemon ) <EOL> thread . isDaemon = true <EOL> if ( priority > <NUM_LIT:0> ) <EOL> thread . priority = priority <EOL> if ( name != null ) <EOL> thread . name = name <EOL> if ( contextClassLoader != null ) <EOL> thread . contextClassLoader = contextClassLoader <EOL> if ( start ) <EOL> thread . start ( ) <EOL> return thread <EOL> }","docstring":"/**\n * Creates a thread that runs the specified [block] of code.\n *\n * @param start if `true`, the thread is immediately started.\n * @param isDaemon if `true`, the thread is created as a daemon thread. The Java Virtual Machine exits when\n * the only threads running are all daemon threads.\n * @param contextClassLoader the class loader to use for loading classes and resources in this thread.\n * @param name the name of the thread.\n * @param priority the priority of the thread.\n */"}
{"signature":"@ kotlin . internal . InlineOnly <EOL> public inline fun < T : Any > ThreadLocal < T > . getOrSet ( default : ( ) -> T ) : T","body":"{ <EOL> return get ( ) ? : default ( ) . also ( this :: set ) <EOL> }","docstring":"/**\n * Gets the value in the current thread's copy of this\n * thread-local variable or replaces the value with the result of calling\n * [default] function in case if that value was `null`.\n *\n * If the variable has no value for the current thread,\n * it is first initialized to the value returned\n * by an invocation of the [ThreadLocal.initialValue] method.\n * Then if it is still `null`, the provided [default] function is called and its result\n * is stored for the current thread and then returned.\n */"}
{"signature":"fun x ( )","body":"{ }","docstring":"/**\n * [LazyThreadSafetyMode.PUB<caret>LICATION]\n */"}
{"signature":"fun lenetOnMnistInferenceWithTensorNames ( )","body":"{ <EOL> val ( train , test ) = mnist ( ) <EOL> SavedModel . load ( PATH_TO_MODEL ) . use { <EOL> println ( it . graphToString ( ) ) <EOL> val prediction = it . predict ( train . getX ( <NUM_LIT:0> ) , \"<STR_LIT>\" , \"<STR_LIT>\" ) <EOL> println ( \"<STR_LIT>\" ) <EOL> println ( \"<STR_LIT>\" + train . getY ( <NUM_LIT:0> ) ) <EOL> val predictions = it . predict ( test ) { data -> predict ( data , \"<STR_LIT>\" , \"<STR_LIT>\" ) } <EOL> println ( predictions . toString ( ) ) <EOL> println ( \"<STR_LIT>\" ) <EOL> } <EOL> }","docstring":"/**\n * This examples demonstrates running [SavedModel] for prediction on [mnist] dataset.\n *\n * It uses string tensor names to get access to input/output tensors in TensorFlow static graph.\n */"}
{"signature":"fun main ( ) : Unit","body":"= lenetOnMnistInferenceWithTensorNames ( )","docstring":"/** */"}
{"signature":"public fun append ( value : Char ) : Appendable","body":"public fun append ( value : Char ) : Appendable","docstring":"/**\n * Appends the specified character [value] to this Appendable and returns this instance.\n *\n * @param value the character to append.\n */"}
{"signature":"public fun append ( value : CharSequence ? ) : Appendable","body":"public fun append ( value : CharSequence ? ) : Appendable","docstring":"/**\n * Appends the specified character sequence [value] to this Appendable and returns this instance.\n *\n * @param value the character sequence to append. If [value] is `null`, then the four characters `\"null\"` are appended to this Appendable.\n */"}
{"signature":"public fun append ( value : CharSequence ? , startIndex : Int , endIndex : Int ) : Appendable","body":"public fun append ( value : CharSequence ? , startIndex : Int , endIndex : Int ) : Appendable","docstring":"/**\n * Appends a subsequence of the specified character sequence [value] to this Appendable and returns this instance.\n *\n * @param value the character sequence from which a subsequence is appended. If [value] is `null`,\n * then characters are appended as if [value] contained the four characters `\"null\"`.\n * @param startIndex the beginning (inclusive) of the subsequence to append.\n * @param endIndex the end (exclusive) of the subsequence to append.\n *\n * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of the [value] character sequence indices or when `startIndex > endIndex`.\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> public fun < T : Appendable > T . appendRange ( value : CharSequence , startIndex : Int , endIndex : Int ) : T","body":"{ <EOL> @ Suppress ( \"<STR_LIT:UNCHECKED_CAST>\" ) <EOL> return append ( value , startIndex , endIndex ) as T <EOL> }","docstring":"/**\n * Appends a subsequence of the specified character sequence [value] to this Appendable and returns this instance.\n *\n * @param value the character sequence from which a subsequence is appended.\n * @param startIndex the beginning (inclusive) of the subsequence to append.\n * @param endIndex the end (exclusive) of the subsequence to append.\n *\n * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of the [value] character sequence indices or when `startIndex > endIndex`.\n */"}
{"signature":"public fun < T : Appendable > T . append ( vararg value : CharSequence ? ) : T","body":"{ <EOL> for ( item in value ) <EOL> append ( item ) <EOL> return this <EOL> }","docstring":"/**\n * Appends all arguments to the given [Appendable].\n */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun Appendable . appendLine ( ) : Appendable","body":"= append ( '<CHAR_LIT:\\n>' )","docstring":"/** Appends a line feed character (`\\n`) to this Appendable. */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun Appendable . appendLine ( value : CharSequence ? ) : Appendable","body":"= append ( value ) . appendLine ( )","docstring":"/** Appends value to the given Appendable and a line feed character (`\\n`) after it. */"}
{"signature":"@ SinceKotlin ( \"<STR_LIT:1.4>\" ) <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun Appendable . appendLine ( value : Char ) : Appendable","body":"= append ( value ) . appendLine ( )","docstring":"/** Appends value to the given Appendable and a line feed character (`\\n`) after it. */"}
{"signature":"internal fun decompiledText ( file : FileWithMetadata . Compatible , serializerProtocol : SerializerExtensionProtocol , flexibleTypeDeserializer : FlexibleTypeDeserializer , renderer : DescriptorRenderer , deserializationConfiguration : DeserializationConfiguration = DeserializationConfiguration . Default ) : DecompiledText","body":"{ <EOL> val packageFqName = file . packageFqName <EOL> val resolver = KlibMetadataDeserializerForDecompiler ( packageFqName , file . proto , file . nameResolver , serializerProtocol , flexibleTypeDeserializer , deserializationConfiguration , ) <EOL> val declarations = arrayListOf < DeclarationDescriptor > ( ) <EOL> declarations . addAll ( resolver . resolveDeclarationsInFacade ( packageFqName ) ) <EOL> for ( classProto in file . classesToDecompile ) { <EOL> val classId = file . nameResolver . getClassId ( classProto . fqName ) <EOL> declarations . addIfNotNull ( resolver . resolveTopLevelClass ( classId ) ) <EOL> } <EOL> return buildDecompiledText ( packageFqName , declarations , renderer ) <EOL> }","docstring":"/**\n * This function is extracted for [Fe10KlibMetadataDecompiler], [Fe10KlibMetadataStubBuilder] and [K2KlibMetadataDecompiler].\n * TODO: K2 shouldn't use descriptor renderer for building decompiled text.\n * Note that decompiled text is not used for building stubs in K2.\n * That's why in K2 it is important to preserve declaration order during deserialization to not get PSI vs. stubs mismatch.\n */"}
{"signature":"fun getPreviewImageBounds ( sourceImageWidth : Int , sourceImageHeight : Int , viewWidth : Int , viewHeight : Int , scaleType : PreviewView . ScaleType ) : PreviewImageBounds","body":"{ <EOL> val scale = if ( scaleType == PreviewView . ScaleType . FILL_START || scaleType == PreviewView . ScaleType . FILL_END || scaleType == PreviewView . ScaleType . FILL_CENTER ) { <EOL> max ( viewWidth . toFloat ( ) / sourceImageWidth , viewHeight . toFloat ( ) / sourceImageHeight ) <EOL> } else { <EOL> min ( viewWidth . toFloat ( ) / sourceImageWidth , viewHeight . toFloat ( ) / sourceImageHeight ) <EOL> } <EOL> val previewImageWidth = sourceImageWidth * scale <EOL> val previewImageHeight = sourceImageHeight * scale <EOL> return when ( scaleType ) { <EOL> PreviewView . ScaleType . FILL_START , PreviewView . ScaleType . FIT_START -> { <EOL> PreviewImageBounds ( <NUM_LIT> , <NUM_LIT> , previewImageWidth , previewImageHeight ) <EOL> } <EOL> PreviewView . ScaleType . FILL_END , PreviewView . ScaleType . FIT_END -> { <EOL> PreviewImageBounds ( viewWidth - previewImageWidth , viewHeight - previewImageHeight , previewImageWidth , previewImageHeight ) <EOL> } <EOL> else -> { <EOL> PreviewImageBounds ( viewWidth / <NUM_LIT:2> - previewImageWidth / <NUM_LIT:2> , viewHeight / <NUM_LIT:2> - previewImageHeight / <NUM_LIT:2> , previewImageWidth , previewImageHeight ) <EOL> } <EOL> } <EOL> }","docstring":"/**\n * Calculate the location of the preview image top-left corner (relative to the component top-left corner)\n * and dimensions, to be used for displaying detected objects, for example with the [DetectorViewBase].\n *\n * When camera preview resolution differs from the dimensions of the [PreviewView] used to display camera input,\n * image is scaled and cropped or padded according to the provided [PreviewView.ScaleType]. Because of this,\n * in order to display detected objects on the [PreviewView], their coordinates need to be converted.\n * This method returns [PreviewImageBounds] object containing the necessary information to preform the conversion\n * from the image coordinate system to the view coordinate system.\n *\n * @param [sourceImageWidth] width of the image from the camera\n * @param [sourceImageHeight] height of the image from the camera\n * @param [viewWidth] width of the target [PreviewView]\n * @param [viewHeight] height of the target [PreviewView]\n * @param [scaleType] scaling option used in the target [PreviewView]\n *\n * @see <a href=\"https://developer.android.com/training/camerax/preview#scale-type\">Scale type</a>\n */"}
{"signature":"internal fun generateKotlinVersion ( apiDir : File , filePrinter : ( targetFile : File , Printer . ( ) -> Unit ) -> Unit )","body":"{ <EOL> val kotlinVersionFqName = FqName ( \"<STR_LIT>\" ) <EOL> filePrinter ( fileFromFqName ( apiDir , kotlinVersionFqName ) ) { <EOL> generateDeclaration ( \"<STR_LIT>\" , kotlinVersionFqName , afterType = \"<STR_LIT>\" ) { <EOL> for ( languageVersion in LanguageVersion . values ( ) ) { <EOL> val prefix = when { <EOL> languageVersion . isUnsupported -> \"<STR_LIT>\" <EOL> languageVersion . isDeprecated -> \"<STR_LIT>\" <EOL> else -> \"<STR_LIT>\" <EOL> } <EOL> println ( \"<STR_LIT>\" ) <EOL> } <EOL> println ( \"<STR_LIT:;>\" ) <EOL> println ( ) <EOL> println ( \"<STR_LIT>\" ) <EOL> withIndent { <EOL> println ( \"<STR_LIT>\" ) <EOL> println ( \"<STR_LIT>\" ) <EOL> println ( \"<STR_LIT>\" ) <EOL> println ( \"<STR_LIT>\" ) <EOL> println ( ) <EOL> println ( \"<STR_LIT>\" ) <EOL> println ( \"<STR_LIT>\" ) <EOL> } <EOL> println ( \"<STR_LIT:}>\" ) <EOL> } <EOL> } <EOL> }","docstring":"/**\n * ApiVersion and LanguageVersion are almost the same in the compiler api, so Gradle DSL options\n * exposes KotlinVersion that covers both of them.\n */"}
{"signature":"public fun chars ( value : String )","body":"public fun chars ( value : String )","docstring":"/**\n * A literal string.\n *\n * When formatting, the string is appended to the result as is,\n * and when parsing, the string is expected to be present in the input verbatim.\n */"}
{"signature":"public fun year ( padding : Padding = Padding . ZERO )","body":"public fun year ( padding : Padding = Padding . ZERO )","docstring":"/**\n * A year number.\n *\n * By default, for years [-9999..9999], it's formatted as a decimal number, zero-padded to four digits, though\n * this padding can be disabled or changed to space padding by passing [padding].\n * For years outside this range, it's formatted as a decimal number with a leading sign, so the year 12345\n * is formatted as \"+12345\".\n */"}
{"signature":"public fun yearTwoDigits ( baseYear : Int )","body":"public fun yearTwoDigits ( baseYear : Int )","docstring":"/**\n * The last two digits of the ISO year.\n *\n * [baseYear] is the base year for the two-digit year.\n * For example, if [baseYear] is 1960, then this format correctly works with years [1960..2059].\n *\n * On formatting, when given a year in the valid range, it returns the last two digits of the year,\n * so 1993 becomes \"93\". When given a year outside the valid range, it returns the full year number\n * with a leading sign, so 1850 becomes \"+1850\", and -200 becomes \"-200\".\n *\n * On parsing, it accepts either a two-digit year or a full year number with a leading sign.\n * When given a two-digit year, it returns a year in the valid range, so \"93\" becomes 1993,\n * and when given a full year number with a leading sign, it parses the full year number,\n * so \"+1850\" becomes 1850.\n */"}
{"signature":"public fun monthNumber ( padding : Padding = Padding . ZERO )","body":"public fun monthNumber ( padding : Padding = Padding . ZERO )","docstring":"/**\n * A month-of-year number, from 1 to 12.\n *\n * By default, it's padded with zeros to two digits. This can be changed by passing [padding].\n */"}
{"signature":"public fun monthName ( names : MonthNames )","body":"public fun monthName ( names : MonthNames )","docstring":"/**\n * A month name (for example, \"January\").\n *\n * Example:\n * ```\n * monthName(MonthNames.ENGLISH_FULL)\n * ```\n */"}
{"signature":"public fun dayOfMonth ( padding : Padding = Padding . ZERO )","body":"public fun dayOfMonth ( padding : Padding = Padding . ZERO )","docstring":"/**\n * A day-of-month number, from 1 to 31.\n *\n * By default, it's padded with zeros to two digits. This can be changed by passing [padding].\n */"}
{"signature":"public fun dayOfWeek ( names : DayOfWeekNames )","body":"public fun dayOfWeek ( names : DayOfWeekNames )","docstring":"/**\n * A day-of-week name (for example, \"Thursday\").\n *\n * Example:\n * ```\n * dayOfWeek(DayOfWeekNames.ENGLISH_FULL)\n * ```\n */"}
{"signature":"public fun date ( format : DateTimeFormat < LocalDate > )","body":"public fun date ( format : DateTimeFormat < LocalDate > )","docstring":"/**\n * An existing [DateTimeFormat] for the date part.\n *\n * Example:\n * ```\n * date(LocalDate.Formats.ISO)\n * ```\n */"}
{"signature":"public fun hour ( padding : Padding = Padding . ZERO )","body":"public fun hour ( padding : Padding = Padding . ZERO )","docstring":"/**\n * The hour of the day, from 0 to 23.\n *\n * By default, it's zero-padded to two digits, but this can be changed with [padding].\n */"}
{"signature":"public fun amPmHour ( padding : Padding = Padding . ZERO )","body":"public fun amPmHour ( padding : Padding = Padding . ZERO )","docstring":"/**\n * The hour of the day in the 12-hour clock:\n *\n * * Midnight is 12,\n * * Hours 1-11 are 1-11,\n * * Noon is 12,\n * * Hours 13-23 are 1-11.\n *\n * To disambiguate between the first and the second halves of the day, [amPmMarker] should be used.\n *\n * By default, it's zero-padded to two digits, but this can be changed with [padding].\n *\n * @see [amPmMarker]\n */"}
{"signature":"public fun amPmMarker ( am : String , pm : String )","body":"public fun amPmMarker ( am : String , pm : String )","docstring":"/**\n * The AM/PM marker, using the specified strings.\n *\n * [am] is used for the AM marker (0-11 hours), [pm] is used for the PM marker (12-23 hours).\n *\n * @see [amPmHour]\n */"}
{"signature":"public fun minute ( padding : Padding = Padding . ZERO )","body":"public fun minute ( padding : Padding = Padding . ZERO )","docstring":"/**\n * The minute of hour.\n *\n * By default, it's zero-padded to two digits, but this can be changed with [padding].\n */"}
{"signature":"public fun second ( padding : Padding = Padding . ZERO )","body":"public fun second ( padding : Padding = Padding . ZERO )","docstring":"/**\n * The second of minute.\n *\n * By default, it's zero-padded to two digits, but this can be changed with [padding].\n *\n * This field has the default value of 0. If you want to omit it, use [optional].\n */"}
{"signature":"public fun secondFraction ( minLength : Int = <NUM_LIT:1> , maxLength : Int = <NUM_LIT:9> )","body":"public fun secondFraction ( minLength : Int = <NUM_LIT:1> , maxLength : Int = <NUM_LIT:9> )","docstring":"/**\n * The fractional part of the second without the leading dot.\n *\n * When formatting, the decimal fraction will be rounded to fit in the specified [maxLength] and will add\n * trailing zeroes to the specified [minLength].\n * Rounding is performed using the round-toward-zero rounding mode.\n *\n * When parsing, the parser will require that the fraction is at least [minLength] and at most [maxLength]\n * digits long.\n *\n * This field has the default value of 0. If you want to omit it, use [optional].\n *\n * See also the [secondFraction] overload that accepts just one parameter, the exact length of the fractional\n * part.\n *\n * @throws IllegalArgumentException if [minLength] is greater than [maxLength] or if either is not in the range 1..9.\n */"}
{"signature":"public fun secondFraction ( fixedLength : Int )","body":"{ <EOL> secondFraction ( fixedLength , fixedLength ) <EOL> }","docstring":"/**\n * The fractional part of the second without the leading dot.\n *\n * When formatting, the decimal fraction will add trailing zeroes or be rounded as necessary to always output\n * exactly the number of digits specified in [fixedLength].\n * Rounding is performed using the round-toward-zero rounding mode.\n *\n * When parsing, exactly [fixedLength] digits will be consumed.\n *\n * This field has the default value of 0. If you want to omit it, use [optional].\n *\n * See also the [secondFraction] overload that accepts two parameters, the minimum and maximum length of the\n * fractional part.\n *\n * @throws IllegalArgumentException if [fixedLength] is not in the range 1..9.\n *\n * @see secondFraction that accepts two parameters.\n */"}
{"signature":"public fun time ( format : DateTimeFormat < LocalTime > )","body":"public fun time ( format : DateTimeFormat < LocalTime > )","docstring":"/**\n * An existing [DateTimeFormat] for the time part.\n *\n * Example:\n * ```\n * time(LocalTime.Formats.ISO)\n * ```\n */"}
{"signature":"public fun dateTime ( format : DateTimeFormat < LocalDateTime > )","body":"public fun dateTime ( format : DateTimeFormat < LocalDateTime > )","docstring":"/**\n * An existing [DateTimeFormat] for the date-time part.\n *\n * Example:\n * ```\n * dateTime(LocalDateTime.Formats.ISO)\n * ```\n */"}
{"signature":"public fun offsetHours ( padding : Padding = Padding . ZERO )","body":"public fun offsetHours ( padding : Padding = Padding . ZERO )","docstring":"/**\n * The total number of hours in the UTC offset, including the sign.\n *\n * By default, it's zero-padded to two digits, but this can be changed with [padding].\n *\n * This field has the default value of 0. If you want to omit it, use [optional].\n */"}
{"signature":"public fun offsetMinutesOfHour ( padding : Padding = Padding . ZERO )","body":"public fun offsetMinutesOfHour ( padding : Padding = Padding . ZERO )","docstring":"/**\n * The minute-of-hour of the UTC offset.\n *\n * By default, it's zero-padded to two digits, but this can be changed with [padding].\n *\n * This field has the default value of 0. If you want to omit it, use [optional].\n */"}
{"signature":"public fun offsetSecondsOfMinute ( padding : Padding = Padding . ZERO )","body":"public fun offsetSecondsOfMinute ( padding : Padding = Padding . ZERO )","docstring":"/**\n * The second-of-minute of the UTC offset.\n *\n * By default, it's zero-padded to two digits, but this can be changed with [padding].\n *\n * This field has the default value of 0. If you want to omit it, use [optional].\n */"}
{"signature":"public fun offset ( format : DateTimeFormat < UtcOffset > )","body":"public fun offset ( format : DateTimeFormat < UtcOffset > )","docstring":"/**\n * An existing [DateTimeFormat] for the UTC offset part.\n *\n * Example:\n * ```\n * offset(UtcOffset.Formats.FOUR_DIGITS)\n * ```\n */"}
{"signature":"public fun timeZoneId ( )","body":"public fun timeZoneId ( )","docstring":"/**\n * The IANA time zone identifier, for example, \"Europe/Berlin\".\n *\n * When formatting, the timezone identifier is supplied as is, without any validation.\n * On parsing, [TimeZone.availableZoneIds] is used to validate the identifier.\n */"}
{"signature":"public fun dateTimeComponents ( format : DateTimeFormat < DateTimeComponents > )","body":"public fun dateTimeComponents ( format : DateTimeFormat < DateTimeComponents > )","docstring":"/**\n * An existing [DateTimeFormat].\n *\n * Example:\n * ```\n * dateTimeComponents(DateTimeComponents.Formats.RFC_1123)\n * ```\n */"}
{"signature":"internal fun DateTimeFormatBuilder . WithTime . secondFractionInternal ( minLength : Int , maxLength : Int , grouping : List < Int > )","body":"{ <EOL> @ Suppress ( \"<STR_LIT>\" ) <EOL> when ( this ) { <EOL> is AbstractWithTimeBuilder -> addFormatStructureForTime ( BasicFormatStructure ( FractionalSecondDirective ( minLength , maxLength , grouping ) ) ) <EOL> } <EOL> }","docstring":"/**\n * The fractional part of the second without the leading dot.\n *\n * When formatting, the decimal fraction will round the number to fit in the specified [maxLength] and will add\n * trailing zeroes to the specified [minLength].\n *\n * Additionally, [grouping] is a list, where the i'th (1-based) element specifies how many trailing zeros to add during\n * formatting when the number would have i digits.\n *\n * When parsing, the parser will require that the fraction is at least [minLength] and at most [maxLength]\n * digits long.\n *\n * This field has the default value of 0. If you want to omit it, use [optional].\n *\n * @throws IllegalArgumentException if [minLength] is greater than [maxLength] or if either is not in the range 1..9.\n */"}
{"signature":"@ Suppress ( \"<STR_LIT:UNCHECKED_CAST>\" ) <EOL> public fun < T : DateTimeFormatBuilder > T . alternativeParsing ( vararg alternativeFormats : T . ( ) -> Unit , primaryFormat : T . ( ) -> Unit ) : Unit","body":"= when ( this ) { <EOL> is AbstractDateTimeFormatBuilder < * , * > -> <EOL> appendAlternativeParsingImpl ( * alternativeFormats as Array < out AbstractDateTimeFormatBuilder < * , * > . ( ) -> Unit > , mainFormat = primaryFormat as ( AbstractDateTimeFormatBuilder < * , * > . ( ) -> Unit ) ) <EOL> else -> throw IllegalStateException ( \"<STR_LIT>\" ) <EOL> }","docstring":"/**\n * A format along with other ways to parse the same portion of the value.\n *\n * When parsing, first, [primaryFormat] is used; if parsing the whole string fails using that, the formats\n * from [alternativeFormats] are tried in order.\n *\n * When formatting, the [primaryFormat] is used to format the value, and [alternativeFormats] are ignored.\n *\n * Example:\n * ```\n * alternativeParsing(\n * { dayOfMonth(); char('-'); monthNumber() },\n * { monthNumber(); char(' '); dayOfMonth() },\n * ) { monthNumber(); char('/'); dayOfMonth() }\n * ```\n *\n * This will always format a date as `MM/DD`, but will also accept `DD-MM` and `MM DD`.\n */"}
{"signature":"@ Suppress ( \"<STR_LIT:UNCHECKED_CAST>\" ) <EOL> public fun < T : DateTimeFormatBuilder > T . optional ( ifZero : String = \"<STR_LIT>\" , format : T . ( ) -> Unit ) : Unit","body":"= when ( this ) { <EOL> is AbstractDateTimeFormatBuilder < * , * > -> appendOptionalImpl ( onZero = ifZero , format as ( AbstractDateTimeFormatBuilder < * , * > . ( ) -> Unit ) ) <EOL> else -> throw IllegalStateException ( \"<STR_LIT>\" ) <EOL> }","docstring":"/**\n * An optional section.\n *\n * When formatting, the section is formatted if the value of any field in the block is not equal to the default value.\n * Only [optional] calls where all the fields have default values are permitted.\n *\n * Example:\n * ```\n * offsetHours(); char(':'); offsetMinutesOfHour()\n * optional { char(':'); offsetSecondsOfMinute() }\n * ```\n *\n * Here, because seconds have the default value of zero, they are formatted only if they are not equal to zero, so the\n * UTC offset `+18:30:00` gets formatted as `\"+18:30\"`, but `+18:30:01` becomes `\"+18:30:01\"`.\n *\n * When parsing, either [format] or, if that fails, the literal [ifZero] are parsed. If the [ifZero] string is parsed,\n * the values in [format] get assigned their default values.\n *\n * [ifZero] defines the string that is used if values are the default ones.\n *\n * @throws IllegalArgumentException if not all fields used in [format] have a default value.\n */"}
{"signature":"public fun DateTimeFormatBuilder . char ( value : Char ) : Unit","body":"= chars ( value . toString ( ) )","docstring":"/**\n * A literal character.\n *\n * This is a shorthand for `chars(value.toString())`.\n */"}
{"signature":"private fun < T : DoubleColonLHS > tryResolveLHS ( doubleColonExpression : FirCallableReferenceAccess , criterion : ( FirCallableReferenceAccess ) -> Boolean , resolve : ( FirExpression ) -> T ? <EOL> ) : T ?","body":"{ <EOL> val expression = doubleColonExpression . explicitReceiver ? : return null <EOL> if ( ! criterion ( doubleColonExpression ) ) return null <EOL> return resolve ( expression ) <EOL> }","docstring":"/**\n * Returns null if the LHS is definitely not an expression. Returns a non-null result if a resolution was attempted and led to\n * either a successful result or not.\n */"}
{"signature":"fun getElement ( element : @ UnsafeVariance E ) : E ?","body":"fun getElement ( element : @ UnsafeVariance E ) : E ?","docstring":"/**\n * Searches for the specified element in this set.\n *\n * @return the element from the set equal to [element], or `null` if no such element found.\n */"}
{"signature":"protected abstract fun applyImpl ( data : FloatArray , shape : TensorShape ) : FloatArray","body":"protected abstract fun applyImpl ( data : FloatArray , shape : TensorShape ) : FloatArray","docstring":"/**\n * Actual implementation of the [Operation] that should be applied to the [data].\n */"}
{"signature":"@ ExperimentalSerializationApi <EOL> public fun decodeStringChunked ( consumeChunk : ( chunk : String ) -> Unit )","body":"@ ExperimentalSerializationApi <EOL> public fun decodeStringChunked ( consumeChunk : ( chunk : String ) -> Unit )","docstring":"/**\n * Method allows decoding a string value by fixed-size chunks.\n * Usable for handling very large strings that may not fit in memory.\n * Chunk size is guaranteed to not exceed 16384 chars (but it may be smaller than that).\n * Feeds string chunks to the provided consumer.\n *\n * @param consumeChunk - lambda function to handle string chunks\n *\n * Example usage:\n * ```\n * @Serializable(with = LargeStringSerializer::class)\n * data class LargeStringData(val largeString: String)\n *\n * @Serializable\n * data class ClassWithLargeStringDataField(val largeStringField: LargeStringData)\n *\n * object LargeStringSerializer : KSerializer<LargeStringData> {\n * override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor(\"LargeStringContent\", PrimitiveKind.STRING)\n *\n * override fun deserialize(decoder: Decoder): LargeStringData {\n * require(decoder is ChunkedDecoder) { \"Only chunked decoder supported\" }\n *\n * val tmpFile = createTempFile()\n * val writer = FileWriter(tmpFile.toFile()).use {\n * decoder.decodeStringChunked { chunk ->\n * writer.append(chunk)\n * }\n * }\n * return LargeStringData(\"file://${tmpFile.absolutePathString()}\")\n * }\n * }\n * ```\n *\n * In this sample, we need to be able to handle a huge string coming from json. Instead of storing it in memory,\n * we offload it into a file and return the file name instead\n */"}
{"signature":"internal fun DClass . classlikesInJava ( ) : List < DClasslike >","body":"{ <EOL> val classlikes = classlikes <EOL> . filter { it . name != companion ? . name } <EOL> . map { it . asJava ( ) } <EOL> val companionAsJava = companion ? . companionAsJava ( ) <EOL> return if ( companionAsJava != null ) classlikes . plus ( companionAsJava ) else classlikes <EOL> }","docstring":"/**\n * Companion objects requires some custom logic for rendering as Java.\n * They are excluded from usual classlikes rendering and added after.\n */"}
{"signature":"internal fun DObject . asJava ( excludedProps : List < DProperty > = emptyList ( ) , excludedFunctions : List < DFunction > = emptyList ( ) ) : DObject","body":"= copy ( functions = functions . plus ( properties . filterNot { it in excludedProps } . filter { ! it . isJvmField && ! it . isConst && ! it . isLateInit && ! it . hasJvmSynthetic ( ) } . flatMap { listOf ( it . getter , it . setter ) } ) . filterNotNull ( ) . filterNot { it in excludedFunctions } . filterNot { it . hasJvmSynthetic ( ) } . flatMap { it . asJava ( dri . classNames ? : name . orEmpty ( ) ) } , properties = properties . filterNot { it . hasJvmSynthetic ( ) } . filterNot { it in excludedProps } . map { it . asJava ( isFromObjectOrCompanion = true ) } + DProperty ( name = OBJECT_INSTANCE_NAME , modifier = sourceSets . associateWith { JavaModifier . Final } , dri = dri . copy ( callable = Callable ( OBJECT_INSTANCE_NAME , null , emptyList ( ) ) ) , documentation = emptyMap ( ) , sources = emptyMap ( ) , visibility = sourceSets . associateWith { <EOL> JavaVisibility . Public <EOL> } , type = GenericTypeConstructor ( dri , emptyList ( ) ) , setter = null , getter = null , sourceSets = sourceSets , receiver = null , generics = emptyList ( ) , expectPresentInSet = expectPresentInSet , isExpectActual = false , extra = PropertyContainer . withAll ( sourceSets . map { <EOL> mapOf ( it to setOf ( ExtraModifiers . JavaOnlyModifiers . Static ) ) . toAdditionalModifiers ( ) <EOL> } ) ) , classlikes = classlikes . map { it . asJava ( ) } , supertypes = supertypes . mapValues { it . value . map { it . asJava ( ) } } )","docstring":"/**\n * Parameters [excludedProps] and [excludedFunctions] used for rendering companion objects\n * where some members (that lifted to outer class) are not rendered\n */"}
{"signature":"public fun recursivePrintGroupInHDF5File ( hdfFile : HdfFile , group : Group )","body":"{ <EOL> for ( node in group ) { <EOL> println ( \"<STR_LIT>\" + node . name ) <EOL> for ( ( key , value ) in node . attributes ) { <EOL> println ( \"<STR_LIT>\" ) <EOL> if ( value . isScalar ) { <EOL> println ( \"<STR_LIT>\" + value . data . toString ( ) ) <EOL> } else if ( value . data is Array < * > ) { <EOL> for ( i in <NUM_LIT:0> until value . size . toInt ( ) ) <EOL> println ( \"<STR_LIT>\" + ( value . data as Array < * > ) [ i ] . toString ( ) ) <EOL> } <EOL> } <EOL> if ( node is Group ) { <EOL> recursivePrintGroupInHDF5File ( hdfFile , node ) <EOL> } else { <EOL> println ( \"<STR_LIT>\" + node . path ) <EOL> val dataset = hdfFile . getDatasetByPath ( node . path ) <EOL> val dims = arrayOf ( dataset . dimensions ) <EOL> println ( \"<STR_LIT>\" + dims . contentDeepToString ( ) ) <EOL> } <EOL> } <EOL> }","docstring":"/**\n * Helper function to print out file in hdf5 format for debugging purposes.\n */"}
{"signature":"public fun encodeJsonElement ( element : JsonElement )","body":"public fun encodeJsonElement ( element : JsonElement )","docstring":"/**\n * Appends the given JSON [element] to the current output.\n * This method is allowed to invoke only as the part of the whole serialization process of the class,\n * calling this method after invoking [beginStructure] or any `encode*` method will lead to unspecified behaviour\n * and may produce an invalid JSON result.\n * For example:\n * ```\n * class Holder(val value: Int, val list: List<Int>())\n *\n * // Holder serialize method\n * fun serialize(encoder: Encoder, value: Holder) {\n * // Completely okay, the whole Holder object is read\n * val jsonObject = JsonObject(...) // build a JsonObject from Holder\n * (encoder as JsonEncoder).encodeJsonElement(jsonObject) // Write it\n * }\n *\n * // Incorrect Holder serialize method\n * fun serialize(encoder: Encoder, value: Holder) {\n * val composite = encoder.beginStructure(descriptor)\n * composite.encodeSerializableElement(descriptor, 0, Int.serializer(), value.value)\n * val array = JsonArray(value.list)\n * // Incorrect, encoder is already in an intermediate state after encodeSerializableElement\n * (composite as JsonEncoder).encodeJsonElement(array)\n * composite.endStructure(descriptor)\n * // ...\n * }\n * ```\n */"}
{"signature":"@ Test <EOL> @ TodoAnalysisApi <EOL> fun `test - stringBuilder` ( )","body":"{ <EOL> doTest ( dependenciesDir . resolve ( \"<STR_LIT>\" ) ) <EOL> }","docstring":"/**\n * - Missing implementation of mangling\n */"}
{"signature":"@ Test <EOL> fun `test - exportedAndNotExportedDependency` ( )","body":"{ <EOL> doTest ( dependenciesDir . resolve ( \"<STR_LIT>\" ) , configuration = HeaderGenerator . Configuration ( frameworkName = \"<STR_LIT>\" , withObjCBaseDeclarationStubs = true , dependencies = listOf ( testLibraryAKlibFile , testLibraryBKlibFile ) , exportedDependencies = setOf ( testLibraryAKlibFile ) ) ) <EOL> }","docstring":"/**\n * https://youtrack.jetbrains.com/issue/KT-65327/Support-reading-klib-contents-in-Analysis-API\n * Requires being able to use AA to iterate over symbols to 'export' the dependency\n */"}
{"signature":"private fun fullMergeControlFlowEdge ( dest : Int , frame : F , canReuse : Boolean = false )","body":"{ <EOL> val oldFrame = frames [ dest ] <EOL> val changes = when { <EOL> canReuse && ! isMergeNode [ dest ] -> { <EOL> frames [ dest ] = frame <EOL> true <EOL> } <EOL> oldFrame == null -> { <EOL> frames [ dest ] = newFrame ( frame . locals , frame . maxStackSize ) . apply { init ( frame ) } <EOL> true <EOL> } <EOL> ! isMergeNode [ dest ] -> { <EOL> oldFrame . init ( frame ) <EOL> true <EOL> } <EOL> else -> try { <EOL> oldFrame . merge ( frame , interpreter ) <EOL> } catch ( e : AnalyzerException ) { <EOL> throw AnalyzerException ( null , \"<STR_LIT>\" ) <EOL> } <EOL> } <EOL> updateQueue ( changes , dest ) <EOL> }","docstring":"/**\n * Updates frame at the index [dest] with its old value if provided and previous control flow node frame [frame].\n * Reuses old frame when possible and when [canReuse] is true.\n * If updated, adds the frame to the queue\n */"}
{"signature":"private fun FirSimpleFunction . isPlatformOverriddenFunction ( session : FirSession , baseDeclaration : FirSimpleFunction ) : Boolean ?","body":"{ <EOL> if ( this . name != baseDeclaration . name ) { <EOL> return null <EOL> } <EOL> val superInfo = baseDeclaration . symbol . decodeObjCMethodAnnotation ( session ) ? : return null <EOL> val subInfo = symbol . decodeObjCMethodAnnotation ( session ) <EOL> return if ( subInfo != null ) { <EOL> superInfo . selector == subInfo . selector <EOL> } else { <EOL> if ( ! parameterNamesMatch ( this , baseDeclaration ) ) false else null <EOL> } <EOL> }","docstring":"/**\n * mimics ObjCOverridabilityCondition.isOverridable\n */"}
{"signature":"private fun parameterNamesMatch ( first : FirSimpleFunction , second : FirSimpleFunction ) : Boolean","body":"{ <EOL> if ( first . valueParameters . size != second . valueParameters . size ) { <EOL> return false <EOL> } <EOL> first . valueParameters . forEachIndexed { index , parameter -> <EOL> if ( index > <NUM_LIT:0> && parameter . name != second . valueParameters [ index ] . name ) { <EOL> return false <EOL> } <EOL> } <EOL> return true <EOL> }","docstring":"/**\n * mimics ObjCInteropKt.parameterNamesMatch\n */"}