@specs-feup/clava-misra 1.0.0 → 1.0.2

package/src/MISRA.ts

@@ -0,0 +1,276 @@
+import { BinaryOp, Break, Case, Expression, If, Joinpoint, Program, Scope, Statement, Switch } from "@specs-feup/clava/api/Joinpoints.js";
+import { getNumOfSwitchClauses, isCommentStmt } from "./utils/utils.js";
+import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import Clava from "@specs-feup/clava/api/clava/Clava.js";
+
+export enum MISRATransformationType {
+    NoChange,
+    DescendantChange,
+    Replacement,
+    Removal
+}
+
+/**
+ * Represents an error in MISRA compliance, including the rule ID, the joinpoint where the violation occurred, and a descriptive message.
+ */
+export class MISRAError {
+    /**
+     * Represents the specific MISRA-C rule that was violated
+     */
+    public ruleID: string;
+    /**
+     * The joinpoint where the error was detected
+     */
+    public $jp: Joinpoint;
+    /**
+     * Explanation of the violation
+     */
+    public message: string;
+
+    /**
+     * 
+     * @param ruleID - specific MISRA rule that was violated
+     * @param $jp - joinpoint where the error was detected
+     * @param message - description of the error
+     */
+    constructor(ruleID: string, $jp: Joinpoint, message: string) {
+        this.ruleID = ruleID;
+        this.$jp = $jp;
+        this.message =  message;
+    }
+
+    /**
+     * Checks if two instances of MISRAError are equal based on all properties
+     * @param other 
+     * @returns Returns `true` if the errors are the same, `false` otherwise
+     */
+    equals(other: MISRAError): boolean {
+        return this.ruleID === other.ruleID &&
+               this.$jp.astId === other.$jp.astId &&
+               this.message === other.message;
+    }
+
+    /**
+     * 
+     */
+    isActiveError(): boolean {
+        return (Query.root() as Joinpoint).contains(this.$jp);
+    }
+}
+
+/**
+ * A report of a MISRA transformation, including the transformation type and an optional new joinpoint node.
+ * 
+ * If the transformation type is `Replacement`, the `newNode` must be provided to indicate the new joinpoint.
+ */
+export class MISRATransformationReport {
+    /**
+     * The type of the MISRA transformation
+     */
+    type: MISRATransformationType;
+    /**
+     * An optional new joinpoint node, provided if the transformation involves a replacement
+     */
+    newNode?: Joinpoint; 
+
+    /**
+     * 
+     * @param type The type of the MISRA transformation
+     * @param newNode The new joinpoint node resulting from the transformation. Required if the transformation type is `Replacement`.
+     */
+    constructor(type: MISRATransformationType, newNode?: Joinpoint) {
+        this.type = type;
+        if (type === MISRATransformationType.Replacement && !newNode) {
+            throw new Error("newNode must be provided when a 'Replacement' transformation is performed");
+        }
+        this.newNode = newNode;
+    }
+}
+
+/**
+ * Converts a switch statement into either consecutive statements or if statements
+ * - If the switch has only one clause and a default case, it is converted to consecutive statements
+ * - Otherwise, it is converted to if statements
+ */
+export class MISRASwitchConverter {
+    /**
+     * Converts a switch statement to consecutive statements or if statements
+     * 
+     * @param switchStmt - The switch statement to convert
+     * @returns The converted statements or `undefined` if no statements remain
+     */
+    static convert(switchStmt: Switch): Statement | undefined {
+        if (switchStmt.hasDefaultCase && getNumOfSwitchClauses(switchStmt) < 2) {  // The statements will always be executed 
+            return this.convertToConsecutiveStmts(switchStmt);
+        } else {
+            return this.convertToIfStatements(switchStmt);
+        }
+    }
+
+    /**
+     * Converts a switch with only one clause and a default case into consecutive statements
+     * 
+     * @param switchStmt - The switch statement to convert
+     * @returns The first statement or `undefined` if no statements remain
+     */
+    static convertToConsecutiveStmts(switchStmt: Switch): Statement | undefined {
+        const scope = switchStmt.children[1] as Scope;
+        this.removeBreakStmts(scope);
+        this.removeCases(scope);
+
+        // If there are no statements except break and comments, the switch can be removed
+        if (scope.children.length === 0 || scope.children.every(stmt => isCommentStmt(stmt))) {
+            switchStmt.detach();
+            return undefined;
+        }
+
+        let firstStmt, lastStmt;
+        const stmts = scope.children as Statement[];
+        for (let i = 0; i < stmts.length; i++) {
+            const stmt = stmts[i];
+            stmt.detach();
+
+            if (!firstStmt) {
+                firstStmt = stmt;
+                switchStmt.replaceWith(firstStmt);
+                lastStmt = stmt;
+                continue;
+            }
+            lastStmt!.insertAfter(stmt);
+            lastStmt = stmt;
+        }
+        return firstStmt as Statement;
+    }
+
+    /**
+     * Converts a switch statement into a series of if statements
+     * 
+     * @param switchStmt - The switch statement to convert
+     * @returns The first if statement created
+     */
+    static convertToIfStatements(switchStmt: Switch): If {
+        const scope = switchStmt.children[1] as Scope;
+        const consecutiveCases = this.consecutiveCases(switchStmt);
+        this.removeBreakStmts(scope);
+
+        let ifStmt: If;
+        let lastIfStmt: If | undefined;
+        for (let i = 0; i < consecutiveCases.length; i++) {
+            const cases = consecutiveCases[i];
+
+            if (cases.some(caseStmt => caseStmt.isDefault)) { // Has default case
+                lastIfStmt!.setElse(ClavaJoinPoints.scope(...cases[cases.length-1].instructions));
+            } else {
+                lastIfStmt = this.createIfStatement(switchStmt.condition, cases, i, lastIfStmt)
+                if (i === 0) {
+                    ifStmt = lastIfStmt;
+                }
+            }
+        }
+        switchStmt.replaceWith(ifStmt!);
+        return ifStmt!;
+    }
+
+    /**
+     * Creates an if statement for the given consecutive cases
+     * 
+     * @param condition - The switch condition
+     * @param cases - A list of consecutive cases
+     * @param index - The index of the current case group
+     * @param lastIfStmt - The last if statement, used to chain else
+     * @returns The new if statement
+     */
+    private static createIfStatement(condition: Expression, cases: Case[], index: number, lastIfStmt: If | undefined): If {
+        const conditionExpr = this.equivalentCondition(condition, cases);
+        const thenBody = ClavaJoinPoints.scope(...cases[cases.length - 1].instructions);
+        const newIfStmt = ClavaJoinPoints.ifStmt(conditionExpr, thenBody);
+
+        if (index === 0) {
+            return newIfStmt;
+        } else {
+            lastIfStmt!.setElse(newIfStmt);
+            return newIfStmt;
+        }
+    }
+
+    /**
+     * Creates the equivalent condition for an if statement based on the case values
+     * 
+     * @param condition - The switch condition
+     * @param cases - A list of case` statements
+     * @returns The combined condition
+     */
+    private static equivalentCondition(condition: Expression, cases: Case[]): Expression {
+        let lastBinaryOp: BinaryOp;
+
+        for (let i = 0; i < cases.length; i++) {
+            const caseStmt = cases[i];
+            const newBinaryOp = ClavaJoinPoints.binaryOp("==", condition, caseStmt.values[0]);
+            
+            if (i === 0) {
+                lastBinaryOp = newBinaryOp;
+                continue;
+            } 
+            lastBinaryOp = ClavaJoinPoints.binaryOp("||", lastBinaryOp!, newBinaryOp);
+        }
+        return lastBinaryOp!;
+    }
+
+    /**
+     * Removes all break statements from the given scope
+     * @param scope - The scope from which the break statements will be removed
+     */
+    private static removeBreakStmts(scope: Scope) {
+        const breakStmts = scope.children.filter(child => child instanceof Break);
+        breakStmts.forEach(stmt => stmt.detach());
+    }
+
+    /**
+     * Removes all case statements from the given scope
+     * @param scope - The scope from which the case statements will be removed
+     */
+    private static removeCases(scope: Scope) {
+        const cases = scope.children.filter(child => child instanceof Case);
+        cases.forEach(caseStmt => caseStmt.detach());
+    }
+
+    /**
+     * Groups case statements into consecutive blocks, ensuring the block with the default case is last
+     * 
+     * @param switchStmt - The switch statement
+     * @returns The grouped case statements
+     */
+    private static consecutiveCases(switchStmt: Switch): Case[][] {
+        let caseGroups: Case[][] = [];
+        let currentList: Case[] = [];
+
+        for (const caseStmt of switchStmt.cases) {
+            currentList.push(caseStmt);
+
+            if (caseStmt.instructions.length !== 0) { // Has no consecutive case
+                caseGroups.push(currentList);
+                currentList = [];
+            } 
+        }
+
+        // Ensure the block containing the default case is placed at the last position
+        return this.organizeCaseGroups(caseGroups); 
+    }
+
+    /**
+     * Organizes case groups such that the group with default case is placed last.
+     * 
+     * @param caseGroups - The groups of case statements
+     * @returns The organized case groups
+     */
+    private static organizeCaseGroups(caseGroups: Case[][]): Case[][] {
+        const nonDefaultGroups = caseGroups.filter(block => !block.some(caseStmt => caseStmt.isDefault));
+        const defaultBlock = caseGroups.find(block => block.some(caseStmt => caseStmt.isDefault));
+        
+        if (defaultBlock) {
+            nonDefaultGroups.push(defaultBlock);
+        }
+        return nonDefaultGroups;
+    }
+}

