Fix lint + Kotlin compiler warnings

Author: markushi

sentry-compose/src/androidMain/kotlin/io/sentry/compose/SentryComposeHelper.kt

@@ -12,7 +12,7 @@ import io.sentry.ILogger
 import io.sentry.SentryLevel
 import java.lang.reflect.Field
 
-internal class SentryComposeHelper(private val logger: ILogger) {
+internal class SentryComposeHelper(logger: ILogger) {
 
     private val testTagElementField: Field? =
         loadField(logger, "androidx.compose.ui.platform.TestTagElement", "tag")
@@ -131,7 +131,7 @@ public fun LayoutCoordinates.boundsInWindow(rootCoordinates: LayoutCoordinates?)
  * `kotlin.comparisons.minOf()` for 4 arguments as it avoids allocating an array because of the
  * varargs.
  */
-private inline fun fastMinOf(a: Float, b: Float, c: Float, d: Float): Float {
+private fun fastMinOf(a: Float, b: Float, c: Float, d: Float): Float {
     return minOf(a, minOf(b, minOf(c, d)))
 }
 
@@ -140,7 +140,7 @@ private inline fun fastMinOf(a: Float, b: Float, c: Float, d: Float): Float {
  * `kotlin.comparisons.maxOf()` for 4 arguments as it avoids allocating an array because of the
  * varargs.
  */
-private inline fun fastMaxOf(a: Float, b: Float, c: Float, d: Float): Float {
+private fun fastMaxOf(a: Float, b: Float, c: Float, d: Float): Float {
     return maxOf(a, maxOf(b, maxOf(c, d)))
 }
 
@@ -149,15 +149,15 @@ private inline fun fastMaxOf(a: Float, b: Float, c: Float, d: Float): Float {
  * [maximumValue]. Unlike [Float.coerceIn], the range is not validated: the caller must ensure that
  * [minimumValue] is less than [maximumValue].
  */
-private inline fun Float.fastCoerceIn(minimumValue: Float, maximumValue: Float) =
+private fun Float.fastCoerceIn(minimumValue: Float, maximumValue: Float) =
     this.fastCoerceAtLeast(minimumValue).fastCoerceAtMost(maximumValue)
 
 /** Ensures that this value is not less than the specified [minimumValue]. */
-private inline fun Float.fastCoerceAtLeast(minimumValue: Float): Float {
+private fun Float.fastCoerceAtLeast(minimumValue: Float): Float {
     return if (this < minimumValue) minimumValue else this
 }
 
 /** Ensures that this value is not greater than the specified [maximumValue]. */
-private inline fun Float.fastCoerceAtMost(maximumValue: Float): Float {
+private fun Float.fastCoerceAtMost(maximumValue: Float): Float {
     return if (this > maximumValue) maximumValue else this
 }

sentry-compose/src/androidMain/kotlin/io/sentry/compose/gestures/ComposeGestureTargetLocator.kt

@@ -2,6 +2,7 @@
 
 package io.sentry.compose.gestures
 
+import androidx.compose.ui.InternalComposeUiApi
 import androidx.compose.ui.geometry.Offset
 import androidx.compose.ui.node.LayoutNode
 import androidx.compose.ui.node.Owner
@@ -17,6 +18,7 @@ import io.sentry.util.AutoClosableReentrantLock
 import java.util.LinkedList
 import java.util.Queue
 
+@OptIn(InternalComposeUiApi::class)
 public class ComposeGestureTargetLocator(private val logger: ILogger) : GestureTargetLocator {
     @Volatile
     private var composeHelper: SentryComposeHelper? = null

sentry-compose/src/androidUnitTest/kotlin/io/sentry/compose/viewhierarchy/ComposeViewHierarchyExporterTest.kt

@@ -17,8 +17,8 @@ import io.sentry.protocol.ViewHierarchyNode
 import org.junit.Assert
 import org.junit.Test
 import org.mockito.Mockito
-import org.mockito.Mockito.`when`
 import org.mockito.kotlin.any
+import org.mockito.kotlin.mock
 import org.mockito.kotlin.whenever
 
 class ComposeViewHierarchyExporterTest {
@@ -31,10 +31,8 @@ class ComposeViewHierarchyExporterTest {
         val childC = mockLayoutNode(false, null, 10, 20)
         val parent = mockLayoutNode(true, "root", 30, 40, listOf(childA, childB, childC))
 
-        val node = Mockito.mock(
-            Owner::class.java
-        )
-        `when`(node.root).thenReturn(parent)
+        val node = mock<Owner>()
+        whenever(node.root).thenReturn(parent)
 
         val exporter: ViewHierarchyExporter =
             ComposeViewHierarchyExporter(NoOpLogger.getInstance())
@@ -71,12 +69,12 @@ class ComposeViewHierarchyExporterTest {
             val nodeA = Mockito.mock(
                 LayoutNode::class.java
             )
-            `when`(nodeA.isPlaced).thenReturn(isPlaced)
+            whenever(nodeA.isPlaced).thenReturn(isPlaced)
 
             val modifierInfo = Mockito.mock(
                 ModifierInfo::class.java
             )
-            `when`(modifierInfo.modifier)
+            whenever(modifierInfo.modifier)
                 .thenReturn(
                     object : SemanticsModifier {
                         override val semanticsConfiguration: SemanticsConfiguration
@@ -94,9 +92,9 @@ class ComposeViewHierarchyExporterTest {
                 )
             val modifierInfoList: MutableList<ModifierInfo> = ArrayList()
             modifierInfoList.add(modifierInfo)
-            `when`((nodeA.getModifierInfo())).thenReturn(modifierInfoList)
+            whenever((nodeA.getModifierInfo())).thenReturn(modifierInfoList)
 
-            `when`((nodeA.zSortedChildren))
+            whenever((nodeA.zSortedChildren))
                 .thenReturn(mutableVectorOf<LayoutNode>().apply { addAll(children) })
 
             val coordinates = Mockito.mock(
@@ -108,7 +106,7 @@ class ComposeViewHierarchyExporterTest {
             whenever(coordinates.parentLayoutCoordinates).thenReturn(parentCoordinates)
             whenever(parentCoordinates.localBoundingBoxOf(any(), any()))
                 .thenReturn(Rect(0f, 0f, width.toFloat(), height.toFloat()))
-            `when`(nodeA.coordinates).thenReturn(coordinates)
+            whenever(nodeA.coordinates).thenReturn(coordinates)
             return nodeA
         }
     }