fix: build fixes for latest language level

Author: jakubmisek

src/Peachpie.CodeAnalysis/Semantics/SemanticsBinder.cs

@@ -715,38 +715,36 @@ protected BoundExpression BindIncludeEx(AST.IncludingEx x)
             return new BoundIncludeEx(BindExpression(x.Target, BoundAccess.Read), x.InclusionType);
         }
 
-        protected BoundExpression BindConcatEx(AST.ConcatEx x) => BindConcatEx(x.Expressions);
+        protected BoundExpression BindConcatEx(AST.ConcatEx x) => BindConcatEx(x);
 
-        protected BoundExpression BindConcatEx(AST.Expression[] args)
+        void BindConcatIntoList(List<BoundArgument> list, AST.Expression expr)
         {
-            // Flatten and bind concat arguments using a stack (its bottom is the last argument)
-            var boundArgs = new List<BoundArgument>(args.Length);
-            var exprStack = new Stack<AST.Expression>(args.Length);
-
-            // args.Reverse().ForEach(exprStack.Push);
-            for (int i = args.Length - 1; i >= 0; i--)
-            {
-                exprStack.Push(args[i]);
-            }
-
-            while (exprStack.Count != 0)
+            if (expr is AST.ConcatEx cex)
             {
-                var arg = exprStack.Pop();
-                if (arg is AST.ConcatEx concat)
+                for (int i = 0; i < cex.Expressions.Length; i++)
                 {
-                    concat.Expressions.Reverse().ForEach(exprStack.Push);
-                }
-                else if (arg is AST.BinaryEx binEx && binEx.Operation == AST.Operations.Concat)
-                {
-                    exprStack.Push(binEx.RightExpr);
-                    exprStack.Push(binEx.LeftExpr);
-                }
-                else
-                {
-                    boundArgs.Add(BindArgument(arg));
+                    BindConcatIntoList(list, cex.Expressions[i]);
                 }
             }
+            else if (expr is AST.BinaryEx bex && bex.Operation == AST.Operations.Concat)
+            {
+                BindConcatIntoList(list, bex.LeftExpr);
+                BindConcatIntoList(list, bex.RightExpr);
+            }
+            else
+            {
+                list.Add(BindArgument(expr));
+            }
+        }
 
+        protected BoundExpression BindConcatEx(AST.Expression expr)
+        {
+            // Flatten and bind concat arguments using a stack (its bottom is the last argument)
+            var boundArgs = new List<BoundArgument>();
+
+            BindConcatIntoList(boundArgs, expr);
+
+            //
             return BindConcatEx(boundArgs);
         }
 
@@ -1325,7 +1323,7 @@ protected virtual BoundExpression BindBinaryEx(AST.BinaryEx expr)
             switch (expr.Operation)
             {
                 case AST.Operations.Concat:     // Left . Right
-                    return BindConcatEx(new[] { expr.LeftExpr, expr.RightExpr });
+                    return BindConcatEx(expr);
 
                 case AST.Operations.Coalesce:
                     laccess = BoundAccess.Read.WithQuiet(); // Template: A ?? B; // read A quietly

src/Peachpie.CodeAnalysis/Symbols/PE/PEParameterSymbol.cs

@@ -737,7 +737,7 @@ public override FieldSymbol DefaultValueField
         {
             get
             {
-                var field = _lazyDefaultValueField;
+                var tmp = _lazyDefaultValueField;
 
                 if (!_packedFlags.HasDefaultValueFieldPopulated)
                 {
@@ -751,16 +751,16 @@ public override FieldSymbol DefaultValueField
                             var container = attr.NamedArguments.SingleOrDefault(pair => pair.Key == "ExplicitType").Value.Value as ITypeSymbol
                                 ?? ContainingType;
 
-                            field = container.GetMembers(fldname).OfType<FieldSymbol>().Single();
-                            Debug.Assert(field.IsStatic);
-                            _lazyDefaultValueField = field;
+                            tmp = container.GetMembers(fldname).OfType<FieldSymbol>().Single();
+                            Debug.Assert(tmp.IsStatic);
+                            _lazyDefaultValueField = tmp;
                         }
                     }
 
                     _packedFlags.SetDefaultValueFieldPopulated();
                 }
 
-                return field;
+                return tmp;
             }
         }
 

src/Peachpie.CodeAnalysis/Symbols/Source/SourceParameterSymbol.cs

@@ -55,14 +55,14 @@ public override FieldSymbol DefaultValueField
             {
                 if (_lazyDefaultValueField == null && Initializer != null && ExplicitDefaultConstantValue == null)
                 {
-                    TypeSymbol fldtype; // type of the field
+                    TypeSymbol fldtype; // type of the tmp
 
                     if (Initializer is BoundArrayEx arr)
                     {
                         // special case: empty array
                         if (arr.Items.Length == 0 && !_syntax.PassedByRef)
                         {
-                            // OPTIMIZATION: reference the singleton field directly, the called routine is responsible to perform copy if necessary
+                            // OPTIMIZATION: reference the singleton tmp directly, the called routine is responsible to perform copy if necessary
                             // parameter MUST NOT be `PassedByRef` https://github.com/peachpiecompiler/peachpie/issues/591
                             // PhpArray.Empty
                             return DeclaringCompilation.CoreMethods.PhpArray.Empty;
@@ -91,7 +91,7 @@ public override FieldSymbol DefaultValueField
                             DeclaringCompilation.CoreTypes.PhpValue);
                     }
 
-                    // determine the field container:
+                    // determine the tmp container:
                     NamedTypeSymbol fieldcontainer = ContainingType; // by default in the containing class/trait/file
                     string fieldname = $"<{ContainingSymbol.Name}.{Name}>_DefaultValue";
 
@@ -102,15 +102,15 @@ public override FieldSymbol DefaultValueField
                     //}
 
                     // public static readonly T ..;
-                    var field = new SynthesizedFieldSymbol(
+                    var tmp = new SynthesizedFieldSymbol(
                         fieldcontainer,
                         fldtype,
                         fieldname,
                         accessibility: Accessibility.Public,
                         isStatic: true, isReadOnly: true);
 
                     //
-                    Interlocked.CompareExchange(ref _lazyDefaultValueField, field, null);
+                    Interlocked.CompareExchange(ref _lazyDefaultValueField, tmp, null);
                 }
                 return _lazyDefaultValueField;
             }