Forward port changes from v0.6 release branch

Merge from release-0.6:
- Implement erlang:nif_error/1 (#1768)
- Replace quick_sort with merge_sort for lists (#1767)
- Fix lists:seq/2,3 when they should return an empty list (#1766)

Author: bettio

CHANGELOG.md

@@ -74,10 +74,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 
 - Added `lists:keysort/2`
+- Added `lists:merge/2,3`
 
 ### Fixed
 
 - Fixed a bug where binary matching could fail due to a missing preservation of the matched binary.
+- Fixed a bug where `lists:seq/2` wouldn't return the empty list in valid cases.
+
+### Changed
+
+- lists sort function now use a stable merge sort implementation instead of quick sort
 
 ## [0.6.6] - 2025-06-23
 

libs/estdlib/src/lists.erl

@@ -60,6 +60,7 @@
     join/2,
     seq/2, seq/3,
     sort/1, sort/2,
+    merge/2, merge/3,
     split/2,
     usort/1, usort/2,
     dropwhile/2,
@@ -622,7 +623,9 @@ join_1(_Sep, []) ->
 %%-----------------------------------------------------------------------------
 -spec seq(From :: integer(), To :: integer()) -> list().
 seq(From, To) when is_integer(From) andalso is_integer(To) andalso From =< To ->
-    seq_r(From, To, 1, []).
+    seq_r(From, To, 1, []);
+seq(From, To) when is_integer(From) andalso is_integer(To) andalso From =:= To + 1 ->
+    [].
 
 %%-----------------------------------------------------------------------------
 %% @param   From    from integer
@@ -644,6 +647,8 @@ seq(From, To, Incr) when
     error(badarg);
 seq(To, To, 0) ->
     [To];
+seq(From, To, Incr) when From =:= To + Incr ->
+    [];
 seq(From, To, Incr) ->
     Last = From + ((To - From) div Incr) * Incr,
     seq_r(From, Last, Incr, []).
@@ -672,8 +677,23 @@ sort(List) when is_list(List) ->
 %% @end
 %%-----------------------------------------------------------------------------
 -spec sort(Fun :: fun((T, T) -> boolean()), List :: [T]) -> [T].
-sort(Fun, List) when is_function(Fun), is_list(List) ->
-    quick_sort(Fun, List).
+sort(Fun, List) when is_function(Fun, 2), is_list(List) ->
+    merge_sort(Fun, List).
+
+merge_sort(_Fun, []) ->
+    [];
+merge_sort(_Fun, [_] = L) ->
+    L;
+merge_sort(Fun, List) ->
+    {H1, H2} = merge_sort_split(List, List, []),
+    merge(Fun, merge_sort(Fun, H1), merge_sort(Fun, H2), []).
+
+merge_sort_split([], Half1, Half2) ->
+    {lists:reverse(Half2), Half1};
+merge_sort_split([_], Half1, Half2) ->
+    {lists:reverse(Half2), Half1};
+merge_sort_split([_, _ | T], [H | Half1T], Half2) ->
+    merge_sort_split(T, Half1T, [H | Half2]).
 
 %%-----------------------------------------------------------------------------
 %% @param   N elements non negative Integer
@@ -708,14 +728,39 @@ split(N, [H | T], R) ->
 split(_, [], _) ->
     badarg.
 
-%% Attribution: https://erlang.org/doc/programming_examples/list_comprehensions.html#quick-sort
-%% @private
-quick_sort(Fun, [Pivot | T]) ->
-    quick_sort(Fun, [X || X <- T, Fun(X, Pivot)]) ++
-        [Pivot] ++
-        quick_sort(Fun, [X || X <- T, not Fun(X, Pivot)]);
-quick_sort(_Fun, []) ->
-    [].
+%%-----------------------------------------------------------------------------
+%% @param   List1 first list to merge, previously sorted
+%% @param   List2 second list to merge, previously sorted
+%% @returns Merged list of List1 and List2
+%% @doc     Returns a list formed by merging List1 and List2, following natural
+%%          order. If elements compare equal, element from List1 is picked first
+%% @end
+%%-----------------------------------------------------------------------------
+merge(List1, List2) ->
+    merge(fun lt/2, List1, List2, []).
+
+%%-----------------------------------------------------------------------------
+%% @param   Fun ordering function
+%% @param   List1 first list to merge, previously sorted
+%% @param   List2 second list to merge, previously sorted
+%% @returns Merged list of List1 and List2
+%% @doc     Returns a list formed by merging List1 and List2, following Fun
+%%          order. If elements compare equal, element from List1 is picked first
+%% @end
+%%-----------------------------------------------------------------------------
+merge(Fun, List1, List2) ->
+    merge(Fun, List1, List2, []).
+
+merge(_Fun, [], Right, Acc) ->
+    lists:reverse(Acc, Right);
+merge(_Fun, Left, [], Acc) ->
+    lists:reverse(Acc, Left);
+merge(Fun, [A | As], [B | Bs], Acc) ->
+    % keep sort stable, if B < A, put it first, otherwise keep A first
+    case Fun(B, A) of
+        true -> merge(Fun, [A | As], Bs, [B | Acc]);
+        false -> merge(Fun, As, [B | Bs], [A | Acc])
+    end.
 
 %% @private
 lt(A, B) -> A < B.

src/libAtomVM/nifs.c

@@ -194,6 +194,7 @@ static term nif_code_load_abs(Context *ctx, int argc, term argv[]);
 static term nif_code_load_binary(Context *ctx, int argc, term argv[]);
 static term nif_code_ensure_loaded(Context *ctx, int argc, term argv[]);
 static term nif_erlang_module_loaded(Context *ctx, int argc, term argv[]);
+static term nif_erlang_nif_error(Context *ctx, int argc, term argv[]);
 static term nif_lists_reverse(Context *ctx, int argc, term argv[]);
 static term nif_maps_from_keys(Context *ctx, int argc, term argv[]);
 static term nif_maps_next(Context *ctx, int argc, term argv[]);
@@ -831,6 +832,12 @@ static const struct Nif module_loaded_nif =
     .nif_ptr = nif_erlang_module_loaded
 };
 
+static const struct Nif nif_error_nif =
+{
+    .base.type = NIFFunctionType,
+    .nif_ptr = nif_erlang_nif_error
+};
+
 static const struct Nif lists_reverse_nif =
 {
     .base.type = NIFFunctionType,
@@ -5414,6 +5421,14 @@ static term nif_erlang_module_loaded(Context *ctx, int argc, term argv[])
     return module != NULL ? TRUE_ATOM : FALSE_ATOM;
 }
 
+static term nif_erlang_nif_error(Context *ctx, int argc, term argv[])
+{
+    UNUSED(argc);
+    UNUSED(argv);
+
+    RAISE_ERROR(UNDEF_ATOM);
+}
+
 static term nif_lists_reverse(Context *ctx, int argc, term argv[])
 {
     // Compared to erlang version, compute the length of the list and allocate

src/libAtomVM/nifs.gperf

@@ -138,6 +138,7 @@ erlang:dist_ctrl_get_data_notification/1, &dist_ctrl_get_data_notification_nif
 erlang:dist_ctrl_get_data/1, &dist_ctrl_get_data_nif
 erlang:dist_ctrl_put_data/2, &dist_ctrl_put_data_nif
 erlang:module_loaded/1,&module_loaded_nif
+erlang:nif_error/1,&nif_error_nif
 erts_debug:flat_size/1, &flat_size_nif
 ets:new/2, &ets_new_nif
 ets:insert/2, &ets_insert_nif

tests/libs/estdlib/test_lists.erl

@@ -133,6 +133,34 @@ test_keysort() ->
     ?ASSERT_MATCH(lists:keysort(2, [{foo, 2}, {bar, 1}]), [{bar, 1}, {foo, 2}]),
     ?ASSERT_ERROR(lists:keysort(1, [1, 2])),
     ?ASSERT_ERROR(lists:keysort(3, [{1, bar}, {2, foo}])),
+
+    % Our sort is always stable, but older versions of OTP only have
+    % keysort/2 documented as stable
+    ?ASSERT_MATCH(
+        lists:keysort(1, [
+            {3, a}, {2, c}, {1, z}, {2, b}, {2, a}
+        ]),
+        [{1, z}, {2, c}, {2, b}, {2, a}, {3, a}]
+    ),
+    ?ASSERT_MATCH(
+        lists:keysort(1, [
+            {3, a}, {1, z}, {2, c}, {2, b}, {2, a}
+        ]),
+        [{1, z}, {2, c}, {2, b}, {2, a}, {3, a}]
+    ),
+    ?ASSERT_MATCH(
+        lists:keysort(1, [
+            {3, a}, {2, c}, {2, b}, {1, z}, {2, a}
+        ]),
+        [{1, z}, {2, c}, {2, b}, {2, a}, {3, a}]
+    ),
+    ?ASSERT_MATCH(
+        lists:keysort(1, [
+            {3, a}, {2, c}, {2, b}, {2, a}, {1, z}
+        ]),
+        [{1, z}, {2, c}, {2, b}, {2, a}, {3, a}]
+    ),
+
     ok.
 
 test_keystore() ->
@@ -287,6 +315,8 @@ test_seq() ->
     ?ASSERT_MATCH(lists:seq(5, 1, -1), [5, 4, 3, 2, 1]),
     ?ASSERT_MATCH(lists:seq(1, 1, 0), [1]),
     ?ASSERT_MATCH(lists:seq(1, 1), [1]),
+    ?ASSERT_MATCH(lists:seq(1, 0), []),
+    ?ASSERT_MATCH(lists:seq(1, 0, 1), []),
 
     ?ASSERT_ERROR(lists:seq(foo, 1)),
     ?ASSERT_ERROR(lists:seq(1, bar)),