@specs-feup/clava-misra 1.0.0 → 1.0.2

package/src/rules/Section17_Functions/Rule_17_6_StaticArraySizeParam.ts

@@ -0,0 +1,68 @@
+import { AdjustedType, ArrayType, FunctionJp, Joinpoint, Param } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRARule from "../../MISRARule.js";
+import MISRAContext from "../../MISRAContext.js";
+import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
+import { MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import { getParamReferences } from "../../utils/utils.js";
+
+/**
+ * MISRA Rule 17.6: The declaration of an array parameter shall not contain the static keyword between the [ ]
+ */
+export default class Rule_17_6_StaticArraySizeParam extends MISRARule {
+    #invalidParams: Param[] = [];
+    constructor(context: MISRAContext) {
+        super("17.6", context);
+    }
+
+    /**
+     * Checks if the given joinpoint represents a function with any array parameter containing the 'static' keyword between the [ ].
+     * 
+     * @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 FunctionJp) || $jp.root.standard === "c90") return false;
+
+        this.#invalidParams = $jp.params.filter(paramJp => paramJp.type instanceof AdjustedType &&
+            paramJp.type.originalType instanceof ArrayType &&
+            paramJp.type.originalType.arraySize !== -1 &&
+            /\[\s*static\s+\d+\s*\]/.test(paramJp.code)
+        );
+
+        if (logErrors) {
+            for (const invalidParam of this.#invalidParams) {
+                this.logMISRAError(invalidParam, `The 'static' keyword cannot appear inside the square brackets ('[]') in array parameter declarations.`)
+            }
+        }
+        return this.#invalidParams.length > 0;
+    }
+
+    /**
+     * Transforms the joinpoint if it represents a function with any array parameter containing the 'static' keyword between the square brackets.
+     * 
+     * @param $jp - Joinpoint to transform
+     * @returns Report detailing the transformation result
+     */
+    transform($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp)) return new MISRATransformationReport(MISRATransformationType.NoChange);
+        
+        for (const invalidParam of this.#invalidParams) {
+            const paramRefs = getParamReferences(invalidParam, $jp);
+
+            // Replace the parameter with a new array parameter whose size is variant
+            const originalType = (invalidParam.type as AdjustedType).originalType;
+            const newJp = ClavaJoinPoints.param(
+                invalidParam.name, 
+                ClavaJoinPoints.incompleteArrayType((originalType as ArrayType).elementType)
+            );            
+            const newParam = invalidParam.replaceWith(newJp) as Param;
+
+            // Replace all references to the invalid parameter with the new one
+            for (const ref of paramRefs) {
+                ref.replaceWith(newParam.varref());
+            }
+        }
+        return new MISRATransformationReport(MISRATransformationType.DescendantChange);
+    }
+}

package/src/rules/Section17_Functions/Rule_17_7_UnusedReturnValue.ts

@@ -0,0 +1,49 @@
+import { BuiltinType, Call, ExprStmt, Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRARule from "../../MISRARule.js";
+import MISRAContext from "../../MISRAContext.js";
+import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
+import { MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import { isCallToImplicitFunction } from "../../utils/utils.js";
+
+/**
+ * MISRA Rule 17.7: The value returned by a function having non-void return type shall be
+used
+ */
+export default class Rule_17_7_UnusedReturnValue extends MISRARule {
+    constructor(context: MISRAContext) {
+        super("17.7", context);
+    }
+
+    /**
+     * Checks if the given joinpoint represents a non-void function call with an unused return value.
+     * 
+     * @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 Call)) return false;
+
+        if ($jp.returnType instanceof BuiltinType && $jp.returnType.isVoid) return false;
+
+        if ($jp.parent instanceof ExprStmt && logErrors) {
+            this.logMISRAError($jp,`Return value of ${$jp.signature} must be used. It can be discarded with an explicit cast to void.`);
+        }
+        return $jp.parent instanceof ExprStmt;
+    }
+
+    /**
+     * Transforms the joinpoint if it represents a non-void function call, whose return type is unused. 
+     * It ensures that the return value is explicitly cast to void.
+     * 
+     * @param $jp - Joinpoint to transform
+     * @returns Report detailing the transformation result
+     */
+    transform($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp)) return new MISRATransformationReport(MISRATransformationType.NoChange);
+        
+        const callJp = $jp as Call;
+        const newJp =  ClavaJoinPoints.cStyleCast(ClavaJoinPoints.type("void"), callJp);
+        return new MISRATransformationReport(MISRATransformationType.Replacement, $jp.replaceWith(newJp));
+    }
+}

