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.replace("--cfg", "").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 "macros", 91 srctree / "rust" / "macros" / "lib.rs", 92 ["std", "proc_macro"], 93 is_proc_macro=True, 94 ) 95 96 append_crate( 97 "build_error", 98 srctree / "rust" / "build_error.rs", 99 ["core", "compiler_builtins"], 100 ) 101 102 append_crate( 103 "pin_init_internal", 104 srctree / "rust" / "pin-init" / "internal" / "src" / "lib.rs", 105 [], 106 cfg=["kernel"], 107 is_proc_macro=True, 108 ) 109 110 append_crate( 111 "pin_init", 112 srctree / "rust" / "pin-init" / "src" / "lib.rs", 113 ["core", "pin_init_internal", "macros"], 114 cfg=["kernel"], 115 ) 116 117 append_crate( 118 "ffi", 119 srctree / "rust" / "ffi.rs", 120 ["core", "compiler_builtins"], 121 ) 122 123 def append_crate_with_generated( 124 display_name, 125 deps, 126 ): 127 append_crate( 128 display_name, 129 srctree / "rust"/ display_name / "lib.rs", 130 deps, 131 cfg=cfg, 132 ) 133 crates[-1]["env"]["OBJTREE"] = str(objtree.resolve(True)) 134 crates[-1]["source"] = { 135 "include_dirs": [ 136 str(srctree / "rust" / display_name), 137 str(objtree / "rust") 138 ], 139 "exclude_dirs": [], 140 } 141 142 append_crate_with_generated("bindings", ["core", "ffi"]) 143 append_crate_with_generated("uapi", ["core", "ffi"]) 144 append_crate_with_generated("kernel", ["core", "macros", "build_error", "pin_init", "ffi", "bindings", "uapi"]) 145 146 def is_root_crate(build_file, target): 147 try: 148 return f"{target}.o" in open(build_file).read() 149 except FileNotFoundError: 150 return False 151 152 # Then, the rest outside of `rust/`. 153 # 154 # We explicitly mention the top-level folders we want to cover. 155 extra_dirs = map(lambda dir: srctree / dir, ("samples", "drivers")) 156 if external_src is not None: 157 extra_dirs = [external_src] 158 for folder in extra_dirs: 159 for path in folder.rglob("*.rs"): 160 logging.info("Checking %s", path) 161 name = path.name.replace(".rs", "") 162 163 # Skip those that are not crate roots. 164 if not is_root_crate(path.parent / "Makefile", name) and \ 165 not is_root_crate(path.parent / "Kbuild", name): 166 continue 167 168 logging.info("Adding %s", name) 169 append_crate( 170 name, 171 path, 172 ["core", "kernel"], 173 cfg=cfg, 174 ) 175 176 return crates 177 178def main(): 179 parser = argparse.ArgumentParser() 180 parser.add_argument('--verbose', '-v', action='store_true') 181 parser.add_argument('--cfgs', action='append', default=[]) 182 parser.add_argument("core_edition") 183 parser.add_argument("srctree", type=pathlib.Path) 184 parser.add_argument("objtree", type=pathlib.Path) 185 parser.add_argument("sysroot", type=pathlib.Path) 186 parser.add_argument("sysroot_src", type=pathlib.Path) 187 parser.add_argument("exttree", type=pathlib.Path, nargs="?") 188 args = parser.parse_args() 189 190 logging.basicConfig( 191 format="[%(asctime)s] [%(levelname)s] %(message)s", 192 level=logging.INFO if args.verbose else logging.WARNING 193 ) 194 195 # Making sure that the `sysroot` and `sysroot_src` belong to the same toolchain. 196 assert args.sysroot in args.sysroot_src.parents 197 198 rust_project = { 199 "crates": generate_crates(args.srctree, args.objtree, args.sysroot_src, args.exttree, args.cfgs, args.core_edition), 200 "sysroot": str(args.sysroot), 201 } 202 203 json.dump(rust_project, sys.stdout, sort_keys=True, indent=4) 204 205if __name__ == "__main__": 206 main() 207