@specs-feup/clava-misra 1.0.0 → 1.0.1

package/src/utils/utils.ts

@@ -0,0 +1,221 @@
+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 } from "@specs-feup/clava/api/Joinpoints.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 type is not defined
+ */
+export function getBaseType($jp: Joinpoint): Type | undefined {
+    if (!hasDefinedType($jp)) return undefined;
+
+    let jpType: Type;
+    if ($jp.type instanceof PointerType) {
+        jpType = $jp.type.pointee;
+        while (jpType instanceof PointerType) {
+            jpType = jpType.pointee;
+        }
+    } else if ($jp.type instanceof ArrayType) {
+        jpType = $jp.type.elementType;
+    } else {
+        jpType = $jp.type;
+    }
+    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).get().filter(jp => jp.hasType && jp.type !== null && jp.type !== undefined)
+    }
+    return Query.search(Joinpoint).get().filter(jp => 
+        jp.hasType && 
+        jp.type !== null && 
+        jp.type !== undefined);
+}
+
+/**
+ * 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;
+}

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

package/src/misra/passes/S16_SwitchStatementPass.ts

@@ -1,168 +0,0 @@
-import { LaraJoinPoint } from "@specs-feup/lara/api/LaraJoinPoint.js";
-import MISRAPass from "../MISRAPass.js";
-import { PreprocessingReqs } from "../MISRAReporter.js";
-import { BinaryOp, Break, BuiltinType, Case, Expression, Joinpoint, Switch } from "@specs-feup/clava/api/Joinpoints.js";
-import Fix from "@specs-feup/clava/api/clava/analysis/Fix.js";
-import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
-
-export default class S16_SwitchStatementPass extends MISRAPass {
-    protected _preprocessingReqs: PreprocessingReqs[] = [];
-    private _wellFormedSwitch: boolean = false;
-
-    initRuleMapper(): void {
-        this._ruleMapper = new Map([
-            [1, this.r16_1_16_3_wellFormedSwitch.bind(this)],
-            [2, this.r16_2_topLevelSwitchLabels.bind(this)],
-            [4, this.r16_4_switchHasDefault.bind(this)],
-            [5, this.r16_5_defaultFirstOrLast.bind(this)],
-            [6, this.r16_6_noTwoClauses.bind(this)],
-            [7, this.r16_7_noEssentialBooleanInSwitch.bind(this)]
-        ]);
-    }
-    
-    matchJoinpoint($jp: LaraJoinPoint): boolean {
-        return $jp instanceof Switch || $jp instanceof Case;
-    }
-
-    private r16_1_16_3_wellFormedSwitch($startNode: Joinpoint) {
-        if (!($startNode instanceof Switch)) return;
-        this._wellFormedSwitch = true;
-
-        let foundStmt = false;
-        let first = true;
-        for (const child of $startNode.children[1].children) {
-            if (child instanceof Break) {;
-                foundStmt = false;
-            }
-            else if (child instanceof Case) {
-                first = false;
-            }
-            else {
-                foundStmt = true;
-            }
-
-            if (foundStmt && child instanceof Case) {
-                this.logMISRAError(`A break is missing before ${child.code}`);
-                this._wellFormedSwitch = false;
-            }
-        }
-        if (!($startNode.children[1].lastChild instanceof Break)) {
-            this.logMISRAError("A break is missing at the end of the switch statement.");
-            this._wellFormedSwitch = false;
-        }  
-    }
-
-    private r16_2_topLevelSwitchLabels($startNode: Joinpoint) {
-        if (!($startNode instanceof Case)) return;
-
-        if (!($startNode.currentRegion instanceof Switch)) {
-            this.logMISRAError("A switch label can only be used if its enclosing compound statement is the switch statement itself.");
-        }
-    }
-
-    private r16_4_switchHasDefault($startNode: Joinpoint) {
-        if (!($startNode instanceof Switch && !$startNode.hasDefaultCase)) return;
-
-        this.logMISRAError("Switch statement is missing a default case.");
-    }
-    
-
-    private r16_5_defaultFirstOrLast($startNode: Joinpoint) {
-        if (!($startNode instanceof Switch)) return;
-
-        for (let i = 0; i < $startNode.cases.length; i++) {
-            if ($startNode.cases[i].isDefault && (i == 0 || i == $startNode.cases.length-1)) {
-                return;
-            }
-            else if ($startNode.cases[i].isDefault) {
-                this.logMISRAError("The default case of a switch statement must be the first or last label.");
-                return;
-            }
-        }
-    }
-
-    private r16_6_noTwoClauses($startNode: Joinpoint) {
-        if (!($startNode instanceof Switch)) return;
-        this.dependsOn(1, $startNode);
-        if (this._wellFormedSwitch === false) return; 
-
-        let clauses = 0;
-        for (const child of $startNode.children[1].children) {
-            if (child instanceof Break) {
-                clauses++;
-            }
-        }
-
-        if (clauses <= 2) {
-            this.logMISRAError("Switch statements should have more than two clauses.", new Fix(
-                $startNode,
-                (switchStmt: Joinpoint) => {
-                    const switchJp = switchStmt as Switch;
-                    let firstClauseExpr: Expression | undefined = undefined;
-                    let secondClauseExpr: Expression | undefined = undefined;
-                    let firstClause: Joinpoint[] = [];
-                    let secondClause: Joinpoint[] = [];
-                    let currClauseExpr: Expression | undefined = undefined;
-                    let currClause: Joinpoint[] = [];
-                    let clauseHasDefault: boolean = false;
-                    let filledFirstClause: boolean = false;
-                    const newVar = ClavaJoinPoints.varDecl("switchToIf_" + switchJp.astId, switchJp.condition);
-                    switchJp.insertBefore(newVar.stmt);
-                    for (const child of switchStmt.children[1].children) {
-                            if (child instanceof Case) {
-                                let tempOp: BinaryOp;
-                                if (child.isDefault) {
-                                    clauseHasDefault = true;
-                                    continue;
-                                }
-                                else if (child.values.length === 1) {
-                                    tempOp = ClavaJoinPoints.binaryOp("eq", newVar.varref(), child.values[0]);
-                                }
-                                else {
-                                    tempOp = ClavaJoinPoints.binaryOp("l_or", ClavaJoinPoints.binaryOp("ge", newVar.varref(), child.values[0]), ClavaJoinPoints.binaryOp("le", newVar.varref(), child.values[1]));
-                                }
-                                currClauseExpr = currClauseExpr ? ClavaJoinPoints.binaryOp("l_or", currClauseExpr, tempOp) : tempOp;
-                            }
-                            else if (child instanceof Break) {
-                                if (clauseHasDefault) {
-                                    secondClause = currClause;
-                                    secondClauseExpr = undefined;
-                                }
-                                else if (filledFirstClause) {
-                                    secondClause = currClause;
-                                    secondClauseExpr = currClauseExpr;
-                                }
-                                else {
-                                    firstClause = currClause;
-                                    firstClauseExpr = currClauseExpr;
-                                    filledFirstClause = true;
-                                }
-                                clauseHasDefault = false;
-                                currClause = [];
-                                currClauseExpr = undefined;
-                            }
-                            else {
-                                currClause.push(child);
-                            }
-                    }
-
-                    const elseStmt = secondClauseExpr ? ClavaJoinPoints.ifStmt(secondClauseExpr, ClavaJoinPoints.scope(...secondClause)) : ClavaJoinPoints.scope(...secondClause);
-                    switchJp.replaceWith(ClavaJoinPoints.ifStmt(firstClauseExpr ?? "", ClavaJoinPoints.scope(...firstClause), elseStmt));
-                }
-            ));
-        }
-    }
-
-    private r16_7_noEssentialBooleanInSwitch($startNode: Joinpoint) { //UNFINISHED, can have transformation
-        if (!($startNode instanceof Switch)) return;
-        this.dependsOn(1, $startNode);
-        if (this._wellFormedSwitch === false) return;
-
-        if ($startNode.condition.type.desugarAll instanceof BuiltinType && $startNode.condition.type.desugarAll.builtinKind === "Bool") {
-            this.logMISRAError("The controlling expression of a switch statement must not have essentially boolean type.");
-        }
-    }
-
-    protected _name: string = "Switch statements";
-
-}

package/src/misra/passes/S3_CommentPass.ts

@@ -1,40 +0,0 @@
-import { LaraJoinPoint } from "@specs-feup/lara/api/LaraJoinPoint.js";
-import MISRAPass from "../MISRAPass.js";
-import { PreprocessingReqs } from "../MISRAReporter.js";
-import { Comment, Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
-import Fix from "@specs-feup/clava/api/clava/analysis/Fix.js";
-
-export default class S3_CommentPass extends MISRAPass {
-    protected _preprocessingReqs: PreprocessingReqs[] = [];
-
-    initRuleMapper(): void {
-        this._ruleMapper = new Map([
-            [3, this.r3_1_fixComments.bind(this)]
-        ]);
-    }
-
-    matchJoinpoint($jp: LaraJoinPoint): boolean {
-        return true;
-    }
-
-    private static removeCommentSequences(str: string) {
-        return str.replace(/(\/\/|\/\*)/g, '');
-    }
-    
-    private r3_1_fixComments($startNode: Joinpoint) { //inlines
-        if ($startNode instanceof Comment && /(\/\/|\/\*)/g.test($startNode.text)) {
-            this.logMISRAError(`Comment ${$startNode.text} contains invalid character sequences.`, new Fix(
-                $startNode,
-                $jp => ($jp as Comment).setText(S3_CommentPass.removeCommentSequences($startNode.text))
-            ));
-        } 
-        $startNode.inlineComments.filter(comment => /(\/\/|\/\*)/g.test(comment.text)).forEach(comment => {
-            this.logMISRAError(`Comment ${comment.text} contains invalid character sequences.`, new Fix(
-                $startNode,
-                $jp => ($jp as Comment).setText(S3_CommentPass.removeCommentSequences(comment.text))
-            ));
-        });
-    }
-
-    protected _name: string = "Comments";
-}

package/src/misra/sections/Section21_StandardLibraries.ts

@@ -1,65 +0,0 @@
-import Query from "@specs-feup/lara/api/weaver/Query.js";
-import { Call, FileJp, Include, Joinpoint, Program } from "@specs-feup/clava/api/Joinpoints.js";
-import MISRAAnalyser from "../MISRAAnalyser.js";
-
-export default class Section21_StandardLibraries extends MISRAAnalyser {
-    ruleMapper: Map<number, (jp: FileJp | Program) => void>;
-
-    constructor(rules: number[]) {
-        super(rules);
-        this.ruleMapper = new Map([
-            [3, this.r21_3_noDynamicAllocation.bind(this)],
-            [4, this.r21_4_noSetjmpUsage.bind(this)],
-            [5, this.r21_5_noSignalUsage.bind(this)],
-            [6, this.r21_6_noStandardIO.bind(this)],
-            [7, this.r21_7_noStringFunctions.bind(this)],
-            [8, this.r21_8_noSysFunctions.bind(this)],
-            [9, this.r21_9_noStdAlgos.bind(this)],
-            [10, this.r21_10_noDateUsage.bind(this)],
-            [11, this.r21_11_noTgmathUsage.bind(this)],
-            [12, this.r21_12_noFenvExceptions.bind(this)]
-        ]);
-    }
-
-    private r21_3_noDynamicAllocation($startNode: Joinpoint) {
-        Query.searchFrom($startNode, Call, {name: /(malloc|realloc|calloc|free)/}).get().forEach(call => this.logMISRAError(call, "Use of memory allocation functions provided by <stdlib.h> is not allowed."), this);
-    }
-
-    private r21_4_noSetjmpUsage($startNode: Joinpoint) {
-        Query.searchFrom($startNode, Include, {name: "setjmp.h", isAngled: true}).get().forEach(include => this.logMISRAError(include, "Use of <setjmp.h> is not allowed."), this);
-    }
-    
-    private r21_5_noSignalUsage($startNode: Joinpoint) {
-        Query.searchFrom($startNode, Include, {name: "signal.h", isAngled: true}).get().forEach(include => this.logMISRAError(include, "Use of <setjmp.h> is not allowed."), this);
-    }
-
-    private r21_6_noStandardIO($startNode: Joinpoint) {
-        Query.searchFrom($startNode, Include, {name: /(stdio.h|wchar.h)/}).get().forEach(include => this.logMISRAError(include, "Use of the standard library I/O functions provided by <stdio.h> and <wchar.h> is not allowed."), this);
-    }
-
-    //how to avoid triggering errors for functions with the same name?
-    private r21_7_noStringFunctions($startNode: Joinpoint) {
-        Query.searchFrom($startNode, Call, {name: /(atoi|atof|atol|atoll)/}).get().forEach(call => this.logMISRAError(call, `Use of function ${call.signature} is not allowed.`), this);
-    }
-
-    private r21_8_noSysFunctions($startNode: Joinpoint) {
-        Query.searchFrom($startNode, Call, {name: /(system|abort|exit|getenv)/}).get().forEach(call => this.logMISRAError(call, `Use of function ${call.signature} is not allowed.`), this);
-    }
-
-    private r21_9_noStdAlgos($startNode: Joinpoint) {
-        Query.searchFrom($startNode, Call, {name: /(qsort|bsearch)/}).get().forEach(call => this.logMISRAError(call, `Use of function ${call.signature} is not allowed.`), this);
-    }
-
-    private r21_10_noDateUsage($startNode: Joinpoint) {
-        Query.searchFrom($startNode, Include, {name: "time.h", isAngled: true}).get().forEach(include => this.logMISRAError(include, "Use of <time.h> is not allowed."), this);
-        Query.searchFrom($startNode, Call, {name: "wcsftime"}).get().forEach(call => this.logMISRAError(call, "Identifier 'wcsftime' shall not be used."), this);
-    }
-    
-    private r21_11_noTgmathUsage($startNode: Joinpoint) {
-        Query.searchFrom($startNode, Include, {name: "tgmath.h", isAngled: true}).get().forEach(include => this.logMISRAError(include, "Use of <tgmath.h> is not allowed."), this);
-    }
-
-    private r21_12_noFenvExceptions($startNode: Joinpoint) {
-        Query.searchFrom($startNode, Call, {name : /(feclearexcept|fegetexceptflag|feraiseexcept|fesetexceptflag|fetestexcept)/}).get().forEach(call => this.logMISRAError(call, `Use of function ${call.signature} is not allowed`), this);
-    }
-}