--- maven-compiler-plugin-3.8.1/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.1/src/main/filtered-resources/META-INF/maven/org.apache.maven.plugins/maven-compiler-plugin/plugin-help.xml 2019-11-25 17:47:55.264289561 +0100 @@ -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} + + + + --- maven-compiler-plugin-3.8.1/src/main/filtered-resources/META-INF/maven/plugin.xml 1970-01-01 01:00:00.000000000 +0100 +++ maven-compiler-plugin-3.8.1/src/main/filtered-resources/META-INF/maven/plugin.xml 2019-11-25 17:48:57.728635290 +0100 @@ -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.6.2 + + + org.codehaus.plexus + plexus-classworlds + jar + 2.6.0 + + + org.codehaus.plexus + plexus-utils + jar + 3.2.1 + + + 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.6.2 + + + org.apache.maven.resolver + maven-resolver-util + jar + 1.4.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.inject + guice + jar + 4.2.1 + + + aopalliance + aopalliance + jar + 1.0 + + + cglib + cglib + jar + 3.2.0 + + + com.google.guava + guava + jar + 19.0 + + + org.apache.maven + maven-resolver-provider + jar + 3.6.2 + + + org.slf4j + slf4j-api + jar + 1.7.25 + + + org.apache.maven.resolver + maven-resolver-api + jar + 1.4.1 + + + javax.inject + javax.inject + jar + 1 + + + org.apache.maven.resolver + maven-resolver-impl + jar + 1.4.1 + + + org.apache.maven + maven-repository-metadata + jar + 3.6.2 + + + org.apache.maven.resolver + maven-resolver-spi + jar + 1.4.1 + + + org.codehaus.plexus + plexus-component-annotations + jar + 1.5.5 + + + org.apache.maven + maven-model-builder + jar + 3.6.2 + + + org.apache.maven + maven-builder-support + jar + 3.6.2 + + + org.apache.maven + maven-settings-builder + jar + 3.6.2 + + + 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 + 7.0 + + + 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.25 + + +