Feature: New hint - Detect functions calls that may be replaced with a constant.

DeanEdisGG · DeanEdisGG · commit 0d47d3261cb9 · 2021-09-19T11:38:25.000+01:00
diff --git a/ShaderShrinker/Shrinker.Lexer/TypeToken.cs b/ShaderShrinker/Shrinker.Lexer/TypeToken.cs
@@ -76,7 +76,22 @@ public string Content
             "mat3", "mat3x2", "mat3x3", "mat3x4",
             "mat4", "mat4x2", "mat4x3", "mat4x4"
         };
-        public static IEnumerable<string> Names { get; } = new[] { "void", "bool", "int",  "uint", "float", "sampler1D", "sampler2D", "sampler3D" }.Union(MultiValueTypes);
+        public static IEnumerable<string> Names { get; } = new[] { "void", "bool", "int",  "uint", "float", "sampler1D", "sampler2D", "sampler3D", "samplerCube" }.Union(MultiValueTypes);
+
+        public static IEnumerable<string> GlslInputs { get; } = new[]
+        {
+            "iResolution",
+            "iTime",
+            "iTimeDelta",
+            "iFrame",
+            "iFrameRate",
+            "iChannelTime",
+            "iChannelResolution",
+            "iMouse",
+            "iChannel",
+            "iDate",
+            "iSampleRate"
+        };
 
         public IToken TryJoin(List<IToken> tokens, int tokenIndex, out int deletePrevious, out int deleteTotal)
         {
diff --git a/ShaderShrinker/Shrinker.Parser/CodeHint.cs b/ShaderShrinker/Shrinker.Parser/CodeHint.cs
@@ -21,5 +21,7 @@ protected CodeHint(string item, string suggestion)
             Item = item;
             Suggestion = suggestion;
         }
+
+        public override string ToString() => $"{Item}|{Suggestion}";
     }
 }
diff --git a/ShaderShrinker/Shrinker.Parser/Hinter.cs b/ShaderShrinker/Shrinker.Parser/Hinter.cs
@@ -22,6 +22,7 @@ namespace Shrinker.Parser
     public static class Hinter
     {
         // todo - Report when single value passed to any function.
+        // todo - If function called in 'if' (or 'else') blocks, suggest parameterizing.
         public static IEnumerable<CodeHint> GetHints(this SyntaxNode rootNode)
         {
             if (rootNode.HasEntryPointFunction())
@@ -35,6 +36,9 @@ public static IEnumerable<CodeHint> GetHints(this SyntaxNode rootNode)
 
             foreach (var codeHint in DetectDefinableReferences(rootNode))
                 yield return codeHint;
+
+            foreach (var codeHint in DetectFunctionsCalledWithConstArguments(rootNode))
+                yield return codeHint;
         }
 
         private static IEnumerable<CodeHint> DetectFunctionsToInline(SyntaxNode rootNode)
@@ -93,6 +97,25 @@ private static IEnumerable<CodeHint> DetectDefinableReferences(SyntaxNode rootNo
             }
         }
 
