@specs-feup/clava-misra 1.0.0 → 1.0.1

package/src/rules/Section16_SwitchStatements/Rule_16_2_TopLevelSwitch.ts

@@ -0,0 +1,40 @@
+import { 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";
+
+/**
+ * MISRA Rule 16.2: A switch label shall only be used when the most closely-enclos ing
+compound statement is the body of a switch statement
+ */
+export default class Rule_16_2_TopLevelSwitch extends MISRARule {
+    #misplacedCases: Case[] = [];
+
+    constructor(context: MISRAContext) {
+        super("16.2", context);
+    }
+
+    match($jp: Joinpoint, logErrors: boolean = false): boolean {
+        if (!($jp instanceof Switch)) return false;
+
+        this.#misplacedCases = Query.searchFrom($jp, Case).get()
+            .filter(caseLabel => !(caseLabel.currentRegion instanceof Switch));
+
+        if (logErrors) {
+            this.#misplacedCases.forEach(caseLabel =>
+                this.logMISRAError(caseLabel, "A switch label can only be used if its enclosing compound statement is the switch statement itself.")
+            );
+        }    
+        return this.#misplacedCases.length > 0;
+    }
+
+    transform($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp)) return new MISRATransformationReport(MISRATransformationType.NoChange);
+        
+        for (const caseLabel of this.#misplacedCases) {
+            caseLabel.detach();
+        }
+        return new MISRATransformationReport(MISRATransformationType.DescendantChange);
+    }
+}

package/src/rules/Section16_SwitchStatements/Rule_16_3_UnconditionalBreak.ts

@@ -0,0 +1,69 @@
+import { Break, Joinpoint, Statement, 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 ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
+
+/**
+ * MISRA Rule 16.3: An unconditional break statement shall terminate every switch-clause
+ */
+export default class Rule_16_3_UnconditionalBreak extends MISRARule {
+    #statementsNeedingBreakAfter: Joinpoint[] = [];
+
+    constructor(context: MISRAContext) {
+        super("16.3", context);
+    }
+
+    match($jp: Joinpoint, logErrors: boolean = false): boolean {
+        if (!($jp instanceof Switch)) return false;
+
+        this.#statementsNeedingBreakAfter = $jp.cases.map(caseLabel => getLastStmtOfCase(caseLabel))
+            .filter(lastStmt => lastStmt && !(lastStmt instanceof Break)) as Joinpoint[];
+
+        if (logErrors) {
+            this.#statementsNeedingBreakAfter.forEach(stmt => {
+                this.logMISRAError(stmt, `Missing unconditional break after statement '${stmt.code}'`);
+            });
+        }
+        return this.#statementsNeedingBreakAfter.length > 0;
+    }
+
+    private getNextStatementsToExecute(jp: Joinpoint): Joinpoint[] {
+        let stmts = [];
+
+        for (const sibling of jp.siblingsRight) {
+            if (sibling instanceof Break)
+                break;
+            if (sibling instanceof Case)
+                continue;
+            stmts.push(sibling.deepCopy());
+        }
+        return stmts;
+    }
+
+    private insertNextStatementsToExecute(jp: Joinpoint) {
+        const nextStmts = this.getNextStatementsToExecute(jp);
+        let lastStmt = jp;
+
+        for (const stmt of nextStmts) {
+            lastStmt.insertAfter(stmt);
+            lastStmt = stmt;
+        }
+        lastStmt.insertAfter(ClavaJoinPoints.breakStmt());
+    }
+
+    transform($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp)) 
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
+        
+        for (const stmt of this.#statementsNeedingBreakAfter) {
+            if (stmt.rightJp === undefined) { // last statement of the switch
+                stmt.insertAfter(ClavaJoinPoints.breakStmt());
+            } else {
+                this.insertNextStatementsToExecute(stmt);
+            }
+        }
+        return new MISRATransformationReport(MISRATransformationType.DescendantChange);
+    }
+}

package/src/rules/Section16_SwitchStatements/Rule_16_4_SwitchHasDefault.ts

