@specs-feup/clava-misra 1.0.0 → 1.0.2

package/src/rules/Section16_SwitchStatements/Rule_16_2_TopLevelSwitch.ts

@@ -0,0 +1,41 @@
+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-enclosing
+compound statement is the body of a switch statement
+ */
+export default class Rule_16_2_TopLevelSwitch extends MISRARule {
+    priority = 2; 
+    #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,70 @@
+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 {
+    priority = 2; 
+    #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,41 @@
+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);
+
+        $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 list
+        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,61 @@
+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 {
+    priority = 3;
+
+    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);
+        
+        const switchJp = $jp as Switch;
+        if (switchHasConditionalBreak(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.")
+            }
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
+        }
+
+        const transformResultNode = MISRASwitchConverter.convert(switchJp);
+        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,57 @@
+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 {
+    priority = 3; 
+    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_3_ImplicitFunction.ts

@@ -0,0 +1,180 @@
+import { Call, FileJp, Joinpoint, Program } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRARule from "../../MISRARule.js";
+import MISRAContext from "../../MISRAContext.js";
+import { MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import { getFilesWithCallToImplicitFunction, getIncludesOfFile, isCallToImplicitFunction, isValidFile, removeIncludeFromFile } from "../../utils/utils.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
+
+/**
+ * MISRA Rule 17.3: A function shall not be declared implicitly
+ */
+export default class Rule_17_3_ImplicitFunction extends MISRARule {
+    priority = 1;
+
+    constructor(context: MISRAContext) {
+        super("17.3", context);
+    }
+
+    /**
+     * Checks if the given joinpoint represents a call to an implicit function.
+     * 
+     * @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 Program)) return false;
+        
+        const implicitCalls = Query.searchFrom($jp, Call, (callJp) => isCallToImplicitFunction(callJp)). get();
+        for (const callJp of implicitCalls) {
+            if (logErrors) {
+                this.logMISRAError(callJp, `Function '${callJp.name}' is declared implicitly.`);
+            }
+        }
+        return implicitCalls.length > 0;
+    }
+
+    /**
+     * Transforms every implicit call by adding a missing include directive or extern statement specified on the config file.
+     * 
+     * - If the configuration is missing or the specified fix is invalid (i.e., not a '.h' or '.c'), no transformation is performed and the call is left unchanged.
+     * - The fix is applied only if it successfully resolves the issue (i.e., makes the call explicit and the file compiles with no error).
+     * - Otherwise, the fix is removed.
+     * 
+     * @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 programJp = $jp as Program;
+        const filesWithImplicitCall = getFilesWithCallToImplicitFunction(programJp);
+        let changedDescendant = false;
+
+        for (const fileJp of filesWithImplicitCall) {
+            changedDescendant = changedDescendant || this.solveImplicitCalls(fileJp);
+        }
+
+        if (changedDescendant) {
+            programJp.rebuild();
+            return new MISRATransformationReport(MISRATransformationType.Replacement, Query.root() as Program);
+        } else {
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
+        }
+    }
+
+    /**
+     * Retrieves the fix for a implicit call specified on the config file (.h or .c)
+     * @param callJp 
+     * @param errorMsgPrefix 
+     * @returns 
+     */
+    private getImplicitFixFromConfig(callJp: Call, errorMsgPrefix: string): string | undefined {
+        if (!this.context.config) {
+            this.logMISRAError(callJp, `${errorMsgPrefix} Include or extern not added due to missing config file.`);
+            return undefined;
+        }
+    
+        let configFix: string | undefined;
+        try {
+            configFix = this.context.config.get("implicitCalls")[callJp.name];
+        } catch {
+            this.logMISRAError(callJp, `${errorMsgPrefix} Include or extern was not added as \'implicitCalls\' is not defined in the configuration file.`);
+            return undefined;
+        }
+    
+        if (configFix === undefined) {
+            this.logMISRAError(callJp, `${errorMsgPrefix} Couldn't add include or extern due to missing configuration for function '${callJp.name}'.`);
+            return undefined;
+        }
+    
+        if (!(configFix.endsWith(".h") || configFix.endsWith(".c"))) {
+            this.logMISRAError(callJp, `${errorMsgPrefix} Cannot add include or extern without a .h or .c reference.`);
+            return undefined;
+        }
+        return configFix;
+    }
+
+    /**
+     * Attempts to resolve implicit function calls in a file by adding missing includes or extern statements based on the configuration file.
+     * @param fileJp The file to analyze
+     * @returns `true` if any changes were made to the file, otherwise `false`.
+     */
+    private solveImplicitCalls(fileJp: FileJp): boolean {
+        const implicitCalls = Query.searchFrom(fileJp, Call, (callJp) => (isCallToImplicitFunction(callJp))).get();
+        const originalIncludes = getIncludesOfFile(fileJp);
+        let solvedCalls = new Set<string>();
+        let addedIncludes: string[] = [];
+        let changedFile = false;
+
+        for (const callJp of implicitCalls) {
+            const errorMsgPrefix = `Function '${callJp.name}' is declared implicitly.`;
+            
+            if (solvedCalls.has(callJp.name)) {
+                continue;
+            } 
+            
+            const configFix = this.getImplicitFixFromConfig(callJp, errorMsgPrefix);
+            if (!configFix) {
+                continue;
+            }
+
+            const callIndex = Query.searchFrom(fileJp, Call, { name: callJp.name }).get().findIndex(c => c.equals(callJp));
+            const isInclude = configFix.endsWith(".h");
+            if (isInclude) {
+                if (originalIncludes.includes(configFix)) {
+                    this.logMISRAError(callJp, `${errorMsgPrefix} Provided include \'${configFix}\' does not fix the violation.`);
+                } 
+                else if (addedIncludes.includes(configFix)) {
+                    
+                    if (this.isValidFileWithExplicitCall(fileJp, callJp.name, callIndex)) {
+                        solvedCalls.add(callJp.name);
+                    } else {
+                        this.logMISRAError(callJp, `${errorMsgPrefix} Provided include \'${configFix}\' does not fix the violation.`);
+                    }
+                } 
+                else {
+                    fileJp.addInclude(configFix);
+                    const fileCompiles = this.isValidFileWithExplicitCall(fileJp, callJp.name, callIndex);
+
+                    if (fileCompiles) {
+                        solvedCalls.add(callJp.name);
+                        addedIncludes.push(configFix);
+                        changedFile = true;
+                    } else {
+                        removeIncludeFromFile(configFix, fileJp);
+                        this.logMISRAError(callJp, `${errorMsgPrefix} Provided include \'${configFix}\' does not fix the violation.`);
+                    }
+                }
+            }
+        }
+        return changedFile;
+    }
+
+    /**
+     * Checks if the rebuilt version of the file compiles and if the provided call is no longer implicit
+     * @param fileJp The file to analyze
+     * @param funcName The function name to search the call
+     * @param callIndex The index of the call 
+     */
+    private isValidFileWithExplicitCall(fileJp: FileJp, funcName: string, callIndex: number) {
+        const programJp = fileJp.parent as Program;
+        let copyFile = ClavaJoinPoints.fileWithSource(`temp_misra_${fileJp.name}`, fileJp.code, fileJp.relativeFolderpath);
+    
+        copyFile = programJp.addFile(copyFile) as FileJp;
+        try {
+            const rebuiltFile = copyFile.rebuild();
+            const fileToRemove = Query.searchFrom(programJp, FileJp, {filepath: rebuiltFile.filepath}).first() as FileJp;
+            const callJp = Query.searchFrom(fileToRemove, Call, {name: funcName}).get().at(callIndex);
+            const isExplicitCall = callJp !== undefined && !isCallToImplicitFunction(callJp);
+
+            fileToRemove?.detach();
+            return isExplicitCall;
+
+        } catch(error) {
+            copyFile.detach();
+            return false;
+        }
+    }
+}

package/src/rules/Section17_Functions/Rule_17_4_NonVoidReturn.ts

@@ -0,0 +1,91 @@
+import { BuiltinType, FileJp, 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";
+import { isValidFile } from "../../utils/utils.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 
+- 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 missing/invalid or the specified default value is invalid, no transformation is performed and the function is left unchanged.
+     * - 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;
+        const fileJp = functionJp.getAncestor("file") as FileJp;
+        const returnType = functionJp.type.code;
+        const errorMsgPrefix = `Function '${functionJp.name}' reaches the end without a return statement.`;
+
+        if (!this.context.config) {
+            this.logMISRAError($jp, `${errorMsgPrefix} Default value return not added due to missing config file.`)
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
+        }
+
+        let defaultValueReturn;
+        try {
+            defaultValueReturn = this.context.config.get("defaultValues")[returnType];
+        } catch (error) {  
+            this.logMISRAError($jp, `${errorMsgPrefix} Default value return was not added as \'defaultValues\' is not defined in the configuration file.`);
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
+        }
+
+        if (defaultValueReturn === undefined) {
+            this.logMISRAError($jp, `${errorMsgPrefix} Default value return not added due to missing default value configuration for type '${returnType}'.`);
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
+        }
+
+        // Insert return statement and validate it
+        const returnStmt = ClavaJoinPoints.returnStmt(ClavaJoinPoints.exprLiteral(String(defaultValueReturn), functionJp.returnType)) as ReturnStmt;
+        functionJp.body.lastChild ? functionJp.body.lastChild.insertAfter(returnStmt) : functionJp.body.setFirstChild(returnStmt);
+
+        // Validate the provided default value. If it is invalid, the return stmt is removed
+        if (isValidFile(fileJp)) {
+            return new MISRATransformationReport(MISRATransformationType.DescendantChange);
+        } 
+        returnStmt.detach();
+        this.logMISRAError($jp, `${errorMsgPrefix} Provided default value for type '${functionJp.type.code}' is invalid and was therefore not inserted.`);
+        return new MISRATransformationReport(MISRATransformationType.NoChange);
+    }
+}