@specs-feup/clava-misra 1.0.2 → 1.0.4

package/src/rules/Section17_Functions/Rule_17_3_ImplicitFunction.ts

@@ -1,67 +1,45 @@
 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 { AnalysisType, MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import { findFunctionDef } from "../../utils/FunctionUtils.js";
+import { getCallIndex, isCallToImplicitFunction } from "../../utils/CallUtils.js";
 import Query from "@specs-feup/lara/api/weaver/Query.js";
-import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
+import { addExternFunctionDecl, getFilesWithCallToImplicitFunction, getIncludesOfFile, isValidFileWithExplicitCall, removeIncludeFromFile } from "../../utils/FileUtils.js";
+import UserConfigurableRule from "../UserConfigurableRule.js";
 
 /**
- * MISRA Rule 17.3: A function shall not be declared implicitly
+ * MISRA-C Rule 17.3: A function shall not be declared implicitly
  */
-export default class Rule_17_3_ImplicitFunction extends MISRARule {
-    priority = 1;
+export default class Rule_17_3_ImplicitFunction extends UserConfigurableRule {
+    /**
+     * A positive integer starting from 1 that indicates the rule's priority, determining the order in which rules are applied.
+     */
+    readonly priority = 1;
 
-    constructor(context: MISRAContext) {
-        super("17.3", context);
-    }
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SINGLE_TRANSLATION_UNIT;
 
     /**
-     * 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
+     * Standards to which this rule applies to
      */
-    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;
+    protected override readonly appliesTo = new Set(["c90"]);
+
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "17.3";
     }
 
     /**
-     * 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.
+     * Returns the prefix to be used for error messages related to the given joinpoint
      * 
-     * @param $jp - Joinpoint to transform
-     * @returns Report detailing the transformation result
+     * @param $jp - Joinpoint where the violation was detected 
+     * @returns Returns a prefix to prepend to error messages if no configuration is specified or if the configuration does not contain a fix for this violation
      */
-    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);
-        }
+    getErrorMsgPrefix(callJp: Call): string {
+        return `Function '${callJp.name}' is declared implicitly.`;
     }
 
     /**
@@ -70,7 +48,9 @@ export default class Rule_17_3_ImplicitFunction extends MISRARule {
      * @param errorMsgPrefix 
      * @returns 
      */