@@ -0,0 +1,46 @@
+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 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
+ */
+export default class Rule_16_4_SwitchHasDefault extends MISRARule {
+    constructor(context: MISRAContext) {
+        super("16.4", context);
+    }
+
+    /**
+     * Checks if the given joinpoint is a switch statement with a default case
+     * @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;
+
+        const noDefaultCase = !$jp.hasDefaultCase;
+        if (noDefaultCase && logErrors) {
+            this.logMISRAError($jp, "Switch statement is missing a default case.")
+        }    
+        return noDefaultCase;
+    }
+
+    transform($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp)) return new MISRATransformationReport(MISRATransformationType.NoChange);
+
+        if ((getNumOfSwitchClauses($jp as Switch) < 2 || switchHasBooleanCondition($jp as Switch)) &&
+            !switchHasConditionalBreak($jp as Switch)) { // Will be handled by rules 16.6 or 16.7
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
+        } 
+
+        $jp.children[1].lastChild
+            .insertAfter(ClavaJoinPoints.defaultStmt())
+            .insertAfter(ClavaJoinPoints.emptyStmt())
+            .insertAfter(ClavaJoinPoints.breakStmt());
+        return new MISRATransformationReport(MISRATransformationType.DescendantChange);
+    }
+}

package/src/rules/Section16_SwitchStatements/Rule_16_5_DefaultFirstOrLast.ts

@@ -0,0 +1,113 @@
+import {Case, Comment, Joinpoint, Statement, Switch, WrapperStmt } 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";
+
+/**
+ * MISRA 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 {
+
+    constructor(context: MISRAContext) {
+        super("16.5", context);
+    }
+
+    /**
+     * Retrieves all consecutive case statements to the left of a given case statement
+     * 
+     * @param $jp - The starting case statement from which the search will begin
+     * @returns  Array containing consecutive case statements to the left of the provided joinpoint
+     * 
+     */
+    private getConsecutiveRightCases($jp: Case): Joinpoint[] {
+        const cases = [];
+        for (const stmt of $jp.siblingsRight) {
+            if (!(stmt instanceof Case || isCommentStmt($jp)))
+                break;
+            cases.push(stmt);
+        }
+        return cases;
+    }
+
+    /**
+     * Retrieves all consecutive case statements to the right of a given case statement
+     * 
+     * @param $jp - The starting case statement from which the search will begin
+     * @returns  Array containing consecutive case statements to the right of the provided joinpoint
+     * 
+     */
+    private getConsecutiveLeftCases($jp: Case): Joinpoint[] {
+        let cases: Joinpoint[] = [];
+        for (let i = $jp.siblingsLeft.length - 1; i >= 0; i--) {
+            const currentStmt = $jp.siblingsLeft[i];
+            if (!(currentStmt instanceof Case || isCommentStmt($jp))) {
+                break;
+            }
+           cases.push($jp.siblingsLeft[i]);
+        }
+        return cases.reverse();
+    }
+
+    /**
+     * Checks if the given joinpoint is a switch statement where the default label appears either as first of last label
+     * @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;
+
+        const caseStmts = $jp.cases;
+        for (let i = 0; i < caseStmts.length; i++) {
+            const currentCase = caseStmts[i];
+            if (currentCase.isDefault) {
+                if (i == 0 || i == caseStmts.length - 1) {
+                    return false;
+                } 
+                if (logErrors) {
+                    this.logMISRAError($jp, "The default case of a switch statement must be the first or last label.")
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Transforms a switch statement so that the default case appears as the last label
+     * - If the default case is not already the last case within its case clause list, it is repositioned
+     * - Then, the entire case clause list containing the default case to the end of the switch statement
+     * @param $jp - Joinpoint to transform
+     * @returns Report detailing the transformation result
+     */
+    transform($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp)) return new MISRATransformationReport(MISRATransformationType.NoChange);
+
+        const defaultCase = ($jp as Switch).getDefaultCase;
+        const rightStatements = defaultCase.siblingsRight.filter(sibling => !isCommentStmt(sibling));
+       
+        //  Reposition the default case to the last position within its case clause lis
+        if (rightStatements[0] instanceof Case) { // At least one of the first statements is a Case
+            const rightConsecutiveCases = this.getConsecutiveRightCases(defaultCase);
+            const lastRightCase = rightConsecutiveCases[rightConsecutiveCases.length - 1];
+            
+            defaultCase.detach();
+            lastRightCase.insertAfter(defaultCase);
+            if (defaultCase.nextCase === undefined) { // Default is now the last case
+                return new MISRATransformationReport(MISRATransformationType.DescendantChange);
+            }
+        }
+
+        // Move the entire case clause list containing the default case to the end of the switch statement
+        const switchScope = $jp.children[1];
+        const stmts = [...this.getConsecutiveLeftCases(defaultCase), defaultCase, ...defaultCase.instructions];
+
+        for (const stmt of stmts) {
+            stmt.detach();
+            switchScope.lastChild.insertAfter(stmt);
+        }
+        return new MISRATransformationReport(MISRATransformationType.DescendantChange);
+    }
+}

