Allow typespec attrs to be used as module attrs (#8327)

Port of: c190f09

Author: fertapric

lib/elixir/lib/kernel/typespec.ex

@@ -71,24 +71,24 @@ defmodule Kernel.Typespec do
       type_to_signature(expr) == signature
     end
 
-    :lists.any(finder, get_typespec(bag, :type))
+    :lists.any(finder, get_typespecs(bag, [:type, :opaque, :typep]))
   end
 
   def spec_to_callback(module, {name, arity} = signature)
       when is_atom(module) and is_atom(name) and arity in 0..255 do
     {_set, bag} = :elixir_module.data_tables(module)
 
-    filter = fn {expr, _} = object ->
+    filter = fn {:spec, expr, pos} ->
       if spec_to_signature(expr) == signature do
-        :ets.delete_object(bag, {:spec, object})
-        store_typespec(bag, :callback, object)
+        delete_typespec(bag, :spec, expr, pos)
+        store_typespec(bag, :callback, expr, pos)
         true
       else
         false
       end
     end
 
-    :lists.filter(filter, get_typespec(bag, :spec)) != []
+    :lists.filter(filter, get_typespecs(bag, :spec)) != []
   end
 
   ## Typespec definition and storage
@@ -100,7 +100,7 @@ defmodule Kernel.Typespec do
   """
   def deftypespec(:spec, expr, _line, _file, module, pos) do
     {_set, bag} = :elixir_module.data_tables(module)
-    store_typespec(bag, :spec, {expr, pos})
+    store_typespec(bag, :spec, expr, pos)
   end
 
   def deftypespec(kind, expr, line, _file, module, pos)
@@ -116,7 +116,7 @@ defmodule Kernel.Typespec do
         :error
     end
 
-    store_typespec(bag, kind, {expr, pos})
+    store_typespec(bag, kind, expr, pos)
   end
 
   def deftypespec(kind, expr, line, file, module, pos)
@@ -143,17 +143,34 @@ defmodule Kernel.Typespec do
         :error
     end
 
-    store_typespec(bag, :type, {kind, expr, pos})
+    store_typespec(bag, kind, expr, pos)
   end
 
-  defp get_typespec(bag, key) do
-    :ets.lookup_element(bag, key, 2)
+  defp get_typespecs(bag, keys) when is_list(keys) do
+    :lists.flatmap(&get_typespecs(bag, &1), keys)
+  end
+
+  defp get_typespecs(bag, key) do
+    :ets.lookup_element(bag, {:accumulate, key}, 2)
   catch
     :error, :badarg -> []
   end
 
-  defp store_typespec(bag, key, value) do
-    :ets.insert(bag, {key, value})
+  defp take_typespecs(bag, keys) when is_list(keys) do
+    :lists.flatmap(&take_typespecs(bag, &1), keys)
+  end
+
+  defp take_typespecs(bag, key) do
+    :lists.map(&elem(&1, 1), :ets.take(bag, {:accumulate, key}))
+  end
+
+  defp store_typespec(bag, key, expr, pos) do
+    :ets.insert(bag, {{:accumulate, key}, {key, expr, pos}})
+    :ok
+  end
+
+  defp delete_typespec(bag, key, expr, pos) do
+    :ets.delete_object(bag, {{:accumulate, key}, {key, expr, pos}})
     :ok
   end
 
@@ -192,19 +209,15 @@ defmodule Kernel.Typespec do
 
   @doc false
   def translate_typespecs_for_module(_set, bag) do
-    types = Enum.map(take_typespec(bag, :type), &translate_type/1)
-    specs = Enum.map(take_typespec(bag, :spec), &translate_spec/1)
-    callbacks = Enum.map(take_typespec(bag, :callback), &translate_spec/1)
-    macrocallbacks = Enum.map(take_typespec(bag, :macrocallback), &translate_spec/1)
-    optional_callbacks = List.flatten(get_typespec(bag, {:accumulate, :optional_callbacks}))
+    types = Enum.map(take_typespecs(bag, [:type, :opaque, :typep]), &translate_type/1)
+    specs = Enum.map(take_typespecs(bag, :spec), &translate_spec/1)
+    callbacks = Enum.map(take_typespecs(bag, :callback), &translate_spec/1)
+    macrocallbacks = Enum.map(take_typespecs(bag, :macrocallback), &translate_spec/1)
+    optional_callbacks = List.flatten(get_typespecs(bag, :optional_callbacks))
     {types, specs, callbacks, macrocallbacks, optional_callbacks}
   end
 
-  defp take_typespec(bag, key) do
-    :ets.take(bag, key)
-  end
-
-  defp translate_type({_, {kind, {:::, _, [{name, _, args}, definition]}, pos}})
+  defp translate_type({kind, {:::, _, [{name, _, args}, definition]}, pos})
        when is_atom(name) and name != ::: do
     caller = :elixir_locals.get_cached_env(pos)
 
@@ -247,7 +260,7 @@ defmodule Kernel.Typespec do
     {kind, {name, arity}, caller.line, type, export}
   end
 
-  defp translate_type({_, {_kind, other, pos}}) do
+  defp translate_type({_kind, other, pos}) do
     caller = :elixir_locals.get_cached_env(pos)
     type_spec = Macro.to_string(other)
     compile_error(caller, "invalid type specification: #{type_spec}")
@@ -259,12 +272,12 @@ defmodule Kernel.Typespec do
 
   defp valid_variable_ast?(_), do: false
 
-  defp translate_spec({kind, {{:when, _meta, [spec, guard]}, pos}}) do
+  defp translate_spec({kind, {:when, _meta, [spec, guard]}, pos}) do
     caller = :elixir_locals.get_cached_env(pos)
     translate_spec(kind, spec, guard, caller)
   end
 
-  defp translate_spec({kind, {spec, pos}}) do
+  defp translate_spec({kind, spec, pos}) do
     caller = :elixir_locals.get_cached_env(pos)
     translate_spec(kind, spec, [], caller)
   end

lib/elixir/lib/module.ex

@@ -466,7 +466,7 @@ defmodule Module do
       of the corresponding setting in `Code.compiler_options/1`
 
     * `@compile {:inline, some_fun: 2, other_fun: 3}` - inlines the given
-      name/arity pairs. Inlining is applied locally, calls from another 
+      name/arity pairs. Inlining is applied locally, calls from another
       module are not affected by this option
 
     * `@compile {:autoload, false}` - disables automatic loading of
@@ -1864,9 +1864,9 @@ defmodule Module do
     do: {atom, :__on_definition__}
 
   defp preprocess_attribute(key, _value)
-       when key in [:type, :typep, :export_type, :opaque, :callback, :macrocallback] do
+       when key in [:type, :typep, :export_type, :opaque, :spec, :callback, :macrocallback] do
     raise ArgumentError,
-          "attributes type, typep, export_type, opaque, callback, and macrocallback" <>
+          "attributes type, typep, export_type, opaque, spec, callback, and macrocallback " <>
             "must be set directly via the @ notation"
   end
 

lib/elixir/src/elixir_module.erl

@@ -211,7 +211,7 @@ build(Line, File, Module, Lexical) ->
 
   %% In the bag table we store:
   %%
-  %% * {{accumulate, Attribute}, ...}
+  %% * {{accumulate, Attribute}, ...} (includes typespecs)
   %% * {attributes, ...}
   %% * {impls, ...}
   %% * {deprecated, ...}
@@ -221,7 +221,6 @@ build(Line, File, Module, Lexical) ->
   %% * {{clauses, Tuple}, ...} (from elixir_def)
   %% * {reattach, ...} (from elixir_local)
   %% * {{local, Tuple}, ...} (from elixir_local)
-  %% * {spec, ...}, {type, ...}, {callback, ...}, {macrocallback, ...}
   %%
   DataBag = ets:new(Module, [duplicate_bag, public]),
 
@@ -238,6 +237,12 @@ build(Line, File, Module, Lexical) ->
     {dialyzer, [], accumulate},
     {external_resource, [], accumulate},
     {on_definition, [], accumulate},
+    {type, [], accumulate},
+    {opaque, [], accumulate},
+    {typep, [], accumulate},
+    {spec, [], accumulate},
+    {callback, [], accumulate},
+    {macrocallback, [], accumulate},
     {on_load, [], accumulate},
     {optional_callbacks, [], accumulate},
 

lib/elixir/test/elixir/kernel/errors_test.exs

@@ -503,6 +503,22 @@ defmodule Kernel.ErrorsTest do
     end
   end
 
+  test "typespec attributes set via Module.put_attribute/4" do
+    message =
+      "attributes type, typep, export_type, opaque, spec, callback, and macrocallback " <>
+        "must be set directly via the @ notation"
+
+    for kind <- [:type, :typep, :opaque, :spec, :callback, :macrocallback] do
+      assert_eval_raise ArgumentError,
+                        message,
+                        """
+                        defmodule PutTypespecAttribute do
+                          Module.put_attribute(__MODULE__, #{inspect(kind)}, {})
+                        end
+                        """
+    end
+  end
+
   test "invalid struct field value" do
     msg = ~r"invalid value for struct field baz, cannot escape "
 

lib/elixir/test/elixir/typespec_test.exs

@@ -747,6 +747,136 @@ defmodule TypespecTest do
       assert [{:atom, _, :is_subtype}, [{:var, _, :y}, {:var, _, :x}]] = constraint_type
     end
 
+    test "@type, @opaque, and @typep as module attributes" do
+      defmodule TypeModuleAttributes do
+        @type type1 :: boolean
+        @opaque opaque1 :: boolean
+        @typep typep1 :: boolean
+
+        def type1, do: @type
+        def opaque1, do: @opaque
+        def typep1, do: @typep
+
+        @type type2 :: atom
+        @type type3 :: pid
+        @opaque opaque2 :: atom
+        @opaque opaque3 :: pid
+        @typep typep2 :: atom
+
+        def type2, do: @type
+        def opaque2, do: @opaque
+        def typep2, do: @typep
+
+        # Avoid unused warnings
+        @spec foo(typep1) :: typep2
+        def foo(_x), do: :ok
+      end
+
+      assert [
+               {:type, {:::, _, [{:type1, _, _}, {:boolean, _, _}]},
+                {TypespecTest.TypeModuleAttributes, _}}
+             ] = TypeModuleAttributes.type1()
+
+      assert [
+               {:type, {:::, _, [{:type3, _, _}, {:pid, _, _}]},
+                {TypespecTest.TypeModuleAttributes, _}},
+               {:type, {:::, _, [{:type2, _, _}, {:atom, _, _}]},
+                {TypespecTest.TypeModuleAttributes, _}},
+               {:type, {:::, _, [{:type1, _, _}, {:boolean, _, _}]},
+                {TypespecTest.TypeModuleAttributes, _}}
+             ] = TypeModuleAttributes.type2()
+
+      assert [
+               {:opaque, {:::, _, [{:opaque1, _, _}, {:boolean, _, _}]},
+                {TypespecTest.TypeModuleAttributes, _}}
+             ] = TypeModuleAttributes.opaque1()
+
+      assert [
+               {:opaque, {:::, _, [{:opaque3, _, _}, {:pid, _, _}]},
+                {TypespecTest.TypeModuleAttributes, _}},
+               {:opaque, {:::, _, [{:opaque2, _, _}, {:atom, _, _}]},
+                {TypespecTest.TypeModuleAttributes, _}},
+               {:opaque, {:::, _, [{:opaque1, _, _}, {:boolean, _, _}]},
+                {TypespecTest.TypeModuleAttributes, _}}
+             ] = TypeModuleAttributes.opaque2()
+
+      assert [
+               {:typep, {:::, _, [{:typep1, _, _}, {:boolean, _, _}]},
+                {TypespecTest.TypeModuleAttributes, _}}
+             ] = TypeModuleAttributes.typep1()
+
+      assert [
+               {:typep, {:::, _, [{:typep2, _, _}, {:atom, _, _}]},
+                {TypespecTest.TypeModuleAttributes, _}},
+               {:typep, {:::, _, [{:typep1, _, _}, {:boolean, _, _}]},
+                {TypespecTest.TypeModuleAttributes, _}}
+             ] = TypeModuleAttributes.typep2()
+    after
+      :code.delete(TypeModuleAttributes)
+      :code.purge(TypeModuleAttributes)
+    end
+
+    test "@spec, @callback, and @macrocallback as module attributes" do
+      defmodule SpecModuleAttributes do
+        @callback callback1 :: integer
+        @macrocallback macrocallback1 :: integer
+
+        @spec spec1 :: boolean
+        def spec1, do: @spec
+
+        @callback callback2 :: boolean
+        @macrocallback macrocallback2 :: boolean
+
+        @spec spec2 :: atom
+        def spec2, do: @spec
+
+        @spec spec3 :: pid
+        def spec3, do: :ok
+        def spec4, do: @spec
+
+        def callback, do: @callback
+        def macrocallback, do: @macrocallback
+      end
+
+      assert [
+               {:spec, {:::, _, [{:spec1, _, _}, {:boolean, _, _}]},
+                {TypespecTest.SpecModuleAttributes, _}}
+             ] = SpecModuleAttributes.spec1()
+
+      assert [
+               {:spec, {:::, _, [{:spec2, _, _}, {:atom, _, _}]},
+                {TypespecTest.SpecModuleAttributes, _}},
+               {:spec, {:::, _, [{:spec1, _, _}, {:boolean, _, _}]},
+                {TypespecTest.SpecModuleAttributes, _}}
+             ] = SpecModuleAttributes.spec2()
+
+      assert [
+               {:spec, {:::, _, [{:spec3, _, _}, {:pid, _, _}]},
+                {TypespecTest.SpecModuleAttributes, _}},
+               {:spec, {:::, _, [{:spec2, _, _}, {:atom, _, _}]},
+                {TypespecTest.SpecModuleAttributes, _}},
+               {:spec, {:::, _, [{:spec1, _, _}, {:boolean, _, _}]},
+                {TypespecTest.SpecModuleAttributes, _}}
+             ] = SpecModuleAttributes.spec4()
+
+      assert [
+               {:callback, {:::, _, [{:callback2, _, _}, {:boolean, _, _}]},
+                {TypespecTest.SpecModuleAttributes, _}},
+               {:callback, {:::, _, [{:callback1, _, _}, {:integer, _, _}]},
+                {TypespecTest.SpecModuleAttributes, _}}
+             ] = SpecModuleAttributes.callback()
+
+      assert [
+               {:macrocallback, {:::, _, [{:macrocallback2, _, _}, {:boolean, _, _}]},
+                {TypespecTest.SpecModuleAttributes, _}},
+               {:macrocallback, {:::, _, [{:macrocallback1, _, _}, {:integer, _, _}]},
+                {TypespecTest.SpecModuleAttributes, _}}
+             ] = SpecModuleAttributes.macrocallback()
+    after
+      :code.delete(SpecModuleAttributes)
+      :code.purge(SpecModuleAttributes)
+    end
+
     test "@callback(callback)" do
       bytecode =
         test_module do