[build] Improve support for building on GitHub Codespaces (#1241)

Context: https://docs.github.com/en/codespaces/setting-up-your-project-for-codespaces/adding-a-dev-container-configuration/introduction-to-dev-containers
Context: https://docs.github.com/en/codespaces/setting-up-your-project-for-codespaces/adding-a-dev-container-configuration/introduction-to-dev-containers#using-the-default-dev-container-configuration
Context: https://github.com/orgs/community/discussions/25429

There are two issues when trying to build `Java.Interop.sln` within
a [GitHub Codespace][0]:

 1. `dotnet build -t:Prepare Java.Interop.sln` fails.
 2. `mono` was required on Linux environments.

`dotnet build -t:Prepare` fails because `Java.Interop.sln` references
`Xamarin.Android.Tools.AndroidSdk.csproj`, which does not exist
immediately after checkout:

        /usr/share/dotnet/sdk/8.0.303/NuGet.targets(414,5): error MSB3202:
        The project file "…/java-interop/external/xamarin-android-tools/src/Xamarin.Android.Tools.AndroidSdk/Xamarin.Android.Tools.AndroidSdk.csproj"
        was not found.

This apparently happens *before* the `Prepare` target executes, so
the `git submodule update --init --recursive` within that target
doesn't execute.

Fix this by adding a `.devcontainer/devcontainer.json` which contains
a `postCreateCommand` section which runs
`git submodule update --init --recursive`.  Additionally, have
`devcontainer.json` use the
`mcr.microsoft.com/devcontainers/universal:2-linux` image, which
supports C#, Java, and C++ development (among others), which is handy
as this repo contains C#, Java, and C++ code to compile.

Once the submodule problem is addressed, `dotnet build -t:Prepare`
fails again because `mono` was required in Linux environments, and
the default environment that GitHub Codespace creates when typing
`.` within dotnet/java-interop has `dotnet` installed, but not `mono`.
This results the error:

        …/java-interop/build-tools/Java.Interop.BootstrapTasks/Java.Interop.BootstrapTasks.targets(50,5):
        error MSB3073: The command "which mono" exited with code 1.

Update `Java.Interop.BootstrapTasks.targets` so that `mono` is no
longer required on Linux platforms.  If `which mono` returns the
empty string, then `bin/Build*/MonoInfo.props` is not created.

Finally, the `mcr.microsoft.com/devcontainers/universal:2-linux`
image defaults to using JDK 17.  The
`JniPeerMembersTests.DoesTheJmethodNeedToMatchDeclaringType()` test
crashes under JDK 17 with:

	FATAL ERROR in native method: Wrong object class or methodID passed to JNI call

Update `DoesTheJmethodNeedToMatchDeclaringType()` to skip the test
when running on JDK 17 or later.

With these changes, a new GitHub codespace against dotnet/java-interop
can now build and run tests, a'la:

        % dotnet build -t:Prepare Java.Interop.sln
        % dotnet build Java.Interop.sln
        % dotnet test bin/TestDebug-net8.0/Java.Interop-Tests.dll
        …
        Passed!  - Failed:     0, Passed:   629, Skipped:     3, Total:   632, Duration: 4 s - Java.Interop-Tests.dll (net8.0)


~~ Oddities and annoyances with GitHub Codespaces: ~~

 1. On macOS + Safari, "Hamburger menu" > File > Close Editor *says* ⌘W.
    However, *using* ⌘W results in closing the
    GitHub Codespaces *Safari tab*.

    *Oops*.

    Pressing ⌘Z will reopen the closed Safari tab.

    I don't know how to close a VSCode tab without using the mouse.
    Ctrl+W doesn't do it.

 2. You make a change, and commit it by using `git commit` within the
    Terminal (Ctrl+Shift+Backtick ⌃ ⇧ \`).

    A new tab for `COMMIT_EDITMSG` opens.  This is good.

    If you then *search for text* that appears within that editor
    window, and that text appears within the editor window --
    e.g. search for "the" -- then the "return" key keeps finding the
    next search match, which makes it difficult to enter blank lines.

    You must either fully dismiss the search dialog by hitting
    Escape ⎋ a few times, or by clicking the close `x` button on the
    search panel, or use Ctrl+return ⌃return to enter a newline.
    This was "odd", especially as Escape ⎋ doesn't appear to reliably
    dismiss the search panel for me.

[0]: https://github.com/features/codespaces

Author: jonpryor

.devcontainer/devcontainer.json

@@ -0,0 +1,34 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/dotnet
+{
+	"name": "Linux Universal Image",
+	// Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
+	"image": "mcr.microsoft.com/devcontainers/universal:2-linux"
+
+    // Features to add to the dev container. More info: https://containers.dev/features.
+	, "features": {
+		"ghcr.io/devcontainers/features/java:1": {
+			"version": "17",
+			"jdkDistro": "ms"
+		}
+	}
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [5000, 5001],
+	// "portsAttributes": {
+	//		"5001": {
+	//			"protocol": "https"
+	//		}
+	// }
+
+	// Use 'postCreateCommand' to run commands after the container is created.
+	// Have GitHub Codespaces checkout all submodules
+	// https://github.com/orgs/community/discussions/25429
+	, "postCreateCommand": "git submodule update --init --recursive"
+
+	// Configure tool-specific properties.
+	// "customizations": {},
+
+	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+	// "remoteUser": "root"
+}

README.md

@@ -28,7 +28,7 @@ and [Architecture][architecture] pages.
 
 `Java.Interop.sln` must first run some "preparatory" tasks before it can be built:
 
-```
+```console
 dotnet build -t:Prepare
 ```
 

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

@@ -1,7 +1,7 @@
 <Project>
 
   <Target Name="_CreateMonoInfoProps"
-      Condition=" $([MSBuild]::IsOSPlatform ('linux')) Or $([MSBuild]::IsOSPlatform ('osx')) "
+      Condition=" ($([MSBuild]::IsOSPlatform ('linux')) Or $([MSBuild]::IsOSPlatform ('osx'))) And '$(_MonoPath)' != '' "
       AfterTargets="AfterBuild"
       DependsOnTargets="_GetLinuxMonoPaths;_GetMacOSMonoPaths"
       Inputs="$(MSBuildThisFileFullPath);$(MSBuildThisFileDirectory)Java.Interop.BootstrapTasks.csproj"
@@ -45,13 +45,19 @@
     <Touch Files="$(_OutputPath)mono.mk" />
   </Target>
 
-  <Target Name="_GetLinuxMonoPaths"
+  <Target Name="_GetLinuxMonoPath"
       Condition=" $([MSBuild]::IsOSPlatform ('linux')) ">
     <Exec
         Command="which mono"
-        ConsoleToMsBuild="True">
+        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">

tests/Java.Interop-Tests/Java.Interop/JniPeerMembersTests.cs

@@ -142,6 +142,11 @@ public unsafe void DoesTheJmethodNeedToMatchDeclaringType ()
 			if (Environment.GetEnvironmentVariable ("CPUTYPE") is string cpu && cpu == "arm64") {
 				Assert.Ignore ("nope!");
 			}
+			if (VM.JdkInfo.Version is Version v && v >= new Version (17, 0)) {
+				// JDK-17 now crashes on this test as well:
+				// FATAL ERROR in native method: Wrong object class or methodID passed to JNI call
+				Assert.Ignore ("nope!");
+			}
 			var iface   = new JniType ("net/dot/jni/test/AndroidInterface");
 			var desugar = new JniType ("net/dot/jni/test/DesugarAndroidInterface$_CC");
 			var m       = desugar.GetStaticMethod ("getClassName", "()Ljava/lang/String;");

tests/TestJVM/TestJVM.cs

@@ -24,20 +24,33 @@ public TestJVMOptions (Assembly? callingAssembly = null)
 		public  ICollection<string>         JarFilePaths    {get;}      = new List<string> ();
 		public  Assembly                    CallingAssembly {get; set;}
 		public  Dictionary<string, Type>?   TypeMappings    {get; set;}
+
+		internal    JdkInfo?                JdkInfo         {get; set;}
 	}
 
 	public class TestJVM : JreRuntime {
 
+#if !__ANDROID__
+		public JdkInfo? JdkInfo { get; private set; }
+#endif  // !__ANDROID__
+
 		public TestJVM (TestJVMOptions builder)
 			: base (OverrideOptions (builder))
 		{
+#if !__ANDROID__
+			this.JdkInfo    = builder.JdkInfo;
+#endif  // !__ANDROID__
+
 		}
 
 		static TestJVMOptions OverrideOptions (TestJVMOptions builder)
 		{
 			var dir = GetOutputDirectoryName ();
 
-			builder.JvmLibraryPath                                  = GetJvmLibraryPath ();
+			var info = GetJdkInfo ();
+
+			builder.JvmLibraryPath                                  = info.JdkJvmPath;
+			builder.JdkInfo                                         = info.JdkInfo;
 			builder.JniAddNativeMethodRegistrationAttributePresent  = true;
 			builder.JniGlobalReferenceLogWriter                     = GetLogOutput ("JAVA_INTEROP_GREF_LOG", "g-", builder.CallingAssembly);
 			builder.JniLocalReferenceLogWriter                      = GetLogOutput ("JAVA_INTEROP_LREF_LOG", "l-", builder.CallingAssembly);
@@ -67,35 +80,37 @@ static string GetOutputDirectoryName ()
 			return new StreamWriter (path, append: false, encoding: new UTF8Encoding (encoderShouldEmitUTF8Identifier: false));
 		}
 
-		public static string? GetJvmLibraryPath ()
+		public static string? GetJvmLibraryPath () => GetJdkInfo ().JdkJvmPath;
+
+		static (JdkInfo? JdkInfo, string? JdkJvmPath) GetJdkInfo ()
 		{
-			var jdkDir  = ReadJavaSdkDirectoryFromJdkInfoProps ();
-			if (jdkDir != null) {
-				return jdkDir;
+			var info    = ReadJavaSdkDirectoryFromJdkInfoProps ();
+			if (info.JdkJvmPath != null) {
+				return (JdkInfo: info.JavaSdkDirectory == null ? null : new JdkInfo (info.JavaSdkDirectory), JdkJvmPath: info.JdkJvmPath);
 			}
 			var jdk = JdkInfo.GetKnownSystemJdkInfos ()
 				.FirstOrDefault ();
-			return jdk?.JdkJvmPath;
+			return (jdk, jdk?.JdkJvmPath);
 		}
 
-		static string? ReadJavaSdkDirectoryFromJdkInfoProps ()
+		static (string? JavaSdkDirectory, string? JdkJvmPath) ReadJavaSdkDirectoryFromJdkInfoProps ()
 		{
 			var location    = typeof (TestJVM).Assembly.Location;
 			var binDir      = Path.GetDirectoryName (Path.GetDirectoryName (location)) ?? Environment.CurrentDirectory;
 			var testDir     = Path.GetFileName (Path.GetDirectoryName (location));
 			if (testDir == null) {
-				return null;
+				return (null, null);
 			}
 			if (!testDir.StartsWith ("Test", StringComparison.OrdinalIgnoreCase)) {
-				return null;
+				return (null, null);
 			}
 			var buildName   = testDir.Replace ("Test", "Build");
 			if (buildName.Contains ('-')) {
 				buildName   = buildName.Substring (0, buildName.IndexOf ('-'));
 			}
 			var jdkPropFile = Path.Combine (binDir, buildName, "JdkInfo.props");
 			if (!File.Exists (jdkPropFile)) {
-				return null;
+				return (null, null);
 			}
 
 			var msbuild     = XNamespace.Get ("http://schemas.microsoft.com/developer/msbuild/2003");
@@ -108,9 +123,14 @@ static string GetOutputDirectoryName ()
 				.Elements (msbuild + "JdkJvmPath")
 				.FirstOrDefault ();
 			if (jdkJvmPath == null) {
-				return null;
+				return (null, null);
 			}
-			return jdkJvmPath.Value;
+			var jdkPath     = jdkProps.Elements ()
+				.Elements (msbuild + "PropertyGroup")
+				.Elements (msbuild + "JavaSdkDirectory")
+				.FirstOrDefault ();
+
+			return (JavaSdkDirectory: jdkPath?.Value, JdkJvmPath: jdkJvmPath.Value);
 		}
 
 		public TestJVM (string[]? jars = null, Dictionary<string, Type>? typeMappings = null)