Merge pull request #1378 from bjorng/bjorn/disallow-unicode-module-names/OTP-14285

Don't allow module names with non-latin1 characters

3 files changed, 53 insertions, 16 deletions

diff --git a/lib/stdlib/doc/src/unicode_usage.xml b/lib/stdlib/doc/src/unicode_usage.xml
index efc8b75075..a8ef8ff5c5 100644
--- a/lib/stdlib/doc/src/unicode_usage.xml
+++ b/lib/stdlib/doc/src/unicode_usage.xml
@@ -62,6 +62,10 @@
 
 	<item><p>In Erlang/OTP 17.0, the encoding default for Erlang
 	source files was switched to UTF-8.</p></item>
+
+	<item><p>In Erlang/OTP 20.0, atoms and function can contain
+	Unicode characters. Module names are still restricted to
+	the ISO-Latin-1 range.</p></item>
       </list>
 
     <p>This section outlines the current Unicode support and gives some
@@ -339,9 +343,10 @@
       <tag>The language</tag>
       <item>
         <p>Having the source code in UTF-8 also allows you to write string
-          literals containing Unicode characters with code points &gt; 255,
-          although atoms, module names, and function names are restricted to
-          the ISO Latin-1 range. Binary literals, where you use type
+          literals, function names, and atoms containing Unicode
+	  characters with code points &gt; 255.
+          Module names are still restricted to the ISO Latin-1 range.
+	  Binary literals, where you use type
           <c>/utf8</c>, can also be expressed using Unicode characters &gt; 255.
           Having module names using characters other than 7-bit ASCII can cause
           trouble on operating systems with inconsistent file naming schemes,
@@ -432,15 +437,17 @@ external_charlist() = maybe_improper_list(char() | external_unicode_binary() |
 
   <section>
     <title>Basic Language Support</title>
-    <p><marker id="unicode_in_erlang"/>As from Erlang/OTP R16, Erlang source
-      files can be written in UTF-8 or bytewise (<c>latin1</c>) encoding. For
-      information about how to state the encoding of an Erlang source file, see
-      the <seealso marker="stdlib:epp#encoding"><c>epp(3)</c></seealso> module.
-      Strings and comments can be written using Unicode, but functions must
-      still be named using characters from the ISO Latin-1 character set, and
-      atoms are restricted to the same ISO Latin-1 range. These restrictions in
-      the language are of course independent of the encoding of the source
-      file.</p>
+    <p><marker id="unicode_in_erlang"/>As from Erlang/OTP R16, Erlang
+    source files can be written in UTF-8 or bytewise (<c>latin1</c>)
+    encoding. For information about how to state the encoding of an
+    Erlang source file, see the <seealso
+    marker="stdlib:epp#encoding"><c>epp(3)</c></seealso> module.  As
+    from Erlang/OTP R16, strings and comments can be written using
+    Unicode.  As from Erlang/OTP 20, also atoms and functions can be
+    written using Unicode. Modules names must still be named using
+    characters from the ISO Latin-1 character set.  (These
+    restrictions in the language are independent of the encoding of
+    the source file.)</p>
 
     <section>
       <title>Bit Syntax</title>
diff --git a/lib/stdlib/src/erl_lint.erl b/lib/stdlib/src/erl_lint.erl
index 0ffca0886f..0789f5dfb7 100644
--- a/lib/stdlib/src/erl_lint.erl
+++ b/lib/stdlib/src/erl_lint.erl
@@ -156,6 +156,8 @@ format_error(pmod_unsupported) ->
     "parameterized modules are no longer supported";
 %% format_error({redefine_mod_import, M, P}) ->
 %%     io_lib:format("module '~s' already imported from package '~s'", [M, P]);
+format_error(non_latin1_module_unsupported) ->
+    "module names with non-latin1 characters are not supported";
 
 format_error(invalid_call) ->
     "invalid function call";
@@ -733,9 +735,15 @@ form(Form, #lint{state=State}=St) ->
 start_state({attribute,Line,module,{_,_}}=Form, St0) ->
     St1 = add_error(Line, pmod_unsupported, St0),
     attribute_state(Form, St1#lint{state=attribute});
-start_state({attribute,_,module,M}, St0) ->
+start_state({attribute,Line,module,M}, St0) ->
     St1 = St0#lint{module=M},
-    St1#lint{state=attribute};
+    St2 = St1#lint{state=attribute},
+    case is_non_latin1_name(M) of
+        true ->
+            add_error(Line, non_latin1_module_unsupported, St2);
+        false ->
+            St2
+    end;
 start_state(Form, St) ->
     Anno = case Form of
                {eof, L} -> erl_anno:new(L);
@@ -745,6 +753,9 @@ start_state(Form, St) ->
     St1 = add_error(Anno, undefined_module, St),
     attribute_state(Form, St1#lint{state=attribute}).
 
+is_non_latin1_name(Name) ->
+    lists:any(fun(C) -> C > 255 end, atom_to_list(Name)).
+
 %% attribute_state(Form, State) ->
 %%      State'
 
diff --git a/lib/stdlib/test/erl_lint_SUITE.erl b/lib/stdlib/test/erl_lint_SUITE.erl
index df38edf393..4af1c26c0f 100644
--- a/lib/stdlib/test/erl_lint_SUITE.erl
+++ b/lib/stdlib/test/erl_lint_SUITE.erl
@@ -64,7 +64,8 @@
          predef/1,
          maps/1,maps_type/1,maps_parallel_match/1,
          otp_11851/1,otp_11879/1,otp_13230/1,
-         record_errors/1, otp_xxxxx/1]).
+         record_errors/1, otp_xxxxx/1,
+         non_latin1_module/1]).
 
 suite() ->
     [{ct_hooks,[ts_install_cth]},
@@ -84,7 +85,7 @@ all() ->
      too_many_arguments, basic_errors, bin_syntax_errors, predef,
      maps, maps_type, maps_parallel_match,
      otp_11851, otp_11879, otp_13230,
-     record_errors, otp_xxxxx].
+     record_errors, otp_xxxxx, non_latin1_module].
 
 groups() -> 
     [{unused_vars_warn, [],
@@ -3923,6 +3924,24 @@ otp_xxxxx(Config) ->
            []}],
     run(Config, Ts).
 
+%% OTP-14285: We currently don't support non-latin1 module names.
+
+non_latin1_module(_Config) ->
+    do_non_latin1_module('юникод'),
+    do_non_latin1_module(list_to_atom([256,$a,$b,$c])),
+    do_non_latin1_module(list_to_atom([$a,$b,256,$c])),
+    ok.
+
+do_non_latin1_module(Mod) ->
+    File = atom_to_list(Mod) ++ ".erl",
+    Forms = [{attribute,1,file,{File,1}},
+             {attribute,1,module,Mod},
+             {eof,2}],
+    error = compile:forms(Forms),
+    {error,_,[]} = compile:forms(Forms, [return]),
+    ok.
+
+
 run(Config, Tests) ->
     F = fun({N,P,Ws,E}, BadL) ->
                 case catch run_test(Config, P, Ws) of