package/src/rules/Section16_SwitchStatements/Rule_16_6_SwitchMinTwoClauses.ts

@@ -0,0 +1,57 @@
+import {Break, Case, Joinpoint, Statement, Expression, 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";
+
+/**
+ * MISRA Rule 16.6:  Every switch statement shall have at least two switch-clauses.
+ */
+export default class Rule_16_6_SwitchMinTwoClauses extends MISRARule {
+
+    constructor(context: MISRAContext) {
+        super("16.6", context);
+    }
+
+    /**
+     * Checks if the given joinpoint is a switch statement with less than two clauses
+     * @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;
+
+        const nonCompliant = getNumOfSwitchClauses($jp) < 2;
+        if (nonCompliant && logErrors) {
+            this.logMISRAError($jp, "Switch statements should have at least two clauses.")
+        }
+        return nonCompliant;
+    }
+
+    /**
+     * Transforms a switch statement with less than two clauses into equivalent statement(s), only if there is no conditional break.
+     * If a conditional break is present, no transformation is performed and an error is generated.
+     * 
+     * @param $jp - Joinpoint to transform
+     * @returns Report detailing the transformation result
+     */
+    transform($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp)) return new MISRATransformationReport(MISRATransformationType.NoChange);
+        
+        if (switchHasConditionalBreak($jp as Switch)) {
+            this.logMISRAError($jp, "switch statement must have at least two clauses and cannot be transformed due to a conditional break statement.")
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
+        }
+
+        const transformResultNode = MISRASwitchConverter.convert($jp as Switch);
+        if (transformResultNode) {
+            return new MISRATransformationReport(
+                MISRATransformationType.Replacement,
+                transformResultNode
+            );
+        } 
+        // Only breaks were present, so the switch was removed
+        return new MISRATransformationReport(MISRATransformationType.Removal);
+    }
+}

package/src/rules/Section16_SwitchStatements/Rule_16_7_NonBooleanSwitchCondition.ts

@@ -0,0 +1,56 @@
+import { BuiltinType, 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 { switchHasBooleanCondition, switchHasConditionalBreak } from "../../utils/utils.js";
+
+/**
+ * MISRA Rule 16.7: A switch-expression shall not have essentially Boolean type.
+ */
+export default class Rule_16_7_NonBooleanSwitchCondition extends MISRARule {
+    constructor(context: MISRAContext) {
+        super("16.7", context);
+    }
+
+    /**
+     * Checks if the given joinpoint is a switch statement with an essentially Boolean condition
+     * @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;
+
+        const booleanCondition = switchHasBooleanCondition($jp);
+        if (booleanCondition && logErrors) {
+            this.logMISRAError($jp, `Switch statement controlling expression ${$jp.condition.code} must not have essentially boolean type.`)
+        }    
+        return booleanCondition;
+    }
+
+    /**
+     * Transforms a switch statement with a Boolean condition into equivalent statement(s), only if there is no conditional break.
+     * If a conditional break is present, no transformation is performed and an error is generated.
+     * 
+     * @param $jp - Joinpoint to transform
+     * @returns Report detailing the transformation result
+     */
+    transform($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp)) return new MISRATransformationReport(MISRATransformationType.NoChange);
+
+        if (switchHasConditionalBreak($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);
+        }
+        
+        const transformResultNode = MISRASwitchConverter.convert($jp as Switch);
+        if (transformResultNode) {
+            return new MISRATransformationReport(
+                MISRATransformationType.Replacement,
+                transformResultNode
+            );
+        } 
+        // Only breaks were present, so the switch was removed
+        return new MISRATransformationReport(MISRATransformationType.Removal);
+    }
+}

