Refactoring pipeline interpretation to first completely desugar it before running it through future interpreters.

Author: cesarParra

expression-src/main/src/interpreter/ContextResolver.cls

@@ -438,13 +438,11 @@ public with sharing class ContextResolver implements Visitor {
     }
 
     public Object visit(Expr.PipelineFunction pipelineFunction) {
-        resolve(pipelineFunction.left);
-        resolve(pipelineFunction.body);
-        return null;
+        throw new UnsupportedOperationException('Pipeline functions should first be desugared before being resolved.');
     }
 
     public Object visit(Expr.Capture capture) {
-        return null;
+        throw new UnsupportedOperationException('Capture expressions should first be desugared before being resolved.');
     }
 
     private final Map<SObjectType, Fields> cachedFieldsBySObjectType = new Map<SObjectType, Fields>();

expression-src/main/src/interpreter/Interpreter.cls

@@ -357,28 +357,9 @@ public virtual with sharing class Interpreter implements Visitor {
     }
 
     public virtual Object visit(Expr.FunctionCall function) {
-        attemptCapture(function);
         return FunctionCaller.exec(this, function);
     }
 
-    protected void attemptCapture(Expr.FunctionCall function) {
-        if (pendingCapture == null || pendingCapture.isExplicit == true) {
-            return;
-        }
-
-        // If there is a pipeline capture pending, then the first function
-        // call we encounter should use that as its first argument.
-        if (function.arguments.isEmpty()) {
-            function.arguments.add(pendingCapture.expression);
-        } else {
-            function.arguments.add(0, pendingCapture.expression);
-        }
-
-        // Once captured, we clear the pending capture to avoid any additional
-        // functions to the right-hand side of the pipeline to try and use it.
-        pendingCapture = null;
-    }
-
     public Object visit(Expr.ListLiteral listLiteral) {
         inListLiteralCounter++;
         List<Object> resultList = new List<Object>();
@@ -586,66 +567,16 @@ public virtual with sharing class Interpreter implements Visitor {
 
         return new ShouldNotAdd();
     }
-
-    private PendingCapture pendingCapture;
+    
     public Object visit(Expr.PipelineFunction pipelineFunction) {
-        if (pipelineFunction.hasExplicitCapture) {
-            // When dealing with an explicit capture, we immediately evaluate
-            // the left-hand side of the pipeline, and store it for it to be used
-            // whenever a capture ("_") expression is encountered within the right-hand side (body).
-            this.pendingCapture = explicit(evaluate(pipelineFunction.left));
-        } else {
-            // If there is no capture on the right-hand side of the pipeline,
-            // then it acts as syntactic sugar for passing the left-hand side
-            // as the first argument to the function call on the right-hand side.
-            // Thus, it does not get evaluated, but rather stored as an expression
-            // for it to be evaluated during function call argument resolution.
-            this.pendingCapture = implicit(pipelineFunction.left);
-        }
-
-        Object toReturn = evaluate(pipelineFunction.body);
-        return toReturn;
+        throw new Exceptions.UnknownException(
+            'Pipelines should first be desugared by the PipeResolver before reaching the Interpreter.'
+        );
     }
 
     public Object visit(Expr.Capture capture) {
-        if (this.pendingCapture == null) {
-            throw new Exceptions.RuntimeException(
-                capture.captureToken,
-                'Capture expressions can only be used inside pipeline functions.'
-            );
-        }
-
-        if (pendingCapture.isExplicit == false) {
-            // This should be unreachable, since the PipelineFunction visitor
-            // should have populated the pending capture as explicit.
-            throw new Exceptions.UnknownException(
-                capture.captureToken.position,
-                'Internal error: expected an explicit pending capture.'
-            );
-        }
-
-        return this.pendingCapture.result;
-    }
-
-    private class PendingCapture {
-        private Boolean isExplicit;
-        // Populated when isExplicit is false
-        private Expr expression;
-        // Populated when isExplicit is true
-        private Object result;
-    }
-
-    private static PendingCapture explicit(Object result) {
-        PendingCapture capture = new PendingCapture();
-        capture.isExplicit = true;
-        capture.result = result;
-        return capture;
-    }
-
-    private static PendingCapture implicit(Expr expression) {
-        PendingCapture capture = new PendingCapture();
-        capture.isExplicit = false;
-        capture.expression = expression;
-        return capture;
+        throw new Exceptions.UnknownException(
+            'Captures should first be desugared by the PipeResolver before reaching the Interpreter.'
+        );
     }
 }

