SVALint 2.0__py3-none-any.whl

SVALint/__main__.py

@@ -0,0 +1,9 @@
+import logging
+from .asfigo_linter import SVALinter  
+
+def main():
+    byolDemo = SVALinter(configFile="config.toml", logLevel=logging.INFO)
+    byolDemo.runLinter()
+
+if __name__ == "__main__":
+    main()

SVALint/af_lint_rule.py

@@ -0,0 +1,58 @@
+# ----------------------------------------------------
+# SPDX-FileCopyrightText: AsFigo Technologies, UK
+# SPDX-FileCopyrightText: VerifWorks, India
+# SPDX-License-Identifier: MIT
+# ----------------------------------------------------
+import logging
+from bin import verible_verilog_syntax
+from abc import ABC, abstractmethod
+
+class AsFigoLintRule(ABC):
+    """Base class for all linting rules."""
+
+    VeribleSyntax = verible_verilog_syntax
+    rule_count = 0  # Class variable to track rules executed
+
+    
+    def __init__(self, linter):
+        self.linter = linter  # Store the linter instance
+        self.ruleID = 'SVALintDefaultRuleID'
+        '''
+        if not hasattr(self, "ruleID"):  # Ensure ruleID exists in subclasses
+            raise ValueError(f"{self.__class__.__name__} must define a `ruleID` attribute!")
+        '''
+
+
+    @classmethod
+    def get_rule_count(cls):
+        return cls.rule_count  # Get the count of rules applied
+
+    @abstractmethod
+    def apply(self, filePath: str, data: verible_verilog_syntax.SyntaxData):
+        """Abstract method to apply the rule."""
+        raise NotImplementedError
+
+    def getClassName(self, classNode):
+        """Extracts the class name from a class declaration."""
+        for header in classNode.iter_find_all({"tag": "kClassHeader"}):
+            for identifier in header.iter_find_all({"tag": "SymbolIdentifier"}):
+                return identifier.text
+        return "Unknown"
+
+    def getQualifiers(self, varNode):
+        """Extracts variable qualifiers (e.g., local, protected, rand)."""
+        qualifiers = set()
+        for qualList in varNode.iter_find_all({"tag": "kQualifierList"}):
+            qualifiers.update(qualList.text.split())  # Extract words
+        return qualifiers
+
+    def run(self, filePath: str, data: verible_verilog_syntax.SyntaxData):
+        """Wrapper method to automatically count and apply the rule."""
+        AsFigoLintRule.rule_count += 1  # Automatically increment rule count
+        message = (
+                f"Running lint ruleID: {self.ruleID} on file: {filePath}\n"
+                )
+
+        self.linter.logInfo(self.ruleID, message)
+
+        self.apply(filePath, data)  # Call the actual rule logic

SVALint/asfigo_linter.py

