feat: PHP 8.5 language level, Pipe operator implementation

Author: jakubmisek

Directory.Build.props

@@ -42,7 +42,7 @@
 
     <PeachpieLibraryRegularExpressionsVersion>1.7.0</PeachpieLibraryRegularExpressionsVersion>
     <MySqlConnectorVersion>2.0.0</MySqlConnectorVersion>
-    <ParserVersion>8.4.17524</ParserVersion>
+    <ParserVersion>8.5.17973</ParserVersion>
     <PeachpieMicrosoftCodeAnalysisVersion>3.7.4</PeachpieMicrosoftCodeAnalysisVersion>
 
   </PropertyGroup>

src/Peachpie.CodeAnalysis/CodeGen/Graph/BoundExpression.cs

@@ -187,6 +187,10 @@ internal override TypeSymbol Emit(CodeGenerator cg)
                     returned_type = EmitSpaceship(cg);
                     break;
 
+                case Operations.Pipe:
+                    returned_type = EmitPipeCall(cg);
+                    break;
+
                 default:
                     throw cg.NotImplementedException(message: $"BinaryEx {this.Operation} is not implemented.", op: this);
             }
@@ -2085,6 +2089,17 @@ internal static TypeSymbol EmitPow(CodeGenerator cg, TypeSymbol xtype, FlowAnaly
 
             }
         }
+
+        private TypeSymbol EmitPipeCall(CodeGenerator cg)
+        {
+            // Template: ((IPhpCallable)RValue).invoke( ctx, LValue )
+
+            cg.EmitConvert(this.Right, cg.CoreTypes.IPhpCallable); // Left is already a BoundConvertToCallable
+            cg.EmitLoadContext();
+            cg.EmitConvertToPhpValue(cg.Emit(this.Left), this.Right.TypeRefMask);
+
+            return cg.EmitCall(ILOpCode.Callvirt, cg.CoreMethods.IPhpCallable.Invoke_Context_PhpValue);
+        }
     }
 
     partial class BoundUnaryEx

src/Peachpie.CodeAnalysis/FlowAnalysis/ExpressionAnalysis.cs

@@ -1286,6 +1286,9 @@ TypeRefMask ResolveBinaryEx(BoundBinaryEx x, ConditionBranch branch)
                 case Operations.Spaceship:
                     return TypeCtx.GetLongTypeMask(); // -1, 0, +1
 
+                case Operations.Pipe:
+                    return TypeRefMask.AnyType; // TODO: return value of the callback in R-Value
+
                 default:
                     throw ExceptionUtilities.UnexpectedValue(x.Operation);
             }

src/Peachpie.CodeAnalysis/Semantics/Graph/BuilderVisitor.cs