-    private getImplicitFixFromConfig(callJp: Call, errorMsgPrefix: string): string | undefined {
+    getFixFromConfig(callJp: Call): string | undefined {
+        const errorMsgPrefix = this.getErrorMsgPrefix(callJp);
+        
         if (!this.context.config) {
             this.logMISRAError(callJp, `${errorMsgPrefix} Include or extern not added due to missing config file.`);
             return undefined;
@@ -96,6 +76,57 @@ export default class Rule_17_3_ImplicitFunction extends MISRARule {
         return configFix;
     }
 
+    /**
+     * 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 && this.appliesToCurrentStandard())) return false;
+        
+        const implicitCalls = Query.searchFrom($jp, Call, (callJp) => isCallToImplicitFunction(callJp)). get();
+        if (logErrors) {
+            for (const callJp of implicitCalls) {
+                this.logMISRAError(callJp, this.getErrorMsgPrefix(callJp));
+            }
+        }
+        
+        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' file), 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
+     */
+    apply($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp)) 
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
+
+        const filesWithImplicitCall = getFilesWithCallToImplicitFunction($jp as Program);
+        let changedDescendant = false;
+
+        for (const fileJp of filesWithImplicitCall) {
+            if (this.solveImplicitCalls(fileJp)) {
+                changedDescendant = true;
+            }
+        }
+
+        if (changedDescendant) {
+            this.rebuildProgram();
+            return new MISRATransformationReport(MISRATransformationType.Replacement, Query.root() as Program);
+        } else {
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
+        }
+    }
+
     /**
      * 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
@@ -105,76 +136,94 @@ export default class Rule_17_3_ImplicitFunction extends MISRARule {
         const implicitCalls = Query.searchFrom(fileJp, Call, (callJp) => (isCallToImplicitFunction(callJp))).get();
         const originalIncludes = getIncludesOfFile(fileJp);
         let solvedCalls = new Set<string>();
-        let addedIncludes: string[] = [];
+        let addedIncludes = new Set<string>();
         let changedFile = false;
 
-        for (const callJp of implicitCalls) {
-            const errorMsgPrefix = `Function '${callJp.name}' is declared implicitly.`;
+        for (const callJp of implicitCalls) {   
+            if (this.context.getRuleResult(this.ruleID, callJp) === MISRATransformationType.NoChange) {
+                continue;
+            }
             
             if (solvedCalls.has(callJp.name)) {
                 continue;
             } 
-            
-            const configFix = this.getImplicitFixFromConfig(callJp, errorMsgPrefix);
-            if (!configFix) {
+
+            const configFix = this.getFixFromConfig(callJp);
+            if (configFix === undefined) {
+                this.context.addRuleResult(this.ruleID, callJp, MISRATransformationType.NoChange);
                 continue;
             }
 
-            const callIndex = Query.searchFrom(fileJp, Call, { name: callJp.name }).get().findIndex(c => c.equals(callJp));
+            const callIndex = getCallIndex(fileJp, 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.`);
-                    }
+            const success = isInclude ? 
+                this.solveWithInclude(fileJp, callJp, configFix, originalIncludes, addedIncludes, callIndex) :
+                this.solveWithExtern(fileJp, callJp, configFix, callIndex);
+
+            if (success) {
+                solvedCalls.add(callJp.name);
+                changedFile = true;
+                if (isInclude) {
+                    addedIncludes.add(configFix);
                 }
+            } else {
+                this.context.addRuleResult(this.ruleID, callJp, MISRATransformationType.NoChange);
             }
         }
         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);
+    private solveWithInclude(fileJp: FileJp, callJp: Call, includePath: string, originalIncludes: Set<string>, addedIncludes: Set<string>, callIndex: number): boolean {
+        const errorMsgPrefix = this.getErrorMsgPrefix(callJp);
+        let success = false;
+
+        if (originalIncludes.has(includePath)) {
+            this.logMISRAError(callJp, `${errorMsgPrefix} Provided include \'${includePath}\' does not fix the violation.`);
+        } 
+        else if (addedIncludes.has(includePath)) {
+            
+            if (isValidFileWithExplicitCall(fileJp, callJp.name, callIndex)) {
+                success = true;
+            } else {
+                this.logMISRAError(callJp, `${errorMsgPrefix} Provided include \'${includePath}\' does not fix the violation.`);
+            }
+        } 
+        else {
+            fileJp.addInclude(includePath);
+            const fileCompiles = isValidFileWithExplicitCall(fileJp, callJp.name, callIndex);
+
+            if (fileCompiles) {
+                success = true;
+            } else {
+                removeIncludeFromFile(includePath, fileJp);
+                this.logMISRAError(callJp, `${errorMsgPrefix} Provided include \'${includePath}\' does not fix the violation.`);
+            }
+        }
+        return success;
+    }
+
+    private solveWithExtern(fileJp: FileJp, callJp: Call, functionLocation: string, callIndex: number): boolean {
+        const errorMsgPrefix = this.getErrorMsgPrefix(callJp);
+        const functionDef = findFunctionDef(callJp.name, functionLocation);
+        let success = false;
 
-            fileToRemove?.detach();
-            return isExplicitCall;
+        if (!functionDef) {
+            this.logMISRAError(callJp, `${errorMsgPrefix} Provided file \'${functionLocation}\' does not have function definition.`);
+        } else {
+            const externDecl = addExternFunctionDecl(fileJp, functionDef);
 
-        } catch(error) {
-            copyFile.detach();
-            return false;
+            if (!externDecl) {
+                this.logMISRAError(callJp, `${errorMsgPrefix} Provided definition at \'${functionLocation}\' does not have external linkage.`);
+            } else {
+                const fileCompiles = isValidFileWithExplicitCall(fileJp, callJp.name, callIndex, true);
+                if (fileCompiles) {
+                    success = true;
+                } else {
+                    externDecl.detach();
+                    this.logMISRAError(callJp, `${errorMsgPrefix} Provided definition at \'${functionLocation}\' does not fix the violation.`);
+                }
+            }
         }
+        return success;
     }
-}
+}

package/src/rules/Section17_Functions/Rule_17_4_NonVoidReturn.ts

@@ -1,20 +1,31 @@
-import { BuiltinType, FileJp, FunctionJp, Joinpoint, ReturnStmt } from "@specs-feup/clava/api/Joinpoints.js";
-import MISRARule from "../../MISRARule.js";
-import MISRAContext from "../../MISRAContext.js";
+import { Body, BuiltinType, FileJp, FunctionJp, Joinpoint, ReturnStmt } from "@specs-feup/clava/api/Joinpoints.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";
+import { AnalysisType, MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import { isValidFile } from "../../utils/FileUtils.js";
+import UserConfigurableRule from "../UserConfigurableRule.js";
+import ClavaNode from "@specs-feup/clava-flow/ClavaNode";
+import ReturnNode from "@specs-feup/clava-flow/cfg/node/ReturnNode";
+import ClavaCfgGenerator from "@specs-feup/clava-flow/transformation/ClavaCfgGenerator";
+import BaseNode from "@specs-feup/flow/graph/BaseNode";
+import Graph from "@specs-feup/flow/graph/Graph";
+import ControlFlowEdge from "@specs-feup/flow/flow/ControlFlowEdge";
 
 /**
- * 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
+* MISRA-C 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);
+export default class Rule_17_4_NonVoidReturn extends UserConfigurableRule {
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SINGLE_TRANSLATION_UNIT;
+
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "17.4";
     }
 
     /**
@@ -26,20 +37,48 @@ export default class Rule_17_4_NonVoidReturn extends MISRARule {
      */
     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;
+        if ($jp.body.children.some(childJp => childJp instanceof ReturnStmt)) return false;
+        
+        const nonCompliant = !this.allControlPathsReturn($jp);
 
-        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.`)
-            }
+        if (logErrors && nonCompliant) {
+            this.logMISRAError($jp, `Function '${$jp.name}' reaches the end without a return statement.`)
         }
-        return emptyReturnStms.length > 0 || exitReturn === undefined;
+        return nonCompliant;
+    }
+
+    /**
+     * Performs a depth.first search on the function's control flow graph (CFG) to check if all exit paths in the function have a return statement
+     * 
+     * @param functionJp  The function to analyze
+     * @returns Returns true if all exit paths in the function have an explicit return statement, otherwise returns false.
+     */
+    private allControlPathsReturn(functionJp: FunctionJp) {
+        // Generate control flow graph 
+        const cfg = Graph.create().apply(new ClavaCfgGenerator(functionJp));
+        const startNode: BaseNode.Class = cfg.nodes.filterIs(ClavaNode).filter(node => node.jp instanceof Body)[0];
+        cfg.edges.filter(edge => edge.is(ControlFlowEdge) && edge.as(ControlFlowEdge).isFake).forEach((edge) => {
+            edge.remove();
+        })
+        
+        const stack = [startNode];
+        const visited = new Set();
+    
+        while (stack.length > 0) {
+            const node = stack.pop()!;
+    
+            if (visited.has(node) || node?.is(ReturnNode)) 
+                continue;
+            
+            let children = Array.from(node.outgoers).map(edge => edge.target);
+            if (!children || children.length === 0)  
+                return false; // Reached the end of the graph without finding a single return statement
+    
+            children = children.filter(child => !visited.has(child));
+            children.forEach(child => stack.push(child.as(BaseNode)));
+        }
+        return true; 
     }
 
     /**
@@ -50,29 +89,19 @@ export default class Rule_17_4_NonVoidReturn 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);
-        
-        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);
+    apply($jp: Joinpoint): MISRATransformationReport {
+        const previousResult = $jp instanceof FunctionJp ? this.context.getRuleResult(this.ruleID, $jp) : undefined;
+        if (previousResult === MISRATransformationType.NoChange || !this.match($jp)) {
+            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);
-        }
+        const functionJp = $jp as FunctionJp;
+        const fileJp = functionJp.getAncestor("file") as FileJp;
+        const errorMsgPrefix = this.getErrorMsgPrefix(functionJp);
 
+        const defaultValueReturn = this.getFixFromConfig(functionJp);
         if (defaultValueReturn === undefined) {
-            this.logMISRAError($jp, `${errorMsgPrefix} Default value return not added due to missing default value configuration for type '${returnType}'.`);
+            this.context.addRuleResult(this.ruleID, $jp, MISRATransformationType.NoChange);
             return new MISRATransformationReport(MISRATransformationType.NoChange);
         }
 
@@ -80,12 +109,53 @@ export default class Rule_17_4_NonVoidReturn extends MISRARule {
         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
+        // Validate the provided default value
         if (isValidFile(fileJp)) {
             return new MISRATransformationReport(MISRATransformationType.DescendantChange);
         } 
+
+        // If the default value is invalid, the return stmt is removed
         returnStmt.detach();
         this.logMISRAError($jp, `${errorMsgPrefix} Provided default value for type '${functionJp.type.code}' is invalid and was therefore not inserted.`);
+        this.context.addRuleResult(this.ruleID, $jp, MISRATransformationType.NoChange);
         return new MISRATransformationReport(MISRATransformationType.NoChange);
     }
+
+    /**
+     * Returns the prefix to be used for error messages related to the given joinpoint
+     * 
+     * @param $jp - Joinpoint where the violation was detected 
+     * @returns Returns a prefix to prepend to error messages if no configuration is specified or if the configuration does not contain a fix for this violation
+     */
+    getErrorMsgPrefix(functionJp: FunctionJp): string {
+        return `Function '${functionJp.name}' reaches the end without a return statement.`;
+    }
+
+    /**
+     * Retrieves a fix for the given joinpoint using the provided configuration file
+     * @param $jp - Joinpoint where the violation was detected
+     * @return The fix retrieved from the configuration for the violation, or `undefined` if no applicable fix is found.
+     */
+    getFixFromConfig(functionJp: FunctionJp): string | undefined {
+        const errorMsgPrefix = this.getErrorMsgPrefix(functionJp);
+
+        if (!this.context.config) {
+            this.logMISRAError(functionJp, `${errorMsgPrefix} Default value return not added due to missing config file.`)
+            return undefined;
+        }
+
+        let defaultValueReturn: string | undefined = undefined;
+        const returnType = functionJp.type.code;
+        try {
+            defaultValueReturn = this.context.config.get("defaultValues")[returnType];
+        } catch (error) {  
+            this.logMISRAError(functionJp, `${errorMsgPrefix} Default value return was not added as \'defaultValues\' is not defined in the configuration file.`);
+            return undefined;
+        }
+
+        if (defaultValueReturn === undefined) {
+            this.logMISRAError(functionJp, `${errorMsgPrefix} Default value return not added due to missing default value configuration for type '${returnType}'.`);
+        }
+        return defaultValueReturn;
+    }
 }

