anchor.diff:                  #{ VRef := Other } ->
                       error({multiple_match_contexts, [Reg, Other]});
                   #{} ->
  -                    verify_arg_type(Lbl, Reg, Type, Vst),
  -                    verify_local_args(X - 1, Lbl, CtxRefs#{ VRef => Reg }, Vst)
  +                    verify_arg_type(Reg, Type, ParamTypes),
  +                    verify_local_args(X - 1, ParamTypes,
  +                                      CtxRefs#{ VRef => Reg }, Vst)
               end;
           Type ->
  -            verify_arg_type(Lbl, Reg, Type, Vst),
  -            verify_local_args(X - 1, Lbl, CtxRefs, Vst)
  +            verify_arg_type(Reg, Type, ParamTypes),
  +            verify_local_args(X - 1, ParamTypes, CtxRefs, Vst)
       end.
   
   %% Verifies that the given argument narrows to what the function expects.
  -verify_arg_type(Lbl, Reg, #ms{}, #vst{ft=Ft}) ->
  +verify_arg_type(Reg, #ms{}, ParamTypes) ->
       %% Match contexts require explicit support, and may not be passed to a
       %% function that accepts arbitrary terms.
  -    case gb_trees:lookup({Lbl, Reg}, Ft) of
  -        {value, #ms{}} -> ok;
  -        _ -> error(no_bs_start_match2)
  -    end;
  -verify_arg_type(Lbl, Reg, GivenType, #vst{ft=Ft}) ->
  -    case gb_trees:lookup({Lbl, Reg}, Ft) of
  -        {value, #ms{}} ->
  +    case ParamTypes of
  +        #{ Reg := #ms{}} -> ok;
  +        #{} -> error(no_bs_start_match2)
  +    end;
  +verify_arg_type(Reg, GivenType, ParamTypes) ->
  +    case ParamTypes of
  +        #{ Reg := #ms{}} ->
               %% Functions that accept match contexts also accept all other
               %% terms. This will change once we support union types.
               ok;
  -        {value, RequiredType} ->
  +        #{ Reg := RequiredType } ->
               case vat_1(GivenType, RequiredType) of
                   true -> ok;
                   false -> error({bad_arg_type, Reg, GivenType, RequiredType})
               end;
  -        none ->
  +        #{} ->
               ok
       end.
   
  
positive.code: %%  format as used in the compiler and in .S files.
  
  validate(Module, Fs) ->
      Ft = index_parameter_types(Fs, []),
      validate_0(Module, Fs, Ft).
  
  validate_0(_Module, [], _) -> [];
  
negative.code: 
  verify_call_args(_, 0, #vst{}) ->
      ok;
  verify_call_args({f,Lbl}, Live, #vst{ft=Ft}=Vst) when is_integer(Live) ->
      case gb_trees:lookup(Lbl, Ft) of
          {value, FuncInfo} ->
              #{ arity := Live,
                 parameter_types := ParamTypes } = FuncInfo,
              verify_local_args(Live - 1, ParamTypes, #{}, Vst);
          none ->
              error(local_call_to_unknown_function)
      end;
  verify_call_args(_, Live, Vst) when is_integer(Live)->
      verify_remote_args_1(Live - 1, Vst);
  verify_call_args(_, Live, _) ->
  