Feature: New hint - Function parameter is unused.

Author: DeanEdisGG

ShaderShrinker/Shrinker.Parser/CodeHint.cs

@@ -16,7 +16,7 @@ public class CodeHint
         public string Item { get; }
         public string Suggestion { get; }
 
-        public CodeHint(string item, string suggestion)
+        protected CodeHint(string item, string suggestion)
         {
             Item = item;
             Suggestion = suggestion;

ShaderShrinker/Shrinker.Parser/Hinter.cs

@@ -11,6 +11,7 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using Shrinker.Lexer;
 using Shrinker.Parser.SyntaxNodes;
 
 namespace Shrinker.Parser
@@ -26,6 +27,15 @@ public static IEnumerable<CodeHint> GetHints(this SyntaxNode rootNode)
             if (!rootNode.HasEntryPointFunction())
                 yield break;
 
+            foreach (var codeHint in DetectFunctionsToInline(rootNode))
+                yield return codeHint;
+
+            foreach (var codeHint in DetectUnusedFunctionParam(rootNode))
+                yield return codeHint;
+        }
+
+        private static IEnumerable<CodeHint> DetectFunctionsToInline(SyntaxNode rootNode)
+        {
             var localFunctions = rootNode.FunctionDefinitions().ToList();
             foreach (var function in localFunctions)
             {
@@ -38,10 +48,47 @@ public static IEnumerable<CodeHint> GetHints(this SyntaxNode rootNode)
                 callSites += rootNode.TheTree.OfType<PragmaDefineSyntaxNode>().Count(o => o.ToCode().Contains(function.Name));
 
                 if (callSites == 0 && !function.IsMain())
-                    yield return new CodeHint(function.UiName, "Never used - Consider removing.");
+                    yield return new UnusedFunctionHint(function.UiName);
 
                 if (callSites == 1)
-                    yield return new CodeHint(function.UiName, "Only called once - Consider inlining.");
+                    yield return new FunctionToInlineHint(function.UiName);
+            }
+        }
+
+        private static IEnumerable<CodeHint> DetectUnusedFunctionParam(SyntaxNode rootNode)
+        {
+            var localFunctions = rootNode.FunctionDefinitions().ToList();
+            foreach (var function in localFunctions.Where(o => !o.IsMain()))
+            {
+                foreach (var paramName in function.ParamNames.Select(o => o.Token.Content))
+                {
+                    var isUsed = function.Braces.TheTree
+                        .Select(o => o.Token?.Content ?? (o as VariableAssignmentSyntaxNode)?.Name)
+                        .Any(o => o?.StartsWithVarName(paramName) == true);
+                    if (!isUsed)
+                        yield return new FunctionHasUnusedParam(function.UiName, paramName);
+                }
+            }
+        }
+
+        public class UnusedFunctionHint : CodeHint
+        {
+            public UnusedFunctionHint(string function) : base(function, "Function is never called.")
+            {
+            }
+        }
+
+        public class FunctionToInlineHint : CodeHint
+        {
+            public FunctionToInlineHint(string function) : base(function, "Function is called only once - Consider inlining.")
+            {
+            }
+        }
+        
+        public class FunctionHasUnusedParam : CodeHint
+        {
+            public FunctionHasUnusedParam(string function, string param) : base(function, $"Function parameter '{param}' is unused.")
+            {
             }
         }
     }

ShaderShrinker/Shrinker.Parser/Optimizations/SimplifyFunctionDeclarationsExtension.cs

@@ -23,13 +23,7 @@ public static void SimplifyFunctionDeclarations(this SyntaxNode rootNode)
 
             // Remove param names.
             foreach (var declaration in functionDeclarations.Where(o => o.Params.Children.Any()))
-            {
-                var paramNames = declaration.Params.Children
-                    .OfType<GenericSyntaxNode>()
-                    .Where(o => o.Token is AlphaNumToken)
-                    .ToList();
-                paramNames.ForEach(o => o.Remove());
-            }
+                declaration.ParamNames.ForEach(o => o.Remove());
 
             // Remove declaration if no matching definition.
             var functionDefinitionNames = rootNode.FunctionDefinitions().Select(o => o.Name);

