Change typespec guards to keyword list

Previous syntax:
@SPEC fun(a) :: b when is_var(a) and is_subtype(b, [a])
New syntax:
@SPEC fun(a) :: b when a: var, b: [a]

Author: ericmj

lib/elixir/lib/kernel/typespec.ex

@@ -243,24 +243,41 @@ defmodule Kernel.Typespec do
   Converts a spec clause back to Elixir AST.
   """
   def spec_to_ast(name, { :type, line, :fun, [{:type, _, :product, args}, result] }) do
-    args = lc arg inlist args, do: typespec_to_ast(arg)
-    { :::, [line: line], [{ name, [line: line], args }, typespec_to_ast(result)] }
+    ast_args = lc arg inlist args, do: typespec_to_ast(arg)
+    ast = { :::, [line: line], [{ name, [line: line], ast_args }, typespec_to_ast(result)] }
+
+    vars = args ++ [result]
+      |> Enum.flat_map(&collect_vars/1)
+      |> Enum.uniq
+      |> Enum.map(&{ &1, { :var, [line: line], nil } })
+
+    unless vars == [] do
+      ast = { :when, [line: line], [ast, vars] }
+    end
+
+    ast
   end
 
   def spec_to_ast(name, { :type, line, :fun, [] }) do
     { :::, [line: line], [{ name, [line: line], [] }, quote(do: term)] }
   end
 
   def spec_to_ast(name, { :type, line, :bounded_fun, [{ :type, _, :fun, [{ :type, _, :product, args }, result] }, constraints] }) do
-    [h|t] =
-      lc {:type, line, :constraint, [{:atom, _, :is_subtype}, [var, type]]} inlist constraints do
-        { :is_subtype, [line: line], [typespec_to_ast(var), typespec_to_ast(type)] }
+    guards =
+      lc {:type, _, :constraint, [{:atom, _, :is_subtype}, [{ :var, _, var }, type]]} inlist constraints do
+        { var, typespec_to_ast(type) }
       end
 
-    args = lc arg inlist args, do: typespec_to_ast(arg)
-    guards = Enum.reduce t, h, fn(x, acc) -> { :and, line, [acc, x] } end
+    ast_args = lc arg inlist args, do: typespec_to_ast(arg)
+
+    vars = args ++ [result]
+      |> Enum.flat_map(&collect_vars/1)
+      |> Enum.uniq
+
+    vars = vars -- Keyword.keys(guards)
+      |> Enum.map(&{ &1, { :var, [line: line], nil } })
 
-    { :when, [line: line], [{ :::, [line: line], [{ name, [line: line], args }, typespec_to_ast(result)] }, guards] }
+    { :when, [line: line], [{ :::, [line: line], [{ name, [line: line], ast_args }, typespec_to_ast(result)] }, guards ++ vars] }
   end
 
   @doc """
@@ -418,28 +435,27 @@ defmodule Kernel.Typespec do
   end
 
   @doc false
-  def defspec(type, { :when, _, [{ :::, _, [{ name, meta, args }, return] }, constraints_guard] }, caller) do
+  def defspec(type, { :when, meta2, [{ :::, _, [{ name, meta, args }, return] }, guard] }, caller) do
     if is_atom(args), do: args = []
-    vars = guard_to_vars(constraints_guard)
-    constraints = guard_to_constraints(constraints_guard, vars, caller)
+
+    unless Keyword.keyword?(guard) do
+      guard = Macro.to_string(guard)
+      compile_error caller, "invalid guard in function type specification `#{guard}`"
+    end
+
+    vars = Keyword.keys(guard)
+    constraints = guard_to_constraints(guard, vars, meta2, caller)
+
     spec = { :type, line(meta), :fun, fn_args(meta, args, return, vars, caller) }
     if constraints != [] do
       spec = { :type, line(meta), :bounded_fun, [spec, constraints] }
     end
+
     code = { { name, Kernel.length(args) }, spec }
     Module.compile_typespec(caller.module, type, code)
     code
   end
 
