Inline and remove AbstractingFormulaExtractor

This class is weirdly coupled with its subclasses. It uses a regex and
assumes that some arbitrary groups exist and have the correct meaning.
Furthermore, the exception handling handles
UncheckedUnParseableFormulaException specially which should also be an
implementation detail of the code that actually throws it. Last but not
least, it only saves redundant exception handling code (which is
dependent on the subclass) as the matching code has to be repeated by
CPPDiffLineFormulaExtractor anyways (also degrading performance as the
regex needs to be matched twice for no reason).

Author: ibbem

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

@@ -4,8 +4,10 @@
 import org.antlr.v4.runtime.CommonTokenStream;
 import org.prop4j.Node;
 import org.prop4j.Not;
+import org.tinylog.Logger;
+import org.variantsync.diffdetective.error.UncheckedUnParseableFormulaException;
 import org.variantsync.diffdetective.error.UnparseableFormulaException;
-import org.variantsync.diffdetective.feature.AbstractingFormulaExtractor;
+import org.variantsync.diffdetective.feature.DiffLineFormulaExtractor;
 import org.variantsync.diffdetective.feature.ParseErrorListener;
 import org.variantsync.diffdetective.feature.antlr.CExpressionLexer;
 import org.variantsync.diffdetective.feature.antlr.CExpressionParser;
@@ -22,15 +24,11 @@
  *
  * @author Paul Bittner, Sören Viegener, Benjamin Moosherr, Alexander Schultheiß
  */
