@specs-feup/clava-misra 1.0.0 → 1.0.2

package/src/misra-old/sections/Section10_EssentialTypeModel.ts

@@ -0,0 +1,377 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { Program, FileJp, TernaryOp, UnaryOp, BinaryOp, Joinpoint, Cast, BuiltinType, Type, Expression, IntLiteral, EnumType, QualType, ReturnStmt, FunctionJp, Call, Op, ParenExpr, Varref } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRAAnalyser from "../MISRAAnalyser.js";
+import Fix from "@specs-feup/clava/api/clava/analysis/Fix.js";
+import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
+
+export enum EssentialTypes {
+    UNSIGNED = "unsigned",
+    CHAR = "char",
+    SIGNED = "signed",
+    ENUM = "enum",
+    FLOAT = "float",
+    BOOL = "bool",
+    UNKOWN = "unkown"
+};
+
+export default class Section10_EssentialTypeModel extends MISRAAnalyser {
+    ruleMapper: Map<string, (jp: Program | FileJp) => void>;
+
+    constructor(rules?: string[]) {
+        super(rules);
+        this.ruleMapper = new Map([
+            ["10.1", this.r10_1_appropriateEssentialOperands.bind(this)],
+            ["10.2", this.r10_2_appropriateCharOperands.bind(this)],
+            ["10.3", this.r10_3_noInvalidAssignments.bind(this)],
+            ["10.5", this.r10_5_noInvalidCasts.bind(this)],
+            ["10.6", this.r10_6_noWiderCompositeExprAssignments.bind(this)],
+            ["10.8", this.r10_8_noWiderCompositeCasts.bind(this)]
+        ]);
+    }
+
+    static getEssentialType(bType: Type): EssentialTypes {
+        let type = bType.desugarAll;
+        while (type instanceof QualType) {
+            type = type.unqualifiedType.desugarAll;
+        }
+
+        if (type instanceof BuiltinType) {
+            if (type.builtinKind === "Bool") {
+                return EssentialTypes.BOOL;
+            }
+            else if (type.builtinKind === "Char_S") {
+                return EssentialTypes.CHAR;
+            }
+            else if (type.isInteger && type.isSigned) {
+                return EssentialTypes.SIGNED;
+            }
+            else if (type.isInteger && !type.isSigned) {
+                return EssentialTypes.UNSIGNED;
+            }
+            else if (type.isFloat) {
+                return EssentialTypes.FLOAT;
+            }
+        }
+        else if (type instanceof EnumType) {
+            return type.name === undefined ? EssentialTypes.SIGNED : EssentialTypes.ENUM;
+        }
+
+        return EssentialTypes.UNKOWN;
+    }
+
+    static isInteger($et: EssentialTypes): boolean {
+        return $et === EssentialTypes.SIGNED || $et === EssentialTypes.UNSIGNED;
+    }
+
+    static getExprEssentialType($expr: Expression): EssentialTypes {
+        if ($expr instanceof BinaryOp) {
+            if ($expr.kind === "add") {
+                if ((this.getExprEssentialType($expr.left) === EssentialTypes.CHAR && this.isInteger(this.getExprEssentialType($expr.right)))
+                        || (this.getExprEssentialType($expr.right) === EssentialTypes.CHAR && this.isInteger(this.getExprEssentialType($expr.left)))) {
+                    return EssentialTypes.CHAR;
+                }
+            }
+            else if ($expr.kind === "sub") {
+                if (this.getExprEssentialType($expr.left) === EssentialTypes.CHAR) {
+                    if (this.getExprEssentialType($expr.right) === EssentialTypes.CHAR) {
+                        return EssentialTypes.CHAR;
+                    }
+                }
+            }
+        }
+        return this.getEssentialType($expr.type);
+    }
+
+    private restrictOperand($expr: Expression, $restrictedType: EssentialTypes, $baseExpr: Expression, $castTo?: BuiltinType) {
+        const et = Section10_EssentialTypeModel.getExprEssentialType($expr);
+        if (et === $restrictedType) {
+            const fix = $castTo ? new Fix($expr, ($jp) => {
+                $jp.replaceWith(ClavaJoinPoints.cStyleCast($castTo, $jp as Expression));
+            }) : undefined;
+            this.logMISRAError(this.currentRule, $baseExpr, `Operand ${$expr.code} of expression ${$baseExpr.code} must not have essentially ${et} type.`, fix);
+        }
+    }
+
+    private restrictOperandList($expr: Expression, $restrictedTypes: EssentialTypes[], $baseExpr: Expression, $castTo?: BuiltinType) {
+        for (const type of $restrictedTypes) {
+            this.restrictOperand($expr, type, $baseExpr, $castTo);
+        }
+    }
+    
+    private r10_1_appropriateEssentialOperands($startNode: Joinpoint) { //missing exception and compound operators
+        Query.searchFrom($startNode, Op).get().forEach(op => {
+            if (op instanceof TernaryOp) {
+                this.restrictOperandList(op.cond, [EssentialTypes.CHAR, EssentialTypes.ENUM, EssentialTypes.FLOAT, EssentialTypes.SIGNED, EssentialTypes.UNSIGNED], op);
+            }
+            else if (op instanceof BinaryOp) {
+                switch (op.kind) {
+                    case "shl":
+                    case "shr":
+                        if (!(op.right instanceof IntLiteral)) this.restrictOperand(op.right, EssentialTypes.SIGNED, op);
+                    case "and":
+                    case "or":
+                    case "x_or":
+                        this.restrictOperand(op.left, EssentialTypes.SIGNED, op);
+                        if (op.kind !== "shl" && op.kind !== "shr") this.restrictOperand(op.right, EssentialTypes.SIGNED, op);
+                    case "rem":
+                        this.restrictOperand(op.left, EssentialTypes.FLOAT, op);
+                        this.restrictOperand(op.right, EssentialTypes.FLOAT, op);
+                    case "mul":
+                    case "div":
+                        this.restrictOperand(op.left, EssentialTypes.CHAR, op);
+                        this.restrictOperand(op.right, EssentialTypes.CHAR, op);
+                    case "add":
+                    case "sub":
+                        this.restrictOperand(op.left, EssentialTypes.ENUM, op);
+                        this.restrictOperand(op.right, EssentialTypes.ENUM, op);
+                    case "le":
+                    case "ge":
+                    case "lt":
+                    case "gt":
+                        this.restrictOperand(op.left, EssentialTypes.BOOL, op);
+                        this.restrictOperand(op.right, EssentialTypes.BOOL, op);
+                        break;
+                    case "l_and":
+                    case "l_or":
+                        this.restrictOperandList(op.left, [EssentialTypes.ENUM, EssentialTypes.CHAR, EssentialTypes.SIGNED, EssentialTypes.UNSIGNED, EssentialTypes.FLOAT], op);
+                        this.restrictOperandList(op.right, [EssentialTypes.ENUM, EssentialTypes.CHAR, EssentialTypes.SIGNED, EssentialTypes.UNSIGNED, EssentialTypes.FLOAT], op);
+                        break;
+                }
+            }
+            else if (op instanceof UnaryOp) {
+                switch (op.kind) {
+                    case "minus":
+                        this.restrictOperand(op.operand, EssentialTypes.UNSIGNED, op);
+                    case "plus":
+                        this.restrictOperandList(op.operand, [EssentialTypes.BOOL, EssentialTypes.CHAR, EssentialTypes.ENUM], op);
+                        break;
+                    case "l_not":
+                        this.restrictOperandList(op.operand, [EssentialTypes.ENUM, EssentialTypes.CHAR, EssentialTypes.SIGNED, EssentialTypes.UNSIGNED, EssentialTypes.FLOAT], op);
+                        break;
+                    case "not":
+                        this.restrictOperandList(op.operand, [EssentialTypes.BOOL, EssentialTypes.CHAR, EssentialTypes.ENUM, EssentialTypes.FLOAT, EssentialTypes.SIGNED], op);
+                        break;
+                }
+            }
+        }, this);
+    }
+
+    private r10_2_appropriateCharOperands($startNode: Joinpoint) {
+        Query.searchFrom($startNode, BinaryOp, {kind: /(add|sub)/}).get().forEach(bOp => {
+            if (bOp.kind === "add") {
+                if (Section10_EssentialTypeModel.getExprEssentialType(bOp.left) === EssentialTypes.CHAR && Section10_EssentialTypeModel.getExprEssentialType(bOp.right) === EssentialTypes.CHAR) {
+                    this.logMISRAError(this.currentRule, bOp, `Both operands of addition ${bOp.code} have essentially character type.`);
+                    return;
+                }
+            
+                let otherType;
+                if (Section10_EssentialTypeModel.getExprEssentialType(bOp.left) === EssentialTypes.CHAR) {
+                    otherType = Section10_EssentialTypeModel.getExprEssentialType(bOp.right);
+                }
+                else if (Section10_EssentialTypeModel.getExprEssentialType(bOp.right) === EssentialTypes.CHAR) {
+                    otherType = Section10_EssentialTypeModel.getExprEssentialType(bOp.left);
+                }
+
+                if (otherType && !Section10_EssentialTypeModel.isInteger(otherType)) {
+                    this.logMISRAError(this.currentRule, bOp, `One operand of addition ${bOp.code} has essentially character type, so the other one must have either essentially signed or unsigned type.`);
+                    return;
+                }
+            }
+            else if (bOp.kind === "sub") {
+                if (Section10_EssentialTypeModel.getExprEssentialType(bOp.left) === EssentialTypes.CHAR) {
+                    const rightType = Section10_EssentialTypeModel.getExprEssentialType(bOp.right);
+                    if (!([EssentialTypes.CHAR, EssentialTypes.SIGNED, EssentialTypes.UNKOWN].some(et => et === rightType))) {
+                        this.logMISRAError(this.currentRule, bOp, `Left operand of subtraction ${bOp.code} has essentially character type, so the RHS must be essentially signed, unsigned, or char.`);
+                        return;
+                    }
+                }
+                else if (Section10_EssentialTypeModel.getExprEssentialType(bOp.right) === EssentialTypes.CHAR) {
+                    this.logMISRAError(this.currentRule, bOp, `Right operand of subtraction ${bOp.code} can only be of essentially character type if the LHS is too.`);
+                    return;
+                }
+            }
+        }, this);
+    }
+
+    private r10_3_noInvalidAssignments($startNode: Joinpoint) { //not working for decls
+        Query.searchFrom($startNode, BinaryOp, {kind: "assign"}).get().forEach(bOp => {
+            if (Section10_EssentialTypeModel.getEssentialType(bOp.left.type) !== Section10_EssentialTypeModel.getEssentialType(bOp.right.type)) {
+                this.logMISRAError(this.currentRule, bOp, `Value ${bOp.right.code} cannot be assigned to ${bOp.left.code}, since it has a different essential type category.`);
+            }
+            else if (bOp.left.bitWidth < bOp.right.bitWidth) {
+                this.logMISRAError(this.currentRule, bOp, `Value ${bOp.right.code} cannot be assigned to ${bOp.left.code} since it has a narrower type.`);
+            }
+        }, this);
+        Query.searchFrom($startNode, ReturnStmt).get().forEach(ret => {
+            const fun = ret.getAncestor("function") as FunctionJp;
+            //console.log(ret.returnExpr.code, ret.returnExpr.bitWidth);
+            //console.log(fun.bitWidth);
+            if (Section10_EssentialTypeModel.getEssentialType(ret.returnExpr.type) !== Section10_EssentialTypeModel.getEssentialType(fun.returnType)) {
+                this.logMISRAError(this.currentRule, ret, `Value ${ret.returnExpr.code} cannot be returned by ${fun.signature}, since it has a different essential type category.`);
+            }
+            else if (fun.bitWidth < ret.returnExpr.bitWidth) {
+                this.logMISRAError(this.currentRule, ret, `Value ${ret.returnExpr.code} cannot be returned by ${fun.signature} since it has a narrower type.`);
+            }
+        }, this);
+        Query.searchFrom($startNode, Call).get().forEach(call => {
+            const funParams = call.directCallee.params;
+            for (let i = 0; i < funParams.length; i++) {
+                if (Section10_EssentialTypeModel.getEssentialType(funParams[i].type) !== Section10_EssentialTypeModel.getEssentialType(call.argList[0].type)) {
+                    this.logMISRAError(this.currentRule, call, `Value ${call.argList[i].code} cannot be assigned to parameter ${funParams[i].code}, since it has a different essential type category.`);
+                }
+                else if (funParams[i].bitWidth < call.argList[i].bitWidth) {
+                    this.logMISRAError(this.currentRule, call, `Value ${call.argList[i].code} cannot be assigned to parameter ${funParams[i].code}, since it has a narrower type.`);
+                }
+            }
+        }, this);
+    }
+
+    private static checkBoolSource(subExpr: Expression) {
+        if (subExpr.type.desugarAll instanceof BuiltinType && subExpr.type.desugarAll.builtinKind === "Bool") {
+            return true;
+        }
+        else if (subExpr instanceof IntLiteral && (Number(subExpr.value) === 0 || Number(subExpr.value) === 1)) {
+            return true;
+        }
+        else return false;
+    }
+
+    private r10_5_noInvalidCasts($startNode: Joinpoint) {//chars, anonymous enums
+        Query.searchFrom($startNode, Cast).get().forEach(cast => {
+            const fromType = cast.fromType.desugarAll;
+            const toType = cast.toType.desugarAll;
+
+            if (toType instanceof BuiltinType) {
+                console.log(toType.builtinKind)
+            }
+
+            if (toType instanceof BuiltinType && toType.builtinKind === "Bool" && !Section10_EssentialTypeModel.checkBoolSource(cast.subExpr)) {
+                this.logMISRAError(this.currentRule, cast, "Only essentially boolean values, or the integer constants 0 or 1, may be cast to an essentially boolean type.");
+            }
+            else if (toType instanceof EnumType && !(fromType instanceof EnumType && toType.name === fromType.name)) {
+                this.logMISRAError(this.currentRule, cast, "Only essentially enum values of the same enum may be cast to an essentially enum type.");
+            }
+            else if (toType instanceof BuiltinType && toType.builtinKind === "Int" && toType.isSigned && fromType instanceof BuiltinType && fromType.builtinKind === "Bool") {
+                this.logMISRAError(this.currentRule, cast, "Essentially boolean values should not be cast to an essentially signed type.");
+            }
+            else if (toType instanceof BuiltinType && toType.builtinKind === "Int" && !toType.isSigned && fromType instanceof BuiltinType && fromType.builtinKind === "Bool") {
+                this.logMISRAError(this.currentRule, cast, "Essentially boolean values should not be cast to an essentially unsigned type.");
+            }
+            else if (toType instanceof BuiltinType && toType.isFloat && fromType instanceof BuiltinType && fromType.builtinKind === "Bool") {
+                this.logMISRAError(this.currentRule, cast, "Essentially boolean values should not be cast to an essentially floating type.");
+            }
+        }, this);
+    }
+
+    private static isCompositeBinaryExpr($op: BinaryOp) {
+        return /(add)|(sub)|(mul)|(div)|(rem)|(shl)|(shr)|(l_and)|(l_or)|(xor)/.test($op.kind);
+    }
+
+    private static isCompositeExpr($expr: Expression): Expression | undefined {
+        if ($expr instanceof ParenExpr) {
+            return this.isCompositeExpr($expr.subExpr);
+        }
+        else if ($expr instanceof BinaryOp) {
+            if (this.isCompositeBinaryExpr($expr)) {
+                return $expr;
+            }
+        }
+        else if ($expr instanceof TernaryOp) {
+            if (this.isCompositeExpr($expr.trueExpr) || this.isCompositeExpr($expr.falseExpr)) {
+                return $expr;
+            }
+        }
+        else return undefined;
+    }
+
+    private static compositeExprWidth($op: Expression): number {
+        if ($op instanceof BinaryOp && Section10_EssentialTypeModel.isCompositeBinaryExpr($op)) {
+            const leftW = Section10_EssentialTypeModel.compositeExprWidth($op.left);
+            const rightW = Section10_EssentialTypeModel.compositeExprWidth($op.right);
+            return Math.max(leftW, rightW);
+        }
+        else if ($op instanceof TernaryOp) {
+            const secondW = Section10_EssentialTypeModel.compositeExprWidth($op.trueExpr);
+            const thirdW = Section10_EssentialTypeModel.compositeExprWidth($op.falseExpr);
+            return Math.min(secondW, thirdW);
+        }
+        else if ($op instanceof ParenExpr) {
+            return this.compositeExprWidth($op.subExpr);
+        }
+        else return $op.bitWidth;
+    }
+
+    private static transformBinaryOp($expr: BinaryOp, $type: Type) {
+        $expr.left.replaceWith(ClavaJoinPoints.cStyleCast($type, $expr.left));
+    }
+
+    private static transformTernaryOp($expr: TernaryOp, $type: Type, $bitWidth: number) {
+        const trueExpr = this.isCompositeExpr($expr.trueExpr);
+        const falseExpr = this.isCompositeExpr($expr.falseExpr);
+        if (trueExpr && this.compositeExprWidth(trueExpr) < $bitWidth) {
+            if (trueExpr instanceof TernaryOp) this.transformTernaryOp(trueExpr, $type, $bitWidth);
+            else if (trueExpr instanceof BinaryOp) this.transformBinaryOp(trueExpr, $type);
+        }
+
+        if (falseExpr && this.compositeExprWidth(falseExpr) < $type.bitWidth) {
+            if (falseExpr instanceof TernaryOp) this.transformTernaryOp(falseExpr, $type, $bitWidth);
+            else if (falseExpr instanceof BinaryOp) this.transformBinaryOp(falseExpr, $type);
+        }
+    }
+
+    private r10_6_noWiderCompositeExprAssignments($startNode: Joinpoint) { //unfinished for rets and params
+        Query.searchFrom($startNode, Expression).get().forEach(expr => {
+            const compositeExpr = Section10_EssentialTypeModel.isCompositeExpr(expr);
+            if (compositeExpr) {
+                const parent = expr.parent;
+                if (parent instanceof BinaryOp && parent.kind === "assign") {
+                    if (Section10_EssentialTypeModel.compositeExprWidth(compositeExpr) < parent.left.bitWidth) {
+                        this.logMISRAError(this.currentRule, compositeExpr, "A composite expression must not be assigned to a value with wider type.", new Fix(compositeExpr, op => {
+                            if (op instanceof BinaryOp) {
+                                Section10_EssentialTypeModel.transformBinaryOp(op, op.parent.type);
+                            }
+                            else if (op instanceof TernaryOp) {
+                                op.replaceWith(ClavaJoinPoints.cStyleCast(op.parent.type, op));
+                            }
+                        }));
+                    }
+                }
+            }
+        }, this);
+        /*Query.searchFrom($startNode, Op, {kind: /(add)|(sub)|(mul)|(div)|(rem)|(shl)|(shr)|(l_and)|(l_or)|(xor)/}).get().forEach(op => {
+            const parent = op.parent;
+            if (parent instanceof BinaryOp && parent.kind === "assign") {
+                if (Section10_EssentialTypeModel.compositeExprWidth(op) < parent.left.bitWidth) {
+                    this.logMISRAError(op, "A composite expression must not be assigned to a value with wider type.", new Fix(op, op => {
+                        const opJp = op as BinaryOp;
+                        opJp.left.replaceWith(ClavaJoinPoints.cStyleCast(opJp.parent.type, opJp.left));
+                    }));
+                }
+            }
+        }, this);*/
+    }
+
+    private r10_8_noWiderCompositeCasts($startNode: Joinpoint) {
+        Query.searchFrom($startNode, Cast).get().forEach(cast => {
+            const compositeExpr = Section10_EssentialTypeModel.isCompositeExpr(cast.subExpr);
+            if (compositeExpr) {
+                if (Section10_EssentialTypeModel.getEssentialType(cast.fromType) !== Section10_EssentialTypeModel.getEssentialType(cast.toType)) {
+                    this.logMISRAError(this.currentRule, cast, `Composite expression ${cast.subExpr.code} cannot be cast to ${cast.toType.code}, since it has a different essential type category.`);
+                }
+                else if (cast.bitWidth > Section10_EssentialTypeModel.compositeExprWidth(compositeExpr)) {
+                    this.logMISRAError(this.currentRule, compositeExpr, `Composite expression ${cast.subExpr.code} cannot be cast to ${cast.toType.code} since it is a wider type.`, new Fix(cast, cast => {
+                        const castJp = cast as Cast;
+                        const compositeExpr = Section10_EssentialTypeModel.isCompositeExpr(castJp.subExpr);
+                        if (compositeExpr instanceof BinaryOp) {
+                            compositeExpr.left.replaceWith(ClavaJoinPoints.cStyleCast(cast.type, compositeExpr.left));
+                            cast.replaceWith(compositeExpr);
+                        }
+                        else if (compositeExpr instanceof TernaryOp) {
+                            Section10_EssentialTypeModel.transformTernaryOp(compositeExpr, cast.type, cast.bitWidth);
+                        }
+                    }));
+                }
+            }
+        });
+    }
+}

