@specs-feup/clava-misra 1.0.2 → 1.0.4

package/src/rules/Section21-StandardLibraries/DisallowedStdLibFunctionRule.ts

@@ -0,0 +1,317 @@
+import { Call, Joinpoint, Program, FileJp, Include } from "@specs-feup/clava/api/Joinpoints.js";
+import { AnalysisType, MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { addExternFunctionDecl, findFilesReferencingHeader, getCallsToLibrary, getExternFunctionDecls, getIncludesOfFile, isValidFile } from "../../utils/FileUtils.js";
+import { findFunctionDef } from "../../utils/FunctionUtils.js";
+import UserConfigurableRule from "../UserConfigurableRule.js";
+
+/**
+ * 
+ * Abstract base class for MISRA-C rules that prohibit the use of function of a standard library.
+ *
+ * Need to implement/define:
+ *  - analysisType
+ *  - standardLibrary
+ *  - invalidFunctions
+ *  - name() 
+ */
+export default abstract class DisallowedStdLibFunctionRule extends UserConfigurableRule {
+    /**
+     *  A positive integer starting from 1 that indicates the rule's priority, determining the order in which rules are applied.
+     */
+    readonly priority = 1;
+
+    /**
+     * A map that keeps track of invalid usages found in each file.
+     */
+    protected invalidFiles = new Map<FileJp, Call[]>();
+
+    /**
+     * The name of the standard library 
+     */
+    protected abstract standardLibrary: string;
+
+    /**
+     * Names of functions from {@link standardLibrary} that are forbidden. 
+     * If the set is empty, all functions from {@link standardLibrary} are forbidden.
+     */
+    protected abstract invalidFunctions: Set<string>;
+
+    /**
+     * Calls that could not be resolved and their respective error message, stored to prevent repeated attempts of correction after rebuild.
+     */
+    protected unresolvedCalls: Map<string, string> = new Map<string, string>();
+
+    /**
+     * Files where headers were kept because other library features are still used.
+     */
+    protected filesWithRetainedHeaders: Set<string> = new Set<string>();
+
+    /**
+     * Specifies the scope of analysis: single unit or entire system.
+     */
+    abstract readonly analysisType: AnalysisType;
+
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    abstract override get name(): string;
+
+    /**
+     * Checks if all functions of the library are forbidden
+     */
+    private isLibraryFullyDisallowed(): boolean {
+        return this.invalidFunctions.size === 0;
+    }
+
+    /**
+     * Logs a MISRA error when the entire library is disallowed and 
+     * records the file to track headers that must be retained.
+     * 
+     * @param fileJp - The file in which the disallowed include was found.
+     */
+    private logDisallowedInclude(fileJp: FileJp) {
+        if (!this.isLibraryFullyDisallowed()) { // Only specific functions are forbidden
+            return;
+        } 
+        const includeJp = Query.searchFrom(fileJp, Include, {name: this.standardLibrary}).get()[0];
+        this.logMISRAError(includeJp, `The system header file <${includeJp.name}> shall not be used.`);
+        this.context.addRuleResult(this.ruleID, includeJp, MISRATransformationType.NoChange);
+        
+        if (!this.filesWithRetainedHeaders.has(fileJp.name)) {
+            this.filesWithRetainedHeaders.add(fileJp.name);
+        }
+    }
+
+    /**
+     * Logs a MISRA error for a disallowed function call and records
+     * the call along with its error message to avoid repeated attempts
+     * 
+     * @param callJp - The disallowed function call 
+     * @param msg - Description of the violation
+     */
+    private logDisallowedCall(callJp: Call, msg: string) {
+        this.logMISRAError(callJp, msg);
+        this.context.addRuleResult(this.ruleID, callJp, MISRATransformationType.NoChange);
+        if (!this.unresolvedCalls.has(callJp.name)) {
+            this.unresolvedCalls.set(callJp.name, msg);
+        }
+    }
+
+    /**
+     * Returns the prefix to be used for error messages related to the given joinpoint
+     * 
+     * @param $jp - Joinpoint where the violation was detected 
+     * @returns Returns a prefix to prepend to error messages if no configuration is specified or if the configuration does not contain a fix for this violation
+     */
+    protected getErrorMsgPrefix(callJp: Call): string {
+        return `Function '${callJp.name}' of <${this.standardLibrary}> shall not be used.`
+    }
+
+    /**
+     * Retrieves a fix for the given joinpoint using the provided configuration file
+     * @param $jp - Joinpoint where the violation was detected
+     * @return The fix retrieved from the configuration for the violation, or `undefined` if no applicable fix is found.
+     */
+    protected getFixFromConfig(callJp: Call): Map<string, string> | undefined {
+        const errorMsgPrefix = this.getErrorMsgPrefix(callJp);
+
+        if (!this.context.config) {
+            this.logDisallowedCall(callJp, `${errorMsgPrefix} Extern not added due to missing config file.`);
+            return undefined;
+        }
+
+        let configFix = this.context.config.get("disallowedFunctions");
+        if (!configFix) {
+            this.logDisallowedCall(callJp, `${errorMsgPrefix} Extern was not added as \'disallowedFunctions\' is not defined in the configuration file.`);
+            return undefined;
+        } 
+
+        if (!configFix[this.standardLibrary]) {
+            this.logDisallowedCall(callJp, `${errorMsgPrefix} Couldn't add extern due to missing configuration for standard library <${this.standardLibrary}>.`);
+            return undefined;
+        }
+
+        if (!configFix[this.standardLibrary][callJp.name]) {
+            this.logDisallowedCall(callJp, `${errorMsgPrefix} Couldn't add extern due to missing configuration for function \'${callJp.name}\' of standard library <${this.standardLibrary}>.`);
+            return undefined;
+        }
+
+        const location = configFix[this.standardLibrary][callJp.name]["location"];
+        const replacement_func = configFix[this.standardLibrary][callJp.name]["replacement"];
+
+        if (location === undefined || replacement_func === undefined) {
+            this.logDisallowedCall(callJp, `${errorMsgPrefix} Couldn't add extern due to incomplete configuration for function \'${callJp.name}\' of standard library <${this.standardLibrary}>.`);
+            return undefined;
+        }
+        return new Map([
+            ["function", replacement_func],
+            ["location", location]
+        ]);
+    }
+
+    /**
+     * 
+     * @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 Program && this.appliesToCurrentStandard())) return false;
+
+        this.invalidFiles = new Map<FileJp, Call[]>();
+        const referencingFiles = findFilesReferencingHeader(this.standardLibrary);
+        let nonCompliant = false;
+
+        for (const fileJp of referencingFiles) {
+            const invalidCalls = getCallsToLibrary(fileJp, this.standardLibrary, this.invalidFunctions);
+            
+            if (invalidCalls.length > 0 || this.isLibraryFullyDisallowed()) {
+                this.invalidFiles.set(fileJp, invalidCalls);
+                nonCompliant = true;
+            }
+            if (logErrors) {
+                invalidCalls.forEach(callJp => this.logMISRAError(callJp, this.getErrorMsgPrefix(callJp)));
+                this.logDisallowedInclude(fileJp);
+            } 
+        }
+        return nonCompliant;
+    }
+
+    /**
+     * 
+     * @param $jp - Joinpoint to transform
+     * @returns Report detailing the transformation result
+     */
+    apply($jp: Joinpoint): MISRATransformationReport {
+        if (!this.match($jp)) return new MISRATransformationReport(MISRATransformationType.NoChange);
+    
+        let changedDescendant = false;
+        for (const [fileJp, invalidCalls] of this.invalidFiles) {
+            if (this.solveDisallowedFunctions(fileJp, invalidCalls)) {
+                changedDescendant = true;
+            }
+        }
+
+        // Rebuild AST if any file changed
+        if (changedDescendant) { 
+            this.rebuildProgram();
+            return new MISRATransformationReport(MISRATransformationType.Replacement, Query.root() as Program);
+        }
+        return new MISRATransformationReport(MISRATransformationType.NoChange);
+    }
+
+    private solveDisallowedFunctions(fileJp: FileJp, invalidCalls: Call[]): boolean {
+        let externFunctions = this.getExternFunctionDeclIds(fileJp);
+        let changedFile = false;
+        let solvedCallsCount = 0;
+        let solvedCalls = new Map<string, string>();
+
+        for (const callJp of invalidCalls) {
+            if (this.solveDisallowedFunctionCall(callJp, fileJp, externFunctions, solvedCalls)) {
+                changedFile = true;
+                solvedCallsCount++;
+            }
+        }
+
+        // Try to remove the include 
+        const fixedAllCalls = solvedCallsCount === invalidCalls.length;
+        this.removeInclude(fileJp, fixedAllCalls);
+
+        return changedFile;
+    }
+
+    private solveDisallowedFunctionCall(callJp: Call, fileJp: FileJp, externFunctions: Set<string>, solvedCalls: Map<string, string>): boolean {
+        if (solvedCalls.has(callJp.name)) {
+            callJp.setName(solvedCalls.get(callJp.name)!);
+            return true;
+        }
+        
+        // Skip call if previous AST visit marked it as unfixable
+        if (this.context.getRuleResult(this.ruleID, callJp) === MISRATransformationType.NoChange) {
+            return false;
+        }
+
+        // Skip call if previous visits, before rebuild, marked it as unfixable
+        if (this.unresolvedCalls.has(callJp.name)) {
+            this.logDisallowedCall(callJp, this.unresolvedCalls.get(callJp.name)!);
+        }
+
+        const errorMsgPrefix = this.getErrorMsgPrefix(callJp);
+        const configFix = this.getFixFromConfig(callJp);
+       
+        // Skip if config file was not specified or provides an invalid fix
+        if (!configFix) { 
+            return false;
+        }
+
+        const [location, replacement_func] = [configFix.get("location"), configFix.get("function")];
+        const functionDef = findFunctionDef(replacement_func!, location!);
+
+        // Skip if specified function doesn't exist
+        if (!functionDef) {
+            this.logDisallowedCall(callJp, `${errorMsgPrefix} Provided file \'${location}\' does not have function definition.`);
+            return false;
+        }
+
+        // Skip if specified function doesn't have external linkage
+        let externDecl: Joinpoint | undefined;
+        if (!externFunctions.has(functionDef.astId)) {
+            externDecl = addExternFunctionDecl(fileJp, functionDef);
+
+            if (externDecl === undefined) {
+                this.logDisallowedCall(callJp, `${errorMsgPrefix} Provided definition at \'${location}\' does not have external linkage.`);
+                return false;
+            }
+        }
+
+        const previousCallName = callJp.name;
+        callJp.setName(functionDef.name);
+        if (isValidFile(fileJp)) {
+            externFunctions.add(functionDef.astId);
+            solvedCalls.set(previousCallName, functionDef.name);
+            return true;
+        } else { // If file does not compile, remove added external declaration and mark call as unfixable
+            externDecl?.detach();
+            callJp.setName(previousCallName);
+            this.logDisallowedCall(callJp, `${errorMsgPrefix} Provided definition at \'${location}\' does not fix the violation.`);
+            return false;
+        }
+    }
+
+    private getExternFunctionDeclIds(fileJp: FileJp): Set<string> {
+        return new Set(
+          getExternFunctionDecls(fileJp)
+            .filter((funcJp) => funcJp.definitionJp !== undefined)
+            .map((funcJp) => funcJp.definitionJp.astId)
+        );
+    }
+
+    /**
+     * Removes the standard library include if it is fully disallowed and all invalid calls were fixed.
+     * If the file is invalid after include removal  because other library features are still being used (e.g.: typedefs), the include is re-added.
+     * 
+     * @param fileJp The file to modify
+     * @param fixedAllCalls Flag to indicate whether all calls were fixed
+     */
+    private removeInclude(fileJp: FileJp, fixedAllCalls: boolean) {
+        if (!this.isLibraryFullyDisallowed()) return;
+
+        const includeJp = Query.searchFrom(fileJp, Include, {name: this.standardLibrary}).get()[0];
+        const ruleResult = this.context.getRuleResult(this.ruleID, includeJp);
+
+        if (ruleResult !== undefined) return;
+          
+        if (this.filesWithRetainedHeaders.has(fileJp.name) || !fixedAllCalls) { // Keep include and log MISRA error 
+            this.logDisallowedInclude(fileJp);
+        } else { 
+            includeJp.detach();
+
+            // Re-add include and log error if any other library features are still referenced
+            if (!isValidFile(fileJp)) { 
+                fileJp.addInclude(this.standardLibrary, true);
+                this.logDisallowedInclude(fileJp);
+            }
+        }
+    }
+}

package/src/rules/Section21-StandardLibraries/Rule_21_10_NoTimeDateFunctions.ts

@@ -0,0 +1,30 @@
+import { AnalysisType } from "../../MISRA.js";
+import DisallowedStdLibFunctionRule from "./DisallowedStdLibFunctionRule.js";
+
+/**
+ * MISRA-C Rule 21.10: The Standard Library time and date functions shall not be used
+ */
+export default class Rule_21_10_NoTimeDateFunctions extends DisallowedStdLibFunctionRule {
+    /**
+     * The name of the standard library 
+     */
+    protected standardLibrary = "time.h";
+
+    /**
+     * Names of functions from {@link standardLibrary} that are forbidden. 
+     * If the set is empty, all functions from {@link standardLibrary} are forbidden.
+     */
+    protected invalidFunctions = new Set<string>();
+
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SINGLE_TRANSLATION_UNIT;
+
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "21.10";
+    }    
+}

