anchor.diff:                         0,
                          MsgDef).
   
  +compute_translations(Defs, Opts) ->
  +    lists:foldl(
  +      fun({Name, Dict}, D) ->
  +              %% For now it is an (internal) error if translations overlap,
  +              %% (don't expect that to happen with current translations)
  +              %% but in the future (eg with user-specified translations)
  +              %% they might stack instead: ie Ts1 ++ Ts2 instead of error.
  +              dict:merge(fun(Key, Ts1, Ts2) ->
  +                                 error({error,{duplicate_translation,
  +                                               {when_adding_transls_for,Name},
  +                                               {key,Key},
  +                                               {translations,Ts1,Ts2}}})
  +                         end,
  +                         Dict, D)
  +      end,
  +      dict:new(),
  +      [{map_translations, compute_map_translations(Defs, Opts)},
  +       {any_translations, compute_any_translations(Defs, Opts)}]).
  +
   compute_map_translations(Defs, Opts) ->
       MapInfos =
           fold_msg_fields(
  
positive.code:       "       If no package is defined, nothing will be prepended.\n"
        "       Default is to not prepend package names for backwards\n"
        "       compatibility, but it is needed for some proto files.\n"},
       {"msgprefix", 'string()', msg_name_prefix, "Prefix\n"
        "       Prefix each message with Prefix.\n"},
       {"modprefix", 'string()', module_name_prefix, "Prefix\n"
  
negative.code:       || {ElemPath, OpTransls} <- dict:to_list(Ts)],
       format_default_merge_translators(AnRes, Opts)].
  
  format_field_op_translator(ElemPath, Op, CallTemplate) when Op /= verify ->
      ArgTemplate = last_tuple_element(CallTemplate),
      FnName = mk_tr_fn_name(ElemPath, Op),
      InArgs = underscore_unused_args(args_by_op(Op), ArgTemplate),
  