Add static rule for unused Function parameters

scan-command/src/main/java/io/ballerina/scan/internal/CoreRule.java

@@ -20,6 +20,7 @@
 
 import io.ballerina.scan.Rule;
 import io.ballerina.scan.RuleKind;
+import io.ballerina.scan.utils.RuleDescription;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -30,7 +31,9 @@
  * @since 0.1.0
  * */
 enum CoreRule {
-    AVOID_CHECKPANIC(RuleFactory.createRule(1, "Avoid checkpanic", RuleKind.CODE_SMELL));
+    AVOID_CHECKPANIC(RuleFactory.createRule(1, RuleDescription.AVOID_CHECKPANIC, RuleKind.CODE_SMELL)),
+    UNUSED_FUNCTION_PARAMETERS(RuleFactory.createRule(2,
+            RuleDescription.UNUSED_FUNCTION_PARAMETERS, RuleKind.CODE_SMELL));
 
     private final Rule rule;
 

scan-command/src/main/java/io/ballerina/scan/internal/ProjectAnalyzer.java

@@ -113,7 +113,8 @@ List<Issue> analyze(List<Rule> inbuiltRules) {
     private Consumer<DocumentId> analyzeDocument(Module module, ScannerContextImpl scannerContext) {
         return documentId -> {
             Document document = module.document(documentId);
-            StaticCodeAnalyzer analyzer = new StaticCodeAnalyzer(document, scannerContext);
+            StaticCodeAnalyzer analyzer = new StaticCodeAnalyzer(document, scannerContext,
+                    module.getCompilation().getSemanticModel());
             analyzer.analyze();
         };
     }

scan-command/src/main/java/io/ballerina/scan/internal/StaticCodeAnalyzer.java

@@ -18,14 +18,25 @@
 
 package io.ballerina.scan.internal;
 
+import io.ballerina.compiler.api.SemanticModel;
+import io.ballerina.compiler.api.symbols.Symbol;
 import io.ballerina.compiler.syntax.tree.CheckExpressionNode;
+import io.ballerina.compiler.syntax.tree.FunctionSignatureNode;
+import io.ballerina.compiler.syntax.tree.ImplicitAnonymousFunctionExpressionNode;
+import io.ballerina.compiler.syntax.tree.ImplicitAnonymousFunctionParameters;
+import io.ballerina.compiler.syntax.tree.IncludedRecordParameterNode;
 import io.ballerina.compiler.syntax.tree.ModulePartNode;
+import io.ballerina.compiler.syntax.tree.Node;
 import io.ballerina.compiler.syntax.tree.NodeVisitor;
+import io.ballerina.compiler.syntax.tree.SimpleNameReferenceNode;
 import io.ballerina.compiler.syntax.tree.SyntaxKind;
 import io.ballerina.compiler.syntax.tree.SyntaxTree;
 import io.ballerina.projects.Document;
+import io.ballerina.scan.Rule;
 import io.ballerina.scan.ScannerContext;
 
+import java.util.Optional;
+
 /**
  * {@code StaticCodeAnalyzer} contains the logic to perform core static code analysis on Ballerina documents.
  *
@@ -35,11 +46,13 @@ class StaticCodeAnalyzer extends NodeVisitor {
     private final Document document;
     private final SyntaxTree syntaxTree;
     private final ScannerContext scannerContext;
+    private final SemanticModel semanticModel;
 
-    StaticCodeAnalyzer(Document document, ScannerContextImpl scannerContext) {
+    StaticCodeAnalyzer(Document document, ScannerContextImpl scannerContext, SemanticModel semanticModel) {
         this.document = document;
         this.syntaxTree = document.syntaxTree();
         this.scannerContext = scannerContext;
+        this.semanticModel = semanticModel;
     }
 
     void analyze() {
@@ -54,8 +67,62 @@ void analyze() {
     @Override
     public void visit(CheckExpressionNode checkExpressionNode) {
         if (checkExpressionNode.checkKeyword().kind().equals(SyntaxKind.CHECKPANIC_KEYWORD)) {
-            scannerContext.getReporter().reportIssue(document, checkExpressionNode.location(),
-                    CoreRule.AVOID_CHECKPANIC.rule());
+            reportIssue(scannerContext, document, checkExpressionNode, CoreRule.AVOID_CHECKPANIC.rule());
+        }
+    }
+
+    @Override
+    public void visit(FunctionSignatureNode functionSignatureNode) {
+        functionSignatureNode.parameters().forEach(parameter -> {
+            if (parameter instanceof IncludedRecordParameterNode includedRecordParameterNode) {
+                includedRecordParameterNode.paramName().ifPresent(name -> {
+                    if (isUnusedNode(name, semanticModel)) {
+                        reportIssue(scannerContext, document, name, CoreRule.UNUSED_FUNCTION_PARAMETERS.rule());
+                    }
+                });
+            } else {
+                if (isUnusedNode(parameter, semanticModel)) {
+                    reportIssue(scannerContext, document, parameter, CoreRule.UNUSED_FUNCTION_PARAMETERS.rule());
+                }
+            }
+            this.visitSyntaxNode(parameter);
+        });
+        functionSignatureNode.returnTypeDesc().ifPresent(returnTypeDesc -> returnTypeDesc.accept(this));
+    }
+
+    @Override
+    public void visit(ImplicitAnonymousFunctionExpressionNode implicitAnonymousFunctionExpressionNode) {
+        checkUnusedParametersInImplicitFunctionExpression(implicitAnonymousFunctionExpressionNode.params());
+        this.visitSyntaxNode(implicitAnonymousFunctionExpressionNode.expression());
+    }
+
+    private void checkUnusedParametersInImplicitFunctionExpression(Node params) {
+        if (params instanceof ImplicitAnonymousFunctionParameters parameters) {
+            parameters.parameters().forEach(parameter -> {
+                if (isUnusedNode(parameter, semanticModel)) {
+                    reportIssue(scannerContext, document, parameter, CoreRule.UNUSED_FUNCTION_PARAMETERS.rule());
+                }
+            });
+            return;
+        }
+
+        if (params instanceof SimpleNameReferenceNode) {
+            if (isUnusedNode(params, semanticModel)) {
+                reportIssue(scannerContext, document, params, CoreRule.UNUSED_FUNCTION_PARAMETERS.rule());
+            }
         }
     }
+
+    private void reportIssue(ScannerContext scannerContext, Document document, Node node, Rule rule) {
+        scannerContext.getReporter().reportIssue(document, node.location(), rule);
+    }
+
+    private boolean isUnusedNode(Node node, SemanticModel semanticModel) {
+        Optional<Symbol> symbol = semanticModel.symbol(node);
+        if (symbol.isEmpty()) {
+            return false;
+        }
+
+        return semanticModel.references(symbol.get()).size() == 1;
+    }
 }

scan-command/src/main/java/io/ballerina/scan/utils/RuleDescription.java

@@ -0,0 +1,9 @@
+package io.ballerina.scan.utils;
+
+public class RuleDescription {
+    public static final String AVOID_CHECKPANIC = "Avoid checkpanic";
+    public static final String UNUSED_FUNCTION_PARAMETERS = "Unused function parameters";
+
+    private RuleDescription() {
+    }
+}

scan-command/src/test/java/io/ballerina/scan/internal/CheckPanicAnalyzerTest.java

@@ -0,0 +1,28 @@
+package io.ballerina.scan.internal;
+
+import io.ballerina.projects.Document;
+import io.ballerina.scan.Issue;
+import io.ballerina.scan.RuleKind;
+import io.ballerina.scan.utils.RuleDescription;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+public class CheckPanicAnalyzerTest extends StaticCodeAnalyzerTest {
+
+    @Test(description = "test checkpanic analyzer")
+    void testCheckpanicAnalyzer() {
+        String documentName = "rule_checkpanic.bal";
+        Document document = loadDocument(documentName);
+        ScannerContextImpl scannerContext = new ScannerContextImpl(List.of(CoreRule.AVOID_CHECKPANIC.rule()));
+        StaticCodeAnalyzer staticCodeAnalyzer = new StaticCodeAnalyzer(document,
+                scannerContext, document.module().getCompilation().getSemanticModel());
+        staticCodeAnalyzer.analyze();
+        List<Issue> issues = scannerContext.getReporter().getIssues();
+        Assert.assertEquals(issues.size(), 1);
+
+        assertIssue(issues.get(0), documentName, 20, 17, 20, 39, "ballerina:1", 1,
+                RuleDescription.AVOID_CHECKPANIC, RuleKind.CODE_SMELL);
+    }
+}

scan-command/src/test/java/io/ballerina/scan/internal/CoreRuleTest.java

@@ -20,6 +20,7 @@
 
 import io.ballerina.scan.Rule;
 import io.ballerina.scan.RuleKind;
+import io.ballerina.scan.utils.RuleDescription;
 import org.testng.Assert;
 import org.testng.annotations.Test;
 
@@ -31,15 +32,24 @@
 public class CoreRuleTest {
     @Test(description = "test all rules")
     void testAllRules() {
-        Assert.assertEquals(CoreRule.rules().size(), 1);
+        Assert.assertEquals(CoreRule.rules().size(), 2);
     }
 
     @Test(description = "test checkpanic rule")
     void testCheckpanicRule() {
         Rule rule = CoreRule.AVOID_CHECKPANIC.rule();
         Assert.assertEquals(rule.id(), "ballerina:1");
         Assert.assertEquals(rule.numericId(), 1);
-        Assert.assertEquals(rule.description(), "Avoid checkpanic");
+        Assert.assertEquals(rule.description(), RuleDescription.AVOID_CHECKPANIC);
+        Assert.assertEquals(rule.kind(), RuleKind.CODE_SMELL);
+    }
+
+    @Test(description = "test unused function parameters test")
+    void testUnusedFunctionParameterRule() {
+        Rule rule = CoreRule.UNUSED_FUNCTION_PARAMETERS.rule();
+        Assert.assertEquals(rule.id(), "ballerina:2");
+        Assert.assertEquals(rule.numericId(), 2);
+        Assert.assertEquals(rule.description(), RuleDescription.UNUSED_FUNCTION_PARAMETERS);
         Assert.assertEquals(rule.kind(), RuleKind.CODE_SMELL);
     }
 }

scan-command/src/test/java/io/ballerina/scan/internal/StaticCodeAnalyzerTest.java

@@ -29,10 +29,8 @@
 import io.ballerina.scan.Source;
 import io.ballerina.tools.text.LineRange;
 import org.testng.Assert;
-import org.testng.annotations.Test;
 
 import java.nio.file.Path;
-import java.util.List;
 
 /**
  * Core analyzer tests.
@@ -42,33 +40,25 @@
 public class StaticCodeAnalyzerTest extends BaseTest {
     private final Path coreRuleBalFiles = testResources.resolve("test-resources").resolve("core-rules");
 
-    private Document loadDocument(String documentName) {
+    Document loadDocument(String documentName) {
         Project project = SingleFileProject.load(coreRuleBalFiles.resolve(documentName));
         Module defaultModule = project.currentPackage().getDefaultModule();
         return defaultModule.document(defaultModule.documentIds().iterator().next());
     }
 
-    @Test(description = "test checkpanic analyzer")
-    void testCheckpanicAnalyzer() {
-        String documentName = "rule_checkpanic.bal";
-        Document document = loadDocument(documentName);
-        ScannerContextImpl scannerContext = new ScannerContextImpl(List.of(CoreRule.AVOID_CHECKPANIC.rule()));
-        StaticCodeAnalyzer staticCodeAnalyzer = new StaticCodeAnalyzer(document, scannerContext);
-        staticCodeAnalyzer.analyze();
-        List<Issue> issues = scannerContext.getReporter().getIssues();
-        Assert.assertEquals(issues.size(), 1);
-        Issue issue = issues.get(0);
+    void assertIssue(Issue issue, String documentName, int startLine, int startOffset, int endLine, int endOffset,
+                     String ruleId, int numericId, String description, RuleKind ruleKind) {
         Assert.assertEquals(issue.source(), Source.BUILT_IN);
         LineRange location = issue.location().lineRange();
         Assert.assertEquals(location.fileName(), documentName);
-        Assert.assertEquals(location.startLine().line(), 20);
-        Assert.assertEquals(location.startLine().offset(), 17);
-        Assert.assertEquals(location.endLine().line(), 20);
-        Assert.assertEquals(location.endLine().offset(), 39);
+        Assert.assertEquals(location.startLine().line(), startLine);
+        Assert.assertEquals(location.startLine().offset(), startOffset);
+        Assert.assertEquals(location.endLine().line(), endLine);
+        Assert.assertEquals(location.endLine().offset(), endOffset);
         Rule rule = issue.rule();
-        Assert.assertEquals(rule.id(), "ballerina:1");
-        Assert.assertEquals(rule.numericId(), 1);
-        Assert.assertEquals(rule.description(), "Avoid checkpanic");
-        Assert.assertEquals(rule.kind(), RuleKind.CODE_SMELL);
+        Assert.assertEquals(rule.id(), ruleId);
+        Assert.assertEquals(rule.numericId(), numericId);
+        Assert.assertEquals(rule.description(), description);
+        Assert.assertEquals(rule.kind(), ruleKind);
     }
 }