@specs-feup/clava-misra 1.0.2 → 1.0.4

package/src/utils/ProgramUtils.ts

@@ -0,0 +1,107 @@
+import { Vardecl, FunctionJp, LabelStmt, NamedDecl, StorageClass } from "@specs-feup/clava/api/Joinpoints.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { isExternalLinkageIdentifier, isIdentifierDecl, isInternalLinkageIdentifier } from "./IdentifierUtils.js";
+
+let cachedInternalLinkageIdentifiers: (FunctionJp | Vardecl)[] | null = null;
+let cachedExternalLinkageIdentifiers: (FunctionJp | Vardecl)[] | null = null;
+let cachedExternalLinkageVars: (Vardecl)[] | null = null;
+let cachedExternalVarRefs: (Vardecl)[] | null = null;
+let cachedIdentifierDecls: any[] | null = null;
+
+/**
+ * Clears all cached identifiers and variable references
+ */
+export function resetCaches() {
+    cachedInternalLinkageIdentifiers = null;
+    cachedExternalLinkageIdentifiers = null;
+    cachedExternalLinkageVars = null;
+    cachedExternalVarRefs = null;
+    cachedIdentifierDecls = null;
+}
+
+/**
+ * Clears the cache of external variable references
+ */
+export function resetExternalVarRefs() {
+    cachedExternalVarRefs = null;
+}
+
+/**
+ * Retrieves all variables and functions that are eligible for `extern` linkage, i.e., 
+ * elements with storage classes that are not `STATIC` or `EXTERN`
+ *
+ *  @returns Array of functions and variables that can be declared as external
+ */
+export function getExternalLinkageIdentifiers(): (FunctionJp | Vardecl)[] {
+    if (cachedExternalLinkageIdentifiers !== null) {
+        return cachedExternalLinkageIdentifiers;
+    }
+
+    const externalLinkageVarDecls = getExternalLinkageVars();
+    const externalLinkageFunctions = Query.search(FunctionJp, (varDeclJp) => isExternalLinkageIdentifier(varDeclJp)).get();
+
+    cachedExternalLinkageIdentifiers = [
+        ...externalLinkageFunctions, 
+        ...externalLinkageVarDecls
+    ];
+    return cachedExternalLinkageIdentifiers;
+}
+
+/**
+ * Gets identifiers with internal linkage
+ * 
+ * @returns List of functions and variable declarations with internal linkage
+ */
+export function getInternalLinkageIdentifiers(): (FunctionJp | Vardecl)[] {
+    if (cachedInternalLinkageIdentifiers !== null) {
+        return cachedInternalLinkageIdentifiers;
+    }
+
+    const internalLinkageVarsDecls = Query.search(Vardecl, (decl) => isInternalLinkageIdentifier(decl)).get();
+    const internalLinkageFunctions =  Query.search(FunctionJp, (decl) => isInternalLinkageIdentifier(decl)).get();
+    cachedInternalLinkageIdentifiers = [
+        ...internalLinkageFunctions, 
+        ...internalLinkageVarsDecls
+    ];
+    return cachedInternalLinkageIdentifiers;
+}
+
+/**
+ * Gets identifiers with external linkage
+ * 
+ * @returns List of functions and variable declarations with external linkage
+ */
+export function getExternalLinkageVars(): Vardecl[] {
+    if (cachedExternalLinkageVars != null) {
+        return cachedExternalLinkageVars;
+    }
+    cachedExternalLinkageVars = Query.search(Vardecl, (varDeclJp) => isExternalLinkageIdentifier(varDeclJp)).get();
+    return cachedExternalLinkageVars;
+}
+
+/**
+ * Gets all variable declared with 'extern'
+ * 
+ * @returns List of variable declarations with extern storage class
+ */
+export function getExternalVarRefs(): Vardecl[] {
+    if (cachedExternalVarRefs !== null) {
+        return cachedExternalVarRefs;
+    }
+    cachedExternalVarRefs = Query.search(Vardecl, {storageClass: StorageClass.EXTERN}).get();
+    return cachedExternalVarRefs;
+}
+
+/**
+ * Gets all named declarations and labels
+ */
+export function getIdentifierDecls(): any[] {
+    if (cachedIdentifierDecls !== null) {
+        return cachedIdentifierDecls;
+    }
+    cachedIdentifierDecls = [
+        ...Query.search(NamedDecl).get(),
+        ...Query.search(LabelStmt).get(),
+    ].filter((jp) => isIdentifierDecl(jp));
+    return cachedIdentifierDecls;
+}

