Ensure we don't leak erlang terms on failure, closes #2303

Author: José Valim

lib/elixir/src/elixir_errors.erl

@@ -55,10 +55,18 @@ parse_error(Meta, File, <<"syntax error before: ">>, <<"'end'">>) ->
   raise(Meta, File, 'Elixir.SyntaxError', <<"unexpected token: end">>);
 
 %% Binaries are wrapped in [<<...>>], so we need to unwrap them
-parse_error(Meta, File, Error, <<"[<<", Token/binary>>) when is_binary(Error) ->
-  Rest = binary_part(Token, 0, byte_size(Token) - 3),
-  Message = <<Error / binary, Rest / binary >>,
-  raise(Meta, File, 'Elixir.SyntaxError', Message);
+parse_error(Meta, File, Error, <<"[", _/binary>> = Full) when is_binary(Error) ->
+  Rest =
+    case binary:split(Full, <<"<<">>) of
+      [Lead, Token] ->
+        case binary:split(Token, <<">>">>) of
+          [Part, _] when Lead == <<$[>> -> Part;
+          _ -> <<$">>
+        end;
+      [_] ->
+        <<$">>
+    end,
+  raise(Meta, File, 'Elixir.SyntaxError', <<Error/binary, Rest/binary >>);
 
 %% Everything else is fine as is
 parse_error(Meta, File, Error, Token) when is_binary(Error), is_binary(Token) ->

lib/elixir/src/elixir_parser.yrl

@@ -23,10 +23,10 @@ Nonterminals
   .
 
 Terminals
-  identifier kw_identifier kw_identifier_string bracket_identifier
+  identifier kw_identifier kw_identifier_safe kw_identifier_unsafe bracket_identifier
   paren_identifier do_identifier block_identifier
   fn 'end' aliases
-  number signed_number atom atom_string bin_string list_string sigil
+  number signed_number atom atom_safe atom_unsafe bin_string list_string sigil
   dot_call_op op_identifier
   comp_op at_op unary_op and_op or_op arrow_op match_op in_op in_match_op type_op
   dual_op add_op mult_op exp_op two_op pipe_op stab_op when_op assoc_op
@@ -208,7 +208,8 @@ access_expr -> max_expr : '$1'.
 
 %% Aliases and properly formed calls. Used by map_expr.
 max_expr -> atom : ?exprs('$1').
-max_expr -> atom_string : build_atom_string('$1').
+max_expr -> atom_safe : build_quoted_atom('$1', true).
+max_expr -> atom_unsafe : build_quoted_atom('$1', false).
 max_expr -> parens_call call_args_parens : build_identifier('$1', '$2').
 max_expr -> parens_call call_args_parens call_args_parens : build_nested_parens('$1', '$2', '$3').
 max_expr -> dot_alias : '$1'.
@@ -428,8 +429,10 @@ call_args_parens -> open_paren call_args_parens_base ',' kw close_paren : revers
 
 kw_eol -> kw_identifier : ?exprs('$1').
 kw_eol -> kw_identifier eol : ?exprs('$1').
-kw_eol -> kw_identifier_string : build_atom_string('$1').
-kw_eol -> kw_identifier_string eol : build_atom_string('$1').
+kw_eol -> kw_identifier_safe : build_quoted_atom('$1', true).
+kw_eol -> kw_identifier_safe eol : build_quoted_atom('$1', true).
+kw_eol -> kw_identifier_unsafe : build_quoted_atom('$1', false).
+kw_eol -> kw_identifier_unsafe eol : build_quoted_atom('$1', false).
 
 kw_base -> kw_eol container_expr : [{'$1', '$2'}].
 kw_base -> kw_base ',' kw_eol container_expr : [{'$3', '$4'}|'$1'].
@@ -513,7 +516,6 @@ Erlang code.
 -define(line(Node), element(2, Node)).
 -define(exprs(Node), element(3, Node)).
 -define(rearrange_uop(Op), (Op == 'not' orelse Op == '!')).
--define(is_atom_string(Atom), (Atom == atom_string orelse Atom == kw_identifier_string)).
 
 %% The following directive is needed for (significantly) faster
 %% compilation of the generated .erl file by the HiPE compiler
@@ -633,9 +635,9 @@ build_list_string({list_string, Line, Args}) ->
   Meta = meta(Line),
   {{'.', Meta, ['Elixir.String', to_char_list]}, Meta, [{'<<>>', Meta, string_parts(Args)}]}.
 
-build_atom_string({Atom, _Line, Safe, [H]}) when ?is_atom_string(Atom) andalso is_binary(H) ->
+build_quoted_atom({_, _Line, [H]}, Safe) when is_binary(H) ->
   Op = binary_to_atom_op(Safe), erlang:Op(H, utf8);
-build_atom_string({Atom, Line, Safe, Args}) when ?is_atom_string(Atom) ->
+build_quoted_atom({_, Line, Args}, Safe) ->
   Meta = meta(Line),
   {{'.', Meta, [erlang, binary_to_atom_op(Safe)]}, Meta, [{'<<>>', Meta, string_parts(Args)}, utf8]}.
 

lib/elixir/src/elixir_tokenizer.erl

@@ -238,8 +238,11 @@ tokenize([$:,H|T] = Original, Line, Scope, Tokens) when ?is_quote(H) ->
   case elixir_interpolation:extract(Line, Scope, true, T, H) of
     {NewLine, Parts, Rest} ->
       Unescaped = unescape_tokens(Parts),
-      ExistingAtomsOnly = Scope#elixir_tokenizer.existing_atoms_only,
-      tokenize(Rest, NewLine, Scope, [{atom_string, Line, ExistingAtomsOnly, Unescaped}|Tokens]);
+      Key = case Scope#elixir_tokenizer.existing_atoms_only of
+        true  -> atom_safe;
+        false -> atom_unsafe
+      end,
+      tokenize(Rest, NewLine, Scope, [{Key, Line, Unescaped}|Tokens]);
     {error, Reason} ->
       interpolation_error(Reason, Original, Tokens, " (for atom starting at line ~B)", [Line])
   end;
@@ -504,8 +507,11 @@ handle_strings(T, Line, H, Scope, Tokens) ->
       interpolation_error(Reason, [H|T], Tokens, " (for string starting at line ~B)", [Line]);
     {NewLine, Parts, [$:|Rest]} when ?is_space(hd(Rest)) ->
       Unescaped = unescape_tokens(Parts),
-      ExistingAtomsOnly = Scope#elixir_tokenizer.existing_atoms_only,
-      tokenize(Rest, NewLine, Scope, [{kw_identifier_string, Line, ExistingAtomsOnly, Unescaped}|Tokens]);
+      Key = case Scope#elixir_tokenizer.existing_atoms_only of
+        true  -> kw_identifier_safe;
+        false -> kw_identifier_unsafe
+      end,
+      tokenize(Rest, NewLine, Scope, [{Key, Line, Unescaped}|Tokens]);
     {NewLine, Parts, Rest} ->
       Token = {string_type(H), Line, unescape_tokens(Parts)},
       tokenize(Rest, NewLine, Scope, [Token|Tokens])

lib/elixir/src/elixir_translator.erl

@@ -238,7 +238,7 @@ translate({{'.', _, [Left, Right]}, Meta, Args}, S)
               {atom, Line, TRight}},
             {map_field_assoc, Line,
               {atom, Line, term},
-              {atom, Line, TVar}}]},
+              TVar}]},
 
           %% TODO There is a bug in dialyzer that makes it fail on
           %% empty maps. We work around the bug below by using

lib/elixir/test/elixir/kernel/errors_test.exs

@@ -15,10 +15,22 @@ defmodule Kernel.ErrorsTest do
       '\end\nlol\nbarbecue'
   end
 
-  test :invalid_string do
+  test :invalid_quoted_token do
     assert_compile_fail SyntaxError,
       "nofile:1: syntax error before: \"world\"",
       '"hello" "world"'
+
+    assert_compile_fail SyntaxError,
+      "nofile:1: syntax error before: foo",
+      'Foo.:foo'
+
+    assert_compile_fail SyntaxError,
+      "nofile:1: syntax error before: \"foo\"",
+      'Foo.:"foo\#{:bar}"'
+
+    assert_compile_fail SyntaxError,
+      "nofile:1: syntax error before: \"",
+      'Foo.:"\#{:bar}"'
   end
 
   test :invalid_or_reserved_codepoint do