refactor: apply local search fixes to VIATRA

2 files changed, 37 insertions, 33 deletions

diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/ExtendOperationExecutor.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/ExtendOperationExecutor.java
index 01179118..a72c30dd 100644
--- a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/ExtendOperationExecutor.java
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/ExtendOperationExecutor.java
@@ -1,19 +1,20 @@
 /*******************************************************************************
  * Copyright (c) 2010-2013, Zoltan Ujhelyi, Akos Horvath, Istvan Rath and Daniel Varro
+ * Copyright (c) 2023 The Refinery Authors <https://refinery.tools/>
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
  * http://www.eclipse.org/legal/epl-v20.html.
- * 
+ *
  * SPDX-License-Identifier: EPL-2.0
  *******************************************************************************/
 package tools.refinery.viatra.runtime.localsearch.operations;
 
-import java.util.Iterator;
-
 import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
 import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
 import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation.ISearchOperationExecutor;
 
+import java.util.Iterator;
+
 /**
  * An operation that can be used to enumerate all possible values for a single position based on a constraint
  * @author Zoltan Ujhelyi, Akos Horvath
@@ -31,42 +32,46 @@ public abstract class ExtendOperationExecutor<T> implements ISearchOperationExec
     protected abstract Iterator<? extends T> getIterator(MatchingFrame frame, ISearchContext context);
     /**
      * Updates the frame with the next element of the iterator. Called during {@link #execute(MatchingFrame, ISearchContext)}.
-     * 
+     *
      * @return true if the update is successful or false otherwise; in case of false is returned, the next element should be taken from the iterator.
      * @since 2.0
      */
     protected abstract boolean fillInValue(T newValue, MatchingFrame frame, ISearchContext context);
-    
+
     /**
      * Restores the frame to the state before {@link #fillInValue(Object, MatchingFrame, ISearchContext)}. Called during
      * {@link #onBacktrack(MatchingFrame, ISearchContext)}.
-     * 
+     *
      * @since 2.0
      */
     protected abstract void cleanup(MatchingFrame frame, ISearchContext context);
-    
+
     @Override
     public void onInitialize(MatchingFrame frame, ISearchContext context) {
         it = getIterator(frame, context);
     }
-    
+
     @Override
     public void onBacktrack(MatchingFrame frame, ISearchContext context) {
         it = null;
 
     }
 
-    @Override
-    public boolean execute(MatchingFrame frame, ISearchContext context) {
-        if (it.hasNext()){
-            T newValue = it.next();
-            while(!fillInValue(newValue, frame, context) && it.hasNext()){
-                newValue = it.next();
-            }
-            return true;
-        } else {
-            return false;
-        }
-    }
-    
+        /**
+         * Fixed version that handles failed unification of variables correctly.
+         * @param frame The matching frame to extend.
+         * @param context The search context.
+         * @return {@code true} if an extension was found, {@code false} otherwise.
+         */
+        @Override
+        public boolean execute(MatchingFrame frame, ISearchContext context) {
+                while (it.hasNext()) {
+                        var newValue = it.next();
+                        if (fillInValue(newValue, frame, context)) {
+                                return true;
+                        }
+                }
+                return false;
+        }
+
 }
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/compiler/GenericOperationCompiler.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/compiler/GenericOperationCompiler.java
index 606048b7..d86982e9 100644
--- a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/compiler/GenericOperationCompiler.java
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/compiler/GenericOperationCompiler.java
@@ -1,19 +1,14 @@
 /*******************************************************************************
  * Copyright (c) 2010-2017, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * Copyright (c) 2023 The Refinery Authors <https://refinery.tools/>
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
  * http://www.eclipse.org/legal/epl-v20.html.
- * 
+ *
  * SPDX-License-Identifier: EPL-2.0
  *******************************************************************************/
 package tools.refinery.viatra.runtime.localsearch.planner.compiler;
 
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
 import tools.refinery.viatra.runtime.localsearch.operations.generic.GenericTypeCheck;
 import tools.refinery.viatra.runtime.localsearch.operations.generic.GenericTypeExtend;
 import tools.refinery.viatra.runtime.localsearch.operations.generic.GenericTypeExtendSingleValue;
@@ -25,6 +20,8 @@ import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.TypeConst
 import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
 import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
 
+import java.util.*;
+
 /**
  * @author Zoltan Ujhelyi
  * @since 1.7
@@ -46,9 +43,9 @@ public class GenericOperationCompiler extends AbstractOperationCompiler {
             positions[i] = variableMapping.get(variable);
         }
         operations.add(new GenericTypeCheck(inputKey, positions, TupleMask.fromSelectedIndices(variableMapping.size(), positions)));
-        
+
     }
-    
+
     @Override
     protected void createCheck(TypeConstraint typeConstraint, Map<PVariable, Integer> variableMapping) {
         IInputKey inputKey = typeConstraint.getSupplierKey();
@@ -60,7 +57,7 @@ public class GenericOperationCompiler extends AbstractOperationCompiler {
         }
         operations.add(new GenericTypeCheck(inputKey, positions, TupleMask.fromSelectedIndices(variableMapping.size(), positions)));
     }
-    
+
     @Override
     protected void createUnaryTypeCheck(IInputKey inputKey, int position) {
         int[] positions = new int[] {position};
@@ -71,7 +68,7 @@ public class GenericOperationCompiler extends AbstractOperationCompiler {
     protected void createExtend(TypeConstraint typeConstraint, Map<PVariable, Integer> variableMapping) {
         IInputKey inputKey = typeConstraint.getSupplierKey();
         Tuple tuple = typeConstraint.getVariablesTuple();
-        
+
         int[] positions = new int[tuple.getSize()];
         List<Integer> boundVariableIndices = new ArrayList<>();
         List<Integer> boundVariables = new ArrayList<>();
@@ -89,7 +86,9 @@ public class GenericOperationCompiler extends AbstractOperationCompiler {
         }
         TupleMask indexerMask = TupleMask.fromSelectedIndices(inputKey.getArity(), boundVariableIndices);
         TupleMask callMask = TupleMask.fromSelectedIndices(variableMapping.size(), boundVariables);
-        if (unboundVariables.size() == 1) {
+                // If multiple tuple elements from the indexer should be bound to the same variable, we must use a
+                // {@link GenericTypeExtend} check whether the tuple elements have the same value.
+                if (unboundVariables.size() == 1 && indexerMask.getSize() + 1 == indexerMask.getSourceWidth()) {
             operations.add(new GenericTypeExtendSingleValue(inputKey, positions, callMask, indexerMask, unboundVariables.iterator().next()));
         } else {
             operations.add(new GenericTypeExtend(inputKey, positions, callMask, indexerMask, unboundVariables));