Move compile config to a Gradle convention

This commit moves the compile configuration from the Gradle DSL to a
convention. This configuration is not changing often, and we're using
that opportunity to make the Java source compatibility a project
property so as to easily recent JDKs this on the command line.

See gh-23282

build.gradle

@@ -64,6 +64,7 @@ configure(allprojects) { project ->
 	apply plugin: "java"
 	apply plugin: "kotlin"
 	apply plugin: "checkstyle"
+	apply plugin: 'org.springframework.build.compile'
 	apply plugin: 'org.springframework.build.optional-dependencies'
 	apply plugin: 'org.springframework.build.test-sources'
 	apply plugin: "io.spring.dependency-management"
@@ -96,32 +97,6 @@ configure(allprojects) { project ->
 		}
 	}
 
-	def commonCompilerArgs =
-			["-Xlint:serial", "-Xlint:cast", "-Xlint:classfile", "-Xlint:dep-ann",
-			 "-Xlint:divzero", "-Xlint:empty", "-Xlint:finally", "-Xlint:overrides",
-			 "-Xlint:path", "-Xlint:processing", "-Xlint:static", "-Xlint:try", "-Xlint:-options"]
-
-	compileJava.options*.compilerArgs = commonCompilerArgs +
-			["-Xlint:varargs", "-Xlint:fallthrough", "-Xlint:rawtypes",
-			 "-Xlint:deprecation", "-Xlint:unchecked", "-Werror"]
-
-	compileTestJava.options*.compilerArgs = commonCompilerArgs +
-			["-Xlint:-varargs", "-Xlint:-fallthrough", "-Xlint:-rawtypes",
-			 "-Xlint:-deprecation", "-Xlint:-unchecked"]
-
-	compileJava {
-		sourceCompatibility = 1.8  // can be switched to 11 for testing
-		targetCompatibility = 1.8
-		options.encoding = "UTF-8"
-	}
-
-	compileTestJava {
-		sourceCompatibility = 1.8  // can be switched to 11 for testing
-		targetCompatibility = 1.8
-		options.encoding = "UTF-8"
-		options.compilerArgs += "-parameters"
-	}
-
 	compileKotlin {
 		kotlinOptions {
 			jvmTarget = "1.8"

buildSrc/README.md

@@ -0,0 +1,32 @@
+# Spring Framework build
+
+This folder contains the custom plugins and conventions for the Spring Framework build.
+They are declared in the `build.gradle` file in this folder.
+
+## Build Conventions
+
+### Compiler conventions
+
+The `org.springframework.build.compile` applies the Java compiler conventions to the build.
+By default, the build is compiling sources with the `1.8` source and target compatibility.
+You can test a different source compatibility version on the CLI with a project property like:
+
+```
+./gradlew test -PjavaSourceVersion=11
+```
+
+## Build Plugins
+
+## Optional dependencies
+
+The `org.springframework.build.optional-dependencies` plugin creates a new `optional`
+Gradle configuration - it adds the dependencies to the project's compile and runtime classpath
+but doesn't affect the classpath of dependent projects.
+This plugin does not provide a `provided` configuration, as the native `compileOnly` and `testCompileOnly`
+configurations are preferred.
+
+## Test sources
+
+The `org.springframework.build.test-sources` updates `testCompile` dependencies to include
+the test source sets of `project()` dependencies. This plugin is used in the Spring Framework build 
+to share test utilities and fixtures amongst modules.

buildSrc/build.gradle

@@ -13,6 +13,10 @@ dependencies {
 
 gradlePlugin {
 	plugins {
+		compileConventionsPlugin {
+			id = "org.springframework.build.compile"
+			implementationClass = "org.springframework.build.compile.CompilerConventionsPlugin"
+		}
 		optionalDependenciesPlugin {
 			id = "org.springframework.build.optional-dependencies"
 			implementationClass = "org.springframework.build.optional.OptionalDependenciesPlugin"

buildSrc/src/main/java/org/springframework/build/compile/CompilerConventionsPlugin.java

@@ -0,0 +1,103 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.build.compile;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.gradle.api.JavaVersion;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.plugins.JavaPlugin;
+import org.gradle.api.plugins.JavaPluginConvention;
+import org.gradle.api.tasks.compile.JavaCompile;
+
+/**
+ * {@link Plugin} that applies conventions for compiling Java sources in Spring Framework.
+ * <p>One can override the default Java source compatibility version
+ * with a dedicated property on the CLI: {@code "./gradlew test -PjavaSourceVersion=11"}.
+ *
+ * @author Brian Clozel
+ */
+public class CompilerConventionsPlugin implements Plugin<Project> {
+
+	/**
+	 * The project property that can be used to switch the Java source
+	 * compatibility version for building source and test classes.
+	 */
+	public static String JAVA_SOURCE_VERSION_PROPERTY = "javaSourceVersion";
+
+	public static JavaVersion DEFAULT_COMPILER_VERSION = JavaVersion.VERSION_1_8;
+
+	private static List<String> COMPILER_ARGS;
+
+	private static List<String> TEST_COMPILER_ARGS;
+
+	static {
+		List<String> commonCompilerArgs = Arrays.asList(
+				"-Xlint:serial", "-Xlint:cast", "-Xlint:classfile", "-Xlint:dep-ann",
+				"-Xlint:divzero", "-Xlint:empty", "-Xlint:finally", "-Xlint:overrides",
+				"-Xlint:path", "-Xlint:processing", "-Xlint:static", "-Xlint:try", "-Xlint:-options"
+		);
+		COMPILER_ARGS = new ArrayList<>();
+		COMPILER_ARGS.addAll(commonCompilerArgs);
+		COMPILER_ARGS.addAll(Arrays.asList(
+				"-Xlint:serial", "-Xlint:cast", "-Xlint:classfile", "-Xlint:dep-ann",
+				"-Xlint:divzero", "-Xlint:empty", "-Xlint:finally", "-Xlint:overrides",
+				"-Xlint:path", "-Xlint:processing", "-Xlint:static", "-Xlint:try", "-Xlint:-options"
+		));
+		TEST_COMPILER_ARGS = new ArrayList<>();
+		TEST_COMPILER_ARGS.addAll(commonCompilerArgs);
+		TEST_COMPILER_ARGS.addAll(Arrays.asList("-Xlint:-varargs", "-Xlint:-fallthrough", "-Xlint:-rawtypes",
+				"-Xlint:-deprecation", "-Xlint:-unchecked", "-parameters"));
+	}
+
+	@Override
+	public void apply(Project project) {
+		project.getPlugins().withType(JavaPlugin.class, javaPlugin -> applyJavaCompileConventions(project));
+	}
+
+	/**
+	 * Applies the common Java compiler options for sources and test sources.
+	 * @param project the current project
+	 */
+	private void applyJavaCompileConventions(Project project) {
+		JavaPluginConvention java = project.getConvention().getPlugin(JavaPluginConvention.class);
+		if (project.hasProperty(JAVA_SOURCE_VERSION_PROPERTY)) {
+			JavaVersion javaSourceVersion = JavaVersion.toVersion(project.property(JAVA_SOURCE_VERSION_PROPERTY));
+			java.setSourceCompatibility(javaSourceVersion);
+		}
+		else {
+			java.setSourceCompatibility(DEFAULT_COMPILER_VERSION);
+		}
+		java.setTargetCompatibility(DEFAULT_COMPILER_VERSION);
+
+		project.getTasks().withType(JavaCompile.class)
+				.matching(javaCompile -> javaCompile.getName().equals(JavaPlugin.COMPILE_JAVA_TASK_NAME))
+				.forEach(compileTask -> {
+					compileTask.getOptions().setCompilerArgs(COMPILER_ARGS);
+					compileTask.getOptions().setEncoding("UTF-8");
+				});
+		project.getTasks().withType(JavaCompile.class)
+				.matching(javaCompile -> javaCompile.getName().equals(JavaPlugin.COMPILE_TEST_JAVA_TASK_NAME))
+				.forEach(compileTask -> {
+					compileTask.getOptions().setCompilerArgs(TEST_COMPILER_ARGS);
+					compileTask.getOptions().setEncoding("UTF-8");
+				});
+	}
+}

buildSrc/src/main/java/org/springframework/build/testsources/TestSourcesPlugin.java

@@ -47,6 +47,7 @@ public class TestSourcesPlugin implements Plugin<Project> {
 	/**
 	 * List of configurations this plugin should look for project dependencies in.
 	 */
+	@SuppressWarnings("deprecation")
 	private static final List<String> CONFIGURATIONS = Arrays.asList(
 			JavaPlugin.COMPILE_CONFIGURATION_NAME,
 			JavaPlugin.API_CONFIGURATION_NAME,