Add test cases

Author: JukkaL

mypy/exportjson.py

@@ -67,24 +67,29 @@
 JsonDict: _TypeAlias = dict[str, Any]
 
 
-def convert_binary_cache_to_json(data: bytes) -> JsonDict:
+class Config:
+    def __init__(self, *, implicit_names: bool = True) -> None:
+        self.implicit_names = implicit_names
+
+
+def convert_binary_cache_to_json(data: bytes, *, implicit_names: bool = True) -> JsonDict:
     tree = MypyFile.read(Buffer(data))
-    return convert_mypy_file_to_json(tree)
+    return convert_mypy_file_to_json(tree, Config(implicit_names=implicit_names))
 
 
-def convert_mypy_file_to_json(self: MypyFile) -> JsonDict:
+def convert_mypy_file_to_json(self: MypyFile, cfg: Config) -> JsonDict:
     return {
         ".class": "MypyFile",
         "_fullname": self._fullname,
-        "names": convert_symbol_table(self.names, self._fullname),
+        "names": convert_symbol_table(self.names, cfg),
         "is_stub": self.is_stub,
         "path": self.path,
         "is_partial_stub_package": self.is_partial_stub_package,
         "future_import_flags": sorted(self.future_import_flags),
     }
 
 
-def convert_symbol_table(self: SymbolTable, fullname: str) -> JsonDict:
+def convert_symbol_table(self: SymbolTable, cfg: Config) -> JsonDict:
     data: JsonDict = {".class": "SymbolTable"}
     for key, value in self.items():
         # Skip __builtins__: it's a reference to the builtins
@@ -93,11 +98,20 @@ def convert_symbol_table(self: SymbolTable, fullname: str) -> JsonDict:
         # accessed by users of the module.
         if key == "__builtins__" or value.no_serialize:
             continue
-        data[key] = convert_symbol_table_node(value, fullname, key)
+        if not cfg.implicit_names and key in {
+            "__spec__",
+            "__package__",
+            "__file__",
+            "__doc__",
+            "__annotations__",
+            "__name__",
+        }:
+            continue
+        data[key] = convert_symbol_table_node(value, cfg)
     return data
 
 
-def convert_symbol_table_node(self: SymbolTableNode, prefix: str | None, name: str) -> JsonDict:
+def convert_symbol_table_node(self: SymbolTableNode, cfg: Config) -> JsonDict:
     data: JsonDict = {".class": "SymbolTableNode", "kind": node_kinds[self.kind]}
     if self.module_hidden:
         data["module_hidden"] = True