package/src/rules/Section20-PreprocessingDirectives/Rule_20_2_InvalidHeaderFileName.ts

@@ -0,0 +1,120 @@
+import { FileJp, Include, Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRARule from "../../MISRARule.js";
+import MISRAContext from "../../MISRAContext.js";
+import { MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import * as path from 'path';
+
+/**
+ * MISRA Rule 20.2: The ', " or \ characters and the /* or // character sequences shall not occur in a header filename
+ */
+export default class Rule_20_2_InvalidHeaderFileName extends MISRARule {
+    constructor(context: MISRAContext) {
+        super("20.2", context);
+    }
+
+    /**
+     * Checks if the given joinpoint is a header file whose name includes invalid characters.
+     * 
+     * @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 FileJp && $jp.isHeader)) return false;
+
+        const isNonCompliant = /.*('|"|\\|\/\*|\/\/).*/.test($jp.name);
+        if (isNonCompliant && logErrors) {
+            this.logMISRAError($jp, `Invalid characters in header filename. Invalid characters are ', ", \\, and the sequences /* and //.`)
+        }
+        return isNonCompliant;
+    }
+
+    /**
+     * Renames a header file to ensure it contains only valid characters and updates all related includes accordingly.
+     * 
+     * @param $jp - Joinpoint to transform
+     * @returns Report detailing the transformation result
+     */
+    transform($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp)) {
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
+        }
+    
+        const fileJp = $jp as FileJp;
+        const includesOfHeader = this.getMatchingIncludes(fileJp);
+        const newFilename = this.context.generateHeaderFilename();
+    
+        fileJp.setName(newFilename);
+        this.updateIncludes(includesOfHeader, newFilename);
+        return new MISRATransformationReport(MISRATransformationType.DescendantChange);
+    }
+    
+    /**
+     * Finds all include joinpoints that reference a specific header file 
+     * 
+     * @param headerFileJp - The header file joinpoint
+     * @returns List of matching include statements
+     */
+    private getMatchingIncludes(headerFileJp: FileJp): Include[] {
+        return Query.search(Include).get().filter(includeJp =>
+            path.basename(includeJp.name) === headerFileJp.name &&
+            this.getHeaderFilePath(includeJp) === headerFileJp.path);
+    }
+    
+    /**
+     *  Computes the full path to the header file based on the include statement
+     * 
+     * @param includeJp The include joinpoint
+     * @returns Resolved path to the header file
+     */
+    private getHeaderFilePath(includeJp: Include): string {
+        try {
+            if (includeJp.name.startsWith("../")) {
+                return includeJp.relativeFolderpath;
+            } else { 
+                const relativeDir = path.dirname(includeJp.name);
+                const fileJp = includeJp.getAncestor("file") as FileJp | undefined;
+                return path.resolve(fileJp!.path, relativeDir);
+            }
+        } catch (error) {
+            return "";
+        }
+    }
+
+    /**
+     * Updates the provided include joinpoints to reference the new header file name
+     * 
+     * @param includesOfHeader List of include joinpoints to update
+     * @param newFilename The new filename for the header file
+     */
+    private updateIncludes(includesOfHeader: Include[], newFilename: string): void {
+        for (const includeJp of includesOfHeader) {
+            const fileJp = includeJp.getAncestor("file") as FileJp | undefined;
+    
+            const newIncludeJpName = this.getNewIncludeName(includeJp, newFilename);
+            fileJp!.addInclude(newIncludeJpName);
+    
+            const tempInclude = Query.searchFrom(fileJp!, Include, {name: includeName => path.normalize(includeName) === newIncludeJpName}).first();
+    
+            if (tempInclude) {
+                includeJp.replaceWith(tempInclude.deepCopy());
+                tempInclude.detach();
+            }
+        }
+    }
+    
+    /**
+     * Computes the new include path with the updated header file name
+     * 
+     * @param includeJp - Original include statement
+     * @param newHeaderFileName - New header file name
+     * @returns The updated include path
+     */
+    private getNewIncludeName(includeJp: Include, newHeaderFileName: string): string {
+        const isFile = path.extname(includeJp.name) !== '';
+        const baseDir = isFile ? path.dirname(includeJp.name) : includeJp.name;
+
+        return path.join(baseDir, newHeaderFileName);
+    }
+}

