Only justify applications in IEx stacktraces

Author: José Valim

lib/elixir/lib/exception.ex

@@ -10,21 +10,21 @@ defexception SystemLimitError,  message: "a system limit has been reached"
 defexception SyntaxError, [file: nil, line: nil, description: "syntax error"] do
   def message(exception) do
     Exception.format_file_line(Path.relative_to_cwd(exception.file), exception.line) <>
-      exception.description
+      " " <> exception.description
   end
 end
 
 defexception TokenMissingError, [file: nil, line: nil, description: "expression is incomplete"] do
   def message(exception) do
     Exception.format_file_line(Path.relative_to_cwd(exception.file), exception.line) <>
-      exception.description
+      " " <> exception.description
   end
 end
 
 defexception CompileError, [file: nil, line: nil, description: "compile error"] do
   def message(exception) do
     Exception.format_file_line(Path.relative_to_cwd(exception.file), exception.line) <>
-      exception.description
+      " " <> exception.description
   end
 end
 
@@ -149,6 +149,16 @@ defmodule Exception do
   pass the `System.stacktrace` as argument.
   """
 
+  @type stacktrace :: [stacktrace_entry]
+
+  @type stacktrace_entry ::
+        { module, function, arity_or_args, location } |
+        { function, arity_or_args, location }
+
+  @typep function :: atom
+  @typep arity_or_args :: non_neg_integer | list
+  @typep location :: Keyword.t
+
   @doc """
   Normalizes an exception, converting Erlang exceptions
   to Elixir exceptions.
@@ -221,48 +231,38 @@ defmodule Exception do
   end
 
   @doc """
-  Receives a tuple representing a stacktrace entry and formats it.
-  """
-  def format_stacktrace_entry(entry) do
-    format_stacktrace_entry_into_fields(entry)
-    |> tuple_to_list
-    |> Enum.filter(fn field -> field && field != "" end)
-    |> Enum.join(" ")
-  end
-
-  @doc """
-  Returns the fields from a single frame in a stack trace as a list of 
-  `[ app, location, mfa/module/file ]` where all but location can be nil. 
-  Intended for use inside the Elixir libraries and iex only
+  Receives an stacktrace entry and formats it into a string.
   """
+  @spec format_stacktrace_entry(stacktrace_entry) :: String.t
+  def format_stacktrace_entry(entry)
 
   # From Macro.Env.stacktrace
-  def format_stacktrace_entry_into_fields({ module, :__MODULE__, 0, location }) do
-    { nil, format_location(location), inspect(module) <> " (module)" }
+  def format_stacktrace_entry({ module, :__MODULE__, 0, location }) do
+    format_location(location) <> inspect(module) <> " (module)"
   end
 
   # From :elixir_compiler_*
-  def format_stacktrace_entry_into_fields({ _module, :__MODULE__, 1, location }) do
-    { nil, format_location(location), "(module)" }
+  def format_stacktrace_entry({ _module, :__MODULE__, 1, location }) do
+    format_location(location) <> "(module)"
   end
 
   # From :elixir_compiler_*
-  def format_stacktrace_entry_into_fields({ _module, :__FILE__, 1, location }) do
-    { nil, format_location(location),  "(file)" }
+  def format_stacktrace_entry({ _module, :__FILE__, 1, location }) do
+    format_location(location) <> "(file)"
   end
 
-  def format_stacktrace_entry_into_fields({module, fun, arity, location}) do
-    { format_application(module), format_location(location), format_mfa(module, fun, arity) }
+  def format_stacktrace_entry({module, fun, arity, location}) do
+    format_application(module) <> format_location(location) <> format_mfa(module, fun, arity)
   end
 
-  def format_stacktrace_entry_into_fields({fun, arity, location}) do
-    { nil, format_location(location), format_fa(fun, arity) }
+  def format_stacktrace_entry({fun, arity, location}) do
+    format_location(location) <> format_fa(fun, arity)
   end
 
   defp format_application(module) do
     case :application.get_application(module) do
-      { :ok, app } -> "(" <> atom_to_binary(app) <> ")"
-      :undefined   -> nil
+      { :ok, app } -> "(" <> atom_to_binary(app) <> ") "
+      :undefined   -> ""
     end
   end
 
