| package org.checkerframework.framework.test.diagnostics; |
| |
| import java.io.File; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.LinkedHashSet; |
| import java.util.List; |
| import java.util.Set; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| import javax.tools.Diagnostic; |
| import javax.tools.JavaFileObject; |
| import org.checkerframework.checker.nullness.qual.EnsuresNonNullIf; |
| import org.checkerframework.checker.nullness.qual.Nullable; |
| import org.checkerframework.javacutil.Pair; |
| import org.plumelib.util.CollectionsPlume; |
| |
| /** A set of utilities and factory methods useful for working with TestDiagnostics. */ |
| public class TestDiagnosticUtils { |
| |
| /** How the diagnostics appear in Java source files. */ |
| public static final String DIAGNOSTIC_IN_JAVA_REGEX = |
| "\\s*(error|fixable-error|warning|fixable-warning|other):\\s*(\\(?.*\\)?)\\s*"; |
| /** How the diagnostics appear in Java source files. */ |
| public static final Pattern DIAGNOSTIC_IN_JAVA_PATTERN = |
| Pattern.compile(DIAGNOSTIC_IN_JAVA_REGEX); |
| |
| public static final String DIAGNOSTIC_WARNING_IN_JAVA_REGEX = "\\s*warning:\\s*(.*\\s*.*)\\s*"; |
| public static final Pattern DIAGNOSTIC_WARNING_IN_JAVA_PATTERN = |
| Pattern.compile(DIAGNOSTIC_WARNING_IN_JAVA_REGEX); |
| |
| // How the diagnostics appear in javax tools diagnostics from the compiler. |
| public static final String DIAGNOSTIC_REGEX = ":(\\d+):" + DIAGNOSTIC_IN_JAVA_REGEX; |
| public static final Pattern DIAGNOSTIC_PATTERN = Pattern.compile(DIAGNOSTIC_REGEX); |
| |
| public static final String DIAGNOSTIC_WARNING_REGEX = |
| ":(\\d+):" + DIAGNOSTIC_WARNING_IN_JAVA_REGEX; |
| public static final Pattern DIAGNOSTIC_WARNING_PATTERN = |
| Pattern.compile(DIAGNOSTIC_WARNING_REGEX); |
| |
| // How the diagnostics appear in diagnostic files (.out). |
| public static final String DIAGNOSTIC_FILE_REGEX = ".+\\.java" + DIAGNOSTIC_REGEX; |
| public static final Pattern DIAGNOSTIC_FILE_PATTERN = Pattern.compile(DIAGNOSTIC_FILE_REGEX); |
| |
| public static final String DIAGNOSTIC_FILE_WARNING_REGEX = ".+\\.java" + DIAGNOSTIC_WARNING_REGEX; |
| public static final Pattern DIAGNOSTIC_FILE_WARNING_PATTERN = |
| Pattern.compile(DIAGNOSTIC_FILE_WARNING_REGEX); |
| |
| /** |
| * Instantiate the diagnostic based on a string that would appear in diagnostic files (i.e. files |
| * that only contain line after line of expected diagnostics). |
| * |
| * @param stringFromDiagnosticFile a single diagnostic string to parse |
| * @return a new TestDiagnostic |
| */ |
| public static TestDiagnostic fromDiagnosticFileString(String stringFromDiagnosticFile) { |
| return fromPatternMatching( |
| DIAGNOSTIC_FILE_PATTERN, |
| DIAGNOSTIC_WARNING_IN_JAVA_PATTERN, |
| "", |
| null, |
| stringFromDiagnosticFile); |
| } |
| |
| /** |
| * Instantiate the diagnostic from a string that would appear in a Java file, e.g.: "error: |
| * (message)" |
| * |
| * @param filename the file containing the diagnostic (and the error) |
| * @param lineNumber the line number of the line immediately below the diagnostic comment in the |
| * Java file |
| * @param stringFromJavaFile the string containing the diagnostic |
| * @return a new TestDiagnostic |
| */ |
| public static TestDiagnostic fromJavaFileComment( |
| String filename, long lineNumber, String stringFromJavaFile) { |
| return fromPatternMatching( |
| DIAGNOSTIC_IN_JAVA_PATTERN, |
| DIAGNOSTIC_WARNING_IN_JAVA_PATTERN, |
| filename, |
| lineNumber, |
| stringFromJavaFile); |
| } |
| /** |
| * Instantiate a diagnostic from output produced by the Java compiler. The resulting diagnostic is |
| * never fixable and always has parentheses. |
| */ |
| public static TestDiagnostic fromJavaxToolsDiagnostic( |
| String diagnosticString, boolean noMsgText) { |
| // It would be nice not to parse this from the diagnostic string. |
| // However, diagnostic.toString() may contain "[unchecked]" even though getMessage() does not. |
| // Since we want to match the error messages reported by javac exactly, we must parse. |
| Pair<String, String> trimmed = formatJavaxToolString(diagnosticString, noMsgText); |
| return fromPatternMatching( |
| DIAGNOSTIC_PATTERN, DIAGNOSTIC_WARNING_PATTERN, trimmed.second, null, trimmed.first); |
| } |
| |
| /** |
| * Instantiate the diagnostic from a JSpecify string that would appear in a Java file, e.g.: |
| * "jspecify_some_category". |
| * |
| * @param filename the file containing the diagnostic (and the error) |
| * @param lineNumber the line number of the line immediately below the diagnostic comment in the |
| * Java file |
| * @param stringFromJavaFile the string containing the diagnostic |
| * @return a new TestDiagnostic |
| */ |
| public static TestDiagnostic fromJSpecifyFileComment( |
| String filename, long lineNumber, String stringFromJavaFile) { |
| return new TestDiagnostic( |
| filename, |
| lineNumber, |
| DiagnosticKind.JSpecify, |
| stringFromJavaFile, |
| /*isFixable=*/ false, |
| /*omitParentheses=*/ true); |
| } |
| |
| /** |
| * Instantiate the diagnostic via pattern-matching against patterns. |
| * |
| * @param diagnosticPattern a pattern that matches any diagnostic |
| * @param warningPattern a pattern that matches a warning diagnostic |
| * @param filename the file name |
| * @param lineNumber the line number |
| * @param diagnosticString the string to parse |
| * @return a diagnostic parsed from the given string |
| */ |
| @SuppressWarnings("nullness") // TODO: regular expression group access |
| protected static TestDiagnostic fromPatternMatching( |
| Pattern diagnosticPattern, |
| Pattern warningPattern, |
| String filename, |
| @Nullable Long lineNumber, |
| String diagnosticString) { |
| final DiagnosticKind kind; |
| final String message; |
| final boolean isFixable; |
| final boolean noParentheses; |
| long lineNo = -1; |
| int capturingGroupOffset = 1; |
| |
| if (lineNumber != null) { |
| lineNo = lineNumber; |
| capturingGroupOffset = 0; |
| } |
| |
| Matcher diagnosticMatcher = diagnosticPattern.matcher(diagnosticString); |
| if (diagnosticMatcher.matches()) { |
| Pair<DiagnosticKind, Boolean> categoryToFixable = |
| parseCategoryString(diagnosticMatcher.group(1 + capturingGroupOffset)); |
| kind = categoryToFixable.first; |
| isFixable = categoryToFixable.second; |
| String msg = diagnosticMatcher.group(2 + capturingGroupOffset).trim(); |
| noParentheses = msg.equals("") || msg.charAt(0) != '(' || msg.charAt(msg.length() - 1) != ')'; |
| message = noParentheses ? msg : msg.substring(1, msg.length() - 1); |
| |
| if (lineNumber == null) { |
| lineNo = Long.parseLong(diagnosticMatcher.group(1)); |
| } |
| |
| } else { |
| Matcher warningMatcher = warningPattern.matcher(diagnosticString); |
| if (warningMatcher.matches()) { |
| kind = DiagnosticKind.Warning; |
| isFixable = false; |
| message = warningMatcher.group(1 + capturingGroupOffset); |
| noParentheses = true; |
| |
| if (lineNumber == null) { |
| lineNo = Long.parseLong(diagnosticMatcher.group(1)); |
| } |
| |
| } else if (diagnosticString.startsWith("warning:")) { |
| kind = DiagnosticKind.Warning; |
| isFixable = false; |
| message = diagnosticString.substring("warning:".length()).trim(); |
| noParentheses = true; |
| if (lineNumber != null) { |
| lineNo = lineNumber; |
| } else { |
| lineNo = 0; |
| } |
| |
| } else { |
| kind = DiagnosticKind.Other; |
| isFixable = false; |
| message = diagnosticString; |
| noParentheses = true; |
| |
| // this should only happen if we are parsing a Java Diagnostic from the compiler |
| // that we did do not handle |
| if (lineNumber == null) { |
| lineNo = -1; |
| } |
| } |
| } |
| return new TestDiagnostic(filename, lineNo, kind, message, isFixable, noParentheses); |
| } |
| |
| /** |
| * Given a javax diagnostic, return a pair of (trimmed, fileame), where "trimmed" is the first |
| * line of the message, without the leading filename. |
| * |
| * @param original a javax diagnostic |
| * @param noMsgText whether to do work; if false, this returns a pair of (argument, ""). |
| * @return the diagnostic, split into message and filename |
| */ |
| public static Pair<String, String> formatJavaxToolString(String original, boolean noMsgText) { |
| String trimmed = original; |
| String filename = ""; |
| if (noMsgText) { |
| if (!retainAllLines(trimmed)) { |
| int lineSepPos = trimmed.indexOf(System.lineSeparator()); |
| if (lineSepPos != -1) { |
| trimmed = trimmed.substring(0, lineSepPos); |
| } |
| |
| int extensionPos = trimmed.indexOf(".java:"); |
| if (extensionPos != -1) { |
| int basenameStart = trimmed.lastIndexOf(File.separator); |
| filename = trimmed.substring(basenameStart + 1, extensionPos + 5).trim(); |
| trimmed = trimmed.substring(extensionPos + 5).trim(); |
| } |
| } |
| } |
| |
| return Pair.of(trimmed, filename); |
| } |
| |
| /** |
| * Returns true if all lines of the message should be shown, false if only the first line should |
| * be shown. |
| * |
| * @param message a diagnostic message |
| * @return true if all lines of the message should be shown |
| */ |
| private static boolean retainAllLines(String message) { |
| // Retain all if it is a thrown exception "unexpected Throwable" or it is a Checker Framework |
| // Error (contains "Compilation unit") or is OutOfMemoryError. |
| return message.contains("unexpected Throwable") |
| || message.contains("Compilation unit") |
| || message.contains("OutOfMemoryError"); |
| } |
| |
| /** |
| * Given a category string that may be prepended with "fixable-", return the category enum that |
| * corresponds with the category and whether or not it is a isFixable error |
| */ |
| private static Pair<DiagnosticKind, Boolean> parseCategoryString(String category) { |
| final String fixable = "fixable-"; |
| final boolean isFixable = category.startsWith(fixable); |
| if (isFixable) { |
| category = category.substring(fixable.length()); |
| } |
| DiagnosticKind categoryEnum = DiagnosticKind.fromParseString(category); |
| if (categoryEnum == null) { |
| throw new Error("Unparsable category: " + category); |
| } |
| |
| return Pair.of(categoryEnum, isFixable); |
| } |
| |
| /** |
| * Return true if this line in a Java file indicates an expected diagnostic that might be |
| * continued on the next line. |
| */ |
| public static boolean isJavaDiagnosticLineStart(String originalLine) { |
| final String trimmedLine = originalLine.trim(); |
| return trimmedLine.startsWith("// ::") || trimmedLine.startsWith("// warning:"); |
| } |
| |
| /** |
| * Convert an end-of-line diagnostic message to a beginning-of-line one. Returns the argument |
| * unchanged if it does not contain an end-of-line diagnostic message. |
| * |
| * <p>Most diagnostics in Java files start at the beginning of a line. Occasionally, javac issues |
| * a warning about implicit code, such as an implicit constructor, on the line <em>immediately |
| * after</em> a curly brace. The only place to put the expected diagnostic message is on the line |
| * with the curly brace. |
| * |
| * <p>This implementation replaces "{ // ::" by "// ::", converting the end-of-line diagnostic |
| * message to a beginning-of-line one that the rest of the code can handle. It is rather specific |
| * (to avoid false positive matches, such as when "// ::" is commented out in source code). It |
| * could be extended in the future if such an extension is necessary. |
| */ |
| public static String handleEndOfLineJavaDiagnostic(String originalLine) { |
| int curlyIndex = originalLine.indexOf("{ // ::"); |
| if (curlyIndex == -1) { |
| return originalLine; |
| } else { |
| return originalLine.substring(curlyIndex + 2); |
| } |
| } |
| |
| /** Return true if this line in a Java file continues an expected diagnostic. */ |
| @EnsuresNonNullIf(result = true, expression = "#1") |
| public static boolean isJavaDiagnosticLineContinuation(@Nullable String originalLine) { |
| if (originalLine == null) { |
| return false; |
| } |
| final String trimmedLine = originalLine.trim(); |
| // Unlike with errors, there is no logic elsewhere for splitting multiple "warning:"s. So, |
| // avoid concatenating them. Also, each one must begin a line. They are allowed to wrap to |
| // the next line, though. |
| return trimmedLine.startsWith("// ") && !trimmedLine.startsWith("// warning:"); |
| } |
| |
| /** |
| * Return the continuation part. The argument is such that {@link |
| * #isJavaDiagnosticLineContinuation} returns true. |
| */ |
| public static String continuationPart(String originalLine) { |
| return originalLine.trim().substring(2).trim(); |
| } |
| |
| /** |
| * Convert a line in a Java source file to a TestDiagnosticLine. |
| * |
| * <p>The input {@code line} is possibly the concatenation of multiple source lines, if the |
| * diagnostic was split across lines in the source code. |
| */ |
| public static TestDiagnosticLine fromJavaSourceLine( |
| String filename, String line, long lineNumber) { |
| final String trimmedLine = line.trim(); |
| long errorLine = lineNumber + 1; |
| |
| if (trimmedLine.startsWith("// ::")) { |
| String restOfLine = trimmedLine.substring(5); // drop the "// ::" |
| String[] diagnosticStrs = restOfLine.split("::"); |
| List<TestDiagnostic> diagnostics = |
| CollectionsPlume.mapList( |
| (String diagnostic) -> fromJavaFileComment(filename, errorLine, diagnostic), |
| diagnosticStrs); |
| return new TestDiagnosticLine( |
| filename, errorLine, line, Collections.unmodifiableList(diagnostics)); |
| |
| } else if (trimmedLine.startsWith("// warning:")) { |
| // This special diagnostic does not expect a line number nor a file name |
| String diagnosticString = trimmedLine.substring(2); |
| TestDiagnostic diagnostic = fromJavaFileComment("", 0, diagnosticString); |
| return new TestDiagnosticLine("", 0, line, Collections.singletonList(diagnostic)); |
| } else if (trimmedLine.startsWith("//::")) { |
| TestDiagnostic diagnostic = |
| new TestDiagnostic( |
| filename, |
| lineNumber, |
| DiagnosticKind.Error, |
| "Use \"// ::\", not \"//::\"", |
| false, |
| true); |
| return new TestDiagnosticLine( |
| filename, lineNumber, line, Collections.singletonList(diagnostic)); |
| } else if (trimmedLine.startsWith("// jspecify_")) { |
| TestDiagnostic diagnostic = |
| fromJSpecifyFileComment(filename, errorLine, trimmedLine.substring(3)); |
| return new TestDiagnosticLine( |
| filename, errorLine, line, Collections.singletonList(diagnostic)); |
| } else { |
| // It's a bit gross to create empty diagnostics (returning null might be more |
| // efficient), but they will be filtered out later. |
| return new TestDiagnosticLine(filename, errorLine, line, Collections.emptyList()); |
| } |
| } |
| |
| /** Convert a line in a DiagnosticFile to a TestDiagnosticLine. */ |
| public static TestDiagnosticLine fromDiagnosticFileLine(String diagnosticLine) { |
| final String trimmedLine = diagnosticLine.trim(); |
| if (trimmedLine.startsWith("#") || trimmedLine.isEmpty()) { |
| return new TestDiagnosticLine("", -1, diagnosticLine, Collections.emptyList()); |
| } |
| |
| TestDiagnostic diagnostic = fromDiagnosticFileString(diagnosticLine); |
| return new TestDiagnosticLine( |
| "", diagnostic.getLineNumber(), diagnosticLine, Arrays.asList(diagnostic)); |
| } |
| |
| public static Set<TestDiagnostic> fromJavaxDiagnosticList( |
| List<Diagnostic<? extends JavaFileObject>> javaxDiagnostics, boolean noMsgText) { |
| Set<TestDiagnostic> diagnostics = new LinkedHashSet<>(javaxDiagnostics.size()); |
| |
| for (Diagnostic<? extends JavaFileObject> diagnostic : javaxDiagnostics) { |
| // See TestDiagnosticUtils as to why we use diagnostic.toString rather |
| // than convert from the diagnostic itself |
| final String diagnosticString = diagnostic.toString(); |
| |
| // suppress Xlint warnings |
| if (diagnosticString.contains("uses unchecked or unsafe operations.") |
| || diagnosticString.contains("Recompile with -Xlint:unchecked for details.") |
| || diagnosticString.endsWith(" declares unsafe vararg methods.") |
| || diagnosticString.contains("Recompile with -Xlint:varargs for details.")) { |
| continue; |
| } |
| |
| diagnostics.add(TestDiagnosticUtils.fromJavaxToolsDiagnostic(diagnosticString, noMsgText)); |
| } |
| |
| return diagnostics; |
| } |
| |
| /** |
| * Converts the given diagnostics to strings (as they would appear in a source file individually). |
| * |
| * @param diagnostics a list of diagnostics |
| * @return a list of the diagnastics as they would appear in a source file |
| */ |
| public static List<String> diagnosticsToString(List<TestDiagnostic> diagnostics) { |
| return CollectionsPlume.mapList(TestDiagnostic::toString, diagnostics); |
| } |
| |
| public static void removeDiagnosticsOfKind( |
| DiagnosticKind kind, List<TestDiagnostic> expectedDiagnostics) { |
| for (int i = 0; i < expectedDiagnostics.size(); /*no-increment*/ ) { |
| if (expectedDiagnostics.get(i).getKind() == kind) { |
| expectedDiagnostics.remove(i); |
| } else { |
| ++i; |
| } |
| } |
| } |
| } |
