Remove orphaned version-bootstrap tooling

Continues the script-sprawl cleanup by dropping the "rootstrap module
update" cluster that only the per-module ffi/dart split ever needed.

- Delete update_modules.py: an undocumented, over-engineered bootstrapper
  for a new version's modules.yaml (token-vote category prediction plus
  multi-tier header synthesis). The documented workflow copies the
  previous version's modules.yaml by hand; this parallel path was never
  referenced by the guide and produced entries that had to be reviewed
  anyway.
- Slim rootstrap_index.py (258 -> 186 lines) down to what
  resolve_type_dups actually uses -- pkg-config Requires direction and
  include-graph reachability. Drop the manifest persistence
  (to_manifest / from_manifest / open) and the update-only queries
  (header_exists / expand_glob / includedir_owners); the
  rootstrap_manifest.yaml baseline they served was never committed.
- resolve_type_dups.py now builds the ownership index only from a live
  rootstrap (the manifest fallback had no producer left); it still
  degrades cleanly to dependency in-degree / file order when no rootstrap
  is present.
- Remove modules_yaml naming helpers (lib_to_module_name, soname_of) that
  only update_modules / import_configs used.

Verified: rootstrap_index's kept queries and resolve_type_dups'
Ownership.decide run correctly against the Tizen 6.0 rootstrap; the
generate path is unaffected -- 6.0 regeneration is byte-identical, dart
analyze is clean, and check_consistency passes for all six versions.

Author: JSUYA

scripts/modules_yaml.py

@@ -3,7 +3,7 @@
 #
 # Provides an ordered, trailing-comment-preserving load/dump cycle that
 # reproduces the committed files byte-for-byte, plus small naming helpers
-# shared by update_modules.py and resolve_type_dups.py.
+# used by build_configs.py, generate_tizen.py and resolve_type_dups.py.
 
 from __future__ import annotations
 
@@ -121,36 +121,3 @@ def to_upper_camel(name: str) -> str:
     return ''.join(p[:1].upper() + p[1:] for p in name.split('_') if p)
 
 
-def lib_to_module_name(libname: str) -> str:
-    """libcapi-appfw-app-common.so.0 -> capi_appfw_app_common"""
-    name = libname
-    if name.startswith('lib'):
-        name = name[3:]
-    name = re.sub(r'(\.so)(\.[0-9]+)*$', '', name)
-    return name.replace('-', '_')
-
-
-def soname_of(base: str, files: list[str]) -> str:
-    """Pick the soname to record in modules.yaml for a library.
-
-    base is the unversioned name ('libfoo.so'); files are all matching
-    filenames in the rootstrap. Committed entries use the runtime soname:
-    the highest major version, in its shortest form ('libfoo.so.1' over
-    'libfoo.so.1.3.3', but 'libfoo.so.0.1' when no single-major file
-    exists). Falls back to base when only the unversioned symlink exists.
-    """
-    versioned = []
-    for f in files:
-        m = re.fullmatch(re.escape(base) + r'((?:\.\d+)+)', f)
-        if m:
-            parts = tuple(int(p) for p in m.group(1)[1:].split('.'))
-            versioned.append((parts, f))
-    if not versioned:
-        return base
-    top_major = max(v[0][0] for v in versioned)
-    in_major = [v for v in versioned if v[0][0] == top_major]
-    # shortest version tuple wins (the actual soname); tie-break on value
-    in_major.sort(key=lambda v: (len(v[0]), v[0]))
-    return in_major[0][1]
-
-

scripts/resolve_type_dups.py

@@ -5,8 +5,8 @@
 #   python3 scripts/resolve_type_dups.py <version> [--assume-generated]
 #
 # Requires a local rootstrap, dart, and llvm (ffigen) — this is a maintainer
-# tool, not a CI check. Typical use right after update_modules.py +
-# generate_bindings.sh on a new version.
+# tool, not a CI check. Typical use right after adding a new version's
+# modules.yaml and running generate_bindings.sh.
 #
 # What it fixes automatically (dart analyze AMBIGUOUS_EXPORT):
 #   struct/union/typedef duplicates -> deps entry on the non-owning module
@@ -237,14 +237,12 @@ def main():
     cfg_path = os.path.join(ROOT, 'configs', args.version, 'modules.yaml')
     cfg, comments = modules_yaml.load(cfg_path)
 
+    # The rootstrap index sharpens ownership decisions (pkg-config Requires and
+    # include-graph direction); without it, decide() falls back to dependency
+    # in-degree and file order.
     rootstrap = os.path.join(ROOT, 'rootstraps', args.version)
-    manifest = os.path.join(ROOT, 'configs', args.version,
-                            'rootstrap_manifest.yaml')
-    index = None
-    if os.path.isdir(rootstrap):
-        index = RootstrapIndex.scan(args.version, rootstrap)
-    elif os.path.isfile(manifest):
-        index = RootstrapIndex.from_manifest(manifest)
+    index = RootstrapIndex.scan(args.version, rootstrap) \
+        if os.path.isdir(rootstrap) else None
 
     if not args.assume_generated and not args.analyze_only and not args.dry_run:
         print('Running initial full generation (generate_bindings.sh)...')

scripts/rootstrap_index.py