-  def defspec(type, { :when, _, [fun, { :::, _, [guards, return] }] } = spec, caller) do
-    new_spec = { :when, [], [{ :::, [], [fun, return] }, guards] }
-    IO.write "typespec format is deprecated `#{Macro.to_string(spec)}`\n" <>
-      "new format is: `#{Macro.to_string(new_spec)}`\n" <>
-      Exception.format_stacktrace
-
-    defspec(type, new_spec, caller)
-  end
-
   def defspec(type, { :::, _, [{ name, meta, args }, return] }, caller) do
     if is_atom(args), do: args = []
     spec = { :type, line(meta), :fun, fn_args(meta, args, return, [], caller) }
@@ -453,40 +469,48 @@ defmodule Kernel.Typespec do
     compile_error caller, "invalid function type specification `#{spec}`"
   end
 
-  defp guard_to_vars({ :is_subtype, _, [{ name, _, _ }, _] }) do
-    [name]
+  defp guard_to_constraints(guard, vars, meta, caller) do
+    line = line(meta)
+
+    Enum.reduce(guard, [], fn
+      { _name, { :var, _, context } }, acc when is_atom(context) ->
+        acc
+      { name, type }, acc ->
+        constraint = [{ :atom, line, :is_subtype }, [{:var, line, name}, typespec(type, vars, caller)]]
+        type = { :type, line, :constraint, constraint }
+        [type|acc]
+    end) |> Enum.reverse
   end
 
-  defp guard_to_vars({ :is_var, _, [{ name, _, _ }] }) do
-    [name]
+  ## To AST conversion
+
+  defp collect_vars({ :ann_type, _line, args }) do
+    Enum.flat_map(args, &collect_vars/1)
   end
 
-  defp guard_to_vars({ :and, _, [left, right] }) do
-    guard_to_vars(left) ++ guard_to_vars(right)
+  defp collect_vars({ :type, _line, _kind, args }) do
+    Enum.flat_map(args, &collect_vars/1)
   end
 
-  defp guard_to_constraints({ :is_subtype, meta, [{ name, _, context }, type] }, vars, caller)
-      when is_atom(name) and is_atom(context) do
-    line = line(meta)
-    contraints = [{ :atom, line, :is_subtype }, [{:var, line, name}, typespec(type, vars, caller)]]
-    [{ :type, line, :constraint, contraints }]
+  defp collect_vars({ :remote_type, _line, args }) do
+    Enum.flat_map(args, &collect_vars/1)
   end
 
-  defp guard_to_constraints({ :is_var, _, [{ name, _, context }] }, _, _)
-      when is_atom(name) and is_atom(context) do
-    []
+  defp collect_vars({ :typed_record_field, _line, type }) do
+    collect_vars(type)
   end
 
-  defp guard_to_constraints({ :and, _, [left, right] }, vars, caller) do
-    guard_to_constraints(left, vars, caller) ++ guard_to_constraints(right, vars, caller)
+  defp collect_vars({:paren_type, _line, [type]}) do
+    collect_vars(type)
   end
 
-  defp guard_to_constraints(other, _vars, caller) do
-    guard = Macro.to_string(other)
-    compile_error caller, "invalid guard in function type specification `#{guard}`"
+  defp collect_vars({:var, _line, var}) do
+    [erl_to_ex_var(var)]
   end
 
-  ## To AST conversion
+  defp collect_vars(_) do
+    []
+  end
 
   defp typespec_to_ast({ :type, line, :tuple, :any }) do
     typespec_to_ast({:type, line, :tuple, []})
@@ -549,14 +573,7 @@ defmodule Kernel.Typespec do
   end
 
   defp typespec_to_ast({ :var, line, var }) do
-    var =
-      case atom_to_binary(var) do
-        <<"_", c :: [binary, size(1)], rest :: binary>> ->
-          binary_to_atom("_#{String.downcase(c)}#{rest}")
-        <<c :: [binary, size(1)], rest :: binary>> ->
-          binary_to_atom("#{String.downcase(c)}#{rest}")
-      end
-    { var, line, nil }
+    { erl_to_ex_var(var), line, nil }
   end
 
   # Special shortcut(s)
@@ -598,6 +615,15 @@ defmodule Kernel.Typespec do
 
   defp typespec_to_ast(other), do: other
 
+  defp erl_to_ex_var(var) do
+    case atom_to_binary(var) do
+      <<"_", c :: [binary, size(1)], rest :: binary>> ->
+        binary_to_atom("_#{String.downcase(c)}#{rest}")
+      <<c :: [binary, size(1)], rest :: binary>> ->
+        binary_to_atom("#{String.downcase(c)}#{rest}")
+    end
+  end
+
   ## From AST conversion
 
   defp line(meta) do

