Extend Rule0051 on exit() method with Label variable (#1097)

Author: Arthurvdv

BusinessCentral.LinterCop.Test/Rule0051.cs

@@ -13,6 +13,7 @@ public void Setup()
     }
 
     [Test]
+    [TestCase("ExitStatementLabel")]
 #if !LessThenSpring2024
     [TestCase("GetMethodStringLiteral")]
     [TestCase("GetMethodStrSubstNo")]
@@ -29,6 +30,8 @@ public async Task HasDiagnostic(string testCase)
     }
 
     [Test]
+    [TestCase("ExitStatementLabelWithLocked")]
+    [TestCase("ExitStatementLabelWithMaxLength")]
 #if !LessThenSpring2024
     [TestCase("GetMethodCompanyName")]
     [TestCase("GetMethodStringLiteral")]

BusinessCentral.LinterCop.Test/TestCases/Rule0051/HasDiagnostic/ExitStatementLabel.al

@@ -0,0 +1,9 @@
+codeunit 50000 MyCodeunit
+{
+    internal procedure MyProcedure(): Text[10]
+    var
+        MyLabelLbl: Label 'My Label';
+    begin
+        exit([|MyLabelLbl|]);
+end;
+}

BusinessCentral.LinterCop.Test/TestCases/Rule0051/NoDiagnostic/ExitStatementLabelWithLocked.al

@@ -0,0 +1,9 @@
+codeunit 50000 MyCodeunit
+{
+    internal procedure MyProcedure(): Text[10]
+    var
+        MyLabelLbl: Label 'My Label', Locked = true;
+    begin
+        exit([|MyLabelLbl|]);
+end;
+}

BusinessCentral.LinterCop.Test/TestCases/Rule0051/NoDiagnostic/ExitStatementLabelWithMaxLength.al

@@ -0,0 +1,9 @@
+codeunit 50000 MyCodeunit
+{
+    internal procedure MyProcedure(): Text[10]
+    var
+        MyLabelLbl: Label 'My Label', MaxLength = 10;
+    begin
+        exit([|MyLabelLbl|]);
+end;
+}

BusinessCentral.LinterCop/Design/Rule0051PossibleOverflowAssigning.cs

@@ -4,7 +4,9 @@
 using BusinessCentral.LinterCop.Helpers;
 using Microsoft.Dynamics.Nav.CodeAnalysis;
 using Microsoft.Dynamics.Nav.CodeAnalysis.Diagnostics;
+using Microsoft.Dynamics.Nav.CodeAnalysis.Semantics;
 using Microsoft.Dynamics.Nav.CodeAnalysis.Symbols;
+using Microsoft.Dynamics.Nav.CodeAnalysis.Syntax;
 
 namespace BusinessCentral.LinterCop.Design;
 
@@ -31,6 +33,7 @@ public override void Initialize(AnalysisContext context)
 #if !LessThenSpring2024
         context.RegisterOperationAction(AnalyzeGetMethod, OperationKind.InvocationExpression);
 #endif
+        context.RegisterOperationAction(AnalyzeExitStatement, OperationKind.ExitStatement);
     }
     private void AnalyzeSetFilter(OperationAnalysisContext ctx)
     {
@@ -161,6 +164,82 @@ private void AnalyzeGetMethod(OperationAnalysisContext ctx)
     }
 #endif
 
+    // This rule is an extension of the CodeCop AA0139 to only check for Label variables without the MaxLength or Locked property explicitly set.
+    // https://learn.microsoft.com/en-us/dynamics365/business-central/dev-itpro/developer/analyzers/codecop-aa0139
+    private void AnalyzeExitStatement(OperationAnalysisContext ctx)
+    {
+        if (ctx.IsObsoletePendingOrRemoved() || ctx.Operation is not IExitStatement operation)
+            return;
+
+        // Early return if there is no returned value on the exit statement
+        if (operation.ReturnedValue is null || operation.ReturnedValue is not IConversionExpression argValue)
+            return;
+
+        if (argValue.Operand.Type.GetNavTypeKindSafe() != NavTypeKind.Label)
+            return;
+
+        if (argValue.Operand.GetSymbol() is not IVariableSymbol variable)
+            return;
+
+        var syntax = variable.DeclaringSyntaxReference?.GetSyntax();
+        if (syntax is null)
+            return;
+
+        var propertiesNode = syntax.DescendantNodes()
+            .FirstOrDefault(n => n.Kind == SyntaxKind.CommaSeparatedIdentifierEqualsLiteralList);
+
+        bool hasMaxLengthOrLocked = false;
+        if (propertiesNode is not null)
+        {
+            foreach (var child in propertiesNode.ChildNodes())
+            {
+                if (child is IdentifierEqualsLiteralSyntax prop)
+                {
+                    string name = prop.Identifier.ToString();
+                    if (name.Equals("MaxLength", StringComparison.OrdinalIgnoreCase) ||
+                        name.Equals("Locked", StringComparison.OrdinalIgnoreCase))
+                    {
+                        hasMaxLengthOrLocked = true;
+                        break;
+                    }
+                }
+            }
+        }
+
+        // If the property MaxLength or Locked is set, then let the CodeCop AA0139 rule handle it.
+        if (hasMaxLengthOrLocked)
+            return;
+
+        if (ctx.Operation.Syntax.GetFirstParent(SyntaxKind.MethodDeclaration) is not MethodDeclarationSyntax methodDeclaration)
+            return;
+
+        var semanticModel = ctx.Compilation.GetSemanticModel(methodDeclaration.SyntaxTree);
+        var returnValueSymbol = semanticModel.GetDeclaredSymbol(methodDeclaration.ReturnValue);
+
+        if (returnValueSymbol?.GetTypeSymbol() is not ITypeSymbol returnTypeSymbol)
+            return;
+
+        bool isError = false;
+        int typeLength = GetTypeLength(returnTypeSymbol, ref isError);
+        if (isError || typeLength == int.MaxValue)
+            return;
+
+        int expressionLength = this.CalculateMaxExpressionLength(argValue.Operand, ref isError);
+        if (!isError && expressionLength > typeLength)
+        {
+            string lengthSuffix = expressionLength < int.MaxValue
+                ? $"[{expressionLength}]"
+                : string.Empty;
+
+            ctx.ReportDiagnostic(
+                Diagnostic.Create(
+                    DiagnosticDescriptors.Rule0051PossibleOverflowAssigning,
+                    operation.ReturnedValue.Syntax.GetLocation(),
+                    $"{variable.GetTypeSymbol().ToDisplayString()}{lengthSuffix}",
+                    returnTypeSymbol.ToDisplayString()));
+        }
+    }
+
     private static int GetTypeLength(ITypeSymbol type, ref bool isError)
     {
         if (!type.IsTextType())