Fix ambiguities in the Lint class around treating it as data vs exception.

Author: nedtwigg

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

@@ -20,26 +20,61 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.Objects;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 /**
  * Models a linted line or line range. Note that there is no concept of severity level - responsibility
  * for severity and confidence are pushed down to the configuration of the lint tool. If a lint makes it
  * to Spotless, then it is by definition.
  */
 public final class Lint implements Serializable {
-	/** Returns a runtime exception which, if thrown, will create a lint at an undefined line. */
-	public static ShortcutException atUndefinedLine(String code, String msg) {
-		return new ShortcutException(Lint.create(code, msg, LINE_UNDEFINED));
+	public static Lint atUndefinedLine(String ruleId, String detail) {
+		return new Lint(LINE_UNDEFINED, ruleId, detail);
 	}
 
-	/** Returns a runtime exception which, if thrown, will lint a specific line. */
-	public static ShortcutException atLine(int line, String code, String msg) {
-		return new ShortcutException(Lint.create(code, msg, line));
+	public static Lint atLine(int line, String ruleId, String detail) {
+		return new Lint(line, ruleId, detail);
 	}
 
-	/** Returns a runtime exception which, if thrown, will lint a specific line range. */
-	public static ShortcutException atLineRange(int lineStart, int lineEnd, String code, String msg) {
-		return new ShortcutException(Lint.create(code, msg, lineStart, lineEnd));
+	public static Lint atLineRange(int lineStart, int lineEnd, String ruleId, String detail) {
+		return new Lint(lineStart, lineEnd, ruleId, detail);
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	private int lineStart, lineEnd; // 1-indexed, inclusive
+	private String ruleId; // e.g. CN_IDIOM https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#cn-class-implements-cloneable-but-does-not-define-or-use-clone-method-cn-idiom
+	private String detail;
+
+	private Lint(int lineStart, int lineEnd, String ruleId, String detail) {
+		if (lineEnd < lineStart) {
+			throw new IllegalArgumentException("lineEnd must be >= lineStart: lineStart=" + lineStart + " lineEnd=" + lineEnd);
+		}
+		this.lineStart = lineStart;
+		this.lineEnd = lineEnd;
+		this.ruleId = LineEnding.toUnix(ruleId);
+		this.detail = LineEnding.toUnix(detail);
+	}
+
+	private Lint(int line, String ruleId, String detail) {
+		this(line, line, ruleId, detail);
+	}
+
+	public int getLineStart() {
+		return lineStart;
+	}
+
+	public int getLineEnd() {
+		return lineEnd;
+	}
+
+	public String getRuleId() {
+		return ruleId;
+	}
+
+	public String getDetail() {
+		return detail;
 	}
 
 	/** Any exception which implements this interface will have its lints extracted and reported cleanly to the user. */
@@ -48,14 +83,15 @@ public interface Has {
 	}
 
 	/** An exception for shortcutting execution to report a lint to the user. */
-	public static class ShortcutException extends RuntimeException implements Has {
+	static class ShortcutException extends RuntimeException implements Has {
 		public ShortcutException(Lint... lints) {
 			this(Arrays.asList(lints));
 		}
 
 		private final List<Lint> lints;
 
-		public ShortcutException(Collection<Lint> lints) {
+		ShortcutException(Collection<Lint> lints) {
+			super(lints.iterator().next().detail);
 			this.lints = List.copyOf(lints);
 		}
 
@@ -65,56 +101,26 @@ public List<Lint> getLints() {
 		}
 	}
 
-	private static final long serialVersionUID = 1L;
-
-	private int lineStart, lineEnd; // 1-indexed, inclusive
-	private String code; // e.g. CN_IDIOM https://spotbugs.readthedocs.io/en/stable/bugDescriptions.html#cn-class-implements-cloneable-but-does-not-define-or-use-clone-method-cn-idiom
-	private String msg;
-
-	private Lint(int lineStart, int lineEnd, String lintCode, String lintMsg) {
-		this.lineStart = lineStart;
-		this.lineEnd = lineEnd;
-		this.code = LineEnding.toUnix(lintCode);
-		this.msg = LineEnding.toUnix(lintMsg);
+	/** Returns an exception which will wrap all of the given lints using {@link Has} */
+	public static RuntimeException shortcut(Collection<Lint> lints) {
+		return new ShortcutException(lints);
 	}
 
-	public static Lint create(String code, String msg, int lineStart, int lineEnd) {
-		if (lineEnd < lineStart) {
-			throw new IllegalArgumentException("lineEnd must be >= lineStart: lineStart=" + lineStart + " lineEnd=" + lineEnd);
-		}
-		return new Lint(lineStart, lineEnd, code, msg);
-	}
-
-	public static Lint create(String code, String msg, int line) {
-		return new Lint(line, line, code, msg);
-	}
-
-	public int getLineStart() {
-		return lineStart;
-	}
-
-	public int getLineEnd() {
-		return lineEnd;
-	}
-
-	public String getCode() {
-		return code;
-	}
-
-	public String getMsg() {
-		return msg;
+	/** Returns an exception which will wrap this lint using {@link Has} */
+	public RuntimeException shortcut() {
+		return new ShortcutException(this);
 	}
 
 	@Override
 	public String toString() {
 		if (lineStart == lineEnd) {
 			if (lineStart == LINE_UNDEFINED) {
-				return "LINE_UNDEFINED: (" + code + ") " + msg;
+				return "LINE_UNDEFINED: (" + ruleId + ") " + detail;
 			} else {
-				return lineStart + ": (" + code + ") " + msg;
+				return "L" + lineStart + ": (" + ruleId + ") " + detail;
 			}
 		} else {
-			return lineStart + "-" + lineEnd + ": (" + code + ") " + msg;
+			return "L" + lineStart + "-" + lineEnd + ": (" + ruleId + ") " + detail;
 		}
 	}
 
@@ -125,27 +131,36 @@ public boolean equals(Object o) {
 		if (o == null || getClass() != o.getClass())
 			return false;
 		Lint lint = (Lint) o;
-		return lineStart == lint.lineStart && lineEnd == lint.lineEnd && Objects.equals(code, lint.code) && Objects.equals(msg, lint.msg);
+		return lineStart == lint.lineStart && lineEnd == lint.lineEnd && Objects.equals(ruleId, lint.ruleId) && Objects.equals(detail, lint.detail);
 	}
 
 	@Override
 	public int hashCode() {
-		return Objects.hash(lineStart, lineEnd, code, msg);
+		return Objects.hash(lineStart, lineEnd, ruleId, detail);
 	}
 
 	/** Attempts to parse a line number from the given exception. */
-	static Lint createFromThrowable(FormatterStep step, String content, Throwable e) {
+	static Lint createFromThrowable(FormatterStep step, Throwable e) {
 		Throwable current = e;
 		while (current != null) {
 			String message = current.getMessage();
 			int lineNumber = lineNumberFor(message);
 			if (lineNumber != -1) {
-				return Lint.create(step.getName(), msgFrom(message), lineNumber);
+				return new Lint(lineNumber, step.getName(), msgFrom(message));
 			}
 			current = current.getCause();
 		}
-		int numNewlines = (int) content.codePoints().filter(c -> c == '\n').count();
-		return Lint.create(step.getName(), ThrowingEx.stacktrace(e), 1, 1 + numNewlines);
+		String exceptionName = e.getClass().getName();
+		String detail = ThrowingEx.stacktrace(e);
+		if (detail.startsWith(exceptionName + ": ")) {
+			detail = detail.substring(exceptionName.length() + 2);
+		}
+		Matcher matcher = Pattern.compile("line (\\d+)").matcher(detail);
+		int line = LINE_UNDEFINED;
+		if (matcher.find()) {
+			line = Integer.parseInt(matcher.group(1));
+		}
+		return Lint.atLine(line, exceptionName, detail);
 	}
 
 	private static int lineNumberFor(String message) {