package/src/rules/Section21-StandardLibraries/Rule_21_11_NoTgmathFunctions.ts

@@ -0,0 +1,35 @@
+import { AnalysisType } from "../../MISRA.js";
+import DisallowedStdLibFunctionRule from "./DisallowedStdLibFunctionRule.js";
+
+/**
+ * MISRA-C Rule 21.11: The standard header file <tgmath.h> shall not be used
+ */
+export default class Rule_21_11_NoTgmathFunctions extends DisallowedStdLibFunctionRule {
+    /**
+     * The name of the standard library 
+     */
+    protected standardLibrary = "tgmath.h";
+
+    /**
+     * Names of functions from {@link standardLibrary} that are forbidden. 
+     * If the set is empty, all functions from {@link standardLibrary} are forbidden.
+     */
+    protected invalidFunctions = new Set<string>();
+
+    /**
+     * Standards to which this rule applies to
+     */
+    protected override readonly appliesTo = new Set(["c99", "c11"]);
+
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SINGLE_TRANSLATION_UNIT;
+
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "21.11";
+    }    
+}

package/src/rules/Section21-StandardLibraries/Rule_21_3_NoDynamicMemory.ts

@@ -0,0 +1,30 @@
+import { AnalysisType } from "../../MISRA.js";
+import DisallowedStdLibFunctionRule from "./DisallowedStdLibFunctionRule.js";
+
+/**
+ * MISRA-C Rule 21.3: The memory allocation and deallocation functions of <stdlib.h> shall not be used
+ */
+export default class Rule_21_3_NoDynamicMemory extends DisallowedStdLibFunctionRule {
+    /**
+     * The name of the standard library 
+     */
+    protected standardLibrary = "stdlib.h";
+
+    /**
+     * Names of functions from {@link standardLibrary} that are forbidden. 
+     * If the set is empty, all functions from {@link standardLibrary} are forbidden.
+     */
+    protected invalidFunctions = new Set(["calloc", "malloc", "aligned_alloc", "realloc", "free"]);
+
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SINGLE_TRANSLATION_UNIT;
+
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "21.3";
+    }    
+}