@@ -110,11 +124,11 @@ def convert_symbol_table_node(self: SymbolTableNode, prefix: str | None, name: s
     if self.cross_ref:
         data["cross_ref"] = self.cross_ref
     elif self.node is not None:
-        data["node"] = convert_symbol_node(self.node)
+        data["node"] = convert_symbol_node(self.node, cfg)
     return data
 
 
-def convert_symbol_node(self: SymbolNode) -> JsonDict:
+def convert_symbol_node(self: SymbolNode, cfg: Config) -> JsonDict:
     if isinstance(self, FuncDef):
         return convert_func_def(self)
     elif isinstance(self, OverloadedFuncDef):
@@ -124,7 +138,7 @@ def convert_symbol_node(self: SymbolNode) -> JsonDict:
     elif isinstance(self, Var):
         return convert_var(self)
     elif isinstance(self, TypeInfo):
-        return convert_type_info(self)
+        return convert_type_info(self, cfg)
     elif isinstance(self, TypeAlias):
         return convert_type_alias(self)
     elif isinstance(self, TypeVarExpr):
@@ -210,12 +224,12 @@ def convert_var(self: Var) -> JsonDict:
     return data
 
 
-def convert_type_info(self: TypeInfo) -> JsonDict:
+def convert_type_info(self: TypeInfo, cfg: Config) -> JsonDict:
     data = {
         ".class": "TypeInfo",
         "module_name": self.module_name,
         "fullname": self.fullname,
-        "names": convert_symbol_table(self.names, self.fullname),
+        "names": convert_symbol_table(self.names, cfg),
         "defn": convert_class_def(self.defn),
         "abstract_attributes": self.abstract_attributes,
         "type_vars": self.type_vars,
@@ -250,7 +264,12 @@ def convert_type_info(self: TypeInfo) -> JsonDict:
 
 
 def convert_class_def(self: ClassDef) -> JsonDict:
-    return {}
+    return {
+        ".class": "ClassDef",
+        "name": self.name,
+        "fullname": self.fullname,
+        "type_vars": [convert_type(v) for v in self.type_vars],
+    }
 
 
 def convert_type_alias(self: TypeAlias) -> JsonDict:

mypy/test/testexportjson.py

@@ -0,0 +1,61 @@
+"""Test cases for the mypy cache JSON export tool."""
+
+from __future__ import annotations
+
+import os
+import json
+import re
+import pprint
+import sys
+
+from mypy import build
+from mypy.errors import CompileError
+from mypy.modulefinder import BuildSource
+from mypy.options import Options
+from mypy.test.config import test_temp_dir
+from mypy.test.data import DataDrivenTestCase, DataSuite
+from mypy.test.helpers import assert_string_arrays_equal
+from mypy.exportjson import convert_binary_cache_to_json
+
+
+class TypeExportSuite(DataSuite):
+    required_out_section = True
+    files = ["exportjson.test"]
+
+    def run_case(self, testcase: DataDrivenTestCase) -> None:
+        try:
+            src = "\n".join(testcase.input)
+            options = Options()
+            options.use_builtins_fixtures = True
+            options.show_traceback = True
+            options.allow_empty_bodies = True
+            options.fixed_format_cache = True
+            result = build.build(
+                sources=[BuildSource("main", None, src)],
+                options=options,
+                alt_lib_path=test_temp_dir,
+            )
+            a = result.errors
+
+            major, minor = sys.version_info[:2]
+            cache_dir = os.path.join(".mypy_cache", f"{major}.{minor}")
+
+            for module in result.files:
+                if module in ("builtins", "typing", "_typeshed", "__main__"):
+                    continue
+                fnam = os.path.join(cache_dir, f"{module}.data.ff")
+                with open(fnam, "rb") as f:
+                    json_data = convert_binary_cache_to_json(f.read(), implicit_names=False)
+                for line in json.dumps(json_data, indent=4).splitlines():
+                    if '"path": ' in line:
+                        # We source file path is unpredictable, so filter it out
+                        line = re.sub(r'"[^"]+\.pyi?"', "...", line)
+                    a.append(line)
+                print(fnam)
+        except CompileError as e:
+            a = e.messages
+        assert_string_arrays_equal(
+            testcase.output,
+            a,
+            f"Invalid output ({testcase.file}, line {testcase.line})",
+        )

test-data/unit/exportjson.test

@@ -0,0 +1,124 @@
+-- Test cases for exporting mypy cache files to JSON (mypy.exportjson).
+--
+-- The tool is maintained on a best effort basis so we don't attempt to have
+-- full test coverage.
+
+[case testExportVar]
+import m
+
+[file m.py]
+x = 0
+
+[out]
+{
+    ".class": "MypyFile",
+    "_fullname": "m",
+    "names": {
+        ".class": "SymbolTable",
+        "x": {
+            ".class": "SymbolTableNode",
+            "kind": "Gdef",
+            "node": {
+                ".class": "Var",
+                "name": "x",
+                "fullname": "m.x",
+                "type": {
+                    ".class": "Instance",
+                    "type_ref": null,
+                    "args": []
+                },
+                "setter_type": null,
+                "flags": [
+                    "is_ready",
+                    "is_inferred",
+                    "has_explicit_value"
+                ]
+            }
+        }
+    },
+    "is_stub": false,
+    "path": ...,
+    "is_partial_stub_package": false,
+    "future_import_flags": []
+}
+
+[case testExportClass]
+import m
+
+[file m.py]
+class C:
+    x: int
+
+[out]
+{
+    ".class": "MypyFile",
+    "_fullname": "m",
+    "names": {
+        ".class": "SymbolTable",
+        "C": {
+            ".class": "SymbolTableNode",
+            "kind": "Gdef",
+            "node": {
+                ".class": "TypeInfo",
+                "module_name": "m",
+                "fullname": "m.C",
+                "names": {
+                    ".class": "SymbolTable",
+                    "x": {
+                        ".class": "SymbolTableNode",
+                        "kind": "Mdef",
+                        "node": {
+                            ".class": "Var",
+                            "name": "x",
+                            "fullname": "m.C.x",
+                            "type": {
+                                ".class": "Instance",
+                                "type_ref": null,
+                                "args": []
+                            },
+                            "setter_type": null,
+                            "flags": [
+                                "is_initialized_in_class",
+                                "is_ready"
+                            ]
+                        }
+                    }
+                },
+                "defn": {
+                    ".class": "ClassDef",
+                    "name": "C",
+                    "fullname": "m.C",
+                    "type_vars": []
+                },
+                "abstract_attributes": [],
+                "type_vars": [],
+                "has_param_spec_type": false,
+                "bases": [
+                    {
+                        ".class": "Instance",
+                        "type_ref": "builtins.object",
+                        "args": []
+                    }
+                ],
+                "mro": [],
+                "_promote": [],
+                "alt_promote": null,
+                "declared_metaclass": null,
+                "metaclass_type": null,
+                "tuple_type": null,
+                "typeddict_type": null,
+                "flags": [],
+                "metadata": {},
+                "slots": null,
+                "deletable_attributes": [],
+                "self_type": null,
+                "dataclass_transform_spec": null,
+                "deprecated": null
+            }
+        }
+    },
+    "is_stub": false,
+    "path": ...,
+    "is_partial_stub_package": false,
+    "future_import_flags": []
+}