Give FormatterStepSerializationRoundtrip a special serialization format instead.

Author: nedtwigg

lib/src/main/java/com/diffplug/spotless/ConfigurationCacheHack.java

@@ -15,73 +15,89 @@
  */
 package com.diffplug.spotless;
 
-import java.io.IOException;
-import java.util.AbstractList;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
 
 /**
  * Gradle requires three things:
  * - Gradle defines cache equality based on your serialized representation
- * - Combined with remote build cache, you cannot have any absolute paths in your serialized representation
- * - Combined with configuration cache, you must be able to roundtrip yourself through serialization
+ * - Combined with remote build cache, you cannot have any absolute paths in
+ * your serialized representation
+ * - Combined with configuration cache, you must be able to roundtrip yourself
+ * through serialization
  *
  * These requirements are at odds with each other, as described in these issues
- * - Gradle issue to define custom equality https://github.com/gradle/gradle/issues/29816
- * - Spotless plea for developer cache instead of configuration cache https://github.com/diffplug/spotless/issues/987
- * - Spotless cache miss bug fixed by this class https://github.com/diffplug/spotless/issues/2168
+ * - Gradle issue to define custom equality
+ * https://github.com/gradle/gradle/issues/29816
+ * - Spotless plea for developer cache instead of configuration cache
+ * https://github.com/diffplug/spotless/issues/987
+ * - Spotless cache miss bug fixed by this class
+ * https://github.com/diffplug/spotless/issues/2168
  *
- * The point of this class is to create containers which can optimize the serialized representation for either
+ * The point of this class is to create containers which can optimize the
+ * serialized representation for either
  * - roundtrip integrity
  * - equality
  *
  * It is a horrific hack, but it works, and it's the only way I can figure
  * to make Spotless work with all of Gradle's cache systems.
  */
 public class ConfigurationCacheHack {
-	static boolean SERIALIZE_FOR_ROUNDTRIP = false;
-
 	public enum OptimizeFor {
 		ROUNDTRIP, EQUALITY,
 	}
 
-	public static class StepList extends AbstractList<FormatterStep> {
+	public static class StepList implements java.io.Serializable {
 		private final boolean optimizeForEquality;
-		private transient ArrayList<FormatterStep> backingList = new ArrayList<>();
+		private final ArrayList<Object> backingList = new ArrayList<>();
 
 		public StepList(OptimizeFor optimizeFor) {
 			this.optimizeForEquality = optimizeFor == OptimizeFor.EQUALITY;
 		}
 
-		@Override
 		public void clear() {
 			backingList.clear();
 		}
 
-		@Override
-		public boolean addAll(Collection<? extends FormatterStep> c) {
-			return backingList.addAll(c);
-		}
-
-		private void writeObject(java.io.ObjectOutputStream out) throws IOException {
-			out.defaultWriteObject();
-			SERIALIZE_FOR_ROUNDTRIP = !optimizeForEquality;
-			out.writeObject(backingList);
+		public void addAll(Collection<? extends FormatterStep> c) {
+			for (FormatterStep step : c) {
+				if (step instanceof FormatterStepSerializationRoundtrip) {
+					var clone = ((FormatterStepSerializationRoundtrip) step).hackClone(optimizeForEquality);
+					backingList.add(clone);
+				} else {
+					backingList.add(step);
+				}
+			}
 		}
 
-		private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
-			in.defaultReadObject();
-			backingList = (ArrayList<FormatterStep>) in.readObject();
+		public List<FormatterStep> getSteps() {
+			var result = new ArrayList<FormatterStep>(backingList.size());
+			for (Object obj : backingList) {
+				if (obj instanceof FormatterStepSerializationRoundtrip.HackClone) {
+					result.add(((FormatterStepSerializationRoundtrip.HackClone) obj).rehydrate());
+				} else {
+					result.add((FormatterStep) obj);
+				}
+			}
+			return result;
 		}
 
 		@Override
-		public FormatterStep get(int index) {
-			return backingList.get(index);
+		public boolean equals(Object o) {
+			if (this == o)
+				return true;
+			if (o == null || getClass() != o.getClass())
+				return false;
+			StepList stepList = (StepList) o;
+			return optimizeForEquality == stepList.optimizeForEquality &&
+					backingList.equals(stepList.backingList);
 		}
 
 		@Override
-		public int size() {
-			return backingList.size();
+		public int hashCode() {
+			return Objects.hash(optimizeForEquality, backingList);
 		}
 	}
 }

lib/src/main/java/com/diffplug/spotless/Formatter.java

@@ -35,8 +35,6 @@
 
 import javax.annotation.Nullable;
 
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-
 /** Formatter which performs the full formatting. */
 public final class Formatter implements Serializable, AutoCloseable {
 	private static final long serialVersionUID = 1L;
@@ -59,13 +57,11 @@ private Formatter(String name, LineEnding.Policy lineEndingsPolicy, Charset enco
 	}
 
 	// override serialize output
-	@SuppressFBWarnings("ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD")
 	private void writeObject(ObjectOutputStream out) throws IOException {
 		out.writeObject(name);
 		out.writeObject(lineEndingsPolicy);
 		out.writeObject(encoding.name());
 		out.writeObject(rootDir.toString());
-		ConfigurationCacheHack.SERIALIZE_FOR_ROUNDTRIP = true;
 		out.writeObject(steps);
 		out.writeObject(exceptionPolicy);
 	}

lib/src/main/java/com/diffplug/spotless/FormatterStepSerializationRoundtrip.java

@@ -16,12 +16,12 @@
 package com.diffplug.spotless;
 
 import java.io.IOException;
-import java.io.ObjectStreamException;
 import java.io.Serializable;
+import java.util.Objects;
 
 import edu.umd.cs.findbugs.annotations.Nullable;
 
-class FormatterStepSerializationRoundtrip<RoundtripState extends Serializable, EqualityState extends Serializable> extends FormatterStepEqualityOnStateSerialization<EqualityState> {
+final class FormatterStepSerializationRoundtrip<RoundtripState extends Serializable, EqualityState extends Serializable> extends FormatterStepEqualityOnStateSerialization<EqualityState> {
 	private static final long serialVersionUID = 1L;
 	private final String name;
 	private final transient ThrowingEx.Supplier<RoundtripState> initializer;
@@ -30,7 +30,7 @@ class FormatterStepSerializationRoundtrip<RoundtripState extends Serializable, E
 	private final SerializedFunction<RoundtripState, EqualityState> equalityStateExtractor;
 	private final SerializedFunction<EqualityState, FormatterFunc> equalityStateToFormatter;
 
-	public FormatterStepSerializationRoundtrip(String name, ThrowingEx.Supplier<RoundtripState> initializer, SerializedFunction<RoundtripState, EqualityState> equalityStateExtractor, SerializedFunction<EqualityState, FormatterFunc> equalityStateToFormatter) {
+	FormatterStepSerializationRoundtrip(String name, ThrowingEx.Supplier<RoundtripState> initializer, SerializedFunction<RoundtripState, EqualityState> equalityStateExtractor, SerializedFunction<EqualityState, FormatterFunc> equalityStateToFormatter) {
 		this.name = name;
 		this.initializer = initializer;
 		this.equalityStateExtractor = equalityStateExtractor;
@@ -42,13 +42,17 @@ public String getName() {
 		return name;
 	}
 
+	private RoundtripState roundtripStateSupplier() throws Exception {
+		if (roundtripStateInternal == null) {
+			roundtripStateInternal = initializer.get();
+		}
+		return roundtripStateInternal;
+	}
+
 	@Override
 	protected EqualityState stateSupplier() throws Exception {
 		if (equalityStateInternal == null) {
-			if (roundtripStateInternal == null) {
-				roundtripStateInternal = initializer.get();
-			}
-			equalityStateInternal = equalityStateExtractor.apply(roundtripStateInternal);
+			equalityStateInternal = equalityStateExtractor.apply(roundtripStateSupplier());
 		}
 		return equalityStateInternal;
 	}
@@ -58,25 +62,55 @@ protected FormatterFunc stateToFormatter(EqualityState equalityState) throws Exc
 		return equalityStateToFormatter.apply(equalityState);
 	}
 
-	// override serialize output
-	private void writeObject(java.io.ObjectOutputStream out) throws IOException {
-		if (ConfigurationCacheHack.SERIALIZE_FOR_ROUNDTRIP) {
-			if (roundtripStateInternal == null) {
-				roundtripStateInternal = ThrowingEx.get(initializer::get);
+	HackClone<?, ?> hackClone(boolean optimizeForEquality) {
+		return new HackClone<>(this, optimizeForEquality);
+	}
+
+	static class HackClone<RoundtripState extends Serializable, EqualityState extends Serializable> implements Serializable {
+		transient FormatterStepSerializationRoundtrip<?, ?> original;
+		boolean optimizeForEquality;
+		@Nullable
+		FormatterStepSerializationRoundtrip cleaned;
+
+		HackClone(@Nullable FormatterStepSerializationRoundtrip<RoundtripState, EqualityState> original, boolean optimizeForEquality) {
+			this.original = original;
+			this.optimizeForEquality = optimizeForEquality;
+		}
+
+		private void writeObject(java.io.ObjectOutputStream out) throws IOException {
+			if (cleaned == null) {
+				cleaned = new FormatterStepSerializationRoundtrip(original.name, null, original.equalityStateExtractor, original.equalityStateToFormatter);
+				if (optimizeForEquality) {
+					cleaned.equalityStateInternal = ThrowingEx.get(original::stateSupplier);
+				} else {
+					cleaned.roundtripStateInternal = ThrowingEx.get(original::roundtripStateSupplier);
+				}
 			}
-			equalityStateInternal = null;
-		} else {
-			equalityStateInternal = ThrowingEx.get(this::stateSupplier);
-			roundtripStateInternal = null;
+			out.defaultWriteObject();
 		}
-		out.defaultWriteObject();
-	}
 
-	private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
-		in.defaultReadObject();
-	}
+		public FormatterStep rehydrate() {
+			try {
+				throw new Exception("rehydrate optimizeForEquality=" + optimizeForEquality + " orig=" + original + " cleaned=" + cleaned);
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+			return original != null ? original : Objects.requireNonNull(cleaned, "how is clean null if this has been serialized?");
+		}
+
+		@Override
+		public boolean equals(Object o) {
+			if (this == o)
+				return true;
+			if (o == null || getClass() != o.getClass())
+				return false;
+			HackClone<?, ?> that = (HackClone<?, ?>) o;
+			return optimizeForEquality == that.optimizeForEquality && rehydrate().equals(that.rehydrate());
+		}
 
-	private void readObjectNoData() throws ObjectStreamException {
-		throw new UnsupportedOperationException();
+		@Override
+		public int hashCode() {
+			return rehydrate().hashCode() ^ Boolean.hashCode(optimizeForEquality);
+		}
 	}
 }

plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessTask.java

@@ -17,7 +17,6 @@
 
 import java.io.File;
 import java.nio.charset.Charset;
-import java.util.Collections;
 import java.util.List;
 import java.util.Locale;
 import java.util.Objects;
@@ -150,17 +149,17 @@ public File getOutputDirectory() {
 		return outputDirectory;
 	}
 
-	private final List<FormatterStep> stepsInternalRoundtrip = new ConfigurationCacheHack.StepList(ConfigurationCacheHack.OptimizeFor.ROUNDTRIP);
-	private final List<FormatterStep> stepsInternalEquality = new ConfigurationCacheHack.StepList(ConfigurationCacheHack.OptimizeFor.EQUALITY);
+	private final ConfigurationCacheHack.StepList stepsInternalRoundtrip = new ConfigurationCacheHack.StepList(ConfigurationCacheHack.OptimizeFor.ROUNDTRIP);
+	private final ConfigurationCacheHack.StepList stepsInternalEquality = new ConfigurationCacheHack.StepList(ConfigurationCacheHack.OptimizeFor.EQUALITY);
 
 	@Internal
-	public List<FormatterStep> getStepsInternalRoundtrip() {
-		return Collections.unmodifiableList(stepsInternalRoundtrip);
+	public ConfigurationCacheHack.StepList getStepsInternalRoundtrip() {
+		return stepsInternalRoundtrip;
 	}
 
 	@Input
-	public List<FormatterStep> getStepsInternalEquality() {
-		return Collections.unmodifiableList(stepsInternalEquality);
+	public ConfigurationCacheHack.StepList getStepsInternalEquality() {
+		return stepsInternalEquality;
 	}
 
 	public void setSteps(List<FormatterStep> steps) {
@@ -187,7 +186,7 @@ Formatter buildFormatter() {
 				.lineEndingsPolicy(getLineEndingsPolicy().get())
 				.encoding(Charset.forName(encoding))
 				.rootDir(getProjectDir().get().getAsFile().toPath())
-				.steps(stepsInternalRoundtrip)
+				.steps(stepsInternalRoundtrip.getSteps())
 				.exceptionPolicy(exceptionPolicy)
 				.build();
 	}