Fixes

Author: josevalim

lib/elixir/lib/enum.ex

@@ -5001,3 +5001,69 @@ defimpl Enumerable, for: Function do
       description: "only anonymous functions of arity 2 are enumerable"
   end
 end
+
+defimpl Enumerable, for: Range do
+  def reduce(first..last//step, acc, fun) do
+    reduce(first, last, acc, fun, step)
+  end
+
+  # TODO: Remove me on v2.0
+  def reduce(%{__struct__: Range, first: first, last: last} = range, acc, fun) do
+    step = if first <= last, do: 1, else: -1
+    reduce(Map.put(range, :step, step), acc, fun)
+  end
+
+  defp reduce(_first, _last, {:halt, acc}, _fun, _step) do
+    {:halted, acc}
+  end
+
+  defp reduce(first, last, {:suspend, acc}, fun, step) do
+    {:suspended, acc, &reduce(first, last, &1, fun, step)}
+  end
+
+  defp reduce(first, last, {:cont, acc}, fun, step)
+       when step > 0 and first <= last
+       when step < 0 and first >= last do
+    reduce(first + step, last, fun.(first, acc), fun, step)
+  end
+
+  defp reduce(_, _, {:cont, acc}, _fun, _up) do
+    {:done, acc}
+  end
+
+  def member?(first..last//step, value) when is_integer(value) do
+    if step > 0 do
+      {:ok, first <= value and value <= last and rem(value - first, step) == 0}
+    else
+      {:ok, last <= value and value <= first and rem(value - first, step) == 0}
+    end
+  end
+
+  # TODO: Remove me on v2.0
+  def member?(%{__struct__: Range, first: first, last: last} = range, value)
+      when is_integer(value) do
+    step = if first <= last, do: 1, else: -1
+    member?(Map.put(range, :step, step), value)
+  end
+
+  def member?(_, _value) do
+    {:ok, false}
+  end
+
+  def count(range) do
+    {:ok, Range.size(range)}
+  end
+
+  def slice(first.._//step = range) do
+    {:ok, Range.size(range), &slice(first + &1 * step, step + &3 - 1, &2)}
+  end
+
+  # TODO: Remove me on v2.0
+  def slice(%{__struct__: Range, first: first, last: last} = range) do
+    step = if first <= last, do: 1, else: -1
+    slice(Map.put(range, :step, step))
+  end
+
+  defp slice(_current, _step, 0), do: []
+  defp slice(current, step, remaining), do: [current | slice(current + step, step, remaining - 1)]
+end

lib/elixir/lib/inspect.ex

@@ -200,7 +200,13 @@ defprotocol Inspect do
                 do: var!(info)
 
           var!(name) = Macro.inspect_atom(:literal, unquote(module))
-          unquote(inspect_module).inspect(var!(struct), var!(name), var!(infos), var!(opts))
+
+          unquote(inspect_module).inspect_as_struct(
+            var!(struct),
+            var!(name),
+            var!(infos),
+            var!(opts)
+          )
         end
       end
     end
@@ -390,6 +396,10 @@ end
 
 defimpl Inspect, for: Map do
   def inspect(map, opts) do
+    inspect_as_map(map, opts)
+  end
+
+  def inspect_as_map(map, opts) do
     list =
       if Keyword.get(opts.custom_options, :sort_maps) do
         map |> Map.to_list() |> :lists.sort()
@@ -408,7 +418,7 @@ defimpl Inspect, for: Map do
     map_container_doc(list, "", opts, fun)
   end
 
-  def inspect(map, name, infos, opts) do
+  def inspect_as_struct(map, name, infos, opts) do
     fun = fn %{field: field}, opts -> Inspect.List.keyword({field, Map.get(map, field)}, opts) end
     map_container_doc(infos, name, opts, fun)
   end
@@ -599,25 +609,36 @@ end
 defimpl Inspect, for: Any do
   def inspect(%module{} = struct, opts) do
     try do
-      {module.__struct__(), module.__info__(:struct)}
+      module.__info__(:struct)
     rescue
-      _ -> Inspect.Map.inspect(struct, opts)
+      _ -> Inspect.Map.inspect_as_map(struct, opts)
     else
-      {dunder, fields} ->
-        if Map.keys(dunder) == Map.keys(struct) do
-          infos =
-            for %{field: field} = info <- fields,
-                field not in [:__struct__, :__exception__],
-                do: info
-
-          Inspect.Map.inspect(struct, Macro.inspect_atom(:literal, module), infos, opts)
+      info ->
+        if valid_struct?(info, struct) do
+          info =
+            for %{field: field} = map <- info,
+                field != :__exception__,
+                do: map
+
+          Inspect.Map.inspect_as_struct(struct, Macro.inspect_atom(:literal, module), info, opts)
         else
-          Inspect.Map.inspect(struct, opts)
+          Inspect.Map.inspect_as_map(struct, opts)
         end
     end
   end
 
-  def inspect(map, name, infos, opts) do
+  defp valid_struct?(info, struct), do: valid_struct?(info, struct, map_size(struct) - 1)
+
+  defp valid_struct?([%{field: field} | info], struct, count) when is_map_key(struct, field),
+    do: valid_struct?(info, struct, count - 1)
+
+  defp valid_struct?([], _struct, 0),
+    do: true
+
+  defp valid_struct?(_fields, _struct, _count),
+    do: false
+
+  def inspect_as_struct(map, name, infos, opts) do
     open = color_doc("#" <> name <> "<", :map, opts)
     sep = color_doc(",", :map, opts)
     close = color_doc(">", :map, opts)
@@ -631,6 +652,25 @@ defimpl Inspect, for: Any do
   end
 end
 
+defimpl Inspect, for: Range do
+  import Inspect.Algebra
+  import Kernel, except: [inspect: 2]
+
+  def inspect(first..last//1, opts) when last >= first do
+    concat([to_doc(first, opts), "..", to_doc(last, opts)])
+  end
+
+  def inspect(first..last//step, opts) do
+    concat([to_doc(first, opts), "..", to_doc(last, opts), "//", to_doc(step, opts)])
+  end
+
+  # TODO: Remove me on v2.0
+  def inspect(%{__struct__: Range, first: first, last: last} = range, opts) do
+    step = if first <= last, do: 1, else: -1
+    inspect(Map.put(range, :step, step), opts)
+  end
+end
+
 require Protocol
 
 Protocol.derive(

lib/elixir/lib/inspect/algebra.ex

@@ -355,14 +355,14 @@ defmodule Inspect.Algebra do
           # we won't try to render any failed instruct when building
           # the error message.
           if Process.get(:inspect_trap) do
-            Inspect.Map.inspect(struct, opts)
+            Inspect.Map.inspect_as_map(struct, opts)
           else
             try do
               Process.put(:inspect_trap, true)
 
               inspected_struct =
                 struct
-                |> Inspect.Map.inspect(%{
+                |> Inspect.Map.inspect_as_map(%{
                   opts
                   | syntax_colors: [],
                     inspect_fun: Inspect.Opts.default_inspect_fun()
@@ -389,7 +389,7 @@ defmodule Inspect.Algebra do
           end
       end
     else
-      Inspect.Map.inspect(struct, opts)
+      Inspect.Map.inspect_as_map(struct, opts)
     end
   end
 

lib/elixir/lib/kernel.ex

@@ -4064,7 +4064,7 @@ defmodule Kernel do
         -1
       end
 
-    {:%{}, [], [__struct__: Elixir.Range, first: first, last: last, step: step]}
+    {:%, [], [Elixir.Range, {:%{}, [], [first: first, last: last, step: step]}]}
   end
 
   defp stepless_range(nil, first, last, _caller) do
@@ -4090,7 +4090,7 @@ defmodule Kernel do
       Macro.Env.stacktrace(caller)
     )
 
-    {:%{}, [], [__struct__: Elixir.Range, first: first, last: last, step: step]}
+    {:%, [], [Elixir.Range, {:%{}, [], [first: first, last: last, step: step]}]}
   end
 
   defp stepless_range(:match, first, last, caller) do
@@ -4103,7 +4103,7 @@ defmodule Kernel do
       Macro.Env.stacktrace(caller)
     )
 
-    {:%{}, [], [__struct__: Elixir.Range, first: first, last: last]}
+    {:%, [], [Elixir.Range, {:%{}, [], [first: first, last: last]}]}
   end
 
   @doc """
@@ -4142,7 +4142,7 @@ defmodule Kernel do
         range(__CALLER__.context, first, last, step)
 
       false ->
-        range(__CALLER__.context, first, last, step)
+        {:%{}, [], [__struct__: Elixir.Range, first: first, last: last, step: step]}
     end
   end
 
@@ -4553,11 +4553,10 @@ defmodule Kernel do
         raise ArgumentError, "found unescaped value on the right side of in/2: #{inspect(right)}"
 
       right ->
-        with {:%{}, _meta, fields} <- right,
-             [__struct__: Elixir.Range, first: first, last: last, step: step] <-
-               :lists.usort(fields) do
-          in_var(in_body?, left, &in_range(&1, expand.(first), expand.(last), expand.(step)))
-        else
+        case range_fields(right) do
+          [first: first, last: last, step: step] ->
+            in_var(in_body?, left, &in_range(&1, expand.(first), expand.(last), expand.(step)))
+
           _ when in_body? ->
             quote(do: Elixir.Enum.member?(unquote(right), unquote(left)))
 
@@ -4567,6 +4566,10 @@ defmodule Kernel do
     end
   end
 
+  defp range_fields({:%, _, [Elixir.Range, {:%{}, _, fields}]}), do: :lists.usort(fields)
+  defp range_fields({:%{}, _, [__struct__: Elixir.Range] ++ fields}), do: :lists.usort(fields)
+  defp range_fields(_), do: []
+
   defp raise_on_invalid_args_in_2(right) do
     raise ArgumentError, <<
       "invalid right argument for operator \"in\", it expects a compile-time proper list ",

lib/elixir/lib/module/types/apply.ex

@@ -829,20 +829,26 @@ defmodule Module.Types.Apply do
     {mod, fun, arity, converter} = mfac
     meta = elem(expr, 1)
 
-    mfa_or_fa = if mod, do: Exception.format_mfa(mod, fun, arity), else: "#{fun}/#{arity}"
-
     # Protocol errors can be very verbose, so we collapse structs
-    {caller, hints, opts} =
+    {banner, hints, opts} =
       cond do
         meta[:from_interpolation] ->
-          {"string interpolation", [:interpolation], [collapse_structs: true]}
+          {_, _, [arg]} = expr
+
+          {"""
+           incompatible value given to string interpolation:
+
+               #{expr_to_string(arg) |> indent(4)}
+
+           it has type:
+           """, [:interpolation], [collapse_structs: true]}
 
         Code.ensure_loaded?(mod) and
             Keyword.has_key?(mod.module_info(:attributes), :__protocol__) ->
-          {mfa_or_fa, [{:protocol, mod}], [collapse_structs: true]}
+          {nil, [{:protocol, mod}], [collapse_structs: true]}
 
         true ->
-          {mfa_or_fa, [], []}
+          {nil, [], []}
       end
 
     explanation =
@@ -852,16 +858,24 @@ defmodule Module.Types.Apply do
         #{clauses_args_to_quoted_string(clauses, converter, opts)}
         """
 
+    mfa_or_fa = if mod, do: Exception.format_mfa(mod, fun, arity), else: "#{fun}/#{arity}"
+
+    banner =
+      banner ||
+        """
+        incompatible types given to #{mfa_or_fa}:
+
+            #{expr_to_string(expr) |> indent(4)}
+
+        given types:
+        """
+
     %{
       details: %{typing_traces: traces},
       message:
         IO.iodata_to_binary([
+          banner,
           """
-          incompatible types given to #{caller}:
-
-              #{expr_to_string(expr) |> indent(4)}
-
-          given types:
 
               #{args_to_quoted_string(args_types, domain, converter) |> indent(4)}
 

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

@@ -73,7 +73,7 @@ defmodule Module.Types.Helpers do
       :interpolation ->
         """
 
-        #{hint()} string interpolation in Elixir use the String.Chars protocol to \
+        #{hint()} string interpolation in Elixir uses the String.Chars protocol to \
         convert a data structure into a string. Either convert the data type into a \
         string upfront or implement the protocol accordingly
         """
@@ -82,7 +82,7 @@ defmodule Module.Types.Helpers do
         """
 
         #{hint()} #{inspect(protocol)} is a protocol in Elixir. Either make sure you \
-        give valid data types as argument or implement the protocol accordingly
+        give valid data types as arguments or implement the protocol accordingly
         """
 
       :anonymous_rescue ->
@@ -218,12 +218,34 @@ defmodule Module.Types.Helpers do
   @doc """
   Converts the given expression to a string,
   translating inlined Erlang calls back to Elixir.
+
+  We also undo some macro expresions done by the Kernel module.
   """
   def expr_to_string(expr) do
     expr
     |> Macro.prewalk(fn
-      {{:., _, [mod, fun]}, meta, args} -> erl_to_ex(mod, fun, args, meta)
-      other -> other
+      {:%, _, [Range, {:%{}, _, fields}]} = node ->
+        case :lists.usort(fields) do
+          [first: first, last: last, step: step] ->
+            quote do
+              unquote(first)..unquote(last)//unquote(step)
+            end
+
+          _ ->
+            node
+        end
+
+      {{:., _, [Elixir.String.Chars, :to_string]}, meta, [arg]} ->
+        {:to_string, meta, [arg]}
+
+      {{:., _, [Elixir.List.Chars, :to_charlist]}, meta, [arg]} ->
+        {:to_charlist, meta, [arg]}
+
+      {{:., _, [mod, fun]}, meta, args} ->
+        erl_to_ex(mod, fun, args, meta)
+
+      other ->
+        other
     end)
     |> Macro.to_string()
   end