refactor: Simplify the annotation parsing interfaces

Author: ibbem

src/main/java/org/variantsync/diffdetective/datasets/predefined/Marlin.java

@@ -2,7 +2,8 @@
 
 import org.variantsync.diffdetective.datasets.PatchDiffParseOptions;
 import org.variantsync.diffdetective.datasets.Repository;
-import org.variantsync.diffdetective.feature.PreprocessorAnnotationParser;
+import org.variantsync.diffdetective.feature.AnnotationParser;
+import org.variantsync.diffdetective.feature.cpp.CPPAnnotationParser;
 
 import java.nio.file.Path;
 
@@ -12,9 +13,9 @@
  * @author Kevin Jedelhauser, Paul Maximilian Bittner
  */
 public class Marlin {
-    public static final PreprocessorAnnotationParser ANNOTATION_PARSER =
-            PreprocessorAnnotationParser.CreateCppAnnotationParser(
-                    new MarlinCPPDiffLineFormulaExtractor()
+    public static final AnnotationParser ANNOTATION_PARSER =
+            new CPPAnnotationParser(
+                    // TODO new MarlinCPPDiffLineFormulaExtractor()
             );
 
     /**

src/main/java/org/variantsync/diffdetective/datasets/predefined/MarlinCPPDiffLineFormulaExtractor.java

@@ -1,6 +1,6 @@
 package org.variantsync.diffdetective.datasets.predefined;
 
-import org.variantsync.diffdetective.feature.cpp.CPPDiffLineFormulaExtractor;
+import org.variantsync.diffdetective.feature.DiffLineFormulaExtractor;
 
 import java.util.regex.Pattern;
 
@@ -11,7 +11,7 @@
  *
  * @author Paul Bittner
  */
-public class MarlinCPPDiffLineFormulaExtractor extends CPPDiffLineFormulaExtractor {
+public class MarlinCPPDiffLineFormulaExtractor implements DiffLineFormulaExtractor {
     private static final Pattern ENABLED_PATTERN = Pattern.compile("ENABLED\\s*\\(([^)]*)\\)");
     private static final Pattern DISABLED_PATTERN = Pattern.compile("DISABLED\\s*\\(([^)]*)\\)");
 
@@ -20,7 +20,7 @@ public String resolveFeatureMacroFunctions(String formula) {
         return
                 replaceAll(ENABLED_PATTERN, "$1",
                         replaceAll(DISABLED_PATTERN, "!($1)",
-                                super.resolveFeatureMacroFunctions(formula)));
+                                formula));
     }
 
     private String replaceAll(Pattern pattern, String replacement, String string) {

src/main/java/org/variantsync/diffdetective/feature/Annotation.java

@@ -0,0 +1,38 @@
+package org.variantsync.diffdetective.feature;
+
+import org.prop4j.Node;
+
+/**
+ * Represents a new annotation (i.e., a change in the presence condition).
+ * This includes, {@link AnnotationType#If adding to the presence condition},
+ * {@link AnnotationType#Endif removing the most recent formula}
+ * and {@link AnnotationType others}.
+ *
+ * @param type the type of this annotation
+ * @param formula the formula associated to {@code type}.
+ * Non-null iff {@link AnnotationType#requiresFormula type.requiresFormula}.
+ */
+public record Annotation(
+    AnnotationType type,
+    Node formula
+) {
+    public Annotation(AnnotationType type, Node formula) {
+        this.type = type;
+        this.formula = formula;
+
+        if (type.requiresFormula && formula == null) {
+            throw new IllegalArgumentException("Annotations of type " + type.name + " but got null");
+        }
+        if (!type.requiresFormula && formula != null) {
+            throw new IllegalArgumentException("Annotations of type " + type.name + " do not accept a formula but it was given " + formula);
+        }
+    }
+
+    /**
+     * Equivalent to {@link #Annotation(AnnotationType, Node) Annotation(type, null)}.
+     * Hence, only useable iff {@link AnnotationType#requiresFormula !type.requiresFormula}.
+     */
+    public Annotation(AnnotationType type) {
+        this(type, null);
+    }
+}

src/main/java/org/variantsync/diffdetective/feature/AnnotationParser.java

@@ -1,31 +1,23 @@
 package org.variantsync.diffdetective.feature;
 
-import org.prop4j.Node;
 import org.variantsync.diffdetective.error.UnparseableFormulaException;
 
 /**
  * Interface for a parser that analyzes annotations in parsed text. The parser is responsible for determining the type
- * of the annotation (see {@link AnnotationType}), and parsing the annotation into a {@link Node}.
+ * of the annotation (see {@link AnnotationType}), and parsing the annotation into a {@link org.prop4j.Node}.
  * <p>
  * See {@link PreprocessorAnnotationParser} for an example of how an implementation of AnnotationParser could look like.
  * </p>
  */
 public interface AnnotationParser {
     /**
-     * Determine the annotation type for the given piece of text (typically a line of source code).
+     * Parse the given line as an annotation.
+     * Note that {@code line} might also be a line in a diff (i.e., preceded by {@code -} or {@code +}).
      *
-     * @param text The text of which the type is determined.
-     * @return The annotation type of the piece of text.
+     * @param line that might contain an annotation
+     * @return the annotation type and the associated formula.
+     * If {@code line} doesn't contain an annotation, returns {@code Annotation(AnnotationType.NONE)}.
+     * @throws UnparseableFormulaException if an annotation is detected but it is malformed
      */
-    AnnotationType determineAnnotationType(String text);
-
-    /**
-     * Parse the condition of the given text containing an annotation (typically a line of source code).
-     *
-     * @param text The text containing a conditional annotation
-     * @return The formula of the condition in the given annotation.
-     * If no such formula could be extracted, returns a Literal with the line's condition as name.
-     * @throws UnparseableFormulaException if there is an error while parsing.
-     */
-    Node parseAnnotation(String text) throws UnparseableFormulaException;
+    Annotation parseAnnotation(String line) throws UnparseableFormulaException;
 }

src/main/java/org/variantsync/diffdetective/feature/AnnotationType.java

@@ -9,34 +9,39 @@ public enum AnnotationType {
      * The piece of text (e.g., "#if ...") contains a conditional annotation that starts a new
      * annotated subtree in the variation tree.
      */
-    If("if"),
+    If("if", true),
 
     /**
      * The piece of text (e.g., "#elif ...") contains a conditional annotation which is only checked
      * if the conditions of all preceding annotations belonging to the same annotation chain are not fulfilled.
      */
-    Elif("elif"),
+    Elif("elif", true),
 
     /**
      * The piece of text (e.g., "#else") contains an annotation that marks a subtree as used alternative
      * if the condition of the preceding annotation in the same annotation chain is not fulfilled.
      */
-    Else("else"),
+    Else("else", false),
 
     /**
      * The piece of text (e.g., "#endif") marks the end of an annotation (chain).
      */
-    Endif("endif"),
+    Endif("endif", false),
 
     /**
      * The piece of text contains no annotation. This usually means that it contains an artifact.
      */
-    None("NONE");
+    None("NONE", false);
 
     public final String name;
+    /**
+     * Does this type of annotation require a formula?
+     */
+    public final boolean requiresFormula;
 
-    AnnotationType(String name) {
+    AnnotationType(String name, boolean requiresFormula) {
         this.name = name;
+        this.requiresFormula = requiresFormula;
     }
 
     /**

src/main/java/org/variantsync/diffdetective/feature/DiffLineFormulaExtractor.java

@@ -16,14 +16,6 @@
  * @author Paul Bittner, Sören Viegener, Benjamin Moosherr, Alexander Schultheiß
  */
 public interface DiffLineFormulaExtractor {
-    /**
-     * Extracts the feature formula as a string from a line (possibly within a diff).
-     *
-     * @param line The line of which to get the feature mapping
-     * @return The feature mapping as a String of the given line
-     */
-    Node extractFormula(final String line) throws UnparseableFormulaException;
-
     /**
      * Resolves any macros in the given formula that are relevant for feature annotations.
      * For example, in {@link org.variantsync.diffdetective.datasets.predefined.MarlinCPPDiffLineFormulaExtractor Marlin},

src/main/java/org/variantsync/diffdetective/feature/PreprocessorAnnotationParser.java

@@ -2,104 +2,90 @@
 
 import org.prop4j.Node;
 import org.variantsync.diffdetective.error.UnparseableFormulaException;
-import org.variantsync.diffdetective.feature.cpp.CPPDiffLineFormulaExtractor;
-import org.variantsync.diffdetective.feature.jpp.JPPDiffLineFormulaExtractor;
-
+import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 /**
  * A parser of preprocessor-like annotations.
  *
  * @author Paul Bittner, Alexander Schultheiß
+ * @see org.variantsync.diffdetective.feature.cpp.CPPAnnotationParser
+ * @see org.variantsync.diffdetective.feature.jpp.JPPAnnotationParser
  */
-public class PreprocessorAnnotationParser implements AnnotationParser {
-    /**
-     * Matches the beginning or end of CPP conditional macros.
-     * It doesn't match the whole macro name, for example for {@code #ifdef} only {@code "#if"} is
-     * matched and only {@code "if"} is captured.
-     * <p>
-     * Note that this pattern doesn't handle comments between {@code #} and the macro name.
-     */
-    protected final static Pattern CPP_PATTERN =
-            Pattern.compile("^[+-]?\\s*#\\s*(if|elif|else|endif)");
-
+public abstract class PreprocessorAnnotationParser implements AnnotationParser {
     /**
-     * Matches the beginning or end of JPP conditional macros.
-     * It doesn't match the whole macro name, for example for {@code //#if defined(x)} only {@code "//#if"} is
-     * matched and only {@code "if"} is captured.
+     * Pattern that is used to extract the {@link AnnotationType} and the associated {@link org.prop4j.Node formula}.
      * <p>
+     * The pattern needs to contain at least the two named capture groups {@code directive} and {@code formula}.
+     * The {@code directive} group must match a string that can be processed by {@link #parseAnnotationType}
+     * and whenever the resulting annotation type {@link AnnotationType#requiresFormula requires a formula},
+     * the capture group {@code formula} needs to match the formula that should be processed by {@link parseFormula}.
      */
-    protected final static Pattern JPP_PATTERN =
-            Pattern.compile("^[+-]?\\s*//\\s*#\\s*(if|elif|else|endif)");
-
-    /**
-     * Default parser for C preprocessor annotations.
-     * Created by invoking {@link #PreprocessorAnnotationParser(Pattern, DiffLineFormulaExtractor)}.
-     */
-    public static final PreprocessorAnnotationParser CPPAnnotationParser =
-            new PreprocessorAnnotationParser(CPP_PATTERN, new CPPDiffLineFormulaExtractor());
-
-    /**
-     * Default parser for <a href="https://www.slashdev.ca/javapp/">JavaPP (Java PreProcessor)</a> annotations.
-     * Created by invoking {@link #PreprocessorAnnotationParser(Pattern, DiffLineFormulaExtractor)}.
-     */
-    public static final PreprocessorAnnotationParser JPPAnnotationParser =
-            new PreprocessorAnnotationParser(JPP_PATTERN, new JPPDiffLineFormulaExtractor());
-
-    // Pattern that is used to identify the AnnotationType of a given annotation.
-    private final Pattern annotationPattern;
-    private final DiffLineFormulaExtractor extractor;
+    protected final Pattern annotationPattern;
 
     /**
      * Creates a new preprocessor annotation parser.
      *
-     * @param annotationPattern Pattern that is used to identify the AnnotationType of a given annotation; {@link #CPP_PATTERN} provides an example
-     * @param formulaExtractor  An extractor that extracts the formula part of a preprocessor annotation
+     * @param annotationPattern pattern that identifies the {@link AnnotationType} and the associated {@link org.prop4j.Node formula} of an annotation
+     * @see #annotationPattern
      */
-    public PreprocessorAnnotationParser(final Pattern annotationPattern, DiffLineFormulaExtractor formulaExtractor) {
+    public PreprocessorAnnotationParser(Pattern annotationPattern) {
         this.annotationPattern = annotationPattern;
-        this.extractor = formulaExtractor;
     }
 
-    /**
-     * Creates a new preprocessor annotation parser for C preprocessor annotations.
-     *
-     * @param formulaExtractor An extractor that extracts the formula part of a preprocessor annotation
-     */
-    public static PreprocessorAnnotationParser CreateCppAnnotationParser(DiffLineFormulaExtractor formulaExtractor) {
-        return new PreprocessorAnnotationParser(CPP_PATTERN, formulaExtractor);
+    @Override
+    public Annotation parseAnnotation(final String line) throws UnparseableFormulaException {
+        // Match the formula from the macro line
+        final Matcher matcher = annotationPattern.matcher(line);
+        if (!matcher.find()) {
+            return new Annotation(AnnotationType.None);
+        }
+        String directive = matcher.group("directive");
+        String formula = matcher.group("formula");
+        AnnotationType annotationType = parseAnnotationType(directive);
+
+        if (!annotationType.requiresFormula) {
+            return new Annotation(annotationType);
+        }
+
+        if (annotationType.requiresFormula && formula == null) {
+            throw new UnparseableFormulaException("Annotations of type " + annotationType.name + " require a formula but none was given");
+        }
+
+        return new Annotation(annotationType, parseFormula(directive, formula));
     }
 
     /**
-     * Creates a new preprocessor annotation parser for <a href="https://www.slashdev.ca/javapp/">JavaPP (Java PreProcessor)</a> annotations.
-     *
-     * @param formulaExtractor An extractor that extracts the formula part of a preprocessor annotation
+     * Converts the string captured by the named capture group {@code directive} of {@link #annotationPattern} into an {@link AnnotationType}.
      */
-    public static PreprocessorAnnotationParser CreateJppAnnotationParser(DiffLineFormulaExtractor formulaExtractor) {
-        return new PreprocessorAnnotationParser(JPP_PATTERN, formulaExtractor);
+    protected AnnotationType parseAnnotationType(String directive) {
+        if (directive.startsWith("if")) {
+            return AnnotationType.If;
+        } else if (directive.startsWith("elif")) {
+            return AnnotationType.Elif;
+        } else if (directive.equals("else")) {
+            return AnnotationType.Else;
+        } else if (directive.equals("endif")) {
+            return AnnotationType.Endif;
+        }
+
+        throw new IllegalArgumentException("The directive " + directive + " is not a valid conditional compilation directive");
     }
 
     /**
-     * Parses the condition of the given line of source code that contains a preprocessor macro (i.e., IF, IFDEF, ELIF).
+     * Parses the feature formula of a preprocessor annotation line.
+     * It should abstract complex formulas (e.g., if they contain arithmetics or macro calls) as desired.
+     * For example, for the line {@code "#if A && B == C"},
+     * this method is should be called like {@code parseFormula("if", "A && B == C")}
+     * (the exact arguments are determined by {@link annotationPattern}
+     * and it should return something like {@code and(var("A"), var("B==C"))}.
+     * <p>
+     * This method is only called if {@code directive} actually requires a formula as determined by {@link #parseAnnotationType}.
      *
-     * @param line The line of code of a preprocessor annotation.
-     * @return The formula of the macro in the given line.
-     * If no such formula could be parsed, returns a Literal with the line's condition as name.
-     * @throws UnparseableFormulaException when {@link DiffLineFormulaExtractor#extractFormula(String)} throws.
+     * @param directive as matched by the named capture group {@code directive} of {@link annotationPattern}
+     * @param formula as matched by the named capture group {@code formula} of {@link annotationPattern}
+     * @return the feature mapping
+     * @throws UnparseableFormulaException if {@code formula} is ill-formed.
      */
-    @Override
-    public Node parseAnnotation(String line) throws UnparseableFormulaException {
-        return extractor.extractFormula(line);
-    }
-
-    @Override
-    public AnnotationType determineAnnotationType(String text) {
-        var matcher = annotationPattern.matcher(text);
-        int nameId = 1;
-        if (matcher.find()) {
-            return AnnotationType.fromName(matcher.group(nameId));
-        } else {
-            return AnnotationType.None;
-        }
-    }
+    protected abstract Node parseFormula(String directive, String formula) throws UnparseableFormulaException;
 }