debugging progress

Author: pmbittner

src/main/java/org/variantsync/diffdetective/experiments/views/ViewAnalysis.java

@@ -43,6 +43,8 @@ public void initializeResults(Analysis analysis) {
     private void runQueryExperiment(Analysis analysis, final DiffTree d, final Query q) {
         final long preprocessingTime, naiveTime, optimizedTime;
 
+        //Show.diff(d, "D").showAndAwait();
+
         final Clock c = new Clock();
 
         final BiPredicate<Time, Projection> inV = DiffView.computeWhenNodesAreRelevant(d, q);
@@ -114,9 +116,12 @@ else if (a.isConditionalAnnotation()) {
         features.remove(FixTrueFalse.False.var.toString());
 
         final List<Query> queries = new ArrayList<>(3);
-        addRandomQuery(deselectedPCs, this::randomVariantQuery,  queries);
-        addRandomQuery(features,      this::randomFeatureQuery,  queries);
-        addRandomQuery(artifacts,     this::randomArtifactQuery, queries);
+//        addRandomQuery(deselectedPCs, this::randomVariantQuery,  queries);
+//        addRandomQuery(features,      this::randomFeatureQuery,  queries);
+//        addRandomQuery(artifacts,     this::randomArtifactQuery, queries);
+        addAll(deselectedPCs, this::allVariantQueries,  queries);
+        addAll(features,      this::allFeatureQueries,  queries);
+        addAll(artifacts,     this::allArtifactQueries, queries);
         return queries;
     }
 
@@ -133,6 +138,34 @@ private static <QueryData, QueryCandidates extends Collection<QueryData>> void a
         }
     }
 
+    private static <QueryData, QueryCandidates extends Collection<? extends QueryData>> void addAll(
+            QueryCandidates source,
+            Function<? super QueryCandidates, ? extends Collection<? extends Query>> prepare,
+            Collection<Query> target
+    ) {
+        if (!source.isEmpty()) {
+            target.addAll(prepare.apply(source));
+        }
+    }
+
+    private List<VariantQuery> allVariantQueries(final List<Node> deselectedPCs) {
+        /*
+         * Select a random satisfiable configuration (i.e., a non-false config).
+         * Unsatisfiable configs cause empty views which
+         * (1) we suspect to be rather useless and thus unused in practice
+         * (2) cause a crash in view generation because everything is removed, even the mandatory root.
+         */
+        final List<VariantQuery> all = new ArrayList<>();
+        for (final Node deselectedPC : deselectedPCs) {
+            final FixTrueFalse.Formula p = FixTrueFalse.EliminateTrueAndFalseInplace(deselectedPC);
+            if (SAT.isSatisfiable(p)) {
+                all.add(new VariantQuery(p));
+            }
+        }
+
+        return all;
+    }
+
     private Query randomVariantQuery(final List<Node> deselectedPCs) {
         /*
         Do we need this?
@@ -168,6 +201,10 @@ private Query randomVariantQuery(final List<Node> deselectedPCs) {
         return new VariantQuery(winner);
     }
 
+    private List<FeatureQuery> allFeatureQueries(final Set<String> features) {
+        return features.stream().map(FeatureQuery::new).toList();
+    }
+
     private Query randomFeatureQuery(final Set<String> features) {
         /*
         Pick a random feature for our query.
@@ -177,6 +214,10 @@ private Query randomFeatureQuery(final Set<String> features) {
         return new FeatureQuery(CollectionUtils.getRandomElement(random, features));
     }
 
+    private List<ArtifactQuery> allArtifactQueries(final Set<String> artifacts) {
+        return artifacts.stream().map(ArtifactQuery::new).toList();
+    }
+
     private Query randomArtifactQuery(final Set<String> artifacts) {
         /*
         Pick a random artifact for our query.

src/main/java/org/variantsync/diffdetective/variation/diff/view/DiffView.java

@@ -104,12 +104,31 @@ Using our own formatter without diff headers (paired with a maximum context (?))
             //textDiff = HUNK_HEADER_REGEX.matcher(textDiff).replaceAll("");
         }
 //        Logger.info("Full Diff\n" + textDiff);
-
-        final DiffTree view = DiffTreeParser.createDiffTree(textDiff,
-                new DiffTreeParseOptions(
-                        true,
-                        true
-                ));
+        final DiffTree view;
+        try {
+            view = DiffTreeParser.createDiffTree(textDiff,
+                    new DiffTreeParseOptions(
+                            true,
+                            true
+                    ));
+        } catch (DiffParseException e) {
+            Logger.error("""
+                            Could not parse diff obtained with query {}:
+                            Text before:
+                            {}
+                            
+                            Text after:
+                            {}
+                            
+                            Diff:
+                            {}
+                            """,
+                    q,
+                    projectionViewText[0],
+                    projectionViewText[1],
+                    textDiff);
+            throw e;
+        }
         view.setSource(new ViewSource(d, q));
 //        Logger.info("success");
         return view;

src/test/java/ViewTest.java

@@ -55,6 +55,23 @@ private static void showViews(
         );
     }
 
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "emacsbug1"
+    })
+    void debugTest(String filename) throws IOException, DiffParseException {
+        final String filenameWithEnding = filename + ".diff";
+        final Path testfile = resDir.resolve(filenameWithEnding);
+        Logger.debug("Testing " + testfile);
+//        is(  /* Check both of the above conditions, for symbols.  */)
+        final DiffTree D = DiffTree.fromFile(testfile, DiffTreeParseOptions.Default);
+        D.assertConsistency();
+
+        final Query debugQuery = new ArtifactQuery("  /* Check both of the above conditions, for symbols.  */");
+        Show.diff(DiffView.optimized(D, debugQuery)).showAndAwait();
+        Show.diff(DiffView.naive(D, debugQuery)).showAndAwait();
+    }
+
 
     @ParameterizedTest
     @ValueSource(strings = {

src/test/resources/badvdiff/emacsbug1.diff

@@ -0,0 +1,38 @@
+ #ifdef GC_CHECK_MARKED_OBJECTS
+ 
+   /* Check that the object pointed to by PO is known to be a Lisp
+      structure allocated from the heap.  */
+ #define CHECK_ALLOCATED()			\
+   do {						\
+     m = mem_find (po);				\
+     if (m == MEM_NIL)				\
+       emacs_abort ();				\
+   } while (0)
+ 
+   /* Check that the object pointed to by PO is live, using predicate
+      function LIVEP.  */
+ #define CHECK_LIVE(LIVEP)			\
+   do {						\
+     if (!LIVEP (m, po))				\
+       emacs_abort ();				\
+   } while (0)
+ 
+   /* Check both of the above conditions, for non-symbols.  */
+ #define CHECK_ALLOCATED_AND_LIVE(LIVEP)		\
+   do {						\
+     CHECK_ALLOCATED ();				\
+     CHECK_LIVE (LIVEP);				\
+   } while (0)					\
+ 
+   /* Check both of the above conditions, for symbols.  */
+ #define CHECK_ALLOCATED_AND_LIVE_SYMBOL()	\
+   do {						\
+     if (!c_symbol_p (ptr))			\
+       {						\
+     CHECK_ALLOCATED ();			\
+     CHECK_LIVE (live_symbol_p);		\
+       }						\
+   } while (0)					\
+ 
+ #endif
+