fix(parse): avoid style wrapper ambiguity

Avoid wrapping custom JSONStyle values on the default parse path, while keeping JSON lazy-value lifting available on JSONStyle itself. This lets broad style-level StructUtils methods dispatch without conflicting with JSONReadStyle forwarding.

Fixes #464

Author: quinnj

src/parse.jl

@@ -174,9 +174,12 @@ StructUtils.fieldtagkey(::JSONStyle) = :json
 StructUtils.defaultstate(st::JSONReadStyle) = StructUtils.defaultstate(st.style)
 
 # forward StructUtils API to the inner style so user-provided JSONStyle dispatches are honored
-StructUtils.dictlike(st::JSONReadStyle, ::Type{T}) where {T} = StructUtils.dictlike(st.style, T)
-StructUtils.arraylike(st::JSONReadStyle, ::Type{T}) where {T} = StructUtils.arraylike(st.style, T)
-StructUtils.nulllike(st::JSONReadStyle, ::Type{T}) where {T} = StructUtils.nulllike(st.style, T)
+StructUtils.dictlike(st::JSONReadStyle{O,N,S}, ::Type{T}) where {O,N,S<:JSONStyle,T} =
+    StructUtils.dictlike(st.style, T)
+StructUtils.arraylike(st::JSONReadStyle{O,N,S}, ::Type{T}) where {O,N,S<:JSONStyle,T} =
+    StructUtils.arraylike(st.style, T)
+StructUtils.nulllike(st::JSONReadStyle{O,N,S}, ::Type{T}) where {O,N,S<:JSONStyle,T} =
+    StructUtils.nulllike(st.style, T)
 # Keep structlike forwarding specific to custom JSONStyle wrappers so type-level StructStyle
 # specializations (for example @nonstruct types) continue to dispatch without ambiguity.
 StructUtils.structlike(st::JSONReadStyle{O,N,S}, ::Type{T}) where {O,N,S<:JSONStyle,T} =
