[Mono] Add mono hot reload support for updating parameter name

src/mono/mono/component/hot_reload.c

@@ -1600,29 +1600,7 @@ apply_enclog_pass1 (MonoImage *image_base, MonoImage *image_dmeta, DeltaInfo *de
 		}
 		case MONO_TABLE_PARAM: {
 			*should_invalidate_transformed_code = true;
-			if (!is_addition) {
-				/* We only allow modifications where the parameter name doesn't change. */
-				uint32_t base_param [MONO_PARAM_SIZE];
-				uint32_t upd_param [MONO_PARAM_SIZE];
-				int mapped_token = hot_reload_relative_delta_index (image_dmeta, delta_info, mono_metadata_make_token (token_table, token_index));
-				g_assert (mapped_token != -1);
-				mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "row[0x%02x]:0x%08x PARAM update.  mapped index = 0x%08x\n", i, log_token, mapped_token);
-
-				mono_metadata_decode_row (&image_dmeta->tables [MONO_TABLE_PARAM], mapped_token - 1, upd_param, MONO_PARAM_SIZE);
-				mono_metadata_decode_row (&image_base->tables [MONO_TABLE_PARAM], token_index - 1, base_param, MONO_PARAM_SIZE);
-
-				const char *base_name = mono_metadata_string_heap (image_base, base_param [MONO_PARAM_NAME]);
-				const char *upd_name = mono_metadata_string_heap (image_base, upd_param [MONO_PARAM_NAME]);
-				mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_METADATA_UPDATE, "row[0x%02x: 0x%08x PARAM update: seq = %d (base = %d), name = '%s' (base = '%s')\n", i, log_token, upd_param [MONO_PARAM_SEQUENCE], base_param [MONO_PARAM_SEQUENCE], upd_name, base_name);
-				if (strcmp (base_name, upd_name) != 0 || base_param [MONO_PARAM_SEQUENCE] != upd_param [MONO_PARAM_SEQUENCE]) {
-					mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_METADATA_UPDATE, "row[0x%02x]:0x%08x we do not support patching of existing PARAM table cols.", i, log_token);
-					mono_error_set_type_load_name (error, NULL, image_base->name, "EnC: we do not support patching of existing PARAM table cols. token=0x%08x", log_token);
-					unsupported_edits = TRUE;
-					continue;
-				}
-				break;
-			} else
-				break; /* added a row. ok */
+			break;
 		}
 		case MONO_TABLE_TYPEDEF: {
 			*should_invalidate_transformed_code = true;
@@ -3493,7 +3471,7 @@ hot_reload_get_method_params (MonoImage *base_image, uint32_t methoddef_token, u
 static const char *
 hot_reload_get_capabilities (void)
 {
-	return "Baseline AddMethodToExistingType AddStaticFieldToExistingType NewTypeDefinition ChangeCustomAttributes AddInstanceFieldToExistingType GenericAddMethodToExistingType GenericUpdateMethod";
+	return "Baseline AddMethodToExistingType AddStaticFieldToExistingType NewTypeDefinition ChangeCustomAttributes AddInstanceFieldToExistingType GenericAddMethodToExistingType GenericUpdateMethod UpdateParameters";
 }
 
 static GENERATE_GET_CLASS_WITH_CACHE_DECL (hot_reload_instance_field_table);

src/mono/mono/metadata/metadata.c

@@ -5107,8 +5107,12 @@ mono_metadata_custom_attrs_from_index (MonoImage *meta, guint32 index)
 		return 0;
 
 	if (G_UNLIKELY (meta->has_updates)) {
-		if (!found && !mono_metadata_update_metadata_linear_search (meta, tdef, &loc, table_locator))
+		if (mono_metadata_table_num_rows (meta, MONO_TABLE_CUSTOMATTRIBUTE) > table_info_get_rows (tdef) || mono_metadata_update_has_modified_rows (tdef)) {
+			if (!found && !mono_metadata_update_metadata_linear_search (meta, tdef, &loc, table_locator))
+				return 0;
+		} else {
 			return 0;
+		}
 	}
 
 	/* Find the first entry by searching backwards */

src/mono/mono/metadata/reflection-cache.h

@@ -12,6 +12,7 @@
 #include <mono/metadata/mono-hash.h>
 #include <mono/metadata/mempool.h>
 #include <mono/utils/mono-error-internals.h>
+#include <mono/metadata/metadata-update.h>
 
 /*
  * We need to return always the same object for MethodInfo, FieldInfo etc..
@@ -22,6 +23,7 @@
 typedef struct {
 	gpointer item;
 	MonoClass *refclass;
+	uint32_t generation; /* 0 is normal; hot reload may change it */
 } ReflectedEntry;
 
 gboolean
@@ -59,6 +61,7 @@ cache_object (MonoMemoryManager *mem_manager, MonoClass *klass, gpointer item, M
 		ReflectedEntry *e = alloc_reflected_entry (mem_manager);
 		e->item = item;
 		e->refclass = klass;
+		e->generation = mono_metadata_update_get_thread_generation();
 		mono_conc_g_hash_table_insert (mem_manager->refobject_hash, e, o);
 		obj = o;
 	}
@@ -83,6 +86,7 @@ cache_object_handle (MonoMemoryManager *mem_manager, MonoClass *klass, gpointer
 			ReflectedEntry *e = alloc_reflected_entry (mem_manager);
 			e->item = item;
 			e->refclass = klass;
+			e->generation = mono_metadata_update_get_thread_generation();
 			mono_conc_g_hash_table_insert (mem_manager->refobject_hash, e, MONO_HANDLE_RAW (o));
 			MONO_HANDLE_ASSIGN (obj, o);
 		}
@@ -92,6 +96,7 @@ cache_object_handle (MonoMemoryManager *mem_manager, MonoClass *klass, gpointer
 			ReflectedEntry *e = alloc_reflected_entry (mem_manager);
 			e->item = item;
 			e->refclass = klass;
+			e->generation = mono_metadata_update_get_thread_generation();
 			mono_weak_hash_table_insert (mem_manager->weak_refobject_hash, e, MONO_HANDLE_RAW (o));
 			MONO_HANDLE_ASSIGN (obj, o);
 		}
@@ -107,6 +112,7 @@ static inline MonoObjectHandle
 check_object_handle (MonoMemoryManager *mem_manager, MonoClass *klass, gpointer item)
 {
 	MonoObjectHandle obj_handle;
+	gpointer orig_e, orig_value;
 	ReflectedEntry e;
 	e.item = item;
 	e.refclass = klass;
@@ -123,6 +129,24 @@ check_object_handle (MonoMemoryManager *mem_manager, MonoClass *klass, gpointer
 		MonoWeakHashTable *hash = mem_manager->weak_refobject_hash;
 		obj_handle = MONO_HANDLE_NEW (MonoObject, (MonoObject *)mono_weak_hash_table_lookup (hash, &e));
 	}
+
+	if (!mem_manager->collectible) {
+		MonoConcGHashTable *hash = mem_manager->refobject_hash;
+		if (mono_conc_g_hash_table_lookup_extended (hash, &e, &orig_e, &orig_value))
+			if (((ReflectedEntry *)orig_e)->generation < mono_metadata_update_get_thread_generation()) {
+				mono_conc_g_hash_table_remove (hash, &e);
+				free_reflected_entry ((ReflectedEntry *)orig_e);
+				obj_handle = MONO_HANDLE_NEW (MonoObject, NULL);
+			} else {
+				obj_handle = MONO_HANDLE_NEW (MonoObject, (MonoObject *)orig_value);
+			}
+		else {
+			obj_handle = MONO_HANDLE_NEW (MonoObject, NULL);
+		}
+	} else {
+		MonoWeakHashTable *hash = mem_manager->weak_refobject_hash;
+		obj_handle = MONO_HANDLE_NEW (MonoObject, (MonoObject *)mono_weak_hash_table_lookup (hash, &e));
+	}
 	mono_mem_manager_unlock (mem_manager);
 
 	return obj_handle;

src/mono/wasm/debugger/DebuggerTestSuite/HotReloadTests.cs

@@ -599,5 +599,43 @@ await SendCommandAndCheck (JObject.FromObject(new { }), "Debugger.resume", scrip
                                                    }, "c", num_fields: 2);
                                        });
         }