package/src/rules/Section21-StandardLibraries/Rule_21_6_NoStdIOFunctions.ts

@@ -0,0 +1,30 @@
+import { AnalysisType } from "../../MISRA.js";
+import DisallowedStdLibFunctionRule from "./DisallowedStdLibFunctionRule.js";
+
+/**
+ * MISRA-C Rule 21.6: The Standard Library input/output functions shall not be used
+ */
+export default class Rule_21_6_NoStdIOFunctions extends DisallowedStdLibFunctionRule {
+    /**
+     * The name of the standard library 
+     */
+    protected standardLibrary = "stdio.h";
+    
+    /**
+     * Names of functions from {@link standardLibrary} that are forbidden. 
+     * If the set is empty, all functions from {@link standardLibrary} are forbidden.
+     */
+    protected invalidFunctions = new Set<string>();
+    
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SINGLE_TRANSLATION_UNIT;
+
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "21.6";
+    }    
+}

package/src/rules/Section21-StandardLibraries/Rule_21_7_NoNumericStringConversions.ts

@@ -0,0 +1,29 @@
+import { AnalysisType } from "../../MISRA.js";
+import DisallowedStdLibFunctionRule from "./DisallowedStdLibFunctionRule.js";
+
+/**
+ * MISRA-C Rule 21.7: The atof, atoi, atol and atoll functions of <stdlib.h> shall not be used.
+ */
+export default class Rule_21_7_NoNumericStringConversions extends DisallowedStdLibFunctionRule {
+    /**
+     * The name of the standard library 
+     */
+    protected standardLibrary = "stdlib.h";
+    
+    /**
+     * Names of functions from {@link standardLibrary} that are forbidden. 
+     * If the set is empty, all functions from {@link standardLibrary} are forbidden.
+     */
+    protected invalidFunctions = new Set(["atof", "atoi", "atol", "atoll"]);
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SINGLE_TRANSLATION_UNIT;
+
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "21.7";
+    }    
+}

