{"record":{"id":"3aabd7bc3afd3356","repo":"bchavez/Bogus","slug":"cannot-parse-arguments-for-mm-name-argument-lis","errorCode":null,"errorMessage":"Cannot parse arguments for {mm.Name}. Argument list: {string.Join(\",\", parameters)}","messagePattern":"Cannot parse arguments for (.+?)\\. Argument list: (.+?)","errorType":"exception","errorClass":"ArgumentException","httpStatus":null,"severity":"error","filePath":"Source/Bogus/Tokenizer.cs","lineNumber":156,"sourceCode":"   private static object[] ConvertStringArgumentsToObjects(string[] parameters, MustashMethod mm)\n   {\n      try\n      {\n         return mm.Method.GetParameters()\n                         .Zip(parameters, GetValueForParameter)\n                         .ToArray();\n      }\n      catch (OverflowException ex)\n      {\n         throw new ArgumentOutOfRangeException($\"One of the arguments for {mm.Name} is out of supported range. Argument list: {string.Join(\",\", parameters)}\", ex);\n      }\n      catch (Exception ex) when (ex is InvalidCastException or FormatException)\n      {\n         throw new ArgumentException($\"One of the arguments for {mm.Name} cannot be converted to target type. Argument list: {string.Join(\",\", parameters)}\", ex);\n      }\n      catch (Exception ex)\n      {\n         throw new ArgumentException($\"Cannot parse arguments for {mm.Name}. Argument list: {string.Join(\",\", parameters)}\", ex);\n      }\n   }\n\n   private static object GetValueForParameter(ParameterInfo parameterInfo, string parameterValue)\n   {\n      var type = Nullable.GetUnderlyingType(parameterInfo.ParameterType) ?? parameterInfo.ParameterType;\n\n      if( typeof(Enum).IsAssignableFrom(type)) return Enum.Parse(type, parameterValue);\n\n      if( typeof(TimeSpan) == type ) return TimeSpan.Parse(parameterValue);\n\n      return Convert.ChangeType(parameterValue, type);\n   }\n\n   private static string GetArgumentsString(string methodCall, int parametersStart)\n   {\n      var parametersEnd = methodCall.IndexOf(')');\n      if( parametersEnd == -1 )","sourceCodeStart":138,"sourceCodeEnd":174,"githubUrl":"https://github.com/bchavez/Bogus/blob/6ece18c5c22648ab4606e45a0aaf2f07fc5259e4/Source/Bogus/Tokenizer.cs#L138-L174","documentation":"The fallback catch-all in Tokenizer.ConvertStringArgumentsToObjects (Tokenizer.cs:156) catches any conversion exception not already handled (i.e. not OverflowException, InvalidCastException, or FormatException) and rethrows as ArgumentException. The most common source is System.ArgumentException from Enum.Parse(type, value) when value is not a defined member of the enum: that ArgumentException is neither InvalidCast nor Format, so it slips past the filtered handlers into this generic one.","triggerScenarios":"Passing an UNDEFINED enum member name to an enum-typed parameter, e.g. {{system.filetype(\"notreal\")}} where 'notreal' is not a defined member: Enum.Parse throws ArgumentException, rewrapped here. Any other exotic converter exception also lands here.","commonSituations":"Guessing enum member names from strings; version skew where an enum member was renamed or removed between Bogus versions; data files referencing an enum value that no longer exists; typos in case-sensitive enum names.","solutions":["Use only currently-defined enum member names (case-sensitive) or their integral values as the argument.","Inspect the inner exception (InnerException / its Message) to identify the rejected value and target type.","If you control the input, validate enum names against Enum.GetNames(targetType) before templating."],"exampleFix":"// before\nfaker.Parse(\"{{system.filetype(\\\"notreal\\\")}}\");\n// after\nfaker.Parse(\"{{system.filetype(\\\"jpeg\\\")}}\"); // use a defined member","handlingStrategy":"validation","validationCode":"// The generic catch is most often Enum.Parse rejecting an undefined member; pre-check enums.\nstatic bool EnumArgOk(string value, Type targetType)\n{\n    var t = Nullable.GetUnderlyingType(targetType) ?? targetType;\n    if (!typeof(Enum).IsAssignableFrom(t)) return true;\n    return Enum.IsDefined(t, value) || (int.TryParse(value, out var n) && Enum.IsDefined(t, n));\n}","typeGuard":null,"tryCatchPattern":"try { var s = faker.Parse(tpl); }\ncatch (ArgumentException ex) when (ex.Message.Contains(\"Cannot parse arguments\"))\n{\n    // Inspect ex.InnerException: for enum params it is the ArgumentException from Enum.Parse.\n    throw new InvalidOperationException($\"Argument parsing failed (often an undefined enum member) in template: {tpl}\", ex);\n}","preventionTips":["For enum-typed params, use only Enum.GetNames-defined values.","After a Bogus upgrade, re-check any enum member names you template against the new definitions.","Treat a sudden 'Cannot parse arguments' on a previously-working template as a likely enum/member rename."],"tags":["mustache-template","argument-parsing","enum","tokenizer"],"backgroundTag":null,"analyzedSha":"6ece18c5c22648ab4606e45a0aaf2f07fc5259e4","analyzedAt":"2026-08-13T21:08:15.463Z","schemaVersion":2},"datasetVersion":"2026-08-14T05:17:29.042Z"}