@specs-feup/clava-misra 1.0.2 → 1.0.4

package/src/ast-visitor/Context.ts

@@ -0,0 +1,16 @@
+/**
+ * Key-value storage to share data between visits
+ * 
+ *  @template T Type of the stored values
+ */
+export default class Context<T> {
+    protected storage: Map<string, T> = new Map();
+
+    put(key: string, value: T) {
+        this.storage.set(key, value);
+    }
+
+    get(key: string): T | undefined {
+        return this.storage.get(key);
+    } 
+}

package/src/ast-visitor/Visit.ts

@@ -0,0 +1,26 @@
+import { LaraJoinPoint } from "@specs-feup/lara/api/LaraJoinPoint.js";
+
+/**
+ * Common interface for AST transformations applied to a single node
+ * 
+ * Need to implement:
+ * - apply($jp)
+ * 
+ * @template T Type of data stored in the shared context
+ * @template C Type of the context (default is Context<T>)
+ */
+export default abstract class Visit {
+    /**
+     * Applies the transformation to the given node
+     * @param $jp The node to transform
+     * @returns Transformation result
+     */
+    abstract apply($jp: LaraJoinPoint): unknown;
+
+    /**
+     * @returns List of dependent visits, which is empty by default
+     */
+    get dependencies(): Visit[] {
+        return [];
+    }
+}

package/src/ast-visitor/VisitWithContext.ts

@@ -0,0 +1,42 @@
+import { LaraJoinPoint } from "@specs-feup/lara/api/LaraJoinPoint.js";
+import Context from "./Context.js";
+import Visit from "./Visit.js";
+
+/**
+ * Visit with a shared context to enable communication between visits 
+ * 
+ * Need to implement:
+ * - apply($jp)
+ * - initialValue()
+ */
+export default abstract class VisitWithContext<T, C extends Context<T> = Context<T>> extends Visit {
+    protected context: C;
+
+    /**
+     * @param context Shared context object
+     */
+    constructor(context: C) {
+        super();
+        this.context = context;
+        this.context.put(this.name, this.initialValue());
+    }
+
+    /**
+     * @return Visit name, defaults to class name
+     */
+    get name(): string {
+        return this.constructor.name;
+    }
+
+    /**
+     * @returns Initial value stored in the shared context
+     */
+    abstract initialValue(): T;
+
+    /**
+     * Applies the transformation to the given node
+     * @param $jp The node to transform
+     * @returns Transformation result
+     */
+    abstract apply($jp: LaraJoinPoint): unknown;
+}

package/src/main.ts

@@ -1,7 +1,4 @@
-import VisualizationTool from "@specs-feup/clava-visualization/api/VisualizationTool.js";
 import MISRATool from "./MISRATool.js";
 
 MISRATool.checkCompliance();
-MISRATool.applyCorrections();
-
-//await VisualizationTool.visualize();
+MISRATool.correctViolations();

package/src/rules/Section13_SideEffects/Rule_13_6_SafeSizeOfOperand.ts