@@ -285,29 +285,6 @@ defmodule Exception do
     end
   end
 
-  @doc """
-  Formats the caller, i.e. the first entry in the stacktrace.
-
-  A stacktrace must be given as an argument. If not, this function
-  calculates a new stacktrace based on the caller and formats it. As
-  a consequence, the value of `System.stacktrace` is changed.
-
-  Notice that due to tail call optimization, the stacktrace
-  may not report the direct caller of the function.
-  """
-  def format_caller(trace \\ nil) do
-    trace = trace || try do
-      throw(:stacktrace)
-    catch
-      :stacktrace -> Enum.drop(:erlang.get_stacktrace, 2)
-    end
-
-    case trace do
-      [entry|_] -> format_stacktrace_entry(entry)
-      _ -> "nofile:0: "
-    end
-  end
-
   @doc """
   Receives an anonymous function and arity and formats it as
   shown in stacktraces. The arity may also be a list of arguments.
@@ -326,8 +303,9 @@ defmodule Exception do
   Receives a module, fun and arity and formats it
   as shown in stacktraces. The arity may also be a list
   of arguments.
-  
+
   ## Examples
+
       iex> Exception.format_mfa Foo, :bar, 1
       "Foo.bar/1"
       iex> Exception.format_mfa Foo, :bar, []
@@ -337,66 +315,51 @@ defmodule Exception do
 
   Anonymous functions are reported as -func/arity-anonfn-count-,
   where func is the name of the enclosing function. Convert to
-  "nth fn in func/arity"
+  "anonymous fn in func/arity"
   """
+  def format_mfa(module, fun, arity) when is_atom(fun) do
+    fun =
+      case inspect(fun) do
+        ":" <> fun -> fun
+        fun -> fun
+      end
 
-  def format_mfa(module, nil, arity), 
-  do: do_format_mfa(module, "nil", arity) 
-
-  def format_mfa(module, fun, arity) when is_atom(fun),
-  do: do_format_mfa(module, to_string(fun), arity) 
-
-  defp do_format_mfa(module, fun, arity) when not(is_binary(fun)),
-  do: format_mfa(module, inspect(fun), arity) 
-
-  defp do_format_mfa(module, "-" <> fun, arity) do
-    [ outer_fun, "fun", count, "" ] = String.split(fun, "-")
-    "#{format_nth(count)} anonymous fn#{format_arity(arity)} in #{inspect module}.#{outer_fun}"
-  end
-
-  # Erlang internal
-  defp do_format_mfa(module, ":" <> fun, arity),  
-  do: format_mfa(module, maybe_quote_name(fun), arity)
-
-  defp do_format_mfa(module, fun, arity) do
-    "#{inspect module}.#{maybe_quote_name(fun)}#{format_arity(arity)}"
+    case match?("\"-" <> _, fun) and String.split(fun, "-") do
+      [ "\"", outer_fun, "fun", _count, "\"" ] ->
+        "anonymous fn#{format_arity(arity)} in #{inspect module}.#{outer_fun}"
+      _ ->
+        "#{inspect module}.#{fun}#{format_arity(arity)}"
+    end
   end
 
   defp format_arity(arity) when is_list(arity) do
     inspected = lc x inlist arity, do: inspect(x)
     "(#{Enum.join(inspected, ", ")})"
   end
 
-  defp format_arity(arity),  do: "/#{arity}"
-
-  defp format_nth("0"), do: "first"
-  defp format_nth("1"), do: "second"
-  defp format_nth("2"), do: "third"
-  defp format_nth(n),   do:  "#{binary_to_integer(n)+1}th"
-
+  defp format_arity(arity), do: "/#{arity}"
 
   @doc """
   Formats the given file and line as shown in stacktraces.
-  If any of the values are nil, they are omitted. If the
-  optional suffix is omitted, a space is appended to
-  the result.
+  If any of the values are nil, they are omitted.
 
   ## Examples
 
       iex> Exception.format_file_line("foo", 1)
-      "foo:1: "
-
-      iex> Exception.format_file_line("foo", 1, "")
       "foo:1:"
 
       iex> Exception.format_file_line("foo", nil)
-      "foo: "
+      "foo:"
 
       iex> Exception.format_file_line(nil, nil)
       ""
 
   """
