anchor.diff:  %%  a standard Erlang type (no catch/try tags or match contexts).
   
   get_term_type(Src, Vst) ->
  -    case get_move_term_type(Src, Vst) of
  +    case get_movable_term_type(Src, Vst) of
           #ms{} -> error({match_context,Src});
           Type -> Type
       end.
   
  -%% get_move_term_type(Src, ValidatorState) -> Type
  +%% get_movable_term_type(Src, ValidatorState) -> Type
   %%  Get the type of the source Src. The returned type Type will be
   %%  a standard Erlang type (no catch/try tags). Match contexts are OK.
   
  -get_move_term_type(Src, Vst) ->
  +get_movable_term_type(Src, Vst) ->
       case get_raw_type(Src, Vst) of
           initialized -> error({unassigned,Src});
           uninitialized -> error({uninitialized_reg,Src});
           {catchtag,_} -> error({catchtag,Src});
           {trytag,_} -> error({trytag,Src});
           tuple_in_progress -> error({tuple_in_progress,Src});
  +        {literal,_}=Lit -> get_literal_type(Lit);
           Type -> Type
       end.
   
  
positive.code:     error({invalid_tag_register,Src}).
  
  %% get_raw_type(Src, ValidatorState) -> Type
  %%  Return the type of a register without doing any validity checks.
  get_raw_type({x,X}=Src, #vst{current=#st{xs=Xs}}=Vst) when is_integer(X) ->
      check_limit(Src),
      case Xs of
  
negative.code:     %% hack is only needed until we get proper union types.
      complex_test(Fail,
                   fun(FailVst) ->
                           case get_movable_term_type(Src, FailVst) of
                               #ms{} -> override_type(term, Src, FailVst);
                               _ -> FailVst
                           end
                   end,
                   fun(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)
  