@@ -0,0 +1,114 @@
+import { BinaryOp, Call, FileJp, Joinpoint, ParenExpr, UnaryExprOrType, UnaryOp, VariableArrayType, Varref } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRARule from "../../MISRARule.js";
+import { AnalysisType, MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { getVolatileVarRefs } from "../../utils/VarUtils.js";
+import { isValidFile } from "../../utils/FileUtils.js";
+import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
+
+/**
+ * MISRA-C Rule 13.6: The operand of the sizeof operator shall not contain any expression which has potential side effects
+ */
+export default class Rule_13_6_SafeSizeOfOperand extends MISRARule {   
+    /**
+     * Scope of analysis
+     */
+    analysisType = AnalysisType.SINGLE_TRANSLATION_UNIT;
+
+    #modifyingExpressions: (UnaryOp | BinaryOp)[] = [];
+    #functionCalls: Call[] = [];
+    #volatileRefs: Varref[] = [];
+
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "13.6";
+    }
+
+    private operandIsVariableArrayType($jp: UnaryExprOrType) {
+        return $jp.argType != undefined && $jp.argType instanceof VariableArrayType;
+    }
+
+    /**
+     * 
+     * @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 UnaryExprOrType && $jp.kind === "sizeof")) {
+            return false;
+        }
+
+        this.#functionCalls = Query.searchFromInclusive($jp, Call).get();
+        this.#volatileRefs = this.operandIsVariableArrayType($jp) ? getVolatileVarRefs(($jp.argType as VariableArrayType).sizeExpr) : [];
+        this.#modifyingExpressions = [
+            ...Query.searchFromInclusive($jp, UnaryOp,  {kind: /(post_inc)|(post_dec)|(pre_inc)|(pre_dec)/}).get(), 
+            ...Query.searchFromInclusive($jp, BinaryOp, {kind: /(assign)|(add_assign)|(sub_assign)|(mul_assign)|(div_assign)|(rem_assign)|(shl_assign)|(shr_assign)|(and_assign)|(xor_assign)|(or_assign)/}).get()
+        ];
+
+        const isNonCompliant = this.#functionCalls.length > 0 || this.#modifyingExpressions.length > 0 || this.#volatileRefs.length > 0;
+
+        if (isNonCompliant && logErrors) {
+            this.#functionCalls.forEach(call => {
+                this.logMISRAError(call, `Function call '${call.name}' in sizeof is not allowed because it has no effect.`);
+            });
+
+            this.#modifyingExpressions.forEach(expr => {
+                this.logMISRAError(expr, `Modifying expression '${expr.code}' in sizeof is not allowed because it has no effect.`);
+            });
+
+            this.#volatileRefs.forEach(ref => {
+                this.logMISRAError(ref, `Access to volatile object ${ref.name} in sizeof is not allowed.`);
+            });
+        } 
+
+        return isNonCompliant;        
+    }
+
+    apply($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp)) {
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
+        }
+
+        if (!this.operandIsVariableArrayType($jp as UnaryExprOrType)) {
+            for (const callJp of this.#functionCalls) {
+                const callAncestor = callJp.getAncestor("call");
+                if (callAncestor === undefined || callAncestor.depth < $jp.depth) {
+                    const functionType = callJp.functionType.returnType;
+                    const fileJp = callJp.getAncestor("file") as FileJp;
+                    const tempJp = fileJp.lastChild.insertAfter(ClavaJoinPoints.stmtLiteral(`static int _temp_misra_var = sizeof(${functionType.code});`));
+                    const jpIndex = Query.searchFrom(fileJp, UnaryExprOrType).get().length;
+
+                    let newSizeOf = isValidFile(fileJp, UnaryExprOrType, jpIndex) as UnaryExprOrType;
+                    newSizeOf = $jp.replaceWith(newSizeOf) as UnaryExprOrType;
+                    newSizeOf.setArgType(functionType);
+                    tempJp.detach();
+                    return new MISRATransformationReport(MISRATransformationType.Replacement, newSizeOf);
+                }
+            }
+
+            for (const expr of this.#modifyingExpressions) {
+                let varRef = expr instanceof BinaryOp ? 
+                    expr.left : Query.searchFrom(expr, Varref).get()[0];
+                expr.replaceWith(varRef);
+            }
+            return new MISRATransformationReport(MISRATransformationType.DescendantChange);
+        } 
+        else {
+            this.#functionCalls.forEach(call => {
+                this.logMISRAError(call, `Function call '${call.name}' in sizeof is not allowed. Could not correct because it is used to define a variable-length array type and it is unspecified whether it will be evaluated or not.`);
+            });
+
+            this.#modifyingExpressions.forEach(expr => {
+                this.logMISRAError(expr, `Modifying expression '${expr.code}' in sizeof is not allowed. Could not correct because it is used to define a variable-length array type and it is unspecified whether it will be evaluated or not.`);
+            });
+
+            this.#volatileRefs.forEach(ref => {
+                this.logMISRAError(ref,`Access to volatile object '${ref.name}' in sizeof is not allowed. Could not correct because it is used to define a variable-length array type and it is unspecified whether it will be evaluated or not.`);
+            });
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
+        }
+    }
+}

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);
         }