Don't require compile-time features to be enabled in the runtime

Earlier during development of Erlang/OTP 26 we hard-coded the
`maybe_expr` feature to be always enable in the runtime system.
Remove that hack and no longer require any compile-time feature to be
enabled in the runtime system.

4 files changed, 16 insertions, 53 deletions

diff --git a/erts/preloaded/ebin/erlang.beam b/erts/preloaded/ebin/erlang.beam
index f350516f37..1d375c755c 100644
--- a/erts/preloaded/ebin/erlang.beam
+++ b/erts/preloaded/ebin/erlang.beam
diff --git a/erts/preloaded/src/erlang.erl b/erts/preloaded/src/erlang.erl
index cb32ed8ff2..87ff9624c2 100644
--- a/erts/preloaded/src/erlang.erl
+++ b/erts/preloaded/src/erlang.erl
@@ -2336,26 +2336,15 @@ is_tuple(_Term) ->
               | {features_not_allowed, [atom()]}.
 load_module(Mod, Code) ->
     try
-        Allowed =
-            case erlang:module_loaded(erl_features) of
-                true ->
-                    erl_features:load_allowed(Code);
-                false -> ok
-            end,
-        case Allowed of
-            {not_allowed, NotEnabled} ->
-                {error, {features_not_allowed, NotEnabled}};
-            ok ->
-                case erlang:prepare_loading(Mod, Code) of
-                    {error,_}=Error ->
-                        Error;
-                    Prep when erlang:is_reference(Prep) ->
-                        case erlang:finish_loading([Prep]) of
-                            ok ->
-                                {module,Mod};
-                            {Error,[Mod]} ->
-                                {error,Error}
-                        end
+        case erlang:prepare_loading(Mod, Code) of
+            {error,_}=Error ->
+                Error;
+            Prep when erlang:is_reference(Prep) ->
+                case erlang:finish_loading([Prep]) of
+                    ok ->
+                        {module,Mod};
+                    {Error,[Mod]} ->
+                        {error,Error}
                 end
         end
     catch
diff --git a/erts/test/erlc_SUITE.erl b/erts/test/erlc_SUITE.erl
index a0417051b7..1149d8816d 100644
--- a/erts/test/erlc_SUITE.erl
+++ b/erts/test/erlc_SUITE.erl
@@ -840,9 +840,9 @@ features_macros(Config) when is_list(Config) ->
 
     true = erpc:call(Node1, erlang, module_loaded, [erl_features]),
 
-    %% We can't load this due to experimental_ftr_1 not being enabled
-    %% in the runtime
-    {error, {features_not_allowed, [experimental_ftr_1]}} =
+    %% Starting from OTP 26, compile-time features don't need to be
+    %% enabled in the runtime system.
+    {module, f_macros} =
         erpc:call(Node1, code, load_file, [f_macros]),
     %% Check features enabled during compilation
     [approved_ftr_1, approved_ftr_2, experimental_ftr_1] =
@@ -934,8 +934,6 @@ features_all(Config) when is_list(Config) ->
                            "-disable-feature", "all"]),
     %% Check features enabled during compilation
     [approved_ftr_2] = erpc:call(Node2, erl_features, used, [foo]),
-    {error, {features_not_allowed, [approved_ftr_2]}} =
-        erpc:call(Node2, code, load_file, [foo]),
     peer:stop(Peer2),
 
     ok.
@@ -975,8 +973,7 @@ features_runtime(Config) when is_list(Config) ->
                   experimental_ftr_1,
                   experimental_ftr_2],
     Approved = [approved_ftr_2,
-                approved_ftr_1,
-                maybe_expr],
+                approved_ftr_1],
 
     {_Compile, _SrcDir, _OutDir} = compile_fun(Config),
 
@@ -1011,14 +1008,14 @@ features_runtime(Config) when is_list(Config) ->
     peer:stop(Peer0),
 
     {Peer1, Node1} = peer(["-enable-feature", "experimental_ftr_2"]),
-    [experimental_ftr_2, approved_ftr_2, approved_ftr_1, maybe_expr] =
+    [experimental_ftr_2, approved_ftr_2, approved_ftr_1] =
         erpc:call(Node1, erl_features, enabled, []),
     [while, until, unless] =  erpc:call(Node1, erl_features, keywords, []),
 
     peer:stop(Peer1),
 
     {Peer2, Node2} = peer(["-disable-feature", "all"]),
-    [maybe_expr] = erpc:call(Node2, erl_features, enabled, []),
+    [] = erpc:call(Node2, erl_features, enabled, []),
     [] =  erpc:call(Node2, erl_features, keywords, []),
 
     peer:stop(Peer2),
diff --git a/lib/stdlib/src/erl_features.erl b/lib/stdlib/src/erl_features.erl
index ac2ecd3c37..ffccfcbfb3 100644
--- a/lib/stdlib/src/erl_features.erl
+++ b/lib/stdlib/src/erl_features.erl
@@ -26,7 +26,6 @@
          short/1,
          long/1,
          enabled/0,
-         load_allowed/1,
          keywords/0,
          keywords/1,
          keyword_fun/2,
@@ -386,15 +385,12 @@ init_features() ->
                     Features),
 
     %% Save state
-    Enabled = lists:uniq(Enabled0 ++ permanently_enabled_in_erts()),
+    Enabled = lists:uniq(Enabled0),
     enabled_features(Enabled),
     set_keywords(Keywords),
     persistent_term:put({?MODULE, init_done}, true),
     ok.
 
-permanently_enabled_in_erts() ->
-    [maybe_expr].
-
 init_specs() ->
     Specs = case os:getenv("OTP_TEST_FEATURES") of
                 "true" -> test_features();
@@ -428,25 +424,6 @@ keywords() ->
 set_keywords(Words) ->
     persistent_term:put({?MODULE, keywords}, Words).
 
-%% Check that any features used in the module are enabled in the
-%% runtime system.  If not, return
-%%  {not_allowed, <list of not enabled features>}.
--spec load_allowed(binary()) -> ok | {not_allowed, [feature()]}.
-load_allowed(Binary) ->
-    maybe
-        Meta = erts_internal:beamfile_chunk(Binary, "Meta"),
-        true ?= Meta =/= undefined,
-        MetaData = binary_to_term(Meta),
-        Used = proplists:get_value(enabled_features, MetaData, []),
-        Enabled = enabled(),
-        NotEnabled = [UFtr || UFtr <- Used,
-                              not lists:member(UFtr, Enabled)],
-        [_|_] ?= NotEnabled,
-        {not_allowed, NotEnabled}
-    else
-        _ -> ok
-    end.
-
 %% Return features used by module or beam file
 -spec used(module() | file:filename()) -> [feature()].
 used(Module) when is_atom(Module) ->