@specs-feup/clava-misra 1.0.2 → 1.0.4

package/src/rules/Section5_Identifiers/Rule_5_9_UniqueInternalLinkIdentifiers.ts

@@ -0,0 +1,47 @@
+import {Joinpoint, Program} from "@specs-feup/clava/api/Joinpoints.js";
+import { getIdentifierDecls, getInternalLinkageIdentifiers } from "../../utils/ProgramUtils.js";
+import { getIdentifierName, isIdentifierDuplicated, isIdentifierNameDeclaredBefore, isInternalLinkageIdentifier } from "../../utils/IdentifierUtils.js";
+import IdentifierRenameRule from "./IdentifierRenameRule.js";
+import { AnalysisType } from "../../MISRA.js";
+
+/**
+ * MISRA-C Rule 5.9: Identifiers that define objects or functions with internal linkage should be unique
+ */
+export default class Rule_5_9_UniqueInternalLinkIdentifiers extends IdentifierRenameRule {
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SYSTEM;
+
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "5.9";
+    }
+
+    /**
+     * 
+     * @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 Program)) return false;
+
+        const internalLinkageIdentifiers = getInternalLinkageIdentifiers();
+        this.invalidIdentifiers = getIdentifierDecls().filter((identifierJp) => 
+            isInternalLinkageIdentifier(identifierJp) ? 
+                isIdentifierNameDeclaredBefore(identifierJp, internalLinkageIdentifiers) :
+                isIdentifierDuplicated(identifierJp, internalLinkageIdentifiers)
+        );
+        
+        const nonCompliant = this.invalidIdentifiers.length > 0;
+        if (nonCompliant && logErrors) {
+            this.invalidIdentifiers.forEach(identifierJp => {
+                this.logMISRAError(identifierJp, `Identifier '${getIdentifierName(identifierJp)}' is already defined with internal linkage in this or other file.`);
+            })
+        }
+        return nonCompliant;
+    }
+}

package/src/rules/Section8_DeclarationsAndDefinitions/Rule_8_6_SingleExternalDefinition.ts

@@ -0,0 +1,118 @@
+import { FileJp, Joinpoint, Program, StorageClass, Vardecl } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRARule from "../../MISRARule.js";
+import { AnalysisType, MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import { getIdentifierName } from "../../utils/IdentifierUtils.js";
+import { getExternalLinkageVars, resetCaches, resetExternalVarRefs } from "../../utils/ProgramUtils.js";
+import { compareLocation } from "../../utils/JoinpointUtils.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { isSameVarDecl } from "../../utils/VarUtils.js";
+
+/**
+ * MISRA-C Rule 8.6: An identifier with external linkage shall have exactly one external definition
+ */
+export default class Rule_8_6_SingleExternalDefinition extends MISRARule {
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SYSTEM;
+
+    /**
+     * A positive integer starting from 1 that indicates the rule's priority, determining the order in which rules are applied.
+     */
+    readonly priority = 2; 
+    
+    #invalidDecls: Vardecl[] = [];
+
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "8.6";
+    }
+
+    /**
+     * 
+     * @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 Program)) {
+            return false;
+        } 
+
+        const externalLinkageVars = getExternalLinkageVars();
+        this.#invalidDecls = externalLinkageVars.filter((decl1) =>
+          externalLinkageVars.some((decl2) =>
+                isSameVarDecl(decl1, decl2) &&
+                decl1.getAncestor("file").ast !== decl2.getAncestor("file").ast &&
+                compareLocation(decl2, decl1) < 0
+            )
+        );
+
+        const nonCompliant = this.#invalidDecls.length > 0;
+        if (nonCompliant && logErrors) {
+            this.#invalidDecls.forEach(identifierJp => {
+                this.logMISRAError(identifierJp, `Identifier '${getIdentifierName(identifierJp)}' with external linkage is defined in multiple files.`)
+            });
+        }
+        return nonCompliant;
+    }
+
+    /**
+     * 
+     * @param $jp - Joinpoint to transform
+     * @returns Report detailing the transformation result
+     */
+    apply($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp)) {
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
+        } 
+
+        let solved = false;
+        const uniqueDecls = this.#invalidDecls.reduce((acc: Vardecl[], decl1) => acc.some(decl2 => isSameVarDecl(decl1, decl2)) ? acc : [...acc, decl1], []);
+
+        for (const decl of uniqueDecls) {
+            if (this.context.getRuleResult(this.ruleID, decl) === MISRATransformationType.NoChange) {
+                continue;
+            }
+
+            const filesWithInitialization = Query.search(FileJp, (fileJp) => {
+              return fileJp.descendants.some((jp) => 
+                isSameVarDecl(jp, decl) && (jp as Vardecl).init !== undefined
+              );
+            }).get();
+
+            if (filesWithInitialization.length > 1) {
+                
+                const other = this.#invalidDecls.filter(identifier => isSameVarDecl(identifier, decl));
+                for (const varDecl of other) {
+                    this.logMISRAError(varDecl, `Identifier '${getIdentifierName(varDecl)}' with external linkage has multiple definitions across files. Automatic correction cannot be applied due to multiple initializations.`);
+                    this.context.addRuleResult(this.ruleID, varDecl, MISRATransformationType.NoChange);
+                }
+            } 
+            else if (filesWithInitialization.length === 0) {
+                const other = this.#invalidDecls.filter(identifier => isSameVarDecl(decl, identifier));
+                other.forEach(varDecl => {
+                    varDecl.setStorageClass(StorageClass.EXTERN)
+                });
+                solved = true;
+            }
+            else {
+                const other = getExternalLinkageVars().filter(identifierJp => 
+                    isSameVarDecl(decl, identifierJp) && 
+                    (identifierJp.getAncestor("file").ast !== filesWithInitialization[0].ast)
+                ); 
+                other.forEach(varDecl => {
+                    varDecl.setStorageClass(StorageClass.EXTERN);
+                });
+                solved = true;
+            } 
+        }
+        if (solved) {
+            resetCaches();
+            return new MISRATransformationReport(MISRATransformationType.DescendantChange);
+        }
+        return new MISRATransformationReport(MISRATransformationType.NoChange);
+    }
+}

