Rename function with typo: truthness -> truthiness (elixir-lang#14489)

Author: sabiwara

lib/elixir/lib/module/types/descr.ex

@@ -705,13 +705,13 @@ defmodule Module.Types.Descr do
   ]
 
   @doc """
-  Compute the truthness of an element.
+  Compute the truthiness of an element.
 
   It is either :undefined, :always_true, or :always_false.
   """
-  def truthness(:term), do: :undefined
+  def truthiness(:term), do: :undefined
 
-  def truthness(%{} = descr) do
+  def truthiness(%{} = descr) do
     descr = Map.get(descr, :dynamic, descr)
 
     case descr do

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

@@ -285,7 +285,7 @@ defmodule Module.Types.Expr do
 
         context =
           if is_warning(stack) do
-            case truthness(head_type) do
+            case truthiness(head_type) do
               :always_true when not last? ->
                 warning = {:badcond, "always match", head_type, head, context}
                 warn(__MODULE__, warning, meta, stack, context)

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

@@ -665,21 +665,21 @@ defmodule Module.Types.DescrTest do
       assert fun_fetch(dynamic(), 1) == :ok
     end
 
-    test "truthness" do
+    test "truthiness" do
       for type <- [term(), none(), atom(), boolean(), union(atom([false]), integer())] do
-        assert truthness(type) == :undefined
-        assert truthness(dynamic(type)) == :undefined
+        assert truthiness(type) == :undefined
+        assert truthiness(dynamic(type)) == :undefined
       end
 
       for type <- [atom([false]), atom([nil]), atom([nil, false]), atom([false, nil])] do
-        assert truthness(type) == :always_false
-        assert truthness(dynamic(type)) == :always_false
+        assert truthiness(type) == :always_false
+        assert truthiness(dynamic(type)) == :always_false
       end
 
       for type <-
             [negation(atom()), atom([true]), negation(atom([false, nil])), atom([:ok]), integer()] do
-        assert truthness(type) == :always_true
-        assert truthness(dynamic(type)) == :always_true
+        assert truthiness(type) == :always_true
+        assert truthiness(dynamic(type)) == :always_true
       end
     end