package/src/rules/Section2_UnusedCode/Rule_2_3_UnusedTypeDecl.ts

@@ -0,0 +1,78 @@
+import { EnumDecl, Joinpoint,RecordJp,TypedefDecl, TypedefType } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRARule from "../../MISRARule.js";
+import MISRAContext from "../../MISRAContext.js";
+import { MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import { getBaseType, getTagUses, getTypeDecl, getTypedJps } from "../../utils/utils.js";
+
+/**
+ * MISRA-C Rule 2.3: A project should not contain unused type declarations.
+ */
+export default class Rule_2_3_UnusedTypeDecl extends MISRARule {
+    priority = 3;
+
+    constructor(context: MISRAContext) {
+        super("2.3", context);
+    }
+
+    /**
+     * Checks if a given joinpoint uses the specified typedef declaration.
+     * @param jp - The joinpoint to check
+     * @param typeDecl - The typedef declaration to check against
+     * @returns Returns true if the joinpoint uses the given typedef declaration, false otherwise
+     */
+    private isTypedefUsed(jp: Joinpoint, typeDecl: TypedefDecl): boolean {
+        const jpType = getBaseType(jp);
+        return !jpType?.isBuiltin && jpType instanceof TypedefType && jpType.decl.astId === typeDecl.astId;
+    }
+
+    /**
+     * Retrieves all joinpoints that use the specified typedef declaration
+     * 
+     * @param typeDecl - The typedef declaration to search for in the joinpoints
+     * @returns Array of joinpoints that use the given typedef declaration
+     */
+    private getTypeDefUses(typeDecl: TypedefDecl): Joinpoint[] {
+        return getTypedJps().filter(jp => this.isTypedefUsed(jp, typeDecl));
+    }
+
+    /**
+     * Checks if the given joinpoint represents an unused type declaration
+     * @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 {
+        const typeDecl = getTypeDecl($jp);
+        if (typeDecl === undefined) return false;
+
+        const isUnused = this.getTypeDefUses(typeDecl).length === 0;
+        if (logErrors && isUnused) {
+            this.logMISRAError($jp, `Type declaration ${typeDecl.name} is declared but not used.`)
+        }
+        return isUnused;
+    }
+    
+    /**
+     * Transforms the joinpoint if it represents an unused type declaration
+     * 
+     * - If the joinpoint defines a tag (named struct, enum or union) that is referenced elsewhere in the code,
+     *  the joinpoint is replaced by the tag
+     * - Otherwise, the joinpoint is simply removed from the AST
+     * 
+     * @param $jp - Joinpoint to transform
+     * @returns Report detailing the transformation result
+     */
+    transform($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp)) 
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
+
+        if (($jp instanceof RecordJp || $jp instanceof EnumDecl) && $jp.name && getTagUses($jp).length > 0) { 
+            $jp.lastChild.detach();
+            return new MISRATransformationReport(MISRATransformationType.DescendantChange);
+        } else {
+            $jp.detach();
+            return new MISRATransformationReport(MISRATransformationType.Removal);
+        }
+
+    }
+}

package/src/rules/Section2_UnusedCode/Rule_2_4_UnusedTagDecl.ts

@@ -0,0 +1,61 @@
+import { Joinpoint, RecordJp, EnumDecl, TagType, ElaboratedType } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRARule from "../../MISRARule.js";
+import MISRAContext from "../../MISRAContext.js";
+import { MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import { getTagUses, hasTypeDecl } from "../../utils/utils.js";
+
+/**
+ * MISRA-C Rule 2.4: A project should not contain unused tag declarations.
+ */
+export default class Rule_2_4_UnusedTagDecl extends MISRARule {
+    priority = 3; 
+    
+    constructor(context: MISRAContext) {
+        super("2.4", context);
+    }
+
+    /**
+     * Checks if the given joinpoint is an unused tag declaration
+     * A tag is considered to be unused if it has no references in the code or is only used within a typedef
+     * 
+     * @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 RecordJp || $jp instanceof EnumDecl)) return false;
+
+        const containsTypeDecl = hasTypeDecl($jp);
+        const jpName = $jp.name;
+        if (containsTypeDecl && jpName === undefined || jpName === null || (jpName as string).trim().length === 0) {
+            return false;
+        }
+
+        const isUnused = getTagUses($jp).length === 0;
+        if (isUnused && logErrors) {
+            this.logMISRAError($jp, 
+                containsTypeDecl ? `The tag '${$jp.name}' is declared but only used in a typedef.` : `The tag '${$jp.name}' is declared but not used.`);
+        }
+        return isUnused;
+    }
+    
+    /**
+     * Transforms the joinpoint if it is an unused tag declaration
+     * - If the joinpoint is a tag declared in a typedef, it removes the name. 
+     * - Otherwise, the joinpoint is detached.
+     * 
+     * @param $jp - Joinpoint to transform
+     * @returns Report detailing the transformation result
+     */
+    transform($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp)) 
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
+        
+        if (hasTypeDecl($jp)) {
+            ($jp as RecordJp | EnumDecl).setName('');
+            return new MISRATransformationReport(MISRATransformationType.DescendantChange);
+        }
+        $jp.detach();
+        return new MISRATransformationReport(MISRATransformationType.Removal);
+    }
+}