@@ -1,19 +1,17 @@
 #!/usr/bin/env python3
-# Rootstrap scanner and index used by update_modules.py / resolve_type_dups.py.
+# Rootstrap scanner used by resolve_type_dups.py to decide type ownership.
 #
 # Scans rootstraps/<version>/usr for shared libraries, headers, and pkg-config
-# files, and can persist the result as configs/<version>/rootstrap_manifest.yaml
-# so future bootstraps can diff against a version whose SDK is no longer
-# installed (rootstraps/ itself is gitignored).
+# files, and answers the two questions the duplicate-type resolver needs: does
+# one pkg-config Require another, and does one header transitively #include
+# another (include-graph reachability).
 
 from __future__ import annotations
 
 import os
 import re
 from collections import deque
 
-import yaml
-
 ROOT = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
 
 _LIB_RE = re.compile(r'^(lib[^/]+?\.so)((?:\.\d+)*)$')
@@ -25,21 +23,8 @@ class PcInfo:
     def __init__(self, name):
         self.name = name
         self.libs = []          # bare -l names, e.g. 'capi-appfw-application'
-        self.includedirs = []   # relative to rootstrap root, e.g. 'usr/include/appfw'
         self.requires = []      # pc names from Requires:
 
-    def to_dict(self):
-        return {'libs': self.libs, 'includedirs': self.includedirs,
-                'requires': self.requires}
-
-    @classmethod
-    def from_dict(cls, name, d):
-        pc = cls(name)
-        pc.libs = d.get('libs') or []
-        pc.includedirs = d.get('includedirs') or []
-        pc.requires = d.get('requires') or []
-        return pc
-
 
 def _parse_pc(path: str, name: str) -> PcInfo:
     pc = PcInfo(name)
@@ -66,10 +51,6 @@ def expand(s: str, depth=0) -> str:
     for tok in expand(fields.get('Libs', '')).split():
         if tok.startswith('-l'):
             pc.libs.append(tok[2:])
-    for tok in expand(fields.get('Cflags', '')).split():
-        if tok.startswith('-I'):
-            d = tok[2:].lstrip('/')
-            pc.includedirs.append(d)
     for tok in re.split(r'[,\s]+', expand(fields.get('Requires', ''))):
         # skip version constraints like '>=' '1.0'
         if tok and not re.match(r'^[<>=!]|^\d', tok):
@@ -122,60 +103,7 @@ def scan(cls, version: str, rootstrap_dir: str) -> 'RootstrapIndex':
                     idx.pc_by_lib.setdefault(base, name)
         return idx
 
-    def to_manifest(self, path: str):
-        data = {
-            'version': self.version,
-            'libs': {b: sorted(fs) for b, fs in sorted(self.lib_files.items())},
-            'headers': sorted(self.headers),
-            'pkgconfig': {n: pc.to_dict() for n, pc in sorted(self.pcs.items())},
-        }
-        with open(path, 'w') as f:
-            yaml.safe_dump(data, f, sort_keys=True, width=200)
-
-    @classmethod
-    def from_manifest(cls, path: str) -> 'RootstrapIndex':
-        with open(path) as f:
-            data = yaml.safe_load(f)
-        idx = cls(str(data['version']))
-        idx.lib_files = {b: list(fs) for b, fs in (data.get('libs') or {}).items()}
-        idx.headers = set(data.get('headers') or [])
-        for name, d in (data.get('pkgconfig') or {}).items():
-            idx.pcs[name] = PcInfo.from_dict(name, d)
-        for name, pc in idx.pcs.items():
-            for l in pc.libs:
-                base = f'lib{l}.so'
-                if base in idx.lib_files:
-                    idx.pc_by_lib.setdefault(base, name)
-        return idx
-
-    @classmethod
-    def open(cls, version: str, path: str) -> 'RootstrapIndex':
-        """Load from a rootstrap directory or a manifest file."""
-        if os.path.isdir(path):
-            return cls.scan(version, path)
-        return cls.from_manifest(path)
-
-    # -- queries ---------------------------------------------------------------
-
-    def header_exists(self, ref: str) -> bool:
-        """ref as written in modules.yaml (basename or subpath)."""
-        if ref in self.headers:
-            return True
-        suffix = '/' + ref
-        return any(h.endswith(suffix) for h in self.headers)
-
-    def expand_glob(self, pattern: str) -> list[str]:
-        """Expand a ffigen include-directive glob like '**/AL/*.h'."""
-        pat = pattern.lstrip('/')
-        if pat.startswith('**/'):
-            pat = pat[3:]
-        rx = re.compile(
-            '(^|/)' + re.escape(pat).replace(r'\*\*', '.*').replace(r'\*', '[^/]*') + '$')
-        return sorted(h for h in self.headers if rx.search(h))
-
-    def includedir_owners(self, d: str) -> list[str]:
-        """pc names whose Cflags mention include dir d (relative path)."""
-        return [n for n, pc in self.pcs.items() if d in pc.includedirs]
+    # -- ownership queries -----------------------------------------------------
 
     def pc_requires_transitively(self, a: str, b: str, depth: int = 2) -> bool:
         """True if pc `a` requires pc `b` within `depth` hops."""