+        private static IEnumerable<CodeHint> DetectFunctionsCalledWithConstArguments(SyntaxNode rootNode)
+        {
+            foreach (var function in rootNode.FunctionDefinitions())
+            {
+                var functionCallsWithConstParams =
+                    function
+                    .FunctionCalls()
+                    .Where(o => o.Params.IsNumericCsv(true))
+                    .Where(o => !o.ModifiesGlobalVariables());
+
+                foreach (var hintableFunctionCall in functionCallsWithConstParams)
+                {
+                    var callee = hintableFunctionCall.GetCalleeDefinition();
+                    if (callee != null && callee.ReturnType != "void" && !callee.UsesGlslInputs())
+                        yield return new FunctionCalledWithConstParams(hintableFunctionCall);
+                }
+            }
+        }
+
         public class UnusedFunctionHint : CodeHint
         {
             public UnusedFunctionHint(string function) : base(function, "Function is never called.")
@@ -113,6 +136,13 @@ public FunctionHasUnusedParam(string function, string param) : base(function, $"
             {
             }
         }
+
+        public class FunctionCalledWithConstParams : CodeHint
+        {
+            public FunctionCalledWithConstParams(SyntaxNode function) : base(function.ToCode(), "Function called with constant arguments. Consider replacing with the result.")
+            {
+            }
+        }
         
         public class IntroduceDefine : CodeHint
         {
diff --git a/ShaderShrinker/Shrinker.Parser/Optimizations/CombineAssignmentWithReturnExtension.cs b/ShaderShrinker/Shrinker.Parser/Optimizations/CombineAssignmentWithReturnExtension.cs
@@ -73,9 +73,9 @@ public static bool CombineAssignmentWithReturn(this SyntaxNode rootNode)
 
                             // Are we assigning from a non-const global variable?
                             // Bad idea - It might be modified by a function call in the 'return'.
-                            var functionsInReturn = returnNode.TheTree.OfType<FunctionCallSyntaxNode>().ToList();
+                            var functionsInReturn = returnNode.FunctionCalls().ToList();
                             if (functionsInReturn.Any() ||
-                                assignment.TheTree.OfType<FunctionCallSyntaxNode>().Any())
+                                assignment.FunctionCalls().Any())
                             {
                                 var globals = rootNode.GlobalVariables()
                                     .Where(o => (o.Parent as VariableDeclarationSyntaxNode)?.VariableType.IsConst != true)
diff --git a/ShaderShrinker/Shrinker.Parser/Optimizations/InlineConstantVariablesExtension.cs b/ShaderShrinker/Shrinker.Parser/Optimizations/InlineConstantVariablesExtension.cs
@@ -61,7 +61,7 @@ public static void InlineConstantVariables(this SyntaxNode rootNode)
                                   definition.ValueNodes.Count() == 2 &&
                                   definition.Children[0]?.Token is TypeToken &&
                                   definition.Children[1] is RoundBracketSyntaxNode brackets &&
-                                  brackets.IsSimpleCsv();
+                                  brackets.IsNumericCsv();
 
                     if (!couldInline)
                         continue;
diff --git a/ShaderShrinker/Shrinker.Parser/Optimizations/InlineDefinesExtension.cs b/ShaderShrinker/Shrinker.Parser/Optimizations/InlineDefinesExtension.cs
@@ -73,7 +73,7 @@ private static bool CouldInline(PragmaDefineSyntaxNode o)
                     return o.ValueNodes[0].Token is TypeToken t &&
                         t.IsGlslType &&
                         o.ValueNodes[1] is RoundBracketSyntaxNode brackets &&
-                        brackets.IsSimpleCsv();
+                        brackets.IsNumericCsv();
             }
 
             // Nope - Can't inline.
diff --git a/ShaderShrinker/Shrinker.Parser/Optimizations/PerformArithmeticExtension.cs b/ShaderShrinker/Shrinker.Parser/Optimizations/PerformArithmeticExtension.cs
@@ -126,7 +126,7 @@ public static bool PerformArithmetic(this SyntaxNode rootNode)
                 // pow(1.1, 2.2) => <the result>
                 var functionCalls = rootNode.TheTree.OfType<GlslFunctionCallSyntaxNode>().ToList();
                 foreach (var powNode in functionCalls
-                    .Where(o => o.Name == "pow" && o.Params.IsSimpleCsv())
+                    .Where(o => o.Name == "pow" && o.Params.IsNumericCsv())
                     .ToList())
                 {
                     var xy = powNode.Params.Children.Where(o => o.Token is FloatToken).Select(o => ((FloatToken)o.Token).Number).ToList();
@@ -154,7 +154,7 @@ public static bool PerformArithmetic(this SyntaxNode rootNode)
                 };
 
                 foreach (var mathNode in functionCalls
-                    .Where(o => mathOp.Select(op => op.Item1).Contains(o.Name) && o.Params.IsSimpleCsv())
+                    .Where(o => mathOp.Select(op => op.Item1).Contains(o.Name) && o.Params.IsNumericCsv())
                     .ToList())
                 {
                     var x = mathNode.Params.Children.Where(o => o.Token is FloatToken).Select(o => ((FloatToken)o.Token).Number).ToList();
@@ -177,7 +177,7 @@ public static bool PerformArithmetic(this SyntaxNode rootNode)
                         continue;
 
                     // Brackets must be filled with floats.
-                    if (!brackets.IsSimpleCsv())
+                    if (!brackets.IsNumericCsv())
                         continue;
 
                     // Find the math symbol.
diff --git a/ShaderShrinker/Shrinker.Parser/Optimizations/RemoveUnusedVariablesExtension.cs b/ShaderShrinker/Shrinker.Parser/Optimizations/RemoveUnusedVariablesExtension.cs
@@ -48,7 +48,7 @@ public static void RemoveUnusedVariables(this SyntaxNode rootNode)
                     {
                         // 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 || o.ModifiesGlobalVariables()))
+                        if (assignment.FunctionCalls().Any(o => o.HasOutParam || o.ModifiesGlobalVariables()))
                         {
                             var rhs = assignment.ValueNodes.ToList();
                             rhs.Add(new GenericSyntaxNode(new SemicolonToken()));
diff --git a/ShaderShrinker/Shrinker.Parser/SyntaxNodes/FunctionCallSyntaxNode.cs b/ShaderShrinker/Shrinker.Parser/SyntaxNodes/FunctionCallSyntaxNode.cs
@@ -40,5 +40,11 @@ private FunctionCallSyntaxNode(string name)
 
         public bool ModifiesGlobalVariables() =>
             this.Root().FunctionDefinitions().FirstOrDefault(o => o.Name == Name)?.ModifiesGlobalVariables() == true;
+
+        /// <summary>
+        /// Find the definition of the function being called (which may be null for functions defined in other buffers, or GLSL function calls).
+        /// </summary>
+        public FunctionDefinitionSyntaxNode GetCalleeDefinition() =>
+            this.Root().FunctionDefinitions().FirstOrDefault(o => o.Name == Name && Params.GetCsv().Count() == o.Params.GetCsv().Count());
     }
 }
diff --git a/ShaderShrinker/Shrinker.Parser/SyntaxNodes/FunctionDefinitionSyntaxNode.cs b/ShaderShrinker/Shrinker.Parser/SyntaxNodes/FunctionDefinitionSyntaxNode.cs
@@ -53,16 +53,21 @@ public bool ModifiesGlobalVariables()
                 return true;
 
             // Check any calls made by self...
-            return theTree.OfType<FunctionCallSyntaxNode>().Any(o => o.ModifiesGlobalVariables());
+            return this.FunctionCalls().Any(o => o.ModifiesGlobalVariables());
         }
 
+        /// <summary>
+        /// Whether the function uses iTime, iResolution, etc.
+        /// </summary>
+        public bool UsesGlslInputs() => TheTree.Select(o => o?.Token?.Content).Intersect(TypeToken.GlslInputs).Any();
+
         public bool DoesCall(FunctionDefinitionSyntaxNode otherFunction) =>
-            Braces.TheTree.OfType<FunctionCallSyntaxNode>().Any(o => o.Name == otherFunction.Name);
+            this.FunctionCalls().Any(o => o.Name == otherFunction.Name);
 
         /// <summary>
         /// How many times does this function call another?
         /// </summary>
         public int CallCount(FunctionDefinitionSyntaxNode otherFunction) =>
-            Braces.TheTree.OfType<FunctionCallSyntaxNode>().Count(o => o.Name == otherFunction.Name);
+            this.FunctionCalls().Count(o => o.Name == otherFunction.Name);
     }
 }