package/src/rules/Section17_Functions/Rule_17_4_NonVoidReturn.ts

@@ -0,0 +1,78 @@
+import { BuiltinType, Call, EnumDecl, ExprStmt, FunctionJp, Joinpoint, ReturnStmt } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRARule from "../../MISRARule.js";
+import MISRAContext from "../../MISRAContext.js";
+import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
+import { MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+
+/**
+ * MISRA Rule 17.4: All exit paths from a function with non-void return type shall have an
+explicit return statement with an expression. In a non-void function:
+- Every return statement has an expression, and a 
+- Control cannot reach the end of the function without encountering a return statement
+ */
+export default class Rule_17_4_NonVoidReturn extends MISRARule {
+    constructor(context: MISRAContext) {
+        super("17.4", context);
+    }
+
+    /**
+     * Checks if the given joinpoint represents a non-void function that lacks an explicit return statement with an expression.
+     * 
+     * @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 FunctionJp && $jp.isImplementation)) return false;
+
+        if ($jp.returnType instanceof BuiltinType && $jp.returnType.isVoid) return false;
+
+        const emptyReturnStms = Query.searchFrom($jp, ReturnStmt, {returnExpr: undefined}).get();
+        const exitReturn = $jp.body.children.filter(child => child instanceof ReturnStmt && !emptyReturnStms.includes(child))[0];
+        if (logErrors) {
+            emptyReturnStms?.forEach(emptyReturn =>
+                this.logMISRAError(emptyReturn, "Every return statement in a non-void function must include an expression.")
+            )
+            if (exitReturn === undefined) {
+                this.logMISRAError($jp, `Function '${$jp.name}' reaches the end without a return statement.`)
+            }
+        }
+        return emptyReturnStms.length > 0 || exitReturn === undefined;
+    }
+
+    /**
+     * Transforms a non-void function joinpoint that has no return statement at the end, by adding a default return value based on the config file.
+     * - If the configuration file is is missing or invalid, no transformation is performed.
+     * - Otherwise, a return statement is inserted as the last statement of the function. 
+     * 
+     * @param $jp - Joinpoint to transform
+     * @returns Report detailing the transformation result
+     */
+    transform($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp)) return new MISRATransformationReport(MISRATransformationType.NoChange);
+        
+        const functionJp = $jp as FunctionJp;
+        if (this.context.config) {
+            try {
+                const returnType = functionJp.type.code;
+                const defaultValueReturn = this.context.config.get("defaultValues")[returnType];
+
+                if (defaultValueReturn === undefined) {
+                    this.logMISRAError($jp, `Function '${functionJp.name}' reaches the end without a return statement. Default value return not added due to missing default value configuration for type '${returnType}'.`);
+                    return new MISRATransformationReport(MISRATransformationType.NoChange);
+                }
+                const newJp = ClavaJoinPoints.returnStmt(ClavaJoinPoints.exprLiteral(String(defaultValueReturn), functionJp.returnType)) as ReturnStmt;
+                functionJp.body.lastChild ? functionJp.body.lastChild.insertAfter(newJp) : functionJp.body.setFirstChild(newJp);
+
+                return new MISRATransformationReport(MISRATransformationType.DescendantChange);
+            
+            } catch (error) {  
+                this.logMISRAError($jp, `Function '${functionJp.name}' reaches the end without a return statement. Default value return not added due to invalid structure of configuration file.`);
+                return new MISRATransformationReport(MISRATransformationType.NoChange);
+            }
+        }   
+        this.logMISRAError($jp, `Function '${functionJp.name}' reaches the end without a return statement. Default value return not added due to missing config file.`)
+        return new MISRATransformationReport(MISRATransformationType.NoChange);
+    }
+}

package/src/rules/Section17_Functions/Rule_17_6_StaticArraySizeParam.ts

