Add Check for Leaking/Mutating an already-forked mutable instance (Bundle)

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=242811734

Author: dx404

check_api/src/main/java/com/google/errorprone/matchers/Matchers.java

@@ -130,6 +130,15 @@ public boolean matches(T t, VisitorState state) {
    */
   @SafeVarargs
   public static <T extends Tree> Matcher<T> allOf(final Matcher<? super T>... matchers) {
+    return Matchers.<T>allOf(ImmutableList.copyOf(matchers));
+  }
+
+  /**
+   * Compose several matchers together, such that the composite matches an AST node iff all the
+   * given matchers do.
+   */
+  public static <T extends Tree> Matcher<T> allOf(
+      final Iterable<? extends Matcher<? super T>> matchers) {
     return new Matcher<T>() {
       @Override
       public boolean matches(T t, VisitorState state) {

core/src/test/java/com/google/errorprone/bugpatterns/android/testdata/stubs/android/location/Location.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2019 The Error Prone Authors.
+ *
+ * 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.
+ */
+
+package android.location;
+
+import android.os.Bundle;
+
+public class Location {
+
+  public Location(String provider) {
+    throw new RuntimeException("Stub!");
+  }
+
+  public Location(Location l) {
+    throw new RuntimeException("Stub!");
+  }
+
+  public android.os.Bundle getExtras() {
+    throw new RuntimeException("Stub!");
+  }
+
+  public void setExtras(Bundle extras) {
+    throw new RuntimeException("Stub!");
+  }
+}

core/src/test/java/com/google/errorprone/bugpatterns/android/testdata/stubs/android/os/Bundle.java

@@ -25,4 +25,8 @@ public Bundle() {}
   public Serializable getSerializable(String key) {
     return null;
   }
+
+  public void putCharSequence(String key, CharSequence value) {
+    throw new RuntimeException("Stub!");
+  }
 }

core/src/test/java/com/google/errorprone/bugpatterns/inject/dagger/testdata/stubs/android/os/Bundle.java

@@ -16,4 +16,17 @@
 
 package android.os;
 
-public class Bundle {}
+import java.io.Serializable;
+
+/** Stub for android.os.Bundle */
+public class Bundle {
+  public Bundle() {}
+
+  public Serializable getSerializable(String key) {
+    return null;
+  }
+
+  public void putCharSequence(String key, CharSequence value) {
+    throw new RuntimeException("Stub!");
+  }
+}

docs/bugpattern/LeakingForkedAndroidBundle.md

@@ -0,0 +1,31 @@
+> When passing a mutable instance into a method which makes a deep copy of the
+> instance, it results in discrepancies between the forked instances. It is
+> prone to errors if one expects the state change on the original instance to be
+> reflected on the method with its forked instance.
+
+
+```java {.bad}
+Location location = new Location("gps");
+Bundle bundle = new Bundle();
+bundle.putFloat("someFloat", 12.3f);
+location.setExtras(bundle);
+
+// Now add more things to the bundle, but it won't modify the internal
+// representation stored by Location.
+bundle.putInt("someInt", 7);
+```
+
+```java {.bad}
+private static Bundle getLocationExtras(Location location) {
+  Bundle bundle = location.getExtras();
+  if (bundle != null) {
+    return bundle;
+  }
+  bundle = new Bundle();
+  location.setExtras(bundle);
+
+  // Now leaks the bundle which is subject to modification in its
+  // method of invocation.
+  return bundle;
+}
+```