Silence warnings for expressions that are assigned to "_"

There is currently no zero-cost way to silence the warning
"the result of the expression is ignored", which is issued
for code such as:

  list_to_integer(S),
  ok

Such code can be useful for assertions or input validation.

Teach the compiler to silence the warning for expressions
that are explicitly assigned to to the "_" variable,
such as:

  _ = list_to_integer(S),
  ok

Implement it by having the v3_core pass annotate calls in
Core Erlang like this:

  let <_> = ( call 'erlang':'list_to_integer'(S) -| ['result_not_wanted'] )
      in 'ok'

and modifiy sys_core_fold to suppress the warning for any call
having the annotation.

We deliberately do not make it possible to silence the warnings
for expressions like:

  {build,an,unnecessary,term}, ok

or

  is_list(L), ok

because we don't know of any real-world scenarios in which that would
be useful.

2 files changed, 31 insertions, 12 deletions

diff --git a/lib/compiler/src/sys_core_fold.erl b/lib/compiler/src/sys_core_fold.erl
index 068478496b..3b374be015 100644
--- a/lib/compiler/src/sys_core_fold.erl
+++ b/lib/compiler/src/sys_core_fold.erl
@@ -602,15 +602,23 @@ count_bits_1(Int, Bits) -> count_bits_1(Int bsr 64, Bits+64).
 %%  a rewritten expression consisting of a sequence of
 %%  the arguments only is returned.
 
-useless_call(effect, #c_call{module=#c_literal{val=Mod},
+useless_call(effect, #c_call{anno=Anno,
+			     module=#c_literal{val=Mod},
 			     name=#c_literal{val=Name},
 			     args=Args}=Call) ->
     A = length(Args),
     case erl_bifs:is_safe(Mod, Name, A) of
 	false ->
 	    case erl_bifs:is_pure(Mod, Name, A) of
-		true -> add_warning(Call, result_ignored);
-		false -> ok
+		true ->
+		    case member(result_not_wanted, Anno) of
+			false ->
+			    add_warning(Call, result_ignored);
+			true ->
+			    ok
+		    end;
+		false ->
+		    ok
 	    end,
 	    no;
 	true ->
@@ -2806,7 +2814,8 @@ format_error({no_effect,{erlang,F,A}}) ->
 		 end,
     flatten(io_lib:format(Fmt, Args));
 format_error(result_ignored) ->
-    "the result of the expression is ignored";
+    "the result of the expression is ignored "
+	"(suppress the warning by assigning the expression to the _ variable)";
 format_error(useless_building) ->
     "a term is constructed, but never used";
 format_error(bin_opt_alias) ->
diff --git a/lib/compiler/src/v3_core.erl b/lib/compiler/src/v3_core.erl
index 4ac2196d79..b2f0ac75c7 100644
--- a/lib/compiler/src/v3_core.erl
+++ b/lib/compiler/src/v3_core.erl
@@ -128,6 +128,7 @@
 -record(core, {vcount=0 :: non_neg_integer(),	%Variable counter
 	       fcount=0 :: non_neg_integer(),	%Function counter
 	       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.
@@ -580,10 +581,14 @@ expr({'fun',L,{function,F,A},{_,_,_}=Id}, St) ->
     {#c_var{anno=Lanno++[{id,Id}],name={F,A}},[],St};
 expr({'fun',L,{clauses,Cs},Id}, St) ->
     fun_tq(Id, Cs, L, St);
-expr({call,L,{remote,_,M,F},As0}, St0) ->
+expr({call,L,{remote,_,M,F},As0}, #core{wanted=Wanted}=St0) ->
     {[M1,F1|As1],Aps,St1} = safe_list([M,F|As0], St0),
     Lanno = lineno_anno(L, St1),
-    {#icall{anno=#a{anno=Lanno},module=M1,name=F1,args=As1},Aps,St1};
+    Anno = case Wanted of
+	       false -> [result_not_wanted|Lanno];
+	       true -> Lanno
+	   end,
+    {#icall{anno=#a{anno=Anno},module=M1,name=F1,args=As1},Aps,St1};
 expr({call,Lc,{atom,Lf,F},As0}, St0) ->
     {As1,Aps,St1} = safe_list(As0, St0),
     Op = #c_var{anno=lineno_anno(Lf, St1),name={F,length(As1)}},
@@ -596,23 +601,28 @@ expr({call,L,FunExp,As0}, St0) ->
 expr({match,L,P0,E0}, St0) ->
     %% First fold matches together to create aliases.
     {P1,E1} = fold_match(E0, P0),
-    {E2,Eps,St1} = novars(E1, St0),
+    St1 = case P1 of
+	      {var,_,'_'} -> St0#core{wanted=false};
+	      _ -> St0
+	  end,
+    {E2,Eps,St2} = novars(E1, St1),
+    St3 = St2#core{wanted=St0#core.wanted},
     P2 = try
-	     pattern(P1, St1)
+	     pattern(P1, St3)
 	 catch
 	     throw:Thrown ->
 		 Thrown
 	 end,
-    {Fpat,St2} = new_var(St1),
+    {Fpat,St4} = new_var(St3),
     Fc = fail_clause([Fpat], c_tuple([#c_literal{val=badmatch},Fpat])),
-    Lanno = lineno_anno(L, St2),
+    Lanno = lineno_anno(L, St4),
     case P2 of
 	nomatch ->
-	    St = add_warning(L, nomatch, St2),
+	    St = add_warning(L, nomatch, St4),
 	    {#icase{anno=#a{anno=Lanno},
 		    args=[E2],clauses=[],fc=Fc},Eps,St};
 	Other when not is_atom(Other) ->
-	    {#imatch{anno=#a{anno=Lanno},pat=P2,arg=E2,fc=Fc},Eps,St2}
+	    {#imatch{anno=#a{anno=Lanno},pat=P2,arg=E2,fc=Fc},Eps,St4}
     end;
 expr({op,_,'++',{lc,Llc,E,Qs},More}, St0) ->
     %% Optimise '++' here because of the list comprehension algorithm.