xref: /linux/scripts/generate_rust_analyzer.py (revision 55d0969c451159cff86949b38c39171cab962069) 
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
6import argparse
7import json
8import logging
9import os
10import pathlib
11import sys
12
13def 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
21def 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        "alloc",
69        sysroot_src / "alloc" / "src" / "lib.rs",
70        ["core", "compiler_builtins"],
71        cfg=crates_cfgs.get("alloc", []),
72    )
73
74    append_crate(
75        "macros",
76        srctree / "rust" / "macros" / "lib.rs",
77        [],
78        is_proc_macro=True,
79    )
80    crates[-1]["proc_macro_dylib_path"] = f"{objtree}/rust/libmacros.so"
81
82    append_crate(
83        "build_error",
84        srctree / "rust" / "build_error.rs",
85        ["core", "compiler_builtins"],
86    )
87
88    append_crate(
89        "bindings",
90        srctree / "rust"/ "bindings" / "lib.rs",
91        ["core"],
92        cfg=cfg,
93    )
94    crates[-1]["env"]["OBJTREE"] = str(objtree.resolve(True))
95
96    append_crate(
97        "kernel",
98        srctree / "rust" / "kernel" / "lib.rs",
99        ["core", "alloc", "macros", "build_error", "bindings"],
100        cfg=cfg,
101    )
102    crates[-1]["source"] = {
103        "include_dirs": [
104            str(srctree / "rust" / "kernel"),
105            str(objtree / "rust")
106        ],
107        "exclude_dirs": [],
108    }
109
110    def is_root_crate(build_file, target):
111        try:
112            return f"{target}.o" in open(build_file).read()
113        except FileNotFoundError:
114            return False
115
116    # Then, the rest outside of `rust/`.
117    #
118    # We explicitly mention the top-level folders we want to cover.
119    extra_dirs = map(lambda dir: srctree / dir, ("samples", "drivers"))
120    if external_src is not None:
121        extra_dirs = [external_src]
122    for folder in extra_dirs:
123        for path in folder.rglob("*.rs"):
124            logging.info("Checking %s", path)
125            name = path.name.replace(".rs", "")
126
127            # Skip those that are not crate roots.
128            if not is_root_crate(path.parent / "Makefile", name) and \
129               not is_root_crate(path.parent / "Kbuild", name):
130                continue
131
132            logging.info("Adding %s", name)
133            append_crate(
134                name,
135                path,
136                ["core", "alloc", "kernel"],
137                cfg=cfg,
138            )
139
140    return crates
141
142def main():
143    parser = argparse.ArgumentParser()
144    parser.add_argument('--verbose', '-v', action='store_true')
145    parser.add_argument('--cfgs', action='append', default=[])
146    parser.add_argument("srctree", type=pathlib.Path)
147    parser.add_argument("objtree", type=pathlib.Path)
148    parser.add_argument("sysroot", type=pathlib.Path)
149    parser.add_argument("sysroot_src", type=pathlib.Path)
150    parser.add_argument("exttree", type=pathlib.Path, nargs="?")
151    args = parser.parse_args()
152
153    logging.basicConfig(
154        format="[%(asctime)s] [%(levelname)s] %(message)s",
155        level=logging.INFO if args.verbose else logging.WARNING
156    )
157
158    # Making sure that the `sysroot` and `sysroot_src` belong to the same toolchain.
159    assert args.sysroot in args.sysroot_src.parents
160
161    rust_project = {
162        "crates": generate_crates(args.srctree, args.objtree, args.sysroot_src, args.exttree, args.cfgs),
163        "sysroot": str(args.sysroot),
164    }
165
166    json.dump(rust_project, sys.stdout, sort_keys=True, indent=4)
167
168if __name__ == "__main__":
169    main()
170