@@ -802,21 +802,18 @@ public override void VisitJumpStmt(JumpStmt x)
         public override void VisitIfStmt(IfStmt x)
         {
             var end = NewBlock();
-
             var conditions = x.Conditions;
-            Debug.Assert(conditions.Length != 0);
+            
             BoundBlock elseBlock = null;
-            for (int i = 0; i < conditions.Length; i++)
+            foreach (var cond in conditions)
             {
-                var cond = conditions[i];
                 if (cond.Condition != null)  // if (Condition) ...
                 {
-                    elseBlock = (i == conditions.Length - 1) ? end : NewBlock();
+                    elseBlock = cond.Else == null ? end : NewBlock();
                     _current = Connect(_current, NewBlock(), elseBlock, cond.Condition);
                 }
                 else  // else ...
                 {
-                    Debug.Assert(i != 0 && elseBlock != null);
                     var body = elseBlock;
                     elseBlock = end;    // last ConditionalStmt
                     _current = WithNewOrdinal(body);

src/Peachpie.CodeAnalysis/Semantics/SemanticsBinder.cs

@@ -715,8 +715,6 @@ protected BoundExpression BindIncludeEx(AST.IncludingEx x)
             return new BoundIncludeEx(BindExpression(x.Target, BoundAccess.Read), x.InclusionType);
         }
 
-        protected BoundExpression BindConcatEx(AST.ConcatEx x) => BindConcatEx(x);
-
         void BindConcatIntoList(List<BoundArgument> list, AST.Expression expr)
         {
             if (expr is AST.ConcatEx cex)
@@ -963,11 +961,23 @@ AST.Expression BindArm(AST.IExpression value, AST.MatchArm arm, AST.IExpression
                     for (int i = 0; i < arm.ConditionList.Length; i++)
                     {
                         // value === condition[i]
-                        var cond = new AST.BinaryEx(arm.ConditionList[i].Span, AST.Operations.Identical, (AST.Expression)value, (AST.Expression)arm.ConditionList[i]) { ContainingElement = arm };
-
-                        condition = condition == null
-                            ? cond
-                            : new AST.BinaryEx(Span.Invalid, AST.Operations.Or, condition, cond) { ContainingElement = arm };
+                        var cond = AST.BinaryEx.Create(
+                            arm.ConditionList[i].Span,
+                            AST.Operations.Identical,
+                            (AST.Expression)value,
+                            (AST.Expression)arm.ConditionList[i])
+                        ;
+                        cond.ContainingElement = arm;
+
+                        if (condition == null)
+                        {
+                            condition = cond;
+                        }
+                        else
+                        {
+                            condition = AST.BinaryEx.Create(Span.Invalid, AST.Operations.Or, condition, cond);
+                            condition.ContainingElement = arm;
+                        }
                     }
 
                     if (condition == null)
@@ -1329,6 +1339,16 @@ protected virtual BoundExpression BindBinaryEx(AST.BinaryEx expr)
                     laccess = BoundAccess.Read.WithQuiet(); // Template: A ?? B; // read A quietly
                     goto default;
 
+                case AST.Operations.Pipe:
+                    // Template: A |> B;
+                    // A: PhpValue
+                    // B: IPhpoCallable
+                    return new BoundBinaryEx(
+                        BindExpression(expr.LeftExpr, laccess),
+                        new BoundConvertToCallable(BindExpression(expr.RightExpr, BoundAccess.Read), this.DeclaringCompilation),
+                        expr.Operation
+                    );
+
                 default:
                     return new BoundBinaryEx(
                         BindExpression(expr.LeftExpr, laccess),

src/Peachpie.CodeAnalysis/Symbols/CoreMembers.cs

@@ -902,10 +902,18 @@ public struct IPhpCallableHolder
             public IPhpCallableHolder(CoreTypes ct)
             {
                 CoreTypes = ct;
-                _Invoke_Context_PhpValueArray = null; // lazy
+                
+                // lazy
+                _Invoke_Context = null;
+                _Invoke_Context_PhpValue = null;
+                _Invoke_Context_PhpValueArray = null;
                 //Invoke_Context_PhpValueArray = ct.IPhpCallable.Method("Invoke", ct.Context, ct.PhpValueArray);
             }
 
+            public MethodSymbol Invoke_Context => _Invoke_Context ??= CoreTypes.IPhpCallable.Method("Invoke", CoreTypes.Context).Symbol;
+
+            public MethodSymbol Invoke_Context_PhpValue => _Invoke_Context_PhpValue ??= CoreTypes.IPhpCallable.Method("Invoke", CoreTypes.Context, CoreTypes.PhpValue).Symbol;
+
             public MethodSymbol Invoke_Context_PhpValueArray
             {
                 get
@@ -927,6 +935,8 @@ public MethodSymbol Invoke_Context_PhpValueArray
             }
 
             MethodSymbol
+                _Invoke_Context,
+                _Invoke_Context_PhpValue,
                 _Invoke_Context_PhpValueArray;
         }
 

src/Peachpie.CodeAnalysis/Syntax/PhpSyntaxTree.cs

@@ -88,6 +88,7 @@ public class PhpSyntaxTree : SyntaxTree
             { new Version(8, 2), LanguageFeatures.Php82Set },
             { new Version(8, 3), LanguageFeatures.Php83Set },
             { new Version(8, 4), LanguageFeatures.Php84Set },
+            { new Version(8, 5), LanguageFeatures.Php85Set },
         };
 
         public static Version LatestLanguageVersion => SupportedLanguageVersions.Max();