Feature: New hint - Golfing common expression using #define.

I.e. smoothstep, iResolution, normalize

Author: DeanEdisGG

ShaderShrinker/Shrinker.Parser/Hinter.cs

@@ -24,13 +24,16 @@ public static class Hinter
         // todo - Report when single value passed to any function.
         public static IEnumerable<CodeHint> GetHints(this SyntaxNode rootNode)
         {
-            if (!rootNode.HasEntryPointFunction())
-                yield break;
+            if (rootNode.HasEntryPointFunction())
+            {
+                foreach (var codeHint in DetectFunctionsToInline(rootNode))
+                    yield return codeHint;
 
-            foreach (var codeHint in DetectFunctionsToInline(rootNode))
-                yield return codeHint;
+                foreach (var codeHint in DetectUnusedFunctionParam(rootNode))
+                    yield return codeHint;
+            }
 
-            foreach (var codeHint in DetectUnusedFunctionParam(rootNode))
+            foreach (var codeHint in DetectDefinableReferences(rootNode))
                 yield return codeHint;
         }
 
@@ -71,6 +74,25 @@ private static IEnumerable<CodeHint> DetectUnusedFunctionParam(SyntaxNode rootNo
             }
         }
 
+        private static IEnumerable<CodeHint> DetectDefinableReferences(SyntaxNode rootNode)
+        {
+            var candidates = new[] { "smoothstep", "iResolution", "normalize" };
+            var replacement = new[] { "S smoothstep", "R iResolution", "N normalize" };
+            var usages = rootNode.TheTree
+                .Select(o => o.Token?.Content ?? (o as FunctionCallSyntaxNode)?.Name)
+                .Where(o => candidates.Any(o.StartsWithVarName))
+                .ToList();
+            foreach (var candidate in candidates)
+            {
+                var usageCount = usages.Count(o => o.StartsWithVarName(candidate));
+                var oldSize = candidate.Length * usageCount;
+                var newSize = 8 + candidate.Length + usageCount + usageCount;
+
+                if (newSize < oldSize)
+                    yield return new IntroduceDefine(candidate, replacement[candidates.ToList().IndexOf(candidate)]);
+            }
+        }
+
         public class UnusedFunctionHint : CodeHint
         {
             public UnusedFunctionHint(string function) : base(function, "Function is never called.")
@@ -91,5 +113,12 @@ public FunctionHasUnusedParam(string function, string param) : base(function, $"
             {
             }
         }
+        
+        public class IntroduceDefine : CodeHint
+        {
+            public IntroduceDefine(string originalName, string defineNameAndValue) : base(originalName, $"[GOLF] Consider adding '#define {defineNameAndValue}'")
+            {
+            }
+        }
     }
 }

ShaderShrinker/Shrinker.Parser/Optimizations/SimplifyFunctionDeclarationsExtension.cs

@@ -10,7 +10,6 @@
 // -----------------------------------------------------------------------
 
 using System.Linq;
-using Shrinker.Lexer;
 using Shrinker.Parser.SyntaxNodes;
 
 namespace Shrinker.Parser.Optimizations

ShaderShrinker/UnitTests/HinterTests.cs

@@ -59,5 +59,49 @@ public void CheckDetectingFunctionWithUnusedParam(
             Assert.That(hints, Has.Count.EqualTo(1));
             Assert.That(() => hints.Single().Suggestion, Does.Contain("'b'"));
         }
+
+        [Test]
+        public void CheckSingleUseResolutionDoesNotTriggerHint()
+        {
+            var lexer = new Lexer();
+            lexer.Load("float main() { return iResolution.x; }");
+
+            var rootNode = new Parser(lexer).Parse();
+
+            Assert.That(() => rootNode.GetHints(), Is.Empty);
+        }
+
+        [Test]
+        public void CheckMultiUseResolutionDoesNotTriggerHint()
+        {
+            var lexer = new Lexer();
+            lexer.Load("float main() { return iResolution.x + iResolution.y + iResolution.y; }");
+
+            var rootNode = new Parser(lexer).Parse();
+
+            Assert.That(() => rootNode.GetHints().OfType<Hinter.IntroduceDefine>().ToList(), Has.Count.EqualTo(1));
+        }
+
+        [Test]
+        public void CheckSingleUseSmoothstepDoesNotTriggerHint()
+        {
+            var lexer = new Lexer();
+            lexer.Load("float main() { return smoothstep(0.0, 1.0, 0.5); }");
+
+            var rootNode = new Parser(lexer).Parse();
+
+            Assert.That(() => rootNode.GetHints(), Is.Empty);
+        }
+
+        [Test]
+        public void CheckMultiUseSmoothstepDoesNotTriggerHint()
+        {
+            var lexer = new Lexer();
+            lexer.Load("float main() { return smoothstep(0.0, 1.0, smoothstep(0.0, 1.0, smoothstep(0.0, 1.0, 0.5))); }");
+
+            var rootNode = new Parser(lexer).Parse();
+
+            Assert.That(() => rootNode.GetHints().OfType<Hinter.IntroduceDefine>().ToList(), Has.Count.EqualTo(1));
+        }
     }
 }