Keep warnings when traversing clauses

Author: josevalim

lib/elixir/lib/module/types/expr.ex

@@ -203,7 +203,7 @@ defmodule Module.Types.Expr do
     stack = push_expr_stack(expr, stack)
 
     with {:ok, _expr_type, context} <- of_expr(case_expr, stack, context),
-         :ok <- of_clauses(clauses, stack, context),
+         {:ok, context} <- of_clauses(clauses, stack, context),
          do: {:ok, :dynamic, context}
   end
 
@@ -212,7 +212,7 @@ defmodule Module.Types.Expr do
     stack = push_expr_stack(expr, stack)
 
     case of_clauses(clauses, stack, context) do
-      :ok -> {:ok, :dynamic, context}
+      {:ok, context} -> {:ok, :dynamic, context}
       {:error, reason} -> {:error, reason}
     end
   end
@@ -224,23 +224,31 @@ defmodule Module.Types.Expr do
   def of_expr({:try, _meta, [blocks]} = expr, stack, context) do
     stack = push_expr_stack(expr, stack)
 
-    result =
-      each_ok(blocks, fn
-        {:rescue, clauses} ->
-          each_ok(clauses, fn
-            {:->, _, [[{:in, _, [var, _exceptions]}], body]} ->
+    {result, context} =
+      reduce_ok(blocks, context, fn
+        {:rescue, clauses}, context ->
+          reduce_ok(clauses, context, fn
+            {:->, _, [[{:in, _, [var, _exceptions]}], body]}, context = acc ->
               {_type, context} = new_pattern_var(var, context)
-              of_expr_ok(body, stack, context)
 
-            {:->, _, [[var], body]} ->
+              with {:ok, context} <- of_expr_context(body, stack, context) do
+                {:ok, keep_warnings(acc, context)}
+              end
+
+            {:->, _, [[var], body]}, context = acc ->
               {_type, context} = new_pattern_var(var, context)
-              of_expr_ok(body, stack, context)
+
+              with {:ok, context} <- of_expr_context(body, stack, context) do
+                {:ok, keep_warnings(acc, context)}
+              end
           end)
 
-        {block, body} when block in @try_blocks ->
-          of_expr_ok(body, stack, context)
+        {block, body}, context = acc when block in @try_blocks ->
+          with {:ok, context} <- of_expr_context(body, stack, context) do
+            {:ok, keep_warnings(acc, context)}
+          end
 
-        {block, clauses} when block in @try_clause_blocks ->
+        {block, clauses}, context when block in @try_clause_blocks ->
           of_clauses(clauses, stack, context)
       end)
 
@@ -254,18 +262,18 @@ defmodule Module.Types.Expr do
   def of_expr({:receive, _meta, [blocks]} = expr, stack, context) do
     stack = push_expr_stack(expr, stack)
 
-    result =
-      each_ok(blocks, fn
-        {:do, {:__block__, _, []}} ->
-          :ok
+    {result, context} =
+      reduce_ok(blocks, context, fn
+        {:do, {:__block__, _, []}}, context ->
+          {:ok, context}
 
-        {:do, clauses} ->
+        {:do, clauses}, context ->
           of_clauses(clauses, stack, context)
 
-        {:after, [{:->, _meta, [head, body]}]} ->
+        {:after, [{:->, _meta, [head, body]}]}, context = acc ->
           with {:ok, _type, context} <- of_expr(head, stack, context),
-               {:ok, _type, _context} <- of_expr(body, stack, context),
-               do: :ok
+               {:ok, _type, context} <- of_expr(body, stack, context),
+               do: {:ok, keep_warnings(acc, context)}
       end)
 
     case result do
@@ -282,7 +290,7 @@ defmodule Module.Types.Expr do
     with {:ok, context} <- reduce_ok(clauses, context, &for_clause(&1, stack, &2)),
          {:ok, context} <- reduce_ok(opts, context, &for_option(&1, stack, &2)) do
       if opts[:reduce] do
-        with :ok <- of_clauses(block, stack, context) do
+        with {:ok, context} <- of_clauses(block, stack, context) do
           {:ok, :dynamic, context}
         end
       else
@@ -437,22 +445,23 @@ defmodule Module.Types.Expr do
   end
 
   defp with_option({:else, clauses}, stack, context) do
-    case of_clauses(clauses, stack, context) do
-      :ok -> {:ok, context}
-      {:error, reason} -> {:error, reason}
-    end
+    of_clauses(clauses, stack, context)
   end
 
   defp of_clauses(clauses, stack, context) do
-    each_ok(clauses, fn {:->, _meta, [head, body]} ->
+    reduce_ok(clauses, context, fn {:->, _meta, [head, body]}, context = acc ->
       {patterns, guards} = extract_head(head)
 
       with {:ok, _, context} <- Pattern.of_head(patterns, guards, stack, context),
-           {:ok, _expr_type, _context} <- of_expr(body, stack, context),
-           do: :ok
+           {:ok, _expr_type, context} <- of_expr(body, stack, context),
+           do: {:ok, keep_warnings(acc, context)}
     end)
   end
 
+  defp keep_warnings(context, %{warnings: warnings}) do
+    %{context | warnings: warnings}
+  end
+
   defp extract_head([{:when, _meta, args}]) do
     case Enum.split(args, -1) do
       {patterns, [guards]} -> {patterns, flatten_when(guards)}
@@ -479,13 +488,6 @@ defmodule Module.Types.Expr do
     end
   end
 
-  defp of_expr_ok(expr, stack, context) do
-    case of_expr(expr, stack, context) do
-      {:ok, _type, _context} -> :ok
-      {:error, reason} -> {:error, reason}
-    end
-  end
-
   defp new_pattern_var({:_, _meta, var_context}, context) when is_atom(var_context) do
     {:dynamic, context}
   end

lib/elixir/lib/module/types/helpers.ex

@@ -81,19 +81,6 @@ defmodule Module.Types.Helpers do
 
   defp do_map_ok([], acc, _fun), do: {:ok, Enum.reverse(acc)}
 
-  @doc """
-  Like `Enum.each/2` but only continues while `fun` returns `:ok`
-  and stops on `{:error, reason}`.
-  """
-  def each_ok([head | tail], fun) do
-    case fun.(head) do
-      :ok -> each_ok(tail, fun)
-      {:error, reason} -> {:error, reason}
-    end
-  end
-
-  def each_ok([], _fun), do: :ok
-
   @doc """
   Like `Enum.map_reduce/3` but only continues while `fun` returns `{:ok, elem, acc}`
   and stops on `{:error, reason}`.

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

@@ -23,7 +23,10 @@ defmodule Module.Types.TypesTest do
     with {:ok, _types, context} <-
            Pattern.of_head(patterns, guards, TypeHelper.new_stack(), TypeHelper.new_context()),
          {:ok, type, context} <- Expr.of_expr(body, TypeHelper.new_stack(), context) do
-      flunk("expexted error, got: #{inspect(Types.lift_type(type, context))}")
+      case context.warnings do
+        [warning] -> {:warning, warning}
+        _ -> flunk("expexted error, got: #{inspect(Types.lift_type(type, context))}")
+      end
     else
       {:error, {type, reason, context}} ->
         {:error, {type, reason, context}}
@@ -48,12 +51,18 @@ defmodule Module.Types.TypesTest do
     min
   end
 
+  defp to_warning({:warning, {module, warning, _location}}) do
+    warning
+    |> module.format_warning()
+    |> IO.iodata_to_binary()
+  end
+
   defp to_warning({:error, {type, reason, context}}) do
     {Module.Types, error, _location} = Module.Types.error_to_warning(type, reason, context)
 
     error
     |> Module.Types.format_warning()
-    |> List.to_string()
+    |> IO.iodata_to_binary()
     |> String.trim_trailing("\nConflict found at")
   end
 
@@ -69,6 +78,17 @@ defmodule Module.Types.TypesTest do
     assert Types.expr_to_string(quote(do: :erlang.element(:erlang.+(a, 1), b))) == "elem(b, a)"
   end
 
+  test "undefined function warnings" do
+    assert warning([], URI.unknown("foo")) ==
+             "URI.unknown/1 is undefined or private"
+
+    assert warning([], if(true, do: URI.unknown("foo"))) ==
+             "URI.unknown/1 is undefined or private"
+
+    assert warning([], try(do: :ok, after: URI.unknown("foo"))) ==
+             "URI.unknown/1 is undefined or private"
+  end
+
   describe "function head warnings" do
     test "warns on literals" do
       string = warning([var = 123, var = "abc"], var)