@specs-feup/clava-misra 1.0.2 → 1.0.3

package/src/rules/Section16_SwitchStatements/Rule_16_2_TopLevelSwitch.ts

@@ -1,21 +1,39 @@
-import { Case, Joinpoint, Switch } from "@specs-feup/clava/api/Joinpoints.js";
+import { Break, Case, Joinpoint, Switch } from "@specs-feup/clava/api/Joinpoints.js";
 import MISRARule from "../../MISRARule.js";
-import MISRAContext from "../../MISRAContext.js";
 import Query from "@specs-feup/lara/api/weaver/Query.js";
-import { MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import { AnalysisType, MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
 
 /**
- * MISRA Rule 16.2: A switch label shall only be used when the most closely-enclosing
-compound statement is the body of a switch statement
+ * MISRA-C Rule 16.2: A switch label shall only be used when the most closely-enclosing compound statement is the body of a switch statement
  */
-export default class Rule_16_2_TopLevelSwitch extends MISRARule {
-    priority = 2; 
-    #misplacedCases: Case[] = [];
+export default class Rule_16_2_TopLevelSwitch extends MISRARule {    
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SINGLE_TRANSLATION_UNIT;
+
+    /**
+     * A positive integer starting from 1 that indicates the rule's priority, determining the order in which rules are applied.
+     */
+    readonly priority = 4; 
 
-    constructor(context: MISRAContext) {
-        super("16.2", context);
+    #misplacedCases: Case[] = [];
+    
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "16.2";
     }
 
+    /**
+     * Checks if the given joinpoint is a switch statement with any misplaced case labels. 
+     * A case label is considered misplaced if it is not a direct child of the switch body.
+     * 
+     * @param $jp - Joinpoint to analyze
+     * @param logErrors - [logErrors=false] - Whether to log errors if a violation is detected
+     * @returns Returns true if the joinpoint violates the rule, false otherwise
+     */
     match($jp: Joinpoint, logErrors: boolean = false): boolean {
         if (!($jp instanceof Switch)) return false;
 
@@ -30,12 +48,84 @@ export default class Rule_16_2_TopLevelSwitch extends MISRARule {
         return this.#misplacedCases.length > 0;
     }
 
-    transform($jp: Joinpoint): MISRATransformationReport {
-        if (!this.match($jp)) return new MISRATransformationReport(MISRATransformationType.NoChange);
+    /**
+     * Transforms the joinpoint if it represents a switch with any misplaced case labels. 
+     * For that, each case label is moved to a new location within the switch.
+     * 
+     * @param $jp - Joinpoint to transform
+     * @returns Report detailing the transformation result
+     */
+    apply($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp)) 
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
         
         for (const caseLabel of this.#misplacedCases) {
-            caseLabel.detach();
+            this.changeCaseLocation(caseLabel);
         }
         return new MISRATransformationReport(MISRATransformationType.DescendantChange);
     }
+
+
+    /**
+     * Relocates a inner case to a new position while preserving control flow.
+     * First, copies the instructions to be executed (direct siblings and fall-through code).
+     * Then, moves the case to the new position and finally appends the copied instructions after the case.
+     * 
+     * @param caseLabel The inner case to relocate
+     */
+    private changeCaseLocation(caseLabel: Case) {
+        // Collect instructions that follow the given case
+        const instructions = caseLabel.siblingsRight.map(sibling => sibling.deepCopy());
+
+        // If direct instruction do not have a break statement, find additional statements from higher scopes that will be executed
+        if (!instructions.some(instruction => instruction instanceof Break)) {
+            let lastScope: Joinpoint = caseLabel;
+            do {
+                lastScope = lastScope.parent;
+                const rightStmts = lastScope.siblingsRight;
+                for (const rightStmt of rightStmts) {
+                    if (rightStmt.currentRegion instanceof Switch && rightStmt instanceof Case) {
+                        break;
+                    }
+                    instructions.push(rightStmt.deepCopy());
+                }
+            } while(!(lastScope.currentRegion instanceof Switch));
+        }
+
+        // Locate target position
+        const caseAncestor = this.getCaseAncestor(caseLabel);
+        const caseAncestorRightSiblings = caseAncestor.siblingsRight;
+        const nextCaseIndex = caseAncestorRightSiblings.findIndex(jp => jp instanceof Case);
+        const targetStmt = nextCaseIndex != -1 ? caseAncestorRightSiblings[nextCaseIndex] : caseAncestorRightSiblings[caseAncestorRightSiblings.length - 1];
+
+        // Move case label to the new position
+        caseLabel.detach();
+        if (targetStmt instanceof Case) {
+            targetStmt.insertBefore(caseLabel);
+        } else {
+            targetStmt.insertAfter(caseLabel);
+        }
+
+        // Add instructions after caseLabel
+        let lastStmt: Joinpoint = caseLabel;
+        for (const instruction of instructions) {
+            lastStmt.insertAfter(instruction);
+            lastStmt = instruction;
+        }
+    }
+
+    /**
+     * Retrieves the top-level case that contains a given inner case label.
+     * 
+     * @param caseLabel - The inner case joinpoint
+     * @returns The ancestor case that contains the given inner case
+     */
+    private getCaseAncestor(caseLabel: Case): Case {
+        let stmt: Joinpoint = caseLabel; 
+        while (!(stmt.currentRegion instanceof Switch)) {
+            stmt = stmt.parent;
+        }
+        const caseAncestor = stmt.siblingsLeft.reverse().find(jp => jp instanceof Case);
+        return caseAncestor!;
+    }
 }

package/src/rules/Section16_SwitchStatements/Rule_16_3_UnconditionalBreak.ts

@@ -1,19 +1,33 @@
-import { Break, Joinpoint, Statement, Switch, Case } from "@specs-feup/clava/api/Joinpoints.js";
+import { Break, Joinpoint, Switch, Case } from "@specs-feup/clava/api/Joinpoints.js";
 import MISRARule from "../../MISRARule.js";
-import MISRAContext from "../../MISRAContext.js";
-import { MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
-import { getLastStmtOfCase } from "../../utils/utils.js";
+import { AnalysisType, MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
 import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
+import { getLastStmtOfCase } from "../../utils/SwitchUtils.js";
 
 /**
- * MISRA Rule 16.3: An unconditional break statement shall terminate every switch-clause
+ * MISRA-C Rule 16.3: An unconditional break statement shall terminate every switch-clause
  */
 export default class Rule_16_3_UnconditionalBreak extends MISRARule {
-    priority = 2; 
-    #statementsNeedingBreakAfter: Joinpoint[] = [];
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SINGLE_TRANSLATION_UNIT;
 
-    constructor(context: MISRAContext) {
-        super("16.3", context);
+    /**
+     * A positive integer starting from 1 that indicates the rule's priority, determining the order in which rules are applied.
+     */
+    readonly priority = 3; 
+    
+    /**
+     * List of statements that require a `break` statement as their last sibling 
+     */
+    #statementsNeedingBreakAfter: Joinpoint[] = [];
+    
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "16.3";
     }
 
     match($jp: Joinpoint, logErrors: boolean = false): boolean {
@@ -54,7 +68,7 @@ export default class Rule_16_3_UnconditionalBreak extends MISRARule {
         lastStmt.insertAfter(ClavaJoinPoints.breakStmt());
     }
 
-    transform($jp: Joinpoint): MISRATransformationReport {
+    apply($jp: Joinpoint): MISRATransformationReport {
         if (!this.match($jp)) 
             return new MISRATransformationReport(MISRATransformationType.NoChange);
         

package/src/rules/Section16_SwitchStatements/Rule_16_4_SwitchHasDefault.ts

@@ -1,16 +1,22 @@
 import { Joinpoint, Switch } from "@specs-feup/clava/api/Joinpoints.js";
 import MISRARule from "../../MISRARule.js";
-import MISRAContext from "../../MISRAContext.js";
-import { MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import { AnalysisType, MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
 import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
-import { getNumOfSwitchClauses, switchHasBooleanCondition, switchHasConditionalBreak } from "../../utils/utils.js";
 
 /**
- * MISRA Rule 16.4: Every switch statement shall have a default label
+ * MISRA-C Rule 16.4: Every switch statement shall have a default label
  */
 export default class Rule_16_4_SwitchHasDefault extends MISRARule {
-    constructor(context: MISRAContext) {
-        super("16.4", context);
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SINGLE_TRANSLATION_UNIT;
+
+     /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "16.4";
     }
 
     /**
@@ -29,13 +35,16 @@ export default class Rule_16_4_SwitchHasDefault extends MISRARule {
         return noDefaultCase;
     }
 
-    transform($jp: Joinpoint): MISRATransformationReport {
-        if (!this.match($jp)) return new MISRATransformationReport(MISRATransformationType.NoChange);
+    apply($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp)) 
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
 
         $jp.children[1].lastChild
             .insertAfter(ClavaJoinPoints.defaultStmt())
             .insertAfter(ClavaJoinPoints.emptyStmt())
             .insertAfter(ClavaJoinPoints.breakStmt());
+
+        this.context.addRuleResult(this.ruleID, $jp, MISRATransformationType.DescendantChange);
         return new MISRATransformationReport(MISRATransformationType.DescendantChange);
     }
 }

package/src/rules/Section16_SwitchStatements/Rule_16_5_DefaultFirstOrLast.ts

@@ -1,17 +1,22 @@
-import {Case, Comment, Joinpoint, Statement, Switch, WrapperStmt } from "@specs-feup/clava/api/Joinpoints.js";
+import {Case, Joinpoint, Switch } from "@specs-feup/clava/api/Joinpoints.js";
 import MISRARule from "../../MISRARule.js";
-import MISRAContext from "../../MISRAContext.js";
-import { MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
-import { isCommentStmt } from "../../utils/utils.js";
+import { AnalysisType, MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import { isCommentStmt } from "../../utils/CommentUtils.js";
 
 /**
- * MISRA Rule 16.5: A default label shall appear as either the first or the last switch label of
-a switch statement
+ * MISRA-C Rule 16.5: A default label shall appear as either the first or the last switch label of a switch statement
  */
 export default class Rule_16_5_DefaultFirstOrLast extends MISRARule {
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SINGLE_TRANSLATION_UNIT;
 
-    constructor(context: MISRAContext) {
-        super("16.5", context);
+     /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "16.5";
     }
 
     /**
@@ -24,7 +29,7 @@ export default class Rule_16_5_DefaultFirstOrLast extends MISRARule {
     private getConsecutiveRightCases($jp: Case): Joinpoint[] {
         const cases = [];
         for (const stmt of $jp.siblingsRight) {
-            if (!(stmt instanceof Case || isCommentStmt($jp)))
+            if (!(stmt instanceof Case || isCommentStmt(stmt)))
                 break;
             cases.push(stmt);
         }
@@ -67,7 +72,7 @@ export default class Rule_16_5_DefaultFirstOrLast extends MISRARule {
                     return false;
                 } 
                 if (logErrors) {
-                    this.logMISRAError($jp, "The default case of a switch statement must be the first or last label.")
+                    this.logMISRAError(currentCase, "The default case of a switch statement must be the first or last label.")
                 }
                 return true;
             }
@@ -82,8 +87,11 @@ export default class Rule_16_5_DefaultFirstOrLast extends MISRARule {
      * @param $jp - Joinpoint to transform
      * @returns Report detailing the transformation result
      */
-    transform($jp: Joinpoint): MISRATransformationReport {
-        if (!this.match($jp)) return new MISRATransformationReport(MISRATransformationType.NoChange);
+    apply($jp: Joinpoint): MISRATransformationReport {
+        const previousResult = $jp instanceof Switch ? this.context.getRuleResult("16.4", $jp) : undefined;
+        if (previousResult === MISRATransformationType.DescendantChange || !this.match($jp)) {
+            return new MISRATransformationReport(MISRATransformationType.NoChange);   
+        }
 
         const defaultCase = ($jp as Switch).getDefaultCase;
         const rightStatements = defaultCase.siblingsRight.filter(sibling => !isCommentStmt(sibling));

package/src/rules/Section16_SwitchStatements/Rule_16_6_SwitchMinTwoClauses.ts

@@ -1,17 +1,27 @@
-import {Break, Case, Joinpoint, Statement, Expression, Switch } from "@specs-feup/clava/api/Joinpoints.js";
+import {Joinpoint, Switch } from "@specs-feup/clava/api/Joinpoints.js";
 import MISRARule from "../../MISRARule.js";
-import MISRAContext from "../../MISRAContext.js";
-import { MISRASwitchConverter, MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
-import { getNumOfSwitchClauses, switchHasConditionalBreak } from "../../utils/utils.js";
+import { AnalysisType, MISRASwitchConverter, MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import { countSwitchClauses, hasConditionalBreak } from "../../utils/SwitchUtils.js";
 
 /**
- * MISRA Rule 16.6:  Every switch statement shall have at least two switch-clauses.
+ * MISRA-C Rule 16.6:  Every switch statement shall have at least two switch-clauses.
  */
 export default class Rule_16_6_SwitchMinTwoClauses extends MISRARule {
-    priority = 3;
+    /**
+     * A positive integer starting from 1 that indicates the rule's priority, determining the order in which rules are applied.
+     */
+    readonly priority = 5;
 
-    constructor(context: MISRAContext) {
-        super("16.6", context);
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SINGLE_TRANSLATION_UNIT;
+
+     /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "16.6";
     }
 
     /**
@@ -23,7 +33,7 @@ export default class Rule_16_6_SwitchMinTwoClauses extends MISRARule {
     match($jp: Joinpoint, logErrors: boolean = false): boolean {
         if (!($jp instanceof Switch)) return false;
 
-        const nonCompliant = getNumOfSwitchClauses($jp) < 2;
+        const nonCompliant = countSwitchClauses($jp) < 2;
         if (nonCompliant && logErrors) {
             this.logMISRAError($jp, "Switch statements should have at least two clauses.")
         }
@@ -37,11 +47,12 @@ export default class Rule_16_6_SwitchMinTwoClauses extends MISRARule {
      * @param $jp - Joinpoint to transform
      * @returns Report detailing the transformation result
      */
-    transform($jp: Joinpoint): MISRATransformationReport {
-        if (!this.match($jp)) return new MISRATransformationReport(MISRATransformationType.NoChange);
+    apply($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp)) 
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
         
         const switchJp = $jp as Switch;
-        if (switchHasConditionalBreak(switchJp)) {
+        if (hasConditionalBreak(switchJp)) {
             if (switchJp.hasDefaultCase) {
                 this.logMISRAError($jp, "Switch statement must have at least two clauses and cannot be transformed due to a conditional break statement.")
             }

package/src/rules/Section16_SwitchStatements/Rule_16_7_NonBooleanSwitchCondition.ts

@@ -1,16 +1,46 @@
-import { BuiltinType, Joinpoint, Switch } from "@specs-feup/clava/api/Joinpoints.js";
+import { BinaryOp, BuiltinType, Joinpoint, Switch, UnaryOp } from "@specs-feup/clava/api/Joinpoints.js";
 import MISRARule from "../../MISRARule.js";
-import MISRAContext from "../../MISRAContext.js";
-import { MISRASwitchConverter, MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
-import { switchHasBooleanCondition, switchHasConditionalBreak } from "../../utils/utils.js";
+import { AnalysisType, MISRASwitchConverter, MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import { hasConditionalBreak } from "../../utils/SwitchUtils.js";
+import { hasDefinedType } from "../../utils/JoinpointUtils.js";
 
 /**
- * MISRA Rule 16.7: A switch-expression shall not have essentially Boolean type.
+ * MISRA-C Rule 16.7: A switch-expression shall not have essentially Boolean type.
  */
 export default class Rule_16_7_NonBooleanSwitchCondition extends MISRARule {
-    priority = 3; 
-    constructor(context: MISRAContext) {
-        super("16.7", context);
+    /**
+     * A positive integer starting from 1 that indicates the rule's priority, determining the order in which rules are applied.
+     */
+    readonly priority = 5; 
+    
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SINGLE_TRANSLATION_UNIT;
+
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "16.7";
+    }
+
+    /**
+     * Checks if the provided switch statement has a Boolean condition
+     * @param switchStmt The switch statement to check
+     * @returns Returns true if the switch statement has a Boolean condition, otherwise false
+     */
+    switchHasBooleanCondition(switchStmt: Switch): boolean {
+        const switchCondition = switchStmt.condition;
+
+        if (switchCondition instanceof BinaryOp || switchCondition instanceof UnaryOp) {
+            const logicalOps = new Set(["lt", "gt", "le", "ge", "eq", "ne", "not", "l_not", "and", "or"]);
+            return logicalOps.has(switchCondition.kind);
+        }
+        
+        return hasDefinedType(switchCondition) && 
+            switchCondition.type instanceof BuiltinType && 
+            switchCondition.type.builtinKind === "Bool";
     }
 
     /**
@@ -22,9 +52,9 @@ export default class Rule_16_7_NonBooleanSwitchCondition extends MISRARule {
     match($jp: Joinpoint, logErrors: boolean = false): boolean {
         if (!($jp instanceof Switch)) return false;
 
-        const booleanCondition = switchHasBooleanCondition($jp);
+        const booleanCondition = this.switchHasBooleanCondition($jp);
         if (booleanCondition && logErrors) {
-            this.logMISRAError($jp, `Switch statement controlling expression ${$jp.condition.code} must not have essentially boolean type.`)
+            this.logMISRAError($jp, `Switch statement controlling expression '${$jp.condition.code}' must not have essentially boolean type.`)
         }    
         return booleanCondition;
     }
@@ -36,10 +66,11 @@ export default class Rule_16_7_NonBooleanSwitchCondition extends MISRARule {
      * @param $jp - Joinpoint to transform
      * @returns Report detailing the transformation result
      */
-    transform($jp: Joinpoint): MISRATransformationReport {
-        if (!this.match($jp)) return new MISRATransformationReport(MISRATransformationType.NoChange);
+    apply($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp)) 
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
 
-        if (switchHasConditionalBreak($jp as Switch)) {
+        if (hasConditionalBreak($jp as Switch)) {
             this.logMISRAError($jp, `The switch statement's controlling expression ${($jp as Switch).condition.code} must not be of a boolean type and cannot be transformed due to a conditional break statement.`)
             return new MISRATransformationReport(MISRATransformationType.NoChange);
         }