Keep all special characters in boolean abstraction

Replacing special characters in variable names is mostly necessary to
adhere to the grammar supported by the FeatureIDE parser for `Node`s.
However, we already do our own parsing using Antlr4 so we can skip this
step by building the `Node` tree our selves. This also removes one more
source of bugs because overall there is less code involved.

Beware that this introduces a semantic change: The new JPP parser
abstracts `!defined(property)` to a negative literal `defined(property)`
instead of a positive literal with a prefix denoting the negation.

Author: ibbem

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

@@ -1,14 +1,10 @@
 package org.variantsync.diffdetective.feature;
 
-import org.prop4j.Literal;
 import org.prop4j.Node;
-import org.prop4j.NodeReader;
 import org.tinylog.Logger;
 import org.variantsync.diffdetective.error.UncheckedUnParseableFormulaException;
 import org.variantsync.diffdetective.error.UnparseableFormulaException;
-import org.variantsync.diffdetective.util.fide.FixTrueFalse;
 
-import java.util.function.Supplier;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -47,8 +43,6 @@ public AbstractingFormulaExtractor(Pattern annotationPattern) {
     @Override
     public Node extractFormula(final String text) throws UnparseableFormulaException {
         final Matcher matcher = annotationPattern.matcher(text);
-        final Supplier<UnparseableFormulaException> couldNotExtractFormula = () ->
-                new UnparseableFormulaException("Could not extract formula from line \"" + text + "\".");
 
         // Retrieve the formula from the macro line
         String fm;
@@ -59,50 +53,18 @@ public Node extractFormula(final String text) throws UnparseableFormulaException
                 fm = matcher.group(4);
             }
         } else {
-            throw couldNotExtractFormula.get();
+            throw new UnparseableFormulaException("Could not extract formula from line \"" + text + "\".");
         }
 
         // abstract complex formulas (e.g., if they contain arithmetics or macro calls)
         try {
-            fm = abstractFormula(fm);
+            return abstractFormula(fm);
         } catch (UncheckedUnParseableFormulaException e) {
             throw e.inner();
         } catch (Exception e) {
             Logger.warn(e);
             throw new UnparseableFormulaException(e);
         }
-
-        if (fm.isEmpty()) {
-            throw couldNotExtractFormula.get();
-        }
-
-        return parseFormula(fm);
-    }
-
-    /**
-     * Parser that uses the {@link NodeReader} from FeatureIDE and uses its
-     * {@link NodeReader#activateJavaSymbols() java symbols} to match operators.
-     */
-    protected Node parseFormula(String text) {
-        final NodeReader nodeReader = new NodeReader();
-        nodeReader.activateJavaSymbols();
-
-        Node node = nodeReader.stringToNode(text);
-
-        // if parsing succeeded
-        if (node != null) {
-            // TODO: Is this our desired behaviour?
-            //       If so, should we document it by not using get here
-            //       and instead keeping the witness that this call happened?
-            node = FixTrueFalse.EliminateTrueAndFalseInplace(node).get();
-        }
-
-        if (node == null) {
-//            Logger.warn("Could not parse expression '{}' to feature mapping. Usin>
-            node = new Literal(text);
-        }
-
-        return node;
     }
 
     /**
@@ -113,5 +75,5 @@ protected Node parseFormula(String text) {
      * @param formula that is to be abstracted
      * @return the abstracted formula
      */
-    protected abstract String abstractFormula(String formula);
+    protected abstract Node abstractFormula(String formula);
 }