Fix warnings

Author: josevalim

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

@@ -241,9 +241,9 @@ In the long term, Elixir developers who want static typing guarantees must expli
 
 Our goal with type inference is to avoid false positives: we will only emit typing violations if the code always fails. However, in some situations, Elixir may, on purpose, define a more strict type during inference, as to encourage certain idioms or to help spot bugs. Those cases are documented below.
 
-* Struct update syntax: when using the struct update syntax, `%User{user | name: "John Doe"}`, `user` must be guaranteed statically to be always be a `User` struct
+  * Struct update syntax: when using the struct update syntax, `%User{user | name: "John Doe"}`, `user` must be guaranteed statically to be always be a `User` struct
 
-* Single-clause anonymous functions: Elixir always considers the code inside anonynous functions to be executed. For example, in the snippet below
+  * Single-clause anonymous functions: Elixir always considers the code inside anonynous functions to be executed. For example, in the snippet below, even though the code will only fail at runtime if the anonymous function is later executed, Elixir will treat it as if the function is always executed. If the function has multiple clauses, then Elixir doesn't know which clause will be executed, and makes no assumption.
 
     ```elixir
     def example(x) do
@@ -252,8 +252,6 @@ Our goal with type inference is to avoid false positives: we will only emit typi
     end
     ```
 
-  even though the code will only fail at runtime if the anonymous function is executed, Elixir will treat it as if the function is always executed. If the function has multiple clauses, then Elixir doesn't know which clause will be executed, and makes no assumption.
-
 ## Roadmap
 
 At this moment, Elixir implements type inference of all language constructs. The goal is to assess performance and collect feedback on the quality of error messages, before introducing user facing types.

lib/elixir/src/elixir_fn.erl

@@ -155,7 +155,7 @@ escape({'&', Meta, [Pos]}, E, Dict) when is_integer(Pos), Pos > 0 ->
       {Var, Dict};
     error ->
       Next = elixir_module:next_counter(?key(E, module)),
-      Var = {capture, [{counter, Next}, {capture, Pos} | Meta], nil},
+      Var = {'_&', [{counter, Next}, {capture, Pos} | Meta], ?MODULE},
       {Var, orddict:store(Pos, Var, Dict)}
   end;
 escape({'&', Meta, [Pos]}, E, _Dict) when is_integer(Pos) ->

lib/elixir/test/elixir/kernel/expansion_test.exs

@@ -1217,8 +1217,8 @@ defmodule Kernel.ExpansionTest do
                 [
                   {:->, [line: 1],
                    [
-                     [{:capture, [capture: 1, line: 1], nil}],
-                     {:capture, [capture: 1, line: 1], nil}
+                     [{:"_&", [capture: 1, line: 1], :elixir_fn}],
+                     {:"_&", [capture: 1, line: 1], :elixir_fn}
                    ]}
                 ]}
     end

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

@@ -1318,12 +1318,6 @@ defmodule Module.Types.ExprTest do
 
                  dynamic()
 
-             where "capture" was given the type:
-
-                 # type: dynamic()
-                 # from: types_test.ex:LINE
-                 &1
-
              instead of using &1, you must define an anonymous function, define a variable and pattern match on "%Date{}"
              """
 

lib/ex_unit/test/ex_unit/formatter_test.exs

@@ -593,13 +593,16 @@ defmodule ExUnit.FormatterTest do
   end
 
   test "inspect failure" do
-    failure = [{:error, catch_assertion(assert :will_fail == struct!(BadInspect)), []}]
+    failure = [
+      {:error, catch_assertion(assert Process.get(:unused, :will_fail) == struct!(BadInspect)),
+       []}
+    ]
 
     assert format_test_failure(test(), failure, 1, 80, &formatter/2) =~ ~s'''
              1) world (Hello)
                 test/ex_unit/formatter_test.exs:1
                 Assertion with == failed
-                code:  assert :will_fail == struct!(BadInspect)
+                code:  assert Process.get(:unused, :will_fail) == struct!(BadInspect)
                 left:  :will_fail
                 right: #Inspect.Error<
              got FunctionClauseError with message: