@specs-feup/clava-misra 1.0.0 → 1.0.2

package/src/tests/Section2_UnusedCode/Rule_2_6_UnusedLabels.test.ts

@@ -0,0 +1,49 @@
+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 = `
+    int test1() {
+        int x = 0;
+        goto label1;
+
+        label1: 
+            x++;
+
+        return 0;
+    }`;
+
+const failingCode = `
+    int test2() {
+        int x = 0;
+        label1: 
+            x = 1;
+            label2:
+                x++;
+
+        goto label3;
+
+        label3: 
+            x += 4;
+        return 0;
+    }`;
+
+const files: TestFile[] = [
+    { name: "bad.c", code: failingCode },
+    { name: "good.c", code: passingCode }
+];
+
+describe("Rule 2.6", () => {
+    registerSourceCode(files);
+
+    it("should detect errors in bad.c", () => {
+        expect(countMISRAErrors()).toBe(2);
+
+        expect(countMISRAErrors(Query.search(FileJp, {name: "bad.c"}).first()!)).toBe(2);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "good.c"}).first()!)).toBe(0);
+    });
+
+    it("should correct errors in bad.c", () => {
+        expect(countErrorsAfterCorrection()).toBe(0);
+    });
+});

package/src/tests/Section2_UnusedCode/Rule_2_7_UnusedParameters.test.ts

@@ -0,0 +1,55 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestFile } from "../utils.js";
+import { FileJp } from "@specs-feup/clava/api/Joinpoints.js";
+
+const failingCode = `
+    int foo(int x, int y, int z); 
+
+    int foo(int x, int y, int z) { 
+        y++;
+        return y;
+    }
+
+    int main() {
+        int a = 5, b = 10, c = 15;
+        int result1 = foo(a, b, c);
+
+        int result2 = result1 + foo(a, b, c);
+        
+        return result2;
+    }`;
+
+const passingCode = `
+    extern int foo(int x, int y, int z);
+
+    int my_func(int x, int y, int z) {
+        return x + y + z;
+    }
+        
+    int my_func2() {
+        return 0;
+    }
+
+    int bar() { 
+        return my_func(1, 2, 3) + foo(50, 51, 52);
+    }`;
+
+const files: TestFile[] = [
+    { name: "bad.c", code: failingCode },
+    { name: "good.c", code: passingCode }
+];
+
+describe("Rule 2.7", () => {
+    registerSourceCode(files);
+
+    it("should detect errors in bad.c", () => {
+        expect(countMISRAErrors()).toBe(2);
+        
+        expect(countMISRAErrors(Query.search(FileJp, {name: "bad.c"}).first()!)).toBe(2);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "good.c"}).first()!)).toBe(0);
+    });
+
+    it("should correct errors in bad.c", () => {
+        expect(countErrorsAfterCorrection()).toBe(0);
+    });
+});

package/src/tests/Section3_Comments/Rule_3_1_CommentSequences.test.ts

@@ -0,0 +1,37 @@
+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 = `int main() {
+    int x, y, z;// good inline comment
+    // good */ comment
+    return 0;
+}`;
+
+const failingCode = `int test() {
+    int x, y, z; // bad inl/*ine comment
+
+    /* bad /* block comment */
+
+    return 0;
+}`;
+
+const files: TestFile[] = [
+    { name: "bad.c", code: failingCode },
+    { name: "good.c", code: passingCode }
+];
+
+describe("Rule 3.1", () => {
+    registerSourceCode(files);
+
+    it("should detect errors in bad.c", () => {
+        expect(countMISRAErrors()).toBe(2);
+
+        expect(countMISRAErrors(Query.search(FileJp, {name: "bad.c"}).first()!)).toBe(2);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "good.c"}).first()!)).toBe(0);
+    });
+
+    it("should correct errors in bad.c", () => {
+        expect(countErrorsAfterCorrection()).toBe(0);
+    });
+});

package/src/tests/utils.ts