@@ -0,0 +1,121 @@
+# ----------------------------------------------------
+# SPDX-FileCopyrightText: AsFigo Technologies, UK
+# SPDX-FileCopyrightText: VerifWorks, India
+# SPDX-License-Identifier: MIT
+# ----------------------------------------------------
+
+import argparse
+import tomli
+import os.path
+import copy
+import functools
+from operator import countOf
+import operator as op
+import logging
+import json
+import string_utils.validation  as str_val
+from .af_lint_rule import AsFigoLintRule
+
+class BaseLintLogger:
+    def __init__(self, prefix, configFile="config.toml", logLevel=logging.INFO, logFile="svalint_run.log"):
+        self.prefix = prefix
+        self.logger = logging.getLogger(f"{prefix}Logger")
+        self.logger.setLevel(logLevel)
+
+        formatter = logging.Formatter('%(message)s')
+
+        stream_handler = logging.StreamHandler()
+        stream_handler.setLevel(logLevel)
+        stream_handler.setFormatter(formatter)
+
+        file_handler = logging.FileHandler(logFile, mode='a')
+        file_handler.setLevel(logLevel)
+        file_handler.setFormatter(formatter)
+
+        if self.logger.hasHandlers():
+            self.logger.handlers.clear()
+
+        self.logger.addHandler(stream_handler)
+        self.logger.addHandler(file_handler)
+
+        self.rulesConfig = self.loadConfig(configFile)
+        self.infoCount = 0
+        self.warningCount = 0
+        self.errorCount = 0
+        self.errorList = []
+        self.warningList = []
+
+    def loadConfig(self, configFile):
+        try:
+            with open(configFile, "rb") as file:
+                config = tomli.load(file)
+            return config.get("rules", {})
+        except FileNotFoundError:
+            self.logger.warning(f"{self.prefix}: Config file '{configFile}' not found. Using default settings.")
+            return {}
+
+    def ruleEnabled(self, ruleId):
+        return self.rulesConfig.get(ruleId, True)
+
+    def logInfo(self, ruleId, msg, severity="INFO"):
+        self.infoCount += 1
+
+        logMsg = f"{self.prefix}: INFO: {msg}"
+        self.logger.info(logMsg)
+
+    def logViolation(self, ruleId, msg, severity="ERROR"):
+        if self.ruleEnabled(ruleId):
+            wrapped_msg = msg
+            logMsg = f"{self.prefix}: Violation: [{ruleId}]:\n{msg}"
+
+            if severity == "ERROR":
+                self.errorCount += 1
+                self.errorList.append(ruleId)  # Store error ID
+                self.logger.error(logMsg)
+            elif severity == "WARNING":
+                self.warningCount += 1
+                self.warningList.append(ruleId)  # Store warning ID
+                self.logger.warning(logMsg)
+            else:
+                raise ValueError(f"Unsupported severity level: {severity}")
+        else:
+            self.logger.info(f"{self.prefix}: Rule [{ruleId}] is disabled and will not be logged.")
+
+    def logSummary(self):
+        self.logger.info("\n--------------------------------")
+        self.logger.info("AsFigo SVALint Report Summary")
+        self.logger.info(f"Total lint rules executed: {AsFigoLintRule.get_rule_count()}")
+
+        self.logger.info("--------------------------------")
+                # Report counts by severity
+        self.logger.info("** Report counts by severity")
+        self.logger.info(f"INFO    : {self.infoCount}")
+        self.logger.info(f"WARNING : {self.warningCount}")
+        self.logger.info(f"ERROR   : {self.errorCount}")
+
+        # Report counts by ID (show each unique rule ID and how many times it was logged)
+        self.logger.info("\n** Report counts by ID")
+        self._printRuleCounts(self.errorList, "ERROR")
+        self._printRuleCounts(self.warningList, "WARNING")
+
+        self.logger.info("--------------------------------\n")
+
+    def _printRuleCounts(self, ruleList, severity):
+        ruleDict = {}
+        for ruleId in ruleList:
+            ruleDict[ruleId] = ruleDict.get(ruleId, 0) + 1
+        
+        for ruleId, count in sorted(ruleDict.items(), key=lambda x: -x[1]):  # Sort by highest count
+            self.logger.info(f"[{ruleId}] {count}")
+
+class AsFigoLinter(BaseLintLogger):
+    def __init__(self, configFile="config.toml", logLevel=logging.INFO):
+        super().__init__(prefix="AsFigo", configFile=configFile, logLevel=logLevel)
+        self.args = self.parseArguments()
+        self.testName = self.args.test
+
+    def parseArguments(self):
+        parser = argparse.ArgumentParser(description="AsFigoLinter Argument Parser")
+        parser.add_argument("-t", "--test", required=True, help="Input test name (file path)")
+        return parser.parse_args()
+    

SVALint/rules/af_asrt_naming.py