package/src/rules/Section8_DeclarationsAndDefinitions/Rule_8_7_RestrictExternalLinkage.ts

@@ -0,0 +1,89 @@
+import { FunctionJp, Joinpoint, Program, StorageClass, Vardecl, Varref } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRARule from "../../MISRARule.js";
+import { AnalysisType, MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import { getIdentifierName, isExternalLinkageIdentifier } from "../../utils/IdentifierUtils.js";
+import { findExternalVarRefs, hasMultipleExternalLinkDeclarations, isVarUsed } from "../../utils/VarUtils.js";
+import { findExternalFunctionDecl, isFunctionUsed } from "../../utils/FunctionUtils.js";
+import { resetCaches, resetExternalVarRefs } from "../../utils/ProgramUtils.js";
+
+/**
+ * MISRA-C Rule 8.7: Functions and objects should not be defined with external linkage if they are referenced in only one translation unit
+ */
+export default class Rule_8_7_RestrictExternalLinkage extends MISRARule {
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SYSTEM;
+
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "8.7";
+    }
+
+    /**
+     * External declarations (`extern`) of the current identifier found in other source files.
+     */
+    #externalDecls: FunctionJp[] | Vardecl[] = [];
+
+    /**
+     * 
+     * @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 (!isExternalLinkageIdentifier($jp) || ($jp instanceof FunctionJp && $jp.name === "main")) {
+            return false;
+        } 
+
+        this.#externalDecls = $jp instanceof Vardecl ? findExternalVarRefs($jp) : findExternalFunctionDecl($jp as FunctionJp);
+        const isUsed = this.#externalDecls.some(decl => decl instanceof Vardecl ? isVarUsed(decl) : isFunctionUsed(decl));
+        const nonCompliant = this.#externalDecls.length === 0 || !isUsed; 
+        if (nonCompliant && logErrors) {
+            this.logMISRAError(
+                $jp, 
+                `${$jp instanceof FunctionJp ? "Function" : "Object"} '${getIdentifierName($jp)}' has external linkage but is only referenced within a single translation unit. Consider using the 'static' keyword to give it internal linkage.`
+            );
+            this.#externalDecls.forEach(decl => this.logMISRAError(decl, `'extern' declaration of '${getIdentifierName(decl)}' is unused. The corresponding definition is not referenced outside its translation unit and does not require external linkage.`))
+        } 
+        return nonCompliant;
+    }
+
+    /**
+     * 
+     * @param $jp - Joinpoint to transform
+     * @returns Report detailing the transformation result
+     */
+    apply($jp: Joinpoint): MISRATransformationReport {
+        const previousResult =  this.context.getRuleResult(this.ruleID, $jp);
+        if (previousResult === MISRATransformationType.NoChange || !this.match($jp)) {
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
+        } 
+
+        this.removeExternalDeclarations();
+        if ($jp instanceof Vardecl && hasMultipleExternalLinkDeclarations($jp)) {
+            this.logMISRAError(
+                $jp, 
+                `${$jp instanceof FunctionJp ? "Function" : "Object"} '${getIdentifierName($jp)}' has external linkage but is only referenced within a single translation unit. Couldn't give it internal linkage as it is defined in multiple files.`)
+            this.context.addRuleResult(this.ruleID, $jp, MISRATransformationType.NoChange);
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
+        }
+        
+        const identifierJp = ($jp as Vardecl | FunctionJp);
+        identifierJp.setStorageClass(StorageClass.STATIC);
+        resetCaches();
+        return new MISRATransformationReport(MISRATransformationType.DescendantChange);
+    }
+
+    /**
+     * Removes unused external declarations (`extern`) of the current identifier found in other source files.
+     */
+    private removeExternalDeclarations() {
+        if (this.#externalDecls.length > 0 && this.#externalDecls[0] instanceof Vardecl) {
+            resetExternalVarRefs();
+        }
+        this.#externalDecls.forEach(decl => decl instanceof FunctionJp ? decl.detach() : decl.parent.detach());
+    }
+}

