Replace String Check with AST Check

Author: rcosta358

liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/VariableResolver.java

@@ -76,7 +76,7 @@ private static void resolveRecursive(Expression exp, Map<String, Expression> map
             }
         } else if (left instanceof Var var && canSubstitute(var, right)) {
             map.put(var.getName(), right.clone());
-        } else if (left instanceof FunctionInvocation && !right.toString().contains(leftKey)) {
+        } else if (left instanceof FunctionInvocation && !containsExpression(right, left)) {
             map.put(leftKey, right.clone());
         }
     }
@@ -147,7 +147,7 @@ private static boolean hasUsage(Expression exp, String name) {
                     && (right.isLiteral() || (!(right instanceof Var) && canSubstitute(v, right))))
                 return false;
             if (left instanceof FunctionInvocation && left.toString().equals(name)
-                    && (right.isLiteral() || (!(right instanceof Var) && !right.toString().contains(name))))
+                    && (right.isLiteral() || (!(right instanceof Var) && !containsExpression(right, left))))
                 return false;
             if (right instanceof Var v && v.getName().equals(name) && left.isLiteral())
                 return false;
@@ -210,4 +210,18 @@ private static boolean containsVariable(Expression exp, String name) {
         }
         return false;
     }
+
+    private static boolean containsExpression(Expression exp, Expression target) {
+        if (exp.equals(target))
+            return true;
+
+        if (!exp.hasChildren())
+            return false;
+
+        for (Expression child : exp.getChildren()) {
+            if (containsExpression(child, target))
+                return true;
+        }
+        return false;
+    }
 }

liquidjava-verifier/src/test/java/liquidjava/rj_language/opt/VariableResolverTest.java

@@ -134,6 +134,15 @@ void testFunctionInvocationEqualitiesResolveTransitively() {
         assertEquals("1", result.get("func(b)").toString());
     }
 
+    @Test
+    void testFunctionInvocationNamesAreMatchedStructurally() {
+        Expression expression = parse("f(a) > 0 && f(a) == ff(a) + b");
+        Map<String, Expression> result = VariableResolver.resolve(expression);
+
+        assertEquals(1, result.size(), "Should not treat ff(a) as a use of f(a)");
+        assertEquals("ff(a) + b", result.get("f(a)").toString());
+    }
+
     @Test
     void testUnusedFunctionInvocationEqualityIsIgnored() {
         Expression expression = parse("x > 0 && size(stack) == 1");