package/src/rules/Section21-StandardLibraries/Rule_21_8_NoProcessControlFunctions.ts

@@ -0,0 +1,36 @@
+import { AnalysisType } from "../../MISRA.js";
+import DisallowedStdLibFunctionRule from "./DisallowedStdLibFunctionRule.js";
+
+/**
+ * MISRA-C Rule 21.8: The library functions abort, exit, getenv and system of <stdlib.h>
+ * shall not be used
+ */
+export default class Rule_21_8_NoProcessControlFunctions extends DisallowedStdLibFunctionRule {
+    /**
+     * Standards to which this rule applies to
+     */
+    protected override readonly appliesTo = new Set(["c90", "c99"]);
+
+    /**
+     * The name of the standard library 
+     */
+    protected standardLibrary = "stdlib.h";
+
+    /**
+     * Names of functions from {@link standardLibrary} that are forbidden. 
+     * If the set is empty, all functions from {@link standardLibrary} are forbidden.
+     */
+    protected invalidFunctions = new Set(["abort", "exit", "getenv", "system"]);
+
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SINGLE_TRANSLATION_UNIT;
+
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "21.8";
+    }    
+}

package/src/rules/Section21-StandardLibraries/Rule_21_9_NoGenericSearchOrSort.ts

@@ -0,0 +1,30 @@
+import { AnalysisType } from "../../MISRA.js";
+import DisallowedStdLibFunctionRule from "./DisallowedStdLibFunctionRule.js";
+
+/**
+ * MISRA-C Rule 21.9: The library functions bsearch and qsort of <stdlib.h> shall not be used.
+ */
+export default class Rule_21_9_NoGenericSearchOrSort extends DisallowedStdLibFunctionRule {
+    /**
+     * The name of the standard library 
+     */
+    protected standardLibrary = "stdlib.h";
+
+    /**
+     * Names of functions from {@link standardLibrary} that are forbidden. 
+     * If the set is empty, all functions from {@link standardLibrary} are forbidden.
+     */
+    protected invalidFunctions = new Set(["bsearch", "qsort"]);
+    
+    /**
+     * Scope of analysis
+     */
+    readonly analysisType = AnalysisType.SINGLE_TRANSLATION_UNIT;
+
+    /**
+     * @returns Rule identifier according to MISRA-C:2012
+     */
+    override get name(): string {
+        return "21.9";
+    }    
+}

