Fix regression on default inference, closes #15359

Author: josevalim

lib/elixir/lib/module/types.ex

@@ -360,20 +360,21 @@ defmodule Module.Types do
         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} ->
+      {_, _, mapping, inferred} =
+        Enum.reduce(arrows, {0, 0, [], []}, fn
+          {clause_domain, return_type}, {index, total, 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, [])
+            {type_index, inferred} =
+              add_inferred(inferred, clause_types, return_type, total - 1, [])
 
-            {index + 1, [{0, index} | mapping], inferred}
+            total = if type_index == -1, do: total + 1, else: total
+            {index + 1, total, [{0, index} | mapping], inferred}
         end)
 
       domain =

lib/elixir/pages/references/gradual-set-theoretic-types.md

@@ -235,7 +235,7 @@ On the other hand, type inference offers the benefit of enabling type checking f
 
 Type inference in Elixir is best-effort: it doesn't guarantee it will find all possible type incompatibilities, only that it may find bugs where all combinations of a type _will_ fail, even in the absence of explicit type annotations. It is meant to be an efficient routine that brings developers some benefits of static typing, without requiring any effort from them and keeping the expressiveness of the language.
 
-In the long term, Elixir developers who want static typing guarantees must explicitly add type signatures to their functions (see "Roadmap"). Any function with an explicit type signature will be typed checked against the user-provided annotations, as in other statically typed languages. 
+In the long term, Elixir developers who want static typing guarantees must explicitly add type signatures to their functions (see "Roadmap"). Any function with an explicit type signature will be typed checked against the user-provided annotations, as in other statically typed languages.
 
 ### False positives during inference
 

lib/elixir/test/elixir/module/types/infer_test.exs

@@ -283,4 +283,33 @@ defmodule Module.Types.InferTest do
              {[atom([:error])], dynamic(tuple([atom([:error]), term()]))}
            ]
   end
+
+  test "from defaults (regression with multiple clauses)", config do
+    types =
+      infer config do
+        def entries(tree_node, opts \\ [keep_text: true])
+
+        def entries({_, _, subentries}, keep_text: false) do
+          Enum.filter(subentries, &is_tuple/1)
+        end
+
+        def entries({_, _, subentries}, keep_text: _) do
+          subentries
+        end
+
+        def entries({_, _, _} = tree_node, opts) do
+          opts = Keyword.validate!(opts, keep_text: true)
+          entries(tree_node, keep_text: opts[:keep_text])
+        end
+
+        def entries(_tree_node, _opts), do: nil
+      end
+
+    {:infer, _, signature} = types[{:entries, 1}]
+
+    assert signature == [
+             {[tuple([term(), term(), term()])], dynamic()},
+             {[negation(tuple([term(), term(), term()]))], atom([nil])}
+           ]
+  end
 end