[prone] Apply UnnecessaryDefaultInEnumSwitch

Author: Vincent Potucek

lib-extra/src/jdt/java/com/diffplug/spotless/extra/glue/jdt/DefaultJavaElementComparator.java

@@ -347,28 +347,14 @@ public int compare(BodyDeclaration bodyDeclaration1, BodyDeclaration bodyDeclara
 	}
 
 	private static int sortPreservedCategory(int category) {
-		switch (category) {
-		case STATIC_FIELDS_INDEX:
-		case STATIC_INIT_INDEX:
-			return STATIC_FIELDS_INDEX;
-		case FIELDS_INDEX:
-		case INIT_INDEX:
-			return FIELDS_INDEX;
-		default:
-			return category;
-		}
+		return switch (category) {
+			case STATIC_FIELDS_INDEX, STATIC_INIT_INDEX -> STATIC_FIELDS_INDEX;
+			case FIELDS_INDEX, INIT_INDEX -> FIELDS_INDEX;
+			default -> category;
+		};
 	}
 
-	private boolean isSortPreserved(BodyDeclaration bodyDeclaration) {
-		switch (bodyDeclaration.getNodeType()) {
-		case ASTNode.FIELD_DECLARATION:
-		case ASTNode.ENUM_CONSTANT_DECLARATION:
-		case ASTNode.INITIALIZER:
-			return true;
-		default:
-			return false;
-		}
-	}
+	private boolean isSortPreserved(BodyDeclaration bodyDeclaration) {return switch(bodyDeclaration.getNodeType()){case ASTNode.FIELD_DECLARATION,ASTNode.ENUM_CONSTANT_DECLARATION,ASTNode.INITIALIZER->true;default->false;};}
 
 	private int preserveRelativeOrder(BodyDeclaration bodyDeclaration1, BodyDeclaration bodyDeclaration2) {
 		int value1 = (Integer) bodyDeclaration1.getProperty(CompilationUnitSorter.RELATIVE_ORDER);

lib-extra/src/main/java/com/diffplug/spotless/extra/GitAttributesLineEndings.java

@@ -15,6 +15,10 @@
  */
 package com.diffplug.spotless.extra;
 
+import static com.diffplug.spotless.LineEnding.PLATFORM_NATIVE;
+import static com.diffplug.spotless.LineEnding.UNIX;
+import static com.diffplug.spotless.LineEnding.WINDOWS;
+
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
@@ -91,10 +95,9 @@ public LazyAllTheSame(File projectDir, Supplier<Iterable<File>> toFormat) {
 		protected String calculateState() throws Exception {
 			var files = toFormat.get().iterator();
 			if (files.hasNext()) {
-				Runtime runtime = new RuntimeInit(projectDir).atRuntime();
-				return runtime.getEndingFor(files.next());
+				return new RuntimeInit(projectDir).atRuntime().getEndingFor(files.next());
 			} else {
-				return LineEnding.UNIX.str();
+				return UNIX.str();
 			}
 		}
 
@@ -300,15 +303,14 @@ public String getEndingFor(File file) {
 		}
 
 		private static String convertEolToLineEnding(String eol, File file) {
-			switch (eol.toLowerCase(Locale.ROOT)) {
-			case "lf":
-				return LineEnding.UNIX.str();
-			case "crlf":
-				return LineEnding.WINDOWS.str();
-			default:
-				LOGGER.warn(".gitattributes file has unspecified eol value: {} for {}, defaulting to platform native", eol, file);
-				return LineEnding.PLATFORM_NATIVE.str();
-			}
+			return switch (eol.toLowerCase(Locale.ROOT)) {
+				case "lf" -> UNIX.str();
+				case "crlf" -> WINDOWS.str();
+				default -> {
+					LOGGER.warn(".gitattributes file has unspecified eol value: {} for {}, defaulting to platform native", eol, file);
+					yield PLATFORM_NATIVE.str();
+				}
+			};
 		}
 
 		private LineEnding findDefaultLineEnding(Config config) {
@@ -318,12 +320,12 @@ private LineEnding findDefaultLineEnding(Config config) {
 				// autocrlf=true converts CRLF->LF during commit
 				//               and converts LF->CRLF during checkout
 				// so CRLF is the default line ending
-				return LineEnding.WINDOWS;
+				return WINDOWS;
 			} else if (autoCRLF == AutoCRLF.INPUT) {
 				// autocrlf=input converts CRLF->LF during commit
 				//                and does no conversion during checkout
 				// mostly used on Unix, so LF is the default encoding
-				return LineEnding.UNIX;
+				return UNIX;
 			} else if (autoCRLF == AutoCRLF.FALSE) {
 				// handle core.eol
 				EOL eol = config.getEnum(ConfigConstants.CONFIG_CORE_SECTION, null, ConfigConstants.CONFIG_KEY_EOL, EOL.NATIVE);
@@ -335,14 +337,11 @@ private LineEnding findDefaultLineEnding(Config config) {
 
 		/** Creates a LineEnding from an EOL. */
 		private static LineEnding fromEol(EOL eol) {
-			// @formatter:off
-			switch (eol) {
-			case CRLF:    return LineEnding.WINDOWS;
-			case LF:      return LineEnding.UNIX;
-			case NATIVE:  return LineEnding.PLATFORM_NATIVE;
-			default: throw new IllegalArgumentException("Unknown eol " + eol);
-			}
-			// @formatter:on
+			return switch (eol) {
+				case CRLF -> WINDOWS;
+				case LF -> UNIX;
+				case NATIVE -> PLATFORM_NATIVE;
+			};
 		}
 	}
 

lib/src/ktfmt/java/com/diffplug/spotless/glue/ktfmt/KtfmtFormatterFunc.java

@@ -58,7 +58,6 @@ private FormattingOptions createFormattingOptions() throws Exception {
 			case META -> Formatter.META_FORMAT;
 			case GOOGLE -> Formatter.GOOGLE_FORMAT;
 			case KOTLIN_LANG -> Formatter.KOTLINLANG_FORMAT;
-			default -> throw new IllegalStateException("Unknown formatting option " + style);
 		};
 
 		if (ktfmtFormattingOptions != null) {

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

@@ -30,36 +30,53 @@
  * Represents the line endings which should be written by the tool.
  */
 public enum LineEnding {
-	// @formatter:off
-	/** Uses the same line endings as Git, using {@code .gitattributes} and the {@code core.eol} property. */
+	/**
+	 * Uses the same line endings as Git, using {@code .gitattributes} and the {@code core.eol} property.
+	 */
 	GIT_ATTRIBUTES {
 		/** .gitattributes is path-specific, so you must use {@link LineEnding#createPolicy(File, Supplier)}. */
-		@Override @Deprecated
+		@Override
+		@Deprecated
 		public Policy createPolicy() {
 			return super.createPolicy();
 		}
 	},
-	/** Uses the same line endings as Git, and assumes that every single file being formatted will have the same line ending. */
+	/**
+	 * Uses the same line endings as Git, and assumes that every single file being formatted will have the same line
+	 * ending.
+	 */
 	GIT_ATTRIBUTES_FAST_ALLSAME {
 		/** .gitattributes is path-specific, so you must use {@link LineEnding#createPolicy(File, Supplier)}. */
-		@Override @Deprecated
+		@Override
+		@Deprecated
 		public Policy createPolicy() {
 			return super.createPolicy();
 		}
 	},
-	/** {@code \n} on unix systems, {@code \r\n} on windows systems. */
+	/**
+	 * {@code \n} on unix systems, {@code \r\n} on windows systems.
+	 */
 	PLATFORM_NATIVE,
-	/** {@code \r\n} */
+	/**
+	 * {@code \r\n}
+	 */
 	WINDOWS,
-    /** {@code \n} */
-    UNIX,
-    /** {@code \r} */
-    MAC_CLASSIC,
-    /** preserve the line ending of the first line (no matter which format) */
-    PRESERVE;
-	// @formatter:on
-
-	/** Returns a {@link Policy} appropriate for files which are contained within the given rootFolder. */
+	/**
+	 * {@code \n}
+	 */
+	UNIX,
+	/**
+	 * {@code \r}
+	 */
+	MAC_CLASSIC,
+	/**
+	 * preserve the line ending of the first line (no matter which format)
+	 */
+	PRESERVE;
+
+	/**
+	 * Returns a {@link Policy} appropriate for files which are contained within the given rootFolder.
+	 */
 	public Policy createPolicy(File projectDir, Supplier<Iterable<File>> toFormat) {
 		Objects.requireNonNull(projectDir, "projectDir");
 		Objects.requireNonNull(toFormat, "toFormat");
@@ -76,25 +93,29 @@ public Policy createPolicy(File projectDir, Supplier<Iterable<File>> toFormat) {
 			Method method = clazz.getMethod(gitAttributesMethod, File.class, Supplier.class);
 			return ThrowingEx.get(() -> (Policy) method.invoke(null, projectDir, toFormat));
 		} catch (ClassNotFoundException | NoSuchMethodException | SecurityException e) {
-			throw new IllegalStateException("LineEnding.GIT_ATTRIBUTES requires the spotless-lib-extra library, but it is not on the classpath", e);
+			throw new IllegalStateException("LineEnding.GIT_ATTRIBUTES requires the spotless-lib-extra library, but it" +
+					" is not on the classpath", e);
 		}
 	}
 
-	// @formatter:off
-	/** Should use {@link #createPolicy(File, Supplier)} instead, but this will work iff its a path-independent LineEnding policy. */
+	/**
+	 * Should use {@link #createPolicy(File, Supplier)} instead, but this will work iff its a path-independent
+	 * LineEnding policy.
+	 */
 	public Policy createPolicy() {
-		switch (this) {
-		case PLATFORM_NATIVE:	return _PLATFORM_NATIVE_POLICY;
-		case WINDOWS:			return WINDOWS_POLICY;
-		case UNIX:				return UNIX_POLICY;
-		case MAC_CLASSIC:		return MAC_CLASSIC_POLICY;
-		case PRESERVE:			return PRESERVE_POLICY;
-		default:	throw new UnsupportedOperationException(this + " is a path-specific line ending.");
-		}
+		return switch (this) {
+			case PLATFORM_NATIVE -> _PLATFORM_NATIVE_POLICY;
+			case WINDOWS -> WINDOWS_POLICY;
+			case UNIX -> UNIX_POLICY;
+			case MAC_CLASSIC -> MAC_CLASSIC_POLICY;
+			case PRESERVE -> PRESERVE_POLICY;
+			default -> throw new UnsupportedOperationException(this + " is a path-specific line ending.");
+		};
 	}
 
 	static class ConstantLineEndingPolicy extends NoLambda.EqualityBasedOnSerialization implements Policy {
-		@Serial private static final long serialVersionUID = 1L;
+		@Serial
+		private static final long serialVersionUID = 1L;
 
 		final String lineEnding;
 
@@ -109,90 +130,99 @@ public String getEndingFor(File file) {
 	}
 
 	static class PreserveLineEndingPolicy extends NoLambda.EqualityBasedOnSerialization implements Policy {
-		@Serial private static final long serialVersionUID = 2L;
-
-        @Override
-        public String getEndingFor(File file) {
-            // assume US-ASCII encoding (only line ending characters need to be decoded anyways)
-            try (Reader reader = new FileReader(file, StandardCharsets.US_ASCII)) {
-                return getEndingFor(reader);
-            } catch (IOException e) {
-                throw new IllegalArgumentException("Could not determine line ending of file: " + file, e);
-            }
-        }
-
-        static String getEndingFor(Reader reader) throws IOException {
-            char previousCharacter = 0;
-            char currentCharacter = 0;
-            int readResult;
-            while ((readResult = reader.read()) != -1) {
-                currentCharacter = (char) readResult;
-                if (currentCharacter == '\n') {
-                    if (previousCharacter == '\r') {
-                        return WINDOWS.str();
-                    } else {
-                        return UNIX.str();
-                    }
-                } else {
-                    if (previousCharacter == '\r') {
-                        return MAC_CLASSIC.str();
-                    }
-                }
-                previousCharacter = currentCharacter;
-            }
-            if (previousCharacter == '\r') {
-                return MAC_CLASSIC.str();
-            }
-            // assume UNIX line endings if no line ending was found
-            return UNIX.str();
-        }
+		@Serial
+		private static final long serialVersionUID = 2L;
+
+		@Override
+		public String getEndingFor(File file) {
+			// assume US-ASCII encoding (only line ending characters need to be decoded anyways)
+			try (Reader reader = new FileReader(file, StandardCharsets.US_ASCII)) {
+				return getEndingFor(reader);
+			} catch (IOException e) {
+				throw new IllegalArgumentException("Could not determine line ending of file: " + file, e);
+			}
+		}
+
+		static String getEndingFor(Reader reader) throws IOException {
+			char previousCharacter = 0;
+			char currentCharacter;
+			int readResult;
+			while ((readResult = reader.read()) != -1) {
+				currentCharacter = (char) readResult;
+				if (currentCharacter == '\n') {
+					if (previousCharacter == '\r') {
+						return WINDOWS.str();
+					} else {
+						return UNIX.str();
+					}
+				} else {
+					if (previousCharacter == '\r') {
+						return MAC_CLASSIC.str();
+					}
+				}
+				previousCharacter = currentCharacter;
+			}
+			if (previousCharacter == '\r') {
+				return MAC_CLASSIC.str();
+			}
+			// assume UNIX line endings if no line ending was found
+			return UNIX.str();
+		}
 	}
 
 	private static final Policy WINDOWS_POLICY = new ConstantLineEndingPolicy(WINDOWS.str());
 	private static final Policy UNIX_POLICY = new ConstantLineEndingPolicy(UNIX.str());
-    private static final Policy MAC_CLASSIC_POLICY = new ConstantLineEndingPolicy(MAC_CLASSIC.str());
-    private static final Policy PRESERVE_POLICY = new PreserveLineEndingPolicy();
+	private static final Policy MAC_CLASSIC_POLICY = new ConstantLineEndingPolicy(MAC_CLASSIC.str());
+	private static final Policy PRESERVE_POLICY = new PreserveLineEndingPolicy();
 	private static final String _PLATFORM_NATIVE = System.getProperty("line.separator");
 	private static final Policy _PLATFORM_NATIVE_POLICY = new ConstantLineEndingPolicy(_PLATFORM_NATIVE);
 	private static final boolean NATIVE_IS_WIN = _PLATFORM_NATIVE.equals(WINDOWS.str());
 
 	/**
+	 * @see FileSignature#machineIsWin()
 	 * @deprecated Using the system-native line endings to detect the windows operating system has turned out
 	 * to be unreliable.  Use {@link FileSignature#machineIsWin()} instead.
-	 *
-	 * @see FileSignature#machineIsWin()
 	 */
 	@Deprecated
 	public static boolean nativeIsWin() {
 		return NATIVE_IS_WIN;
 	}
 
-	/** Returns the standard line ending for this policy. */
+	/**
+	 * Returns the standard line ending for this policy.
+	 */
 	public String str() {
-		switch (this) {
-		case PLATFORM_NATIVE:	return _PLATFORM_NATIVE;
-		case WINDOWS:			return "\r\n";
-		case UNIX:				return "\n";
-		case MAC_CLASSIC:		return "\r";
-		default:	throw new UnsupportedOperationException(this + " is a path-specific line ending.");
-		}
+		return switch (this) {
+			case PLATFORM_NATIVE -> _PLATFORM_NATIVE;
+			case WINDOWS -> "\r\n";
+			case UNIX -> "\n";
+			case MAC_CLASSIC -> "\r";
+			default -> throw new UnsupportedOperationException(this + " is a path-specific line ending.");
+		};
 	}
-	// @formatter:on
 
-	/** A policy for line endings which can vary based on the specific file being requested. */
+	/**
+	 * A policy for line endings which can vary based on the specific file being requested.
+	 */
 	public interface Policy extends Serializable, NoLambda {
-		/** Returns the line ending appropriate for the given file. */
+		/**
+		 * Returns the line ending appropriate for the given file.
+		 */
 		String getEndingFor(File file);
 
-		/** Returns true iff this file has unix line endings. */
+		/**
+		 * Returns true iff this file has unix line endings.
+		 */
 		public default boolean isUnix(File file) {
 			Objects.requireNonNull(file);
 			String ending = getEndingFor(file);
 			return ending.equals(UNIX.str());
 		}
 	}
 
-	/** Returns a string with exclusively unix line endings. */
+	/**
+	 * Returns a string with exclusively unix line endings.
+	 */
 	public static String toUnix(String input) {
 		int lastCarriageReturn = input.lastIndexOf('\r');
 		if (lastCarriageReturn == -1) {