-  def format_file_line(file, line, suffix // " ") do
+  def format_file_line(file, line) do
+    format_file_line(file, line, "")
+  end
+
+  defp format_file_line(file, line, suffix) do
     if file do
       if line && line != 0 do
         "#{file}:#{line}:#{suffix}"
@@ -409,7 +372,7 @@ defmodule Exception do
   end
 
   defp format_location(opts) do
-    format_file_line Keyword.get(opts, :file), Keyword.get(opts, :line), ""
+    format_file_line Keyword.get(opts, :file), Keyword.get(opts, :line), " "
   end
 
   defp from_stacktrace([{ module, function, args, _ }|_]) when is_list(args) do
@@ -423,50 +386,4 @@ defmodule Exception do
   defp from_stacktrace(_) do
     { nil, nil, nil }
   end
-
-
-  # have to use :re here because exceptions may be triggered before Regexp
-  # module is compiled.
-  @function_name_re :re.compile(
-    %S{
-       \A(                                       
-            [\w]+[?!]?         
-          | ->
-          | <-
-          | :: 
-          | \|{1,3}
-          | =
-          | &&&?
-          | <=?
-          | >=? 
-          | ===?
-          | !==?
-          | =~
-          | <<< 
-          | >>>
-          | \+\+? 
-          | --? 
-          | <>
-          | \+
-          | -
-          | \*
-          | //?
-          | ^^^
-          | !
-          | \^ 
-          | & 
-          | ~~~
-          | @
-    )\z}, [:extended] )
-
-  defp maybe_quote_name(fun) do
-    name = to_string(fun)
-    {:ok, re} = @function_name_re
-    case :re.run(name, re) do
-      { :match, _} -> name
-      _            -> inspect name
-    end
-  end
-
-                                    
 end

lib/elixir/lib/module.ex

@@ -777,8 +777,10 @@ defmodule Module do
         cond do
           :lists.member(key, acc) ->
             []
-          is_list(warn) ->
-            :elixir_errors.warn Exception.format_caller(warn), "undefined module attribute @#{key}, " <>
+          is_list(warn) && (entry = List.first(warn)) ->
+            opts = elem(entry, size(entry) - 1)
+            info = Exception.format_file_line(Keyword.get(opts, :file), Keyword.get(opts, :line))
+            :elixir_errors.warn info, "undefined module attribute @#{key}, " <>
               "please remove access to @#{key} or explicitly set it to nil before access\n"
             nil
           true ->

lib/elixir/test/elixir/exception_test.exs

@@ -62,6 +62,7 @@ defmodule Kernel.ExceptionTest do
     assert Exception.format_mfa(nil, :bar, []) == "nil.bar()"
     assert Exception.format_mfa(:foo, :bar, [1, 2]) == ":foo.bar(1, 2)"
     assert Exception.format_mfa(Foo, :"bar baz", 1) == "Foo.\"bar baz\"/1"
+    assert Exception.format_mfa(Foo, :"-func/2-fun-0-", 4) == "anonymous fn/4 in Foo.func/2"
   end
 
   test "format_fa" do
@@ -104,7 +105,7 @@ defmodule Kernel.ExceptionTest do
       end
     file = __ENV__.file |> Path.relative_to_cwd |> String.to_char_list!
     assert {Kernel.ExceptionTest, :"test raise preserves the stacktrace", _,
-           [file: ^file, line: 100]} = stacktrace
+           [file: ^file, line: 101]} = stacktrace
   end
 
   test "defexception" do

lib/elixir/test/elixir/kernel/warning_test.exs

@@ -334,7 +334,7 @@ defmodule Kernel.WarningTest do
   test :undefined_module_attribute_with_file do
     assert capture_err(fn ->
       Code.load_file(fixture_path("attribute_warning.ex"))
-    end) =~ "attribute_warning.ex:2: AttributeWarning (module) warning: undefined module attribute @foo, please remove access to @foo or explicitly set it to nil before access"
+    end) =~ "attribute_warning.ex:2: warning: undefined module attribute @foo, please remove access to @foo or explicitly set it to nil before access"
   after
     purge AttributeWarning
   end