@specs-feup/clava-misra 1.0.2 → 1.0.4

package/src/MISRA.ts

@@ -1,9 +1,23 @@
-import { BinaryOp, Break, Case, Expression, If, Joinpoint, Program, Scope, Statement, Switch } from "@specs-feup/clava/api/Joinpoints.js";
-import { getNumOfSwitchClauses, isCommentStmt } from "./utils/utils.js";
+import { BinaryOp, Break, Case, Expression, If, Joinpoint, Scope, Statement, Switch } from "@specs-feup/clava/api/Joinpoints.js";
+import { isCommentStmt } from "./utils/CommentUtils.js";
 import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
 import Query from "@specs-feup/lara/api/weaver/Query.js";
-import Clava from "@specs-feup/clava/api/clava/Clava.js";
+import { countSwitchClauses } from "./utils/SwitchUtils.js";
 
+type NodeID = string;
+
+/**
+ * Specifies whether a MISRA rule is applied to a single translation unit
+ * or requires analysis of the entire program.
+ */
+export enum AnalysisType {
+    SINGLE_TRANSLATION_UNIT = "single",
+    SYSTEM = "system"
+}
+
+/**
+ * Types of transformations a rule can apply to a AST node.
+ */
 export enum MISRATransformationType {
     NoChange,
     DescendantChange,
@@ -11,32 +25,34 @@ export enum MISRATransformationType {
     Removal
 }
 
+export type MISRATransformationResults = Map<NodeID, MISRATransformationType>;
+
 /**
- * Represents an error in MISRA compliance, including the rule ID, the joinpoint where the violation occurred, and a descriptive message.
+ * Represents a MISRA-C rule violation.
  */
 export class MISRAError {
     /**
      * Represents the specific MISRA-C rule that was violated
      */
-    public ruleID: string;
+    public readonly ruleID: string;
     /**
      * The joinpoint where the error was detected
      */
-    public $jp: Joinpoint;
+    public readonly joinpoint: Joinpoint;
     /**
      * Explanation of the violation
      */
-    public message: string;
+    public readonly message: string;
 
     /**
      * 
-     * @param ruleID - specific MISRA rule that was violated
-     * @param $jp - joinpoint where the error was detected
-     * @param message - description of the error
+     * @param ruleID Identifier of the violated rule
+     * @param $jp Joinpoint where the error was detected
+     * @param message Description of the error
      */
     constructor(ruleID: string, $jp: Joinpoint, message: string) {
         this.ruleID = ruleID;
-        this.$jp = $jp;
+        this.joinpoint = $jp;
         this.message =  message;
     }
 
@@ -47,15 +63,15 @@ export class MISRAError {
      */
     equals(other: MISRAError): boolean {
         return this.ruleID === other.ruleID &&
-               this.$jp.astId === other.$jp.astId &&
+               this.joinpoint.astId === other.joinpoint.astId &&
                this.message === other.message;
     }
 
     /**
-     * 
+     * Checks if the associated joinpoint is still present in program's AST
      */
     isActiveError(): boolean {
-        return (Query.root() as Joinpoint).contains(this.$jp);
+        return (Query.root() as Joinpoint).contains(this.joinpoint);
     }
 }
 
@@ -68,11 +84,11 @@ export class MISRATransformationReport {
     /**
      * The type of the MISRA transformation
      */
-    type: MISRATransformationType;
+    public readonly type: MISRATransformationType;
     /**
      * An optional new joinpoint node, provided if the transformation involves a replacement
      */
-    newNode?: Joinpoint; 
+    public readonly newNode?: Joinpoint; 
 
     /**
      * 
@@ -101,7 +117,7 @@ export class MISRASwitchConverter {
      * @returns The converted statements or `undefined` if no statements remain
      */
     static convert(switchStmt: Switch): Statement | undefined {
-        if (switchStmt.hasDefaultCase && getNumOfSwitchClauses(switchStmt) < 2) {  // The statements will always be executed 
+        if (switchStmt.hasDefaultCase && countSwitchClauses(switchStmt) < 2) {  // The statements will always be executed 
             return this.convertToConsecutiveStmts(switchStmt);
         } else {
             return this.convertToIfStatements(switchStmt);

package/src/MISRAContext.ts

@@ -1,42 +1,77 @@
-import { Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
-import { MISRAError } from "./MISRA.js";
+import { EnumDecl, FunctionJp, Joinpoint, LabelStmt, RecordJp, TypedefDecl, Vardecl } from "@specs-feup/clava/api/Joinpoints.js";
+import { MISRAError, MISRATransformationResults, MISRATransformationType } from "./MISRA.js";
 import * as fs from 'fs';
+import Context from "./ast-visitor/Context.js";
+import { compareLocation, getFileLocation } from "./utils/JoinpointUtils.js";
 
 /**
- * Tracks MISRA errors and warnings during the analysis and/or transformation of the code.
- * Also generated unique variable and function names.
+ * Tracks MISRA-C violations during the analysis and/or transformation of the code.
+ * Also generates unique variable and function names.
  */
-export default class MISRAContext {
+export default class MISRAContext extends Context<MISRATransformationResults> {
     /**
-     * List of MISRA errors, that could not be resolved during the transformation process
+     * Stores MISRA-C rule violations.
+     * 
+     * When checking compliance, this includes all detected violations.
+     * When performing transformations, it includes only the violations that could not be resolved.
      */
     #misraErrors: MISRAError[] = [];
+    #misraErrorKeys = new Set<string>();
 
     /**
-     * Configuration provided by the user to assist in rule corrections
+     * User-provided configuration to assist in violation correction
      */
     #config: Map<string, any> | undefined = undefined;
 
     #varCounter = 0;
-    #funcCounter = 0;
-    #headerCounter = 0;
+    #functionCounter = 0;
+    #labelCounter = 0;
+    #typeDefCounter = 0;
+    #enumCounter = 0;
+    #structCounter = 0;
+    #unionCounter = 0;
 
-    #varPrefix = "__misra_var_";
-    #funcPrefix = "__misra_func_";
-    #headerPrefix = "misra_hdr_";
+    #varPrefix = "_misra_var_";
+    #funcPrefix = "_misra_func_";
+    #labelPrefix = "_misra_label_";
+    #typeDefPrefix = "_misra_typedef_";
+    #enumPrefix = "_misra_enum_";
+    #structPrefix = "_misra_struct_";
+    #unionPrefix = "_misra_union_";
 
+    /**
+     * Returns all violations found in the source code.
+     */
     get errors(): MISRAError[] {
         return this.#misraErrors;
     }
 
+    /**
+     * Returns violations linked to nodes that are still present in the AST after correction.
+     */
     get activeErrors(): MISRAError[] {
         return this.#misraErrors.filter(error => error.isActiveError());
     }
 
+    /**
+     * Orders errors according to their location
+     */
+    private sortErrors(errors?: MISRAError[]) {
+        let errorList = errors ? errors : this.#misraErrors;
+        errorList.sort((error1, error2) => compareLocation(error1.joinpoint, error2.joinpoint));
+    }
+
+   /**
+    * Returns the user-provided configuration that assists in violation correction, if provided. Otherwise, returns undefined. 
+    */
     get config(): Map<string, any> | undefined {
         return this.#config;
     }
 
+    /**
+     * Loads the JSON config file and transforms it into an internal Map representation.
+     * If the file does not exist, logs an error and exits the process.
+     */
     set config(configFilePath: string) {
         if (fs.existsSync(configFilePath)) {
             const data = fs.readFileSync(configFilePath, 'utf-8');
@@ -47,38 +82,101 @@ export default class MISRAContext {
         }
     }
 
-    generateVarName() {
-        return `${this.#varPrefix}${this.#varCounter++}`;
+    /**
+     * Clears stored information.
+     */
+    resetStorage() {
+        [...this.storage.keys()].forEach(key => {
+            this.storage.set(key, new Map())
+        });
+        this.#misraErrors = [];
+        this.#misraErrorKeys = new Set<string>();
     }
 
-    generateFuncName() {
-        return `${this.#funcPrefix}${this.#funcCounter++}`;
+    /**
+     * Returns the type of transformation applied by the specified rule to the given AST node.
+     * If no transformation was recorded, returns undefined.
+     * 
+     * @param ruleID Identifier of the violated rule
+     * @param $jp AST node
+     * @returns The type of transformation applied, or undefined if none was recorded.
+     */
+    getRuleResult(ruleID: string, $jp: Joinpoint): MISRATransformationType | undefined {
+        return this.get(ruleID)?.get($jp.astId);
     }
 
-    generateHeaderFilename() {
-        return `${this.#headerPrefix}${this.#headerCounter++}.h`;
+    /**
+     * Registers the type of transformation a rule applied to a AST node
+     * @param ruleID Identifier of the violated rule
+     * @param $jp 
+     * @param result Applied transformation
+     */
+    addRuleResult(ruleID: string, $jp: Joinpoint, result: MISRATransformationType) {
+        let transformations = this.get(ruleID);
+
+        if (transformations === undefined) {
+            transformations = new Map();
+            this.put(ruleID, transformations);
+        }
+        transformations.set($jp.astId, result);
     }
 
+    /**
+     * Registers a new violation of the standard
+     * 
+     * @param ruleID Identifier of the violated rule
+     * @param $jp Joinpoint where the error was detected
+     * @param message Description of the error
+     */
     addMISRAError(ruleID: string, $jp: Joinpoint, message: string) {
-        const newError = new MISRAError(ruleID, $jp, message);
+        const key = `${ruleID}-${$jp.astId}-${message}`;
+        if (!this.#misraErrorKeys.has(key)) {
+            this.#misraErrorKeys.add(key);
+            this.#misraErrors.push(new MISRAError(ruleID, $jp, message));
+        }
+    }
 
-        if (!this.#misraErrors.some(error => error.equals(newError))) {
-            this.#misraErrors.push(newError);
+    generateIdentifierName($jp: Joinpoint) {
+        if ($jp instanceof Vardecl) {
+            return `${this.#varPrefix}${this.#varCounter++}`;
+        } else if ($jp instanceof FunctionJp) {
+            return `${this.#funcPrefix}${this.#functionCounter++}`;
+        } else if ($jp instanceof LabelStmt) {
+            return `${this.#labelPrefix}${this.#labelCounter++}`;
+        } else if ($jp instanceof TypedefDecl) {
+            return `${this.#typeDefPrefix}${this.#typeDefCounter++}`;
+        } else if ($jp instanceof EnumDecl) {
+            return `${this.#enumPrefix}${this.#enumCounter++}`;
+        } else if ($jp instanceof RecordJp) {
+            return $jp.kind === `struct` ? 
+                `${this.#structPrefix}${this.#structCounter++}` :
+                `${this.#unionPrefix}${this.#unionCounter++}`
         }
     }
 
-    private printError(error: MISRAError): void {
-        console.log(`MISRA-C Rule ${error.ruleID} violation at ${error.$jp.filepath}@${error.$jp.line}:${error.$jp.column}: ${error.message}\n`);
+    /**
+     * Outputs a formatted MISRA-C rule violation message
+     * 
+     * @param error - The MISRA error object containing the rule ID, message, and location
+     */
+    private outputError(error: MISRAError): void {
+        console.log(`- [Rule ${error.ruleID}] at ${getFileLocation(error.joinpoint)}: ${error.message}\n`);
     }
     
-    public printAllErrors(): void {
-        this.#misraErrors.forEach(error => this.printError(error));
+    /**
+     * Displays all violations found in the source code.
+     */
+    outputAllErrors(): void {
+        this.sortErrors();
+        this.#misraErrors.forEach(error => this.outputError(error));
     }
     
-    public printActiveErrors(): void {
-        this.#misraErrors
-            .filter(error => error.isActiveError())
-            .forEach(error => this.printError(error));
+    /**
+     * Displays violations linked to nodes that are still present in the AST after correction.
+     */
+    outputActiveErrors(): void {
+        const errors = this.activeErrors;
+        this.sortErrors(errors);
+        errors.forEach(error => this.outputError(error));
     }
-    
 }

package/src/MISRARule.ts

@@ -1,56 +1,64 @@
-import { Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import { Joinpoint, Program } from "@specs-feup/clava/api/Joinpoints.js";
 import MISRAContext from "./MISRAContext.js";
-import { MISRATransformationReport } from "./MISRA.js";
+import { AnalysisType, MISRATransformationReport, MISRATransformationResults } from "./MISRA.js";
+import { LaraJoinPoint } from "@specs-feup/lara/api/LaraJoinPoint.js";
+import Clava from "@specs-feup/clava/api/clava/Clava.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { resetCaches } from "./utils/ProgramUtils.js";
+import StandardGuideline from "./StandardGuideline.js";
 
 /**
  * Represents a MISRA Rule that detects and corrects violations in the code according to MISRA standards.
  * 
- * Need to implement:
+ * Need to implement/define:
+ *  - analysisType
+ *  - name()
  *  - match($jp, logErrors)
- *  - transform($jp)
+ *  - apply($jp)
  */
-export default abstract class MISRARule {
+export default abstract class MISRARule extends StandardGuideline<MISRATransformationResults, MISRAContext> {
     /**
-     * Unique identifier for the MISRA rule.
+     * A positive integer starting from 1 that indicates the rule's priority, determining the order in which rules are applied.
+     * By default, a rule has the lowest priority unless overridden.
      */
-    readonly ruleID: string;
+    readonly priority: number = Number.MAX_VALUE;
 
     /**
-     * Priority of the rule which is low by default.
+     * Scope of analysis: single unit or entire system.
      */
-    readonly priority: number = 4;
-    
-    /** 
-     * MISRA context for error tracking and rule transformations state
-     */    
-    protected context: MISRAContext;
+    abstract readonly analysisType: AnalysisType;
+
+    /**
+     * Standards to which this rule applies to
+     */
+    protected readonly appliesTo: Set<string> = new Set(["c90", "c99", "c11"]);
 
     /**
      * 
-     * @param ruleID - Unique identifier for the MISRA-C rule
      * @param context - MISRA context for error tracking and rule transformations state
      */
-    constructor(ruleID: string, context: MISRAContext) {
-        this.ruleID = ruleID;
-        this.context = context;
+    constructor(context: MISRAContext) {
+        super(context);
     }
 
     /**
-     * Checks if the joinpoint violates the rule
-     * 
-     * @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
+     * @returns Initial value stored in the shared context
      */
-    abstract match($jp: Joinpoint, logErrors: boolean): boolean;
+    override initialValue(): MISRATransformationResults {
+        return new Map();
+    }
 
     /**
-     * Transforms the joinpoint to comply with the MISRA-C rule
-     * 
-     * @param $jp - Joinpoint to transform
-     * @returns Report detailing the transformation result
+     * @returns Rule identifier according to MISRA-C:2012
      */
-    abstract transform($jp: Joinpoint): MISRATransformationReport;
+    abstract override get name(): string;
+
+    /**
+     * An alias for 'name'
+     */
+    get ruleID(): string {
+        return this.name;
+    }
 
     /**
      * Logs a MISRA-C rule violation error
@@ -61,4 +69,28 @@ export default abstract class MISRARule {
     protected logMISRAError($jp: Joinpoint, msg:string): void {
         this.context.addMISRAError(this.ruleID, $jp, msg); 
     }
+
+    /**
+     * Verifies if the rule applies to the standard being used
+     */
+    protected appliesToCurrentStandard(): boolean {
+        return this.appliesTo.has(Clava.getStandard());
+    }
+
+    /**
+     *  Rebuilds the program based on the current AST, clears stored data in the shared context, and resets all caches
+     */
+    protected rebuildProgram() {
+        (Query.root() as Program).rebuild();
+        this.context.resetStorage();
+        resetCaches();
+    }
+
+    /**
+     * Transforms the joinpoint to comply with the MISRA-C rule
+     * 
+     * @param $jp - Joinpoint to transform
+     * @returns Report detailing the transformation result
+     */
+    abstract apply($jp: LaraJoinPoint): MISRATransformationReport;
 }

package/src/MISRATool.ts

@@ -1,33 +1,30 @@
 import Query from "@specs-feup/lara/api/weaver/Query.js";
-import { Call, FileJp, Joinpoint, Program } from "@specs-feup/clava/api/Joinpoints.js";
+import { FileJp, FunctionJp, Joinpoint, Program } from "@specs-feup/clava/api/Joinpoints.js";
 import MISRARule from "./MISRARule.js";
-import sortRules from "./rules/index.js";
 import MISRAContext from "./MISRAContext.js";
-import { MISRAError, MISRATransformationType } from "./MISRA.js";
-import { isCallToImplicitFunction } from "./utils/utils.js";
+import { MISRATransformationType } from "./MISRA.js";
+import Clava from "@specs-feup/clava/api/clava/Clava.js";
+import { resetCaches } from "./utils/ProgramUtils.js";
+import { selectRules } from "./rules/index.js";
+import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
+
+enum ExecutionMode {
+    CORRECTION,
+    DETECTION
+}
 
 export default class MISRATool {
     static #misraRules: MISRARule[];
-    static #context: MISRAContext;
-
-    private static init(startingPoint: FileJp | Program) {
-        this.validateStdVersion(startingPoint);
-        this.#context = new MISRAContext();
-        this.#misraRules = sortRules(this.#context);
-    }
-
-    private static validateStdVersion(startingPoint: FileJp | Program) {
-        const allowedVersions = ["c90", "c99", "c11"];
-        const stdVersion = startingPoint instanceof Program ? startingPoint.standard : (startingPoint.root as Program).standard;
-
-        if (!allowedVersions.includes(stdVersion)) {
-            console.error(`[Clava-MISRATool] Invalid --std value. Allowed values: ${allowedVersions.join(", ")}`);
-            process.exit(1);
-        }
-    }
+    public static context: MISRAContext;
+    static readonly #standards = new Set(["c90", "c99", "c11"]);
+    static readonly #ruleTypes = new Set(["all", "single", "system"]);
 
+    /**
+     * Checks whether the source code complies with MISRA C coding guidelines and reports all violations identified during the analysis
+     * @param startingPoint The AST node from which to start the analysis
+     */
     public static checkCompliance(startingPoint: Program | FileJp = Query.root() as Program) {
-        this.init(startingPoint);
+        this.init();
 
         const nodes = [startingPoint, ...startingPoint.descendants];
         for (const node of nodes) {
@@ -35,39 +32,52 @@ export default class MISRATool {
                 rule.match(node, true);
             }
         }
-        if (this.#context.errors.length > 0) {
-            this.#context.printAllErrors();
-        } else {
-            console.log("[Clava-MISRATool] No MISRA-C violations detected.");
-        }
+        this.outputReport(ExecutionMode.DETECTION);
     } 
 
-    public static applyCorrections(configFilePath?: string) {
-        this.init(Query.root() as Program);
+    /**
+     * Transforms the source code to comply with the coding guidelines. 
+     * After the transformation, any violations that could not be fixed will be displayed along with their justification.
+     */
+    public static correctViolations() {
+        this.init();
+
+        // Store config file in context, if provided
+        const configFilePath = this.getArgValue("config");
         if (configFilePath) {
-            this.#context.config = configFilePath;
+            this.context.config = configFilePath;
         }
 
+        // Correct violations
         let iteration = 0;
-        let modified = false;
-        do {
+        let modified = true;
+        while (modified) {
             console.log(`[Clava-MISRATool] Iteration #${++iteration}: Applying MISRA-C transformations...`);
             modified = this.transformAST(Query.root() as Program);
-        } while(modified);
-
-        if (this.#context.errors.length === 0) {
-            console.log("[Clava-MISRATool] All detected violations were corrected.");
-        } else {
-            console.log("\n[Clava-MISRATool] Remaining MISRA-C violations:");
-            this.#context.printActiveErrors();
         }
+
+        // Additional transformation: insert explicit 'void' in the argument list of functions with no parameters
+        const functionJps = Query.search(FunctionJp).get();
+        functionJps.forEach(functionJp => {
+            if (functionJp.params.length === 0) {
+                functionJp.addParam("", ClavaJoinPoints.builtinType("void"));
+            }
+        })
+
+        this.outputReport(ExecutionMode.CORRECTION);
     }
 
+    /**
+     * Recursively transforms the AST using a pre-order traversal
+     * 
+     * @param $jp  AST node from which to start the visit.
+     * @returns Return true if any modification was made (removal, replacement or changes in descendants). Otherwise, returns false.
+     */
     private static transformAST($jp: Joinpoint): boolean {
         let modified = false;
 
         for (const rule of this.#misraRules) {
-            const transformReport = rule.transform($jp);
+            const transformReport = rule.apply($jp);
 
             if (transformReport.type !== MISRATransformationType.NoChange) {
                 modified = true;
@@ -85,11 +95,85 @@ export default class MISRATool {
         return modified;
     }
 
+    /**
+     * Validates the C standard, creates a MISRA context, and initializes rules. 
+     */
+    private static init() {
+        this.validateStdVersion();
+        this.context = new MISRAContext();
+        resetCaches();
+        this.initRules();
+    }
+
+    /**
+     * Selects applicable rules according to the analysis type. When not specified, both system and single translation unit rules are selected.
+     */
+    private static initRules() {
+        const typeStr = this.getArgValue("type", this.#ruleTypes) ?? "all";
+        this.#misraRules = selectRules(this.context, typeStr);
+    }
+
+    /**
+     * Checks whether the provided standard version is valid and supported
+     */
+    private static validateStdVersion() {
+        const stdVersion = (Query.root() as Program).standard;
+
+        if (!this.#standards.has(stdVersion)) {
+            console.error(`[Clava-MISRATool] Invalid -std value. Allowed values: ${[...this.#standards].join(", ")}`);
+            process.exit(1);
+        }
+    }
+
+    private static getArgValue(field: string, validValues?: Set<string>): string | undefined{
+        const args = Clava.getData().get("argv") as string;
+        if (!args) return undefined;
+
+        const pair = args.split(/\s+/).find(arg => arg.startsWith(field + "="));
+        if (!pair) return undefined;
+
+        const value = pair.split("=")[1];
+        if (validValues && !validValues.has(value)) {
+            console.error(`[Clava-MISRATool] Invalid '${field}' value. Allowed values: ${[...validValues].join(", ")}`);
+            process.exit(1);
+        }
+        return value;
+    }
+
+    /**
+     * Displays standard violations based on execution mode. 
+     * - In detection mode, all violations are shown.
+     * - In correction mode, only the remaining violations are displayed
+     * 
+     * @param mode execution mode 
+     */
+    private static outputReport(mode: ExecutionMode) {
+        const isDetection = mode === ExecutionMode.DETECTION;
+        const errorCount = isDetection ? this.getErrorCount() : this.getActiveErrorCount();
+
+        if (errorCount > 0) {
+          console.log(isDetection
+            ? `[Clava-MISRATool] Detected ${errorCount} MISRA-C violation${errorCount === 1 ? "" : "s"}:\n`
+            : `[Clava-MISRATool] ${errorCount} MISRA-C violation${errorCount === 1 ? "" : "s"} remain${errorCount === 1 ? "s" : ""} after transformation:\n`
+          );
+          isDetection ? this.context.outputAllErrors() : this.context.outputActiveErrors();
+        } 
+        else {
+          console.log(isDetection ? "[Clava-MISRATool] No MISRA-C violations detected.\n" : "[Clava-MISRATool] All detected violations were corrected.\n");
+        }
+    }
+
+    /**
+     * @returns Returns the number of identified violations.
+     */
     public static getErrorCount(): number {
-        return this.#context.errors.length;
+        return this.context.errors.length;
     }
 
+    /**
+     * @returns Returns the number of active errors linked to nodes that are still present in the AST after correction.
+     */
     public static getActiveErrorCount(): number {
-        return this.#context.activeErrors.length;
+        return this.context.activeErrors.length;
     }
 }

package/src/StandardGuideline.ts

@@ -0,0 +1,23 @@
+import { Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import Context from "./ast-visitor/Context.js";
+import VisitWithContext from "./ast-visitor/VisitWithContext.js";
+
+/**
+ * Represents a standard guideline that detects and corrects violations in the code according to a particular coding standard.
+ * 
+ * Need to implement/define:
+ *  - initialValue()
+ *  - match($jp, logErrors)
+ *  - apply($jp)
+ */
+export default abstract class StandardGuideline<T,C extends Context<T> = Context<T>> extends VisitWithContext<T, C> {
+
+    /**
+     * Checks if the joinpoint violates the guideline
+     * 
+     * @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 guideline, false otherwise
+     */
+    abstract match($jp: Joinpoint, logErrors: boolean): boolean;
+}