xref: /linux/scripts/generate_rust_analyzer.py (revision a4851eeef3e7cbcd89b5fd0234c04ce408a9ae81) 
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 subprocess
12import sys
13
14def args_crates_cfgs(cfgs):
15    crates_cfgs = {}
16    for cfg in cfgs:
17        crate, vals = cfg.split("=", 1)
18        crates_cfgs[crate] = vals.split()
19
20    return crates_cfgs
21
22def generate_crates(srctree, objtree, sysroot_src, external_src, cfgs, core_edition):
23    # Generate the configuration list.
24    cfg = []
25    with open(objtree / "include" / "generated" / "rustc_cfg") as fd:
26        for line in fd:
27            line = line.replace("--cfg=", "")
28            line = line.replace("\n", "")
29            cfg.append(line)
30
31    # Now fill the crates list -- dependencies need to come first.
32    #
33    # Avoid O(n^2) iterations by keeping a map of indexes.
34    crates = []
35    crates_indexes = {}
36    crates_cfgs = args_crates_cfgs(cfgs)
37
38    def append_crate(display_name, root_module, deps, cfg=[], is_workspace_member=True, is_proc_macro=False, edition="2021"):
39        crate = {
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": edition,
47            "env": {
48                "RUST_MODFILE": "This is only for rust-analyzer"
49            }
50        }
51        if is_proc_macro:
52            proc_macro_dylib_name = subprocess.check_output(
53                [os.environ["RUSTC"], "--print", "file-names", "--crate-name", display_name, "--crate-type", "proc-macro", "-"],
54                stdin=subprocess.DEVNULL,
55            ).decode('utf-8').strip()
56            crate["proc_macro_dylib_path"] = f"{objtree}/rust/{proc_macro_dylib_name}"
57        crates_indexes[display_name] = len(crates)
58        crates.append(crate)
59
60    def append_sysroot_crate(
61        display_name,
62        deps,
63        cfg=[],
64        edition="2021",
65    ):
66        append_crate(
67            display_name,
68            sysroot_src / display_name / "src" / "lib.rs",
69            deps,
70            cfg,
71            is_workspace_member=False,
72            edition=edition,
73        )
74
75    # NB: sysroot crates reexport items from one another so setting up our transitive dependencies
76    # here is important for ensuring that rust-analyzer can resolve symbols. The sources of truth
77    # for this dependency graph are `(sysroot_src / crate / "Cargo.toml" for crate in crates)`.
78    append_sysroot_crate("core", [], cfg=crates_cfgs.get("core", []), edition=core_edition)
79    append_sysroot_crate("alloc", ["core"])
80    append_sysroot_crate("std", ["alloc", "core"])
81    append_sysroot_crate("proc_macro", ["core", "std"])
82
83    append_crate(
84        "compiler_builtins",
85        srctree / "rust" / "compiler_builtins.rs",
86        [],
87    )
88
89    append_crate(
90        "proc_macro2",
91        srctree / "rust" / "proc-macro2" / "lib.rs",
92        ["core", "alloc", "std", "proc_macro"],
93        cfg=crates_cfgs["proc_macro2"],
94    )
95
96    append_crate(
97        "macros",
98        srctree / "rust" / "macros" / "lib.rs",
99        ["std", "proc_macro"],
100        is_proc_macro=True,
101    )
102
103    append_crate(
104        "build_error",
105        srctree / "rust" / "build_error.rs",
106        ["core", "compiler_builtins"],
107    )
108
109    append_crate(
110        "pin_init_internal",
111        srctree / "rust" / "pin-init" / "internal" / "src" / "lib.rs",
112        [],
113        cfg=["kernel"],
114        is_proc_macro=True,
115    )
116
117    append_crate(
118        "pin_init",
119        srctree / "rust" / "pin-init" / "src" / "lib.rs",
120        ["core", "pin_init_internal", "macros"],
121        cfg=["kernel"],
122    )
123
124    append_crate(
125        "ffi",
126        srctree / "rust" / "ffi.rs",
127        ["core", "compiler_builtins"],
128    )
129
130    def append_crate_with_generated(
131        display_name,
132        deps,
133    ):
134        append_crate(
135            display_name,
136            srctree / "rust"/ display_name / "lib.rs",
137            deps,
138            cfg=cfg,
139        )
140        crates[-1]["env"]["OBJTREE"] = str(objtree.resolve(True))
141        crates[-1]["source"] = {
142            "include_dirs": [
143                str(srctree / "rust" / display_name),
144                str(objtree / "rust")
145            ],
146            "exclude_dirs": [],
147        }
148
149    append_crate_with_generated("bindings", ["core", "ffi", "pin_init"])
150    append_crate_with_generated("uapi", ["core", "ffi", "pin_init"])
151    append_crate_with_generated("kernel", ["core", "macros", "build_error", "pin_init", "ffi", "bindings", "uapi"])
152
153    def is_root_crate(build_file, target):
154        try:
155            return f"{target}.o" in open(build_file).read()
156        except FileNotFoundError:
157            return False
158
159    # Then, the rest outside of `rust/`.
160    #
161    # We explicitly mention the top-level folders we want to cover.
162    extra_dirs = map(lambda dir: srctree / dir, ("samples", "drivers"))
163    if external_src is not None:
164        extra_dirs = [external_src]
165    for folder in extra_dirs:
166        for path in folder.rglob("*.rs"):
167            logging.info("Checking %s", path)
168            name = path.name.replace(".rs", "")
169
170            # Skip those that are not crate roots.
171            if not is_root_crate(path.parent / "Makefile", name) and \
172               not is_root_crate(path.parent / "Kbuild", name):
173                continue
174
175            logging.info("Adding %s", name)
176            append_crate(
177                name,
178                path,
179                ["core", "kernel"],
180                cfg=cfg,
181            )
182
183    return crates
184
185def main():
186    parser = argparse.ArgumentParser()
187    parser.add_argument('--verbose', '-v', action='store_true')
188    parser.add_argument('--cfgs', action='append', default=[])
189    parser.add_argument("core_edition")
190    parser.add_argument("srctree", type=pathlib.Path)
191    parser.add_argument("objtree", type=pathlib.Path)
192    parser.add_argument("sysroot", type=pathlib.Path)
193    parser.add_argument("sysroot_src", type=pathlib.Path)
194    parser.add_argument("exttree", type=pathlib.Path, nargs="?")
195    args = parser.parse_args()
196
197    logging.basicConfig(
198        format="[%(asctime)s] [%(levelname)s] %(message)s",
199        level=logging.INFO if args.verbose else logging.WARNING
200    )
201
202    # Making sure that the `sysroot` and `sysroot_src` belong to the same toolchain.
203    assert args.sysroot in args.sysroot_src.parents
204
205    rust_project = {
206        "crates": generate_crates(args.srctree, args.objtree, args.sysroot_src, args.exttree, args.cfgs, args.core_edition),
207        "sysroot": str(args.sysroot),
208    }
209
210    json.dump(rust_project, sys.stdout, sort_keys=True, indent=4)
211
212if __name__ == "__main__":
213    main()
214