Files
hermes-agent/pm/build_compilers.py
Teknium 2d11905f79 fix(pm): only blame a missing compiler when the executable is absent
The `command '...' failed` pattern also matched a compiler that ran and
failed on a source error ("command 'gcc' failed with exit code 1"), so the
hint told users to install a compiler they already have. Match distutils'
missing-executable form ("failed: No such file or directory") only.
2026-11-02 20:27:41 -08:00

99 lines
4.6 KiB
Python

"""Point native source builds under PM's pinned interpreter at tools this host has.
python-build-standalone records the toolchain it was built with in sysconfig:
on Linux ``CC = 'clang -pthread'``, ``CXX = 'clang++ -pthread'``, linkers that
start with the same commands, and an ``AR`` under its deleted ``/tools/llvm``
build directory; on macOS only that archiver is foreign. setuptools compiles
every extension with those values unless the environment overrides them, so a
Debian/Ubuntu/WSL host with only gcc/g++ failed any sdist build with
``No such file or directory: 'clang++'`` (python-olm, via the matrix extra).
Stdlib only: ``pm.environment.classify_uv_failure`` imports this on the
bootstrap runner's pre-3.11 system python.
"""
from __future__ import annotations
from collections.abc import Mapping
import functools
import json
from pathlib import Path
import re
import shutil
import subprocess
import sys
# setuptools derives LDSHARED from an overridden CC but never LDCXXSHARED from
# CXX, so each compiler's own linker is rewritten with it.
_COMPILERS = (("CC", "LDSHARED"), ("CXX", "LDCXXSHARED"))
_GCC_FAMILY = {"clang": "gcc", "clang++": "g++"}
_RECORDED = ("CC", "CXX", "LDSHARED", "LDCXXSHARED", "AR")
_MISSING_COMPILER = (
re.compile(r"No such file or directory: '([^']+)'"),
# distutils' spawn when the executable is absent; a compiler that ran and failed
# ("command 'gcc' failed with exit code 1") is a source error, not a missing tool.
re.compile(r"command '([^']+)' failed: No such file or directory"),
re.compile(r"No CMAKE_(?:C|CXX)_COMPILER could be found"),
)
_COMPILER_NAME = re.compile(r"(?:clang(?:\+\+)?|g?cc|g\+\+|c\+\+)(?:-[\d.]+)?")
_COMPILER_REMEDY = ("{what}: install a C/C++ compiler (Debian/Ubuntu/WSL: `sudo apt install build-essential`; "
"Fedora: `sudo dnf install gcc gcc-c++`; macOS: `xcode-select --install`) "
"or point CC/CXX at one, then retry")
@functools.lru_cache(maxsize=None) # noqa: UP033 -- functools.cache is 3.9+; the bootstrap runner can be older
def _recorded_toolchain(python: str) -> dict[str, str]:
code = ("import json, sysconfig; "
f"print(json.dumps({{k: sysconfig.get_config_var(k) or '' for k in {_RECORDED!r}}}))")
try:
result = subprocess.run([python, "-I", "-c", code], capture_output=True, text=True,
timeout=30, check=False)
return json.loads(result.stdout) if result.returncode == 0 else {}
except (OSError, subprocess.TimeoutExpired, ValueError):
return {}
def _linux_defaults(recorded: Mapping[str, str], env: Mapping[str, str]) -> dict[str, str]:
search = env.get("PATH")
defaults: dict[str, str] = {}
for compiler_var, linker_var in _COMPILERS:
command = recorded.get(compiler_var, "")
program = command.split(" ", 1)[0]
substitute = _GCC_FAMILY.get(program)
if (compiler_var in env or substitute is None or shutil.which(program, path=search)
or not shutil.which(substitute, path=search)):
continue
defaults[compiler_var] = substitute + command[len(program):]
linker = recorded.get(linker_var, "")
if linker_var not in env and linker.split(" ", 1)[0] == program:
defaults[linker_var] = substitute + linker[len(program):]
archiver = recorded.get("AR", "")
if archiver and not shutil.which(archiver, path=search) and shutil.which("ar", path=search):
defaults["AR"] = "ar"
return defaults
def pinned_build_defaults(python: Path, env: Mapping[str, str]) -> dict[str, str]:
"""Defaults for build variables the pinned interpreter records but this host lacks.
Callers ``setdefault`` them, so a CC/CXX/AR the user set always wins. A recorded
compiler with no gcc-family equivalent on PATH is left alone; the build then
fails and ``missing_compiler_remedy`` names the fix.
"""
if sys.platform == "darwin":
return {"AR": "/usr/bin/ar"}
if sys.platform != "linux":
return {}
return _linux_defaults(_recorded_toolchain(str(python)), env)
def missing_compiler_remedy(output: str) -> str:
"""The install hint for a build that failed because no compiler exists, else ''."""
for pattern in _MISSING_COMPILER:
for match in pattern.finditer(output):
if not match.groups():
return _COMPILER_REMEDY.format(what="this package compiles native code and no compiler was found")
if _COMPILER_NAME.fullmatch(Path(match.group(1)).name):
return _COMPILER_REMEDY.format(what=f"the build needs `{match.group(1)}`, which is not on PATH")
return ""