diff --git a/ShaderShrinker/Shrinker.Parser/SyntaxNodes/RoundBracketSyntaxNode.cs b/ShaderShrinker/Shrinker.Parser/SyntaxNodes/RoundBracketSyntaxNode.cs
@@ -53,7 +53,26 @@ public IEnumerable<IList<SyntaxNode>> GetCsv()
         /// <summary>
         /// Check if the brackets contain a simple sequence of numbers. (E.g. (1, 3, 2))
         /// </summary>
-        public bool IsSimpleCsv() =>
-            TheTree.Skip(1).All(o => o.Token is INumberToken || o.Token is CommaToken);
+        /// <param name="allowNumericVectors">If true, allow constant vector expressions (E.g. 'vec3(1,2,3)')</param>
+        public bool IsNumericCsv(bool allowNumericVectors = false)
+        {
+            foreach (var node in TheTree.Skip(1))
+            {
+                if (node.Token is INumberToken or CommaToken)
+                    continue;
+
+                // If it's a vector, we can sometimes allow that.
+                if (allowNumericVectors)
+                {
+                    if (node is RoundBracketSyntaxNode || node.Token?.Content?.IsAnyOf("vec2", "vec3", "vec4") == true)
+                        continue;
+                }
+
+                return false;
+            }
+
+            // OK, as long as there _is_ some content.
+            return TheTree.Skip(1).Any();
+        }
     }
 }
