@specs-feup/clava-misra 1.0.0

package/CxxSources/lib.cpp

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

package/CxxSources/lib.h

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

package/CxxSources/main.cpp

@@ -0,0 +1,40 @@
+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/README.md

@@ -0,0 +1,32 @@
+# clava-project-template
+
+A template for developing projects for Clava in Typescript
+
+## Installing dev environment
+
+Execute the following commands to download all the required code:
+
+```bash
+npm install
+```
+
+## Executing Clava-JS
+
+You can execute your project in Clava by running the following on your terminal
+
+```bash
+npm run run
+```
+
+Take a look inside the `scripts` field in the `package.json` file for more information.
+
+You can also run tests, get test coverage information and generate documentation for your project.
+
+## Debugging
+
+You can get debugging information using a `DEBUG` environment variable.
+This variable is used by the [debug](https://www.npmjs.com/package/debug) module to determine what to expose.
+
+```bash
+DEBUG="*" npm run run
+```

package/TODO.md

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

package/consumer_order.txt

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

package/jest.config.js

@@ -0,0 +1,25 @@
+import { weaverConfig } from "clava-js/code/WeaverConfiguration.js";
+
+const config = {
+  preset: "ts-jest/presets/default-esm",
+  testEnvironment: "lara-js/jest/jestEnvironment.js",
+  testEnvironmentOptions: {
+    weaverConfig,
+  },
+  globalSetup: "lara-js/jest/jestGlobalSetup.js",
+  globalTeardown: "lara-js/jest/jestGlobalTeardown.js",
+  setupFiles: ["lara-js/jest/setupFiles/sharedJavaModule.js"],
+  //notify: true,
+  //notifyMode: "always",
+  //verbose: true,
+  collectCoverage: false,
+  coverageDirectory: "coverage",
+  coverageReporters: ["text", "lcov"],
+  collectCoverageFrom: ["src/**/*[^.d].(t|j)s"],
+  coverageProvider: "v8",
+  moduleNameMapper: {
+    "(.+)\\.js": "$1",
+  }
+};
+
+export default config;

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@specs-feup/clava-misra",
+  "version": "1.0.0",
+  "author": "L. Sousa",
+  "description": "A template for developing projects for Clava in Typescript",
+  "type": "module",
+  "scripts": {
+    "run": "npx clava classic dist/main.js -p CxxSources/",
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "lint": "eslint .",
+    "docs": "typedoc",
+    "test": "cross-env NODE_OPTIONS='$NODE_OPTIONS --experimental-vm-modules' jest --detectOpenHandles --forceExit src",
+    "test:cov": "npm run test -- --coverage",
+    "test:watch": "npm run test -- --watch"
+  },
+  "dependencies": {
+    "@specs-feup/clava": "^3.0.5",
+    "@specs-feup/clava-visualization": "^1.0.4",
+    "@specs-feup/lara-visualization": "^1.0.3",
+    "@specs-feup/lara": "^3.0.4"
+  }
+}

package/src/foo.ts

@@ -0,0 +1,6 @@
+import { FunctionJp } from "@specs-feup/clava/api/Joinpoints.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+
+export function foo() {
+    return Query.search(FunctionJp).get().length;
+};

package/src/main.ts

