Merge pull request #217 from JuliaIO/td-common-abstract-type

Introduce `common_abstract_type` option

Author: Drvi

docs/src/index.md

@@ -126,6 +126,10 @@ For translating proto files, use `protojl` function (previously `protoc`). To de
 ### Mutability
 Messages are now translated to immutable structs. This means that code that used the mutable structs to accumulate data will now have to prepare each field and construct the struct after all of them are ready.
 
+### Common abstract type
+
+By default, the generated structs don't share any common abstract type (well, except `Any`), when you set the `common_abstract_type` option to `true`, every struct definition will be a subtype of `ProtoBuf.AbstractProtoBufMessage`.
+
 ### Naming Conventions
 The naming of nested messages and enums now generates names, that cannot collide with other definitions. For example:
 ```protobuf

src/ProtoBuf.jl

@@ -125,8 +125,10 @@ function encode(e::AbstractProtoEncoder, ::T) where {T}
     throw(MethodError(encode, (typeof(e), T)))
 end
 
+abstract type AbstractProtoBufMessage end
+
 export protojl, encode, ProtoEncoder, decode, decode!, ProtoDecoder
-export OneOf
+export OneOf, AbstractProtoBufMessage
 export reserved_fields, extendable_field_numbers, oneof_field_types, field_numbers, default_values
 
 if Base.VERSION >= v"1.4.2"

src/codegen/CodeGenerators.jl

@@ -31,6 +31,7 @@ Base.@kwdef struct Options
     force_required::Union{Nothing,Dict{String,Set{String}}} = nothing
     add_kwarg_constructors::Bool = false
     parametrize_oneofs::Bool = false
+    common_abstract_type::Bool = false
 end
 
 struct Context
@@ -63,6 +64,7 @@ include("utils.jl")
         force_required::Union{Nothing,Dict{String,Set{String}}}=nothing,
         add_kwarg_constructors::Bool=false,
         parametrize_oneofs::Bool=false,
+        common_abstract_type::Bool=false,
     ) -> Nothing
 
 Generate Julia code for `.proto` files at `relative_paths` within `search_directories` and save it to `output_directory`.
@@ -115,6 +117,7 @@ to
 struct MyMessage{T1<:Union{Nothing, OneOf{<:Union{Int, String}}}}
     oneof_field::T1
 end
+- `common_abstract_type::Bool=false`: When `true`, all generated structs will subtype `ProtoBuf.AbstractProtoBufMessage`.
 ```
 
 # Notes
@@ -129,8 +132,9 @@ function protojl(
     force_required::Union{Nothing,<:Dict{<:AbstractString,<:Set{<:AbstractString}}}=nothing,
     add_kwarg_constructors::Bool=false,
     parametrize_oneofs::Bool=false,
+    common_abstract_type::Bool = false,
 )
-    options = Options(include_vendored_wellknown_types, always_use_modules, force_required, add_kwarg_constructors, parametrize_oneofs)
+    options = Options(include_vendored_wellknown_types, always_use_modules, force_required, add_kwarg_constructors, parametrize_oneofs, common_abstract_type)
     return _protojl(relative_paths, search_directories, output_directory, options)
 end
 

src/codegen/toplevel_definitions.jl

@@ -86,7 +86,7 @@ function generate_struct(io, t::MessageType, ctx::Context)
     type_params = get_type_params(t, ctx)
     params_string = get_type_param_string(type_params)
 
-    print(io, "struct ", struct_name, length(t.fields) > 0 ? params_string : ' ', _maybe_subtype(abstract_base_name))
+    print(io, "struct ", struct_name, length(t.fields) > 0 ? params_string : ' ', _maybe_subtype(abstract_base_name, ctx.options))
     length(t.fields) > 0 && println(io)
     for field in t.fields
         generate_struct_field(io, field, ctx, type_params)
@@ -173,6 +173,7 @@ function translate(io, rp::ResolvedProtoFile, file_map::Dict{String,ResolvedProt
         end
     end # Otherwise all includes will happen in the enclosing module
     println(io, "import ProtoBuf as PB")
+    options.common_abstract_type && println(io, "using ProtoBuf: AbstractProtoBufMessage")
     println(io, "using ProtoBuf: OneOf")
     println(io, "using EnumX: @enumx")
     if (is_namespaced(p) || options.always_use_modules) && !isempty(p.definitions)
@@ -191,7 +192,7 @@ function translate(io, rp::ResolvedProtoFile, file_map::Dict{String,ResolvedProt
     end
     !isempty(p.cyclic_definitions) && println(io, "\n\n# Abstract types to help resolve mutually recursive definitions")
     for name in p.cyclic_definitions
-        println(io, "abstract type ", abstract_type_name(name), " end")
+        println(io, "abstract type ", abstract_type_name(name), options.common_abstract_type ? " <: AbstractProtoBufMessage" : "", " end")
     end
     println(io)
     for def_name in p.sorted_definitions

src/codegen/types.jl

@@ -112,8 +112,8 @@ function _get_type_bound(f::OneOfType, ctx::Context)
     return type
 end
 
-function _maybe_subtype(name)
-    isempty(name) && return ""
+function _maybe_subtype(name, options)
+    isempty(name) && return options.common_abstract_type ? " <: AbstractProtoBufMessage" : ""
     return string(" <: ", abstract_type_name(name))
 end
 

test/test_codegen.jl

@@ -78,6 +78,15 @@ end
         end # module"""
     end
 
+    @testset "Minimal proto file with common abstract type" begin
+        s, p, ctx = translate_simple_proto("", Options(always_use_modules=false, common_abstract_type=true))
+        @test s == """
+        import ProtoBuf as PB
+        using ProtoBuf: AbstractProtoBufMessage
+        using ProtoBuf: OneOf
+        using EnumX: @enumx"""
+    end
+
     @testset "Minimal proto file with file imports" begin
         s, p, ctx = translate_simple_proto("import \"path/to/a\";", Dict("path/to/a" => ""), Options(always_use_modules=false))
         @test s == """
@@ -284,6 +293,25 @@ end
         @test CodeGenerators.jl_init_value(p.definitions["A"].fields[1], ctx) == "Ref{Union{Nothing,B}}(nothing)"
     end
 
+    @testset "Simple type with a common abstract type" begin
+        s, p, ctx = translate_simple_proto("message B { optional int32 b = 1; }", Options(always_use_modules=false, common_abstract_type=true))
+        @test generate_struct_str(p.definitions["B"], ctx) == """
+        struct B <: AbstractProtoBufMessage
+            b::Int32
+        end
+        """
+    end
+
+    @testset "Self-referential type with a common abstract type" begin
+        s, p, ctx = translate_simple_proto("message B { optional B b = 1; }", Options(always_use_modules=false, common_abstract_type=true))
+        @test occursin("abstract type var\"##AbstractB\" <: AbstractProtoBufMessage end", s)
+        @test generate_struct_str(p.definitions["B"], ctx) == """
+        struct B <: var"##AbstractB"
+            b::Union{Nothing,B}
+        end
+        """
+    end
+
     @testset "OneOf field codegen" begin
         s, p, ctx = translate_simple_proto("message A { oneof a { int32 b = 1; } }", Options(parametrize_oneofs=true))
         @test occursin("""