package/src/misra-old/sections/Section11_PointerTypeConversions.ts

@@ -0,0 +1,104 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { Program, FileJp, Cast, FunctionType, PointerType, BuiltinType, IntLiteral, Joinpoint, QualType } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRAAnalyser from "../MISRAAnalyser.js";
+import Section10_EssentialTypeModel, { EssentialTypes } from "./Section10_EssentialTypeModel.js";
+
+export default class Section11_PointerTypeConversions extends MISRAAnalyser {
+    ruleMapper: Map<string, (jp: Program | FileJp) => void>;
+    
+    constructor(rules?: string[]) {
+        super(rules);
+        this.ruleMapper = new Map([
+            ["11.1", this.r11_1_noFunctionPointerConversions.bind(this)],
+            ["11.4", this.r11_4_noIntToPointer.bind(this)],
+            ["11.7", this.r11_7_noFloatConversions.bind(this)],
+            ["11.5", this.r11_5_noConversionFromVoid.bind(this)]
+        ]);
+    }
+
+    private static functionTypesMatch(t1: FunctionType, t2: FunctionType) {
+        //console.log(t1.returnType.kind, t2.returnType.kind);
+        if (t1.returnType != t2.returnType) {
+            return false;
+        }
+        if (t1.paramTypes.length !== t2.paramTypes.length) {
+            return false;
+        }
+        for (let i = 0; i < t1.paramTypes.length; i++) {
+            if (t1.paramTypes[i] != t2.paramTypes[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private r11_1_noFunctionPointerConversions($startNode: Joinpoint) { //type equality not working
+        Query.searchFrom($startNode, Cast).get().forEach(cast => {
+            const fromType = cast.fromType.desugarAll;
+            const toType = cast.toType.desugarAll;
+
+            if (fromType instanceof PointerType && toType instanceof PointerType && fromType.pointee.desugarAll instanceof FunctionType && toType.pointee.desugarAll instanceof FunctionType) {
+                if (!Section11_PointerTypeConversions.functionTypesMatch(fromType.pointee.desugarAll, toType.pointee.desugarAll)) {
+                    this.logMISRAError(this.currentRule, cast, "A function pointer can only be converted into another function pointer if the types match.");
+
+                }
+            }
+            else if (fromType instanceof PointerType && fromType.pointee.desugarAll instanceof FunctionType) {
+                if (!(toType instanceof BuiltinType && toType.isVoid)) {
+                    this.logMISRAError(this.currentRule, cast, "A function pointer can only be converted into another function pointer if the types match.");
+                }
+            }
+            else if (toType instanceof PointerType && toType.pointee.desugarAll instanceof FunctionType) {
+                if (!(cast.subExpr instanceof IntLiteral && Number(cast.subExpr.value) === 0)) {
+                    this.logMISRAError(this.currentRule, cast, "Only null pointer constants can be converted into function pointers.");
+                }
+            }
+        });
+    }
+
+    private r11_4_noIntToPointer($startNode: Joinpoint) {
+        Query.searchFrom($startNode, Cast).get().forEach(cast => {
+            const fromType = cast.fromType.desugarAll;
+            const toType = cast.toType.desugarAll;
+            if (fromType.isPointer !== toType.isPointer) {
+                this.logMISRAError(this.currentRule, cast, "Integers should not be converted to pointers and vice-versa.");
+            }
+        })
+    }
+
+    private r11_5_noConversionFromVoid($startNode: Joinpoint) {
+        Query.searchFrom($startNode, Cast).get().forEach(cast => {
+            const fromType = cast.fromType.desugarAll;
+            const toType =cast.toType.desugarAll;
+            if (fromType instanceof PointerType && fromType.pointee instanceof BuiltinType && fromType.pointee.isVoid
+                && toType instanceof PointerType && !(toType.pointee instanceof BuiltinType && toType.pointee.isVoid)) {
+                this.logMISRAError(this.currentRule, cast, "Pointer to void should not be converted to pointer to object");
+            }
+        });
+    }
+
+    private r11_7_noFloatConversions($startNode: Joinpoint) {
+        Query.searchFrom($startNode, Cast).get().forEach(cast => {
+            let fromType = cast.fromType.desugarAll;
+            let toType = cast.fromType.desugarAll;
+
+            if (fromType instanceof QualType) {
+                fromType = fromType.unqualifiedType.desugarAll;
+            }
+            if (toType instanceof QualType) {
+                toType = toType.unqualifiedType.desugarAll;
+            }
+
+            if (fromType instanceof PointerType && !(toType instanceof PointerType)
+                    && Section10_EssentialTypeModel.getEssentialType(toType) !== EssentialTypes.SIGNED
+                    && Section10_EssentialTypeModel.getEssentialType(toType) !== EssentialTypes.UNSIGNED) {
+                this.logMISRAError(this.currentRule, cast, "A pointer to object cannot be cast to a non-integer arithmetic type.");
+            }
+            else if (toType instanceof PointerType && !(fromType instanceof PointerType)
+                    && Section10_EssentialTypeModel.getEssentialType(fromType) !== EssentialTypes.SIGNED
+                    && Section10_EssentialTypeModel.getEssentialType(fromType) !== EssentialTypes.UNSIGNED) {
+                this.logMISRAError(this.currentRule, cast, "A non-arithmetic integer value cannot be cast to a pointer to object.");
+            }
+        }, this);
+    }
+}

package/src/{misra → misra-old}/sections/Section12_Expressions.ts

@@ -5,13 +5,13 @@ import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
 import Fix from "@specs-feup/clava/api/clava/analysis/Fix.js";
 
 export default class Section12_Expressions extends MISRAAnalyser {
-    ruleMapper: Map<number, (jp: Program | FileJp) => void>;
+    ruleMapper: Map<string, (jp: Program | FileJp) => void>;
     
-    constructor(rules: number[]) {
+    constructor(rules?: string[]) {
         super(rules);
         this.ruleMapper = new Map([
-            [1, this.r12_1_explicitPrecedence.bind(this)],
-            [3, this.r12_3_noCommaOperator.bind(this)]
+            ["12.1", this.r12_1_explicitPrecedence.bind(this)],
+            ["12.3", this.r12_3_noCommaOperator.bind(this)]
         ]);
     }
 
@@ -55,7 +55,7 @@ export default class Section12_Expressions extends MISRAAnalyser {
                 || (bOp.parent instanceof Op && Section12_Expressions.isSamePrecedence(bOp.kind, bOp.parent.kind))
                 || (bOp.parent.instanceOf("parenExpr"))) continue;
     
-            this.logMISRAError(bOp, `Operator precedence in expression ${bOp.code} is not explicit.`, new Fix(bOp, ($jp: Joinpoint) => {
+            this.logMISRAError(this.currentRule, bOp, `Operator precedence in expression ${bOp.code} is not explicit.`, new Fix(bOp, ($jp: Joinpoint) => {
                 const parenExpr = ClavaJoinPoints.parenthesis($jp as Expression);
                 bOp.replaceWith(parenExpr);
             }));
@@ -67,10 +67,10 @@ export default class Section12_Expressions extends MISRAAnalyser {
             const loopAncestor = op.getAncestor("loop");
             if (loopAncestor instanceof Loop && (loopAncestor?.step?.contains(op) || loopAncestor?.cond?.contains(op) || loopAncestor?.init?.contains(op))) {
                 console.log(`Cannot eliminate comma operator in expression ${op.code} since it is at the head of a loop.`);
-                this.logMISRAError(op, "Use of the comma operator is not allowed.");
+                this.logMISRAError(this.currentRule, op, "Use of the comma operator is not allowed.");
             }
             else {
-                this.logMISRAError(op, "Use of the comma operator is not allowed.", new Fix(op, ($jp: Joinpoint) => {
+                this.logMISRAError(this.currentRule, op, "Use of the comma operator is not allowed.", new Fix(op, ($jp: Joinpoint) => {
                     $jp.insertBefore(($jp as BinaryOp).left.stmt);
                     $jp.replaceWith(($jp as BinaryOp).right);
                 }));

package/src/{misra → misra-old}/sections/Section13_SideEffects.ts

@@ -6,32 +6,32 @@ import TraversalType from "@specs-feup/lara/api/weaver/TraversalType.js";
 import Fix from "@specs-feup/clava/api/clava/analysis/Fix.js";
 
 export default class Section13_SideEffects extends MISRAAnalyser {
-    ruleMapper: Map<number, (jp: Program | FileJp) => void>;
+    ruleMapper: Map<string, (jp: Program | FileJp) => void>;
     
-    constructor(rules: number[]) {
+    constructor(rules?: string[]) {
         super(rules);
         this.ruleMapper = new Map([
-            [1, this.r13_1_initListSideEffects.bind(this)],
-            [3, this.r13_3_noIncrementSideEffects.bind(this)],
-            [4, this.r13_4_noUseOfAssignmentValue.bind(this)],
-            [5, this.r13_5_shortCircuitSideEffects.bind(this)]
+            ["13.1", this.r13_1_initListSideEffects.bind(this)],
+            ["13.3", this.r13_3_noIncrementSideEffects.bind(this)],
+            ["13.4", this.r13_4_noUseOfAssignmentValue.bind(this)],
+            ["13.5", this.r13_5_shortCircuitSideEffects.bind(this)]
         ]);
     }
 
-    private checkPotentialPersistentSideEffects<T>($startNode: Joinpoint, type: any, filters: any, name: string, childFun: ($jp: T) => Joinpoint) {
+    private checkPotentialPersistentSideEffects<T>(ruleID: string, $startNode: Joinpoint, type: any, filters: any, name: string, childFun: ($jp: T) => Joinpoint) {
         Query.searchFrom($startNode, type, filters).get().forEach(list => {
             Query.searchFromInclusive(childFun(list), Varref).get().forEach(ref => {
                 if (ref.type instanceof QualType && ref.type.qualifiers?.includes("volatile")) {
-                    this.logMISRAError(list, `${name} ${list.code} contains persistent side effects: an access to volatile object ${ref.name}.`)
+                    this.logMISRAError(ruleID, list, `${name} ${list.code} contains persistent side effects: an access to volatile object ${ref.name}.`)
                 }
             }, this); 
             Query.searchFromInclusive(childFun(list), Call).get().forEach(call => {
-                this.logMISRAError(list, `${name} ${list.code} may contain persistent side effects in call to ${call.name}.`);
+                this.logMISRAError(ruleID, list, `${name} ${list.code} may contain persistent side effects in call to ${call.name}.`);
             }, this);
             Query.searchFromInclusive(childFun(list), UnaryOp, {kind: /(post_inc)|(post_dec)|(pre_inc)|(pre_dec)/}).get().forEach(op => { //use chain?
                 Query.searchFrom(op, Varref).get().forEach(ref => {
                     if (ref.declaration instanceof Vardecl && ref.declaration.isGlobal) {
-                        this.logMISRAError(list, `${name} ${list.code} may contain persistent side effects in expression ${op.code}.`)
+                        this.logMISRAError(ruleID, list, `${name} ${list.code} may contain persistent side effects in expression ${op.code}.`)
                     } 
                 });
             }, this);
@@ -39,7 +39,7 @@ export default class Section13_SideEffects extends MISRAAnalyser {
     }
 
     private r13_1_initListSideEffects($startNode: Joinpoint) {
-        this.checkPotentialPersistentSideEffects<Joinpoint>($startNode, InitList, undefined, "Initializer list", jp => jp);
+        this.checkPotentialPersistentSideEffects<Joinpoint>(this.currentRule, $startNode, InitList, undefined, "Initializer list", jp => jp);
     }
 
     private static visitAllExprs(fun: ($jp: Joinpoint) => void, root: Joinpoint) {
@@ -61,7 +61,7 @@ export default class Section13_SideEffects extends MISRAAnalyser {
         const assignments = Query.searchFromInclusive(exprRoot, BinaryOp, {isAssignment: true}).get();
         if (jps.length + calls.length + assignments.length < 2) return;
 
-        this.logMISRAError(exprRoot, `Expression ${exprRoot.code} contains a pre/post inc/decrement operator and other side effects.`, new Fix(exprRoot, ($jp: Joinpoint) => {
+        this.logMISRAError(this.currentRule, exprRoot, `Expression ${exprRoot.code} contains a pre/post inc/decrement operator and other side effects.`, new Fix(exprRoot, ($jp: Joinpoint) => {
             const jps = Query.searchFrom($jp, UnaryOp, {kind: /(post_inc)|(post_dec)|(pre_inc)|(pre_dec)/}, TraversalType.POSTORDER).get();
             const calls = Query.searchFromInclusive($jp, Call).get();
             const assignments = Query.searchFromInclusive($jp, BinaryOp, {isAssignment: true}).get();
@@ -76,7 +76,7 @@ export default class Section13_SideEffects extends MISRAAnalyser {
                 else {
                     $jp.insertBefore(jp.deepCopy());
                 }
-                console.log(jp);
+                //console.log(jp);
                 jp.replaceWith(jp.operand);
             }
         }));
@@ -89,12 +89,12 @@ export default class Section13_SideEffects extends MISRAAnalyser {
     private r13_4_noUseOfAssignmentValue($startNode: Joinpoint) {
         for (const bOp of Query.searchFrom($startNode, BinaryOp, {isAssignment: true})) {
             if (!bOp.parent.instanceOf("exprStmt") && !(bOp.parent.instanceOf("parenExpr") && bOp.parent?.parent?.instanceOf("exprStmt"))) {
-                this.logMISRAError(bOp, `Value of assignment expression ${bOp.code} should not be used.`);
+                this.logMISRAError(this.currentRule, bOp, `Value of assignment expression ${bOp.code} should not be used.`);
             }
         }
     }
 
     private r13_5_shortCircuitSideEffects($startNode: Joinpoint) {
-        this.checkPotentialPersistentSideEffects<BinaryOp>($startNode, BinaryOp, {operator: /(\&\&|\|\|)/}, "RHS of && or || expression", jp => jp.right);
+        this.checkPotentialPersistentSideEffects<BinaryOp>(this.currentRule, $startNode, BinaryOp, {operator: /(\&\&|\|\|)/}, "RHS of && or || expression", jp => jp.right);
     }
 }

package/src/misra-old/sections/Section14_ControlStmtExprs.ts

@@ -0,0 +1,27 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { Program, FileJp, Loop, Joinpoint, If, ExprStmt } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRAAnalyser from "../MISRAAnalyser.js";
+
+export default class Section14_ControlStmtExprs extends MISRAAnalyser {
+    ruleMapper: Map<string, (jp: Program | FileJp) => void>;
+
+    constructor(rules?: string[]) {
+        super(rules);
+        this.ruleMapper = new Map([
+            ["14.4", this.r14_4_essentiallyBooleanInControllingExpr.bind(this)]
+        ]);
+    }
+    
+    private r14_4_essentiallyBooleanInControllingExpr($startNode: Joinpoint) { //better way?
+        Query.searchFrom($startNode, Loop).get().forEach(loop => {
+            if ((loop.cond as ExprStmt).expr.type.code !== "bool") {
+                this.logMISRAError(this.currentRule, loop, `Loop controlling expression ${(loop.cond as ExprStmt).expr.code} does not have essentially boolean type.`);
+            }
+        }, this);
+        Query.searchFrom($startNode, If).get().forEach(ifStmt => {
+            if (ifStmt.cond.type.code !== "bool") {
+                this.logMISRAError(this.currentRule, ifStmt, `Loop controlling expression ${ifStmt.cond.code} does not have essentially boolean type.`);
+            }
+        }, this);
+    }
+}