Optimize pipelines with single-placeholder PFAs

Author: thekid

src/main/php/lang/ast/emit/EmulatePipelines.class.php

@@ -1,6 +1,6 @@
 <?php namespace lang\ast\emit;
 
-use lang\ast\nodes\{CallableExpression, CallableNewExpression, Variable, Placeholder};
+use lang\ast\nodes\{CallableExpression, CallableNewExpression, Literal, Placeholder, Variable};
 
 /**
  * Emulates pipelines / the pipe operator, including a null-safe version.
@@ -10,54 +10,87 @@
  * $in |> $expr;
  * ($expr)($in);
  *
+ * // Optimize for string literals:
+ * $in |> 'strlen';
+ * strlen($in);
+ *
  * // Optimize for first-class callables with single placeholder argument:
  * $in |> strlen(...);
  * strlen($in);
+ *
+ * // Optimize for partial functions with single placeholder argument:
+ * $in |> str_replace('test', 'ok', ?);
+ * strlen('test', 'ok', $in);
  * ```
  *
  * @see  https://wiki.php.net/rfc/pipe-operator-v3
  * @see  https://externals.io/message/107661#107670
+ * @test lang.ast.unittest.emit.EmulatePipelinesTest
  * @test lang.ast.unittest.emit.PipelinesTest
  */
 trait EmulatePipelines {
 
-  private function singlePlaceholder($arguments) {
-    return 1 === sizeof($arguments) && $arguments[0] instanceof Placeholder;
+  private function passSingle($arguments, $arg) {
+    $placeholder= -1;
+    foreach ($arguments as $n => $argument) {
+      if ($argument instanceof Placeholder) {
+        if ($placeholder > -1) return null;
+        $placeholder= $n;
+      }
+    }
+
+    $r= $arguments;
+    $r[$placeholder]= $arg;
+    return $r;
   }
 
   protected function emitPipeTarget($result, $target, $arg) {
-    if ($target instanceof CallableNewExpression && $this->singlePlaceholder($target->arguments)) {
-      $target->type->arguments= [new Variable(substr($arg, 1))];
+    if ($target instanceof CallableNewExpression && ($pass= $this->passSingle($target->arguments, $arg))) {
+      $target->type->arguments= $pass;
       $this->emitOne($result, $target->type);
       $target->type->arguments= null;
-    } else if ($target instanceof CallableExpression && $this->singlePlaceholder($target->arguments)) {
+    } else if ($target instanceof CallableExpression && ($pass= $this->passSingle($target->arguments, $arg))) {
       $this->emitOne($result, $target->expression);
-      $result->out->write('('.$arg.')');
+      $result->out->write('(');
+      $this->emitArguments($result, $pass);
+      $result->out->write(')');
+    } else if ($target instanceof Literal) {
+      $result->out->write(trim($target->expression, '"\''));
+      $result->out->write('(');
+      $this->emitOne($result, $arg);
+      $result->out->write(')');
     } else {
       $result->out->write('(');
       $this->emitOne($result, $target);
-      $result->out->write(')('.$arg.')');
+      $result->out->write(')(');
+      $this->emitOne($result, $arg);
+      $result->out->write(')');
     }
   }
 
   protected function emitPipe($result, $pipe) {
 
-    // $expr |> strtoupper(...) => [$arg= $expr, strtoupper($arg)][1]
-    $t= $result->temp();
-    $result->out->write('['.$t.'=');
-    $this->emitOne($result, $pipe->expression);
-    $result->out->write(',');
-    $this->emitPipeTarget($result, $pipe->target, $t);
-    $result->out->write('][1]');
+    // <const> |> strtoupper(...) => strtoupper(<const>)
+    // <expr> |> strtoupper(...) => [$arg= <expr>, strtoupper($arg)][1]
+    if ($this->isConstant($result, $pipe->expression)) {
+      $this->emitPipeTarget($result, $pipe->target, $pipe->expression);
+    } else {
+      $t= $result->temp();
+      $result->out->write('['.$t.'=');
+      $this->emitOne($result, $pipe->expression);
+      $result->out->write(',');
+      $this->emitPipeTarget($result, $pipe->target, new Variable(substr($t, 1)));
+      $result->out->write('][1]');
+    }
   }
 
   protected function emitNullsafePipe($result, $pipe) {
 
-    // $expr ?|> strtoupper(...) => null === ($arg= $expr) ? null : strtoupper($arg)
+    // <expr> ?|> strtoupper(...) => null === ($arg= <expr>) ? null : strtoupper($arg)
     $t= $result->temp();
     $result->out->write('null===('.$t.'=');
     $this->emitOne($result, $pipe->expression);
     $result->out->write(')?null:');
-    $this->emitPipeTarget($result, $pipe->target, $t);
+    $this->emitPipeTarget($result, $pipe->target, new Variable(substr($t, 1)));
   }
 }

src/test/php/lang/ast/unittest/emit/CallableSyntaxTest.class.php

@@ -323,6 +323,15 @@ public function run() {
     Assert::equals(['hi world'], $r);
   }
 
+  #[Test, Expect(class: Error::class, message: '/Too few arguments/')]
+  public function partial_function_application_returned_by_pipe() {
+    $this->run('class %T {
+      public function run() {
+        "hi" |> str_replace("hello", ?, ?);
+      }
+    }');
+  }
+
   #[Test]
   public function partial_function_application_pass_named() {
     $f= $this->run('class %T {

src/test/php/lang/ast/unittest/emit/EmulatePipelinesTest.class.php

@@ -0,0 +1,73 @@
+<?php namespace lang\ast\unittest\emit;
+
+use test\{Assert, Test, Values};
+
+class EmulatePipelinesTest extends EmittingTest {
+
+  /** @return string */
+  protected function runtime() { return 'php:8.4.0'; }
+
+  #[Test]
+  public function lhs_evaluation_order() {
+    Assert::equals(
+      '[$_0=result(),($expr)($_0)][1];',
+      $this->emit('result() |> $expr;')
+    );
+  }
+
+  #[Test]
+  public function to_expression() {
+    Assert::equals(
+      '($expr)("hi");',
+      $this->emit('"hi" |> $expr;')
+    );
+  }
+
+  #[Test, Values(['"strlen"', "'strlen'"])]
+  public function to_string_literal($notation) {
+    Assert::equals(
+      'strlen("hi");',
+      $this->emit('"hi" |> '.$notation.';')
+    );
+  }
+
+  #[Test]
+  public function to_array_literal() {
+    Assert::equals(
+      '([$this,"func",])("hi");',
+      $this->emit('"hi" |> [$this, "func"];')
+    );
+  }
+
+  #[Test]
+  public function to_first_class_callable() {
+    Assert::equals(
+      'strlen("hi");',
+      $this->emit('"hi" |> strlen(...);')
+    );
+  }
+
+  #[Test]
+  public function to_callable_new() {
+    Assert::equals(
+      'new \\util\\Date("2025-07-12");',
+      $this->emit('"2025-07-12" |> new \\util\\Date(...);')
+    );
+  }
+
+  #[Test]
+  public function to_partial_function_application() {
+    Assert::equals(
+      'str_replace("hi","hello","hi");',
+      $this->emit('"hi" |> str_replace("hi", "hello", ?);')
+    );
+  }
+
+  #[Test]
+  public function chained() {
+    Assert::equals(
+      '[$_0=strtoupper("hi"),trim($_0,"{}")][1];',
+      $this->emit('"hi" |> strtoupper(...) |> trim(?, "{}");')
+    );
+  }
+}