[atomicfu-JVM] Preparation for commonization of JVM and K/N transformers
The following updates in the JVM/IR plugin were made: * Lots of refactoring with preparation for K/N support: commonization of transformations. * Improved error handling (checks for visibility constraints, appending message about usage constraints in case of an error). * Explicit requirements for the visibility of atomic properties: to prevent leaking they should be private/internal or be members of private/internal classes. * Fixed visibility of generated properties: volatile properties are always private and atomic updaters have the same visibility as the original atomic property. * Volatile fields are generated from scratch and original atomic properties are removed. * Delegated properties support is fixed (only declaration in the same scope is allowed). * Non-inline atomic extensions are forbidden. * For top-level atomics: only one wrapper class per file (with corresponding visibility) is generated. * Bug fixes. The corresponding tickets: https://github.com/Kotlin/kotlinx-atomicfu/issues/322 KT-60528 Merge-request: KT-MR-10579 Merged-by: Maria Sokolova <maria.sokolova@jetbrains.com>
This commit is contained in:
mvicsokolova
@@ -1,146 +0,0 @@
|
||||
import kotlinx.atomicfu.*
|
||||
import kotlin.test.*
|
||||
|
||||
class IntArithmetic {
|
||||
val _x = atomic(0)
|
||||
val x get() = _x.value
|
||||
}
|
||||
|
||||
class LongArithmetic {
|
||||
val _x = atomic(4294967296)
|
||||
val x get() = _x.value
|
||||
val y = atomic(5000000000)
|
||||
val z = atomic(2424920024888888848)
|
||||
val max = atomic(9223372036854775807)
|
||||
}
|
||||
|
||||
class BooleanArithmetic {
|
||||
val _x = atomic(false)
|
||||
val x get() = _x.value
|
||||
}
|
||||
|
||||
class ReferenceArithmetic {
|
||||
val _x = atomic<String?>(null)
|
||||
}
|
||||
|
||||
class VisibilitiesTest {
|
||||
val a = atomic(0)
|
||||
public val b = atomic(1)
|
||||
private val c = atomic(2)
|
||||
internal val d = atomic(3)
|
||||
|
||||
fun test() {
|
||||
a.lazySet(45)
|
||||
b.lazySet(56)
|
||||
c.lazySet(46)
|
||||
d.lazySet(67)
|
||||
}
|
||||
}
|
||||
|
||||
class ArithmeticTest {
|
||||
val local = atomic(0)
|
||||
|
||||
fun testGetValue() {
|
||||
val a = IntArithmetic()
|
||||
a._x.value = 5
|
||||
assertEquals(5, a._x.value)
|
||||
var aValue = a._x.value
|
||||
assertEquals(5, aValue)
|
||||
assertEquals(5, a.x)
|
||||
|
||||
local.value = 555
|
||||
aValue = local.value
|
||||
assertEquals(aValue, local.value)
|
||||
}
|
||||
|
||||
fun testAtomicCallPlaces(): Boolean {
|
||||
val a = IntArithmetic()
|
||||
a._x.value = 5
|
||||
a._x.compareAndSet(5, 42)
|
||||
val res = a._x.compareAndSet(42, 45)
|
||||
assertTrue(res)
|
||||
assertTrue(a._x.compareAndSet(45, 77))
|
||||
assertFalse(a._x.compareAndSet(95, 77))
|
||||
return a._x.compareAndSet(77, 88)
|
||||
}
|
||||
|
||||
fun testInt() {
|
||||
val a = IntArithmetic()
|
||||
assertEquals(0, a.x)
|
||||
val update = 3
|
||||
assertEquals(0, a._x.getAndSet(update))
|
||||
assertTrue(a._x.compareAndSet(update, 8))
|
||||
a._x.lazySet(1)
|
||||
assertEquals(1, a.x)
|
||||
assertEquals(1, a._x.getAndSet(2))
|
||||
assertEquals(2, a.x)
|
||||
assertEquals(2, a._x.getAndIncrement())
|
||||
assertEquals(3, a.x)
|
||||
assertEquals(3, a._x.getAndDecrement())
|
||||
assertEquals(2, a.x)
|
||||
assertEquals(2, a._x.getAndAdd(2))
|
||||
assertEquals(4, a.x)
|
||||
assertEquals(7, a._x.addAndGet(3))
|
||||
assertEquals(7, a.x)
|
||||
assertEquals(8, a._x.incrementAndGet())
|
||||
assertEquals(8, a.x)
|
||||
assertEquals(7, a._x.decrementAndGet())
|
||||
assertEquals(7, a.x)
|
||||
assertTrue(a._x.compareAndSet(7, 10))
|
||||
}
|
||||
|
||||
fun testLong() {
|
||||
val a = LongArithmetic()
|
||||
assertEquals(2424920024888888848, a.z.value)
|
||||
a.z.lazySet(8424920024888888848)
|
||||
assertEquals(8424920024888888848, a.z.value)
|
||||
assertEquals(8424920024888888848, a.z.getAndSet(8924920024888888848))
|
||||
assertEquals(8924920024888888848, a.z.value)
|
||||
assertEquals(8924920024888888849, a.z.incrementAndGet())
|
||||
assertEquals(8924920024888888849, a.z.value)
|
||||
assertEquals(8924920024888888849, a.z.getAndDecrement())
|
||||
assertEquals(8924920024888888848, a.z.value)
|
||||
assertEquals(8924920024888888848, a.z.getAndAdd(100000000000000000))
|
||||
assertEquals(9024920024888888848, a.z.value)
|
||||
assertEquals(-198452011965886959, a.z.addAndGet(-9223372036854775807))
|
||||
assertEquals(-198452011965886959, a.z.value)
|
||||
assertEquals(-198452011965886958, a.z.incrementAndGet())
|
||||
assertEquals(-198452011965886958, a.z.value)
|
||||
assertEquals(-198452011965886959, a.z.decrementAndGet())
|
||||
assertEquals(-198452011965886959, a.z.value)
|
||||
}
|
||||
|
||||
fun testBoolean() {
|
||||
val a = BooleanArithmetic()
|
||||
assertEquals(false, a._x.value)
|
||||
assertFalse(a.x)
|
||||
a._x.lazySet(true)
|
||||
assertTrue(a.x)
|
||||
assertTrue(a._x.getAndSet(true))
|
||||
assertTrue(a._x.compareAndSet(true, false))
|
||||
assertFalse(a.x)
|
||||
}
|
||||
|
||||
fun testReference() {
|
||||
val a = ReferenceArithmetic()
|
||||
a._x.value = "aaa"
|
||||
assertEquals("aaa", a._x.value)
|
||||
a._x.lazySet("bb")
|
||||
assertEquals("bb", a._x.value)
|
||||
assertEquals("bb", a._x.getAndSet("ccc"))
|
||||
assertEquals("ccc", a._x.value)
|
||||
}
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
val testClass = ArithmeticTest()
|
||||
|
||||
testClass.testGetValue()
|
||||
if (!testClass.testAtomicCallPlaces()) return "testAtomicCallPlaces: FAILED"
|
||||
|
||||
testClass.testInt()
|
||||
testClass.testLong()
|
||||
testClass.testBoolean()
|
||||
testClass.testReference()
|
||||
return "OK"
|
||||
}
|
||||
@@ -1,103 +0,0 @@
|
||||
@kotlin.Metadata
|
||||
public final class ArithmeticTest {
|
||||
// source: 'ArithmeticTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field local$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field local: int
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public final static @org.jetbrains.annotations.NotNull method getLocal$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public final method getLocal(): int
|
||||
public final method testAtomicCallPlaces(): boolean
|
||||
public final method testBoolean(): void
|
||||
public final method testGetValue(): void
|
||||
public final method testInt(): void
|
||||
public final method testLong(): void
|
||||
public final method testReference(): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class ArithmeticTestKt {
|
||||
// source: 'ArithmeticTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class BooleanArithmetic {
|
||||
// source: 'ArithmeticTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field _x$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field _x: int
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public final method getX(): boolean
|
||||
public final static @org.jetbrains.annotations.NotNull method get_x$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public final method get_x(): int
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class IntArithmetic {
|
||||
// source: 'ArithmeticTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field _x$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field _x: int
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public final method getX(): int
|
||||
public final static @org.jetbrains.annotations.NotNull method get_x$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public final method get_x(): int
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LongArithmetic {
|
||||
// source: 'ArithmeticTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field _x$FU: java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field _x: long
|
||||
private final static @org.jetbrains.annotations.NotNull field max$FU: java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field max: long
|
||||
private final static @org.jetbrains.annotations.NotNull field y$FU: java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field y: long
|
||||
private final static @org.jetbrains.annotations.NotNull field z$FU: java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field z: long
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public final static @org.jetbrains.annotations.NotNull method getMax$FU(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
public final method getMax(): long
|
||||
public final method getX(): long
|
||||
public final static @org.jetbrains.annotations.NotNull method getY$FU(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
public final method getY(): long
|
||||
public final static @org.jetbrains.annotations.NotNull method getZ$FU(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
public final method getZ(): long
|
||||
public final static @org.jetbrains.annotations.NotNull method get_x$FU(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
public final method get_x(): long
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class ReferenceArithmetic {
|
||||
// source: 'ArithmeticTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field _x$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field _x: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public final static @org.jetbrains.annotations.NotNull method get_x$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
public final @org.jetbrains.annotations.Nullable method get_x(): java.lang.Object
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class VisibilitiesTest {
|
||||
// source: 'ArithmeticTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field a$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field a: int
|
||||
private final static @org.jetbrains.annotations.NotNull field b$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field b: int
|
||||
private final static @org.jetbrains.annotations.NotNull field c$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field c: int
|
||||
private final static @org.jetbrains.annotations.NotNull field d$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field d: int
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public final static @org.jetbrains.annotations.NotNull method getA$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public final method getA(): int
|
||||
public final static @org.jetbrains.annotations.NotNull method getB$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public final method getB(): int
|
||||
public final static @org.jetbrains.annotations.NotNull method getD$FU$main(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public final method getD$main(): int
|
||||
public final method test(): void
|
||||
}
|
||||
@@ -1,50 +0,0 @@
|
||||
@kotlin.Metadata
|
||||
public final class ArrayInlineExtensionTest$A {
|
||||
// source: 'ArrayInlineExtensionTest.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field s: java.lang.String
|
||||
public method <init>(@org.jetbrains.annotations.NotNull p0: java.lang.String): void
|
||||
public final @org.jetbrains.annotations.NotNull method getS(): java.lang.String
|
||||
public final inner class ArrayInlineExtensionTest$A
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class ArrayInlineExtensionTest {
|
||||
// source: 'ArrayInlineExtensionTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field a$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field a: int
|
||||
private final @org.jetbrains.annotations.NotNull field intArr: java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private final @org.jetbrains.annotations.NotNull field longArr: java.util.concurrent.atomic.AtomicLongArray
|
||||
private final @org.jetbrains.annotations.NotNull field refArr: java.util.concurrent.atomic.AtomicReferenceArray
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
private final method bar$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int): int
|
||||
private final method bar$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int): int
|
||||
private final method casLoop(p0: int): int
|
||||
private final method casLoopExpression(p0: long): long
|
||||
private final method extensionLoop$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int): int
|
||||
private final method extensionLoop$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int): int
|
||||
private final method extensionLoopExpression$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int): int
|
||||
private final method extensionLoopExpression$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int): int
|
||||
private final method extensionLoopMixedReceivers$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int, p4: int, p5: int): int
|
||||
private final method extensionLoopMixedReceivers$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int, p3: int, p4: int): int
|
||||
private final method extensionLoopRecursive$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int): int
|
||||
private final method extensionLoopRecursive$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int): int
|
||||
private final method foo$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int): int
|
||||
private final method foo$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int): int
|
||||
public final static @org.jetbrains.annotations.NotNull method getA$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public final method getA(): int
|
||||
public final @org.jetbrains.annotations.NotNull method getIntArr(): java.util.concurrent.atomic.AtomicIntegerArray
|
||||
public final @org.jetbrains.annotations.NotNull method getLongArr(): java.util.concurrent.atomic.AtomicLongArray
|
||||
public final @org.jetbrains.annotations.NotNull method getRefArr(): java.util.concurrent.atomic.AtomicReferenceArray
|
||||
private final method loop$atomicfu$array(p0: java.util.concurrent.atomic.AtomicIntegerArray, p1: int, p2: kotlin.jvm.functions.Function1): void
|
||||
private final method loop$atomicfu$array(p0: java.util.concurrent.atomic.AtomicLongArray, p1: int, p2: kotlin.jvm.functions.Function1): void
|
||||
private final method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
public final method testIntExtensionLoops(): void
|
||||
public final inner class ArrayInlineExtensionTest$A
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class ArrayInlineExtensionTestKt {
|
||||
// source: 'ArrayInlineExtensionTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
@@ -1,51 +0,0 @@
|
||||
@kotlin.Metadata
|
||||
public final class ARef {
|
||||
// source: 'AtomicArrayTest.kt'
|
||||
private final field n: int
|
||||
public method <init>(p0: int): void
|
||||
public final method component1(): int
|
||||
public synthetic static method copy$default(p0: ARef, p1: int, p2: int, p3: java.lang.Object): ARef
|
||||
public final @org.jetbrains.annotations.NotNull method copy(p0: int): ARef
|
||||
public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean
|
||||
public final method getN(): int
|
||||
public method hashCode(): int
|
||||
public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class AtomicArrayClass {
|
||||
// source: 'AtomicArrayTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field a$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field a: java.lang.Object
|
||||
private final @org.jetbrains.annotations.NotNull field anyArr: java.util.concurrent.atomic.AtomicReferenceArray
|
||||
private final @org.jetbrains.annotations.NotNull field booleanArr: java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private final @org.jetbrains.annotations.NotNull field intArr: java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private final @org.jetbrains.annotations.NotNull field longArr: java.util.concurrent.atomic.AtomicLongArray
|
||||
private final @org.jetbrains.annotations.NotNull field refArr: java.util.concurrent.atomic.AtomicReferenceArray
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public final static @org.jetbrains.annotations.NotNull method getA$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
public final @org.jetbrains.annotations.Nullable method getA(): java.lang.Object
|
||||
public final @org.jetbrains.annotations.NotNull method getAnyArr(): java.util.concurrent.atomic.AtomicReferenceArray
|
||||
public final @org.jetbrains.annotations.NotNull method getBooleanArr(): java.util.concurrent.atomic.AtomicIntegerArray
|
||||
public final @org.jetbrains.annotations.NotNull method getIntArr(): java.util.concurrent.atomic.AtomicIntegerArray
|
||||
public final @org.jetbrains.annotations.NotNull method getLongArr(): java.util.concurrent.atomic.AtomicLongArray
|
||||
public final @org.jetbrains.annotations.NotNull method getRefArr(): java.util.concurrent.atomic.AtomicReferenceArray
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class AtomicArrayTest {
|
||||
// source: 'AtomicArrayTest.kt'
|
||||
public method <init>(): void
|
||||
public final method testAnyArray(): void
|
||||
public final method testBooleanArray(): void
|
||||
public final method testIntArray(): void
|
||||
public final method testLongArray(): void
|
||||
public final method testRefArray(): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class AtomicArrayTestKt {
|
||||
// source: 'AtomicArrayTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
@@ -1,44 +0,0 @@
|
||||
@kotlin.Metadata
|
||||
public final class ComplexLoopTestKt {
|
||||
// source: 'ComplexLoopTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LoopTest {
|
||||
// source: 'ComplexLoopTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field a$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field a: int
|
||||
private final static @org.jetbrains.annotations.NotNull field b$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field b: int
|
||||
private final static @org.jetbrains.annotations.NotNull field c$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field c: int
|
||||
private final @org.jetbrains.annotations.NotNull field intArr: java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private final static @org.jetbrains.annotations.NotNull field r$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field r: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
private final method embeddedLoops(p0: int): int
|
||||
private final method embeddedUpdate(p0: int): int
|
||||
private final method extensionEmbeddedLoops$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int): int
|
||||
private final method extensionEmbeddedLoops$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int): int
|
||||
private final method extesntionEmbeddedRefUpdate$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceArray, p2: int, p3: java.lang.String): java.lang.String
|
||||
private final method extesntionEmbeddedRefUpdate$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p2: java.lang.String): java.lang.String
|
||||
public final static @org.jetbrains.annotations.NotNull method getA$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public final method getA(): int
|
||||
public final static @org.jetbrains.annotations.NotNull method getB$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public final method getB(): int
|
||||
public final static @org.jetbrains.annotations.NotNull method getC$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public final method getC(): int
|
||||
public final @org.jetbrains.annotations.NotNull method getIntArr(): java.util.concurrent.atomic.AtomicIntegerArray
|
||||
public final static @org.jetbrains.annotations.NotNull method getR$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
public final @org.jetbrains.annotations.Nullable method getR(): java.lang.Object
|
||||
private final method loop$atomicfu$array(p0: java.util.concurrent.atomic.AtomicIntegerArray, p1: int, p2: kotlin.jvm.functions.Function1): void
|
||||
private final method loop$atomicfu$array(p0: java.util.concurrent.atomic.AtomicReferenceArray, p1: int, p2: kotlin.jvm.functions.Function1): void
|
||||
private final method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private final method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
public final method test(): void
|
||||
private final method updateAndGet$atomicfu$array(p0: java.util.concurrent.atomic.AtomicReferenceArray, p1: int, p2: kotlin.jvm.functions.Function1): java.lang.Object
|
||||
private final method updateAndGet$atomicfu(p0: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): int
|
||||
private final method updateAndGet$atomicfu(p0: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): java.lang.Object
|
||||
}
|
||||
@@ -1,81 +0,0 @@
|
||||
@kotlin.Metadata
|
||||
public final class ExtensionLoopTestKt {
|
||||
// source: 'ExtensionLoopTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field ref$ExtensionLoopTest$VolatileWrapper: Ref$ExtensionLoopTest$VolatileWrapper
|
||||
static method <clinit>(): void
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
private final static method loop$atomicfu$array(p0: java.util.concurrent.atomic.AtomicReferenceArray, p1: int, p2: kotlin.jvm.functions.Function1): void
|
||||
private final static method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
public final static method testTopLevelExtensionLoop(): void
|
||||
private final static method topLevelExtensionLoop$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceArray, p2: int, p3: java.lang.String): java.lang.String
|
||||
private final static method topLevelExtensionLoop$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p2: java.lang.String): java.lang.String
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LoopTest$A {
|
||||
// source: 'ExtensionLoopTest.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field s: java.lang.String
|
||||
public method <init>(@org.jetbrains.annotations.NotNull p0: java.lang.String): void
|
||||
public final @org.jetbrains.annotations.NotNull method getS(): java.lang.String
|
||||
public final inner class LoopTest$A
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LoopTest {
|
||||
// source: 'ExtensionLoopTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field a$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private final static @org.jetbrains.annotations.NotNull field a1$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field a1: int
|
||||
private volatile @kotlin.jvm.Volatile field a: int
|
||||
private final static @org.jetbrains.annotations.NotNull field b$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field b: int
|
||||
private final static @org.jetbrains.annotations.NotNull field l$FU: java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field l: long
|
||||
private final static @org.jetbrains.annotations.NotNull field r$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field r: java.lang.Object
|
||||
private final static @org.jetbrains.annotations.NotNull field rs$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field rs: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
private final method bar$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int): int
|
||||
private final method bar$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int): int
|
||||
private final method casLoop(p0: int): int
|
||||
private final method casLoopExpression(p0: int): int
|
||||
private final method extensionLoop$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int): int
|
||||
private final method extensionLoop$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int): int
|
||||
private final method extensionLoopExpression$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int): int
|
||||
private final method extensionLoopExpression$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int): int
|
||||
private final method extensionLoopMixedReceivers$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int, p4: int): int
|
||||
private final method extensionLoopMixedReceivers$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int, p3: int): int
|
||||
private final method extensionLoopRecursive$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int): int
|
||||
private final method extensionLoopRecursive$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int): int
|
||||
private final method foo$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int): int
|
||||
private final method foo$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int): int
|
||||
public final static @org.jetbrains.annotations.NotNull method getA$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public final method getA(): int
|
||||
public final static @org.jetbrains.annotations.NotNull method getA1$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public final method getA1(): int
|
||||
public final static @org.jetbrains.annotations.NotNull method getB$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public final method getB(): int
|
||||
public final static @org.jetbrains.annotations.NotNull method getL$FU(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
public final method getL(): long
|
||||
public final static @org.jetbrains.annotations.NotNull method getR$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
public final @org.jetbrains.annotations.Nullable method getR(): java.lang.Object
|
||||
public final static @org.jetbrains.annotations.NotNull method getRs$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
public final @org.jetbrains.annotations.Nullable method getRs(): java.lang.Object
|
||||
private final method loop$atomicfu$array(p0: java.util.concurrent.atomic.AtomicIntegerArray, p1: int, p2: kotlin.jvm.functions.Function1): void
|
||||
private final method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
public final method testIntExtensionLoops(): void
|
||||
public final inner class LoopTest$A
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
final class Ref$ExtensionLoopTest$VolatileWrapper {
|
||||
// source: 'ExtensionLoopTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field ref$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field ref: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
private method <init>(): void
|
||||
public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
|
||||
public synthetic final static method access$getRef$FU$p(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
}
|
||||
@@ -1,38 +0,0 @@
|
||||
@kotlin.Metadata
|
||||
public final class ExtensionsTest {
|
||||
// source: 'ExtensionsTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field a$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field a: int
|
||||
private final static @org.jetbrains.annotations.NotNull field b$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field b: int
|
||||
private final static @org.jetbrains.annotations.NotNull field l$FU: java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field l: long
|
||||
private final static @org.jetbrains.annotations.NotNull field s$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field s: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public final method booleanExtensionArithmetic$atomicfu$array(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int): void
|
||||
public final method booleanExtensionArithmetic$atomicfu(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater): void
|
||||
public final static @org.jetbrains.annotations.NotNull method getA$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public final method getA(): int
|
||||
public final static @org.jetbrains.annotations.NotNull method getB$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public final method getB(): int
|
||||
public final static @org.jetbrains.annotations.NotNull method getL$FU(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
public final method getL(): long
|
||||
public final static @org.jetbrains.annotations.NotNull method getS$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
public final @org.jetbrains.annotations.Nullable method getS(): java.lang.Object
|
||||
public final method intExtensionArithmetic$atomicfu$array(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int): void
|
||||
public final method intExtensionArithmetic$atomicfu(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater): void
|
||||
public final method longExtensionArithmetic$atomicfu$array(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: java.util.concurrent.atomic.AtomicLongArray, p2: int): void
|
||||
public final method longExtensionArithmetic$atomicfu(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: java.util.concurrent.atomic.AtomicLongFieldUpdater): void
|
||||
public final method refExtension$atomicfu$array(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: java.util.concurrent.atomic.AtomicReferenceArray, p2: int): void
|
||||
public final method refExtension$atomicfu(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: java.util.concurrent.atomic.AtomicReferenceFieldUpdater): void
|
||||
public final method testExtension(): void
|
||||
public final method testScopedFieldGetters(): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class ExtensionsTestKt {
|
||||
// source: 'ExtensionsTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
@@ -1,118 +0,0 @@
|
||||
@kotlin.Metadata
|
||||
public final class DelegatedProvider$_a$DelegatedProvider$VolatileWrapper {
|
||||
// source: 'FieldInObjectTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field _a$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field _a: int
|
||||
static method <clinit>(): void
|
||||
private method <init>(): void
|
||||
public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
|
||||
public synthetic final static method access$get_a$p(p0: DelegatedProvider$_a$DelegatedProvider$VolatileWrapper): int
|
||||
public synthetic final static method access$set_a$p(p0: DelegatedProvider$_a$DelegatedProvider$VolatileWrapper, p1: int): void
|
||||
public final static @org.jetbrains.annotations.NotNull method get_a$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public final method get_a(): int
|
||||
public final inner class DelegatedProvider$_a$DelegatedProvider$VolatileWrapper
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class DelegatedProvider {
|
||||
// source: 'FieldInObjectTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull field INSTANCE: DelegatedProvider
|
||||
private final static @org.jetbrains.annotations.NotNull field _a$DelegatedProvider$VolatileWrapper: DelegatedProvider$_a$DelegatedProvider$VolatileWrapper
|
||||
private volatile @kotlin.jvm.Volatile field vInt: int
|
||||
static method <clinit>(): void
|
||||
private method <init>(): void
|
||||
public final method getA(): int
|
||||
public final method getVInt(): int
|
||||
public final static @org.jetbrains.annotations.NotNull method get_a$DelegatedProvider$VolatileWrapper(): DelegatedProvider$_a$DelegatedProvider$VolatileWrapper
|
||||
public final method setA(p0: int): void
|
||||
public final method setVInt(p0: int): void
|
||||
public final inner class DelegatedProvider$_a$DelegatedProvider$VolatileWrapper
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class FieldInObjectTestKt {
|
||||
// source: 'FieldInObjectTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
private final static method testDelegatedPropertiesInObject(): void
|
||||
private final static method testFieldInObject(): void
|
||||
public final inner class DelegatedProvider$_a$DelegatedProvider$VolatileWrapper
|
||||
public final inner class Provider$_ref$Provider$VolatileWrapper
|
||||
public final inner class Provider$_x$Provider$VolatileWrapper
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
final class Provider$Port$Provider$VolatileWrapper {
|
||||
// source: 'FieldInObjectTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field port$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field port: int
|
||||
static method <clinit>(): void
|
||||
private method <init>(): void
|
||||
public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
|
||||
public synthetic final static method access$getPort$FU$p(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private final inner class Provider$Port$Provider$VolatileWrapper
|
||||
public final inner class kotlin/random/Random$Default
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
final class Provider$_l$Provider$VolatileWrapper {
|
||||
// source: 'FieldInObjectTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field _l$FU: java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field _l: long
|
||||
static method <clinit>(): void
|
||||
private method <init>(): void
|
||||
public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
|
||||
public synthetic final static method access$get_l$FU$p(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private final inner class Provider$_l$Provider$VolatileWrapper
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class Provider$_ref$Provider$VolatileWrapper {
|
||||
// source: 'FieldInObjectTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field _ref$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field _ref: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
private method <init>(): void
|
||||
public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
|
||||
public final static @org.jetbrains.annotations.NotNull method get_ref$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
public final @org.jetbrains.annotations.Nullable method get_ref(): java.lang.Object
|
||||
public final inner class Provider$_ref$Provider$VolatileWrapper
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class Provider$_x$Provider$VolatileWrapper {
|
||||
// source: 'FieldInObjectTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field _x$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field _x: int
|
||||
static method <clinit>(): void
|
||||
private method <init>(): void
|
||||
public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
|
||||
public final static @org.jetbrains.annotations.NotNull method get_x$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public final method get_x(): int
|
||||
public final inner class Provider$_x$Provider$VolatileWrapper
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class Provider {
|
||||
// source: 'FieldInObjectTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull field INSTANCE: Provider
|
||||
private final static @org.jetbrains.annotations.NotNull field _l$Provider$VolatileWrapper: Provider$_l$Provider$VolatileWrapper
|
||||
private final static @org.jetbrains.annotations.NotNull field _ref$Provider$VolatileWrapper: Provider$_ref$Provider$VolatileWrapper
|
||||
private final static @org.jetbrains.annotations.NotNull field _x$Provider$VolatileWrapper: Provider$_x$Provider$VolatileWrapper
|
||||
private final static @org.jetbrains.annotations.NotNull field intArr: java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private final static @org.jetbrains.annotations.NotNull field longArr: java.util.concurrent.atomic.AtomicLongArray
|
||||
private final static @org.jetbrains.annotations.NotNull field port$Provider$VolatileWrapper: Provider$Port$Provider$VolatileWrapper
|
||||
private final static @org.jetbrains.annotations.NotNull field refArr: java.util.concurrent.atomic.AtomicReferenceArray
|
||||
static method <clinit>(): void
|
||||
private method <init>(): void
|
||||
public final static @org.jetbrains.annotations.NotNull method getIntArr(): java.util.concurrent.atomic.AtomicIntegerArray
|
||||
public final method getL(): long
|
||||
public final static @org.jetbrains.annotations.NotNull method getLongArr(): java.util.concurrent.atomic.AtomicLongArray
|
||||
public final static @org.jetbrains.annotations.NotNull method getRefArr(): java.util.concurrent.atomic.AtomicReferenceArray
|
||||
public final static @org.jetbrains.annotations.NotNull method get_ref$Provider$VolatileWrapper(): Provider$_ref$Provider$VolatileWrapper
|
||||
public final static @org.jetbrains.annotations.NotNull method get_x$Provider$VolatileWrapper(): Provider$_x$Provider$VolatileWrapper
|
||||
public final method next(): int
|
||||
private final inner class Provider$Port$Provider$VolatileWrapper
|
||||
private final inner class Provider$_l$Provider$VolatileWrapper
|
||||
public final inner class Provider$_ref$Provider$VolatileWrapper
|
||||
public final inner class Provider$_x$Provider$VolatileWrapper
|
||||
}
|
||||
-26
@@ -1,26 +0,0 @@
|
||||
@kotlin.Metadata
|
||||
public final class IndexArrayElementGetterTest$AtomicArrayClass {
|
||||
// source: 'IndexArrayElementGetterTest.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field intArr: java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private final @org.jetbrains.annotations.NotNull field longArr: java.util.concurrent.atomic.AtomicLongArray
|
||||
public method <init>(): void
|
||||
public final @org.jetbrains.annotations.NotNull method getIntArr(): java.util.concurrent.atomic.AtomicIntegerArray
|
||||
public final @org.jetbrains.annotations.NotNull method getLongArr(): java.util.concurrent.atomic.AtomicLongArray
|
||||
public final inner class IndexArrayElementGetterTest$AtomicArrayClass
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class IndexArrayElementGetterTest {
|
||||
// source: 'IndexArrayElementGetterTest.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field clazz: IndexArrayElementGetterTest$AtomicArrayClass
|
||||
public method <init>(): void
|
||||
public final method fib(p0: int): int
|
||||
public final method testIndexArrayElementGetting(): void
|
||||
public final inner class IndexArrayElementGetterTest$AtomicArrayClass
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class IndexArrayElementGetterTestKt {
|
||||
// source: 'IndexArrayElementGetterTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
@@ -1,37 +0,0 @@
|
||||
import kotlinx.atomicfu.*
|
||||
import kotlin.test.*
|
||||
|
||||
class LambdaTest {
|
||||
val a = atomic(0)
|
||||
val rs = atomic<String>("bbbb")
|
||||
|
||||
private inline fun inlineLambda(
|
||||
arg: Int,
|
||||
crossinline block: (Int) -> Unit
|
||||
) = block(arg)
|
||||
|
||||
fun loopInLambda1(to: Int) = inlineLambda(to) sc@ { arg ->
|
||||
a.loop { value ->
|
||||
a.compareAndSet(value, arg)
|
||||
return@sc
|
||||
}
|
||||
}
|
||||
|
||||
fun loopInLambda2(to: Int) = inlineLambda(to) { arg1 ->
|
||||
inlineLambda(arg1) sc@ { arg2 ->
|
||||
a.loop { value ->
|
||||
a.compareAndSet(value, arg2)
|
||||
return@sc
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
val testClass = LambdaTest()
|
||||
testClass.loopInLambda1(34)
|
||||
assertEquals(34, testClass.a.value)
|
||||
testClass.loopInLambda1(77)
|
||||
assertEquals(77, testClass.a.value)
|
||||
return "OK"
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
@kotlin.Metadata
|
||||
public final class LambdaTest {
|
||||
// source: 'LambdaTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field a$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field a: int
|
||||
private final static @org.jetbrains.annotations.NotNull field rs$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field rs: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public final static @org.jetbrains.annotations.NotNull method getA$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public final method getA(): int
|
||||
public final static @org.jetbrains.annotations.NotNull method getRs$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
public final @org.jetbrains.annotations.Nullable method getRs(): java.lang.Object
|
||||
private final method inlineLambda(p0: int, p1: kotlin.jvm.functions.Function1): void
|
||||
private final method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
public final method loopInLambda1(p0: int): void
|
||||
public final method loopInLambda2(p0: int): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LambdaTestKt {
|
||||
// source: 'LambdaTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
@kotlin.Metadata
|
||||
final class LateinitPropertiesTest$Data {
|
||||
// source: 'LateinitPropertiesTest.kt'
|
||||
private final field n: int
|
||||
public method <init>(p0: int): void
|
||||
public final method getN(): int
|
||||
private final inner class LateinitPropertiesTest$Data
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LateinitPropertiesTest {
|
||||
// source: 'LateinitPropertiesTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field a$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field a: int
|
||||
private final static @org.jetbrains.annotations.NotNull field dataRef$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field dataRef: java.lang.Object
|
||||
private final static @org.jetbrains.annotations.NotNull field head$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field head: java.lang.Object
|
||||
private final @org.jetbrains.annotations.NotNull field lateIntArr: java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private final @org.jetbrains.annotations.NotNull field lateRefArr: java.util.concurrent.atomic.AtomicReferenceArray
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public final method test(): void
|
||||
private final inner class LateinitPropertiesTest$Data
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LateinitPropertiesTestKt {
|
||||
// source: 'LateinitPropertiesTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
@kotlin.Metadata
|
||||
final class LockFreeQueue$Node {
|
||||
// source: 'LockFreeQueueTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field next$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field next: java.lang.Object
|
||||
private final field value: int
|
||||
static method <clinit>(): void
|
||||
public method <init>(p0: int): void
|
||||
public final static @org.jetbrains.annotations.NotNull method getNext$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
public final @org.jetbrains.annotations.Nullable method getNext(): java.lang.Object
|
||||
public final method getValue(): int
|
||||
private final inner class LockFreeQueue$Node
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LockFreeQueue {
|
||||
// source: 'LockFreeQueueTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field head$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field head: java.lang.Object
|
||||
private final static @org.jetbrains.annotations.NotNull field tail$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field tail: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public final method dequeue(): int
|
||||
public final method enqueue(p0: int): void
|
||||
private final method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private final inner class LockFreeQueue$Node
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LockFreeQueueTest {
|
||||
// source: 'LockFreeQueueTest.kt'
|
||||
public method <init>(): void
|
||||
public final method testBasic(): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LockFreeQueueTestKt {
|
||||
// source: 'LockFreeQueueTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
@@ -1,18 +0,0 @@
|
||||
@kotlin.Metadata
|
||||
public final class LockTest {
|
||||
// source: 'LockTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field inProgressLock$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field inProgressLock: int
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public final method testLock(): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LockTestKt {
|
||||
// source: 'LockTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
public final static @org.jetbrains.annotations.NotNull method reflectionTest(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: java.util.Map): java.util.List
|
||||
private final static method tryAcquire$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int): boolean
|
||||
private final static method tryAcquire$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater): boolean
|
||||
}
|
||||
@@ -1,66 +0,0 @@
|
||||
@kotlin.Metadata
|
||||
public final class LoopTest$A {
|
||||
// source: 'LoopTest.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field s: java.lang.String
|
||||
public method <init>(@org.jetbrains.annotations.NotNull p0: java.lang.String): void
|
||||
public final @org.jetbrains.annotations.NotNull method getS(): java.lang.String
|
||||
public final inner class LoopTest$A
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LoopTest {
|
||||
// source: 'LoopTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field a$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private final static @org.jetbrains.annotations.NotNull field a1$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field a1: int
|
||||
private volatile @kotlin.jvm.Volatile field a: int
|
||||
private final static @org.jetbrains.annotations.NotNull field b$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field b: int
|
||||
private final static @org.jetbrains.annotations.NotNull field l$FU: java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field l: long
|
||||
private final static @org.jetbrains.annotations.NotNull field r$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field r: java.lang.Object
|
||||
private final static @org.jetbrains.annotations.NotNull field rs$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field rs: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public final method atomicfuBooleanLoopTest(): void
|
||||
public final method atomicfuGetAndUpdateTest(): void
|
||||
public final method atomicfuIntLoopTest(): void
|
||||
public final method atomicfuLongLoopTest(): void
|
||||
public final method atomicfuLoopTest(): void
|
||||
public final method atomicfuRefLoopTest(): void
|
||||
public final method atomicfuUpdateAndGetTest(): void
|
||||
public final method atomicfuUpdateTest(): void
|
||||
public final static @org.jetbrains.annotations.NotNull method getA$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public final method getA(): int
|
||||
public final static @org.jetbrains.annotations.NotNull method getA1$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public final method getA1(): int
|
||||
private final method getAndUpdate$atomicfu(p0: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): int
|
||||
private final method getAndUpdate$atomicfu(p0: java.util.concurrent.atomic.AtomicLongFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): long
|
||||
private final method getAndUpdate$atomicfu(p0: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): java.lang.Object
|
||||
public final static @org.jetbrains.annotations.NotNull method getB$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public final method getB(): int
|
||||
public final static @org.jetbrains.annotations.NotNull method getL$FU(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
public final method getL(): long
|
||||
public final static @org.jetbrains.annotations.NotNull method getR$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
public final @org.jetbrains.annotations.Nullable method getR(): java.lang.Object
|
||||
public final static @org.jetbrains.annotations.NotNull method getRs$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
public final @org.jetbrains.annotations.Nullable method getRs(): java.lang.Object
|
||||
private final method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private final method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicLongFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private final method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private final method update$atomicfu(p0: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private final method update$atomicfu(p0: java.util.concurrent.atomic.AtomicLongFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private final method update$atomicfu(p0: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private final method updateAndGet$atomicfu(p0: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): int
|
||||
private final method updateAndGet$atomicfu(p0: java.util.concurrent.atomic.AtomicLongFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): long
|
||||
private final method updateAndGet$atomicfu(p0: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): java.lang.Object
|
||||
public final inner class LoopTest$A
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LoopTestKt {
|
||||
// source: 'LoopTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
-19
@@ -1,19 +0,0 @@
|
||||
@kotlin.Metadata
|
||||
public final class ParameterizedInlineFunExtensionTest {
|
||||
// source: 'ParameterizedInlineFunExtensionTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field tail$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field tail: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
private final method bar$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceArray, p2: int, p3: java.lang.Object, p4: java.lang.Object): java.lang.Object
|
||||
private final method bar$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p2: java.lang.Object, p3: java.lang.Object): java.lang.Object
|
||||
private final method foo$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceArray, p2: int, p3: java.lang.Object, p4: java.lang.Object, p5: kotlin.jvm.functions.Function1): java.lang.Object
|
||||
private final method foo$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p2: java.lang.Object, p3: java.lang.Object, p4: kotlin.jvm.functions.Function1): java.lang.Object
|
||||
public final method testClose(): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class ParameterizedInlineFunExtensionTestKt {
|
||||
// source: 'ParameterizedInlineFunExtensionTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
@@ -1,19 +0,0 @@
|
||||
@kotlin.Metadata
|
||||
public final class PropertyDeclarationTest {
|
||||
// source: 'PropertyDeclarationTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field a$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field a: int
|
||||
private final static @org.jetbrains.annotations.NotNull field head$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field head: java.lang.Object
|
||||
private final @org.jetbrains.annotations.NotNull field lateIntArr: java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private final @org.jetbrains.annotations.NotNull field lateRefArr: java.util.concurrent.atomic.AtomicReferenceArray
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public final method test(): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class PropertyDeclarationTestKt {
|
||||
// source: 'PropertyDeclarationTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
@@ -1,145 +0,0 @@
|
||||
@kotlin.Metadata
|
||||
final class A$TopLevelTest$VolatileWrapper {
|
||||
// source: 'TopLevelTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field a$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field a: int
|
||||
static method <clinit>(): void
|
||||
private method <init>(): void
|
||||
public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
|
||||
public synthetic final static method access$getA$FU$p(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class ANode {
|
||||
// source: 'TopLevelTest.kt'
|
||||
private final field b: java.lang.Object
|
||||
public method <init>(p0: java.lang.Object): void
|
||||
public final method component1(): java.lang.Object
|
||||
public synthetic static method copy$default(p0: ANode, p1: java.lang.Object, p2: int, p3: java.lang.Object): ANode
|
||||
public final @org.jetbrains.annotations.NotNull method copy(p0: java.lang.Object): ANode
|
||||
public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean
|
||||
public final method getB(): java.lang.Object
|
||||
public method hashCode(): int
|
||||
public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
final class AbcNode$TopLevelTest$VolatileWrapper {
|
||||
// source: 'TopLevelTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field abcNode$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field abcNode: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
private method <init>(): void
|
||||
public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
|
||||
public synthetic final static method access$getAbcNode$FU$p(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
final class Any$TopLevelTest$VolatileWrapper {
|
||||
// source: 'TopLevelTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field any$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field any: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
private method <init>(): void
|
||||
public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
|
||||
public synthetic final static method access$getAny$FU$p(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
final class B$TopLevelTest$VolatileWrapper {
|
||||
// source: 'TopLevelTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field b$FU: java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field b: long
|
||||
static method <clinit>(): void
|
||||
private method <init>(): void
|
||||
public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
|
||||
public synthetic final static method access$getB$FU$p(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class BNode {
|
||||
// source: 'TopLevelTest.kt'
|
||||
private final field c: java.lang.Object
|
||||
public method <init>(p0: java.lang.Object): void
|
||||
public final method component1(): java.lang.Object
|
||||
public synthetic static method copy$default(p0: BNode, p1: java.lang.Object, p2: int, p3: java.lang.Object): BNode
|
||||
public final @org.jetbrains.annotations.NotNull method copy(p0: java.lang.Object): BNode
|
||||
public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean
|
||||
public final method getC(): java.lang.Object
|
||||
public method hashCode(): int
|
||||
public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
final class C$TopLevelTest$VolatileWrapper {
|
||||
// source: 'TopLevelTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field c$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field c: int
|
||||
static method <clinit>(): void
|
||||
private method <init>(): void
|
||||
public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
|
||||
public synthetic final static method access$getC$FU$p(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class CNode {
|
||||
// source: 'TopLevelTest.kt'
|
||||
private final field d: int
|
||||
public method <init>(p0: int): void
|
||||
public final method component1(): int
|
||||
public synthetic static method copy$default(p0: CNode, p1: int, p2: int, p3: java.lang.Object): CNode
|
||||
public final @org.jetbrains.annotations.NotNull method copy(p0: int): CNode
|
||||
public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean
|
||||
public final method getD(): int
|
||||
public method hashCode(): int
|
||||
public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class TopLevelArrayTest {
|
||||
// source: 'TopLevelTest.kt'
|
||||
public method <init>(): void
|
||||
public final method testBooleanArray(): void
|
||||
public final method testIntArray(): void
|
||||
public final method testLongArray(): void
|
||||
public final method testRefArray(): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class TopLevelPrimitiveTest {
|
||||
// source: 'TopLevelTest.kt'
|
||||
public method <init>(): void
|
||||
public final method testTopLevelArrayOfNulls(): void
|
||||
public final method testTopLevelBoolean(): void
|
||||
public final method testTopLevelInt(): void
|
||||
public final method testTopLevelLong(): void
|
||||
public final method testTopLevelRef(): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class TopLevelTestKt {
|
||||
// source: 'TopLevelTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field a$TopLevelTest$VolatileWrapper: A$TopLevelTest$VolatileWrapper
|
||||
private final static @org.jetbrains.annotations.NotNull field abcNode$TopLevelTest$VolatileWrapper: AbcNode$TopLevelTest$VolatileWrapper
|
||||
private final static @org.jetbrains.annotations.NotNull field any$TopLevelTest$VolatileWrapper: Any$TopLevelTest$VolatileWrapper
|
||||
private final static @org.jetbrains.annotations.NotNull field anyRefArr: java.util.concurrent.atomic.AtomicReferenceArray
|
||||
private final static @org.jetbrains.annotations.NotNull field b$TopLevelTest$VolatileWrapper: B$TopLevelTest$VolatileWrapper
|
||||
private final static @org.jetbrains.annotations.NotNull field booleanArr: java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private final static @org.jetbrains.annotations.NotNull field c$TopLevelTest$VolatileWrapper: C$TopLevelTest$VolatileWrapper
|
||||
private final static @org.jetbrains.annotations.NotNull field intArr: java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private final static @org.jetbrains.annotations.NotNull field longArr: java.util.concurrent.atomic.AtomicLongArray
|
||||
private final static @org.jetbrains.annotations.NotNull field refArr: java.util.concurrent.atomic.AtomicReferenceArray
|
||||
private final static @org.jetbrains.annotations.NotNull field stringAtomicNullArr: java.util.concurrent.atomic.AtomicReferenceArray
|
||||
static method <clinit>(): void
|
||||
public synthetic final static method access$getA$TopLevelTest$VolatileWrapper$p(): A$TopLevelTest$VolatileWrapper
|
||||
public synthetic final static method access$getAbcNode$TopLevelTest$VolatileWrapper$p(): AbcNode$TopLevelTest$VolatileWrapper
|
||||
public synthetic final static method access$getAny$TopLevelTest$VolatileWrapper$p(): Any$TopLevelTest$VolatileWrapper
|
||||
public synthetic final static method access$getB$TopLevelTest$VolatileWrapper$p(): B$TopLevelTest$VolatileWrapper
|
||||
public synthetic final static method access$getBooleanArr$p(): java.util.concurrent.atomic.AtomicIntegerArray
|
||||
public synthetic final static method access$getC$TopLevelTest$VolatileWrapper$p(): C$TopLevelTest$VolatileWrapper
|
||||
public synthetic final static method access$getIntArr$p(): java.util.concurrent.atomic.AtomicIntegerArray
|
||||
public synthetic final static method access$getLongArr$p(): java.util.concurrent.atomic.AtomicLongArray
|
||||
public synthetic final static method access$getRefArr$p(): java.util.concurrent.atomic.AtomicReferenceArray
|
||||
public synthetic final static method access$getStringAtomicNullArr$p(): java.util.concurrent.atomic.AtomicReferenceArray
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
@@ -1,46 +0,0 @@
|
||||
@kotlin.Metadata
|
||||
final enum class TraceTest$Status {
|
||||
// source: 'TraceTest.kt'
|
||||
private synthetic final static field $ENTRIES: kotlin.enums.EnumEntries
|
||||
private synthetic final static field $VALUES: TraceTest$Status[]
|
||||
public final enum static field END: TraceTest$Status
|
||||
public final enum static field START: TraceTest$Status
|
||||
private synthetic final static method $values(): TraceTest$Status[]
|
||||
static method <clinit>(): void
|
||||
private method <init>(p0: java.lang.String, p1: int): void
|
||||
public static @org.jetbrains.annotations.NotNull method getEntries(): kotlin.enums.EnumEntries
|
||||
public static method valueOf(p0: java.lang.String): TraceTest$Status
|
||||
public static method values(): TraceTest$Status[]
|
||||
private final inner class TraceTest$Status
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class TraceTest {
|
||||
// source: 'TraceTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field a$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private final static @org.jetbrains.annotations.NotNull field a1$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field a1: int
|
||||
private final static @org.jetbrains.annotations.NotNull field a2$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field a2: int
|
||||
private final static @org.jetbrains.annotations.NotNull field a3$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field a3: int
|
||||
private volatile @kotlin.jvm.Volatile field a: int
|
||||
private final static @org.jetbrains.annotations.NotNull field s$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field s: int
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public final method test(): void
|
||||
public final method testDefaultTrace(): void
|
||||
public final method testMultipleAppend(): void
|
||||
public final method testNamedTrace(): void
|
||||
public final method testTraceInBlock(): void
|
||||
public final method testTraceWithFormat(): void
|
||||
public final method testTraceWithSize(): void
|
||||
private final inner class TraceTest$Status
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class TraceTestKt {
|
||||
// source: 'TraceTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
@@ -1,54 +0,0 @@
|
||||
@kotlin.Metadata
|
||||
final class TopLevelS$UncheckedCastTest$VolatileWrapper {
|
||||
// source: 'UncheckedCastTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field topLevelS$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field topLevelS: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
private method <init>(): void
|
||||
public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
|
||||
public synthetic final static method access$getTopLevelS$FU$p(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
final class UncheckedCastTest$Box {
|
||||
// source: 'UncheckedCastTest.kt'
|
||||
private final field b: int
|
||||
public method <init>(p0: int): void
|
||||
public final method component1(): int
|
||||
public synthetic static method copy$default(p0: UncheckedCastTest$Box, p1: int, p2: int, p3: java.lang.Object): UncheckedCastTest$Box
|
||||
public final @org.jetbrains.annotations.NotNull method copy(p0: int): UncheckedCastTest$Box
|
||||
public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean
|
||||
public final method getB(): int
|
||||
public method hashCode(): int
|
||||
public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
|
||||
private final inner class UncheckedCastTest$Box
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class UncheckedCastTest {
|
||||
// source: 'UncheckedCastTest.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field a: java.util.concurrent.atomic.AtomicReferenceArray
|
||||
private final static @org.jetbrains.annotations.NotNull field bs$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field bs: java.lang.Object
|
||||
private final static @org.jetbrains.annotations.NotNull field s$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field s: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
private final method getString$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceArray, p2: int): java.lang.String
|
||||
private final method getString$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceFieldUpdater): java.lang.String
|
||||
public final method testArrayValueUncheckedCast(): void
|
||||
public final method testArrayValueUncheckedCastInlineFunc(): void
|
||||
public final method testAtomicValUncheckedCast(): void
|
||||
public final method testInlineFunc(): void
|
||||
public final method testTopLevelValUnchekedCast(): void
|
||||
private final inner class UncheckedCastTest$Box
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class UncheckedCastTestKt {
|
||||
// source: 'UncheckedCastTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field topLevelS$UncheckedCastTest$VolatileWrapper: TopLevelS$UncheckedCastTest$VolatileWrapper
|
||||
static method <clinit>(): void
|
||||
public synthetic final static method access$getTopLevelS$UncheckedCastTest$VolatileWrapper$p(): TopLevelS$UncheckedCastTest$VolatileWrapper
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
+4
-4
@@ -2,10 +2,10 @@ import kotlinx.atomicfu.*
|
||||
import kotlin.test.*
|
||||
|
||||
class ArrayInlineExtensionTest {
|
||||
val intArr = AtomicIntArray(10)
|
||||
val a = atomic(100)
|
||||
val longArr = AtomicLongArray(10)
|
||||
val refArr = atomicArrayOfNulls<Any?>(5)
|
||||
private val intArr = AtomicIntArray(10)
|
||||
private val a = atomic(100)
|
||||
private val longArr = AtomicLongArray(10)
|
||||
private val refArr = atomicArrayOfNulls<Any?>(5)
|
||||
|
||||
class A(val s: String)
|
||||
|
||||
Vendored
+51
@@ -0,0 +1,51 @@
|
||||
@kotlin.Metadata
|
||||
public final class ArrayInlineExtensionTest$A {
|
||||
// source: 'ArrayInlineExtensionTest.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field s: java.lang.String
|
||||
public method <init>(@org.jetbrains.annotations.NotNull p0: java.lang.String): void
|
||||
public final @org.jetbrains.annotations.NotNull method getS(): java.lang.String
|
||||
public final inner class ArrayInlineExtensionTest$A
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class ArrayInlineExtensionTest {
|
||||
// source: 'ArrayInlineExtensionTest.kt'
|
||||
private synthetic final static field a$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field a$volatile: int
|
||||
private synthetic final field intArr: java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private synthetic final field longArr: java.util.concurrent.atomic.AtomicLongArray
|
||||
private synthetic final field refArr: java.util.concurrent.atomic.AtomicReferenceArray
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
private synthetic final method bar$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int): int
|
||||
private synthetic final method bar$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int): int
|
||||
private final method casLoop(p0: int): int
|
||||
private final method casLoopExpression(p0: long): long
|
||||
private synthetic final method extensionLoop$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int): int
|
||||
private synthetic final method extensionLoop$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int): int
|
||||
private synthetic final method extensionLoopExpression$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int): int
|
||||
private synthetic final method extensionLoopExpression$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int): int
|
||||
private synthetic final method extensionLoopMixedReceivers$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int, p4: int, p5: int): int
|
||||
private synthetic final method extensionLoopMixedReceivers$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int, p3: int, p4: int): int
|
||||
private synthetic final method extensionLoopRecursive$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int): int
|
||||
private synthetic final method extensionLoopRecursive$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int): int
|
||||
private synthetic final method foo$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int): int
|
||||
private synthetic final method foo$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int): int
|
||||
private synthetic final static method getA$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getA$volatile(): int
|
||||
private synthetic final method getIntArr(): java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private synthetic final method getLongArr(): java.util.concurrent.atomic.AtomicLongArray
|
||||
private synthetic final method getRefArr(): java.util.concurrent.atomic.AtomicReferenceArray
|
||||
private synthetic final method loop$atomicfu$array(p0: java.util.concurrent.atomic.AtomicIntegerArray, p1: int, p2: kotlin.jvm.functions.Function1): void
|
||||
private synthetic final method loop$atomicfu$array(p0: java.util.concurrent.atomic.AtomicLongArray, p1: int, p2: kotlin.jvm.functions.Function1): void
|
||||
private synthetic final method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private synthetic final method setA$volatile(p0: int): void
|
||||
public final method testIntExtensionLoops(): void
|
||||
public final inner class ArrayInlineExtensionTest$A
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class ArrayInlineExtensionTestKt {
|
||||
// source: 'ArrayInlineExtensionTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
+8
-6
@@ -16,18 +16,20 @@ final class ArrayInlineFunctionTest$Box {
|
||||
@kotlin.Metadata
|
||||
public final class ArrayInlineFunctionTest {
|
||||
// source: 'ArrayLoopTest.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field anyArr: java.util.concurrent.atomic.AtomicReferenceArray
|
||||
private final @org.jetbrains.annotations.NotNull field refArr: java.util.concurrent.atomic.AtomicReferenceArray
|
||||
private synthetic final field anyArr: java.util.concurrent.atomic.AtomicReferenceArray
|
||||
private synthetic final field refArr: java.util.concurrent.atomic.AtomicReferenceArray
|
||||
public method <init>(): void
|
||||
private final method action(p0: ArrayInlineFunctionTest$Box): ArrayInlineFunctionTest$Box
|
||||
private final method getAndUpdate$atomicfu$array(p0: java.util.concurrent.atomic.AtomicReferenceArray, p1: int, p2: kotlin.jvm.functions.Function1): java.lang.Object
|
||||
private final method loop$atomicfu$array(p0: java.util.concurrent.atomic.AtomicReferenceArray, p1: int, p2: kotlin.jvm.functions.Function1): void
|
||||
private synthetic final method getAndUpdate$atomicfu$array(p0: java.util.concurrent.atomic.AtomicReferenceArray, p1: int, p2: kotlin.jvm.functions.Function1): java.lang.Object
|
||||
private synthetic final method getAnyArr(): java.util.concurrent.atomic.AtomicReferenceArray
|
||||
private synthetic final method getRefArr(): java.util.concurrent.atomic.AtomicReferenceArray
|
||||
private synthetic final method loop$atomicfu$array(p0: java.util.concurrent.atomic.AtomicReferenceArray, p1: int, p2: kotlin.jvm.functions.Function1): void
|
||||
public final method testArrayElementGetAndUpdate(): void
|
||||
public final method testArrayElementUpdate(): void
|
||||
public final method testArrayElementUpdateAndGet(): void
|
||||
public final method testSetArrayElementValueInLoop(): void
|
||||
private final method update$atomicfu$array(p0: java.util.concurrent.atomic.AtomicReferenceArray, p1: int, p2: kotlin.jvm.functions.Function1): void
|
||||
private final method updateAndGet$atomicfu$array(p0: java.util.concurrent.atomic.AtomicReferenceArray, p1: int, p2: kotlin.jvm.functions.Function1): java.lang.Object
|
||||
private synthetic final method update$atomicfu$array(p0: java.util.concurrent.atomic.AtomicReferenceArray, p1: int, p2: kotlin.jvm.functions.Function1): void
|
||||
private synthetic final method updateAndGet$atomicfu$array(p0: java.util.concurrent.atomic.AtomicReferenceArray, p1: int, p2: kotlin.jvm.functions.Function1): java.lang.Object
|
||||
private final inner class ArrayInlineFunctionTest$Box
|
||||
}
|
||||
|
||||
+5
-5
@@ -2,11 +2,11 @@ import kotlinx.atomicfu.*
|
||||
import kotlin.test.*
|
||||
|
||||
class LoopTest {
|
||||
val a = atomic(10)
|
||||
val b = atomic(11)
|
||||
val c = atomic(12)
|
||||
val r = atomic<String>("aaa")
|
||||
val intArr = AtomicIntArray(10)
|
||||
private val a = atomic(10)
|
||||
private val b = atomic(11)
|
||||
private val c = atomic(12)
|
||||
private val r = atomic<String>("aaa")
|
||||
private val intArr = AtomicIntArray(10)
|
||||
|
||||
private inline fun AtomicInt.extensionEmbeddedLoops(to: Int): Int =
|
||||
loop { cur1 ->
|
||||
+48
@@ -0,0 +1,48 @@
|
||||
@kotlin.Metadata
|
||||
public final class ComplexLoopTestKt {
|
||||
// source: 'ComplexLoopTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LoopTest {
|
||||
// source: 'ComplexLoopTest.kt'
|
||||
private synthetic final static field a$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field a$volatile: int
|
||||
private synthetic final static field b$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field b$volatile: int
|
||||
private synthetic final static field c$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field c$volatile: int
|
||||
private synthetic final field intArr: java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private synthetic final static field r$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field r$volatile: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
private final method embeddedLoops(p0: int): int
|
||||
private final method embeddedUpdate(p0: int): int
|
||||
private synthetic final method extensionEmbeddedLoops$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int): int
|
||||
private synthetic final method extensionEmbeddedLoops$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int): int
|
||||
private synthetic final method extesntionEmbeddedRefUpdate$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceArray, p2: int, p3: java.lang.String): java.lang.String
|
||||
private synthetic final method extesntionEmbeddedRefUpdate$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p2: java.lang.String): java.lang.String
|
||||
private synthetic final static method getA$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getA$volatile(): int
|
||||
private synthetic final static method getB$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getB$volatile(): int
|
||||
private synthetic final static method getC$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getC$volatile(): int
|
||||
private synthetic final method getIntArr(): java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private synthetic final static method getR$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getR$volatile(): java.lang.Object
|
||||
private synthetic final method loop$atomicfu$array(p0: java.util.concurrent.atomic.AtomicIntegerArray, p1: int, p2: kotlin.jvm.functions.Function1): void
|
||||
private synthetic final method loop$atomicfu$array(p0: java.util.concurrent.atomic.AtomicReferenceArray, p1: int, p2: kotlin.jvm.functions.Function1): void
|
||||
private synthetic final method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private synthetic final method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private synthetic final method setA$volatile(p0: int): void
|
||||
private synthetic final method setB$volatile(p0: int): void
|
||||
private synthetic final method setC$volatile(p0: int): void
|
||||
private synthetic final method setR$volatile(p0: java.lang.Object): void
|
||||
public final method test(): void
|
||||
private synthetic final method updateAndGet$atomicfu$array(p0: java.util.concurrent.atomic.AtomicReferenceArray, p1: int, p2: kotlin.jvm.functions.Function1): java.lang.Object
|
||||
private synthetic final method updateAndGet$atomicfu(p0: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): int
|
||||
private synthetic final method updateAndGet$atomicfu(p0: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): java.lang.Object
|
||||
}
|
||||
+6
-6
@@ -2,12 +2,12 @@ import kotlinx.atomicfu.*
|
||||
import kotlin.test.*
|
||||
|
||||
class LoopTest {
|
||||
val a = atomic(0)
|
||||
val a1 = atomic(1)
|
||||
val b = atomic(true)
|
||||
val l = atomic(5000000000)
|
||||
val r = atomic<A>(A("aaaa"))
|
||||
val rs = atomic<String>("bbbb")
|
||||
private val a = atomic(0)
|
||||
private val a1 = atomic(1)
|
||||
private val b = atomic(true)
|
||||
private val l = atomic(5000000000)
|
||||
private val r = atomic<A>(A("aaaa"))
|
||||
private val rs = atomic<String>("bbbb")
|
||||
|
||||
class A(val s: String)
|
||||
|
||||
+91
@@ -0,0 +1,91 @@
|
||||
@kotlin.Metadata
|
||||
synthetic final class ExtensionLoopTest$VolatileWrapper$atomicfu$private {
|
||||
// source: 'ExtensionLoopTest.kt'
|
||||
private synthetic final static field ref$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field ref$volatile: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
private method <init>(): void
|
||||
public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
|
||||
public synthetic final static method access$getRef$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final static method getRef$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getRef$volatile(): java.lang.Object
|
||||
private synthetic final method setRef$volatile(p0: java.lang.Object): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class ExtensionLoopTestKt {
|
||||
// source: 'ExtensionLoopTest.kt'
|
||||
private synthetic final static field extensionLoopTest$VolatileWrapper$atomicfu$private: ExtensionLoopTest$VolatileWrapper$atomicfu$private
|
||||
static method <clinit>(): void
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
private synthetic final static method getExtensionLoopTest$VolatileWrapper$atomicfu$private(): ExtensionLoopTest$VolatileWrapper$atomicfu$private
|
||||
private synthetic final static method loop$atomicfu$array(p0: java.util.concurrent.atomic.AtomicReferenceArray, p1: int, p2: kotlin.jvm.functions.Function1): void
|
||||
private synthetic final static method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
public final static method testTopLevelExtensionLoop(): void
|
||||
private synthetic final static method topLevelExtensionLoop$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceArray, p2: int, p3: java.lang.String): java.lang.String
|
||||
private synthetic final static method topLevelExtensionLoop$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p2: java.lang.String): java.lang.String
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LoopTest$A {
|
||||
// source: 'ExtensionLoopTest.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field s: java.lang.String
|
||||
public method <init>(@org.jetbrains.annotations.NotNull p0: java.lang.String): void
|
||||
public final @org.jetbrains.annotations.NotNull method getS(): java.lang.String
|
||||
public final inner class LoopTest$A
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LoopTest {
|
||||
// source: 'ExtensionLoopTest.kt'
|
||||
private synthetic final static field a$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field a$volatile: int
|
||||
private synthetic final static field a1$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field a1$volatile: int
|
||||
private synthetic final static field b$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field b$volatile: int
|
||||
private synthetic final static field l$volatile$FU: java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic volatile field l$volatile: long
|
||||
private synthetic final static field r$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field r$volatile: java.lang.Object
|
||||
private synthetic final static field rs$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field rs$volatile: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
private synthetic final method bar$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int): int
|
||||
private synthetic final method bar$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int): int
|
||||
private final method casLoop(p0: int): int
|
||||
private final method casLoopExpression(p0: int): int
|
||||
private synthetic final method extensionLoop$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int): int
|
||||
private synthetic final method extensionLoop$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int): int
|
||||
private synthetic final method extensionLoopExpression$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int): int
|
||||
private synthetic final method extensionLoopExpression$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int): int
|
||||
private synthetic final method extensionLoopMixedReceivers$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int, p4: int): int
|
||||
private synthetic final method extensionLoopMixedReceivers$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int, p3: int): int
|
||||
private synthetic final method extensionLoopRecursive$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int): int
|
||||
private synthetic final method extensionLoopRecursive$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int): int
|
||||
private synthetic final method foo$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int, p3: int): int
|
||||
private synthetic final method foo$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p2: int): int
|
||||
private synthetic final static method getA$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getA$volatile(): int
|
||||
private synthetic final static method getA1$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getA1$volatile(): int
|
||||
private synthetic final static method getB$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getB$volatile(): int
|
||||
private synthetic final static method getL$volatile$FU(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic final method getL$volatile(): long
|
||||
private synthetic final static method getR$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getR$volatile(): java.lang.Object
|
||||
private synthetic final static method getRs$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getRs$volatile(): java.lang.Object
|
||||
private synthetic final method loop$atomicfu$array(p0: java.util.concurrent.atomic.AtomicIntegerArray, p1: int, p2: kotlin.jvm.functions.Function1): void
|
||||
private synthetic final method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private synthetic final method setA$volatile(p0: int): void
|
||||
private synthetic final method setA1$volatile(p0: int): void
|
||||
private synthetic final method setB$volatile(p0: int): void
|
||||
private synthetic final method setL$volatile(p0: long): void
|
||||
private synthetic final method setR$volatile(p0: java.lang.Object): void
|
||||
private synthetic final method setRs$volatile(p0: java.lang.Object): void
|
||||
public final method testIntExtensionLoops(): void
|
||||
public final inner class LoopTest$A
|
||||
}
|
||||
+9
-9
@@ -2,10 +2,10 @@ import kotlinx.atomicfu.*
|
||||
import kotlin.test.*
|
||||
|
||||
class ExtensionsTest {
|
||||
val a = atomic(0)
|
||||
val l = atomic(0L)
|
||||
val s = atomic<String?>(null)
|
||||
val b = atomic(true)
|
||||
private val a = atomic(0)
|
||||
private val l = atomic(0L)
|
||||
private val s = atomic<String?>(null)
|
||||
private val b = atomic(true)
|
||||
|
||||
fun testScopedFieldGetters() {
|
||||
check(a.value == 0)
|
||||
@@ -31,7 +31,7 @@ class ExtensionsTest {
|
||||
check(a.compareAndSet(7, 10))
|
||||
}
|
||||
|
||||
inline fun AtomicInt.intExtensionArithmetic() {
|
||||
private inline fun AtomicInt.intExtensionArithmetic() {
|
||||
value = 0
|
||||
check(value == 0)
|
||||
val update = 3
|
||||
@@ -58,7 +58,7 @@ class ExtensionsTest {
|
||||
check(value == 55)
|
||||
}
|
||||
|
||||
inline fun AtomicLong.longExtensionArithmetic() {
|
||||
private inline fun AtomicLong.longExtensionArithmetic() {
|
||||
value = 2424920024888888848
|
||||
check(value == 2424920024888888848)
|
||||
lazySet(8424920024888888848)
|
||||
@@ -79,7 +79,7 @@ class ExtensionsTest {
|
||||
check(value == -198452011965886959)
|
||||
}
|
||||
|
||||
inline fun AtomicRef<String?>.refExtension() {
|
||||
private inline fun AtomicRef<String?>.refExtension() {
|
||||
value = "aaa"
|
||||
check(value == "aaa")
|
||||
lazySet("bb")
|
||||
@@ -88,7 +88,7 @@ class ExtensionsTest {
|
||||
check(value == "ccc")
|
||||
}
|
||||
|
||||
inline fun AtomicBoolean.booleanExtensionArithmetic() {
|
||||
private inline fun AtomicBoolean.booleanExtensionArithmetic() {
|
||||
value = false
|
||||
check(!value)
|
||||
lazySet(true)
|
||||
@@ -112,4 +112,4 @@ fun box(): String {
|
||||
testClass.testScopedFieldGetters()
|
||||
testClass.testExtension()
|
||||
return "OK"
|
||||
}
|
||||
}
|
||||
+42
@@ -0,0 +1,42 @@
|
||||
@kotlin.Metadata
|
||||
public final class ExtensionsTest {
|
||||
// source: 'ExtensionsTest.kt'
|
||||
private synthetic final static field a$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field a$volatile: int
|
||||
private synthetic final static field b$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field b$volatile: int
|
||||
private synthetic final static field l$volatile$FU: java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic volatile field l$volatile: long
|
||||
private synthetic final static field s$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field s$volatile: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
private synthetic final method booleanExtensionArithmetic$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int): void
|
||||
private synthetic final method booleanExtensionArithmetic$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater): void
|
||||
private synthetic final static method getA$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getA$volatile(): int
|
||||
private synthetic final static method getB$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getB$volatile(): int
|
||||
private synthetic final static method getL$volatile$FU(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic final method getL$volatile(): long
|
||||
private synthetic final static method getS$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getS$volatile(): java.lang.Object
|
||||
private synthetic final method intExtensionArithmetic$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int): void
|
||||
private synthetic final method intExtensionArithmetic$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater): void
|
||||
private synthetic final method longExtensionArithmetic$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicLongArray, p2: int): void
|
||||
private synthetic final method longExtensionArithmetic$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicLongFieldUpdater): void
|
||||
private synthetic final method refExtension$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceArray, p2: int): void
|
||||
private synthetic final method refExtension$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceFieldUpdater): void
|
||||
private synthetic final method setA$volatile(p0: int): void
|
||||
private synthetic final method setB$volatile(p0: int): void
|
||||
private synthetic final method setL$volatile(p0: long): void
|
||||
private synthetic final method setS$volatile(p0: java.lang.Object): void
|
||||
public final method testExtension(): void
|
||||
public final method testScopedFieldGetters(): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class ExtensionsTestKt {
|
||||
// source: 'ExtensionsTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
+2
-2
@@ -18,7 +18,7 @@ class InlineExtensionWithTypeParameterTest {
|
||||
return cur.id
|
||||
}
|
||||
|
||||
val sref = atomic(SemaphoreSegment(0))
|
||||
private val sref = atomic(SemaphoreSegment(0))
|
||||
|
||||
fun testInlineExtensionWithTypeParameter() {
|
||||
val s = SemaphoreSegment(77)
|
||||
@@ -30,4 +30,4 @@ fun box(): String {
|
||||
val testClass = InlineExtensionWithTypeParameterTest()
|
||||
testClass.testInlineExtensionWithTypeParameter()
|
||||
return "OK"
|
||||
}
|
||||
}
|
||||
+7
-6
@@ -18,15 +18,16 @@ public final class InlineExtensionWithTypeParameterTest$SemaphoreSegment {
|
||||
@kotlin.Metadata
|
||||
public final class InlineExtensionWithTypeParameterTest {
|
||||
// source: 'InlineExtensionWithTypeParameterTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field sref$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field sref: java.lang.Object
|
||||
private synthetic final static field sref$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field sref$volatile: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
private final method foo$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceArray, p2: int, p3: int, p4: InlineExtensionWithTypeParameterTest$Segment): int
|
||||
private final method foo$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p2: int, p3: InlineExtensionWithTypeParameterTest$Segment): int
|
||||
private synthetic final method foo$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceArray, p2: int, p3: int, p4: InlineExtensionWithTypeParameterTest$Segment): int
|
||||
private synthetic final method foo$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p2: int, p3: InlineExtensionWithTypeParameterTest$Segment): int
|
||||
private final method getSegmentId(p0: InlineExtensionWithTypeParameterTest$Segment): int
|
||||
public final static @org.jetbrains.annotations.NotNull method getSref$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
public final @org.jetbrains.annotations.Nullable method getSref(): java.lang.Object
|
||||
private synthetic final static method getSref$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getSref$volatile(): java.lang.Object
|
||||
private synthetic final method setSref$volatile(p0: java.lang.Object): void
|
||||
public final method testInlineExtensionWithTypeParameter(): void
|
||||
public abstract inner class InlineExtensionWithTypeParameterTest$Segment
|
||||
public final inner class InlineExtensionWithTypeParameterTest$SemaphoreSegment
|
||||
+52
@@ -0,0 +1,52 @@
|
||||
import kotlinx.atomicfu.*
|
||||
import kotlin.test.*
|
||||
|
||||
class LambdaTest {
|
||||
private val a = atomic(0)
|
||||
private val rs = atomic<String>("bbbb")
|
||||
|
||||
private inline fun <T> inlineLambda(
|
||||
arg: T,
|
||||
crossinline block: (T) -> Unit
|
||||
) = block(arg)
|
||||
|
||||
fun loopInLambda1(to: Int) = inlineLambda(to) sc@ { arg ->
|
||||
a.loop { value ->
|
||||
a.compareAndSet(value, arg)
|
||||
return@sc
|
||||
}
|
||||
}
|
||||
|
||||
fun loopInLambda2(to: Int) = inlineLambda(to) { arg1 ->
|
||||
inlineLambda(arg1) sc@ { arg2 ->
|
||||
a.loop { value ->
|
||||
a.compareAndSet(value, arg2)
|
||||
return@sc
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun loopInLambda2Ref(to: String) = inlineLambda(to) { arg1 ->
|
||||
inlineLambda(arg1) sc@ { arg2 ->
|
||||
rs.loop { value ->
|
||||
rs.compareAndSet(value, arg2)
|
||||
return@sc
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun test() {
|
||||
loopInLambda1(34)
|
||||
assertEquals(34, a.value)
|
||||
loopInLambda1(77)
|
||||
assertEquals(77, a.value)
|
||||
loopInLambda2Ref("bbb")
|
||||
assertEquals("bbb", rs.value)
|
||||
}
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
val testClass = LambdaTest()
|
||||
testClass.test()
|
||||
return "OK"
|
||||
}
|
||||
+31
@@ -0,0 +1,31 @@
|
||||
@kotlin.Metadata
|
||||
public final class LambdaTest {
|
||||
// source: 'LambdaTest.kt'
|
||||
private synthetic final static field a$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field a$volatile: int
|
||||
private synthetic final static field rs$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field rs$volatile: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public synthetic final static method access$getA$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public synthetic final static method access$getRs$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final static method getA$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getA$volatile(): int
|
||||
private synthetic final static method getRs$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getRs$volatile(): java.lang.Object
|
||||
private final method inlineLambda(p0: java.lang.Object, p1: kotlin.jvm.functions.Function1): void
|
||||
private synthetic final method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private synthetic final method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
public final method loopInLambda1(p0: int): void
|
||||
public final method loopInLambda2(p0: int): void
|
||||
public final method loopInLambda2Ref(@org.jetbrains.annotations.NotNull p0: java.lang.String): void
|
||||
private synthetic final method setA$volatile(p0: int): void
|
||||
private synthetic final method setRs$volatile(p0: java.lang.Object): void
|
||||
public final method test(): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LambdaTestKt {
|
||||
// source: 'LambdaTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
+6
-3
@@ -1,16 +1,19 @@
|
||||
@kotlin.Metadata
|
||||
public final class LockFreeIntBits {
|
||||
// source: 'LockFreeIntBitsTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field bits$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field bits: int
|
||||
private synthetic final static field bits$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field bits$volatile: int
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public final method bitClear(p0: int): boolean
|
||||
public final method bitSet(p0: int): boolean
|
||||
private final method bitUpdate(p0: kotlin.jvm.functions.Function1, p1: kotlin.jvm.functions.Function1): boolean
|
||||
public final method get(p0: int): boolean
|
||||
private synthetic final static method getBits$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getBits$volatile(): int
|
||||
private final method mask(p0: int): int
|
||||
private final method update$atomicfu(p0: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private synthetic final method setBits$volatile(p0: int): void
|
||||
private synthetic final method update$atomicfu(p0: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
@kotlin.Metadata
|
||||
public final class LockTest {
|
||||
// source: 'LockTest.kt'
|
||||
private synthetic final static field inProgressLock$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field inProgressLock$volatile: int
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
private synthetic final static method getInProgressLock$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getInProgressLock$volatile(): int
|
||||
private synthetic final method setInProgressLock$volatile(p0: int): void
|
||||
public final method testLock(): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LockTestKt {
|
||||
// source: 'LockTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
public final static @org.jetbrains.annotations.NotNull method reflectionTest(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: java.util.Map): java.util.List
|
||||
private synthetic final static method tryAcquire$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerArray, p2: int): boolean
|
||||
private synthetic final static method tryAcquire$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicIntegerFieldUpdater): boolean
|
||||
}
|
||||
+22
@@ -0,0 +1,22 @@
|
||||
@kotlin.Metadata
|
||||
public final class ParameterizedInlineFunExtensionTest {
|
||||
// source: 'ParameterizedInlineFunExtensionTest.kt'
|
||||
private synthetic final static field tail$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field tail$volatile: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
private synthetic final method bar$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceArray, p2: int, p3: java.lang.Object, p4: java.lang.Object): java.lang.Object
|
||||
private synthetic final method bar$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p2: java.lang.Object, p3: java.lang.Object): java.lang.Object
|
||||
private synthetic final method foo$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceArray, p2: int, p3: java.lang.Object, p4: java.lang.Object, p5: kotlin.jvm.functions.Function1): java.lang.Object
|
||||
private synthetic final method foo$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p2: java.lang.Object, p3: java.lang.Object, p4: kotlin.jvm.functions.Function1): java.lang.Object
|
||||
private synthetic final static method getTail$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getTail$volatile(): java.lang.Object
|
||||
private synthetic final method setTail$volatile(p0: java.lang.Object): void
|
||||
public final method testClose(): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class ParameterizedInlineFunExtensionTestKt {
|
||||
// source: 'ParameterizedInlineFunExtensionTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
+130
@@ -0,0 +1,130 @@
|
||||
import kotlinx.atomicfu.*
|
||||
import kotlin.test.*
|
||||
|
||||
class IntArithmetic {
|
||||
private val _x = atomic(0)
|
||||
val x get() = _x.value
|
||||
|
||||
private val local = atomic(0)
|
||||
|
||||
private fun testGetValue() {
|
||||
_x.value = 5
|
||||
assertEquals(5, _x.value)
|
||||
var aValue = _x.value
|
||||
assertEquals(5, aValue)
|
||||
assertEquals(5, x)
|
||||
|
||||
local.value = 555
|
||||
aValue = local.value
|
||||
assertEquals(aValue, local.value)
|
||||
}
|
||||
|
||||
private fun testAtomicCallPlaces() {
|
||||
_x.value = 5
|
||||
_x.compareAndSet(5, 42)
|
||||
val res = _x.compareAndSet(42, 45)
|
||||
assertTrue(res)
|
||||
assertTrue(_x.compareAndSet(45, 77))
|
||||
assertFalse(_x.compareAndSet(95, 77))
|
||||
assertTrue(_x.compareAndSet(77, 88))
|
||||
}
|
||||
|
||||
private fun testInt() {
|
||||
_x.value = 0
|
||||
assertEquals(0, x)
|
||||
val update = 3
|
||||
assertEquals(0, _x.getAndSet(update))
|
||||
assertTrue(_x.compareAndSet(update, 8))
|
||||
_x.lazySet(1)
|
||||
assertEquals(1, x)
|
||||
assertEquals(1, _x.getAndSet(2))
|
||||
assertEquals(2, x)
|
||||
assertEquals(2, _x.getAndIncrement())
|
||||
assertEquals(3, x)
|
||||
assertEquals(3, _x.getAndDecrement())
|
||||
assertEquals(2, x)
|
||||
assertEquals(2, _x.getAndAdd(2))
|
||||
assertEquals(4, x)
|
||||
assertEquals(7, _x.addAndGet(3))
|
||||
assertEquals(7, x)
|
||||
assertEquals(8, _x.incrementAndGet())
|
||||
assertEquals(8, x)
|
||||
assertEquals(7, _x.decrementAndGet())
|
||||
assertEquals(7, x)
|
||||
assertTrue(_x.compareAndSet(7, 10))
|
||||
}
|
||||
|
||||
fun test() {
|
||||
testGetValue()
|
||||
testAtomicCallPlaces()
|
||||
testInt()
|
||||
}
|
||||
}
|
||||
|
||||
class LongArithmetic {
|
||||
private val _x = atomic(4294967296)
|
||||
val x get() = _x.value
|
||||
private val y = atomic(5000000000)
|
||||
private val z = atomic(2424920024888888848)
|
||||
private val max = atomic(9223372036854775807)
|
||||
|
||||
fun testLong() {
|
||||
assertEquals(2424920024888888848, z.value)
|
||||
z.lazySet(8424920024888888848)
|
||||
assertEquals(8424920024888888848, z.value)
|
||||
assertEquals(8424920024888888848, z.getAndSet(8924920024888888848))
|
||||
assertEquals(8924920024888888848, z.value)
|
||||
assertEquals(8924920024888888849, z.incrementAndGet())
|
||||
assertEquals(8924920024888888849, z.value)
|
||||
assertEquals(8924920024888888849, z.getAndDecrement())
|
||||
assertEquals(8924920024888888848, z.value)
|
||||
assertEquals(8924920024888888848, z.getAndAdd(100000000000000000))
|
||||
assertEquals(9024920024888888848, z.value)
|
||||
assertEquals(-198452011965886959, z.addAndGet(-9223372036854775807))
|
||||
assertEquals(-198452011965886959, z.value)
|
||||
assertEquals(-198452011965886958, z.incrementAndGet())
|
||||
assertEquals(-198452011965886958, z.value)
|
||||
assertEquals(-198452011965886959, z.decrementAndGet())
|
||||
assertEquals(-198452011965886959, z.value)
|
||||
}
|
||||
}
|
||||
|
||||
class BooleanArithmetic {
|
||||
private val _x = atomic(false)
|
||||
val x get() = _x.value
|
||||
|
||||
fun testBoolean() {
|
||||
assertEquals(false, _x.value)
|
||||
assertFalse(x)
|
||||
_x.lazySet(true)
|
||||
assertTrue(x)
|
||||
assertTrue(_x.getAndSet(true))
|
||||
assertTrue(_x.compareAndSet(true, false))
|
||||
assertFalse(x)
|
||||
}
|
||||
}
|
||||
|
||||
class ReferenceArithmetic {
|
||||
private val _x = atomic<String?>(null)
|
||||
|
||||
fun testReference() {
|
||||
_x.value = "aaa"
|
||||
assertEquals("aaa", _x.value)
|
||||
_x.lazySet("bb")
|
||||
assertEquals("bb", _x.value)
|
||||
assertEquals("bb", _x.getAndSet("ccc"))
|
||||
assertEquals("ccc", _x.value)
|
||||
}
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
val intClass = IntArithmetic()
|
||||
intClass.test()
|
||||
val longClass = LongArithmetic()
|
||||
longClass.testLong()
|
||||
val booleanClass = BooleanArithmetic()
|
||||
booleanClass.testBoolean()
|
||||
val refClass = ReferenceArithmetic()
|
||||
refClass.testReference()
|
||||
return "OK"
|
||||
}
|
||||
+83
@@ -0,0 +1,83 @@
|
||||
@kotlin.Metadata
|
||||
public final class ArithmeticTestKt {
|
||||
// source: 'ArithmeticTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class BooleanArithmetic {
|
||||
// source: 'ArithmeticTest.kt'
|
||||
private synthetic final static field _x$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field _x$volatile: int
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public final method getX(): boolean
|
||||
private synthetic final static method get_x$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method get_x$volatile(): int
|
||||
private synthetic final method set_x$volatile(p0: int): void
|
||||
public final method testBoolean(): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class IntArithmetic {
|
||||
// source: 'ArithmeticTest.kt'
|
||||
private synthetic final static field _x$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field _x$volatile: int
|
||||
private synthetic final static field local$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field local$volatile: int
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
private synthetic final static method getLocal$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getLocal$volatile(): int
|
||||
public final method getX(): int
|
||||
private synthetic final static method get_x$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method get_x$volatile(): int
|
||||
private synthetic final method setLocal$volatile(p0: int): void
|
||||
private synthetic final method set_x$volatile(p0: int): void
|
||||
public final method test(): void
|
||||
private final method testAtomicCallPlaces(): void
|
||||
private final method testGetValue(): void
|
||||
private final method testInt(): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LongArithmetic {
|
||||
// source: 'ArithmeticTest.kt'
|
||||
private synthetic final static field _x$volatile$FU: java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic volatile field _x$volatile: long
|
||||
private synthetic final static field max$volatile$FU: java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic volatile field max$volatile: long
|
||||
private synthetic final static field y$volatile$FU: java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic volatile field y$volatile: long
|
||||
private synthetic final static field z$volatile$FU: java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic volatile field z$volatile: long
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
private synthetic final static method getMax$volatile$FU(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic final method getMax$volatile(): long
|
||||
public final method getX(): long
|
||||
private synthetic final static method getY$volatile$FU(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic final method getY$volatile(): long
|
||||
private synthetic final static method getZ$volatile$FU(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic final method getZ$volatile(): long
|
||||
private synthetic final static method get_x$volatile$FU(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic final method get_x$volatile(): long
|
||||
private synthetic final method setMax$volatile(p0: long): void
|
||||
private synthetic final method setY$volatile(p0: long): void
|
||||
private synthetic final method setZ$volatile(p0: long): void
|
||||
private synthetic final method set_x$volatile(p0: long): void
|
||||
public final method testLong(): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class ReferenceArithmetic {
|
||||
// source: 'ArithmeticTest.kt'
|
||||
private synthetic final static field _x$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field _x$volatile: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
private synthetic final static method get_x$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method get_x$volatile(): java.lang.Object
|
||||
private synthetic final method set_x$volatile(p0: java.lang.Object): void
|
||||
public final method testReference(): void
|
||||
}
|
||||
+3
-3
@@ -87,13 +87,13 @@ class AtomicArrayTest {
|
||||
}
|
||||
}
|
||||
|
||||
class AtomicArrayClass {
|
||||
private class AtomicArrayClass {
|
||||
val intArr = AtomicIntArray(10)
|
||||
val longArr = AtomicLongArray(10)
|
||||
val booleanArr = AtomicBooleanArray(10)
|
||||
val refArr = atomicArrayOfNulls<ARef>(10)
|
||||
val anyArr = atomicArrayOfNulls<Any?>(10)
|
||||
val a = atomic(ARef(8))
|
||||
internal val a = atomic(ARef(8))
|
||||
}
|
||||
|
||||
data class ARef(val n: Int)
|
||||
@@ -106,4 +106,4 @@ fun box(): String {
|
||||
testClass.testRefArray()
|
||||
testClass.testAnyArray()
|
||||
return "OK"
|
||||
}
|
||||
}
|
||||
+53
@@ -0,0 +1,53 @@
|
||||
@kotlin.Metadata
|
||||
public final class ARef {
|
||||
// source: 'AtomicArrayTest.kt'
|
||||
private final field n: int
|
||||
public method <init>(p0: int): void
|
||||
public final method component1(): int
|
||||
public synthetic static method copy$default(p0: ARef, p1: int, p2: int, p3: java.lang.Object): ARef
|
||||
public final @org.jetbrains.annotations.NotNull method copy(p0: int): ARef
|
||||
public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean
|
||||
public final method getN(): int
|
||||
public method hashCode(): int
|
||||
public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
final class AtomicArrayClass {
|
||||
// source: 'AtomicArrayTest.kt'
|
||||
private synthetic final static field a$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field a$volatile: java.lang.Object
|
||||
private synthetic final field anyArr: java.util.concurrent.atomic.AtomicReferenceArray
|
||||
private synthetic final field booleanArr: java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private synthetic final field intArr: java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private synthetic final field longArr: java.util.concurrent.atomic.AtomicLongArray
|
||||
private synthetic final field refArr: java.util.concurrent.atomic.AtomicReferenceArray
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public synthetic final static method access$getA$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final static method getA$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getA$volatile(): java.lang.Object
|
||||
public synthetic final method getAnyArr(): java.util.concurrent.atomic.AtomicReferenceArray
|
||||
public synthetic final method getBooleanArr(): java.util.concurrent.atomic.AtomicIntegerArray
|
||||
public synthetic final method getIntArr(): java.util.concurrent.atomic.AtomicIntegerArray
|
||||
public synthetic final method getLongArr(): java.util.concurrent.atomic.AtomicLongArray
|
||||
public synthetic final method getRefArr(): java.util.concurrent.atomic.AtomicReferenceArray
|
||||
private synthetic final method setA$volatile(p0: java.lang.Object): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class AtomicArrayTest {
|
||||
// source: 'AtomicArrayTest.kt'
|
||||
public method <init>(): void
|
||||
public final method testAnyArray(): void
|
||||
public final method testBooleanArray(): void
|
||||
public final method testIntArray(): void
|
||||
public final method testLongArray(): void
|
||||
public final method testRefArray(): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class AtomicArrayTestKt {
|
||||
// source: 'AtomicArrayTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
+2
-2
@@ -19,7 +19,7 @@ class IndexArrayElementGetterTest {
|
||||
assertEquals(100, clazz.longArr[(fib(4) + fib(5)) % fib(5)].value)
|
||||
}
|
||||
|
||||
class AtomicArrayClass {
|
||||
private class AtomicArrayClass {
|
||||
val intArr = AtomicIntArray(10)
|
||||
val longArr = AtomicLongArray(10)
|
||||
}
|
||||
@@ -29,4 +29,4 @@ fun box(): String {
|
||||
val testClass = IndexArrayElementGetterTest()
|
||||
testClass.testIndexArrayElementGetting()
|
||||
return "OK"
|
||||
}
|
||||
}
|
||||
Vendored
+26
@@ -0,0 +1,26 @@
|
||||
@kotlin.Metadata
|
||||
final class IndexArrayElementGetterTest$AtomicArrayClass {
|
||||
// source: 'IndexArrayElementGetterTest.kt'
|
||||
private synthetic final field intArr: java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private synthetic final field longArr: java.util.concurrent.atomic.AtomicLongArray
|
||||
public method <init>(): void
|
||||
public synthetic final method getIntArr(): java.util.concurrent.atomic.AtomicIntegerArray
|
||||
public synthetic final method getLongArr(): java.util.concurrent.atomic.AtomicLongArray
|
||||
private final inner class IndexArrayElementGetterTest$AtomicArrayClass
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class IndexArrayElementGetterTest {
|
||||
// source: 'IndexArrayElementGetterTest.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field clazz: IndexArrayElementGetterTest$AtomicArrayClass
|
||||
public method <init>(): void
|
||||
public final method fib(p0: int): int
|
||||
public final method testIndexArrayElementGetting(): void
|
||||
private final inner class IndexArrayElementGetterTest$AtomicArrayClass
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class IndexArrayElementGetterTestKt {
|
||||
// source: 'IndexArrayElementGetterTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
+33
@@ -0,0 +1,33 @@
|
||||
import kotlinx.atomicfu.*
|
||||
import kotlin.test.*
|
||||
|
||||
private class AAA {
|
||||
private val _counter = atomic(5L)
|
||||
val counterValue: Long get() = _counter.value
|
||||
val delegateCounterValue by _counter
|
||||
val lateInitInt: AtomicInt
|
||||
val intArr: AtomicIntArray
|
||||
|
||||
// test ensures that transformation does not change the order of initialization
|
||||
init {
|
||||
lateInitInt = atomic(10)
|
||||
assertTrue(lateInitInt.compareAndSet(10, 100))
|
||||
assertEquals(100, lateInitInt.value)
|
||||
intArr = AtomicIntArray(10)
|
||||
intArr[0].value = 10
|
||||
assertTrue(intArr[0].compareAndSet(10, 100))
|
||||
intArr[1].value = 20
|
||||
}
|
||||
|
||||
init {
|
||||
assertEquals(5L, _counter.value)
|
||||
assertEquals(5L,counterValue)
|
||||
assertEquals(5L, delegateCounterValue)
|
||||
assertEquals(120, intArr[0].value + intArr[1].value)
|
||||
}
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
val intClass = AAA()
|
||||
return "OK"
|
||||
}
|
||||
+26
@@ -0,0 +1,26 @@
|
||||
@kotlin.Metadata
|
||||
final class AAA {
|
||||
// source: 'InitializationOrderTest.kt'
|
||||
private synthetic final static field _counter$volatile$FU: java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic volatile field _counter$volatile: long
|
||||
private synthetic final field intArr: java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private synthetic final static field lateInitInt$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field lateInitInt$volatile: int
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public final method getCounterValue(): long
|
||||
public final method getDelegateCounterValue(): long
|
||||
public synthetic final method getIntArr(): java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private synthetic final static method getLateInitInt$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getLateInitInt$volatile(): int
|
||||
private synthetic final static method get_counter$volatile$FU(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic final method get_counter$volatile(): long
|
||||
private synthetic final method setLateInitInt$volatile(p0: int): void
|
||||
private synthetic final method set_counter$volatile(p0: long): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InitializationOrderTestKt {
|
||||
// source: 'InitializationOrderTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
+42
@@ -0,0 +1,42 @@
|
||||
@kotlin.Metadata
|
||||
final class LateinitPropertiesTest$Data {
|
||||
// source: 'LateinitPropertiesTest.kt'
|
||||
private final field n: int
|
||||
public method <init>(p0: int): void
|
||||
public final method getN(): int
|
||||
private final inner class LateinitPropertiesTest$Data
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LateinitPropertiesTest {
|
||||
// source: 'LateinitPropertiesTest.kt'
|
||||
private synthetic final static field a$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field a$volatile: int
|
||||
private synthetic final static field dataRef$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field dataRef$volatile: java.lang.Object
|
||||
private synthetic final static field head$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field head$volatile: java.lang.Object
|
||||
private synthetic final field lateIntArr: java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private synthetic final field lateRefArr: java.util.concurrent.atomic.AtomicReferenceArray
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
private synthetic final static method getA$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getA$volatile(): int
|
||||
private synthetic final static method getDataRef$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getDataRef$volatile(): java.lang.Object
|
||||
private synthetic final static method getHead$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getHead$volatile(): java.lang.Object
|
||||
private synthetic final method getLateIntArr(): java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private synthetic final method getLateRefArr(): java.util.concurrent.atomic.AtomicReferenceArray
|
||||
private synthetic final method setA$volatile(p0: int): void
|
||||
private synthetic final method setDataRef$volatile(p0: java.lang.Object): void
|
||||
private synthetic final method setHead$volatile(p0: java.lang.Object): void
|
||||
public final method test(): void
|
||||
private final inner class LateinitPropertiesTest$Data
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LateinitPropertiesTestKt {
|
||||
// source: 'LateinitPropertiesTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
+6
-3
@@ -10,15 +10,18 @@ final class LockFreeLongCounter$Inner {
|
||||
@kotlin.Metadata
|
||||
public final class LockFreeLongCounter {
|
||||
// source: 'LockFreeLongCounterTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field counter$FU: java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field counter: long
|
||||
private synthetic final static field counter$volatile$FU: java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic volatile field counter$volatile: long
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public synthetic final static method access$getCounter$FU$p(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
public synthetic final static method access$getCounter$volatile$FU(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
public final method add2(): long
|
||||
public final method get(): long
|
||||
private synthetic final static method getCounter$volatile$FU(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic final method getCounter$volatile(): long
|
||||
public final method getInner(): long
|
||||
public final method increment(): long
|
||||
private synthetic final method setCounter$volatile(p0: long): void
|
||||
public final method setM2(): void
|
||||
private final inner class LockFreeLongCounter$Inner
|
||||
}
|
||||
+1
-1
@@ -52,4 +52,4 @@ fun box(): String {
|
||||
val testClass = LockFreeQueueTest()
|
||||
testClass.testBasic()
|
||||
return "OK"
|
||||
}
|
||||
}
|
||||
+49
@@ -0,0 +1,49 @@
|
||||
@kotlin.Metadata
|
||||
final class LockFreeQueue$Node {
|
||||
// source: 'LockFreeQueueTest.kt'
|
||||
private synthetic final static field next$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field next$volatile: java.lang.Object
|
||||
private final field value: int
|
||||
static method <clinit>(): void
|
||||
public method <init>(p0: int): void
|
||||
public synthetic final static method access$getNext$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final static method getNext$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getNext$volatile(): java.lang.Object
|
||||
public final method getValue(): int
|
||||
private synthetic final method setNext$volatile(p0: java.lang.Object): void
|
||||
private final inner class LockFreeQueue$Node
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LockFreeQueue {
|
||||
// source: 'LockFreeQueueTest.kt'
|
||||
private synthetic final static field head$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field head$volatile: java.lang.Object
|
||||
private synthetic final static field tail$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field tail$volatile: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public final method dequeue(): int
|
||||
public final method enqueue(p0: int): void
|
||||
private synthetic final static method getHead$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getHead$volatile(): java.lang.Object
|
||||
private synthetic final static method getTail$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getTail$volatile(): java.lang.Object
|
||||
private synthetic final method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private synthetic final method setHead$volatile(p0: java.lang.Object): void
|
||||
private synthetic final method setTail$volatile(p0: java.lang.Object): void
|
||||
private final inner class LockFreeQueue$Node
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LockFreeQueueTest {
|
||||
// source: 'LockFreeQueueTest.kt'
|
||||
public method <init>(): void
|
||||
public final method testBasic(): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LockFreeQueueTestKt {
|
||||
// source: 'LockFreeQueueTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
+8
-5
@@ -12,19 +12,22 @@ final class LockFreeStack$Node {
|
||||
@kotlin.Metadata
|
||||
public final class LockFreeStack {
|
||||
// source: 'LockFreeStackTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field top$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field top: java.lang.Object
|
||||
private synthetic final static field top$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field top$volatile: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public final method clear(): void
|
||||
private final method getAndUpdate$atomicfu(p0: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): java.lang.Object
|
||||
private synthetic final method getAndUpdate$atomicfu(p0: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): java.lang.Object
|
||||
private synthetic final static method getTop$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getTop$volatile(): java.lang.Object
|
||||
public final method isEmpty(): boolean
|
||||
private final method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private synthetic final method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
public final @org.jetbrains.annotations.Nullable method popLoop(): java.lang.Object
|
||||
public final @org.jetbrains.annotations.Nullable method popUpdate(): java.lang.Object
|
||||
public final method pushLoop(p0: java.lang.Object): void
|
||||
public final method pushUpdate(p0: java.lang.Object): void
|
||||
private final method update$atomicfu(p0: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private synthetic final method setTop$volatile(p0: java.lang.Object): void
|
||||
private synthetic final method update$atomicfu(p0: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private final inner class LockFreeStack$Node
|
||||
}
|
||||
|
||||
+7
-7
@@ -2,12 +2,12 @@ import kotlinx.atomicfu.*
|
||||
import kotlin.test.*
|
||||
|
||||
class LoopTest {
|
||||
val a = atomic(0)
|
||||
val a1 = atomic(1)
|
||||
val b = atomic(true)
|
||||
val l = atomic(5000000000)
|
||||
val r = atomic<A>(A("aaaa"))
|
||||
val rs = atomic<String>("bbbb")
|
||||
private val a = atomic(0)
|
||||
private val a1 = atomic(1)
|
||||
private val b = atomic(true)
|
||||
private val l = atomic(5000000000)
|
||||
private val r = atomic<A>(A("aaaa"))
|
||||
private val rs = atomic<String>("bbbb")
|
||||
|
||||
class A(val s: String)
|
||||
|
||||
@@ -49,7 +49,7 @@ class LoopTest {
|
||||
}
|
||||
}
|
||||
|
||||
inline fun atomicfuLoopTest() {
|
||||
fun atomicfuLoopTest() {
|
||||
atomicfuIntLoopTest()
|
||||
assertEquals(777, a.value)
|
||||
atomicfuBooleanLoopTest()
|
||||
@@ -0,0 +1,72 @@
|
||||
@kotlin.Metadata
|
||||
public final class LoopTest$A {
|
||||
// source: 'LoopTest.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field s: java.lang.String
|
||||
public method <init>(@org.jetbrains.annotations.NotNull p0: java.lang.String): void
|
||||
public final @org.jetbrains.annotations.NotNull method getS(): java.lang.String
|
||||
public final inner class LoopTest$A
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LoopTest {
|
||||
// source: 'LoopTest.kt'
|
||||
private synthetic final static field a$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field a$volatile: int
|
||||
private synthetic final static field a1$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field a1$volatile: int
|
||||
private synthetic final static field b$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field b$volatile: int
|
||||
private synthetic final static field l$volatile$FU: java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic volatile field l$volatile: long
|
||||
private synthetic final static field r$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field r$volatile: java.lang.Object
|
||||
private synthetic final static field rs$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field rs$volatile: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public final method atomicfuBooleanLoopTest(): void
|
||||
public final method atomicfuGetAndUpdateTest(): void
|
||||
public final method atomicfuIntLoopTest(): void
|
||||
public final method atomicfuLongLoopTest(): void
|
||||
public final method atomicfuLoopTest(): void
|
||||
public final method atomicfuRefLoopTest(): void
|
||||
public final method atomicfuUpdateAndGetTest(): void
|
||||
public final method atomicfuUpdateTest(): void
|
||||
private synthetic final static method getA$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getA$volatile(): int
|
||||
private synthetic final static method getA1$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getA1$volatile(): int
|
||||
private synthetic final method getAndUpdate$atomicfu(p0: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): int
|
||||
private synthetic final method getAndUpdate$atomicfu(p0: java.util.concurrent.atomic.AtomicLongFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): long
|
||||
private synthetic final method getAndUpdate$atomicfu(p0: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): java.lang.Object
|
||||
private synthetic final static method getB$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getB$volatile(): int
|
||||
private synthetic final static method getL$volatile$FU(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic final method getL$volatile(): long
|
||||
private synthetic final static method getR$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getR$volatile(): java.lang.Object
|
||||
private synthetic final static method getRs$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getRs$volatile(): java.lang.Object
|
||||
private synthetic final method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private synthetic final method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicLongFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private synthetic final method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private synthetic final method setA$volatile(p0: int): void
|
||||
private synthetic final method setA1$volatile(p0: int): void
|
||||
private synthetic final method setB$volatile(p0: int): void
|
||||
private synthetic final method setL$volatile(p0: long): void
|
||||
private synthetic final method setR$volatile(p0: java.lang.Object): void
|
||||
private synthetic final method setRs$volatile(p0: java.lang.Object): void
|
||||
private synthetic final method update$atomicfu(p0: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private synthetic final method update$atomicfu(p0: java.util.concurrent.atomic.AtomicLongFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private synthetic final method update$atomicfu(p0: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private synthetic final method updateAndGet$atomicfu(p0: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): int
|
||||
private synthetic final method updateAndGet$atomicfu(p0: java.util.concurrent.atomic.AtomicLongFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): long
|
||||
private synthetic final method updateAndGet$atomicfu(p0: java.util.concurrent.atomic.AtomicReferenceFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): java.lang.Object
|
||||
public final inner class LoopTest$A
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class LoopTestKt {
|
||||
// source: 'LoopTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
+10
-4
@@ -11,14 +11,20 @@ public final class MultiInit$Companion {
|
||||
public final class MultiInit {
|
||||
// source: 'MultiInitTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull field Companion: MultiInit$Companion
|
||||
private final static @org.jetbrains.annotations.NotNull field a$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field a: int
|
||||
private final static @org.jetbrains.annotations.NotNull field b$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field b: int
|
||||
private synthetic final static field a$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field a$volatile: int
|
||||
private synthetic final static field b$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field b$volatile: int
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
private synthetic final static method getA$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getA$volatile(): int
|
||||
private synthetic final static method getB$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getB$volatile(): int
|
||||
public final method incA(): int
|
||||
public final method incB(): int
|
||||
private synthetic final method setA$volatile(p0: int): void
|
||||
private synthetic final method setB$volatile(p0: int): void
|
||||
public final inner class MultiInit$Companion
|
||||
}
|
||||
|
||||
+2
-2
@@ -23,7 +23,7 @@ class D (val e: E)
|
||||
class E (val x: Int)
|
||||
|
||||
|
||||
class AtomicState(value: Any) {
|
||||
private class AtomicState(value: Any) {
|
||||
val state = atomic<Any?>(value)
|
||||
}
|
||||
|
||||
@@ -42,4 +42,4 @@ fun box(): String {
|
||||
val testClass = ScopeTest()
|
||||
testClass.scopeTest()
|
||||
return "OK"
|
||||
}
|
||||
}
|
||||
+7
-5
@@ -13,14 +13,16 @@ public final class AA {
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class AtomicState {
|
||||
final class AtomicState {
|
||||
// source: 'ScopeTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field state$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field state: java.lang.Object
|
||||
private synthetic final static field state$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field state$volatile: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
public method <init>(@org.jetbrains.annotations.NotNull p0: java.lang.Object): void
|
||||
public final static @org.jetbrains.annotations.NotNull method getState$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
public final @org.jetbrains.annotations.Nullable method getState(): java.lang.Object
|
||||
public synthetic final static method access$getState$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final static method getState$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getState$volatile(): java.lang.Object
|
||||
private synthetic final method setState$volatile(p0: java.lang.Object): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
+6
-3
@@ -1,11 +1,14 @@
|
||||
@kotlin.Metadata
|
||||
public final class SimpleLock {
|
||||
// source: 'SimpleLockTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field _locked$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field _locked: int
|
||||
private synthetic final static field _locked$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field _locked$volatile: int
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
private final method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private synthetic final static method get_locked$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method get_locked$volatile(): int
|
||||
private synthetic final method loop$atomicfu(p0: java.util.concurrent.atomic.AtomicIntegerFieldUpdater, p1: kotlin.jvm.functions.Function1, p2: java.lang.Object): void
|
||||
private synthetic final method set_locked$volatile(p0: int): void
|
||||
public final method withLock(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function0): java.lang.Object
|
||||
}
|
||||
|
||||
+65
@@ -0,0 +1,65 @@
|
||||
@kotlin.Metadata
|
||||
final class UncheckedCastTest$Box {
|
||||
// source: 'UncheckedCastTest.kt'
|
||||
private final field b: int
|
||||
public method <init>(p0: int): void
|
||||
public final method component1(): int
|
||||
public synthetic static method copy$default(p0: UncheckedCastTest$Box, p1: int, p2: int, p3: java.lang.Object): UncheckedCastTest$Box
|
||||
public final @org.jetbrains.annotations.NotNull method copy(p0: int): UncheckedCastTest$Box
|
||||
public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean
|
||||
public final method getB(): int
|
||||
public method hashCode(): int
|
||||
public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
|
||||
private final inner class UncheckedCastTest$Box
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
synthetic final class UncheckedCastTest$VolatileWrapper$atomicfu$private {
|
||||
// source: 'UncheckedCastTest.kt'
|
||||
private synthetic final static field topLevelS$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field topLevelS$volatile: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
private method <init>(): void
|
||||
public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
|
||||
public synthetic final static method access$getTopLevelS$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final static method getTopLevelS$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getTopLevelS$volatile(): java.lang.Object
|
||||
private synthetic final method setTopLevelS$volatile(p0: java.lang.Object): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class UncheckedCastTest {
|
||||
// source: 'UncheckedCastTest.kt'
|
||||
private synthetic final field a: java.util.concurrent.atomic.AtomicReferenceArray
|
||||
private synthetic final static field bs$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field bs$volatile: java.lang.Object
|
||||
private synthetic final static field s$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field s$volatile: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
private synthetic final method getA(): java.util.concurrent.atomic.AtomicReferenceArray
|
||||
private synthetic final static method getBs$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getBs$volatile(): java.lang.Object
|
||||
private synthetic final static method getS$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getS$volatile(): java.lang.Object
|
||||
private synthetic final method getString$atomicfu$array(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceArray, p2: int): java.lang.String
|
||||
private synthetic final method getString$atomicfu(p0: java.lang.Object, p1: java.util.concurrent.atomic.AtomicReferenceFieldUpdater): java.lang.String
|
||||
private synthetic final method setBs$volatile(p0: java.lang.Object): void
|
||||
private synthetic final method setS$volatile(p0: java.lang.Object): void
|
||||
public final method testArrayValueUncheckedCast(): void
|
||||
public final method testArrayValueUncheckedCastInlineFunc(): void
|
||||
public final method testAtomicValUncheckedCast(): void
|
||||
public final method testInlineFunc(): void
|
||||
public final method testTopLevelValUnchekedCast(): void
|
||||
private final inner class UncheckedCastTest$Box
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class UncheckedCastTestKt {
|
||||
// source: 'UncheckedCastTest.kt'
|
||||
private synthetic final static field uncheckedCastTest$VolatileWrapper$atomicfu$private: UncheckedCastTest$VolatileWrapper$atomicfu$private
|
||||
static method <clinit>(): void
|
||||
public synthetic final static method access$getUncheckedCastTest$VolatileWrapper$atomicfu$private(): UncheckedCastTest$VolatileWrapper$atomicfu$private
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
private synthetic final static method getUncheckedCastTest$VolatileWrapper$atomicfu$private(): UncheckedCastTest$VolatileWrapper$atomicfu$private
|
||||
}
|
||||
+1
-12
@@ -104,22 +104,12 @@ class DelegatedProperties {
|
||||
assertEquals(99, vRef.b.n)
|
||||
}
|
||||
|
||||
inner class D {
|
||||
var c by atomic("aaa")
|
||||
}
|
||||
|
||||
fun testScopedVolatileProperties() {
|
||||
val clazz = D()
|
||||
assertEquals("aaa", clazz.c)
|
||||
clazz.c = "bbb"
|
||||
assertEquals("bbb", clazz.c)
|
||||
}
|
||||
|
||||
fun testDelegatedVariablesFlow() {
|
||||
_a.lazySet(55)
|
||||
assertEquals(55, _a.value)
|
||||
assertEquals(55, a)
|
||||
var aValue = a
|
||||
assertEquals(55, aValue)
|
||||
}
|
||||
|
||||
fun test() {
|
||||
@@ -131,7 +121,6 @@ class DelegatedProperties {
|
||||
testVolatileBoolean()
|
||||
testVolatileLong()
|
||||
testVolatileRef()
|
||||
testScopedVolatileProperties()
|
||||
testDelegatedVariablesFlow()
|
||||
}
|
||||
}
|
||||
+43
-40
@@ -17,32 +17,21 @@ public final class DelegatedProperties$B {
|
||||
public final inner class DelegatedProperties$B
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class DelegatedProperties$D {
|
||||
// source: 'DelegatedPropertiesTest.kt'
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field c: java.lang.Object
|
||||
synthetic final field this$0: DelegatedProperties
|
||||
public method <init>(p0: DelegatedProperties): void
|
||||
public final @org.jetbrains.annotations.NotNull method getC(): java.lang.String
|
||||
public final method setC(@org.jetbrains.annotations.NotNull p0: java.lang.String): void
|
||||
public final inner class DelegatedProperties$D
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class DelegatedProperties {
|
||||
// source: 'DelegatedPropertiesTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field _a$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field _a: int
|
||||
private final static @org.jetbrains.annotations.NotNull field _b$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field _b: int
|
||||
private final static @org.jetbrains.annotations.NotNull field _l$FU: java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field _l: long
|
||||
private final static @org.jetbrains.annotations.NotNull field _ref$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field _ref: java.lang.Object
|
||||
private volatile @kotlin.jvm.Volatile field vBoolean: int
|
||||
private volatile @kotlin.jvm.Volatile field vInt: int
|
||||
private volatile @kotlin.jvm.Volatile field vLong: int
|
||||
private volatile @kotlin.jvm.Volatile @org.jetbrains.annotations.Nullable field vRef: java.lang.Object
|
||||
private synthetic final static field _a$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field _a$volatile: int
|
||||
private synthetic final static field _b$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field _b$volatile: int
|
||||
private synthetic final static field _l$volatile$FU: java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic volatile field _l$volatile: long
|
||||
private synthetic final static field _ref$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field _ref$volatile: java.lang.Object
|
||||
private synthetic volatile field vBoolean$volatile: boolean
|
||||
private synthetic volatile field vInt$volatile: int
|
||||
private synthetic volatile field vLong$volatile: int
|
||||
private synthetic volatile field vRef$volatile: java.lang.Object
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
public final method getA(): int
|
||||
@@ -54,6 +43,14 @@ public final class DelegatedProperties {
|
||||
private final method getVInt(): int
|
||||
private final method getVLong(): int
|
||||
private final method getVRef(): DelegatedProperties$A
|
||||
private synthetic final static method get_a$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method get_a$volatile(): int
|
||||
private synthetic final static method get_b$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method get_b$volatile(): int
|
||||
private synthetic final static method get_l$volatile$FU(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic final method get_l$volatile(): long
|
||||
private synthetic final static method get_ref$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method get_ref$volatile(): java.lang.Object
|
||||
public final method setA(p0: int): void
|
||||
private final method setB(p0: boolean): void
|
||||
private final method setL(p0: long): void
|
||||
@@ -63,29 +60,48 @@ public final class DelegatedProperties {
|
||||
private final method setVInt(p0: int): void
|
||||
private final method setVLong(p0: int): void
|
||||
private final method setVRef(p0: DelegatedProperties$A): void
|
||||
private synthetic final method set_a$volatile(p0: int): void
|
||||
private synthetic final method set_b$volatile(p0: int): void
|
||||
private synthetic final method set_l$volatile(p0: long): void
|
||||
private synthetic final method set_ref$volatile(p0: java.lang.Object): void
|
||||
public final method test(): void
|
||||
public final method testDelegatedAtomicBoolean(): void
|
||||
public final method testDelegatedAtomicInt(): void
|
||||
public final method testDelegatedAtomicLong(): void
|
||||
public final method testDelegatedAtomicRef(): void
|
||||
public final method testDelegatedVariablesFlow(): void
|
||||
public final method testScopedVolatileProperties(): void
|
||||
public final method testVolatileBoolean(): void
|
||||
public final method testVolatileInt(): void
|
||||
public final method testVolatileLong(): void
|
||||
public final method testVolatileRef(): void
|
||||
public final inner class DelegatedProperties$A
|
||||
public final inner class DelegatedProperties$B
|
||||
public final inner class DelegatedProperties$D
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
synthetic final class DelegatedPropertiesTest$VolatileWrapper$atomicfu$private {
|
||||
// source: 'DelegatedPropertiesTest.kt'
|
||||
private synthetic final static field _topLevelInt$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field _topLevelInt$volatile: int
|
||||
static method <clinit>(): void
|
||||
private method <init>(): void
|
||||
public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
|
||||
public synthetic final static method access$get_topLevelInt$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public synthetic final static method access$get_topLevelInt$volatile$p(p0: DelegatedPropertiesTest$VolatileWrapper$atomicfu$private): int
|
||||
public synthetic final static method access$set_topLevelInt$volatile$p(p0: DelegatedPropertiesTest$VolatileWrapper$atomicfu$private, p1: int): void
|
||||
private synthetic final static method get_topLevelInt$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method get_topLevelInt$volatile(): int
|
||||
private synthetic final method set_topLevelInt$volatile(p0: int): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class DelegatedPropertiesTestKt {
|
||||
// source: 'DelegatedPropertiesTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field _topLevelInt$DelegatedPropertiesTest$VolatileWrapper: _topLevelInt$DelegatedPropertiesTest$VolatileWrapper
|
||||
private volatile static @kotlin.jvm.Volatile field topLevelVolatile: int
|
||||
private synthetic final static field delegatedPropertiesTest$VolatileWrapper$atomicfu$private: DelegatedPropertiesTest$VolatileWrapper$atomicfu$private
|
||||
private synthetic volatile static field topLevelVolatile$volatile: int
|
||||
static method <clinit>(): void
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
private synthetic final static method getDelegatedPropertiesTest$VolatileWrapper$atomicfu$private(): DelegatedPropertiesTest$VolatileWrapper$atomicfu$private
|
||||
public final static method getTopLevelInt(): int
|
||||
private final static method getTopLevelVolatile(): int
|
||||
public final static method setTopLevelInt(p0: int): void
|
||||
@@ -93,16 +109,3 @@ public final class DelegatedPropertiesTestKt {
|
||||
public final static method testTopLevelDelegatedProperties(): void
|
||||
public final static method testTopLevelVolatileProperties(): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
final class _topLevelInt$DelegatedPropertiesTest$VolatileWrapper {
|
||||
// source: 'DelegatedPropertiesTest.kt'
|
||||
private final static @org.jetbrains.annotations.NotNull field _topLevelInt$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private volatile @kotlin.jvm.Volatile field _topLevelInt: int
|
||||
static method <clinit>(): void
|
||||
private method <init>(): void
|
||||
public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
|
||||
public synthetic final static method access$get_topLevelInt$FU$p(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public synthetic final static method access$get_topLevelInt$p(p0: _topLevelInt$DelegatedPropertiesTest$VolatileWrapper): int
|
||||
public synthetic final static method access$set_topLevelInt$p(p0: _topLevelInt$DelegatedPropertiesTest$VolatileWrapper, p1: int): void
|
||||
}
|
||||
+3
-3
@@ -2,7 +2,7 @@ import kotlinx.atomicfu.*
|
||||
import kotlin.test.*
|
||||
import kotlin.random.*
|
||||
|
||||
object Provider {
|
||||
private object Provider {
|
||||
private val port = atomic(Random.nextInt(20, 90) * 100)
|
||||
fun next(): Int = port.incrementAndGet()
|
||||
|
||||
@@ -18,8 +18,8 @@ object Provider {
|
||||
val refArr = atomicArrayOfNulls<Any?>(5)
|
||||
}
|
||||
|
||||
object DelegatedProvider {
|
||||
val _a = atomic(42)
|
||||
private object DelegatedProvider {
|
||||
internal val _a = atomic(42)
|
||||
var a: Int by _a
|
||||
|
||||
var vInt by atomic(77)
|
||||
+97
@@ -0,0 +1,97 @@
|
||||
@kotlin.Metadata
|
||||
synthetic final class DelegatedProvider$DelegatedProvider$VolatileWrapper$atomicfu$private {
|
||||
// source: 'FieldInObjectTest.kt'
|
||||
private synthetic final static field _a$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field _a$volatile: int
|
||||
static method <clinit>(): void
|
||||
private method <init>(): void
|
||||
public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
|
||||
public synthetic final static method access$get_a$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public synthetic final static method access$get_a$volatile$p(p0: DelegatedProvider$DelegatedProvider$VolatileWrapper$atomicfu$private): int
|
||||
public synthetic final static method access$set_a$volatile$p(p0: DelegatedProvider$DelegatedProvider$VolatileWrapper$atomicfu$private, p1: int): void
|
||||
private synthetic final static method get_a$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method get_a$volatile(): int
|
||||
private synthetic final method set_a$volatile(p0: int): void
|
||||
private synthetic inner class DelegatedProvider$DelegatedProvider$VolatileWrapper$atomicfu$private
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
final class DelegatedProvider {
|
||||
// source: 'FieldInObjectTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull field INSTANCE: DelegatedProvider
|
||||
private synthetic final static field delegatedProvider$VolatileWrapper$atomicfu$private: DelegatedProvider$DelegatedProvider$VolatileWrapper$atomicfu$private
|
||||
private synthetic volatile field vInt$volatile: int
|
||||
static method <clinit>(): void
|
||||
private method <init>(): void
|
||||
public synthetic final static method access$getDelegatedProvider$VolatileWrapper$atomicfu$private(): DelegatedProvider$DelegatedProvider$VolatileWrapper$atomicfu$private
|
||||
public final method getA(): int
|
||||
private synthetic final static method getDelegatedProvider$VolatileWrapper$atomicfu$private(): DelegatedProvider$DelegatedProvider$VolatileWrapper$atomicfu$private
|
||||
public final method getVInt(): int
|
||||
public final method setA(p0: int): void
|
||||
public final method setVInt(p0: int): void
|
||||
private synthetic inner class DelegatedProvider$DelegatedProvider$VolatileWrapper$atomicfu$private
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class FieldInObjectTestKt {
|
||||
// source: 'FieldInObjectTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
private final static method testDelegatedPropertiesInObject(): void
|
||||
private final static method testFieldInObject(): void
|
||||
private synthetic inner class DelegatedProvider$DelegatedProvider$VolatileWrapper$atomicfu$private
|
||||
private synthetic inner class Provider$Provider$VolatileWrapper$atomicfu$private
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
synthetic final class Provider$Provider$VolatileWrapper$atomicfu$private {
|
||||
// source: 'FieldInObjectTest.kt'
|
||||
private synthetic final static field _l$volatile$FU: java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic volatile field _l$volatile: long
|
||||
private synthetic final static field _ref$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field _ref$volatile: java.lang.Object
|
||||
private synthetic final static field _x$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field _x$volatile: int
|
||||
private synthetic final static field port$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field port$volatile: int
|
||||
static method <clinit>(): void
|
||||
private method <init>(): void
|
||||
public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
|
||||
public synthetic final static method access$getPort$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public synthetic final static method access$get_l$volatile$FU(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
public synthetic final static method access$get_ref$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
public synthetic final static method access$get_x$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final static method getPort$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getPort$volatile(): int
|
||||
private synthetic final static method get_l$volatile$FU(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic final method get_l$volatile(): long
|
||||
private synthetic final static method get_ref$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method get_ref$volatile(): java.lang.Object
|
||||
private synthetic final static method get_x$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method get_x$volatile(): int
|
||||
private synthetic final method setPort$volatile(p0: int): void
|
||||
private synthetic final method set_l$volatile(p0: long): void
|
||||
private synthetic final method set_ref$volatile(p0: java.lang.Object): void
|
||||
private synthetic final method set_x$volatile(p0: int): void
|
||||
private synthetic inner class Provider$Provider$VolatileWrapper$atomicfu$private
|
||||
public final inner class kotlin/random/Random$Default
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
final class Provider {
|
||||
// source: 'FieldInObjectTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull field INSTANCE: Provider
|
||||
private synthetic final static field intArr: java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private synthetic final static field longArr: java.util.concurrent.atomic.AtomicLongArray
|
||||
private synthetic final static field provider$VolatileWrapper$atomicfu$private: Provider$Provider$VolatileWrapper$atomicfu$private
|
||||
private synthetic final static field refArr: java.util.concurrent.atomic.AtomicReferenceArray
|
||||
static method <clinit>(): void
|
||||
private method <init>(): void
|
||||
public synthetic final static method access$getProvider$VolatileWrapper$atomicfu$private(): Provider$Provider$VolatileWrapper$atomicfu$private
|
||||
public synthetic final method getIntArr(): java.util.concurrent.atomic.AtomicIntegerArray
|
||||
public final method getL(): long
|
||||
public synthetic final method getLongArr(): java.util.concurrent.atomic.AtomicLongArray
|
||||
private synthetic final static method getProvider$VolatileWrapper$atomicfu$private(): Provider$Provider$VolatileWrapper$atomicfu$private
|
||||
public synthetic final method getRefArr(): java.util.concurrent.atomic.AtomicReferenceArray
|
||||
public final method next(): int
|
||||
private synthetic inner class Provider$Provider$VolatileWrapper$atomicfu$private
|
||||
}
|
||||
+6
@@ -7,6 +7,12 @@ private val c = atomic(true)
|
||||
private val abcNode = atomic(ANode(BNode(CNode(8))))
|
||||
private val any = atomic<Any?>(null)
|
||||
|
||||
internal val a_internal = atomic(0)
|
||||
internal val b_internal = atomic(2424920024888888848)
|
||||
internal val c_internal = atomic(true)
|
||||
internal val abcNode_internal = atomic(ANode(BNode(CNode(8))))
|
||||
internal val any_internal = atomic<Any?>(null)
|
||||
|
||||
private val intArr = AtomicIntArray(3)
|
||||
private val longArr = AtomicLongArray(5)
|
||||
private val booleanArr = AtomicBooleanArray(4)
|
||||
@@ -0,0 +1,162 @@
|
||||
@kotlin.Metadata
|
||||
public final class ANode {
|
||||
// source: 'TopLevelTest.kt'
|
||||
private final field b: java.lang.Object
|
||||
public method <init>(p0: java.lang.Object): void
|
||||
public final method component1(): java.lang.Object
|
||||
public synthetic static method copy$default(p0: ANode, p1: java.lang.Object, p2: int, p3: java.lang.Object): ANode
|
||||
public final @org.jetbrains.annotations.NotNull method copy(p0: java.lang.Object): ANode
|
||||
public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean
|
||||
public final method getB(): java.lang.Object
|
||||
public method hashCode(): int
|
||||
public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class BNode {
|
||||
// source: 'TopLevelTest.kt'
|
||||
private final field c: java.lang.Object
|
||||
public method <init>(p0: java.lang.Object): void
|
||||
public final method component1(): java.lang.Object
|
||||
public synthetic static method copy$default(p0: BNode, p1: java.lang.Object, p2: int, p3: java.lang.Object): BNode
|
||||
public final @org.jetbrains.annotations.NotNull method copy(p0: java.lang.Object): BNode
|
||||
public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean
|
||||
public final method getC(): java.lang.Object
|
||||
public method hashCode(): int
|
||||
public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class CNode {
|
||||
// source: 'TopLevelTest.kt'
|
||||
private final field d: int
|
||||
public method <init>(p0: int): void
|
||||
public final method component1(): int
|
||||
public synthetic static method copy$default(p0: CNode, p1: int, p2: int, p3: java.lang.Object): CNode
|
||||
public final @org.jetbrains.annotations.NotNull method copy(p0: int): CNode
|
||||
public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean
|
||||
public final method getD(): int
|
||||
public method hashCode(): int
|
||||
public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class TopLevelArrayTest {
|
||||
// source: 'TopLevelTest.kt'
|
||||
public method <init>(): void
|
||||
public final method testBooleanArray(): void
|
||||
public final method testIntArray(): void
|
||||
public final method testLongArray(): void
|
||||
public final method testRefArray(): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class TopLevelPrimitiveTest {
|
||||
// source: 'TopLevelTest.kt'
|
||||
public method <init>(): void
|
||||
public final method testTopLevelArrayOfNulls(): void
|
||||
public final method testTopLevelBoolean(): void
|
||||
public final method testTopLevelInt(): void
|
||||
public final method testTopLevelLong(): void
|
||||
public final method testTopLevelRef(): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public synthetic final class TopLevelTest$VolatileWrapper$atomicfu$internal {
|
||||
// source: 'TopLevelTest.kt'
|
||||
private synthetic final static field a_internal$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field a_internal$volatile: int
|
||||
private synthetic final static field abcNode_internal$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field abcNode_internal$volatile: java.lang.Object
|
||||
private synthetic final static field any_internal$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field any_internal$volatile: java.lang.Object
|
||||
private synthetic final static field b_internal$volatile$FU: java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic volatile field b_internal$volatile: long
|
||||
private synthetic final static field c_internal$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field c_internal$volatile: int
|
||||
static method <clinit>(): void
|
||||
private method <init>(): void
|
||||
public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
|
||||
public synthetic final static method getA_internal$volatile$FU$main(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getA_internal$volatile(): int
|
||||
public synthetic final static method getAbcNode_internal$volatile$FU$main(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getAbcNode_internal$volatile(): java.lang.Object
|
||||
public synthetic final static method getAny_internal$volatile$FU$main(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getAny_internal$volatile(): java.lang.Object
|
||||
public synthetic final static method getB_internal$volatile$FU$main(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic final method getB_internal$volatile(): long
|
||||
public synthetic final static method getC_internal$volatile$FU$main(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getC_internal$volatile(): int
|
||||
private synthetic final method setA_internal$volatile(p0: int): void
|
||||
private synthetic final method setAbcNode_internal$volatile(p0: java.lang.Object): void
|
||||
private synthetic final method setAny_internal$volatile(p0: java.lang.Object): void
|
||||
private synthetic final method setB_internal$volatile(p0: long): void
|
||||
private synthetic final method setC_internal$volatile(p0: int): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
synthetic final class TopLevelTest$VolatileWrapper$atomicfu$private {
|
||||
// source: 'TopLevelTest.kt'
|
||||
private synthetic final static field a$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field a$volatile: int
|
||||
private synthetic final static field abcNode$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field abcNode$volatile: java.lang.Object
|
||||
private synthetic final static field any$volatile$FU: java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic volatile field any$volatile: java.lang.Object
|
||||
private synthetic final static field b$volatile$FU: java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic volatile field b$volatile: long
|
||||
private synthetic final static field c$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field c$volatile: int
|
||||
static method <clinit>(): void
|
||||
private method <init>(): void
|
||||
public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
|
||||
public synthetic final static method access$getA$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
public synthetic final static method access$getAbcNode$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
public synthetic final static method access$getAny$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
public synthetic final static method access$getB$volatile$FU(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
public synthetic final static method access$getC$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final static method getA$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getA$volatile(): int
|
||||
private synthetic final static method getAbcNode$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getAbcNode$volatile(): java.lang.Object
|
||||
private synthetic final static method getAny$volatile$FU(): java.util.concurrent.atomic.AtomicReferenceFieldUpdater
|
||||
private synthetic final method getAny$volatile(): java.lang.Object
|
||||
private synthetic final static method getB$volatile$FU(): java.util.concurrent.atomic.AtomicLongFieldUpdater
|
||||
private synthetic final method getB$volatile(): long
|
||||
private synthetic final static method getC$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getC$volatile(): int
|
||||
private synthetic final method setA$volatile(p0: int): void
|
||||
private synthetic final method setAbcNode$volatile(p0: java.lang.Object): void
|
||||
private synthetic final method setAny$volatile(p0: java.lang.Object): void
|
||||
private synthetic final method setB$volatile(p0: long): void
|
||||
private synthetic final method setC$volatile(p0: int): void
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class TopLevelTestKt {
|
||||
// source: 'TopLevelTest.kt'
|
||||
private synthetic final static field anyRefArr: java.util.concurrent.atomic.AtomicReferenceArray
|
||||
private synthetic final static field booleanArr: java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private synthetic final static field intArr: java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private synthetic final static field longArr: java.util.concurrent.atomic.AtomicLongArray
|
||||
private synthetic final static field refArr: java.util.concurrent.atomic.AtomicReferenceArray
|
||||
private synthetic final static field stringAtomicNullArr: java.util.concurrent.atomic.AtomicReferenceArray
|
||||
private synthetic final static field topLevelTest$VolatileWrapper$atomicfu$internal: TopLevelTest$VolatileWrapper$atomicfu$internal
|
||||
private synthetic final static field topLevelTest$VolatileWrapper$atomicfu$private: TopLevelTest$VolatileWrapper$atomicfu$private
|
||||
static method <clinit>(): void
|
||||
public synthetic final static method access$getBooleanArr(): java.util.concurrent.atomic.AtomicIntegerArray
|
||||
public synthetic final static method access$getIntArr(): java.util.concurrent.atomic.AtomicIntegerArray
|
||||
public synthetic final static method access$getLongArr(): java.util.concurrent.atomic.AtomicLongArray
|
||||
public synthetic final static method access$getRefArr(): java.util.concurrent.atomic.AtomicReferenceArray
|
||||
public synthetic final static method access$getStringAtomicNullArr(): java.util.concurrent.atomic.AtomicReferenceArray
|
||||
public synthetic final static method access$getTopLevelTest$VolatileWrapper$atomicfu$private(): TopLevelTest$VolatileWrapper$atomicfu$private
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
private synthetic final static method getAnyRefArr(): java.util.concurrent.atomic.AtomicReferenceArray
|
||||
private synthetic final static method getBooleanArr(): java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private synthetic final static method getIntArr(): java.util.concurrent.atomic.AtomicIntegerArray
|
||||
private synthetic final static method getLongArr(): java.util.concurrent.atomic.AtomicLongArray
|
||||
private synthetic final static method getRefArr(): java.util.concurrent.atomic.AtomicReferenceArray
|
||||
private synthetic final static method getStringAtomicNullArr(): java.util.concurrent.atomic.AtomicReferenceArray
|
||||
public synthetic final static method getTopLevelTest$VolatileWrapper$atomicfu$internal(): TopLevelTest$VolatileWrapper$atomicfu$internal
|
||||
private synthetic final static method getTopLevelTest$VolatileWrapper$atomicfu$private(): TopLevelTest$VolatileWrapper$atomicfu$private
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
@kotlin.Metadata
|
||||
final enum class TraceTest$Status {
|
||||
// source: 'TraceTest.kt'
|
||||
private synthetic final static field $ENTRIES: kotlin.enums.EnumEntries
|
||||
private synthetic final static field $VALUES: TraceTest$Status[]
|
||||
public final enum static field END: TraceTest$Status
|
||||
public final enum static field START: TraceTest$Status
|
||||
private synthetic final static method $values(): TraceTest$Status[]
|
||||
static method <clinit>(): void
|
||||
private method <init>(p0: java.lang.String, p1: int): void
|
||||
public static @org.jetbrains.annotations.NotNull method getEntries(): kotlin.enums.EnumEntries
|
||||
public static method valueOf(p0: java.lang.String): TraceTest$Status
|
||||
public static method values(): TraceTest$Status[]
|
||||
private final inner class TraceTest$Status
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class TraceTest {
|
||||
// source: 'TraceTest.kt'
|
||||
private synthetic final static field a$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field a$volatile: int
|
||||
private synthetic final static field a1$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field a1$volatile: int
|
||||
private synthetic final static field a2$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field a2$volatile: int
|
||||
private synthetic final static field a3$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field a3$volatile: int
|
||||
private synthetic final static field s$volatile$FU: java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic volatile field s$volatile: int
|
||||
static method <clinit>(): void
|
||||
public method <init>(): void
|
||||
private synthetic final static method getA$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getA$volatile(): int
|
||||
private synthetic final static method getA1$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getA1$volatile(): int
|
||||
private synthetic final static method getA2$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getA2$volatile(): int
|
||||
private synthetic final static method getA3$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getA3$volatile(): int
|
||||
private synthetic final static method getS$volatile$FU(): java.util.concurrent.atomic.AtomicIntegerFieldUpdater
|
||||
private synthetic final method getS$volatile(): int
|
||||
private synthetic final method setA$volatile(p0: int): void
|
||||
private synthetic final method setA1$volatile(p0: int): void
|
||||
private synthetic final method setA2$volatile(p0: int): void
|
||||
private synthetic final method setA3$volatile(p0: int): void
|
||||
private synthetic final method setS$volatile(p0: int): void
|
||||
public final method test(): void
|
||||
public final method testDefaultTrace(): void
|
||||
public final method testMultipleAppend(): void
|
||||
public final method testNamedTrace(): void
|
||||
public final method testTraceInBlock(): void
|
||||
public final method testTraceWithFormat(): void
|
||||
public final method testTraceWithSize(): void
|
||||
private final inner class TraceTest$Status
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class TraceTestKt {
|
||||
// source: 'TraceTest.kt'
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
}
|
||||
Reference in New Issue
Block a user