diff --git a/ShaderShrinker/Shrinker.Parser/SyntaxNodes/SyntaxNodeExtensions.cs b/ShaderShrinker/Shrinker.Parser/SyntaxNodes/SyntaxNodeExtensions.cs
@@ -63,6 +63,9 @@ public static IEnumerable<FunctionDefinitionSyntaxNode> FunctionDefinitions(this
         public static IEnumerable<FunctionDeclarationSyntaxNode> FunctionDeclarations(this SyntaxNode node) =>
             node.Children.OfType<FunctionDeclarationSyntaxNode>();
 
+        public static IEnumerable<FunctionCallSyntaxNode> FunctionCalls(this SyntaxNode node) =>
+            node.TheTree.OfType<FunctionCallSyntaxNode>();
+
         public static SyntaxNode Root(this SyntaxNode node)
         {
             while (node.Parent != null)
diff --git a/ShaderShrinker/Shrinker.sln.DotSettings b/ShaderShrinker/Shrinker.sln.DotSettings
@@ -636,6 +636,7 @@ namespace $NAMESPACE$&#xD;
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Enabledness/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=fastmath/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=glsl/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=hintable/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=IDOM/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=ifdef/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=ifndef/@EntryIndexedValue">True</s:Boolean>
diff --git a/ShaderShrinker/UnitTests/HinterTests.cs b/ShaderShrinker/UnitTests/HinterTests.cs
@@ -125,5 +125,72 @@ public void CheckMultiUseMouseTriggersHint()
 
             Assert.That(() => rootNode.GetHints().OfType<Hinter.IntroduceDefine>().ToList(), Has.Count.EqualTo(1));
         }
+
+        [Test, Sequential]
+        public void CheckCallingVoidFunctionWithConstParamDoesNotTriggerHint(
+            [Values(
+                       "void f(int a) { } void main() { f(1); }",
+                       "void f(float a) { } void main() { f(1.0); }",
+                       "void f(vec3 a) { } void main() { f(vec3(1)); }")
+            ]
+            string code)
+        {
+            var lexer = new Lexer();
+            lexer.Load(code);
+
+            var rootNode = new Parser(lexer).Parse();
+
+            Assert.That(() => rootNode.GetHints().OfType<Hinter.FunctionCalledWithConstParams>(), Is.Empty);
+        }
+
+        [Test]
+        public void CheckCallingFunctionWithConstParamUsingGlobalDoesNotTriggerHint()
+        {
+            var lexer = new Lexer();
+            lexer.Load("int g = 0; int f(int a) { return g + a; } int main() { return f(2); }");
+
+            var rootNode = new Parser(lexer).Parse();
+
+            Assert.That(() => rootNode.GetHints().OfType<Hinter.FunctionCalledWithConstParams>(), Is.Empty);
+        }
+
+        [Test]
+        public void CheckCallingFunctionWithConstParamUsingTimeDoesNotTriggerHint()
+        {
+            var lexer = new Lexer();
+            lexer.Load("float f(float a) { return a + iTime; } float main() { return f(2.0); }");
+
+            var rootNode = new Parser(lexer).Parse();
+
+            Assert.That(() => rootNode.GetHints().OfType<Hinter.FunctionCalledWithConstParams>(), Is.Empty);
+        }
+        
+        [Test]
+        public void CheckCallingFunctionWithNonNumericVectorDoesNotTriggerHint()
+        {
+            var lexer = new Lexer();
+            lexer.Load("vec3 f(vec3 a) { return a * 2.; } vec3 main() { vec3 v = vec3(1); return f(v); }");
+
+            var rootNode = new Parser(lexer).Parse();
+
+            Assert.That(() => rootNode.GetHints().OfType<Hinter.FunctionCalledWithConstParams>(), Is.Empty);
+        }
+
+        [Test]
+        public void CheckCallingFunctionWithConstParamTriggersHint(
+            [Values(
+                       "int f(int a) { return a * 2; } int main() { return f(2); }",
+                       "vec3 f(vec3 a) { return a * 2.; } vec3 main() { return f(vec3(1, 2, 3)); }",
+                       "vec3 f(vec3 a) { return a * 2.; } vec3 main() { return f(vec3(1.1)); }")
+            ]
+            string code)
+        {
+            var lexer = new Lexer();
+            lexer.Load(code);
+
+            var rootNode = new Parser(lexer).Parse();
+
+            Assert.That(() => rootNode.GetHints().OfType<Hinter.FunctionCalledWithConstParams>().ToList(), Has.Count.EqualTo(1));
+        }
     }
 }