+
+        // Enable this test when https://github.com/dotnet/hotreload-utils/pull/264 flows into dotnet/runtime repo
+        // [ConditionalFact(nameof(RunningOnChrome))]
+        // public async Task DebugHotReloadMethod_ChangeParameterName()
+        // {
+        //     string asm_file = Path.Combine(DebuggerTestAppPath, "ApplyUpdateReferencedAssembly.dll");
+        //     string pdb_file = Path.Combine(DebuggerTestAppPath, "ApplyUpdateReferencedAssembly.pdb");
+        //     string asm_file_hot_reload = Path.Combine(DebuggerTestAppPath, "../wasm/ApplyUpdateReferencedAssembly.dll");
+
+        //     var bp_notchanged = await SetBreakpoint(".*/MethodBody1.cs$", 89, 12, use_regex: true);
+        //     // var bp_invalid = await SetBreakpoint(".*/MethodBody1.cs$", 59, 12, use_regex: true);
+
+        //     var pause_location = await LoadAssemblyAndTestHotReloadUsingSDBWithoutChanges(
+        //             asm_file, pdb_file, "MethodBody9", "test", expectBpResolvedEvent: true, sourcesToWait: new string [] { "MethodBody0.cs", "MethodBody1.cs" });
+
+        //     CheckLocation("dotnet://ApplyUpdateReferencedAssembly.dll/MethodBody1.cs", 89, 12, scripts, pause_location["callFrames"]?[0]["location"]);
+        //     await StepAndCheck(StepKind.Over, "dotnet://ApplyUpdateReferencedAssembly.dll/MethodBody1.cs", 90, 12, "ApplyUpdateReferencedAssembly.MethodBody9.M1",
+        //     locals_fn: async (locals) =>
+        //         {
+        //             CheckNumber(locals, "a", 1);
+        //             await Task.CompletedTask;
+        //         }
+        //     );
+        //     //apply first update
+        //     pause_location = await LoadAssemblyAndTestHotReloadUsingSDB(
+        //             asm_file_hot_reload, "MethodBody9", "test", 1);
+
+        //     JToken top_frame = pause_location["callFrames"]?[0];
+        //     AssertEqual("ApplyUpdateReferencedAssembly.MethodBody9.M1", top_frame?["functionName"]?.Value<string>(), top_frame?.ToString());
+        //     CheckLocation("dotnet://ApplyUpdateReferencedAssembly.dll/MethodBody1.cs", 89, 12, scripts, top_frame["location"]);
+        //     await StepAndCheck(StepKind.Over, "dotnet://ApplyUpdateReferencedAssembly.dll/MethodBody1.cs", 90, 12, "ApplyUpdateReferencedAssembly.MethodBody9.M1",
+        //     locals_fn: async (locals) =>
+        //         {
+        //             CheckNumber(locals, "x", 1);
+        //             await Task.CompletedTask;
+        //         }
+        //     );
+        // }
     }
 }

src/mono/wasm/debugger/tests/ApplyUpdateReferencedAssembly/MethodBody1.cs

@@ -57,4 +57,41 @@ public static void StaticMethod1 () {
             Console.WriteLine("original");
         }
     }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    // public class MethodBody9 {
+    //     public static int M1(int a, int b) {
+    //         return a + b;
+    //     }
+
+    //     public static int test() {
+    //         return M1(1, 2);
+    //     }
+    // }
 }

src/mono/wasm/debugger/tests/ApplyUpdateReferencedAssembly/MethodBody1_v1.cs

@@ -84,4 +84,14 @@ public void InstanceMethod () {
             Console.WriteLine($"add a breakpoint the instance method of the new class");
         }
     }
+
+    // public class MethodBody9 {
+    //     public static int M1(int x, int y) {
+    //         return x + y;
+    //     }
+
+    //     public static int test() {
+    //         return M1(1, 2);
+    //     }
+    // }
 }