@specs-feup/clava-misra 1.0.2 → 1.0.3

package/src/utils/TypeDeclUtils.ts

@@ -0,0 +1,89 @@
+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,70 @@
+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);
+}
+
+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
+        );
+}
+
+export function findDuplicateVarDefinition($jp: Vardecl): Vardecl[] {
+    return getExternalLinkageVars().filter((varDeclJp) => varDeclJp.astId !== $jp.astId && isSameVarDecl(varDeclJp, $jp));   
+}
+
+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
+}
+
+export function hasMultipleExternalLinkDeclarations($jp: Vardecl): boolean {
+    return getExternalLinkageIdentifiers().some(identifier => 
+        isSameVarDecl(identifier, $jp) && identifier.getAncestor("file").ast !== $jp.getAncestor("file").ast
+    );
+}
+
+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);
-    }
-}

package/src/utils/utils.ts

@@ -1,280 +0,0 @@
-import Query from "@specs-feup/lara/api/weaver/Query.js";
-import { Comment, Type, Case, Joinpoint, ArrayType, TypedefDecl, DeclStmt, TypedefNameDecl, StorageClass, FunctionJp, Vardecl, FileJp, RecordJp, EnumDecl, PointerType, Switch, BuiltinType, BinaryOp, Break, Scope, Statement, Expression, WrapperStmt, ElaboratedType, TagType, Param, Varref, Program, Include, Call } from "@specs-feup/clava/api/Joinpoints.js";
-import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
-
-/**
- * Checks if the comment is an inline comment
- * @param $comment - The comment to check
- * @returns Returns true if it's an inline comment, otherwise returns false
- */
-export function isInlineComment($comment: Comment): boolean {
-    return $comment.astName === "InlineComment";
-}
-
-/**
- * Retrieves all comments associated with a given joinpoint
- * @param $jp - The joinpoint to retrieve comments from
- * @returns Array of comments
- */
-export function getComments($jp: Joinpoint): Comment[] {
-    return $jp instanceof Comment ? [$jp] : $jp.inlineComments;
-}
-
-/**
- * Checks if a given join point is a comment statement
- *
- * @param $jp The join point to check
- * @returns Returns true if the given join point is a comment statement, otherwise false
- */
-export function isCommentStmt($jp: Joinpoint): boolean {
-    return $jp instanceof WrapperStmt && $jp.kind === "comment";
-}
-
-export function getParamReferences($param: Param, $startingPoint: Joinpoint): Varref[] {
-    return Query.searchFrom($startingPoint, Varref, (ref) => {
-                try {
-                    return ref.decl && ref.decl.astId === $param.astId;
-                } catch (error) {
-                    return false;
-                }
-            }).get();
-}
-
-/**
- * Checks if a storage class has external linkage
- * @param $class - The storage class to check
- * @returns Returns true if the class has external linkage, otherwise returns false
- */
-export function hasExternalLinkage($class: StorageClass) {
-    return $class !== StorageClass.STATIC && $class !== StorageClass.EXTERN;
-}
-
-/**
- * Retrieves all variables and functions that can be externed from the files, i.e., 
- * elements with storage classes that are not `STATIC` or `EXTERN`
- * @returns Array of functions and variables that can be externed
- */
-export function getExternals(): (FunctionJp | Vardecl)[] {
-    let result: (FunctionJp | Vardecl)[] = [];
-
-    for (const file of  Query.search(FileJp).get()) {
-        for(const child of file.children) {
-            if((child instanceof Vardecl || child instanceof FunctionJp) && hasExternalLinkage(child.storageClass)) {
-                result.push(child);
-            }
-        }
-    }
-    return result;
-}
-
-/**
- * Checks if the provided node has a defined type
- * @param $jp The joinpoint to check its type
- * @returns true if the joinpoint has a defined type, otherwise false
- */
-export function hasDefinedType($jp: Joinpoint): boolean {
-    return $jp.hasType && $jp.type !== null && $jp.type !== undefined;
-}
-
-/**
- * Retrieves the base type of the provided joinpoint. 
- * @param $jp The joinpoint to retrieve its type
- * @returns The base type of the joinpoint, or undefined if the joinpoint does not have a type
- */
-export function getBaseType($jp: Joinpoint): Type | undefined {
-    if (!hasDefinedType($jp)) return undefined;
-    let jpType = $jp.type;
-
-    while (jpType instanceof PointerType || jpType instanceof ArrayType) {
-        jpType = jpType instanceof PointerType ? jpType.pointee : jpType.elementType;
-    } 
-    return jpType;
-}
-
-/**
- * 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 getTypeDecl($jp: Joinpoint): TypedefDecl | undefined {
-    if ($jp instanceof DeclStmt && $jp.children.length === 1 && $jp.children[0] instanceof TypedefDecl)
-        return $jp.children[0];
-
-    if ($jp instanceof RecordJp || $jp instanceof EnumDecl) {
-        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 hasTypeDecl($jp: Joinpoint): boolean {
-    return getTypeDecl($jp) !== undefined;
-}
-
-/**
- * Retrieves all joinpoints with a defined type 
- * @returns Array of joinpoints with a defined type
- */
-export function getTypedJps(startingPoint?: Joinpoint): Joinpoint[] {
-    if (startingPoint) {
-        return Query.searchFrom(startingPoint, Joinpoint, (jp) => hasDefinedType(jp)).get();
-    }
-    return Query.search(Joinpoint, (jp) => hasDefinedType(jp)).get();
-}
-
-/**
- * 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 isTagUsed($jp: Joinpoint, tag: RecordJp | EnumDecl): boolean {
-    const jpType = getBaseType($jp);
-    return jpType instanceof ElaboratedType && 
-        jpType.namedType instanceof TagType && 
-        jpType.namedType.decl.astId === tag.astId &&
-        $jp.astId !== getTypeDecl(tag)?.astId
-}
-
-/**
- * Retrieves all joinpoints that use the specified tag declaration
- * 
- * @param tag The tag to search for in the joinpoints
- * @returns Array of joinpoints that use the specified tag declaration
- */
-export function getTagUses(tag: RecordJp | EnumDecl): Joinpoint[] {
-    return getTypedJps().filter(jp => isTagUsed(jp, tag));
-}
-
-/**
- * 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 lastStmt: Joinpoint | undefined;
-    for (const stmt of $jp.siblingsRight) {
-        if (stmt instanceof Case) {
-            break;
-        }
-        lastStmt = stmt;
-    }
-    return lastStmt;
-} 
-
-/**
- * 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 getNumOfSwitchClauses($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 has a Boolean condition
- * @param switchStmt The switch statement to check
- * @returns Returns true if the switch statement has a Boolean condition, otherwise false
- */
-export function switchHasBooleanCondition(switchStmt: Switch): boolean {
-    return switchStmt.condition instanceof BinaryOp ||
-            (hasDefinedType(switchStmt.condition) &&
-             switchStmt.condition.type instanceof BuiltinType &&
-              switchStmt.condition.type.builtinKind === "Bool"
-            );
-}
-
-/**
- * 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 switchHasConditionalBreak(switchStmt: Switch): boolean {
-    return Query.searchFrom(switchStmt, Break, { currentRegion: region => region.astId !== switchStmt.astId, enclosingStmt: jp => jp.astId === switchStmt.astId }).get().length > 0;
-}
-
- /**
- * Checks if a file compiles correctly after adding a statement by rebuilding it.
- * If rebuilding fails, the file is considered invalid with the new statement.
- * 
- * @param fileJp - The file to validate.
- */
-export function isValidFile(fileJp: FileJp) : boolean {
-    const programJp = fileJp.parent as Program;
-    let copyFile = ClavaJoinPoints.fileWithSource(`temp_misra_${fileJp.name}`, fileJp.code, fileJp.relativeFolderpath);
-
-    copyFile = programJp.addFile(copyFile) as FileJp;
-    try {
-        const rebuiltFile = copyFile.rebuild();
-        const fileToRemove = Query.searchFrom(programJp, FileJp, {filepath: rebuiltFile.filepath}).first();
-        fileToRemove?.detach();
-        return true;
-    } catch(error) {
-        copyFile.detach();
-        return false;
-    }
-}
-
-/**
- * Retrieves the list of header files included in the given file
- *
- * @param fileJp The file join point
- * @returns An array of strings with the names of the includes
- */
-export function getIncludesOfFile(fileJp: FileJp): string[] {
-    return fileJp.includes.map(includeJp => includeJp.name);
-}
-
-/**
- * Removes a specific include directive from the given file, if it exists
- *
- * @param includeName The name of the include to remove 
- * @param fileJp The file from which the include should be removed
- */
-export function removeIncludeFromFile(includeName: string, fileJp: FileJp) {
-    const include = Query.searchFrom(fileJp, Include, {name: includeName}).first();
-    include?.detach();
-}
-
-/**
- * Check if the given joinpoint represents a call to an implicit function.
- *
- * @param callJp The call join point to analyze
- */
-export function isCallToImplicitFunction(callJp: Call): boolean {
-    return callJp.function.definitionJp === undefined && !callJp.function.isInSystemHeader;
-}
-
-/**
- * Returns all files in the program that contain at least one call to an implicit function
- *
- * @param programJp - The program to analyze
- * @returns A list of files with implicit function calls
- */
-export function getFilesWithCallToImplicitFunction(programJp: Program): FileJp[] {
-    const files = Query.searchFrom(programJp, FileJp).get();
-    return files.filter(
-      (fileJp) =>
-        Query.searchFrom(fileJp, Call, (callJp) =>
-          isCallToImplicitFunction(callJp)
-        ).get().length > 0
-    );
-}