@specs-feup/clava-misra 1.0.0

package/src/misra/sections/Section11_PointerTypeConversions.ts

@@ -0,0 +1,103 @@
+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<number, (jp: Program | FileJp) => void>;
+    
+    constructor(rules: number[]) {
+        super(rules);
+        this.ruleMapper = new Map([
+            [7, this.r11_7_noFloatConversions.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) {
+                console.log("hello");
+                if (!Section11_PointerTypeConversions.functionTypesMatch(fromType.pointee.desugarAll, toType.pointee.desugarAll)) {
+                    this.logMISRAError(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(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(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(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(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(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(cast, "A non-arithmetic integer value cannot be cast to a pointer to object.");
+            }
+        }, this);
+    }
+}

package/src/misra/sections/Section12_Expressions.ts

@@ -0,0 +1,80 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { Program, FileJp, BinaryOp, Joinpoint, Op, Loop, Expression } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRAAnalyser from "../MISRAAnalyser.js";
+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>;
+    
+    constructor(rules: number[]) {
+        super(rules);
+        this.ruleMapper = new Map([
+            [1, this.r12_1_explicitPrecedence.bind(this)],
+            [3, this.r12_3_noCommaOperator.bind(this)]
+        ]);
+    }
+
+    private static isAdditive(op: string): boolean {
+        return op === "add" || op === "sub";
+    }
+    
+    private static isMultiplicative(op: string): boolean {
+        return op === "mul" || op === "div" || op === "rem";
+    }
+    
+    private static isShift(op: string): boolean {
+        return op === "shl" || op === "shr";
+    }
+    
+    private static isRelational(op: string): boolean {
+        return op === "lt" || op === "gt" || op === "le" || op === "ge";
+    }
+    
+    private static isEquality(op: string): boolean {
+        return op === "eq" || op === "ne";
+    }
+    
+    private static isSamePrecedence(op1: string, op2: string): boolean {
+        if (op1 === op2) return true;
+        
+        for (const fun of [this.isAdditive, this.isMultiplicative, this.isShift, this.isRelational, this.isEquality]) {
+            if (fun(op1) && fun(op2)) {
+                return true;
+            }
+        }
+    
+        return false;
+    }
+
+    private r12_1_explicitPrecedence($startNode: Joinpoint) {
+        for (const bOp of Query.searchFrom($startNode, BinaryOp, {isAssignment: false})) {
+            if ((bOp.kind === "ptr_mem_d" || bOp.kind === "ptr_mem_i")
+                || (!bOp.getAncestor("binaryOp") && !bOp.getAncestor("ternaryOp"))
+                || (bOp.parent instanceof BinaryOp && bOp.parent.isAssignment)
+                || (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) => {
+                const parenExpr = ClavaJoinPoints.parenthesis($jp as Expression);
+                bOp.replaceWith(parenExpr);
+            }));
+        }
+    }
+
+    private r12_3_noCommaOperator($startNode: Joinpoint) {
+        Query.searchFrom($startNode, BinaryOp, {operator: ','}).get().forEach(op => {
+            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.");
+            }
+            else {
+                this.logMISRAError(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);
+                }));
+            }
+        }, this);
+    }
+}

package/src/misra/sections/Section13_SideEffects.ts

