anchor.diff:  
     Kind    = protocol_or_behaviour(Module),
     Raw     = "undefined ~ts ~ts ~ts/~B (for ~ts ~ts)",
  -  Message = io_lib:format(Raw, [Kind, DefKind, Def, DefArity, Kind, elixir_aliases:inspect(Module)]),
  -  warn(Line, File, Message);
  -
  -handle_file_warning(_, File, {Line, erl_lint, {undefined_behaviour, Module}}) ->
  -  case elixir_compiler:get_opt(internal) of
  -    true  -> ok;
  -    false ->
  -      warn(Line, File, ["behaviour ", elixir_aliases:inspect(Module), " is undefined"])
  -  end;
  -
  -%% Ignore unused vars at "weird" lines (<= 0)
  -handle_file_warning(_, _File, {Line, erl_lint, {unused_var, _Var}}) when Line =< 0 ->
  -  ok;
  -
  -%% Ignore shadowed and exported vars as we guarantee no conflicts ourselves
  -handle_file_warning(_, _File, {_Line, erl_lint, {shadowed_var, _Var, _Where}}) ->
  -  ok;
  -
  -handle_file_warning(_, _File, {_Line, erl_lint, {exported_var, _Var, _Where}}) ->
  -  ok;
  +  io_lib:format(Raw, [Kind, DefKind, Def, DefArity, Kind, elixir_aliases:inspect(Module)]);
   
   %% Rewrite nomatch_guard to be more generic it can happen inside if, unless, etc
  -handle_file_warning(_, File, {Line, sys_core_fold, nomatch_guard}) ->
  -  warn(Line, File, "this check/guard will always yield the same result");
  +format_error(sys_core_fold, nomatch_guard) ->
  +  "this check/guard will always yield the same result";
   
   %% Properly format other unused vars
  -handle_file_warning(_, File, {Line, erl_lint, {unused_var, Var}}) ->
  -  warn(Line, File, ["variable \"", format_var(Var), "\" is unused"]);
  +format_error(erl_lint, {unused_var, Var}) ->
  +  ["variable \"", format_var(Var), "\" is unused"];
   
   %% Handle literal eval failures
  -handle_file_warning(_, File, {Line, sys_core_fold, {eval_failure, Error}}) ->
  +format_error(sys_core_fold, {eval_failure, Error}) ->
     #{'__struct__' := Struct} = 'Elixir.Exception':normalize(error, Error),
  -  warn(Line, File, ["this expression will fail with ", elixir_aliases:inspect(Struct)]);
  -
  -%% Default behaviour
  -handle_file_warning(_, File, {Line, Module, Desc}) ->
  -  Message = format_error(Module, Desc),
  -  warn(Line, File, Message).
  -
  -handle_file_warning(File, Desc) ->
  -  handle_file_warning(false, File, Desc).
  -
  --spec handle_file_error(file:filename_all(), {non_neg_integer(), module(), any()}) -> no_return().
  -
  -handle_file_error(File, {Line, erl_lint, {unsafe_var, Var, {In, _Where}}}) ->
  -  Translated = case In of
  -    'orelse'  -> 'or';
  -    'andalso' -> 'and';
  -    _ -> In
  -  end,
  -  Message = io_lib:format("cannot define variable \"~ts\" inside ~ts", [format_var(Var), Translated]),
  -  do_raise(Line, File, 'Elixir.CompileError', elixir_utils:characters_to_binary(Message));
  -
  -handle_file_error(File, {Line, erl_lint, {undefined_function, {F, A}}}) ->
  -  Message = io_lib:format("undefined function ~ts/~B", [F, A]),
  -  do_raise(Line, File, 'Elixir.CompileError', elixir_utils:characters_to_binary(Message));
  -
  -handle_file_error(File, {Line, erl_lint, {spec_fun_undefined, {M, F, A}}}) ->
  -  Message = io_lib:format("spec for undefined function ~ts.~ts/~B", [elixir_aliases:inspect(M), F, A]),
  -  do_raise(Line, File, 'Elixir.CompileError', elixir_utils:characters_to_binary(Message));
  -
  -handle_file_error(File, {beam_validator, Rest}) ->
  -  Message = beam_validator:format_error(Rest),
  -  do_raise(0, File, 'Elixir.CompileError', elixir_utils:characters_to_binary(Message));
  -
  -handle_file_error(File, {Line, Module, Desc}) ->
  -  Message = format_error(Module, Desc),
  -  do_raise(Line, File, 'Elixir.CompileError', elixir_utils:characters_to_binary(Message)).
  +  ["this expression will fail with ", elixir_aliases:inspect(Struct)];
  +
  +format_error([], Desc) ->
  +  io_lib:format("~p", [Desc]);
  +
  +format_error(Module, Desc) ->
  +  Module:format_error(Desc).
   
   %% Helpers
  -
  -raise(Meta, File, Kind, Message) when is_list(Meta) ->
  -  {MetaFile, MetaLine} = meta_location(Meta, File),
  -  do_raise(MetaLine, MetaFile, Kind, Message).
   
   file_format(0, File) ->
     io_lib:format("~ts", [elixir_utils:relative_to_cwd(File)]);
  
positive.code:     nil    -> {File, ?line(Meta)}
    end.
  
  do_raise(none, File, Kind, Message) ->
    do_raise(0, File, Kind, Message);
  do_raise({Line, _, _}, File, Kind, Message) when is_integer(Line) ->
    do_raise(Line, File, Kind, Message);
  do_raise(Line, File, Kind, Message) when is_integer(Line), is_binary(File), is_binary(Message) ->
    try
      throw(ok)
    catch
  
negative.code: %% syntax.
  parse_error(Line, File, <<"syntax error before: ">>, <<$$, Char/binary>>) ->
    Message = <<"syntax error before: ?", Char/binary>>,
    raise(Line, File, 'Elixir.SyntaxError', Message);
  
  %% Everything else is fine as is
  parse_error(Line, File, Error, Token) when is_binary(Error), is_binary(Token) ->
    Message = <<Error/binary, Token/binary >>,
    raise(Line, File, 'Elixir.SyntaxError', Message).
  
  %% Helper to parse terms which have been converted to binaries
  parse_erl_term(Term) ->
  