Infer precise types for default arguments

Author: josevalim

lib/elixir/lib/module/types.ex

@@ -4,7 +4,7 @@
 
 defmodule Module.Types do
   @moduledoc false
-  alias Module.Types.{Descr, Expr, Pattern, Helpers}
+  alias Module.Types.{Apply, Descr, Expr, Helpers, Pattern}
 
   # The mode controls what happens on function application when
   # there are gradual arguments. Non-gradual arguments always
@@ -251,17 +251,27 @@ defmodule Module.Types do
       context ->
         {_kind, info, mapping} = Map.fetch!(context.local_sigs, fun_arity)
 
-        clauses_indexes =
-          for type_index <- pending,
-              not skip_unused_clause?(info, type_index),
-              {clause_index, ^type_index} <- mapping,
-              do: clause_index
+        if pending != [] do
+          {used_indexes, unused_indexes} =
+            Enum.reduce(mapping, {[], []}, fn {clause_index, type_index},
+                                              {used_indexes, unused_indexes} ->
+              if type_index in pending and not skip_unused_clause?(info, type_index) do
+                {used_indexes, [clause_index | unused_indexes]}
+              else
+                {[clause_index | used_indexes], unused_indexes}
+              end
+            end)
 
-        Enum.reduce(clauses_indexes, context, fn clause_index, context ->
-          {meta, _args, _guards, _body} = Enum.fetch!(clauses, clause_index)
-          stack = %{stack | function: fun_arity}
-          Helpers.warn(__MODULE__, {:unused_clause, kind, fun_arity}, meta, stack, context)
-        end)
+          unused_indexes = Enum.uniq(unused_indexes) -- used_indexes
+
+          Enum.reduce(unused_indexes, context, fn clause_index, context ->
+            {meta, _args, _guards, _body} = Enum.fetch!(clauses, clause_index)
+            stack = %{stack | function: fun_arity}
+            Helpers.warn(__MODULE__, {:unused_clause, kind, fun_arity}, meta, stack, context)
+          end)
+        else
+          context
+        end
     end
   end
 
@@ -321,6 +331,70 @@ defmodule Module.Types do
     stack = stack |> fresh_stack(mode, fun_arity) |> with_file_meta(meta)
     base_info = {:def, kind, fun, expected}
 
