Update typespecs and enforce with and limit in Inspect.Algebra (#10205)

Author: eksperimental

lib/elixir/lib/inspect/algebra.ex

@@ -31,30 +31,32 @@ defmodule Inspect.Opts do
       options. Useful when implementing the `Inspect` protocol for nested structs
       to pass the custom options through.
 
-    * `:inspect_fun` (since v1.9.0) - a function to build algebra documents,
-      defaults to `Inspect.inspect/2`.
+    * `:inspect_fun` (since v1.9.0) - a function to build algebra documents.
+      Defaults to `Inspect.inspect/2`.
 
     * `:limit` - limits the number of items that are inspected for tuples,
-      bitstrings, maps, lists and any other collection of items. It does not
-      apply to printable strings nor printable charlists and defaults to 50.
+      bitstrings, maps, lists and any other collection of items, with the exception of
+      printable strings and printable charlists which use the `:printable_limit` option.
       If you don't want to limit the number of items to a particular number,
-      use `:infinity`.
+      use `:infinity`. It accepts a positive integer or `:infinity`.
+      Defaults to `50`.
 
-    * `:pretty` - if set to `true` enables pretty printing, defaults to `false`.
+    * `:pretty` - if set to `true` enables pretty printing. Defaults to `false`.
 
     * `:printable_limit` - limits the number of characters that are inspected
       on printable strings and printable charlists. You can use `String.printable?/1`
       and `List.ascii_printable?/1` to check if a given string or charlist is
-      printable. Defaults to 4096. If you don't want to limit the number of
-      characters to a particular number, use `:infinity`.
+      printable. If you don't want to limit the number of characters to a particular
+      number, use `:infinity`. It accepts a positive integer or `:infinity`.
+      Defaults to `4096`.
 
     * `:safe` - when `false`, failures while inspecting structs will be raised
       as errors instead of being wrapped in the `Inspect.Error` exception. This
       is useful when debugging failures and crashes for custom inspect
       implementations.
 
     * `:structs` - when `false`, structs are not formatted by the inspect
-      protocol, they are instead printed as maps, defaults to `true`.
+      protocol, they are instead printed as maps. Defaults to `true`.
 
     * `:syntax_colors` - when set to a keyword list of colors the output is
       colorized. The keys are types and the values are the colors to use for
@@ -63,10 +65,10 @@ defmodule Inspect.Opts do
       `:string`, and `:tuple`. Custom data types may provide their own options.
       Colors can be any `t:IO.ANSI.ansidata/0` as accepted by `IO.ANSI.format/1`.
 
-    * `:width` - defaults to 80 characters, used when pretty is `true` or when
-      printing to IO devices. Set to 0 to force each item to be printed on its
+    * `:width` - number of characters per line used when pretty is `true` or when
+      printing to IO devices. Set to `0` to force each item to be printed on its
       own line. If you don't want to limit the number of items to a particular
-      number, use `:infinity`.
+      number, use `:infinity`. Defaults to `80`.
 
   """
 
@@ -95,13 +97,13 @@ defmodule Inspect.Opts do
           charlists: :infer | :as_lists | :as_charlists,
           custom_options: keyword,
           inspect_fun: (any, t -> Inspect.Algebra.t()),
-          limit: pos_integer | :infinity,
+          limit: non_neg_integer | :infinity,
           pretty: boolean,
-          printable_limit: pos_integer | :infinity,
+          printable_limit: non_neg_integer | :infinity,
           safe: boolean,
           structs: boolean,
           syntax_colors: [{color_key, IO.ANSI.ansidata()}],
-          width: pos_integer | :infinity
+          width: non_neg_integer | :infinity
         }
 end
 
@@ -266,6 +268,9 @@ defmodule Inspect.Algebra do
            when is_binary(doc) or doc in [:doc_nil, :doc_line] or
                   (is_tuple(doc) and elem(doc, 0) in @docs)
 
+  defguardp is_limit(limit) when limit == :infinity or (is_integer(limit) and limit >= 0)
+  defguardp is_width(limit) when limit == :infinity or (is_integer(limit) and limit >= 0)
+
   # Elixir + Inspect.Opts conveniences
 
   @doc """
@@ -397,13 +402,14 @@ defmodule Inspect.Algebra do
     {:lists.reverse(["..." | acc]), simple?}
   end
 
-  defp container_each([term | terms], limit, opts, fun, acc, simple?) when is_list(terms) do
+  defp container_each([term | terms], limit, opts, fun, acc, simple?)
+       when is_list(terms) and is_limit(limit) do
     limit = decrement(limit)
     doc = fun.(term, %{opts | limit: limit})
     container_each(terms, limit, opts, fun, [doc | acc], simple? and simple?(doc))
   end
 
-  defp container_each([left | right], limit, opts, fun, acc, simple?) do
+  defp container_each([left | right], limit, opts, fun, acc, simple?) when is_limit(limit) do
     limit = decrement(limit)
     left = fun.(left, %{opts | limit: limit})
     right = fun.(right, %{opts | limit: limit})
@@ -884,7 +890,7 @@ defmodule Inspect.Algebra do
 
   """
   @spec format(t, non_neg_integer | :infinity) :: iodata
-  def format(doc, width) when is_doc(doc) and (width == :infinity or width >= 0) do
+  def format(doc, width) when is_doc(doc) and is_width(width) do
     format(width, 0, [{0, :flat, doc}])
   end
 
@@ -900,7 +906,12 @@ defmodule Inspect.Algebra do
   #
   @typep mode :: :flat | :flat_no_break | :break | :break_no_flat
 
-  @spec fits?(width :: integer(), column :: integer(), break? :: boolean(), entries) :: boolean()
+  @spec fits?(
+          width :: non_neg_integer(),
+          column :: non_neg_integer(),
+          break? :: boolean(),
+          entries
+        ) :: boolean()
         when entries:
                maybe_improper_list({integer(), mode(), t()}, {:tail, boolean(), entries} | [])
 
@@ -961,7 +972,9 @@ defmodule Inspect.Algebra do
   defp fits?(w, k, b?, [{i, m, doc_group(x, _)} | t]),
     do: fits?(w, k, b?, [{i, m, x} | {:tail, b?, t}])
 
-  @spec format(integer | :infinity, integer, [{integer, mode, t}]) :: [binary]
+  @spec format(width :: non_neg_integer() | :infinity, column :: non_neg_integer(), [
+          {integer, mode, t}
+        ]) :: [binary]
   defp format(_, _, []), do: []
   defp format(w, k, [{_, _, :doc_nil} | t]), do: format(w, k, t)
   defp format(w, _, [{i, _, :doc_line} | t]), do: [indent(i) | format(w, i, t)]

lib/logger/lib/logger/utils.ex

@@ -162,9 +162,11 @@ defmodule Logger.Utils do
   defp inspect_width(_, width), do: width
 
   defp inspect_data([data | _], opts) do
+    width = if opts.width == :none, do: 80, else: opts.width
+
     data
     |> Inspect.Algebra.to_doc(opts)
-    |> Inspect.Algebra.format(opts.width)
+    |> Inspect.Algebra.format(width)
   end
 
   @doc """