@@ -0,0 +1,45 @@
+# ----------------------------------------------------
+# SPDX-FileCopyrightText: AsFigo Technologies, UK
+# SPDX-FileCopyrightText: VerifWorks, India
+# SPDX-License-Identifier: MIT
+# Author: Himank Gangwal, Sep 02, 2025
+# ----------------------------------------------------
+
+from ..af_lint_rule import AsFigoLintRule
+import logging
+import anytree
+
+class AssertNaming(AsFigoLintRule):
+    """Checks if assert follows a naming convention - start with "a_" """
+
+    def __init__(self, linter):
+        self.linter = linter
+        self.ruleID = "ASSERT_NAMING"
+
+    def apply(self, filePath: str, data: AsFigoLintRule.VeribleSyntax.SyntaxData):
+        for curNode in data.tree.iter_find_all({"tag": "kAssertionItem"}):
+            lvLabel = curNode.children[0].text
+            lvVerifDirType = curNode.children[1]
+            if (not 'kAssertPropertyStatement' in lvVerifDirType.tag):
+                continue
+
+            if not lvLabel:
+                continue
+
+            if not lvLabel.startswith("a_"):
+                message = (
+                    f"Debug: Found assert name without a_ prefix. "
+                    f"Use a_ as assert prefix. This helps users to "
+                    f"look for specific patterns in their log files. "
+                    f"Found an Assertion as:\n"
+                    f"{curNode.text}\n"
+                )
+                self.linter.logViolation(self.ruleID, message, "WARNING")
+        
+    def getAssertPropertyName(self, assert_node):
+        """Extracts the assert property name from an assert property statement."""
+        # Look for SymbolIdentifier nodes that represent the assert property name
+        for identifier in assert_node.iter_find_all({"tag": "SymbolIdentifier"}):
+            # The first SymbolIdentifier in an assert property is usually the name
+            return identifier.text
+        return "Unknown"

SVALint/rules/af_asrt_no_label.py

@@ -0,0 +1,30 @@
+# ----------------------------------------------------
+# SPDX-FileCopyrightText: AsFigo Technologies, UK
+# SPDX-FileCopyrightText: VerifWorks, India
+# SPDX-License-Identifier: MIT
+# ----------------------------------------------------
+
+from ..af_lint_rule import AsFigoLintRule
+import logging
+import anytree
+
+class MissingLabelChk(AsFigoLintRule):
+    """Enhance debug-ability of assertions by using labels """
+  
+    def __init__(self, linter):
+        self.linter = linter  # Store the linter instance
+        self.ruleID = "ASSERT_MISSING_LABEL"
+
+    def apply(self, filePath: str, data: AsFigoLintRule.VeribleSyntax.SyntaxData):
+
+        for curNode in data.tree.iter_find_all({"tag": "kAssertionItem"}):
+          lvSvaCode = curNode.text
+          lvAsrtLabel =  curNode.children[0]
+          if (( ":" not in lvAsrtLabel.text)):
+                message = (
+                    f"Error: Missing label for an assert statement.\n"
+                    f"{lvSvaCode}\n"
+                )
+                self.linter.logViolation(self.ruleID, message)
+
+

SVALint/rules/af_assume_naming.py

@@ -0,0 +1,39 @@
+# ----------------------------------------------------
+# SPDX-FileCopyrightText: AsFigo Technologies, UK
+# SPDX-FileCopyrightText: VerifWorks, India
+# SPDX-License-Identifier: MIT
+# Author: Himank Gangwal, Sep 02, 2025
+# ----------------------------------------------------
+
+from ..af_lint_rule import AsFigoLintRule
+import logging
+import anytree
+
+class AssumeNaming(AsFigoLintRule):
+    """Checks if assume follows a naming convention - start with "m_" """
+
+    def __init__(self, linter):
+        self.linter = linter
+        self.ruleID = "ASSUME_NAMING"
+
+    def apply(self, filePath: str, data: AsFigoLintRule.VeribleSyntax.SyntaxData):
+        for curNode in data.tree.iter_find_all({"tag": "kAssertionItem"}):
+            lvLabel = curNode.children[0].text
+            lvVerifDirType = curNode.children[1]
+
+            if (not 'kAssumePropertyStatement' in lvVerifDirType.tag):
+                continue
+
+            if not lvLabel:
+                continue
+
+            if not lvLabel.startswith("m_"):
+                message = (
+                    f"Debug: Found assume name without m_ prefix. "
+                    f"Use m_ as assume prefix. This helps users to "
+                    f"look for specific patterns in their log files. "
+                    f"Found an Assume as:\n"
+                    f"{curNode.text}\n"
+                )
+                self.linter.logViolation(self.ruleID, message, "WARNING")
+        

