Improve error messages

Author: José Valim

lib/elixir/lib/kernel.ex

@@ -2969,7 +2969,8 @@ defmodule Kernel do
         Record.access(atom, fields, args, caller)
       false ->
         case caller.in_match? do
-          true  -> raise "invalid usage of access protocol in signature"
+          true  -> raise << "the access protocol cannot be used inside match clauses ",
+                     "(for example, on the left hand side of a match or in function signatures)" >>
           false -> quote do: Access.access(unquote(element), unquote(args))
         end
     end

lib/elixir/lib/macro/env.ex

@@ -25,7 +25,7 @@ defmodule Macro.Env do
   @type file :: binary
   @type line :: non_neg_integer
   @type aliases :: [{ module, module }]
-  @type context :: :assign | :guard | nil
+  @type context :: :match | :guard | nil
   @type requires :: [module]
   @type functions :: [{ module, [name_arity] }]
   @type macros :: [{ module, [name_arity] }]
@@ -58,7 +58,7 @@ defmodule Macro.Env do
   Returns wether the compilation environment is currently
   inside a match clause.
   """
-  def in_match?(record), do: context(record) == :assign
+  def in_match?(record), do: context(record) == :match
 
   @doc """
   Returns the environment stacktrace.

lib/elixir/src/elixir_aliases.erl

@@ -145,8 +145,8 @@ lookup(Else, Dict) ->
 %% Errors
 
 format_error({unloaded_module, Module}) ->
-  io_lib:format("module ~s is not loaded and could not be found", [elixir_errors:inspect(Module)]);
+  io_lib:format("module ~ts is not loaded and could not be found", [elixir_errors:inspect(Module)]);
 
 format_error({scheduled_module, Module}) ->
