[java-interop] Resuscitate MonoVM GC Bridge (#1316)

Context: dotnet/runtime#112109
Context: f5ce0ad
Context: 3824b97
Context: c6c487b

Commit f5ce0ad copied portions of the .NET for Android Mono GC Bridge
code into `src/java-interop`, but to *build* that code "on Desktop" --
for possible CI and unit test use -- it needed to build against Mono
*somehow*.

The *actual* "how" was unspecified:

  * The macOS build implicitly required that
    `/Library/Frameworks/Mono.framework` exist, and would pull in
    header files and libraries from there.

    This directory would only exist if you installed Mono system-wide
    on your Mac.

  * Linux and Windows were not support *at all*.

Eventually `src/java-interop` got Windows build support in 3824b97.
This allowed `Java.Interop-Tests.dll` to run under .NET Core, but
this did *not* contain any GC bridge code; it was *just* the JNI
wrapper functions such as `java_interop_jnienv_get_version()` and
JVM loading functions such as `java_interop_jvm_create()`.

Eventually (c6c487b), a native `java-interop` library was not needed
*at all*: C#9 function pointers and `NativeLibrary` removed the need
for it to be built at all.

The Mono GC bridge code within java-interop effectively bitrotted, as
nothing *built* it anymore.  .NET for Android has its own (original!)
copy, and CI is primarily concerned about .NET (Core) and not Mono.
(This means the GC bridge *isn't* tested, but everything else is.)

Three things have happened in the meantime:

 1. The Mono team was absorbed into the .NET team, with the new
    "MonoVM" as a supported backend for .NET, selectable by setting
    `$(UseMonoRuntime)`=true on desktop platforms.  MonoVM is used by
    .NET for Android and a supported backend with .NET for iOS, Mac…

 2. MonoVM is now provided as NuGet packages!

 3. There are now efforts to investigate adding something like the GC
    Bridge to CoreCLR and NativeAOT; see dotnet/runtime#112109.
    Some developers involved with this would like to debug how the
    current GC bridge works.  *On desktop Windows*.

Embrace the new world order: remove support for using "system" Mono
installations, the `_CreateMonoInfoProps` target, generation of
`MonoInfo.props`, etc., and instead use MonoVM packages to provide
the MonoVM runtime and header files needed for compilation & linking.
This allows for a consistent build environment across Linux, macOS,
and Windows, though Windows adds one wrinkle:

MonoVM doesn't contain a `coreclr.lib` file for linking.

Add `coreclr.def` and a `coreclr.lib` file to use for linking against
MonoVM on Windows.  `coreclr.lib` was created by:

	lib /def:coreclr.def /out:coreclr.lib /machine:X64

where `coreclr.def` contains the `mono_` symbols that were referenced
by the macOS `libjava-interop.dylib` build, as per
`nm bin/Release-net8.0/libjava-interop.dylib | grep 'U _mono'`.

Update `src/java-interop` so that it builds with the latest MonoVM
headers (`<mono/metadata/appdomain.h>` must now be included), and
allow it to build under Windows (use `Interlocked*` instead of
clang's `__sync_*_and_fetch()`.)

There is one ("tiny") problem with this approach: .NET 9 doesn't
contain MonoVM packages.  For example, the
[`Microsoft.NETCore.App.Runtime.Mono.osx-x64` NuGet package][0] was
last updated for .NET 9 Preview 7; the last *stable* version is for
.NET *8*.

Fortunately we only recently migrated to .NET 9 (f30e420).
Update `JniRuntime.cs` so that we can build the repo when overriding
with `-p:DotNetTargetFramework=net8.0`.

Update `Java.Interop.Sdk` so that the `.jar` it creates is
appropriately copied to `$(OutputPath)` of the referencing project.
This required using `%(Content.CopyToOutputDirectory)`=PreserveNewest
alongside  using `%(Content.TargetPath)` -- which sets the relative
name within `$(OutputPath)` -- and in turn required making
`_JavaCreateJcws` run after `CoreCompile` instead of `Build`, so that
it would properly participate in `%(CopyToOutputDirectory)` logic.

The code to detect that MonoVM is being used within
`Java.Runtime.Environment.dll` has changed; the `Mono.Runtime` type
no longer exists.  Check for `Mono.RuntimeStructs` instead.

Update `TestJVM.GetJvmLibraryPath()` so that it can find
`bin\BuildRelease\JdkInfo.props` when running an app from the
`samples` directory and not from `bin\TestRelease*\…`.

All of this allows for `samples/Hello-Java.Base` to be built against
and run with MonoVM, on Windows!

	# need Release config build because `dotnet publish` is implicitly Release
	dotnet build -c Release -t:Prepare -p:DotNetTargetFramework=net8.0 Java.Interop.sln
	dotnet build -c Release -p:DotNetTargetFramework=net8.0 Java.Interop.sln

	# -p:UseMonoRuntime enables use of MonoVM
	dotnet publish --self-contained -p:UseMonoRuntime=true -p:DotNetTargetFramework=net8.0 -p:UseAppHost=true -p:ErrorOnDuplicatePublishOutputFiles=false samples/Hello-Java.Base/Hello-Java.Base.csproj -r win-x64

Note: replace `-r win-x64` with the appropriate RID for your host.

With that setup, you can then run the sample:
	
	> samples\Hello-Java.Base\bin\Release\win-x64\publish\Hello-Java.Base.exe
	MonoVM support enabled
	# jonp: LoadJvmLibrary(C:\Users\jopryo\android-toolchain\jdk-17\bin\server\jvm.dll)=140710450692096
	# jonp: JNI_CreateJavaVM=140710454831248; JNI_GetCreatedJavaVMs=140710454831280
	# jonp: executing JNI_CreateJavaVM=7ff9b4ad2890
	# jonp: r=0 javavm=7ff9b51fd7f0 jnienv=24d781dddc0
	WARNING in native method: JNI call made without checking exceptions when required to from CallStaticObjectMethodV
	binding? net.dot.jni.sample.MyJLO@a09ee92

[0]: https://www.nuget.org/packages/Microsoft.NETCore.App.Runtime.Mono.osx-x64/

Author: jonpryor

build-tools/Java.Interop.BootstrapTasks/Java.Interop.BootstrapTasks.targets

@@ -1,93 +1,5 @@
 <Project>
 
-  <Target Name="_CreateMonoInfoProps"
-      Condition=" ($([MSBuild]::IsOSPlatform ('linux')) Or $([MSBuild]::IsOSPlatform ('osx'))) And '$(_MonoPath)' != '' "
-      AfterTargets="AfterBuild"
-      DependsOnTargets="_GetLinuxMonoPaths;_GetMacOSMonoPaths"
-      Inputs="$(MSBuildThisFileFullPath);$(MSBuildThisFileDirectory)Java.Interop.BootstrapTasks.csproj"
-      Outputs="$(_OutputPath)MonoInfo.props">
-    <ItemGroup>
-      <_MonoInfoLine Include="&lt;Project&gt;" />
-      <_MonoInfoLine Include="  &lt;Choose&gt;" />
-      <_MonoInfoLine Include="    &lt;When Condition=&quot; %27%24(MonoFrameworkPath)%27 == %27%27 &quot;&gt;" />
-      <_MonoInfoLine Include="      &lt;PropertyGroup&gt;" />
-      <_MonoInfoLine Include="        &lt;MonoFrameworkPath&gt;$(_MonoFrameworkPath)&lt;/MonoFrameworkPath&gt;" />
-      <_MonoInfoLine Include="        &lt;MonoLibs         &gt;$(_MonoLibs)&lt;/MonoLibs&gt;" />
-      <_MonoInfoLine Include="      &lt;/PropertyGroup&gt;" />
-      <_MonoInfoLine Include="      &lt;ItemGroup&gt;" />
-      <_MonoInfoLine Include="        &lt;MonoIncludePath Include=&quot;$(_MonoIncludePath)&quot; /&gt;" />
-      <_MonoInfoLine Include="      &lt;/ItemGroup&gt;" />
-      <_MonoInfoLine Include="    &lt;/When&gt;" />
-      <_MonoInfoLine Include="  &lt;/Choose&gt;" />
-      <_MonoInfoLine Include="&lt;/Project&gt;" />
-    </ItemGroup>
-    <WriteLinesToFile
-        File="$(_OutputPath)MonoInfo.props"
-        Lines="@(_MonoInfoLine)"
-        Overwrite="True"
-    />
-    <Touch Files="$(_OutputPath)MonoInfo.props" />
-  </Target>
-
-  <Target Name="_CreateMonoMk"
-      AfterTargets="AfterBuild"
-      DependsOnTargets="_GetLinuxMonoPaths;_GetMacOSMonoPaths"
-      Inputs="$(MSBuildThisFileFullPath);$(MSBuildThisFileDirectory)Java.Interop.BootstrapTasks.csproj"
-      Outputs="$(_OutputPath)mono.mk">
-    <ItemGroup>
-      <_MonoMkLine Include="JI_MONO_LIB_PATH=$(_MonoLibPath)" />
-    </ItemGroup>
-    <WriteLinesToFile
-        File="$(_OutputPath)mono.mk"
-        Lines="@(_MonoMkLine)"
-        Overwrite="True"
-    />
-    <Touch Files="$(_OutputPath)mono.mk" />
-  </Target>
-
-  <Target Name="_GetLinuxMonoPath"
-      Condition=" $([MSBuild]::IsOSPlatform ('linux')) ">
-    <Exec
-        Command="which mono"
-        ConsoleToMsBuild="true"
-        IgnoreExitCode="true">
-      <Output TaskParameter="ConsoleOutput" PropertyName="_MonoPath" />
-    </Exec>
-  </Target>
-
-  <Target Name="_GetLinuxMonoPaths"
-      DependsOnTargets="_GetLinuxMonoPath"
-      Condition=" $([MSBuild]::IsOSPlatform ('linux')) And '$(_MonoPath)' != '' ">
-    <Exec
-        Command="pkg-config --variable=libdir mono-2"
-        ConsoleToMsBuild="True">
-      <Output TaskParameter="ConsoleOutput" PropertyName="_MonoPkgConfigLibdir" />
-    </Exec>
-    <Exec
-        Command="pkg-config --variable=includedir mono-2"
-        ConsoleToMsBuild="True">
-      <Output TaskParameter="ConsoleOutput" PropertyName="_MonoPkgConfigIncludedir" />
-    </Exec>
-    <PropertyGroup>
-      <_MonoLibPath>$([System.IO.Path]::GetDirectoryName($(_MonoPath)))/../lib/</_MonoLibPath>
-      <_MonoFrameworkPath>$(_MonoPkgConfigLibdir)/libmonosgen-2.0.so</_MonoFrameworkPath>
-      <_MonoIncludePath>$(_MonoPkgConfigIncludedir)</_MonoIncludePath>
-      <_MonoLibs>-L "$(_MonoPkgConfigLibdir)" -lmonosgen-2.0</_MonoLibs>
-    </PropertyGroup>
-  </Target>
-
-  <Target Name="_GetMacOSMonoPaths"
-      Condition=" $([MSBuild]::IsOSPlatform ('osx')) ">
-    <PropertyGroup>
-      <_MonoBase>/Library/Frameworks/Mono.framework/</_MonoBase>
-      <_MonoLibPath>$(_MonoBase)Libraries/</_MonoLibPath>
-      <_MonoFrameworkPath>$(_MonoLibPath)libmonosgen-2.0.1.dylib</_MonoFrameworkPath>
-      <_MonoIncludePath>$(_MonoBase)Headers/mono-2.0</_MonoIncludePath>
-      <_MonoLibs>-L "$(_MonoLibPath)" -lmonosgen-2.0</_MonoLibs>
-    </PropertyGroup>
-  </Target>
-
-
   <Target Name="_CreatePackagePathsProps"
       AfterTargets="AfterBuild"
       Inputs="$(MSBuildThisFileFullPath);$(MSBuildThisFileDirectory)Java.Interop.BootstrapTasks.csproj"

build-tools/Java.Interop.Sdk/Sdk/Sdk.targets

@@ -10,7 +10,7 @@
   </ItemDefinitionGroup>
 
   <PropertyGroup>
-    <JavaOutputJar Condition=" '$(JavaOutputJar)' == '' ">$(OutputPath)$(AssemblyName).jar</JavaOutputJar>
+    <JavaOutputJarName Condition=" '$(JavaOutputJarName)' == '' ">$(AssemblyName).jar</JavaOutputJarName>
   </PropertyGroup>
 
   <PropertyGroup>
@@ -32,7 +32,7 @@
   </Target>
 
   <Target Name="JavaCreateOutputJar"
-      AfterTargets="Build"
+      AfterTargets="CoreCompile"
       DependsOnTargets="$(JavaCreateOutputJarDependsOn)">
   </Target>
 
@@ -43,8 +43,16 @@
     <_JavaManagedBindingDir>$(_JavaIntermediateDir)mcw\</_JavaManagedBindingDir>
     <_JavaJcwClassesDir>$(_JavaIntermediateDir)classes\</_JavaJcwClassesDir>
     <_JavaJcwSourcesDir>$(_JavaIntermediateDir)java\</_JavaJcwSourcesDir>
+    <_JavaOutputJarPath>$(_JavaIntermediateDir)$(JavaOutputJarName)</_JavaOutputJarPath>
   </PropertyGroup>
 
+  <ItemGroup>
+    <Content Include="$(_JavaOutputJarPath)"
+        CopyToOutputDirectory="PreserveNewest"
+        TargetPath="$(JavaOutputJarName)"
+    />
+  </ItemGroup>
+
   <Target Name="_CollectJavaCompileForManagedBindingInputs">
     <ItemGroup>
       <_JavaCompileForBindingInputs
@@ -169,8 +177,8 @@
   <Target Name="_CleanupManagedBinding" />
 
   <Target Name="_JavaCreateJcws"
-      Condition=" '$(TargetPath)' != '' And Exists($(TargetPath))"
-      Inputs="$(TargetPath)"
+      Condition=" '@(IntermediateAssembly)' != '' And Exists(@(IntermediateAssembly))"
+      Inputs="@(IntermediateAssembly)"
       Outputs="$(_JavaJcwSourcesDir).stamp">
     <RemoveDir Directories="$(_JavaJcwSourcesDir)" />
     <MakeDir Directories="$(_JavaJcwSourcesDir)" />
@@ -184,7 +192,7 @@
       <_Output>-o "$(_JavaJcwSourcesDir)."</_Output>
       <_Libpath>@(_RefAsmDirs->'-L "%(Identity)"', ' ')</_Libpath>
     </PropertyGroup>
-    <Exec Command="$(DotnetToolPath) $(_JcwGen) -v &quot;$(TargetPath)&quot; $(_Target) $(_Output) $(_Libpath)" />
+    <Exec Command="$(DotnetToolPath) $(_JcwGen) -v @(IntermediateAssembly->'&quot;%(Identity)&quot;', ' ') $(_Target) $(_Output) $(_Libpath)" />
     <Touch Files="$(_JavaJcwSourcesDir).stamp" AlwaysCreate="True" />
   </Target>
 
@@ -197,7 +205,7 @@
   <Target Name="_JavaCreateOutputJar"
       DependsOnTargets="_JavaCollectGeneratdJcwSource;_JavaCollectJavacRefs"
       Inputs="@(_JavaGeneratedJcwSource)"
-      Outputs="$(JavaOutputJar)">
+      Outputs="$(_JavaOutputJarPath)">
     <RemoveDir Directories="$(_JavaJcwClassesDir)" />
     <MakeDir Directories="$(_JavaJcwClassesDir)" />
     <PropertyGroup>
@@ -215,7 +223,11 @@
     />
     <Exec Command="&quot;$(JavaCPath)&quot; $(_JavacSourceOptions) -d &quot;$(_JavaJcwClassesDir).&quot; -classpath &quot;$(_Classpath)&quot; &quot;@$(_JavaIntermediateDir)_java_sources.txt&quot;" />
     <Delete Files="$(_JavaIntermediateDir)_java_sources.txt" />
-    <Exec Command="&quot;$(JarPath)&quot; cf &quot;$(JavaOutputJar)&quot; -C &quot;$(_JavaJcwClassesDir).&quot; ." />
+    <Exec Command="&quot;$(JarPath)&quot; cf &quot;$(_JavaOutputJarPath)&quot; -C &quot;$(_JavaJcwClassesDir).&quot; ." />
+
+    <ItemGroup>
+      <FileWrites Include="$(_JavaOutputJarPath)" />
+    </ItemGroup>
   </Target>
 
 </Project>

samples/Hello-Java.Base/Program.cs

@@ -17,23 +17,34 @@ class App
 
 		public static void Main (string[] args)
 		{
-			string? jvmPath             = global::Java.InteropTests.TestJVM.GetJvmLibraryPath ();
+			var     logger              = (Action<TraceLevel, string>?) null;
+			string? jvmPath             = null;
 			bool    createMultipleVMs   = false;
 			bool    reportTiming        = false;
 			bool    showHelp            = false;
+			int     verbosity           = 0;
 			var options = new OptionSet () {
 				"Using the JVM from C#!",
 				"",
 				"Options:",
 				{ "jvm=",
-				  $"{{PATH}} to JVM to use.  Default is:\n  {jvmPath}",
+				  $"{{PATH}} to JVM to use.  Default is:\n{Java.InteropTests.TestJVM.GetJvmLibraryPath (logger)}",
 				  v => jvmPath = v },
 				{ "m",
 				  "Create multiple Java VMs.  This will likely crash.",
 				  v => createMultipleVMs = v != null },
 				{ "t",
 				  $"Timing; invoke Object.hashCode() {N} times, print average.",
 				  v => reportTiming = v != null },
+				{ "v|verbosity:",
+				  $"Set console log verbosity to {{LEVEL}}.  Default is 0.",
+				  (int? v) => {
+				    verbosity = v.HasValue ? v.Value : verbosity + 1;
+				    if (verbosity > 0) {
+				      logger    = CreateConsoleLogger ();
+					}
+				  }
+				},
 				{ "h|help",
 				  "Show this message and exit.",
 				  v => showHelp = v != null },
@@ -45,7 +56,7 @@ public static void Main (string[] args)
 			}
 			var builder = new JreRuntimeOptions () {
 				JniAddNativeMethodRegistrationAttributePresent  = true,
-				JvmLibraryPath                                  = jvmPath,
+				JvmLibraryPath                                  = jvmPath ?? global::Java.InteropTests.TestJVM.GetJvmLibraryPath (logger),
 				ClassPath   = {
 					Path.Combine (Path.GetDirectoryName (typeof (App).Assembly.Location)!, "Hello-Java.Base.jar"),
 				},
@@ -70,6 +81,13 @@ public static void Main (string[] args)
 			CreateJLO ();
 		}
 
+		static Action<TraceLevel, string> CreateConsoleLogger ()
+		{
+			return (level, message) => {
+				Console.WriteLine ($"# {level}: {message}");
+			};
+		}
+
 		static void CreateJLO ()
 		{
 			var jlo = new MyJLO ();

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

@@ -445,8 +445,9 @@ public virtual void OnEnterMarshalMethod ()
 		public virtual void OnUserUnhandledException (ref JniTransition transition, Exception e)
 		{
 			transition.SetPendingException (e);
-
+#if NET9_0_OR_GREATER
 			Debugger.BreakForUserUnhandledException (e);
+#endif  // NET9_0_OR_GREATER
 		}
 
 		public virtual void RaisePendingException (Exception pendingException)

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

@@ -91,8 +91,9 @@ static unsafe JreRuntimeOptions CreateJreVM (JreRuntimeOptions builder)
 			builder.TypeManager     ??= new JreTypeManager (builder.typeMappings);
 #endif  // NET
 
-			bool onMono = Type.GetType ("Mono.Runtime", throwOnError: false) != null;
+			bool onMono = Type.GetType ("Mono.RuntimeStructs", throwOnError: false) != null;
 			if (onMono) {
+				Console.WriteLine ($"MonoVM support enabled");
 				builder.ValueManager            = builder.ValueManager              ?? new MonoRuntimeValueManager ();
 				builder.ObjectReferenceManager  = builder.ObjectReferenceManager    ?? new MonoRuntimeObjectReferenceManager ();
 			}

src/java-interop/.gitignore

@@ -1,2 +1,3 @@
+coreclr.exp
 jni.c
 jni.g.cs

src/java-interop/CMakeLists.txt

@@ -1,4 +1,4 @@
-set(CMAKE_OSX_ARCHITECTURES x86_64 arm64)
+cmake_minimum_required(VERSION 3.10.2)
 
 project(
     java-interop
@@ -14,8 +14,9 @@ set(CMAKE_CXX_EXTENSIONS OFF)
 set(CMAKE_CXX_VISIBILITY_PRESET hidden)
 
 option(ENABLE_MONO_INTEGRATION "Require Mono runtime" OFF)
+option(ENABLE_OSX_ARCHITECTURES "macOS architectures" "")
 
-cmake_minimum_required(VERSION 3.10.2)
+set(CMAKE_OSX_ARCHITECTURES ${ENABLE_OSX_ARCHITECTURES})
 
 set(JAVA_INTEROP_CORE_SOURCES
     java-interop-dlfcn.cc
@@ -44,7 +45,6 @@ if(ENABLE_MONO_INTEGRATION)
     include_directories(${dir})
   endforeach()
   list(APPEND LINK_FLAGS ${MONO_LINK_FLAGS})
-  list(APPEND LINK_FLAGS "-Wl,-undefined -Wl,suppress -Wl,-flat_namespace")
   set(JAVA_INTEROP_SOURCES ${JAVA_INTEROP_CORE_SOURCES} ${JAVA_INTEROP_MONO_SOURCES})
 else()
   set(JAVA_INTEROP_SOURCES ${JAVA_INTEROP_CORE_SOURCES})

src/java-interop/coreclr.def

@@ -0,0 +1,20 @@
+LIBRARY CORECLR
+
+EXPORTS
+   mono_class_from_mono_type
+   mono_class_get_field_from_name
+   mono_class_get_name
+   mono_class_get_namespace
+   mono_class_is_subclass_of
+   mono_class_vtable
+   mono_domain_get
+   mono_field_get_value
+   mono_field_set_value
+   mono_field_static_set_value
+   mono_gc_register_bridge_callbacks
+   mono_gc_wait_for_bridge_processing
+   mono_object_get_class
+   mono_thread_attach
+   mono_thread_current
+   mono_thread_get_managed_id
+   mono_thread_get_name_utf8

src/java-interop/coreclr.lib

@@ -3,7 +3,6 @@
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
-#include <pthread.h>
 #include <inttypes.h>
 
 #include "java-interop.h"
@@ -12,6 +11,7 @@
 #include "java-interop-util.h"
 
 #ifdef _WINDOWS
+#include <windows.h>
 #include <fileapi.h>
 #endif
 
@@ -530,13 +530,21 @@ get_object_ref_type (JNIEnv *env, jobject handle)
 static int
 gref_inc (JavaInteropGCBridge *bridge)
 {
+#if _WINDOWS
+	return InterlockedIncrement ((LONG volatile*) &bridge->gc_gref_count);
+#else   // !_WINDOWS
 	return __sync_add_and_fetch (&bridge->gc_gref_count, 1);
+#endif  // _!WINDOWS
 }
 
 static int
 gref_dec (JavaInteropGCBridge *bridge)
 {
+#if _WINDOWS
+	return InterlockedDecrement ((LONG volatile*) &bridge->gc_gref_count);
+#else   // !_WINDOWS
 	return __sync_sub_and_fetch (&bridge->gc_gref_count, 1);
+#endif  // _!WINDOWS
 }
 
 #if defined (ANDROID)

src/java-interop/java-interop-gc-bridge-mono.cc

@@ -4,6 +4,7 @@
 #include "java-interop.h"
 
 #include <mono/metadata/assembly.h>
+#include <mono/metadata/appdomain.h>
 #include <mono/metadata/class.h>
 #include <mono/metadata/object.h>
 #include <mono/metadata/sgen-bridge.h>

src/java-interop/java-interop-mono.h

@@ -28,7 +28,18 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\build-tools\jnienv-gen\jnienv-gen.csproj" ReferenceOutputAssembly="false" />
-  </ItemGroup>  
+  </ItemGroup>
+
+  <PropertyGroup>
+    <DotNetRuntimePacksVersion>8.0.13</DotNetRuntimePacksVersion>
+  </PropertyGroup>
+
+  <ItemGroup Condition=" '$(UseMonoRuntime)' != 'true' ">
+    <PackageDownload
+        Include="Microsoft.NETCore.App.Runtime.Mono.$(NETCoreSdkRuntimeIdentifier)"
+        Version="[$(DotNetRuntimePacksVersion)]"
+    />
+  </ItemGroup>
 
   <Import Project="java-interop.targets" />