Fix: Prevent removing an assignment when the RHS has a function call which (directly or indirectly) modifies a global variable.

Fixes color being removed from Shane's awesome shader: https://www.shadertoy.com/view/flj3Wm

Author: DeanEdisGG

ShaderShrinker/Shrinker.Parser/Optimizations/DetectConstantsExtension.cs

@@ -9,7 +9,6 @@
 //  </summary>
 // -----------------------------------------------------------------------
 
-using System.Collections.Generic;
 using System.Linq;
 using Shrinker.Lexer;
 using Shrinker.Parser.SyntaxNodes;

ShaderShrinker/Shrinker.Parser/Optimizations/RemoveUnusedVariablesExtension.cs

@@ -46,9 +46,9 @@ public static void RemoveUnusedVariables(this SyntaxNode rootNode)
                         .Where(o => o.Name == varName).ToList();
                     foreach (var assignment in assignments)
                     {
-                        // If RHS of the assignment calls a function with an 'out/inout' param, it is not save to remove.
+                        // If RHS of the assignment calls a function with an 'out/inout' param, it is not safe to remove.
                         // Instead, replace the assignment with the RHS component.
-                        if (assignment.TheTree.OfType<FunctionCallSyntaxNode>().Any(o => o.HasOutParam))
+                        if (assignment.TheTree.OfType<FunctionCallSyntaxNode>().Any(o => o.HasOutParam || o.ModifiesGlobalVariables()))
                         {
                             var rhs = assignment.ValueNodes.ToList();
                             rhs.Add(new GenericSyntaxNode(new SemicolonToken()));

ShaderShrinker/Shrinker.Parser/SyntaxNodes/FunctionCallSyntaxNode.cs

@@ -37,5 +37,8 @@ private FunctionCallSyntaxNode(string name)
         protected override SyntaxNode CreateSelf() => new FunctionCallSyntaxNode(Name);
 
         public virtual bool HasOutParam => this.Root().Children.OfType<FunctionSyntaxNodeBase>().Any(o => o.Name == Name && o.HasOutParam);
+
+        public bool ModifiesGlobalVariables() =>
+            this.Root().FunctionDefinitions().FirstOrDefault(o => o.Name == Name)?.ModifiesGlobalVariables() == true;
     }
 }

ShaderShrinker/Shrinker.Parser/SyntaxNodes/FunctionDefinitionSyntaxNode.cs

@@ -11,6 +11,7 @@
 
 using System;
 using System.Linq;
+using Shrinker.Lexer;
 
 namespace Shrinker.Parser.SyntaxNodes
 {
@@ -41,5 +42,18 @@ private FunctionDefinitionSyntaxNode()
         public override string UiName => $"{ReturnType} {Name}{(Params.Children.Any() ? "(...)" : "()")} {{...}}";
 
         protected override SyntaxNode CreateSelf() => new FunctionDefinitionSyntaxNode { ReturnType = ReturnType };
+
+        public bool ModifiesGlobalVariables()
+        {
+            var globals = this.GlobalVariables().Select(o => o.Name).ToList();
+            var theTree = Braces.TheTree.ToList();
+
+            // Check self.
+            if (theTree.Any(o => globals.Any(g => o.Token?.Content?.StartsWithVarName(g) == true)))
+                return true;
+
+            // Check any calls made by self...
+            return theTree.OfType<FunctionCallSyntaxNode>().Any(o => o.ModifiesGlobalVariables());
+        }
     }
 }

ShaderShrinker/UnitTests/ShrinkerTests.cs

@@ -1597,6 +1597,23 @@ public void CheckVariableAssignedByFunctionCallOutParamCalledByReturnStatementIs
             Assert.That(rootNode.ToCode().ToSimple(), Is.EqualTo(Code));
         }
 
+        [Test]
+        public void CheckUnusedVariableAssignmentWhichCallsFunctionWhichModifiedGlobalVariableDoesNotRemoveFunctionCall()
+        {
+            const string Code = "int g; int f() { g = 1; return 1; } int ff() { return f(); } void main() { int n = ff(n); }";
+
+            var lexer = new Lexer();
+            lexer.Load(Code);
+
+            var options = CustomOptions.None();
+            options.CombineAssignmentWithSingleUse = true;
+            var rootNode = new Parser(lexer)
+                .Parse()
+                .Simplify(options);
+
+            Assert.That(rootNode.ToCode().ToSimple(), Is.EqualTo(Code));
+        }
+
         [Test, Sequential]
         public void CheckFindingVariablesToMakeConst(
             [Values("int g = 2; int main() { return g; }",