package/src/rules/Section17_Functions/Rule_17_6_StaticArraySizeParam.ts

@@ -1,17 +1,33 @@
 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";
+import { AnalysisType, MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import { getParamReferences } from "../../utils/FunctionUtils.js";
 
 /**
- * MISRA Rule 17.6: The declaration of an array parameter shall not contain the static keyword between the [ ]
+ * MISRA-C 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 {
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SINGLE_TRANSLATION_UNIT;
+
+    /**
+     * Standards to which this rule applies to
+     */
+    protected override readonly appliesTo = new Set(["c99", "c11"]);
+
+    /**
+     * List of static array size params
+     */
     #invalidParams: Param[] = [];
-    constructor(context: MISRAContext) {
-        super("17.6", context);
+
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "17.6";
     }
 
     /**
@@ -22,7 +38,7 @@ export default class Rule_17_6_StaticArraySizeParam extends MISRARule {
      * @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;
+        if (!($jp instanceof FunctionJp && this.appliesToCurrentStandard())) return false;
 
         this.#invalidParams = $jp.params.filter(paramJp => paramJp.type instanceof AdjustedType &&
             paramJp.type.originalType instanceof ArrayType &&
@@ -44,11 +60,12 @@ export default class Rule_17_6_StaticArraySizeParam 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);
         
         for (const invalidParam of this.#invalidParams) {
-            const paramRefs = getParamReferences(invalidParam, $jp);
+            const paramRefs = getParamReferences(invalidParam, $jp as FunctionJp);
 
             // Replace the parameter with a new array parameter whose size is variant
             const originalType = (invalidParam.type as AdjustedType).originalType;

package/src/rules/Section17_Functions/Rule_17_7_UnusedReturnValue.ts

@@ -1,17 +1,22 @@
-import { BuiltinType, Call, ExprStmt, Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import { BuiltinType, Call, Cast, 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";
-import { isCallToImplicitFunction } from "../../utils/utils.js";
+import { AnalysisType, MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
 
 /**
- * MISRA Rule 17.7: The value returned by a function having non-void return type shall be
-used
+ * MISRA-C 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);
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SINGLE_TRANSLATION_UNIT;
+
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "17.7";
     }
 
     /**
@@ -39,11 +44,14 @@ export default class Rule_17_7_UnusedReturnValue 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 callJp = $jp as Call;
-        const newJp =  ClavaJoinPoints.cStyleCast(ClavaJoinPoints.type("void"), callJp);
-        return new MISRATransformationReport(MISRATransformationType.Replacement, $jp.replaceWith(newJp));
+        const castJp =  ClavaJoinPoints.cStyleCast(ClavaJoinPoints.type("void"), callJp);
+        const newJp = $jp.replaceWith(castJp) as Cast;
+        newJp.subExpr.replaceWith($jp);
+        return new MISRATransformationReport(MISRATransformationType.Replacement, newJp);
     }
 }