[jcw-gen, jnimarshalmethod-gen] Native method consistency (#1160)

Context: #1153
Context: 4787e01
Context: 77800dd

PR #1153 is exploring the use of [.NET Native AOT][0] to produce a
native library which is used *within* a `java`-originated process:

	% java -cp … com/microsoft/hello_from_jni/App
	# launches NativeAOT-generated native lib, executes C# code…

As NativeAOT has no support for `System.Reflection.Emit`, the only
way for Java code to invoke managed code -- in a Desktop Java.Base
environment! [^0] see 4787e01 -- would be to pre-generate the
required marshal methods via `jnimarshalmethod-gen`.

This in turn requires updating `jcw-gen` to support the pre-existing
`Java.Interop.JavaCallableAttribute`, so that C# code could
reasonably declare methods visible to Java, along with the
introduction of, and support for, a new
`Java.Interop.JavaCallableConstructorAttribute` type.  This allows
straightforward usage:

	[JniTypeSignature ("example/ManagedType")]      // for a nice Java name!
	class ManagedType : Java.Lang.Object {

	    int value;

	    [JavaCallableConstructor(SuperConstructorExpression="")]
	    public ManagedType (int value) {
	        this.value = value;
	    }

	    [JavaCallable ("getString")]
	    public Java.Lang.String GetString () {
	        return new Java.Lang.String ($"Hello from C#, via Java.Interop! Value={value}");
	    }
	}

Run this through `jcw-gen` and `jnimarshalmethod-gen`, run the app,
and nothing worked (?!), because not all pieces were in agreement.

Java `native` method registration is One Of Those Things™ that
involves lots of moving pieces:

  * `generator` emits bindings for Java types, which includes Java
    method names, signatures, and (on .NET Android) the "connector
    method" to use:

        [Register ("toString", "()Ljava/lang/String;", "GetToStringHandler")]   // .NET Android
        [JniMethodSignature ("toString", "()Ljava/lang/String;")]               // Java.Base
        public override unsafe string? ToString () {…}

  * `jcw-gen` uses `generator` output, *prefixing* Java method names
    with `n_` for `native` method declarations, along with a
    method wrapper [^1]

        public String toString() {return n_toString();}
        private native String n_toString();

  * `jnimarshalmethod-gen` emits marshal methods for Java.Base,
    and needs to register the `native` methods declared by `jcw-gen`.
    `jnimarshalmethod-gen` and `jcw-gen` need to be consistent with
    each other.

  * `MarshalMemberbuilder.CreateMarshalToManagedMethodRegistration()`
    creates a `JniNativeMethodRegistration` instance which contains
    the name of the Java `native` method to register, and was
    using a name inconsistent with `jcw-gen`.

Turns Out, `jcw-gen`, `jnimarshalmethod-gen`, and
`MarshalMemberBuilder` were *not* consistent.

The only "real" `jnimarshalmethod-gen` usage (77800dd) is with the
`Java.Interop.Export-Tests` unit test assembly, which *did not use*
`jcw-gen`; it contained only hand-written Java code.  Consequently,
*none* of the Java `native` methods declared within it had an `n_`
prefix, and since this worked with `jnimarshalmethod-gen`, this means
that `jnimarshalmethod-gen` registration logic likewise didn't use
`n_` prefixed method names.

The result is that in the NativeAOT app, it would attempt to register
the `native` Java method `ManagedType.getString()`, while what
`jcw-gen` declared was `ManagedType.n_getString()`!

Java promptly threw an exception, and the app crashed.

Update `Java.Interop.Export-Tests` so that all the methods used with
`MarshalMemberBuilder` are declared with `n_` prefixes, and add
a `Java.Lang.Object` subclass example to the unit tests:

Update `tests/Java.Interop.Tools.JavaCallableWrappers-Tests` to
add a test for `.CodeGenerationTarget==JavaInterop1`.

Add `$(NoWarn)` to
`Java.Interop.Tools.JavaCallableWrappers-Tests.csproj` in order to
"work around" warnings-as-errors:

	…/src/Java.Interop.NamingCustomAttributes/Java.Interop/ExportFieldAttribute.cs(19,63): error CA1019: Remove the property setter from Name or reduce its accessibility because it corresponds to positional argument name
	…/src/Java.Interop.NamingCustomAttributes/Android.Runtime/RegisterAttribute.cs(53,4): error CA1019: Remove the property setter from Name or reduce its accessibility because it corresponds to positional argument name
	…/src/Java.Interop.NamingCustomAttributes/Java.Interop/ExportFieldAttribute.cs(12,16): error CA1813: Avoid unsealed attributes
	…

These are "weird"; the warnings/errors appear to come in because
`Java.Interop.Tools.JavaCallableWrappers-Tests.csproj` now includes:

	<Compile Include="..\..\src\Java.Interop\Java.Interop\JniTypeSignatureAttribute.cs" />

which appears to pull in `src/Java.Interop/.editorconfig`, which makes
CA1019 and CA1813 errors.  (I do not understand what is happening.)

Update `jnimarshalmethod-gen` so that the Java `native` methods it
registers have an `n_` prefix.

Refactor `ExpressionAssemblyBuilder.CreateRegistrationMethod()` to
`ExpressionAssemblyBuilder.AddRegistrationMethod()`, so that
the `EmitConsoleWriteLine()` invocation can provide the *full*
type name of the `__RegisterNativeMembers()` method, which helps
when there is more than one such method running around…

Update `ExpressionAssemblyBuilder` so that the delegate types it
creates for marshal method registration all have
`[UnmanagedFunctionPointer(CallingConvention.Winapi)]`.  (This isn't
needed *here*, but is needed in the context of NativeAOT, as
NativeAOT will only emit "marshal stubs" for delegate types which
have `[UnmanagedFunctionPointer]`.)  Unfortunately, adding
`[UnmanagedFunctionPointer]` broke things:

	error JM4006: jnimarshalmethod-gen: Unable to process assembly '…/Hello-NativeAOTFromJNI.dll'
	Failed to resolve System.Runtime.InteropServices.CallingConvention
	Mono.Cecil.ResolutionException: Failed to resolve System.Runtime.InteropServices.CallingConvention
	   at Mono.Cecil.Mixin.CheckedResolve(TypeReference self)
	   at Mono.Cecil.SignatureWriter.WriteCustomAttributeEnumValue(TypeReference enum_type, Object value)
	   …

The problem is that `CallingConvention` was resolved from
`System.Private.CoreLib`, and when we removed that assembly
reference, the `CallingConvention` couldn't be resolved at all.

We could "fix" this by explicitly adding a reference to
`System.Runtime.InteropServices.dll`, but how many more such corner
cases exist?  The current approach is not viable.

Remove the code from 77800dd which attempts to remove
`System.Private.CoreLib`.  So long as `ExpressionAssemblyBuilder`
output is *only* used in "completed" apps (not distributed in NuGet
packages or some "intermediate" form), referencing
`System.Private.CoreLib` is "fine".

Update `jnimarshalmethod-gen` assembly location probing: in #1153, it
was attempting to resolve the *full assembly name* of `Java.Base`, as
`Java.Base, Version=7.0.0.0, Culture=neutral, PublicKeyToken=null`,
causing it to attempt to load the file
`Java.Base, Version=7.0.0.0, Culture=neutral, PublicKeyToken=null.dll`,
which doesn't exist.  Use `AssemblyName` to parse the string and
extract out the assembly name, so that `Java.Base.dll` is probed for
and found.

Update `JreTypeManager` to *also* register the marshal methods
generated by
`Runtime.MarshalMemberBuilder.GetExportedMemberRegistrations()`.

With all that, the updated `Java.Interop.Export-Tests` test now work
both before and after `jnimarshalmethod-gen` is run:

	% dotnet test --logger "console;verbosity=detailed" bin/TestDebug-net7.0/Java.Interop.Export-Tests.dll &&
	  dotnet bin/Debug-net7.0/jnimarshalmethod-gen.dll  bin/TestDebug-net7.0/Java.Interop.Export-Tests.dll &&
	  dotnet test --logger "console;verbosity=detailed" bin/TestDebug-net7.0/Java.Interop.Export-Tests.dll
	…

TODO:

  * `generator --codegen-target=JavaInterop1` should emit
    JNI method signature information for constructors!
    This would likely remove the need for
    `[JavaCallableConstructor(SuperConstructorExpression="")`.

  * #1159

[0]: https://learn.microsoft.com/dotnet/core/deploying/native-aot

[^0]: In a .NET Android environment, marshal methods are part of
      `generator` output, so things would be more straightforward
      there, though all the `_JniMarshal_*` types that are declared
      would also need to have
      `[UnmanagedFunctionPointer(CallingConvention.Winapi)]`…

[^1]: Why not just declare `toString()` as `native`?  Why have the
      separate `n_`-prefixed version?  To make the
      `#if MONODROID_TIMING` block more consistent within
      `JavaCallableWrapperGenerator.GenerateMethod()`.
      It's likely "too late" to *easily* change this now.

Author: jonpryor

src/Java.Interop.Export/Java.Interop/JavaCallableAttribute.cs

@@ -1,3 +1,4 @@
+#nullable enable
 using System;
 
 namespace Java.Interop {

src/Java.Interop.Export/Java.Interop/JavaCallableConstructorAttribute.cs

@@ -0,0 +1,16 @@
+#nullable enable
+using System;
+
+namespace Java.Interop {
+
+	[AttributeUsage (AttributeTargets.Constructor, AllowMultiple=false)]
+	public sealed class JavaCallableConstructorAttribute : Attribute {
+
+		public JavaCallableConstructorAttribute ()
+		{
+		}
+
+		public  string?     SuperConstructorExpression  {get; set;}
+		public  string?     Signature                   {get; set;}
+	}
+}

src/Java.Interop.Export/Java.Interop/MarshalMemberBuilder.cs

@@ -68,7 +68,7 @@ public JniNativeMethodRegistration CreateMarshalToManagedMethodRegistration (Jav
 
 		string GetJniMethodName (JavaCallableAttribute export, MethodInfo method)
 		{
-			return export.Name ?? "n_" + method.Name;
+			return "n_" + method.Name;
 		}
 
 		public string GetJniMethodSignature (JavaCallableAttribute export, MethodInfo method)

src/Java.Interop.Tools.Expressions/Java.Interop.Tools.Expressions/ExpressionAssemblyBuilder.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq.Expressions;
+using System.Runtime.InteropServices;
 using System.Text;
 
 using Java.Interop;
@@ -58,7 +59,7 @@ static MethodDefinition CreateMethodDefinition (AssemblyDefinition declaringAsse
 		return mmDef;
 	}
 
-	public MethodDefinition CreateRegistrationMethod (IList<ExpressionMethodRegistration> methods)
+	public void AddRegistrationMethod (TypeDefinition declaringType, IList<ExpressionMethodRegistration> methods)
 	{
 		var registrations = new MethodDefinition (
 			name:       "__RegisterNativeMembers",
@@ -70,6 +71,8 @@ public MethodDefinition CreateRegistrationMethod (IList<ExpressionMethodRegistra
 			},
 		};
 
+		declaringType.Methods.Add (registrations);
+
 		var ctor    = typeof (JniAddNativeMethodRegistrationAttribute).GetConstructor (Type.EmptyTypes);
 		var attr    = new CustomAttribute (DeclaringAssemblyDefinition.MainModule.ImportReference (ctor));
 		registrations.CustomAttributes.Add (attr);
@@ -83,7 +86,7 @@ public MethodDefinition CreateRegistrationMethod (IList<ExpressionMethodRegistra
 		registrations.Body.Variables.Add (array);
 
 		var il = registrations.Body.GetILProcessor ();
-		EmitConsoleWriteLine (il, $"# jonp: called __RegisterNativeMembers w/ {methods.Count} methods to register.");
+		EmitConsoleWriteLine (il, $"# jonp: called `{declaringType.FullName}.__RegisterNativeMembers()` w/ {methods.Count} methods to register.");
 		il.Emit (OpCodes.Ldc_I4, methods.Count);
 		il.Emit (OpCodes.Newarr, DeclaringAssemblyDefinition.MainModule.ImportReference (arrayType.GetElementType ()));
 		// il.Emit (OpCodes.Stloc_0);
@@ -116,9 +119,6 @@ public MethodDefinition CreateRegistrationMethod (IList<ExpressionMethodRegistra
 		il.Emit (OpCodes.Ldloc_0);
 		il.Emit (OpCodes.Call, DeclaringAssemblyDefinition.MainModule.ImportReference (addRegistrations.Method));
 		il.Emit (OpCodes.Ret);
-
-
-		return registrations;
 	}
 
 	void EmitConsoleWriteLine (ILProcessor il, string message)
@@ -187,6 +187,15 @@ public TypeDefinition CreateMarshalMethodDelegateType (string delegateName, ILis
 		);
 		delegateDef.BaseType = DeclaringAssemblyDefinition.MainModule.ImportReference (typeof (MulticastDelegate));
 
+		var ufpCtor     = typeof (UnmanagedFunctionPointerAttribute).GetConstructor (new[]{typeof (CallingConvention)});
+		var ufpCtorRef  = DeclaringAssemblyDefinition.MainModule.ImportReference (ufpCtor);
+		var ufpAttr     = new CustomAttribute (ufpCtorRef);
+		ufpAttr.ConstructorArguments.Add (
+				new CustomAttributeArgument (
+					DeclaringAssemblyDefinition.MainModule.ImportReference (typeof (CallingConvention)),
+					CallingConvention.Winapi));
+		delegateDef.CustomAttributes.Add (ufpAttr);
+
 		var delegateCtor = new MethodDefinition (
 				name:       ".ctor",
 				attributes: MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName,
@@ -237,22 +246,10 @@ public void Write (string path)
 		};
 		var newAsm              = AssemblyDefinition.ReadAssembly (c, rp);
 		module                  = newAsm.MainModule;
-		var systemRuntimeRef    = module.AssemblyReferences.FirstOrDefault (r => r.Name == "System.Runtime");
-		var privateCorelibRef   = module.AssemblyReferences.FirstOrDefault (r => r.Name == "System.Private.CoreLib");
-
-		if (systemRuntimeRef == null && privateCorelibRef != null) {
-			systemRuntimeRef    = GetSystemRuntimeReference ();
-			module.AssemblyReferences.Add (systemRuntimeRef);
-		}
 
 		var selfRef             = module.AssemblyReferences.FirstOrDefault (r => r.Name == newAsm.Name.Name);
 		foreach (var member in module.GetMemberReferences ()) {
 			Logger (TraceLevel.Verbose, $"# jonp: looking at ref for member: [{member.DeclaringType.Scope?.Name}]{member}");
-			if (member.DeclaringType.Scope == privateCorelibRef) {
-				Logger (TraceLevel.Verbose, $"# jonp: Fixing scope ref for member: {member}");
-				member.DeclaringType.Scope = systemRuntimeRef;
-				continue;
-			}
 			if (member.DeclaringType.Scope == selfRef) {
 				Logger (TraceLevel.Verbose, $"# jonp: Fixing scope self ref for member: {member}");
 				member.DeclaringType.Scope = null;
@@ -261,18 +258,12 @@ public void Write (string path)
 		}
 		foreach (var type in module.GetTypeReferences ()) {
 			Logger (TraceLevel.Verbose, $"# jonp: looking at ref for type: [{type.Scope}]{type}");
-			if (type.Scope == privateCorelibRef) {
-				Logger (TraceLevel.Verbose, $"# jonp: Fixing scope ref for type: {type}");
-				type.Scope = systemRuntimeRef;
-				continue;
-			}
 			if (type.Scope == selfRef) {
 				Logger (TraceLevel.Verbose, $"# jonp: Fixing scope self ref for type: {type}");
 				type.Scope = null;
 				continue;
 			}
 		}
-		module.AssemblyReferences.Remove (privateCorelibRef);
 		if (selfRef != null) {
 			module.AssemblyReferences.Remove (selfRef);
 		}

src/Java.Interop.Tools.JavaCallableWrappers/Java.Interop.Tools.JavaCallableWrappers/JavaCallableWrapperGenerator.cs

@@ -164,7 +164,13 @@ void AddNestedTypes (TypeDefinition type)
 				var baseRegisteredMethod = GetBaseRegisteredMethod (minfo);
 				if (baseRegisteredMethod != null)
 					AddMethod (baseRegisteredMethod, minfo);
-				else if (minfo.AnyCustomAttributes (typeof(ExportFieldAttribute))) {
+				else if (minfo.AnyCustomAttributes ("Java.Interop.JavaCallableAttribute")) {
+					AddMethod (null, minfo);
+					HasExport = true;
+				} else if (minfo.AnyCustomAttributes ("Java.Interop.JavaCallableConstructorAttribute")) {
+					AddMethod (null, minfo);
+					HasExport = true;
+				} else if (minfo.AnyCustomAttributes (typeof(ExportFieldAttribute))) {
 					AddMethod (null, minfo);
 					HasExport = true;
 				} else if (minfo.AnyCustomAttributes (typeof (ExportAttribute))) {
@@ -412,6 +418,25 @@ ExportAttribute ToExportAttribute (CustomAttribute attr, IMemberDefinition decla
 			return new ExportAttribute (name) {ThrownNames = thrown, SuperArgumentsString = superArgs};
 		}
 
+		ExportAttribute ToExportAttributeFromJavaCallableAttribute (CustomAttribute attr, IMemberDefinition declaringMember)
+		{
+			var name = attr.ConstructorArguments.Count > 0
+				? (string) attr.ConstructorArguments [0].Value
+				: declaringMember.Name;
+			return new ExportAttribute (name);
+		}
+
+		ExportAttribute ToExportAttributeFromJavaCallableConstructorAttribute (CustomAttribute attr, IMemberDefinition declaringMember)
+		{
+			var superArgs = (string) attr.Properties
+				.FirstOrDefault (p => p.Name == "SuperConstructorExpression")
+				.Argument
+				.Value;
+			return new ExportAttribute (".ctor") {
+				SuperArgumentsString = superArgs,
+			};
+		}
+
 		internal static ExportFieldAttribute ToExportFieldAttribute (CustomAttribute attr)
 		{
 			return new ExportFieldAttribute ((string) attr.ConstructorArguments [0].Value);
@@ -447,7 +472,11 @@ static IEnumerable<RegisterAttribute> GetMethodRegistrationAttributes (Mono.Ceci
 
 		IEnumerable<ExportAttribute> GetExportAttributes (IMemberDefinition p)
 		{
-			return GetAttributes<ExportAttribute> (p, a => ToExportAttribute (a, p));
+			return GetAttributes<ExportAttribute> (p, a => ToExportAttribute (a, p))
+				.Concat (GetAttributes<ExportAttribute> (p, "Java.Interop.JavaCallableAttribute",
+					a => ToExportAttributeFromJavaCallableAttribute (a, p)))
+				.Concat (GetAttributes<ExportAttribute> (p, "Java.Interop.JavaCallableConstructorAttribute",
+					a => ToExportAttributeFromJavaCallableConstructorAttribute (a, p)));
 		}
 
 		static IEnumerable<ExportFieldAttribute> GetExportFieldAttributes (Mono.Cecil.ICustomAttributeProvider p)
@@ -458,7 +487,13 @@ static IEnumerable<ExportFieldAttribute> GetExportFieldAttributes (Mono.Cecil.IC
 		static IEnumerable<TAttribute> GetAttributes<TAttribute> (Mono.Cecil.ICustomAttributeProvider p, Func<CustomAttribute, TAttribute?> selector)
 			where TAttribute : class
 		{
-			return p.GetCustomAttributes (typeof (TAttribute))
+			return GetAttributes (p, typeof (TAttribute).FullName, selector);
+		}
+
+		static IEnumerable<TAttribute> GetAttributes<TAttribute> (Mono.Cecil.ICustomAttributeProvider p, string attributeName, Func<CustomAttribute, TAttribute?> selector)
+			where TAttribute : class
+		{
+			return p.GetCustomAttributes (attributeName)
 				.Select (selector)
 				.Where (v => v != null)
 				.Select (v => v!);

src/Java.Interop/Java.Interop/JniRuntime.JniTypeManager.cs

@@ -412,11 +412,17 @@ protected bool TryRegisterNativeMembers (JniType nativeClass, Type type, string?
 			bool TryLoadJniMarshalMethods (JniType nativeClass, Type type, string? methods)
 			{
 				var marshalType = type?.GetNestedType ("__<$>_jni_marshal_methods", BindingFlags.NonPublic);
-				if (marshalType == null)
+				if (marshalType == null) {
 					return false;
+				}
 
-				var registerMethod = marshalType.GetRuntimeMethod ("__RegisterNativeMembers", registerMethodParameters);
-
+				var registerMethod = marshalType.GetMethod (
+						name:           "__RegisterNativeMembers",
+						bindingAttr:    BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public,
+						binder:         null,
+						callConvention: default,
+						types:          registerMethodParameters,
+						modifiers:      null);
 				return TryRegisterNativeMembers (nativeClass, marshalType, methods, registerMethod);
 			}
 
@@ -466,8 +472,10 @@ bool FindAndCallRegisterMethod (Type marshalType, JniNativeMethodRegistrationArg
 						continue;
 					}
 
+					var declaringTypeName = methodInfo.DeclaringType?.FullName ?? "<no-decl-type>";
+
 					if ((methodInfo.Attributes & MethodAttributes.Static) != MethodAttributes.Static) {
-						throw new InvalidOperationException ($"The method {methodInfo} marked with {nameof (JniAddNativeMethodRegistrationAttribute)} must be static");
+						throw new InvalidOperationException ($"The method `{declaringTypeName}.{methodInfo}` marked with [{nameof (JniAddNativeMethodRegistrationAttribute)}] must be static!");
 					}
 
 					var register = (Action<JniNativeMethodRegistrationArguments>)methodInfo.CreateDelegate (typeof (Action<JniNativeMethodRegistrationArguments>));

src/Java.Interop/Java.Interop/JniTypeSignatureAttribute.cs

@@ -11,7 +11,9 @@ public sealed class JniTypeSignatureAttribute : Attribute {
 
 		public JniTypeSignatureAttribute (string simpleReference)
 		{
+#if !JCW_ONLY_TYPE_NAMES
 			JniRuntime.JniTypeManager.AssertSimpleReference (simpleReference, nameof (simpleReference));
+#endif  // !JCW_ONLY_TYPE_NAMES
 
 			SimpleReference     = simpleReference;
 		}

src/Java.Interop/Java.Interop/ManagedPeer.cs

@@ -216,7 +216,7 @@ static unsafe void RegisterNativeMembers (
 
 			}
 			catch (Exception e) when (JniEnvironment.Runtime.ExceptionShouldTransitionToJni (e)) {
-				Debug.WriteLine (e.ToString ());
+				Debug.WriteLine ($"Exception when trying to register native methods with JNI: {e}");
 				envp.SetPendingException (e);
 			}
 			finally {

src/Java.Runtime.Environment/Java.Interop/JreTypeManager.cs

@@ -52,6 +52,10 @@ public override void RegisterNativeMembers (JniType nativeClass, Type type, Read
 				registrations.Add (new JniNativeMethodRegistration (name, signature, marshaler!));
 			}
 
+			foreach (var registration in Runtime.MarshalMemberBuilder.GetExportedMemberRegistrations (type)) {
+				registrations.Add (registration);
+			}
+
 			nativeClass.RegisterNativeMethods (registrations.ToArray ());
 		}
 

tests/Java.Interop.Export-Tests/Java.Interop.Export-Tests.csproj

@@ -22,19 +22,16 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\Java.Interop\Java.Interop.csproj" />
+    <ProjectReference Include="..\..\src\Java.Base\Java.Base.csproj" />
     <ProjectReference Include="..\..\src\Java.Interop.Export\Java.Interop.Export.csproj" />
     <ProjectReference Include="..\..\src\Java.Runtime.Environment\Java.Runtime.Environment.csproj" />
     <ProjectReference Include="..\TestJVM\TestJVM.csproj" />
   </ItemGroup>
 
   <ItemGroup>
-    <JavaExportTestJar Include="$(MSBuildThisFileDirectory)java\com\xamarin\interop\export\ExportType.java" />
+    <JavaExportTestJar Include="$(MSBuildThisFileDirectory)java\**\*.java" />
   </ItemGroup>
 
-  <Target Name="BuildExportTestJar" BeforeTargets="Build" Inputs="@(JavaExportTestJar)" Outputs="$(OutputPath)export-test.jar">
-    <MakeDir Directories="$(IntermediateOutputPath)et-classes" />
-    <Exec Command="&quot;$(JavaCPath)&quot; -classpath &quot;$(OutputPath)java-interop.jar&quot; $(_JavacSourceOptions) -d &quot;$(IntermediateOutputPath)et-classes&quot; @(JavaExportTestJar->'%(Identity)', ' ')" />
-    <Exec Command="&quot;$(JarPath)&quot; cf &quot;$(OutputPath)export-test.jar&quot; -C &quot;$(IntermediateOutputPath)et-classes&quot; ." />
-  </Target>
+  <Import Project="Java.Interop.Export-Tests.targets" />
 
 </Project>

tests/Java.Interop.Export-Tests/Java.Interop.Export-Tests.targets

@@ -0,0 +1,53 @@
+<Project>
+
+  <Target Name="_CreateJavaCallableWrappers"
+      Condition=" '$(TargetPath)' != '' "
+      BeforeTargets="BuildExportTestJar"
+      Inputs="$(TargetPath)"
+      Outputs="$(IntermediateOutputPath)java\.stamp">
+    <RemoveDir Directories="$(IntermediateOutputPath)java" />
+    <MakeDir Directories="$(IntermediateOutputPath)java" />
+    <ItemGroup>
+      <!-- I can't find a good way to trim the trailing `\`, so append with `.` so we can sanely quote for $(_Libpath) -->
+      <_RefAsmDirs Include="@(ReferencePathWithRefAssemblies->'%(RootDir)%(Directory).'->Distinct())" />
+    </ItemGroup>
+    <PropertyGroup>
+      <_JcwGen>"$(UtilityOutputFullPath)/jcw-gen.dll"</_JcwGen>
+      <_Target>--codegen-target JavaInterop1</_Target>
+      <_Output>-o "$(IntermediateOutputPath)/java"</_Output>
+      <_Libpath>@(_RefAsmDirs->'-L "%(Identity)"', ' ')</_Libpath>
+    </PropertyGroup>
+    <Exec Command="$(DotnetToolPath) $(_JcwGen) &quot;$(TargetPath)&quot; $(_Target) $(_Output) $(_Libpath)" />
+    <Touch Files="$(IntermediateOutputPath)java\.stamp" AlwaysCreate="True" />
+  </Target>
+
+  <Target Name="BuildExportTestJar"
+      AfterTargets="Build"
+      Inputs="$(TargetPath);@(JavaExportTestJar)"
+      Outputs="$(OutputPath)export-test.jar">
+    <MakeDir Directories="$(IntermediateOutputPath)et-classes" />
+    <ItemGroup>
+      <_JcwSource Include="$(IntermediateOutputPath)java\**\*.java" />
+    </ItemGroup>
+    <ItemGroup>
+      <_Source Include="@(_JcwSource->Replace('%5c', '/'))" />
+      <_Source Include="@(JavaExportTestJar->Replace('%5c', '/'))" />
+    </ItemGroup>
+    <WriteLinesToFile
+        File="$(IntermediateOutputPath)_java_sources.txt"
+        Lines="@(_Source)"
+        Overwrite="True"
+    />
+    <ItemGroup>
+      <_JavacOpt Include="$(_JavacSourceOptions)" />
+      <_JavacOpt Include="-d &quot;$(IntermediateOutputPath)et-classes&quot; " />
+      <_JavacOpt Include="-classpath &quot;$(OutputPath)java-interop.jar&quot; " />
+      <_JavacOpt Include="&quot;@$(IntermediateOutputPath)_java_sources.txt&quot;" />
+      <_JavacOpt Include="-h &quot;$(IntermediateOutputPath)et-classes&quot; " />
+    </ItemGroup>
+    <Exec Command="&quot;$(JavaCPath)&quot; @(_JavacOpt, ' ')" />
+    <Delete Files="$(IntermediateOutputPath)_java_sources.txt" />
+    <Exec Command="&quot;$(JarPath)&quot; cf &quot;$(OutputPath)export-test.jar&quot; -C &quot;$(IntermediateOutputPath)et-classes&quot; ." />
+  </Target>
+
+</Project>

tests/Java.Interop.Export-Tests/Java.Interop/JavaCallableExample.cs

@@ -0,0 +1,23 @@
+using Java.Interop;
+
+namespace Java.InteropTests;
+
+[JniTypeSignature (TypeSignature)]
+class JavaCallableExample : Java.Lang.Object {
+
+	internal const string TypeSignature = "net/dot/jni/test/JavaCallableExample";
+
+	[JavaCallableConstructor(SuperConstructorExpression="")]
+	public JavaCallableExample (int a)
+	{
+		this.a = a;
+	}
+
+	int a;
+
+	[JavaCallable ("getA")]
+	public int GetA ()
+	{
+		return a;
+	}
+}

tests/Java.Interop.Export-Tests/Java.Interop/JavaCallableExampleTests.cs

@@ -0,0 +1,21 @@
+using Java.Interop;
+
+using NUnit.Framework;
+
+namespace Java.InteropTests;
+
+[TestFixture]
+class JavaCallableExampleTest : JavaVMFixture
+{
+	[Test]
+	public void JavaCallableWrappers ()
+	{
+		using var jce = CreateUseJavaCallableExampleType ();
+		var m = jce.GetStaticMethod ("test", "()Z");
+		var z = JniEnvironment.StaticMethods.CallStaticBooleanMethod (jce.PeerReference, m);
+		Assert.IsTrue (z);
+	}
+
+	static JniType CreateUseJavaCallableExampleType () =>
+		new JniType ("net/dot/jni/test/UseJavaCallableExample");
+}