StrixOS/build_soong
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Run ErrorProne in OpenJDK9"

Browse Source
This commit is contained in:
Colin Cross
2018-06-21 20:47:41 +00:00
committed by Gerrit Code Review
parent 1737a4f8a7 6654810f37
commit 8eb0ad15bf
6 changed files with 61 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
android/config.go
View File

@@ -322,10 +322,8 @@ func NewConfig(srcDir, buildDir string) (Config, error) {
func (c *config) fromEnv() error {
switch c.Getenv("EXPERIMENTAL_USE_OPENJDK9") {
case "":
if c.Getenv("RUN_ERROR_PRONE") != "true" {
// Use OpenJDK9, but target 1.8
c.useOpenJDK9 = true
}
// Use OpenJDK9, but target 1.8
c.useOpenJDK9 = true
case "false":
// Use OpenJDK8
case "1.8":
@@ -631,6 +629,10 @@ func (c *config) UseGoma() bool {
return Bool(c.productVariables.UseGoma)
}
func (c *config) RunErrorProne() bool {
return c.IsEnvTrue("RUN_ERROR_PRONE")
}
// Returns true if OpenJDK9 prebuilts are being used
func (c *config) UseOpenJDK9() bool {
return c.useOpenJDK9

39
java/builder.go
View File

@@ -26,7 +26,6 @@ import (
"github.com/google/blueprint"
"android/soong/android"
"android/soong/java/config"
)
var (
@@ -80,29 +79,6 @@ var (
},
"kotlincFlags", "classpath", "srcJars", "srcJarDir", "outDir", "kotlinJvmTarget")
errorprone = pctx.AndroidStaticRule("errorprone",
blueprint.RuleParams{
Command: `rm -rf "$outDir" "$annoDir" "$srcJarDir" && mkdir -p "$outDir" "$annoDir" "$srcJarDir" && ` +
`${config.ZipSyncCmd} -d $srcJarDir -l $srcJarDir/list -f "*.java" $srcJars && ` +
`${config.SoongJavacWrapper} ${config.ErrorProneCmd} ` +
`$processorpath $javacFlags $bootClasspath $classpath ` +
`-source $javaVersion -target $javaVersion ` +
`-d $outDir -s $annoDir @$out.rsp @$srcJarDir/list && ` +
`${config.SoongZipCmd} -jar -o $out -C $outDir -D $outDir`,
CommandDeps: []string{
"${config.JavaCmd}",
"${config.ErrorProneJavacJar}",
"${config.ErrorProneJar}",
"${config.SoongZipCmd}",
"${config.ZipSyncCmd}",
},
CommandOrderOnly: []string{"${config.SoongJavacWrapper}"},
Rspfile: "$out.rsp",
RspfileContent: "$in",
},
"javacFlags", "bootClasspath", "classpath", "processorpath", "srcJars", "srcJarDir",
"outDir", "annoDir", "javaVersion")
turbine = pctx.AndroidStaticRule("turbine",
blueprint.RuleParams{
Command: `rm -rf "$outDir" && mkdir -p "$outDir" && ` +
@@ -161,6 +137,7 @@ type javaBuilderFlags struct {
javaVersion string
errorProneExtraJavacFlags string
errorProneProcessorPath classpath
kotlincFlags string
kotlincClasspath classpath
@@ -208,26 +185,24 @@ func TransformJavaToClasses(ctx android.ModuleContext, outputFile android.Writab
desc += strconv.Itoa(shardIdx)
}
transformJavaToClasses(ctx, outputFile, shardIdx, srcFiles, srcJars, flags, deps, "javac", desc, javac)
transformJavaToClasses(ctx, outputFile, shardIdx, srcFiles, srcJars, flags, deps, "javac", desc)
}
func RunErrorProne(ctx android.ModuleContext, outputFile android.WritablePath,
srcFiles, srcJars android.Paths, flags javaBuilderFlags) {
if config.ErrorProneJar == "" {
ctx.ModuleErrorf("cannot build with Error Prone, missing external/error_prone?")
}
flags.processorPath = append(flags.errorProneProcessorPath, flags.processorPath...)
if len(flags.errorProneExtraJavacFlags) > 0 {
if len(flags.javacFlags) > 0 {
flags.javacFlags = flags.errorProneExtraJavacFlags + " " + flags.javacFlags
flags.javacFlags += " " + flags.errorProneExtraJavacFlags
} else {
flags.javacFlags = flags.errorProneExtraJavacFlags
}
}
transformJavaToClasses(ctx, outputFile, -1, srcFiles, srcJars, flags, nil,
"errorprone", "errorprone", errorprone)
"errorprone", "errorprone")
}
func TransformJavaToHeaderClasses(ctx android.ModuleContext, outputFile android.WritablePath,
@@ -276,7 +251,7 @@ func TransformJavaToHeaderClasses(ctx android.ModuleContext, outputFile android.
func transformJavaToClasses(ctx android.ModuleContext, outputFile android.WritablePath,
shardIdx int, srcFiles, srcJars android.Paths,
flags javaBuilderFlags, deps android.Paths,
intermediatesDir, desc string, rule blueprint.Rule) {
intermediatesDir, desc string) {
deps = append(deps, srcJars...)
@@ -308,7 +283,7 @@ func transformJavaToClasses(ctx android.ModuleContext, outputFile android.Writab
annoDir = filepath.Join(shardDir, annoDir)
}
ctx.Build(pctx, android.BuildParams{
Rule: rule,
Rule: javac,
Description: desc,
Output: outputFile,
Inputs: srcFiles,

49
java/config/error_prone.go
View File

@@ -14,39 +14,40 @@
package config
import "android/soong/android"
import (
"strings"
"android/soong/android"
)
var (
// These will be filled out by external/error_prone/soong/error_prone.go if it is available
ErrorProneJavacJar string
ErrorProneJar string
ErrorProneClasspath string
ErrorProneChecksError string
ErrorProneChecksWarning string
ErrorProneChecksDefaultDisabled string
ErrorProneFlags string
ErrorProneClasspath []string
ErrorProneChecksError []string
ErrorProneChecksWarning []string
ErrorProneChecksDefaultDisabled []string
ErrorProneChecksOff []string
ErrorProneFlags []string
)
// Wrapper that grabs value of val late so it can be initialized by a later module's init function
func errorProneVar(name string, val *string) {
func errorProneVar(name string, val *[]string, sep string) {
pctx.VariableFunc(name, func(android.PackageVarContext) string {
return *val
return strings.Join(*val, sep)
})
}
func init() {
errorProneVar("ErrorProneJar", &ErrorProneJar)
errorProneVar("ErrorProneJavacJar", &ErrorProneJavacJar)
errorProneVar("ErrorProneClasspath", &ErrorProneClasspath)
errorProneVar("ErrorProneChecksError", &ErrorProneChecksError)
errorProneVar("ErrorProneChecksWarning", &ErrorProneChecksWarning)
errorProneVar("ErrorProneChecksDefaultDisabled", &ErrorProneChecksDefaultDisabled)
errorProneVar("ErrorProneFlags", &ErrorProneFlags)
pctx.StaticVariable("ErrorProneCmd",
"${JavaCmd} -Xmx${JavacHeapSize} -Xbootclasspath/p:${ErrorProneJavacJar} "+
"-cp ${ErrorProneJar}:${ErrorProneClasspath} "+
"${ErrorProneFlags} ${CommonJdkFlags} "+
"${ErrorProneChecksError} ${ErrorProneChecksWarning} ${ErrorProneChecksDefaultDisabled}")
errorProneVar("ErrorProneClasspath", &ErrorProneClasspath, ":")
errorProneVar("ErrorProneChecksError", &ErrorProneChecksError, " ")
errorProneVar("ErrorProneChecksWarning", &ErrorProneChecksWarning, " ")
errorProneVar("ErrorProneChecksDefaultDisabled", &ErrorProneChecksDefaultDisabled, " ")
errorProneVar("ErrorProneChecksOff", &ErrorProneChecksOff, " ")
errorProneVar("ErrorProneFlags", &ErrorProneFlags, " ")
pctx.StaticVariable("ErrorProneChecks", strings.Join([]string{
"${ErrorProneChecksOff}",
"${ErrorProneChecksError}",
"${ErrorProneChecksWarning}",
"${ErrorProneChecksDefaultDisabled}",
}, " "))
}

13
java/config/makevars.go
View File

@@ -52,14 +52,15 @@ func makeVarsProvider(ctx android.MakeVarsContext) {
ctx.Strict("TURBINE", "${TurbineJar}")
if ctx.Config().IsEnvTrue("RUN_ERROR_PRONE") {
ctx.Strict("TARGET_JAVAC", "${ErrorProneCmd}")
ctx.Strict("HOST_JAVAC", "${ErrorProneCmd}")
} else {
ctx.Strict("TARGET_JAVAC", "${JavacCmd} ${CommonJdkFlags}")
ctx.Strict("HOST_JAVAC", "${JavacCmd} ${CommonJdkFlags}")
if ctx.Config().RunErrorProne() {
ctx.Strict("ERROR_PRONE_JARS", strings.Join(ErrorProneClasspath, " "))
ctx.Strict("ERROR_PRONE_FLAGS", "${ErrorProneFlags}")
ctx.Strict("ERROR_PRONE_CHECKS", "${ErrorProneChecks}")
}
ctx.Strict("TARGET_JAVAC", "${JavacCmd} ${CommonJdkFlags}")
ctx.Strict("HOST_JAVAC", "${JavacCmd} ${CommonJdkFlags}")
if ctx.Config().UseOpenJDK9() {
ctx.Strict("JLINK", "${JlinkCmd}")
ctx.Strict("JMOD", "${JmodCmd}")

18
java/java.go
View File

@@ -843,8 +843,20 @@ func (j *Module) collectBuilderFlags(ctx android.ModuleContext, deps deps) javaB
flags.javacFlags = "$javacFlags"
}
if len(j.properties.Errorprone.Javacflags) > 0 {
flags.errorProneExtraJavacFlags = strings.Join(j.properties.Errorprone.Javacflags, " ")
if ctx.Config().RunErrorProne() {
if config.ErrorProneClasspath == nil {
ctx.ModuleErrorf("cannot build with Error Prone, missing external/error_prone?")
}
errorProneFlags := []string{
"-Xplugin:ErrorProne",
"${config.ErrorProneChecks}",
}
errorProneFlags = append(errorProneFlags, j.properties.Errorprone.Javacflags...)
flags.errorProneExtraJavacFlags = "${config.ErrorProneFlags} " +
"'" + strings.Join(errorProneFlags, " ") + "'"
flags.errorProneProcessorPath = classpath(android.PathsForSource(ctx, config.ErrorProneClasspath))
}
// javaVersion flag.
@@ -994,7 +1006,7 @@ func (j *Module) compile(ctx android.ModuleContext, extraSrcJars ...android.Path
}
if len(uniqueSrcFiles) > 0 || len(srcJars) > 0 {
var extraJarDeps android.Paths
if ctx.Config().IsEnvTrue("RUN_ERROR_PRONE") {
if ctx.Config().RunErrorProne() {
// If error-prone is enabled, add an additional rule to compile the java files into
// a separate set of classes (so that they don't overwrite the normal ones and require
// a rebuild when error-prone is turned off).

10
ui/build/config.go
View File

@@ -165,15 +165,7 @@ func NewConfig(ctx Context, args ...string) Config {
return override
}
v, ok := ret.environ.Get("EXPERIMENTAL_USE_OPENJDK9")
if !ok {
v2, ok2 := ret.environ.Get("RUN_ERROR_PRONE")
if ok2 && (v2 == "true") {
v = "false"
} else {
v = "1.8"
}
}
if v != "false" {
if !ok || v != "false" {
return java9Home
}
return java8Home