package/src/utils/SwitchUtils.ts

@@ -0,0 +1,52 @@
+import { BinaryOp, Break, BuiltinType, Case, Joinpoint, Switch, UnaryOp } from "@specs-feup/clava/api/Joinpoints.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { hasDefinedType } from "./JoinpointUtils.js";
+
+/**
+ * Retrieves the last statement of the given case
+ * @param $jp - The case to retrieve the last statement from
+ * @returns The last statement of the case or undefined if there are no statements or it has a consecutive case.
+ */
+export function getLastStmtOfCase($jp: Case): Joinpoint | undefined {
+    if ($jp.instructions.length === 0) { // Has a consecutive case
+        return undefined;
+    }
+
+    let caseScopeStmts: Joinpoint[] = [];
+    for (const stmt of $jp.siblingsRight) {
+        if (stmt instanceof Case) {
+            break;
+        }
+        caseScopeStmts.push(stmt);
+    }
+    return !caseScopeStmts.some(stmt => stmt instanceof Break) ? 
+                caseScopeStmts[caseScopeStmts.length - 1] : 
+                caseScopeStmts.find(stmt => stmt instanceof Break);
+} 
+
+/**
+ * Retrieves the number of switch clauses with instructions in the provided switch statement
+ * @param $jp - The switch statement to analyze
+ * @returns The number of switch clauses with instructions
+ */
+export function countSwitchClauses($jp: Switch): number  {
+    let firstStatements = []
+
+    for (const caseLabel of $jp.cases) {
+        if (caseLabel.instructions.length === 0) { // Has a consecutive case
+            continue;
+        }
+        firstStatements.push(caseLabel.instructions[0])
+    }
+    return firstStatements.length;
+} 
+
+/**
+ * Checks if the provided switch statement contains any conditional break
+ * 
+ * @param switchStmt - The switch statement to analyze
+ * @returns Returns true if the switch statement contains a conditional break, otherwise false
+ */
+export function hasConditionalBreak(switchStmt: Switch): boolean {
+    return Query.searchFrom(switchStmt, Break, { currentRegion: region => region.astId !== switchStmt.astId, enclosingStmt: jp => jp.astId === switchStmt.astId }).get().length > 0;
+}

package/src/utils/TypeDeclUtils.ts