@@ -0,0 +1,36 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { FunctionJp, Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import { foo } from "./foo.js";
+import S16_SwitchStatementPass from "./misra/passes/S16_SwitchStatementPass.js";
+import S15_ControlFlowPass from "./misra/passes/S15_ControlFlowPass.js";
+import MISRAReporter from "./misra/MISRAReporter.js";
+import S10_EssentialTypePass from "./misra/passes/S10_EssentialTypePass.js";
+import AggregatePassResult from "@specs-feup/lara/api/lara/pass/results/AggregatePassResult.js";
+import MISRAPassResult from "./misra/MISRAPassResult.js";
+import S12_ExpressionPass from "./misra/passes/S12_ExpressionPass.js";
+import S17_FunctionPass from "./misra/passes/S17_FunctionPass.js";
+import S13_SideEffectPass from "./misra/passes/S13_SideEffectPass.js";
+import S18_PointersArraysPass from "./misra/passes/S18_PointersArraysPass.js";
+
+import VisualizationTool from "@specs-feup/clava-visualization/api/VisualizationTool.js";
+
+const pass = new S16_SwitchStatementPass(true, [1, 6, 7]);
+const reporter = new MISRAReporter();
+
+console.log(Query.root().dump);
+
+const result = reporter.applyPass(
+  pass,
+  Query.root() as Joinpoint
+) as AggregatePassResult;
+if (result) {
+  result.results.forEach((res) => {
+    const reports = (res as MISRAPassResult).reports;
+    console.log(reports);
+    //reports.forEach(rep => rep.fix?.execute());
+  });
+}
+
+console.log("GADASDSAD");
+
+await VisualizationTool.visualize();

package/src/misra/MISRAAnalyser.ts

@@ -0,0 +1,43 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import Analyser from "@specs-feup/clava/api/clava/analysis/Analyser.js";
+import AnalyserResult from "@specs-feup/clava/api/clava/analysis/AnalyserResult.js";
+import { FileJp, Joinpoint, Program } from "@specs-feup/clava/api/Joinpoints.js";
+import ResultFormatManager from "@specs-feup/clava/api/clava/analysis/ResultFormatManager.js"
+import Fix from "@specs-feup/clava/api/clava/analysis/Fix.js";
+
+type T = Program | FileJp;
+
+export default abstract class MISRAAnalyser extends Analyser {
+    #rules: number[];
+    #resultFormatManager = new ResultFormatManager();
+    protected abstract ruleMapper: Map<number, (jp: T) => void>;
+    #results: AnalyserResult[] = [];
+
+    constructor(rules: number[]) {
+        super();
+        this.#rules = rules;
+    }
+
+    get rules(): number[] {return this.#rules.map(num => num)};
+
+    protected logMISRAError(jp: Joinpoint, message: string, fix?: Fix) {
+        this.#results.push(new AnalyserResult(`Non-compliant code at ${jp?.filename}@${jp?.line}:${jp?.column}.`, jp, message, fix))
+    }
+
+    analyse($startNode: T = Query.root() as Program) {
+        for (const rule of this.rules) {
+            const rulePass = this.ruleMapper.get(rule);
+            if (rulePass) {
+                rulePass($startNode);
+            }
+            else {
+                throw new Error("Analyser doesn't support rule number " + rule)
+            }
+        }
+
+        this.#resultFormatManager.setAnalyserResultList(this.#results);
+        const fileResult = this.#resultFormatManager.formatResultList($startNode);
+
+        return fileResult;
+    }
+}

package/src/misra/MISRAPass.ts

@@ -0,0 +1,85 @@
+import { Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import { LaraJoinPoint } from "@specs-feup/lara/api/LaraJoinPoint.js";
+import SimplePass from "@specs-feup/lara/api/lara/pass/SimplePass.js";
+import PassResult from "@specs-feup/lara/api/lara/pass/results/PassResult.js";
+import { Preprocessing, PreprocessingReqs } from "./MISRAReporter.js";
+import MISRAPassResult from "./MISRAPassResult.js";
+import Fix from "@specs-feup/clava/api/clava/analysis/Fix.js";
+
+export default abstract class MISRAPass extends SimplePass {
+    protected _ruleMapper: Map<number, ($jp: Joinpoint) => void> = new Map();
+    private _executedRules: Map<number, boolean> = new Map();
+    private _rules: number[];
+    private _currentRule: number = -1;
+    protected _preprocessing: Preprocessing | undefined;
+    private _result: MISRAPassResult | undefined;
+    protected abstract _preprocessingReqs: PreprocessingReqs[];
+
+    get preprocessingReqs() {
+        return this._preprocessingReqs;
+    }
+
+    abstract initRuleMapper(): void;
+
+    setPreprocessing($preprocessing: Preprocessing): void {
+        this._preprocessing = $preprocessing;
+    }
+
+    protected logMISRAError(message: string, fix?: Fix) {
+        this._result?.addReport({rule: this._currentRule, message, fix});
+    }
+
+    private resetRules(): void {
+        this._executedRules.forEach(($value: boolean, $key: number) => {
+            this._executedRules.set($key, false);
+        }, this);
+    }
+
+    constructor(includeDescendants: boolean = true, rules: number[]) {
+        super(includeDescendants);
+        this._rules = rules;
+        this.initRuleMapper();
+
+        this._ruleMapper.forEach(($value: ($jp: Joinpoint) => void, $key: number) => {
+            this._executedRules.set($key, false);
+        }, this);
+    }
+
+    private executeRule($id: number, $jp: Joinpoint) {
+        if (!this._ruleMapper.has($id)) {
+            throw new Error(`Pass does not support rule ${$id}`);
+        }
+
+        (this._ruleMapper.get($id) as ($jp: Joinpoint) => void)($jp);
+        this._executedRules.set($id, true);
+    }
+
+    protected dependsOn($id: number, $jp: Joinpoint) {
+        const tempId = this._currentRule;
+        if (this._executedRules.get($id) === false) {
+            this._currentRule = $id;
+            this.executeRule($id, $jp);
+        }
+        this._currentRule = tempId;
+    }
+
+    abstract matchJoinpoint($jp: LaraJoinPoint): boolean;
+
+    transformJoinpoint($jp: LaraJoinPoint): MISRAPassResult {
+        if (!this._preprocessing) {
+            throw new Error("Preprocessing object has not been set.");
+        }
+
+        this._result = new MISRAPassResult(this, $jp);
+        this.resetRules();
+        this._rules.forEach($id => {
+            this._currentRule = $id;
+            this.executeRule($id, $jp as Joinpoint);
+        }, this);
+
+        return this._result;
+    }
+
+    protected abstract _name: string;
+    
+}

package/src/misra/MISRAPassResult.ts

@@ -0,0 +1,20 @@
+import Fix from "@specs-feup/clava/api/clava/analysis/Fix.js";
+import PassResult from "@specs-feup/lara/api/lara/pass/results/PassResult.js";
+
+export interface MISRAReport {
+    rule: number,
+    message: string,
+    fix?: Fix
+}
+
+export default class MISRAPassResult extends PassResult {
+    protected _reports: MISRAReport[] = [];
+
+    get reports(): MISRAReport[] {
+        return this._reports;
+    }
+
+    addReport($report: MISRAReport) {
+        this._reports.push($report);
+    }
+}

package/src/misra/MISRAReporter.ts

@@ -0,0 +1,57 @@
+import { FileJp, FunctionJp, Joinpoint, StorageClass, TypedefNameDecl, Vardecl } from "@specs-feup/clava/api/Joinpoints.js";
+import MISRAPass from "./MISRAPass.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import PassResult from "@specs-feup/lara/api/lara/pass/results/PassResult.js";
+import AggregatePassResult from "@specs-feup/lara/api/lara/pass/results/AggregatePassResult.js";
+import MISRAPassResult from "./MISRAPassResult.js";
+
+export enum PreprocessingReqs {
+    TYPEDEF_DECLS = "typedefDecls",
+    EXTERNAL_LINKAGE_DECLS = "externalLinkageDecls"
+}
+
+export interface Preprocessing {
+    typedefDecls?: TypedefNameDecl[],
+    externalLinkageDecls?: (FunctionJp | Vardecl)[]
+}
+
+export default class MISRAReporter {
+    private _preprocessing: Preprocessing = {};
+    private _preprocessingMapper: Map<PreprocessingReqs, () => void> = new Map([
+        [PreprocessingReqs.TYPEDEF_DECLS, this.initTypedefs.bind(this)],
+        [PreprocessingReqs.EXTERNAL_LINKAGE_DECLS, this.initExternals.bind(this)]
+    ]);
+
+    private initTypedefs(): void {
+        this._preprocessing.typedefDecls = Query.search(TypedefNameDecl).get();
+    }
+
+    private static hasExternalLinkage($class: StorageClass) {
+        return $class !== StorageClass.STATIC && $class !== StorageClass.EXTERN;
+    }
+
+    private initExternals(): void {
+        this._preprocessing.externalLinkageDecls = [];
+        Query.search(FileJp).get().forEach(file => {
+            file.children.forEach(child => {
+                if ((child instanceof Vardecl || child instanceof FunctionJp) && MISRAReporter.hasExternalLinkage(child.storageClass)) {
+                    this._preprocessing.externalLinkageDecls?.push(child);
+                }
+            }, this);
+        }, this);
+    }
+
+    applyPass($pass: MISRAPass, $jp: Joinpoint): AggregatePassResult | undefined {
+        $pass.preprocessingReqs.forEach($req => {
+            if (!this._preprocessing[$req]) {
+                (this._preprocessingMapper.get($req) as () => void)();
+            }
+        });
+
+        $pass.setPreprocessing(this._preprocessing);
+        const result = $pass.apply($jp) as AggregatePassResult;
+        if ((result.results as MISRAPassResult[]).some(res => res.reports.length > 0)) {
+            return result;
+        }
+    }
+}