SVALint/rules/af_cover_naming.py

@@ -0,0 +1,39 @@
+# ----------------------------------------------------
+# SPDX-FileCopyrightText: AsFigo Technologies, UK
+# SPDX-FileCopyrightText: VerifWorks, India
+# SPDX-License-Identifier: MIT
+# Author: Himank Gangwal, Sep 02, 2025
+# ----------------------------------------------------
+
+from ..af_lint_rule import AsFigoLintRule
+import logging
+import anytree
+
+class CoverNaming(AsFigoLintRule):
+    """Checks if cover follows a naming convention - start with "c_" """
+
+    def __init__(self, linter):
+        self.linter = linter
+        self.ruleID = "COVER_NAMING"
+
+    def apply(self, filePath: str, data: AsFigoLintRule.VeribleSyntax.SyntaxData):
+        for curNode in data.tree.iter_find_all({"tag": "kAssertionItem"}):
+            lvLabel = curNode.children[0].text
+            lvVerifDirType = curNode.children[1]
+
+            if (not 'kCoverPropertyStatement' in lvVerifDirType.tag):
+                continue
+
+            if not lvLabel:
+                continue
+
+            if not lvLabel.startswith("c_"):
+                message = (
+                    f"Debug: Found cover name without c_ prefix. "
+                    f"Use c_ as cover prefix. This helps users to "
+                    f"look for specific patterns in their log files. "
+                    f"Found a cover as:\n"
+                    f"{curNode.text}\n"
+                )
+                self.linter.logViolation(self.ruleID, message, "WARNING")
+        

SVALint/rules/af_func_cov_nolap.py

@@ -0,0 +1,33 @@
+# ----------------------------------------------------
+# SPDX-FileCopyrightText: AsFigo Technologies, UK
+# SPDX-FileCopyrightText: VerifWorks, India
+# SPDX-License-Identifier: MIT
+# ----------------------------------------------------
+from ..af_lint_rule import AsFigoLintRule
+import logging
+import anytree
+
+class FuncNOLAPInCoverProp(AsFigoLintRule):
+    """Cover Property with non-overlapped implicaiton operator leads to false-positives """
+  
+    def __init__(self, linter):
+        self.linter = linter  # Store the linter instance
+        self.ruleID = "FUNC_NO_NON_OLAP_COVER"
+
+    def apply(self, filePath: str, data: AsFigoLintRule.VeribleSyntax.SyntaxData):
+
+        for curNode in data.tree.iter_find_all({"tag": "kCoverPropertyStatement"}):
+            lvSvaCode = curNode.text
+            lvNonOlapImplG = curNode.iter_find_all({"tag": "|=>"})
+            if (len(list(lvNonOlapImplG)) > 0):
+                message = (
+                    f"FUNC: Found a non-overlapped implication operator with "
+                    f"cover property directive. This leads to vacuous/bogus "
+                    f"functional/assertion/temporal coverage to be collected "
+                    f"and reported. This can be a serious hole in the verification "
+                    f"process as it gives a false-sense of security/coverage."
+                    f"Use ##1 instead. Code snippet: \n"
+                    f"{lvSvaCode}\n"
+                )
+                self.linter.logViolation(self.ruleID, message)
+

SVALint/rules/af_func_cov_olap.py

