Structured parse_errors and type_errors

test/aeso_abi_tests.erl

@@ -161,8 +161,10 @@ permissive_literals_fail_test() ->
         "contract OracleTest =\n"
         "  stateful entrypoint haxx(o : oracle(list(string), option(int))) =\n"
         "    Chain.spend(o, 1000000)\n",
-        {error, <<"Type errors\nCannot unify", _/binary>>} =
-            aeso_compiler:check_call(Contract, "haxx", ["#123"], []),
+    {error, [Err]} =
+        aeso_compiler:check_call(Contract, "haxx", ["#123"], []),
+    ?assertMatch("Cannot unify" ++ _, aeso_errors:pp(Err)),
+    ?assertEqual(type_error, aeso_errors:type(Err)),
     ok.
 
 encode_decode_calldata(FunName, Types, Args) ->

test/aeso_aci_tests.erl

@@ -107,11 +107,11 @@ aci_test_contract(Name) ->
 
 check_stub(Stub, Options) ->
     case aeso_parser:string(binary_to_list(Stub), Options) of
-        {ok, Ast} ->
+        Ast ->
             try
                 %% io:format("AST: ~120p\n", [Ast]),
                 aeso_ast_infer_types:infer(Ast, [])
-            catch _:{type_errors, TE} ->
+            catch throw:{type_errors, TE} ->
                 io:format("Type error:\n~s\n", [TE]),
                 error(TE);
                   _:R ->

test/aeso_compiler_tests.erl

@@ -35,10 +35,10 @@ simple_compile_test_() ->
      [ {"Testing error messages of " ++ ContractName,
         fun() ->
             case compile(aevm, ContractName) of
-                <<"Type errors\n", ErrorString/binary>> ->
-                    check_errors(lists:sort(ExpectedErrors), ErrorString);
                 <<"Parse errors\n", ErrorString/binary>> ->
-                    check_errors(lists:sort(ExpectedErrors), ErrorString)
+                    check_errors(lists:sort(ExpectedErrors), ErrorString);
+                Errors ->
+                    check_errors(lists:sort(ExpectedErrors), Errors)
             end
         end} ||
             {ContractName, ExpectedErrors} <- failing_contracts() ] ++
@@ -65,9 +65,8 @@ simple_compile_test_() ->
             ok
         end} || Backend <- [aevm, fate] ].
 
-check_errors(Expect, ErrorString) ->
-    %% This removes the final single \n as well.
-    Actual = binary:split(<<ErrorString/binary,$\n>>, <<"\n\n">>, [global,trim]),
+check_errors(Expect, Actual0) ->
+    Actual = [ list_to_binary(string:trim(aeso_errors:msg(Err))) || Err <- Actual0 ],
     case {Expect -- Actual, Actual -- Expect} of
         {[], Extra}   -> ?assertMatch({unexpected, []}, {unexpected, Extra});
         {Missing, []} -> ?assertMatch({missing, []}, {missing, Missing});
@@ -81,8 +80,9 @@ compile(Backend, Name) ->
 compile(Backend, Name, Options) ->
     String = aeso_test_utils:read_contract(Name),
     case aeso_compiler:from_string(String, [{src_file, Name}, {backend, Backend} | Options]) of
-        {ok, Map}            -> Map;
-        {error, ErrorString} -> ErrorString
+        {ok, Map}                                        -> Map;
+        {error, ErrorString} when is_binary(ErrorString) -> ErrorString;
+        {error, Errors}                                  -> Errors
     end.
 
 %% compilable_contracts() -> [ContractName].
@@ -353,8 +353,7 @@ failing_contracts() ->
           "but it calls\n"
           "  - state (at line 13, column 13)">>]}
     , {"field_parse_error",
-       [<<"line 6, column 1: In field_parse_error at 5:26:\n"
-          "Cannot use nested fields or keys in record construction: p.x\n">>]}
+       [<<"Cannot use nested fields or keys in record construction: p.x">>]}
     , {"modifier_checks",
        [<<"The function all_the_things (at line 11, column 3) cannot be both public and private.">>,
         <<"Namespaces cannot contain entrypoints (at line 3, column 3). Use 'function' instead.">>,

test/aeso_parser_tests.erl

@@ -39,7 +39,7 @@ simple_contracts_test_() ->
             RightAssoc = fun(Op) -> CheckParens({a, Op, {b, Op, c}}) end,
             NonAssoc   = fun(Op) ->
                             OpAtom = list_to_atom(Op),
-                            ?assertError({error, {_, parse_error, _}},
+                            ?assertThrow({parse_errors, [_]},
                                          parse_expr(NoPar({a, Op, {b, Op, c}}))) end,
             Stronger = fun(Op1, Op2) ->
                     CheckParens({{a, Op1, b}, Op2, c}),
@@ -74,10 +74,7 @@ roundtrip_contract(Name) ->
 parse_string(Text) -> parse_string(Text, []).
 
 parse_string(Text, Opts) ->
-    case aeso_parser:string(Text, Opts) of
-        {ok, Contract} -> Contract;
-        Err -> error(Err)
-    end.
+    aeso_parser:string(Text, Opts).
 
 parse_expr(Text) ->
     [{letval, _, _, _, Expr}] =