Catcrafts/milos-linux
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

rust-analyzer-v7.1: rust-analyzer changes for v7.1

Browse source 
- Add type annotations to generate_rust_analyzer.py.
 - Add support for scripts written in Rust (generate_rust_target.rs,
   rustdoc_test_builder.rs, rustdoc_test_gen.rs).
 - Refactor generate_rust_analyzer.py to explicitly identify host and
   target crates, improve readability, and reduce duplication.
 -----BEGIN PGP SIGNATURE-----
 
 iJEEABYKADkWIQRhFcK9Z2XbvB1p7sfQTA4lF9cSlwUCacqWTRsUgAAAAAAEAA5t
 YW51MiwyLjUrMS4xMiwwLDMACgkQ0EwOJRfXEpeRDAD+KWCQY00dN1CyQK7w94Oy
 EQilIubp564+zbOEmJk4GWgA/2zjk/bcvWkzi4dxzh7lTkJMmCgCAhXGW4QTRgjF
 DmUE
 =6aD+
 -----END PGP SIGNATURE-----

Merge tag 'rust-analyzer-v7.1' of https://github.com/Rust-for-Linux/linux into rust-next

Pull rust-analyzer updates from Tamir Duberstein:

 - Add type annotations to 'generate_rust_analyzer.py'.

 - Add support for scripts written in Rust ('generate_rust_target.rs',
   'rustdoc_test_builder.rs', 'rustdoc_test_gen.rs').

 - Refactor 'generate_rust_analyzer.py' to explicitly identify host and
   target crates, improve readability, and reduce duplication.

* tag 'rust-analyzer-v7.1' of https://github.com/Rust-for-Linux/linux:
  scripts: generate_rust_analyzer.py: reduce cfg plumbing
  scripts: generate_rust_analyzer.py: rename cfg to generated_cfg
  scripts: generate_rust_analyzer.py: avoid FD leak
  scripts: generate_rust_analyzer.py: define scripts
  scripts: generate_rust_analyzer.py: identify crates explicitly
  scripts: generate_rust_analyzer.py: add type hints
  scripts: generate_rust_analyzer.py: drop `"is_proc_macro": false`
  scripts: generate_rust_analyzer.py: extract `{build,register}_crate`
This commit is contained in:
Miguel Ojeda 2026-04-02 10:28:41 +02:00
commit 3418d86267
2 changed files with 211 additions and 77 deletions
Download patch file Download diff file Expand all files Collapse all files

2
rust/Makefile
View file

@ -610,6 +610,8 @@ rust-analyzer:
--cfgs='proc_macro2=$(proc_macro2-cfgs)' \
--cfgs='quote=$(quote-cfgs)' \
--cfgs='syn=$(syn-cfgs)' \
--cfgs='pin_init_internal=$(pin_init_internal-cfgs)' \
--cfgs='pin_init=$(pin_init-cfgs)' \
$(realpath $(srctree)) $(realpath $(objtree)) \
$(rustc_sysroot) $(RUST_LIB_SRC) $(if $(KBUILD_EXTMOD),$(srcroot)) \
> rust-project.json

286
scripts/generate_rust_analyzer.py
View file

