From f14ed648a9e98d6a14bff12fd30faef77d7943db Mon Sep 17 00:00:00 2001 From: Jeff Sharkey Date: Sat, 14 Nov 2020 15:54:22 -0700 Subject: [PATCH] Refaster templates for new TypedXml classes. Since we have over 100 unique schemas across the OS, it would be incredibly tedious to try migrating all that logic to use the more efficient TypedXmlSerializer and TypedXmlPullParser interfaces. To aid this migration process, this change adds Refaster templates that offer to refactor matching existing code in a no-op fashion. This change also upgrades Error Prone to the latest release. Bug: 171832118 Test: manual Change-Id: Ic93a46d646edee98af7d0e2f7891d931fca4825f --- Android.bp | 6 +- .../android/CompatChangeChecker.java | 4 +- .../PendingIntentMutabilityChecker.java | 3 +- .../bugpatterns/android/TargetSdkChecker.java | 2 +- .../matchers/{ => android}/FieldMatchers.java | 3 +- errorprone/refaster/EfficientXml.java | 323 ++++++++++++++++++ .../refaster/EfficientXml.java.refaster | Bin 0 -> 36469 bytes errorprone/refaster/refaster.sh | 11 + 8 files changed, 345 insertions(+), 7 deletions(-) rename errorprone/java/com/google/errorprone/matchers/{ => android}/FieldMatchers.java (97%) create mode 100644 errorprone/refaster/EfficientXml.java create mode 100644 errorprone/refaster/EfficientXml.java.refaster create mode 100755 errorprone/refaster/refaster.sh diff --git a/Android.bp b/Android.bp index 27378d4fcc428..bc19a6fdc3bf9 100644 --- a/Android.bp +++ b/Android.bp @@ -25,6 +25,9 @@ java_defaults { "-Xep:AndroidFrameworkBinderIdentity:ERROR", "-Xep:AndroidFrameworkCompatChange:ERROR", "-Xep:AndroidFrameworkUid:ERROR", + // NOTE: only enable to generate local patchfiles + // "-XepPatchChecks:refaster:frameworks/base/errorprone/refaster/EfficientXml.java.refaster", + // "-XepPatchLocation:/tmp/refaster/", ], }, } @@ -913,8 +916,9 @@ java_library_host { include_dirs: ["external/protobuf/src"], type: "full", }, + // Protos have lots of MissingOverride and similar. errorprone: { - javacflags: ["-Xep:MissingOverride:OFF"], // b/72714520 + javacflags: ["-XepDisableAllChecks"], }, } diff --git a/errorprone/java/com/google/errorprone/bugpatterns/android/CompatChangeChecker.java b/errorprone/java/com/google/errorprone/bugpatterns/android/CompatChangeChecker.java index 9c84f50b76bbe..e759663b5d16e 100644 --- a/errorprone/java/com/google/errorprone/bugpatterns/android/CompatChangeChecker.java +++ b/errorprone/java/com/google/errorprone/bugpatterns/android/CompatChangeChecker.java @@ -18,13 +18,13 @@ package com.google.errorprone.bugpatterns.android; import static com.google.errorprone.BugPattern.SeverityLevel.WARNING; import static com.google.errorprone.bugpatterns.android.TargetSdkChecker.binaryTreeExact; -import static com.google.errorprone.matchers.FieldMatchers.anyFieldInClass; -import static com.google.errorprone.matchers.FieldMatchers.staticField; import static com.google.errorprone.matchers.Matchers.allOf; import static com.google.errorprone.matchers.Matchers.anyOf; import static com.google.errorprone.matchers.Matchers.anything; import static com.google.errorprone.matchers.Matchers.kindIs; import static com.google.errorprone.matchers.Matchers.not; +import static com.google.errorprone.matchers.android.FieldMatchers.anyFieldInClass; +import static com.google.errorprone.matchers.android.FieldMatchers.staticField; import com.google.auto.service.AutoService; import com.google.errorprone.BugPattern; diff --git a/errorprone/java/com/google/errorprone/bugpatterns/android/PendingIntentMutabilityChecker.java b/errorprone/java/com/google/errorprone/bugpatterns/android/PendingIntentMutabilityChecker.java index 2561b41028cce..e323a895ee94c 100644 --- a/errorprone/java/com/google/errorprone/bugpatterns/android/PendingIntentMutabilityChecker.java +++ b/errorprone/java/com/google/errorprone/bugpatterns/android/PendingIntentMutabilityChecker.java @@ -17,12 +17,11 @@ package com.google.errorprone.bugpatterns.android; import static com.google.errorprone.BugPattern.SeverityLevel.WARNING; -import static com.google.errorprone.matchers.FieldMatchers.staticField; import static com.google.errorprone.matchers.Matchers.anyOf; import static com.google.errorprone.matchers.Matchers.contains; import static com.google.errorprone.matchers.Matchers.methodInvocation; import static com.google.errorprone.matchers.Matchers.staticMethod; - +import static com.google.errorprone.matchers.android.FieldMatchers.staticField; import com.google.auto.service.AutoService; import com.google.errorprone.BugPattern; diff --git a/errorprone/java/com/google/errorprone/bugpatterns/android/TargetSdkChecker.java b/errorprone/java/com/google/errorprone/bugpatterns/android/TargetSdkChecker.java index e1ebf42fec19c..032ae00536b94 100644 --- a/errorprone/java/com/google/errorprone/bugpatterns/android/TargetSdkChecker.java +++ b/errorprone/java/com/google/errorprone/bugpatterns/android/TargetSdkChecker.java @@ -28,8 +28,8 @@ import com.google.errorprone.VisitorState; import com.google.errorprone.bugpatterns.BugChecker; import com.google.errorprone.bugpatterns.BugChecker.BinaryTreeMatcher; import com.google.errorprone.matchers.Description; -import com.google.errorprone.matchers.FieldMatchers; import com.google.errorprone.matchers.Matcher; +import com.google.errorprone.matchers.android.FieldMatchers; import com.sun.source.tree.BinaryTree; import com.sun.source.tree.ExpressionTree; import com.sun.source.tree.Tree.Kind; diff --git a/errorprone/java/com/google/errorprone/matchers/FieldMatchers.java b/errorprone/java/com/google/errorprone/matchers/android/FieldMatchers.java similarity index 97% rename from errorprone/java/com/google/errorprone/matchers/FieldMatchers.java rename to errorprone/java/com/google/errorprone/matchers/android/FieldMatchers.java index 08969d60671a1..5d56e80d58f85 100644 --- a/errorprone/java/com/google/errorprone/matchers/FieldMatchers.java +++ b/errorprone/java/com/google/errorprone/matchers/android/FieldMatchers.java @@ -14,9 +14,10 @@ * limitations under the License. */ -package com.google.errorprone.matchers; +package com.google.errorprone.matchers.android; import com.google.errorprone.VisitorState; +import com.google.errorprone.matchers.Matcher; import com.google.errorprone.util.ASTHelpers; import com.sun.source.tree.ExpressionTree; import com.sun.source.tree.ImportTree; diff --git a/errorprone/refaster/EfficientXml.java b/errorprone/refaster/EfficientXml.java new file mode 100644 index 0000000000000..bd1ddfc92e918 --- /dev/null +++ b/errorprone/refaster/EfficientXml.java @@ -0,0 +1,323 @@ +/* + * Copyright (C) 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import android.util.TypedXmlPullParser; +import android.util.TypedXmlSerializer; + +import com.android.internal.util.XmlUtils; + +import com.google.errorprone.refaster.annotation.AfterTemplate; +import com.google.errorprone.refaster.annotation.BeforeTemplate; + +/** + * Refaster templates that migrate callers to equivalent and more efficient + * {@link TypedXmlSerializer} and {@link TypedXmlPullParser} methods. + */ +public class EfficientXml { + class IntToString { + @BeforeTemplate + void beforeToString(TypedXmlSerializer out, String n, int v) throws Exception { + out.attribute(null, n, Integer.toString(v)); + } + + @BeforeTemplate + void beforeValueOf(TypedXmlSerializer out, String n, int v) throws Exception { + out.attribute(null, n, String.valueOf(v)); + } + + @BeforeTemplate + void beforeUtils(TypedXmlSerializer out, String n, int v) throws Exception { + XmlUtils.writeIntAttribute(out, n, v); + } + + @BeforeTemplate + void beforeRadix(TypedXmlSerializer out, String n, int v) throws Exception { + out.attribute(null, n, Integer.toString(v, 10)); + } + + @AfterTemplate + void after(TypedXmlSerializer out, String n, int v) throws Exception { + out.attributeInt(null, n, v); + } + } + + class IntToStringHex { + @BeforeTemplate + void beforeToHexString(TypedXmlSerializer out, String n, int v) throws Exception { + out.attribute(null, n, Integer.toHexString(v)); + } + + @BeforeTemplate + void beforeRadix(TypedXmlSerializer out, String n, int v) throws Exception { + out.attribute(null, n, Integer.toString(v, 16)); + } + + @AfterTemplate + void after(TypedXmlSerializer out, String n, int v) throws Exception { + out.attributeIntHex(null, n, v); + } + } + + class IntFromString { + @BeforeTemplate + int beforeParse(TypedXmlPullParser in, String n) throws Exception { + return Integer.parseInt(in.getAttributeValue(null, n)); + } + + @BeforeTemplate + int beforeUtils(TypedXmlPullParser in, String n) throws Exception { + return XmlUtils.readIntAttribute(in, n); + } + + @BeforeTemplate + int beforeRadix(TypedXmlPullParser in, String n) throws Exception { + return Integer.parseInt(in.getAttributeValue(null, n), 10); + } + + @AfterTemplate + int after(TypedXmlPullParser in, String n) throws Exception { + return in.getAttributeInt(null, n); + } + } + + class IntFromStringDefault { + @BeforeTemplate + int before(TypedXmlPullParser in, String n, int d) throws Exception { + return XmlUtils.readIntAttribute(in, n, d); + } + + @AfterTemplate + int after(TypedXmlPullParser in, String n, int d) throws Exception { + return in.getAttributeInt(null, n, d); + } + } + + class IntFromStringHex { + @BeforeTemplate + int beforeParse(TypedXmlPullParser in, String n) throws Exception { + return Integer.parseInt(in.getAttributeValue(null, n), 16); + } + + @AfterTemplate + int after(TypedXmlPullParser in, String n) throws Exception { + return in.getAttributeIntHex(null, n); + } + } + + class LongToString { + @BeforeTemplate + void beforeToString(TypedXmlSerializer out, String n, long v) throws Exception { + out.attribute(null, n, Long.toString(v)); + } + + @BeforeTemplate + void beforeValueOf(TypedXmlSerializer out, String n, long v) throws Exception { + out.attribute(null, n, String.valueOf(v)); + } + + @BeforeTemplate + void beforeUtils(TypedXmlSerializer out, String n, long v) throws Exception { + XmlUtils.writeLongAttribute(out, n, v); + } + + @BeforeTemplate + void beforeRadix(TypedXmlSerializer out, String n, long v) throws Exception { + out.attribute(null, n, Long.toString(v, 10)); + } + + @AfterTemplate + void after(TypedXmlSerializer out, String n, long v) throws Exception { + out.attributeLong(null, n, v); + } + } + + class LongToStringHex { + @BeforeTemplate + void beforeToHexString(TypedXmlSerializer out, String n, long v) throws Exception { + out.attribute(null, n, Long.toHexString(v)); + } + + @BeforeTemplate + void beforeRadix(TypedXmlSerializer out, String n, long v) throws Exception { + out.attribute(null, n, Long.toString(v, 16)); + } + + @AfterTemplate + void after(TypedXmlSerializer out, String n, long v) throws Exception { + out.attributeLongHex(null, n, v); + } + } + + class LongFromString { + @BeforeTemplate + long beforeParse(TypedXmlPullParser in, String n) throws Exception { + return Long.parseLong(in.getAttributeValue(null, n)); + } + + @BeforeTemplate + long beforeUtils(TypedXmlPullParser in, String n) throws Exception { + return XmlUtils.readLongAttribute(in, n); + } + + @BeforeTemplate + long beforeRadix(TypedXmlPullParser in, String n) throws Exception { + return Long.parseLong(in.getAttributeValue(null, n), 10); + } + + @AfterTemplate + long after(TypedXmlPullParser in, String n) throws Exception { + return in.getAttributeLong(null, n); + } + } + + class LongFromStringDefault { + @BeforeTemplate + long before(TypedXmlPullParser in, String n, long d) throws Exception { + return XmlUtils.readLongAttribute(in, n, d); + } + + @AfterTemplate + long after(TypedXmlPullParser in, String n, long d) throws Exception { + return in.getAttributeLong(null, n, d); + } + } + + class LongFromStringHex { + @BeforeTemplate + long beforeParse(TypedXmlPullParser in, String n) throws Exception { + return Long.parseLong(in.getAttributeValue(null, n), 16); + } + + @AfterTemplate + long after(TypedXmlPullParser in, String n) throws Exception { + return in.getAttributeLongHex(null, n); + } + } + + class FloatToString { + @BeforeTemplate + void beforeToString(TypedXmlSerializer out, String n, float v) throws Exception { + out.attribute(null, n, Float.toString(v)); + } + + @BeforeTemplate + void beforeValueOf(TypedXmlSerializer out, String n, float v) throws Exception { + out.attribute(null, n, String.valueOf(v)); + } + + @BeforeTemplate + void beforeUtils(TypedXmlSerializer out, String n, float v) throws Exception { + XmlUtils.writeFloatAttribute(out, n, v); + } + + @AfterTemplate + void after(TypedXmlSerializer out, String n, float v) throws Exception { + out.attributeFloat(null, n, v); + } + } + + class FloatFromString { + @BeforeTemplate + float beforeParse(TypedXmlPullParser in, String n) throws Exception { + return Float.parseFloat(in.getAttributeValue(null, n)); + } + + @BeforeTemplate + float beforeUtils(TypedXmlPullParser in, String n) throws Exception { + return XmlUtils.readFloatAttribute(in, n); + } + + @AfterTemplate + float after(TypedXmlPullParser in, String n) throws Exception { + return in.getAttributeFloat(null, n); + } + } + + class DoubleToString { + @BeforeTemplate + void beforeToString(TypedXmlSerializer out, String n, double v) throws Exception { + out.attribute(null, n, Double.toString(v)); + } + + @BeforeTemplate + void beforeValueOf(TypedXmlSerializer out, String n, double v) throws Exception { + out.attribute(null, n, String.valueOf(v)); + } + + @AfterTemplate + void after(TypedXmlSerializer out, String n, double v) throws Exception { + out.attributeDouble(null, n, v); + } + } + + class DoubleFromString { + @BeforeTemplate + double beforeParse(TypedXmlPullParser in, String n) throws Exception { + return Double.parseDouble(in.getAttributeValue(null, n)); + } + + @AfterTemplate + double after(TypedXmlPullParser in, String n) throws Exception { + return in.getAttributeDouble(null, n); + } + } + + class BooleanToString { + @BeforeTemplate + void beforeToString(TypedXmlSerializer out, String n, boolean v) throws Exception { + out.attribute(null, n, Boolean.toString(v)); + } + + @BeforeTemplate + void beforeValueOf(TypedXmlSerializer out, String n, boolean v) throws Exception { + out.attribute(null, n, String.valueOf(v)); + } + + @AfterTemplate + void after(TypedXmlSerializer out, String n, boolean v) throws Exception { + out.attributeBoolean(null, n, v); + } + } + + class BooleanFromString { + @BeforeTemplate + boolean beforeParse(TypedXmlPullParser in, String n) throws Exception { + return Boolean.parseBoolean(in.getAttributeValue(null, n)); + } + + @BeforeTemplate + boolean beforeUtils(TypedXmlPullParser in, String n) throws Exception { + return XmlUtils.readBooleanAttribute(in, n); + } + + @AfterTemplate + boolean after(TypedXmlPullParser in, String n) throws Exception { + return in.getAttributeBoolean(null, n, false); + } + } + + class BooleanFromStringDefault { + @BeforeTemplate + boolean before(TypedXmlPullParser in, String n, boolean d) throws Exception { + return XmlUtils.readBooleanAttribute(in, n, d); + } + + @AfterTemplate + boolean after(TypedXmlPullParser in, String n, boolean d) throws Exception { + return in.getAttributeBoolean(null, n, d); + } + } +} diff --git a/errorprone/refaster/EfficientXml.java.refaster b/errorprone/refaster/EfficientXml.java.refaster new file mode 100644 index 0000000000000000000000000000000000000000..f2974fffb83b077a065724fe417adae73354649b GIT binary patch literal 36469 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 literal 0 HcmV?d00001 diff --git a/errorprone/refaster/refaster.sh b/errorprone/refaster/refaster.sh new file mode 100755 index 0000000000000..67dc3e4867565 --- /dev/null +++ b/errorprone/refaster/refaster.sh @@ -0,0 +1,11 @@ + +paths=( + $ANDROID_BUILD_TOP/out/soong/.intermediates/frameworks/base/framework/android_common/turbine-combined/framework.jar + $ANDROID_BUILD_TOP/out/soong/.intermediates/libcore/core-all/android_common/turbine-combined/core-all.jar + $ANDROID_BUILD_TOP/external/error_prone/error_prone/error_prone_refaster-2.4.0.jar +) + +javac -cp "$(IFS=:; echo "${paths[*]}")" \ + "-Xplugin:RefasterRuleCompiler --out $1.refaster" $1 + +rm *.class