package/src/rules/Section8_DeclarationsAndDefinitions/Rule_8_9_BlockScopeDefinition.ts

@@ -0,0 +1,65 @@
+import {DeclStmt, Joinpoint, Vardecl } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRARule from "../../MISRARule.js";
+import { AnalysisType, MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { findReferencingFunctions } from "../../utils/VarUtils.js";
+import { isInternalLinkageIdentifier } from "../../utils/IdentifierUtils.js";
+import { resetCaches } from "../../utils/ProgramUtils.js";
+
+/**
+ * MISRA-C Rule 8.9: An object should be defined at block scope if its identifier only appears in a single function
+ */
+export default class Rule_8_9_BlockScopeDefinition extends MISRARule {
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SYSTEM;
+
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "8.9";
+    }
+
+    /**
+     * Checks if the provided joinpoint represents an object definition with internal linkage, whose identifier only appears in a single function.
+     * 
+     * @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 Vardecl && isInternalLinkageIdentifier($jp))) {
+            return false;
+        }
+
+        const nonCompliant = findReferencingFunctions($jp).length <= 1;
+
+        if (nonCompliant && logErrors) {
+            this.logMISRAError($jp, `Object '${$jp.name}' should be defined at block scope because its identifier only appears in one single function.`)
+        }
+        return nonCompliant;
+    }
+
+    /**
+     * If the joinpoint represents the definition of an object with internal linkage used exclusively in one function, it is moved to that function's block scope.
+     *  
+     * @param $jp - Joinpoint to transform
+     * @returns Report detailing the transformation result
+     */
+    apply($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp)) {
+            return new MISRATransformationReport(MISRATransformationType.NoChange);
+        }
+
+        const referencingFunctions = findReferencingFunctions($jp as Vardecl);
+        const functionJp = referencingFunctions.length > 0 ? referencingFunctions[0] : undefined;
+        const declStmt = $jp.getAncestor("declStmt");
+        declStmt.detach();
+        functionJp?.body.firstChild.insertBefore(declStmt);        
+        resetCaches();
+        
+        return new MISRATransformationReport(MISRATransformationType.Removal);
+    }
+}

package/src/rules/UserConfigurableRule.ts

