Generalize optimizations of case statements

Case expressions such as:

  case {Expr1,Expr} of
     {V1,V2} -> ...
  end

are already optimized to not actually build the tuple. Generalize
the optimization to avoid building any kind of composite term,
such as:

  case {ok,[A,B]} of
    {ok,[X,Y]} -> ...
  end

We don't expect programmers to write such code directly, but
inlining can produce such code.

We need to be careful about the warnings we produce. If the case
expression is a literal, it is expected that no warnings should be
produced for clauses that don't match. We must make sure that we
continue to suppress those warnings.

1 files changed, 282 insertions, 222 deletions

diff --git a/lib/compiler/src/sys_core_fold.erl b/lib/compiler/src/sys_core_fold.erl
index e2002c8e48..a388960312 100644
--- a/lib/compiler/src/sys_core_fold.erl
+++ b/lib/compiler/src/sys_core_fold.erl
@@ -70,7 +70,7 @@
 -export([module/2,format_error/1]).
 
 -import(lists, [map/2,foldl/3,foldr/3,mapfoldl/3,all/2,any/2,
-		reverse/1,reverse/2,member/2,nth/2,flatten/1]).
+		reverse/1,reverse/2,member/2,nth/2,flatten/1,unzip/1]).
 
 -import(cerl, [ann_c_cons/3,ann_c_tuple/2]).
 