@@ -0,0 +1,88 @@
+import { Joinpoint, TypedefDecl, DeclStmt, TypedefType, ElaboratedType, TagType, FileJp, EnumDecl, EnumeratorDecl, Varref } from "@specs-feup/clava/api/Joinpoints.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { getBaseType } from "./JoinpointUtils.js";
+import { isTagDecl, TagDecl } from "./JoinpointUtils.js";
+import { findFilesReferencingHeader, getIncludesOfFile } from "./FileUtils.js";
+
+/**
+ * Retrieves the typedef declaration for the provided joinpoint, if available
+ * @param $jp The joinpoint to analyze
+ * @returns The typedef declaration if found, or undefined if not
+ */
+export function getTypeDefDecl($jp: Joinpoint): TypedefDecl | undefined {
+    if ($jp instanceof DeclStmt && $jp.children.length === 1 && $jp.children[0] instanceof TypedefDecl)
+        return $jp.children[0];
+
+    if (isTagDecl($jp)) {
+        const typeDecls = Query.searchFrom($jp, TypedefDecl).get(); 
+        if (typeDecls.length === 1)
+            return typeDecls[0];
+    }
+}
+
+/**
+ * Checks if the provided joinpoint declares a type (typedef)
+ * @param $jp The joinpoint to check
+ * @returns Returns true if the joinpoint declares a typedef, otherwise false
+ */
+export function hasTypeDefDecl($jp: Joinpoint): boolean {
+    return getTypeDefDecl($jp) !== undefined;
+}
+
+/**
+ * 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
+ */
+export function jpUsesTypedef(jp: Joinpoint, typeDecl: TypedefDecl): boolean {
+    const jpType = getBaseType(jp);
+
+    return !jpType?.isBuiltin && (
+        (jpType instanceof TypedefType &&jpType.decl.astId === typeDecl.astId) ||
+        (jpType instanceof ElaboratedType && jpType.namedType instanceof TypedefType &&jpType.namedType.decl.astId === typeDecl.astId)
+    );
+}
+
+/**
+ * Checks if a given joinpoint uses the specified tag declaration
+ * @param $jp The joinpoint to analyze
+ * @param tag The tag to check against
+ * @returns Returns true if the joinpoint uses the given tag, false otherwise
+ */
+export function jpUsesTag($jp: Joinpoint, tag: TagDecl): boolean {
+    if (tag instanceof EnumDecl && $jp instanceof Varref && getTypeDefDecl(tag) === undefined) {
+        const enumeratorsIDs = tag.enumerators.map(enumerator => enumerator.astId);
+        const decl = $jp.getValue("decl");
+        if (decl instanceof EnumeratorDecl && enumeratorsIDs.includes(decl.astId)) {
+            return true;
+        }
+    }
+
+    const jpType = getBaseType($jp);
+    return jpType instanceof ElaboratedType && 
+        jpType.namedType instanceof TagType && 
+        jpType.namedType.decl.astId === tag.astId &&
+        $jp.astId !== getTypeDefDecl(tag)?.astId
+}
+
+/**
+ * Checks if the provided typedef or tag declaration is used in any part of the program
+ * @param decl - typedef or tag declaration to verify
+ * @returns Returns true if the declaration is used, false otherwise
+ */
+export function isTypeDeclUsed(decl: TypedefDecl | TagDecl): boolean {
+    const fileJp = decl.getAncestor("file") as FileJp;
+    let jps: Joinpoint[] = [];
+
+    if (fileJp.isHeader) {
+        const referencingFiles = findFilesReferencingHeader(fileJp.name);
+        jps = [...fileJp.descendants, ...referencingFiles.flatMap(file => file.descendants)];
+    } else {
+        jps = fileJp.descendants;
+    }
+    
+    return decl instanceof TypedefDecl ? 
+        jps.some(jp => jpUsesTypedef(jp, decl)) :
+        jps.some(jp => jpUsesTag(jp, decl));
+}

package/src/utils/VarUtils.ts

