Support Gradle annotation processing

org.eclipse.jdt.ls.core/META-INF/MANIFEST.MF

@@ -21,6 +21,7 @@ Require-Bundle: org.eclipse.core.runtime;bundle-version="3.12.0",
  org.eclipse.m2e.maven.runtime;resolution:=optional,
  org.eclipse.buildship.core;bundle-version="1.0.18";resolution:=optional,
  org.eclipse.jdt.launching,
+ org.eclipse.jdt.apt.core,
  org.eclipse.jdt.core.manipulation;bundle-version="1.8.0",
  com.google.gson;bundle-version="2.7.0",
  org.apache.commons.lang3;bundle-version="3.1.0",

org.eclipse.jdt.ls.core/build.properties

@@ -11,5 +11,6 @@ bin.includes = META-INF/,\
                gradle/checksums/versions.json,\
                gradle/protobuf/init.gradle,\
                gradle/init/init.gradle,\
-               gradle/android/init.gradle
+               gradle/android/init.gradle,\
+               gradle/apt/init.gradle
 src.includes = src/

org.eclipse.jdt.ls.core/gradle/apt/init.gradle

@@ -0,0 +1,105 @@
+/*******************************************************************************
+ * Copyright (c) 2022 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
+ *******************************************************************************/
+import org.gradle.api.Project
+import org.gradle.api.Plugin
+import org.gradle.api.file.FileCollection
+import org.gradle.api.plugins.PluginContainer
+import org.gradle.api.tasks.compile.CompileOptions
+import org.gradle.api.tasks.compile.JavaCompile
+import org.gradle.tooling.provider.model.ToolingModelBuilder
+import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry
+import org.gradle.util.GradleVersion
+
+import javax.inject.Inject
+
+class GradleAnnotationProcessorPatchPlugin implements Plugin<Project> {
+
+	private final ToolingModelBuilderRegistry registry
+
+	@Inject
+	GradleAnnotationProcessorPatchPlugin(ToolingModelBuilderRegistry registry) {
+		this.registry = registry
+	}
+
+	@Override
+	void apply(Project project) {
+		this.registry.register(new AnnotationProcessorModelBuilder())
+	}
+
+	private static class AnnotationProcessorModelBuilder implements ToolingModelBuilder {
+
+		@Override
+		boolean canBuild(String modelName) {
+			return "java.util.Map" == modelName
+		}
+
+		@Override
+		Object buildAll(String modelName, Project rootProject) {
+			final GradleVersion current = GradleVersion.current().getBaseVersion()
+			if (current < GradleVersion.version("5.2")) {
+				return Collections.emptyMap()
+			}
+
+			Set<Project> allProject = rootProject.getAllprojects()
+			Map<File, Map<String, Object>> annotationProcessorInfo = new HashMap<>()
+			for (Project project : allProject) {
+				PluginContainer plugins = project.getPlugins()
+				if (!hasPlugin(plugins, "java")) {
+					continue
+				}
+				// skip if already configured apt support plugin
+				if (hasPlugin(plugins, "com.diffplug.eclipse.apt")) {
+					continue
+				}
+
+				Set<File> processors = new HashSet<>()
+				List<String> compilerArgs = new LinkedList<>()
+				// Compiler args for test are ignored.
+				// Due to JDT does not differentiate the args between main and test.
+				collectApConfiguration(project, "compileJava", processors, compilerArgs)
+
+				if (processors.size() > 0) {
+					Map<String, Object> apInfo = new HashMap<>()
+					apInfo.put("processors", processors)
+					apInfo.put("compilerArgs", compilerArgs)
+					annotationProcessorInfo.put(project.getProjectDir(), apInfo)
+				}
+			}
+			return annotationProcessorInfo
+		}
+
+		private static boolean hasPlugin(PluginContainer plugins, String pluginId) {
+			return plugins.findPlugin(pluginId) != null
+		}
+
+		private void collectApConfiguration(project, compileTaskName, processors, compilerArgs) {
+			JavaCompile javaCompile = project.getTasks().findByName(compileTaskName)
+			if (javaCompile != null) {
+				CompileOptions options = javaCompile.getOptions()
+				if (!options.compilerArgs.contains("-proc:none")) {
+					FileCollection apPath = options.getAnnotationProcessorPath()
+					if (apPath != null) {
+						processors.addAll(apPath.getFiles())
+					}
+					compilerArgs.addAll(options.getCompilerArgs())
+				}
+			}
+		}
+	}
+}
+
+allprojects {
+	afterEvaluate {
+		it.getPlugins().apply(GradleAnnotationProcessorPatchPlugin)
+	}
+}

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

@@ -17,9 +17,11 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.Set;
 import java.util.regex.Pattern;
 
 import org.eclipse.buildship.core.BuildConfiguration;
@@ -39,6 +41,8 @@
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.debug.core.ILaunchConfiguration;
+import org.eclipse.jdt.apt.core.util.AptConfig;
+import org.eclipse.jdt.apt.core.util.IFactoryPath;
 import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jdt.core.JavaCore;
 import org.eclipse.jdt.core.JavaModelException;
