Remove deprecated support for own t/0 type and defstruct (#412)

Author: v0idpwn

lib/protobuf/dsl.ex

@@ -174,58 +174,17 @@ defmodule Protobuf.DSL do
         unquote(Macro.escape(msg_props))
       end
 
-      cond do
-        # If this is an enum and "@type t()" is already called, it's fine because it's likely
-        # the old code generated by this library.
-        unquote(msg_props.enum?) and unquote(defines_t_type?) ->
-          IO.warn("""
-          Since v0.10.0 of the :protobuf library, the t/0 type in Protobuf enum modules \
-          is automatically generated by "use Protobuf". Remove your explicit definition or \
-          regenerate the files with a newer version of the protoc-gen-elixir escript. \
-          This warning will become an error in version 0.11.0+ of this library.
-          """)
-
-        # If both "defstruct" and "@type t()" are called, it's probably okay because it's the code
-        # we used to generated before from this library, but we want to get rid of it, so we warn.
-        unquote(defines_defstruct?) and unquote(defines_t_type?) ->
-          IO.warn("""
-          Since v0.10.0 of the :protobuf library, the t/0 type and the struct are automatically \
-          generated for modules that call "use Protobuf" if they are Protobuf enums or messages. \
-          Remove your explicit definition of both of these or regenerate the files with the \
-          latest version of the protoc-gen-elixir plugin. This warning will become an error \
-          in version 0.11.0+ of the :protobuf library.\
-          """)
-
-        # If users defined only "defstruct" OR "@type t()", it means either they didn't generate
-        # the code through this library or they modified the generated files. In either case,
-        # let's raise here since we could have inconsistencies between the user-defined spec/type
-        # and our type/spec, respectively.
-        unquote(not msg_props.enum?) and (unquote(defines_defstruct?) or unquote(defines_t_type?)) ->
-          what = if unquote(defines_defstruct?), do: "defstruct/1", else: "@type t() :: ..."
-
-          raise """
-          since v0.10.0 of the :protobuf library, the t/0 type and the struct are automatically \
-          generated for modules that call "use Protobuf" if they are Protobuf enums or messages. \
-          This was the case for #{inspect(unquote(__MODULE__))}, where you call #{what}. \
-          This could cause inconsistencies with the type or struct generated by the library. \
-          You can either:
-
-            * make sure that you define both the t/0 type as well as the struct, but that will
-              become an error in later versions of the Protobuf library
-
-            * remove both the t/0 type definition as well as the struct definition and let the
-              library define both
-
-            * regenerate the file from the Protobuf source definition with the latest version
-              of the protoc-gen-elixir plugin, which won't generate the struct or the t/0 type
-              definition
-
-          """
-
-        # Newest version of this library generate both the t/0 type as well as the struct.
-        true ->
-          unquote(def_t_typespec(msg_props, extension_props, transform_module_ast))
-          unquote(gen_defstruct(msg_props))
+      if unquote(defines_defstruct?) or unquote(defines_t_type?) do
+        raise Protobuf.InvalidError, """
+        since v0.10.0 of the :protobuf library, the t/0 type and the struct are automatically \
+        generated for modules that call "use Protobuf" if they are Protobuf enums or messages, \
+        and their usage was deprecated. Since v0.15.0, they are errors. Remove your explicit \
+        definition of both of these or regenerate the files with the latest version of the \
+        protoc-gen-elixir plugin.\
+        """
+      else
+        unquote(def_t_typespec(msg_props, extension_props, transform_module_ast))
+        unquote(gen_defstruct(msg_props))
       end
 
       unquote(msg_props.enum? && Protobuf.DSL.Enum.quoted_enum_functions(msg_props))

test/protobuf/dsl_test.exs

@@ -1,8 +1,6 @@
 defmodule Protobuf.DSLTest do
   use ExUnit.Case, async: true
 
-  import ExUnit.CaptureIO
-
   alias Protobuf.{FieldProps, MessageProps}
   alias TestMsg.{Foo, Foo2, Proto3Optional}
 
@@ -205,88 +203,92 @@ defmodule Protobuf.DSLTest do
     assert TestMsg.WithTransformModule.transform_module() == TestMsg.TransformModule
   end
 
-  test "emits a warning if there is already a definition for the t/0 type for an enum" do
-    output =
-      capture_io(:stderr, fn ->
-        Code.eval_quoted(
-          quote do
-            defmodule MessageWithWarning do
-              use Protobuf, syntax: :proto3, enum: true
-
-              @type t() :: integer() | :FOO
-
-              field :FOO, 0, type: :bool
-            end
-          end
-        )
-      end)
-
-    assert output =~ "the t/0 type in Protobuf enum modules is automatically generated"
+  test "raises a compilation error if there is already a definition for the t/0 type for an enum" do
+    assert_raise Protobuf.InvalidError,
+                 ~r{t/0 type and the struct are automatically generated},
+                 fn ->
+                   Code.eval_quoted(
+                     quote do
+                       defmodule MessageWithWarning do
+                         use Protobuf, syntax: :proto3, enum: true
+
+                         @type t() :: integer() | :FOO
+
+                         field :FOO, 0, type: :bool
+                       end
+                     end
+                   )
+                 end
   end
 
-  test "emits a warning if there is already a call to defstruct/1 and a definition for the t/0 type" do
-    output =
-      capture_io(:stderr, fn ->
-        Code.eval_quoted(
-          quote do
-            defmodule MessageWithWarning do
-              use Protobuf, syntax: :proto3
+  test "raises a compilation error if there is already a call to defstruct/1 and a definition for the t/0 type" do
+    assert_raise Protobuf.InvalidError,
+                 ~r{t/0 type and the struct are automatically generated},
+                 fn ->
+                   Code.eval_quoted(
+                     quote do
+                       defmodule MessageWithWarning do
+                         use Protobuf, syntax: :proto3
 
-              @type t() :: %__MODULE__{foo: boolean()}
+                         @type t() :: %__MODULE__{foo: boolean()}
 
-              defstruct [:foo]
+                         defstruct [:foo]
 
-              field :foo, 1, type: :bool
-            end
-          end
-        )
-      end)
-
-    assert output =~ "t/0 type and the struct are automatically generated"
+                         field :foo, 1, type: :bool
+                       end
+                     end
+                   )
+                 end
   end
 
   test "raises a compilation error if there is already a call to defstruct/1 but no definition for the t/0 type" do
-    assert_raise RuntimeError, ~r{t/0 type and the struct are automatically generated}, fn ->
-      Code.eval_quoted(
-        quote do
-          defmodule MessageWithDefstructError do
-            use Protobuf, syntax: :proto3
-
-            defstruct [:foo]
-
-            field :foo, 1, type: :bool
-          end
-        end
-      )
-    end
+    assert_raise Protobuf.InvalidError,
+                 ~r{t/0 type and the struct are automatically generated},
+                 fn ->
+                   Code.eval_quoted(
+                     quote do
+                       defmodule MessageWithDefstructError do
+                         use Protobuf, syntax: :proto3
+
+                         defstruct [:foo]
+
+                         field :foo, 1, type: :bool
+                       end
+                     end
+                   )
+                 end
   end
 
   test "raises a compilation error if there is already a definition for the t/0 type but no defstruct" do
-    assert_raise RuntimeError, ~r{the t/0 type and the struct are automatically generated}, fn ->
-      Code.eval_quoted(
-        quote do
-          defmodule MessageWithTTypeError do
-            use Protobuf, syntax: :proto3
-
-            @type t() :: %__MODULE__{foo: boolean()}
-
-            field :foo, 1, type: :bool
-          end
-        end
-      )
-    end
+    assert_raise Protobuf.InvalidError,
+                 ~r{the t/0 type and the struct are automatically generated},
+                 fn ->
+                   Code.eval_quoted(
+                     quote do
+                       defmodule MessageWithTTypeError do
+                         use Protobuf, syntax: :proto3
+
+                         @type t() :: %__MODULE__{foo: boolean()}
+
+                         field :foo, 1, type: :bool
+                       end
+                     end
+                   )
+                 end
   end
 
   test "raises a compilation error if syntax is proto3 and the first enum has tag other than 0" do
-    assert_raise RuntimeError, "the first enum value must have tag 0 in proto3, got: 1", fn ->
-      Code.eval_quoted(
-        quote do
-          defmodule MessageWithProto3BadEnumTag do
-            use Protobuf, syntax: :proto3, enum: true
-            field :NOT_ZERO, 1
-          end
-        end
-      )
-    end
+    assert_raise RuntimeError,
+                 "the first enum value must have tag 0 in proto3, got: 1",
+                 fn ->
+                   Code.eval_quoted(
+                     quote do
+                       defmodule MessageWithProto3BadEnumTag do
+                         use Protobuf, syntax: :proto3, enum: true
+                         field :NOT_ZERO, 1
+                       end
+                     end
+                   )
+                 end
   end
 end