python-ta 2.9.1__tar.gz → 2.10.0__tar.gz

{python_ta-2.9.1/python_ta.egg-info → python_ta-2.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: python-ta
-Version: 2.9.1
+Version: 2.10.0
 Summary: Code checking tool for teaching Python
 Author-email: David Liu <david@cs.toronto.edu>
 License: MIT
@@ -15,8 +15,9 @@ Requires-Dist: astroid~=3.3.5
 Requires-Dist: click<9,>=8.0.1
 Requires-Dist: colorama~=0.4.6
 Requires-Dist: jinja2~=3.1.2
+Requires-Dist: mypy~=1.13
 Requires-Dist: pycodestyle~=2.11
-Requires-Dist: pygments<2.19,>=2.14
+Requires-Dist: pygments<2.20,>=2.14
 Requires-Dist: pylint~=3.3.1
 Requires-Dist: requests<2.33,>=2.28
 Requires-Dist: six
@@ -123,6 +124,7 @@ Simon Chen,
 Freeman Cheng,
 Ivan Chepelev,
 Yianni Culmone,
+Daniel Dervishi,
 Nigel Fong,
 Adam Gleizer,
 Ibrahim Hasan,
@@ -134,6 +136,7 @@ David Kim,
 Simeon Krastnikov,
 Ryan Lee,
 Christopher Li,
+Hoi Ching (Herena) Li,
 Hayley Lin,
 Bruce Liu,
 Merrick Liu,

{python_ta-2.9.1 → python_ta-2.10.0}/README.md

@@ -78,6 +78,7 @@ Simon Chen,
 Freeman Cheng,
 Ivan Chepelev,
 Yianni Culmone,
+Daniel Dervishi,
 Nigel Fong,
 Adam Gleizer,
 Ibrahim Hasan,
@@ -89,6 +90,7 @@ David Kim,
 Simeon Krastnikov,
 Ryan Lee,
 Christopher Li,
+Hoi Ching (Herena) Li,
 Hayley Lin,
 Bruce Liu,
 Merrick Liu,

{python_ta-2.9.1 → python_ta-2.10.0}/pyproject.toml

@@ -11,8 +11,9 @@ dependencies = [
     "click >= 8.0.1, < 9",
     "colorama ~= 0.4.6",
     "jinja2 ~= 3.1.2",
+    "mypy ~= 1.13",
     "pycodestyle ~= 2.11",
-    "pygments >= 2.14,< 2.19",
+    "pygments >= 2.14,< 2.20",
     "pylint ~= 3.3.1",
     "requests >= 2.28,< 2.33",
     "six",

{python_ta-2.9.1 → python_ta-2.10.0}/python_ta/__init__.py

@@ -17,7 +17,7 @@ if __name__ == '__main__':
 
 from __future__ import annotations
 
-__version__ = "2.9.1"  # Version number
+__version__ = "2.10.0"  # Version number
 # First, remove underscore from builtins if it has been bound in the REPL.
 # Must appear before other imports from pylint/python_ta.
 import builtins
@@ -37,7 +37,7 @@ import tokenize
 import webbrowser
 from builtins import FileNotFoundError
 from os import listdir
-from typing import AnyStr, Generator, Optional, TextIO, Union
+from typing import Any, AnyStr, Generator, Optional, TextIO, Union
 
 import pylint.config
 import pylint.lint
@@ -66,8 +66,8 @@ PYLINT_PATCHED = False
 
 def check_errors(
     module_name: Union[list[str], str] = "",
-    config: Union[dict, str] = "",
-    output: Optional[TextIO] = None,
+    config: Union[dict[str, Any], str] = "",
+    output: Optional[str] = None,
     load_default_config: bool = True,
     autoformat: Optional[bool] = False,
 ) -> PythonTaReporter:
@@ -84,12 +84,38 @@ def check_errors(
 
 def check_all(
     module_name: Union[list[str], str] = "",
-    config: Union[dict, str] = "",
-    output: Optional[TextIO] = None,
+    config: Union[dict[str, Any], str] = "",
+    output: Optional[str] = None,
     load_default_config: bool = True,
     autoformat: Optional[bool] = False,
 ) -> PythonTaReporter:
-    """Check a module for errors and style warnings, printing a report."""
+    """Analyse one or more Python modules for code issues and display the results.
+
+    Args:
+        module_name:
+            If an empty string (default), the module where this function is called is checked.
+            If a non-empty string, it is interpreted as a path to a single Python module or a
+            directory containing Python modules. If the latter, all Python modules in the directory
+            are checked.
+            If a list of strings, each string is interpreted as a path to a module or directory,
+            and all modules across all paths are checked.
+        config:
+            If a string, a path to a configuration file to use.
+            If a dictionary, a map of configuration options (each key is the name of an option).
+        output:
+            If provided, the PythonTA report is written to this path. Otherwise, the report
+            is written to standard out or automatically displayed in a web browser, depending
+            on which reporter is used.
+        load_default_config:
+            If True (default), additional configuration passed with the ``config`` option is
+            merged with the default PythonTA configuration file.
+            If False, the default PythonTA configuration is not used.
+        autoformat:
+            If True, autoformat all modules using the black formatting tool before analyzing code.
+
+    Returns:
+        The ``PythonTaReporter`` object that generated the report.
+    """
     return _check(
         module_name=module_name,
         level="all",
@@ -103,8 +129,8 @@ def check_all(
 def _check(
     module_name: Union[list[str], str] = "",
     level: str = "all",
-    local_config: Union[dict, str] = "",
-    output: Optional[TextIO] = None,
+    local_config: Union[dict[str, Any], str] = "",
+    output: Optional[str] = None,
     load_default_config: bool = True,
     autoformat: Optional[bool] = False,
 ) -> PythonTaReporter:
@@ -116,13 +142,13 @@ def _check(
       - no argument -- checks the python file containing the function call.
     `level` is used to specify which checks should be made.
     `local_config` is a dict of config options or string (config file name).
-    `output` is an absolute or relative path to capture pyta data output. Default std out.
+    `output` is an absolute or relative path to capture pyta data output. If None, stdout is used.
     `load_default_config` is used to specify whether to load the default .pylintrc file that comes
     with PythonTA. It will load it by default.
     `autoformat` is used to specify whether the black formatting tool is run. It is not run by default.
     """
     # Configuring logger
-    logging.basicConfig(format="[%(levelname)s] %(message)s", level=logging.NOTSET)
+    logging.basicConfig(format="[%(levelname)s] %(message)s", level=logging.INFO)
 
     linter = reset_linter(config=local_config, load_default_config=load_default_config)
     current_reporter = linter.reporter
@@ -164,16 +190,13 @@ def _check(
                 )
 
                 if autoformat:
-                    linelen = (
-                        local_config["max-line-length"] if "max-line-length" in local_config else 88
-                    )
                     subprocess.run(
                         [
                             sys.executable,
                             "-m",
                             "black",
                             "--skip-string-normalization",
-                            "--line-length=" + str(linelen),
+                            f"--line-length={linter.config.max_line_length}",
                             file_py,
                         ],
                         encoding="utf-8",
@@ -204,12 +227,12 @@ def _check(
                 current_reporter.print_messages(level)
                 if linter.config.pyta_file_permission:
                     f_paths.append(file_py)  # Appending paths for upload
-                logging.info(
+                logging.debug(
                     "File: {} was checked using the configuration file: {}".format(
                         file_py, linter.config_file
                     )
                 )
-                logging.info(
+                logging.debug(
                     "File: {} was checked using the messages-config file: {}".format(
                         file_py, messages_config_path
                     )
@@ -256,24 +279,43 @@ def reset_linter(
         - If the config argument is a dictionary, apply those options afterward.
     Do not re-use a linter object. Returns a new linter.
     """
+
     # Tuple of custom options. Note: 'type' must map to a value equal a key in the pylint/config/option.py `VALIDATORS` dict.
     new_checker_options = (
+        (
+            "server-port",
+            {
+                "default": 0,
+                "type": "int",
+                "metavar": "<port>",
+                "help": "Port number for the HTML report server",
+            },
+        ),
+        (
+            "watch",
+            {
+                "default": False,
+                "type": "yn",
+                "metavar": "<yn>",
+                "help": "Run the HTML report server in persistent mode",
+            },
+        ),
         (
             "pyta-number-of-messages",
             {
                 "default": 0,  # If the value is 0, all messages are displayed.
                 "type": "int",
                 "metavar": "<number_messages>",
-                "help": "Display a certain number of messages to the user, without overwhelming them.",
+                "help": "The maximum number of occurrences of each check to report.",
             },
         ),
         (
             "pyta-template-file",
             {
-                "default": "template.html.jinja",
+                "default": "",
                 "type": "string",
                 "metavar": "<pyta_reporter>",
-                "help": "Template file for html format of htmlreporter output.",
+                "help": "HTML template file for the HTMLReporter.",
             },
         ),
         (
@@ -320,7 +362,7 @@ def reset_linter(
                 "default": False,
                 "type": "yn",
                 "metavar": "<yn>",
-                "help": "allows or disallows pylint: comments",
+                "help": "Allows or disallows 'pylint:' comments",
             },
         ),
         (
@@ -482,7 +524,11 @@ def _get_valid_files_to_check(module_name: Union[list[str], str]) -> Generator[A
 
 
 def doc(msg_id: str) -> None:
-    """Open a webpage explaining the error for the given message."""
+    """Open the PythonTA documentation page for the given error message id.
+
+    Args:
+        msg_id: The five-character error code, e.g. ``"E0401"``.
+    """
     msg_url = HELP_URL + "#" + msg_id.lower()
     print("Opening {} in a browser.".format(msg_url))
     webbrowser.open(msg_url)

{python_ta-2.9.1 → python_ta-2.10.0}/python_ta/cfg/__init__.py

@@ -1,2 +1,3 @@
+from .cfg_generator import generate_cfg
 from .graph import *
 from .visitor import *

{python_ta-2.9.1 → python_ta-2.10.0}/python_ta/cfg/cfg_generator.py

@@ -4,6 +4,7 @@ Provides a function to generate and display the control flow graph of a given mo
 
 from __future__ import annotations
 
+import html
 import importlib.util
 import os.path
 import sys
@@ -110,7 +111,7 @@ def _get_valid_file_path(mod: str = "") -> Optional[str]:
 def _display(
     cfgs: dict[nodes.NodeNG, ControlFlowGraph], filename: str, auto_open: bool = False
 ) -> None:
-    graph = graphviz.Digraph(name=filename, **GRAPH_OPTIONS)
+    graph = graphviz.Digraph(name=filename + ".gv", **GRAPH_OPTIONS)
     for node, cfg in cfgs.items():
         if isinstance(node, nodes.Module):
             subgraph_label = "__main__"
@@ -129,7 +130,7 @@ def _display(
                 _visit(block, c, visited, cfg.end)
             c.attr(label=subgraph_label, **SUBGRAPH_OPTIONS)
 
-    graph.render(filename, view=auto_open)
+    graph.render(outfile=filename + ".svg", view=auto_open)
 
 
 def _visit(block: CFGBlock, graph: graphviz.Digraph, visited: set[int], end: CFGBlock) -> None:
@@ -140,15 +141,37 @@ def _visit(block: CFGBlock, graph: graphviz.Digraph, visited: set[int], end: CFG
     if node_id in visited:
         return
 
-    label = "\n".join([s.as_string() for s in block.statements]) + "\n"
+    label = ""
+    fill_color = "white"
+
+    # Identify special cases
+    if len(block.statements) == 1:
+        stmt = block.statements[0]
+        if isinstance(stmt, nodes.Arguments):
+            label = f"{stmt.as_string()}\n"
+            fill_color = "palegreen"
+        elif isinstance(stmt.parent, nodes.If) and stmt is stmt.parent.test:
+            label = f"< if<U><B>{html.escape(stmt.as_string())}</B></U><BR/> >"
+        elif isinstance(stmt.parent, nodes.While) and stmt is stmt.parent.test:
+            label = f"< while<U><B>{html.escape(stmt.as_string())}</B></U><BR/> >"
+        elif isinstance(stmt.parent, nodes.For) and stmt is stmt.parent.iter:
+            label = f"< for {html.escape(stmt.parent.target.as_string())} in<U><B>{html.escape(stmt.as_string())}</B></U><BR/> >"
+        elif isinstance(stmt.parent, nodes.For) and stmt is stmt.parent.target:
+            label = f"< for<U><B>{html.escape(stmt.as_string())} </B></U> in {html.escape(stmt.parent.iter.as_string())}<BR/> >"
+
+    if not label:  # Default
+        label = "\n".join([s.as_string() for s in block.statements]) + "\n"
+
     # Need to escape backslashes explicitly.
     label = label.replace("\\", "\\\\")
     # \l is used for left alignment.
     label = label.replace("\n", "\\l")
 
-    fill_color = "grey93" if not block.reachable else "white"
-    # Change the fill colour if block is the end of the cfg
-    fill_color = "black" if block == end else fill_color
+    # Change the fill colour if block is the end of the cfg or unreachable
+    if block == end:
+        fill_color = "black"
+    elif not block.reachable:
+        fill_color = "grey93"
 
     graph.node(node_id, label=label, fillcolor=fill_color, style="filled")
     visited.add(node_id)

{python_ta-2.9.1 → python_ta-2.10.0}/python_ta/cfg/graph.py

@@ -56,7 +56,7 @@ class ControlFlowGraph:
     # z3 constraints of preconditions
     precondition_constraints: List[ExprRef]
     # map from variable names to z3 variables
-    _z3_vars: Dict[str, ExprRef]
+    z3_vars: Dict[str, ExprRef]
 
     def __init__(self, cfg_id: int = 0) -> None:
         self.block_count = 0
@@ -64,7 +64,7 @@ class ControlFlowGraph:
         self.unreachable_blocks = set()
         self.start = self.create_block()
         self.end = self.create_block()
-        self._z3_vars = {}
+        self.z3_vars = {}
         self.precondition_constraints = []
 
     def add_arguments(self, args: Arguments) -> None:
@@ -76,7 +76,7 @@ class ControlFlowGraph:
             # Parse types
             parser = Z3Parser()
             z3_vars = parser.parse_arguments(args)
-            self._z3_vars.update(z3_vars)
+            self.z3_vars.update(z3_vars)
 
     def create_block(
         self,
@@ -276,7 +276,7 @@ class ControlFlowGraph:
 
         for path_id, path in enumerate(self.get_paths()):
             # starting a new path
-            z3_environment = Z3Environment(self._z3_vars, self.precondition_constraints)
+            z3_environment = Z3Environment(self.z3_vars, self.precondition_constraints)
             for edge in path:
                 # traverse through edge
                 if edge.condition is not None:

python_ta-2.10.0/python_ta/checkers/condition_logic_checker.py

@@ -0,0 +1,115 @@
+"""
+Check for redundant/impossible If or While conditions in functions based on z3 constraints
+"""
+
+from __future__ import annotations
+
+from typing import Any, Union
+
+try:
+    import z3
+
+    from ..cfg.graph import Z3Environment
+
+    z3_dependency_available = True
+except ImportError:
+    z3 = Any
+    Z3Environment = Any
+    z3_dependency_available = False
+
+from astroid import nodes
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import only_required_for_messages
+from pylint.lint import PyLinter
+
+
+class ConditionLogicChecker(BaseChecker):
+    name = "redundant-condition"
+    msgs = {
+        "R9900": (
+            """This condition will always evaluate to True.""",
+            "redundant-condition",
+            "Used when an If or While statement is always True. Requires the z3 configuration option to be True.",
+        ),
+        "R9901": (
+            """This condition will always evaluate to False.""",
+            "impossible-condition",
+            "Used when an If or While statement is always False. Requires the z3 configuration option to be True.",
+        ),
+    }
+    options = (
+        (
+            "z3",
+            {
+                "default": False,
+                "type": "yn",
+                "metavar": "<y or n>",
+                "help": "Use Z3 to perform logical feasibility analysis in program control flow.",
+            },
+        ),
+    )
+
+    @only_required_for_messages("redundant-condition", "impossible-condition")
+    def visit_if(self, node: nodes.If) -> None:
+        """Visit if statement"""
+        self._check_condition(node)
+
+    @only_required_for_messages("redundant-condition", "impossible-condition")
+    def visit_while(self, node: nodes.While) -> None:
+        """Visit while statement"""
+        self._check_condition(node)
+
+    def _check_condition(self, node: Union[nodes.If, nodes.While]) -> None:
+        """Check whether a condition in an `if` or `while` statement is redundant
+        or impossible based on the feasible execution paths.
+
+        - A condition is redundant if for every feasible execution path
+        leading to the node, the condition must be True due to precedent constraints.
+        - A condition is impossible if for every feasible execution path
+        leading to the node, the condition must be False due to precedent constraints.
+        """
+        if (
+            not hasattr(node, "cfg_block")
+            or not z3_dependency_available
+            or not self.linter.config.z3
+        ):
+            return
+
+        node_block = node.cfg_block
+
+        # create node condition z3 constraint
+        condition_node = node.test
+        env = Z3Environment(node.frame().cfg.z3_vars, [])
+        z3_condition = env.parse_constraint(condition_node)
+
+        if z3_condition is None:
+            return
+
+        if all(
+            self._check_unsat(z3.And(*constraints), z3.Not(z3_condition))
+            for edge in (pred for pred in node_block.predecessors if pred.is_feasible)
+            for constraints in edge.z3_constraints.values()
+        ):
+            self.add_message("redundant-condition", node=node.test)
+
+        if all(
+            self._check_unsat(z3.And(*constraints), z3_condition)
+            for edge in (pred for pred in node_block.predecessors if pred.is_feasible)
+            for constraints in edge.z3_constraints.values()
+        ):
+            self.add_message("impossible-condition", node=node.test)
+
+    def _check_unsat(self, prev_constraints: z3.ExprRef, node_constraint: z3.ExprRef) -> bool:
+        """Check if the conjunction of the given constraints is unsatisfiable.
+
+        - prev_constraints (z3.ExprRef): Constraints from previous nodes.
+        - node_constraint (z3.ExprRef): The condition to check at the current node.
+        """
+        solver = z3.Solver()
+        solver.add(z3.And(prev_constraints, node_constraint))
+        return solver.check() == z3.unsat
+
+
+def register(linter: PyLinter) -> None:
+    """Required method to auto-register this checker to the linter."""
+    linter.register_checker(ConditionLogicChecker(linter))

{python_ta-2.9.1 → python_ta-2.10.0}/python_ta/checkers/pycodestyle_checker.py

@@ -28,9 +28,9 @@ class PycodestyleChecker(BaseRawFileChecker):
         ),
     )
 
-    def process_module(self, node: nodes.NodeNG) -> None:
+    def process_module(self, node: nodes.Module) -> None:
         style_guide = pycodestyle.StyleGuide(
-            paths=[node.stream().name],
+            paths=[node.file],
             reporter=JSONReport,
             ignore=self.linter.config.pycodestyle_ignore,
         )

{python_ta-2.9.1 → python_ta-2.10.0}/python_ta/checkers/redundant_assignment_checker.py

@@ -76,7 +76,7 @@ class RedundantAssignmentChecker(BaseChecker):
     @only_required_for_messages("redundant-assignment")
     def visit_annassign(self, node: nodes.AnnAssign) -> None:
         """Visit the annotated assign node"""
-        if node in self._redundant_assignment:
+        if node.value is not None and node in self._redundant_assignment:
             self.add_message("redundant-assignment", node=node, args=node.target.name)
 
     def visit_module(self, node: nodes.Module) -> None:
@@ -151,7 +151,9 @@ class RedundantAssignmentChecker(BaseChecker):
                     parent = (
                         node.parent.parent if isinstance(node.parent, nodes.Tuple) else node.parent
                     )
-                    if node.name in gen.difference(kill):
+                    if isinstance(parent, nodes.AnnAssign) and parent.value is None:
+                        continue
+                    elif node.name in gen.difference(kill):
                         # add redundant assignment
                         if parent not in self._redundant_assignment:
                             self._redundant_assignment[parent] = []

python_ta-2.10.0/python_ta/checkers/static_type_checker.py

@@ -0,0 +1,134 @@
+import re
+from typing import Optional
+
+from astroid import nodes
+from mypy import api
+from pylint.checkers import BaseRawFileChecker
+from pylint.lint import PyLinter
+
+
+class StaticTypeChecker(BaseRawFileChecker):
+    """Checker for static type checking using Mypy."""
+
+    name = "static_type_checker"
+    msgs = {
+        "E9951": (
+            "Argument %s to %s has incompatible type %s; expected %s",
+            "incompatible-argument-type",
+            "Used when a function argument has an incompatible type",
+        ),
+        "E9952": (
+            "Incompatible types in assignment (expression has type %s, variable has type %s)",
+            "incompatible-assignment",
+            "Used when there is an incompatible assignment",
+        ),
+        "E9953": (
+            "List item %s has incompatible type %s; expected %s",
+            "list-item-type-mismatch",
+            "Used when a list item has an incompatible type",
+        ),
+        "E9954": (
+            "Unsupported operand types for %s (%s and %s)",
+            "unsupported-operand-types",
+            "Used when an operation is attempted between incompatible types",
+        ),
+        "E9955": (
+            "Item of type %s in Union has no attribute %s",
+            "union-attr-error",
+            "Used when accessing an attribute that may not exist on a Union type",
+        ),
+        "E9956": (
+            "Dict entry %s has incompatible type %s: %s; expected %s: %s",
+            "dict-item-type-mismatch",
+            "Used when a dictionary entry has an incompatible key or value type",
+        ),
+    }
+    options = (
+        (
+            "mypy-options",
+            {
+                "default": ["ignore-missing-imports", "follow-imports=skip"],
+                "type": "csv",
+                "metavar": "<mypy options>",
+                "help": "List of configuration flags for mypy",
+            },
+        ),
+    )
+
+    COMMON_PATTERN = (
+        r"^(?P<file>[^:]+):(?P<start_line>\d+):(?P<start_col>\d+):"
+        r"(?P<end_line>\d+):(?P<end_col>\d+): error: (?P<message>.+) \[(?P<code>[\w-]+)\]"
+    )
+
+    SPECIFIC_PATTERNS = {
+        "arg-type": re.compile(
+            r"Argument (?P<arg_num>\d+) to \"(?P<func_name>[^\"]+)\" has incompatible type \"(?P<incomp_type>[^\"]+)\"; expected \"(?P<exp_type>[^\"]+)\""
+        ),
+        "assignment": re.compile(
+            r"Incompatible types in assignment \(expression has type \"(?P<expr_type>[^\"]+)\", variable has type \"(?P<var_type>[^\"]+)\"\)"
+        ),
+        "list-item": re.compile(
+            r"List item (?P<item_index>\d+) has incompatible type \"(?P<item_type>[^\"]+)\"; expected \"(?P<exp_type>[^\"]+)\""
+        ),
+        "operator": re.compile(
+            r"Unsupported operand types for (?P<operator>\S+) \(\"(?P<left_type>[^\"]+)\" and \"(?P<right_type>[^\"]+)\"\)"
+        ),
+        "union-attr": re.compile(
+            r"Item \"(?P<item_type>[^\"]+)\" of \"[^\"]+\" has no attribute \"(?P<attribute>[^\"]+)\""
+        ),
+        "dict-item": re.compile(
+            r"Dict entry (?P<entry_index>\d+) has incompatible type \"(?P<key_type>[^\"]+)\": \"(?P<value_type>[^\"]+)\"; expected \"(?P<exp_key_type>[^\"]+)\": \"(?P<exp_value_type>[^\"]+)\""
+        ),
+    }
+
+    def process_module(self, node: nodes.Module) -> None:
+        """Run Mypy on the current file and handle type errors."""
+        filename = node.file
+
+        mypy_options = ["--show-error-end"]
+        for arg in self.linter.config.mypy_options:
+            mypy_options.append("--" + arg)
+
+        result, _, _ = api.run([filename] + mypy_options)
+
+        for line in result.splitlines():
+            common_match = re.match(self.COMMON_PATTERN, line)
+            if not common_match:
+                continue
+
+            common_data = common_match.groupdict()
+
+            specific_pattern = self.SPECIFIC_PATTERNS.get(common_data["code"])
+            if specific_pattern:
+                specific_match = specific_pattern.search(common_data["message"])
+                if specific_match:
+                    specific_data = specific_match.groupdict()
+                    self._add_message(common_data, specific_data)
+
+    def _add_message(self, common_data: dict, specific_data: dict) -> None:
+        """Add a message using the common and specific data."""
+        code = common_data["code"]
+        code_to_msgid = {
+            "arg-type": "incompatible-argument-type",
+            "assignment": "incompatible-assignment",
+            "list-item": "list-item-type-mismatch",
+            "operator": "unsupported-operand-types",
+            "union-attr": "union-attr-error",
+            "dict-item": "dict-item-type-mismatch",
+        }
+        msgid = code_to_msgid.get(code)
+        if not msgid:
+            return
+        self.add_message(
+            msgid,
+            line=int(common_data["start_line"]),
+            col_offset=int(common_data["start_col"]),
+            end_lineno=int(common_data["end_line"]),
+            end_col_offset=int(common_data["end_col"]),
+            args=tuple(specific_data.values()),
+        )
+
+
+def register(linter: PyLinter) -> None:
+    """Register the static type checker with the PyLinter."""
+    linter.register_checker(StaticTypeChecker(linter))