package/src/rules/Section2_UnusedCode/Rule_2_3_UnusedTypeDecl.ts

@@ -1,38 +1,23 @@
-import { EnumDecl, Joinpoint,RecordJp,TypedefDecl, TypedefType } from "@specs-feup/clava/api/Joinpoints.js";
+import { 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 { getBaseType, getTagUses, getTypeDecl, getTypedJps } from "../../utils/utils.js";
+import { AnalysisType, MISRATransformationReport, MISRATransformationType } from "../../MISRA.js";
+import { getTypeDefDecl, isTypeDeclUsed } from "../../utils/TypeDeclUtils.js";
+import { isTagDecl } from "../../utils/JoinpointUtils.js";
 
 /**
  * MISRA-C Rule 2.3: A project should not contain unused type declarations.
  */
 export default class Rule_2_3_UnusedTypeDecl extends MISRARule {
-    priority = 3;
-
-    constructor(context: MISRAContext) {
-        super("2.3", context);
-    }
-
     /**
-     * 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
+     * Scope of analysis
      */
-    private isTypedefUsed(jp: Joinpoint, typeDecl: TypedefDecl): boolean {
-        const jpType = getBaseType(jp);
-        return !jpType?.isBuiltin && jpType instanceof TypedefType && jpType.decl.astId === typeDecl.astId;
-    }
+    readonly analysisType = AnalysisType.SYSTEM;
 
     /**
-     * Retrieves all joinpoints that use the specified typedef declaration
-     * 
-     * @param typeDecl - The typedef declaration to search for in the joinpoints
-     * @returns Array of joinpoints that use the given typedef declaration
+     * @returns Rule identifier according to MISRA-C:2012
      */
-    private getTypeDefUses(typeDecl: TypedefDecl): Joinpoint[] {
-        return getTypedJps().filter(jp => this.isTypedefUsed(jp, typeDecl));
+    override get name(): string {
+        return "2.3";
     }
 
     /**
@@ -42,12 +27,12 @@ export default class Rule_2_3_UnusedTypeDecl extends MISRARule {
      * @returns Returns true if the joinpoint violates the rule, false otherwise
      */
     match($jp: Joinpoint, logErrors: boolean = false): boolean {
-        const typeDecl = getTypeDecl($jp);
+        const typeDecl = getTypeDefDecl($jp);
         if (typeDecl === undefined) return false;
 
-        const isUnused = this.getTypeDefUses(typeDecl).length === 0;
+        const isUnused = !isTypeDeclUsed(typeDecl);
         if (logErrors && isUnused) {
-            this.logMISRAError($jp, `Type declaration ${typeDecl.name} is declared but not used.`)
+            this.logMISRAError($jp, `Type declaration '${typeDecl.name}' is declared but not used.`)
         }
         return isUnused;
     }
@@ -62,11 +47,11 @@ export default class Rule_2_3_UnusedTypeDecl extends MISRARule {
      * @param $jp - Joinpoint to transform
      * @returns Report detailing the transformation result
      */
-    transform($jp: Joinpoint): MISRATransformationReport {
+    apply($jp: Joinpoint): MISRATransformationReport {
         if (!this.match($jp)) 
             return new MISRATransformationReport(MISRATransformationType.NoChange);
 
-        if (($jp instanceof RecordJp || $jp instanceof EnumDecl) && $jp.name && getTagUses($jp).length > 0) { 
+        if (isTagDecl($jp) && $jp.name && isTypeDeclUsed($jp)) { 
             $jp.lastChild.detach();
             return new MISRATransformationReport(MISRATransformationType.DescendantChange);
         } else {