@@ -0,0 +1,33 @@
+# ----------------------------------------------------
+# SPDX-FileCopyrightText: AsFigo Technologies, UK
+# SPDX-FileCopyrightText: VerifWorks, India
+# SPDX-License-Identifier: MIT
+# ----------------------------------------------------
+from ..af_lint_rule import AsFigoLintRule
+import logging
+import anytree
+
+class FuncOLAPInCoverProp(AsFigoLintRule):
+    """Cover Property with overlapped implicaiton operator leads to false-positives """
+  
+    def __init__(self, linter):
+        self.linter = linter  # Store the linter instance
+        self.ruleID = "FUNC_NO_OLAP_COVER"
+
+    def apply(self, filePath: str, data: AsFigoLintRule.VeribleSyntax.SyntaxData):
+
+        for curNode in data.tree.iter_find_all({"tag": "kCoverPropertyStatement"}):
+            lvSvaCode = curNode.text
+            lvNonOlapImplG = curNode.iter_find_all({"tag": "|->"})
+            if (len(list(lvNonOlapImplG)) > 0):
+                message = (
+                    f"FUNC: Found a overlapped implication operator with "
+                    f"cover property directive. This leads to vacuous/bogus "
+                    f"functional/assertion/temporal coverage to be collected "
+                    f"and reported. This can be a serious hole in the verification "
+                    f"process as it gives a false-sense of security/coverage."
+                    f"Use ##0 instead. Code snippet: \n"
+                    f"{lvSvaCode}\n"
+                )
+                self.linter.logViolation(self.ruleID, message)
+

SVALint/rules/af_func_missing_fablk.py

@@ -0,0 +1,36 @@
+# ----------------------------------------------------
+# SPDX-FileCopyrightText: AsFigo Technologies, UK
+# SPDX-FileCopyrightText: VerifWorks, India
+# SPDX-License-Identifier: MIT
+# ----------------------------------------------------
+from ..af_lint_rule import AsFigoLintRule
+import logging
+import anytree
+
+class FuncMissingFABLK(AsFigoLintRule):
+    """Action block related checks """
+  
+    def __init__(self, linter):
+        self.linter = linter  # Store the linter instance
+        self.ruleID = "FUNC_MISSING_FAIL_ABLK"
+
+    def apply(self, filePath: str, data: AsFigoLintRule.VeribleSyntax.SyntaxData):
+
+        for curNode in data.tree.iter_find_all({"tag": "kAssertionItem"}):
+            lvSvaCode = curNode.text
+
+            lvAsrtIter = curNode.iter_find_all({"tag": "kAssertPropertyStatement"})
+            lvAsrtProp = next(lvAsrtIter, None)
+            if lvAsrtProp is None:
+                continue
+
+            lvAsrtFailAblkNode = curNode.iter_find_all({"tag": "kElseClause"})
+            lvAsrtFailAblkNodeNxt = next(lvAsrtFailAblkNode, None)
+            if lvAsrtFailAblkNodeNxt is None:
+                message = (
+                    f"FUNC: Missing fail action block in assert statement.\n"
+                    f"Severly impacts verification completeness as errors may go undetected\n"
+                    f"{lvSvaCode}\n"
+                )
+                self.linter.logViolation(self.ruleID, message)
+

SVALint/rules/af_func_no_ub_in_cnseq.py

@@ -0,0 +1,43 @@
+# ----------------------------------------------------
+# SPDX-FileCopyrightText: AsFigo Technologies, UK
+# SPDX-FileCopyrightText: VerifWorks, India
+# SPDX-License-Identifier: MIT
+# ----------------------------------------------------
+
+from ..af_lint_rule import AsFigoLintRule
+import logging
+import anytree
+
+
+class NoUBRangeInConseqAsrt(AsFigoLintRule):
+    lvMsg = """
+    From book: https://payhip.com/b/7HvMk
+
+by @hdlcohen
+
+An assertion with an infinite range in its consequent can never FAIL, but can PASS.
+
+$rose(req) |-> ##[0:$] ack);
+Consider using a more deterministic delay
+
+    """
+
+    def __init__(self, linter):
+        self.linter = linter
+        # Store the linter instance
+        self.ruleID = "FUNC_AVOID_$_RANGE_IN_CONSEQ_A"
+
+    def apply(self, filePath: str, data: AsFigoLintRule.VeribleSyntax.SyntaxData):
+
+        for curNode in data.tree.iter_find_all({"tag": "kAssertionItem"}):
+            lvSvaCode = curNode.text
+            for curImplNode in curNode.iter_find_all({"tag": "|->"}):
+                lvImplCnseqNode = curImplNode.siblings[1]
+                lvRangeG = lvImplCnseqNode.iter_find_all({"tag": "kCycleDelayRange"})
+                for curDelRangeNode in lvRangeG:
+                    lvCnseqUBRangeG = curDelRangeNode.iter_find_all({"tag": "$"})
+                    lvCnseqUBRangeList = list(lvCnseqUBRangeG)
+                    if len(lvCnseqUBRangeList) > 0:
+                        message = f"{self.lvMsg}\n" f"{lvSvaCode}\n"
+
+                        self.linter.logViolation(self.ruleID, message)