@@ -0,0 +1,68 @@
+import { AdjustedType, ArrayType, FunctionJp, Joinpoint, Param } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRARule from "../../MISRARule.js";
+import MISRAContext from "../../MISRAContext.js";
+import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
+import { MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import { getParamReferences } from "../../utils/utils.js";
+
+/**
+ * MISRA Rule 17.6: The declaration of an array parameter shall not contain the static keyword between the [ ]
+ */
+export default class Rule_17_6_StaticArraySizeParam extends MISRARule {
+    #invalidParams: Param[] = [];
+    constructor(context: MISRAContext) {
+        super("17.6", context);
+    }
+
+    /**
+     * Checks if the given joinpoint represents a function with any array parameter containing the 'static' keyword between the [ ].
+     * 
+     * @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 FunctionJp) || $jp.root.standard === "c90") return false;
+
+        this.#invalidParams = $jp.params.filter(paramJp => paramJp.type instanceof AdjustedType &&
+            paramJp.type.originalType instanceof ArrayType &&
+            paramJp.type.originalType.arraySize !== -1 &&
+            /\[\s*static\s+\d+\s*\]/.test(paramJp.code)
+        );
+
+        if (logErrors) {
+            for (const invalidParam of this.#invalidParams) {
+                this.logMISRAError(invalidParam, `The 'static' keyword cannot appear inside the square brackets ('[]') in array parameter declarations.`)
+            }
+        }
+        return this.#invalidParams.length > 0;
+    }
+
+    /**
+     * Transforms the joinpoint if it represents a function with any array parameter containing the 'static' keyword between the square brackets.
+     * 
+     * @param $jp - Joinpoint to transform
+     * @returns Report detailing the transformation result
+     */
+    transform($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp)) return new MISRATransformationReport(MISRATransformationType.NoChange);
+        
+        for (const invalidParam of this.#invalidParams) {
+            const paramRefs = getParamReferences(invalidParam, $jp);
+
+            // Replace the parameter with a new array parameter whose size is variant
+            const originalType = (invalidParam.type as AdjustedType).originalType;
+            const newJp = ClavaJoinPoints.param(
+                invalidParam.name, 
+                ClavaJoinPoints.incompleteArrayType((originalType as ArrayType).elementType)
+            );            
+            const newParam = invalidParam.replaceWith(newJp) as Param;
+
+            // Replace all references to the invalid parameter with the new one
+            for (const ref of paramRefs) {
+                ref.replaceWith(newParam.varref());
+            }
+        }
+        return new MISRATransformationReport(MISRATransformationType.DescendantChange);
+    }
+}

package/src/rules/Section17_Functions/Rule_17_7_UnusedReturnValue.ts

@@ -0,0 +1,47 @@
+import { BuiltinType, Call, ExprStmt, Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRARule from "../../MISRARule.js";
+import MISRAContext from "../../MISRAContext.js";
+import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
+import { MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+
+/**
+ * MISRA Rule 17.7: The value returned by a function having non-void return type shall be
+used
+ */
+export default class Rule_17_7_UnusedReturnValue extends MISRARule {
+    constructor(context: MISRAContext) {
+        super("17.7", context);
+    }
+
+    /**
+     * Checks if the given joinpoint represents a non-void function call with an unused return value.
+     * 
+     * @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 Call)) return false;
+
+        if ($jp.returnType instanceof BuiltinType && $jp.returnType.isVoid) return false;
+
+        if ($jp.parent instanceof ExprStmt && logErrors) {
+            this.logMISRAError($jp,`Return value of ${$jp.signature} must be used. It can be discarded with an explicit cast to void.`);
+        }
+        return $jp.parent instanceof ExprStmt;
+    }
+
+    /**
+     * Transforms the joinpoint if it represents a non-void function call, whose return type is unused. 
+     * It ensures that the return value is explicitly cast to void.
+     * 
+     * @param $jp - Joinpoint to transform
+     * @returns Report detailing the transformation result
+     */
+    transform($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp)) return new MISRATransformationReport(MISRATransformationType.NoChange);
+        
+        const newJp =  ClavaJoinPoints.cStyleCast(ClavaJoinPoints.type("void"), $jp as Call);
+        return new MISRATransformationReport(MISRATransformationType.Replacement, $jp.replaceWith(newJp));
+    }
+}