Merge branch 'bg/compiler-cover-and-clean' into dev

* bg/compiler-cover-and-clean:
  v3_life: Remove clause that cannot match in match_fail/3
  v3_life tests: Cover exception handling code in v3_life:function/1
  beam_type: Remove redundant clause
  v3_core tests: Cover make_bool_switch_guard/5
  v3_core tests: Cover handling of pattern aliases
  v3_core: Remove a clause in is_simple/1 that cannot match
  v3_core: Remove unused support for generating compilation errors
  Remove stray support for the put_literal/2 instruction
  Remove stray support for the bs_bits_to_bytes2/2 instruction
  Remove the bs_bits_to_bytes/3 instruction
  Cover handling of 'math' BIFs
  beam_bool: Remove a clause in live_regs/1 that cannot match
  beam_bool: Cover handling of bs_context_to_binary in initialized_regs/2
  beam_bool: Remove a clause in initialized_regs/2 that cannot match
  beam_block: Remove a clause that will never be executed
  erts: Stop supporting non-literal empty tuples
  compile: Remove code that is only executed on Solaris
  Do not cover-analyze core_scan
  core_SUITE_data: Don't ignore *.core files in this directory

OTP-8636 bg/compiler-cover-and-clean

1 files changed, 15 insertions, 29 deletions

diff --git a/lib/compiler/src/v3_core.erl b/lib/compiler/src/v3_core.erl
index b2f0ac75c7..16c5b6b415 100644
--- a/lib/compiler/src/v3_core.erl
+++ b/lib/compiler/src/v3_core.erl
@@ -130,7 +130,6 @@
 	       in_guard=false :: boolean(),	%In guard or not.
 	       wanted=true :: boolean(),	%Result wanted or not.
 	       opts     :: [compile:option()],	%Options.
-	       es=[]    :: [error()],		%Errors.
 	       ws=[]    :: [warning()],		%Warnings.
                file=[{file,""}]}).              %File
 
@@ -145,42 +144,37 @@
 
 module({Mod,Exp,Forms}, Opts) ->
     Cexp = map(fun ({_N,_A} = NA) -> #c_var{name=NA} end, Exp),
-    {Kfs0,As0,Es,Ws,_File} = foldl(fun (F, Acc) ->
-					   form(F, Acc, Opts)
-				   end, {[],[],[],[],[]}, Forms),
+    {Kfs0,As0,Ws,_File} = foldl(fun (F, Acc) ->
+					form(F, Acc, Opts)
+				end, {[],[],[],[]}, Forms),
     Kfs = reverse(Kfs0),
     As = reverse(As0),
-    case Es of
-	[] ->
-	    {ok,#c_module{name=#c_literal{val=Mod},exports=Cexp,attrs=As,defs=Kfs},Ws};
-	_ ->
-	    {error,Es,Ws}
-    end.
+    {ok,#c_module{name=#c_literal{val=Mod},exports=Cexp,attrs=As,defs=Kfs},Ws}.
 
-form({function,_,_,_,_}=F0, {Fs,As,Es0,Ws0,File}, Opts) ->
-    {F,Es,Ws} = function(F0, Es0, Ws0, File, Opts),
-    {[F|Fs],As,Es,Ws,File};
-form({attribute,_,file,{File,_Line}}, {Fs,As,Es,Ws,_}, _Opts) ->
-    {Fs,As,Es,Ws,File};
-form({attribute,_,_,_}=F, {Fs,As,Es,Ws,File}, _Opts) ->
-    {Fs,[attribute(F)|As],Es,Ws,File}.
+form({function,_,_,_,_}=F0, {Fs,As,Ws0,File}, Opts) ->
+    {F,Ws} = function(F0, Ws0, File, Opts),
+    {[F|Fs],As,Ws,File};
+form({attribute,_,file,{File,_Line}}, {Fs,As,Ws,_}, _Opts) ->
+    {Fs,As,Ws,File};
+form({attribute,_,_,_}=F, {Fs,As,Ws,File}, _Opts) ->
+    {Fs,[attribute(F)|As],Ws,File}.
 
 attribute({attribute,Line,Name,Val}) ->
     {#c_literal{val=Name, anno=[Line]}, #c_literal{val=Val, anno=[Line]}}.
 
-function({function,_,Name,Arity,Cs0}, Es0, Ws0, File, Opts) ->
+function({function,_,Name,Arity,Cs0}, Ws0, File, Opts) ->
     %%ok = io:fwrite("~p - ", [{Name,Arity}]),
-    St0 = #core{vcount=0,opts=Opts,es=Es0,ws=Ws0,file=[{file,File}]},
+    St0 = #core{vcount=0,opts=Opts,ws=Ws0,file=[{file,File}]},
     {B0,St1} = body(Cs0, Name, Arity, St0),
     %%ok = io:fwrite("1", []),
     %%ok = io:fwrite("~w:~p~n", [?LINE,B0]),
     {B1,St2} = ubody(B0, St1),
     %%ok = io:fwrite("2", []),
     %%ok = io:fwrite("~w:~p~n", [?LINE,B1]),
-    {B2,#core{es=Es,ws=Ws}} = cbody(B1, St2),
+    {B2,#core{ws=Ws}} = cbody(B1, St2),
     %%ok = io:fwrite("3~n", []),
     %%ok = io:fwrite("~w:~p~n", [?LINE,B2]),
-    {{#c_var{name={Name,Arity}},B2},Es,Ws}.
+    {{#c_var{name={Name,Arity}},B2},Ws}.
 
 body(Cs0, Name, Arity, St0) ->
     Anno = lineno_anno(element(2, hd(Cs0)), St0),
@@ -2096,20 +2090,12 @@ is_simple(#c_literal{}) -> true;
 is_simple(#c_cons{hd=H,tl=T}) ->
     is_simple(H) andalso is_simple(T);
 is_simple(#c_tuple{es=Es}) -> is_simple_list(Es);
-is_simple(#c_binary{segments=Es}) -> is_simp_bin(Es);
 is_simple(_) -> false.
 
 -spec is_simple_list([cerl:cerl()]) -> boolean().
 
 is_simple_list(Es) -> lists:all(fun is_simple/1, Es).
 
--spec is_simp_bin([cerl:cerl()]) -> boolean().
-
-is_simp_bin(Es) ->
-    lists:all(fun (#c_bitstr{val=E,size=S}) ->
-		      is_simple(E) andalso is_simple(S)
-	      end, Es).
-
 %%%
 %%% Handling of warnings.
 %%%