From d78ae54255ac36905d077ff64e93f6742c580d51 Mon Sep 17 00:00:00 2001
From: Marek Habersack <grendel@twistedcode.net>
Date: Tue, 27 Jun 2023 11:37:15 +0200
Subject: [PATCH] [marshal methods] Add support for wrapping the `char` type

`System.Char` is an unblittable type and, as such, it has to be treated
specially by the marshal methods wrapper generator to properly cast it
to/from a matching blittable type.  In this case the latter is `ushort`,
since both on the Java and Managed side, `char` is a 16-bit entity.
---
 .../MarshalMethodsAssemblyRewriter.cs         | 39 ++++++++++++++++---
 1 file changed, 34 insertions(+), 5 deletions(-)

diff --git a/src/Xamarin.Android.Build.Tasks/Utilities/MarshalMethodsAssemblyRewriter.cs b/src/Xamarin.Android.Build.Tasks/Utilities/MarshalMethodsAssemblyRewriter.cs
index acd69f2d7ea..0c08312b436 100644
--- a/src/Xamarin.Android.Build.Tasks/Utilities/MarshalMethodsAssemblyRewriter.cs
+++ b/src/Xamarin.Android.Build.Tasks/Utilities/MarshalMethodsAssemblyRewriter.cs
@@ -195,7 +195,7 @@ MethodDefinition GenerateWrapper (MarshalMethodEntry method, Dictionary<Assembly
 			MethodDefinition callback = method.NativeCallback;
 			AssemblyImports imports = assemblyImports [callback.Module.Assembly];
 			string wrapperName = $"{callback.Name}_mm_wrapper";
-			TypeReference retType = MapToBlittableTypeIfNecessary (callback.ReturnType, out bool returnTypeMapped);
+			TypeReference retType = MapToBlittableTypeIfNecessary (callback, callback.ReturnType, out bool returnTypeMapped);
 			bool hasReturnValue = String.Compare ("System.Void", callback.ReturnType.FullName, StringComparison.Ordinal) != 0;
 			var wrapperMethod = new MethodDefinition (wrapperName, callback.Attributes, retType);
 
@@ -222,7 +222,7 @@ MethodDefinition GenerateWrapper (MarshalMethodEntry method, Dictionary<Assembly
 			Instruction? inst = null;
 			uint nparam = 0;
 			foreach (ParameterDefinition pdef in callback.Parameters) {
-				TypeReference newType = MapToBlittableTypeIfNecessary (pdef.ParameterType, out _);
+				TypeReference newType = MapToBlittableTypeIfNecessary (callback, pdef.ParameterType, out _);
 				wrapperMethod.Parameters.Add (new ParameterDefinition (pdef.Name, pdef.Attributes, newType));
 
 				inst = GetLoadArgInstruction (nparam++, pdef);
@@ -313,6 +313,11 @@ void GenerateNonBlittableConversion (TypeReference sourceType, TypeReference tar
 					return;
 				}
 
+				if (IsCharConversion (sourceType, targetType)) {
+					// There isn't any special code we need to generate.
+					return;
+				}
+
 				ThrowUnsupportedType (sourceType);
 			}
 
@@ -330,6 +335,11 @@ void GenerateRetValCast (TypeReference sourceType, TypeReference targetType)
 					return;
 				}
 
+				if (IsCharConversion (sourceType, targetType)) {
+					// There isn't any special code we need to generate.
+					return;
+				}
+
 				ThrowUnsupportedType (sourceType);
 			}
 
@@ -346,9 +356,22 @@ bool IsBooleanConversion (TypeReference sourceType, TypeReference targetType)
 				return false;
 			}
 
+			bool IsCharConversion (TypeReference sourceType, TypeReference targetType)
+			{
+				if (String.Compare ("System.Char", sourceType.FullName, StringComparison.Ordinal) == 0) {
+					if (String.Compare ("System.UInt16", targetType.FullName, StringComparison.Ordinal) != 0) {
+						throw new InvalidOperationException ($"Unexpected conversion from '{sourceType.FullName}' to '{targetType.FullName}'");
+					}
+
+					return true;
+				}
+
+				return false;
+			}
+
 			void ThrowUnsupportedType (TypeReference type)
 			{
-				throw new InvalidOperationException ($"Unsupported non-blittable type '{type.FullName}'");
+				throw new InvalidOperationException ($"Unsupported non-blittable type '{type.FullName}' in method '{callback.FullName}'");
 			}
 		}
 
@@ -437,7 +460,7 @@ Instruction GetLoadArgInstruction (uint nparam, ParameterDefinition pdef)
 			return Instruction.Create (ldargOp, pdef);
 		}
 
-		TypeReference MapToBlittableTypeIfNecessary (TypeReference type, out bool typeMapped)
+		TypeReference MapToBlittableTypeIfNecessary (MethodDefinition method, TypeReference type, out bool typeMapped)
 		{
 			if (type.IsBlittable () || String.Compare ("System.Void", type.FullName, StringComparison.Ordinal) == 0) {
 				typeMapped = false;
@@ -450,7 +473,13 @@ TypeReference MapToBlittableTypeIfNecessary (TypeReference type, out bool typeMa
 				return ReturnValid (typeof(byte));
 			}
 
-			throw new NotSupportedException ($"Cannot map unsupported blittable type '{type.FullName}'");
+			if (String.Compare ("System.Char", type.FullName, StringComparison.Ordinal) == 0) {
+				// `char` is 16-bytes both in Java and in .NET
+				typeMapped = true;
+				return ReturnValid (typeof(ushort));
+			}
+
+			throw new NotSupportedException ($"Cannot map unsupported blittable type '{type.FullName}' in method '{method.FullName}'");
 
 			TypeReference ReturnValid (Type typeToLookUp)
 			{