C#: When adjusting parameter names matching keywords, also adjust those names in the function comment if any.

Author: adalisk-emikhaylov

src/generators/csharp/generator.cpp

@@ -88,7 +88,7 @@ namespace mrbind::CSharp
         }
     }
 
-    bool AdjustIfMatchesCSharpKeyword(std::string &str)
+    bool AdjustIfMatchesCSharpKeyword(std::string &str, std::string *also_adjust)
     {
         static const std::unordered_set<std::string> csharp_keywords = {
             // Those are from here: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/
@@ -174,7 +174,35 @@ namespace mrbind::CSharp
 
         if (csharp_keywords.contains(str))
         {
-            str += '_';
+            std::string new_str = str + '_';
+
+            if (also_adjust)
+            {
+                auto HandleOccurence = [&](const std::string &prefix, const std::string &suffix)
+                {
+                    *also_adjust = Strings::Replace(*also_adjust, prefix + str + suffix, prefix + new_str + suffix);
+                };
+
+                // Just some quotes.
+                HandleOccurence("`", "`");
+                HandleOccurence("'", "'");
+                HandleOccurence("\"", "\"");
+
+                // Doxygen.
+                for (std::string symbol : {"@", "\\"})
+                {
+                    // Parameter descriptions.
+                    HandleOccurence(symbol + "param ", " ");
+
+                    // Single words in inline code blocks.
+                    // `c` and `p` do the same thing.
+                    HandleOccurence(symbol + "c ", " ");
+                    HandleOccurence(symbol + "p ", " ");
+                }
+            }
+
+            str = std::move(new_str);
+
             return true;
         }
 
@@ -8232,25 +8260,23 @@ namespace mrbind::CSharp
         }
 
         { // Adjust parameter names to not be C# keywords.
-
-
-            static constexpr auto AdjustParam = [](CInterop::FuncParam &param)
+            static constexpr auto AdjustParam = [](CInterop::FuncParam &param, std::string &comment)
             {
                 if (param.name)
                 {
-                    if (AdjustIfMatchesCSharpKeyword(*param.name))
+                    if (AdjustIfMatchesCSharpKeyword(*param.name, &comment))
                         param.name_or_placeholder = *param.name;
                 }
                 else
                 {
-                    AdjustIfMatchesCSharpKeyword(param.name_or_placeholder); // Just in case?
+                    AdjustIfMatchesCSharpKeyword(param.name_or_placeholder, &comment); // Just in case?
                 }
             };
 
             static constexpr auto AdjustFuncLike = [](CInterop::BasicFuncLike &func)
             {
                 for (auto &param : func.params)
-                    AdjustParam(param);
+                    AdjustParam(param, func.comment.c_style);
             };
 
             // Free functions.

src/generators/csharp/generator.h

@@ -101,7 +101,10 @@ namespace mrbind::CSharp
 
     // If `str` matches one of C# keywords, appends `_` to it to avoid collisions.
     // Returns true if the adjustment has been made.
-    bool AdjustIfMatchesCSharpKeyword(std::string &str);
+    // If `also_adjust` is specified and an adjustment was made, we also apply this replacement to occurences of the offending string in `*also_adjust`,
+    //   but only in specific contexts, to avoid confusing it with plain English words. Those contexts include different kinds of quotes,
+    //   `\param ...` doxygen parameter names, etc.
+    bool AdjustIfMatchesCSharpKeyword(std::string &str, std::string *also_adjust = nullptr);
 
     // You can call this on the result of the `...ToCSharpIdentifier()` functions above, to make the first letter of the result lowercase.
     // Also calls `AdjustIfMatchesCSharpKeyword()` to avoid keyword collisions.

test/input/MR/test_csharp.h

@@ -82,6 +82,15 @@ namespace MR::CSharp
     inline const std::string test_constness_str(const std::string, const std::string = "42") {return "43";}
     #pragma clang diagnostic pop
 
+    // Test how we adjust keywords in parameter names.
+    // \param params blah
+    // @param params blah
+    // `params` 'params' "params" params huhparams paramshuh \p params \c params @p params @c params \A params @A params
+    // In this comment, only quoted and `\param ...` uses are adjusted, and not standalone occurences of the word (even if it's a separate word, let alone if it's just a part of a word).
+    // `\c ...` and `\p ...` are handled, but unknown tags like `\A ...` are not.
+    // <param name="params">This is also handled, naturally, because we handle quotes.</param>
+    inline void test_keyword_in_param_name(int params) {(void)params;}
+
 
     /// Enum comment.
     enum class E1

test/output_c/include/MR/test_csharp.h

@@ -867,6 +867,16 @@ MR_C_API int MR_CSharp_test_constness_int(int _1, const int *_2);
 /// Never returns null. Returns an instance allocated on the heap! Must call `MR_C_std_string_Destroy()` to free it when you're done using it.
 MR_C_API MR_C_std_string *MR_CSharp_test_constness_str(const char *_1, const char *_1_end, const char *_2, const char *_2_end);
 
+// Test how we adjust keywords in parameter names.
+// \param params blah
+// @param params blah
+// `params` 'params' "params" params huhparams paramshuh \p params \c params @p params @c params \A params @A params
+// In this comment, only quoted and `\param ...` uses are adjusted, and not standalone occurences of the word (even if it's a separate word, let alone if it's just a part of a word).
+// `\c ...` and `\p ...` are handled, but unknown tags like `\A ...` are not.
+// <param name="params">This is also handled, naturally, because we handle quotes.</param>
+/// Generated from function `MR::CSharp::test_keyword_in_param_name`.
+MR_C_API void MR_CSharp_test_keyword_in_param_name(int params);
+
 /// Generated from function `MR::CSharp::test_enum`.
 /// Parameter `b` has a default argument: `E1::b`, pass a null pointer to use it.
 MR_C_API MR_CSharp_E1 MR_CSharp_test_enum_MR_CSharp_E1(MR_CSharp_E1 a, const MR_CSharp_E1 *b);

test/output_c/source/MR/test_csharp.cpp

@@ -284,6 +284,15 @@ MR_C_std_string *MR_CSharp_test_constness_str(const char *_1, const char *_1_end
     ) // MRBINDC_TRY
 }
 
+void MR_CSharp_test_keyword_in_param_name(int params)
+{
+    MRBINDC_TRY(
+    ::MR::CSharp::test_keyword_in_param_name(
+        params
+    );
+    ) // MRBINDC_TRY
+}
+
 MR_CSharp_E1 MR_CSharp_test_enum_MR_CSharp_E1(MR_CSharp_E1 a, const MR_CSharp_E1 *b)
 {
     MRBINDC_TRY(

test/output_c_fixed_typedefs/include/MR/test_csharp.h

@@ -870,6 +870,16 @@ MR_C_API int32_t MR_CSharp_test_constness_int(int32_t _1, const int32_t *_2);
 // Never returns null. Returns an instance allocated on the heap! Must call `MR_C_std_string_Destroy()` to free it when you're done using it.
 MR_C_API MR_C_std_string *MR_CSharp_test_constness_str(const char *_1, const char *_1_end, const char *_2, const char *_2_end);
 
+// Test how we adjust keywords in parameter names.
+// \param params blah
+// @param params blah
+// `params` 'params' "params" params huhparams paramshuh \p params \c params @p params @c params \A params @A params
+// In this comment, only quoted and `\param ...` uses are adjusted, and not standalone occurences of the word (even if it's a separate word, let alone if it's just a part of a word).
+// `\c ...` and `\p ...` are handled, but unknown tags like `\A ...` are not.
+// <param name="params">This is also handled, naturally, because we handle quotes.</param>
+// Generated from function `MR::CSharp::test_keyword_in_param_name`.
+MR_C_API void MR_CSharp_test_keyword_in_param_name(int32_t params);
+
 // Generated from function `MR::CSharp::test_enum`.
 // Parameter `b` has a default argument: `E1::b`, pass a null pointer to use it.
 MR_C_API MR_CSharp_E1 MR_CSharp_test_enum_MR_CSharp_E1(MR_CSharp_E1 a, const MR_CSharp_E1 *b);

test/output_c_fixed_typedefs/source/MR/test_csharp.cpp

@@ -242,6 +242,13 @@ MR_C_std_string *MR_CSharp_test_constness_str(const char *_1, const char *_1_end
     ));
 }
 
+void MR_CSharp_test_keyword_in_param_name(int32_t params)
+{
+    ::MR::CSharp::test_keyword_in_param_name(
+        params
+    );
+}
+
 MR_CSharp_E1 MR_CSharp_test_enum_MR_CSharp_E1(MR_CSharp_E1 a, const MR_CSharp_E1 *b)
 {
     using namespace MR;

test/output_c_fixed_typedefs_64_only/include/MR/test_csharp.h

@@ -867,6 +867,16 @@ MR_C_API int MR_CSharp_test_constness_int(int _1, const int *_2);
 /// Never returns null. Returns an instance allocated on the heap! Must call `MR_C_std_string_Destroy()` to free it when you're done using it.
 MR_C_API MR_C_std_string *MR_CSharp_test_constness_str(const char *_1, const char *_1_end, const char *_2, const char *_2_end);
 
+// Test how we adjust keywords in parameter names.
+// \param params blah
+// @param params blah
+// `params` 'params' "params" params huhparams paramshuh \p params \c params @p params @c params \A params @A params
+// In this comment, only quoted and `\param ...` uses are adjusted, and not standalone occurences of the word (even if it's a separate word, let alone if it's just a part of a word).
+// `\c ...` and `\p ...` are handled, but unknown tags like `\A ...` are not.
+// <param name="params">This is also handled, naturally, because we handle quotes.</param>
+/// Generated from function `MR::CSharp::test_keyword_in_param_name`.
+MR_C_API void MR_CSharp_test_keyword_in_param_name(int params);
+
 /// Generated from function `MR::CSharp::test_enum`.
 /// Parameter `b` has a default argument: `E1::b`, pass a null pointer to use it.
 MR_C_API MR_CSharp_E1 MR_CSharp_test_enum_MR_CSharp_E1(MR_CSharp_E1 a, const MR_CSharp_E1 *b);

test/output_c_fixed_typedefs_64_only/source/MR/test_csharp.cpp

@@ -240,6 +240,13 @@ MR_C_std_string *MR_CSharp_test_constness_str(const char *_1, const char *_1_end
     ));
 }
 
