fix routine analysis when compact() is there

avoids nullifying all the types

Author: jakubmisek

src/Peachpie.CodeAnalysis/FlowAnalysis/ExpressionAnalysis.cs

@@ -1891,12 +1891,17 @@ TypeRefMask BindValidRoutineCall(BoundRoutineCall call, MethodSymbol method, Imm
                 var rflags = method.InvocationFlags(out var localaccess);
                 Routine.Flags |= rflags;
 
-                if ((rflags & RoutineFlags.UsesLocals) != 0
-                    //&& (x is BoundGlobalFunctionCall gf && gf.Name.NameValue.Name.Value == "extract") // "compact" does not change locals // CONSIDER // TODO
-                    )
+                if ((rflags & RoutineFlags.UsesLocals) != 0)
                 {
-                    // function may change/add local variables
-                    State.SetAllUnknown(true);
+                    if (call is BoundGlobalFunctionCall && method.Name == "compact")
+                    {
+                        // "compact" does not change locals // NOTE: it's ugly cause we don't have flags for that yet
+                    }
+                    else
+                    {
+                        // function may change/add local variables
+                        State.SetAllUnknown(true);
+                    }
                 }
 
                 if (localaccess != null)

src/Peachpie.CodeAnalysis/FlowAnalysis/FlowContext.cs

@@ -132,17 +132,17 @@ public VariableHandle GetVarIndex(VariableName name)
             return new VariableHandle() { Slot = index, Name = name };
         }
 
-        /// <summary>
-        /// Enumerates all known variables as pairs of their index and name.
-        /// </summary>
-        public IEnumerable<VariableHandle> EnumerateVariables()
-        {
-            return _varsIndex.Select(pair => new VariableHandle()
-            {
-                Slot = pair.Value,
-                Name = pair.Key,
-            });
-        }
+        ///// <summary>
+        ///// Enumerates all known variables as pairs of their index and name.
+        ///// </summary>
+        //public IEnumerable<VariableHandle> EnumerateVariables()
+        //{
+        //    return _varsIndex.Select(pair => new VariableHandle()
+        //    {
+        //        Slot = pair.Value,
+        //        Name = pair.Key,
+        //    });
+        //}
 
         public void SetReference(int varindex)
         {

src/Peachpie.CodeAnalysis/FlowAnalysis/FlowState.cs

@@ -1,4 +1,5 @@
 using Devsense.PHP.Syntax;
+using Devsense.PHP.Syntax.Ast;
 using Microsoft.CodeAnalysis;
 using Pchp.CodeAnalysis.Semantics;
 using Pchp.CodeAnalysis.Symbols;
@@ -213,18 +214,27 @@ public bool Equals(IFlowState<FlowState> other)
         public void SetLocalType(VariableHandle handle, TypeRefMask tmask)
         {
             handle.ThrowIfInvalid();
+            SetLocalType(handle.Slot, tmask);
+        }
 
-            if (handle >= _varsType.Length)
+        /// <summary>
+        /// Sets variable type in this state.
+        /// </summary>
+        /// <param name="varindex">Variable slot.</param>
+        /// <param name="tmask">Variable type. If <c>uninitialized</c>, the variable is set as not initialized in this state.</param>
+        public void SetLocalType(int varindex, TypeRefMask tmask)
+        {
+            if (varindex >= _varsType.Length)
             {
-                Array.Resize(ref _varsType, handle + 1);
+                Array.Resize(ref _varsType, varindex + 1);
             }
 
-            _varsType[handle] = tmask;
+            _varsType[varindex] = tmask;
 
-            this.FlowContext.AddVarType(handle, tmask);    // TODO: collect merged type information at the end of analysis
+            this.FlowContext.AddVarType(varindex, tmask);    // TODO: collect merged type information at the end of analysis
 
             // update the _initializedMask
-            SetVarInitialized(handle);
+            SetVarInitialized(varindex);
         }
 
         /// <summary>
@@ -282,9 +292,14 @@ public void SetAllUnknown(bool maybeRef)
                 ? TypeRefMask.AnyType.WithRefFlag
                 : TypeRefMask.AnyType;
 
-            foreach (var v in FlowContext.EnumerateVariables())
+            //foreach (var v in FlowContext.EnumerateVariables())
+            //{
+            //    SetLocalType(v, tmask);
+            //}
+
+            for (int i = 0; i < FlowContext.VarsType.Length; i++)
             {
-                SetLocalType(v, tmask);
+                SetLocalType(i, tmask);
             }
 
             // all initialized
@@ -306,9 +321,10 @@ public void FlowThroughReturn(TypeRefMask type)
             FlowContext.ReturnType |= type;
         }
 
-        public void SetVarInitialized(VariableHandle handle)
+        public void SetVarInitialized(VariableHandle handle) => SetVarInitialized(handle.Slot);
+
+        public void SetVarInitialized(int varindex)
         {
-            int varindex = handle.Slot;
             if (varindex >= 0 && varindex < FlowContext.BitsCount)
             {
                 _initializedMask |= 1ul << varindex;