File 3542-features-Add-support-for-handling-features... of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 3542-features-Add-support-for-handling-features.patch of Package erlang (Revision 33fb1bfcfb3bce757d0f7cfc6a9a3eaf)

Currently displaying revision 33fb1bfcfb3bce757d0f7cfc6a9a3eaf , Show latest

From 55b51892b9556c18b2b5aa7607cfe80db9ca4e8d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cons=20T=20=C3=85hs?= <cons@erlang.org>
Date: Mon, 8 Nov 2021 09:47:47 +0100
Subject: [PATCH 2/7] [features] Add support for handling features

* Utility and features specifications in erl_features
* Compiler support
 * Add predefined macros for features
 * Add support for parsing (long) options to erlc
 * Conditionally allow 'else' (also used in preprocessor) as keyword
   * This will be needed for EEP49
 * Add feature info in new Meta chunk in beam file
 * Add warning for atoms that are keywords in features
 * Add new feature description options to erlc
   * -list-feature to list existing features in short form
   * -describe-feature <ftr> to get long description of feature

* Runtime support
 * Store enabled features with persistent_term (only set at startup)
 * Check features in Meta chunk to determine whether load is allowed

* Features use for test (in erl_features) active when env variable
  OTP_TEST_FEATURES is set to true

* init of erl_features is lazy
  * Using on_load functions only work after code_server is up
    and running.
---
 erts/preloaded/src/erlang.erl             |  26 +-
 erts/preloaded/src/erts.app.src           |   2 +-
 lib/compiler/src/compile.erl              |  93 ++--
 lib/kernel/src/code.erl                   |   3 +-
 lib/stdlib/src/Makefile                   |   1 +
 lib/stdlib/src/epp.erl                    | 220 +++++++--
 lib/stdlib/src/erl_compile.erl            |  82 +++-
 lib/stdlib/src/erl_features.erl           | 564 ++++++++++++++++++++++
 lib/stdlib/src/erl_lint.erl               |  28 +-
 lib/stdlib/src/erl_scan.erl               |  72 +--
 lib/stdlib/src/stdlib.app.src             |   1 +
 lib/stdlib/test/epp_SUITE.erl             |  13 +-
 lib/syntax_tools/src/syntax_tools.app.src |   2 +-
 13 files changed, 976 insertions(+), 131 deletions(-)
 create mode 100644 lib/stdlib/src/erl_features.erl

diff --git a/erts/preloaded/src/erlang.erl b/erts/preloaded/src/erlang.erl
index b0430f4182..bbdd46dd80 100644
--- a/erts/preloaded/src/erlang.erl
+++ b/erts/preloaded/src/erlang.erl
@@ -2310,18 +2310,24 @@ is_tuple(_Term) ->
 -spec load_module(Module, Binary) -> {module, Module} | {error, Reason} when
       Module :: module(),
       Binary :: binary(),
-      Reason :: badfile | not_purged | on_load.
+      Reason :: badfile | not_purged | on_load | not_allowed.
 load_module(Mod, Code) ->
     try
-        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}
+        Allowed = (not erlang:module_loaded(erl_features))
+            orelse erl_features:load_allowed(Code),
+        if not Allowed ->
+                {error, not_allowed};
+           true ->
+                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
         end
     catch
diff --git a/lib/compiler/src/compile.erl b/lib/compiler/src/compile.erl
index 847ea484ba..d82f53d772 100644
--- a/lib/compiler/src/compile.erl
+++ b/lib/compiler/src/compile.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1996-2021. All Rights Reserved.
+%% Copyright Ericsson AB 1996-2022. All Rights Reserved.
 %%
 %% Licensed under the Apache License, Version 2.0 (the "License");
 %% you may not use this file except in compliance with the License.
