@specs-feup/clava-misra 1.0.2 → 1.0.4

package/src/rules/Section2_UnusedCode/Rule_2_4_UnusedTagDecl.ts

@@ -1,40 +1,53 @@
-import { Joinpoint, RecordJp, EnumDecl, TagType, ElaboratedType } from "@specs-feup/clava/api/Joinpoints.js";
+import { Joinpoint, DeclStmt } 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";
+import { AnalysisType, MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import { hasTypeDefDecl, isTypeDeclUsed } from "../../utils/TypeDeclUtils.js";
+import { isTagDecl, TagDecl } from "../../utils/JoinpointUtils.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);
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SYSTEM;
+
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "2.4";
     }
 
     /**
      * 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
+     * A tag is considered unused if it has no references in the code or if it's 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;
+        if (!(isTagDecl($jp) || ($jp instanceof DeclStmt && $jp.decls.length === 1))) {
+            return false;
+        } 
+        
+        if ($jp instanceof DeclStmt && !isTagDecl($jp.decls[0])) {
+            return false;
+        }
 
-        const containsTypeDecl = hasTypeDecl($jp);
-        const jpName = $jp.name;
-        if (containsTypeDecl && jpName === undefined || jpName === null || (jpName as string).trim().length === 0) {
+        const tagJp: TagDecl = $jp instanceof DeclStmt ? $jp.decls[0] as TagDecl : $jp;
+        const containsTypeDecl = hasTypeDefDecl(tagJp);
+        const jpName = tagJp.name;
+        if (containsTypeDecl && (jpName === undefined || jpName === null || (jpName as string).trim().length === 0)) {
             return false;
         }
 
-        const isUnused = getTagUses($jp).length === 0;
+        const isUnused = !isTypeDeclUsed(tagJp);
         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.`);
+            this.logMISRAError(tagJp, 
+                containsTypeDecl ? `The tag '${tagJp.name}' is declared but only used in a typedef.` : `The tag '${tagJp.name}' is declared but not used.`);
         }
         return isUnused;
     }
@@ -47,12 +60,13 @@ export default class Rule_2_4_UnusedTagDecl extends MISRARule {
      * @param $jp - Joinpoint to transform
      * @returns Report detailing the transformation result
      */