package/src/MISRAContext.ts

@@ -0,0 +1,84 @@
+import { Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import { MISRAError } from "./MISRA.js";
+import * as fs from 'fs';
+
+/**
+ * Tracks MISRA errors and warnings during the analysis and/or transformation of the code.
+ * Also generated unique variable and function names.
+ */
+export default class MISRAContext {
+    /**
+     * List of MISRA errors, that could not be resolved during the transformation process
+     */
+    #misraErrors: MISRAError[] = [];
+
+    /**
+     * Configuration provided by the user to assist in rule corrections
+     */
+    #config: Map<string, any> | undefined = undefined;
+
+    #varCounter = 0;
+    #funcCounter = 0;
+    #headerCounter = 0;
+
+    #varPrefix = "__misra_var_";
+    #funcPrefix = "__misra_func_";
+    #headerPrefix = "misra_hdr_";
+
+    get errors(): MISRAError[] {
+        return this.#misraErrors;
+    }
+
+    get activeErrors(): MISRAError[] {
+        return this.#misraErrors.filter(error => error.isActiveError());
+    }
+
+    get config(): Map<string, any> | undefined {
+        return this.#config;
+    }
+
+    set config(configFilePath: string) {
+        if (fs.existsSync(configFilePath)) {
+            const data = fs.readFileSync(configFilePath, 'utf-8');
+            this.#config = new Map(Object.entries(JSON.parse(data)));
+        } else {
+            console.error(`[Clava-MISRATool] Provided configuration file was not found.`);
+            process.exit(1);
+        }
+    }
+
+    generateVarName() {
+        return `${this.#varPrefix}${this.#varCounter++}`;
+    }
+
+    generateFuncName() {
+        return `${this.#funcPrefix}${this.#funcCounter++}`;
+    }
+
+    generateHeaderFilename() {
+        return `${this.#headerPrefix}${this.#headerCounter++}.h`;
+    }
+
+    addMISRAError(ruleID: string, $jp: Joinpoint, message: string) {
+        const newError = new MISRAError(ruleID, $jp, message);
+
+        if (!this.#misraErrors.some(error => error.equals(newError))) {
+            this.#misraErrors.push(newError);
+        }
+    }
+
+    private printError(error: MISRAError): void {
+        console.log(`MISRA-C Rule ${error.ruleID} violation at ${error.$jp.filepath}@${error.$jp.line}:${error.$jp.column}: ${error.message}\n`);
+    }
+    
+    public printAllErrors(): void {
+        this.#misraErrors.forEach(error => this.printError(error));
+    }
+    
+    public printActiveErrors(): void {
+        this.#misraErrors
+            .filter(error => error.isActiveError())
+            .forEach(error => this.printError(error));
+    }
+    
+}

package/src/MISRARule.ts

@@ -0,0 +1,64 @@
+import { Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRAContext from "./MISRAContext.js";
+import { MISRATransformationReport } from "./MISRA.js";
+
+/**
+ * Represents a MISRA Rule that detects and corrects violations in the code according to MISRA standards.
+ * 
+ * Need to implement:
+ *  - match($jp, logErrors)
+ *  - transform($jp)
+ */
+export default abstract class MISRARule {
+    /**
+     * Unique identifier for the MISRA rule.
+     */
+    readonly ruleID: string;
+
+    /**
+     * Priority of the rule which is low by default.
+     */
+    readonly priority: number = 4;
+    
+    /** 
+     * MISRA context for error tracking and rule transformations state
+     */    
+    protected context: MISRAContext;
+
+    /**
+     * 
+     * @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;
+    }
+
+    /**
+     * 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
+     */
+    abstract match($jp: Joinpoint, logErrors: boolean): boolean;
+
+    /**
+     * Transforms the joinpoint to comply with the MISRA-C rule
+     * 
+     * @param $jp - Joinpoint to transform
+     * @returns Report detailing the transformation result
+     */
+    abstract transform($jp: Joinpoint): MISRATransformationReport;
+
+    /**
+     * Logs a MISRA-C rule violation error
+     * 
+     * @param $jp - The joinpoint where the violation occurred
+     * @param msg - Description of the violation
+     */
+    protected logMISRAError($jp: Joinpoint, msg:string): void {
+        this.context.addMISRAError(this.ruleID, $jp, msg); 
+    }
+}

package/src/MISRATool.ts

@@ -0,0 +1,95 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { Call, 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";
+
+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 checkCompliance(startingPoint: Program | FileJp = Query.root() as Program) {
+        this.init(startingPoint);
+
+        const nodes = [startingPoint, ...startingPoint.descendants];
+        for (const node of nodes) {
+            for (const rule of this.#misraRules) {
+                rule.match(node, true);
+            }
+        }
+        if (this.#context.errors.length > 0) {
+            this.#context.printAllErrors();
+        } else {
+            console.log("[Clava-MISRATool] No MISRA-C violations detected.");
+        }
+    } 
+
+    public static applyCorrections(configFilePath?: string) {
+        this.init(Query.root() as Program);
+        if (configFilePath) {
+            this.#context.config = configFilePath;
+        }
+
+        let iteration = 0;
+        let modified = false;
+        do {
+            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();
+        }
+    }
+
+    private static transformAST($jp: Joinpoint): boolean {
+        let modified = false;
+
+        for (const rule of this.#misraRules) {
+            const transformReport = rule.transform($jp);
+
+            if (transformReport.type !== MISRATransformationType.NoChange) {
+                modified = true;
+                if (transformReport.type === MISRATransformationType.Removal)
+                    return modified;
+                else if (transformReport.type === MISRATransformationType.Replacement)
+                    $jp = transformReport.newNode as Joinpoint;
+            }
+        }
+
+        for (const child of $jp.children) {
+            if (this.transformAST(child)) 
+                modified = true;
+        }
+        return modified;
+    }
+
+    public static getErrorCount(): number {
+        return this.#context.errors.length;
+    }
+
+    public static getActiveErrorCount(): number {
+        return this.#context.activeErrors.length;
+    }
+}

package/src/main.ts

@@ -1,36 +1,7 @@
-import Query from "@specs-feup/lara/api/weaver/Query.js";
-import { FunctionJp, Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
-import { foo } from "./foo.js";
-import S16_SwitchStatementPass from "./misra/passes/S16_SwitchStatementPass.js";
-import S15_ControlFlowPass from "./misra/passes/S15_ControlFlowPass.js";
-import MISRAReporter from "./misra/MISRAReporter.js";
-import S10_EssentialTypePass from "./misra/passes/S10_EssentialTypePass.js";
-import AggregatePassResult from "@specs-feup/lara/api/lara/pass/results/AggregatePassResult.js";
-import MISRAPassResult from "./misra/MISRAPassResult.js";
-import S12_ExpressionPass from "./misra/passes/S12_ExpressionPass.js";
-import S17_FunctionPass from "./misra/passes/S17_FunctionPass.js";
-import S13_SideEffectPass from "./misra/passes/S13_SideEffectPass.js";
-import S18_PointersArraysPass from "./misra/passes/S18_PointersArraysPass.js";
-
 import VisualizationTool from "@specs-feup/clava-visualization/api/VisualizationTool.js";
+import MISRATool from "./MISRATool.js";
 
-const pass = new S16_SwitchStatementPass(true, [1, 6, 7]);
-const reporter = new MISRAReporter();
-
-console.log(Query.root().dump);
-
-const result = reporter.applyPass(
-  pass,
-  Query.root() as Joinpoint
-) as AggregatePassResult;
-if (result) {
-  result.results.forEach((res) => {
-    const reports = (res as MISRAPassResult).reports;
-    console.log(reports);
-    //reports.forEach(rep => rep.fix?.execute());
-  });
-}
-
-console.log("GADASDSAD");
+MISRATool.checkCompliance();
+MISRATool.applyCorrections();
 
-await VisualizationTool.visualize();
+//await VisualizationTool.visualize();

package/src/misra-old/MISRAAnalyser.ts

@@ -0,0 +1,60 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import Analyser from "@specs-feup/clava/api/clava/analysis/Analyser.js";
+import AnalyserResult from "@specs-feup/clava/api/clava/analysis/AnalyserResult.js";
+import { FileJp, Joinpoint, Program } from "@specs-feup/clava/api/Joinpoints.js";
+import ResultFormatManager from "@specs-feup/clava/api/clava/analysis/ResultFormatManager.js"
+import Fix from "@specs-feup/clava/api/clava/analysis/Fix.js";
+import MISRAAnalyserResult from "./MISRAAnalyserResult.js";
+
+type T = Program | FileJp;
+
+export default abstract class MISRAAnalyser extends Analyser {
+    #selectedRules: string[];
+    #results: AnalyserResult[] = [];
+    #resultFormatManager = new ResultFormatManager();
+    protected currentRule: string = "";
+    protected abstract ruleMapper: Map<string, (jp: T) => void>;
+
+    constructor(rules?: string[]) {
+        super();
+        this.#selectedRules = rules ?? [];
+    }
+
+    public addSelectedRule(ruleID: string) {
+        this.#selectedRules.push(ruleID);
+    }
+
+    public setSelectedRules(rules: string[]) {
+        this.#selectedRules = rules;
+    }
+
+    protected logMISRAError(ruleID: string, jp: Joinpoint, message: string, fix?: Fix) {
+        this.#results.push(
+            new MISRAAnalyserResult(
+                ruleID, 
+                `MISRA Rule ${ruleID} violation at ${jp?.filename}@${jp?.line}:${jp?.column}`, jp, message, fix
+            )
+        );
+    }
+
+    analyse($startNode: T = Query.root() as Program) {
+        if (this.#selectedRules.length === 0) {
+            this.setSelectedRules(Array.from(this.ruleMapper.keys()));
+        }
+
+        for (const rule of this.#selectedRules) {
+            this.currentRule = rule;
+            const rulePass = this.ruleMapper.get(rule);
+            if (rulePass) {
+                rulePass($startNode);
+            }
+            else {
+                throw new Error("Analyser doesn't support rule number " + rule);
+            }
+        }
+
+        this.#resultFormatManager.setAnalyserResultList(this.#results);
+        const fileResult = this.#resultFormatManager.formatResultList($startNode);
+        return fileResult;
+    }
+}

package/src/misra-old/MISRAAnalyserResult.ts

@@ -0,0 +1,16 @@
+import AnalyserResult from "@specs-feup/clava/api/clava/analysis/AnalyserResult.js";
+import Fix from "@specs-feup/clava/api/clava/analysis/Fix.js";
+import { Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+
+export default class MISRAAnalyserResult extends AnalyserResult {
+    private violatedRule: string;
+
+    constructor(rule:string, name: string, node: Joinpoint, message: string, fix?: Fix) {
+        super(name, node, message, fix);
+        this.violatedRule = rule;
+    }
+
+    getViolatedRule() {
+        return this.violatedRule;
+    }
+}