SVALint/rules/af_missing_elbl_prop.py

@@ -0,0 +1,34 @@
+# ----------------------------------------------------
+# SPDX-FileCopyrightText: AsFigo Technologies, UK
+# SPDX-FileCopyrightText: VerifWorks, India
+# SPDX-License-Identifier: MIT
+# ----------------------------------------------------
+
+from ..af_lint_rule import AsFigoLintRule
+import logging
+import anytree
+
+
+class MissingEndLblProp(AsFigoLintRule):
+    """Checks for missing end-labels in property """
+
+    def __init__(self, linter):
+        self.linter = linter
+        # Store the linter instance
+        self.ruleID = "DBG_MISS_END_LBL_PROP"
+
+    def apply(
+        self, filePath: str, data: AsFigoLintRule.VeribleSyntax.SyntaxData
+    ):
+        for curNode in data.tree.iter_find_all(
+            {"tag": "kPropertyDeclaration"}):
+            lvSvaCode = curNode.text
+            lvLastElem = curNode.descendants[-1]
+            if (not lvLastElem.text):
+                message = (
+                    f"Debug: Found a property without endlabel. Use of endlabels "
+                    f"greatly enhances debug and increases productivity\n"
+                    f"{lvSvaCode}\n"
+                )
+
+                self.linter.logViolation(self.ruleID, message)

SVALint/rules/af_missing_elbl_seq.py

@@ -0,0 +1,34 @@
+# ----------------------------------------------------
+# SPDX-FileCopyrightText: AsFigo Technologies, UK
+# SPDX-FileCopyrightText: VerifWorks, India
+# SPDX-License-Identifier: MIT
+# ----------------------------------------------------
+
+from ..af_lint_rule import AsFigoLintRule
+import logging
+import anytree
+
+
+class MissingEndLblSEQ(AsFigoLintRule):
+    """Checks for missing end-labels in seqeunce """
+
+    def __init__(self, linter):
+        self.linter = linter
+        # Store the linter instance
+        self.ruleID = "DBG_MISS_END_LBL_SEQ"
+
+    def apply(
+        self, filePath: str, data: AsFigoLintRule.VeribleSyntax.SyntaxData
+    ):
+        for curNode in data.tree.iter_find_all(
+            {"tag": "kSequenceDeclaration"}):
+            lvSvaCode = curNode.text
+            lvLastElem = curNode.descendants[-1]
+            if (not lvLastElem.text):
+                message = (
+                    f"Debug: Found a SEQ without endlabel. Use of endlabels "
+                    f"greatly enhances debug and increases productivity\n"
+                    f"{lvSvaCode}\n"
+                )
+
+                self.linter.logViolation(self.ruleID, message)

SVALint/rules/af_no_aa_exists_sva.py