@@ -1018,41 +1018,65 @@ do_parse_module(DefEncoding, #compile{ifile=File,options=Opts,dir=Dir}=St) ->
                         false ->
                             1
                     end,
-
-    %% FIXME: Rewrite this when the enable feature EEP has been implemented.
-    ResWordFun = case proplists:get_value(enable_feature, Opts, []) of
-                     maybe_expr ->
-                         fun('maybe') -> true;
-                            ('else') -> true;
-                            (Other) -> erl_scan:reserved_word(Other)
-                         end;
-                     _ ->
-                         fun erl_scan:reserved_word/1
-                 end,
-
-    R = epp:parse_file(File,
-                       [{includes,[".",Dir|inc_paths(Opts)]},
-                        {source_name, SourceName},
-                        {macros,pre_defs(Opts)},
-                        {default_encoding,DefEncoding},
-                        {location,StartLocation},
-                        {reserved_word_fun,ResWordFun},
-                        extra]),
-    case R of
-	{ok,Forms0,Extra} ->
-	    Encoding = proplists:get_value(encoding, Extra),
-            Forms = case with_columns(Opts ++ compile_options(Forms0)) of
-                        true ->
-                            Forms0;
-                        false ->
-                            strip_columns(Forms0)
-                    end,
-            {ok,Forms,St#compile{encoding=Encoding}};
-	{error,E} ->
-	    Es = [{St#compile.ifile,[{none,?MODULE,{epp,E}}]}],
-	    {error,St#compile{errors=St#compile.errors ++ Es}}
+    case erl_features:keyword_fun(Opts, fun erl_scan:f_reserved_word/1) of
+        {ok, {Features, ResWordFun}} ->
+            R = epp:parse_file(File,
+                               [{includes,[".",Dir|inc_paths(Opts)]},
+                                {source_name, SourceName},
+                                {macros,pre_defs(Opts)},
+                                {default_encoding,DefEncoding},
+                                {location,StartLocation},
+                                {reserved_word_fun, ResWordFun},
+                                {features, Features},
+                                extra]),
+            case R of
+                %% FIXME Extra should include used features as well
+                {ok,Forms0,Extra} ->
+                    Encoding = proplists:get_value(encoding, Extra),
+                    %% Get features used in the module, indicated by
+                    %% enabling features with
+                    %% -compile({enable_feature, ..}).
+                    UsedFtrs = proplists:get_value(features, Extra),
+                    St1 = metadata_add_features(UsedFtrs, St),
+                    Forms = case with_columns(Opts ++ compile_options(Forms0)) of
+                                true ->
+                                    Forms0;
+                                false ->
+                                    strip_columns(Forms0)
+                            end,
+                    {ok,Forms,St1#compile{encoding=Encoding}};
+                {error,E} ->
+                    Es = [{St#compile.ifile,[{none,?MODULE,{epp,E}}]}],
+                    {error,St#compile{errors=St#compile.errors ++ Es}}
+            end;
+        {error, {Mod, Reason}} ->
+            Es = [{St#compile.ifile,[{none, Mod, Reason}]}],
+            {error, St#compile{errors = St#compile.errors ++ Es}}
     end.
 
+%% The atom to be used in the proplist of the meta chunk indicating
+%% the features used when compiling the module.
+-define(META_USED_FEATURES, enabled_features).
+-define(META_CHUNK_NAME, <<"Meta">>).
+
+metadata_add_features(Ftrs, #compile{extra_chunks = Extra} = St) ->
+    MetaData =
+        case proplists:get_value(?META_CHUNK_NAME, Extra) of
+            undefined ->
+                [];
+            Bin ->
+                erlang:binary_to_term(Bin)
+        end,
+    OldFtrs = proplists:get_value(?META_USED_FEATURES, MetaData, []),
+    NewFtrs = (Ftrs -- OldFtrs) ++ OldFtrs,
+    MetaData1 =
+        proplists:from_map(maps:put(?META_USED_FEATURES, NewFtrs,
+                                    proplists:to_map(MetaData))),
+    Extra1 = proplists:from_map(maps:put(?META_CHUNK_NAME,
+                                         erlang:term_to_binary(MetaData1),
+                                         proplists:to_map(Extra))),
+    St#compile{extra_chunks = Extra1}.
+
 with_columns(Opts) ->
     case proplists:get_value(error_location, Opts, column) of
         column -> true;
@@ -2081,6 +2105,7 @@ pre_load() ->
 	 epp,
 	 erl_bifs,
 	 erl_expand_records,
+         erl_features,
 	 erl_lint,
 	 erl_parse,
 	 erl_scan,
diff --git a/lib/kernel/src/code.erl b/lib/kernel/src/code.erl
index 71a570fa7b..3b426600d3 100644
--- a/lib/kernel/src/code.erl
+++ b/lib/kernel/src/code.erl
@@ -739,7 +739,8 @@ do_start() ->
 
 load_code_server_prerequisites() ->
     %% Please keep the alphabetical order.
-    Needed = [binary,
+    Needed = [beam_lib,
+              binary,
 	      ets,
 	      filename,
 	      gb_sets,
diff --git a/lib/stdlib/src/Makefile b/lib/stdlib/src/Makefile
index 88f41634fe..b7b5ead962 100644
--- a/lib/stdlib/src/Makefile
+++ b/lib/stdlib/src/Makefile
@@ -65,6 +65,7 @@ MODULES= \
 	erl_error \
 	erl_eval \
 	erl_expand_records \
+	erl_features \
 	erl_internal \
 	erl_lint \
 	erl_parse \
diff --git a/lib/stdlib/src/epp.erl b/lib/stdlib/src/epp.erl
index 1f14133039..1c2dbcb3bb 100644
--- a/lib/stdlib/src/epp.erl
+++ b/lib/stdlib/src/epp.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1996-2021. All Rights Reserved.
+%% Copyright Ericsson AB 1996-2022. All Rights Reserved.
 %%
 %% Licensed under the Apache License, Version 2.0 (the "License");
 %% you may not use this file except in compliance with the License.
@@ -72,9 +72,12 @@
               uses = #{}			%Macro use structure
 	            :: #{name() => [{argspec(), [used()]}]},
               default_encoding = ?DEFAULT_ENCODING :: source_encoding(),
-	      pre_opened = false :: boolean(),
-              fname = [] :: function_name_type(),
-              erl_scan_opts = [] :: erl_scan:options()
+              pre_opened = false :: boolean(),
+              in_prefix = true :: boolean(),
+              erl_scan_opts = [] :: [_],
+              features = [] :: [atom()],
+              else_reserved = false :: boolean(),
+              fname = [] :: function_name_type()
 	     }).
 
 %% open(Options)
@@ -132,12 +135,14 @@ open(Options) ->
         Name ->
             Self = self(),
             Epp = spawn(fun() -> server(Self, Name, Options) end),
+            Extra = proplists:get_bool(extra, Options),
             case epp_request(Epp) of
-                {ok, Pid, Encoding} ->
-                    case proplists:get_bool(extra, Options) of
-                        true -> {ok, Pid, [{encoding, Encoding}]};
-                        false -> {ok, Pid}
-                    end;
+                {ok, Pid, Encoding} when Extra ->
+                    {ok, Pid, [{encoding, Encoding}]};
+                {ok, Pid, _} ->
+                    {ok, Pid};
+                {ok, Pid} when Extra ->
+                    {ok, Pid, []};
                 Other ->
                     Other
             end
@@ -240,6 +245,8 @@ format_error({error,Term}) ->
     io_lib:format("-error(~tp).", [Term]);
 format_error({warning,Term}) ->
     io_lib:format("-warning(~tp).", [Term]);
+format_error(ftr_after_prefix) ->
+    "feature directive not allowed after anything interesting";
 format_error(E) -> file:format_error(E).
 
 -spec scan_file(FileName, Options) ->
@@ -298,6 +305,8 @@ parse_file(Ifile, Path, Predefs) ->
 		  {'macros', PredefMacros :: macros()} |
 		  {'default_encoding', DefEncoding :: source_encoding()} |
 		  {'location',StartLocation :: erl_anno:location()} |
+                  {'reserved_word_fun', Fun :: fun((atom()) -> boolean())} |
+                  {'features', [Feature :: atom()]} |
 		  'extra'],
       Form :: erl_parse:abstract_form()
             | {'error', ErrorInfo}
@@ -312,11 +321,13 @@ parse_file(Ifile, Options) ->
 	{ok,Epp} ->
 	    Forms = parse_file(Epp),
 	    close(Epp),
-	    {ok,Forms};
+	    {ok, Forms};
 	{ok,Epp,Extra} ->
 	    Forms = parse_file(Epp),
+            Epp ! {get_features, self()},
+            Ftrs = receive X -> X end,
 	    close(Epp),
-	    {ok,Forms,Extra};
+	    {ok, Forms, [{features, Ftrs} | Extra]};
 	{error,E} ->
 	    {error,E}
     end.
@@ -594,7 +605,8 @@ server(Pid, Name, Options) ->
 init_server(Pid, FileName, Options, St0) ->
     SourceName = proplists:get_value(source_name, Options, FileName),
     Pdm = proplists:get_value(macros, Options, []),
-    Ms0 = predef_macros(SourceName),
+    Features = proplists:get_value(features, Options, []),
+    Ms0 = predef_macros(SourceName, Features),
     case user_predef(Pdm, Ms0) of
 	{ok,Ms1} ->
             DefEncoding = proplists:get_value(default_encoding, Options,
@@ -605,16 +617,19 @@ init_server(Pid, FileName, Options, St0) ->
             %% first in path
             Path = [filename:dirname(FileName) |
                     proplists:get_value(includes, Options, [])],
-
-            ResWordFun = proplists:get_value(reserved_word_fun, Options,
-                                             fun erl_scan:reserved_word/1),
-
+            ResWordFun =
+                proplists:get_value(reserved_word_fun, Options,
+                                    fun erl_scan:f_reserved_word/1),
             %% the default location is 1 for backwards compatibility, not {1,1}
             AtLocation = proplists:get_value(location, Options, 1),
+
             St = St0#epp{delta=0, name=SourceName, name2=SourceName,
 			 path=Path, location=AtLocation, macs=Ms1,
 			 default_encoding=DefEncoding,
-                         erl_scan_opts=[{reserved_word_fun,ResWordFun}]},
+                         erl_scan_opts =
+                             [{reserved_word_fun, ResWordFun}],
+                         features = Features,
+                         else_reserved = ResWordFun('else')},
             From = wait_request(St),
             Anno = erl_anno:new(AtLocation),
             enter_file_reply(From, file_name(SourceName), Anno,
@@ -628,10 +643,11 @@ init_server(Pid, FileName, Options, St0) ->
 %%  Initialise the macro dictionary with the default predefined macros,
 %%  FILE, LINE, MODULE as undefined, MACHINE and MACHINE value.
 
-predef_macros(File) ->
+predef_macros(File, EnabledFeatures) ->
     Machine = list_to_atom(erlang:system_info(machine)),
     Anno = line1(),
     OtpVersion = list_to_integer(erlang:system_info(otp_release)),
+    AvailableFeatures = erl_features:features(),
     Defs = [{'FILE', 	           {none,[{string,Anno,File}]}},
 	    {'FUNCTION_NAME',      undefined},
 	    {'FUNCTION_ARITY',     undefined},
@@ -642,10 +658,38 @@ predef_macros(File) ->
 	    {'BASE_MODULE_STRING', undefined},
 	    {'MACHINE',	           {none,[{atom,Anno,Machine}]}},
 	    {Machine,	           {none,[{atom,Anno,true}]}},
-	    {'OTP_RELEASE',	   {none,[{integer,Anno,OtpVersion}]}}
+	    {'OTP_RELEASE',	   {none,[{integer,Anno,OtpVersion}]}},
+            %% FIXME Understand this has to be a list.  Is it because
+            %% it takes an argument?
+            {'FEATURE_AVAILABLE',  [ftr_macro(AvailableFeatures)]},
+            {'FEATURE_ENABLED', [ftr_macro(EnabledFeatures)]}
 	   ],
     maps:from_list(Defs).
 
+%% Make macro definition from a list of features.  The macro takes one
+%% argument and returns true when argument is available as a feature.
+ftr_macro(Features) ->
+    Anno = line1(),
+    Arg = 'X',
+    Fexp = fun(Ftr) -> [{'(', Anno},
+                        {var, Anno, Arg},
+                        {')', Anno},
+                        {'==', Anno},
+                        {atom, Anno, Ftr}]
+           end,
+    Body =
+        case Features of
+            [] -> [{atom, Anno, false}];
+            [Ftr| Ftrs] ->
+                [{'(', Anno}|
+                 lists:foldl(fun(F, Expr) ->
+                                     Fexp(F) ++ [{'orelse', Anno} | Expr]
+                            end,
+                            Fexp(Ftr) ++ [{')', Anno}],
+                            Ftrs)]
+        end,
+    {1, {[Arg], Body}}.
+
 %% user_predef(PreDefMacros, Macros) ->
 %%	{ok,MacroDict} | {error,E}
 %%  Add the predefined macros to the macros dictionary. A macro without a
@@ -680,6 +724,9 @@ user_predef([], Ms) -> {ok,Ms}.
 wait_request(St) ->
     receive
 	{epp_request,From,scan_erl_form} -> From;
+        {get_features, From} ->
+            From ! St#epp.features,
+            wait_request(St);
 	{epp_request,From,macro_defs} ->
 	    %% Return the old format to avoid any incompability issues.
 	    Defs = [{{atom,K},V} || {K,V} <- maps:to_list(St#epp.macs)],
@@ -736,7 +783,11 @@ enter_file2(NewF, Pname, From, St0, AtLocation) ->
     Anno = erl_anno:new(AtLocation),
     enter_file_reply(From, Pname, Anno, AtLocation, code),
     #epp{macs = Ms0,
-         default_encoding = DefEncoding} = St0,
+         default_encoding = DefEncoding,
+         in_prefix = InPrefix,
+         erl_scan_opts = ScanOpts,
+         else_reserved = ElseReserved,
+         features = Ftrs} = St0,
     Ms = Ms0#{'FILE':={none,[{string,Anno,Pname}]}},
     %% update the head of the include path to be the directory of the new
     %% source file, so that an included file can always include other files
@@ -748,6 +799,10 @@ enter_file2(NewF, Pname, From, St0, AtLocation) ->
     _ = set_encoding(NewF, DefEncoding),
     #epp{file=NewF,location=AtLocation,name=Pname,name2=Pname,delta=0,
          sstk=[St0|St0#epp.sstk],path=Path,macs=Ms,
+         in_prefix = InPrefix,
+         features = Ftrs,
+         erl_scan_opts = ScanOpts,
+         else_reserved = ElseReserved,
          default_encoding=DefEncoding}.
 
 enter_file_reply(From, Name, LocationAnno, AtLocation, Where) ->
@@ -789,8 +844,16 @@ leave_file(From, St) ->
                     CurrLoc = add_line(OldLoc, Delta),
                     Anno = erl_anno:new(CurrLoc),
 		    Ms0 = St#epp.macs,
+                    InPrefix = St#epp.in_prefix,
+                    Ftrs = St#epp.features,
+                    ElseReserved = St#epp.else_reserved,
+                    ScanOpts = St#epp.erl_scan_opts,
 		    Ms = Ms0#{'FILE':={none,[{string,Anno,OldName2}]}},
-                    NextSt = OldSt#epp{sstk=Sts,macs=Ms,uses=St#epp.uses},
+                    NextSt = OldSt#epp{sstk=Sts,macs=Ms,uses=St#epp.uses,
+                                       in_prefix = InPrefix,
+                                       features = Ftrs,
+                                       else_reserved = ElseReserved,
+                                       erl_scan_opts = ScanOpts},
 		    enter_file_reply(From, OldName, Anno, CurrLoc, code),
                     case OldName2 =:= OldName of
                         true ->
@@ -812,27 +875,30 @@ leave_file(From, St) ->
 %% scan_toks(Tokens, From, EppState)
 
 scan_toks(From, St) ->
-    case io:scan_erl_form(St#epp.file, '', St#epp.location, St#epp.erl_scan_opts) of
-	{ok,Toks,Cl} ->
-	    scan_toks(Toks, From, St#epp{location=Cl});
-	{error,E,Cl} ->
-	    epp_reply(From, {error,E}),
-	    wait_req_scan(St#epp{location=Cl});
-	{eof,Cl} ->
-	    leave_file(From, St#epp{location=Cl});
-	{error,_E} ->
+    #epp{file = File, location = Loc, erl_scan_opts = ScanOpts} = St,
+    case io:scan_erl_form(File, '', Loc, ScanOpts) of
+        {ok,Toks,Cl} ->
+            scan_toks(Toks, From, St#epp{location=Cl});
+        {error,E,Cl} ->
+            epp_reply(From, {error,E}),
+            wait_req_scan(St#epp{location=Cl});
+        {eof,Cl} ->
+            leave_file(From, St#epp{location=Cl});
+        {error,_E} ->
             epp_reply(From, {error,{St#epp.location,epp,cannot_parse}}),
-	    leave_file(wait_request(St), St)	%This serious, just exit!
+            leave_file(wait_request(St), St)	%This serious, just exit!
     end.
 
+scan_toks([{'-',_Lh},{atom,_Ld,feature}=Feature|Toks], From, St) ->
+    scan_feature(Toks, Feature, From, St);
 scan_toks([{'-',_Lh},{atom,_Ld,define}=Define|Toks], From, St) ->
     scan_define(Toks, Define, From, St);
 scan_toks([{'-',_Lh},{atom,_Ld,undef}=Undef|Toks], From, St) ->
-    scan_undef(Toks, Undef, From, St);
+    scan_undef(Toks, Undef, From, leave_prefix(St));
 scan_toks([{'-',_Lh},{atom,_Ld,error}=Error|Toks], From, St) ->
-    scan_err_warn(Toks, Error, From, St);
+    scan_err_warn(Toks, Error, From, leave_prefix(St));
 scan_toks([{'-',_Lh},{atom,_Ld,warning}=Warn|Toks], From, St) ->
-    scan_err_warn(Toks, Warn, From, St);
+    scan_err_warn(Toks, Warn, From, leave_prefix(St));
 scan_toks([{'-',_Lh},{atom,_Li,include}=Inc|Toks], From, St) ->
     scan_include(Toks, Inc, From, St);
 scan_toks([{'-',_Lh},{atom,_Li,include_lib}=IncLib|Toks], From, St) ->
@@ -843,7 +909,9 @@ scan_toks([{'-',_Lh},{atom,_Li,ifndef}=IfnDef|Toks], From, St) ->
     scan_ifndef(Toks, IfnDef, From, St);
 scan_toks([{'-',_Lh},{atom,_Le,'else'}=Else|Toks], From, St) ->
     scan_else(Toks, Else, From, St);
-scan_toks([{'-',_Lh},{'else',_Le}=Else|Toks], From, St) ->
+%% conditionally allow else as a keyword
+scan_toks([{'-',_Lh},{'else',_Le}=Else|Toks], From, St)
+  when St#epp.else_reserved ->
     scan_else(Toks, Else, From, St);
 scan_toks([{'-',_Lh},{'if',_Le}=If|Toks], From, St) ->
     scan_if(Toks, If, From, St);
@@ -862,13 +930,37 @@ scan_toks([{'-',_Lh},{atom,_Lf,file}=FileToken|Toks0], From, St) ->
 scan_toks(Toks0, From, St) ->
     case catch expand_macros(Toks0, St#epp{fname=Toks0}) of
 	Toks1 when is_list(Toks1) ->
+            InPrefix =
+                St#epp.in_prefix
+                andalso case Toks1 of
+                            [] -> true;
+                            [{'-', _Loc}, Tok | _] ->
+                                in_prefix(Tok);
+                            _ ->
+                                false
+                        end,
 	    epp_reply(From, {ok,Toks1}),
-	    wait_req_scan(St#epp{macs=scan_module(Toks1, St#epp.macs)});
+	    wait_req_scan(St#epp{in_prefix = InPrefix,
+                                 macs=scan_module(Toks1, St#epp.macs)});
 	{error,ErrL,What} ->
 	    epp_reply(From, {error,{ErrL,epp,What}}),
 	    wait_req_scan(St)
     end.
 
+%% Determine whether we have passed the prefix where a -feature
+%% directive is allowed.
+in_prefix({atom, _, Atom}) ->
+    %% These directives are allowed inside the prefix
+    lists:member(Atom, ['module', 'feature',
+                        'if', 'else', 'elif', 'endif', 'ifdef', 'ifndef',
+                        'define', 'undef',
+                        'include', 'include_lib']);
+in_prefix(_T) ->
+    false.
+
+leave_prefix(#epp{} = St) ->
+    St#epp{in_prefix = false}.
+
 scan_module([{'-',_Ah},{atom,_Am,module},{'(',_Al}|Ts], Ms) ->
     scan_module_1(Ts, Ms);
 scan_module([{'-',_Ah},{atom,_Am,extends},{'(',_Al}|Ts], Ms) ->
@@ -909,6 +1001,58 @@ scan_err_warn(Toks, {atom,_,Tag}=Token, From, St) ->
     epp_reply(From, {error,{loc(T),epp,{bad,Tag}}}),
     wait_req_scan(St).
 
+%% scan a feature directive
+scan_feature([{'(', _Ap}, {atom, _Am, Ind},
+              {',', _}, {atom, _, Ftr}, {')', _}, {dot, _}],
+             Feature, From, St)
+  when St#epp.in_prefix,
+       (Ind =:= enable
+        orelse Ind =:= disable) ->
+    case update_features(St, Ind, Ftr, loc(Feature)) of
+        {ok, St1} ->
+            scan_toks(From, St1);
+        {error, {{Mod, Reason}, ErrLoc}} ->
+            epp_reply(From, {error, {ErrLoc, Mod, Reason}}),
+            wait_req_scan(St)
+    end;
+scan_feature([{'(', _Ap}, {atom, _Am, _Ind},
+              {',', _}, {atom, _, _Ftr}, {')', _}, {dot, _}| _Toks],
+             Feature, From, St) when not St#epp.in_prefix ->
+    epp_reply(From, {error, {loc(Feature), epp,
+                             ftr_after_prefix}}),
+    wait_req_scan(St);
+scan_feature(Toks, {atom, _, Tag} = Token, From, St) ->
+    T = no_match(Toks, Token),
+    epp_reply(From, {error,{loc(T),epp,{bad,Tag}}}),
+    wait_req_scan(St).
+
+%% FIXME Rewrite this
+update_features(St0, Ind, Ftr, Loc) ->
+    Ftrs0 = St0#epp.features,
+    ScanOpts = St0#epp.erl_scan_opts,
+    KeywordFun =
+        case proplists:get_value(reserved_word_fun, ScanOpts) of
+            undefined -> fun erl_scan:f_reserved_word/1;
+            Fun -> Fun
+        end,
+    case erl_features:keyword_fun(Ind, Ftr, Ftrs0, KeywordFun) of
+        {error, Reason} ->
+            {error, {Reason, Loc}};
+        {ok, ResWordFun1, Ftrs1} ->
+            Macs0 = St0#epp.macs,
+            Macs1 = Macs0#{'FEATURE_ENABLED' => [ftr_macro(Ftrs1)]},
+            %% ?liof("ok!\n", []),
+            %% FIXME WE need to keep any other scan_opts
+            %% present.  Right now, there are no other, but
+            %% that might change.
+            StX = St0#epp{erl_scan_opts =
+                              [{reserved_word_fun, ResWordFun1}],
+                          features = Ftrs1,
+                          else_reserved = ResWordFun1('else'),
+                          macs = Macs1},
+            {ok, StX}
+    end.
+
 %% scan_define(Tokens, DefineToken, From, EppState)
 
 scan_define([{'(',_Ap},{Type,_Am,_}=Mac|Toks], Def, From, St)
@@ -1328,6 +1472,7 @@ new_location(Ln, {Le,_}, {Lf,_}) ->
 %%  nested conditionals and repeated 'else's.
 
 skip_toks(From, St, [I|Sis]) ->
+    ElseReserved = St#epp.else_reserved,
     case io:scan_erl_form(St#epp.file, '', St#epp.location, St#epp.erl_scan_opts) of
 	{ok,[{'-',_Ah},{atom,_Ai,ifdef}|_Toks],Cl} ->
 	    skip_toks(From, St#epp{location=Cl}, [ifdef,I|Sis]);
@@ -1337,7 +1482,8 @@ skip_toks(From, St, [I|Sis]) ->
 	    skip_toks(From, St#epp{location=Cl}, ['if',I|Sis]);
 	{ok,[{'-',_Ah},{atom,_Ae,'else'}=Else|_Toks],Cl}->
 	    skip_else(Else, From, St#epp{location=Cl}, [I|Sis]);
-	{ok,[{'-',_Ah},{'else',_Ae}=Else|_Toks],Cl}->
+        %% conditionally allow else as reserved word
+	{ok,[{'-',_Ah},{'else',_Ae}=Else|_Toks],Cl} when ElseReserved ->
 	    skip_else(Else, From, St#epp{location=Cl}, [I|Sis]);
 	{ok,[{'-',_Ah},{atom,_Ae,'elif'}=Elif|Toks],Cl}->
 	    skip_elif(Toks, Elif, From, St#epp{location=Cl}, [I|Sis]);
diff --git a/lib/stdlib/src/erl_compile.erl b/lib/stdlib/src/erl_compile.erl
index 063d3e700d..87af230c67 100644
--- a/lib/stdlib/src/erl_compile.erl
+++ b/lib/stdlib/src/erl_compile.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1997-2021. All Rights Reserved.
+%% Copyright Ericsson AB 1997-2022. All Rights Reserved.
 %%
 %% Licensed under the Apache License, Version 2.0 (the "License");
 %% you may not use this file except in compliance with the License.
@@ -109,6 +109,9 @@ compile1(Files, Opts) ->
 parse_generic_option("b"++Opt, T0, Opts) ->
     {OutputType,T} = get_option("b", Opt, T0),
     compile1(T, Opts#options{output_type=list_to_atom(OutputType)});
+%% parse_generic_option("c"++Opt, T0, Opts) ->
+%%     {InputType,T} = get_option("c", Opt, T0),
+%%     compile1(T, Opts#options{input_type=[$.| InputType]});
 parse_generic_option("D"++Opt, T0, #options{defines=Defs}=Opts) ->
     {Val0,T} = get_option("D", Opt, T0),
     {Key0,Val1} = split_at_equals(Val0, []),
@@ -171,6 +174,25 @@ parse_generic_option("P", T, #options{specific=Spec}=Opts) ->
     compile1(T, Opts#options{specific=['P'|Spec]});
 parse_generic_option("S", T, #options{specific=Spec}=Opts) ->
     compile1(T, Opts#options{specific=['S'|Spec]});
+parse_generic_option("enable-feature" ++ Str, T0,
+                     #options{specific = Spec} = Opts) ->
+    {FtrStr, T} = get_option("enable-feature", Str, T0),
+    Feature = list_to_atom(FtrStr),
+    compile1(T, Opts#options{
+                  specific = Spec ++ [{enable_feature, Feature}]});
+parse_generic_option("disable-feature" ++ Str, T0,
+                     #options{specific = Spec} = Opts) ->
+    {FtrStr, T} = get_option("disable-feature", Str, T0),
+    Feature = list_to_atom(FtrStr),
+    compile1(T, Opts#options{specific = Spec ++ [{disable_feature, Feature}]});
+parse_generic_option("describe-feature" ++ Str, T0,
+                     #options{specific = Spec} = Opts) ->
+    {FtrStr, T} = get_option("disable-feature", Str, T0),
+    Feature = list_to_atom(FtrStr),
+    compile1(T, Opts#options{specific =[{describe_feature, Feature}| Spec]});
+parse_generic_option("list-features", T,
+                     #options{specific = Spec} = Opts) ->
+    compile1(T, Opts#options{specific =[{list_features, true}| Spec]});
 parse_generic_option(Option, _T, _Opts) ->
     usage(io_lib:format("Unknown option: -~ts\n", [Option])).
 
@@ -230,11 +252,24 @@ usage(Error) ->
 	 {"-E","generate listing of expanded code (Erlang compiler)"},
 	 {"-S","generate assembly listing (Erlang compiler)"},
 	 {"-P","generate listing of preprocessed code (Erlang compiler)"},
+         {"-enable-feature <feature>",
+          "enable <feature> when compiling (Erlang compiler)"},
+         {"-disable-feature <feature>",
+          "disable <feature> when compiling (Erlang compiler)"},
+         {"-list-features",
+          "list short descriptions of available feature (Erlang compiler)"},
+         {"-describe-feature <feature>",
+          "show long description of <feature>"},
 	 {"+term","pass the Erlang term unchanged to the compiler"}],
+    Fmt = fun(K, D) when length(K) < 15 ->
+                  io_lib:format("~-14s ~s\n", [K, D]);
+             (K, D) ->
+                  io_lib:format("~s\n~-14s ~s\n", [K, "", D])
+          end,
     Msg = [Error,
            "Usage: erlc [Options] file.ext ...\n",
            "Options:\n",
-           [io_lib:format("~-14s ~s\n", [K,D]) || {K,D} <- H]],
+           [Fmt(K, D) || {K,D} <- H]],
     throw({error, Msg}).
 
 get_option(_Name, [], [[C|_]=Option|T]) when C =/= $- ->
@@ -252,14 +287,19 @@ split_at_equals([], Acc) ->
     {lists:reverse(Acc),[]}.
 
 compile2(Files, #options{cwd=Cwd,includes=Incl,outfile=Outfile}=Opts0) ->
-    Opts = Opts0#options{includes=lists:reverse(Incl)},
-    case {Outfile,length(Files)} of
-	{"", _} ->
-	    compile3(Files, Cwd, Opts);
-	{[_|_], 1} ->
-	    compile3(Files, Cwd, Opts);
-	{[_|_], _N} ->
-            throw({error, "Output file name given, but more than one input file.\n"})
+    case show_info(Opts0) of
+        {ok, Msg} ->
+            throw({error, Msg});
+        false ->
+            Opts = Opts0#options{includes=lists:reverse(Incl)},
+            case {Outfile,length(Files)} of
+                {"", _} ->
+                    compile3(Files, Cwd, Opts);
+                {[_|_], 1} ->
+                    compile3(Files, Cwd, Opts);
+                {[_|_], _N} ->
+                    throw({error, "Output file name given, but more than one input file.\n"})
+            end
     end.
 
 %% Compile the list of files, until done or compilation fails.
@@ -278,6 +318,28 @@ compile3([File|Rest], Cwd, Options) ->
     compile3(Rest, Cwd, Options);
 compile3([], _Cwd, _Options) -> ok.
 
+show_info(#options{specific = Spec}) ->
+    G = fun G0([]) -> undefined;
+            G0([E|Es]) ->
+                case proplists:get_value(E, Spec) of
+                    undefined -> G0(Es);
+                    V -> {E, V}
+                end
+        end,
+
+    case G([list_features, describe_feature]) of
+        {list_features, true} ->
+            Features = erl_features:features(),
+            Msg = ["Available features:\n",
+                   [io_lib:format(" ~-13s ~s\n", [Ftr, erl_features:short(Ftr)])
+                    || Ftr <- Features]],
+            {ok, Msg};
+        {describe_feature, Ftr} ->
+            {ok, erl_features:long(Ftr)};
+        _ ->
+            false
+    end.
+
 %% Invoke the appropriate compiler, depending on the file extension.
 compile_file("", Input, _Output, _Options) ->
     throw({error, io_lib:format("File has no extension: ~ts~n", [Input])});
diff --git a/lib/stdlib/src/erl_features.erl b/lib/stdlib/src/erl_features.erl
new file mode 100644
index 0000000000..d8618f9c3f
--- /dev/null
+++ b/lib/stdlib/src/erl_features.erl
@@ -0,0 +1,564 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2021-2022. All Rights Reserved.
+%%
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
+%%
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
+%%
+%% %CopyrightEnd%
+%%
+-module(erl_features).
+
+%% FIXME divide the exported functions in public and internal for the
+%% sake of documentation.
+-export([features/0,
+         feature_info/1,
+         collect_features/1,
+         short/1,
+         long/1,
+         enabled_features/0,
+         is_valid_feature/1,
+         load_allowed/1,
+         keywords/0,
+         keywords/1,
+         keyword_fun/2,
+         keyword_fun/4,
+         enable_feature/1,
+         disable_feature/1,
+         format_error/1,
+         format_error/2]).
+
+-export([features_used/1]).
+
+-type type() :: 'extension' | 'backwards_incompatible_change'.
+-type status() :: 'experimental'
+                  | 'approved'
+                  | 'permanent'
+                  | 'rejected'.
+-type release() :: non_neg_integer().
+-type error() :: {?MODULE, {'invalid_features', [atom()]}}.
+
+-define(VALID_FEATURE(Feature),
+        (case is_valid_feature(Feature) of
+             false ->
+                 error(invalid_feature, [Feature],
+                       [{error_info,
+                         #{module => ?MODULE,
+                           cause => #{1 => "unknown feature"}}}]);
+             true -> ok
+         end)).
+
+%% Specification about currently known features.
+feature_specs() ->
+    #{}.
+
+%% Currently known features
+-spec features() -> [atom()].
+features() ->
+    Map = case persistent_term:get({?MODULE, feature_specs}, none) of
+              none -> init_specs();
+              M -> M
+          end,
+    maps:keys(Map).
+
+is_valid_feature(Ftr) ->
+    lists:member(Ftr, features()).
+
+-spec short(atom()) -> iolist().
+short(Feature) ->
+    #{short := Short,
+      status := Status} = Info = feature_info(Feature),
+    #{Status := Release} = Info,
+    io_lib:format("~-40s ~-12s (~p)", [Short, Status, Release]).
+
+long(Feature) ->
+    #{short := Short,
+      description := Description,
+      status := Status,
+      keywords := Keywords,
+      type := Type} = Info = feature_info(Feature),
+    StatusFmt = "  ~-10s ~-12s (~p)\n",
+    History = [io_lib:format(StatusFmt, [T, S, R])
+               || {T, S, R} <- history(Status, Info)],
+    KeywordsStrs =
+        if Keywords == [] -> "";
+           true ->
+                io_lib:format("  ~-10s ~p\n", ["Keywords", Keywords])
+        end,
+    Lines = [{"~s - ~s\n", [Feature, Short]},
+             {"  ~-10s ~s\n", ["Type", Type]},
+             {"~s", [History]},
+             {"~s", [KeywordsStrs]},
+             {"\n~s\n", [nqTeX(Description)]}],
+    [io_lib:format(FStr, Args) || {FStr, Args} <- Lines].
+
+history(Current, Info) ->
+    G = fun(Key, S) ->
+                case maps:find(Key, Info) of
+                    error -> [];
+                    {ok, R} -> [{S, Key, R}]
+                end
+        end,
+    F = fun(Key) -> G(Key, "") end,
+    History =
+        case Current of
+            experimental -> [];
+            rejected -> F(experimental);
+            approved -> F(experimental);
+            permanent -> F(approved) ++ F(experimental)
+        end,
+    G(Current, "Status") ++ History.
+
+%% Dead simple line breaking for better presentation.
+nqTeX(String) ->
+    Words = string:tokens(String, " "),
+    WithLens = lists:map(fun(W) -> {W, length(W)} end, Words),
+    adjust(WithLens).
+
+adjust(WLs) ->
+    adjust(0, WLs, []).
+
+adjust(_, [], Ws) ->
+    lists:reverse(tl(Ws));
+adjust(Col, [{W, L}| WLs], Ws) ->
+    case Col + L > 72 of
+        true ->
+            lists:reverse(["\n"| tl(Ws)])
+                ++ adjust(L+1, WLs, [" ", W]);
+        false ->
+            adjust(Col + L + 1, WLs, [" ", W| Ws])
+    end.
+
+
+-spec feature_info(atom()) -> FeatureInfoMap | no_return()
+              when
+      Description :: string(),
+      FeatureInfoMap ::
+        #{description := Description,
+          short := Description,
+          type := type(),
+          keywords := [atom()],
+          status := status(),
+          experimental => release(),
+          approved => release(),
+          permanent => release(),
+          rejected => release()
+         }.
+feature_info(Feature) ->
+    ?VALID_FEATURE(Feature),
+
+    Map = persistent_term:get({?MODULE, feature_specs}),
+    maps:get(Feature, Map).
+
+%% New keywords for a feature.  The current set is just for
+%% tests and development.
+-spec keywords(atom()) -> [atom()].
+keywords(Ftr) ->
+    ?VALID_FEATURE(Ftr),
+
+    #{keywords := Keywords} = feature_info(Ftr),
+    Keywords.
+
+%% Internal - Ftr is valid
+keywords(Ftr, Map) ->
+    maps:get(keywords, maps:get(Ftr, Map)).
+
+%% Utilities
+%% Returns list of enabled features and a new keywords function
+%% -spec keyword_fun_add_feature(atom(), fun((atom()) -> boolean())) ->
+%%           {'ok', fun((atom()) -> boolean())}
+%%               | {'error', error()}.
+keyword_fun(Opts, KeywordFun) ->
+    %% Get items enabling or disabling features, preserving order.
+    IsFtr = fun({enable_feature, _}) -> true;
+               ({disable_feature, _}) -> true;
+               (_) -> false
+            end,
+    FeatureOps = lists:filter(IsFtr, Opts),
+    {AddFeatures, DelFeatures} = collect_features(FeatureOps),
+    %% FIXME check that all features are known at this stage so we
+    %% don't miss out on reporting any unknown features.
+
+    case keyword_fun_add_features(AddFeatures, KeywordFun) of
+        {ok, Fun} ->
+            case keyword_fun_remove_features(DelFeatures, Fun) of
+                {ok, FunX} ->
+                    {ok, {AddFeatures -- DelFeatures, FunX}};
+                {error, _} = Error ->
+                    %% FIXME We are missing potential incorrect
+                    %% features being disabled
+                    Error
+            end;
+        {error, _} = Error ->
+            Error
+    end.
+
+%% -spec keyword_fun_add_feature(atom(), fun((atom()) -> boolean())) ->
+%%           {'ok', fun((atom()) -> boolean())}
+%%               | {'error', error()}.
+keyword_fun(Ind, Feature, Ftrs, KeywordFun) ->
+    case is_valid_feature(Feature) of
+        true ->
+            case Ind of
+                enable ->
+                    {ok,
+                     add_feature(Feature, KeywordFun),
+                     [Feature | Ftrs]};
+                disable ->
+                    {ok,
+                     remove_feature(Feature, KeywordFun),
+                     Ftrs -- [Feature]}
+            end;
+        false ->
+            {error, {?MODULE, {invalid_features, [Feature]}}}
+    end.
+
+%% FIXME Rename this to reflect that it returns a function!
+add_feature(Feature, F) ->
+    Words = keywords(Feature),
+    fun(Word) ->
+            lists:member(Word, Words)
+                orelse F(Word)
+    end.
+
+%% FIXME Rename this to reflect that it returns a function!
+remove_feature(Feature, F) ->
+    Words = keywords(Feature),
+    fun(Word) ->
+            case lists:member(Word, Words) of
+                true -> false;
+                false -> F(Word)
+            end
+    end.
+
+-spec keyword_fun_add_features([atom()], fun((atom()) -> boolean())) ->
+          {'ok', fun((atom()) -> boolean())}
+              | {'error', error()}.
+keyword_fun_add_features(Features, F) ->
+    case lists:all(fun is_valid_feature/1, Features) of
+        true ->
+            {ok, lists:foldl(fun add_feature/2, F, Features)};
+        false ->
+            IsInvalid = fun(Ftr) -> not is_valid_feature(Ftr) end,
+            Invalid = lists:filter(IsInvalid, Features),
+            {error, {?MODULE, {invalid_features, Invalid}}}
+    end.
+
+-spec keyword_fun_remove_features([atom()], fun((atom()) -> boolean())) ->
+          {'ok', fun((atom()) -> boolean())}
+              | {'error', error()}.
+keyword_fun_remove_features(Features, F) ->
+    case lists:all(fun is_valid_feature/1, Features) of
+        true ->
+            {ok, lists:foldl(fun remove_feature/2, F, Features)};
+        false ->
+            IsInvalid = fun(Ftr) -> not is_valid_feature(Ftr) end,
+            Invalid = lists:filter(IsInvalid, Features),
+            {error, {?MODULE, {invalid_features, Invalid}}}
+    end.
+
+format_error(Reason, [{_M, _F, _Args, Info}| _St]) ->
+    ErrorInfo = proplists:get_value(error_info, Info, #{}),
+    ErrorMap = maps:get(cause, ErrorInfo),
+    ErrorMap#{reason => io_lib:format("~p: ~p", [?MODULE, Reason])}.
+
+format_error({invalid_features, Features}) ->
+    Fmt = fun F([Ftr]) -> io_lib:fwrite("'~p'", [Ftr]);
+              F([Ftr1, Ftr2]) ->
+                  io_lib:fwrite("'~p' and '~p'", [Ftr1, Ftr2]);
+              F([Ftr| Ftrs]) ->
+                  io_lib:fwrite("'~p', ~s", [Ftr, F(Ftrs)])
+          end,
+    case Features of
+        [Ftr] ->
+            io_lib:fwrite("the feature ~s does not exist.", [Fmt([Ftr])]);
+        Ftrs ->
+            io_lib:fwrite("the features ~s do not exist.", [Fmt(Ftrs)])
+    end.
+
+%% Hold the state of which features are currently enabled.
+%% This is almost static, so we go for an almost permanent state,
+%% i.e., use persistent_term.
+init_features() ->
+    Map = init_specs(),
+
+    persistent_term:put({?MODULE, enabled_features}, []),
+    persistent_term:put({?MODULE, keywords}, []),
+
+    RawOps = lists:filter(fun({Tag, _}) ->
+                                      Tag == 'enable-feature'
+                                          orelse Tag == 'disable-feature';
+                                 (_) -> false
+                              end,
+                              init:get_arguments()),
+
+    Cnv = fun('enable-feature') -> enable_feature;
+             ('disable-feature') -> disable_feature
+          end,
+
+    FeatureOps = lists:append(lists:map(fun({Tag, Strings}) ->
+                                                lists:map(fun(S) ->
+                                                                  {Tag, S} end,
+                                                          Strings)
+                                        end,
+                                        RawOps)),
+
+    %% Convert failure, e.g., too long string for atom, to not
+    %% being a valid feature.
+    F = fun({Tag, String}) ->
+                try
+                    Atom = list_to_atom(String),
+                    case is_valid_feature(Atom) of
+                        true -> {true, {Cnv(Tag), Atom}};
+                        false when Atom == all ->
+                            {true, {Cnv(Tag), Atom}};
+                        false -> false
+                    end
+                catch
+                    _ -> false
+                end
+        end,
+    FOps = lists:filtermap(F, FeatureOps),
+    {Features, _} = collect_features(FOps),
+    {Enabled, Keywords} =
+        lists:foldl(fun(Ftr, {Ftrs, Keys}) ->
+                            case lists:member(Ftr, Ftrs) of
+                                true ->
+                                    {Ftrs, Keys};
+                                false ->
+                                    {[Ftr| Ftrs],
+                                     keywords(Ftr, Map) ++ Keys}
+                            end
+                    end,
+                    {[], []},
+                    Features),
+
+    %% Save state
+    enabled_features(Enabled),
+    set_keywords(Keywords),
+    persistent_term:put({?MODULE, init_done}, true),
+    ok.
+
+init_specs() ->
+    Specs = case os:getenv("OTP_TEST_FEATURES") of
+                "true" -> test_features();
+                _ -> feature_specs()
+            end,
+    persistent_term:put({?MODULE, feature_specs}, Specs),
+    Specs.
+
+ensure_init() ->
+    case persistent_term:get({?MODULE, init_done}, false) of
+        true -> ok;
+        false ->
+            init_features()
+    end.
+
+%% FIXME - remove this.  It should not be available at runtime.  This
+%% is all done by the init code.
+enable_feature(Feature) ->
+    ?VALID_FEATURE(Feature),
+
+    Features = enabled_features(),
+    case lists:member(Feature, Features) of
+        true ->
+            %% already there, maybe raise an error
+            Features;
+        false ->
+            NewFeatures = [Feature| Features],
+            enabled_features(NewFeatures),
+            Keywords = keywords(),
+            New = keywords(Feature),
+            set_keywords(New ++ Keywords),
+            NewFeatures
+    end.
+
+disable_feature(Feature) ->
+    ?VALID_FEATURE(Feature),
+
+    Features = enabled_features(),
+    case lists:member(Feature, Features) of
+        true ->
+            NewFeatures = Features -- [Feature],
+            enabled_features(NewFeatures),
+            Keywords = keywords(),
+            Rem = keywords(Feature),
+            set_keywords(Keywords -- Rem),
+            NewFeatures;
+        false ->
+            %% Not there, possibly raise an error
+            Features
+    end.
+
+enabled_features() ->
+    ensure_init(),
+    persistent_term:get({?MODULE, enabled_features}).
+
+enabled_features(Ftrs) ->
+    persistent_term:put({?MODULE, enabled_features}, Ftrs).
+
+keywords() ->
+    ensure_init(),
+    persistent_term:get({?MODULE, keywords}).
+
+set_keywords(Words) ->
+    persistent_term:put({?MODULE, keywords}, Words).
+
+
+-spec load_allowed(binary()) -> boolean().
+load_allowed(Binary) ->
+    case erts_internal:beamfile_chunk(Binary, "Meta") of
+        undefined ->
+            true;
+        Meta ->
+            MetaData = erlang:binary_to_term(Meta),
+            case proplists:get_value(enabled_features, MetaData) of
+                undefined ->
+                    true;
+                Used ->
+                    Enabled = enabled_features(),
+                    lists:all(fun(UFtr) ->
+                                      lists:member(UFtr, Enabled)
+                              end,
+                              Used)
+            end
+    end.
+
+
+%% Return features used by module or beam file
+features_used(Module) when is_atom(Module) ->
+    case code:get_object_code(Module) of
+        error ->
+            not_found;
+        {_Mod, Bin, _Fname} ->
+            features_in(Bin)
+    end;
+features_used(FName) when is_list(FName) ->
+    features_in(FName).
+
+features_in(NameOrBin) ->
+    case beam_lib:chunks(NameOrBin, ["Meta"], [allow_missing_chunks]) of
+        {ok, {_, [{_, missing_chunk}]}} ->
+            [];
+        {ok, {_, [{_, Meta}]}} ->
+            MetaData = erlang:binary_to_term(Meta),
+            proplists:get_value(enabled_features, MetaData, []);
+        _ ->
+            not_found
+    end.
+
+approved_features() ->
+    [Ftr || Ftr <- features(),
+            maps:get(status, feature_info(Ftr)) == approved].
+
+permanent_features() ->
+    [Ftr || Ftr <- features(),
+            maps:get(status, feature_info(Ftr)) == permanent].
+
+%% Interpret feature ops (enable or disable) to build the full set of
+%% features.  The meta feature 'all' is expanded to all known
+%% features.
+collect_features(FOps) ->
+    %% Features enabled by default
+    Enabled = approved_features() ++ permanent_features(),
+    collect_features(FOps, Enabled, []).
+
+collect_features([], Add, Del) ->
+    {Add, Del};
+collect_features([{enable_feature, all}| FOps], Add, _Del) ->
+    All = features(),
+    Add1 = lists:foldl(fun add_ftr/2, Add, All),
+    collect_features(FOps, Add1, []);
+collect_features([{enable_feature, Feature}| FOps], Add, Del) ->
+    collect_features(FOps, add_ftr(Feature, Add), Del -- [Feature]);
+collect_features([{disable_feature, all}| FOps], _Add, Del) ->
+    %% Start over
+    All = features(),
+    collect_features(FOps, [], Del -- All);
+collect_features([{disable_feature, Feature}| FOps], Add, Del) ->
+    collect_features(FOps, Add -- [Feature],
+                     add_ftr(Feature, Del)).
+
+add_ftr(F, []) ->
+    [F];
+add_ftr(F, [F| _] = Fs) ->
+    Fs;
+add_ftr(F, [F0| Fs]) ->
+    [F0| add_ftr(F, Fs)].
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% Test features - not present in a release
+test_features() ->
+    #{ifn_expr =>
+          #{short => "New expression `ifn cond -> body end`",
+            description =>
+                "Inclusion of expression `ifn cond -> body end`, which "
+            "evaluates `body` when cond is false.  This is a truly "
+            "experimental feature, present only to show and use the "
+            "support for experimental features.  Not extensively tested.  "
+            "Implementated by a transformation in the parser.",
+            status => experimental,
+            experimental => 24,
+            keywords => ['ifn'],
+            type => extension},
+      ifnot_expr =>
+          #{short => "New expression `ifnot cond -> body end`",
+            description =>
+                "Inclusion of expression `ifnot cond -> body end`, which "
+            "evaluates `body` when cond is false.  This is a truly "
+            "experimental feature, present only to show and use the "
+            "support for experimental features.  Not extensively tested.  "
+            "Similar to ifn_expr, but with a deeper implementation.",
+            status => experimental,
+            experimental => 25,
+            keywords => ['ifnot'],
+            type => extension},
+      unless_expr =>
+          #{short => "`unless <cond> -> <bodby> end",
+            description =>
+                "Introduction of new expression `unless <cond> -> <body> end."
+            " Truly experimental.",
+            status => experimental,
+            experimental => 25,
+            keywords => ['unless'],
+            type => extension},
+      maps =>
+          #{short => "Add maps as new data type",
+            description => "Add new low data type maps with syntactic "
+            "support in Erlang as well native support in the beam. "
+            "Insert, lookup and delete are asymptotically constant.",
+            status => permanent,
+            experimental => 17,
+            approved => 18,
+            permanent => 19,
+            keywords => [],
+            type => extension},
+      cond_expr =>
+          #{short => "Introduce general Lisp style conditional",
+            description =>
+                "Finally complement the painfully broken `if` "
+            "with a general conditional as in Lisp from the days of old.",
+            status => approved,
+            experimental => 24,
+            approved => 25,
+            keywords => [],
+            type => extension},
+      while_expr =>
+          #{short => "Introduce strange iterative expressions",
+            description =>
+                "Introduce looping constructs, with seemingly "
+            "destructive assignment and vague semantics.",
+            status => experimental,
+            experimental => 25,
+            keywords => ['while', 'until'],
+            type => extension}}.
diff --git a/lib/stdlib/src/erl_lint.erl b/lib/stdlib/src/erl_lint.erl
index 84ae2f6bf9..3ae2bc41c4 100644
--- a/lib/stdlib/src/erl_lint.erl
+++ b/lib/stdlib/src/erl_lint.erl
@@ -199,6 +199,9 @@ format_error(invalid_call) ->
 format_error(invalid_record) ->
     "invalid record expression";
 
+format_error({future_feature, Ftr, Atom}) ->
+    io_lib:format("atom '~p' is reserved in the experimental feature '~p'",
+                  [Atom, Ftr]);
 format_error({attribute,A}) ->
     io_lib:format("attribute ~tw after function definitions", [A]);
 format_error({missing_qlc_hrl,A}) ->
@@ -588,6 +591,7 @@ module(Forms, FileName) ->
       ErrorInfo :: error_info()).
 
 module(Forms, FileName, Opts0) ->
+    %% FIXME Hmm, this is not coherent with the semantics of features
     %% We want the options given on the command line to take
     %% precedence over options in the module.
     Opts = compiler_options(Forms) ++ Opts0,
@@ -658,7 +662,10 @@ start(File, Opts) ->
                       true, Opts)},
          {nif_inline,
           bool_option(warn_nif_inline, nowarn_nif_inline,
-                      true, Opts)}
+                      true, Opts)},
+         {keyword_warning,
+          bool_option(warn_keywords, nowarn_keywords,
+                      false, Opts)}
 	],
     Enabled1 = [Category || {Category,true} <- Enabled0],
     Enabled = ordsets:from_list(Enabled1),
@@ -4164,7 +4171,22 @@ test_overriden_by_local(Anno, OldTest, Arity, St) ->
 %% keyword_warning(Anno, Atom, State) -> State.
 %%  Add warning for atoms that will be reserved keywords in the future.
 %%  (Currently, no such keywords to warn for.)
-keyword_warning(_Anno, _A, St) -> St.
+keyword_warning(Anno, Atom, St) ->
+    case is_warn_enabled(keyword_warning, St) of
+        true ->
+            Ftrs = erl_features:features(),
+            Reserved =
+                fun(Ftr) ->
+                        lists:member(Atom, erl_features:keywords(Ftr))
+                end,
+            case lists:filter(Reserved, Ftrs) of
+                [] -> St;
+                [Ftr] ->
+                    add_warning(Anno, {future_feature, Ftr, Atom}, St)
+            end;
+        false ->
+            St
+    end.
 
 %% format_function(Anno, ModName, FuncName, [Arg], State) -> State.
 %%  Add warning for bad calls to io:fwrite/format functions.
diff --git a/lib/stdlib/src/erl_scan.erl b/lib/stdlib/src/erl_scan.erl
index d1c3b94cf3..a30747b5e5 100644
--- a/lib/stdlib/src/erl_scan.erl
+++ b/lib/stdlib/src/erl_scan.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1996-2021. All Rights Reserved.
+%% Copyright Ericsson AB 1996-2022. All Rights Reserved.
 %%
 %% Licensed under the Apache License, Version 2.0 (the "License");
 %% you may not use this file except in compliance with the License.
@@ -52,7 +52,8 @@
 %%% External exports
 
 -export([string/1,string/2,string/3,tokens/3,tokens/4,
-         format_error/1,reserved_word/1]).
+         format_error/1,reserved_word/1,
+         f_reserved_word/1]).
 
 -export([column/1,end_location/1,line/1,location/1,text/1,
          category/1,symbol/1]).
@@ -1227,32 +1228,43 @@ tabs(8)  ->  "\t\t\t\t\t\t\t\t";
 tabs(9)  ->  "\t\t\t\t\t\t\t\t\t";
 tabs(10) ->  "\t\t\t\t\t\t\t\t\t\t".
 
+%% Dynamic version of reserved_word that knows about the possibility
+%% that enabled features might change the set of reserved words.
 -spec reserved_word(Atom :: atom()) -> boolean().
-reserved_word('after') -> true;
-reserved_word('begin') -> true;
-reserved_word('case') -> true;
-reserved_word('try') -> true;
-reserved_word('cond') -> true;
-reserved_word('catch') -> true;
-reserved_word('andalso') -> true;
-reserved_word('orelse') -> true;
-reserved_word('end') -> true;
-reserved_word('fun') -> true;
-reserved_word('if') -> true;
-reserved_word('let') -> true;
-reserved_word('of') -> true;
-reserved_word('receive') -> true;
-reserved_word('when') -> true;
-reserved_word('bnot') -> true;
-reserved_word('not') -> true;
-reserved_word('div') -> true;
-reserved_word('rem') -> true;
-reserved_word('band') -> true;
-reserved_word('and') -> true;
-reserved_word('bor') -> true;
-reserved_word('bxor') -> true;
-reserved_word('bsl') -> true;
-reserved_word('bsr') -> true;
-reserved_word('or') -> true;
-reserved_word('xor') -> true;
-reserved_word(_) -> false.
+reserved_word(Atom) ->
+    case f_reserved_word(Atom) of
+        true -> true;
+        false ->
+            lists:member(Atom, erl_features:keywords())
+    end.
+
+%% Static version of reserved_words.  These represent the fixed set of
+%% reserved words.
+f_reserved_word('after') -> true;
+f_reserved_word('begin') -> true;
+f_reserved_word('case') -> true;
+f_reserved_word('try') -> true;
+f_reserved_word('cond') -> true;
+f_reserved_word('catch') -> true;
+f_reserved_word('andalso') -> true;
+f_reserved_word('orelse') -> true;
+f_reserved_word('end') -> true;
+f_reserved_word('fun') -> true;
+f_reserved_word('if') -> true;
+f_reserved_word('let') -> true;
+f_reserved_word('of') -> true;
+f_reserved_word('receive') -> true;
+f_reserved_word('when') -> true;
+f_reserved_word('bnot') -> true;
+f_reserved_word('not') -> true;
+f_reserved_word('div') -> true;
+f_reserved_word('rem') -> true;
+f_reserved_word('band') -> true;
+f_reserved_word('and') -> true;
+f_reserved_word('bor') -> true;
+f_reserved_word('bxor') -> true;
+f_reserved_word('bsl') -> true;
+f_reserved_word('bsr') -> true;
+f_reserved_word('or') -> true;
+f_reserved_word('xor') -> true;
+f_reserved_word(_) -> false.
diff --git a/lib/stdlib/src/stdlib.app.src b/lib/stdlib/src/stdlib.app.src
index 9962fef931..fbf0e73149 100644
--- a/lib/stdlib/src/stdlib.app.src
+++ b/lib/stdlib/src/stdlib.app.src
@@ -46,6 +46,7 @@
 	     erl_error,
 	     erl_eval,
              erl_expand_records,
+             erl_features,
 	     erl_internal,
 	     erl_lint,
 	     erl_parse,
diff --git a/lib/stdlib/test/epp_SUITE.erl b/lib/stdlib/test/epp_SUITE.erl
index 30437de302..8e800f8112 100644
--- a/lib/stdlib/test/epp_SUITE.erl
+++ b/lib/stdlib/test/epp_SUITE.erl
@@ -1609,8 +1609,9 @@ encoding(Config) when is_list(Config) ->
 	epp_parse_file(ErlFile, [{default_encoding,latin1}]),
     {ok,[{attribute,1,file,_},
 	 {attribute,1,module,encoding},
-	 {eof,3}],[{encoding,none}]} =
+	 {eof,3}],Extra0} =
 	epp_parse_file(ErlFile, [{default_encoding,latin1},extra]),
+    none = proplists:get_value(encoding, Extra0),
 
     %% Try a latin-1 file with encoding given in a comment.
     C2 = <<"-module(encoding).
@@ -1632,16 +1633,20 @@ encoding(Config) when is_list(Config) ->
 	epp_parse_file(ErlFile, [{default_encoding,utf8}]),
     {ok,[{attribute,1,file,_},
 	 {attribute,1,module,encoding},
-	 {eof,4}],[{encoding,latin1}]} =
+	 {eof,4}],Extra1} =
 	epp_parse_file(ErlFile, [extra]),
+    latin1 = proplists:get_value(encoding, Extra1),
+
     {ok,[{attribute,1,file,_},
 	 {attribute,1,module,encoding},
-	 {eof,4}],[{encoding,latin1}]} =
+	 {eof,4}],Extra2} =
 	epp_parse_file(ErlFile, [{default_encoding,latin1},extra]),
+    latin1 = proplists:get_value(encoding, Extra2),
     {ok,[{attribute,1,file,_},
 	 {attribute,1,module,encoding},
-	 {eof,4}],[{encoding,latin1}]} =
+	 {eof,4}],Extra3} =
 	epp_parse_file(ErlFile, [{default_encoding,utf8},extra]),
+    latin1 = proplists:get_value(encoding, Extra3),
     ok.
 
 extends(Config) ->
-- 
2.34.1

Places

File 3542-features-Add-support-for-handling-features.patch of Package erlang (Revision 33fb1bfcfb3bce757d0f7cfc6a9a3eaf)

Places