+void MR_CSharp_test_keyword_in_param_name(int params)
+{
+    ::MR::CSharp::test_keyword_in_param_name(
+        params
+    );
+}
+
 MR_CSharp_E1 MR_CSharp_test_enum_MR_CSharp_E1(MR_CSharp_E1 a, const MR_CSharp_E1 *b)
 {
     using namespace MR;

test/output_csharp/src/MR/test_csharp.cs

@@ -24207,6 +24207,23 @@ public static unsafe MR.CS.Std.String TestConstnessStr(string _1, string? _2 = n
                 }
             }
 
+            // Test how we adjust keywords in parameter names.
+            // \param params_ blah
+            // @param params_ blah
+            // `params_` 'params_' "params_" params huhparams paramshuh \p params_ \c params_ @p params_ @c params_ \A params @A params
+            // In this comment, only quoted and `\param ...` uses are adjusted, and not standalone occurences of the word (even if it's a separate word, let alone if it's just a part of a word).
+            // `\c ...` and `\p ...` are handled, but unknown tags like `\A ...` are not.
+            // <param name="params_">This is also handled, naturally, because we handle quotes.</param>
+            /// Generated from function `MR::CSharp::test_keyword_in_param_name`.
+            public static void TestKeywordInParamName(int params_)
+            {
+                [System.Runtime.InteropServices.DllImport("bleh", EntryPoint = "MR_CSharp_test_keyword_in_param_name", ExactSpelling = true)]
+                extern static void __MR_CSharp_test_keyword_in_param_name(int params_);
+                MR.CS.Misc._Exceptions.Prepare();
+                MR.CS.Misc._Exceptions.ThrowIfNeeded();
+                __MR_CSharp_test_keyword_in_param_name(params_);
+            }
+
             /// Generated from function `MR::CSharp::test_enum`.
             /// Parameter `b` defaults to `E1::b`.
             public static unsafe MR.CS.CSharp.E1 TestEnum(MR.CS.CSharp.E1 a, MR.CS.CSharp.E1? b = null)