@ -10,8 +10,9 @@ import os
import pathlib
import subprocess
import sys
from typing import Dict, Iterable, List, Literal, Optional, TypedDict
def args_crates_cfgs(cfgs):
def args_crates_cfgs(cfgs: List[str]) -> Dict[str, List[str]]:
crates_cfgs = {}
for cfg in cfgs:
crate, vals = cfg.split("=", 1)
@ -19,54 +20,158 @@ def args_crates_cfgs(cfgs):
return crates_cfgs
def generate_crates(srctree, objtree, sysroot_src, external_src, cfgs, core_edition):
class Dependency(TypedDict):
crate: int
name: str
class Source(TypedDict):
include_dirs: List[str]
exclude_dirs: List[str]
class Crate(TypedDict):
display_name: str
root_module: str
is_workspace_member: bool
deps: List[Dependency]
cfg: List[str]
edition: str
env: Dict[str, str]
class ProcMacroCrate(Crate):
is_proc_macro: Literal[True]
proc_macro_dylib_path: str # `pathlib.Path` is not JSON serializable.
class CrateWithGenerated(Crate):
source: Source
def generate_crates(
srctree: pathlib.Path,
objtree: pathlib.Path,
sysroot_src: pathlib.Path,
external_src: Optional[pathlib.Path],
cfgs: List[str],
core_edition: str,
) -> List[Crate]:
# Generate the configuration list.
cfg = []
generated_cfg = []
with open(objtree / "include" / "generated" / "rustc_cfg") as fd:
for line in fd:
line = line.replace("--cfg=", "")
line = line.replace("\n", "")
cfg.append(line)
generated_cfg.append(line)
# Now fill the crates list -- dependencies need to come first.
#
# Avoid O(n^2) iterations by keeping a map of indexes.
crates = []
crates_indexes = {}
# Now fill the crates list.
crates: List[Crate] = []
crates_cfgs = args_crates_cfgs(cfgs)
def append_crate(display_name, root_module, deps, cfg=[], is_workspace_member=True, is_proc_macro=False, edition="2021"):
crate = {
def build_crate(
display_name: str,
root_module: pathlib.Path,
deps: List[Dependency],
*,
cfg: Optional[List[str]],
is_workspace_member: Optional[bool],
edition: Optional[str],
) -> Crate:
cfg = cfg if cfg is not None else crates_cfgs.get(display_name, [])
is_workspace_member = (
is_workspace_member if is_workspace_member is not None else True
)
edition = edition if edition is not None else "2021"
return {
"display_name": display_name,
"root_module": str(root_module),
"is_workspace_member": is_workspace_member,
"is_proc_macro": is_proc_macro,
"deps": [{"crate": crates_indexes[dep], "name": dep} for dep in deps],
"deps": deps,
"cfg": cfg,
"edition": edition,
"env": {
"RUST_MODFILE": "This is only for rust-analyzer"
}
}
if is_proc_macro:
proc_macro_dylib_name = subprocess.check_output(
[os.environ["RUSTC"], "--print", "file-names", "--crate-name", display_name, "--crate-type", "proc-macro", "-"],
def append_proc_macro_crate(
display_name: str,
root_module: pathlib.Path,
deps: List[Dependency],
*,
cfg: Optional[List[str]] = None,
is_workspace_member: Optional[bool] = None,
edition: Optional[str] = None,
) -> Dependency:
crate = build_crate(
display_name,
root_module,
deps,
cfg=cfg,
is_workspace_member=is_workspace_member,
edition=edition,
)
proc_macro_dylib_name = (
subprocess.check_output(
[
os.environ["RUSTC"],
"--print",
"file-names",
"--crate-name",
display_name,
"--crate-type",
"proc-macro",
"-",
],
stdin=subprocess.DEVNULL,
).decode('utf-8').strip()
crate["proc_macro_dylib_path"] = f"{objtree}/rust/{proc_macro_dylib_name}"
crates_indexes[display_name] = len(crates)
)
.decode("utf-8")
.strip()
)
proc_macro_crate: ProcMacroCrate = {
**crate,
"is_proc_macro": True,
"proc_macro_dylib_path": str(objtree / "rust" / proc_macro_dylib_name),
}
return register_crate(proc_macro_crate)
def register_crate(crate: Crate) -> Dependency:
index = len(crates)
crates.append(crate)
return {"crate": index, "name": crate["display_name"]}
def append_crate(
display_name: str,
root_module: pathlib.Path,
deps: List[Dependency],
*,
cfg: Optional[List[str]] = None,
is_workspace_member: Optional[bool] = None,
edition: Optional[str] = None,
) -> Dependency:
return register_crate(
build_crate(
display_name,
root_module,
deps,
cfg=cfg,
is_workspace_member=is_workspace_member,
edition=edition,
)
)
def append_sysroot_crate(
display_name,
deps,
cfg=[],
):
append_crate(
display_name: str,
deps: List[Dependency],
*,
cfg: Optional[List[str]] = None,
) -> Dependency:
return append_crate(
display_name,
sysroot_src / display_name / "src" / "lib.rs",
deps,
cfg,
cfg=cfg,
is_workspace_member=False,
# Miguel Ojeda writes:
#
@ -98,112 +203,128 @@ def generate_crates(srctree, objtree, sysroot_src, external_src, cfgs, core_edit
# NB: sysroot crates reexport items from one another so setting up our transitive dependencies
# here is important for ensuring that rust-analyzer can resolve symbols. The sources of truth
# for this dependency graph are `(sysroot_src / crate / "Cargo.toml" for crate in crates)`.
append_sysroot_crate("core", [], cfg=crates_cfgs.get("core", []))
append_sysroot_crate("alloc", ["core"])
append_sysroot_crate("std", ["alloc", "core"])
append_sysroot_crate("proc_macro", ["core", "std"])
core = append_sysroot_crate("core", [])
alloc = append_sysroot_crate("alloc", [core])
std = append_sysroot_crate("std", [alloc, core])
proc_macro = append_sysroot_crate("proc_macro", [core, std])
append_crate(
compiler_builtins = append_crate(
"compiler_builtins",
srctree / "rust" / "compiler_builtins.rs",
["core"],
[core],
)
append_crate(
proc_macro2 = append_crate(
"proc_macro2",
srctree / "rust" / "proc-macro2" / "lib.rs",
["core", "alloc", "std", "proc_macro"],
cfg=crates_cfgs["proc_macro2"],
[core, alloc, std, proc_macro],
)
append_crate(
quote = append_crate(
"quote",
srctree / "rust" / "quote" / "lib.rs",
["core", "alloc", "std", "proc_macro", "proc_macro2"],
cfg=crates_cfgs["quote"],
[core, alloc, std, proc_macro, proc_macro2],
edition="2018",
)
append_crate(
syn = append_crate(
"syn",
srctree / "rust" / "syn" / "lib.rs",
["std", "proc_macro", "proc_macro2", "quote"],
cfg=crates_cfgs["syn"],
[std, proc_macro, proc_macro2, quote],
)
append_crate(
macros = append_proc_macro_crate(
"macros",
srctree / "rust" / "macros" / "lib.rs",
["std", "proc_macro", "proc_macro2", "quote", "syn"],
is_proc_macro=True,
[std, proc_macro, proc_macro2, quote, syn],
)
append_crate(
build_error = append_crate(
"build_error",
srctree / "rust" / "build_error.rs",
["core", "compiler_builtins"],
[core, compiler_builtins],
)
append_crate(
pin_init_internal = append_proc_macro_crate(
"pin_init_internal",
srctree / "rust" / "pin-init" / "internal" / "src" / "lib.rs",
["std", "proc_macro", "proc_macro2", "quote", "syn"],
cfg=["kernel"],
is_proc_macro=True,
[std, proc_macro, proc_macro2, quote, syn],
)
append_crate(
pin_init = append_crate(
"pin_init",
srctree / "rust" / "pin-init" / "src" / "lib.rs",
["core", "compiler_builtins", "pin_init_internal", "macros"],
cfg=["kernel"],
[core, compiler_builtins, pin_init_internal, macros],
)
append_crate(
ffi = append_crate(
"ffi",
srctree / "rust" / "ffi.rs",
["core", "compiler_builtins"],
[core, compiler_builtins],
)
def append_crate_with_generated(
display_name,
deps,
):
append_crate(
display_name: str,
deps: List[Dependency],
) -> Dependency:
crate = build_crate(
display_name,
srctree / "rust"/ display_name / "lib.rs",
deps,
cfg=cfg,
cfg=generated_cfg,
is_workspace_member=True,
edition=None,
)
crates[-1]["env"]["OBJTREE"] = str(objtree.resolve(True))
crates[-1]["source"] = {
"include_dirs": [
str(srctree / "rust" / display_name),
str(objtree / "rust")
],
"exclude_dirs": [],
crate["env"]["OBJTREE"] = str(objtree.resolve(True))
crate_with_generated: CrateWithGenerated = {
**crate,
"source": {
"include_dirs": [
str(srctree / "rust" / display_name),
str(objtree / "rust"),
],
"exclude_dirs": [],
},
}
return register_crate(crate_with_generated)
append_crate_with_generated("bindings", ["core", "ffi", "pin_init"])
append_crate_with_generated("uapi", ["core", "ffi", "pin_init"])
append_crate_with_generated("kernel", ["core", "macros", "build_error", "pin_init", "ffi", "bindings", "uapi"])
bindings = append_crate_with_generated("bindings", [core, ffi, pin_init])
uapi = append_crate_with_generated("uapi", [core, ffi, pin_init])
kernel = append_crate_with_generated(
"kernel", [core, macros, build_error, pin_init, ffi, bindings, uapi]
)
def is_root_crate(build_file, target):
scripts = srctree / "scripts"
makefile = (scripts / "Makefile").read_text()
for path in scripts.glob("*.rs"):
name = path.stem
if f"{name}-rust" not in makefile:
continue
append_crate(
name,
path,
[std],
)
def is_root_crate(build_file: pathlib.Path, target: str) -> bool:
try:
return f"{target}.o" in open(build_file).read()
contents = build_file.read_text()
except FileNotFoundError:
return False
return f"{target}.o" in contents
# Then, the rest outside of `rust/`.
#
# We explicitly mention the top-level folders we want to cover.
extra_dirs = map(lambda dir: srctree / dir, ("samples", "drivers"))
extra_dirs: Iterable[pathlib.Path] = (
srctree / dir for dir in ("samples", "drivers")
)
if external_src is not None:
extra_dirs = [external_src]
for folder in extra_dirs:
for path in folder.rglob("*.rs"):
logging.info("Checking %s", path)
name = path.name.replace(".rs", "")
name = path.stem
# Skip those that are not crate roots.
if not is_root_crate(path.parent / "Makefile", name) and \
@ -214,13 +335,13 @@ def generate_crates(srctree, objtree, sysroot_src, external_src, cfgs, core_edit
append_crate(
name,
path,
["core", "kernel", "pin_init"],
cfg=cfg,
[core, kernel, pin_init],
cfg=generated_cfg,
)
return crates
def main():
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument('--verbose', '-v', action='store_true')
parser.add_argument('--cfgs', action='append', default=[])
@ -230,7 +351,18 @@ def main():
parser.add_argument("sysroot", type=pathlib.Path)
parser.add_argument("sysroot_src", type=pathlib.Path)
parser.add_argument("exttree", type=pathlib.Path, nargs="?")
args = parser.parse_args()
class Args(argparse.Namespace):
verbose: bool
cfgs: List[str]
srctree: pathlib.Path
objtree: pathlib.Path
sysroot: pathlib.Path
sysroot_src: pathlib.Path
exttree: Optional[pathlib.Path]
core_edition: str
args = parser.parse_args(namespace=Args())
logging.basicConfig(
format="[%(asctime)s] [%(levelname)s] %(message)s",