@specs-feup/clava-misra 1.0.2 → 1.0.3

package/src/MISRARule.ts

@@ -1,56 +1,64 @@
-import { Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import { Joinpoint, Program } from "@specs-feup/clava/api/Joinpoints.js";
 import MISRAContext from "./MISRAContext.js";
-import { MISRATransformationReport } from "./MISRA.js";
+import { AnalysisType, MISRATransformationReport, MISRATransformationResults } from "./MISRA.js";
+import { LaraJoinPoint } from "@specs-feup/lara/api/LaraJoinPoint.js";
+import Clava from "@specs-feup/clava/api/clava/Clava.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { resetCaches } from "./utils/ProgramUtils.js";
+import StandardGuideline from "./StandardGuideline.js";
 
 /**
  * Represents a MISRA Rule that detects and corrects violations in the code according to MISRA standards.
  * 
- * Need to implement:
+ * Need to implement/define:
+ *  - analysisType
+ *  - name()
  *  - match($jp, logErrors)
- *  - transform($jp)
+ *  - apply($jp)
  */
-export default abstract class MISRARule {
+export default abstract class MISRARule extends StandardGuideline<MISRATransformationResults, MISRAContext> {
     /**
-     * Unique identifier for the MISRA rule.
+     * A positive integer starting from 1 that indicates the rule's priority, determining the order in which rules are applied.
+     * By default, a rule has the lowest priority unless overridden.
      */
-    readonly ruleID: string;
+    readonly priority: number = Number.MAX_VALUE;
 
     /**
-     * Priority of the rule which is low by default.
+     * Scope of analysis: single unit or entire system.
      */
-    readonly priority: number = 4;
-    
-    /** 
-     * MISRA context for error tracking and rule transformations state
-     */    
-    protected context: MISRAContext;
+    abstract readonly analysisType: AnalysisType;
+
+    /**
+     * Standards to which this rule applies to
+     */
+    protected readonly appliesTo: Set<string> = new Set(["c90", "c99", "c11"]);
 
     /**
      * 
-     * @param ruleID - Unique identifier for the MISRA-C rule
      * @param context - MISRA context for error tracking and rule transformations state
      */
-    constructor(ruleID: string, context: MISRAContext) {
-        this.ruleID = ruleID;
-        this.context = context;
+    constructor(context: MISRAContext) {
+        super(context);
     }
 
     /**
-     * Checks if the joinpoint violates the rule
-     * 
-     * @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
+     * @returns Initial value stored in the shared context
      */
-    abstract match($jp: Joinpoint, logErrors: boolean): boolean;
+    override initialValue(): MISRATransformationResults {
+        return new Map();
+    }
 
     /**
-     * Transforms the joinpoint to comply with the MISRA-C rule
-     * 
-     * @param $jp - Joinpoint to transform
-     * @returns Report detailing the transformation result
+     * @returns Rule identifier according to MISRA-C:2012
      */
-    abstract transform($jp: Joinpoint): MISRATransformationReport;
+    abstract override get name(): string;
+
+    /**
+     * An alias for 'name'
+     */
+    get ruleID(): string {
+        return this.name;
+    }
 
     /**
      * Logs a MISRA-C rule violation error
@@ -61,4 +69,28 @@ export default abstract class MISRARule {
     protected logMISRAError($jp: Joinpoint, msg:string): void {
         this.context.addMISRAError(this.ruleID, $jp, msg); 
     }
+
+    /**
+     * Verifies if the rule applies to the standard being used
+     */
+    protected appliesToCurrentStandard(): boolean {
+        return this.appliesTo.has(Clava.getStandard());
+    }
+
+    /**
+     *  Rebuilds the program based on the current AST, clears stored data in the shared context, and resets all caches
+     */
+    protected rebuildProgram() {
+        (Query.root() as Program).rebuild();
+        this.context.resetStorage();
+        resetCaches();
+    }
+
+    /**
+     * Transforms the joinpoint to comply with the MISRA-C rule
+     * 
+     * @param $jp - Joinpoint to transform
+     * @returns Report detailing the transformation result
+     */
+    abstract apply($jp: LaraJoinPoint): MISRATransformationReport;
 }

package/src/MISRATool.ts

@@ -1,33 +1,25 @@
 import Query from "@specs-feup/lara/api/weaver/Query.js";
-import { Call, FileJp, Joinpoint, Program } from "@specs-feup/clava/api/Joinpoints.js";
+import { FileJp, Joinpoint, Program } from "@specs-feup/clava/api/Joinpoints.js";
 import MISRARule from "./MISRARule.js";
-import sortRules from "./rules/index.js";
 import MISRAContext from "./MISRAContext.js";
-import { MISRAError, MISRATransformationType } from "./MISRA.js";
-import { isCallToImplicitFunction } from "./utils/utils.js";
+import { MISRATransformationType } from "./MISRA.js";
+import Clava from "@specs-feup/clava/api/clava/Clava.js";
+import { resetCaches } from "./utils/ProgramUtils.js";
+import { selectRules } from "./rules/index.js";
+
+enum ExecutionMode {
+    CORRECTION,
+    DETECTION
+}
 
 export default class MISRATool {
     static #misraRules: MISRARule[];
-    static #context: MISRAContext;
-
-    private static init(startingPoint: FileJp | Program) {
-        this.validateStdVersion(startingPoint);
-        this.#context = new MISRAContext();
-        this.#misraRules = sortRules(this.#context);
-    }
-
-    private static validateStdVersion(startingPoint: FileJp | Program) {
-        const allowedVersions = ["c90", "c99", "c11"];
-        const stdVersion = startingPoint instanceof Program ? startingPoint.standard : (startingPoint.root as Program).standard;
-
-        if (!allowedVersions.includes(stdVersion)) {
-            console.error(`[Clava-MISRATool] Invalid --std value. Allowed values: ${allowedVersions.join(", ")}`);
-            process.exit(1);
-        }
-    }
+    public static context: MISRAContext;
+    static readonly #standards = new Set(["c90", "c99", "c11"]);
+    static readonly #ruleTypes = new Set(["all", "single", "system"]);
 
     public static checkCompliance(startingPoint: Program | FileJp = Query.root() as Program) {
-        this.init(startingPoint);
+        this.init();
 
         const nodes = [startingPoint, ...startingPoint.descendants];
         for (const node of nodes) {
@@ -35,39 +27,42 @@ export default class MISRATool {
                 rule.match(node, true);
             }
         }
-        if (this.#context.errors.length > 0) {
-            this.#context.printAllErrors();
-        } else {
-            console.log("[Clava-MISRATool] No MISRA-C violations detected.");
-        }
+        this.outputReport(ExecutionMode.DETECTION);
     } 
 
-    public static applyCorrections(configFilePath?: string) {
-        this.init(Query.root() as Program);
+    /**
+     * Transforms the source code to comply with the coding guidelines. 
+     * After the transformation, any violations that could not be fixed will be displayed along with their justification.
+     */
+    public static correctViolations() {
+        this.init();
+
+        // Store config file in context, if provided
+        const configFilePath = this.getArgValue("config");
         if (configFilePath) {
-            this.#context.config = configFilePath;
+            this.context.config = configFilePath;
         }
 
         let iteration = 0;
-        let modified = false;
-        do {
+        let modified = true;
+        while (modified) {
             console.log(`[Clava-MISRATool] Iteration #${++iteration}: Applying MISRA-C transformations...`);
             modified = this.transformAST(Query.root() as Program);
-        } while(modified);
-
-        if (this.#context.errors.length === 0) {
-            console.log("[Clava-MISRATool] All detected violations were corrected.");
-        } else {
-            console.log("\n[Clava-MISRATool] Remaining MISRA-C violations:");
-            this.#context.printActiveErrors();
         }
+        this.outputReport(ExecutionMode.CORRECTION);
     }
 
+    /**
+     * Recursively transforms the AST using a pre-order traversal
+     * 
+     * @param $jp  AST node from which to start the visit.
+     * @returns Return true if any modifications were made (removal, replacement, or changes in descendants). Otherwise, returns false.
+     */
     private static transformAST($jp: Joinpoint): boolean {
         let modified = false;
 
         for (const rule of this.#misraRules) {
-            const transformReport = rule.transform($jp);
+            const transformReport = rule.apply($jp);
 
             if (transformReport.type !== MISRATransformationType.NoChange) {
                 modified = true;
@@ -85,11 +80,82 @@ export default class MISRATool {
         return modified;
     }
 
+    private static init() {
+        this.validateStdVersion();
+        this.context = new MISRAContext();
+        resetCaches();
+        this.initRules();
+    }
+
+    /**
+     * Selects applicable rules according to the analysis type. When not specified, both system and single translation unit rules are selected.
+     */
+    private static initRules() {
+        const typeStr = this.getArgValue("type", this.#ruleTypes) ?? "all";
+        this.#misraRules = selectRules(this.context, typeStr);
+    }
+
+    /**
+     * Checks whether the provided standard version is valid and supported
+     */
+    private static validateStdVersion() {
+        const stdVersion = (Query.root() as Program).standard;
+
+        if (!this.#standards.has(stdVersion)) {
+            console.error(`[Clava-MISRATool] Invalid -std value. Allowed values: ${[...this.#standards].join(", ")}`);
+            process.exit(1);
+        }
+    }
+
+    private static getArgValue(field: string, validValues?: Set<string>): string | undefined{
+        const args = Clava.getData().get("argv") as string;
+        if (!args) return undefined;
+
+        const pair = args.split(/\s+/).find(arg => arg.startsWith(field + "="));
+        if (!pair) return undefined;
+
+        const value = pair.split("=")[1];
+        if (validValues && !validValues.has(value)) {
+            console.error(`[Clava-MISRATool] Invalid '${field}' value. Allowed values: ${[...validValues].join(", ")}`);
+            process.exit(1);
+        }
+        return value;
+    }
+
+    /**
+     * Displays standard violations based on execution mode. 
+     * - In detection mode, all violations are shown.
+     * - In correction mode, only the remaining violations are displayed
+     * 
+     * @param mode execution mode 
+     */
+    private static outputReport(mode: ExecutionMode) {
+        const isDetection = mode === ExecutionMode.DETECTION;
+        const errorCount = isDetection ? this.getErrorCount() : this.getActiveErrorCount();
+
+        if (errorCount > 0) {
+          console.log(isDetection
+            ? `[Clava-MISRATool] Detected ${errorCount} MISRA-C violation${errorCount === 1 ? "" : "s"}:\n`
+            : `[Clava-MISRATool] ${errorCount} MISRA-C violation${errorCount === 1 ? "" : "s"} remain${errorCount === 1 ? "s" : ""} after transformation:\n`
+          );
+          isDetection ? this.context.outputAllErrors() : this.context.outputActiveErrors();
+        } 
+        else {
+          console.log(isDetection ? "[Clava-MISRATool] No MISRA-C violations detected.\n" : "[Clava-MISRATool] All detected violations were corrected.\n");
+        }
+    }
+
+    /**
+     * @returns Returns the number of identified violations.
+     */
     public static getErrorCount(): number {
-        return this.#context.errors.length;
+        return this.context.errors.length;
     }
 
+    /**
+     * @returns Returns the number of active errors linked to nodes that are still present in the AST after correction.
+     */
     public static getActiveErrorCount(): number {
-        return this.#context.activeErrors.length;
+        return this.context.activeErrors.length;
     }
 }

package/src/StandardGuideline.ts

@@ -0,0 +1,23 @@
+import { Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import Context from "./ast-visitor/Context.js";
+import VisitWithContext from "./ast-visitor/VisitWithContext.js";
+
+/**
+ * Represents a standard guideline that detects and corrects violations in the code according to a particular coding standard.
+ * 
+ * Need to implement/define:
+ *  - initialValue()
+ *  - match($jp, logErrors)
+ *  - apply($jp)
+ */
+export default abstract class StandardGuideline<T,C extends Context<T> = Context<T>> extends VisitWithContext<T, C> {
+
+    /**
+     * Checks if the joinpoint violates the guideline
+     * 
+     * @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 guideline, false otherwise
+     */
+    abstract match($jp: Joinpoint, logErrors: boolean): boolean;
+}

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

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

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