anchor.diff:      Es = set_element_type(Index, get_type(Lit, #{}), #{}),
       [{Tuple,#t_tuple{size=Index,elements=Es}}];
   infer_eq_lit(_, _) -> [].
  +
  +infer_type_negative(Op, Args, Ds) ->
  +    case is_negative_inference_safe(Op, Args) of
  +        true ->
  +            infer_type(Op, Args, Ds);
  +        false ->
  +            []
  +    end.
  +
  +%% Conservative list of instructions for which negative
  +%% inference is safe.
  +is_negative_inference_safe(is_nonempty_list, _Args) -> true;
  +is_negative_inference_safe(_, _) -> false.
   
   infer_type({bif,element}, [#b_literal{val=Pos},#b_var{}=Tuple], _Ds) ->
       if
  
positive.code:     %%
      %% However, it is safe to subtract a type inferred from '=:=' if
      %% it is single-valued, e.g. if it is [] or the atom 'true'.
      EqTypes0 = infer_eq_type(Op, Args, Ts, Ds),
      {Types1,EqTypes} = partition(fun({_,T}) ->
                                           is_singleton_type(T)
                                   end, EqTypes0),
  
      Types = Types1 ++ Types0,
      {meet_types(EqTypes++Types, Ts),subtract_types(Types, Ts)}.
  
  infer_types_switch(V, Lit, Ts, #d{ds=Ds}) ->
      Types = infer_eq_type({bif,'=:='}, [V, Lit], Ts, Ds),
  
negative.code: 
  -include("beam_ssa_opt.hrl").
  -import(lists, [all/2,any/2,droplast/1,foldl/3,last/1,member/2,
                  keyfind/3,reverse/1,reverse/2,
                  seq/2,sort/1,split/2]).
  
  -define(UNICODE_INT, #t_integer{elements={0,16#10FFFF}}).
  