Arm backend: Flatten nested Python manifest tables

Flatten nested TOML tables when reading Python public API
manifest entries so validation also checks nested symbols.

Add regression coverage that shows nested entries are parsed
and that missing nested symbols are reported by validation.

Signed-off-by: Sebastian Larsson <sebastian.larsson@arm.com>
Change-Id: Ic04883d07647b3b6f4ed9b86c68d969dcbd90ade

Author: Sebastian-Larsson

backends/arm/scripts/public_api_manifest/validate_public_api_manifest.py

@@ -56,25 +56,38 @@ def read_manifest(manifest_path: Path) -> dict:
         return tomllib.load(manifest_file)
 
 
-def get_manifest_python_symbols(manifest: dict) -> dict[str, dict[str, str]]:
-    python_manifest = manifest.get("python")
-    if not isinstance(python_manifest, dict):
-        raise ValueError("Manifest is missing [python] section")
-
+def _collect_python_symbols(
+    table: dict[str, object],
+    *,
+    prefix: str = "",
+) -> dict[str, dict[str, str]]:
     symbols: dict[str, dict[str, str]] = {}
-    for name, entry in python_manifest.items():
-        if not isinstance(entry, dict):
-            raise ValueError(f"Entry [python.{name}] must be a table")
-        kind = entry.get("kind")
-        signature = entry.get("signature")
+    kind = table.get("kind")
+    signature = table.get("signature")
+    if kind is not None or signature is not None:
         if not isinstance(kind, str) or not isinstance(signature, str):
             raise ValueError(
-                f"Entry [python.{name}] must define `kind` and `signature`"
+                f"Entry [python.{prefix}] must define `kind` and `signature`"
             )
-        symbols[name] = {"kind": kind, "signature": signature}
+        symbols[prefix] = {"kind": kind, "signature": signature}
+
+    for name, entry in table.items():
+        if name in {"kind", "signature"}:
+            continue
+        if not isinstance(entry, dict):
+            raise ValueError(f"Entry [python.{prefix}] contains invalid child {name}")
+        child_prefix = f"{prefix}.{name}" if prefix else name
+        symbols.update(_collect_python_symbols(entry, prefix=child_prefix))
     return symbols
 
 
+def get_manifest_python_symbols(manifest: dict) -> dict[str, dict[str, str]]:
+    python_manifest = manifest.get("python")
+    if not isinstance(python_manifest, dict):
+        raise ValueError("Manifest is missing [python] section")
+    return _collect_python_symbols(python_manifest)
+
+
 def get_current_python_symbols(
     *,
     include_deprecated: bool = False,

backends/arm/test/misc/test_validate_public_api_manifest.py

@@ -6,9 +6,16 @@
 from pathlib import Path
 
 import executorch.backends.arm.scripts.public_api_manifest.validate_public_api_manifest as vpam
+
+try:
+    import tomllib
+except ModuleNotFoundError:
+    import tomli as tomllib
+
 from executorch.backends.arm.scripts.public_api_manifest.validate_public_api_manifest import (
     format_validation_report,
     get_current_python_symbols,
+    get_manifest_python_symbols,
     validate_symbols,
 )
 
@@ -36,6 +43,61 @@ def test_public_api_manifest_exact_comparison_rejects_signature_expansion():
     assert issues[0][1] == "signature changed"
 
 
+def test_get_manifest_python_symbols_flattens_nested_tables():
+    manifest = tomllib.loads(
+        """
+        [python]
+
+        [python.Foo]
+        kind = "class"
+        signature = "Foo()"
+
+        [python.Foo.bar]
+        kind = "function"
+        signature = "Foo.bar() -> None"
+        """
+    )
+
+    assert get_manifest_python_symbols(manifest) == {
+        "Foo": {"kind": "class", "signature": "Foo()"},
+        "Foo.bar": {"kind": "function", "signature": "Foo.bar() -> None"},
+    }
+
+
+def test_nested_python_manifest_entries_are_validated():
+    manifest_symbols = get_manifest_python_symbols(
+        tomllib.loads(
+            """
+            [python]
+
+            [python.Foo]
+            kind = "class"
+            signature = "Foo()"
+
+            [python.Foo.bar]
+            kind = "function"
+            signature = "Foo.bar(x: int) -> int"
+            """
+        )
+    )
+
+    issues = validate_symbols(
+        manifest_symbols,
+        {
+            "Foo": {"kind": "class", "signature": "Foo()"},
+        },
+    )
+
+    assert issues == [
+        (
+            "Foo.bar",
+            "entry is present in the manifest but missing from the current API",
+            "Foo.bar(x: int) -> int",
+            None,
+        )
+    ]
+
+
 def test_public_api_manifest_static_accepts_backward_compatible_signature_expansion():
     manifest_entries = {
         "foo": {"kind": "function", "signature": "foo(x: int, y: int = 0) -> int"}