afsvalint 2.0__tar.gz

afsvalint-2.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: afsvalint
+Version: 2.0
+Requires-Dist: anytree
+Requires-Dist: tomli
+Requires-Dist: python-string-utils
+Dynamic: requires-dist

afsvalint-2.0/README.md

@@ -0,0 +1,67 @@
+# SVALint
+Linter for SystemVerilog Assertions (SVA). Following the philosophy of BYOL - Build Your Own Linter, SVALint is an example of how users can roll out their own linters! 
+
+**SVALint** is an open-source **minimalist** linter tool designed to enforce style and consistency rules for SystemVerilog code. It provides a framework for **Build Your Own Linter** (**BYOL**), allowing users to create their own custom lint rules while benefiting from built-in checks such as proper encapsulation, naming conventions, line spacing, and other cosmetic rules. This linter integrates seamlessly into your development pipeline to ensure consistent, high-quality code.
+## Table of Contents
+1. [SVALint: SystemVerilog Checker - Linter](#svalint-systemverilog-checker---linter)
+2. [BYOL - Build Your Own Linter](#byol---build-your-own-linter)
+3. [Open Source](#open-source)
+4. [Directory Structure](#directory-structure)
+5. [Installation](#installation)
+6. [Usage](#usage)   - [Running the Linter from Command Line](#running-the-linter-from-command-line)   - [Running with Makefile (Optional)](#running-with-makefile-optional)   - [Test Cases](#test-cases)
+7. [Adding New Lint Rules](#adding-new-lint-rules)
+8. [Example Rule (in `src/rules/`)](#example-rule-in-srcrules)
+9. [Dependencies](#dependencies)
+10. [License](#license)
+11. [Credits](#credits)
+    
+## BYOL - Build Your Own Linter
+The core concept of **SVALint** is **BYOL** (Build Your Own Linter), a framework that lets you easily define custom linting rules tailored to your specific needs. Whether it's enforcing naming conventions, checking for proper encapsulation, or any other rule, **SVALint** is flexible and extensible.
+With **BYOL**, you can create new rules quickly and add them to your pipeline. The linter is fully customizable, empowering you to ensure that your SystemVerilog code adheres to your specific standards.
+## Open Source
+This project is **open source** and licensed under the MIT License. Contributions are welcome, and you are free to fork, modify, and distribute it according to your needs. We encourage you to contribute to the community by adding new rules, improving the existing ones, or integrating **SVALint** with other tools and environments.
+## Directory Structure
+TBD
+## Installation
+1. Clone the repository:
+```bash
+git clone https://github.com/AsFigo/svalint.git
+cd svalint
+```
+3. Install required dependencies - Verible mainly
+
+See: https://github.com/chipsalliance/verible
+
+3. pip install anytree
+4. pip install tomli
+   
+
+## Usage
+### Running the Linter from Command Line
+The linter can be run using the `svalint.py` script located in the `bin/` directory. This script checks SystemVerilog files against the defined style rules.
+1. To run the linter on a specific file:
+```bash
+python bin/svalint.py -t <path_to_file.sv>
+```
+
+### Adding New Lint Rules
+1. Create a new Python file inside the `src/rules/` directory. Each file should contain a class that inherits from the base linter class (`AsFigoLinter`).
+2. Implement the rule logic in the derived class. Each rule should implement a method like `apply` or `run` to check for the specific violation.
+3. After implementing the rule, add the rule to the configuration to enable or disable it.
+
+## Example Rule (in `src/rules/`)
+ 
+## Dependencies
+- Python 3.x- Any necessary libraries like `verible_verilog_syntax`
+
+## License
+This project is **open source** and licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+---
+This **SVALint** linter is part of the **BYOL** (Build Your Own Linter) framework from **AsFigo Technologies**. It's an open-source tool, and we encourage you to contribute to its growth, whether through adding new lint rules, improving existing ones, or enhancing documentation.
+Let us know how you're using **SVALint**, and feel free to contribute back to the community!
+
+## Credits
+The rules and guidelines in **SVALint** are based on the following sources:
+- **SystemVerilog Assertions Handbook***  Ben Cohen, Ajeetha Kumari Venkatesan, Lisa Piper, Srinivasan Venkataramanan: Many of the rules in this linter are inspired by the coding practices and design patterns outlined in this book, which provides a comprehensive approach to SystemVerilog Assertions, focusing on best practices for code quality and maintainability.
+- **lowRISC Coding Guidelines**: This linter also draws upon the coding standards and guidelines from the lowRISC project. Their best practices for SystemVerilog coding have been a key resource for defining rules related to naming conventions, encapsulation, and other critical aspects of design quality.
+- **Verible**: is an opensource SystemVerilog parser from Google and available via ChipsAlliance

afsvalint-2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

afsvalint-2.0/setup.py

@@ -0,0 +1,18 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="afsvalint",
+    version="2.0",
+    packages=find_packages(where="src"),
+    package_dir={"": "src"},
+    install_requires=[
+        "anytree",
+        "tomli",
+        "python-string-utils"
+    ],
+    entry_points={
+        "console_scripts": [
+            "svalint = bin.svalint:main",
+        ],
+    },
+)

afsvalint-2.0/src/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()

afsvalint-2.0/src/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

afsvalint-2.0/src/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()
+    

afsvalint-2.0/src/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"

afsvalint-2.0/src/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)
+
+

afsvalint-2.0/src/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")
+        

afsvalint-2.0/src/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")
+        

afsvalint-2.0/src/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)
+

afsvalint-2.0/src/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)
+

afsvalint-2.0/src/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)
+

afsvalint-2.0/src/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)

afsvalint-2.0/src/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)