@@ -0,0 +1,100 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import AnalyserResult from "@specs-feup/clava/api/clava/analysis/AnalyserResult.js";
+import { Program, FileJp, Joinpoint, Varref, Call, QualType, Vardecl, UnaryOp, InitList, BinaryOp } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRAAnalyser from "../MISRAAnalyser.js";
+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>;
+    
+    constructor(rules: number[]) {
+        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)]
+        ]);
+    }
+
+    private checkPotentialPersistentSideEffects<T>($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); 
+            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);
+            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);
+        }, this); 
+    }
+
+    private r13_1_initListSideEffects($startNode: Joinpoint) {
+        this.checkPotentialPersistentSideEffects<Joinpoint>($startNode, InitList, undefined, "Initializer list", jp => jp);
+    }
+
+    private static visitAllExprs(fun: ($jp: Joinpoint) => void, root: Joinpoint) {
+        let curr = root;
+        while (curr) {
+            const temp = curr;
+            //console.log(temp.joinPointType);
+            curr = curr.rightJp;
+            if (temp.instanceOf("expression")) {
+                fun(temp);
+            }
+            else Section13_SideEffects.visitAllExprs(fun, temp.children[0]);
+        }
+    }
+    
+    private checkIncrementSideEffects(exprRoot: Joinpoint) { //something wierd but mostly working if not for duplicates
+        const jps = Query.searchFrom(exprRoot, UnaryOp, {kind: /(post_inc)|(post_dec)|(pre_inc)|(pre_dec)/}, TraversalType.POSTORDER).get();
+        const calls = Query.searchFromInclusive(exprRoot, Call).get();
+        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) => {
+            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();
+
+            const transformationNo = (calls.length === 0 && assignments.length === 0) ? jps.length - 1 : jps.length;
+
+            for (let i = 0; i < transformationNo; i++) {
+                const jp = jps[i];
+                if (/post_.*/.test(jp.kind)) {
+                    $jp.insertAfter(jp.deepCopy());
+                }
+                else {
+                    $jp.insertBefore(jp.deepCopy());
+                }
+                console.log(jp);
+                jp.replaceWith(jp.operand);
+            }
+        }));
+    }
+
+    private r13_3_noIncrementSideEffects($startNode: Joinpoint) {
+        Section13_SideEffects.visitAllExprs(this.checkIncrementSideEffects, $startNode);
+    }
+
+    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.`);
+            }
+        }
+    }
+
+    private r13_5_shortCircuitSideEffects($startNode: Joinpoint) {
+        this.checkPotentialPersistentSideEffects<BinaryOp>($startNode, BinaryOp, {operator: /(\&\&|\|\|)/}, "RHS of && or || expression", jp => jp.right);
+    }
+}

package/src/misra/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<number, (jp: Program | FileJp) => void>;
+
+    constructor(rules: number[]) {
+        super(rules);
+        this.ruleMapper = new Map([
+            [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(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(ifStmt, `Loop controlling expression ${ifStmt.cond.code} does not have essentially boolean type.`);
+            }
+        }, this);
+    }
+}

package/src/misra/sections/Section15_ControlFlow.ts

@@ -0,0 +1,114 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { Program, FileJp, GotoStmt, Joinpoint, LabelStmt, Break } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRAAnalyser from "../MISRAAnalyser.js";
+
+export default class Section15_ControlFlow extends MISRAAnalyser {
+    ruleMapper: Map<number, (jp: Program | FileJp) => void>;
+    
+    constructor(rules: number[]) {
+        super(rules);
+        this.ruleMapper = new Map([
+            [1, this.r15_1_noGoto.bind(this)],
+            [2, this.r15_2_noBackJumps.bind(this)],
+            [3, this.r15_3_gotoBlockEnclosed.bind(this)],
+            [4, this.r15_4_loopSingleBreak.bind(this)]
+        ]);
+    }
+
+    private r15_1_noGoto($startNode: Joinpoint) {
+        Query.searchFrom($startNode, GotoStmt).get().forEach(goto => this.logMISRAError(goto, "goto statements should not be used."), this);
+
+        return [];
+    }
+
+    private static isBeforeInCode(line1: number, col1: number, line2: number, col2: number): boolean {
+        if (line1 < line2) return true;
+        else return col1 < col2;
+    }
+
+    private r15_2_noBackJumps($startNode: Joinpoint) {
+        for (const gotoStmt of Query.searchFrom($startNode, GotoStmt)) {
+            if (!Section15_ControlFlow.isBeforeInCode(gotoStmt.line, gotoStmt.column, gotoStmt.label.line, gotoStmt.label.column)) {
+                this.logMISRAError(gotoStmt, "Back jumps using goto statements are not allowed.");
+            } //maybe there is a better way?
+        }
+    }
+
+    private r15_3_gotoBlockEnclosed($startNode: Joinpoint) { 
+        const labelMap = new Map();
+    
+        Query.searchFrom($startNode, LabelStmt).get().forEach(stmt => labelMap.set(stmt.decl.astId, stmt.astId));
+    
+        for (const gotoStmt of Query.searchFrom($startNode, GotoStmt)) {
+            let curr = gotoStmt.getAncestor("scope");
+            const ancestor = gotoStmt.getAncestor("function");
+            let error = true;
+            let temp;
+    
+            do {
+                temp = curr;
+                if (curr.children.map(n => n.astId).includes(labelMap.get(gotoStmt.label.astId))) {
+                    error = false;
+                    break;
+                }
+                curr = curr.getAncestor("scope");
+            } while (temp.parent.astId !== ancestor.astId);
+    
+            if (error) {
+                this.logMISRAError(gotoStmt, `Label ${gotoStmt.label.name} is not declared in a block enclosing the goto statement.`);
+            }
+        }
+    }
+
+    private static addBreaksToExits($startNode: Joinpoint, exits: Map<string, number>, nodes: Map<string, Joinpoint>) {
+        for (const goto of Query.searchFrom($startNode, Break)) {
+            const ancestor = goto.getAncestor("loop");
+            if (ancestor && exits.has(ancestor.astId)) {
+                exits.set(ancestor.astId, (exits.get(ancestor.astId) ?? 0) + 1);
+            }
+            else if (ancestor) {
+                exits.set(ancestor.astId, 1);
+                nodes.set(ancestor.astId, ancestor);
+            }
+        }
+    }
+    
+    private static addGotosToExits($startNode: Joinpoint, exits: Map<string, number>, nodes: Map<string, Joinpoint>, labels: Map<string, Joinpoint>) {
+        for (const goto of Query.searchFrom($startNode, GotoStmt)) {
+            let ancestor = goto.getAncestor("loop");
+            const labelAncestor = labels.get(goto.label.astId)?.getAncestor("loop");
+    
+            while (ancestor) {
+                if (labelAncestor?.astId === ancestor.astId) break;
+    
+    
+                if (ancestor && exits.has(ancestor.astId)) {
+                    exits.set(ancestor.astId, (exits.get(ancestor.astId) ?? 0) + 1);
+                }
+                else if (ancestor) {
+                    exits.set(ancestor.astId, 1);
+                    nodes.set(ancestor.astId, ancestor);
+                }
+    
+                ancestor = ancestor.getAncestor("loop");
+            }
+        }
+    }
+
+    private r15_4_loopSingleBreak($startNode: Joinpoint) {
+        const labelMap = new Map();
+    
+        Query.searchFrom($startNode, LabelStmt).get().forEach(stmt => labelMap.set(stmt.decl.astId, stmt));
+    
+        const exits = new Map<string, number>();
+        const nodes = new Map<string, Joinpoint>();
+        Section15_ControlFlow.addBreaksToExits($startNode, exits, nodes);
+        Section15_ControlFlow.addGotosToExits($startNode, exits, nodes, labelMap);
+    
+        exits.forEach((v, k, m) => {
+            if (v > 1) {
+                this.logMISRAError(nodes.get(k) as Joinpoint, "Loops should have at most one break/goto statement.")
+            }
+        }, this);
+    }
+}

package/src/misra/sections/Section16_SwitchStatements.ts

@@ -0,0 +1,154 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { Program, FileJp, Switch, Break, Case, Joinpoint, BuiltinType, BoolLiteral, Expression } 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 default class Section16_SwitchStatements extends MISRAAnalyser {
+    ruleMapper: Map<number, (jp: Program | FileJp) => void>;
+
+    constructor(rules: number[]) {
+        super(rules);
+        this.ruleMapper = new Map([
+            [1, this.r16_1_16_3_wellFormedSwitch.bind(this)],
+            [2, this.r16_2_topLevelSwitchLabels.bind(this)],
+            [4, this.r16_4_switchHasDefault.bind(this)],
+            [5, this.r16_5_defaultFirstOrLast.bind(this)],
+            [7, this.r16_7_noEssentialBooleanInSwitch.bind(this)]
+        ]);
+    }
+
+    private r16_1_16_3_wellFormedSwitch($startNode: Joinpoint) {
+        for (const switchStmt of Query.searchFrom($startNode, Switch)) {
+    
+            let foundStmt = false;
+            let first = true;
+            for (const child of switchStmt.children[1].children) {
+                if (child instanceof Break) {;
+                    foundStmt = false;
+                }
+                else if (child instanceof Case) {
+                    first = false;
+                }
+                else {
+                    foundStmt = true;
+                }
+    
+                if (foundStmt && child.instanceOf("case")) {
+                    this.logMISRAError(child, `A break is missing before ${child.code}`);
+                }
+            }
+            if (!switchStmt.children[1].lastChild.instanceOf("break")) {
+                this.logMISRAError(switchStmt.children[1].lastChild, "A break is missing at the end of the switch statement.");
+            }
+        }   
+    }
+
+    private r16_2_topLevelSwitchLabels($startNode: Joinpoint) {
+        Query.searchFrom($startNode, Case).get().forEach(caseLabel => {
+            if (!caseLabel.currentRegion.instanceOf("switch")) {
+                this.logMISRAError(caseLabel, "A switch label can only be used if its enclosing compound statement is the switch statement itself.")
+            }
+        }, this);
+    }
+
+    private r16_4_switchHasDefault($startNode: Joinpoint) {
+        Query.searchFrom($startNode, Switch, {hasDefaultCase: false}).get().forEach(sw => this.logMISRAError(sw, "Switch statement is missing a default case."), this);
+    }
+    
+
+    private r16_5_defaultFirstOrLast($startNode: Joinpoint) {
+        Query.searchFrom($startNode, Switch).get().forEach(switchStmt => {
+            for (let i = 0; i < switchStmt.cases.length; i++) {
+                if (switchStmt.cases[i].isDefault && (i == 0 || i == switchStmt.cases.length)) {
+                    return;
+                }
+                else if (switchStmt.cases[i].isDefault) {
+                    this.logMISRAError(switchStmt, "The default case of a switch statement must be the first or last label.");
+                    return;
+                }
+            }
+        }, this);
+    }
+
+    private r16_6_noTwoClauses($startNode: Joinpoint) {
+        Query.searchFrom($startNode, Switch).get().forEach(switchStmt => {
+            let clauses = 0;
+            let foundStmt = false;
+            for (const child of switchStmt.children[1].children) {
+                if (child instanceof Case && foundStmt) {
+                    clauses++;
+                    foundStmt = false;
+                }
+                else if (child instanceof Break) {
+                    clauses++;
+                    foundStmt = false;
+                }
+                else {
+                    foundStmt = true;
+                }
+            }
+
+            if (clauses == 2) {
+                this.logMISRAError(switchStmt, "Switch statements should have more than two clauses.", new Fix(
+                    switchStmt,
+                    (switchStmt: Joinpoint) => {
+                        let firstClauseExpr: Expression;
+                        let secondClauseExpr: Expression;
+                        let firstClause: Joinpoint[] = [];
+                        let secondClause: Joinpoint[] = []
+                        for (const child of switchStmt.children[1].children) {
+                             
+                        }
+                    }
+                ));
+            }
+        }, this);
+    }
+
+    private r16_7_noEssentialBooleanInSwitch($startNode: Joinpoint) { //is this the best way?
+        Query.searchFrom($startNode, Switch).get().forEach(switchStmt => {
+            if (switchStmt.condition.type instanceof BuiltinType && switchStmt.condition.type.builtinKind === "Bool") {
+                this.logMISRAError(switchStmt, `Switch statement controlling expression ${switchStmt.condition.code} must not have essentially boolean type.`, new Fix(
+                    switchStmt,
+                    (switchStmt) => {
+                        const trueClause: Joinpoint[] = [];
+                        const falseClause: Joinpoint[] = [];
+                        let inTrue: boolean = false;
+                        let inFalse: boolean = false;
+                        for (const child of switchStmt.children[1].children) {
+                            if (child instanceof Case && child.values.length == 1 && child.values[0].children[0] instanceof BoolLiteral && child.values[0].children[0].value) {
+                                inTrue = true;
+                                inFalse = false;
+                            }
+                            else if (child instanceof Case && child.values.length == 1 && child.values[0].children[0] instanceof BoolLiteral && !child.values[0].children[0].value) {
+                                inFalse = true;
+                                inTrue = false;
+                            }
+                            else if (child instanceof Break) {
+                                inTrue = false;
+                                inFalse = false;
+                            }
+
+                            if (inTrue && !(child instanceof Case)) {
+                                trueClause.push(child.deepCopy());
+                            }
+                            else if (inFalse && !(child instanceof Case)) {
+                                falseClause.push(child.deepCopy());
+                            }
+                        }
+
+                        const ifStmt = ClavaJoinPoints.ifStmt(
+                            (switchStmt as Switch).condition,
+                            ClavaJoinPoints.scope(...trueClause),
+                            ClavaJoinPoints.scope(...falseClause)
+                        );
+
+                        switchStmt.replaceWith(ifStmt);
+                    }
+                ));
+            }
+        }, this);
+    }
+    
+}

package/src/misra/sections/Section17_Functions.ts

@@ -0,0 +1,33 @@
+import { Program, FileJp, Joinpoint, Include, Call, BuiltinType, ExprStmt } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRAAnalyser from "../MISRAAnalyser.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import Fix from "@specs-feup/clava/api/clava/analysis/Fix.js";
+import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
+
+export default class Section17_Functions extends MISRAAnalyser {
+    protected ruleMapper: Map<number, (jp: Program | FileJp) => void>;
+    
+    constructor(rules: number[]) {
+        super(rules);
+        this.ruleMapper = new Map([
+            [1, this.r17_1_noStdargUsage.bind(this)],
+            [7, this.r17_7_returnValuesAreUsed.bind(this)]
+        ]);
+    }
+
+    private r17_1_noStdargUsage($startNode: Joinpoint) {
+        Query.searchFrom($startNode, Include, {name: "stdarg.h", isAngled: true}).get().forEach(include => this.logMISRAError(include, "Use of <stdarg.h> is not allowed."), this);
+    }
+
+    private r17_7_returnValuesAreUsed($startNode: Joinpoint) {
+        Query.searchFrom($startNode, Call, {returnType: (type) => !(type instanceof BuiltinType && type.isVoid)}).get().forEach(call => {
+            console.log(call.parent);
+            if (call.parent instanceof ExprStmt) {
+                this.logMISRAError(call, `Return value of ${call.signature} must be used. It can be discarded with an explicit cast to void.`, new Fix(call, ($jp) => {
+                    const newJp = ClavaJoinPoints.cStyleCast(ClavaJoinPoints.type("void"), $jp.deepCopy() as Call);
+                    $jp.replaceWith(newJp);
+                }));
+            }
+        }, this);
+    }
+}