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 6 import argparse 7 import json 8 import logging 9 import os 10 import pathlib 11 import sys 12 13 def 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 21 def 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 142 def 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 168 if __name__ == "__main__": 169 main() 170