-  io_lib:format("module ~s is not loaded but was defined. This happens because you are trying to use a module in the same context it is defined. Try defining the module outside the context that requires it.",
+  io_lib:format("module ~ts is not loaded but was defined. This happens because you are trying to use a module in the same context it is defined. Try defining the module outside the context that requires it.",
     [elixir_errors:inspect(Module)]).

lib/elixir/src/elixir_clauses.erl

@@ -19,15 +19,15 @@ get_pairs(Meta, Key, Clauses, S, AllowNil) ->
     { Key, nil } when AllowNil ->
       [];
     { Key, _ } ->
-      elixir_errors:syntax_error(Meta, S#elixir_scope.file, "expected pairs with -> for key ~s", [Key]);
+      elixir_errors:syntax_error(Meta, S#elixir_scope.file, "expected pairs with -> for key ~ts", [Key]);
     _ ->
       []
   end.
 
 % Function for translating assigns.
 
-assigns(Fun, Args, #elixir_scope{context=Context} = S) when Context /= assign ->
-  { Result, NewS } = assigns(Fun, Args, S#elixir_scope{context=assign, temp_vars=orddict:new()}),
+assigns(Fun, Args, #elixir_scope{context=Context} = S) when Context /= match ->
+  { Result, NewS } = assigns(Fun, Args, S#elixir_scope{context=match, temp_vars=orddict:new()}),
   { Result, NewS#elixir_scope{context=Context} };
 
 assigns(Fun, Args, S) -> Fun(Args, S).
@@ -176,10 +176,10 @@ each_clause(Meta, { 'after', [Condition], Expr }, S) ->
   { { clause, ?line(Meta), [TCondition], [], TBody }, SB };
 
 each_clause(Meta, { Key, [_|_], _ }, S) when Key == do; Key == 'after' ->
-  elixir_errors:syntax_error(Meta, S#elixir_scope.file, "too many arguments given for ~s", [Key]);
+  elixir_errors:syntax_error(Meta, S#elixir_scope.file, "too many arguments given for ~ts", [Key]);
 
 each_clause(Meta, { Key, _, _ }, S) ->
-  elixir_errors:syntax_error(Meta, S#elixir_scope.file, "invalid key ~s", [Key]).
+  elixir_errors:syntax_error(Meta, S#elixir_scope.file, "invalid key ~ts", [Key]).
 
 % Check if the given expression is a match tuple.
 % This is a small optimization to allow us to change

lib/elixir/src/elixir_compiler.erl

@@ -137,11 +137,11 @@ env_default_opts() ->
             {ok,List} when is_list(List) -> List;
             {ok,Term} -> [Term];
             {error,_Reason} ->
-              io:format("Ignoring bad term in ~s\n", [Key]),
+              io:format("Ignoring bad term in ~ts\n", [Key]),
               []
           end;
         {error, {_,_,_Reason}, _} ->
-          io:format("Ignoring bad term in ~s\n", [Key]),
+          io:format("Ignoring bad term in ~ts\n", [Key]),
           []
       end
   end.
@@ -195,7 +195,7 @@ core_file(File) ->
   try
     Lists = file(list_to_binary(File)),
     [binary_to_path(X, "lib/elixir/ebin") || X <- Lists],
-    io:format("Compiled ~s~n", [File])
+    io:format("Compiled ~ts~n", [File])
   catch
     Kind:Reason ->
       io:format("~p: ~p~nstacktrace: ~p~n", [Kind, Reason, erlang:get_stacktrace()]),
@@ -235,7 +235,7 @@ core_main() ->
 %% ERROR HANDLING
 
 format_error({ skip_native, Module }) ->
-  io_lib:format("skipping native compilation for ~s because it contains on_load attribute",
+  io_lib:format("skipping native compilation for ~ts because it contains on_load attribute",
     [elixir_errors:inspect(Module)]).
 
 format_errors(_File, []) ->

lib/elixir/src/elixir_def.erl

@@ -75,7 +75,7 @@ store_definition(Kind, Line, Module, Call, Body, RawS) ->
   { Name, Args } = case elixir_clauses:extract_args(NameAndArgs) of
     error ->
       Format = [Kind, 'Elixir.Macro':to_binary(NameAndArgs)],
-      elixir_errors:syntax_error(Line, S#elixir_scope.file, "invalid syntax in ~s ~s", Format);
+      elixir_errors:syntax_error(Line, S#elixir_scope.file, "invalid syntax in ~ts ~ts", Format);
     Tuple ->
       Tuple
   end,
@@ -85,7 +85,7 @@ store_definition(Kind, Line, Module, Call, Body, RawS) ->
 
 store_definition(Kind, Line, nil, _Name, _Args, _Guards, _Body, RawS) ->
   S = elixir_scope:deserialize(RawS),
-  elixir_errors:syntax_error(Line, S#elixir_scope.file, "cannot define function outside module, invalid scope for ~s", [Kind]);
+  elixir_errors:syntax_error(Line, S#elixir_scope.file, "cannot define function outside module, invalid scope for ~ts", [Kind]);
 
 store_definition(Kind, Line, Module, Name, Args, Guards, Body, RawS) ->
   do_store_definition(Kind, Line, Module, Name, Args, Guards, Body, elixir_scope:deserialize(RawS)).
@@ -312,7 +312,7 @@ check_valid_defaults(Line, File, Name, Arity, _) ->
   elixir_errors:handle_file_warning(File, { Line, ?MODULE, { clauses_with_docs, { Name, Arity } } }).
 
 assert_no_aliases_name(Line, '__aliases__', [Atom], #elixir_scope{file=File}) when is_atom(Atom) ->
-  Message = "function names should start with lowercase characters or underscore, invalid name ~s",
+  Message = "function names should start with lowercase characters or underscore, invalid name ~ts",
   elixir_errors:syntax_error(Line, File, Message, [atom_to_binary(Atom, utf8)]);
 
 assert_no_aliases_name(_Meta, _Aliases, _Args, _S) ->
@@ -321,10 +321,10 @@ assert_no_aliases_name(_Meta, _Aliases, _Args, _S) ->
 %% Format errors
 
 format_error({clauses_with_docs,{Name,Arity}}) ->
-  io_lib:format("function ~s/~B has default values and multiple clauses, use a separate clause for declaring defaults", [Name, Arity]);
+  io_lib:format("function ~ts/~B has default values and multiple clauses, use a separate clause for declaring defaults", [Name, Arity]);
 
 format_error({changed_clause,{{Name,Arity},{ElseName,ElseArity}}}) ->
-  io_lib:format("function ~s/~B does not match previous clause ~s/~B", [Name, Arity, ElseName, ElseArity]);
+  io_lib:format("function ~ts/~B does not match previous clause ~ts/~B", [Name, Arity, ElseName, ElseArity]);
 
 format_error({changed_kind,{Name,Arity,Previous,Current}}) ->
-  io_lib:format("~s ~s/~B already defined as ~s", [Current, Name, Arity, Previous]).
+  io_lib:format("~ts ~ts/~B already defined as ~ts", [Current, Name, Arity, Previous]).

lib/elixir/src/elixir_def_local.erl

@@ -75,4 +75,4 @@ check_unused_local_macros(File, Recorded, Defmacrop) ->
       Check, not lists:member(Fun, Recorded)].
 
 format_error({unused_macro,{Name, Arity}}) ->
-  io_lib:format("macro ~s/~B is unused", [Name, Arity]).
+  io_lib:format("macro ~ts/~B is unused", [Name, Arity]).

lib/elixir/src/elixir_def_overridable.erl

@@ -88,7 +88,7 @@ store_pending(Module) ->
 format_error({ no_super, Module, { Name, Arity } }) ->
   Bins   = [ format_fa(X) || { X, { _, _, _ } } <- overridable(Module)],
   Joined = 'Elixir.Enum':join(Bins, <<", ">>),
-  io_lib:format("no super defined for ~s/~B in module ~s. Overridable functions available are: ~s",
+  io_lib:format("no super defined for ~ts/~B in module ~ts. Overridable functions available are: ~ts",
     [Name, Arity, elixir_errors:inspect(Module), Joined]).
 
 format_fa({ Name, Arity }) ->

lib/elixir/src/elixir_dispatch.erl

@@ -223,7 +223,7 @@ munge_stacktrace(_, [], _) ->
 
 format_error({ unrequired_module,{Receiver, Name, Arity, Required }}) ->
   String = string:join([elixir_errors:inspect(R) || R <- Required], ", "),
-  io_lib:format("tried to invoke macro ~s.~s/~B but module was not required. Required: ~s",
+  io_lib:format("tried to invoke macro ~ts.~ts/~B but module was not required. Required: ~ts",
     [elixir_errors:inspect(Receiver), Name, Arity, String]).
 
 %% INTROSPECTION

lib/elixir/src/elixir_errors.erl

@@ -4,8 +4,8 @@
 -export([syntax_error/3, syntax_error/4, inspect/1,
   form_error/4, parse_error/4, assert_module_scope/3,
   assert_no_function_scope/3, assert_function_scope/3,
-  assert_no_assign_scope/3, assert_no_guard_scope/3,
-  assert_no_assign_or_guard_scope/3,
+  assert_no_match_scope/3, assert_no_guard_scope/3,
+  assert_no_match_or_guard_scope/3,
   handle_file_warning/2, handle_file_warning/3, handle_file_error/2,
   deprecation/3, deprecation/4, file_format/3]).
 -include("elixir.hrl").
@@ -97,15 +97,15 @@ handle_file_warning(_, _File, { _Line, v3_kernel, bad_call }) -> [];
 %% Rewrite
 handle_file_warning(_, File, {Line,erl_lint,{undefined_behaviour_func,{Fun,Arity},Module}}) ->
   Kind    = protocol_or_behaviour(Module),
-  Raw     = "undefined ~s function ~s/~B (for ~s ~s)",
+  Raw     = "undefined ~ts function ~ts/~B (for ~ts ~ts)",
   Message = io_lib:format(Raw, [Kind, Fun, Arity, Kind, inspect(Module)]),
   io:format(file_format(Line, File, Message));
 
 handle_file_warning(_, File, {Line,erl_lint,{undefined_behaviour,Module}}) ->
   case elixir_compiler:get_opt(internal) of
     true  -> [];
     false ->
-      Message = io_lib:format("behaviour ~s undefined", [inspect(Module)]),
+      Message = io_lib:format("behaviour ~ts undefined", [inspect(Module)]),
       io:format(file_format(Line, File, Message))
   end;
 
@@ -137,26 +137,26 @@ handle_file_error(File, {Line,Module,Desc}) ->
 
 assert_no_function_scope(_Meta, _Kind, #elixir_scope{function=nil}) -> [];
 assert_no_function_scope(Meta, Kind, S) ->
-  syntax_error(Meta, S#elixir_scope.file, "cannot invoke ~s inside a function", [Kind]).
+  syntax_error(Meta, S#elixir_scope.file, "cannot invoke ~ts inside a function", [Kind]).
 
-assert_no_assign_or_guard_scope(Meta, Kind, S) ->
-  assert_no_assign_scope(Meta, Kind, S),
+assert_no_match_or_guard_scope(Meta, Kind, S) ->
+  assert_no_match_scope(Meta, Kind, S),
   assert_no_guard_scope(Meta, Kind, S).
 
-assert_no_assign_scope(Meta, Kind, #elixir_scope{context=assign} = S) ->
-  syntax_error(Meta, S#elixir_scope.file, "cannot invoke ~s inside assign", [Kind]);
-assert_no_assign_scope(_Meta, _Kind, _S) -> [].
+assert_no_match_scope(Meta, Kind, #elixir_scope{context=match} = S) ->
+  syntax_error(Meta, S#elixir_scope.file, "cannot invoke ~ts inside match clause", [Kind]);
+assert_no_match_scope(_Meta, _Kind, _S) -> [].
 
 assert_no_guard_scope(Meta, Kind, #elixir_scope{context=guard} = S) ->
-  syntax_error(Meta, S#elixir_scope.file, "cannot invoke ~s inside guard", [Kind]);
+  syntax_error(Meta, S#elixir_scope.file, "cannot invoke ~ts inside guard", [Kind]);
 assert_no_guard_scope(_Meta, _Kind, _S) -> [].
 
 assert_module_scope(Meta, Kind, #elixir_scope{module=nil,file=File}) ->
-  syntax_error(Meta, File, "cannot invoke ~s outside module", [Kind]);
+  syntax_error(Meta, File, "cannot invoke ~ts outside module", [Kind]);
 assert_module_scope(_Meta, _Kind, #elixir_scope{module=Module}) -> Module.
 
 assert_function_scope(Meta, Kind, #elixir_scope{function=nil,file=File}) ->
-  syntax_error(Meta, File, "cannot invoke ~s outside function", [Kind]);
+  syntax_error(Meta, File, "cannot invoke ~ts outside function", [Kind]);
 assert_function_scope(_Meta, _Kind, #elixir_scope{function=Function}) -> Function.
 
 %% Helpers