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, core_edition): 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, edition="2021"): 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": edition, 47 "env": { 48 "RUST_MODFILE": "This is only for rust-analyzer" 49 } 50 }) 51 52 def append_sysroot_crate( 53 display_name, 54 deps, 55 cfg=[], 56 edition="2021", 57 ): 58 append_crate( 59 display_name, 60 sysroot_src / display_name / "src" / "lib.rs", 61 deps, 62 cfg, 63 is_workspace_member=False, 64 edition=edition, 65 ) 66 67 # NB: sysroot crates reexport items from one another so setting up our transitive dependencies 68 # here is important for ensuring that rust-analyzer can resolve symbols. The sources of truth 69 # for this dependency graph are `(sysroot_src / crate / "Cargo.toml" for crate in crates)`. 70 append_sysroot_crate("core", [], cfg=crates_cfgs.get("core", []), edition=core_edition) 71 append_sysroot_crate("alloc", ["core"]) 72 append_sysroot_crate("std", ["alloc", "core"]) 73 append_sysroot_crate("proc_macro", ["core", "std"]) 74 75 append_crate( 76 "compiler_builtins", 77 srctree / "rust" / "compiler_builtins.rs", 78 [], 79 ) 80 81 append_crate( 82 "macros", 83 srctree / "rust" / "macros" / "lib.rs", 84 ["std", "proc_macro"], 85 is_proc_macro=True, 86 ) 87 crates[-1]["proc_macro_dylib_path"] = f"{objtree}/rust/libmacros.so" 88 89 append_crate( 90 "build_error", 91 srctree / "rust" / "build_error.rs", 92 ["core", "compiler_builtins"], 93 ) 94 95 append_crate( 96 "ffi", 97 srctree / "rust" / "ffi.rs", 98 ["core", "compiler_builtins"], 99 ) 100 101 def append_crate_with_generated( 102 display_name, 103 deps, 104 ): 105 append_crate( 106 display_name, 107 srctree / "rust"/ display_name / "lib.rs", 108 deps, 109 cfg=cfg, 110 ) 111 crates[-1]["env"]["OBJTREE"] = str(objtree.resolve(True)) 112 crates[-1]["source"] = { 113 "include_dirs": [ 114 str(srctree / "rust" / display_name), 115 str(objtree / "rust") 116 ], 117 "exclude_dirs": [], 118 } 119 120 append_crate_with_generated("bindings", ["core", "ffi"]) 121 append_crate_with_generated("uapi", ["core", "ffi"]) 122 append_crate_with_generated("kernel", ["core", "macros", "build_error", "ffi", "bindings", "uapi"]) 123 124 def is_root_crate(build_file, target): 125 try: 126 return f"{target}.o" in open(build_file).read() 127 except FileNotFoundError: 128 return False 129 130 # Then, the rest outside of `rust/`. 131 # 132 # We explicitly mention the top-level folders we want to cover. 133 extra_dirs = map(lambda dir: srctree / dir, ("samples", "drivers")) 134 if external_src is not None: 135 extra_dirs = [external_src] 136 for folder in extra_dirs: 137 for path in folder.rglob("*.rs"): 138 logging.info("Checking %s", path) 139 name = path.name.replace(".rs", "") 140 141 # Skip those that are not crate roots. 142 if not is_root_crate(path.parent / "Makefile", name) and \ 143 not is_root_crate(path.parent / "Kbuild", name): 144 continue 145 146 logging.info("Adding %s", name) 147 append_crate( 148 name, 149 path, 150 ["core", "kernel"], 151 cfg=cfg, 152 ) 153 154 return crates 155 156def main(): 157 parser = argparse.ArgumentParser() 158 parser.add_argument('--verbose', '-v', action='store_true') 159 parser.add_argument('--cfgs', action='append', default=[]) 160 parser.add_argument("core_edition") 161 parser.add_argument("srctree", type=pathlib.Path) 162 parser.add_argument("objtree", type=pathlib.Path) 163 parser.add_argument("sysroot", type=pathlib.Path) 164 parser.add_argument("sysroot_src", type=pathlib.Path) 165 parser.add_argument("exttree", type=pathlib.Path, nargs="?") 166 args = parser.parse_args() 167 168 logging.basicConfig( 169 format="[%(asctime)s] [%(levelname)s] %(message)s", 170 level=logging.INFO if args.verbose else logging.WARNING 171 ) 172 173 # Making sure that the `sysroot` and `sysroot_src` belong to the same toolchain. 174 assert args.sysroot in args.sysroot_src.parents 175 176 rust_project = { 177 "crates": generate_crates(args.srctree, args.objtree, args.sysroot_src, args.exttree, args.cfgs, args.core_edition), 178 "sysroot": str(args.sysroot), 179 } 180 181 json.dump(rust_project, sys.stdout, sort_keys=True, indent=4) 182 183if __name__ == "__main__": 184 main() 185