package/src/rules/Section2_UnusedCode/Rule_2_6_UnusedLabels.ts

@@ -0,0 +1,47 @@
+import { GotoStmt, FunctionJp, Joinpoint, LabelStmt } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRARule from "../../MISRARule.js";
+import MISRAContext from "../../MISRAContext.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+
+/**
+ * Rule 2.6: Unused Labels. 
+ *  Checks for labels within a function that are not used.
+ */
+export default class Rule_2_6_UnusedLabels extends MISRARule {
+    priority = 3; 
+    
+    constructor(context: MISRAContext) {
+        super("2.6", context);
+    }
+
+    private getUnusedLabels(func: FunctionJp): LabelStmt[] {
+        return Query.searchFrom(func, LabelStmt).get().filter(label => 
+            Query.searchFrom(func, GotoStmt, { label: jp => jp.astId === label.decl.astId }).get().length === 0
+        );
+    }
+
+    match($jp: Joinpoint, logErrors: boolean = false): boolean {
+        if (!($jp instanceof FunctionJp)) 
+            return false;
+
+        const unusedLabels = this.getUnusedLabels($jp);
+        if (logErrors) {
+            unusedLabels.forEach(label => 
+                this.logMISRAError(label, `Label ${label.decl.name} is unused in function ${$jp.name}.`)
+            )
+        }
+        return unusedLabels.length > 0;
+    }
+    
+    transform($jp: Joinpoint): MISRATransformationReport {
+        if(!this.match($jp)) 
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
+
+        const unusedLabels = this.getUnusedLabels($jp as FunctionJp);
+        for (const label of unusedLabels) {
+            label.detach();
+        }
+        return new MISRATransformationReport(MISRATransformationType.DescendantChange);
+    }
+}

package/src/rules/Section2_UnusedCode/Rule_2_7_UnusedParameters.ts

@@ -0,0 +1,67 @@
+import { FunctionJp, Joinpoint, Param, Varref, Call } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRARule from "../../MISRARule.js";
+import MISRAContext from "../../MISRAContext.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import { getParamReferences } from "../../utils/utils.js";
+import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
+
+export default class Rule_2_7_UnusedParameters extends MISRARule {
+    priority = 3; 
+
+    constructor(context: MISRAContext) {
+        super("2.7", context);
+    }
+
+    private getUnusedParams(func: FunctionJp): Param[] {
+        return func.params.filter(param => getParamReferences(param, func).length === 0);
+    }    
+
+    private getUsedParams(func: FunctionJp): Param[] {
+        return func.params.filter(param => getParamReferences(param, func).length > 0);
+    }
+
+    private getUsedParamsPositions(func: FunctionJp): number[] {
+        let result = [];
+        for (let i = 0; i < func.params.length; i++) {
+            const param = func.params[i];
+            if (Query.searchFrom(func, Varref, { decl: jp => jp?.astId === param.astId }).get().length > 0) {
+                result.push(i);
+            }
+        }
+        return result;
+    }   
+
+    match($jp: Joinpoint, logErrors: boolean = false): boolean {
+        if (!($jp instanceof FunctionJp && $jp.isImplementation)) return false;
+
+        const unusedParams = this.getUnusedParams($jp);
+        if (logErrors) {
+            unusedParams.forEach(param => 
+                this.logMISRAError(param, `Parameter '${param.name}' is unused in function ${$jp.name}.`)
+            )
+        }
+        return unusedParams.length > 0;
+    }
+    
+    transform($jp: Joinpoint): MISRATransformationReport {
+        if(!this.match($jp)) return new MISRATransformationReport(MISRATransformationType.NoChange);
+
+        const functionJp = $jp as FunctionJp;
+        const usedParams = this.getUsedParams(functionJp);
+        const usedParamsPositions = this.getUsedParamsPositions(functionJp);
+        const calls = Query.search(Call, {function: jp => jp.astId === $jp.astId}).get();
+        
+        functionJp.setParams(usedParams);
+        for (const funcDecl of functionJp.declarationJps) {
+            funcDecl.setParams(usedParams);
+        }
+
+        for (const call of calls) {
+            const newArgs = usedParamsPositions.map(i => call.args[i]);
+            const newCall = functionJp.newCall(newArgs)
+            call.replaceWith(newCall);
+        }
+        return new MISRATransformationReport(MISRATransformationType.DescendantChange);
+    }
+}

