fix: clarify operator grouping and resolve an ambiguous path-string overload (#80)

PR: #80

Author: OmarAlJarrah

kuri/src/commonMain/kotlin/org/dexpace/kuri/host/Ipv4Rfc3986.kt

@@ -43,6 +43,9 @@ internal object Ipv4Rfc3986 {
     /** Packs exactly four octets (high to low) into a single 32-bit [Int]. */
     private fun packOctets(octets: List<Int>): Int {
         require(octets.size == Ipv4.IPV4_OCTET_COUNT) { "expected four octets, got ${octets.size}" }
-        return octets.fold(0) { acc, octet -> (acc shl Ipv4.BITS_PER_OCTET) or octet }
+        return octets.fold(0) { acc, octet ->
+            val shifted = acc shl Ipv4.BITS_PER_OCTET
+            shifted or octet
+        }
     }
 }

kuri/src/commonMain/kotlin/org/dexpace/kuri/idna/Punycode.kt

@@ -210,7 +210,8 @@ internal object Punycode {
                 terminated = true
                 break
             }
-            output.append(digitToCodePoint(t + (q - t) % (BASE - t)))
+            val remainder = (q - t) % (BASE - t)
+            output.append(digitToCodePoint(t + remainder))
             q = (q - t) / (BASE - t)
         }
         check(terminated) { "generalized integer did not terminate" }
@@ -297,7 +298,9 @@ internal object Punycode {
             scaled /= (BASE - TMIN)
             k += BASE
         }
-        return k + ((BASE - TMIN + 1) * scaled) / (scaled + SKEW)
+        val numerator = (BASE - TMIN + 1) * scaled
+        val term = numerator / (scaled + SKEW)
+        return k + term
     }
 
     /** Clamps the digit threshold `t` for weight [k] under [bias] to `TMIN..TMAX`. */

kuri/src/commonMain/kotlin/org/dexpace/kuri/parser/ComponentPath.kt

@@ -94,7 +94,7 @@ private const val URI_PATH_SEPARATOR: String = "/"
  * selects the absolute (`/a/b`) versus rootless (`a/b`) form, so a relative reference (`a/b`) and a
  * scheme-rootless path (`mailto:a@b`) each round-trip unchanged.
  */
-internal fun ComponentPath.Segments.toUriPathString(): String =
+internal fun ComponentPath.Segments.toSegmentsPathString(): String =
     when {
         segments.isEmpty() -> ""
         rooted -> URI_PATH_SEPARATOR + segments.joinToString(URI_PATH_SEPARATOR)
@@ -105,13 +105,14 @@ internal fun ComponentPath.Segments.toUriPathString(): String =
  * Encodes any [ComponentPath] back to its RFC 3986 §5.3 string form: an [Opaque][ComponentPath.Opaque] path
  * verbatim (no `/` guard, never dot-collapsed), else the [Segments][ComponentPath.Segments] join.
  *
- * The smart-cast `Segments` receiver dispatches to the more specific [toUriPathString] overload, so
- * this is a dispatch, not a recursion.
+ * Named distinctly from [toSegmentsPathString] (rather than overloading the same name) so dispatch
+ * never depends on the caller's static type: a `ComponentPath`-typed receiver always reaches this
+ * function, which then forwards the smart-cast `Segments` case explicitly.
  */
 internal fun ComponentPath.toUriPathString(): String =
     when (this) {
         is ComponentPath.Opaque -> path
-        is ComponentPath.Segments -> toUriPathString()
+        is ComponentPath.Segments -> toSegmentsPathString()
     }
 
 /**
@@ -352,10 +353,10 @@ internal data class BuilderPath(
      */
     fun effectivePath(hasHost: Boolean): String =
         when (rooting) {
-            PathRooting.ROOTED -> ComponentPath.Segments(segments, rooted = true).toUriPathString()
-            PathRooting.ROOTLESS -> ComponentPath.Segments(segments, rooted = false).toUriPathString()
+            PathRooting.ROOTED -> ComponentPath.Segments(segments, rooted = true).toSegmentsPathString()
+            PathRooting.ROOTLESS -> ComponentPath.Segments(segments, rooted = false).toSegmentsPathString()
             PathRooting.DEFERRED -> {
-                val rootless = ComponentPath.Segments(segments, rooted = false).toUriPathString()
+                val rootless = ComponentPath.Segments(segments, rooted = false).toSegmentsPathString()
                 if (hasHost) URI_PATH_SEPARATOR + rootless else rootless
             }
         }