@@ -0,0 +1,60 @@
+import { Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import { LaraJoinPoint } from "@specs-feup/lara/api/LaraJoinPoint.js";
+import MISRARule from "../MISRARule.js";
+import { AnalysisType, MISRATransformationReport } from "../MISRA.js";
+
+/**
+ * Represents a MISRARule that requires the user to provide custom settings to assist in the automatic transformation.
+ * 
+ * Need to implement/define:
+ *  - analysisType
+ *  - name()
+ *  - getErrorMsgPrefix($jp)
+ *  - getFixFromConfig($jp, errorMsgPrefix)
+ *  - match($jp, logErrors)
+ *  - apply($jp)
+ *  
+ */
+export default abstract class UserConfigurableRule extends MISRARule {
+    /**
+     * Specifies the scope of analysis: single unit or entire system.
+     */
+    abstract readonly analysisType: AnalysisType;
+    
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    abstract override get name(): string;
+
+    /**
+     * Returns the prefix to be used for error messages related to the given joinpoint
+     * 
+     * @param $jp - Joinpoint where the violation was detected 
+     * @returns Returns a prefix to prepend to error messages if no configuration is specified or if the configuration does not contain a fix for this violation
+     */
+    protected abstract getErrorMsgPrefix($jp: Joinpoint): string;
+
+    /**
+     * Retrieves a fix for the given joinpoint using the provided configuration file
+     * @param $jp - Joinpoint where the violation was detected
+     * @return The fix retrieved from the configuration for the violation, or `undefined` if no applicable fix is found.
+     */
+    protected abstract getFixFromConfig($jp: Joinpoint): any;
+
+    /**
+     * Checks if the joinpoint violates the rule
+     * 
+     * @param $jp - Joinpoint to analyze
+     * @param logErrors - [logErrors=false] - Whether to log errors if a violation is detected
+     * @returns Returns true if the joinpoint violates the rule, false otherwise
+     */
+    abstract match($jp: Joinpoint, logErrors: boolean): boolean;
+
+    /**
+     * Transforms the joinpoint to comply with the MISRA-C rule
+     * 
+     * @param $jp - Joinpoint to transform
+     * @returns Report detailing the transformation result
+     */
+    abstract apply($jp: LaraJoinPoint): MISRATransformationReport;
+}

package/src/rules/index.ts

@@ -1,5 +1,6 @@
 import MISRAContext from "../MISRAContext.js";
 import MISRARule from "../MISRARule.js";
+import Rule_13_6_SafeSizeOfOperand from "./Section13_SideEffects/Rule_13_6_SafeSizeOfOperand.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";
@@ -10,22 +11,52 @@ import Rule_17_3_ImplicitFunction from "./Section17_Functions/Rule_17_3_Implicit
 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_21_10_NoTimeDateFunctions from "./Section21-StandardLibraries/Rule_21_10_NoTimeDateFunctions.js";
+import Rule_21_11_NoTgmathFunctions from "./Section21-StandardLibraries/Rule_21_11_NoTgmathFunctions.js";
+import Rule_21_3_NoDynamicMemory from "./Section21-StandardLibraries/Rule_21_3_NoDynamicMemory.js";
+import Rule_21_6_NoStdIOFunctions from "./Section21-StandardLibraries/Rule_21_6_NoStdIOFunctions.js";
+import Rule_21_7_NoNumericStringConversions from "./Section21-StandardLibraries/Rule_21_7_NoNumericStringConversions.js";
+import Rule_21_8_NoProcessControlFunctions from "./Section21-StandardLibraries/Rule_21_8_NoProcessControlFunctions.js";
+import Rule_21_9_NoGenericSearchOrSort from "./Section21-StandardLibraries/Rule_21_9_NoGenericSearchOrSort.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";
+import Rule_5_1_DistinctExternalIdentifiers from "./Section5_Identifiers/Rule_5_1_DistinctExternalIdentifiers.js";
+import Rule_5_6_UniqueTypedefNames from "./Section5_Identifiers/Rule_5_6_UniqueTypedefNames.js";
+import Rule_5_7_UniqueTagNames from "./Section5_Identifiers/Rule_5_7_UniqueTagNames.js";
+import Rule_5_8_UniqueExternalLinkIdentifiers from "./Section5_Identifiers/Rule_5_8_UniqueExternalLinkIdentifiers.js";
+import Rule_5_9_UniqueInternalLinkIdentifiers from "./Section5_Identifiers/Rule_5_9_UniqueInternalLinkIdentifiers.js";
+import Rule_8_6_SingleExternalDefinition from "./Section8_DeclarationsAndDefinitions/Rule_8_6_SingleExternalDefinition.js";
+import Rule_8_7_RestrictExternalLinkage from "./Section8_DeclarationsAndDefinitions/Rule_8_7_RestrictExternalLinkage.js";
+import Rule_8_9_BlockScopeDefinition from "./Section8_DeclarationsAndDefinitions/Rule_8_9_BlockScopeDefinition.js";
 
-export function sortRules(context: MISRAContext) {
+/**
+ * Selects MISRA-C rules based on the provided analysis type.
+ * Returns rules sorted by priority (lower value has higher priority).
+ *
+ * @param context - The shared analysis context
+ * @param analysisType - Rule type to include ("all" for all rules).
+ * @returns Filtered and sorted list of MISRA rules.
+ */
+export function selectRules(context: MISRAContext, analysisType: string) {
      
-    const rules: MISRARule[] = [
+    let 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_5_1_DistinctExternalIdentifiers(context),
+        new Rule_5_6_UniqueTypedefNames(context),
+        new Rule_5_7_UniqueTagNames(context),
+        new Rule_5_8_UniqueExternalLinkIdentifiers(context),
+        new Rule_5_9_UniqueInternalLinkIdentifiers(context),
+        new Rule_8_6_SingleExternalDefinition(context),
+        new Rule_8_7_RestrictExternalLinkage(context),
+        new Rule_8_9_BlockScopeDefinition(context),
+        new Rule_13_6_SafeSizeOfOperand(context),
         new Rule_16_2_TopLevelSwitch(context),
         new Rule_16_3_UnconditionalBreak(context),
         new Rule_16_4_SwitchHasDefault(context),
@@ -36,9 +67,16 @@ export function sortRules(context: MISRAContext) {
         new Rule_17_4_NonVoidReturn(context),
         new Rule_17_6_StaticArraySizeParam(context),
         new Rule_17_7_UnusedReturnValue(context),
+        new Rule_21_3_NoDynamicMemory(context),
+        new Rule_21_6_NoStdIOFunctions(context),
+        new Rule_21_7_NoNumericStringConversions(context),
+        new Rule_21_8_NoProcessControlFunctions(context),
+        new Rule_21_9_NoGenericSearchOrSort(context),
+        new Rule_21_10_NoTimeDateFunctions(context),
+        new Rule_21_11_NoTgmathFunctions(context)
     ];
-
-    return rules.sort((ruleA, ruleB) => ruleA.priority - ruleB.priority);
+    rules.sort((ruleA, ruleB) => ruleA.priority - ruleB.priority); 
+    return analysisType === "all" ? rules : rules.filter(rule => rule.analysisType === analysisType);
 }
 
-export default sortRules;
+export default selectRules;

package/src/tests/Section13_SideEffects/Rule_13_6_SafeSizeOfOperand.test.ts

@@ -0,0 +1,114 @@
+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 misraExample = `
+#include <stdint.h>
+#include <stddef.h>
+
+static void test_13_6_1(void) {
+    volatile int32_t i;
+    int32_t j; 
+    size_t s;
+
+    s = sizeof(j);               
+    s = sizeof(j++);             // Non-compliant (rule 13.6)
+    s = sizeof(i);               
+    s = sizeof(int32_t);         
+}
+
+static void f(int32_t n) { 
+    static volatile uint32_t v; 
+    size_t s;
+    s = sizeof(int32_t[n]);                            /* Compliant */
+    s = sizeof(int32_t[n++]);                          /* Non-compliant (rule 13.6) */
+}
+`;
+
+const passingCode = `
+#include <stdint.h>
+#include <stddef.h>
+
+static void test_13_6_2(int32_t n1, int32_t buffer[]) {
+    size_t s1;
+    volatile int32_t i1;
+    int32_t j1; 
+
+    s1 = sizeof(j1);                /* Compliant */
+    s1 = sizeof(i1);                /* Compliant - exception */
+    s1 = sizeof(i1 + j1);           /* Compliant */
+    s1 = sizeof(int32_t);           /* Compliant */
+    s1 = sizeof( int32_t[ n1 ] );   /* Compliant */
+    s1 = sizeof(buffer[s1]);        /* Compliant */
+}
+`;
+
+const failingCode = `
+#include <stdint.h>
+#include <stddef.h>
+
+static int32_t foo_13_6_3(float n) {
+    if (n > 0) {
+        return 1;
+    }
+    return -1;
+}
+
+static float bar_13_6_4() {
+    return 5.0;
+}
+
+static void test_13_6_3(int32_t n) {
+    uint32_t a2 = 0x0F;
+    uint32_t b2 = 0x0A;
+    int32_t i2;
+    int32_t j2;
+    size_t s2;
+    
+    s2 = sizeof(i2++);          // Non-compliant (rule 13.6) 
+    s2 = sizeof(i2--);          // Non-compliant (rule 13.6)
+    s2 = sizeof(++i2);          // Non-compliant (rule 13.6) 
+    s2 = sizeof(i2--);          // Non-compliant (rule 13.6) 
+    s2 = sizeof(j2 = i2);       // Non-compliant (rule 13.6) 
+    s2 = sizeof(j2 += i2);      // Non-compliant (rule 13.6) 
+    s2 = sizeof(j2 -= 2);       // Non-compliant (rule 13.6)
+    s2 = sizeof(j2 *= 2);       // Non-compliant (rule 13.6)
+    s2 = sizeof(j2 /= 2);       // Non-compliant (rule 13.6)
+    s2 = sizeof(j2 %= 2);       // Non-compliant (rule 13.6)
+    s2 = sizeof(a2 <<= 1);      // Non-compliant (rule 13.6)
+    s2 = sizeof(a2 >>= 1);      // Non-compliant (rule 13.6)
+    s2 = sizeof(b2 &= 0xAB);    // Non-compliant (rule 13.6)
+    s2 = sizeof(b2 ^= 0xAB);    // Non-compliant (rule 13.6)
+    s2 = sizeof(b2 |= 0xAB);    // Non-compliant (rule 13.6)
+    
+    // Function calls
+    s2 = sizeof(bar_13_6_4());
+    s2 = sizeof(foo_13_6_3(bar_13_6_4()));
+
+    // Declaration of variable-length array type; will not be corrected
+    s2 = sizeof(int32_t[ n++ ]);      // Non-compliant (rule 13.6)
+}
+`;
+
+const files: TestFile[] = [
+    { name: "misraExample.c", code: misraExample},
+    { name: "bad.c", code: failingCode },
+    { name: "good.c", code: passingCode }
+];
+
+describe("Rule 13.6", () => {
+    registerSourceCode(files);
+
+    it("should detect errors in bad.c", () => {
+        expect(countMISRAErrors()).toBe(21);
+        expect(countMISRAErrors("13.6")).toBe(21); 
+
+        expect(countMISRAErrors(Query.search(FileJp, {name: "misraExample.c"}).first()!)).toBe(2);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "bad.c"}).first()!)).toBe(19);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "good.c"}).first()!)).toBe(0);
+    });
+
+    it("should correct errors in bad.c", () => {
+        expect(countErrorsAfterCorrection()).toBe(2);
+    });
+});

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

@@ -2,8 +2,8 @@ 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 ) {
+const passingCode = `
+static void foo1( void ) {
     int x, y;
     switch ( x )
     {
@@ -15,10 +15,11 @@ const passingCode =
         default:
             break;
     }
-}`;
+}
+`;
 
 const failingCode = 
-`void foo2( void ) {
+`static void foo2( void ) {
     int x, y;
     switch ( x )
     {
@@ -32,7 +33,8 @@ const failingCode =
         default:
             break;
     }
-}`;
+}
+`;
 
 const files: TestFile[] = [
     { name: "bad.c", code: failingCode },