diff --git a/ShaderShrinker/UnitTests/InstallerVersionUpdater.cs b/ShaderShrinker/UnitTests/InstallerVersionUpdater.cs
@@ -17,7 +17,7 @@
 namespace UnitTests
 {
     [TestFixture]
-    public class ReadmeBuInstallerVersionUpdater
+    public class InstallerVersionUpdater
     {
         [Test]
         public void UpdateInstallerVersion()
diff --git a/ShaderShrinker/UnitTests/RoundBracketSyntaxNodeTests.cs b/ShaderShrinker/UnitTests/RoundBracketSyntaxNodeTests.cs
@@ -0,0 +1,68 @@
+﻿// -----------------------------------------------------------------------
+//  <copyright file="RoundBracketSyntaxNodeTests.cs">
+//      Copyright (c) 2021 Dean Edis. All rights reserved.
+//  </copyright>
+//  <summary>
+//  This example is provided on an "as is" basis and without warranty of any kind.
+//  We do not warrant or make any representations regarding the use or
+//  results of use of this example.
+//  </summary>
+// -----------------------------------------------------------------------
+
+using NUnit.Framework;
+using Shrinker.Lexer;
+using Shrinker.Parser.SyntaxNodes;
+
+namespace UnitTests
+{
+    [TestFixture]
+    public class RoundBracketSyntaxNodeTests : UnitTestBase
+    {
+        [Test, Sequential]
+        public void GivenEmptyCsvCheckIsNumericCsvReturnsFalse([Values] bool allowNumericVectors)
+        {
+            Assert.That(new RoundBracketSyntaxNode().IsNumericCsv(allowNumericVectors), Is.False);
+        }
+
+        [Test, Sequential]
+        public void GivenSingleNonNumericCsvCheckIsNumericCsvReturnsFalse([Values] bool allowNumericVectors)
+        {
+            Assert.That(new RoundBracketSyntaxNode(new[] { new GenericSyntaxNode("a") }).IsNumericCsv(allowNumericVectors), Is.False);
+        }
+
+        [Test, Sequential]
+        public void GivenMultiNonNumericCsvCheckIsNumericCsvReturnsFalse([Values] bool allowNumericVectors)
+        {
+            Assert.That(new RoundBracketSyntaxNode(new[] { new GenericSyntaxNode("a"), new GenericSyntaxNode(new IntToken(23)) }).IsNumericCsv(allowNumericVectors), Is.False);
+        }
+
+        [Test, Sequential]
+        public void GivenSingleNumericCsvCheckIsNumericCsvReturnsTrue([Values] bool allowNumericVectors)
+        {
+            Assert.That(new RoundBracketSyntaxNode(new[] { new GenericSyntaxNode(new IntToken(23)) }).IsNumericCsv(allowNumericVectors), Is.True);
+        }
+
+        [Test, Sequential]
+        public void GivenMultiNumericCsvCheckIsNumericCsvReturnsTrue([Values] bool allowNumericVectors)
+        {
+            Assert.That(new RoundBracketSyntaxNode(new[] { new GenericSyntaxNode(new IntToken(23)), new GenericSyntaxNode(FloatToken.From(32.23, 2)) }).IsNumericCsv(allowNumericVectors), Is.True);
+        }
+        
+        [Test, Sequential]
+        public void GivenVectorCsvCheckIsNumericCsvReturnsTrueOnlyIfAllowingNumericVectors([Values] bool allowNumericVectors)
+        {
+            var nodes = new SyntaxNode[]
+            {
+                new GenericSyntaxNode(new TypeToken("vec3")),
+                new RoundBracketSyntaxNode(new []
+                {
+                    new GenericSyntaxNode(new IntToken(1)),
+                    new GenericSyntaxNode(new CommaToken()),
+                    new GenericSyntaxNode(FloatToken.From(12.3, 2))
+                })
+            };
+
+            Assert.That(new RoundBracketSyntaxNode(nodes).IsNumericCsv(allowNumericVectors), Is.EqualTo(allowNumericVectors));
+        }
+    }
+}
diff --git a/ShaderShrinker/UnitTests/ShrinkerTests.cs b/ShaderShrinker/UnitTests/ShrinkerTests.cs

Original file line number	Diff line number	Diff line change
`@@ -21,5 +21,7 @@ protected CodeHint(string item, string suggestion)`
`21`	`21`	`Item = item;`
`22`	`22`	`Suggestion = suggestion;`
`23`	`23`	`}`
	`24`	`+`
	`25`	`+ public override string ToString() => $"{Item}\|{Suggestion}";`
`24`	`26`	`}`
`25`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,7 @@ namespace Shrinker.Parser`
`22`	`22`	`public static class Hinter`
`23`	`23`	`{`
`24`	`24`	`// todo - Report when single value passed to any function.`
	`25`	`+ // todo - If function called in 'if' (or 'else') blocks, suggest parameterizing.`
`25`	`26`	`public static IEnumerable<CodeHint> GetHints(this SyntaxNode rootNode)`
`26`	`27`	`{`
`27`	`28`	`if (rootNode.HasEntryPointFunction())`
`@@ -35,6 +36,9 @@ public static IEnumerable<CodeHint> GetHints(this SyntaxNode rootNode)`
`35`	`36`
`36`	`37`	`foreach (var codeHint in DetectDefinableReferences(rootNode))`
`37`	`38`	`yield return codeHint;`
	`39`	`+`
	`40`	`+ foreach (var codeHint in DetectFunctionsCalledWithConstArguments(rootNode))`
	`41`	`+ yield return codeHint;`
`38`	`42`	`}`
`39`	`43`
`40`	`44`	`private static IEnumerable<CodeHint> DetectFunctionsToInline(SyntaxNode rootNode)`
`@@ -93,6 +97,25 @@ private static IEnumerable<CodeHint> DetectDefinableReferences(SyntaxNode rootNo`
`93`	`97`	`}`
`94`	`98`	`}`
`95`	`99`
	`100`	`+ private static IEnumerable<CodeHint> DetectFunctionsCalledWithConstArguments(SyntaxNode rootNode)`
	`101`	`+ {`
	`102`	`+ foreach (var function in rootNode.FunctionDefinitions())`
	`103`	`+ {`
	`104`	`+ var functionCallsWithConstParams =`
	`105`	`+ function`
	`106`	`+ .FunctionCalls()`
	`107`	`+ .Where(o => o.Params.IsNumericCsv(true))`
	`108`	`+ .Where(o => !o.ModifiesGlobalVariables());`
	`109`	`+`
	`110`	`+ foreach (var hintableFunctionCall in functionCallsWithConstParams)`
	`111`	`+ {`
	`112`	`+ var callee = hintableFunctionCall.GetCalleeDefinition();`
	`113`	`+ if (callee != null && callee.ReturnType != "void" && !callee.UsesGlslInputs())`
	`114`	`+ yield return new FunctionCalledWithConstParams(hintableFunctionCall);`
	`115`	`+ }`
	`116`	`+ }`
	`117`	`+ }`
	`118`	`+`
`96`	`119`	`public class UnusedFunctionHint : CodeHint`
`97`	`120`	`{`
`98`	`121`	`public UnusedFunctionHint(string function) : base(function, "Function is never called.")`
`@@ -113,6 +136,13 @@ public FunctionHasUnusedParam(string function, string param) : base(function, $"`
`113`	`136`	`{`
`114`	`137`	`}`
`115`	`138`	`}`
	`139`	`+`
	`140`	`+ public class FunctionCalledWithConstParams : CodeHint`
	`141`	`+ {`
	`142`	`+ public FunctionCalledWithConstParams(SyntaxNode function) : base(function.ToCode(), "Function called with constant arguments. Consider replacing with the result.")`
	`143`	`+ {`
	`144`	`+ }`
	`145`	`+ }`
`116`	`146`
`117`	`147`	`public class IntroduceDefine : CodeHint`
`118`	`148`	`{`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ private static bool CouldInline(PragmaDefineSyntaxNode o)`
`73`	`73`	`return o.ValueNodes[0].Token is TypeToken t &&`
`74`	`74`	`t.IsGlslType &&`
`75`	`75`	`o.ValueNodes[1] is RoundBracketSyntaxNode brackets &&`
`76`		`- brackets.IsSimpleCsv();`
	`76`	`+ brackets.IsNumericCsv();`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`// Nope - Can't inline.`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ public static void RemoveUnusedVariables(this SyntaxNode rootNode)`
`48`	`48`	`{`
`49`	`49`	`// If RHS of the assignment calls a function with an 'out/inout' param, it is not safe to remove.`
`50`	`50`	`// Instead, replace the assignment with the RHS component.`
`51`		`- if (assignment.TheTree.OfType<FunctionCallSyntaxNode>().Any(o => o.HasOutParam \|\| o.ModifiesGlobalVariables()))`
	`51`	`+ if (assignment.FunctionCalls().Any(o => o.HasOutParam \|\| o.ModifiesGlobalVariables()))`
`52`	`52`	`{`
`53`	`53`	`var rhs = assignment.ValueNodes.ToList();`
`54`	`54`	`rhs.Add(new GenericSyntaxNode(new SemicolonToken()));`
Original file line number	Diff line number	Diff line change
`@@ -40,5 +40,11 @@ private FunctionCallSyntaxNode(string name)`
`40`	`40`
`41`	`41`	`public bool ModifiesGlobalVariables() =>`
`42`	`42`	`this.Root().FunctionDefinitions().FirstOrDefault(o => o.Name == Name)?.ModifiesGlobalVariables() == true;`
	`43`	`+`
	`44`	`+ /// <summary>`
	`45`	`+ /// Find the definition of the function being called (which may be null for functions defined in other buffers, or GLSL function calls).`
	`46`	`+ /// </summary>`
	`47`	`+ public FunctionDefinitionSyntaxNode GetCalleeDefinition() =>`
	`48`	`+ this.Root().FunctionDefinitions().FirstOrDefault(o => o.Name == Name && Params.GetCsv().Count() == o.Params.GetCsv().Count());`
`43`	`49`	`}`
`44`	`50`	`}`