lib/elixir/lib/list.ex

@@ -48,7 +48,7 @@ defmodule List do
       iex> List.duplicate([1, 2], 2)
       [[1,2],[1,2]]
   """
-  @spec duplicate(elem, non_neg_integer) :: [elem] when is_var(elem)
+  @spec duplicate(elem, non_neg_integer) :: [elem] when elem: var
   def duplicate(elem, n) do
     :lists.duplicate(n, elem)
   end
@@ -62,7 +62,7 @@ defmodule List do
       [1,2,3]
 
   """
-  @spec flatten(deep_list) :: list when is_subtype(deep_list, [any | deep_list])
+  @spec flatten(deep_list) :: list when deep_list: [any | deep_list]
   def flatten(list) do
     :lists.flatten(list)
   end
@@ -78,7 +78,7 @@ defmodule List do
       [1,2,3,4,5]
 
   """
-  @spec flatten(deep_list, [elem]) :: [elem] when is_subtype(deep_list, [elem | deep_list]) and is_var(elem)
+  @spec flatten(deep_list, [elem]) :: [elem] when elem: var, deep_list: [elem | deep_list]
   def flatten(list, tail) do
     :lists.flatten(list, tail)
   end
@@ -96,7 +96,7 @@ defmodule List do
       2
 
   """
-  @spec foldl([elem], acc, (elem, acc -> acc)) :: acc when is_var(elem) and is_var(acc)
+  @spec foldl([elem], acc, (elem, acc -> acc)) :: acc when elem: var, acc: var
   def foldl(list, acc, function) when is_list(list) and is_function(function) do
     :lists.foldl(function, acc, list)
   end
@@ -111,7 +111,7 @@ defmodule List do
       -2
 
   """
-  @spec foldr([elem], acc, (elem, acc -> acc)) :: acc when is_var(elem) and is_var(acc)
+  @spec foldr([elem], acc, (elem, acc -> acc)) :: acc when elem: var, acc: var
   def foldr(list, acc, function) when is_list(list) and is_function(function) do
     :lists.foldr(function, acc, list)
   end
@@ -129,7 +129,7 @@ defmodule List do
       3
 
   """
-  @spec last([elem]) :: nil | elem when is_var(elem)
+  @spec last([elem]) :: nil | elem when elem: var
 
   def last([]), do: nil
 
@@ -399,7 +399,7 @@ defmodule List do
       [1, 2, 3]
 
   """
-  @spec update_at([elem], integer, (elem -> any)) :: list when is_var(elem)
+  @spec update_at([elem], integer, (elem -> any)) :: list when elem: var
   def update_at(list, index, fun) do
     if index < 0 do
       do_update_at(list, length(list) + index, fun)

lib/elixir/test/elixir/typespec_test.exs

@@ -322,13 +322,13 @@ defmodule Typespec.TypeTest do
   test "@spec(spec) with guards" do
     { spec1, spec2, spec3 } = test_module do
       def myfun1(x), do: x
-      spec1 = @spec myfun1(x) :: boolean when is_subtype(x, integer)
+      spec1 = @spec myfun1(x) :: boolean when [x: integer]
 
       def myfun2(x), do: x
-      spec2 = @spec myfun2(x) :: x when is_var(x)
+      spec2 = @spec myfun2(x) :: x when [x: var]
 
       def myfun3(_x, y), do: y
-      spec3 = @spec myfun3(x, y) :: y when is_subtype(y, x) and is_var(x)
+      spec3 = @spec myfun3(x, y) :: y when [y: x, x: var]
 
       { spec1, spec2, spec3 }
     end
@@ -455,7 +455,8 @@ defmodule Typespec.TypeTest do
     specs = [
       (quote do: @spec a() :: integer()),
       (quote do: @spec a(atom()) :: integer()),
-      (quote do: @spec a(b) :: integer() when is_subtype(b, integer())),
+      (quote do: @spec a(b) :: integer() when [b: integer()]),
+      (quote do: @spec a(b) :: b when [b: var])
     ]
 
     compiled = test_module do