From 2ce0092000f545d5b1b7dcddcb9299ff443f3d4f Mon Sep 17 00:00:00 2001
From: Pieter Olivier <pieter.olivier@swat.engineering>
Date: Tue, 19 Nov 2024 12:12:41 +0100
Subject: [PATCH] Fixed the case where one of the alternative of an ambiguity
 is an empty error

---
 .../rascalmpl/library/util/ErrorRecovery.java | 28 +++++++++++--------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/src/org/rascalmpl/library/util/ErrorRecovery.java b/src/org/rascalmpl/library/util/ErrorRecovery.java
index d117a59d717..8282d3dec4a 100644
--- a/src/org/rascalmpl/library/util/ErrorRecovery.java
+++ b/src/org/rascalmpl/library/util/ErrorRecovery.java
@@ -31,10 +31,12 @@ public ErrorRecovery(IRascalValueFactory rascalValues) {
     private static class ScoredTree {
         public final IConstructor tree;
         public final int score;
+        public final boolean hasErrors;
 
-        public ScoredTree(IConstructor tree, int score) {
+        public ScoredTree(IConstructor tree, int score, boolean hasErrors) {
             this.tree = tree;
             this.score = score;
+            this.hasErrors = hasErrors;
         }
     }
 
@@ -60,8 +62,8 @@ private ScoredTree disambiguate(IConstructor tree, boolean allowAmbiguity, Map<I
         } else if (type == RascalValueFactory.Tree_Amb) {
             result = disambiguateAmb((ITree) tree, allowAmbiguity, processedTrees);
         } else {
-            // Other trees (cycle, char) do not have subtrees so they have a score of 0
-            result = new ScoredTree(tree, 0);
+            // Other trees (cycle, char) do not have subtrees so they have a score of 0 and no errors
+            result = new ScoredTree(tree, 0, false);
         }
 
         return result;
@@ -74,10 +76,11 @@ private ScoredTree disambiguateAppl(ITree appl, boolean allowAmbiguity, Map<ICon
         }
 
         if (ProductionAdapter.isSkipped(appl.getProduction())) {
-            result = new ScoredTree(appl, ((IList) appl.get(1)).length());
+            result = new ScoredTree(appl, ((IList) appl.get(1)).length(), true);
         } else {
             IList args = TreeAdapter.getArgs(appl);
             int totalScore = 0;
+            boolean hasErrors = false;
             IListWriter disambiguatedArgs = null;
 
             // Disambiguate and score all children
@@ -85,6 +88,7 @@ private ScoredTree disambiguateAppl(ITree appl, boolean allowAmbiguity, Map<ICon
                 IValue arg = args.get(i);
                 ScoredTree disambiguatedArg = disambiguate((IConstructor) arg, allowAmbiguity, processedTrees);
                 totalScore += disambiguatedArg.score;
+                hasErrors |= disambiguatedArg.hasErrors;
                 if (disambiguatedArg.tree != arg && disambiguatedArgs == null) {
                     disambiguatedArgs = rascalValues.listWriter();
                     for (int j=0; j<i; j++) {
@@ -107,7 +111,7 @@ private ScoredTree disambiguateAppl(ITree appl, boolean allowAmbiguity, Map<ICon
                 resultTree = appl;
             }
 
-            result = new ScoredTree(resultTree, totalScore);
+            result = new ScoredTree(resultTree, totalScore, hasErrors);
         }
 
         processedTrees.put(appl, result);
@@ -127,17 +131,17 @@ private ScoredTree disambiguateAmb(ITree amb, boolean allowAmbiguity, Map<IConst
         ScoredTree errorAltWithBestScore = null;
         for (IValue alt : originalAlts) {
             ScoredTree disambiguatedAlt = disambiguate((IConstructor) alt, allowAmbiguity, processedTrees);
-            if (disambiguatedAlt.score == 0) {
+            if (disambiguatedAlt.hasErrors) {
+                // Only keep the best of the error trees
+                if (errorAltWithBestScore == null || errorAltWithBestScore.score > disambiguatedAlt.score) {
+                    errorAltWithBestScore = disambiguatedAlt;
+                }
+            } else {
                 // Non-error tree
                 if (alternativesWithoutErrors == null) {
                     alternativesWithoutErrors = rascalValues.setWriter();
                 }
                 alternativesWithoutErrors.insert(disambiguatedAlt.tree);
-            } else {
-                // Only keep the best of the error trees
-                if (errorAltWithBestScore == null || errorAltWithBestScore.score > disambiguatedAlt.score) {
-                    errorAltWithBestScore = disambiguatedAlt;
-                }
             }
         }
 
@@ -166,7 +170,7 @@ private ScoredTree disambiguateAmb(ITree amb, boolean allowAmbiguity, Map<IConst
             }
         }
 
-        result = new ScoredTree(resultTree, 0);
+        result = new ScoredTree(resultTree, 0, false);
         processedTrees.put(amb, result);
 
         return result;