fix(floats): preserve parsedigits extension API

Keep the historical parsedigits signature and decimal behavior for custom AbstractConf implementations. Route built-in parsers through a separate context-aware core so matching decimal and delimiter bytes remain unambiguous without breaking downstream packages.

Author: quinnj

src/floats.jl

@@ -299,7 +299,7 @@ end
     end
 
     # start parsing digits or decimal point; we start digits as UInt64(0) and can _widen type if needed
-    x, code, pos = parsedigits(conf, source, pos, len, b, code, options, decimal, UInt64(0), neg, startpos)
+    x, code, pos = parsedigits_context(conf, source, pos, len, b, code, options, decimal, UInt64(0), neg, startpos)
     if !isfinite(x)
         code |= SPECIAL_VALUE
     end
@@ -334,10 +334,18 @@ getx(x, f) = f === nothing ? x : nothing
 # statically compiled (`juliac --trim`) binary the widened instance doesn't exist, so
 # parsing a wide-digit float would fail at runtime. The `@noinline` wrappers keep each
 # ladder step compiling separately, which is what bounds base-case compilation.
-@noinline _parsedigits(conf::AbstractConf{T}, source, pos, len, b, code, options, decimal::UInt8, digits::IntType, neg::Bool, startpos, overflow_invalid::Bool, ndigits::Int, f::F) where {T, IntType, F} =
-    parsedigits(conf, source, pos, len, b, code, options, decimal, digits, neg, startpos, overflow_invalid, ndigits, f)::Tuple{rettype(T), ReturnCode, Int}
+@noinline _parsedigits(conf::AbstractConf{T}, source, pos, len, b, code, options, digits::IntType, neg::Bool, startpos, overflow_invalid::Bool, ndigits::Int, f::F) where {T, IntType, F} =
+    parsedigits(conf, source, pos, len, b, code, options, digits, neg, startpos, overflow_invalid, ndigits, f)::Tuple{rettype(T), ReturnCode, Int}
 
-@inline function parsedigits(conf::AbstractConf{T}, source, pos, len, b, code, options, decimal::UInt8, digits::IntType, neg::Bool, startpos, overflow_invalid::Bool=false, ndigits::Int=0, f::F=nothing) where {T, IntType, F}
+@noinline _parsedigits_context(conf::AbstractConf{T}, source, pos, len, b, code, options, decimal::UInt8, digits::IntType, neg::Bool, startpos, overflow_invalid::Bool, ndigits::Int, f::F) where {T, IntType, F} =
+    parsedigits_context(conf, source, pos, len, b, code, options, decimal, digits, neg, startpos, overflow_invalid, ndigits, f)::Tuple{rettype(T), ReturnCode, Int}
+
+# Custom AbstractConf implementations use this entry point. Keep its historical
+# signature and decimal behavior while built-in parsers pass explicit context.
+@inline parsedigits(conf::AbstractConf{T}, source, pos, len, b, code, options, digits::IntType, neg::Bool, startpos, overflow_invalid::Bool=false, ndigits::Int=0, f::F=nothing) where {T, IntType, F} =
+    parsedigits_context(conf, source, pos, len, b, code, options, options.decimal, digits, neg, startpos, overflow_invalid, ndigits, f)
+
+@inline function parsedigits_context(conf::AbstractConf{T}, source, pos, len, b, code, options, decimal::UInt8, digits::IntType, neg::Bool, startpos, overflow_invalid::Bool=false, ndigits::Int=0, f::F=nothing) where {T, IntType, F}
     x = zero(T)
     anydigits = false
     has_groupmark = _has_groupmark(options, code)
@@ -351,7 +359,7 @@ getx(x, f) = f === nothing ? x : nothing
         while true
             if b <= 0x09
                 if overflows(IntType) && digits > overflowval(IntType)
-                    return _parsedigits(conf, source, pos, len, b + UInt8('0'), code, options, decimal, _widen(digits), neg, startpos, overflow_invalid, ndigits, f)::Tuple{rettype(T), ReturnCode, Int}
+                    return _parsedigits_context(conf, source, pos, len, b + UInt8('0'), code, options, decimal, _widen(digits), neg, startpos, overflow_invalid, ndigits, f)::Tuple{rettype(T), ReturnCode, Int}
                 elseif ndigits > maxdigits(T)
                     # if input is way too big, just bail
                     fastseek!(source, startpos - 1)

src/ints.jl

@@ -128,7 +128,7 @@ function parsenumber(source, pos, len, b, code, f::F, opts, checkdelim::Bool) wh
     b = peekbyte(source, pos)
     # parse rest of number
     decimal = _effective_decimal(opts, code, checkdelim)
-    _, code, pos = parsedigits(DefaultConf{Number}(), source, pos, len, b, code, opts, decimal, Int64(0), neg, startpos, true, 0, f)
+    _, code, pos = parsedigits_context(DefaultConf{Number}(), source, pos, len, b, code, opts, decimal, Int64(0), neg, startpos, true, 0, f)
     if invalid(code)
         # by default, parsedigits only has up to Float64 precision; if we overflow
         # let's try BigFloat

test/floats.jl

@@ -528,6 +528,18 @@ end
     Parsers.xparse(BigFloat, bytes; decimal=',', delim=';')
     @test bytes == codeunits("1,2;3")
     @test Parsers.parse(BigFloat, collect(codeunits("1.")), Parsers.Options(delim='.')) == BigFloat(1)
+
+    # Custom AbstractConf implementations use this historical parsedigits entry point.
+    source = codeunits("1,2")
+    options = Parsers.Options(decimal=',', delim=',')
+    x, code, pos = Parsers.parsedigits(
+        Parsers.DefaultConf{Float64}(), source, 1, length(source), source[1],
+        Parsers.SUCCESS, options, UInt64(0), false, 1, false, 0, nothing,
+    )
+    @test x == 1.2
+    @test Parsers.ok(code)
+    @test Parsers.eof(code)
+    @test pos == 4
 end
 
 @testset "BigFloats" begin