Allow types to be given to defrecordp

Part of #1288

Author: José Valim

CHANGELOG.md

@@ -9,6 +9,7 @@
   * [Mix] Implement `Mix.Version` for basic versioniong semantics
   * [Mix] Support creation and installation of archives (.ez files)
   * [Mix] `github: ...` shortcut now uses the faster `git` schema instead of `https`
+  * [Record] Allow types to be given to `defrecordp`
 
 * bug fix
   * [Kernel] The elixir executable on Windows now supports the same options as the UNIX one

lib/elixir/lib/kernel.ex

@@ -1489,6 +1489,21 @@ defmodule Kernel do
       user(name: name) = record
       name #=> "José"
 
+  ## Types
+
+  `defrecordp` automatically generates an opaque time based
+  on the record name and the types can be modified too. The
+  following definition:
+
+      defrecordp :user,
+        name: "José" :: binary,
+        age: 25 :: integer
+
+  Will generate the following type:
+
+      @opaque user :: { :user, binary, integer }
+
+  All the fields without a specified type are assumed to have type `term`.
   """
   defmacro defrecordp(name, fields) when is_atom(name) do
     Record.defrecordp(name, fields)

lib/elixir/lib/record.ex

@@ -127,21 +127,28 @@ defmodule Record do
   ## Types
 
   Every record defines a type named `t` that can be accessed in typespecs.
-  For example, assuming the `Config` record defined above, it could be used
-  in typespecs as follow:
+  Those types can be passed at the moment the record is defined:
 
-      @spec handle_config(Config.t) :: boolean()
+      defrecord User,
+        name: "" :: string,
+        age: 0 :: integer
 
-  Inside the record definition, a developer can define his own types too:
+  All the fields without a specified type are assumed to have type `term`.
+
+  Assuming the `User` record defined above, it could be used in typespecs
+  as follow:
+
+      @spec handle_user(User.t) :: boolean()
+
+  If the developer wants to define their own types to be used with the
+  record, Elixir allows a more lengthy definition with the help of the
+  `record_type` macro:
 
       defrecord Config, counter: 0, failures: [] do
         @type kind :: term
         record_type counter: integer, failures: [kind]
       end
 
-  When defining a type, all the fields not mentioned in the type are
-  assumed to have type `term`.
-
   ## Importing records
 
   It is also possible to import a public record (a record, defined using
@@ -173,29 +180,50 @@ defmodule Record do
   """
   def defrecord(name, values, opts) do
     block = Keyword.get(opts, :do, nil)
+    { fields, types } = record_split(values)
 
     quote do
-      unquoted_values = unquote(values)
+      unquoted_fields = unquote(fields)
 
       defmodule unquote(name) do
         @moduledoc false
         import Elixir.Record.DSL
 
         @record_fields []
-        @record_types  []
+        @record_types  unquote(types)
 
-        # Reassign values to inner scope to
+        # Reassign fields to inner scope to
         # avoid conflicts in nested records
-        values = unquoted_values
+        fields = unquoted_fields
 
-        Elixir.Record.deffunctions(values, __ENV__)
+        Elixir.Record.deffunctions(fields, __ENV__)
         value = unquote(block)
-        Elixir.Record.deftypes(values, @record_types, __ENV__)
+        Elixir.Record.deftypes(fields, @record_types, __ENV__)
         value
       end
     end
   end
 
+  defp record_split(fields) when is_list(fields) do
+    record_split(fields, [], [])
+  end
+
+  defp record_split(other) do
+    { other, [] }
+  end
+
+  defp record_split([{ field, { :::, _, [default, type] }}|t], defaults, types) do
+    record_split t, [{ field, default }|defaults], [{ field, Macro.escape(type) }|types]
+  end
+
+  defp record_split([other|t], defaults, types) do
+    record_split t, [other|defaults], types
+  end
+
+  defp record_split([], defaults, types) do
+    { Enum.reverse(defaults), types }
+  end
+
   @doc """
   Import public record definition as a set of private macros (as defined by defrecordp/2)
 
@@ -224,12 +252,27 @@ defmodule Record do
   in `values`. This is invoked directly by `Kernel.defrecordp`,
   so check it for more information and documentation.
   """
-  def defrecordp(name, fields) do
+  def defrecordp(name, fields) when is_atom(name) and is_list(fields) do
+    { fields, types } = recordp_split(fields, [], [])
+
     quote do
       Record.defmacros(unquote(name), unquote(fields), __ENV__)
+      @opaque unquote(name)() :: { unquote(name), unquote_splicing(types) }
     end
   end
 
+  defp recordp_split([{ field, { :::, _, [default, type] }}|t], defaults, types) do
+    recordp_split t, [{ field, default }|defaults], [type|types]
+  end
+
+  defp recordp_split([other|t], defaults, types) do
+    recordp_split t, [other|defaults], [quote(do: term)|types]
+  end
+
+  defp recordp_split([], defaults, types) do
+    { Enum.reverse(defaults), Enum.reverse(types) }
+  end
+
   @doc """
   Defines record functions skipping the module definition.
   This is called directly by `defrecord`. It expects the record

lib/elixir/test/elixir/record_test.exs

@@ -49,6 +49,8 @@ defrecord RecordTest.WithRecordType, a: 0, b: 1 do
   record_type a: integer
 end
 
+defrecord RecordTest.WithInlineType, a: nil :: atom, b: 1 :: integer
+
 defmodule RecordTest.Macros do
   defrecordp :_user, name: "José", age: 25
 

lib/elixir/test/elixir/typespec_test.exs

@@ -259,6 +259,16 @@ defmodule Typespec.TypeTest do
     assert [{:mytype, _, []}, {:mytype1, _, []}] = types
   end
 
+  test "@type from defrecordp" do
+    types = test_module do
+      defrecordp :user, name: nil, age: 0 :: integer
+      @opaque
+    end
+
+    assert [{:user, {:type, _, :tuple,
+             [{:atom, _, :user}, {:type, _, :term, []}, {:type, _, :integer, []}]}, []}] = types
+  end
+
   test "defines_type?" do
     test_module do
       @type mytype :: tuple