fix: don't encode errors directly into AST (#27)

Author: mhanberg

lib/spitfire.ex

@@ -178,10 +178,15 @@ defmodule Spitfire do
         {ast, parser} = parse_expression(parser, @lowest, false, false, true)
 
         parser =
-          if peek_token(parser) in [:eol, :eof] and parser.tokens != :eot do
-            next_token(parser)
-          else
-            parser
+          cond do
+            match?({:__block__, [{:error, true} | _], _}, ast) ->
+              next_token(parser)
+
+            peek_token(parser) in [:eol, :eof] and parser.tokens != :eot ->
+              next_token(parser)
+
+            true ->
+              parser
           end
 
         ast = push_eoe(ast, current_eoe(parser))
@@ -272,7 +277,7 @@ defmodule Spitfire do
           _ -> next_token(parser)
         end
 
-      {{:__error__, meta, ["unknown token: #{ctype}"]}, parser}
+      {{:__block__, [{:error, true} | meta], []}, parser}
     else
       {left, parser} = prefix.(parser)
 
@@ -289,7 +294,6 @@ defmodule Spitfire do
         while is_nil(Map.get(parser, :stab_state)) and not MapSet.member?(terminals, peek_token(parser)) &&
                 (current_token(parser) != :do and peek_token(parser) != :eol) &&
                 calc_prec(parser, associativity, precedence) <- {left, parser} do
-          # dbg(parser)
           parser = consume_fuel(parser)
           peek_token_type = peek_token_type(parser)
 
@@ -476,8 +480,7 @@ defmodule Spitfire do
               |> put_error({meta, "missing closing parentheses"})
               |> Map.put(:nesting, old_nesting)
 
-            # FIXME: we shouldn't emit errors into the actual ast, just stickem in the parser
-            {{:__error__, meta, ["missing closing parentheses"]}, next_token(parser)}
+            {{:__block__, [{:error, true} | meta], []}, next_token(parser)}
           end
 
         true ->
@@ -488,7 +491,7 @@ defmodule Spitfire do
             |> put_error({meta, "missing closing parentheses"})
             |> Map.put(:nesting, old_nesting)
 
-          {{:__error__, meta, ["missing closing parentheses"]}, next_token(parser)}
+          {{:__block__, [{:error, true} | meta], []}, next_token(parser)}
       end
     end
   end
@@ -782,9 +785,9 @@ defmodule Spitfire do
 
     {rhs, parser} =
       case rhs do
-        {:__error__, _, ["unknown token:" <> _]} ->
+        {:__block__, [{:error, true} | _], []} ->
           parser = put_error(pre_parser, {meta, "malformed right-hand side of #{token} operator"})
-          {{:__error__, meta, ["malformed right-hand side of #{token} operator"]}, parser}
+          {{:__block__, [{:error, true} | meta], []}, parser}
 
         _ ->
           {rhs, parser}
@@ -1407,7 +1410,7 @@ defmodule Spitfire do
 
             {pairs, parser} =
               with [{potential_error, parser}, {item, parser_for_errors} | rest] <- all_pairs,
