anchor.diff:                                       ?expr({'<OFName>','<OFVar>'})),
                           replace_term('<verify-fn>', FVerifierFn2),
                           replace_tree('<OFVar>', OFVar),
  -                        replace_term('<OFName>', OFName)]
  +                        replace_term('<OFName>', OFName),
  +                        splice_trees('MaybeTrUserData',
  +                                     maybe_userdata_param(F, TrUserDataVar))]
                      end
                      || #?gpb_field{name=OFName, type=Type}=F <- OFields])]);
           {maps, omitted} ->
               ?expr(
                  case 'M' of
                      '<oneof-pattern>' ->
  -                       '<verify-fn>'('<OFVar>', ['<OFName>', '<FName>' | Path]);
  +                       '<verify-fn>'('<OFVar>', ['<OFName>', '<FName>' | Path],
  +                                     'MaybeTrUserData');
                      '#{<FName> := <F>}' ->
                          mk_type_error(invalid_oneof, '<F>', ['<FName>' | Path]);
                      _ ->
  
positive.code:                           maps    -> true
                        end,
      FnName = mk_fn(v_msg_, MsgName),
      [nowarn_dialyzer_attr(FnName,2),
       gpb_codegen:format_fn(
         FnName,
         fun('<msg-match>', '<Path>') ->
                 '<verify-fields>',
                 ok;
            ('<M>', Path) when is_map('<M>') ->
                 mk_type_error(
                   {missing_fields, 'NonOptKeys'--maps:keys('<M>'), '<MsgName>'},
                   '<M>', Path);
            ('<X>', Path) ->
                 mk_type_error({expected_msg,'<MsgName>'}, X, Path)
         end,
         [replace_tree('<msg-match>', FieldMatching),
          replace_tree('<Path>', if MsgDef == [] -> ?expr(_Path);
                                    MsgDef /= [] -> ?expr(Path)
                                 end),
          splice_trees('<verify-fields>',
                       field_verifiers(MsgName, MsgDef, FVars, MsgVar,
                                       AnRes, Opts)),
          repeat_clauses('<X>', case NeedsMatchOther of
                                    true  -> [[replace_tree('<X>', ?expr(X))]];
  
negative.code: %% -- verifiers -----------------------------------------------------
  
  format_verifiers_top_function(Defs, Opts) ->
      case {contains_messages(Defs), get_records_or_maps_by_opts(Opts)} of
          {false, records} -> format_verifiers_top_no_msgs_r();
          {false, maps}    -> format_verifiers_top_no_msgs_m();
          {true,  _}       -> format_verifiers_top_with_msgs(Defs, Opts)
      end.
  
  format_verifiers_top_no_msgs_r() ->
      [?f("-spec verify_msg(_) -> no_return().~n", []),
       gpb_codegen:format_fn(
         verify_msg,
         fun(Msg) -> call_self(Msg, []) end),
       ?f("-spec verify_msg(_,_) -> no_return().~n", []),
       gpb_codegen:format_fn(
         verify_msg,
         fun(Msg,_Opts) -> mk_type_error(not_a_known_message, Msg, []) end),
       "\n"].
  
  format_verifiers_top_no_msgs_m() ->
      [?f("-spec verify_msg(_,_) -> no_return().~n", []),
       gpb_codegen:format_fn(
         verify_msg,
         fun(Msg, MsgName) -> call_self(Msg, MsgName, []) end),
       ?f("-spec verify_msg(_,_,_) -> no_return().~n", []),
       gpb_codegen:format_fn(
         verify_msg,
         fun(Msg, _MsgName, _Opts) ->
                 mk_type_error(not_a_known_message, Msg, [])
         end),
       "\n"].
  
  format_verifiers_top_with_msgs(Defs, Opts) ->
      Mapping = get_records_or_maps_by_opts(Opts),
      MsgNameVars = case Mapping of
                        records -> [];
                        maps    -> [?expr(MsgName)]
                    end,
      [gpb_codegen:format_fn(
         verify_msg,
         fun(Msg, '<MsgName>') -> call_self(Msg, '<MsgName>', []) end,
         [splice_trees('<MsgName>', MsgNameVars)]),
       gpb_codegen:format_fn(
         verify_msg,
         fun(Msg, '<MsgName>', Opts) ->
                 TrUserData = proplists:get_value(user_data, Opts),
                 case '<MsgOrMsgName>' of
                     '<msg-match>' -> '<verify-msg>'(Msg, ['<MsgName>'],
                                                     TrUserData);
                     _ -> mk_type_error(not_a_known_message, Msg, [])
                 end
         end,
  