anchor.diff:      verify_y_init(Vst),
   
       %% #ms{} can represent either a match context or a term, so we have to mark
  -    %% the source as a term if it fails, and retain the incoming type if it
  -    %% succeeds (match context or not).
  -    %%
  -    %% The override_type hack is only needed until we get proper union types.
  +    %% the source as a term if it fails with a match context as an input. This
  +    %% hack is only needed until we get proper union types.
       complex_test(Fail,
                    fun(FailVst) ->
  -                         override_type(term, Src, FailVst)
  +                         case get_raw_type(Src, FailVst) of
  +                             #ms{} -> override_type(term, Src, FailVst);
  +                             _ -> FailVst
  +                         end
                    end,
                    fun(SuccVst0) ->
  -                         SuccVst = prune_x_regs(Live, SuccVst0),
  +                         SuccVst1 = update_type(fun meet/2, binary, Src, SuccVst0),
  +                         SuccVst = prune_x_regs(Live, SuccVst1),
                            extract_term(Type, bs_start_match, [Src], Dst,
                                         SuccVst, SuccVst0)
                    end, Vst).
  
positive.code:     Other;
  meet(Other, term) ->
      Other;
  meet({literal,_}, {literal,_}) ->
      none;
  meet(T1, {literal,_}=T2) ->
  
negative.code: bif_return_type(float, _, _) -> {float,[]};
  bif_return_type('/', _, _) -> {float,[]};
  %% Binary operations
  bif_return_type('binary_part', [_,_], _) -> binary;
  bif_return_type('binary_part', [_,_,_], _) -> binary;
  bif_return_type('bit_size', [_], _) -> {integer,[]};
  bif_return_type('byte_size', [_], _) -> {integer,[]};
  %% Integer operations.
  bif_return_type(ceil, [_], _) -> {integer,[]};
  bif_return_type('div', [_,_], _) -> {integer,[]};
  