package/src/rules/Section3_Comments/Rule_3_1_CommentSequences.ts

@@ -0,0 +1,41 @@
+import { Comment, Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRARule from "../../MISRARule.js";
+import MISRAContext from "../../MISRAContext.js";
+import { isInlineComment, getComments } from "../../utils/utils.js";
+import { MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+
+/**
+ * MISRA Rule 3.1: 
+ */
+export default class Rule_3_1_CommentSequences extends MISRARule {
+
+    constructor(context: MISRAContext) {
+        super("3.1", context);
+    }
+
+    match($jp: Joinpoint, logErrors: boolean = false): boolean {
+        const invalidComments = getComments($jp).filter(comment => 
+            (isInlineComment(comment) && /(\/\*)/g.test(comment.text)) ||
+            (!isInlineComment(comment) && /(\/\/|\/\*)/g.test(comment.text)));
+
+        if (logErrors) {
+            invalidComments.forEach(comment =>
+                this.logMISRAError(comment, `Comment \'${comment.text}\' contains invalid character sequences.`)
+            )
+        }
+        return invalidComments.length > 0;
+    }
+
+    transform($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp)) 
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
+
+        const comments = getComments($jp);
+        for (const comment of comments) {
+            const invalidSymbols = isInlineComment(comment) ? /(\/\*)/g : /(\/\/|\/\*)/g;
+            const newText = comment.text.replace(invalidSymbols, '');
+            comment.setText(newText);
+        }
+        return new MISRATransformationReport(MISRATransformationType.DescendantChange);;
+    }
+}

package/src/rules/Section3_Comments/Rule_3_2_LineSplicing.ts

@@ -0,0 +1,36 @@
+import { Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRARule from "../../MISRARule.js";
+import MISRAContext from "../../MISRAContext.js";
+import { isInlineComment, getComments } from "../../utils/utils.js";
+import { MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+
+export default class Rule_3_2_LineSplicing extends MISRARule {
+    
+    constructor(context: MISRAContext) {
+        super("3.2", context);
+    }
+
+    match($jp: Joinpoint, logErrors: boolean = false): boolean {
+        const invalidComments = getComments($jp).filter(comment => 
+            (isInlineComment(comment) && /\/\n/g.test(comment.text)));
+
+        if (logErrors) {
+            invalidComments.forEach(comment =>
+                this.logMISRAError(comment, `Comment ${comment.text} contains invalid character sequences.`)
+            )
+        }
+        return invalidComments.length > 0;
+    }
+
+    transform($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp))
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
+
+        const comments = getComments($jp);
+        for (const comment of comments) {
+            const newText = comment.text.replace(/\/\n/g, '');
+            comment.setText(newText);
+        }
+        return new MISRATransformationReport(MISRATransformationType.DescendantChange);
+    }
+}

package/src/rules/index.ts

