Create PartialFunctionCallIterator to centralize the logic of partial functions

src/main/java/org/rumbledb/compiler/ExecutionModeVisitor.java

@@ -267,7 +267,9 @@ public StaticContext visitFunctionCall(FunctionCallExpression expression, Static
                     expression.getMetadata()
                 );
         }
-        if (BuiltinFunctionCatalogue.exists(expression.getFunctionIdentifier())) {
+        if (expression.isPartialApplication()) {
+            expression.setHighestExecutionMode(ExecutionMode.LOCAL);
+        } else if (BuiltinFunctionCatalogue.exists(expression.getFunctionIdentifier())) {
             BuiltinFunction builtinFunction = BuiltinFunctionCatalogue.getBuiltinFunction(
                 expression.getFunctionIdentifier()
             );

src/main/java/org/rumbledb/compiler/InferTypeVisitor.java

@@ -21,7 +21,6 @@
 import org.rumbledb.exceptions.OurBadException;
 import org.rumbledb.exceptions.UnexpectedStaticTypeException;
 import org.rumbledb.exceptions.UnknownFunctionCallException;
-import org.rumbledb.exceptions.UnsupportedFeatureException;
 import org.rumbledb.expressions.AbstractNodeVisitor;
 import org.rumbledb.expressions.CommaExpression;
 import org.rumbledb.expressions.Expression;
@@ -761,13 +760,6 @@ public StaticContext visitFunctionCall(FunctionCallExpression expression, Static
         visitDescendants(expression, argument);
 
         if (BuiltinFunctionCatalogue.exists(expression.getFunctionIdentifier())) {
-            if (expression.isPartialApplication()) {
-                /// This should never be reached because partial application on built-in functions should have been rewritten before
-                throw new UnsupportedFeatureException(
-                        "Partial application on built-in functions are not supported.",
-                        expression.getMetadata()
-                );
-            }
             BuiltinFunction builtinFunction = BuiltinFunctionCatalogue.getBuiltinFunction(
                 expression.getFunctionIdentifier()
             );

src/main/java/org/rumbledb/compiler/RuntimeIteratorVisitor.java

@@ -1330,7 +1330,18 @@ public RuntimeIterator visitFunctionCall(FunctionCallExpression expression, Runt
         FunctionIdentifier identifier = new FunctionIdentifier(fnName, arity);
 
         RuntimeIterator runtimeIterator = null;
-        if (BuiltinFunctionCatalogue.exists(identifier)) {
+        if (expression.isPartialApplication()) {
+            runtimeIterator = new DynamicFunctionCallIterator(
+                    new NamedFunctionRefRuntimeIterator(
+                            identifier,
+                            expression.getStaticContextForRuntime(this.config, this.visitorConfig)
+                    ),
+                    arguments,
+                    expression.getStaticContextForRuntime(this.config, this.visitorConfig)
+            );
+        }
+
+        else if (BuiltinFunctionCatalogue.exists(identifier)) {
             runtimeIterator = NamedFunctions.getBuiltInFunctionIterator(
                 identifier,
                 arguments,

src/main/java/org/rumbledb/compiler/VisitorHelpers.java

@@ -65,15 +65,6 @@ private static void inferTypes(Module module, RumbleRuntimeConfiguration conf) {
 
     private static MainModule applyTypeIndependentOptimizations(MainModule module, RumbleRuntimeConfiguration conf) {
         MainModule result = module;
-        if (conf.debug()) {
-            System.err.println("***************************************");
-            System.err.println("Builtin Partial Application Rewrite Visitor");
-            System.err.println("***************************************");
-        }
-        result = (MainModule) new BuiltinPartialApplicationRewriteVisitor().visit(result, null);
-        if (conf.debug()) {
-            printTree(result, conf);
-        }
         // Annotate recursive functions as such
         if (conf.debug()) {
             System.err.println("***************************************");

src/main/java/org/rumbledb/context/NamedFunctions.java

@@ -29,13 +29,13 @@
 import org.rumbledb.exceptions.DuplicateFunctionIdentifierException;
 import org.rumbledb.exceptions.ExceptionMetadata;
 import org.rumbledb.exceptions.OurBadException;
-import org.rumbledb.exceptions.UnsupportedFeatureException;
 import org.rumbledb.exceptions.UnknownFunctionCallException;
 import org.rumbledb.expressions.ExecutionMode;
 import org.rumbledb.items.FunctionItem;
 import org.rumbledb.runtime.RuntimeIterator;
 import org.rumbledb.runtime.functions.BuiltinFunctionItemCallIterator;
 import org.rumbledb.runtime.functions.FunctionItemCallIterator;
+import org.rumbledb.runtime.functions.PartialFunctionCallIterator;
 import org.rumbledb.runtime.functions.sequences.general.DataFunctionIterator;
 import org.rumbledb.runtime.typing.AtMostOneItemTypePromotionIterator;
 import org.rumbledb.runtime.typing.TypePromotionIterator;
@@ -104,7 +104,21 @@ public static RuntimeIterator buildFunctionItemCallIterator(
             List<RuntimeIterator> arguments,
             boolean isTailOptimization
     ) {
-        ExceptionMetadata metadata = callerRuntimeContext.getMetadata();
+        if (isTailOptimization) {
+            return new PartialFunctionCallIterator(
+                    functionItem,
+                    arguments,
+                    callerRuntimeContext.withExecutionMode(ExecutionMode.LOCAL),
+                    Name.TAIL_CALL_OPTIMIZATION
+            );
+        }
+        if (arguments.stream().anyMatch(a -> a == null)) {
+            return new PartialFunctionCallIterator(
+                    functionItem,
+                    arguments,
+                    callerRuntimeContext.withExecutionMode(ExecutionMode.LOCAL)
+            );
+        }
         SequenceType sequenceType = functionItem.getSignature().getReturnType();
         SequenceType innerSequenceType = functionItem.getBodyIterator().getStaticType();
         RuntimeStaticContext outerStaticContext = callerRuntimeContext.withStaticType(
@@ -118,12 +132,6 @@ public static RuntimeIterator buildFunctionItemCallIterator(
         ).withExecutionMode(executionModeForFunctionCall);
         RuntimeIterator functionCallIterator;
         if (functionItem.isBuiltinFunction()) {
-            if (arguments.stream().anyMatch(a -> a == null)) {
-                throw new UnsupportedFeatureException(
-                        "Partial application of builtin named function references is not supported yet.",
-                        metadata
-                );
-            }
             functionCallIterator = new BuiltinFunctionItemCallIterator(
                     functionItem,
                     arguments,