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