+    case clauses do
+      [{meta, args, [], {:super, _, [_ | _]} = body}] ->
+        default_local_handler(meta, args, body, base_info, kind, fun, expected, stack, context)
+
+      _ ->
+        infer_local_handler(clauses, base_info, kind, fun, expected, stack, context)
+    end
+  end
+
+  defp default_local_handler(meta, args, body, base_info, kind, fun, expected, stack, context) do
+    guards = []
+    previous = Pattern.init_previous()
+    fresh_context = fresh_context(context)
+    info = {base_info, args, guards}
+
+    try do
+      {trees, _, _, _, head_context} =
+        Pattern.of_head(args, guards, expected, previous, info, meta, stack, fresh_context)
+
+      # Compute the intersected arrows from the function call
+      {:super, meta, call_args} = body
+      {_kind, call_fun} = Keyword.fetch!(meta, :super)
+      term = Descr.term()
+      of_fun = &Expr.of_expr/5
+
+      {arrows, body_context} =
+        Apply.local_arrows(call_fun, call_args, term, body, stack, head_context, of_fun)
+
+      # For each arrow, compute the default arrow
+      {_, mapping, inferred} =
+        Enum.reduce(arrows, {0, [], []}, fn
+          {clause_domain, return_type}, {index, mapping, inferred} ->
+            of_fun = &Expr.of_expr(&1, &2, body, stack, &3)
+
+            {_clause_args, clause_context} =
+              Helpers.zip_map_reduce(call_args, clause_domain, head_context, of_fun)
+
+            clause_types = Pattern.of_domain(trees, stack, clause_context)
+
+            {_type_index, inferred} =
+              add_inferred(inferred, clause_types, return_type, index - 1, [])
+
+            {index + 1, [{0, index} | mapping], inferred}
+        end)
+
+      domain =
+        case inferred do
+          [_] ->
+            nil
+
+          _ ->
+            inferred
+            |> Enum.map(fn {args, _} -> args end)
+            |> Enum.zip_with(fn types -> Enum.reduce(types, &Descr.union/2) end)
+        end
+
+      {{:infer, domain, Enum.reverse(inferred)}, mapping, restore_context(body_context, context)}
+    rescue
+      e ->
+        internal_error!(e, __STACKTRACE__, kind, meta, fun, args, guards, body, stack)
+    end
+  end
+
+  defp infer_local_handler(clauses, base_info, kind, fun, expected, stack, context) do
     {_, _, _, domain, mapping, clauses_types, clauses_context} =
       Enum.reduce(clauses, {0, 0, Pattern.init_previous(), [], [], [], context}, fn
         {meta, args, guards, body},

lib/elixir/lib/module/types/apply.ex

@@ -1375,41 +1375,70 @@ defmodule Module.Types.Apply do
   ## Local
 
   def local(fun, args, expected, {_, meta, _} = expr, stack, context, of_fun) do
-    {local_info, domain, context} = local_domain(fun, args, expected, meta, stack, context)
+    {updated_used?, info, domain, context} =
+      local_domain(fun, args, expected, meta, stack, context)
 
     {args_types, context} =
       zip_map_reduce(args, domain, context, &of_fun.(&1, &2, expr, stack, &3))
 
-    local_apply(local_info, fun, args_types, expr, stack, context)
+    case local_apply(updated_used?, info, fun, args_types, expr, stack, context) do
+      {_indexes, type, context} -> {type, context}
+      {type, context} -> {type, context}
+    end
   end
 
+  def local_arrows(fun, args, expected, {_, meta, _} = expr, stack, context, of_fun) do
+    {updated_used?, info, domain, context} =
+      local_domain(fun, args, expected, meta, stack, context)
+
+    {args_types, context} =
+      zip_map_reduce(args, domain, context, &of_fun.(&1, &2, expr, stack, &3))
+
+    case local_apply(updated_used?, info, fun, args_types, expr, stack, context) do
+      {indexes, _type, context} -> {indexes_to_arrows(indexes, info), context}
+      {type, context} -> {[{Enum.map(args, fn _ -> type end), type}], context}
+    end
+  end
+
+  defp indexes_to_arrows(indexes, {_, _domain, clauses}),
+    do: indexes_to_arrows(Enum.reverse(indexes), clauses, 0)
+
+  defp indexes_to_arrows([index | indexes], [clause | clauses], index),
+    do: [clause | indexes_to_arrows(indexes, clauses, index + 1)]
+
+  defp indexes_to_arrows([_ | _] = indexes, [_clause | clauses], index),
+    do: indexes_to_arrows(indexes, clauses, index + 1)
+
+  defp indexes_to_arrows([], _clauses, _index),
+    do: []
+
   defp local_domain(fun, args, expected, meta, stack, context) do
     arity = length(args)
 
     case stack.local_handler.(meta, {fun, arity}, stack, context) do
       false ->
-        {{false, :none}, List.duplicate(term(), arity), context}
+        {false, :none, List.duplicate(term(), arity), context}
 
       {kind, info, context} ->
         update_used? = is_warning(stack) and kind == :defp
 
         if info == :none do
-          {{update_used?, :none}, List.duplicate(term(), arity), context}
+          {update_used?, :none, List.duplicate(term(), arity), context}
         else
-          {{update_used?, info}, filter_domain(info, expected, arity), context}
+          {update_used?, info, filter_domain(info, expected, arity), context}
         end
     end
   end
 
-  defp local_apply({update_used?, :none}, fun, args_types, _expr, _stack, context) do
+  defp local_apply(update_used?, :none, fun, args_types, _expr, _stack, context) do
     if update_used? do
       {dynamic(), put_in(context.local_used[{fun, length(args_types)}], [])}
     else
       {dynamic(), context}
     end
   end
 
-  defp local_apply({update_used?, info}, fun, args_types, expr, stack, context) do
+  defp local_apply(update_used?, info, fun, args_types, expr, stack, context) do
     case local_apply(info, args_types, stack) do
       {indexes, type} ->
         context =
@@ -1421,7 +1450,7 @@ defmodule Module.Types.Apply do
             context
           end
 
-        {type, context}
+        {indexes, type, context}
 
       :error ->
         error = {:badlocal, info, args_types, expr, context}