@@ -0,0 +1,51 @@
+import MISRATool from "../MISRATool.js";
+import Clava from "@specs-feup/clava/api/clava/Clava.js";
+import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
+import { FileJp, Program } from "@specs-feup/clava/api/Joinpoints.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import * as os from 'os';
+
+export function countMISRAErrors(startingPoint: FileJp | Program = Query.root() as Program): number {
+  MISRATool.checkCompliance(startingPoint);
+  return MISRATool.getErrorCount();
+}
+
+export function countErrorsAfterCorrection(configPath?: string): number {
+  MISRATool.applyCorrections(configPath);
+  return MISRATool.getActiveErrorCount();
+}
+
+export interface TestFile {
+    name: string,
+    code: string
+    path?: string
+}
+
+export function registerSourceCode(files: TestFile[]): void {
+    beforeEach(() => {
+      const dataStore = Clava.getData();
+
+      dataStore.setStandard(process.env.STD_VERSION!);
+
+      // If running on macOS, change libcCxxMode
+      if (os.platform() === 'darwin') {
+        const key = "libcCxxMode";
+        const allowedValues = dataStore.getType(key).getEnumConstants();
+        const systemValue = allowedValues.find((value: any) => value.name() === "SYSTEM");
+        dataStore.put(key, systemValue);
+      }
+
+      Clava.getProgram().push();
+      const program = Clava.getProgram();
+      files.forEach(file => {
+        const sourceFile = ClavaJoinPoints.fileWithSource(file.name, file.code, file.path);
+        program.addFile(sourceFile);
+      });
+      program.rebuild();
+    });
+  
+    afterEach(() => {
+      Clava.getProgram().rebuild();
+      Clava.getProgram().pop();
+    });
+}

package/src/utils/utils.ts

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

package/tsconfig.json

@@ -1,6 +1,6 @@
 {
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules", "**/*.spec.ts", "**/*.test.ts"],
+  "include": ["src/**/*.ts", "src/**/*.json"],
+  "exclude": ["node_modules", "**/*.spec.ts", "**/*.test.ts", "src/misra-old"],
   "compilerOptions": {
     "outDir": "dist",
     "target": "ES2022",
@@ -12,7 +12,8 @@
     "moduleResolution": "NodeNext",
     "sourceMap": true,
     "declarationMap": true,
-    "allowSyntheticDefaultImports": true
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true
     //"esModuleInterop": true
   }
 }

package/typedoc.config.js

@@ -1,6 +1,6 @@
 import { fileURLToPath } from "url";
 
 export default {
-  extends: [ fileURLToPath(import.meta.resolve("lara-js/typedoc.base.json")) ],
+  extends: [ fileURLToPath(import.meta.resolve("@specs-feup/lara/typedoc.base.json")) ],
   entryPoints: ["src/"],
 }

package/CxxSources/lib.cpp

@@ -1,3 +0,0 @@
-#include <stdio.h>
-
-void foo() { printf("Hello, world!"); }

package/CxxSources/lib.h

@@ -1,8 +0,0 @@
-#ifndef __LIB_H__
-#define __LIB_H__
-
-#include <stdio.h>
-
-void foo();
-
-#endif // __LIB_H__

package/CxxSources/main.cpp

@@ -1,40 +0,0 @@
-void f ( void )
-{
-    int x, y, z;
-    int flag;
-    switch (x) {
-        case 1:
-            z = y+x;
-            break;
-        case 2:
-            z = y-x;
-            break;
-        default:
-            z = 4;
-            break;
-    }
-    switch (flag) {
-        case 0:
-            x = 2;
-            break;
-        case 1: 
-            x = 4;
-            break;
-        case 2:
-            x = 6;
-            break;
-    }
-    switch (z) {
-        case 1:
-            y = 0;
-            break;
-        case 6:
-        case 42:
-            y = 1;
-            break;
-        case 9139:
-        default:
-            y = 2;
-            break;
-    }
-}

package/TODO.md

@@ -1 +0,0 @@
-section 8 has a rule that hasn't been adapted yet

package/consumer_order.txt

@@ -1,2 +0,0 @@
-ASTConsumer built 1
-ASTConsumer destroyed 1