-public class CPPDiffLineFormulaExtractor extends AbstractingFormulaExtractor {
+public class CPPDiffLineFormulaExtractor implements DiffLineFormulaExtractor {
     // ^[+-]?\s*#\s*(if|ifdef|ifndef|elif)(\s+(.*)|\((.*)\))$
     private static final String CPP_ANNOTATION_REGEX = "^[+-]?\\s*#\\s*(if|ifdef|ifndef|elif)([\\s(].*)$";
     private static final Pattern CPP_ANNOTATION_PATTERN = Pattern.compile(CPP_ANNOTATION_REGEX);
 
-    public CPPDiffLineFormulaExtractor() {
-        super(CPP_ANNOTATION_PATTERN);
-    }
-
     /**
      * Extracts and parses the feature formula from a macro line (possibly within a diff).
      *
@@ -39,38 +37,36 @@ public CPPDiffLineFormulaExtractor() {
      */
     @Override
     public Node extractFormula(final String line) throws UnparseableFormulaException {
-        // Delegate the formula extraction to AbstractingFormulaExtractor
-        Node fm = super.extractFormula(line);
-
-        // negate for ifndef
+        // Match the formula from the macro line
         final Matcher matcher = CPP_ANNOTATION_PATTERN.matcher(line);
-        if (matcher.find() && "ifndef".equals(matcher.group(1))) {
-            fm = new Not(fm);
+        if (!matcher.find()) {
+            throw new UnparseableFormulaException("Could not extract formula from line \"" + line + "\".");
         }
+        String annotationType = matcher.group(1);
+        String formula = matcher.group(2);
 
-        return fm;
-    }
+        // abstract complex formulas (e.g., if they contain arithmetics or macro calls)
+        Node parsedFormula;
+        try {
+            CExpressionLexer lexer = new CExpressionLexer(CharStreams.fromString(formula));
+            CommonTokenStream tokens = new CommonTokenStream(lexer);
 
-    /**
-     * Abstract the given formula.
-     * <p>
-     * First, the visitor uses ANTLR to parse the formula into a parse tree gives the tree to a {@link ControllingCExpressionVisitor}.
-     * The visitor traverses the tree starting from the root, searching for subtrees that must be abstracted.
-     * If such a subtree is found, the visitor calls an {@link AbstractingCExpressionVisitor} to abstract the part of
-     * the formula in the subtree.
-     * </p>
-     *
-     * @param formula that is to be abstracted
-     * @return the abstracted formula
-     */
-    @Override
-    protected Node abstractFormula(String formula) {
-        CExpressionLexer lexer = new CExpressionLexer(CharStreams.fromString(formula));
-        CommonTokenStream tokens = new CommonTokenStream(lexer);
+            CExpressionParser parser = new CExpressionParser(tokens);
+            parser.addErrorListener(new ParseErrorListener(formula));
+
+            parsedFormula = parser.expression().accept(new ControllingCExpressionVisitor());
+        } catch (UncheckedUnParseableFormulaException e) {
+            throw e.inner();
+        } catch (Exception e) {
+            Logger.warn(e);
+            throw new UnparseableFormulaException(e);
+        }
 
-        CExpressionParser parser = new CExpressionParser(tokens);
-        parser.addErrorListener(new ParseErrorListener(formula));
+        // negate for ifndef
+        if ("ifndef".equals(annotationType)) {
+            parsedFormula = new Not(parsedFormula);
+        }
 
-        return parser.expression().accept(new ControllingCExpressionVisitor());
+        return parsedFormula;
     }
 }

src/main/java/org/variantsync/diffdetective/feature/cpp/CPPDiffLineFormulaExtractor.java

@@ -4,11 +4,15 @@
 import org.antlr.v4.runtime.CommonTokenStream;
 import org.antlr.v4.runtime.tree.ParseTree;
 import org.prop4j.Node;
-import org.variantsync.diffdetective.feature.AbstractingFormulaExtractor;
+import org.tinylog.Logger;
+import org.variantsync.diffdetective.error.UncheckedUnParseableFormulaException;
+import org.variantsync.diffdetective.error.UnparseableFormulaException;
+import org.variantsync.diffdetective.feature.DiffLineFormulaExtractor;
 import org.variantsync.diffdetective.feature.ParseErrorListener;
 import org.variantsync.diffdetective.feature.antlr.JPPExpressionLexer;
 import org.variantsync.diffdetective.feature.antlr.JPPExpressionParser;
 
+import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 /**
@@ -20,14 +24,10 @@
  *
  * @author Alexander Schultheiß
  */
-public class JPPDiffLineFormulaExtractor extends AbstractingFormulaExtractor {
+public class JPPDiffLineFormulaExtractor implements DiffLineFormulaExtractor {
     private static final String JPP_ANNOTATION_REGEX = "^[+-]?\\s*//\\s*#\\s*(if|elif)([\\s(].*)$";
     private static final Pattern JPP_ANNOTATION_PATTERN = Pattern.compile(JPP_ANNOTATION_REGEX);
 
-    public JPPDiffLineFormulaExtractor() {
-        super(JPP_ANNOTATION_PATTERN);
-    }
-
     /**
      * Abstract the given formula.
      * <p>
@@ -36,16 +36,31 @@ public JPPDiffLineFormulaExtractor() {
      * If such a subtree is found, the visitor abstracts the part of the formula in the subtree.
      * </p>
      *
-     * @param formula that is to be abstracted
+     * @param line that contains the formula to be abstracted
      * @return the abstracted formula
      */
     @Override
-    protected Node abstractFormula(String formula) {
-        JPPExpressionLexer lexer = new JPPExpressionLexer(CharStreams.fromString(formula));
-        CommonTokenStream tokens = new CommonTokenStream(lexer);
-        JPPExpressionParser parser = new JPPExpressionParser(tokens);
-        parser.addErrorListener(new ParseErrorListener(formula));
-        ParseTree tree = parser.expression();
-        return tree.accept(new ControllingJPPExpressionVisitor());
+    public Node extractFormula(final String line) throws UnparseableFormulaException {
+        // Match the formula from the macro line
+        final Matcher matcher = JPP_ANNOTATION_PATTERN.matcher(line);
+        if (!matcher.find()) {
+            throw new UnparseableFormulaException("Could not extract formula from line \"" + line + "\".");
+        }
+        String formula = matcher.group(2);
+
+        // abstract complex formulas (e.g., if they contain arithmetics or macro calls)
+        try {
+            JPPExpressionLexer lexer = new JPPExpressionLexer(CharStreams.fromString(formula));
+            CommonTokenStream tokens = new CommonTokenStream(lexer);
+            JPPExpressionParser parser = new JPPExpressionParser(tokens);
+            parser.addErrorListener(new ParseErrorListener(formula));
+            ParseTree tree = parser.expression();
+            return tree.accept(new ControllingJPPExpressionVisitor());
+        } catch (UncheckedUnParseableFormulaException e) {
+            throw e.inner();
+        } catch (Exception e) {
+            Logger.warn(e);
+            throw new UnparseableFormulaException(e);
+        }
     }
 }