@@ -192,6 +195,11 @@ function jsonreadstyle(::Type{T}, ::Type{O}, null, style::StructStyle, unknown_f
     if T === Any && !ignore_unknown_fields
         throw(ArgumentError("`unknown_fields` is only supported when parsing into a target type or existing object"))
     end
+    # A JSONStyle already has JSON field tags and lazy-value lifting; avoid wrapping
+    # the default path so broad style methods do not become ambiguous.
+    if O === DEFAULT_OBJECT_TYPE && null === nothing && ignore_unknown_fields && style isa JSONStyle
+        return style
+    end
     return JSONReadStyle{O}(null, style, ignore_unknown_fields)
 end
 
@@ -377,28 +385,47 @@ function StructUtils.make(st::StructStyle, ::Type{Any}, x::LazyValues)
 end
 
 # catch PtrString via lift or make! so we can ensure it never "escapes" to user-level
+StructUtils.liftkey(st::JSONStyle, ::Type{T}, x::PtrString) where {T} =
+    StructUtils.liftkey(st, T, convert(String, x))
 StructUtils.liftkey(st::JSONReadStyle, ::Type{T}, x::PtrString) where {T} =
     StructUtils.liftkey(st, T, convert(String, x))
+StructUtils.lift(st::JSONStyle, ::Type{T}, x::PtrString, tags) where {T} =
+    StructUtils.lift(st, T, convert(String, x), tags)
 StructUtils.lift(st::JSONReadStyle, ::Type{T}, x::PtrString, tags) where {T} =
     StructUtils.lift(st, T, convert(String, x), tags)
+StructUtils.lift(st::JSONStyle, ::Type{T}, x::PtrString) where {T} =
+    StructUtils.lift(st, T, convert(String, x))
 StructUtils.lift(st::JSONReadStyle, ::Type{T}, x::PtrString) where {T} =
     StructUtils.lift(st, T, convert(String, x))
 
 # liftkey for numeric dict key types to enable round-tripping Dict{Int,V}, Dict{Float64,V}, etc.
 # these correspond to the lowerkey definitions in write.jl that convert numeric keys to strings
-StructUtils.liftkey(::JSONReadStyle, ::Type{T}, x::AbstractString) where {T<:Integer} = Base.parse(T, x)
-StructUtils.liftkey(::JSONReadStyle, ::Type{T}, x::AbstractString) where {T<:AbstractFloat} = Base.parse(T, x)
+StructUtils.liftkey(::JSONStyle, ::Type{T}, x::AbstractString) where {T<:Integer} = Base.parse(T, x)
+StructUtils.liftkey(::JSONStyle, ::Type{T}, x::AbstractString) where {T<:AbstractFloat} = Base.parse(T, x)
 
 StructUtils.lift(style::JSONReadStyle, ::Type{T}, x, tags) where {T} = StructUtils.lift(style.style, T, x, tags)
 StructUtils.lift(style::JSONReadStyle, ::Type{T}, x) where {T} = StructUtils.lift(style.style, T, x)
 
+function StructUtils.lift(style::JSONStyle, ::Type{T}, x::LazyValues) where {T<:AbstractArray{E,0}} where {E}
+    m = T(undef)
+    m[1], pos = StructUtils.lift(style, E, x)
+    return m, pos
+end
+
 function StructUtils.lift(style::JSONReadStyle, ::Type{T}, x::LazyValues) where {T<:AbstractArray{E,0}} where {E}
     m = T(undef)
     m[1], pos = StructUtils.lift(style, E, x)
     return m, pos
 end
 
-function StructUtils.lift(style::JSONReadStyle, ::Type{T}, x::LazyValues, tags=(;)) where {T}
+StructUtils.lift(style::JSONStyle, ::Type{T}, x::LazyValues, tags=(;)) where {T} =
+    _liftjsonvalue(style, T, x, tags)
+StructUtils.lift(style::JSONReadStyle, ::Type{T}, x::LazyValues, tags) where {T} =
+    _liftjsonvalue(style, T, x, tags)
+StructUtils.lift(style::JSONReadStyle, ::Type{T}, x::LazyValues) where {T} =
+    _liftjsonvalue(style, T, x, (;))
+
+function _liftjsonvalue(style::JSONStyle, ::Type{T}, x::LazyValues, tags) where {T}
     type = gettype(x)
     buf = getbuf(x)
     if type == JSONTypes.STRING

test/parse.jl

@@ -237,6 +237,28 @@ Base.valtype(::DictlikeViaCustomStyle) = Int
 StructUtils.addkeyval!(a::DictlikeViaCustomStyle, k, v) = StructUtils.addkeyval!(a.vals, k, v)
 StructUtils.dictlike(::CustomJSONStyle, ::Type{DictlikeViaCustomStyle}) = true
 
+# https://github.com/JuliaIO/JSON.jl/issues/464 - broad style dispatch should not
+# become ambiguous with JSONReadStyle's custom style wrapper
+struct DictlikeViaStructStyle
+    vals::Dict{String,Int}
+end
+Base.keytype(::DictlikeViaStructStyle) = String
+Base.valtype(::DictlikeViaStructStyle) = Int
+StructUtils.initialize(::StructUtils.StructStyle, ::Type{DictlikeViaStructStyle}, source) =
+    DictlikeViaStructStyle(Dict{String,Int}())
+StructUtils.addkeyval!(a::DictlikeViaStructStyle, k, v) = StructUtils.addkeyval!(a.vals, k, v)
+StructUtils.dictlike(::StructUtils.StructStyle, ::Type{DictlikeViaStructStyle}) = true
+
+struct DictlikeViaAbstractJSONStyle
+    vals::Dict{String,Int}
+end
+Base.keytype(::DictlikeViaAbstractJSONStyle) = String
+Base.valtype(::DictlikeViaAbstractJSONStyle) = Int
+StructUtils.initialize(::JSON.JSONStyle, ::Type{DictlikeViaAbstractJSONStyle}, source) =
+    DictlikeViaAbstractJSONStyle(Dict{String,Int}())
+StructUtils.addkeyval!(a::DictlikeViaAbstractJSONStyle, k, v) = StructUtils.addkeyval!(a.vals, k, v)
+StructUtils.dictlike(::JSON.JSONStyle, ::Type{DictlikeViaAbstractJSONStyle}) = true
+
 StructUtils.structlike(::RefValueStyle, ::Type{Base.RefValue{Int}}) = false
 StructUtils.lower(::RefValueStyle, x::Base.RefValue{Int}) = x[]
 StructUtils.lift(::RefValueStyle, ::Type{Base.RefValue{Int}}, x::Integer) = Ref{Int}(x), nothing
@@ -786,6 +808,20 @@ StructUtils.lift(::RefValueStyle, ::Type{Base.RefValue{Int}}, x::Integer) = Ref{
     let res = JSON.parse("""{"a": 1, "b": 2}""", DictlikeViaCustomStyle; style=CustomJSONStyle())
         @test res.vals == Dict("a" => 1, "b" => 2)
     end
+    # https://github.com/JuliaIO/JSON.jl/issues/464 - broad style-level dictlike methods must
+    # not conflict with JSONReadStyle's custom style wrapper
+    let res = JSON.parse("""{"a": 1, "b": 2}""", DictlikeViaStructStyle)
+        @test res.vals == Dict("a" => 1, "b" => 2)
+    end
+    let res = JSON.parse("""{"a": 1, "b": 2}""", DictlikeViaAbstractJSONStyle)
+        @test res.vals == Dict("a" => 1, "b" => 2)
+    end
+    let res = JSON.parse("""{"a": 1, "b": 2}""", DictlikeViaStructStyle; style=CustomJSONStyle())
+        @test res.vals == Dict("a" => 1, "b" => 2)
+    end
+    let res = JSON.parse("""{"a": 1, "b": 2}""", DictlikeViaAbstractJSONStyle; style=CustomJSONStyle())
+        @test res.vals == Dict("a" => 1, "b" => 2)
+    end
     # https://github.com/JuliaIO/JSON.jl/issues/462 - structlike dispatch on custom JSONStyle must reach user method
     let json = JSON.json(Ref{Int}(1); style=RefValueStyle())
         @test json == "1"