From 5539ea66e84ed50c4d590b680e7e4e4871b7d4f1d7f0b107081da376e2ebfc56 Mon Sep 17 00:00:00 2001 From: Fridrich Strba Date: Mon, 1 Apr 2019 09:28:24 +0000 Subject: [PATCH] OBS-URL: https://build.opensuse.org/package/show/Java:packages/maven-compiler-plugin?expand=0&rev=1 --- .gitattributes | 23 + .gitignore | 1 + ...n-compiler-plugin-3.8.0-source-release.zip | 3 + ...-compiler-plugin-bootstrap-resources.patch | 2123 +++++++++++++++++ maven-compiler-plugin-build.xml | 252 ++ maven-compiler-plugin.spec | 121 + 6 files changed, 2523 insertions(+) create mode 100644 .gitattributes create mode 100644 .gitignore create mode 100644 maven-compiler-plugin-3.8.0-source-release.zip create mode 100644 maven-compiler-plugin-bootstrap-resources.patch create mode 100644 maven-compiler-plugin-build.xml create mode 100644 maven-compiler-plugin.spec diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..9b03811 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,23 @@ +## Default LFS +*.7z filter=lfs diff=lfs merge=lfs -text +*.bsp filter=lfs diff=lfs merge=lfs -text +*.bz2 filter=lfs diff=lfs merge=lfs -text +*.gem filter=lfs diff=lfs merge=lfs -text +*.gz filter=lfs diff=lfs merge=lfs -text +*.jar filter=lfs diff=lfs merge=lfs -text +*.lz filter=lfs diff=lfs merge=lfs -text +*.lzma filter=lfs diff=lfs merge=lfs -text +*.obscpio filter=lfs diff=lfs merge=lfs -text +*.oxt filter=lfs diff=lfs merge=lfs -text +*.pdf filter=lfs diff=lfs merge=lfs -text +*.png filter=lfs diff=lfs merge=lfs -text +*.rpm filter=lfs diff=lfs merge=lfs -text +*.tbz filter=lfs diff=lfs merge=lfs -text +*.tbz2 filter=lfs diff=lfs merge=lfs -text +*.tgz filter=lfs diff=lfs merge=lfs -text +*.ttf filter=lfs diff=lfs merge=lfs -text +*.txz filter=lfs diff=lfs merge=lfs -text +*.whl filter=lfs diff=lfs merge=lfs -text +*.xz filter=lfs diff=lfs merge=lfs -text +*.zip filter=lfs diff=lfs merge=lfs -text +*.zst filter=lfs diff=lfs merge=lfs -text diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..57affb6 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.osc diff --git a/maven-compiler-plugin-3.8.0-source-release.zip b/maven-compiler-plugin-3.8.0-source-release.zip new file mode 100644 index 0000000..3ee4485 --- /dev/null +++ b/maven-compiler-plugin-3.8.0-source-release.zip @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1035961b4d8119bfa56e04b009425e008f37e12017482fb473be4ff916b982c2 +size 569602 diff --git a/maven-compiler-plugin-bootstrap-resources.patch b/maven-compiler-plugin-bootstrap-resources.patch new file mode 100644 index 0000000..56dc03b --- /dev/null +++ b/maven-compiler-plugin-bootstrap-resources.patch @@ -0,0 +1,2123 @@ +--- maven-compiler-plugin-3.8.0/src/main/filtered-resources/META-INF/maven/org.apache.maven.plugins/maven-compiler-plugin/plugin-help.xml 1970-01-01 01:00:00.000000000 +0100 ++++ maven-compiler-plugin-3.8.0/src/main/filtered-resources/META-INF/maven/org.apache.maven.plugins/maven-compiler-plugin/plugin-help.xml 2019-04-01 10:49:48.537467091 +0200 +@@ -0,0 +1,720 @@ ++ ++ ++ ${project.name} ++ ${project.description} ++ ${project.groupId} ++ ${project.artifactId} ++ ${project.version} ++ compiler ++ ++ ++ compile ++ Compiles application sources ++ compile ++ false ++ true ++ false ++ false ++ false ++ true ++ compile ++ org.apache.maven.plugin.compiler.CompilerMojo ++ java ++ per-lookup ++ once-per-session ++ 2.0 ++ true ++ ++ ++ annotationProcessorPaths ++ java.util.List ++ 3.5 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ annotationProcessors ++ java.lang.String[] ++ 2.2 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ compilerArgs ++ java.util.List ++ 3.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ compilerArgument ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ compilerArguments ++ java.util.Map ++ 2.0.1 ++ use {@link #compilerArgs} instead. ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ compilerId ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ compilerReuseStrategy ++ java.lang.String ++ 2.5 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ compilerVersion ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ debug ++ boolean ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ debuglevel ++ java.lang.String ++ 2.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ encoding ++ java.lang.String ++ 2.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ excludes ++ java.util.Set ++ false ++ true ++ Compiles application sources ++ ++ ++ executable ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ failOnError ++ boolean ++ 2.0.2 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ failOnWarning ++ boolean ++ 3.6 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ fileExtensions ++ java.util.List ++ 3.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ forceJavacCompilerUse ++ boolean ++ 3.0 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ fork ++ boolean ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ generatedSourcesDirectory ++ java.io.File ++ 2.2 ++ false ++ true ++ Compiles application sources ++ ++ ++ includes ++ java.util.Set ++ false ++ true ++ Compiles application sources ++ ++ ++ jdkToolchain ++ java.util.Map ++ 3.6 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ maxmem ++ java.lang.String ++ 2.0.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ meminitial ++ java.lang.String ++ 2.0.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ multiReleaseOutput ++ boolean ++ 3.7.1 ++ false ++ true ++ Compiles application sources ++ ++ ++ optimize ++ boolean ++ This property is a no-op in {@code javac}. ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ outputFileName ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ parameters ++ boolean ++ 3.6.2 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ proc ++ java.lang.String ++ 2.2 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ release ++ java.lang.String ++ 3.6 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ showDeprecation ++ boolean ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ showWarnings ++ boolean ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ skipMain ++ boolean ++ false ++ true ++ Compiles application sources ++ ++ ++ skipMultiThreadWarning ++ boolean ++ 2.5 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ source ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ staleMillis ++ int ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ target ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ useIncrementalCompilation ++ boolean ++ 3.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ verbose ++ boolean ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ ++ ${maven.compiler.compilerId} ++ ${maven.compiler.compilerReuseStrategy} ++ ${maven.compiler.compilerVersion} ++ ${maven.compiler.debug} ++ ${maven.compiler.debuglevel} ++ ${encoding} ++ ${maven.compiler.executable} ++ ${maven.compiler.failOnError} ++ ${maven.compiler.failOnWarning} ++ ${maven.compiler.forceJavacCompilerUse} ++ ${maven.compiler.fork} ++ ++ ${maven.compiler.maxmem} ++ ${maven.compiler.meminitial} ++ ${maven.compiler.optimize} ++ ${maven.compiler.parameters} ++ ${maven.compiler.release} ++ ${maven.compiler.showDeprecation} ++ ${maven.compiler.showWarnings} ++ ${maven.main.skip} ++ ${maven.compiler.skipMultiThreadWarning} ++ ${maven.compiler.source} ++ ${lastModGranularityMs} ++ ${maven.compiler.target} ++ ${maven.compiler.useIncrementalCompilation} ++ ${maven.compiler.verbose} ++ ++ ++ ++ testCompile ++ Compiles application test sources. ++ test ++ false ++ true ++ false ++ false ++ false ++ true ++ test-compile ++ org.apache.maven.plugin.compiler.TestCompilerMojo ++ java ++ per-lookup ++ once-per-session ++ 2.0 ++ true ++ ++ ++ annotationProcessorPaths ++ java.util.List ++ 3.5 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ annotationProcessors ++ java.lang.String[] ++ 2.2 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ compilerArgs ++ java.util.List ++ 3.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ compilerArgument ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ compilerArguments ++ java.util.Map ++ 2.0.1 ++ use {@link #compilerArgs} instead. ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ compilerId ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ compilerReuseStrategy ++ java.lang.String ++ 2.5 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ compilerVersion ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ debug ++ boolean ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ debuglevel ++ java.lang.String ++ 2.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ encoding ++ java.lang.String ++ 2.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ executable ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ failOnError ++ boolean ++ 2.0.2 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ failOnWarning ++ boolean ++ 3.6 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ fileExtensions ++ java.util.List ++ 3.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ forceJavacCompilerUse ++ boolean ++ 3.0 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ fork ++ boolean ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ generatedTestSourcesDirectory ++ java.io.File ++ 2.2 ++ false ++ true ++ Compiles application test sources. ++ ++ ++ jdkToolchain ++ java.util.Map ++ 3.6 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ maxmem ++ java.lang.String ++ 2.0.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ meminitial ++ java.lang.String ++ 2.0.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ optimize ++ boolean ++ This property is a no-op in {@code javac}. ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ outputFileName ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ parameters ++ boolean ++ 3.6.2 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ proc ++ java.lang.String ++ 2.2 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ release ++ java.lang.String ++ 3.6 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ showDeprecation ++ boolean ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ showWarnings ++ boolean ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ skip ++ boolean ++ false ++ true ++ Compiles application test sources. ++ ++ ++ skipMultiThreadWarning ++ boolean ++ 2.5 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ source ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ staleMillis ++ int ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ target ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ testCompilerArgument ++ java.lang.String ++ 2.1 ++ false ++ true ++ Compiles application test sources. ++ ++ ++ testCompilerArguments ++ java.util.Map ++ 2.1 ++ false ++ true ++ Compiles application test sources. ++ ++ ++ testExcludes ++ java.util.Set ++ false ++ true ++ Compiles application test sources. ++ ++ ++ testIncludes ++ java.util.Set ++ false ++ true ++ Compiles application test sources. ++ ++ ++ testRelease ++ java.lang.String ++ 3.6 ++ false ++ true ++ Compiles application test sources. ++ ++ ++ testSource ++ java.lang.String ++ 2.1 ++ false ++ true ++ Compiles application test sources. ++ ++ ++ testTarget ++ java.lang.String ++ 2.1 ++ false ++ true ++ Compiles application test sources. ++ ++ ++ useIncrementalCompilation ++ boolean ++ 3.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ verbose ++ boolean ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two scans of all the source code if the compiler has to have the entire set of sources. This is currently the case for at least the C# compiler and most likely all the other .NET compilers too. ++ ++ ++ ++ ${maven.compiler.compilerId} ++ ${maven.compiler.compilerReuseStrategy} ++ ${maven.compiler.compilerVersion} ++ ${maven.compiler.debug} ++ ${maven.compiler.debuglevel} ++ ${encoding} ++ ${maven.compiler.executable} ++ ${maven.compiler.failOnError} ++ ${maven.compiler.failOnWarning} ++ ${maven.compiler.forceJavacCompilerUse} ++ ${maven.compiler.fork} ++ ++ ${maven.compiler.maxmem} ++ ${maven.compiler.meminitial} ++ ${maven.compiler.optimize} ++ ${maven.compiler.parameters} ++ ${maven.compiler.release} ++ ${maven.compiler.showDeprecation} ++ ${maven.compiler.showWarnings} ++ ${maven.test.skip} ++ ${maven.compiler.skipMultiThreadWarning} ++ ${maven.compiler.source} ++ ${lastModGranularityMs} ++ ${maven.compiler.target} ++ ${maven.compiler.testRelease} ++ ${maven.compiler.testSource} ++ ${maven.compiler.testTarget} ++ ${maven.compiler.useIncrementalCompilation} ++ ${maven.compiler.verbose} ++ ++ ++ ++ +diff -urEbwBN maven-compiler-plugin-3.8.0.orig/src/main/filtered-resources/META-INF/maven/plugin.xml maven-compiler-plugin-3.8.0/src/main/filtered-resources/META-INF/maven/plugin.xml +--- maven-compiler-plugin-3.8.0/src/main/filtered-resources/META-INF/maven/plugin.xml 1970-01-01 01:00:00.000000000 +0100 ++++ maven-compiler-plugin-3.8.0/src/main/filtered-resources/META-INF/maven/plugin.xml 2019-04-01 10:52:00.226118248 +0200 +@@ -0,0 +1,1396 @@ ++ ++ ++ ${project.name} ++ ${project.description} ++ ${project.groupId} ++ ${project.artifactId} ++ ${project.version} ++ compiler ++ false ++ true ++ ++ ++ compile ++ Compiles application sources ++ compile ++ false ++ true ++ false ++ false ++ false ++ true ++ compile ++ org.apache.maven.plugin.compiler.CompilerMojo ++ java ++ per-lookup ++ once-per-session ++ 2.0 ++ true ++ ++ ++ annotationProcessorPaths ++ java.util.List ++ 3.5 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ annotationProcessors ++ java.lang.String[] ++ 2.2 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ basedir ++ java.io.File ++ true ++ false ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ buildDirectory ++ java.io.File ++ true ++ false ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ compilePath ++ java.util.List ++ true ++ false ++ Compiles application sources ++ ++ ++ compileSourceRoots ++ java.util.List ++ true ++ false ++ Compiles application sources ++ ++ ++ compilerArgs ++ java.util.List ++ 3.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ compilerArgument ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ compilerArguments ++ java.util.Map ++ 2.0.1 ++ use {@link #compilerArgs} instead. ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ compilerId ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ compilerReuseStrategy ++ java.lang.String ++ 2.5 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ compilerVersion ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ debug ++ boolean ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ debuglevel ++ java.lang.String ++ 2.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ encoding ++ java.lang.String ++ 2.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ excludes ++ java.util.Set ++ false ++ true ++ Compiles application sources ++ ++ ++ executable ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ failOnError ++ boolean ++ 2.0.2 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ failOnWarning ++ boolean ++ 3.6 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ fileExtensions ++ java.util.List ++ 3.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ forceJavacCompilerUse ++ boolean ++ 3.0 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ fork ++ boolean ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ generatedSourcesDirectory ++ java.io.File ++ 2.2 ++ false ++ true ++ Compiles application sources ++ ++ ++ includes ++ java.util.Set ++ false ++ true ++ Compiles application sources ++ ++ ++ jdkToolchain ++ java.util.Map ++ 3.6 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ maxmem ++ java.lang.String ++ 2.0.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ meminitial ++ java.lang.String ++ 2.0.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ mojoExecution ++ org.apache.maven.plugin.MojoExecution ++ 3.0 needed for storing the status for the incremental build support. ++ true ++ false ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ multiReleaseOutput ++ boolean ++ 3.7.1 ++ false ++ true ++ Compiles application sources ++ ++ ++ optimize ++ boolean ++ This property is a no-op in {@code javac}. ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ outputDirectory ++ java.io.File ++ true ++ false ++ Compiles application sources ++ ++ ++ outputFileName ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ parameters ++ boolean ++ 3.6.2 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ proc ++ java.lang.String ++ 2.2 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ project ++ org.apache.maven.project.MavenProject ++ true ++ false ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ projectArtifact ++ org.apache.maven.artifact.Artifact ++ true ++ false ++ Compiles application sources ++ ++ ++ release ++ java.lang.String ++ 3.6 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ session ++ org.apache.maven.execution.MavenSession ++ true ++ false ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ showDeprecation ++ boolean ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ showWarnings ++ boolean ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ skipMain ++ boolean ++ false ++ true ++ Compiles application sources ++ ++ ++ skipMultiThreadWarning ++ boolean ++ 2.5 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ source ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ staleMillis ++ int ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ target ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ useIncrementalCompilation ++ boolean ++ 3.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ verbose ++ boolean ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ ++ ++ ++ ++ ++ ${maven.compiler.compilerId} ++ ${maven.compiler.compilerReuseStrategy} ++ ${maven.compiler.compilerVersion} ++ ${maven.compiler.debug} ++ ${maven.compiler.debuglevel} ++ ${encoding} ++ ${maven.compiler.executable} ++ ${maven.compiler.failOnError} ++ ${maven.compiler.failOnWarning} ++ ${maven.compiler.forceJavacCompilerUse} ++ ${maven.compiler.fork} ++ ++ ${maven.compiler.maxmem} ++ ${maven.compiler.meminitial} ++ ++ ${maven.compiler.optimize} ++ ++ ${maven.compiler.parameters} ++ ++ ++ ${maven.compiler.release} ++ ++ ${maven.compiler.showDeprecation} ++ ${maven.compiler.showWarnings} ++ ${maven.main.skip} ++ ${maven.compiler.skipMultiThreadWarning} ++ ${maven.compiler.source} ++ ${lastModGranularityMs} ++ ${maven.compiler.target} ++ ${maven.compiler.useIncrementalCompilation} ++ ${maven.compiler.verbose} ++ ++ ++ ++ org.apache.maven.artifact.handler.manager.ArtifactHandlerManager ++ artifactHandlerManager ++ ++ ++ org.codehaus.plexus.compiler.manager.CompilerManager ++ compilerManager ++ ++ ++ org.codehaus.plexus.languages.java.jpms.LocationManager ++ locationManager ++ ++ ++ org.apache.maven.repository.RepositorySystem ++ repositorySystem ++ ++ ++ org.apache.maven.artifact.resolver.ResolutionErrorHandler ++ resolutionErrorHandler ++ ++ ++ org.apache.maven.toolchain.ToolchainManager ++ toolchainManager ++ ++ ++ ++ ++ testCompile ++ Compiles application test sources. ++ test ++ false ++ true ++ false ++ false ++ false ++ true ++ test-compile ++ org.apache.maven.plugin.compiler.TestCompilerMojo ++ java ++ per-lookup ++ once-per-session ++ 2.0 ++ true ++ ++ ++ annotationProcessorPaths ++ java.util.List ++ 3.5 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ annotationProcessors ++ java.lang.String[] ++ 2.2 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ basedir ++ java.io.File ++ true ++ false ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ buildDirectory ++ java.io.File ++ true ++ false ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ compilePath ++ java.util.List ++ false ++ false ++ Compiles application test sources. ++ ++ ++ compileSourceRoots ++ java.util.List ++ true ++ false ++ Compiles application test sources. ++ ++ ++ compilerArgs ++ java.util.List ++ 3.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ compilerArgument ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ compilerArguments ++ java.util.Map ++ 2.0.1 ++ use {@link #compilerArgs} instead. ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ compilerId ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ compilerReuseStrategy ++ java.lang.String ++ 2.5 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ compilerVersion ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ debug ++ boolean ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ debuglevel ++ java.lang.String ++ 2.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ encoding ++ java.lang.String ++ 2.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ executable ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ failOnError ++ boolean ++ 2.0.2 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ failOnWarning ++ boolean ++ 3.6 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ fileExtensions ++ java.util.List ++ 3.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ forceJavacCompilerUse ++ boolean ++ 3.0 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ fork ++ boolean ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ generatedTestSourcesDirectory ++ java.io.File ++ 2.2 ++ false ++ true ++ Compiles application test sources. ++ ++ ++ jdkToolchain ++ java.util.Map ++ 3.6 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ maxmem ++ java.lang.String ++ 2.0.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ meminitial ++ java.lang.String ++ 2.0.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ mojoExecution ++ org.apache.maven.plugin.MojoExecution ++ 3.0 needed for storing the status for the incremental build support. ++ true ++ false ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ optimize ++ boolean ++ This property is a no-op in {@code javac}. ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ outputDirectory ++ java.io.File ++ true ++ false ++ Compiles application test sources. ++ ++ ++ outputFileName ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ parameters ++ boolean ++ 3.6.2 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ proc ++ java.lang.String ++ 2.2 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ project ++ org.apache.maven.project.MavenProject ++ true ++ false ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ release ++ java.lang.String ++ 3.6 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ session ++ org.apache.maven.execution.MavenSession ++ true ++ false ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ showDeprecation ++ boolean ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ showWarnings ++ boolean ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ skip ++ boolean ++ false ++ true ++ Compiles application test sources. ++ ++ ++ skipMultiThreadWarning ++ boolean ++ 2.5 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ source ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ staleMillis ++ int ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ target ++ java.lang.String ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ testCompilerArgument ++ java.lang.String ++ 2.1 ++ false ++ true ++ Compiles application test sources. ++ ++ ++ testCompilerArguments ++ java.util.Map ++ 2.1 ++ false ++ true ++ Compiles application test sources. ++ ++ ++ testExcludes ++ java.util.Set ++ false ++ true ++ Compiles application test sources. ++ ++ ++ testIncludes ++ java.util.Set ++ false ++ true ++ Compiles application test sources. ++ ++ ++ testPath ++ java.util.List ++ false ++ false ++ Compiles application test sources. ++ ++ ++ testRelease ++ java.lang.String ++ 3.6 ++ false ++ true ++ Compiles application test sources. ++ ++ ++ testSource ++ java.lang.String ++ 2.1 ++ false ++ true ++ Compiles application test sources. ++ ++ ++ testTarget ++ java.lang.String ++ 2.1 ++ false ++ true ++ Compiles application test sources. ++ ++ ++ useIncrementalCompilation ++ boolean ++ 3.1 ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ verbose ++ boolean ++ false ++ true ++ TODO: At least one step could be optimized, currently the plugin will do two ++scans of all the source code if the compiler has to have the entire set of ++sources. This is currently the case for at least the C# compiler and most ++likely all the other .NET compilers too. ++ ++ ++ ++ ++ ++ ++ ++ ${maven.compiler.compilerId} ++ ${maven.compiler.compilerReuseStrategy} ++ ${maven.compiler.compilerVersion} ++ ${maven.compiler.debug} ++ ${maven.compiler.debuglevel} ++ ${encoding} ++ ${maven.compiler.executable} ++ ${maven.compiler.failOnError} ++ ${maven.compiler.failOnWarning} ++ ${maven.compiler.forceJavacCompilerUse} ++ ${maven.compiler.fork} ++ ++ ${maven.compiler.maxmem} ++ ${maven.compiler.meminitial} ++ ++ ${maven.compiler.optimize} ++ ++ ${maven.compiler.parameters} ++ ++ ${maven.compiler.release} ++ ++ ${maven.compiler.showDeprecation} ++ ${maven.compiler.showWarnings} ++ ${maven.test.skip} ++ ${maven.compiler.skipMultiThreadWarning} ++ ${maven.compiler.source} ++ ${lastModGranularityMs} ++ ${maven.compiler.target} ++ ++ ${maven.compiler.testRelease} ++ ${maven.compiler.testSource} ++ ${maven.compiler.testTarget} ++ ${maven.compiler.useIncrementalCompilation} ++ ${maven.compiler.verbose} ++ ++ ++ ++ org.apache.maven.artifact.handler.manager.ArtifactHandlerManager ++ artifactHandlerManager ++ ++ ++ org.codehaus.plexus.compiler.manager.CompilerManager ++ compilerManager ++ ++ ++ org.codehaus.plexus.languages.java.jpms.LocationManager ++ locationManager ++ ++ ++ org.apache.maven.repository.RepositorySystem ++ repositorySystem ++ ++ ++ org.apache.maven.artifact.resolver.ResolutionErrorHandler ++ resolutionErrorHandler ++ ++ ++ org.apache.maven.toolchain.ToolchainManager ++ toolchainManager ++ ++ ++ ++ ++ ++ ++ org.apache.maven ++ maven-plugin-api ++ jar ++ 3.0 ++ ++ ++ org.apache.maven ++ maven-model ++ jar ++ 3.5.4 ++ ++ ++ org.codehaus.plexus ++ plexus-classworlds ++ jar ++ 2.5.2 ++ ++ ++ org.codehaus.plexus ++ plexus-utils ++ jar ++ 3.1.0 ++ ++ ++ org.eclipse.sisu ++ org.eclipse.sisu.plexus ++ jar ++ 0.3.3 ++ ++ ++ org.apache.maven ++ maven-artifact ++ jar ++ 3.0 ++ ++ ++ org.apache.commons ++ commons-lang3 ++ jar ++ 3.8.1 ++ ++ ++ org.apache.maven ++ maven-core ++ jar ++ 3.0 ++ ++ ++ org.apache.maven ++ maven-settings ++ jar ++ 3.5.4 ++ ++ ++ org.apache.maven.resolver ++ maven-resolver-util ++ jar ++ 1.1.1 ++ ++ ++ org.eclipse.sisu ++ org.eclipse.sisu.inject ++ jar ++ 0.3.3 ++ ++ ++ javax.enterprise ++ cdi-api ++ jar ++ 1.1 ++ ++ ++ javax.el ++ javax.el-api ++ jar ++ 3.0.0 ++ ++ ++ org.jboss.spec.javax.interceptor ++ jboss-interceptors-api_1.2_spec ++ jar ++ any ++ ++ ++ com.google.guava ++ guava ++ jar ++ 20.0 ++ ++ ++ com.google.inject ++ guice ++ jar ++ 4.2.0 ++ ++ ++ cglib ++ cglib ++ jar ++ 3.2.0 ++ ++ ++ aopalliance ++ aopalliance ++ jar ++ 1.0 ++ ++ ++ org.apache.maven ++ maven-resolver-provider ++ jar ++ 3.5.4 ++ ++ ++ org.apache.maven.resolver ++ maven-resolver-api ++ jar ++ 1.1.1 ++ ++ ++ javax.inject ++ javax.inject ++ jar ++ 1 ++ ++ ++ org.apache.maven.resolver ++ maven-resolver-impl ++ jar ++ 1.1.1 ++ ++ ++ org.slf4j ++ slf4j-api ++ jar ++ 1.7.25 ++ ++ ++ org.apache.maven ++ maven-repository-metadata ++ jar ++ 3.5.4 ++ ++ ++ org.apache.maven.resolver ++ maven-resolver-spi ++ jar ++ 1.1.1 ++ ++ ++ org.codehaus.plexus ++ plexus-component-annotations ++ jar ++ 1.5.5 ++ ++ ++ org.apache.maven ++ maven-model-builder ++ jar ++ 3.5.4 ++ ++ ++ org.apache.maven ++ maven-builder-support ++ jar ++ 3.5.4 ++ ++ ++ org.apache.maven ++ maven-settings-builder ++ jar ++ 3.5.4 ++ ++ ++ org.sonatype.plexus ++ plexus-sec-dispatcher ++ jar ++ 1.4 ++ ++ ++ org.sonatype.plexus ++ plexus-cipher ++ jar ++ 1.4 ++ ++ ++ org.apache.maven.shared ++ maven-shared-utils ++ jar ++ 3.2.1 ++ ++ ++ commons-io ++ commons-io ++ jar ++ 2.5 ++ ++ ++ org.apache.maven.shared ++ maven-shared-incremental ++ jar ++ 1.1 ++ ++ ++ org.codehaus.plexus ++ plexus-java ++ jar ++ 0.9.10 ++ ++ ++ org.ow2.asm ++ asm ++ jar ++ 6.2 ++ ++ ++ com.thoughtworks.qdox ++ qdox ++ jar ++ 2.0-M9 ++ ++ ++ org.codehaus.plexus ++ plexus-compiler-api ++ jar ++ 2.8.4 ++ ++ ++ org.codehaus.plexus ++ plexus-compiler-manager ++ jar ++ 2.8.4 ++ ++ ++ org.codehaus.plexus ++ plexus-compiler-javac ++ jar ++ 2.8.4 ++ ++ ++ org.codehaus.plexus ++ plexus-interpolation ++ jar ++ 1.24 ++ ++ ++ diff --git a/maven-compiler-plugin-build.xml b/maven-compiler-plugin-build.xml new file mode 100644 index 0000000..01361e6 --- /dev/null +++ b/maven-compiler-plugin-build.xml @@ -0,0 +1,252 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + =================================== WARNING =================================== + JUnit is not present in the test classpath or your $ANT_HOME/lib directory. Tests not executed. + =============================================================================== + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/maven-compiler-plugin.spec b/maven-compiler-plugin.spec new file mode 100644 index 0000000..8feb208 --- /dev/null +++ b/maven-compiler-plugin.spec @@ -0,0 +1,121 @@ +# +# spec file for package maven +# +# Copyright (c) 2019 SUSE LINUX GmbH, Nuernberg, Germany. +# +# All modifications and additions to the file contributed by third parties +# remain the property of their copyright owners, unless otherwise agreed +# upon. The license for this file, and modifications and additions to the +# file, is the same license as for the pristine package itself (unless the +# license for the pristine package is not an Open Source License, in which +# case the license is the MIT License). An "Open Source License" is a +# license that conforms to the Open Source Definition (Version 1.9) +# published by the Open Source Initiative. + +# Please submit bugfixes or comments via https://bugs.opensuse.org/ +# + + +%global flavor @BUILD_FLAVOR@%{nil} +%if "%{flavor}" == "bootstrap" +%bcond_without bootstrap +%else +%bcond_with bootstrap +%endif +%global base_name maven-compiler-plugin +Version: 3.8.0 +Release: 0 +Summary: Maven Compiler Plugin +License: Apache-2.0 +Group: Development/Libraries/Java +URL: http://maven.apache.org/plugins/maven-compiler-plugin +Source0: http://archive.apache.org/dist/maven/plugins/%{base_name}-%{version}-source-release.zip +Source1: %{base_name}-build.xml +Patch0: %{base_name}-bootstrap-resources.patch +BuildRequires: fdupes +BuildRequires: javapackages-local +BuildRequires: maven-lib +BuildRequires: maven-plugin-annotations +BuildRequires: maven-shared-incremental +BuildRequires: maven-shared-utils +BuildRequires: plexus-compiler +BuildRequires: plexus-languages +BuildRequires: unzip +BuildRequires: xmvn-install +BuildRequires: xmvn-resolve +BuildRequires: mvn(org.apache.maven.plugins:maven-plugins:pom:) +BuildArch: noarch +%if %{with bootstrap} +Name: %{base_name}-bootstrap +BuildRequires: ant +%else +Name: %{base_name} +BuildRequires: xmvn +BuildRequires: mvn(org.apache.maven.plugin-testing:maven-plugin-testing-harness) +BuildRequires: mvn(org.apache.maven.plugins:maven-compiler-plugin) +BuildRequires: mvn(org.apache.maven.plugins:maven-jar-plugin) +BuildRequires: mvn(org.apache.maven.plugins:maven-javadoc-plugin) +BuildRequires: mvn(org.apache.maven.plugins:maven-plugin-plugin) +BuildRequires: mvn(org.apache.maven.plugins:maven-resources-plugin) +BuildRequires: mvn(org.apache.maven.plugins:maven-surefire-plugin) +BuildRequires: mvn(org.codehaus.plexus:plexus-component-metadata) +BuildRequires: mvn(org.mockito:mockito-core) +Obsoletes: %{base_name}-bootstrap +%endif + +%description +The Compiler Plugin is used to compile the sources of your project. + +%if %{without bootstrap} +%package javadoc +Summary: Javadoc for %{name} +Group: Documentation/HTML + +%description javadoc +API documentation for %{name}. +%endif + +%prep +%setup -q -n %{base_name}-%{version} +%if %{with bootstrap} +cp %{SOURCE1} build.xml +%patch0 -p1 +%endif + +%build +%if %{with bootstrap} +mkdir -p lib +build-jar-repository -s lib \ + maven/maven-artifact \ + maven/maven-core \ + maven/maven-model \ + maven/maven-plugin-api \ + maven-plugin-tools/maven-plugin-annotations \ + maven-shared-incremental/maven-shared-incremental \ + maven-shared-utils/maven-shared-utils \ + plexus-compiler/plexus-compiler-api \ + plexus-compiler/plexus-compiler-javac \ + plexus-compiler/plexus-compiler-manager \ + plexus-languages/plexus-java +%{ant} -Dtest.skip=true jar +%else +xmvn --batch-mode --offline \ + -Dmaven.test.skip=true -Dsource=7 \ + package org.apache.maven.plugins:maven-javadoc-plugin:aggregate +%endif + +%{mvn_artifact} pom.xml target/%{base_name}-%{version}.jar + +%install +%mvn_install +%fdupes -s %{buildroot}%{_javadocdir} + +%files -f .mfiles +%license LICENSE NOTICE + +%if %{without bootstrap} +%files javadoc -f .mfiles-javadoc +%license LICENSE NOTICE +%endif + +%changelog