From 6654810f3762b6c683c421749b18409725abf586 Mon Sep 17 00:00:00 2001 From: Colin Cross Date: Tue, 19 Jun 2018 22:47:35 -0700 Subject: [PATCH] Run ErrorProne in OpenJDK9 Use the OpenJDK9 javac to run ErrorProne by adding it to -processorpath and using -Xplugin:ErrorProne. Bug: 69485063 Test: m RUN_ERROR_PRONE=true javac-check Change-Id: I0496006b71b70766ef16d57753cbcf037897799c --- android/config.go | 10 ++++---- java/builder.go | 39 ++++++------------------------ java/config/error_prone.go | 49 +++++++++++++++++++------------------- java/config/makevars.go | 13 +++++----- java/java.go | 18 +++++++++++--- ui/build/config.go | 10 +------- 6 files changed, 61 insertions(+), 78 deletions(-) diff --git a/android/config.go b/android/config.go index f5a5e8eb6..b415443b3 100644 --- a/android/config.go +++ b/android/config.go @@ -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 diff --git a/java/builder.go b/java/builder.go index 2a2ed23f1..1944e698a 100644 --- a/java/builder.go +++ b/java/builder.go @@ -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, diff --git a/java/config/error_prone.go b/java/config/error_prone.go index 2c1c002ba..48681b5c9 100644 --- a/java/config/error_prone.go +++ b/java/config/error_prone.go @@ -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}", + }, " ")) } diff --git a/java/config/makevars.go b/java/config/makevars.go index 0e6227422..8dfd3986b 100644 --- a/java/config/makevars.go +++ b/java/config/makevars.go @@ -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}") diff --git a/java/java.go b/java/java.go index 86c3c21cc..5458ea196 100644 --- a/java/java.go +++ b/java/java.go @@ -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). diff --git a/ui/build/config.go b/ui/build/config.go index 345d8ea4e..5dcdf8749 100644 --- a/ui/build/config.go +++ b/ui/build/config.go @@ -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