@@ -0,0 +1,44 @@
+import MISRAContext from "../MISRAContext.js";
+import MISRARule from "../MISRARule.js";
+import Rule_16_2_TopLevelSwitch from "./Section16_SwitchStatements/Rule_16_2_TopLevelSwitch.js";
+import Rule_16_3_UnconditionalBreak from "./Section16_SwitchStatements/Rule_16_3_UnconditionalBreak.js";
+import Rule_16_4_SwitchHasDefault from "./Section16_SwitchStatements/Rule_16_4_SwitchHasDefault.js";
+import Rule_16_5_DefaultFirstOrLast from "./Section16_SwitchStatements/Rule_16_5_DefaultFirstOrLast.js";
+import Rule_16_6_SwitchMinTwoClauses from "./Section16_SwitchStatements/Rule_16_6_SwitchMinTwoClauses.js";
+import Rule_16_7_NonBooleanSwitchCondition from "./Section16_SwitchStatements/Rule_16_7_NonBooleanSwitchCondition.js";
+import Rule_17_3_ImplicitFunction from "./Section17_Functions/Rule_17_3_ImplicitFunction.js";
+import Rule_17_4_NonVoidReturn from "./Section17_Functions/Rule_17_4_NonVoidReturn.js";
+import Rule_17_6_StaticArraySizeParam from "./Section17_Functions/Rule_17_6_StaticArraySizeParam.js";
+import Rule_17_7_UnusedReturnValue from "./Section17_Functions/Rule_17_7_UnusedReturnValue.js";
+import Rule_2_3_UnusedTypeDecl from "./Section2_UnusedCode/Rule_2_3_UnusedTypeDecl.js";
+import Rule_2_4_UnusedTagDecl from "./Section2_UnusedCode/Rule_2_4_UnusedTagDecl.js";
+import Rule_2_6_UnusedLabels from "./Section2_UnusedCode/Rule_2_6_UnusedLabels.js";
+import Rule_2_7_UnusedParameters from "./Section2_UnusedCode/Rule_2_7_UnusedParameters.js";
+import Rule_3_1_CommentSequences from "./Section3_Comments/Rule_3_1_CommentSequences.js";
+import Rule_3_2_CommentSequences from "./Section3_Comments/Rule_3_2_LineSplicing.js";
+
+export function sortRules(context: MISRAContext) {
+     
+    const rules: MISRARule[] = [
+        new Rule_2_3_UnusedTypeDecl(context),
+        new Rule_2_4_UnusedTagDecl(context),
+        new Rule_2_6_UnusedLabels(context),
+        new Rule_2_7_UnusedParameters(context),
+        new Rule_3_1_CommentSequences(context),
+        new Rule_3_2_CommentSequences(context),
+        new Rule_16_2_TopLevelSwitch(context),
+        new Rule_16_3_UnconditionalBreak(context),
+        new Rule_16_4_SwitchHasDefault(context),
+        new Rule_16_5_DefaultFirstOrLast(context),
+        new Rule_16_6_SwitchMinTwoClauses(context),
+        new Rule_16_7_NonBooleanSwitchCondition(context), 
+        new Rule_17_3_ImplicitFunction(context),
+        new Rule_17_4_NonVoidReturn(context),
+        new Rule_17_6_StaticArraySizeParam(context),
+        new Rule_17_7_UnusedReturnValue(context),
+    ];
+
+    return rules.sort((ruleA, ruleB) => ruleA.priority - ruleB.priority);
+}
+
+export default sortRules;

package/src/tests/Section16_SwitchStatements/Rule_16_2_TopLevelSwitch.test.ts

@@ -0,0 +1,55 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestFile } from "../utils.js";
+import { FileJp } from "@specs-feup/clava/api/Joinpoints.js";
+
+const passingCode = 
+`void foo1( void ) {
+    int x, y;
+    switch ( x )
+    {
+        case 1: 
+            if ( y == 1 ) {
+                x = 1;
+            }
+            break;
+        default:
+            break;
+    }
+}`;
+
+const failingCode = 
+`void foo2( void ) {
+    int x, y;
+    switch ( x )
+    {
+        case 1: /* Compliant */
+            if ( y == 1 )
+            {
+                case 2: /* Non-compliant */
+                x = 1;
+            }
+            break;
+        default:
+            break;
+    }
+}`;
+
+const files: TestFile[] = [
+    { name: "bad.c", code: failingCode },
+    { name: "good.c", code: passingCode }
+];
+
+describe("Rule 16.2", () => {
+    registerSourceCode(files);
+
+    it("should detect errors in bad.c", () => {
+        expect(countMISRAErrors()).toBe(1);
+
+        expect(countMISRAErrors(Query.search(FileJp, {name: "bad.c"}).first()!)).toBe(1);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "good.c"}).first()!)).toBe(0);
+    });
+
+    it("should correct errors in bad.c", () => {
+        expect(countErrorsAfterCorrection()).toBe(0);
+    });
+});