@@ -0,0 +1,56 @@
+# ----------------------------------------------------
+# SPDX-FileCopyrightText: AsFigo Technologies, UK
+# SPDX-FileCopyrightText: VerifWorks, India
+# SPDX-License-Identifier: MIT
+# Author: Himank Gangwal, Sep 02, 2025
+# ----------------------------------------------------
+
+from ..af_lint_rule import AsFigoLintRule
+import logging
+import anytree
+
+class AvoidAAExistsSVA(AsFigoLintRule):
+    """Checks if Assoc array method exist() is in the SVA code """
+
+    lvMsg = """
+Rule suggested by Ben Cohen:
+
+IEEE LRM 1800 states:
+
+16.6 Boolean expressions: “Elements of dynamic arrays, queues, and associative arrays that are sampled for assertion expression evaluation may get removed from the array or the array may get resized before the assertion expression is evaluated. These specific array elements sampled for assertion expression evaluation shall continue to exist within the scope of the assertion until the assertion expression evaluation completes.”
+
+Many tools are slow to adopt this IEEE 1800 requirement. Several imposed restrictions on the use of associative arrays within assertions, and some prohibited them entirely, likely due to performance concerns.
+
+So avoid usage of array.exists() method call in SVA
+
+e.g.
+((valid, v_err=mem_aarray.exists(addr))
+    """
+    def __init__(self, linter):
+        self.linter = linter
+        self.ruleID = "NO_AA_EXISTS_SVA"
+
+    def apply(self, filePath: str, data: AsFigoLintRule.VeribleSyntax.SyntaxData):
+        for curNode in data.tree.iter_find_all({"tag": ["kPropertyDeclaration"]}):
+            for hierNode in curNode.iter_find_all({"tag": ["kHierarchyExtension"]}):
+                # check if the node contains "exists"
+                if self.containsExists(hierNode):
+                    message = (
+                        f"{self.lvMsg}"
+                        f"COMPAT: Found .exists() in the code. \n"
+                        f"{curNode.text}"
+                    )
+                    self.linter.logViolation(self.ruleID, message)
+                
+    def containsExists(self, node):
+        """Checks if a node or its children contain 'exists' usage."""
+        # Check the current node's text
+        if hasattr(node, 'text') and 'exists' in node.text:
+            return True
+        
+        # Check all SymbolIdentifier nodes in this hierarchy
+        for identifier in node.iter_find_all({"tag": "SymbolIdentifier"}):
+            if identifier.text == "exists":
+                return True
+        
+        return False

SVALint/rules/af_no_dollar_time.py

@@ -0,0 +1,41 @@
+# ----------------------------------------------------
+# SPDX-FileCopyrightText: AsFigo Technologies, UK
+# SPDX-FileCopyrightText: VerifWorks, India
+# SPDX-License-Identifier: MIT
+# ----------------------------------------------------
+
+from ..af_lint_rule import AsFigoLintRule
+import logging
+import anytree
+
+
+class UseRealTimeVsTime(AsFigoLintRule):
+    """Use $realtime than $time in SVA"""
+
+    def __init__(self, linter):
+        self.linter = linter
+        # Store the linter instance
+        self.ruleID = "FUNC_AVOID_DOLLAR_TIME"
+
+    def apply(
+        self, filePath: str, data: AsFigoLintRule.VeribleSyntax.SyntaxData
+    ):
+        for curNode in data.tree.iter_find_all(
+            {"tag": "kPropertyDeclaration"}
+        ):
+            lvSvaCode = curNode.text
+            lvSysTFCall = curNode.iter_find_all({"tag": "kSystemTFCall"})
+            for curSysTFName in lvSysTFCall:
+                lvSysTFNameIter = curSysTFName.iter_find_all({"tag": "SystemTFIdentifier"})
+                lvCurSysTFName = next(lvSysTFNameIter)
+                if ('$time' in lvCurSysTFName.text):
+                    message = (
+                        f"FUNC: Found a call to System function $time "
+                        f"inside a SVA property. "
+                        f"Timing checks should be performed using realtime than "
+                        f"$time. See: below discussion to appreciate the rationale: \n"
+                        f"https://verificationacademy.com/forums/t/sva-for-delayed-state-transition-from-fault-id-to-wait-state-100ms-delay/51322 \n"
+                        f"{lvSvaCode}\n"
+                    )
+
+                    self.linter.logViolation(self.ruleID, message)