compiler: Remove support for packages

1 files changed, 10 insertions, 56 deletions

diff --git a/lib/compiler/src/sys_pre_expand.erl b/lib/compiler/src/sys_pre_expand.erl
index e55fb2a037..a8c69c3cb1 100644
--- a/lib/compiler/src/sys_pre_expand.erl
+++ b/lib/compiler/src/sys_pre_expand.erl
@@ -35,10 +35,8 @@
 
 -record(expand, {module=[],                     %Module name
                  parameters=undefined,          %Module parameters
-                 package="",                    %Module package
                  exports=[],                    %Exports
                  imports=[],                    %Imports
-                 mod_imports,                   %Module Imports
                  compile=[],                    %Compile flags
                  attributes=[],                 %Attributes
                  callbacks=[],                  %Callbacks
@@ -67,12 +65,8 @@ module(Fs0, Opts0) ->
     %% Set pre-defined exported functions.
     PreExp = [{module_info,0},{module_info,1}],
 
-    %% Set pre-defined module imports.
-    PreModImp = [{erlang,erlang},{packages,packages}],
-
     %% Build initial expand record.
     St0 = #expand{exports=PreExp,
-                  mod_imports=dict:from_list(PreModImp),
                   compile=Opts,
                   defined=PreExp,
                   bitdefault = erl_bits:system_bitdefault(),
@@ -242,14 +236,12 @@ forms([], St) -> {[],St}.
 %%  Process an attribute, this just affects the state.
 
 attribute(module, {Module, As}, _L, St) ->
-    M = package_to_string(Module),
-    St#expand{module=list_to_atom(M),
-              package=packages:strip_last(M),
+    true = is_atom(Module),
+    St#expand{module=Module,
               parameters=As};
 attribute(module, Module, _L, St) ->
-    M = package_to_string(Module),
-    St#expand{module=list_to_atom(M),
-              package=packages:strip_last(M)};
+    true = is_atom(Module),
+    St#expand{module=Module};
 attribute(export, Es, _L, St) ->
     St#expand{exports=union(from_list(Es), St#expand.exports)};
 attribute(import, Is, _L, St) ->
@@ -312,8 +304,6 @@ pattern({tuple,Line,Ps}, St0) ->
 %%pattern({struct,Line,Tag,Ps}, St0) ->
 %%    {TPs,TPsvs,St1} = pattern_list(Ps, St0),
 %%    {{tuple,Line,[{atom,Line,Tag}|TPs]},TPsvs,St1};
-pattern({record_field,_,_,_}=M, St) ->
-    {expand_package(M, St),St};  % must be a package name
 pattern({bin,Line,Es0}, St0) ->
     {Es1,St1} = pattern_bin(Es0, St0),
     {{bin,Line,Es1},St1};
@@ -404,8 +394,6 @@ expr({tuple,Line,Es0}, St0) ->
 %%expr({struct,Line,Tag,Es0}, Vs, St0) ->
 %%    {Es1,Esvs,Esus,St1} = expr_list(Es0, Vs, St0),
 %%    {{tuple,Line,[{atom,Line,Tag}|Es1]},Esvs,Esus,St1};
-expr({record_field,_,_,_}=M, St) ->
-    {expand_package(M, St),St};  % must be a package name
 expr({bin,Line,Es0}, St0) ->
     {Es1,St1} = expr_bin(Es0, St0),
     {{bin,Line,Es1},St1};
@@ -448,12 +436,9 @@ expr({call,Line,{atom,La,N}=Atom,As0}, St0) ->
 		    end
 	    end
     end;
-expr({call,Line,{record_field,_,_,_}=M,As0}, St0) ->
-    expr({call,Line,expand_package(M, St0),As0}, St0);
-expr({call,Line,{remote,Lr,M,F},As0}, St0) ->
-    M1 = expand_package(M, St0),
-    {[M2,F1|As1],St1} = expr_list([M1,F|As0], St0),
-    {{call,Line,{remote,Lr,M2,F1},As1},St1};
+expr({call,Line,{remote,Lr,M0,F},As0}, St0) ->
+    {[M1,F1|As1],St1} = expr_list([M0,F|As0], St0),
+    {{call,Line,{remote,Lr,M1,F1},As1},St1};
 expr({call,Line,F,As0}, St0) ->
     {[Fun1|As1],St1} = expr_list([F|As0], St0),
     {{call,Line,Fun1,As1},St1};
@@ -666,32 +651,6 @@ string_to_conses(Line, Cs, Tail) ->
     foldr(fun (C, T) -> {cons,Line,{char,Line,C},T} end, Tail, Cs).
 
 
-%% In syntax trees, module/package names are atoms or lists of atoms.
-
-package_to_string(A) when is_atom(A) -> atom_to_list(A);
-package_to_string(L) when is_list(L) -> packages:concat(L).
-
-expand_package({atom,L,A} = M, St) ->
-    case dict:find(A, St#expand.mod_imports) of
-        {ok, A1} ->
-            {atom,L,A1};
-        error ->
-            case packages:is_segmented(A) of
-                true ->
-                    M;
-                false -> 
-                    M1 = packages:concat(St#expand.package, A),
-                    {atom,L,list_to_atom(M1)}
-            end
-    end;
-expand_package(M, _St) ->
-    case erl_parse:package_segments(M) of
-        error ->
-            M;
-        M1 ->
-            {atom,element(2,M),list_to_atom(package_to_string(M1))}
-    end.
-
 %% import(Line, Imports, State) ->
 %%      State'
 %% imported(Name, Arity, State) ->
@@ -699,15 +658,10 @@ expand_package(M, _St) ->
 %%  Handle import declarations and test for imported functions. No need to
 %%  check when building imports as code is correct.
 
-import({Mod0,Fs}, St) ->
-    Mod = list_to_atom(package_to_string(Mod0)),
+import({Mod,Fs}, St) ->
+    true = is_atom(Mod),
     Mfs = from_list(Fs),
-    St#expand{imports=add_imports(Mod, Mfs, St#expand.imports)};
-import(Mod0, St) ->
-    Mod = package_to_string(Mod0),
-    Key = list_to_atom(packages:last(Mod)),
-    St#expand{mod_imports=dict:store(Key, list_to_atom(Mod),
-                                     St#expand.mod_imports)}.
+    St#expand{imports=add_imports(Mod, Mfs, St#expand.imports)}.
 
 add_imports(Mod, [F|Fs], Is) ->
     add_imports(Mod, Fs, orddict:store(F, Mod, Is));