@@ -66,6 +70,15 @@ public class GradleBuildSupport implements IBuildSupport {
 
 	private static IPreferencesChangeListener listener = new GradlePreferenceChangeListener();
 
+	/**
+	 * The relative path where store the sources generated by annotation processors
+	 */
+	private static final String GENERATED_SOURCES_PATH = "bin/generated-sources/annotations";
+	/**
+	 * The relative path where store the test sources generated by annotation processors
+	 */
+	private static final String GENERATED_TEST_SOURCES_PATH = "bin/generated-test-sources/annotations";
+
 	@Override
 	public boolean applies(IProject project) {
 		return ProjectUtils.isGradleProject(project);
@@ -96,8 +109,115 @@ public void update(IProject project, boolean force, IProgressMonitor monitor) th
 					|| (settingsKtsFile.exists() && JavaLanguageServerPlugin.getDigestStore().updateDigest(settingsKtsFile.toPath()));
 			if (isRoot || shouldUpdate) {
 				gradleBuild.synchronize(monitor);
+				syncAnnotationProcessingConfiguration(gradleBuild, monitor);
+			}
+		}
+	}
+
+	public static void syncAnnotationProcessingConfiguration(IProject project, IProgressMonitor monitor) {
+		Optional<GradleBuild> build = GradleCore.getWorkspace().getBuild(project);
+		if (build.isPresent()) {
+			syncAnnotationProcessingConfiguration(build.get(), monitor);
+		}
+	}
+
+	/**
+	 * Synchronize the annotation processing configurations to JDT APT.
+	 * @param gradleBuild The GradleBuild instance.
+	 * @param monitor progress monitor.
+	 */
+	@SuppressWarnings("unchecked")
+	public static void syncAnnotationProcessingConfiguration(GradleBuild gradleBuild, IProgressMonitor monitor) {
+		PreferenceManager preferencesManager = JavaLanguageServerPlugin.getPreferencesManager();
+		if (preferencesManager == null) {
+			return;
+		}
+		if (!preferencesManager.getPreferences().isGradleAnnotationProcessingEnabled()) {
+			return;
+		}
+
+		File initScript = GradleUtils.getGradleInitScript("/gradle/apt/init.gradle");
+		if (initScript == null) {
+			return;
+		}
+
+		Map<File, Map<String, Object>> model = null;
+		try {
+			model = gradleBuild.withConnection(connection -> {
+				return connection.model(Map.class).withArguments("--init-script", initScript.getAbsolutePath()).get();
+			}, monitor);
+		} catch (Exception e) {
+			JavaLanguageServerPlugin.logException(e.getMessage(), e);
+		}
+
+		if (model == null) {
+			return;
+		}
+
+		// Even reloading a sub project will get the annotation processors for all
+		// the projects, due to the Gradle custom model api's limitation.
+		for (IProject project : ProjectUtils.getGradleProjects()) {
+			Map<String, Object> apConfigurations = model.get(project.getLocation().toFile());
+			if (apConfigurations == null) {
+				continue;
+			}
+
+			Set<File> processors = getProcessors(apConfigurations);
+			if (processors.isEmpty()) {
+				continue;
+			}
+
+			IJavaProject javaProject = JavaCore.create(project);
+			if (javaProject == null) {
+				continue;
+			}
+
+			AptConfig.setGenSrcDir(javaProject, GENERATED_SOURCES_PATH);
+			AptConfig.setGenTestSrcDir(javaProject, GENERATED_TEST_SOURCES_PATH);
+
+			if (!AptConfig.isEnabled(javaProject)) {
+				// setEnabled will ensure the output folder existing on disk, that why
+				// we set enabled status after the output folder is set to APT, which can
+				// avoid generating default output folder.
+				AptConfig.setEnabled(javaProject, true);
 			}
+
+			IFactoryPath factoryPath = AptConfig.getDefaultFactoryPath(javaProject);
+			for(File processor : processors){
+				factoryPath.addExternalJar(processor);
+			}
+
+			try {
+				AptConfig.setFactoryPath(javaProject, factoryPath);
+			} catch (CoreException e) {
+				JavaLanguageServerPlugin.log(e);
+			}
+
+			List<String> compilerArgs = getCompilerArgs(apConfigurations);
+			Map<String, String> newOptions = GradleUtils.parseProcessorOptions(compilerArgs);
+			Map<String, String> currentOptions = AptConfig.getRawProcessorOptions(javaProject);
+			if(!currentOptions.equals(newOptions)) {
+				AptConfig.setProcessorOptions(newOptions, javaProject);
+			}
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	private static List<String> getCompilerArgs(Map<String, Object> apConfigurations) {
+		Object object = apConfigurations.get("compilerArgs");
+		if (!(object instanceof List)) {
+			return Collections.emptyList();
+		}
+		return (List<String>) object;
+	}
+
+	@SuppressWarnings("unchecked")
+	private static Set<File> getProcessors(Map<String, Object> apConfigurations) {
+		Object object = apConfigurations.get("processors");
+		if (!(object instanceof Set)) {
+			return Collections.emptySet();
 		}
+		return (Set<File>) object;
 	}
 
 	private boolean isRoot(IProject project, GradleBuild gradleBuild, IProgressMonitor monitor) {