-    transform($jp: Joinpoint): MISRATransformationReport {
+    apply($jp: Joinpoint): MISRATransformationReport {
         if (!this.match($jp)) 
             return new MISRATransformationReport(MISRATransformationType.NoChange);
         
-        if (hasTypeDecl($jp)) {
-            ($jp as RecordJp | EnumDecl).setName('');
+        const tagJp: TagDecl = $jp instanceof DeclStmt ? $jp.decls[0] as TagDecl : $jp as TagDecl;
+        if (hasTypeDefDecl(tagJp)) {
+            (tagJp).setName('');
             return new MISRATransformationReport(MISRATransformationType.DescendantChange);
         }
         $jp.detach();

package/src/rules/Section2_UnusedCode/Rule_2_6_UnusedLabels.ts

@@ -1,44 +1,57 @@
-import { GotoStmt, FunctionJp, Joinpoint, LabelStmt } from "@specs-feup/clava/api/Joinpoints.js";
+import { FunctionJp, Joinpoint } 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 { AnalysisType, MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import { getUnusedLabels } from "../../utils/FunctionUtils.js";
 
 /**
- * Rule 2.6: Unused Labels. 
- *  Checks for labels within a function that are not used.
+ * MISRA-C Rule 2.6: A function should not contain unused label declarations.
+ *  
  */
 export default class Rule_2_6_UnusedLabels extends MISRARule {
-    priority = 3; 
-    
-    constructor(context: MISRAContext) {
-        super("2.6", context);
-    }
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SINGLE_TRANSLATION_UNIT;
 
-    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
-        );
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "2.6";
     }
 
+    /**
+     * Checks if the given joinpoint represents a function with unused labels.
+     * A tag is considered unused if it is declared but not referenced by any goto statement.
+     * 
+     * @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)) 
             return false;
 
-        const unusedLabels = this.getUnusedLabels($jp);
+        const unusedLabels = getUnusedLabels($jp);
         if (logErrors) {
             unusedLabels.forEach(label => 
-                this.logMISRAError(label, `Label ${label.decl.name} is unused in function ${$jp.name}.`)
+                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)) 
+    /**
+     * Removes all unused labels if the provided joinpoint represents a function
+     * 
+     * @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 unusedLabels = this.getUnusedLabels($jp as FunctionJp);
+        const unusedLabels = getUnusedLabels($jp as FunctionJp);
         for (const label of unusedLabels) {
             label.detach();
         }

package/src/rules/Section2_UnusedCode/Rule_2_7_UnusedParameters.ts

@@ -1,67 +1,112 @@
-import { FunctionJp, Joinpoint, Param, Varref, Call } from "@specs-feup/clava/api/Joinpoints.js";
+import { FunctionJp, Joinpoint, Param, Varref, Call, Program } 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";
+import { AnalysisType, MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import { getDirectParamReferences, getParamReferences, getVLAFieldParamReferences } from "../../utils/FunctionUtils.js";
 
+/**
+ * MISRA-C Rule 2.7: There should be no unused parameters in functions.
+ */
 export default class Rule_2_7_UnusedParameters extends MISRARule {
-    priority = 3; 
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SINGLE_TRANSLATION_UNIT;
+    
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "2.7";
+    }
+
+    #unusedParams: Param[] = [];
+
+    /**
+     * Checks if the program contains function with unused parameters.
+     * A parameter is considered unused if it is never referenced anywhere in the 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 FunctionJp && $jp.isImplementation))
+            return false;
+        
+        const nonCompliant = $jp.params.some((param) => getParamReferences(param, $jp).length === 0);
+        if (logErrors && nonCompliant) {
+            this.#unusedParams = this.getUnusedParams($jp);
+            this.#unusedParams.forEach(param => this.logMISRAError(param, `Parameter '${param.name}' is unused in function '${$jp.name}'.`));
+        }
+        return nonCompliant;
+    }
+
+    /**
+     * Removes all unused parameters from functions in the program
+     * 
+     * @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 funcJp = $jp as FunctionJp;
+        const usedParams = this.getUsedParams(funcJp);
+        const unusedParamsPosition = this.getUnusedParamsPositions(funcJp);
+        const calls = Query.search(Call, {function: jp => jp?.astId === funcJp.astId}).get();
+        
+        funcJp.setParams(usedParams);
 
-    constructor(context: MISRAContext) {
-        super("2.7", context);
+        for (const call of calls) {
+            const unusedArgs = unusedParamsPosition.map(i => call.args[i]);
+            unusedArgs.forEach(arg => arg.detach());
+        }
+        return new MISRATransformationReport(MISRATransformationType.DescendantChange);
     }
 
+    /**
+     * Gets all unused parameters from a function joinpoint
+     * 
+     * @param func - Function joinpoint to analyze
+     * @returns Returns a list of all unused parameters from a function.
+     */
     private getUnusedParams(func: FunctionJp): Param[] {
-        return func.params.filter(param => getParamReferences(param, func).length === 0);
+        return func.params.filter((param) => {
+            if (getDirectParamReferences(param, func).length > 0) return false;
+            return getVLAFieldParamReferences(param, func).length === 0;
+        });
     }    
 
+    /**
+     * Gets all used parameters from a function joinpoint
+     * 
+     * @param func - Function joinpoint to analyze
+     * @returns Returns a list of parameters that are used within a function.
+     */
     private getUsedParams(func: FunctionJp): Param[] {
-        return func.params.filter(param => getParamReferences(param, func).length > 0);
+        return func.params.filter((param) => {
+            if (getDirectParamReferences(param, func).length > 0) return true;
+            return getVLAFieldParamReferences(param, func).length > 0;
+        });
     }
 
-    private getUsedParamsPositions(func: FunctionJp): number[] {
+    /**
+     * Returns the positions (indexes) of parameters that are used in the given function joinpoint.
+     *
+     * @param func - Function joinpoint to analyze
+     * @returns returns a list of numbers representing the indexes of used parameters.
+     */
+    private getUnusedParamsPositions(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) {
+            const varRefs = Query.searchFrom(func, Varref, { decl: jp => jp?.astId === param.astId }).get();
+            if (varRefs.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

@@ -1,18 +1,31 @@
-import { Comment, Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+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";
+import { isInlineComment, getComments } from "../../utils/CommentUtils.js";
+import { AnalysisType, MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
 
 /**
- * MISRA Rule 3.1: 
+ * MISRA-C Rule 3.1: The character sequences /* an d // shall not be used within a comment.
  */
 export default class Rule_3_1_CommentSequences extends MISRARule {
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SINGLE_TRANSLATION_UNIT;
 
-    constructor(context: MISRAContext) {
-        super("3.1", context);
+     /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "3.1";
     }
 
+    /**
+     * Checks if given joinpoint contains disallowed character sequences in comments.
+     * 
+     * @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 invalidComments = getComments($jp).filter(comment => 
             (isInlineComment(comment) && /(\/\*)/g.test(comment.text)) ||
@@ -26,7 +39,13 @@ export default class Rule_3_1_CommentSequences extends MISRARule {
         return invalidComments.length > 0;
     }
 
-    transform($jp: Joinpoint): MISRATransformationReport {
+    /**
+     * Transforms the given joinpoint if it represents a joinpoint containing disallowed character sequences in comments.
+     * 
+     * @param $jp - Joinpoint to transform
+     * @returns Report detailing the transformation result
+     */
+    apply($jp: Joinpoint): MISRATransformationReport {
         if (!this.match($jp)) 
             return new MISRATransformationReport(MISRATransformationType.NoChange);
 

package/src/rules/Section5_Identifiers/IdentifierRenameRule.ts

@@ -0,0 +1,63 @@
+import {Joinpoint, Program} from "@specs-feup/clava/api/Joinpoints.js";
+import MISRARule from "../../MISRARule.js";
+import { AnalysisType, MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import { renameIdentifier } from "../../utils/IdentifierUtils.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+
+/**
+ * Abstract base class for MISRA-C rules that enforce constraints on identifier uniqueness where renaming may be required.
+ * 
+ * Need to implement:
+ *  - analysisType
+ *  - name()
+ *  - match($jp, logErrors)
+ */
+export default abstract class IdentifierRenameRule extends MISRARule {
+    /**
+     * A positive integer starting from 1 that indicates the rule's priority, determining the order in which rules are applied.
+     */
+    readonly priority = 2;
+
+    /**
+     * 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;
+
+    /**
+     * Identifiers with invalid names that require renaming.
+     */
+    protected invalidIdentifiers: 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;
+
+    /**
+     * Renames all invalid identifiers found in the program.
+     * After renaming, the program is rebuilt to ensure proper linking of functions, variables, and their external declarations.
+     * 
+     * @param $jp - Joinpoint to transform
+     * @returns Report detailing the transformation result
+     */
+    apply($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp, false)) {
+            return new MISRATransformationReport(MISRATransformationType.NoChange);   
+        }
+
+        for (const identifierJp of this.invalidIdentifiers) {
+            const newName = this.context.generateIdentifierName(identifierJp)!;
+            renameIdentifier(identifierJp, newName);
+        }
+        return new MISRATransformationReport(MISRATransformationType.Replacement, Query.root() as Program);
+    }
+}

package/src/rules/Section5_Identifiers/Rule_5_1_DistinctExternalIdentifiers.ts

@@ -0,0 +1,52 @@
+import {Joinpoint, Program } from "@specs-feup/clava/api/Joinpoints.js";
+import { areDistinctIdentifiers, getIdentifierName } from "../../utils/IdentifierUtils.js";
+import { getExternalLinkageIdentifiers } from "../../utils/ProgramUtils.js";
+import { compareLocation } from "../../utils/JoinpointUtils.js";
+import { isSameVarDecl } from "../../utils/VarUtils.js";
+import IdentifierRenameRule from "./IdentifierRenameRule.js";
+import { AnalysisType } from "../../MISRA.js";
+
+/**
+ * MISRA-C Rule 5.1 External identifiers shall be distinct.
+ */
+export default class Rule_5_1_DistinctExternalIdentifiers extends IdentifierRenameRule {
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SYSTEM;
+
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "5.1";
+    }
+
+    /**
+     * Checks if the given joinpoint is an external identifier distinct from other external identifiers.
+     * 
+     * @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 externalIdentifiers = getExternalLinkageIdentifiers();
+        this.invalidIdentifiers = 
+            externalIdentifiers.filter(identifier1 =>
+                externalIdentifiers.some(identifier2 =>
+                    !isSameVarDecl(identifier1, identifier2) &&
+                    !areDistinctIdentifiers(identifier1, identifier2) &&
+                    compareLocation(identifier2, identifier1) < 0
+                )
+            );
+        const nonCompliant = this.invalidIdentifiers.length > 0;
+        if (nonCompliant && logErrors) {
+            this.invalidIdentifiers.forEach(identifierJp => {
+                this.logMISRAError(identifierJp, `Identifier '${getIdentifierName(identifierJp)}' is not distinct from other external identifier within the first 31 characters.`)
+            });
+        }
+        return nonCompliant;
+    }
+}

package/src/rules/Section5_Identifiers/Rule_5_6_UniqueTypedefNames.ts

@@ -0,0 +1,62 @@
+import { Joinpoint, Program, TypedefDecl } from "@specs-feup/clava/api/Joinpoints.js";
+import { getIdentifierName, isIdentifierDuplicated, isIdentifierNameDeclaredBefore } from "../../utils/IdentifierUtils.js";
+import { getTypeDefDecl } from "../../utils/TypeDeclUtils.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { isTagDecl } from "../../utils/JoinpointUtils.js";
+import { getIdentifierDecls } from "../../utils/ProgramUtils.js";
+import IdentifierRenameRule from "./IdentifierRenameRule.js";
+import { AnalysisType } from "../../MISRA.js";
+
+/**
+ * MISRA-C Rule 5.6: A typedef name shall be a unique identifier.
+ * 
+ * Exception: The typedef name may be the same as the structure, union  or enumeration tag name associated with the typedef.
+ */
+export default class Rule_5_6_UniqueTypedefNames extends IdentifierRenameRule {
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SYSTEM;
+    
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "5.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 typedefDecls = Query.search(TypedefDecl).get();
+
+        this.invalidIdentifiers = getIdentifierDecls().filter((identifierJp) => 
+        {
+            if (isTagDecl(identifierJp)) {
+                return typedefDecls.filter((decl) =>
+                    getIdentifierName(identifierJp) === getIdentifierName(decl) &&
+                    getTypeDefDecl(identifierJp)?.astId !== decl.astId
+                ).length > 0
+            } 
+            else if (identifierJp instanceof TypedefDecl) {
+                return isIdentifierNameDeclaredBefore(identifierJp, typedefDecls);
+            } 
+            return isIdentifierDuplicated(identifierJp, typedefDecls);
+        });
+
+        const nonCompliant = this.invalidIdentifiers.length > 0;
+
+        if (nonCompliant && logErrors) { 
+            this.invalidIdentifiers.forEach(identifierJp => {
+                this.logMISRAError(identifierJp, `Identifier '${getIdentifierName(identifierJp)}' is also the name of a typedef. Typedef identifiers must not be reused.`);
+            })
+        }
+        return nonCompliant;
+    }
+}

package/src/rules/Section5_Identifiers/Rule_5_7_UniqueTagNames.ts

@@ -0,0 +1,61 @@
+import { Joinpoint, Program, TypedefDecl } from "@specs-feup/clava/api/Joinpoints.js";
+import { getIdentifierName, isIdentifierDuplicated, isIdentifierNameDeclaredBefore } from "../../utils/IdentifierUtils.js";
+import { getTypeDefDecl } from "../../utils/TypeDeclUtils.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { isTagDecl } from "../../utils/JoinpointUtils.js";
+import { getIdentifierDecls } from "../../utils/ProgramUtils.js";
+import IdentifierRenameRule from "./IdentifierRenameRule.js";
+import { AnalysisType } from "../../MISRA.js";
+
+/**
+ * MISRA-C Rule 5.7: A tag name shall be a unique identifier.
+ * 
+ * Exception: The tag name may be the same as the typedef name with which it is  associated.
+ */
+export default class Rule_5_7_UniqueTagNames extends IdentifierRenameRule {
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SYSTEM;
+
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "5.7";
+    }
+
+    /**
+     * Checks whether the given joinpoint represents an identifier that has the same name as any tag (i.e., enum, union or struct)
+     * 
+     * @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 tagDecls = Query.search(Joinpoint, (jp => {return isTagDecl(jp)})).get();
+        this.invalidIdentifiers = getIdentifierDecls().filter((identifierJp) => 
+        {
+            if (identifierJp instanceof TypedefDecl) {
+                return tagDecls.filter((tag) =>
+                    getIdentifierName(identifierJp) === getIdentifierName(tag) &&
+                    getTypeDefDecl(tag)?.ast !== identifierJp.ast
+                ).length > 0;
+            }
+            else if (isTagDecl(identifierJp)) {
+                return isIdentifierNameDeclaredBefore(identifierJp, tagDecls);
+            }
+            return isIdentifierDuplicated(identifierJp, tagDecls);
+        });
+        const nonCompliant = this.invalidIdentifiers.length > 0;
+
+        if (nonCompliant && logErrors) { 
+            this.invalidIdentifiers.forEach(identifierJp => {
+                this.logMISRAError(identifierJp, `Identifier '${getIdentifierName(identifierJp)}' is also the name of a tag. Tag identifiers must not be reused.`);
+            })
+        }
+        return nonCompliant;
+    }
+}

package/src/rules/Section5_Identifiers/Rule_5_8_UniqueExternalLinkIdentifiers.ts

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