expression-src/main/src/interpreter/PipeResolver.cls

@@ -66,6 +66,18 @@ public with sharing class PipeResolver implements Visitor {
     }
 
     public Object visit(Expr.FunctionCall function) {
+        if (this.shouldImplicitlyCapture) {
+            // If there is a pipeline capture pending, then the first function
+            // call we encounter should use that as its first argument.
+            if (function.arguments.isEmpty()) {
+                function.arguments.add(this.waitingForCapture);
+            } else {
+                function.arguments.add(0, this.waitingForCapture);
+            }
+
+            this.resetCaptureFlagsAndState();
+        }
+
         List<Expr> newArguments = new List<Expr>();
         for (Expr argument : function.arguments) {
             newArguments.add(resolve(argument));
@@ -201,29 +213,52 @@ public with sharing class PipeResolver implements Visitor {
         );
     }
 
-    Boolean lookingForCapture = false;
+    Boolean lookingForExplicitCapture = false;
+    Boolean shouldImplicitlyCapture = false;
     Boolean captureFound = false;
+    Expr waitingForCapture;
     public Object visit(Expr.PipelineFunction pipelineFunction) {
         Expr left = resolve(pipelineFunction.left);
-        lookingForCapture = true;
+        this.waitingForCapture = left;
+
+        // We now do an initial pass of the right-hand side, looking for a capture expression.
+        this.lookingForExplicitCapture = true;
         Expr resolvedBody = resolve(pipelineFunction.body);
-        lookingForCapture = false;
-        Object toReturn = new Expr.PipelineFunction(pipelineFunction.pipeToken, left, resolvedBody)
-            .withInnerCapture(captureFound);
-        captureFound = false;
-        return toReturn;
+        this.lookingForExplicitCapture = false;
+
+        if (this.captureFound) {
+            // If a capture was found, we are done. Reset all flags and return the resolved body.
+            this.resetCaptureFlagsAndState();
+            return resolvedBody;
+        } else {
+            // If no capture was found, we flag the need for an implicit capture.
+            // And resolve again, expecting that the first function parameter will be replaced with the left expression.
+            this.shouldImplicitlyCapture = true;
+            resolvedBody = resolve(pipelineFunction.body);
+
+            // Reset all flags and return the resolved body.
+            this.resetCaptureFlagsAndState();
+            return resolvedBody;
+        }
+    }
+
+    void resetCaptureFlagsAndState() {
+        this.lookingForExplicitCapture = false;
+        this.shouldImplicitlyCapture = false;
+        this.captureFound = false;
+        this.waitingForCapture = null;
     }
 
     public Object visit(Expr.Capture capture) {
-        if (lookingForCapture) {
-            captureFound = true;
-        } else {
-            throw new Exceptions.RuntimeException(
-                capture.captureToken,
-                'Capture expressions can only be used inside pipeline functions.'
-            );
+        if (this.lookingForExplicitCapture) {
+            this.captureFound = true;
+            return this.waitingForCapture;
         }
 
-        return capture;
+        // If we reach here, it means a capture expression was used outside of a pipeline function.
+        throw new Exceptions.RuntimeException(
+            capture.captureToken,
+            'Capture expressions can only be used inside pipeline functions.'
+        );
     }
 }

expression-src/main/src/interpreter/query/QueryInterpreter.cls

@@ -221,8 +221,6 @@ public with sharing class QueryInterpreter extends Interpreter {
                 'Functions are not supported in a Query context outside of a where clause.');
         }
 
-        attemptCapture(function);
-
         Map<String, StandardFunction> dateAndTimeFunctions = new DateAndTimeFunctions.DateAndTimeFunctionsProvider().getFunctions();
         Map<String, StandardFunction> supportedWhereFunctions = new Map<String, StandardFunction> {
             'LIKE' => new LikeFn(),