-                   {:__error__, _, ["unknown token: " <> _]} <- potential_error do
+                   {:__block__, [{:error, true} | _], []} <- potential_error do
                 {[{item, parser} | rest],
                  parser
                  |> put_in([:current_token], {:fake_closing_bracket, nil})
@@ -1518,7 +1521,7 @@ defmodule Spitfire do
           _ -> next_token(parser)
         end
 
-      {{:__error__, meta, ["unknown token: #{ctype}"]}, parser}
+      {{:__block__, [], []}, parser}
     else
       {left, parser} = prefix.(parser)
 
@@ -1653,7 +1656,7 @@ defmodule Spitfire do
 
               {pairs, parser} =
                 with [{potential_error, parser}, {item, parser_for_errors} | rest] <- all_pairs,
-                     {:__error__, _, ["unknown token: " <> _]} <- potential_error do
+                     {:__block__, [{:error, true} | _], []} <- potential_error do
                   {[{item, parser} | rest],
                    parser
                    |> put_in([:current_token], {:fake_closing_brace, nil})
@@ -1745,7 +1748,7 @@ defmodule Spitfire do
 
             {pairs, parser} =
               with [{potential_error, parser}, {item, parser_for_errors} | rest] <- all_pairs,
-                   {:__error__, _, ["unknown token: " <> _]} <- potential_error do
+                   {:__block__, [{:error, true} | _meta], []} <- potential_error do
                 {[{item, parser} | rest],
                  parser
                  |> put_in([:current_token], {:fake_closing_bracket, nil})

test/spitfire_test.exs

@@ -1927,7 +1927,7 @@ defmodule SpitfireTest do
       code = "foo $bar, baz"
 
       assert Spitfire.parse(code) ==
-               {:error, {:foo, [line: 1, column: 1], [{:__error__, [line: 1, column: 5], ["unknown token: %"]}]},
+               {:error, {:foo, [line: 1, column: 1], [{:__block__, [error: true, line: 1, column: 5], []}]},
                 [{[line: 1, column: 5], "unknown token: %"}]}
     end
 
@@ -1949,9 +1949,15 @@ defmodule SpitfireTest do
       code = "1 * (2 + 3"
 
       assert Spitfire.parse(code) ==
-               {:error,
-                {:*, [line: 1, column: 3], [1, {:__error__, [line: 1, column: 10], ["missing closing parentheses"]}]},
-                [{[line: 1, column: 10], "missing closing parentheses"}]}
+               {
+                 :error,
+                 {{:*, [line: 1, column: 3], [1, {:__block__, [error: true, line: 1, column: 3], []}]},
+                  [{:closing, [line: 1, column: 10]}, {:line, 1}, {:column, 3}], [{:+, [line: 1, column: 8], [2, 3]}]},
+                 [
+                   {[line: 1, column: 3], "malformed right-hand side of * operator"},
+                   {[line: 1, column: 3], "missing closing parentheses for function invocation"}
+                 ]
+               }
     end
 
     test "missing closing list bracket" do
@@ -1968,6 +1974,13 @@ defmodule SpitfireTest do
 
       assert Spitfire.parse(code) ==
                {:error, {:__block__, [], [[1], :ok]}, [{[line: 1, column: 1], "missing closing bracket for list"}]}
+
+      code = """
+      [1, 2, 3,,
+      """
+
+      assert Spitfire.parse(code) ==
+               {:error, [1, 2, 3], [{[line: 1, column: 1], "missing closing bracket for list"}]}
     end
 
     test "missing closing tuple brace" do
@@ -2149,8 +2162,7 @@ defmodule SpitfireTest do
                       column: 1
                     ],
                     [
-                      {:+, [line: 1, column: 7],
-                       [1, {:__error__, [line: 1, column: 7], ["malformed right-hand side of + operator"]}]}
+                      {:+, [line: 1, column: 7], [1, {:__block__, [error: true, line: 1, column: 7], []}]}
                     ]},
                    {:bar,
                     [
@@ -2430,6 +2442,59 @@ defmodule SpitfireTest do
       assert Spitfire.parse(code) == {:error, :no_fuel_remaining}
     end
 
+    test "doesn't drop the cursor node" do
+      code =
+        ~S'''
+        %{state |
+          foo: s
+        __cursor__()
+        ,
+          bar: Foo.Bar.load(state.foo, state.baz)}
+        '''
+
+      assert Spitfire.parse(code) ==
+               {:error,
+                {:__block__, [],
+                 [
+                   {:%{}, [closing: [line: 2, column: 8], line: 1, column: 1],
+                    [
+                      {:|, [newlines: 1, line: 1, column: 9],
+                       [
+                         {:state, [line: 1, column: 3], nil},
+                         [foo: {:s, [line: 2, column: 8], nil}]
+                       ]}
+                    ]},
+                   {:s, [end_of_expression: [newlines: 1, line: 3, column: 13], line: 2, column: 8],
+                    [{:__cursor__, [closing: [line: 3, column: 12], line: 3, column: 1], []}]},
+                   {:__block__, [error: true, line: 4, column: 1], []},
+                   {{:., [line: 5, column: 15],
+                     [
+                       {:__aliases__, [last: [line: 5, column: 12], line: 5, column: 8], [:Foo, :Bar]},
+                       :load
+                     ]}, [closing: [line: 5, column: 41], line: 5, column: 16],
+                    [
+                      {{:., [line: 5, column: 26], [{:state, [line: 5, column: 21], nil}, :foo]},
+                       [no_parens: true, line: 5, column: 27], []},
+                      {{:., [line: 5, column: 37], [{:state, [line: 5, column: 32], nil}, :baz]},
+                       [no_parens: true, line: 5, column: 38], []}
+                    ]},
+                   {:__block__, [error: true, line: 5, column: 41], []},
+                   {:__block__,
+                    [
+                      end_of_expression: [newlines: 1, line: 5, column: 43],
+                      error: true,
+                      line: 5,
+                      column: 42
+                    ], []}
+                 ]},
+                [
+                  {[line: 2, column: 8], "missing closing brace for map"},
+                  {[line: 4, column: 1], "unknown token: ,"},
+                  {[line: 5, column: 41], "unknown token: )"},
+                  {[line: 5, column: 42], "unknown token: }"}
+                ]}
+    end
+
     test "example from github issue with list elements" do
       code = ~S'''
       defmodule Foo do