fix: RPC ILPP generating invalid IL code when using this instead of this ref for the FastBufferReader/FastBufferWriter parameter of an extension method. (#1393)

* fix: RPC ILPP generating invalid IL code when using `this` instead of `this ref` for the FastBufferReader/FastBufferWriter parameter of an extension method.

Also updated the test so both `this` and `this ref` are exercised - the documentation says to use `this`, but `this ref` was what worked... so for backward compatibility both have to be supported.

* Changelog

* standards fix

Author: ShadauxCat

com.unity.netcode.gameobjects/CHANGELOG.md

@@ -13,6 +13,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
 ### Fixed
 
 - Fixed in-scene NetworkObjects that are moved into the DDOL scene not getting restored to their original active state (enabled/disabled) after a full scene transition (#1354)
+- Fixed invalid IL code being generated when using `this` instead of `this ref` for the FastBufferReader/FastBufferWriter parameter of an extension method. (#1393)
 - Fixed an issue where if you are running as a server (not host) the LoadEventCompleted and UnloadEventCompleted events would fire early by the NetworkSceneManager (#1379)
 
 ### Changed

com.unity.netcode.gameobjects/Editor/CodeGen/NetworkBehaviourILPP.cs

@@ -575,21 +575,28 @@ private MethodReference GetFastBufferWriterWriteMethod(string name, TypeReferenc
                     {
                         if (method.GenericParameters[0].HasConstraints)
                         {
+                            var meetsConstraints = true;
                             foreach (var constraint in method.GenericParameters[0].Constraints)
                             {
                                 var resolvedConstraint = constraint.Resolve();
 
                                 if (
                                     (resolvedConstraint.IsInterface &&
-                                     checkType.HasInterface(resolvedConstraint.FullName))
+                                     !checkType.HasInterface(resolvedConstraint.FullName))
                                     || (resolvedConstraint.IsClass &&
-                                        checkType.Resolve().IsSubclassOf(resolvedConstraint.FullName)))
+                                        !checkType.Resolve().IsSubclassOf(resolvedConstraint.FullName))
+                                    || (resolvedConstraint.Name == "ValueType" && !checkType.IsValueType))
                                 {
-                                    var instanceMethod = new GenericInstanceMethod(method);
-                                    instanceMethod.GenericArguments.Add(checkType);
-                                    return instanceMethod;
+                                    meetsConstraints = false;
+                                    break;
                                 }
                             }
+                            if (meetsConstraints)
+                            {
+                                var instanceMethod = new GenericInstanceMethod(method);
+                                instanceMethod.GenericArguments.Add(checkType);
+                                return instanceMethod;
+                            }
                         }
                     }
                 }
@@ -970,17 +977,23 @@ private void InjectWriteAndCallBlocks(MethodDefinition methodDefinition, CustomA
                         // writer.WriteValueSafe(param) for value types, OR
                         // writer.WriteValueSafe(param, -1, 0) for arrays of value types, OR
                         // writer.WriteValueSafe(param, false) for strings
-                        instructions.Add(processor.Create(OpCodes.Ldloca, serializerLocIdx));
                         var method = methodRef.Resolve();
                         var checkParameter = method.Parameters[0];
                         var isExtensionMethod = false;
-                        if (checkParameter.ParameterType.Resolve() ==
-                            m_FastBufferWriter_TypeRef.MakeByReferenceType().Resolve())
+                        if (methodRef.Resolve().DeclaringType != m_FastBufferWriter_TypeRef.Resolve())
                         {
                             isExtensionMethod = true;
                             checkParameter = method.Parameters[1];
                         }
-                        if (checkParameter.IsIn)
+                        if (!isExtensionMethod || method.Parameters[0].ParameterType.IsByReference)
+                        {
+                            instructions.Add(processor.Create(OpCodes.Ldloca, serializerLocIdx));
+                        }
+                        else
+                        {
+                            instructions.Add(processor.Create(OpCodes.Ldloc, serializerLocIdx));
+                        }
+                        if (checkParameter.IsIn || checkParameter.IsOut || checkParameter.ParameterType.IsByReference)
                         {
                             instructions.Add(processor.Create(OpCodes.Ldarga, paramIndex + 1));
                         }
@@ -1291,7 +1304,18 @@ private MethodDefinition GenerateStaticHandler(MethodDefinition methodDefinition
                 if (foundMethodRef)
                 {
                     // reader.ReadValueSafe(out localVar);
-                    processor.Emit(OpCodes.Ldarga, 1);
+
+                    var checkParameter = methodRef.Resolve().Parameters[0];
+
+                    var isExtensionMethod = methodRef.Resolve().DeclaringType != m_FastBufferReader_TypeRef.Resolve();
+                    if (!isExtensionMethod || checkParameter.ParameterType.IsByReference)
+                    {
+                        processor.Emit(OpCodes.Ldarga, 1);
+                    }
+                    else
+                    {
+                        processor.Emit(OpCodes.Ldarg, 1);
+                    }
                     processor.Emit(OpCodes.Ldloca, localIndex);
                     if (paramType == typeSystem.String)
                     {