scripts/generate_rust_analyzer.py

   1 #!/usr/bin/env python3
   2 # SPDX-License-Identifier: GPL-2.0
   3 """generate_rust_analyzer - Generates the `rust-project.json` file for `rust-analyzer`.
   4 """
   5
   6 import argparse
   7 import json
   8 import logging
   9 import os
  10 import pathlib
  11 import sys
  12
  13 def args_crates_cfgs(cfgs):
  14     crates_cfgs = {}
  15     for cfg in cfgs:
  16         crate, vals = cfg.split("=", 1)
  17         crates_cfgs[crate] = vals.replace("--cfg", "").split()
  18
  19     return crates_cfgs
  20
  21 def generate_crates(srctree, objtree, sysroot_src, external_src, cfgs):
  22     # Generate the configuration list.
  23     cfg = []
  24     with open(objtree / "include" / "generated" / "rustc_cfg") as fd:
  25         for line in fd:
  26             line = line.replace("--cfg=", "")
  27             line = line.replace("\n", "")
  28             cfg.append(line)
  29
  30     # Now fill the crates list -- dependencies need to come first.
  31     #
  32     # Avoid O(n^2) iterations by keeping a map of indexes.
  33     crates = []
  34     crates_indexes = {}
  35     crates_cfgs = args_crates_cfgs(cfgs)
  36
  37     def append_crate(display_name, root_module, deps, cfg=[], is_workspace_member=True, is_proc_macro=False):
  38         crates_indexes[display_name] = len(crates)
  39         crates.append({
  40             "display_name": display_name,
  41             "root_module": str(root_module),
  42             "is_workspace_member": is_workspace_member,
  43             "is_proc_macro": is_proc_macro,
  44             "deps": [{"crate": crates_indexes[dep], "name": dep} for dep in deps],
  45             "cfg": cfg,
  46             "edition": "2021",
  47             "env": {
  48                 "RUST_MODFILE": "This is only for rust-analyzer"
  49             }
  50         })
  51
  52     # First, the ones in `rust/` since they are a bit special.
  53     append_crate(
  54         "core",
  55         sysroot_src / "core" / "src" / "lib.rs",
  56         [],
  57         cfg=crates_cfgs.get("core", []),
  58         is_workspace_member=False,
  59     )
  60
  61     append_crate(
  62         "compiler_builtins",
  63         srctree / "rust" / "compiler_builtins.rs",
  64         [],
  65     )
  66
  67     append_crate(
  68         "macros",
  69         srctree / "rust" / "macros" / "lib.rs",
  70         [],
  71         is_proc_macro=True,
  72     )
  73     crates[-1]["proc_macro_dylib_path"] = f"{objtree}/rust/libmacros.so"
  74
  75     append_crate(
  76         "build_error",
  77         srctree / "rust" / "build_error.rs",
  78         ["core", "compiler_builtins"],
  79     )
  80
  81     append_crate(
  82         "bindings",
  83         srctree / "rust"/ "bindings" / "lib.rs",
  84         ["core"],
  85         cfg=cfg,
  86     )
  87     crates[-1]["env"]["OBJTREE"] = str(objtree.resolve(True))
  88
  89     append_crate(
  90         "kernel",
  91         srctree / "rust" / "kernel" / "lib.rs",
  92         ["core", "macros", "build_error", "bindings"],
  93         cfg=cfg,
  94     )
  95     crates[-1]["source"] = {
  96         "include_dirs": [
  97             str(srctree / "rust" / "kernel"),
  98             str(objtree / "rust")
  99         ],
 100         "exclude_dirs": [],
 101     }
 102
 103     def is_root_crate(build_file, target):
 104         try:
 105             return f"{target}.o" in open(build_file).read()
 106         except FileNotFoundError:
 107             return False
 108
 109     # Then, the rest outside of `rust/`.
 110     #
 111     # We explicitly mention the top-level folders we want to cover.
 112     extra_dirs = map(lambda dir: srctree / dir, ("samples", "drivers"))
 113     if external_src is not None:
 114         extra_dirs = [external_src]
 115     for folder in extra_dirs:
 116         for path in folder.rglob("*.rs"):
 117             logging.info("Checking %s", path)
 118             name = path.name.replace(".rs", "")
 119
 120             # Skip those that are not crate roots.
 121             if not is_root_crate(path.parent / "Makefile", name) and \
 122                not is_root_crate(path.parent / "Kbuild", name):
 123                 continue
 124
 125             logging.info("Adding %s", name)
 126             append_crate(
 127                 name,
 128                 path,
 129                 ["core", "kernel"],
 130                 cfg=cfg,
 131             )
 132
 133     return crates
 134
 135 def main():
 136     parser = argparse.ArgumentParser()
 137     parser.add_argument('--verbose', '-v', action='store_true')
 138     parser.add_argument('--cfgs', action='append', default=[])
 139     parser.add_argument("srctree", type=pathlib.Path)
 140     parser.add_argument("objtree", type=pathlib.Path)
 141     parser.add_argument("sysroot", type=pathlib.Path)
 142     parser.add_argument("sysroot_src", type=pathlib.Path)
 143     parser.add_argument("exttree", type=pathlib.Path, nargs="?")
 144     args = parser.parse_args()
 145
 146     logging.basicConfig(
 147         format="[%(asctime)s] [%(levelname)s] %(message)s",
 148         level=logging.INFO if args.verbose else logging.WARNING
 149     )
 150
 151     # Making sure that the `sysroot` and `sysroot_src` belong to the same toolchain.
 152     assert args.sysroot in args.sysroot_src.parents
 153
 154     rust_project = {
 155         "crates": generate_crates(args.srctree, args.objtree, args.sysroot_src, args.exttree, args.cfgs),
 156         "sysroot": str(args.sysroot),
 157     }
 158
 159     json.dump(rust_project, sys.stdout, sort_keys=True, indent=4)
 160
 161 if __name__ == "__main__":
 162     main()