Select suitable JDK to launch Gradle.

- When the Gradle Java home preference is not set, and
  the default JDK is not compatible with the project
  Gradle, try to find compatible JDK if there is one available.

Signed-off-by: Sheng Chen <sheche@microsoft.com>

Author: jdneo

org.eclipse.jdt.ls.core/src/org/eclipse/jdt/ls/core/internal/managers/GradleProjectImporter.java

@@ -199,6 +199,7 @@ public void importToWorkspace(IProgressMonitor monitor) throws CoreException {
 		if (!applies(monitor)) {
 			return;
 		}
+		inferGradleJavaHome(rootFolder.toPath(), monitor);
 		int projectSize = directories.size();
 		SubMonitor subMonitor = SubMonitor.convert(monitor, projectSize + 1);
 		subMonitor.setTaskName(IMPORTING_GRADLE_PROJECTS);
@@ -291,6 +292,49 @@ public void importToWorkspace(IProgressMonitor monitor) throws CoreException {
 		subMonitor.done();
 	}
 
+	private void inferGradleJavaHome(Path projectFolder, IProgressMonitor monitor) {
+		if (StringUtils.isNotBlank(getPreferences().getGradleJavaHome())) {
+			return;
+		}
+
+		File javaHome = getJavaHome(getPreferences());
+		String javaVersion;
+		if (javaHome == null) {
+			javaVersion = System.getProperty("java.version");
+		} else {
+			StandardVMType type = new StandardVMType();
+			javaVersion = type.readReleaseVersion(javaHome);
+		}
+		if (StringUtils.isBlank(javaVersion)) {
+			// return if failed to get java version.
+			return;
+		}
+
+		BuildConfiguration build = getBuildConfiguration(projectFolder, true);
+		GradleBuild gradleBuild = GradleCore.getWorkspace().createBuild(build);
+		String gradleVersionString = null;
+		try {
+			BuildEnvironment environment = gradleBuild.withConnection(connection -> connection.getModel(BuildEnvironment.class), monitor);
+			GradleEnvironment gradleEnvironment = environment.getGradle();
+			gradleVersionString = gradleEnvironment.getGradleVersion();
+		} catch (Exception e) {
+			// Do nothing
+		}
+		if (gradleVersionString == null) {
+			// return if failed to get gradle version.
+			return;
+		}
+
+		GradleVersion gradleVersion = GradleVersion.version(gradleVersionString);
+		if (GradleUtils.isIncompatible(gradleVersion, javaVersion)) {
+			String highestJavaVersion = GradleUtils.getHighestSupportedJava(gradleVersion);
+			File javaHomeFile = GradleUtils.getJdkToLaunchDaemon(highestJavaVersion);
+			if (javaHomeFile != null) {
+				getPreferences().setGradleJavaHome(javaHomeFile.getAbsolutePath());
+			}
+		}
+	}
+
 	private IStatus importDir(Path projectFolder, IProgressMonitor monitor) {
 		if (monitor.isCanceled()) {
 			return Status.CANCEL_STATUS;
@@ -438,11 +482,18 @@ protected IStatus startSynchronization(Path projectFolder, IProgressMonitor moni
 	}
 
 	public static BuildConfiguration getBuildConfiguration(Path rootFolder) {
+		return getBuildConfiguration(rootFolder, false);
+	}
+
+	public static BuildConfiguration getBuildConfiguration(Path rootFolder, boolean noDaemon) {
 		GradleDistribution distribution = getGradleDistribution(rootFolder);
 		Preferences preferences = getPreferences();
 		File javaHome = getJavaHome(preferences);
 		File gradleUserHome = getGradleUserHomeFile();
 		List<String> gradleArguments = new ArrayList<>();
+		if (noDaemon) {
+			gradleArguments.add("--no-daemon");
+		}
 		gradleArguments.addAll(getGradleInitScriptArgs());
 		gradleArguments.addAll(preferences.getGradleArguments());
 		List<String> gradleJvmArguments = preferences.getGradleJvmArguments();

org.eclipse.jdt.ls.core/src/org/eclipse/jdt/ls/core/internal/managers/GradleUtils.java

@@ -16,6 +16,7 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.StreamCorruptedException;
+import java.lang.Runtime.Version;
 import java.net.URL;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -28,8 +29,11 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
-import java.util.regex.Pattern;
+import java.util.Set;
+import java.util.Map.Entry;
+import java.util.stream.Stream;
 
+import org.apache.commons.lang3.StringUtils;
 import org.eclipse.buildship.core.BuildConfiguration;
 import org.eclipse.buildship.core.GradleBuild;
 import org.eclipse.buildship.core.GradleCore;
@@ -39,14 +43,21 @@
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
+import org.eclipse.jdt.internal.launching.StandardVMType;
+import org.eclipse.jdt.launching.AbstractVMInstall;
+import org.eclipse.jdt.launching.IVMInstall;
+import org.eclipse.jdt.launching.IVMInstallType;
+import org.eclipse.jdt.launching.JavaRuntime;
 import org.eclipse.jdt.ls.core.internal.JavaLanguageServerPlugin;
 import org.eclipse.jdt.ls.core.internal.ProjectUtils;
+import org.eclipse.jdt.ls.core.internal.RuntimeEnvironment;
+import org.eclipse.jdt.ls.core.internal.preferences.Preferences;
 import org.gradle.tooling.model.build.BuildEnvironment;
 import org.gradle.tooling.model.build.GradleEnvironment;
 
 public class GradleUtils {
 
-	public static String MAX_SUPPORTED_JAVA = JavaCore.VERSION_17;
 	// see https://github.com/gradle/gradle/pull/17397
 	public static String INVALID_TYPE_FIXED_VERSION = "7.2";
 	// see https://github.com/gradle/gradle/issues/890
@@ -55,11 +66,6 @@ public class GradleUtils {
 
 	private static final String MESSAGE_DIGEST_ALGORITHM = "SHA-256";
 
-	/**
-	 * A pattern to parse annotation processing arguments.
-	 */
-	private static final Pattern OPTION_PATTERN = Pattern.compile("-A([^ \\t\"']+)");
-
 	public static boolean isIncompatible(GradleVersion gradleVersion, String javaVersion) {
 		if (gradleVersion == null || javaVersion == null || javaVersion.isEmpty()) {
 			return false;
@@ -72,7 +78,13 @@ public static String getHighestSupportedJava(GradleVersion gradleVersion) {
 		GradleVersion baseVersion = gradleVersion.getBaseVersion();
 		try {
 			// https://docs.gradle.org/current/userguide/compatibility.html
-			if (baseVersion.compareTo(GradleVersion.version("7.3")) >= 0) {
+			if (baseVersion.compareTo(GradleVersion.version("8.3")) >= 0) {
+				return JavaCore.VERSION_20;
+			} else if (baseVersion.compareTo(GradleVersion.version("7.6")) >= 0) {
+				return JavaCore.VERSION_19;
+			} else if (baseVersion.compareTo(GradleVersion.version("7.5")) >= 0) {
+				return JavaCore.VERSION_18;
+			} else if (baseVersion.compareTo(GradleVersion.version("7.3")) >= 0) {
 				return JavaCore.VERSION_17;
 			} else if (baseVersion.compareTo(GradleVersion.version("7.0")) >= 0) {
 				return JavaCore.VERSION_16;
@@ -91,10 +103,10 @@ public static String getHighestSupportedJava(GradleVersion gradleVersion) {
 			} else if (baseVersion.compareTo(GradleVersion.version("4.3")) >= 0) {
 				return JavaCore.VERSION_9;
 			}
-			return JavaCore.VERSION_1_8;
 		} catch (IllegalArgumentException e) {
-			return MAX_SUPPORTED_JAVA;
+			// ignore
 		}
+		return JavaCore.VERSION_1_8;
 	}
 
 	public static boolean hasGradleInvalidTypeCodeException(IStatus status, Path projectFolder, IProgressMonitor monitor) {
@@ -293,4 +305,75 @@ public static void synchronizeAnnotationProcessingConfiguration(IProgressMonitor
 			}
 		}
 	}
+
+	/**
+	 * Find the latest JDK but equal or lower than the {@code highestJavaVersion}.
+	 */
+	public static File getJdkToLaunchDaemon(String highestJavaVersion) {
+		if (StringUtils.isBlank(highestJavaVersion)) {
+			return null;
+		}
+
+		Map<String, File> jdks = getAllVmInstalls();;
+		Entry<String, File> selected = null;
+		for (Entry<String, File> jdk : jdks.entrySet()) {
+			String javaVersion = jdk.getKey();
+			if (Version.parse(javaVersion).compareTo(Version.parse(highestJavaVersion)) <= 0
+					&& (selected == null || Version.parse(selected.getKey()).compareTo(Version.parse(javaVersion)) < 0)) {
+				selected = jdk;
+			}
+		}
+
+		return selected == null ? null : selected.getValue();
+	}
+
+	/**
+	 * Get all the available JDK installations in the Eclipse VM registry. If multiple installations
+	 * are found for the same major version, the first found one is return.
+	 *
+	 * The results are returned as map, where key is the major version and value is the file instance of
+	 * the installation.
+	 */
+	private static Map<String, File> getAllVmInstalls() {
+		List<IVMInstall> vmList = Stream.of(JavaRuntime.getVMInstallTypes())
+						.map(IVMInstallType::getVMInstalls)
+						.flatMap(Arrays::stream)
+						.toList();
+		Map<String, File> vmInstalls = new HashMap<>();
+		for (IVMInstall vmInstall : vmList) {
+			if (vmInstall instanceof AbstractVMInstall vm) {
+				String javaVersion = getMajorJavaVersion(vm.getJavaVersion());
+				if (StringUtils.isBlank(javaVersion) || vm.getInstallLocation() == null) {
+					continue;
+				}
+
+				vmInstalls.putIfAbsent(javaVersion, vm.getInstallLocation());
+			}
+		}
+
+		Preferences preferences = JavaLanguageServerPlugin.getPreferencesManager().getPreferences();
+		Set<RuntimeEnvironment> runtimes = preferences.getRuntimes();
+		for (RuntimeEnvironment runtime : runtimes) {
+			if (StringUtils.isBlank(runtime.getPath())) {
+				continue;
+			}
+			File javaHome = new File(runtime.getPath());
+			if (vmInstalls.containsValue(javaHome)) {
+				continue;
+			}
+
+			String javaVersion = new StandardVMType().readReleaseVersion(javaHome);
+			if (StringUtils.isNotBlank(javaVersion)) {
+				// the user preference should have higher priority and replace
+				// the existing one if the major version is the same.
+				vmInstalls.put(getMajorJavaVersion(javaVersion), javaHome);
+			}
+		}
+
+		return vmInstalls;
+	}
+
+	public static String getMajorJavaVersion(String version) {
+		return CompilerOptions.versionFromJdkLevel(CompilerOptions.versionToJdkLevel(version));
+	}
 }

org.eclipse.jdt.ls.tests/src/org/eclipse/jdt/ls/core/internal/managers/GradleUtilsTest.java

@@ -0,0 +1,34 @@
+/*******************************************************************************
+ * Copyright (c) 2023 Microsoft Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     Microsoft Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.ls.core.internal.managers;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.io.File;
+
+import org.junit.Test;
+
+public class GradleUtilsTest {
+	@Test
+	public void testGetJdkToLaunchDaemon() {
+		assertEquals("17", GradleUtils.getMajorJavaVersion("17.0.8"));
+		assertEquals("1.8", GradleUtils.getMajorJavaVersion("1.8.0_202"));
+	}
+
+	@Test
+	public void testGetMajorJavaVersion() {
+		File javaHome = GradleUtils.getJdkToLaunchDaemon("10");
+		assertTrue(javaHome.getAbsolutePath().contains("fakejdk" + File.separator + "10"));
+	}
+}