@@ -302,18 +302,49 @@ expr(#c_letrec{defs=Fs0,body=B0}=Letrec, Ctxt, Sub) ->
     B1 = body(B0, value, Sub),
     Letrec#c_letrec{defs=Fs1,body=B1};
 expr(#c_case{}=Case0, Ctxt, Sub) ->
+    %% Ideally, the compiler should only emit warnings when there is
+    %% a real mistake in the code being compiled. We use the follow
+    %% heuristics in an attempt to approach that ideal:
+    %%
+    %% * If the guard for a clause always fails, we will emit a
+    %%   warning.
+    %%
+    %% * If a case expression is a literal, we will emit no warnings
+    %%   for clauses that will not match or for clauses that are
+    %%   shadowed after a clause that will always match. That means
+    %%   that code such as:
+    %%
+    %%      case ?DEBUG of
+    %%         false -> ok;
+    %%         true -> ...
+    %%      end
+    %%
+    %%   (where ?DEBUG expands to either 'true' or 'false') will not
+    %%   produce any warnings.
+    %%
+    %% * If the case expression is not literal, warnings will be
+    %%   emitted for every clause that don't match and for all
+    %%   clauses following a clause that will always match.
+    %%
+    %% * If no clause will ever match, there will be a warning
+    %%   (in addition to any warnings that may have been emitted
+    %%   according to the rules above).
+    %%
     case opt_bool_case(Case0) of
 	#c_case{arg=Arg0,clauses=Cs0}=Case1 ->
 	    Arg1 = body(Arg0, value, Sub),
-	    {Arg2,Cs1} = case_opt(Arg1, Cs0),
-	    Cs2 = clauses(Arg2, Cs1, Case1, Ctxt, Sub),
-	    Case = eval_case(Case1#c_case{arg=Arg2,clauses=Cs2}, Sub),
-	    bsm_an(Case);
+	    LitExpr = cerl:is_literal(Arg1),
+	    {Arg2,Cs1} = case_opt(Arg1, Cs0, Sub),
+	    Cs2 = clauses(Arg2, Cs1, Ctxt, Sub, LitExpr),
+	    Case = Case1#c_case{arg=Arg2,clauses=Cs2},
+	    warn_no_clause_match(Case1, Case),
+	    Expr = eval_case(Case, Sub),
+	    bsm_an(Expr);
 	Other ->
 	    expr(Other, Ctxt, Sub)
     end;
 expr(#c_receive{clauses=Cs0,timeout=T0,action=A0}=Recv, Ctxt, Sub) ->
-    Cs1 = clauses(#c_var{name='_'}, Cs0, Recv, Ctxt, Sub), %This is all we know
+    Cs1 = clauses(#c_var{name='_'}, Cs0, Ctxt, Sub, false),
     T1 = expr(T0, value, Sub),
     A1 = body(A0, Ctxt, Sub),
     Recv#c_receive{clauses=Cs1,timeout=T1,action=A1};
@@ -1582,39 +1613,39 @@ v_is_value(Var, [{_,#c_var{name=Var}}|_]) -> true;
 v_is_value(Var, [_|T]) -> v_is_value(Var, T);
 v_is_value(_, []) -> false.
 
-%% clauses(E, [Clause], TopLevel, Context, Sub) -> [Clause].
-%%  Trim the clauses by removing all clauses AFTER the first one which
-%%  is guaranteed to match.  Also remove all trivially false clauses.
+%% warn_no_clause_match(CaseOrig, CaseOpt) -> ok
+%%  Generate a warning if none of the user-specified clauses
+%%  will match.
 
-clauses(E, Cs0, TopLevel, Ctxt, Sub) ->
-    Cs = clauses_1(E, Cs0, Ctxt, Sub),
-
-    %% Here we want to warn if no clauses whatsoever will ever
-    %% match, because that is probably a mistake.
-    case all(fun is_compiler_generated/1, Cs) andalso
-	any(fun(C) -> not is_compiler_generated(C) end, Cs0) of
+warn_no_clause_match(CaseOrig, CaseOpt) ->
+    OrigCs = cerl:case_clauses(CaseOrig),
+    OptCs = cerl:case_clauses(CaseOpt),
+    case any(fun(C) -> not is_compiler_generated(C) end, OrigCs) andalso
+	all(fun is_compiler_generated/1, OptCs) of
 	true ->
 	    %% The original list of clauses did contain at least one
 	    %% user-specified clause, but none of them will match.
 	    %% That is probably a mistake.
-	    add_warning(TopLevel, no_clause_match);
+	    add_warning(CaseOrig, no_clause_match);
 	false ->
 	    %% Either there were user-specified clauses left in
 	    %% the transformed clauses, or else none of the original
 	    %% clauses were user-specified to begin with (as in 'andalso').
 	    ok
-    end,
+    end.
 
-    Cs.
+%% clauses(E, [Clause], TopLevel, Context, Sub) -> [Clause].
+%%  Trim the clauses by removing all clauses AFTER the first one which
+%%  is guaranteed to match.  Also remove all trivially false clauses.
 
-clauses_1(E, [C0|Cs], Ctxt, Sub) ->
+clauses(E, [C0|Cs], Ctxt, Sub, LitExpr) ->
     #c_clause{pats=Ps,guard=G} = C1 = clause(C0, E, Ctxt, Sub),
     %%ok = io:fwrite("~w: ~p~n", [?LINE,{E,Ps}]),
     case {will_match(E, Ps),will_succeed(G)} of
 	{yes,yes} ->
-	    Line = get_line(core_lib:get_anno(C1)),
-	    case core_lib:is_literal(E) of
+	    case LitExpr of
 		false ->
+		    Line = get_line(core_lib:get_anno(C1)),
 		    shadow_warning(Cs, Line);
 		true ->
 		    %% If the case expression is a literal,
@@ -1623,15 +1654,13 @@ clauses_1(E, [C0|Cs], Ctxt, Sub) ->
 		    ok
 	    end,
 	    [C1];				%Skip the rest
-	{no,_Suc} ->
-	    clauses_1(E, Cs, Ctxt, Sub);	%Skip this clause
-	{_Mat,no} ->
+	{_Mat,no} ->				%Guard fails.
 	    add_warning(C1, nomatch_guard),
-	    clauses_1(E, Cs, Ctxt, Sub);	%Skip this clause
+	    clauses(E, Cs, Ctxt, Sub, LitExpr);	%Skip this clause
 	{_Mat,_Suc} ->
-	    [C1|clauses_1(E, Cs, Ctxt, Sub)]
+	    [C1|clauses(E, Cs, Ctxt, Sub, LitExpr)]
     end;
-clauses_1(_, [], _, _) -> [].
+clauses(_, [], _, _, _) -> [].
 
 shadow_warning([C|Cs], none) ->
     add_warning(C, nomatch_shadow),
@@ -1649,69 +1678,18 @@ will_succeed(#c_literal{val=true}) -> yes;
 will_succeed(#c_literal{val=false}) -> no;
 will_succeed(_Guard) -> maybe.
 
-%% will_match(Expr, [Pattern]) -> yes | maybe | no.
-%%  Test if we know whether a match will succeed/fail or just don't
-%%  know.  Be conservative.
+%% will_match(Expr, [Pattern]) -> yes | maybe.
+%%  We KNOW that this function is only used after optimizations
+%%  in case_opt/4. Therefore clauses that can definitely not match
+%%  have already been pruned.
 
 will_match(#c_values{es=Es}, Ps) ->
-    will_match_list(Es, Ps, yes);
+    will_match_1(cerl_clauses:match_list(Ps, Es));
 will_match(E, [P]) ->
-    will_match_1(E, P).
-
-will_match_1(_E, #c_var{}) -> yes;		%Will always match
-will_match_1(E, #c_alias{pat=P}) ->		%Pattern decides
-    will_match_1(E, P);
-will_match_1(#c_var{}, _P) -> maybe;
-will_match_1(#c_tuple{es=Es}, #c_tuple{es=Ps}) ->
-    will_match_list(Es, Ps, yes);
-will_match_1(#c_literal{val=Lit}, P) ->
-    will_match_lit(Lit, P);
-will_match_1(_, _) -> maybe.
-
-will_match_list([E|Es], [P|Ps], M) ->
-    case will_match_1(E, P) of
-	yes -> will_match_list(Es, Ps, M);
-	maybe -> will_match_list(Es, Ps, maybe);
-	no -> no
-    end;
-will_match_list([], [], M) -> M.
-
-will_match_lit(Cons, #c_cons{hd=Hp,tl=Tp}) ->
-    case Cons of
-	[H|T] ->
-	    case will_match_lit(H, Hp) of
-		yes -> will_match_lit(T, Tp);
-		Other -> Other
-	    end;
-	_ ->
-	    no
-    end;
-will_match_lit(Tuple, #c_tuple{es=Es}) ->
-    case is_tuple(Tuple) andalso tuple_size(Tuple) =:= length(Es) of
-	true -> will_match_lit_list(tuple_to_list(Tuple), Es);
-	false -> no
-    end;
-will_match_lit(Bin, #c_binary{}) ->
-    case is_bitstring(Bin) of
-	true -> maybe;
-	false -> no
-    end;
-will_match_lit(_, #c_var{}) ->
-    yes;
-will_match_lit(Lit, #c_alias{pat=P}) ->
-    will_match_lit(Lit, P);
-will_match_lit(Lit1, #c_literal{val=Lit2}) ->
-    case Lit1 =:= Lit2 of
-	true -> yes;
-	false -> no
-    end.
+    will_match_1(cerl_clauses:match(P, E)).
 
-will_match_lit_list([H|T], [P|Ps]) ->
-    case will_match_lit(H, P) of
-	yes -> will_match_lit_list(T, Ps);
-	Other -> Other
-    end;
-will_match_lit_list([], []) -> yes.
+will_match_1({false,_}) -> maybe;
+will_match_1({true,_}) -> yes.
 
 %% opt_bool_case(CoreExpr) - CoreExpr'.
 %%  Do various optimizations to case statement that has a
@@ -1910,166 +1888,243 @@ opt_bool_case_guard(Arg, [#c_clause{pats=[#c_literal{val=false}]}=Fc,Tc]) ->
 %%  last clause is guaranteed to match so if there is only one clause
 %%  with a pattern containing only variables then rewrite to a let.
 
-eval_case(#c_case{arg=#c_var{name=V},
-		  clauses=[#c_clause{pats=[P],guard=G,body=B}|_]}=Case,
-	  #sub{t=Tdb}=Sub) ->
-    case orddict:find(V, Tdb) of
-	{ok,Type} ->
-	    case {will_match_type(P, Type),will_succeed(G)} of
-		{yes,yes} ->
-		    {Ps,Es} = remove_non_vars(P, Type),
-		    expr(#c_let{vars=Ps,arg=#c_values{es=Es},body=B},
-			 sub_new(Sub));
-		{_,_} ->
-		    eval_case_1(Case, Sub)
-	    end;
-	error -> eval_case_1(Case, Sub)
-    end;
-eval_case(Case, Sub) -> eval_case_1(Case, Sub).
-
-eval_case_1(#c_case{arg=E,clauses=[#c_clause{pats=Ps,body=B}]}=Case, Sub) ->
-    case is_var_pat(Ps) of
-	true -> expr(#c_let{vars=Ps,arg=E,body=B}, sub_new(Sub));
-	false -> eval_case_2(E, Ps, B, Case)
-    end;
-eval_case_1(Case, _) -> Case.
-
-eval_case_2(E, [P], B, Case) ->
-    %% Recall that there is only one clause and that it is guaranteed to match.
-    %%   If E and P are literals, they must be the same literal and the body
-    %% can be used directly as there are no variables that need to be bound.
-    %%   Otherwise, P could be an alias meaning that two or more variables
-    %% would be bound to E. We don't bother to optimize that case as it
-    %% is rather uncommon.
-    case core_lib:is_literal(E) andalso core_lib:is_literal(P) of
-	false -> Case;
-	true -> B
-    end;
-eval_case_2(_, _, _, Case) -> Case.
-
-is_var_pat(Ps) ->
-    all(fun (#c_var{}) -> true;
-	    (_Pat) -> false
-	end, Ps).
-
-will_match_type(#c_tuple{es=Es}, #c_tuple{es=Ps}) ->
-    will_match_list_type(Es, Ps);
-will_match_type(#c_literal{val=Atom}, #c_literal{val=Atom}) -> yes;
-will_match_type(#c_var{}, #c_var{}) -> yes;
-will_match_type(#c_var{}, #c_alias{}) -> yes;
-will_match_type(_, _) -> no.
-
-will_match_list_type([E|Es], [P|Ps]) ->
-    case will_match_type(E, P) of
-	yes -> will_match_list_type(Es, Ps);
-	no -> no
-    end;
-will_match_list_type([], []) -> yes;
-will_match_list_type(_, _) -> no.		%Different length
-
-remove_non_vars(Ps0, Es0) ->
-    {Ps,Es} = remove_non_vars(Ps0, Es0, [], []),
-    {reverse(Ps),reverse(Es)}.
-
-remove_non_vars(#c_tuple{es=Ps}, #c_tuple{es=Es}, Pacc, Eacc) ->
-    remove_non_vars_list(Ps, Es, Pacc, Eacc);
-remove_non_vars(#c_var{}=Var, #c_alias{var=Evar}, Pacc, Eacc) ->
-    {[Var|Pacc],[Evar|Eacc]};
-remove_non_vars(#c_var{}=Var, #c_var{}=Evar, Pacc, Eacc) ->
-    {[Var|Pacc],[Evar|Eacc]};
-remove_non_vars(P, E, Pacc, Eacc) ->
-    true = core_lib:is_literal(P) andalso core_lib:is_literal(E), %Assertion.
-    {Pacc,Eacc}.
-
-remove_non_vars_list([P|Ps], [E|Es], Pacc0, Eacc0) ->
-    {Pacc,Eacc} = remove_non_vars(P, E, Pacc0, Eacc0),
-    remove_non_vars_list(Ps, Es, Pacc, Eacc);
-remove_non_vars_list([], [], Pacc, Eacc) ->
-    {Pacc,Eacc}.
+eval_case(#c_case{arg=E,clauses=[#c_clause{pats=Ps0,body=B}]}, Sub) ->
+    Es = case cerl:is_c_values(E) of
+	     true -> cerl:values_es(E);
+	     false -> [E]
+	 end,
+    {true,Bs} = cerl_clauses:match_list(Ps0, Es),
+    {Ps,As} = unzip(Bs),
+    expr(#c_let{vars=Ps,arg=core_lib:make_values(As),body=B}, sub_new(Sub));
+eval_case(Case, _) -> Case.
 
 %% case_opt(CaseArg, [Clause]) -> {CaseArg,[Clause]}.
-%%  Try and optimise case by avoid building a tuple in
-%%  the case expression. Instead of building a tuple
-%%  in the case expression, combine the elements into
-%%  multiple "values". If a clause refers to the tuple
-%%  in the case expression (that was not built), introduce
-%%  a let into the guard and/or body to build the tuple.
+%%  Try and optimise a case by avoid building tuples or lists
+%%  in the case expression. Instead combine the variable parts
+%%  of the case expression to multiple "values". If a clause
+%%  refers to the constructed term in the case expression (which
+%%  was not built), introduce a let into the guard and/or body to
+%%  build the term.
 %%
-%%     case {Expr1,Expr2} of		 case <Expr1,Expr2> of
-%%         {P1,P2} -> ...		     <P1,P2> -> ...
+%%     case {ok,[Expr1,Expr2]} of	case <Expr1,Expr2> of
+%%         {ok,[P1,P2]} -> ...		    <P1,P2> -> ...
 %%          .  	       	       	  ==>        .
 %%          .				     .
 %%          .				     .
-%%         Var ->                            <Var1,Var2> ->
-%%             ... Var ...                      let <Var> = {Var1,Var2}
-%%                                                  in ... Var ...
+%%         Var ->                           <Var1,Var2> ->
+%%             ... Var ...                     let <Var> = {ok,[Var1,Var2]}
+%%                                                 in ... Var ...
 %%          .                                 .
 %%          .                                 .
 %%          .				      .
-%%     end.				 end.
+%%     end.				end.
 %%
-case_opt(#c_tuple{anno=A,es=Es}, Cs0) ->
-    Cs1 = case_opt_cs(Cs0, length(Es)),
-    {core_lib:set_anno(core_lib:make_values(Es), A),Cs1};
-case_opt(Arg, Cs) -> {Arg,Cs}.
-
-case_opt_cs([#c_clause{pats=Ps0,guard=G,body=B}=C|Cs], Arity) ->
-    case case_tuple_pat(Ps0, Arity) of
-	{ok,Ps1,Avs} ->
-	    Flet = fun ({V,Pat}, Body) -> letify(V, Pat, Body) end,
-	    [C#c_clause{pats=Ps1,
-			guard=foldl(Flet, G, Avs),
-			body=foldl(Flet, B, Avs)}|case_opt_cs(Cs, Arity)];
-	error ->				%Can't match
-	    add_warning(C, nomatch_clause_type),
-	    case_opt_cs(Cs, Arity)
+case_opt(Arg, Cs0, Sub) ->
+    Cs1 = [{cerl:clause_pats(C),C,[],[]} || C <- Cs0],
+    Args0 = case cerl:is_c_values(Arg) of
+		false -> [Arg];
+		true -> cerl:values_es(Arg)
+	    end,
+    LitExpr = cerl:is_literal(Arg),
+    {Args,Cs2} = case_opt_args(Args0, Cs1, Sub, LitExpr, []),
+    Cs = [cerl:update_c_clause(C,
+			       reverse(Ps),
+			       letify(Bs, cerl:clause_guard(C)),
+			       letify(Bs, cerl:clause_body(C))) ||
+	     {[],C,Ps,Bs} <- Cs2],
+    {core_lib:make_values(Args),Cs}.
+
+case_opt_args([A0|As0], Cs0, Sub, LitExpr, Acc) ->
+    case case_opt_arg(A0, Sub, Cs0, LitExpr) of
+	error ->
+	    %% Nothing to be done. Move on to the next argument.
+	    Cs = [{Ps,C,[P|PsAcc],Bs} || {[P|Ps],C,PsAcc,Bs} <- Cs0],
+	    case_opt_args(As0, Cs, Sub, LitExpr, [A0|Acc]);
+	{ok,As1,Cs} ->
+	    %% The argument was either expanded (from tuple/list) or
+	    %% removed (literal).
+	    case_opt_args(As1++As0, Cs, Sub, LitExpr, Acc)
+    end;
+case_opt_args([], Cs, _Sub, _LitExpr, Acc) ->
+    {reverse(Acc),Cs}.
+
+%% case_opt_arg(Expr, Sub, Clauses0, LitExpr) ->
+%%         {ok,Args,Clauses} | error
+%%  Try to expand one argument to several arguments (if tuple/list)
+%%  or to remove a literal argument.
+%%
+case_opt_arg(E0, Sub, Cs, LitExpr) ->
+    E = maybe_replace_var(E0, Sub),
+    case cerl:is_data(E) of
+	false ->
+	    error;
+	true ->
+	    case cerl:data_type(E) of
+		{atomic,_} ->
+		    case_opt_lit(E, Cs, LitExpr);
+		_ ->
+		    case_opt_data(E, Cs, LitExpr)
+	    end
+    end.
+
+%% maybe_replace_var(Expr0, Sub) -> Expr
+%%  If Expr0 is a variable that has been previously matched and
+%%  is known to be a tuple, return the tuple instead. Otherwise
+%%  return Expr0 unchanged.
+%%
+maybe_replace_var(E, Sub) ->
+    case cerl:is_c_var(E) of
+	false -> E;
+	true -> maybe_replace_var_1(E, Sub)
+    end.
+
+maybe_replace_var_1(E, #sub{t=Tdb}) ->
+    case orddict:find(cerl:var_name(E), Tdb) of
+	{ok,T0} ->
+	    case cerl:is_c_tuple(T0) of
+		false ->
+		    E;
+		true ->
+		    cerl_trees:map(fun(C) ->
+					   case cerl:is_c_alias(C) of
+					       false -> C;
+					       true -> cerl:alias_pat(C)
+					   end
+				   end, T0)
+	    end;
+	error ->
+	    E
+    end.
+
+%% case_opt_lit(Literal, Clauses0, LitExpr) ->
+%%           {ok,[],Clauses} | error
+%%  The current part of the case expression is a literal. That
+%%  means that we will know at compile-time whether a clause
+%%  will match, and we can remove the corresponding pattern from
+%%  each clause.
+%%
+%%  The only complication is if the literal is a binary. Binary
+%%  pattern matching is tricky, so we will give up in that case.
+
+case_opt_lit(Lit, Cs0, LitExpr) ->
+    try case_opt_lit_1(Cs0, Lit, LitExpr) of
+	Cs ->
+	    {ok,[],Cs}
+    catch
+	throw:impossible ->
+	    error
+    end.
+
+case_opt_lit_1([{[P|Ps],C,PsAcc,Bs0}|Cs], E, LitExpr) ->
+    case cerl_clauses:match(P, E) of
+	none ->
+	    %% The pattern will not match the literal. Remove the clause.
+	    %% Unless the entire case expression is a literal, also
+	    %% emit a warning.
+	    case LitExpr of
+		false -> add_warning(C, nomatch_clause_type);
+		true -> ok
+	    end,
+	    case_opt_lit_1(Cs, E, LitExpr);
+	{true,Bs} ->
+	    %% The pattern matches the literal. Remove the pattern
+	    %% and update the bindings.
+	    [{Ps,C,PsAcc,Bs++Bs0}|case_opt_lit_1(Cs, E, LitExpr)];
+	{false,_} ->
+	    %% Binary literal and pattern. We are not sure whether
+	    %% the pattern will match.
+	    throw(impossible)
+    end;
+case_opt_lit_1([], _, _) -> [].
+
+%% case_opt_data(Expr, Clauses0, LitExpr) -> {ok,Exprs,Clauses}
+
+case_opt_data(E, Cs0, LitExpr) ->
+    Es = cerl:data_es(E),
+    Cs = case_opt_data_1(Cs0, Es,
+			 {cerl:data_type(E),cerl:data_arity(E)},
+			 LitExpr),
+    {ok,Es,Cs}.
+
+case_opt_data_1([{[P|Ps0],C,PsAcc,Bs0}|Cs], Es, TypeSig, LitExpr) ->
+    case case_data_pat(P, TypeSig) of
+	{ok,Ps1,Bs1} ->
+	    [{Ps1++Ps0,C,PsAcc,Bs1++Bs0}|
+	     case_opt_data_1(Cs, Es, TypeSig,LitExpr)];
+	error ->
+	    case LitExpr of
+		false -> add_warning(C, nomatch_clause_type);
+		true -> ok
+	    end,
+	    case_opt_data_1(Cs, Es, TypeSig, LitExpr)
     end;
-case_opt_cs([], _) -> [].
+case_opt_data_1([], _, _, _) -> [].
 
-%% case_tuple_pat([Pattern], Arity) -> {ok,[Pattern],[{AliasVar,Pat}]} | error.
+%% case_data_pat(Pattern, Type, Arity) -> {ok,[Pattern],[{AliasVar,Pat}]} | error.
 
-case_tuple_pat([#c_tuple{es=Ps}], Arity) when length(Ps) =:= Arity ->
-    {ok,Ps,[]};
-case_tuple_pat([#c_literal{val=T}], Arity) when tuple_size(T) =:= Arity ->
-    Ps = [#c_literal{val=E} || E <- tuple_to_list(T)],
-    {ok,Ps,[]};
-case_tuple_pat([#c_var{anno=Anno0}=V], Arity) ->
-    Vars = make_vars(Anno0, 1, Arity),
+case_data_pat(P, TypeSig) ->
+    case cerl:is_data(P) of
+	false ->
+	    case_data_pat_var(P, TypeSig);
+	true ->
+	    case {cerl:data_type(P),cerl:data_arity(P)} of
+		TypeSig ->
+		    {ok,cerl:data_es(P),[]};
+		{_,_} ->
+		    error
+	    end
+    end.
 
+%% case_data_pat_var(Pattern, {DataType,ArityType}) ->
+%%          {ok,[Pattern],[{AliasVar,Pat}]}
+
+case_data_pat_var(P, {Type,Arity}=TypeSig) ->
     %% If the entire case statement is evaluated in an effect
     %% context (e.g. "case {A,B} of ... end, ok"), there will
     %% be a warning that a term is constructed but never used.
-    %% To avoid that warning, we must annotate the tuple as
-    %% compiler generated.
-
-    Anno = [compiler_generated|Anno0],
-    {ok,Vars,[{V,#c_tuple{anno=Anno,es=Vars}}]};
-case_tuple_pat([#c_alias{var=V,pat=P}], Arity) ->
-    case case_tuple_pat([P], Arity) of
-	{ok,Ps,Avs} ->
-	    Anno0 = core_lib:get_anno(P),
-	    Anno = [compiler_generated|Anno0],
-	    {ok,Ps,[{V,#c_tuple{anno=Anno,es=unalias_pat_list(Ps)}}|Avs]};
-	error ->
+    %% To avoid that warning, we must annotate the data
+    %% constructor as compiler generated.
+    Ann = [compiler_generated|cerl:get_ann(P)],
+    case cerl:type(P) of
+	var ->
+	    Vars = make_vars(cerl:get_ann(P), Arity),
+	    {ok,Vars,[{P,cerl:ann_make_data(Ann, Type, Vars)}]};
+	alias ->
+	    V = cerl:alias_var(P),
+	    Apat = cerl:alias_pat(P),
+	    case case_data_pat(Apat, TypeSig) of
+		{ok,Ps,Bs} ->
+		    {ok,Ps,[{V,cerl:ann_make_data(Ann, Type, unalias_pat_list(Ps))}|Bs]};
+		error ->
+		    error
+	    end;
+	_ ->
 	    error
-    end;
-case_tuple_pat(_, _) -> error.
+    end.
 
 %% unalias_pat(Pattern) -> Pattern.
 %%  Remove all the aliases in a pattern but using the alias variables
 %%  instead of the values.  We KNOW they will be bound.
 
-unalias_pat(#c_alias{var=V}) -> V;
-unalias_pat(#c_cons{anno=Anno,hd=H0,tl=T0}) ->
-    H1 = unalias_pat(H0),
-    T1 = unalias_pat(T0),
-    ann_c_cons(Anno, H1, T1);
-unalias_pat(#c_tuple{anno=Anno,es=Ps}) ->
-    ann_c_tuple(Anno, unalias_pat_list(Ps));
-unalias_pat(Atomic) -> Atomic.
+unalias_pat(P) ->
+    case cerl:is_c_alias(P) of
+	true ->
+	    cerl:alias_var(P);
+	false ->
+	    case cerl:is_data(P) of
+		false ->
+		    P;
+		true ->
+		    Es = unalias_pat_list(cerl:data_es(P)),
+		    cerl:update_data(P, cerl:data_type(P), Es)
+	    end
+    end.
 
 unalias_pat_list(Ps) -> [unalias_pat(P) || P <- Ps].
 
+make_vars(A, Max) ->
+    make_vars(A, 1, Max).
+
 make_vars(A, I, Max) when I =< Max ->
     [make_var(A)|make_vars(A, I+1, Max)];
 make_vars(_, _, _) -> [].
@@ -2082,6 +2137,11 @@ make_var_name() ->
     put(new_var_num, N+1),
     list_to_atom("fol"++integer_to_list(N)).
 
+letify(Bs, Body) ->
+    foldr(fun({V,Val}, B) ->
+		  letify(V, Val, B)
+	  end, Body, Bs).
+
 letify(#c_var{name=Vname}=Var, Val, Body) ->
     case core_lib:is_var_used(Vname, Body) of
 	true ->
@@ -2102,7 +2162,7 @@ opt_case_in_let_0([#c_var{name=V}], Arg,
 	    case is_simple_case_arg(Arg) andalso
 		not core_lib:is_var_used(V, Case#c_case{arg=#c_literal{val=nil}}) of
 		true ->
-		    opt_bool_case(Case#c_case{arg=Arg});
+		    expr(opt_bool_case(Case#c_case{arg=Arg,clauses=Cs}), sub_new());
 		false ->
 		    Let
 	    end;