@@ -0,0 +1,102 @@
+import { FileJp, FunctionJp, Joinpoint, QualType, StorageClass, Vardecl, Varref } from "@specs-feup/clava/api/Joinpoints.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { getIdentifierName, isExternalLinkageIdentifier } from "./IdentifierUtils.js";
+import { getExternalLinkageIdentifiers, getExternalLinkageVars, getExternalVarRefs } from "./ProgramUtils.js";
+import { findFilesReferencingHeader } from "./FileUtils.js";
+
+/**
+ * Retrieves all variable references qualified as "volatile" starting from the given joinpoint
+ * @param $jp Starting joinpoint
+ * @returns Array of variable references qualified as volatile
+ */
+export function getVolatileVarRefs($jp: Joinpoint): Varref[] {
+    return Query.searchFromInclusive($jp, Varref, (ref) => {
+        try {
+            return ref.type instanceof QualType && ref.type.qualifiers?.includes("volatile")
+        } catch (error) {
+            return false;
+        }
+     }).get();
+}
+
+/**
+ * Retrieves all external references of the given variable
+ * 
+ * @param $varDecl variable to match by name.
+ * @returns Array of external references with the same name as the given variable.
+ */
+export function findExternalVarRefs($varDecl: Vardecl): Vardecl[] {
+    return getExternalVarRefs().filter(ref => ref.name === $varDecl.name);
+}
+
+/**
+ * Identifies functions in the same file that reference the specified variable declaration
+ *
+ * @param $jp The variable declaration
+ * @returns An array of functions that reference the variable
+ */
+export function findReferencingFunctions($jp: Vardecl): FunctionJp[] {
+    const fileJp = $jp.getAncestor("file");
+    const functionsJp = Query.searchFrom(fileJp, FunctionJp).get();
+    
+    return functionsJp
+        .filter(funcJp => 
+            Query.searchFrom(funcJp, Varref, {decl: (declJp) => declJp?.astId === $jp.astId}).get().length > 0
+        );
+}
+
+/**
+ * Finds duplicate definitions of the given variable declaration among external linkage variables
+ *
+ * @param $jp The variable declaration to evaluate
+ * @returns An array of variable declarations representing duplicates
+ */
+export function findDuplicateVarDefinition($jp: Vardecl): Vardecl[] {
+    return getExternalLinkageVars().filter((varDeclJp) => varDeclJp.astId !== $jp.astId && isSameVarDecl(varDeclJp, $jp));   
+}
+
+/**
+ * Checks whether two joinpoints represent the same variable declaration by comparing identifier name, type, and external linkage
+ *
+ * @param $jp1 The first join point
+ * @param $jp2 The second join point
+ * @returns True if both are equivalent external variable declarations, false otherwise
+ */
+export function isSameVarDecl($jp1: Joinpoint, $jp2: Joinpoint): boolean {
+    return $jp1 instanceof Vardecl && $jp2 instanceof Vardecl &&
+            isExternalLinkageIdentifier($jp1) && isExternalLinkageIdentifier($jp2) &&
+            getIdentifierName($jp1) === getIdentifierName($jp2) &&
+		    $jp1.type.code === $jp2.type.code
+}
+
+/**
+ * Checks if the given variable has multiple external linkage declarations across different files
+ *
+ * @param $jp The variable declaration to evaluate
+ * @returns True if multiple external declarations exist, false otherwise
+ */
+
+export function hasMultipleExternalLinkDeclarations($jp: Vardecl): boolean {
+    return getExternalLinkageIdentifiers().some(identifier => 
+        isSameVarDecl(identifier, $jp) && identifier.getAncestor("file").ast !== $jp.getAncestor("file").ast
+    );
+}
+
+/**
+ * Checks whether the given variable declaration is used in its file or in files that include its header.
+ *
+ * @param varDecl The variable declaration to check
+ * @returns True if the variable is referenced, false otherwise
+ */
+export function isVarUsed(varDecl: Vardecl): boolean {
+    const fileJp = varDecl.getAncestor("file") as FileJp;
+    let referencingFiles: FileJp[];
+
+    if (fileJp.isHeader) {
+        const filesWithInclude = findFilesReferencingHeader(fileJp.name);
+        referencingFiles = [fileJp, ...filesWithInclude];
+    } else {
+        referencingFiles = [fileJp];
+    }
+    return referencingFiles.some(fileJp => Query.searchFrom(fileJp, Varref, {name: varDecl.name, decl: (declJp) => declJp?.astId === varDecl.astId}).get().length > 0)
+}

package/tsconfig.json

@@ -13,7 +13,8 @@
     "sourceMap": true,
     "declarationMap": true,
     "allowSyntheticDefaultImports": true,
-    "resolveJsonModule": true
+    "resolveJsonModule": true,
+    "isolatedModules": true,
     //"esModuleInterop": true
   }
 }

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

@@ -1,120 +0,0 @@
-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/Section3_Comments/Rule_3_2_LineSplicing.ts

@@ -1,36 +0,0 @@
-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);
-    }
-}