ShaderShrinker/Shrinker.Parser/SyntaxNodes/FunctionSyntaxNodeBase.cs

@@ -9,6 +9,7 @@
 //  </summary>
 // -----------------------------------------------------------------------
 
+using System.Collections.Generic;
 using System.Linq;
 using Shrinker.Lexer;
 
@@ -23,6 +24,18 @@ public abstract class FunctionSyntaxNodeBase : SyntaxNode
 
         public bool IsVoidParam() => Params.Children.Count == 1 && Params.Children[0].HasNodeContent("void");
 
+        public List<GenericSyntaxNode> ParamNames
+        {
+            get
+            {
+                if (!Params.Children.Any())
+                    return new List<GenericSyntaxNode>();
+                var children = Params.Children.OfType<GenericSyntaxNode>().Where(o => o.Token is AlphaNumToken || o.Token is CommaToken).Append(new GenericSyntaxNode(new CommaToken())).ToList();
+                var commaIndexes = children.Where(o => o.Token is CommaToken).Select(o => children.IndexOf(o));
+                return commaIndexes.Select(i => children[i - 1]).ToList();
+            }
+        }
+
         public bool IsMain() => Name.StartsWith("main");
     }
 }

ShaderShrinker/Shrinker.WpfApp/HintDialog.xaml

@@ -7,7 +7,7 @@
       mc:Ignorable="d" 
       d:DesignHeight="450" d:DesignWidth="800"
       d:DataContext="{d:DesignInstance WpfApp:AppViewModel}"
-      Width="500" Height="400">
+      Width="700" Height="480">
     <Grid.RowDefinitions>
         <RowDefinition Height="*"/>
         <RowDefinition Height="Auto"/>

ShaderShrinker/UnitTests/HinterTests.cs

@@ -0,0 +1,63 @@
+// -----------------------------------------------------------------------
+//  <copyright file="HinterTests.cs" company="Global Graphics Software Ltd">
+//      Copyright (c) 2021 Global Graphics Software Ltd. All rights reserved.
+//  </copyright>
+//  <summary>
+//  This example is provided on an "as is" basis and without warranty of any kind.
+//  Global Graphics Software Ltd. does not warrant or make any representations regarding the use or
+//  results of use of this example.
+//  </summary>
+// -----------------------------------------------------------------------
+
+using System.Linq;
+using NUnit.Framework;
+using Shrinker.Lexer;
+using Shrinker.Parser;
+
+namespace UnitTests
+{
+    [TestFixture]
+    public class HinterTests
+    {
+        [Test]
+        public void CheckDetectingRemoveToInline()
+        {
+            var lexer = new Lexer();
+            lexer.Load("void f() { } void main() { return; }");
+
+            var rootNode = new Parser(lexer).Parse();
+
+            Assert.That(() => rootNode.GetHints().OfType<Hinter.UnusedFunctionHint>().ToList(), Has.Count.EqualTo(1));
+        }
+
+        [Test]
+        public void CheckDetectingFunctionToInline()
+        {
+            var lexer = new Lexer();
+            lexer.Load("void f() { } void main() { f(); }");
+
+            var rootNode = new Parser(lexer).Parse();
+
+            Assert.That(() => rootNode.GetHints().OfType<Hinter.FunctionToInlineHint>().ToList(), Has.Count.EqualTo(1));
+        }
+
+        [Test, Sequential]
+        public void CheckDetectingFunctionWithUnusedParam(
+            [Values(
+                       "int f(int a, int b) { return a * 2; } void main() { f(1, 2); }",
+                       "float f(vec2 a, vec2 b) { return a.x * 2.0; } void main() { f(vec2(1), vec2(2)); }",
+                       "void f(inout T a, int b) { a.a = 2.0; a.b = 1.0; } void main() { T m; f(m, 1); }")
+            ]
+            string code)
+        {
+            var lexer = new Lexer();
+            lexer.Load(code);
+
+            var rootNode = new Parser(lexer).Parse();
+
+            var hints = rootNode.GetHints().OfType<Hinter.FunctionHasUnusedParam>().ToList();
+            Assert.That(hints, Has.Count.EqualTo(1));
+            Assert.That(() => hints.Single().Suggestion, Does.Contain("'b'"));
+        }
+    }
+}