openfoam: fix oneapi support

Signed-off-by: Massimiliano Culpo <massimiliano.culpo@gmail.com>

.github/workflows/unit_tests.yaml

@@ -55,7 +55,7 @@ jobs:
               cmake bison libbison-dev kcov
     - name: Install Python packages
       run: |
-          pip install --upgrade pip setuptools pytest pytest-xdist pytest-cov
+          pip install --upgrade pip setuptools pytest pytest-xdist pytest-cov clingo
           pip install --upgrade flake8 "isort>=4.3.5" "mypy>=0.900" "click" "black"
     - name: Setup git configuration
       run: |
@@ -173,7 +173,6 @@ jobs:
         spack bootstrap disable github-actions-v0.5
         spack bootstrap disable github-actions-v0.6
         spack bootstrap status
-        spack solve zlib
         spack unit-test --verbose --cov --cov-config=pyproject.toml --cov-report=xml:coverage.xml lib/spack/spack/test/concretization/core.py
     - uses: actions/upload-artifact@b4b15b8c7c6ac21ea08fcf65892d2ee8f75cf882
       with:
@@ -211,7 +210,7 @@ jobs:
         . share/spack/setup-env.sh
         $(which spack) bootstrap disable spack-install
         $(which spack) solve zlib
-        common_args=(--dist loadfile --tx '4*popen//python=./bin/spack-tmpconfig python -u ./bin/spack python' -x)
+        common_args=(--dist loadfile --tx '4*popen//python=./bin/spack-tmpconfig python -u ./bin/spack python')
         $(which spack) unit-test --verbose --cov --cov-config=pyproject.toml --cov-report=xml:coverage.xml "${common_args[@]}"
     - uses: actions/upload-artifact@b4b15b8c7c6ac21ea08fcf65892d2ee8f75cf882
       with:
@@ -242,7 +241,7 @@ jobs:
       env:
         COVERAGE_FILE: coverage/.coverage-windows
       run: |
-        spack unit-test -x --verbose --cov --cov-config=pyproject.toml
+        spack unit-test --verbose --cov --cov-config=pyproject.toml
         ./share/spack/qa/validate_last_exit.ps1
     - uses: actions/upload-artifact@b4b15b8c7c6ac21ea08fcf65892d2ee8f75cf882
       with:

etc/spack/defaults/config.yaml

@@ -19,7 +19,7 @@ config:
   install_tree:
     root: $spack/opt/spack
     projections:
-      all: "{architecture}/{compiler.name}-{compiler.version}/{name}-{version}-{hash}"
+      all: "{architecture.platform}/{architecture.target}/{name}-{version}-{hash}"
     # install_tree can include an optional padded length (int or boolean)
     # default is False (do not pad)
     # if padded_length is True, Spack will pad as close to the system max path

etc/spack/defaults/darwin/packages.yaml

@@ -15,12 +15,11 @@
 # -------------------------------------------------------------------------
 packages:
   all:
-    compiler:
-    - apple-clang
-    - clang
-    - gcc
     providers:
+      c: [apple-clang, llvm, gcc]
+      cxx: [apple-clang, llvm, gcc]
       elf: [libelf]
+      fortran: [gcc]
       fuse: [macfuse]
       gl: [apple-gl]
       glu: [apple-glu]

etc/spack/defaults/packages.yaml

@@ -15,19 +15,18 @@
 # -------------------------------------------------------------------------
 packages:
   all:
-    compiler: [gcc, clang, oneapi, xl, nag, fj, aocc]
     providers:
       awk: [gawk]
       armci: [armcimpi]
       blas: [openblas, amdblis]
-      c: [gcc]
-      cxx: [gcc]
+      c: [gcc, llvm, intel-oneapi-compilers, xl, aocc]
+      cxx: [gcc, llvm, intel-oneapi-compilers, xl, aocc]
       D: [ldc]
       daal: [intel-oneapi-daal]
       elf: [elfutils]
       fftw-api: [fftw, amdfftw]
       flame: [libflame, amdlibflame]
-      fortran: [gcc]
+      fortran: [gcc, llvm]
       fortran-rt: [gcc-runtime, intel-oneapi-runtime]
       fuse: [libfuse]
       gl: [glx, osmesa]

etc/spack/defaults/windows/packages.yaml

@@ -15,8 +15,8 @@
 # -------------------------------------------------------------------------
 packages:
   all:
-    compiler:
-    - msvc
     providers:
+      c : [msvc]
+      cxx: [msvc]
       mpi: [msmpi]
       gl: [wgl]

lib/spack/env/cc

@@ -40,11 +40,6 @@ readonly params="\
 SPACK_ENV_PATH
 SPACK_DEBUG_LOG_DIR
 SPACK_DEBUG_LOG_ID
-SPACK_COMPILER_SPEC
-SPACK_CC_RPATH_ARG
-SPACK_CXX_RPATH_ARG
-SPACK_F77_RPATH_ARG
-SPACK_FC_RPATH_ARG
 SPACK_LINKER_ARG
 SPACK_SHORT_SPEC
 SPACK_SYSTEM_DIRS
@@ -223,6 +218,7 @@ for param in $params; do
     if eval "test -z \"\${${param}:-}\""; then
         die "Spack compiler must be run from Spack! Input '$param' is missing."
     fi
+    # FIXME (compiler as nodes) add checks on whether `SPACK_XX_RPATH` is set if `SPACK_XX` is set
 done
 
 # eval this because SPACK_MANAGED_DIRS and SPACK_SYSTEM_DIRS are inputs we don't wanna loop over.
@@ -346,6 +342,9 @@ case "$command" in
         ;;
     ld|ld.gold|ld.lld)
         mode=ld
+        if [ -z "$SPACK_CC_RPATH_ARG" ]; then
+            comp="CXX"
+        fi
         ;;
     *)
         die "Unknown compiler: $command"
@@ -403,7 +402,7 @@ dtags_to_strip="${SPACK_DTAGS_TO_STRIP}"
 linker_arg="${SPACK_LINKER_ARG}"
 
 # Set up rpath variable according to language.
-rpath="ERROR: RPATH ARG WAS NOT SET"
+rpath="ERROR: RPATH ARG WAS NOT SET, MAYBE THE PACKAGE DOES NOT DEPEND ON ${comp}?"
 eval "rpath=\${SPACK_${comp}_RPATH_ARG:?${rpath}}"
 
 # Dump the mode and exit if the command is dump-mode.
@@ -412,13 +411,6 @@ if [ "$SPACK_TEST_COMMAND" = "dump-mode" ]; then
     exit
 fi
 
-# If, say, SPACK_CC is set but SPACK_FC is not, we want to know. Compilers do not
-# *have* to set up Fortran executables, so we need to tell the user when a build is
-# about to attempt to use them unsuccessfully.
-if [ -z "$command" ]; then
-    die "Compiler '$SPACK_COMPILER_SPEC' does not have a $language compiler configured."
-fi
-
 #
 # Filter '.' and Spack environment directories out of PATH so that
 # this script doesn't just call itself
@@ -788,15 +780,17 @@ case "$mode" in
             C)
                 extend spack_flags_list SPACK_ALWAYS_CFLAGS
                 extend spack_flags_list SPACK_CFLAGS
+                preextend flags_list SPACK_TARGET_ARGS_CC
                 ;;
             CXX)
                 extend spack_flags_list SPACK_ALWAYS_CXXFLAGS
                 extend spack_flags_list SPACK_CXXFLAGS
+                preextend flags_list SPACK_TARGET_ARGS_CXX
+                ;;
+            F)
+                preextend flags_list SPACK_TARGET_ARGS_FORTRAN
                 ;;
         esac
-
-        # prepend target args
-        preextend flags_list SPACK_TARGET_ARGS
         ;;
 esac
 

lib/spack/llnl/util/lang.py

@@ -73,7 +73,7 @@ def index_by(objects, *funcs):
     if isinstance(f, str):
         f = lambda x: getattr(x, funcs[0])
     elif isinstance(f, tuple):
-        f = lambda x: tuple(getattr(x, p) for p in funcs[0])
+        f = lambda x: tuple(getattr(x, p, None) for p in funcs[0])
 
     result = {}
     for o in objects:
@@ -995,11 +995,8 @@ def _receive_forwarded(self, context: str, exc: Exception, tb: List[str]):
     def grouped_message(self, with_tracebacks: bool = True) -> str:
         """Print out an error message coalescing all the forwarded errors."""
         each_exception_message = [
-            "{0} raised {1}: {2}{3}".format(
-                context,
-                exc.__class__.__name__,
-                exc,
-                "\n{0}".format("".join(tb)) if with_tracebacks else "",
+            "\n\t{0} raised {1}: {2}\n{3}".format(
+                context, exc.__class__.__name__, exc, f"\n{''.join(tb)}" if with_tracebacks else ""
             )
             for context, exc, tb in self.exceptions
         ]

lib/spack/spack/audit.py

@@ -55,6 +55,7 @@ def _search_duplicate_compilers(error_cls):
 
 import spack.builder
 import spack.config
+import spack.deptypes
 import spack.fetch_strategy
 import spack.patch
 import spack.repo
@@ -1014,7 +1015,14 @@ def _issues_in_depends_on_directive(pkgs, error_cls):
                 #     depends_on('foo+bar ^fee+baz')
                 #
                 # but we'd like to have two dependencies listed instead.
-                nested_dependencies = dep.spec.dependencies()
+                nested_dependencies = dep.spec.edges_to_dependencies()
+                # Filter out pure build dependencies, like:
+                #
+                #     depends_on('foo+bar%gcc')
+                #
+                nested_dependencies = [
+                    x for x in nested_dependencies if x.depflag != spack.deptypes.BUILD
+                ]
                 if nested_dependencies:
                     summary = f"{pkg_name}: nested dependency declaration '{dep.spec}'"
                     ndir = len(nested_dependencies) + 1

lib/spack/spack/binary_distribution.py

@@ -765,7 +765,14 @@ def tarball_directory_name(spec):
     Return name of the tarball directory according to the convention
     <os>-<architecture>/<compiler>/<package>-<version>/
     """
-    return spec.format_path("{architecture}/{compiler.name}-{compiler.version}/{name}-{version}")
+    if spec.original_spec_format() < 5:
+        compiler = spec.annotations.compiler_node_attribute
+        assert compiler is not None, "a compiler spec is expected"
+        return spec.format_path(
+            f"{spec.architecture}/{compiler.name}-{compiler.version}/{spec.name}-{spec.version}"
+        )
+
+    return spec.format_path(f"{spec.architecture.platform}/{spec.name}-{spec.version}")
 
 
 def tarball_name(spec, ext):
@@ -773,9 +780,17 @@ def tarball_name(spec, ext):
     Return the name of the tarfile according to the convention
     <os>-<architecture>-<package>-<dag_hash><ext>
     """
-    spec_formatted = spec.format_path(
-        "{architecture}-{compiler.name}-{compiler.version}-{name}-{version}-{hash}"
-    )
+    if spec.original_spec_format() < 5:
+        compiler = spec.annotations.compiler_node_attribute
+        assert compiler is not None, "a compiler spec is expected"
+        spec_formatted = (
+            f"{spec.architecture}-{compiler.name}-{compiler.version}-{spec.name}"
+            f"-{spec.version}-{spec.dag_hash()}"
+        )
+    else:
+        spec_formatted = (
+            f"{spec.architecture.platform}-{spec.name}-{spec.version}-{spec.dag_hash()}"
+        )
     return f"{spec_formatted}{ext}"
 
 

lib/spack/spack/bootstrap/_common.py

@@ -227,12 +227,13 @@ def _root_spec(spec_str: str) -> str:
     # Add a compiler and platform requirement to the root spec.
     platform = str(spack.platforms.host())
 
-    if platform == "darwin":
-        spec_str += " %apple-clang"
-    elif platform == "windows":
+    # FIXME (compiler as nodes): recover the compiler for source bootstrapping
+    # if platform == "darwin":
+    #    spec_str += " %apple-clang"
+    if platform == "windows":
         spec_str += " %msvc"
-    elif platform == "linux":
-        spec_str += " %gcc"
+    # elif platform == "linux":
+    #    spec_str += " %gcc"
     elif platform == "freebsd":
         spec_str += " %clang"
     spec_str += f" platform={platform}"

lib/spack/spack/bootstrap/clingo.py

@@ -16,8 +16,9 @@
 
 import archspec.cpu
 
-import spack.compiler
-import spack.compilers
+import spack.compilers.config
+import spack.compilers.libraries
+import spack.config
 import spack.platforms
 import spack.spec
 import spack.traverse
@@ -39,7 +40,7 @@ def __init__(self, configuration):
 
         self.external_cmake, self.external_bison = self._externals_from_yaml(configuration)
 
-    def _valid_compiler_or_raise(self) -> "spack.compiler.Compiler":
+    def _valid_compiler_or_raise(self):
         if str(self.host_platform) == "linux":
             compiler_name = "gcc"
         elif str(self.host_platform) == "darwin":
@@ -47,17 +48,30 @@ def _valid_compiler_or_raise(self) -> "spack.compiler.Compiler":
         elif str(self.host_platform) == "windows":
             compiler_name = "msvc"
         elif str(self.host_platform) == "freebsd":
-            compiler_name = "clang"
+            compiler_name = "llvm"
         else:
             raise RuntimeError(f"Cannot bootstrap clingo from sources on {self.host_platform}")
-        candidates = spack.compilers.compilers_for_spec(
-            compiler_name, arch_spec=self.host_architecture
-        )
+
+        candidates = [
+            x
+            for x in spack.compilers.config.CompilerFactory.from_packages_yaml(spack.config.CONFIG)
+            if x.name == compiler_name
+        ]
         if not candidates:
             raise RuntimeError(
                 f"Cannot find any version of {compiler_name} to bootstrap clingo from sources"
             )
-        candidates.sort(key=lambda x: x.spec.version, reverse=True)
+        candidates.sort(key=lambda x: x.version, reverse=True)
+        best = candidates[0]
+        # Get compilers for bootstrapping from the 'builtin' repository
+        best.namespace = "builtin"
+        # If the compiler does not support C++ 14, fail with a legible error message
+        try:
+            _ = best.package.standard_flag(language="cxx", standard="14")
+        except RuntimeError as e:
+            raise RuntimeError(
+                "cannot find a compiler supporting C++ 14 [needed to bootstrap clingo]"
+            ) from e
         return candidates[0]
 
     def _externals_from_yaml(
@@ -76,9 +90,6 @@ def _externals_from_yaml(
                 if not s.satisfies(requirements[pkg_name]):
                     continue
 
-                if not s.intersects(f"%{self.host_compiler.spec}"):
-                    continue
-
                 if not s.intersects(f"arch={self.host_architecture}"):
                     continue
 
@@ -111,11 +122,10 @@ def concretize(self) -> "spack.spec.Spec":
         # Tweak it to conform to the host architecture
         for node in s.traverse():
             node.architecture.os = str(self.host_os)
-            node.compiler = self.host_compiler.spec
             node.architecture = self.host_architecture
 
             if node.name == "gcc-runtime":
-                node.versions = self.host_compiler.spec.versions
+                node.versions = self.host_compiler.versions
 
         for edge in spack.traverse.traverse_edges([s], cover="edges"):
             if edge.spec.name == "python":
@@ -127,6 +137,9 @@ def concretize(self) -> "spack.spec.Spec":
             if edge.spec.name == "cmake" and self.external_cmake:
                 edge.spec = self.external_cmake
 
+            if edge.spec.name == self.host_compiler.name:
+                edge.spec = self.host_compiler
+
             if "libc" in edge.virtuals:
                 edge.spec = self.host_libc
 
@@ -142,12 +155,12 @@ def python_external_spec(self) -> "spack.spec.Spec":
         return self._external_spec(result)
 
     def libc_external_spec(self) -> "spack.spec.Spec":
-        result = self.host_compiler.default_libc
+        detector = spack.compilers.libraries.CompilerPropertyDetector(self.host_compiler)
+        result = detector.default_libc()
         return self._external_spec(result)
 
     def _external_spec(self, initial_spec) -> "spack.spec.Spec":
         initial_spec.namespace = "builtin"
-        initial_spec.compiler = self.host_compiler.spec
         initial_spec.architecture = self.host_architecture
         for flag_type in spack.spec.FlagMap.valid_compiler_flags():
             initial_spec.compiler_flags[flag_type] = []

lib/spack/spack/bootstrap/config.py

@@ -11,7 +11,7 @@
 
 from llnl.util import tty
 
-import spack.compilers
+import spack.compilers.config
 import spack.config
 import spack.environment
 import spack.modules
@@ -143,8 +143,8 @@ def _bootstrap_config_scopes() -> Sequence["spack.config.ConfigScope"]:
 
 def _add_compilers_if_missing() -> None:
     arch = spack.spec.ArchSpec.frontend_arch()
-    if not spack.compilers.compilers_for_arch(arch):
-        spack.compilers.find_compilers()
+    if not spack.compilers.config.compilers_for_arch(arch):
+        spack.compilers.config.find_compilers()
 
 
 @contextlib.contextmanager

lib/spack/spack/bootstrap/core.py

@@ -281,7 +281,12 @@ def try_import(self, module: str, abstract_spec_str: str) -> bool:
 
         # Install the spec that should make the module importable
         with spack.config.override(self.mirror_scope):
-            PackageInstaller([concrete_spec.package], fail_fast=True).install()
+            PackageInstaller(
+                [concrete_spec.package],
+                fail_fast=True,
+                package_use_cache=False,
+                dependencies_use_cache=False,
+            ).install()
 
         if _try_import_from_store(module, query_spec=concrete_spec, query_info=info):
             self.last_search = info
@@ -317,11 +322,10 @@ def create_bootstrapper(conf: ConfigDictionary):
     return _bootstrap_methods[btype](conf)
 
 
-def source_is_enabled_or_raise(conf: ConfigDictionary):
+def source_is_enabled(conf: ConfigDictionary):
     """Raise ValueError if the source is not enabled for bootstrapping"""
     trusted, name = spack.config.get("bootstrap:trusted"), conf["name"]
-    if not trusted.get(name, False):
-        raise ValueError("source is not trusted")
+    return trusted.get(name, False)
 
 
 def ensure_module_importable_or_raise(module: str, abstract_spec: Optional[str] = None):
@@ -351,8 +355,10 @@ def ensure_module_importable_or_raise(module: str, abstract_spec: Optional[str]
     exception_handler = GroupedExceptionHandler()
 
     for current_config in bootstrapping_sources():
+        if not source_is_enabled(current_config):
+            continue
+
         with exception_handler.forward(current_config["name"], Exception):
-            source_is_enabled_or_raise(current_config)
             current_bootstrapper = create_bootstrapper(current_config)
             if current_bootstrapper.try_import(module, abstract_spec):
                 return
@@ -364,11 +370,7 @@ def ensure_module_importable_or_raise(module: str, abstract_spec: Optional[str]
     msg = f'cannot bootstrap the "{module}" Python module '
     if abstract_spec:
         msg += f'from spec "{abstract_spec}" '
-    if tty.is_debug():
-        msg += exception_handler.grouped_message(with_tracebacks=True)
-    else:
-        msg += exception_handler.grouped_message(with_tracebacks=False)
-        msg += "\nRun `spack --debug ...` for more detailed errors"
+    msg += exception_handler.grouped_message(with_tracebacks=tty.is_debug())
     raise ImportError(msg)
 
 
@@ -406,8 +408,9 @@ def ensure_executables_in_path_or_raise(
     exception_handler = GroupedExceptionHandler()
 
     for current_config in bootstrapping_sources():
+        if not source_is_enabled(current_config):
+            continue
         with exception_handler.forward(current_config["name"], Exception):
-            source_is_enabled_or_raise(current_config)
             current_bootstrapper = create_bootstrapper(current_config)
             if current_bootstrapper.try_search_path(executables, abstract_spec):
                 # Additional environment variables needed

lib/spack/spack/build_environment.py

@@ -37,7 +37,6 @@
 import multiprocessing
 import os
 import re
-import stat
 import sys
 import traceback
 import types
@@ -60,7 +59,7 @@
 import spack.build_systems.meson
 import spack.build_systems.python
 import spack.builder
-import spack.compilers
+import spack.compilers.libraries
 import spack.config
 import spack.deptypes as dt
 import spack.error
@@ -74,7 +73,6 @@
 import spack.store
 import spack.subprocess_context
 import spack.util.executable
-import spack.util.libc
 from spack import traverse
 from spack.context import Context
 from spack.error import InstallError, NoHeadersError, NoLibrariesError
@@ -82,6 +80,7 @@
 from spack.util.environment import (
     SYSTEM_DIR_CASE_ENTRY,
     EnvironmentModifications,
+    PrependPath,
     env_flag,
     filter_system_paths,
     get_path,
@@ -297,62 +296,10 @@ def _add_werror_handling(keep_werror, env):
     env.set("SPACK_COMPILER_FLAGS_REPLACE", " ".join(["|".join(item) for item in replace_flags]))
 
 
-def set_compiler_environment_variables(pkg, env):
+def set_wrapper_environment_variables_for_flags(pkg, env):
     assert pkg.spec.concrete
-    compiler = pkg.compiler
     spec = pkg.spec
 
-    # Make sure the executables for this compiler exist
-    compiler.verify_executables()
-
-    # Set compiler variables used by CMake and autotools
-    assert all(key in compiler.link_paths for key in ("cc", "cxx", "f77", "fc"))
-
-    # Populate an object with the list of environment modifications
-    # and return it
-    # TODO : add additional kwargs for better diagnostics, like requestor,
-    # ttyout, ttyerr, etc.
-    link_dir = spack.paths.build_env_path
-
-    # Set SPACK compiler variables so that our wrapper knows what to
-    # call.  If there is no compiler configured then use a default
-    # wrapper which will emit an error if it is used.
-    if compiler.cc:
-        env.set("SPACK_CC", compiler.cc)
-        env.set("CC", os.path.join(link_dir, compiler.link_paths["cc"]))
-    else:
-        env.set("CC", os.path.join(link_dir, "cc"))
-    if compiler.cxx:
-        env.set("SPACK_CXX", compiler.cxx)
-        env.set("CXX", os.path.join(link_dir, compiler.link_paths["cxx"]))
-    else:
-        env.set("CC", os.path.join(link_dir, "c++"))
-    if compiler.f77:
-        env.set("SPACK_F77", compiler.f77)
-        env.set("F77", os.path.join(link_dir, compiler.link_paths["f77"]))
-    else:
-        env.set("F77", os.path.join(link_dir, "f77"))
-    if compiler.fc:
-        env.set("SPACK_FC", compiler.fc)
-        env.set("FC", os.path.join(link_dir, compiler.link_paths["fc"]))
-    else:
-        env.set("FC", os.path.join(link_dir, "fc"))
-
-    # Set SPACK compiler rpath flags so that our wrapper knows what to use
-    env.set("SPACK_CC_RPATH_ARG", compiler.cc_rpath_arg)
-    env.set("SPACK_CXX_RPATH_ARG", compiler.cxx_rpath_arg)
-    env.set("SPACK_F77_RPATH_ARG", compiler.f77_rpath_arg)
-    env.set("SPACK_FC_RPATH_ARG", compiler.fc_rpath_arg)
-    env.set("SPACK_LINKER_ARG", compiler.linker_arg)
-
-    # Check whether we want to force RPATH or RUNPATH
-    if spack.config.get("config:shared_linking:type") == "rpath":
-        env.set("SPACK_DTAGS_TO_STRIP", compiler.enable_new_dtags)
-        env.set("SPACK_DTAGS_TO_ADD", compiler.disable_new_dtags)
-    else:
-        env.set("SPACK_DTAGS_TO_STRIP", compiler.disable_new_dtags)
-        env.set("SPACK_DTAGS_TO_ADD", compiler.enable_new_dtags)
-
     if pkg.keep_werror is not None:
         keep_werror = pkg.keep_werror
     else:
@@ -360,10 +307,6 @@ def set_compiler_environment_variables(pkg, env):
 
     _add_werror_handling(keep_werror, env)
 
-    # Set the target parameters that the compiler will add
-    isa_arg = optimization_flags(compiler, spec.target)
-    env.set("SPACK_TARGET_ARGS", isa_arg)
-
     # Trap spack-tracked compiler flags as appropriate.
     # env_flags are easy to accidentally override.
     inject_flags = {}
@@ -397,74 +340,27 @@ def set_compiler_environment_variables(pkg, env):
             env.set(flag.upper(), " ".join(f for f in env_flags[flag]))
     pkg.flags_to_build_system_args(build_system_flags)
 
-    env.set("SPACK_COMPILER_SPEC", str(spec.compiler))
-
     env.set("SPACK_SYSTEM_DIRS", SYSTEM_DIR_CASE_ENTRY)
 
-    compiler.setup_custom_environment(pkg, env)
+    # FIXME (compiler as nodes): recover this one in the correct packages
+    # compiler.setup_custom_environment(pkg, env)
 
     return env
 
 
 def optimization_flags(compiler, target):
-    if spack.compilers.is_mixed_toolchain(compiler):
-        msg = (
-            "microarchitecture specific optimizations are not "
-            "supported yet on mixed compiler toolchains [check"
-            f" {compiler.name}@{compiler.version} for further details]"
-        )
-        tty.debug(msg)
-        return ""
-
     # Try to check if the current compiler comes with a version number or
     # has an unexpected suffix. If so, treat it as a compiler with a
     # custom spec.
-    compiler_version = compiler.version
-    version_number, suffix = archspec.cpu.version_components(compiler.version)
-    if not version_number or suffix:
-        try:
-            compiler_version = compiler.real_version
-        except spack.util.executable.ProcessError as e:
-            # log this and just return compiler.version instead
-            tty.debug(str(e))
-
+    version_number, _ = archspec.cpu.version_components(compiler.version.dotted_numeric_string)
     try:
-        result = target.optimization_flags(compiler.name, compiler_version.dotted_numeric_string)
+        result = target.optimization_flags(compiler.name, version_number)
     except (ValueError, archspec.cpu.UnsupportedMicroarchitecture):
         result = ""
 
     return result
 
 
-class FilterDefaultDynamicLinkerSearchPaths:
-    """Remove rpaths to directories that are default search paths of the dynamic linker."""
-
-    def __init__(self, dynamic_linker: Optional[str]) -> None:
-        # Identify directories by (inode, device) tuple, which handles symlinks too.
-        self.default_path_identifiers: Set[Tuple[int, int]] = set()
-        if not dynamic_linker:
-            return
-        for path in spack.util.libc.default_search_paths_from_dynamic_linker(dynamic_linker):
-            try:
-                s = os.stat(path)
-                if stat.S_ISDIR(s.st_mode):
-                    self.default_path_identifiers.add((s.st_ino, s.st_dev))
-            except OSError:
-                continue
-
-    def is_dynamic_loader_default_path(self, p: str) -> bool:
-        try:
-            s = os.stat(p)
-            return (s.st_ino, s.st_dev) in self.default_path_identifiers
-        except OSError:
-            return False
-
-    def __call__(self, dirs: List[str]) -> List[str]:
-        if not self.default_path_identifiers:
-            return dirs
-        return [p for p in dirs if not self.is_dynamic_loader_default_path(p)]
-
-
 def set_wrapper_variables(pkg, env):
     """Set environment variables used by the Spack compiler wrapper (which have the prefix
     `SPACK_`) and also add the compiler wrappers to PATH.
@@ -473,39 +369,8 @@ def set_wrapper_variables(pkg, env):
     this function computes these options in a manner that is intended to match the DAG traversal
     order in `SetupContext`. TODO: this is not the case yet, we're using post order, SetupContext
     is using topo order."""
-    # Set environment variables if specified for
-    # the given compiler
-    compiler = pkg.compiler
-    env.extend(spack.schema.environment.parse(compiler.environment))
-
-    if compiler.extra_rpaths:
-        extra_rpaths = ":".join(compiler.extra_rpaths)
-        env.set("SPACK_COMPILER_EXTRA_RPATHS", extra_rpaths)
-
-    # Add spack build environment path with compiler wrappers first in
-    # the path. We add the compiler wrapper path, which includes default
-    # wrappers (cc, c++, f77, f90), AND a subdirectory containing
-    # compiler-specific symlinks.  The latter ensures that builds that
-    # are sensitive to the *name* of the compiler see the right name when
-    # we're building with the wrappers.
-    #
-    # Conflicts on case-insensitive systems (like "CC" and "cc") are
-    # handled by putting one in the <build_env_path>/case-insensitive
-    # directory.  Add that to the path too.
-    env_paths = []
-    compiler_specific = os.path.join(
-        spack.paths.build_env_path, os.path.dirname(pkg.compiler.link_paths["cc"])
-    )
-    for item in [spack.paths.build_env_path, compiler_specific]:
-        env_paths.append(item)
-        ci = os.path.join(item, "case-insensitive")
-        if os.path.isdir(ci):
-            env_paths.append(ci)
-
-    tty.debug("Adding compiler bin/ paths: " + " ".join(env_paths))
-    for item in env_paths:
-        env.prepend_path("PATH", item)
-    env.set_path(SPACK_ENV_PATH, env_paths)
+    # Set compiler flags injected from the spec
+    set_wrapper_environment_variables_for_flags(pkg, env)
 
     # Working directory for the spack command itself, for debug logs.
     if spack.config.get("config:debug"):
@@ -571,22 +436,15 @@ def set_wrapper_variables(pkg, env):
         lib_path = os.path.join(pkg.prefix, libdir)
         rpath_dirs.insert(0, lib_path)
 
-    filter_default_dynamic_linker_search_paths = FilterDefaultDynamicLinkerSearchPaths(
-        pkg.compiler.default_dynamic_linker
-    )
-
     # TODO: filter_system_paths is again wrong (and probably unnecessary due to the is_system_path
     # branch above). link_dirs should be filtered with entries from _parse_link_paths.
     link_dirs = list(dedupe(filter_system_paths(link_dirs)))
     include_dirs = list(dedupe(filter_system_paths(include_dirs)))
     rpath_dirs = list(dedupe(filter_system_paths(rpath_dirs)))
-    rpath_dirs = filter_default_dynamic_linker_search_paths(rpath_dirs)
 
-    # TODO: implicit_rpaths is prefiltered by is_system_path, that should be removed in favor of
-    # just this filter.
-    implicit_rpaths = filter_default_dynamic_linker_search_paths(pkg.compiler.implicit_rpaths())
-    if implicit_rpaths:
-        env.set("SPACK_COMPILER_IMPLICIT_RPATHS", ":".join(implicit_rpaths))
+    default_dynamic_linker_filter = spack.compilers.libraries.dynamic_linker_filter_for(pkg.spec)
+    if default_dynamic_linker_filter:
+        rpath_dirs = default_dynamic_linker_filter(rpath_dirs)
 
     # Spack managed directories include the stage, store and upstream stores. We extend this with
     # their real paths to make it more robust (e.g. /tmp vs /private/tmp on macOS).
@@ -642,22 +500,19 @@ def set_package_py_globals(pkg, context: Context = Context.BUILD):
     # Put spack compiler paths in module scope. (Some packages use it
     # in setup_run_environment etc, so don't put it context == build)
     link_dir = spack.paths.build_env_path
-    pkg_compiler = None
-    try:
-        pkg_compiler = pkg.compiler
-    except spack.compilers.NoCompilerForSpecError as e:
-        tty.debug(f"cannot set 'spack_cc': {str(e)}")
 
-    if pkg_compiler is not None:
-        module.spack_cc = os.path.join(link_dir, pkg_compiler.link_paths["cc"])
-        module.spack_cxx = os.path.join(link_dir, pkg_compiler.link_paths["cxx"])
-        module.spack_f77 = os.path.join(link_dir, pkg_compiler.link_paths["f77"])
-        module.spack_fc = os.path.join(link_dir, pkg_compiler.link_paths["fc"])
-    else:
-        module.spack_cc = None
-        module.spack_cxx = None
-        module.spack_f77 = None
-        module.spack_fc = None
+    # FIXME (compiler as nodes): make this more general, and not tied to three languages
+    # Maybe add a callback?
+    global_names = {
+        "c": ("spack_cc",),
+        "cxx": ("spack_cxx",),
+        "fortran": ("spack_fc", "spack_f77"),
+    }
+    for language in ("c", "cxx", "fortran"):
+        spec = pkg.spec.dependencies(virtuals=[language])
+        value = None if not spec else os.path.join(link_dir, spec[0].package.link_paths[language])
+        for name in global_names[language]:
+            setattr(module, name, value)
 
     # Useful directories within the prefix are encapsulated in
     # a Prefix object.
@@ -824,7 +679,6 @@ def setup_package(pkg, dirty, context: Context = Context.BUILD):
         context == Context.TEST and pkg.test_requires_compiler
     )
     if need_compiler:
-        set_compiler_environment_variables(pkg, env_mods)
         set_wrapper_variables(pkg, env_mods)
 
     # Platform specific setup goes before package specific setup. This is for setting
@@ -836,6 +690,11 @@ def setup_package(pkg, dirty, context: Context = Context.BUILD):
     env_mods.extend(setup_context.get_env_modifications())
     tty.debug("setup_package: collected all modifications from dependencies")
 
+    tty.debug("setup_package: adding compiler wrappers paths")
+    for x in env_mods.group_by_name()["SPACK_ENV_PATH"]:
+        assert isinstance(x, PrependPath), "unexpected setting used for SPACK_ENV_PATH"
+        env_mods.prepend_path("PATH", x.value)
+
     if context == Context.TEST:
         env_mods.prepend_path("PATH", ".")
     elif context == Context.BUILD and not dirty and not env_mods.is_unset("CPATH"):
@@ -849,11 +708,6 @@ def setup_package(pkg, dirty, context: Context = Context.BUILD):
 
     # Load modules on an already clean environment, just before applying Spack's
     # own environment modifications. This ensures Spack controls CC/CXX/... variables.
-    if need_compiler:
-        tty.debug("setup_package: loading compiler modules")
-        for mod in pkg.compiler.modules:
-            load_module(mod)
-
     load_external_modules(pkg)
 
     # Make sure nothing's strange about the Spack environment.

lib/spack/spack/build_systems/autotools.py

@@ -13,6 +13,7 @@
 
 import spack.build_environment
 import spack.builder
+import spack.compilers.libraries
 import spack.error
 import spack.package_base
 import spack.phase_callbacks
@@ -396,33 +397,44 @@ def _do_patch_libtool(self) -> None:
             markers[tag] = "LIBTOOL TAG CONFIG: {0}".format(tag.upper())
 
         # Replace empty linker flag prefixes:
-        if self.pkg.compiler.name == "nag":
+        if self.spec.satisfies("%nag"):
             # Nag is mixed with gcc and g++, which are recognized correctly.
             # Therefore, we change only Fortran values:
+            nag_pkg = self.spec["fortran"].package
             for tag in ["fc", "f77"]:
                 marker = markers[tag]
                 x.filter(
                     regex='^wl=""$',
-                    repl='wl="{0}"'.format(self.pkg.compiler.linker_arg),
-                    start_at="# ### BEGIN {0}".format(marker),
-                    stop_at="# ### END {0}".format(marker),
+                    repl=f'wl="{nag_pkg.linker_arg}"',
+                    start_at=f"# ### BEGIN {marker}",
+                    stop_at=f"# ### END {marker}",
                 )
         else:
-            x.filter(regex='^wl=""$', repl='wl="{0}"'.format(self.pkg.compiler.linker_arg))
+            compiler_spec = spack.compilers.libraries.compiler_spec(self.spec)
+            if compiler_spec:
+                x.filter(regex='^wl=""$', repl='wl="{0}"'.format(compiler_spec.package.linker_arg))
 
         # Replace empty PIC flag values:
-        for cc, marker in markers.items():
+        for compiler, marker in markers.items():
+            if compiler == "cc":
+                language = "c"
+            elif compiler == "cxx":
+                language = "cxx"
+            else:
+                language = "fortran"
+
+            if language not in self.spec:
+                continue
+
             x.filter(
                 regex='^pic_flag=""$',
-                repl='pic_flag="{0}"'.format(
-                    getattr(self.pkg.compiler, "{0}_pic_flag".format(cc))
-                ),
-                start_at="# ### BEGIN {0}".format(marker),
-                stop_at="# ### END {0}".format(marker),
+                repl=f'pic_flag="{self.spec[language].package.pic_flag}"',
+                start_at=f"# ### BEGIN {marker}",
+                stop_at=f"# ### END {marker}",
             )
 
         # Other compiler-specific patches:
-        if self.pkg.compiler.name == "fj":
+        if self.spec.satisfies("%fj"):
             x.filter(regex="-nostdlib", repl="", string=True)
             rehead = r"/\S*/"
             for o in [
@@ -435,7 +447,7 @@ def _do_patch_libtool(self) -> None:
                 r"crtendS\.o",
             ]:
                 x.filter(regex=(rehead + o), repl="")
-        elif self.pkg.compiler.name == "nag":
+        elif self.spec.satisfies("%nag"):
             for tag in ["fc", "f77"]:
                 marker = markers[tag]
                 start_at = "# ### BEGIN {0}".format(marker)

lib/spack/spack/build_systems/cached_cmake.py

@@ -11,6 +11,7 @@
 import llnl.util.tty as tty
 
 import spack.phase_callbacks
+from spack.directives import depends_on
 
 from .cmake import CMakeBuilder, CMakePackage
 
@@ -68,12 +69,7 @@ class CachedCMakeBuilder(CMakeBuilder):
 
     @property
     def cache_name(self):
-        return "{0}-{1}-{2}@{3}.cmake".format(
-            self.pkg.name,
-            self.pkg.spec.architecture,
-            self.pkg.spec.compiler.name,
-            self.pkg.spec.compiler.version,
-        )
+        return f"{self.pkg.name}-{self.spec.architecture.platform}-{self.spec.dag_hash()}.cmake"
 
     @property
     def cache_path(self):
@@ -116,7 +112,9 @@ def initconfig_compiler_entries(self):
         # Fortran compiler is optional
         if "FC" in os.environ:
             spack_fc_entry = cmake_cache_path("CMAKE_Fortran_COMPILER", os.environ["FC"])
-            system_fc_entry = cmake_cache_path("CMAKE_Fortran_COMPILER", self.pkg.compiler.fc)
+            system_fc_entry = cmake_cache_path(
+                "CMAKE_Fortran_COMPILER", self.spec["fortran"].package.fortran
+            )
         else:
             spack_fc_entry = "# No Fortran compiler defined in spec"
             system_fc_entry = "# No Fortran compiler defined in spec"
@@ -132,8 +130,8 @@ def initconfig_compiler_entries(self):
             "  " + cmake_cache_path("CMAKE_CXX_COMPILER", os.environ["CXX"]),
             "  " + spack_fc_entry,
             "else()\n",
-            "  " + cmake_cache_path("CMAKE_C_COMPILER", self.pkg.compiler.cc),
-            "  " + cmake_cache_path("CMAKE_CXX_COMPILER", self.pkg.compiler.cxx),
+            "  " + cmake_cache_path("CMAKE_C_COMPILER", self.spec["c"].package.cc),
+            "  " + cmake_cache_path("CMAKE_CXX_COMPILER", self.spec["cxx"].package.cxx),
             "  " + system_fc_entry,
             "endif()\n",
         ]
@@ -352,6 +350,10 @@ class CachedCMakePackage(CMakePackage):
 
     CMakeBuilder = CachedCMakeBuilder
 
+    # These dependencies are assumed in the builder
+    depends_on("c", type="build")
+    depends_on("cxx", type="build")
+
     def flag_handler(self, name, flags):
         if name in ("cflags", "cxxflags", "cppflags", "fflags"):
             return None, None, None  # handled in the cmake cache

lib/spack/spack/build_systems/compiler.py

@@ -5,15 +5,22 @@
 import itertools
 import os
 import pathlib
+import platform
 import re
 import sys
-from typing import Dict, List, Sequence, Tuple, Union
+from typing import Dict, List, Optional, Sequence, Tuple, Union
+
+import archspec.cpu
 
 import llnl.util.tty as tty
-from llnl.util.lang import classproperty
+from llnl.util.lang import classproperty, memoized
 
-import spack.compiler
+import spack
+import spack.compilers.error
+import spack.compilers.libraries
+import spack.config
 import spack.package_base
+import spack.paths
 import spack.util.executable
 
 # Local "type" for type hints
@@ -44,6 +51,9 @@ class CompilerPackage(spack.package_base.PackageBase):
     #: Static definition of languages supported by this class
     compiler_languages: Sequence[str] = ["c", "cxx", "fortran"]
 
+    #: Relative path to compiler wrappers
+    link_paths: Dict[str, str] = {}
+
     def __init__(self, spec: "spack.spec.Spec"):
         super().__init__(spec)
         msg = f"Supported languages for {spec} are not a subset of possible supported languages"
@@ -78,14 +88,14 @@ def executables(cls) -> Sequence[str]:
         ]
 
     @classmethod
-    def determine_version(cls, exe: Path):
+    def determine_version(cls, exe: Path) -> str:
         version_argument = cls.compiler_version_argument
         if isinstance(version_argument, str):
             version_argument = (version_argument,)
 
         for va in version_argument:
             try:
-                output = spack.compiler.get_compiler_version_output(exe, va)
+                output = compiler_output(exe, version_argument=va)
                 match = re.search(cls.compiler_version_regex, output)
                 if match:
                     return ".".join(match.groups())
@@ -96,6 +106,7 @@ def determine_version(cls, exe: Path):
                     f"[{__file__}] Cannot detect a valid version for the executable "
                     f"{str(exe)}, for package '{cls.name}': {e}"
                 )
+        return ""
 
     @classmethod
     def compiler_bindir(cls, prefix: Path) -> Path:
@@ -143,3 +154,184 @@ def determine_compiler_paths(cls, exes: Sequence[Path]) -> Dict[str, Path]:
     def determine_variants(cls, exes: Sequence[Path], version_str: str) -> Tuple:
         # path determination is separated so it can be reused in subclasses
         return "", {"compilers": cls.determine_compiler_paths(exes=exes)}
+
+    #: Returns the argument needed to set the RPATH, or None if it does not exist
+    rpath_arg: Optional[str] = "-Wl,-rpath,"
+    #: Flag that needs to be used to pass an argument to the linker
+    linker_arg: str = "-Wl,"
+    #: Flag used to produce Position Independent Code
+    pic_flag: str = "-fPIC"
+    #: Flag used to get verbose output
+    verbose_flags: str = "-v"
+    #: Flag to activate OpenMP support
+    openmp_flag: str = "-fopenmp"
+
+    def standard_flag(self, *, language: str, standard: str) -> str:
+        """Returns the flag used to enforce a given standard for a language"""
+        if language not in self.supported_languages:
+            raise spack.compilers.error.UnsupportedCompilerFlag(
+                f"{self.spec} does not provide the '{language}' language"
+            )
+        try:
+            return self._standard_flag(language=language, standard=standard)
+        except (KeyError, RuntimeError) as e:
+            raise spack.compilers.error.UnsupportedCompilerFlag(
+                f"{self.spec} does not provide the '{language}' standard {standard}"
+            ) from e
+
+    def _standard_flag(self, *, language: str, standard: str) -> str:
+        raise NotImplementedError("Must be implemented by derived classes")
+
+    @property
+    def disable_new_dtags(self) -> str:
+        if platform.system() == "Darwin":
+            return ""
+        return "--disable-new-dtags"
+
+    @property
+    def enable_new_dtags(self) -> str:
+        if platform.system() == "Darwin":
+            return ""
+        return "--enable-new-dtags"
+
+    def setup_dependent_build_environment(self, env, dependent_spec):
+        # FIXME (compiler as nodes): check if this is good enough or should be made more general
+
+        # The package is not used as a compiler, so skip this setup
+        if not any(
+            lang in dependent_spec and dependent_spec[lang].name == self.spec.name
+            for lang in ("c", "cxx", "fortran")
+        ):
+            return
+
+        # Populate an object with the list of environment modifications and return it
+        link_dir = pathlib.Path(spack.paths.build_env_path)
+        env_paths = []
+
+        for language, attr_name, wrapper_var_name, spack_var_name in [
+            ("c", "cc", "CC", "SPACK_CC"),
+            ("cxx", "cxx", "CXX", "SPACK_CXX"),
+            ("fortran", "fortran", "F77", "SPACK_F77"),
+            ("fortran", "fortran", "FC", "SPACK_FC"),
+        ]:
+            if language not in dependent_spec or dependent_spec[language].name != self.spec.name:
+                continue
+
+            if not hasattr(self, attr_name):
+                continue
+
+            compiler = getattr(self, attr_name)
+            env.set(spack_var_name, compiler)
+
+            if language not in self.link_paths:
+                continue
+
+            wrapper_path = link_dir / self.link_paths.get(language)
+            env.set(wrapper_var_name, str(wrapper_path))
+            env.set(f"SPACK_{wrapper_var_name}_RPATH_ARG", self.rpath_arg)
+
+            uarch = dependent_spec.architecture.target
+            version_number, _ = archspec.cpu.version_components(
+                self.spec.version.dotted_numeric_string
+            )
+            try:
+                isa_arg = uarch.optimization_flags(self.archspec_name(), version_number)
+            except (ValueError, archspec.cpu.UnsupportedMicroarchitecture):
+                isa_arg = ""
+
+            if isa_arg:
+                env.set(f"SPACK_TARGET_ARGS_{attr_name.upper()}", isa_arg)
+
+            # Add spack build environment path with compiler wrappers first in
+            # the path. We add the compiler wrapper path, which includes default
+            # wrappers (cc, c++, f77, f90), AND a subdirectory containing
+            # compiler-specific symlinks.  The latter ensures that builds that
+            # are sensitive to the *name* of the compiler see the right name when
+            # we're building with the wrappers.
+            #
+            # Conflicts on case-insensitive systems (like "CC" and "cc") are
+            # handled by putting one in the <build_env_path>/case-insensitive
+            # directory.  Add that to the path too.
+            compiler_specific = os.path.join(
+                spack.paths.build_env_path, os.path.dirname(self.link_paths[language])
+            )
+            for item in [spack.paths.build_env_path, compiler_specific]:
+                env_paths.append(item)
+                ci = os.path.join(item, "case-insensitive")
+                if os.path.isdir(ci):
+                    env_paths.append(ci)
+
+        # FIXME (compiler as nodes): make these paths language specific
+        env.set("SPACK_LINKER_ARG", self.linker_arg)
+
+        paths = _implicit_rpaths(pkg=self)
+        if paths:
+            env.set("SPACK_COMPILER_IMPLICIT_RPATHS", ":".join(paths))
+
+        # Check whether we want to force RPATH or RUNPATH
+        if spack.config.CONFIG.get("config:shared_linking:type") == "rpath":
+            env.set("SPACK_DTAGS_TO_STRIP", self.enable_new_dtags)
+            env.set("SPACK_DTAGS_TO_ADD", self.disable_new_dtags)
+        else:
+            env.set("SPACK_DTAGS_TO_STRIP", self.disable_new_dtags)
+            env.set("SPACK_DTAGS_TO_ADD", self.enable_new_dtags)
+
+        spec = self.spec
+        if spec.extra_attributes:
+            extra_rpaths = spec.extra_attributes.get("extra_rpaths")
+            if extra_rpaths:
+                extra_rpaths = ":".join(compiler.extra_rpaths)
+                env.append_path("SPACK_COMPILER_EXTRA_RPATHS", extra_rpaths)
+
+        for item in env_paths:
+            env.prepend_path("SPACK_ENV_PATH", item)
+
+    def archspec_name(self) -> str:
+        """Name that archspec uses to refer to this compiler"""
+        return self.spec.name
+
+
+def _implicit_rpaths(pkg: spack.package_base.PackageBase) -> List[str]:
+    detector = spack.compilers.libraries.CompilerPropertyDetector(pkg.spec)
+    paths = detector.implicit_rpaths()
+    return paths
+
+
+@memoized
+def _compiler_output(
+    compiler_path: Path, *, version_argument: str, ignore_errors: Tuple[int, ...] = ()
+) -> str:
+    """Returns the output from the compiler invoked with the given version argument.
+
+    Args:
+        compiler_path: path of the compiler to be invoked
+        version_argument: the argument used to extract version information
+    """
+    compiler = spack.util.executable.Executable(compiler_path)
+    compiler_invocation_args = {
+        "output": str,
+        "error": str,
+        "ignore_errors": ignore_errors,
+        "timeout": 120,
+        "fail_on_error": True,
+    }
+    if version_argument:
+        output = compiler(version_argument, **compiler_invocation_args)
+    else:
+        output = compiler(**compiler_invocation_args)
+    return output
+
+
+def compiler_output(
+    compiler_path: Path, *, version_argument: str, ignore_errors: Tuple[int, ...] = ()
+) -> str:
+    """Wrapper for _get_compiler_version_output()."""
+    # This ensures that we memoize compiler output by *absolute path*,
+    # not just executable name. If we don't do this, and the path changes
+    # (e.g., during testing), we can get incorrect results.
+    if not os.path.isabs(compiler_path):
+        compiler_path = spack.util.executable.which_string(compiler_path, required=True)
+
+    return _compiler_output(
+        compiler_path, version_argument=version_argument, ignore_errors=ignore_errors
+    )

lib/spack/spack/build_systems/msbuild.py

@@ -75,7 +75,7 @@ def toolchain_version(self):
         Override this method to select a specific version of the toolchain or change
         selection heuristics.
         Default is whatever version of msvc has been selected by concretization"""
-        return "v" + self.pkg.compiler.platform_toolset_ver
+        return "v" + self.spec["msvc"].package.platform_toolset_ver
 
     @property
     def std_msbuild_args(self):

lib/spack/spack/build_systems/oneapi.py

@@ -140,7 +140,7 @@ def setup_run_environment(self, env):
            $ source {prefix}/{component}/{version}/env/vars.sh
         """
         # Only if environment modifications are desired (default is +envmods)
-        if "~envmods" not in self.spec:
+        if "+envmods" in self.spec:
             env.extend(
                 EnvironmentModifications.from_sourcing_file(
                     self.component_prefix.env.join("vars.sh"), *self.env_script_args

lib/spack/spack/build_systems/python.py

@@ -277,10 +277,6 @@ def update_external_dependencies(self, extendee_spec=None):
                         if not python.architecture.target:
                             python.architecture.target = archspec.cpu.host().family.name
 
-                    # Ensure compiler information is present
-                    if not python.compiler:
-                        python.compiler = self.spec.compiler
-
                     python.external_path = self.spec.external_path
                     python._mark_concrete()
             self.spec.add_dependency_edge(python, depflag=dt.BUILD | dt.LINK | dt.RUN, virtuals=())

lib/spack/spack/ci.py

@@ -2138,7 +2138,7 @@ def build_name(self):
         Returns: (str) current spec's CDash build name."""
         spec = self.current_spec
         if spec:
-            build_name = f"{spec.name}@{spec.version}%{spec.compiler} \
+            build_name = f"{spec.name}@{spec.version} \
 hash={spec.dag_hash()} arch={spec.architecture} ({self.build_group})"
             tty.debug(f"Generated CDash build name ({build_name}) from the {spec.name}")
             return build_name

lib/spack/spack/cmd/__init__.py

@@ -372,8 +372,13 @@ def iter_groups(specs, indent, all_headers):
     index = index_by(specs, ("architecture", "compiler"))
     ispace = indent * " "
 
+    def _key(item):
+        if item is None:
+            return ""
+        return str(item)
+
     # Traverse the index and print out each package
-    for i, (architecture, compiler) in enumerate(sorted(index)):
+    for i, (architecture, compiler) in enumerate(sorted(index, key=_key)):
         if i > 0:
             print()
 
@@ -431,6 +436,7 @@ def display_specs(specs, args=None, **kwargs):
 
     """
 
+    # FIXME (compiler as nodes): remove the "show full compiler" arguments, and its use
     def get_arg(name, default=None):
         """Prefer kwargs, then args, then default."""
         if name in kwargs:
@@ -445,7 +451,6 @@ def get_arg(name, default=None):
     hashes = get_arg("long", False)
     namespaces = get_arg("namespaces", False)
     flags = get_arg("show_flags", False)
-    full_compiler = get_arg("show_full_compiler", False)
     variants = get_arg("variants", False)
     groups = get_arg("groups", True)
     all_headers = get_arg("all_headers", False)
@@ -467,10 +472,7 @@ def get_arg(name, default=None):
     if format_string is None:
         nfmt = "{fullname}" if namespaces else "{name}"
         ffmt = ""
-        if full_compiler or flags:
-            ffmt += "{%compiler.name}"
-            if full_compiler:
-                ffmt += "{@compiler.version}"
+        if flags:
             ffmt += " {compiler_flags}"
         vfmt = "{variants}" if variants else ""
         format_string = nfmt + "{@version}" + ffmt + vfmt

lib/spack/spack/cmd/compiler.py

@@ -5,13 +5,14 @@
 
 import argparse
 import sys
+import warnings
 
 import llnl.util.tty as tty
 from llnl.util.lang import index_by
 from llnl.util.tty.colify import colify
 from llnl.util.tty.color import colorize
 
-import spack.compilers
+import spack.compilers.config
 import spack.config
 import spack.spec
 from spack.cmd.common import arguments
@@ -35,13 +36,13 @@ def setup_parser(subparser):
         "--mixed-toolchain",
         action="store_true",
         default=sys.platform == "darwin",
-        help="Allow mixed toolchains (for example: clang, clang++, gfortran)",
+        help="(DEPRECATED) Allow mixed toolchains (for example: clang, clang++, gfortran)",
     )
     mixed_toolchain_group.add_argument(
         "--no-mixed-toolchain",
         action="store_false",
         dest="mixed_toolchain",
-        help="Do not allow mixed toolchains (for example: clang, clang++, gfortran)",
+        help="(DEPRECATED) Do not allow mixed toolchains (for example: clang, clang++, gfortran)",
     )
     find_parser.add_argument("add_paths", nargs=argparse.REMAINDER)
     find_parser.add_argument(
@@ -80,77 +81,97 @@ def compiler_find(args):
     """Search either $PATH or a list of paths OR MODULES for compilers and
     add them to Spack's configuration.
     """
+    if args.mixed_toolchain:
+        warnings.warn(
+            "The '--mixed-toolchain' option has been deprecated in Spack v0.23, and currently "
+            "has no effect. The option will be removed in Spack v0.25"
+        )
+
     paths = args.add_paths or None
-    new_compilers = spack.compilers.find_compilers(
-        path_hints=paths,
-        scope=args.scope,
-        mixed_toolchain=args.mixed_toolchain,
-        max_workers=args.jobs,
+    new_compilers = spack.compilers.config.find_compilers(
+        path_hints=paths, scope=args.scope, max_workers=args.jobs
     )
     if new_compilers:
         n = len(new_compilers)
         s = "s" if n > 1 else ""
-        filename = spack.config.CONFIG.get_config_filename(args.scope, "compilers")
+        filename = spack.config.CONFIG.get_config_filename(args.scope, "packages")
         tty.msg(f"Added {n:d} new compiler{s} to {filename}")
-        compiler_strs = sorted(f"{c.spec.name}@{c.spec.version}" for c in new_compilers)
+        compiler_strs = sorted(f"{spec.name}@{spec.versions}" for spec in new_compilers)
         colify(reversed(compiler_strs), indent=4)
     else:
         tty.msg("Found no new compilers")
     tty.msg("Compilers are defined in the following files:")
-    colify(spack.compilers.compiler_config_files(), indent=4)
+    colify(spack.compilers.config.compiler_config_files(), indent=4)
 
 
 def compiler_remove(args):
-    compiler_spec = spack.spec.CompilerSpec(args.compiler_spec)
-    candidate_compilers = spack.compilers.compilers_for_spec(compiler_spec, scope=args.scope)
+    remover = spack.compilers.config.CompilerRemover(spack.config.CONFIG)
+    candidates = remover.mark_compilers(match=args.compiler_spec, scope=args.scope)
+    if not candidates:
+        tty.die(f"No compiler matches '{args.compiler_spec}'")
 
-    if not candidate_compilers:
-        tty.die("No compilers match spec %s" % compiler_spec)
+    compiler_strs = reversed(sorted(f"{spec.name}@{spec.versions}" for spec in candidates))
 
-    if not args.all and len(candidate_compilers) > 1:
-        tty.error(f"Multiple compilers match spec {compiler_spec}. Choose one:")
-        colify(reversed(sorted([c.spec.display_str for c in candidate_compilers])), indent=4)
-        tty.msg("Or, use `spack compiler remove -a` to remove all of them.")
+    if not args.all and len(candidates) > 1:
+        tty.error(f"multiple compilers match the spec '{args.compiler_spec}':")
+        print()
+        colify(compiler_strs, indent=4)
+        print()
+        print(
+            "Either use a stricter spec to select only one, or use `spack compiler remove -a`"
+            " to remove all of them."
+        )
         sys.exit(1)
 
-    for current_compiler in candidate_compilers:
-        spack.compilers.remove_compiler_from_config(current_compiler.spec, scope=args.scope)
-        tty.msg(f"{current_compiler.spec.display_str} has been removed")
+    remover.flush()
+    tty.msg("The following compilers have been removed:")
+    print()
+    colify(compiler_strs, indent=4)
+    print()
 
 
 def compiler_info(args):
     """Print info about all compilers matching a spec."""
-    cspec = spack.spec.CompilerSpec(args.compiler_spec)
-    compilers = spack.compilers.compilers_for_spec(cspec, scope=args.scope)
+    query = spack.spec.Spec(args.compiler_spec)
+    all_compilers = spack.compilers.config.all_compilers(scope=args.scope, init_config=False)
+
+    compilers = [x for x in all_compilers if x.satisfies(query)]
 
     if not compilers:
-        tty.die("No compilers match spec %s" % cspec)
+        tty.die(f"No compilers match spec {query.cformat()}")
     else:
         for c in compilers:
-            print(c.spec.display_str + ":")
-            print("\tpaths:")
-            for cpath in ["cc", "cxx", "f77", "fc"]:
-                print("\t\t%s = %s" % (cpath, getattr(c, cpath, None)))
-            if c.flags:
-                print("\tflags:")
-                for flag, flag_value in c.flags.items():
-                    print("\t\t%s = %s" % (flag, flag_value))
-            if len(c.environment) != 0:
-                if len(c.environment.get("set", {})) != 0:
-                    print("\tenvironment:")
-                    print("\t    set:")
-                    for key, value in c.environment["set"].items():
-                        print("\t        %s = %s" % (key, value))
-            if c.extra_rpaths:
-                print("\tExtra rpaths:")
-                for extra_rpath in c.extra_rpaths:
-                    print("\t\t%s" % extra_rpath)
-            print("\tmodules  = %s" % c.modules)
-            print("\toperating system  = %s" % c.operating_system)
+            print(f"{c.cformat()}:")
+            print(f"  prefix: {c.external_path}")
+            extra_attributes = getattr(c, "extra_attributes", {})
+            if "compilers" in extra_attributes:
+                print("  compilers:")
+                for language, exe in extra_attributes.get("compilers", {}).items():
+                    print(f"    {language}: {exe}")
+            if "flags" in extra_attributes:
+                print("  flags:")
+                for flag, flag_value in extra_attributes["flags"].items():
+                    print(f"    {flag} = {flag_value}")
+            # FIXME (compiler as nodes): recover this printing
+            # if "environment" in extra_attributes:
+            #     if len(c.environment.get("set", {})) != 0:
+            #         print("\tenvironment:")
+            #         print("\t    set:")
+            #         for key, value in c.environment["set"].items():
+            #             print("\t        %s = %s" % (key, value))
+            if "extra_rpaths" in extra_attributes:
+                print("  extra rpaths:")
+                for extra_rpath in extra_attributes["extra_rpaths"]:
+                    print(f"    {extra_rpath}")
+            if getattr(c, "external_modules", []):
+                print("  modules: ")
+                for module in c.external_modules:
+                    print(f"    {module}")
+            print()
 
 
 def compiler_list(args):
-    compilers = spack.compilers.all_compilers(scope=args.scope, init_config=False)
+    compilers = spack.compilers.config.all_compilers(scope=args.scope, init_config=False)
 
     # If there are no compilers in any scope, and we're outputting to a tty, give a
     # hint to the user.
@@ -163,7 +184,7 @@ def compiler_list(args):
         tty.msg(msg)
         return
 
-    index = index_by(compilers, lambda c: (c.spec.name, c.operating_system, c.target))
+    index = index_by(compilers, spack.compilers.config.name_os_target)
 
     tty.msg("Available compilers")
 
@@ -182,10 +203,10 @@ def compiler_list(args):
         name, os, target = key
         os_str = os
         if target:
-            os_str += "-%s" % target
-        cname = "%s{%s} %s" % (spack.spec.COMPILER_COLOR, name, os_str)
+            os_str += f"-{target}"
+        cname = f"{spack.spec.COMPILER_COLOR}{{{name}}} {os_str}"
         tty.hline(colorize(cname), char="-")
-        colify(reversed(sorted(c.spec.display_str for c in compilers)))
+        colify(reversed(sorted(c.format("{name}@{version}") for c in compilers)))
 
 
 def compiler(parser, args):

lib/spack/spack/cmd/config.py

@@ -518,8 +518,6 @@ def config_prefer_upstream(args):
     for spec in pref_specs:
         # Collect all the upstream compilers and versions for this package.
         pkg = pkgs.get(spec.name, {"version": []})
-        all = pkgs.get("all", {"compiler": []})
-        pkgs["all"] = all
         pkgs[spec.name] = pkg
 
         # We have no existing variant if this is our first added version.
@@ -529,10 +527,6 @@ def config_prefer_upstream(args):
         if version not in pkg["version"]:
             pkg["version"].append(version)
 
-        compiler = str(spec.compiler)
-        if compiler not in all["compiler"]:
-            all["compiler"].append(compiler)
-
         # Get and list all the variants that differ from the default.
         variants = []
         for var_name, variant in spec.variants.items():

lib/spack/spack/cmd/find.py

@@ -99,7 +99,7 @@ def setup_parser(subparser):
         "--show-full-compiler",
         action="store_true",
         dest="show_full_compiler",
-        help="show full compiler specs",
+        help="(DEPRECATED) show full compiler specs. Currently it's a no-op",
     )
     implicit_explicit = subparser.add_mutually_exclusive_group()
     implicit_explicit.add_argument(
@@ -279,7 +279,6 @@ def root_decorator(spec, string):
             # these enforce details in the root specs to show what the user asked for
             namespaces=True,
             show_flags=True,
-            show_full_compiler=True,
             decorator=root_decorator,
             variants=True,
         )
@@ -302,7 +301,6 @@ def root_decorator(spec, string):
             decorator=lambda s, f: color.colorize("@*{%s}" % f),
             namespace=True,
             show_flags=True,
-            show_full_compiler=True,
             variants=True,
         )
         print()

lib/spack/spack/cmd/unit_test.py

@@ -217,7 +217,7 @@ def unit_test(parser, args, unknown_args):
     # Ensure clingo is available before switching to the
     # mock configuration used by unit tests
     with spack.bootstrap.ensure_bootstrap_configuration():
-        spack.bootstrap.ensure_core_dependencies()
+        spack.bootstrap.ensure_clingo_importable_or_raise()
         if pytest is None:
             spack.bootstrap.ensure_environment_dependencies()
             import pytest

lib/spack/spack/compiler.py

@@ -1,850 +0,0 @@
-# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-# Spack Project Developers. See the top-level COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-import contextlib
-import hashlib
-import itertools
-import json
-import os
-import platform
-import re
-import shutil
-import sys
-import tempfile
-from typing import Dict, List, Optional, Sequence
-
-import llnl.path
-import llnl.util.lang
-import llnl.util.tty as tty
-from llnl.util.filesystem import path_contains_subdirectory, paths_containing_libs
-
-import spack.caches
-import spack.error
-import spack.schema.environment
-import spack.spec
-import spack.util.executable
-import spack.util.libc
-import spack.util.module_cmd
-import spack.version
-from spack.util.environment import filter_system_paths
-from spack.util.file_cache import FileCache
-
-__all__ = ["Compiler"]
-
-PATH_INSTANCE_VARS = ["cc", "cxx", "f77", "fc"]
-FLAG_INSTANCE_VARS = ["cflags", "cppflags", "cxxflags", "fflags"]
-
-
-@llnl.util.lang.memoized
-def _get_compiler_version_output(compiler_path, version_arg, ignore_errors=()) -> str:
-    """Invokes the compiler at a given path passing a single
-    version argument and returns the output.
-
-    Args:
-        compiler_path (path): path of the compiler to be invoked
-        version_arg (str): the argument used to extract version information
-    """
-    compiler = spack.util.executable.Executable(compiler_path)
-    compiler_invocation_args = {
-        "output": str,
-        "error": str,
-        "ignore_errors": ignore_errors,
-        "timeout": 120,
-        "fail_on_error": True,
-    }
-    if version_arg:
-        output = compiler(version_arg, **compiler_invocation_args)
-    else:
-        output = compiler(**compiler_invocation_args)
-    return output
-
-
-def get_compiler_version_output(compiler_path, *args, **kwargs) -> str:
-    """Wrapper for _get_compiler_version_output()."""
-    # This ensures that we memoize compiler output by *absolute path*,
-    # not just executable name. If we don't do this, and the path changes
-    # (e.g., during testing), we can get incorrect results.
-    if not os.path.isabs(compiler_path):
-        compiler_path = spack.util.executable.which_string(compiler_path, required=True)
-
-    return _get_compiler_version_output(compiler_path, *args, **kwargs)
-
-
-def tokenize_flags(flags_values, propagate=False):
-    """Given a compiler flag specification as a string, this returns a list
-    where the entries are the flags. For compiler options which set values
-    using the syntax "-flag value", this function groups flags and their
-    values together. Any token not preceded by a "-" is considered the
-    value of a prior flag."""
-    tokens = flags_values.split()
-    if not tokens:
-        return []
-    flag = tokens[0]
-    flags_with_propagation = []
-    for token in tokens[1:]:
-        if not token.startswith("-"):
-            flag += " " + token
-        else:
-            flags_with_propagation.append((flag, propagate))
-            flag = token
-    flags_with_propagation.append((flag, propagate))
-    return flags_with_propagation
-
-
-#: regex for parsing linker lines
-_LINKER_LINE = re.compile(r"^( *|.*[/\\])" r"(link|ld|([^/\\]+-)?ld|collect2)" r"[^/\\]*( |$)")
-
-#: components of linker lines to ignore
-_LINKER_LINE_IGNORE = re.compile(r"(collect2 version|^[A-Za-z0-9_]+=|/ldfe )")
-
-#: regex to match linker search paths
-_LINK_DIR_ARG = re.compile(r"^-L(.:)?(?P<dir>[/\\].*)")
-
-#: regex to match linker library path arguments
-_LIBPATH_ARG = re.compile(r"^[-/](LIBPATH|libpath):(?P<dir>.*)")
-
-
-def _parse_link_paths(string):
-    """Parse implicit link paths from compiler debug output.
-
-    This gives the compiler runtime library paths that we need to add to
-    the RPATH of generated binaries and libraries.  It allows us to
-    ensure, e.g., that codes load the right libstdc++ for their compiler.
-    """
-    lib_search_paths = False
-    raw_link_dirs = []
-    for line in string.splitlines():
-        if lib_search_paths:
-            if line.startswith("\t"):
-                raw_link_dirs.append(line[1:])
-                continue
-            else:
-                lib_search_paths = False
-        elif line.startswith("Library search paths:"):
-            lib_search_paths = True
-
-        if not _LINKER_LINE.match(line):
-            continue
-        if _LINKER_LINE_IGNORE.match(line):
-            continue
-        tty.debug(f"implicit link dirs: link line: {line}")
-
-        next_arg = False
-        for arg in line.split():
-            if arg in ("-L", "-Y"):
-                next_arg = True
-                continue
-
-            if next_arg:
-                raw_link_dirs.append(arg)
-                next_arg = False
-                continue
-
-            link_dir_arg = _LINK_DIR_ARG.match(arg)
-            if link_dir_arg:
-                link_dir = link_dir_arg.group("dir")
-                raw_link_dirs.append(link_dir)
-
-            link_dir_arg = _LIBPATH_ARG.match(arg)
-            if link_dir_arg:
-                link_dir = link_dir_arg.group("dir")
-                raw_link_dirs.append(link_dir)
-
-    implicit_link_dirs = list()
-    visited = set()
-    for link_dir in raw_link_dirs:
-        normalized_path = os.path.abspath(link_dir)
-        if normalized_path not in visited:
-            implicit_link_dirs.append(normalized_path)
-            visited.add(normalized_path)
-
-    tty.debug(f"implicit link dirs: result: {', '.join(implicit_link_dirs)}")
-    return implicit_link_dirs
-
-
-@llnl.path.system_path_filter
-def _parse_non_system_link_dirs(string: str) -> List[str]:
-    """Parses link paths out of compiler debug output.
-
-    Args:
-        string: compiler debug output as a string
-
-    Returns:
-        Implicit link paths parsed from the compiler output
-    """
-    link_dirs = _parse_link_paths(string)
-
-    # Remove directories that do not exist. Some versions of the Cray compiler
-    # report nonexistent directories
-    link_dirs = [d for d in link_dirs if os.path.isdir(d)]
-
-    # Return set of directories containing needed compiler libs, minus
-    # system paths. Note that 'filter_system_paths' only checks for an
-    # exact match, while 'in_system_subdirectory' checks if a path contains
-    # a system directory as a subdirectory
-    link_dirs = filter_system_paths(link_dirs)
-    return list(p for p in link_dirs if not in_system_subdirectory(p))
-
-
-def in_system_subdirectory(path):
-    system_dirs = [
-        "/lib/",
-        "/lib64/",
-        "/usr/lib/",
-        "/usr/lib64/",
-        "/usr/local/lib/",
-        "/usr/local/lib64/",
-    ]
-    return any(path_contains_subdirectory(path, x) for x in system_dirs)
-
-
-class Compiler:
-    """This class encapsulates a Spack "compiler", which includes C,
-    C++, and Fortran compilers.  Subclasses should implement
-    support for specific compilers, their possible names, arguments,
-    and how to identify the particular type of compiler."""
-
-    # Optional prefix regexes for searching for this type of compiler.
-    # Prefixes are sometimes used for toolchains
-    prefixes: List[str] = []
-
-    # Optional suffix regexes for searching for this type of compiler.
-    # Suffixes are used by some frameworks, e.g. macports uses an '-mp-X.Y'
-    # version suffix for gcc.
-    suffixes = [r"-.*"]
-
-    #: Compiler argument that produces version information
-    version_argument = "-dumpversion"
-
-    #: Return values to ignore when invoking the compiler to get its version
-    ignore_version_errors: Sequence[int] = ()
-
-    #: Regex used to extract version from compiler's output
-    version_regex = "(.*)"
-
-    # These libraries are anticipated to be required by all executables built
-    # by any compiler
-    _all_compiler_rpath_libraries = ["libc", "libc++", "libstdc++"]
-
-    #: Platform matcher for Platform objects supported by compiler
-    is_supported_on_platform = lambda x: True
-
-    # Default flags used by a compiler to set an rpath
-    @property
-    def cc_rpath_arg(self):
-        return "-Wl,-rpath,"
-
-    @property
-    def cxx_rpath_arg(self):
-        return "-Wl,-rpath,"
-
-    @property
-    def f77_rpath_arg(self):
-        return "-Wl,-rpath,"
-
-    @property
-    def fc_rpath_arg(self):
-        return "-Wl,-rpath,"
-
-    @property
-    def linker_arg(self):
-        """Flag that need to be used to pass an argument to the linker."""
-        return "-Wl,"
-
-    @property
-    def disable_new_dtags(self):
-        if platform.system() == "Darwin":
-            return ""
-        return "--disable-new-dtags"
-
-    @property
-    def enable_new_dtags(self):
-        if platform.system() == "Darwin":
-            return ""
-        return "--enable-new-dtags"
-
-    @property
-    def debug_flags(self):
-        return ["-g"]
-
-    @property
-    def opt_flags(self):
-        return ["-O", "-O0", "-O1", "-O2", "-O3"]
-
-    def __init__(
-        self,
-        cspec,
-        operating_system,
-        target,
-        paths,
-        modules: Optional[List[str]] = None,
-        alias=None,
-        environment=None,
-        extra_rpaths=None,
-        enable_implicit_rpaths=None,
-        **kwargs,
-    ):
-        self.spec = cspec
-        self.operating_system = str(operating_system)
-        self.target = target
-        self.modules = modules or []
-        self.alias = alias
-        self.environment = environment or {}
-        self.extra_rpaths = extra_rpaths or []
-        self.enable_implicit_rpaths = enable_implicit_rpaths
-        self.cache = COMPILER_CACHE
-
-        self.cc = paths[0]
-        self.cxx = paths[1]
-        self.f77 = None
-        self.fc = None
-        if len(paths) > 2:
-            self.f77 = paths[2]
-            if len(paths) == 3:
-                self.fc = self.f77
-            else:
-                self.fc = paths[3]
-
-        # Unfortunately have to make sure these params are accepted
-        # in the same order they are returned by sorted(flags)
-        # in compilers/__init__.py
-        self.flags = spack.spec.FlagMap(self.spec)
-        for flag in self.flags.valid_compiler_flags():
-            value = kwargs.get(flag, None)
-            if value is not None:
-                values_with_propagation = tokenize_flags(value, False)
-                for value, propagation in values_with_propagation:
-                    self.flags.add_flag(flag, value, propagation)
-
-        # caching value for compiler reported version
-        # used for version checks for API, e.g. C++11 flag
-        self._real_version = None
-
-    def __eq__(self, other):
-        return (
-            self.cc == other.cc
-            and self.cxx == other.cxx
-            and self.fc == other.fc
-            and self.f77 == other.f77
-            and self.spec == other.spec
-            and self.operating_system == other.operating_system
-            and self.target == other.target
-            and self.flags == other.flags
-            and self.modules == other.modules
-            and self.environment == other.environment
-            and self.extra_rpaths == other.extra_rpaths
-            and self.enable_implicit_rpaths == other.enable_implicit_rpaths
-        )
-
-    def __hash__(self):
-        return hash(
-            (
-                self.cc,
-                self.cxx,
-                self.fc,
-                self.f77,
-                self.spec,
-                self.operating_system,
-                self.target,
-                str(self.flags),
-                str(self.modules),
-                str(self.environment),
-                str(self.extra_rpaths),
-                self.enable_implicit_rpaths,
-            )
-        )
-
-    def verify_executables(self):
-        """Raise an error if any of the compiler executables is not valid.
-
-        This method confirms that for all of the compilers (cc, cxx, f77, fc)
-        that have paths, those paths exist and are executable by the current
-        user.
-        Raises a CompilerAccessError if any of the non-null paths for the
-        compiler are not accessible.
-        """
-
-        def accessible_exe(exe):
-            # compilers may contain executable names (on Cray or user edited)
-            if not os.path.isabs(exe):
-                exe = spack.util.executable.which_string(exe)
-                if not exe:
-                    return False
-            return os.path.isfile(exe) and os.access(exe, os.X_OK)
-
-        # setup environment before verifying in case we have executable names
-        # instead of absolute paths
-        with self.compiler_environment():
-            missing = [
-                cmp
-                for cmp in (self.cc, self.cxx, self.f77, self.fc)
-                if cmp and not accessible_exe(cmp)
-            ]
-            if missing:
-                raise CompilerAccessError(self, missing)
-
-    @property
-    def version(self):
-        return self.spec.version
-
-    @property
-    def real_version(self):
-        """Executable reported compiler version used for API-determinations
-
-        E.g. C++11 flag checks.
-        """
-        real_version_str = self.cache.get(self).real_version
-        if not real_version_str or real_version_str == "unknown":
-            return self.version
-
-        return spack.version.StandardVersion.from_string(real_version_str)
-
-    def implicit_rpaths(self) -> List[str]:
-        if self.enable_implicit_rpaths is False:
-            return []
-
-        output = self.compiler_verbose_output
-
-        if not output:
-            return []
-
-        link_dirs = _parse_non_system_link_dirs(output)
-
-        all_required_libs = list(self.required_libs) + Compiler._all_compiler_rpath_libraries
-        return list(paths_containing_libs(link_dirs, all_required_libs))
-
-    @property
-    def default_dynamic_linker(self) -> Optional[str]:
-        """Determine default dynamic linker from compiler link line"""
-        output = self.compiler_verbose_output
-
-        if not output:
-            return None
-
-        return spack.util.libc.parse_dynamic_linker(output)
-
-    @property
-    def default_libc(self) -> Optional["spack.spec.Spec"]:
-        """Determine libc targeted by the compiler from link line"""
-        # technically this should be testing the target platform of the compiler, but we don't have
-        # that, so stick to host platform for now.
-        if sys.platform in ("darwin", "win32"):
-            return None
-
-        dynamic_linker = self.default_dynamic_linker
-
-        if not dynamic_linker:
-            return None
-
-        return spack.util.libc.libc_from_dynamic_linker(dynamic_linker)
-
-    @property
-    def required_libs(self):
-        """For executables created with this compiler, the compiler libraries
-        that would be generally required to run it.
-        """
-        # By default every compiler returns the empty list
-        return []
-
-    @property
-    def compiler_verbose_output(self) -> Optional[str]:
-        """Verbose output from compiling a dummy C source file. Output is cached."""
-        return self.cache.get(self).c_compiler_output
-
-    def _compile_dummy_c_source(self) -> Optional[str]:
-        if self.cc:
-            cc = self.cc
-            ext = "c"
-        else:
-            cc = self.cxx
-            ext = "cc"
-
-        if not cc or not self.verbose_flag:
-            return None
-
-        try:
-            tmpdir = tempfile.mkdtemp(prefix="spack-implicit-link-info")
-            fout = os.path.join(tmpdir, "output")
-            fin = os.path.join(tmpdir, f"main.{ext}")
-
-            with open(fin, "w") as csource:
-                csource.write(
-                    "int main(int argc, char* argv[]) { (void)argc; (void)argv; return 0; }\n"
-                )
-            cc_exe = spack.util.executable.Executable(cc)
-            for flag_type in ["cflags" if cc == self.cc else "cxxflags", "cppflags", "ldflags"]:
-                cc_exe.add_default_arg(*self.flags.get(flag_type, []))
-
-            with self.compiler_environment():
-                return cc_exe(self.verbose_flag, fin, "-o", fout, output=str, error=str)
-        except spack.util.executable.ProcessError as pe:
-            tty.debug("ProcessError: Command exited with non-zero status: " + pe.long_message)
-            return None
-        finally:
-            shutil.rmtree(tmpdir, ignore_errors=True)
-
-    @property
-    def verbose_flag(self) -> Optional[str]:
-        """
-        This property should be overridden in the compiler subclass if a
-        verbose flag is available.
-
-        If it is not overridden, it is assumed to not be supported.
-        """
-
-    # This property should be overridden in the compiler subclass if
-    # OpenMP is supported by that compiler
-    @property
-    def openmp_flag(self):
-        # If it is not overridden, assume it is not supported and warn the user
-        raise UnsupportedCompilerFlag(self, "OpenMP", "openmp_flag")
-
-    # This property should be overridden in the compiler subclass if
-    # C++98 is not the default standard for that compiler
-    @property
-    def cxx98_flag(self):
-        return ""
-
-    # This property should be overridden in the compiler subclass if
-    # C++11 is supported by that compiler
-    @property
-    def cxx11_flag(self):
-        # If it is not overridden, assume it is not supported and warn the user
-        raise UnsupportedCompilerFlag(self, "the C++11 standard", "cxx11_flag")
-
-    # This property should be overridden in the compiler subclass if
-    # C++14 is supported by that compiler
-    @property
-    def cxx14_flag(self):
-        # If it is not overridden, assume it is not supported and warn the user
-        raise UnsupportedCompilerFlag(self, "the C++14 standard", "cxx14_flag")
-
-    # This property should be overridden in the compiler subclass if
-    # C++17 is supported by that compiler
-    @property
-    def cxx17_flag(self):
-        # If it is not overridden, assume it is not supported and warn the user
-        raise UnsupportedCompilerFlag(self, "the C++17 standard", "cxx17_flag")
-
-    # This property should be overridden in the compiler subclass if
-    # C99 is supported by that compiler
-    @property
-    def c99_flag(self):
-        # If it is not overridden, assume it is not supported and warn the user
-        raise UnsupportedCompilerFlag(self, "the C99 standard", "c99_flag")
-
-    # This property should be overridden in the compiler subclass if
-    # C11 is supported by that compiler
-    @property
-    def c11_flag(self):
-        # If it is not overridden, assume it is not supported and warn the user
-        raise UnsupportedCompilerFlag(self, "the C11 standard", "c11_flag")
-
-    @property
-    def cc_pic_flag(self):
-        """Returns the flag used by the C compiler to produce
-        Position Independent Code (PIC)."""
-        return "-fPIC"
-
-    @property
-    def cxx_pic_flag(self):
-        """Returns the flag used by the C++ compiler to produce
-        Position Independent Code (PIC)."""
-        return "-fPIC"
-
-    @property
-    def f77_pic_flag(self):
-        """Returns the flag used by the F77 compiler to produce
-        Position Independent Code (PIC)."""
-        return "-fPIC"
-
-    @property
-    def fc_pic_flag(self):
-        """Returns the flag used by the FC compiler to produce
-        Position Independent Code (PIC)."""
-        return "-fPIC"
-
-    # Note: This is not a class method. The class methods are used to detect
-    # compilers on PATH based systems, and do not set up the run environment of
-    # the compiler. This method can be called on `module` based systems as well
-    def get_real_version(self) -> str:
-        """Query the compiler for its version.
-
-        This is the "real" compiler version, regardless of what is in the
-        compilers.yaml file, which the user can change to name their compiler.
-
-        Use the runtime environment of the compiler (modules and environment
-        modifications) to enable the compiler to run properly on any platform.
-        """
-        cc = spack.util.executable.Executable(self.cc)
-        try:
-            with self.compiler_environment():
-                output = cc(
-                    self.version_argument,
-                    output=str,
-                    error=str,
-                    ignore_errors=tuple(self.ignore_version_errors),
-                )
-                return self.extract_version_from_output(output)
-        except spack.util.executable.ProcessError:
-            return "unknown"
-
-    @property
-    def prefix(self):
-        """Query the compiler for its install prefix. This is the install
-        path as reported by the compiler. Note that paths for cc, cxx, etc
-        are not enough to find the install prefix of the compiler, since
-        the can be symlinks, wrappers, or filenames instead of absolute paths."""
-        raise NotImplementedError("prefix is not implemented for this compiler")
-
-    #
-    # Compiler classes have methods for querying the version of
-    # specific compiler executables.  This is used when discovering compilers.
-    #
-    # Compiler *instances* are just data objects, and can only be
-    # constructed from an actual set of executables.
-    #
-    @classmethod
-    def default_version(cls, cc):
-        """Override just this to override all compiler version functions."""
-        output = get_compiler_version_output(
-            cc, cls.version_argument, tuple(cls.ignore_version_errors)
-        )
-        return cls.extract_version_from_output(output)
-
-    @classmethod
-    @llnl.util.lang.memoized
-    def extract_version_from_output(cls, output: str) -> str:
-        """Extracts the version from compiler's output."""
-        match = re.search(cls.version_regex, output)
-        return match.group(1) if match else "unknown"
-
-    @classmethod
-    def cc_version(cls, cc):
-        return cls.default_version(cc)
-
-    @classmethod
-    def search_regexps(cls, language):
-        # Compile all the regular expressions used for files beforehand.
-        # This searches for any combination of <prefix><name><suffix>
-        # defined for the compiler
-        compiler_names = getattr(cls, "{0}_names".format(language))
-        prefixes = [""] + cls.prefixes
-        suffixes = [""]
-        if sys.platform == "win32":
-            ext = r"\.(?:exe|bat)"
-            cls_suf = [suf + ext for suf in cls.suffixes]
-            ext_suf = [ext]
-            suffixes = suffixes + cls.suffixes + cls_suf + ext_suf
-        else:
-            suffixes = suffixes + cls.suffixes
-        regexp_fmt = r"^({0}){1}({2})$"
-        return [
-            re.compile(regexp_fmt.format(prefix, re.escape(name), suffix))
-            for prefix, name, suffix in itertools.product(prefixes, compiler_names, suffixes)
-        ]
-
-    def setup_custom_environment(self, pkg, env):
-        """Set any environment variables necessary to use the compiler."""
-        pass
-
-    def __repr__(self):
-        """Return a string representation of the compiler toolchain."""
-        return self.__str__()
-
-    def __str__(self):
-        """Return a string representation of the compiler toolchain."""
-        return "%s(%s)" % (
-            self.name,
-            "\n     ".join(
-                (
-                    str(s)
-                    for s in (
-                        self.cc,
-                        self.cxx,
-                        self.f77,
-                        self.fc,
-                        self.modules,
-                        str(self.operating_system),
-                    )
-                )
-            ),
-        )
-
-    @contextlib.contextmanager
-    def compiler_environment(self):
-        # Avoid modifying os.environ if possible.
-        if not self.modules and not self.environment:
-            yield
-            return
-
-        # store environment to replace later
-        backup_env = os.environ.copy()
-
-        try:
-            # load modules and set env variables
-            for module in self.modules:
-                spack.util.module_cmd.load_module(module)
-
-            # apply other compiler environment changes
-            spack.schema.environment.parse(self.environment).apply_modifications()
-
-            yield
-        finally:
-            # Restore environment regardless of whether inner code succeeded
-            os.environ.clear()
-            os.environ.update(backup_env)
-
-    def to_dict(self):
-        flags_dict = {fname: " ".join(fvals) for fname, fvals in self.flags.items()}
-        flags_dict.update(
-            {attr: getattr(self, attr, None) for attr in FLAG_INSTANCE_VARS if hasattr(self, attr)}
-        )
-        result = {
-            "spec": str(self.spec),
-            "paths": {attr: getattr(self, attr, None) for attr in PATH_INSTANCE_VARS},
-            "flags": flags_dict,
-            "operating_system": str(self.operating_system),
-            "target": str(self.target),
-            "modules": self.modules or [],
-            "environment": self.environment or {},
-            "extra_rpaths": self.extra_rpaths or [],
-        }
-
-        if self.enable_implicit_rpaths is not None:
-            result["implicit_rpaths"] = self.enable_implicit_rpaths
-
-        if self.alias:
-            result["alias"] = self.alias
-
-        return result
-
-
-class CompilerAccessError(spack.error.SpackError):
-    def __init__(self, compiler, paths):
-        msg = "Compiler '%s' has executables that are missing" % compiler.spec
-        msg += " or are not executable: %s" % paths
-        super().__init__(msg)
-
-
-class InvalidCompilerError(spack.error.SpackError):
-    def __init__(self):
-        super().__init__("Compiler has no executables.")
-
-
-class UnsupportedCompilerFlag(spack.error.SpackError):
-    def __init__(self, compiler, feature, flag_name, ver_string=None):
-        super().__init__(
-            "{0} ({1}) does not support {2} (as compiler.{3}).".format(
-                compiler.name, ver_string if ver_string else compiler.version, feature, flag_name
-            ),
-            "If you think it should, please edit the compiler.{0} subclass to".format(
-                compiler.name
-            )
-            + " implement the {0} property and submit a pull request or issue.".format(flag_name),
-        )
-
-
-class CompilerCacheEntry:
-    """Deserialized cache entry for a compiler"""
-
-    __slots__ = ["c_compiler_output", "real_version"]
-
-    def __init__(self, c_compiler_output: Optional[str], real_version: str):
-        self.c_compiler_output = c_compiler_output
-        self.real_version = real_version
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Optional[str]]):
-        if not isinstance(data, dict):
-            raise ValueError(f"Invalid {cls.__name__} data")
-        c_compiler_output = data.get("c_compiler_output")
-        real_version = data.get("real_version")
-        if not isinstance(real_version, str) or not isinstance(
-            c_compiler_output, (str, type(None))
-        ):
-            raise ValueError(f"Invalid {cls.__name__} data")
-        return cls(c_compiler_output, real_version)
-
-
-class CompilerCache:
-    """Base class for compiler output cache. Default implementation does not cache anything."""
-
-    def value(self, compiler: Compiler) -> Dict[str, Optional[str]]:
-        return {
-            "c_compiler_output": compiler._compile_dummy_c_source(),
-            "real_version": compiler.get_real_version(),
-        }
-
-    def get(self, compiler: Compiler) -> CompilerCacheEntry:
-        return CompilerCacheEntry.from_dict(self.value(compiler))
-
-
-class FileCompilerCache(CompilerCache):
-    """Cache for compiler output, which is used to determine implicit link paths, the default libc
-    version, and the compiler version."""
-
-    name = os.path.join("compilers", "compilers.json")
-
-    def __init__(self, cache: "FileCache") -> None:
-        self.cache = cache
-        self.cache.init_entry(self.name)
-        self._data: Dict[str, Dict[str, Optional[str]]] = {}
-
-    def _get_entry(self, key: str) -> Optional[CompilerCacheEntry]:
-        try:
-            return CompilerCacheEntry.from_dict(self._data[key])
-        except ValueError:
-            del self._data[key]
-        except KeyError:
-            pass
-        return None
-
-    def get(self, compiler: Compiler) -> CompilerCacheEntry:
-        # Cache hit
-        try:
-            with self.cache.read_transaction(self.name) as f:
-                assert f is not None
-                self._data = json.loads(f.read())
-                assert isinstance(self._data, dict)
-        except (json.JSONDecodeError, AssertionError):
-            self._data = {}
-
-        key = self._key(compiler)
-        value = self._get_entry(key)
-        if value is not None:
-            return value
-
-        # Cache miss
-        with self.cache.write_transaction(self.name) as (old, new):
-            try:
-                assert old is not None
-                self._data = json.loads(old.read())
-                assert isinstance(self._data, dict)
-            except (json.JSONDecodeError, AssertionError):
-                self._data = {}
-
-            # Use cache entry that may have been created by another process in the meantime.
-            entry = self._get_entry(key)
-
-            # Finally compute the cache entry
-            if entry is None:
-                self._data[key] = self.value(compiler)
-                entry = CompilerCacheEntry.from_dict(self._data[key])
-
-            new.write(json.dumps(self._data, separators=(",", ":")))
-
-            return entry
-
-    def _key(self, compiler: Compiler) -> str:
-        as_bytes = json.dumps(compiler.to_dict(), separators=(",", ":")).encode("utf-8")
-        return hashlib.sha256(as_bytes).hexdigest()
-
-
-def _make_compiler_cache():
-    return FileCompilerCache(spack.caches.MISC_CACHE)
-
-
-COMPILER_CACHE: CompilerCache = llnl.util.lang.Singleton(_make_compiler_cache)  # type: ignore

lib/spack/spack/compilers/__init__.py

@@ -2,836 +2,3 @@
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-"""This module contains functions related to finding compilers on the
-system and configuring Spack to use multiple compilers.
-"""
-import importlib
-import os
-import re
-import sys
-import warnings
-from typing import Dict, List, Optional
-
-import archspec.cpu
-
-import llnl.util.filesystem as fs
-import llnl.util.lang
-import llnl.util.tty as tty
-
-import spack.compiler
-import spack.config
-import spack.error
-import spack.paths
-import spack.platforms
-import spack.repo
-import spack.spec
-from spack.operating_systems import windows_os
-from spack.util.environment import get_path
-from spack.util.naming import mod_to_class
-
-_other_instance_vars = [
-    "modules",
-    "operating_system",
-    "environment",
-    "implicit_rpaths",
-    "extra_rpaths",
-]
-
-# TODO: Caches at module level make it difficult to mock configurations in
-# TODO: unit tests. It might be worth reworking their implementation.
-#: cache of compilers constructed from config data, keyed by config entry id.
-_compiler_cache: Dict[str, "spack.compiler.Compiler"] = {}
-
-_compiler_to_pkg = {
-    "clang": "llvm+clang",
-    "oneapi": "intel-oneapi-compilers",
-    "rocmcc": "llvm-amdgpu",
-    "intel@2020:": "intel-oneapi-compilers-classic",
-    "arm": "acfl",
-}
-
-# TODO: generating this from the previous dict causes docs errors
-package_name_to_compiler_name = {
-    "llvm": "clang",
-    "intel-oneapi-compilers": "oneapi",
-    "llvm-amdgpu": "rocmcc",
-    "intel-oneapi-compilers-classic": "intel",
-    "acfl": "arm",
-}
-
-
-#: Tag used to identify packages providing a compiler
-COMPILER_TAG = "compiler"
-
-
-def pkg_spec_for_compiler(cspec):
-    """Return the spec of the package that provides the compiler."""
-    for spec, package in _compiler_to_pkg.items():
-        if cspec.satisfies(spec):
-            spec_str = "%s@%s" % (package, cspec.versions)
-            break
-    else:
-        spec_str = str(cspec)
-    return spack.spec.parse_with_version_concrete(spec_str)
-
-
-def _auto_compiler_spec(function):
-    def converter(cspec_like, *args, **kwargs):
-        if not isinstance(cspec_like, spack.spec.CompilerSpec):
-            cspec_like = spack.spec.CompilerSpec(cspec_like)
-        return function(cspec_like, *args, **kwargs)
-
-    return converter
-
-
-def _to_dict(compiler):
-    """Return a dict version of compiler suitable to insert in YAML."""
-    return {"compiler": compiler.to_dict()}
-
-
-def get_compiler_config(
-    configuration: "spack.config.Configuration",
-    *,
-    scope: Optional[str] = None,
-    init_config: bool = False,
-) -> List[Dict]:
-    """Return the compiler configuration for the specified architecture."""
-    config = configuration.get("compilers", scope=scope) or []
-    if config or not init_config:
-        return config
-
-    merged_config = configuration.get("compilers")
-    if merged_config:
-        # Config is empty for this scope
-        # Do not init config because there is a non-empty scope
-        return config
-
-    find_compilers(scope=scope)
-    config = configuration.get("compilers", scope=scope)
-    return config
-
-
-def get_compiler_config_from_packages(
-    configuration: "spack.config.Configuration", *, scope: Optional[str] = None
-) -> List[Dict]:
-    """Return the compiler configuration from packages.yaml"""
-    packages_yaml = configuration.get("packages", scope=scope)
-    return CompilerConfigFactory.from_packages_yaml(packages_yaml)
-
-
-def compiler_config_files():
-    config_files = list()
-    config = spack.config.CONFIG
-    for scope in config.writable_scopes:
-        name = scope.name
-        compiler_config = config.get("compilers", scope=name)
-        if compiler_config:
-            config_files.append(config.get_config_filename(name, "compilers"))
-        compiler_config_from_packages = get_compiler_config_from_packages(config, scope=name)
-        if compiler_config_from_packages:
-            config_files.append(config.get_config_filename(name, "packages"))
-    return config_files
-
-
-def add_compilers_to_config(compilers, scope=None):
-    """Add compilers to the config for the specified architecture.
-
-    Arguments:
-        compilers: a list of Compiler objects.
-        scope: configuration scope to modify.
-    """
-    compiler_config = get_compiler_config(configuration=spack.config.CONFIG, scope=scope)
-    for compiler in compilers:
-        if not compiler.cc:
-            tty.debug(f"{compiler.spec} does not have a C compiler")
-        if not compiler.cxx:
-            tty.debug(f"{compiler.spec} does not have a C++ compiler")
-        if not compiler.f77:
-            tty.debug(f"{compiler.spec} does not have a Fortran77 compiler")
-        if not compiler.fc:
-            tty.debug(f"{compiler.spec} does not have a Fortran compiler")
-        compiler_config.append(_to_dict(compiler))
-    spack.config.set("compilers", compiler_config, scope=scope)
-
-
-@_auto_compiler_spec
-def remove_compiler_from_config(compiler_spec, scope=None):
-    """Remove compilers from configuration by spec.
-
-    If scope is None, all the scopes are searched for removal.
-
-    Arguments:
-        compiler_spec: compiler to be removed
-        scope: configuration scope to modify
-    """
-    candidate_scopes = [scope]
-    if scope is None:
-        candidate_scopes = spack.config.CONFIG.scopes.keys()
-
-    removal_happened = False
-    for current_scope in candidate_scopes:
-        removal_happened |= _remove_compiler_from_scope(compiler_spec, scope=current_scope)
-
-    msg = "`spack compiler remove` will not remove compilers defined in packages.yaml"
-    msg += "\nTo remove these compilers, either edit the config or use `spack external remove`"
-    tty.debug(msg)
-    return removal_happened
-
-
-def _remove_compiler_from_scope(compiler_spec, scope):
-    """Removes a compiler from a specific configuration scope.
-
-    Args:
-        compiler_spec: compiler to be removed
-        scope: configuration scope under consideration
-
-    Returns:
-         True if one or more compiler entries were actually removed, False otherwise
-    """
-    assert scope is not None, "a specific scope is needed when calling this function"
-    compiler_config = get_compiler_config(configuration=spack.config.CONFIG, scope=scope)
-    filtered_compiler_config = [
-        compiler_entry
-        for compiler_entry in compiler_config
-        if not spack.spec.parse_with_version_concrete(
-            compiler_entry["compiler"]["spec"], compiler=True
-        ).satisfies(compiler_spec)
-    ]
-
-    if len(filtered_compiler_config) == len(compiler_config):
-        return False
-
-    # We need to preserve the YAML type for comments, hence we are copying the
-    # items in the list that has just been retrieved
-    compiler_config[:] = filtered_compiler_config
-    spack.config.CONFIG.set("compilers", compiler_config, scope=scope)
-    return True
-
-
-def all_compilers_config(
-    configuration: "spack.config.Configuration",
-    *,
-    scope: Optional[str] = None,
-    init_config: bool = True,
-) -> List["spack.compiler.Compiler"]:
-    """Return a set of specs for all the compiler versions currently
-    available to build with.  These are instances of CompilerSpec.
-    """
-    from_packages_yaml = get_compiler_config_from_packages(configuration, scope=scope)
-    if from_packages_yaml:
-        init_config = False
-    from_compilers_yaml = get_compiler_config(configuration, scope=scope, init_config=init_config)
-
-    result = from_compilers_yaml + from_packages_yaml
-    # Dedupe entries by the compiler they represent
-    # If the entry is invalid, treat it as unique for deduplication
-    key = lambda c: _compiler_from_config_entry(c["compiler"] or id(c))
-    return list(llnl.util.lang.dedupe(result, key=key))
-
-
-def all_compiler_specs(scope=None, init_config=True):
-    # Return compiler specs from the merged config.
-    return [
-        spack.spec.parse_with_version_concrete(s["compiler"]["spec"], compiler=True)
-        for s in all_compilers_config(spack.config.CONFIG, scope=scope, init_config=init_config)
-    ]
-
-
-def find_compilers(
-    path_hints: Optional[List[str]] = None,
-    *,
-    scope: Optional[str] = None,
-    mixed_toolchain: bool = False,
-    max_workers: Optional[int] = None,
-) -> List["spack.compiler.Compiler"]:
-    """Searches for compiler in the paths given as argument. If any new compiler is found, the
-    configuration is updated, and the list of new compiler objects is returned.
-
-    Args:
-        path_hints: list of path hints where to look for. A sensible default based on the ``PATH``
-            environment variable will be used if the value is None
-        scope: configuration scope to modify
-        mixed_toolchain: allow mixing compilers from different toolchains if otherwise missing for
-            a certain language
-        max_workers: number of processes used to search for compilers
-    """
-    import spack.detection
-
-    known_compilers = set(all_compilers(init_config=False))
-
-    if path_hints is None:
-        path_hints = get_path("PATH")
-    default_paths = fs.search_paths_for_executables(*path_hints)
-    if sys.platform == "win32":
-        default_paths.extend(windows_os.WindowsOs().compiler_search_paths)
-    compiler_pkgs = spack.repo.PATH.packages_with_tags(COMPILER_TAG, full=True)
-
-    detected_packages = spack.detection.by_path(
-        compiler_pkgs, path_hints=default_paths, max_workers=max_workers
-    )
-
-    valid_compilers = {}
-    for name, detected in detected_packages.items():
-        compilers = [x for x in detected if CompilerConfigFactory.from_external_spec(x)]
-        if not compilers:
-            continue
-        valid_compilers[name] = compilers
-
-    def _has_fortran_compilers(x):
-        if "compilers" not in x.extra_attributes:
-            return False
-
-        return "fortran" in x.extra_attributes["compilers"]
-
-    if mixed_toolchain:
-        gccs = [x for x in valid_compilers.get("gcc", []) if _has_fortran_compilers(x)]
-        if gccs:
-            best_gcc = sorted(
-                gccs, key=lambda x: spack.spec.parse_with_version_concrete(x).version
-            )[-1]
-            gfortran = best_gcc.extra_attributes["compilers"]["fortran"]
-            for name in ("llvm", "apple-clang"):
-                if name not in valid_compilers:
-                    continue
-                candidates = valid_compilers[name]
-                for candidate in candidates:
-                    if _has_fortran_compilers(candidate):
-                        continue
-                    candidate.extra_attributes["compilers"]["fortran"] = gfortran
-
-    new_compilers = []
-    for name, detected in valid_compilers.items():
-        for config in CompilerConfigFactory.from_specs(detected):
-            c = _compiler_from_config_entry(config["compiler"])
-            if c in known_compilers:
-                continue
-            new_compilers.append(c)
-
-    add_compilers_to_config(new_compilers, scope=scope)
-    return new_compilers
-
-
-def select_new_compilers(compilers, scope=None):
-    """Given a list of compilers, remove those that are already defined in
-    the configuration.
-    """
-    compilers_not_in_config = []
-    for c in compilers:
-        arch_spec = spack.spec.ArchSpec((None, c.operating_system, c.target))
-        same_specs = compilers_for_spec(
-            c.spec, arch_spec=arch_spec, scope=scope, init_config=False
-        )
-        if not same_specs:
-            compilers_not_in_config.append(c)
-
-    return compilers_not_in_config
-
-
-def supported_compilers() -> List[str]:
-    """Return a set of names of compilers supported by Spack.
-
-    See available_compilers() to get a list of all the available
-    versions of supported compilers.
-    """
-    # Hack to be able to call the compiler `apple-clang` while still
-    # using a valid python name for the module
-    return sorted(all_compiler_names())
-
-
-def supported_compilers_for_host_platform() -> List[str]:
-    """Return a set of compiler class objects supported by Spack
-    that are also supported by the current host platform
-    """
-    host_plat = spack.platforms.real_host()
-    return supported_compilers_for_platform(host_plat)
-
-
-def supported_compilers_for_platform(platform: "spack.platforms.Platform") -> List[str]:
-    """Return a set of compiler class objects supported by Spack
-    that are also supported by the provided platform
-
-    Args:
-        platform (str): string representation of platform
-            for which compiler compatability should be determined
-    """
-    return [
-        name
-        for name in supported_compilers()
-        if class_for_compiler_name(name).is_supported_on_platform(platform)
-    ]
-
-
-def all_compiler_names() -> List[str]:
-    def replace_apple_clang(name):
-        return name if name != "apple_clang" else "apple-clang"
-
-    return [replace_apple_clang(name) for name in all_compiler_module_names()]
-
-
-@llnl.util.lang.memoized
-def all_compiler_module_names() -> List[str]:
-    return list(llnl.util.lang.list_modules(spack.paths.compilers_path))
-
-
-@_auto_compiler_spec
-def supported(compiler_spec):
-    """Test if a particular compiler is supported."""
-    return compiler_spec.name in supported_compilers()
-
-
-@_auto_compiler_spec
-def find(compiler_spec, scope=None, init_config=True):
-    """Return specs of available compilers that match the supplied
-    compiler spec.  Return an empty list if nothing found."""
-    return [c for c in all_compiler_specs(scope, init_config) if c.satisfies(compiler_spec)]
-
-
-@_auto_compiler_spec
-def find_specs_by_arch(compiler_spec, arch_spec, scope=None, init_config=True):
-    """Return specs of available compilers that match the supplied
-    compiler spec.  Return an empty list if nothing found."""
-    return [
-        c.spec
-        for c in compilers_for_spec(
-            compiler_spec, arch_spec=arch_spec, scope=scope, init_config=init_config
-        )
-    ]
-
-
-def all_compilers(scope=None, init_config=True):
-    return all_compilers_from(
-        configuration=spack.config.CONFIG, scope=scope, init_config=init_config
-    )
-
-
-def all_compilers_from(configuration, scope=None, init_config=True):
-    compilers = []
-    for items in all_compilers_config(
-        configuration=configuration, scope=scope, init_config=init_config
-    ):
-        items = items["compiler"]
-        compiler = _compiler_from_config_entry(items)  # can be None in error case
-        if compiler:
-            compilers.append(compiler)
-    return compilers
-
-
-@_auto_compiler_spec
-def compilers_for_spec(compiler_spec, *, arch_spec=None, scope=None, init_config=True):
-    """This gets all compilers that satisfy the supplied CompilerSpec.
-    Returns an empty list if none are found.
-    """
-    config = all_compilers_config(spack.config.CONFIG, scope=scope, init_config=init_config)
-    matches = set(find(compiler_spec, scope, init_config))
-    compilers = []
-    for cspec in matches:
-        compilers.extend(get_compilers(config, cspec, arch_spec))
-    return compilers
-
-
-def compilers_for_arch(arch_spec, scope=None):
-    config = all_compilers_config(spack.config.CONFIG, scope=scope, init_config=False)
-    return list(get_compilers(config, arch_spec=arch_spec))
-
-
-def compiler_specs_for_arch(arch_spec, scope=None):
-    return [c.spec for c in compilers_for_arch(arch_spec, scope)]
-
-
-class CacheReference:
-    """This acts as a hashable reference to any object (regardless of whether
-    the object itself is hashable) and also prevents the object from being
-    garbage-collected (so if two CacheReference objects are equal, they
-    will refer to the same object, since it will not have been gc'ed since
-    the creation of the first CacheReference).
-    """
-
-    def __init__(self, val):
-        self.val = val
-        self.id = id(val)
-
-    def __hash__(self):
-        return self.id
-
-    def __eq__(self, other):
-        return isinstance(other, CacheReference) and self.id == other.id
-
-
-def compiler_from_dict(items):
-    cspec = spack.spec.parse_with_version_concrete(items["spec"], compiler=True)
-    os = items.get("operating_system", None)
-    target = items.get("target", None)
-
-    if not (
-        "paths" in items and all(n in items["paths"] for n in spack.compiler.PATH_INSTANCE_VARS)
-    ):
-        raise InvalidCompilerConfigurationError(cspec)
-
-    cls = class_for_compiler_name(cspec.name)
-
-    compiler_paths = []
-    for c in spack.compiler.PATH_INSTANCE_VARS:
-        compiler_path = items["paths"][c]
-        if compiler_path != "None":
-            compiler_paths.append(compiler_path)
-        else:
-            compiler_paths.append(None)
-
-    mods = items.get("modules")
-    if mods == "None":
-        mods = []
-
-    alias = items.get("alias", None)
-    compiler_flags = items.get("flags", {})
-    environment = items.get("environment", {})
-    extra_rpaths = items.get("extra_rpaths", [])
-    implicit_rpaths = items.get("implicit_rpaths", None)
-
-    # Starting with c22a145, 'implicit_rpaths' was a list. Now it is a
-    # boolean which can be set by the user to disable all automatic
-    # RPATH insertion of compiler libraries
-    if implicit_rpaths is not None and not isinstance(implicit_rpaths, bool):
-        implicit_rpaths = None
-
-    return cls(
-        cspec,
-        os,
-        target,
-        compiler_paths,
-        mods,
-        alias,
-        environment,
-        extra_rpaths,
-        enable_implicit_rpaths=implicit_rpaths,
-        **compiler_flags,
-    )
-
-
-def _compiler_from_config_entry(items):
-    """Note this is intended for internal use only. To avoid re-parsing
-    the same config dictionary this keeps track of its location in
-    memory. If you provide the same dictionary twice it will return
-    the same Compiler object (regardless of whether the dictionary
-    entries have changed).
-    """
-    config_id = CacheReference(items)
-    compiler = _compiler_cache.get(config_id, None)
-
-    if compiler is None:
-        try:
-            compiler = compiler_from_dict(items)
-        except UnknownCompilerError as e:
-            warnings.warn(e.message)
-        _compiler_cache[config_id] = compiler
-
-    return compiler
-
-
-def get_compilers(config, cspec=None, arch_spec=None):
-    compilers = []
-
-    for items in config:
-        items = items["compiler"]
-
-        # We might use equality here.
-        if cspec and not spack.spec.parse_with_version_concrete(
-            items["spec"], compiler=True
-        ).satisfies(cspec):
-            continue
-
-        # If an arch spec is given, confirm that this compiler
-        # is for the given operating system
-        os = items.get("operating_system", None)
-        if arch_spec and os != arch_spec.os:
-            continue
-
-        # If an arch spec is given, confirm that this compiler
-        # is for the given target. If the target is 'any', match
-        # any given arch spec. If the compiler has no assigned
-        # target this is an old compiler config file, skip this logic.
-        target = items.get("target", None)
-
-        try:
-            current_target = archspec.cpu.TARGETS[str(arch_spec.target)]
-            family = str(current_target.family)
-        except KeyError:
-            # TODO: Check if this exception handling makes sense, or if we
-            # TODO: need to change / refactor tests
-            family = str(arch_spec.target)
-        except AttributeError:
-            assert arch_spec is None
-
-        if arch_spec and target and (target != family and target != "any"):
-            # If the family of the target is the family we are seeking,
-            # there's an error in the underlying configuration
-            if archspec.cpu.TARGETS[target].family == family:
-                msg = (
-                    'the "target" field in compilers.yaml accepts only '
-                    'target families [replace "{0}" with "{1}"'
-                    ' in "{2}" specification]'
-                )
-                msg = msg.format(str(target), family, items.get("spec", "??"))
-                raise ValueError(msg)
-            continue
-
-        compiler = _compiler_from_config_entry(items)
-        if compiler:
-            compilers.append(compiler)
-
-    return compilers
-
-
-@_auto_compiler_spec
-def compiler_for_spec(compiler_spec, arch_spec):
-    """Get the compiler that satisfies compiler_spec.  compiler_spec must
-    be concrete."""
-    assert compiler_spec.concrete
-    assert arch_spec.concrete
-
-    compilers = compilers_for_spec(compiler_spec, arch_spec=arch_spec)
-    if len(compilers) < 1:
-        raise NoCompilerForSpecError(compiler_spec, arch_spec.os)
-    if len(compilers) > 1:
-        msg = "Multiple definitions of compiler %s " % compiler_spec
-        msg += "for architecture %s:\n %s" % (arch_spec, compilers)
-        tty.debug(msg)
-    return compilers[0]
-
-
-@llnl.util.lang.memoized
-def class_for_compiler_name(compiler_name):
-    """Given a compiler module name, get the corresponding Compiler class."""
-    if not supported(compiler_name):
-        raise UnknownCompilerError(compiler_name)
-
-    # Hack to be able to call the compiler `apple-clang` while still
-    # using a valid python name for the module
-    submodule_name = compiler_name
-    if compiler_name == "apple-clang":
-        submodule_name = compiler_name.replace("-", "_")
-
-    module_name = ".".join(["spack", "compilers", submodule_name])
-    module_obj = importlib.import_module(module_name)
-    cls = getattr(module_obj, mod_to_class(compiler_name))
-
-    # make a note of the name in the module so we can get to it easily.
-    cls.name = compiler_name
-
-    return cls
-
-
-def all_compiler_types():
-    return [class_for_compiler_name(c) for c in supported_compilers()]
-
-
-def is_mixed_toolchain(compiler):
-    """Returns True if the current compiler is a mixed toolchain,
-    False otherwise.
-
-    Args:
-        compiler (spack.compiler.Compiler): a valid compiler object
-    """
-    import spack.detection.path
-
-    executables = [
-        os.path.basename(compiler.cc or ""),
-        os.path.basename(compiler.cxx or ""),
-        os.path.basename(compiler.f77 or ""),
-        os.path.basename(compiler.fc or ""),
-    ]
-
-    toolchains = set()
-    finder = spack.detection.path.ExecutablesFinder()
-
-    for pkg_name in spack.repo.PATH.packages_with_tags(COMPILER_TAG):
-        pkg_cls = spack.repo.PATH.get_pkg_class(pkg_name)
-        patterns = finder.search_patterns(pkg=pkg_cls)
-        if not patterns:
-            continue
-        joined_pattern = re.compile(r"|".join(patterns))
-
-        if any(joined_pattern.search(exe) for exe in executables):
-            tty.debug(f"[TOOLCHAIN] MATCH {pkg_name}")
-            toolchains.add(pkg_name)
-
-    if len(toolchains) > 1:
-        if (
-            toolchains == {"llvm", "apple-clang", "aocc"}
-            # Msvc toolchain uses Intel ifx
-            or toolchains == {"msvc", "intel-oneapi-compilers"}
-        ):
-            return False
-        tty.debug("[TOOLCHAINS] {0}".format(toolchains))
-        return True
-
-    return False
-
-
-_EXTRA_ATTRIBUTES_KEY = "extra_attributes"
-_COMPILERS_KEY = "compilers"
-_C_KEY = "c"
-_CXX_KEY, _FORTRAN_KEY = "cxx", "fortran"
-
-
-class CompilerConfigFactory:
-    """Class aggregating all ways of constructing a list of compiler config entries."""
-
-    @staticmethod
-    def from_specs(specs: List["spack.spec.Spec"]) -> List[dict]:
-        result = []
-        compiler_package_names = supported_compilers() + list(package_name_to_compiler_name.keys())
-        for s in specs:
-            if s.name not in compiler_package_names:
-                continue
-
-            candidate = CompilerConfigFactory.from_external_spec(s)
-            if candidate is None:
-                continue
-
-            result.append(candidate)
-        return result
-
-    @staticmethod
-    def from_packages_yaml(packages_yaml) -> List[dict]:
-        compiler_specs = []
-        compiler_package_names = supported_compilers() + list(package_name_to_compiler_name.keys())
-        for name, entry in packages_yaml.items():
-            if name not in compiler_package_names:
-                continue
-
-            externals_config = entry.get("externals", None)
-            if not externals_config:
-                continue
-
-            current_specs = []
-            for current_external in externals_config:
-                compiler = CompilerConfigFactory._spec_from_external_config(current_external)
-                if compiler:
-                    current_specs.append(compiler)
-            compiler_specs.extend(current_specs)
-
-        return CompilerConfigFactory.from_specs(compiler_specs)
-
-    @staticmethod
-    def _spec_from_external_config(config):
-        # Allow `@x.y.z` instead of `@=x.y.z`
-        err_header = f"The external spec '{config['spec']}' cannot be used as a compiler"
-        # If extra_attributes is not there I might not want to use this entry as a compiler,
-        # therefore just leave a debug message, but don't be loud with a warning.
-        if _EXTRA_ATTRIBUTES_KEY not in config:
-            tty.debug(f"[{__file__}] {err_header}: missing the '{_EXTRA_ATTRIBUTES_KEY}' key")
-            return None
-        extra_attributes = config[_EXTRA_ATTRIBUTES_KEY]
-        result = spack.spec.Spec(
-            str(spack.spec.parse_with_version_concrete(config["spec"])),
-            external_modules=config.get("modules"),
-        )
-        result.extra_attributes = extra_attributes
-        return result
-
-    @staticmethod
-    def from_external_spec(spec: "spack.spec.Spec") -> Optional[dict]:
-        spec = spack.spec.parse_with_version_concrete(spec)
-        extra_attributes = getattr(spec, _EXTRA_ATTRIBUTES_KEY, None)
-        if extra_attributes is None:
-            return None
-
-        paths = CompilerConfigFactory._extract_compiler_paths(spec)
-        if paths is None:
-            return None
-
-        compiler_spec = spack.spec.CompilerSpec(
-            package_name_to_compiler_name.get(spec.name, spec.name), spec.version
-        )
-
-        operating_system, target = CompilerConfigFactory._extract_os_and_target(spec)
-
-        compiler_entry = {
-            "compiler": {
-                "spec": str(compiler_spec),
-                "paths": paths,
-                "flags": extra_attributes.get("flags", {}),
-                "operating_system": str(operating_system),
-                "target": str(target.family),
-                "modules": getattr(spec, "external_modules", []),
-                "environment": extra_attributes.get("environment", {}),
-                "extra_rpaths": extra_attributes.get("extra_rpaths", []),
-                "implicit_rpaths": extra_attributes.get("implicit_rpaths", None),
-            }
-        }
-        return compiler_entry
-
-    @staticmethod
-    def _extract_compiler_paths(spec: "spack.spec.Spec") -> Optional[Dict[str, str]]:
-        err_header = f"The external spec '{spec}' cannot be used as a compiler"
-        extra_attributes = spec.extra_attributes
-        # If I have 'extra_attributes' warn if 'compilers' is missing,
-        # or we don't have a C compiler
-        if _COMPILERS_KEY not in extra_attributes:
-            warnings.warn(
-                f"{err_header}: missing the '{_COMPILERS_KEY}' key under '{_EXTRA_ATTRIBUTES_KEY}'"
-            )
-            return None
-        attribute_compilers = extra_attributes[_COMPILERS_KEY]
-
-        if _C_KEY not in attribute_compilers:
-            warnings.warn(
-                f"{err_header}: missing the C compiler path under "
-                f"'{_EXTRA_ATTRIBUTES_KEY}:{_COMPILERS_KEY}'"
-            )
-            return None
-        c_compiler = attribute_compilers[_C_KEY]
-
-        # C++ and Fortran compilers are not mandatory, so let's just leave a debug trace
-        if _CXX_KEY not in attribute_compilers:
-            tty.debug(f"[{__file__}] The external spec {spec} does not have a C++ compiler")
-
-        if _FORTRAN_KEY not in attribute_compilers:
-            tty.debug(f"[{__file__}] The external spec {spec} does not have a Fortran compiler")
-
-        # compilers format has cc/fc/f77, externals format has "c/fortran"
-        return {
-            "cc": c_compiler,
-            "cxx": attribute_compilers.get(_CXX_KEY, None),
-            "fc": attribute_compilers.get(_FORTRAN_KEY, None),
-            "f77": attribute_compilers.get(_FORTRAN_KEY, None),
-        }
-
-    @staticmethod
-    def _extract_os_and_target(spec: "spack.spec.Spec"):
-        if not spec.architecture:
-            host_platform = spack.platforms.host()
-            operating_system = host_platform.operating_system("default_os")
-            target = host_platform.target("default_target")
-        else:
-            target = spec.architecture.target
-            if not target:
-                target = spack.platforms.host().target("default_target")
-
-            operating_system = spec.os
-            if not operating_system:
-                host_platform = spack.platforms.host()
-                operating_system = host_platform.operating_system("default_os")
-        return operating_system, target
-
-
-class InvalidCompilerConfigurationError(spack.error.SpackError):
-    def __init__(self, compiler_spec):
-        super().__init__(
-            f'Invalid configuration for [compiler "{compiler_spec}"]: ',
-            f"Compiler configuration must contain entries for "
-            f"all compilers: {spack.compiler.PATH_INSTANCE_VARS}",
-        )
-
-
-class UnknownCompilerError(spack.error.SpackError):
-    def __init__(self, compiler_name):
-        super().__init__("Spack doesn't support the requested compiler: {0}".format(compiler_name))
-
-
-class NoCompilerForSpecError(spack.error.SpackError):
-    def __init__(self, compiler_spec, target):
-        super().__init__(
-            "No compilers for operating system %s satisfy spec %s" % (target, compiler_spec)
-        )

lib/spack/spack/compilers/adaptor.py

@@ -0,0 +1,212 @@
+# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+# Spack Project Developers. See the top-level COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+import enum
+import typing
+from typing import Dict, List
+
+from llnl.util import lang
+
+from .libraries import CompilerPropertyDetector
+
+if typing.TYPE_CHECKING:
+    import spack.spec
+
+
+class Languages(enum.Enum):
+    C = "c"
+    CXX = "cxx"
+    FORTRAN = "fortran"
+
+
+class CompilerAdaptor:
+    def __init__(
+        self, compiled_spec: "spack.spec.Spec", compilers: Dict[Languages, "spack.spec.Spec"]
+    ) -> None:
+        if not compilers:
+            raise AttributeError(f"{compiled_spec} has no 'compiler' attribute")
+
+        self.compilers = compilers
+        self.compiled_spec = compiled_spec
+
+    def _lang_exists_or_raise(self, name: str, *, lang: Languages) -> None:
+        if lang not in self.compilers:
+            raise AttributeError(
+                f"'{self.compiled_spec}' has no {lang.value} compiler, so the "
+                f"'{name}' property cannot be retrieved"
+            )
+
+    def _maybe_return_attribute(self, name: str, *, lang: Languages) -> str:
+        self._lang_exists_or_raise(name, lang=lang)
+        return getattr(self.compilers[lang].package, name)
+
+    @property
+    def cc_rpath_arg(self) -> str:
+        self._lang_exists_or_raise("cc_rpath_arg", lang=Languages.C)
+        return self.compilers[Languages.C].package.rpath_arg
+
+    @property
+    def cxx_rpath_arg(self) -> str:
+        self._lang_exists_or_raise("cxx_rpath_arg", lang=Languages.CXX)
+        return self.compilers[Languages.CXX].package.rpath_arg
+
+    @property
+    def fc_rpath_arg(self) -> str:
+        self._lang_exists_or_raise("fc_rpath_arg", lang=Languages.FORTRAN)
+        return self.compilers[Languages.FORTRAN].package.rpath_arg
+
+    @property
+    def f77_rpath_arg(self) -> str:
+        self._lang_exists_or_raise("f77_rpath_arg", lang=Languages.FORTRAN)
+        return self.compilers[Languages.FORTRAN].package.rpath_arg
+
+    @property
+    def linker_arg(self) -> str:
+        return self._maybe_return_attribute("linker_arg", lang=Languages.C)
+
+    @property
+    def name(self):
+        return next(iter(self.compilers.values())).name
+
+    @property
+    def version(self):
+        return next(iter(self.compilers.values())).version
+
+    def implicit_rpaths(self) -> List[str]:
+        result, seen = [], set()
+        for compiler in self.compilers.values():
+            if compiler in seen:
+                continue
+            seen.add(compiler)
+            result.extend(CompilerPropertyDetector(compiler).implicit_rpaths())
+        return result
+
+    @property
+    def openmp_flag(self) -> str:
+        return next(iter(self.compilers.values())).package.openmp_flag
+
+    @property
+    def cxx98_flag(self) -> str:
+        return self.compilers[Languages.CXX].package.standard_flag(
+            language=Languages.CXX.value, standard="98"
+        )
+
+    @property
+    def cxx11_flag(self) -> str:
+        return self.compilers[Languages.CXX].package.standard_flag(
+            language=Languages.CXX.value, standard="11"
+        )
+
+    @property
+    def cxx14_flag(self) -> str:
+        return self.compilers[Languages.CXX].package.standard_flag(
+            language=Languages.CXX.value, standard="14"
+        )
+
+    @property
+    def cxx17_flag(self) -> str:
+        return self.compilers[Languages.CXX].package.standard_flag(
+            language=Languages.CXX.value, standard="17"
+        )
+
+    @property
+    def cxx20_flag(self) -> str:
+        return self.compilers[Languages.CXX].package.standard_flag(
+            language=Languages.CXX.value, standard="20"
+        )
+
+    @property
+    def cxx23_flag(self) -> str:
+        return self.compilers[Languages.CXX].package.standard_flag(
+            language=Languages.CXX.value, standard="23"
+        )
+
+    @property
+    def c99_flag(self) -> str:
+        return self.compilers[Languages.C].package.standard_flag(
+            language=Languages.C.value, standard="99"
+        )
+
+    @property
+    def c11_flag(self) -> str:
+        return self.compilers[Languages.C].package.standard_flag(
+            language=Languages.C.value, standard="11"
+        )
+
+    @property
+    def c17_flag(self) -> str:
+        return self.compilers[Languages.C].package.standard_flag(
+            language=Languages.C.value, standard="17"
+        )
+
+    @property
+    def c23_flag(self) -> str:
+        return self.compilers[Languages.C].package.standard_flag(
+            language=Languages.C.value, standard="17"
+        )
+
+    @property
+    def cc_pic_flag(self) -> str:
+        self._lang_exists_or_raise("cc_pic_flag", lang=Languages.C)
+        return self.compilers[Languages.C].package.pic_flag
+
+    @property
+    def cxx_pic_flag(self) -> str:
+        self._lang_exists_or_raise("cxx_pic_flag", lang=Languages.CXX)
+        return self.compilers[Languages.CXX].package.pic_flag
+
+    @property
+    def fc_pic_flag(self) -> str:
+        self._lang_exists_or_raise("fc_pic_flag", lang=Languages.FORTRAN)
+        return self.compilers[Languages.FORTRAN].package.pic_flag
+
+    @property
+    def f77_pic_flag(self) -> str:
+        self._lang_exists_or_raise("f77_pic_flag", lang=Languages.FORTRAN)
+        return self.compilers[Languages.FORTRAN].package.pic_flag
+
+    @property
+    def prefix(self) -> str:
+        return next(iter(self.compilers.values())).prefix
+
+    @property
+    def extra_rpaths(self) -> List[str]:
+        compiler = next(iter(self.compilers.values()))
+        return getattr(compiler, "extra_attributes", {}).get("extra_rpaths", [])
+
+    @property
+    def cc(self):
+        return self._maybe_return_attribute("cc", lang=Languages.C)
+
+    @property
+    def cxx(self):
+        return self._maybe_return_attribute("cxx", lang=Languages.CXX)
+
+    @property
+    def fc(self):
+        self._lang_exists_or_raise("fc", lang=Languages.FORTRAN)
+        return self.compilers[Languages.FORTRAN].package.fortran
+
+    @property
+    def f77(self):
+        self._lang_exists_or_raise("f77", lang=Languages.FORTRAN)
+        return self.compilers[Languages.FORTRAN].package.fortran
+
+
+class DeprecatedCompiler(lang.DeprecatedProperty):
+    def __init__(self) -> None:
+        super().__init__(name="compiler")
+
+    def factory(self, instance, owner) -> CompilerAdaptor:
+        spec = instance.spec
+        if not spec.concrete:
+            raise ValueError("Can only get a compiler for a concrete package.")
+
+        compilers = {}
+        for language in Languages:
+            deps = spec.dependencies(virtuals=[language.value])
+            if deps:
+                compilers[language] = deps[0]
+
+        return CompilerAdaptor(instance, compilers)

lib/spack/spack/compilers/aocc.py

@@ -1,120 +0,0 @@
-# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-# Spack Project Developers. See the top-level COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-import os
-import re
-
-import llnl.util.lang
-
-from spack.compiler import Compiler
-from spack.version import ver
-
-
-class Aocc(Compiler):
-    version_argument = "--version"
-
-    @property
-    def debug_flags(self):
-        return [
-            "-gcodeview",
-            "-gdwarf-2",
-            "-gdwarf-3",
-            "-gdwarf-4",
-            "-gdwarf-5",
-            "-gline-tables-only",
-            "-gmodules",
-            "-g",
-        ]
-
-    @property
-    def opt_flags(self):
-        return ["-O0", "-O1", "-O2", "-O3", "-Ofast", "-Os", "-Oz", "-Og", "-O", "-O4"]
-
-    @property
-    def link_paths(self):
-        link_paths = {
-            "cc": os.path.join("aocc", "clang"),
-            "cxx": os.path.join("aocc", "clang++"),
-            "f77": os.path.join("aocc", "flang"),
-            "fc": os.path.join("aocc", "flang"),
-        }
-
-        return link_paths
-
-    @property
-    def verbose_flag(self):
-        return "-v"
-
-    @property
-    def openmp_flag(self):
-        return "-fopenmp"
-
-    @property
-    def cxx11_flag(self):
-        return "-std=c++11"
-
-    @property
-    def cxx14_flag(self):
-        return "-std=c++14"
-
-    @property
-    def cxx17_flag(self):
-        return "-std=c++17"
-
-    @property
-    def c99_flag(self):
-        return "-std=c99"
-
-    @property
-    def c11_flag(self):
-        return "-std=c11"
-
-    @property
-    def cc_pic_flag(self):
-        return "-fPIC"
-
-    @property
-    def cxx_pic_flag(self):
-        return "-fPIC"
-
-    @property
-    def f77_pic_flag(self):
-        return "-fPIC"
-
-    @property
-    def fc_pic_flag(self):
-        return "-fPIC"
-
-    required_libs = ["libclang"]
-
-    @classmethod
-    @llnl.util.lang.memoized
-    def extract_version_from_output(cls, output):
-        match = re.search(r"AOCC_(\d+)[._](\d+)[._](\d+)", output)
-        if match:
-            return ".".join(match.groups())
-        return "unknown"
-
-    @property
-    def stdcxx_libs(self):
-        return ("-lstdc++",)
-
-    @property
-    def cflags(self):
-        return self._handle_default_flag_addtions()
-
-    @property
-    def cxxflags(self):
-        return self._handle_default_flag_addtions()
-
-    @property
-    def fflags(self):
-        return self._handle_default_flag_addtions()
-
-    def _handle_default_flag_addtions(self):
-        # This is a known issue for AOCC 3.0 see:
-        # https://developer.amd.com/wp-content/resources/AOCC-3.0-Install-Guide.pdf
-        if self.version.satisfies(ver("3.0.0")):
-            return "-Wno-unused-command-line-argument " "-mllvm -eliminate-similar-expr=false"

lib/spack/spack/compilers/apple_clang.py

@@ -1,116 +0,0 @@
-# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-# Spack Project Developers. See the top-level COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-import re
-
-import llnl.util.lang
-
-import spack.compiler
-import spack.compilers.clang
-from spack.version import Version
-
-
-class AppleClang(spack.compilers.clang.Clang):
-    openmp_flag = "-Xpreprocessor -fopenmp"
-
-    @classmethod
-    @llnl.util.lang.memoized
-    def extract_version_from_output(cls, output):
-        ver = "unknown"
-        match = re.search(
-            # Apple's LLVM compiler has its own versions, so suffix them.
-            r"^Apple (?:LLVM|clang) version ([^ )]+)",
-            output,
-            # Multi-line, since 'Apple clang' may not be on the first line
-            # in particular, when run as gcc, it seems to output
-            # "Configured with: --prefix=..." as the first line
-            re.M,
-        )
-        if match:
-            ver = match.group(match.lastindex)
-        return ver
-
-    # C++ flags based on CMake Modules/Compiler/AppleClang-CXX.cmake
-
-    @property
-    def cxx11_flag(self):
-        # Spack's AppleClang detection only valid from Xcode >= 4.6
-        if self.real_version < Version("4.0"):
-            raise spack.compiler.UnsupportedCompilerFlag(
-                self, "the C++11 standard", "cxx11_flag", "Xcode < 4.0"
-            )
-        return "-std=c++11"
-
-    @property
-    def cxx14_flag(self):
-        if self.real_version < Version("5.1"):
-            raise spack.compiler.UnsupportedCompilerFlag(
-                self, "the C++14 standard", "cxx14_flag", "Xcode < 5.1"
-            )
-        elif self.real_version < Version("6.1"):
-            return "-std=c++1y"
-
-        return "-std=c++14"
-
-    @property
-    def cxx17_flag(self):
-        if self.real_version < Version("6.1"):
-            raise spack.compiler.UnsupportedCompilerFlag(
-                self, "the C++17 standard", "cxx17_flag", "Xcode < 6.1"
-            )
-        elif self.real_version < Version("10.0"):
-            return "-std=c++1z"
-        return "-std=c++17"
-
-    @property
-    def cxx20_flag(self):
-        if self.real_version < Version("10.0"):
-            raise spack.compiler.UnsupportedCompilerFlag(
-                self, "the C++20 standard", "cxx20_flag", "Xcode < 10.0"
-            )
-        elif self.real_version < Version("13.0"):
-            return "-std=c++2a"
-        return "-std=c++20"
-
-    @property
-    def cxx23_flag(self):
-        if self.real_version < Version("13.0"):
-            raise spack.compiler.UnsupportedCompilerFlag(
-                self, "the C++23 standard", "cxx23_flag", "Xcode < 13.0"
-            )
-        return "-std=c++2b"
-
-    # C flags based on CMake Modules/Compiler/AppleClang-C.cmake
-
-    @property
-    def c99_flag(self):
-        if self.real_version < Version("4.0"):
-            raise spack.compiler.UnsupportedCompilerFlag(
-                self, "the C99 standard", "c99_flag", "< 4.0"
-            )
-        return "-std=c99"
-
-    @property
-    def c11_flag(self):
-        if self.real_version < Version("4.0"):
-            raise spack.compiler.UnsupportedCompilerFlag(
-                self, "the C11 standard", "c11_flag", "< 4.0"
-            )
-        return "-std=c11"
-
-    @property
-    def c17_flag(self):
-        if self.real_version < Version("11.0"):
-            raise spack.compiler.UnsupportedCompilerFlag(
-                self, "the C17 standard", "c17_flag", "< 11.0"
-            )
-        return "-std=c17"
-
-    @property
-    def c23_flag(self):
-        if self.real_version < Version("11.0.3"):
-            raise spack.compiler.UnsupportedCompilerFlag(
-                self, "the C23 standard", "c23_flag", "< 11.0.3"
-            )
-        return "-std=c2x"

lib/spack/spack/compilers/arm.py

@@ -1,80 +0,0 @@
-# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-# Spack Project Developers. See the top-level COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-import os
-
-import spack.compiler
-
-
-class Arm(spack.compiler.Compiler):
-    # Named wrapper links within lib/spack/env
-    link_paths = {
-        "cc": os.path.join("arm", "armclang"),
-        "cxx": os.path.join("arm", "armclang++"),
-        "f77": os.path.join("arm", "armflang"),
-        "fc": os.path.join("arm", "armflang"),
-    }
-
-    # The ``--version`` option seems to be the most consistent one for
-    # arm compilers. Output looks like this:
-    #
-    # $ arm<c/f>lang --version
-    # Arm C/C++/Fortran Compiler version 19.0 (build number 73) (based on LLVM 7.0.2)
-    # Target: aarch64--linux-gnu
-    # Thread model: posix
-    # InstalledDir:
-    # /opt/arm/arm-hpc-compiler-19.0_Generic-AArch64_RHEL-7_aarch64-linux/bin
-    version_argument = "--version"
-    version_regex = r"Arm C\/C\+\+\/Fortran Compiler version ([\d\.]+) "
-
-    @property
-    def verbose_flag(self):
-        return "-v"
-
-    @property
-    def opt_flags(self):
-        return ["-O", "-O0", "-O1", "-O2", "-O3", "-Ofast"]
-
-    @property
-    def openmp_flag(self):
-        return "-fopenmp"
-
-    @property
-    def cxx11_flag(self):
-        return "-std=c++11"
-
-    @property
-    def cxx14_flag(self):
-        return "-std=c++14"
-
-    @property
-    def cxx17_flag(self):
-        return "-std=c++1z"
-
-    @property
-    def c99_flag(self):
-        return "-std=c99"
-
-    @property
-    def c11_flag(self):
-        return "-std=c11"
-
-    @property
-    def cc_pic_flag(self):
-        return "-fPIC"
-
-    @property
-    def cxx_pic_flag(self):
-        return "-fPIC"
-
-    @property
-    def f77_pic_flag(self):
-        return "-fPIC"
-
-    @property
-    def fc_pic_flag(self):
-        return "-fPIC"
-
-    required_libs = ["libclang", "libflang"]

lib/spack/spack/compilers/cce.py

@@ -1,128 +0,0 @@
-# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-# Spack Project Developers. See the top-level COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-import os
-
-from spack.compiler import Compiler, UnsupportedCompilerFlag
-from spack.version import Version
-
-
-class Cce(Compiler):
-    """Cray compiler environment compiler."""
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        # For old cray compilers on module based systems we replace
-        # ``version_argument`` with the old value. Cannot be a property
-        # as the new value is used in classmethods for path-based detection
-        if not self.is_clang_based:
-            self.version_argument = "-V"
-
-    # MacPorts builds gcc versions with prefixes and -mp-X.Y suffixes.
-    suffixes = [r"-mp-\d\.\d"]
-
-    @property
-    def link_paths(self):
-        if any("PrgEnv-cray" in m for m in self.modules):
-            # Old module-based interface to cray compilers
-            return {
-                "cc": os.path.join("cce", "cc"),
-                "cxx": os.path.join("case-insensitive", "CC"),
-                "f77": os.path.join("cce", "ftn"),
-                "fc": os.path.join("cce", "ftn"),
-            }
-
-        return {
-            "cc": os.path.join("cce", "craycc"),
-            "cxx": os.path.join("cce", "case-insensitive", "crayCC"),
-            "f77": os.path.join("cce", "crayftn"),
-            "fc": os.path.join("cce", "crayftn"),
-        }
-
-    @property
-    def is_clang_based(self):
-        version = self._real_version or self.version
-        return version >= Version("9.0") and "classic" not in str(version)
-
-    version_argument = "--version"
-    version_regex = r"[Cc]ray (?:clang|C :|C\+\+ :|Fortran :) [Vv]ersion.*?(\d+(\.\d+)+)"
-
-    @property
-    def verbose_flag(self):
-        return "-v"
-
-    @property
-    def debug_flags(self):
-        return ["-g", "-G0", "-G1", "-G2", "-Gfast"]
-
-    @property
-    def openmp_flag(self):
-        if self.is_clang_based:
-            return "-fopenmp"
-        return "-h omp"
-
-    @property
-    def cxx11_flag(self):
-        if self.is_clang_based:
-            return "-std=c++11"
-        return "-h std=c++11"
-
-    @property
-    def cxx14_flag(self):
-        if self.is_clang_based:
-            return "-std=c++14"
-        return "-h std=c++14"
-
-    @property
-    def cxx17_flag(self):
-        if self.is_clang_based:
-            return "-std=c++17"
-
-    @property
-    def c99_flag(self):
-        if self.is_clang_based:
-            return "-std=c99"
-        elif self.real_version >= Version("8.4"):
-            return "-h std=c99,noconform,gnu"
-        elif self.real_version >= Version("8.1"):
-            return "-h c99,noconform,gnu"
-        raise UnsupportedCompilerFlag(self, "the C99 standard", "c99_flag", "< 8.1")
-
-    @property
-    def c11_flag(self):
-        if self.is_clang_based:
-            return "-std=c11"
-        elif self.real_version >= Version("8.5"):
-            return "-h std=c11,noconform,gnu"
-        raise UnsupportedCompilerFlag(self, "the C11 standard", "c11_flag", "< 8.5")
-
-    @property
-    def cc_pic_flag(self):
-        if self.is_clang_based:
-            return "-fPIC"
-        return "-h PIC"
-
-    @property
-    def cxx_pic_flag(self):
-        if self.is_clang_based:
-            return "-fPIC"
-        return "-h PIC"
-
-    @property
-    def f77_pic_flag(self):
-        if self.is_clang_based:
-            return "-fPIC"
-        return "-h PIC"
-
-    @property
-    def fc_pic_flag(self):
-        if self.is_clang_based:
-            return "-fPIC"
-        return "-h PIC"
-
-    @property
-    def stdcxx_libs(self):
-        # Cray compiler wrappers link to the standard C++ library
-        # without additional flags.
-        return ()

lib/spack/spack/compilers/clang.py

@@ -1,192 +0,0 @@
-# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-# Spack Project Developers. See the top-level COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-import os
-import re
-
-import llnl.util.lang
-
-from spack.compiler import Compiler, UnsupportedCompilerFlag
-from spack.version import Version
-
-#: compiler symlink mappings for mixed f77 compilers
-f77_mapping = [
-    ("gfortran", os.path.join("clang", "gfortran")),
-    ("xlf_r", os.path.join("xl_r", "xlf_r")),
-    ("xlf", os.path.join("xl", "xlf")),
-    ("ifort", os.path.join("intel", "ifort")),
-]
-
-#: compiler symlink mappings for mixed f90/fc compilers
-fc_mapping = [
-    ("gfortran", os.path.join("clang", "gfortran")),
-    ("xlf90_r", os.path.join("xl_r", "xlf90_r")),
-    ("xlf90", os.path.join("xl", "xlf90")),
-    ("ifort", os.path.join("intel", "ifort")),
-]
-
-
-class Clang(Compiler):
-    version_argument = "--version"
-
-    @property
-    def debug_flags(self):
-        return [
-            "-gcodeview",
-            "-gdwarf-2",
-            "-gdwarf-3",
-            "-gdwarf-4",
-            "-gdwarf-5",
-            "-gline-tables-only",
-            "-gmodules",
-            "-g",
-        ]
-
-    @property
-    def opt_flags(self):
-        return ["-O0", "-O1", "-O2", "-O3", "-Ofast", "-Os", "-Oz", "-Og", "-O", "-O4"]
-
-    # Clang has support for using different fortran compilers with the
-    # clang executable.
-    @property
-    def link_paths(self):
-        # clang links are always the same
-        link_paths = {
-            "cc": os.path.join("clang", "clang"),
-            "cxx": os.path.join("clang", "clang++"),
-        }
-
-        # fortran links need to look at the actual compiler names from
-        # compilers.yaml to figure out which named symlink to use
-        for compiler_name, link_path in f77_mapping:
-            if self.f77 and compiler_name in self.f77:
-                link_paths["f77"] = link_path
-                break
-        else:
-            link_paths["f77"] = os.path.join("clang", "flang")
-
-        for compiler_name, link_path in fc_mapping:
-            if self.fc and compiler_name in self.fc:
-                link_paths["fc"] = link_path
-                break
-        else:
-            link_paths["fc"] = os.path.join("clang", "flang")
-
-        return link_paths
-
-    @property
-    def verbose_flag(self):
-        return "-v"
-
-    openmp_flag = "-fopenmp"
-
-    # C++ flags based on CMake Modules/Compiler/Clang.cmake
-
-    @property
-    def cxx11_flag(self):
-        if self.real_version < Version("3.3"):
-            raise UnsupportedCompilerFlag(self, "the C++11 standard", "cxx11_flag", "< 3.3")
-        return "-std=c++11"
-
-    @property
-    def cxx14_flag(self):
-        if self.real_version < Version("3.4"):
-            raise UnsupportedCompilerFlag(self, "the C++14 standard", "cxx14_flag", "< 3.5")
-        elif self.real_version < Version("3.5"):
-            return "-std=c++1y"
-
-        return "-std=c++14"
-
-    @property
-    def cxx17_flag(self):
-        if self.real_version < Version("3.5"):
-            raise UnsupportedCompilerFlag(self, "the C++17 standard", "cxx17_flag", "< 3.5")
-        elif self.real_version < Version("5.0"):
-            return "-std=c++1z"
-
-        return "-std=c++17"
-
-    @property
-    def cxx20_flag(self):
-        if self.real_version < Version("5.0"):
-            raise UnsupportedCompilerFlag(self, "the C++20 standard", "cxx20_flag", "< 5.0")
-        elif self.real_version < Version("11.0"):
-            return "-std=c++2a"
-        else:
-            return "-std=c++20"
-
-    @property
-    def cxx23_flag(self):
-        if self.real_version < Version("12.0"):
-            raise UnsupportedCompilerFlag(self, "the C++23 standard", "cxx23_flag", "< 12.0")
-        elif self.real_version < Version("17.0"):
-            return "-std=c++2b"
-        else:
-            return "-std=c++23"
-
-    @property
-    def c99_flag(self):
-        return "-std=c99"
-
-    @property
-    def c11_flag(self):
-        if self.real_version < Version("3.0"):
-            raise UnsupportedCompilerFlag(self, "the C11 standard", "c11_flag", "< 3.0")
-        if self.real_version < Version("3.1"):
-            return "-std=c1x"
-        return "-std=c11"
-
-    @property
-    def c17_flag(self):
-        if self.real_version < Version("6.0"):
-            raise UnsupportedCompilerFlag(self, "the C17 standard", "c17_flag", "< 6.0")
-        return "-std=c17"
-
-    @property
-    def c23_flag(self):
-        if self.real_version < Version("9.0"):
-            raise UnsupportedCompilerFlag(self, "the C23 standard", "c23_flag", "< 9.0")
-        elif self.real_version < Version("18.0"):
-            return "-std=c2x"
-        else:
-            return "-std=c23"
-
-    @property
-    def cc_pic_flag(self):
-        return "-fPIC"
-
-    @property
-    def cxx_pic_flag(self):
-        return "-fPIC"
-
-    @property
-    def f77_pic_flag(self):
-        return "-fPIC"
-
-    @property
-    def fc_pic_flag(self):
-        return "-fPIC"
-
-    required_libs = ["libclang"]
-
-    @classmethod
-    @llnl.util.lang.memoized
-    def extract_version_from_output(cls, output):
-        ver = "unknown"
-        if ("Apple" in output) or ("AMD" in output):
-            return ver
-
-        match = re.search(
-            # Normal clang compiler versions are left as-is
-            r"(?:clang|flang-new) version ([^ )\n]+)-svn[~.\w\d-]*|"
-            # Don't include hyphenated patch numbers in the version
-            # (see https://github.com/spack/spack/pull/14365 for details)
-            r"(?:clang|flang-new) version ([^ )\n]+?)-[~.\w\d-]*|"
-            r"(?:clang|flang-new) version ([^ )\n]+)",
-            output,
-        )
-        if match:
-            ver = match.group(match.lastindex)
-        return ver

lib/spack/spack/compilers/config.py

@@ -0,0 +1,427 @@
+# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+# Spack Project Developers. See the top-level COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+"""This module contains functions related to finding compilers on the system,
+and configuring Spack to use multiple compilers.
+"""
+import os
+import re
+import sys
+import warnings
+from typing import Any, Dict, List, Optional, Tuple
+
+import archspec.cpu
+
+import llnl.util.filesystem as fs
+import llnl.util.lang
+import llnl.util.tty as tty
+
+import spack.config
+import spack.detection
+import spack.error
+import spack.platforms
+import spack.repo
+import spack.spec
+from spack.operating_systems import windows_os
+from spack.util.environment import get_path
+
+package_name_to_compiler_name = {
+    "llvm": "clang",
+    "intel-oneapi-compilers": "oneapi",
+    "llvm-amdgpu": "rocmcc",
+    "intel-oneapi-compilers-classic": "intel",
+    "acfl": "arm",
+}
+
+
+#: Tag used to identify packages providing a compiler
+COMPILER_TAG = "compiler"
+
+
+def compiler_config_files():
+    config_files = []
+    configuration = spack.config.CONFIG
+    for scope in configuration.writable_scopes:
+        name = scope.name
+
+        from_packages_yaml = CompilerFactory.from_packages_yaml(configuration, scope=name)
+        if from_packages_yaml:
+            config_files.append(configuration.get_config_filename(name, "packages"))
+
+        compiler_config = configuration.get("compilers", scope=name)
+        if compiler_config:
+            config_files.append(configuration.get_config_filename(name, "compilers"))
+
+    return config_files
+
+
+def add_compiler_to_config(new_compilers, *, scope=None) -> None:
+    """Add a Compiler object to the configuration, at the required scope."""
+    # FIXME (compiler as nodes): still needed to read Cray manifest
+    by_name: Dict[str, List["spack.spec.Spec"]] = {}
+    for x in new_compilers:
+        by_name.setdefault(x.name, []).append(x)
+
+    spack.detection.update_configuration(by_name, buildable=True, scope=scope)
+
+
+def find_compilers(
+    path_hints: Optional[List[str]] = None,
+    *,
+    scope: Optional[str] = None,
+    max_workers: Optional[int] = None,
+) -> List["spack.spec.Spec"]:
+    """Searches for compiler in the paths given as argument. If any new compiler is found, the
+    configuration is updated, and the list of new compiler objects is returned.
+
+    Args:
+        path_hints: list of path hints where to look for. A sensible default based on the ``PATH``
+            environment variable will be used if the value is None
+        scope: configuration scope to modify
+        max_workers: number of processes used to search for compilers
+    """
+    if path_hints is None:
+        path_hints = get_path("PATH")
+    default_paths = fs.search_paths_for_executables(*path_hints)
+    if sys.platform == "win32":
+        default_paths.extend(windows_os.WindowsOs().compiler_search_paths)
+    compiler_pkgs = spack.repo.PATH.packages_with_tags(COMPILER_TAG, full=True)
+
+    detected_packages = spack.detection.by_path(
+        compiler_pkgs, path_hints=default_paths, max_workers=max_workers
+    )
+
+    new_compilers = spack.detection.update_configuration(
+        detected_packages, buildable=True, scope=scope
+    )
+    return new_compilers
+
+
+def select_new_compilers(
+    candidates: List["spack.spec.Spec"], *, scope: Optional[str] = None
+) -> List["spack.spec.Spec"]:
+    """Given a list of compilers, remove those that are already defined in
+    the configuration.
+    """
+    compilers_in_config = all_compilers_from(configuration=spack.config.CONFIG, scope=scope)
+    return [c for c in candidates if c not in compilers_in_config]
+
+
+def supported_compilers() -> List[str]:
+    """Returns all the currently supported compiler packages"""
+    return sorted(spack.repo.PATH.packages_with_tags(COMPILER_TAG))
+
+
+def all_compilers(
+    scope: Optional[str] = None, init_config: bool = True
+) -> List["spack.spec.Spec"]:
+    """Returns all the compilers from the current global configuration.
+
+    Args:
+        scope: configuration scope from which to extract the compilers. If None, the merged
+            configuration is used.
+        init_config: if True, search for compilers if none is found in configuration.
+    """
+    compilers = all_compilers_from(configuration=spack.config.CONFIG, scope=scope)
+
+    if not compilers and init_config:
+        find_compilers(scope=scope)
+        compilers = all_compilers_from(configuration=spack.config.CONFIG, scope=scope)
+
+    return compilers
+
+
+def all_compilers_from(
+    configuration: "spack.config.ConfigurationType", scope: Optional[str] = None
+) -> List["spack.spec.Spec"]:
+    """Returns all the compilers from the current global configuration.
+
+    Args:
+        configuration: configuration to be queried
+        scope: configuration scope from which to extract the compilers. If None, the merged
+            configuration is used.
+    """
+    compilers = CompilerFactory.from_packages_yaml(configuration, scope=scope)
+
+    if os.environ.get("SPACK_EXPERIMENTAL_DEPRECATE_COMPILERS_YAML") != "1":
+        legacy_compilers = CompilerFactory.from_compilers_yaml(configuration, scope=scope)
+        if legacy_compilers:
+            # FIXME (compiler as nodes): write how to update the file. Maybe an ad-hoc command
+            warnings.warn(
+                "Some compilers are still defined in 'compilers.yaml', which has been deprecated "
+                "in v0.23. Those configuration files will be ignored from Spack v0.25.\n"
+            )
+            for legacy in legacy_compilers:
+                if not any(c.satisfies(f"{legacy.name}@{legacy.versions}") for c in compilers):
+                    compilers.append(legacy)
+
+    return compilers
+
+
+class CompilerRemover:
+    """Removes compiler from configuration."""
+
+    def __init__(self, configuration: "spack.config.ConfigurationType") -> None:
+        self.configuration = configuration
+        self.marked_packages_yaml: List[Tuple[str, Any]] = []
+        self.marked_compilers_yaml: List[Tuple[str, Any]] = []
+
+    def mark_compilers(
+        self, *, match: str, scope: Optional[str] = None
+    ) -> List["spack.spec.Spec"]:
+        """Marks compilers to be removed in configuration, and returns a corresponding list
+        of specs.
+
+        Args:
+            match: constraint that the compiler must match to be removed.
+            scope: scope where to remove the compiler. If None, all writeable scopes are checked.
+        """
+        self.marked_packages_yaml = []
+        self.marked_compilers_yaml = []
+        candidate_scopes = [scope]
+        if scope is None:
+            candidate_scopes = [x.name for x in self.configuration.writable_scopes]
+
+        all_removals = self._mark_in_packages_yaml(match, candidate_scopes)
+        all_removals.extend(self._mark_in_compilers_yaml(match, candidate_scopes))
+
+        return all_removals
+
+    def _mark_in_packages_yaml(self, match, candidate_scopes):
+        compiler_package_names = supported_compilers()
+        all_removals = []
+        for current_scope in candidate_scopes:
+            packages_yaml = self.configuration.get("packages", scope=current_scope)
+            if not packages_yaml:
+                continue
+
+            removed_from_scope = []
+            for name, entry in packages_yaml.items():
+                if name not in compiler_package_names:
+                    continue
+
+                externals_config = entry.get("externals", None)
+                if not externals_config:
+                    continue
+
+                def _partition_match(external_yaml):
+                    s = CompilerFactory.from_external_yaml(external_yaml)
+                    return not s.satisfies(match)
+
+                to_keep, to_remove = llnl.util.lang.stable_partition(
+                    externals_config, _partition_match
+                )
+                if not to_remove:
+                    continue
+
+                removed_from_scope.extend(to_remove)
+                entry["externals"] = to_keep
+
+            if not removed_from_scope:
+                continue
+
+            self.marked_packages_yaml.append((current_scope, packages_yaml))
+            all_removals.extend(
+                [CompilerFactory.from_external_yaml(x) for x in removed_from_scope]
+            )
+        return all_removals
+
+    def _mark_in_compilers_yaml(self, match, candidate_scopes):
+        if os.environ.get("SPACK_EXPERIMENTAL_DEPRECATE_COMPILERS_YAML") == "1":
+            return []
+
+        all_removals = []
+        for current_scope in candidate_scopes:
+            compilers_yaml = self.configuration.get("compilers", scope=current_scope)
+            if not compilers_yaml:
+                continue
+
+            def _partition_match(entry):
+                external_specs = CompilerFactory.from_legacy_yaml(entry["compiler"])
+                return not any(x.satisfies(match) for x in external_specs)
+
+            to_keep, to_remove = llnl.util.lang.stable_partition(compilers_yaml, _partition_match)
+            if not to_remove:
+                continue
+
+            compilers_yaml[:] = to_keep
+            self.marked_compilers_yaml.append((current_scope, compilers_yaml))
+            for entry in to_remove:
+                all_removals.extend(CompilerFactory.from_legacy_yaml(entry["compiler"]))
+
+        return all_removals
+
+    def flush(self):
+        """Removes from configuration the specs that have been marked by the previous call
+        of ``remove_compilers``.
+        """
+        for scope, packages_yaml in self.marked_packages_yaml:
+            self.configuration.set("packages", packages_yaml, scope=scope)
+
+        for scope, compilers_yaml in self.marked_compilers_yaml:
+            self.configuration.set("compilers", compilers_yaml, scope=scope)
+
+
+def compilers_for_spec(compiler_spec, *, arch_spec=None, scope=None, init_config=True):
+    """This gets all compilers that satisfy the supplied CompilerSpec.
+    Returns an empty list if none are found.
+    """
+    # FIXME (compiler as nodes): to be removed, or reimplemented
+    raise NotImplementedError("still to be implemented")
+
+
+def compilers_for_arch(
+    arch_spec: "spack.spec.ArchSpec", *, scope: Optional[str] = None
+) -> List["spack.spec.Spec"]:
+    """Returns the compilers that can be used on the input architecture"""
+    compilers = all_compilers_from(spack.config.CONFIG, scope=scope)
+    query = f"platform={arch_spec.platform} target=:{arch_spec.target}"
+    return [x for x in compilers if x.satisfies(query)]
+
+
+def class_for_compiler_name(compiler_name):
+    """Given a compiler module name, get the corresponding Compiler class."""
+    # FIXME (compiler as nodes): to be removed, or reimplemented
+    raise NotImplementedError("still to be implemented")
+
+
+_EXTRA_ATTRIBUTES_KEY = "extra_attributes"
+_COMPILERS_KEY = "compilers"
+_C_KEY = "c"
+_CXX_KEY, _FORTRAN_KEY = "cxx", "fortran"
+
+
+def name_os_target(spec: "spack.spec.Spec") -> Tuple[str, str, str]:
+    if not spec.architecture:
+        host_platform = spack.platforms.host()
+        operating_system = host_platform.operating_system("default_os")
+        target = host_platform.target("default_target")
+    else:
+        target = spec.architecture.target
+        if not target:
+            target = spack.platforms.host().target("default_target")
+        target = target
+
+        operating_system = spec.os
+        if not operating_system:
+            host_platform = spack.platforms.host()
+            operating_system = host_platform.operating_system("default_os")
+
+    return spec.name, str(operating_system), str(target)
+
+
+class CompilerFactory:
+    """Class aggregating all ways of constructing a list of compiler specs from config entries."""
+
+    _PACKAGES_YAML_CACHE: Dict[str, Optional["spack.spec.Spec"]] = {}
+    _COMPILERS_YAML_CACHE: Dict[str, List["spack.spec.Spec"]] = {}
+    _GENERIC_TARGET = None
+
+    @staticmethod
+    def from_packages_yaml(
+        configuration: "spack.config.ConfigurationType", *, scope: Optional[str] = None
+    ) -> List["spack.spec.Spec"]:
+        """Returns the compiler specs defined in the "packages" section of the configuration"""
+        compilers = []
+        compiler_package_names = supported_compilers()
+        packages_yaml = configuration.get("packages", scope=scope)
+        for name, entry in packages_yaml.items():
+            if name not in compiler_package_names:
+                continue
+
+            externals_config = entry.get("externals", None)
+            if not externals_config:
+                continue
+
+            compiler_specs = []
+            for current_external in externals_config:
+                key = str(current_external)
+                if key not in CompilerFactory._PACKAGES_YAML_CACHE:
+                    CompilerFactory._PACKAGES_YAML_CACHE[key] = CompilerFactory.from_external_yaml(
+                        current_external
+                    )
+
+                compiler = CompilerFactory._PACKAGES_YAML_CACHE[key]
+                if compiler:
+                    compiler_specs.append(compiler)
+
+            compilers.extend(compiler_specs)
+        return compilers
+
+    @staticmethod
+    def from_external_yaml(config: Dict[str, Any]) -> Optional["spack.spec.Spec"]:
+        """Returns a compiler spec from an external definition from packages.yaml."""
+        # Allow `@x.y.z` instead of `@=x.y.z`
+        err_header = f"The external spec '{config['spec']}' cannot be used as a compiler"
+        # If extra_attributes is not there I might not want to use this entry as a compiler,
+        # therefore just leave a debug message, but don't be loud with a warning.
+        if _EXTRA_ATTRIBUTES_KEY not in config:
+            tty.debug(f"[{__file__}] {err_header}: missing the '{_EXTRA_ATTRIBUTES_KEY}' key")
+            return None
+        extra_attributes = config[_EXTRA_ATTRIBUTES_KEY]
+        result = spack.spec.Spec(
+            str(spack.spec.parse_with_version_concrete(config["spec"])),
+            external_path=config.get("prefix"),
+            external_modules=config.get("modules"),
+        )
+        result.extra_attributes = extra_attributes
+        CompilerFactory._finalize_external_concretization(result)
+        return result
+
+    @staticmethod
+    def _finalize_external_concretization(abstract_spec):
+        if CompilerFactory._GENERIC_TARGET is None:
+            CompilerFactory._GENERIC_TARGET = archspec.cpu.host().family
+
+        if abstract_spec.architecture:
+            abstract_spec.architecture.complete_with_defaults()
+        else:
+            abstract_spec.constrain(spack.spec.Spec.default_arch())
+        abstract_spec.architecture.target = CompilerFactory._GENERIC_TARGET
+        abstract_spec._finalize_concretization()
+
+    @staticmethod
+    def from_legacy_yaml(compiler_dict: Dict[str, Any]) -> List["spack.spec.Spec"]:
+        """Returns a list of external specs, corresponding to a compiler entry
+        from compilers.yaml.
+        """
+        from spack.detection.path import ExecutablesFinder
+
+        # FIXME (compiler as nodes): should we look at targets too?
+        result = []
+        candidate_paths = [x for x in compiler_dict["paths"].values() if x is not None]
+        finder = ExecutablesFinder()
+
+        for pkg_name in spack.repo.PATH.packages_with_tags("compiler"):
+            pkg_cls = spack.repo.PATH.get_pkg_class(pkg_name)
+            pattern = re.compile(r"|".join(finder.search_patterns(pkg=pkg_cls)))
+            filtered_paths = [x for x in candidate_paths if pattern.search(os.path.basename(x))]
+            detected = finder.detect_specs(pkg=pkg_cls, paths=filtered_paths)
+            result.extend(detected)
+
+        for item in result:
+            CompilerFactory._finalize_external_concretization(item)
+
+        return result
+
+    @staticmethod
+    def from_compilers_yaml(
+        configuration: "spack.config.ConfigurationType", *, scope: Optional[str] = None
+    ) -> List["spack.spec.Spec"]:
+        """Returns the compiler specs defined in the "compilers" section of the configuration"""
+        result: List["spack.spec.Spec"] = []
+        for item in configuration.get("compilers", scope=scope):
+            key = str(item)
+            if key not in CompilerFactory._COMPILERS_YAML_CACHE:
+                CompilerFactory._COMPILERS_YAML_CACHE[key] = CompilerFactory.from_legacy_yaml(
+                    item["compiler"]
+                )
+
+            result.extend(CompilerFactory._COMPILERS_YAML_CACHE[key])
+        return result
+
+
+class UnknownCompilerError(spack.error.SpackError):
+    def __init__(self, compiler_name):
+        super().__init__(f"Spack doesn't support the requested compiler: {compiler_name}")

lib/spack/spack/compilers/error.py

@@ -0,0 +1,19 @@
+# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+# Spack Project Developers. See the top-level COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+from ..error import SpackError
+
+
+class CompilerAccessError(SpackError):
+    def __init__(self, compiler, paths):
+        super().__init__(
+            f"Compiler '{compiler.spec}' has executables that are missing"
+            f" or are not executable: {paths}"
+        )
+
+
+class UnsupportedCompilerFlag(SpackError):
+    """Raised when a compiler does not support a flag type (e.g. a flag to enforce a
+    language standard).
+    """

lib/spack/spack/compilers/fj.py

@@ -1,79 +0,0 @@
-# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-# Spack Project Developers. See the top-level COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-import os
-
-import spack.compiler
-
-
-class Fj(spack.compiler.Compiler):
-    # Named wrapper links within build_env_path
-    link_paths = {
-        "cc": os.path.join("fj", "fcc"),
-        "cxx": os.path.join("fj", "case-insensitive", "FCC"),
-        "f77": os.path.join("fj", "frt"),
-        "fc": os.path.join("fj", "frt"),
-    }
-
-    version_argument = "--version"
-    version_regex = r"\((?:FCC|FRT)\) ([a-z\d.]+)"
-
-    required_libs = ["libfj90i", "libfj90f", "libfjsrcinfo"]
-
-    @property
-    def verbose_flag(self):
-        return "-v"
-
-    @property
-    def debug_flags(self):
-        return "-g"
-
-    @property
-    def opt_flags(self):
-        return ["-O0", "-O1", "-O2", "-O3", "-Ofast"]
-
-    @property
-    def openmp_flag(self):
-        return "-Kopenmp"
-
-    @property
-    def cxx98_flag(self):
-        return "-std=c++98"
-
-    @property
-    def cxx11_flag(self):
-        return "-std=c++11"
-
-    @property
-    def cxx14_flag(self):
-        return "-std=c++14"
-
-    @property
-    def cxx17_flag(self):
-        return "-std=c++17"
-
-    @property
-    def c99_flag(self):
-        return "-std=c99"
-
-    @property
-    def c11_flag(self):
-        return "-std=c11"
-
-    @property
-    def cc_pic_flag(self):
-        return "-KPIC"
-
-    @property
-    def cxx_pic_flag(self):
-        return "-KPIC"
-
-    @property
-    def f77_pic_flag(self):
-        return "-KPIC"
-
-    @property
-    def fc_pic_flag(self):
-        return "-KPIC"

lib/spack/spack/compilers/flags.py

@@ -0,0 +1,26 @@
+# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+# Spack Project Developers. See the top-level COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+from typing import List, Tuple
+
+
+def tokenize_flags(flags_values: str, propagate: bool = False) -> List[Tuple[str, bool]]:
+    """Given a compiler flag specification as a string, this returns a list
+    where the entries are the flags. For compiler options which set values
+    using the syntax "-flag value", this function groups flags and their
+    values together. Any token not preceded by a "-" is considered the
+    value of a prior flag."""
+    tokens = flags_values.split()
+    if not tokens:
+        return []
+    flag = tokens[0]
+    flags_with_propagation = []
+    for token in tokens[1:]:
+        if not token.startswith("-"):
+            flag += " " + token
+        else:
+            flags_with_propagation.append((flag, propagate))
+            flag = token
+    flags_with_propagation.append((flag, propagate))
+    return flags_with_propagation

lib/spack/spack/compilers/gcc.py

@@ -1,191 +0,0 @@
-# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-# Spack Project Developers. See the top-level COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-import os
-
-from llnl.util.filesystem import ancestor
-
-import spack.compiler
-import spack.compilers.apple_clang as apple_clang
-import spack.util.executable
-from spack.version import Version
-
-
-class Gcc(spack.compiler.Compiler):
-    # MacPorts builds gcc versions with prefixes and -mp-X or -mp-X.Y suffixes.
-    # Homebrew and Linuxbrew may build gcc with -X, -X.Y suffixes.
-    # Old compatibility versions may contain XY suffixes.
-    suffixes = [r"-mp-\d+(?:\.\d+)?", r"-\d+(?:\.\d+)?", r"\d\d"]
-
-    # Named wrapper links within build_env_path
-    link_paths = {
-        "cc": os.path.join("gcc", "gcc"),
-        "cxx": os.path.join("gcc", "g++"),
-        "f77": os.path.join("gcc", "gfortran"),
-        "fc": os.path.join("gcc", "gfortran"),
-    }
-
-    @property
-    def verbose_flag(self):
-        return "-v"
-
-    @property
-    def debug_flags(self):
-        return ["-g", "-gstabs+", "-gstabs", "-gxcoff+", "-gxcoff", "-gvms"]
-
-    @property
-    def opt_flags(self):
-        return ["-O", "-O0", "-O1", "-O2", "-O3", "-Os", "-Ofast", "-Og"]
-
-    @property
-    def openmp_flag(self):
-        return "-fopenmp"
-
-    @property
-    def cxx98_flag(self):
-        if self.real_version < Version("6.0"):
-            return ""
-        else:
-            return "-std=c++98"
-
-    @property
-    def cxx11_flag(self):
-        if self.real_version < Version("4.3"):
-            raise spack.compiler.UnsupportedCompilerFlag(
-                self, "the C++11 standard", "cxx11_flag", " < 4.3"
-            )
-        elif self.real_version < Version("4.7"):
-            return "-std=c++0x"
-        else:
-            return "-std=c++11"
-
-    @property
-    def cxx14_flag(self):
-        if self.real_version < Version("4.8"):
-            raise spack.compiler.UnsupportedCompilerFlag(
-                self, "the C++14 standard", "cxx14_flag", "< 4.8"
-            )
-        elif self.real_version < Version("4.9"):
-            return "-std=c++1y"
-        else:
-            return "-std=c++14"
-
-    @property
-    def cxx17_flag(self):
-        if self.real_version < Version("5.0"):
-            raise spack.compiler.UnsupportedCompilerFlag(
-                self, "the C++17 standard", "cxx17_flag", "< 5.0"
-            )
-        elif self.real_version < Version("6.0"):
-            return "-std=c++1z"
-        else:
-            return "-std=c++17"
-
-    @property
-    def cxx20_flag(self):
-        if self.real_version < Version("8.0"):
-            raise spack.compiler.UnsupportedCompilerFlag(
-                self, "the C++20 standard", "cxx20_flag", "< 8.0"
-            )
-        elif self.real_version < Version("11.0"):
-            return "-std=c++2a"
-        else:
-            return "-std=c++20"
-
-    @property
-    def cxx23_flag(self):
-        if self.real_version < Version("11.0"):
-            raise spack.compiler.UnsupportedCompilerFlag(
-                self, "the C++23 standard", "cxx23_flag", "< 11.0"
-            )
-        elif self.real_version < Version("14.0"):
-            return "-std=c++2b"
-        else:
-            return "-std=c++23"
-
-    @property
-    def c99_flag(self):
-        if self.real_version < Version("4.5"):
-            raise spack.compiler.UnsupportedCompilerFlag(
-                self, "the C99 standard", "c99_flag", "< 4.5"
-            )
-        return "-std=c99"
-
-    @property
-    def c11_flag(self):
-        if self.real_version < Version("4.7"):
-            raise spack.compiler.UnsupportedCompilerFlag(
-                self, "the C11 standard", "c11_flag", "< 4.7"
-            )
-        return "-std=c11"
-
-    @property
-    def cc_pic_flag(self):
-        return "-fPIC"
-
-    @property
-    def cxx_pic_flag(self):
-        return "-fPIC"
-
-    @property
-    def f77_pic_flag(self):
-        return "-fPIC"
-
-    @property
-    def fc_pic_flag(self):
-        return "-fPIC"
-
-    required_libs = ["libgcc", "libgfortran"]
-
-    @classmethod
-    def default_version(cls, cc):
-        """Older versions of gcc use the ``-dumpversion`` option.
-        Output looks like this::
-
-            4.4.7
-
-        In GCC 7, this option was changed to only return the major
-        version of the compiler::
-
-            7
-
-        A new ``-dumpfullversion`` option was added that gives us
-        what we want::
-
-            7.2.0
-        """
-        # Apple's gcc is actually apple clang, so skip it. Returning
-        # "unknown" ensures this compiler is not detected by default.
-        # Users can add it manually to compilers.yaml at their own risk.
-        if apple_clang.AppleClang.default_version(cc) != "unknown":
-            return "unknown"
-
-        version = super(Gcc, cls).default_version(cc)
-        if Version(version) >= Version("7"):
-            output = spack.compiler.get_compiler_version_output(cc, "-dumpfullversion")
-            version = cls.extract_version_from_output(output)
-        return version
-
-    @property
-    def stdcxx_libs(self):
-        return ("-lstdc++",)
-
-    @property
-    def prefix(self):
-        # GCC reports its install prefix when running ``-print-search-dirs``
-        # on the first line ``install: <prefix>``.
-        cc = spack.util.executable.Executable(self.cc)
-        with self.compiler_environment():
-            gcc_output = cc("-print-search-dirs", output=str, error=str)
-
-            for line in gcc_output.splitlines():
-                if line.startswith("install:"):
-                    gcc_prefix = line.split(":")[1].strip()
-                    # Go from <prefix>/lib/gcc/<triplet>/<version>/ to <prefix>
-                    return ancestor(gcc_prefix, 4)
-
-            raise RuntimeError(
-                "could not find install prefix of GCC from output:\n\t{}".format(gcc_output)
-            )

lib/spack/spack/compilers/intel.py

@@ -1,131 +0,0 @@
-# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-# Spack Project Developers. See the top-level COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-import os
-import sys
-
-from spack.compiler import Compiler, UnsupportedCompilerFlag
-from spack.version import Version
-
-
-class Intel(Compiler):
-    # Named wrapper links within build_env_path
-    link_paths = {
-        "cc": os.path.join("intel", "icc"),
-        "cxx": os.path.join("intel", "icpc"),
-        "f77": os.path.join("intel", "ifort"),
-        "fc": os.path.join("intel", "ifort"),
-    }
-
-    if sys.platform == "win32":
-        version_argument = "/QV"
-    else:
-        version_argument = "--version"
-
-    if sys.platform == "win32":
-        version_regex = r"([1-9][0-9]*\.[0-9]*\.[0-9]*)"
-    else:
-        version_regex = r"\((?:IFORT|ICC)\) ([^ ]+)"
-
-    @property
-    def verbose_flag(self):
-        return "-v"
-
-    required_libs = ["libirc", "libifcore", "libifcoremt", "libirng"]
-
-    @property
-    def debug_flags(self):
-        return ["-debug", "-g", "-g0", "-g1", "-g2", "-g3"]
-
-    @property
-    def opt_flags(self):
-        return ["-O", "-O0", "-O1", "-O2", "-O3", "-Ofast", "-Os"]
-
-    @property
-    def openmp_flag(self):
-        if self.real_version < Version("16.0"):
-            return "-openmp"
-        else:
-            return "-qopenmp"
-
-    @property
-    def cxx11_flag(self):
-        if self.real_version < Version("11.1"):
-            raise UnsupportedCompilerFlag(self, "the C++11 standard", "cxx11_flag", "< 11.1")
-
-        elif self.real_version < Version("13"):
-            return "-std=c++0x"
-        else:
-            return "-std=c++11"
-
-    @property
-    def cxx14_flag(self):
-        # Adapted from CMake's Intel-CXX rules.
-        if self.real_version < Version("15"):
-            raise UnsupportedCompilerFlag(self, "the C++14 standard", "cxx14_flag", "< 15")
-        elif self.real_version < Version("15.0.2"):
-            return "-std=c++1y"
-        else:
-            return "-std=c++14"
-
-    @property
-    def cxx17_flag(self):
-        # https://www.intel.com/content/www/us/en/developer/articles/news/c17-features-supported-by-c-compiler.html
-        if self.real_version < Version("19"):
-            raise UnsupportedCompilerFlag(self, "the C++17 standard", "cxx17_flag", "< 19")
-        else:
-            return "-std=c++17"
-
-    @property
-    def c99_flag(self):
-        if self.real_version < Version("12"):
-            raise UnsupportedCompilerFlag(self, "the C99 standard", "c99_flag", "< 12")
-        else:
-            return "-std=c99"
-
-    @property
-    def c11_flag(self):
-        if self.real_version < Version("16"):
-            raise UnsupportedCompilerFlag(self, "the C11 standard", "c11_flag", "< 16")
-        else:
-            return "-std=c1x"
-
-    @property
-    def c18_flag(self):
-        # c18 supported since oneapi 2022, which is classic version 2021.5.0
-        if self.real_version < Version("21.5.0"):
-            raise UnsupportedCompilerFlag(self, "the C18 standard", "c18_flag", "< 21.5.0")
-        else:
-            return "-std=c18"
-
-    @property
-    def cc_pic_flag(self):
-        return "-fPIC"
-
-    @property
-    def cxx_pic_flag(self):
-        return "-fPIC"
-
-    @property
-    def f77_pic_flag(self):
-        return "-fPIC"
-
-    @property
-    def fc_pic_flag(self):
-        return "-fPIC"
-
-    @property
-    def stdcxx_libs(self):
-        return ("-cxxlib",)
-
-    def setup_custom_environment(self, pkg, env):
-        # Edge cases for Intel's oneAPI compilers when using the legacy classic compilers:
-        # Always pass flags to disable deprecation warnings, since these warnings can
-        # confuse tools that parse the output of compiler commands (e.g. version checks).
-        if self.real_version >= Version("2021") and self.real_version < Version("2024"):
-            env.append_flags("SPACK_ALWAYS_CFLAGS", "-diag-disable=10441")
-            env.append_flags("SPACK_ALWAYS_CXXFLAGS", "-diag-disable=10441")
-        if self.real_version >= Version("2021") and self.real_version < Version("2025"):
-            env.append_flags("SPACK_ALWAYS_FFLAGS", "-diag-disable=10448")

lib/spack/spack/compilers/libraries.py

@@ -0,0 +1,426 @@
+# Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+# Spack Project Developers. See the top-level COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+import contextlib
+import hashlib
+import json
+import os
+import re
+import shutil
+import stat
+import sys
+import tempfile
+import typing
+from typing import Dict, List, Optional, Set, Tuple
+
+import llnl.path
+import llnl.util.lang
+from llnl.util import tty
+from llnl.util.filesystem import path_contains_subdirectory, paths_containing_libs
+
+import spack.caches
+import spack.util.libc
+from spack.util.environment import filter_system_paths
+from spack.util.file_cache import FileCache
+
+if typing.TYPE_CHECKING:
+    import spack.spec
+
+
+#: regex for parsing linker lines
+_LINKER_LINE = re.compile(r"^( *|.*[/\\])" r"(link|ld|([^/\\]+-)?ld|collect2)" r"[^/\\]*( |$)")
+
+#: components of linker lines to ignore
+_LINKER_LINE_IGNORE = re.compile(r"(collect2 version|^[A-Za-z0-9_]+=|/ldfe )")
+
+#: regex to match linker search paths
+_LINK_DIR_ARG = re.compile(r"^-L(.:)?(?P<dir>[/\\].*)")
+
+#: regex to match linker library path arguments
+_LIBPATH_ARG = re.compile(r"^[-/](LIBPATH|libpath):(?P<dir>.*)")
+
+
+@llnl.path.system_path_filter
+def parse_non_system_link_dirs(compiler_debug_output: str) -> List[str]:
+    """Parses link paths out of compiler debug output.
+
+    Args:
+        compiler_debug_output: compiler debug output as a string
+
+    Returns:
+        Implicit link paths parsed from the compiler output
+    """
+    link_dirs = _parse_link_paths(compiler_debug_output)
+
+    # Remove directories that do not exist. Some versions of the Cray compiler
+    # report nonexistent directories
+    link_dirs = filter_non_existing_dirs(link_dirs)
+
+    # Return set of directories containing needed compiler libs, minus
+    # system paths. Note that 'filter_system_paths' only checks for an
+    # exact match, while 'in_system_subdirectory' checks if a path contains
+    # a system directory as a subdirectory
+    link_dirs = filter_system_paths(link_dirs)
+    return list(p for p in link_dirs if not in_system_subdirectory(p))
+
+
+def filter_non_existing_dirs(dirs):
+    return [d for d in dirs if os.path.isdir(d)]
+
+
+def in_system_subdirectory(path):
+    system_dirs = [
+        "/lib/",
+        "/lib64/",
+        "/usr/lib/",
+        "/usr/lib64/",
+        "/usr/local/lib/",
+        "/usr/local/lib64/",
+    ]
+    return any(path_contains_subdirectory(path, x) for x in system_dirs)
+
+
+def _parse_link_paths(string):
+    """Parse implicit link paths from compiler debug output.
+
+    This gives the compiler runtime library paths that we need to add to
+    the RPATH of generated binaries and libraries.  It allows us to
+    ensure, e.g., that codes load the right libstdc++ for their compiler.
+    """
+    lib_search_paths = False
+    raw_link_dirs = []
+    for line in string.splitlines():
+        if lib_search_paths:
+            if line.startswith("\t"):
+                raw_link_dirs.append(line[1:])
+                continue
+            else:
+                lib_search_paths = False
+        elif line.startswith("Library search paths:"):
+            lib_search_paths = True
+
+        if not _LINKER_LINE.match(line):
+            continue
+        if _LINKER_LINE_IGNORE.match(line):
+            continue
+        tty.debug(f"implicit link dirs: link line: {line}")
+
+        next_arg = False
+        for arg in line.split():
+            if arg in ("-L", "-Y"):
+                next_arg = True
+                continue
+
+            if next_arg:
+                raw_link_dirs.append(arg)
+                next_arg = False
+                continue
+
+            link_dir_arg = _LINK_DIR_ARG.match(arg)
+            if link_dir_arg:
+                link_dir = link_dir_arg.group("dir")
+                raw_link_dirs.append(link_dir)
+
+            link_dir_arg = _LIBPATH_ARG.match(arg)
+            if link_dir_arg:
+                link_dir = link_dir_arg.group("dir")
+                raw_link_dirs.append(link_dir)
+
+    implicit_link_dirs = list()
+    visited = set()
+    for link_dir in raw_link_dirs:
+        normalized_path = os.path.abspath(link_dir)
+        if normalized_path not in visited:
+            implicit_link_dirs.append(normalized_path)
+            visited.add(normalized_path)
+
+    tty.debug(f"implicit link dirs: result: {', '.join(implicit_link_dirs)}")
+    return implicit_link_dirs
+
+
+class CompilerPropertyDetector:
+
+    def __init__(self, compiler_spec: "spack.spec.Spec"):
+        assert compiler_spec.external, "only external compiler specs are allowed, so far"
+        assert compiler_spec.concrete, "only concrete compiler specs are allowed, so far"
+        self.spec = compiler_spec
+        self.cache = COMPILER_CACHE
+
+    @contextlib.contextmanager
+    def compiler_environment(self):
+        """Sets the environment to run this compiler"""
+        import spack.schema.environment
+        import spack.util.module_cmd
+
+        # Avoid modifying os.environ if possible.
+        environment = self.spec.extra_attributes.get("environment", {})
+        modules = self.spec.external_modules or []
+        if not self.spec.external_modules and not environment:
+            yield
+            return
+
+        # store environment to replace later
+        backup_env = os.environ.copy()
+
+        try:
+            # load modules and set env variables
+            for module in modules:
+                spack.util.module_cmd.load_module(module)
+
+            # apply other compiler environment changes
+            spack.schema.environment.parse(environment).apply_modifications()
+
+            yield
+        finally:
+            # Restore environment regardless of whether inner code succeeded
+            os.environ.clear()
+            os.environ.update(backup_env)
+
+    def _compile_dummy_c_source(self) -> Optional[str]:
+        import spack.util.executable
+
+        assert self.spec.external, "only external compiler specs are allowed, so far"
+        compiler_pkg = self.spec.package
+        if getattr(compiler_pkg, "cc"):
+            cc = compiler_pkg.cc
+            ext = "c"
+        else:
+            cc = compiler_pkg.cxx
+            ext = "cc"
+
+        if not cc or not self.spec.package.verbose_flags:
+            return None
+
+        try:
+            tmpdir = tempfile.mkdtemp(prefix="spack-implicit-link-info")
+            fout = os.path.join(tmpdir, "output")
+            fin = os.path.join(tmpdir, f"main.{ext}")
+
+            with open(fin, "w") as csource:
+                csource.write(
+                    "int main(int argc, char* argv[]) { (void)argc; (void)argv; return 0; }\n"
+                )
+            cc_exe = spack.util.executable.Executable(cc)
+
+            # FIXME (compiler as nodes): this operation should be encapsulated somewhere else
+            compiler_flags = self.spec.extra_attributes.get("flags", {})
+            for flag_type in [
+                "cflags" if cc == compiler_pkg.cc else "cxxflags",
+                "cppflags",
+                "ldflags",
+            ]:
+                current_flags = compiler_flags.get(flag_type, "").strip()
+                if current_flags:
+                    cc_exe.add_default_arg(*current_flags.split(" "))
+
+            with self.compiler_environment():
+                return cc_exe("-v", fin, "-o", fout, output=str, error=str)
+        except spack.util.executable.ProcessError as pe:
+            tty.debug(f"ProcessError: Command exited with non-zero status: {pe.long_message}")
+            return None
+        finally:
+            shutil.rmtree(tmpdir, ignore_errors=True)
+
+    def compiler_verbose_output(self) -> Optional[str]:
+        return self.cache.get(self.spec).c_compiler_output
+
+    def default_dynamic_linker(self) -> Optional[str]:
+        output = self.compiler_verbose_output()
+
+        if not output:
+            return None
+
+        return spack.util.libc.parse_dynamic_linker(output)
+
+    def default_libc(self) -> Optional["spack.spec.Spec"]:
+        """Determine libc targeted by the compiler from link line"""
+        # technically this should be testing the target platform of the compiler, but we don't have
+        # that, so stick to host platform for now.
+        if sys.platform in ("darwin", "win32"):
+            return None
+
+        dynamic_linker = self.default_dynamic_linker()
+
+        if dynamic_linker is None:
+            return None
+
+        return spack.util.libc.libc_from_dynamic_linker(dynamic_linker)
+
+    def implicit_rpaths(self) -> List[str]:
+        output = self.compiler_verbose_output()
+        if output is None:
+            return []
+
+        link_dirs = parse_non_system_link_dirs(output)
+        all_required_libs = list(self.spec.package.required_libs) + ["libc", "libc++", "libstdc++"]
+        dynamic_linker = self.default_dynamic_linker()
+        # FIXME (compiler as nodes): is this needed ?
+        # if dynamic_linker is None:
+        #     return []
+        result = DefaultDynamicLinkerFilter(dynamic_linker)(
+            paths_containing_libs(link_dirs, all_required_libs)
+        )
+        return list(result)
+
+
+class DefaultDynamicLinkerFilter:
+    """Remove rpaths to directories that are default search paths of the dynamic linker."""
+
+    _CACHE: Dict[Optional[str], Set[Tuple[int, int]]] = {}
+
+    def __init__(self, dynamic_linker: Optional[str]) -> None:
+        if dynamic_linker not in DefaultDynamicLinkerFilter._CACHE:
+            # Identify directories by (inode, device) tuple, which handles symlinks too.
+            default_path_identifiers: Set[Tuple[int, int]] = set()
+            if not dynamic_linker:
+                self.default_path_identifiers = None
+                return
+            for path in spack.util.libc.default_search_paths_from_dynamic_linker(dynamic_linker):
+                try:
+                    s = os.stat(path)
+                    if stat.S_ISDIR(s.st_mode):
+                        default_path_identifiers.add((s.st_ino, s.st_dev))
+                except OSError:
+                    continue
+
+            DefaultDynamicLinkerFilter._CACHE[dynamic_linker] = default_path_identifiers
+
+        self.default_path_identifiers = DefaultDynamicLinkerFilter._CACHE[dynamic_linker]
+
+    def is_dynamic_loader_default_path(self, p: str) -> bool:
+        if self.default_path_identifiers is None:
+            return False
+        try:
+            s = os.stat(p)
+            return (s.st_ino, s.st_dev) in self.default_path_identifiers
+        except OSError:
+            return False
+
+    def __call__(self, dirs: List[str]) -> List[str]:
+        if not self.default_path_identifiers:
+            return dirs
+        return [p for p in dirs if not self.is_dynamic_loader_default_path(p)]
+
+
+def dynamic_linker_filter_for(node: "spack.spec.Spec") -> Optional[DefaultDynamicLinkerFilter]:
+    compiler = compiler_spec(node)
+    if compiler is None:
+        return None
+    detector = CompilerPropertyDetector(compiler)
+    dynamic_linker = detector.default_dynamic_linker()
+    if dynamic_linker is None:
+        return None
+    return DefaultDynamicLinkerFilter(dynamic_linker)
+
+
+def compiler_spec(node: "spack.spec.Spec") -> Optional["spack.spec.Spec"]:
+    """Returns the compiler spec associated with the node passed as argument.
+
+    The function looks for a "c", "cxx", and "fortran" compiler in that order,
+    and returns the first found. If none is found, returns None.
+    """
+    for language in ("c", "cxx", "fortran"):
+        candidates = node.dependencies(virtuals=[language])
+        if candidates:
+            break
+    else:
+        return None
+
+    return candidates[0]
+
+
+class CompilerCacheEntry:
+    """Deserialized cache entry for a compiler"""
+
+    __slots__ = ["c_compiler_output"]
+
+    def __init__(self, c_compiler_output: Optional[str]):
+        self.c_compiler_output = c_compiler_output
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Optional[str]]):
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid {cls.__name__} data")
+        c_compiler_output = data.get("c_compiler_output")
+        if not isinstance(c_compiler_output, (str, type(None))):
+            raise ValueError(f"Invalid {cls.__name__} data")
+        return cls(c_compiler_output)
+
+
+class CompilerCache:
+    """Base class for compiler output cache. Default implementation does not cache anything."""
+
+    def value(self, compiler: "spack.spec.Spec") -> Dict[str, Optional[str]]:
+        return {"c_compiler_output": CompilerPropertyDetector(compiler)._compile_dummy_c_source()}
+
+    def get(self, compiler: "spack.spec.Spec") -> CompilerCacheEntry:
+        return CompilerCacheEntry.from_dict(self.value(compiler))
+
+
+class FileCompilerCache(CompilerCache):
+    """Cache for compiler output, which is used to determine implicit link paths, the default libc
+    version, and the compiler version."""
+
+    name = os.path.join("compilers", "compilers.json")
+
+    def __init__(self, cache: "FileCache") -> None:
+        self.cache = cache
+        self.cache.init_entry(self.name)
+        self._data: Dict[str, Dict[str, Optional[str]]] = {}
+
+    def _get_entry(self, key: str) -> Optional[CompilerCacheEntry]:
+        try:
+            return CompilerCacheEntry.from_dict(self._data[key])
+        except ValueError:
+            del self._data[key]
+        except KeyError:
+            pass
+        return None
+
+    def get(self, compiler: "spack.spec.Spec") -> CompilerCacheEntry:
+        # Cache hit
+        try:
+            with self.cache.read_transaction(self.name) as f:
+                assert f is not None
+                self._data = json.loads(f.read())
+                assert isinstance(self._data, dict)
+        except (json.JSONDecodeError, AssertionError):
+            self._data = {}
+
+        key = self._key(compiler)
+        value = self._get_entry(key)
+        if value is not None:
+            return value
+
+        # Cache miss
+        with self.cache.write_transaction(self.name) as (old, new):
+            try:
+                assert old is not None
+                self._data = json.loads(old.read())
+                assert isinstance(self._data, dict)
+            except (json.JSONDecodeError, AssertionError):
+                self._data = {}
+
+            # Use cache entry that may have been created by another process in the meantime.
+            entry = self._get_entry(key)
+
+            # Finally compute the cache entry
+            if entry is None:
+                self._data[key] = self.value(compiler)
+                entry = CompilerCacheEntry.from_dict(self._data[key])
+
+            new.write(json.dumps(self._data, separators=(",", ":")))
+
+            return entry
+
+    def _key(self, compiler: "spack.spec.Spec") -> str:
+        as_bytes = json.dumps(compiler.to_dict(), separators=(",", ":")).encode("utf-8")
+        return hashlib.sha256(as_bytes).hexdigest()
+
+
+def _make_compiler_cache():
+    return FileCompilerCache(spack.caches.MISC_CACHE)
+
+
+COMPILER_CACHE: CompilerCache = llnl.util.lang.Singleton(_make_compiler_cache)  # type: ignore

lib/spack/spack/compilers/msvc.py

@@ -1,394 +0,0 @@
-# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-# Spack Project Developers. See the top-level COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-import os
-import re
-import subprocess
-import sys
-import tempfile
-from typing import Dict
-
-import archspec.cpu
-
-import spack.compiler
-import spack.operating_systems.windows_os
-import spack.platforms
-import spack.util.executable
-from spack.compiler import Compiler
-from spack.error import SpackError
-from spack.version import Version, VersionRange
-
-FC_PATH: Dict[str, str] = dict()
-
-
-class CmdCall:
-    """Compose a call to `cmd` for an ordered series of cmd commands/scripts"""
-
-    def __init__(self, *cmds):
-        if not cmds:
-            raise RuntimeError(
-                """Attempting to run commands from CMD without specifying commands.
-                Please add commands to be run."""
-            )
-        self._cmds = cmds
-
-    def __call__(self):
-        out = subprocess.check_output(self.cmd_line, stderr=subprocess.STDOUT)  # novermin
-        return out.decode("utf-16le", errors="replace")  # novermin
-
-    @property
-    def cmd_line(self):
-        base_call = "cmd /u /c "
-        commands = " && ".join([x.command_str() for x in self._cmds])
-        # If multiple commands are being invoked by a single subshell
-        # they must be encapsulated by a double quote. Always double
-        # quote to be sure of proper handling
-        # cmd will properly resolve nested double quotes as needed
-        #
-        # `set`` writes out the active env to the subshell stdout,
-        # and in this context we are always trying to obtain env
-        # state so it should always be appended
-        return base_call + f'"{commands} && set"'
-
-
-class VarsInvocation:
-    def __init__(self, script):
-        self._script = script
-
-    def command_str(self):
-        return f'"{self._script}"'
-
-    @property
-    def script(self):
-        return self._script
-
-
-class VCVarsInvocation(VarsInvocation):
-    def __init__(self, script, arch, msvc_version):
-        super(VCVarsInvocation, self).__init__(script)
-        self._arch = arch
-        self._msvc_version = msvc_version
-
-    @property
-    def sdk_ver(self):
-        """Accessor for Windows SDK version property
-
-        Note: This property may not be set by
-        the calling context and as such this property will
-        return an empty string
-
-        This property will ONLY be set if the SDK package
-        is a dependency somewhere in the Spack DAG of the package
-        for which we are constructing an MSVC compiler env.
-        Otherwise this property should be unset to allow the VCVARS
-        script to use its internal heuristics to determine appropriate
-        SDK version
-        """
-        if getattr(self, "_sdk_ver", None):
-            return self._sdk_ver + ".0"
-        return ""
-
-    @sdk_ver.setter
-    def sdk_ver(self, val):
-        self._sdk_ver = val
-
-    @property
-    def arch(self):
-        return self._arch
-
-    @property
-    def vcvars_ver(self):
-        return f"-vcvars_ver={self._msvc_version}"
-
-    def command_str(self):
-        script = super(VCVarsInvocation, self).command_str()
-        return f"{script} {self.arch} {self.sdk_ver} {self.vcvars_ver}"
-
-
-def get_valid_fortran_pth():
-    """Assign maximum available fortran compiler version"""
-    # TODO (johnwparent): validate compatibility w/ try compiler
-    # functionality when added
-    sort_fn = lambda fc_ver: Version(fc_ver)
-    sort_fc_ver = sorted(list(FC_PATH.keys()), key=sort_fn)
-    return FC_PATH[sort_fc_ver[-1]] if sort_fc_ver else None
-
-
-class Msvc(Compiler):
-    # Named wrapper links within build_env_path
-    # Due to the challenges of supporting compiler wrappers
-    # in Windows, we leave these blank, and dynamically compute
-    # based on proper versions of MSVC from there
-    # pending acceptance of #28117 for full support using
-    # compiler wrappers
-    link_paths = {"cc": "", "cxx": "", "f77": "", "fc": ""}
-
-    #: Compiler argument that produces version information
-    version_argument = ""
-
-    # For getting ifx's version, call it with version_argument
-    # and ignore the error code
-    ignore_version_errors = [1]
-
-    #: Regex used to extract version from compiler's output
-    version_regex = r"([1-9][0-9]*\.[0-9]*\.[0-9]*)"
-    # The MSVC compiler class overrides this to prevent instances
-    # of erroneous matching on executable names that cannot be msvc
-    # compilers
-    suffixes = []
-
-    is_supported_on_platform = lambda x: isinstance(x, spack.platforms.Windows)
-
-    def __init__(self, *args, **kwargs):
-        # This positional argument "paths" is later parsed and process by the base class
-        # via the call to `super` later in this method
-        paths = args[3]
-        latest_fc = get_valid_fortran_pth()
-        new_pth = [pth if pth else latest_fc for pth in paths[2:]]
-        paths[2:] = new_pth
-        # Initialize, deferring to base class but then adding the vcvarsallfile
-        # file based on compiler executable path.
-        super().__init__(*args, **kwargs)
-        # To use the MSVC compilers, VCVARS must be invoked
-        # VCVARS is located at a fixed location, referencable
-        # idiomatically by the following relative path from the
-        # compiler.
-        # Spack first finds the compilers via VSWHERE
-        # and stores their path, but their respective VCVARS
-        # file must be invoked before useage.
-        env_cmds = []
-        compiler_root = os.path.join(os.path.dirname(self.cc), "../../../../../..")
-        vcvars_script_path = os.path.join(compiler_root, "Auxiliary", "Build", "vcvars64.bat")
-        # get current platform architecture and format for vcvars argument
-        arch = spack.platforms.real_host().default.lower()
-        arch = arch.replace("-", "_")
-        if str(archspec.cpu.host().family) == "x86_64":
-            arch = "amd64"
-
-        self.vcvars_call = VCVarsInvocation(vcvars_script_path, arch, self.msvc_version)
-        env_cmds.append(self.vcvars_call)
-        # Below is a check for a valid fortran path
-        # paths has c, cxx, fc, and f77 paths in that order
-        # paths[2] refers to the fc path and is a generic check
-        # for a fortran compiler
-        if paths[2]:
-
-            def get_oneapi_root(pth: str):
-                """From within a prefix known to be a oneAPI path
-                determine the oneAPI root path from arbitrary point
-                under root
-
-                Args:
-                    pth: path prefixed within oneAPI root
-                """
-                if not pth:
-                    return ""
-                while os.path.basename(pth) and os.path.basename(pth) != "oneAPI":
-                    pth = os.path.dirname(pth)
-                return pth
-
-            # If this found, it sets all the vars
-            oneapi_root = get_oneapi_root(self.fc)
-            if not oneapi_root:
-                raise RuntimeError(f"Non-oneAPI Fortran compiler {self.fc} assigned to MSVC")
-            oneapi_root_setvars = os.path.join(oneapi_root, "setvars.bat")
-            # some oneAPI exes return a version more precise than their
-            # install paths specify, so we determine path from
-            # the install path rather than the fc executable itself
-            numver = r"\d+\.\d+(?:\.\d+)?"
-            pattern = f"((?:{numver})|(?:latest))"
-            version_from_path = re.search(pattern, self.fc).group(1)
-            oneapi_version_setvars = os.path.join(
-                oneapi_root, "compiler", version_from_path, "env", "vars.bat"
-            )
-            # order matters here, the specific version env must be invoked first,
-            # otherwise it will be ignored if the root setvars sets up the oneapi
-            # env first
-            env_cmds.extend(
-                [VarsInvocation(oneapi_version_setvars), VarsInvocation(oneapi_root_setvars)]
-            )
-        self.msvc_compiler_environment = CmdCall(*env_cmds)
-
-    @property
-    def cxx11_flag(self):
-        return "/std:c++11"
-
-    @property
-    def cxx14_flag(self):
-        return "/std:c++14"
-
-    @property
-    def cxx17_flag(self):
-        return "/std:c++17"
-
-    @property
-    def cxx20_flag(self):
-        return "/std:c++20"
-
-    @property
-    def c11_flag(self):
-        return "/std:c11"
-
-    @property
-    def c17_flag(self):
-        return "/std:c17"
-
-    @property
-    def msvc_version(self):
-        """This is the VCToolset version *NOT* the actual version of the cl compiler
-        For CL version, query `Msvc.cl_version`"""
-        return Version(re.search(Msvc.version_regex, self.cc).group(1))
-
-    @property
-    def short_msvc_version(self):
-        """This is the shorthand VCToolset version of form
-        MSVC<short-ver>
-        """
-        return "MSVC" + self.vc_toolset_ver
-
-    @property
-    def vc_toolset_ver(self):
-        """
-        The toolset version is the version of the combined set of cl and link
-        This typically relates directly to VS version i.e. VS 2022 is v143
-        VS 19 is v142, etc.
-        This value is defined by the first three digits of the major + minor
-        version of the VS toolset (143 for 14.3x.bbbbb). Traditionally the
-        minor version has remained a static two digit number for a VS release
-        series, however, as of VS22, this is no longer true, both
-        14.4x.bbbbb and 14.3x.bbbbb are considered valid VS22 VC toolset
-        versions due to a change in toolset minor version sentiment.
-
-        This is *NOT* the full version, for that see
-        Msvc.msvc_version or MSVC.platform_toolset_ver for the
-        raw platform toolset version
-
-        """
-        ver = self.msvc_version[:2].joined.string[:3]
-        return ver
-
-    @property
-    def platform_toolset_ver(self):
-        """
-        This is the platform toolset version of current MSVC compiler
-        i.e. 142. The platform toolset is the targeted MSVC library/compiler
-        versions by compilation (this is different from the VC Toolset)
-
-
-        This is different from the VC toolset version as established
-        by `short_msvc_version`, but typically are represented by the same
-        three digit value
-        """
-        # Typically VS toolset version and platform toolset versions match
-        # VS22 introduces the first divergence of VS toolset version
-        # (144 for "recent" releases) and platform toolset version (143)
-        # so it needs additional handling until MS releases v144
-        # (assuming v144 is also for VS22)
-        # or adds better support for detection
-        # TODO: (johnwparent) Update this logic for the next platform toolset
-        # or VC toolset version update
-        toolset_ver = self.vc_toolset_ver
-        vs22_toolset = Version(toolset_ver) > Version("142")
-        return toolset_ver if not vs22_toolset else "143"
-
-    @property
-    def visual_studio_version(self):
-        """The four digit Visual Studio version (i.e. 2019 or 2022)
-
-        Note: This differs from the msvc version or toolset version as
-        those properties track the compiler and build tools version
-        respectively, whereas this tracks the VS release associated
-        with a given MSVC compiler.
-        """
-        return re.search(r"[0-9]{4}", self.cc).group(0)
-
-    def _compiler_version(self, compiler):
-        """Returns version object for given compiler"""
-        # ignore_errors below is true here due to ifx's
-        # non zero return code if it is not provided
-        # and input file
-        return Version(
-            re.search(
-                Msvc.version_regex,
-                spack.compiler.get_compiler_version_output(
-                    compiler, version_arg=None, ignore_errors=True
-                ),
-            ).group(1)
-        )
-
-    @property
-    def cl_version(self):
-        """Cl toolset version"""
-        return self._compiler_version(self.cc)
-
-    @property
-    def ifx_version(self):
-        """Ifx compiler version associated with this version of MSVC"""
-        return self._compiler_version(self.fc)
-
-    @property
-    def vs_root(self):
-        # The MSVC install root is located at a fix level above the compiler
-        # and is referenceable idiomatically via the pattern below
-        # this should be consistent accross versions
-        return os.path.abspath(os.path.join(self.cc, "../../../../../../../.."))
-
-    def setup_custom_environment(self, pkg, env):
-        """Set environment variables for MSVC using the
-        Microsoft-provided script."""
-        # Set the build environment variables for spack. Just using
-        # subprocess.call() doesn't work since that operates in its own
-        # environment which is destroyed (along with the adjusted variables)
-        # once the process terminates. So go the long way around: examine
-        # output, sort into dictionary, use that to make the build
-        # environment.
-
-        # vcvars can target specific sdk versions, force it to pick up concretized sdk
-        # version, if needed by spec
-        if pkg.name != "win-sdk" and "win-sdk" in pkg.spec:
-            self.vcvars_call.sdk_ver = pkg.spec["win-sdk"].version.string
-
-        out = self.msvc_compiler_environment()
-        int_env = dict(
-            (key, value)
-            for key, _, value in (line.partition("=") for line in out.splitlines())
-            if key and value
-        )
-
-        for env_var in int_env:
-            if os.pathsep not in int_env[env_var]:
-                env.set(env_var, int_env[env_var])
-            else:
-                env.set_path(env_var, int_env[env_var].split(os.pathsep))
-
-        # certain versions of ifx (2021.3.0:2023.1.0) do not play well with env:TMP
-        # that has a "." character in the path
-        # Work around by pointing tmp to the stage for the duration of the build
-        if self.fc and Version(self.fc_version(self.fc)).satisfies(
-            VersionRange("2021.3.0", "2023.1.0")
-        ):
-            new_tmp = tempfile.mkdtemp(dir=pkg.stage.path)
-            env.set("TMP", new_tmp)
-
-        env.set("CC", self.cc)
-        env.set("CXX", self.cxx)
-        env.set("FC", self.fc)
-        env.set("F77", self.f77)
-
-    @classmethod
-    def fc_version(cls, fc):
-        if not sys.platform == "win32":
-            return "unknown"
-        fc_ver = cls.default_version(fc)
-        FC_PATH[fc_ver] = fc
-        try:
-            sps = spack.operating_systems.windows_os.WindowsOs().compiler_search_paths
-        except AttributeError:
-            raise SpackError(
-                "Windows compiler search paths not established, "
-                "please report this behavior to github.com/spack/spack"
-            )
-        clp = spack.util.executable.which_string("cl", path=sps)
-        return cls.default_version(clp) if clp else fc_ver

lib/spack/spack/compilers/nag.py

@@ -1,112 +0,0 @@
-# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-# Spack Project Developers. See the top-level COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-import os
-import re
-
-import llnl.util.lang
-
-import spack.compiler
-
-
-class Nag(spack.compiler.Compiler):
-    # Named wrapper links within build_env_path
-    # Use default wrappers for C and C++, in case provided in compilers.yaml
-    link_paths = {
-        "cc": "cc",
-        "cxx": "c++",
-        "f77": os.path.join("nag", "nagfor"),
-        "fc": os.path.join("nag", "nagfor"),
-    }
-
-    version_argument = "-V"
-
-    @classmethod
-    @llnl.util.lang.memoized
-    def extract_version_from_output(cls, output):
-        match = re.search(r"NAG Fortran Compiler Release (\d+).(\d+)\(.*\) Build (\d+)", output)
-        if match:
-            return ".".join(match.groups())
-
-    @property
-    def verbose_flag(self):
-        # NAG does not support a flag that would enable verbose output and
-        # compilation/linking at the same time (with either '-#' or '-dryrun'
-        # the compiler only prints the commands but does not run them).
-        # Therefore, the only thing we can do is to pass the '-v' argument to
-        # the underlying GCC. In order to get verbose output from the latter
-        # at both compile and linking stages, we need to call NAG with two
-        # additional flags: '-Wc,-v' and '-Wl,-v'. However, we return only
-        # '-Wl,-v' for the following reasons:
-        #   1) the interface of this method does not support multiple flags in
-        #      the return value and, at least currently, verbose output at the
-        #      linking stage has a higher priority for us;
-        #   2) NAG is usually mixed with GCC compiler, which also accepts
-        #      '-Wl,-v' and produces meaningful result with it: '-v' is passed
-        #      to the linker and the latter produces verbose output for the
-        #      linking stage ('-Wc,-v', however, would break the compilation
-        #      with a message from GCC that the flag is not recognized).
-        #
-        # This way, we at least enable the implicit rpath detection, which is
-        # based on compilation of a C file (see method
-        # spack.compiler._compile_dummy_c_source): in the case of a mixed
-        # NAG/GCC toolchain, the flag will be passed to g++ (e.g.
-        # 'g++ -Wl,-v ./main.c'), otherwise, the flag will be passed to nagfor
-        # (e.g. 'nagfor -Wl,-v ./main.c' - note that nagfor recognizes '.c'
-        # extension and treats the file accordingly). The list of detected
-        # rpaths will contain only GCC-related directories and rpaths to
-        # NAG-related directories are injected by nagfor anyway.
-        return "-Wl,-v"
-
-    @property
-    def openmp_flag(self):
-        return "-openmp"
-
-    @property
-    def debug_flags(self):
-        return ["-g", "-gline", "-g90"]
-
-    @property
-    def opt_flags(self):
-        return ["-O", "-O0", "-O1", "-O2", "-O3", "-O4"]
-
-    @property
-    def cxx11_flag(self):
-        # NAG does not have a C++ compiler
-        # However, it can be mixed with a compiler that does support it
-        return "-std=c++11"
-
-    @property
-    def f77_pic_flag(self):
-        return "-PIC"
-
-    @property
-    def fc_pic_flag(self):
-        return "-PIC"
-
-    # Unlike other compilers, the NAG compiler passes options to GCC, which
-    # then passes them to the linker. Therefore, we need to doubly wrap the
-    # options with '-Wl,-Wl,,'
-    @property
-    def f77_rpath_arg(self):
-        return "-Wl,-Wl,,-rpath,,"
-
-    @property
-    def fc_rpath_arg(self):
-        return "-Wl,-Wl,,-rpath,,"
-
-    @property
-    def linker_arg(self):
-        return "-Wl,-Wl,,"
-
-    @property
-    def disable_new_dtags(self):
-        # Disable RPATH/RUNPATH forcing for NAG/GCC mixed toolchains:
-        return ""
-
-    @property
-    def enable_new_dtags(self):
-        # Disable RPATH/RUNPATH forcing for NAG/GCC mixed toolchains:
-        return ""

lib/spack/spack/compilers/nvhpc.py

@@ -1,79 +0,0 @@
-# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-# Spack Project Developers. See the top-level COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-import os
-
-from spack.compiler import Compiler
-
-
-class Nvhpc(Compiler):
-    # Named wrapper links within build_env_path
-    link_paths = {
-        "cc": os.path.join("nvhpc", "nvc"),
-        "cxx": os.path.join("nvhpc", "nvc++"),
-        "f77": os.path.join("nvhpc", "nvfortran"),
-        "fc": os.path.join("nvhpc", "nvfortran"),
-    }
-
-    version_argument = "--version"
-    version_regex = r"nv[^ ]* (?:[^ ]+ Dev-r)?([0-9.]+)(?:-[0-9]+)?"
-
-    @property
-    def verbose_flag(self):
-        return "-v"
-
-    @property
-    def debug_flags(self):
-        return ["-g", "-gopt"]
-
-    @property
-    def opt_flags(self):
-        return ["-O", "-O0", "-O1", "-O2", "-O3", "-O4"]
-
-    @property
-    def openmp_flag(self):
-        return "-mp"
-
-    @property
-    def cc_pic_flag(self):
-        return "-fpic"
-
-    @property
-    def cxx_pic_flag(self):
-        return "-fpic"
-
-    @property
-    def f77_pic_flag(self):
-        return "-fpic"
-
-    @property
-    def fc_pic_flag(self):
-        return "-fpic"
-
-    @property
-    def c99_flag(self):
-        return "-c99"
-
-    @property
-    def c11_flag(self):
-        return "-c11"
-
-    @property
-    def cxx11_flag(self):
-        return "--c++11"
-
-    @property
-    def cxx14_flag(self):
-        return "--c++14"
-
-    @property
-    def cxx17_flag(self):
-        return "--c++17"
-
-    @property
-    def stdcxx_libs(self):
-        return ("-c++libs",)
-
-    required_libs = ["libnvc", "libnvf"]

lib/spack/spack/compilers/oneapi.py

@@ -1,172 +0,0 @@
-# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-# Spack Project Developers. See the top-level COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-import os
-from os.path import dirname, join
-
-from llnl.util import tty
-from llnl.util.filesystem import ancestor
-
-import spack.util.executable
-from spack.compiler import Compiler
-from spack.version import Version
-
-
-class Oneapi(Compiler):
-    # Named wrapper links within build_env_path
-    link_paths = {
-        "cc": os.path.join("oneapi", "icx"),
-        "cxx": os.path.join("oneapi", "icpx"),
-        "f77": os.path.join("oneapi", "ifx"),
-        "fc": os.path.join("oneapi", "ifx"),
-    }
-
-    version_argument = "--version"
-    version_regex = r"(?:(?:oneAPI DPC\+\+(?:\/C\+\+)? Compiler)|(?:\(IFORT\))|(?:\(IFX\))) (\S+)"
-
-    @property
-    def verbose_flag(self):
-        return "-v"
-
-    required_libs = [
-        "libirc",
-        "libifcore",
-        "libifcoremt",
-        "libirng",
-        "libsvml",
-        "libintlc",
-        "libimf",
-        "libsycl",
-        "libOpenCL",
-    ]
-
-    @property
-    def debug_flags(self):
-        return ["-debug", "-g", "-g0", "-g1", "-g2", "-g3"]
-
-    @property
-    def opt_flags(self):
-        return ["-O", "-O0", "-O1", "-O2", "-O3", "-Ofast", "-Os"]
-
-    @property
-    def openmp_flag(self):
-        return "-fiopenmp"
-
-    # There may be some additional options here for offload, e.g. :
-    #  -fopenmp-simd           Emit OpenMP code only for SIMD-based constructs.
-    #  -fopenmp-targets=<value>
-    #  -fopenmp-version=<value>
-    #  -fopenmp                Parse OpenMP pragmas and generate parallel code.
-    #  -qno-openmp             Disable OpenMP support
-    #  -qopenmp-link=<value>   Choose whether to link with the static or
-    #                          dynamic OpenMP libraries. Default is dynamic.
-    #  -qopenmp-simd           Emit OpenMP code only for SIMD-based constructs.
-    #  -qopenmp-stubs          enables the user to compile OpenMP programs in
-    #                          sequential mode. The OpenMP directives are
-    #                          ignored and a stub OpenMP library is linked.
-    #  -qopenmp-threadprivate=<value>
-    #  -qopenmp                Parse OpenMP pragmas and generate parallel code.
-    #  -static-openmp          Use the static host OpenMP runtime while
-    #                          linking.
-    #  -Xopenmp-target=<triple> <arg>
-    #  -Xopenmp-target <arg>   Pass <arg> to the target offloading toolchain.
-    # Source: icx --help output
-
-    @property
-    def cxx11_flag(self):
-        return "-std=c++11"
-
-    @property
-    def cxx14_flag(self):
-        return "-std=c++14"
-
-    @property
-    def cxx17_flag(self):
-        return "-std=c++17"
-
-    @property
-    def cxx20_flag(self):
-        return "-std=c++20"
-
-    @property
-    def c99_flag(self):
-        return "-std=c99"
-
-    @property
-    def c11_flag(self):
-        return "-std=c1x"
-
-    @property
-    def cc_pic_flag(self):
-        return "-fPIC"
-
-    @property
-    def cxx_pic_flag(self):
-        return "-fPIC"
-
-    @property
-    def f77_pic_flag(self):
-        return "-fPIC"
-
-    @property
-    def fc_pic_flag(self):
-        return "-fPIC"
-
-    @property
-    def stdcxx_libs(self):
-        return ("-cxxlib",)
-
-    @property
-    def prefix(self):
-        # OneAPI reports its install prefix when running ``--version``
-        # on the line ``InstalledDir: <prefix>/bin/compiler``.
-        cc = spack.util.executable.Executable(self.cc)
-        with self.compiler_environment():
-            oneapi_output = cc("--version", output=str, error=str)
-
-            for line in oneapi_output.splitlines():
-                if line.startswith("InstalledDir:"):
-                    oneapi_prefix = line.split(":")[1].strip()
-                    # Go from <prefix>/bin/compiler to <prefix>
-                    return ancestor(oneapi_prefix, 2)
-
-            raise RuntimeError(
-                "could not find install prefix of OneAPI from output:\n\t{}".format(oneapi_output)
-            )
-
-    def setup_custom_environment(self, pkg, env):
-        # workaround bug in icpx driver where it requires sycl-post-link is on the PATH
-        # It is located in the same directory as the driver. Error message:
-        #   clang++: error: unable to execute command:
-        #   Executable "sycl-post-link" doesn't exist!
-        # also ensures that shared objects and libraries required by the compiler,
-        # e.g. libonnx, can be found succesfully
-        # due to a fix, this is no longer required for OneAPI versions >= 2024.2
-        if self.cxx and pkg.spec.satisfies("%oneapi@:2024.1"):
-            env.prepend_path("PATH", dirname(self.cxx))
-            env.prepend_path("LD_LIBRARY_PATH", join(dirname(dirname(self.cxx)), "lib"))
-
-        # Edge cases for Intel's oneAPI compilers when using the legacy classic compilers:
-        # Always pass flags to disable deprecation warnings, since these warnings can
-        # confuse tools that parse the output of compiler commands (e.g. version checks).
-        # This is really only needed for Fortran, since oneapi@ should be using either
-        # icx+icpx+ifx or icx+icpx+ifort. But to be on the safe side (some users may
-        # want to try to swap icpx against icpc, for example), and since the Intel LLVM
-        # compilers accept these diag-disable flags, we apply them for all compilers.
-        if self.real_version >= Version("2021") and self.real_version < Version("2024"):
-            env.append_flags("SPACK_ALWAYS_CFLAGS", "-diag-disable=10441")
-            env.append_flags("SPACK_ALWAYS_CXXFLAGS", "-diag-disable=10441")
-        if self.real_version >= Version("2021") and self.real_version < Version("2025"):
-            env.append_flags("SPACK_ALWAYS_FFLAGS", "-diag-disable=10448")
-
-        # 2024 release bumped the libsycl version because of an ABI
-        # change, 2024 compilers are required.  You will see this
-        # error:
-        #
-        # /usr/bin/ld: warning: libsycl.so.7, needed by ...., not found
-        if pkg.spec.satisfies("%oneapi@:2023"):
-            for c in ["dnn"]:
-                if pkg.spec.satisfies(f"^intel-oneapi-{c}@2024:"):
-                    tty.warn(f"intel-oneapi-{c}@2024 SYCL APIs requires %oneapi@2024:")

lib/spack/spack/compilers/rocmcc.py

@@ -1,54 +0,0 @@
-# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-# Spack Project Developers. See the top-level COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-import re
-
-import llnl.util.lang
-
-import spack.compilers.clang
-
-
-class Rocmcc(spack.compilers.clang.Clang):
-    @property
-    def link_paths(self):
-        link_paths = {
-            "cc": "rocmcc/amdclang",
-            "cxx": "rocmcc/amdclang++",
-            "f77": "rocmcc/amdflang",
-            "fc": "rocmcc/amdflang",
-        }
-
-        return link_paths
-
-    @property
-    def cxx11_flag(self):
-        return "-std=c++11"
-
-    @property
-    def cxx14_flag(self):
-        return "-std=c++14"
-
-    @property
-    def cxx17_flag(self):
-        return "-std=c++17"
-
-    @property
-    def c99_flag(self):
-        return "-std=c99"
-
-    @property
-    def c11_flag(self):
-        return "-std=c11"
-
-    @classmethod
-    @llnl.util.lang.memoized
-    def extract_version_from_output(cls, output):
-        match = re.search(r"llvm-project roc-(\d+)[._](\d+)[._](\d+)", output)
-        if match:
-            return ".".join(match.groups())
-
-    @property
-    def stdcxx_libs(self):
-        return ("-lstdc++",)

lib/spack/spack/compilers/xl.py

@@ -1,93 +0,0 @@
-# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-# Spack Project Developers. See the top-level COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-import os
-
-from spack.compiler import Compiler, UnsupportedCompilerFlag
-from spack.version import Version
-
-
-class Xl(Compiler):
-    # Named wrapper links within build_env_path
-    link_paths = {
-        "cc": os.path.join("xl", "xlc"),
-        "cxx": os.path.join("xl", "xlc++"),
-        "f77": os.path.join("xl", "xlf"),
-        "fc": os.path.join("xl", "xlf90"),
-    }
-
-    version_argument = "-qversion"
-    version_regex = r"([0-9]?[0-9]\.[0-9])"
-
-    @property
-    def verbose_flag(self):
-        return "-V"
-
-    @property
-    def debug_flags(self):
-        return ["-g", "-g0", "-g1", "-g2", "-g8", "-g9"]
-
-    @property
-    def opt_flags(self):
-        return ["-O", "-O0", "-O1", "-O2", "-O3", "-O4", "-O5", "-Ofast"]
-
-    @property
-    def openmp_flag(self):
-        return "-qsmp=omp"
-
-    @property
-    def cxx11_flag(self):
-        if self.real_version < Version("13.1"):
-            raise UnsupportedCompilerFlag(self, "the C++11 standard", "cxx11_flag", "< 13.1")
-        else:
-            return "-qlanglvl=extended0x"
-
-    @property
-    def c99_flag(self):
-        if self.real_version >= Version("13.1.1"):
-            return "-std=gnu99"
-        if self.real_version >= Version("10.1"):
-            return "-qlanglvl=extc99"
-        raise UnsupportedCompilerFlag(self, "the C99 standard", "c99_flag", "< 10.1")
-
-    @property
-    def c11_flag(self):
-        if self.real_version >= Version("13.1.2"):
-            return "-std=gnu11"
-        if self.real_version >= Version("12.1"):
-            return "-qlanglvl=extc1x"
-        raise UnsupportedCompilerFlag(self, "the C11 standard", "c11_flag", "< 12.1")
-
-    @property
-    def cxx14_flag(self):
-        # .real_version does not have the "y.z" component of "w.x.y.z", which
-        # is required to distinguish whether support is available
-        if self.version >= Version("16.1.1.8"):
-            return "-std=c++14"
-        raise UnsupportedCompilerFlag(self, "the C++14 standard", "cxx14_flag", "< 16.1.1.8")
-
-    @property
-    def cc_pic_flag(self):
-        return "-qpic"
-
-    @property
-    def cxx_pic_flag(self):
-        return "-qpic"
-
-    @property
-    def f77_pic_flag(self):
-        return "-qpic"
-
-    @property
-    def fc_pic_flag(self):
-        return "-qpic"
-
-    @property
-    def fflags(self):
-        # The -qzerosize flag is effective only for the Fortran 77
-        # compilers and allows the use of zero size objects.
-        # For Fortran 90 and beyond, it is set by default and has not impact.
-        # Its use has no negative side effects.
-        return "-qzerosize"

lib/spack/spack/compilers/xl_r.py

@@ -1,18 +0,0 @@
-# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
-# Spack Project Developers. See the top-level COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-import os
-
-import spack.compilers.xl
-
-
-class XlR(spack.compilers.xl.Xl):
-    # Named wrapper links within build_env_path
-    link_paths = {
-        "cc": os.path.join("xl_r", "xlc_r"),
-        "cxx": os.path.join("xl_r", "xlc++_r"),
-        "f77": os.path.join("xl_r", "xlf_r"),
-        "fc": os.path.join("xl_r", "xlf90_r"),
-    }

lib/spack/spack/concretize.py

@@ -11,6 +11,7 @@
 import llnl.util.tty as tty
 
 import spack.compilers
+import spack.compilers.config
 import spack.config
 import spack.error
 import spack.repo
@@ -146,7 +147,7 @@ def concretize_separately(
 
     # Ensure we have compilers in compilers.yaml to avoid that
     # processes try to write the config file in parallel
-    _ = spack.compilers.all_compilers_config(spack.config.CONFIG)
+    _ = spack.compilers.config.all_compilers_from(spack.config.CONFIG)
 
     # Early return if there is nothing to do
     if len(args) == 0:

lib/spack/spack/config.py

@@ -715,6 +715,9 @@ def print_section(self, section: str, blame: bool = False, *, scope=None) -> Non
             raise spack.error.ConfigError(f"cannot read '{section}' configuration") from e
 
 
+ConfigurationType = Union[Configuration, lang.Singleton]
+
+
 @contextlib.contextmanager
 def override(
     path_or_scope: Union[ConfigScope, str], value: Optional[Any] = None

lib/spack/spack/cray_manifest.py

@@ -14,7 +14,7 @@
 import llnl.util.tty as tty
 
 import spack.cmd
-import spack.compilers
+import spack.compilers.config
 import spack.deptypes as dt
 import spack.error
 import spack.hash_types as hash_types
@@ -28,13 +28,13 @@
 #: packages here.
 default_path = "/opt/cray/pe/cpe-descriptive-manifest/"
 
-compiler_name_translation = {"nvidia": "nvhpc", "rocm": "rocmcc"}
+compiler_name_translation = {"nvidia": "nvhpc", "rocm": "rocmcc", "clang": "llvm"}
 
 
 def translated_compiler_name(manifest_compiler_name):
     """
     When creating a Compiler object, Spack expects a name matching
-    one of the classes in `spack.compilers`. Names in the Cray manifest
+    one of the classes in `spack.compilers.config`. Names in the Cray manifest
     may differ; for cases where we know the name refers to a compiler in
     Spack, this function translates it automatically.
 
@@ -43,25 +43,25 @@ def translated_compiler_name(manifest_compiler_name):
     """
     if manifest_compiler_name in compiler_name_translation:
         return compiler_name_translation[manifest_compiler_name]
-    elif manifest_compiler_name in spack.compilers.supported_compilers():
+    elif manifest_compiler_name in spack.compilers.config.supported_compilers():
         return manifest_compiler_name
     else:
-        raise spack.compilers.UnknownCompilerError(
+        raise spack.compilers.config.UnknownCompilerError(
             "Manifest parsing - unknown compiler: {0}".format(manifest_compiler_name)
         )
 
 
-def compiler_from_entry(entry: dict, manifest_path: str):
+def compiler_from_entry(entry: dict, *, manifest_path: str) -> "spack.spec.Spec":
     # Note that manifest_path is only passed here to compose a
     # useful warning message when paths appear to be missing.
     compiler_name = translated_compiler_name(entry["name"])
 
+    prefix = None
     if "prefix" in entry:
         prefix = entry["prefix"]
-        paths = dict(
-            (lang, os.path.join(prefix, relpath))
-            for (lang, relpath) in entry["executables"].items()
-        )
+        paths = {
+            lang: os.path.join(prefix, relpath) for lang, relpath in entry["executables"].items()
+        }
     else:
         paths = entry["executables"]
 
@@ -75,25 +75,38 @@ def compiler_from_entry(entry: dict, manifest_path: str):
             missing_paths.append(path)
 
     # to instantiate a compiler class we may need a concrete version:
-    version = "={}".format(entry["version"])
     arch = entry["arch"]
     operating_system = arch["os"]
     target = arch["target"]
+    spec_str = f"{compiler_name}@={entry['version']} os={operating_system} target={target}"
 
-    compiler_cls = spack.compilers.class_for_compiler_name(compiler_name)
-    spec = spack.spec.CompilerSpec(compiler_cls.name, version)
-    path_list = [paths.get(x, None) for x in ("cc", "cxx", "f77", "fc")]
+    compilers = {}
+    for x in ("cc", "cxx", "fc"):
+        language = {"cc": "c", "fc": "fortran"}
+        if x not in paths:
+            continue
+
+        if prefix is None:
+            prefix = os.path.dirname(paths[x])
+
+        compilers[language.get(x, x)] = paths[x]
 
     if missing_paths:
         warnings.warn(
             "Manifest entry refers to nonexistent paths:\n\t"
             + "\n\t".join(missing_paths)
-            + f"\nfor {str(spec)}"
+            + f"\nfor {spec_str}"
             + f"\nin {manifest_path}"
             + "\nPlease report this issue"
         )
 
-    return compiler_cls(spec, operating_system, target, path_list)
+    assert prefix is not None, "compiler prefix must be set"
+    result = spack.spec.Spec(
+        str(spack.spec.parse_with_version_concrete(spec_str)), external_path=prefix
+    )
+    result.extra_attributes = {"compilers": compilers}
+    result._finalize_concretization()
+    return result
 
 
 def spec_from_entry(entry):
@@ -121,7 +134,7 @@ def spec_from_entry(entry):
             version=entry["compiler"]["version"],
         )
 
-    spec_format = "{name}@={version} {compiler} {arch}"
+    spec_format = "{name}@={version} {arch}"
     spec_str = spec_format.format(
         name=entry["name"], version=entry["version"], compiler=compiler_str, arch=arch_str
     )
@@ -182,6 +195,7 @@ def entries_to_specs(entries):
     for entry in entries:
         try:
             spec = spec_from_entry(entry)
+            assert spec.concrete, f"{spec} is not concrete"
             spec_dict[spec._hash] = spec
         except spack.repo.UnknownPackageError:
             tty.debug("Omitting package {0}: no corresponding repo package".format(entry["name"]))
@@ -222,23 +236,24 @@ def read(path, apply_updates):
     tty.debug("{0}: {1} specs read from manifest".format(path, str(len(specs))))
     compilers = list()
     if "compilers" in json_data:
-        compilers.extend(compiler_from_entry(x, path) for x in json_data["compilers"])
-    tty.debug("{0}: {1} compilers read from manifest".format(path, str(len(compilers))))
+        compilers.extend(
+            compiler_from_entry(x, manifest_path=path) for x in json_data["compilers"]
+        )
+    tty.debug(f"{path}: {str(len(compilers))} compilers read from manifest")
     # Filter out the compilers that already appear in the configuration
-    compilers = spack.compilers.select_new_compilers(compilers)
+    compilers = spack.compilers.config.select_new_compilers(compilers)
     if apply_updates and compilers:
-        for compiler in compilers:
-            try:
-                spack.compilers.add_compilers_to_config([compiler])
-            except Exception:
-                warnings.warn(
-                    f"Could not add compiler {str(compiler.spec)}: "
-                    f"\n\tfrom manifest: {path}"
-                    "\nPlease reexecute with 'spack -d' and include the stack trace"
-                )
-                tty.debug(f"Include this\n{traceback.format_exc()}")
+        try:
+            spack.compilers.config.add_compiler_to_config(compilers)
+        except Exception:
+            warnings.warn(
+                f"Could not add compilers from manifest: {path}"
+                "\nPlease reexecute with 'spack -d' and include the stack trace"
+            )
+            tty.debug(f"Include this\n{traceback.format_exc()}")
     if apply_updates:
         for spec in specs.values():
+            assert spec.concrete, f"{spec} is not concrete"
             spack.store.STORE.db.add(spec)
 
 

lib/spack/spack/database.py

@@ -80,7 +80,7 @@
 #: DB version.  This is stuck in the DB file to track changes in format.
 #: Increment by one when the database format changes.
 #: Versions before 5 were not integers.
-_DB_VERSION = vn.Version("7")
+_DB_VERSION = vn.Version("8")
 
 #: For any version combinations here, skip reindex when upgrading.
 #: Reindexing can take considerable time and is not always necessary.
@@ -93,6 +93,8 @@
     (vn.Version("0.9.3"), vn.Version("5")),
     (vn.Version("5"), vn.Version("6")),
     (vn.Version("6"), vn.Version("7")),
+    (vn.Version("6"), vn.Version("8")),
+    (vn.Version("7"), vn.Version("8")),
 ]
 
 #: Default timeout for spack database locks in seconds or None (no timeout).
@@ -141,6 +143,7 @@ def reader(version: vn.StandardVersion) -> Type["spack.spec.SpecfileReaderBase"]
         vn.Version("5"): spack.spec.SpecfileV1,
         vn.Version("6"): spack.spec.SpecfileV3,
         vn.Version("7"): spack.spec.SpecfileV4,
+        vn.Version("8"): spack.spec.SpecfileV5,
     }
     return reader_cls[version]
 

lib/spack/spack/directives.py

@@ -86,9 +86,6 @@ class OpenMpi(Package):
 PatchesType = Union[Patcher, str, List[Union[Patcher, str]]]
 
 
-SUPPORTED_LANGUAGES = ("fortran", "cxx", "c")
-
-
 def _make_when_spec(value: WhenType) -> Optional[spack.spec.Spec]:
     """Create a ``Spec`` that indicates when a directive should be applied.
 
@@ -367,9 +364,6 @@ def depends_on(
 
     """
     dep_spec = spack.spec.Spec(spec)
-    if dep_spec.name in SUPPORTED_LANGUAGES:
-        assert type == "build", "languages must be of 'build' type"
-        return _language(lang_spec_str=spec, when=when)
 
     def _execute_depends_on(pkg: Type[spack.package_base.PackageBase]):
         _depends_on(pkg, dep_spec, when=when, type=type, patches=patches)
@@ -905,21 +899,6 @@ def _execute_requires(pkg: Type[spack.package_base.PackageBase]):
     return _execute_requires
 
 
-@directive("languages")
-def _language(lang_spec_str: str, *, when: Optional[Union[str, bool]] = None):
-    """Temporary implementation of language virtuals, until compilers are proper dependencies."""
-
-    def _execute_languages(pkg: Type[spack.package_base.PackageBase]):
-        when_spec = _make_when_spec(when)
-        if not when_spec:
-            return
-
-        languages = pkg.languages.setdefault(when_spec, set())
-        languages.add(lang_spec_str)
-
-    return _execute_languages
-
-
 class DependencyError(DirectiveError):
     """This is raised when a dependency specification is invalid."""
 

lib/spack/spack/directory_layout.py

@@ -23,7 +23,7 @@
 from spack.error import SpackError
 
 default_projections = {
-    "all": "{architecture}/{compiler.name}-{compiler.version}/{name}-{version}-{hash}"
+    "all": "{architecture.platform}/{architecture.target}/{name}-{version}-{hash}"
 }
 
 

lib/spack/spack/environment/depfile.py

@@ -166,9 +166,7 @@ def __init__(
                 item.target.safe_name(),
                 " ".join(self._install_target(s.safe_name()) for s in item.prereqs),
                 item.target.spec_hash(),
-                item.target.unsafe_format(
-                    "{name}{@version}{%compiler}{variants}{arch=architecture}"
-                ),
+                item.target.unsafe_format("{name}{@version}{variants}{ arch=architecture}"),
                 item.buildcache_flag,
             )
             for item in adjacency_list

lib/spack/spack/environment/environment.py

@@ -135,7 +135,7 @@ def default_manifest_yaml():
 valid_environment_name_re = r"^\w[\w-]*$"
 
 #: version of the lockfile format. Must increase monotonically.
-lockfile_format_version = 5
+lockfile_format_version = 6
 
 
 READER_CLS = {
@@ -144,6 +144,7 @@ def default_manifest_yaml():
     3: spack.spec.SpecfileV2,
     4: spack.spec.SpecfileV3,
     5: spack.spec.SpecfileV4,
+    6: spack.spec.SpecfileV5,
 }
 
 

lib/spack/spack/mixins.py

@@ -71,12 +71,16 @@ def _filter_compiler_wrappers_impl(pkg_or_builder):
 
         x = llnl.util.filesystem.FileFilter(*abs_files)
 
-        compiler_vars = [
-            ("CC", pkg.compiler.cc),
-            ("CXX", pkg.compiler.cxx),
-            ("F77", pkg.compiler.f77),
-            ("FC", pkg.compiler.fc),
-        ]
+        compiler_vars = []
+        if "c" in pkg.spec:
+            compiler_vars.append(("CC", pkg.spec["c"].package.cc))
+
+        if "cxx" in pkg.spec:
+            compiler_vars.append(("CXX", pkg.spec["cxx"].package.cxx))
+
+        if "fortran" in pkg.spec:
+            compiler_vars.append(("FC", pkg.spec["fortran"].package.fortran))
+            compiler_vars.append(("F77", pkg.spec["fortran"].package.fortran))
 
         # Some paths to the compiler wrappers might be substrings of the others.
         # For example:
@@ -104,7 +108,11 @@ def _filter_compiler_wrappers_impl(pkg_or_builder):
             x.filter(wrapper_path, compiler_path, **filter_kwargs)
 
         # Remove this linking flag if present (it turns RPATH into RUNPATH)
-        x.filter("{0}--enable-new-dtags".format(pkg.compiler.linker_arg), "", **filter_kwargs)
+        for compiler_lang in ("c", "cxx", "fortran"):
+            if compiler_lang not in pkg.spec:
+                continue
+            compiler_pkg = pkg.spec[compiler_lang].package
+            x.filter(f"{compiler_pkg.linker_arg}--enable-new-dtags", "", **filter_kwargs)
 
         # NAG compiler is usually mixed with GCC, which has a different
         # prefix for linker arguments.

lib/spack/spack/modules/common.py

@@ -330,18 +330,17 @@ class BaseConfiguration:
     default_projections = {"all": "{name}/{version}-{compiler.name}-{compiler.version}"}
 
     def __init__(self, spec: spack.spec.Spec, module_set_name: str, explicit: bool) -> None:
-        # Module where type(self) is defined
-        m = inspect.getmodule(self)
-        assert m is not None  # make mypy happy
-        self.module = m
         # Spec for which we want to generate a module file
         self.spec = spec
         self.name = module_set_name
         self.explicit = explicit
-        # Dictionary of configuration options that should be applied
-        # to the spec
+        # Dictionary of configuration options that should be applied to the spec
         self.conf = merge_config_rules(self.module.configuration(self.name), self.spec)
 
+    @property
+    def module(self):
+        return inspect.getmodule(self)
+
     @property
     def projections(self):
         """Projection from specs to module names"""

lib/spack/spack/modules/lmod.py

@@ -6,12 +6,13 @@
 import collections
 import itertools
 import os.path
+import pathlib
 from typing import Dict, List, Optional, Tuple
 
 import llnl.util.filesystem as fs
 import llnl.util.lang as lang
 
-import spack.compilers
+import spack.compilers.config
 import spack.config
 import spack.error
 import spack.repo
@@ -59,7 +60,7 @@ def make_context(
     return LmodContext(make_configuration(spec, module_set_name, explicit))
 
 
-def guess_core_compilers(name, store=False) -> List[spack.spec.CompilerSpec]:
+def guess_core_compilers(name, store=False) -> List[spack.spec.Spec]:
     """Guesses the list of core compilers installed in the system.
 
     Args:
@@ -70,16 +71,12 @@ def guess_core_compilers(name, store=False) -> List[spack.spec.CompilerSpec]:
         List of found core compilers
     """
     core_compilers = []
-    for compiler in spack.compilers.all_compilers():
+    for compiler in spack.compilers.config.all_compilers():
         try:
-            # A compiler is considered to be a core compiler if any of the
-            # C, C++ or Fortran compilers reside in a system directory
-            is_system_compiler = any(
-                os.path.dirname(getattr(compiler, x, "")) in spack.util.environment.SYSTEM_DIRS
-                for x in ("cc", "cxx", "f77", "fc")
-            )
+            cc_dir = pathlib.Path(compiler.package.cc).parent
+            is_system_compiler = str(cc_dir) in spack.util.environment.SYSTEM_DIRS
             if is_system_compiler:
-                core_compilers.append(compiler.spec)
+                core_compilers.append(compiler)
         except (KeyError, TypeError, AttributeError):
             continue
 
@@ -101,18 +98,32 @@ class LmodConfiguration(BaseConfiguration):
 
     default_projections = {"all": "{name}/{version}"}
 
+    def __init__(self, spec: spack.spec.Spec, module_set_name: str, explicit: bool) -> None:
+        super().__init__(spec, module_set_name, explicit)
+
+        # FIXME (compiler as nodes): make this a bit more robust
+        candidates = collections.defaultdict(list)
+        for node in spec.traverse(deptype=("link", "run")):
+            candidates["c"].extend(node.dependencies(virtuals="c"))
+            candidates["cxx"].extend(node.dependencies(virtuals="c"))
+
+        # FIXME (compiler as nodes): decide what to do when we have more than one C compiler
+        if candidates["c"] and len(set(candidates["c"])) == 1:
+            self.compiler = candidates["c"][0]
+        elif not candidates["c"]:
+            self.compiler = None
+
     @property
-    def core_compilers(self) -> List[spack.spec.CompilerSpec]:
+    def core_compilers(self) -> List[spack.spec.Spec]:
         """Returns the list of "Core" compilers
 
         Raises:
-            CoreCompilersNotFoundError: if the key was not
-                specified in the configuration file or the sequence
-                is empty
+            CoreCompilersNotFoundError: if the key was not specified in the configuration file or
+                the sequence is empty
         """
-        compilers = [
-            spack.spec.CompilerSpec(c) for c in configuration(self.name).get("core_compilers", [])
-        ]
+        compilers = []
+        for c in configuration(self.name).get("core_compilers", []):
+            compilers.extend(spack.spec.Spec(f"%{c}").dependencies())
 
         if not compilers:
             compilers = guess_core_compilers(self.name, store=True)
@@ -161,12 +172,15 @@ def hierarchy_tokens(self):
     @property
     @lang.memoized
     def requires(self):
-        """Returns a dictionary mapping all the requirements of this spec
-        to the actual provider. 'compiler' is always present among the
-        requirements.
+        """Returns a dictionary mapping all the requirements of this spec to the actual provider.
+
+        The 'compiler' key is always present among the requirements.
         """
         # If it's a core_spec, lie and say it requires a core compiler
-        if any(self.spec.satisfies(core_spec) for core_spec in self.core_specs):
+        if (
+            any(self.spec.satisfies(core_spec) for core_spec in self.core_specs)
+            or self.compiler is None
+        ):
             return {"compiler": self.core_compilers[0]}
 
         hierarchy_filter_list = []
@@ -177,7 +191,8 @@ def requires(self):
 
         # Keep track of the requirements that this package has in terms
         # of virtual packages that participate in the hierarchical structure
-        requirements = {"compiler": self.spec.compiler}
+
+        requirements = {"compiler": self.compiler}
         # For each virtual dependency in the hierarchy
         for x in self.hierarchy_tokens:
             # Skip anything filtered for this spec
@@ -200,17 +215,17 @@ def provides(self):
         # virtual dependencies in spack
 
         # If it is in the list of supported compilers family -> compiler
-        if self.spec.name in spack.compilers.supported_compilers():
-            provides["compiler"] = spack.spec.CompilerSpec(self.spec.format("{name}{@versions}"))
-        elif self.spec.name in spack.compilers.package_name_to_compiler_name:
+        if self.spec.name in spack.compilers.config.supported_compilers():
+            provides["compiler"] = spack.spec.Spec(self.spec.format("{name}{@versions}"))
+        elif self.spec.name in spack.compilers.config.package_name_to_compiler_name:
             # If it is the package for a supported compiler, but of a different name
-            cname = spack.compilers.package_name_to_compiler_name[self.spec.name]
-            provides["compiler"] = spack.spec.CompilerSpec(cname, self.spec.versions)
+            cname = spack.compilers.config.package_name_to_compiler_name[self.spec.name]
+            provides["compiler"] = spack.spec.Spec(cname, self.spec.versions)
 
         # All the other tokens in the hierarchy must be virtual dependencies
         for x in self.hierarchy_tokens:
             if self.spec.package.provides(x):
-                provides[x] = self.spec[x]
+                provides[x] = self.spec
         return provides
 
     @property
@@ -301,12 +316,10 @@ def path_part_fmt(token):
 
         # If we are dealing with a core compiler, return 'Core'
         core_compilers = self.conf.core_compilers
-        if name == "compiler" and any(
-            spack.spec.CompilerSpec(value).satisfies(c) for c in core_compilers
-        ):
+        if name == "compiler" and any(spack.spec.Spec(value).satisfies(c) for c in core_compilers):
             return "Core"
 
-        # CompilerSpec does not have a hash, as we are not allowed to
+        # Spec does not have a hash, as we are not allowed to
         # use different flavors of the same compiler
         if name == "compiler":
             return path_part_fmt(token=value)

lib/spack/spack/package_base.py

@@ -32,7 +32,6 @@
 from llnl.util.lang import classproperty, memoized
 from llnl.util.link_tree import LinkTree
 
-import spack.compilers
 import spack.config
 import spack.dependency
 import spack.deptypes as dt
@@ -53,6 +52,7 @@
 import spack.util.path
 import spack.util.web
 import spack.variant
+from spack.compilers.adaptor import DeprecatedCompiler
 from spack.error import InstallError, NoURLError, PackageError
 from spack.filesystem_view import YamlFilesystemView
 from spack.resource import Resource
@@ -66,10 +66,9 @@
 ]
 FLAG_HANDLER_TYPE = Callable[[str, Iterable[str]], FLAG_HANDLER_RETURN_TYPE]
 
-"""Allowed URL schemes for spack packages."""
+#: Allowed URL schemes for spack packages
 _ALLOWED_URL_SCHEMES = ["http", "https", "ftp", "file", "git"]
 
-
 #: Filename for the Spack build/install log.
 _spack_build_logfile = "spack-build-out.txt"
 
@@ -580,6 +579,8 @@ class PackageBase(WindowsRPath, PackageViewMixin, metaclass=PackageMeta):
 
     """
 
+    compiler = DeprecatedCompiler()
+
     #
     # These are default values for instance variables.
     #
@@ -1498,15 +1499,6 @@ def prefix(self):
     def home(self):
         return self.prefix
 
-    @property  # type: ignore[misc]
-    @memoized
-    def compiler(self):
-        """Get the spack.compiler.Compiler object used to build this package"""
-        if not self.spec.concrete:
-            raise ValueError("Can only get a compiler for a concrete package.")
-
-        return spack.compilers.compiler_for_spec(self.spec.compiler, self.spec.architecture)
-
     def url_version(self, version):
         """
         Given a version, this returns a string that should be substituted
@@ -1618,7 +1610,7 @@ def do_stage(self, mirror_only=False):
         self.stage.create()
 
         # Fetch/expand any associated code.
-        if self.has_code:
+        if self.has_code and not self.spec.external:
             self.do_fetch(mirror_only)
             self.stage.expand_archive()
         else:
@@ -1948,17 +1940,14 @@ def _resource_stage(self, resource):
         return resource_stage_folder
 
     def do_test(self, dirty=False, externals=False):
-        if self.test_requires_compiler:
-            compilers = spack.compilers.compilers_for_spec(
-                self.spec.compiler, arch_spec=self.spec.architecture
+        if self.test_requires_compiler and not any(
+            lang in self.spec for lang in ("c", "cxx", "fortran")
+        ):
+            tty.error(
+                f"Skipping tests for package {self.spec}, since a compiler is required, "
+                f"but not available"
             )
-            if not compilers:
-                tty.error(
-                    "Skipping tests for package %s\n"
-                    % self.spec.format("{name}-{version}-{hash:7}")
-                    + "Package test requires missing compiler %s" % self.spec.compiler
-                )
-                return
+            return
 
         kwargs = {
             "dirty": dirty,

lib/spack/spack/parser.py

@@ -375,12 +375,11 @@ def all_specs(self) -> List["spack.spec.Spec"]:
 class SpecNodeParser:
     """Parse a single spec node from a stream of tokens"""
 
-    __slots__ = "ctx", "has_compiler", "has_version", "literal_str"
+    __slots__ = "ctx", "has_version", "literal_str"
 
     def __init__(self, ctx, literal_str):
         self.ctx = ctx
         self.literal_str = literal_str
-        self.has_compiler = False
         self.has_version = False
 
     def parse(
@@ -427,23 +426,24 @@ def add_flag(name: str, value: str, propagate: bool):
                 raise_parsing_error(str(e), e)
 
         while True:
-            if self.ctx.accept(TokenType.COMPILER):
-                if self.has_compiler:
-                    raise_parsing_error("Spec cannot have multiple compilers")
+            if self.ctx.accept(TokenType.COMPILER) or self.ctx.accept(
+                TokenType.COMPILER_AND_VERSION
+            ):
+                build_dependency = spack.spec.Spec(self.ctx.current_token.value[1:])
+                name_conversion = {
+                    "clang": "llvm",
+                    "oneapi": "intel-oneapi-compilers",
+                    "rocmcc": "llvm-amdgpu",
+                    "intel": "intel-oneapi-compiler-classic",
+                    "arm": "acfl",
+                }
 
-                compiler_name = self.ctx.current_token.value[1:]
-                initial_spec.compiler = spack.spec.CompilerSpec(compiler_name.strip(), ":")
-                self.has_compiler = True
+                if build_dependency.name in name_conversion:
+                    build_dependency.name = name_conversion[build_dependency.name]
 
-            elif self.ctx.accept(TokenType.COMPILER_AND_VERSION):
-                if self.has_compiler:
-                    raise_parsing_error("Spec cannot have multiple compilers")
-
-                compiler_name, compiler_version = self.ctx.current_token.value[1:].split("@")
-                initial_spec.compiler = spack.spec.CompilerSpec(
-                    compiler_name.strip(), compiler_version
+                initial_spec._add_dependency(
+                    build_dependency, depflag=spack.deptypes.BUILD, virtuals=(), direct=True
                 )
-                self.has_compiler = True
 
             elif (
                 self.ctx.accept(TokenType.VERSION_HASH_PAIR)

lib/spack/spack/provider_index.py

@@ -240,9 +240,10 @@ def from_json(stream, repository):
         providers = data["provider_index"]["providers"]
         index.providers = _transform(
             providers,
+            # FIXME (compiler as nodes): avoid to hard-code the Specfile version
             lambda vpkg, plist: (
-                spack.spec.SpecfileV4.from_node_dict(vpkg),
-                set(spack.spec.SpecfileV4.from_node_dict(p) for p in plist),
+                spack.spec.SpecfileV5.from_node_dict(vpkg),
+                set(spack.spec.SpecfileV5.from_node_dict(p) for p in plist),
             ),
         )
         return index

lib/spack/spack/report.py

@@ -78,7 +78,6 @@ def __enter__(self):
                 "packages": [],
             }
             spec_record["properties"].append(Property("architecture", input_spec.architecture))
-            spec_record["properties"].append(Property("compiler", input_spec.compiler))
             self.init_spec_record(input_spec, spec_record)
             self.specs.append(spec_record)
 

lib/spack/spack/reporters/cdash.py

@@ -173,7 +173,7 @@ def build_report_for_package(self, report_dir, package, duration):
         # something went wrong pre-cdash "configure" phase b/c we have an exception and only
         # "update" was encounterd.
         # dump the report in the configure line so teams can see what the issue is
-        if len(phases_encountered) == 1 and package["exception"]:
+        if len(phases_encountered) == 1 and package.get("exception"):
             # TODO this mapping is not ideal since these are pre-configure errors
             # we need to determine if a more appropriate cdash phase can be utilized
             # for now we will add a message to the log explaining this

lib/spack/spack/schema/packages.py

@@ -139,6 +139,15 @@
                     },
                     "variants": variants,
                 },
+                "deprecatedProperties": [
+                    {
+                        "names": ["compiler"],
+                        "message": "The packages:all:compiler preference has been deprecated in "
+                        "Spack v0.24, and is currently ignored. It will be removed from config in "
+                        "Spack v0.26.",
+                        "error": False,
+                    }
+                ],
             }
         },
         "patternProperties": {

lib/spack/spack/solver/asp.py

@@ -27,9 +27,8 @@
 
 import spack
 import spack.binary_distribution
-import spack.compiler
-import spack.compilers
-import spack.concretize
+import spack.compilers.config
+import spack.compilers.flags
 import spack.config
 import spack.deptypes as dt
 import spack.environment as ev
@@ -48,6 +47,7 @@
 import spack.version as vn
 import spack.version.git_ref_lookup
 from spack import traverse
+from spack.compilers.libraries import CompilerPropertyDetector
 
 from .core import (
     AspFunction,
@@ -70,9 +70,6 @@
 
 TransformFunction = Callable[["spack.spec.Spec", List[AspFunction]], List[AspFunction]]
 
-#: Enable the addition of a runtime node
-WITH_RUNTIME = sys.platform != "win32"
-
 #: Data class that contain configuration on what a
 #: clingo solve should output.
 #:
@@ -283,12 +280,11 @@ def _create_counter(specs: List[spack.spec.Spec], tests: bool):
 def all_libcs() -> Set[spack.spec.Spec]:
     """Return a set of all libc specs targeted by any configured compiler. If none, fall back to
     libc determined from the current Python process if dynamically linked."""
-
-    libcs = {
-        c.default_libc
-        for c in spack.compilers.all_compilers_from(spack.config.CONFIG)
-        if c.default_libc
-    }
+    libcs = set()
+    for c in spack.compilers.config.all_compilers_from(spack.config.CONFIG):
+        candidate = CompilerPropertyDetector(c).default_libc()
+        if candidate is not None:
+            libcs.add(candidate)
 
     if libcs:
         return libcs
@@ -297,7 +293,7 @@ def all_libcs() -> Set[spack.spec.Spec]:
     return {libc} if libc else set()
 
 
-def libc_is_compatible(lhs: spack.spec.Spec, rhs: spack.spec.Spec) -> List[spack.spec.Spec]:
+def libc_is_compatible(lhs: spack.spec.Spec, rhs: spack.spec.Spec) -> bool:
     return (
         lhs.name == rhs.name
         and lhs.external_path == rhs.external_path
@@ -310,8 +306,8 @@ def using_libc_compatibility() -> bool:
     return spack.platforms.host().name == "linux"
 
 
-def c_compiler_runs(compiler: spack.compiler.Compiler) -> bool:
-    return compiler.compiler_verbose_output is not None
+def c_compiler_runs(compiler) -> bool:
+    return CompilerPropertyDetector(compiler).compiler_verbose_output() is not None
 
 
 def extend_flag_list(flag_list, new_flags):
@@ -601,10 +597,12 @@ def _external_config_with_implicit_externals(configuration):
     if not using_libc_compatibility():
         return packages_yaml
 
-    for compiler in spack.compilers.all_compilers_from(configuration):
-        libc = compiler.default_libc
-        if libc:
-            entry = {"spec": f"{libc} %{compiler.spec}", "prefix": libc.external_path}
+    seen = set()
+    for compiler in spack.compilers.config.all_compilers_from(configuration):
+        libc = CompilerPropertyDetector(compiler).default_libc()
+        if libc and libc not in seen:
+            seen.add(libc)
+            entry = {"spec": f"{libc}", "prefix": libc.external_path}
             packages_yaml.setdefault(libc.name, {}).setdefault("externals", []).append(entry)
     return packages_yaml
 
@@ -745,27 +743,6 @@ def on_model(model):
         raise UnsatisfiableSpecError(msg)
 
 
-class KnownCompiler(NamedTuple):
-    """Data class to collect information on compilers"""
-
-    spec: "spack.spec.Spec"
-    os: str
-    target: str
-    available: bool
-    compiler_obj: Optional["spack.compiler.Compiler"]
-
-    def _key(self):
-        return self.spec, self.os, self.target
-
-    def __eq__(self, other: object):
-        if not isinstance(other, KnownCompiler):
-            return NotImplemented
-        return self._key() == other._key()
-
-    def __hash__(self):
-        return hash(self._key())
-
-
 class PyclingoDriver:
     def __init__(self, cores=True):
         """Driver for the Python clingo interface.
@@ -1062,13 +1039,13 @@ class SourceContext:
     Facts generated for the spec may include this context.
     """
 
-    def __init__(self):
+    def __init__(self, *, source: Optional[str] = None):
         # This can be "literal" for constraints that come from a user
         # spec (e.g. from the command line); it can be the output of
         # `ConstraintOrigin.append_type_suffix`; the default is "none"
         # (which means it isn't important to keep track of the source
         # in that case).
-        self.source = "none"
+        self.source = "none" if source is None else source
 
 
 class ConditionIdContext(SourceContext):
@@ -1262,16 +1239,6 @@ def conflict_rules(self, pkg):
                 )
                 self.gen.newline()
 
-    def package_languages(self, pkg):
-        for when_spec, languages in pkg.languages.items():
-            condition_msg = f"{pkg.name} needs the {', '.join(sorted(languages))} language"
-            if when_spec != spack.spec.Spec():
-                condition_msg += f" when {when_spec}"
-            condition_id = self.condition(when_spec, required_name=pkg.name, msg=condition_msg)
-            for language in sorted(languages):
-                self.gen.fact(fn.pkg_fact(pkg.name, fn.language(condition_id, language)))
-        self.gen.newline()
-
     def config_compatible_os(self):
         """Facts about compatible os's specified in configs"""
         self.gen.h2("Compatible OS from concretizer config file")
@@ -1281,34 +1248,6 @@ def config_compatible_os(self):
                 self.gen.fact(fn.os_compatible(recent, old))
                 self.gen.newline()
 
-    def compiler_facts(self):
-        """Facts about available compilers."""
-
-        self.gen.h2("Available compilers")
-        for compiler_id, compiler in enumerate(self.possible_compilers):
-            self.gen.fact(fn.compiler_id(compiler_id))
-            self.gen.fact(fn.compiler_name(compiler_id, compiler.spec.name))
-            self.gen.fact(fn.compiler_version(compiler_id, compiler.spec.version))
-
-            if compiler.os:
-                self.gen.fact(fn.compiler_os(compiler_id, compiler.os))
-
-            if compiler.target is not None:
-                self.gen.fact(fn.compiler_target(compiler_id, compiler.target))
-
-            if compiler.compiler_obj is not None:
-                c = compiler.compiler_obj
-                for flag_type, flags in c.flags.items():
-                    flag_group = " ".join(flags)
-                    for flag in flags:
-                        self.gen.fact(fn.compiler_flag(compiler_id, flag_type, flag, flag_group))
-
-            if compiler.available:
-                self.gen.fact(fn.compiler_available(compiler_id))
-
-            self.gen.fact(fn.compiler_weight(compiler_id, compiler_id))
-            self.gen.newline()
-
     def package_requirement_rules(self, pkg):
         self.emit_facts_from_requirement_rules(self.requirement_parser.rules(pkg))
 
@@ -1322,9 +1261,6 @@ def pkg_rules(self, pkg, tests):
         self.pkg_version_rules(pkg)
         self.gen.newline()
 
-        # languages
-        self.package_languages(pkg)
-
         # variants
         self.variant_rules(pkg)
 
@@ -1341,12 +1277,6 @@ def pkg_rules(self, pkg, tests):
         if self.enable_splicing:
             self.package_splice_rules(pkg)
 
-        # virtual preferences
-        self.virtual_preferences(
-            pkg.name,
-            lambda v, p, i: self.gen.fact(fn.pkg_fact(pkg.name, fn.provider_preference(v, p, i))),
-        )
-
         self.package_requirement_rules(pkg)
 
         # trigger and effect tables
@@ -1875,8 +1805,6 @@ def emit_facts_from_requirement_rules(self, rules: List[RequirementRule]):
 
     def external_packages(self):
         """Facts on external packages, from packages.yaml and implicit externals."""
-        packages_yaml = _external_config_with_implicit_externals(spack.config.CONFIG)
-
         self.gen.h1("External packages")
         spec_filters = []
         concretizer_yaml = spack.config.get("concretizer")
@@ -1884,7 +1812,6 @@ def external_packages(self):
         if isinstance(reuse_yaml, typing.Mapping):
             default_include = reuse_yaml.get("include", [])
             default_exclude = reuse_yaml.get("exclude", [])
-            libc_externals = list(all_libcs())
             for source in reuse_yaml.get("from", []):
                 if source["type"] != "external":
                     continue
@@ -1892,7 +1819,7 @@ def external_packages(self):
                 include = source.get("include", default_include)
                 if include:
                     # Since libcs are implicit externals, we need to implicitly include them
-                    include = include + libc_externals
+                    include = include + self.libcs
                 exclude = source.get("exclude", default_exclude)
                 spec_filters.append(
                     SpecFilter(
@@ -1903,6 +1830,7 @@ def external_packages(self):
                     )
                 )
 
+        packages_yaml = _external_config_with_implicit_externals(spack.config.CONFIG)
         for pkg_name, data in packages_yaml.items():
             if pkg_name == "all":
                 continue
@@ -1911,10 +1839,15 @@ def external_packages(self):
             if pkg_name not in self.pkgs:
                 continue
 
+            # This package is not in the possible dependencies
+            if pkg_name not in self.pkgs:
+                continue
+
             # This package is not among possible dependencies
             if pkg_name not in self.pkgs:
                 continue
 
+            self.gen.h2(f"External package: {pkg_name}")
             # Check if the external package is buildable. If it is
             # not then "external(<pkg>)" is a fact, unless we can
             # reuse an already installed spec.
@@ -2131,28 +2064,6 @@ def _spec_clauses(
                 else:
                     clauses.append(f.variant_value(spec.name, vname, value))
 
-        # compiler and compiler version
-        if spec.compiler:
-            clauses.append(f.node_compiler(spec.name, spec.compiler.name))
-
-            if spec.compiler.concrete:
-                clauses.append(
-                    f.node_compiler_version(spec.name, spec.compiler.name, spec.compiler.version)
-                )
-
-            elif spec.compiler.versions and spec.compiler.versions != vn.any_version:
-                # The condition above emits a facts only if we have an actual constraint
-                # on the compiler version, and avoids emitting them if any version is fine
-                clauses.append(
-                    fn.attr(
-                        "node_compiler_version_satisfies",
-                        spec.name,
-                        spec.compiler.name,
-                        spec.compiler.versions,
-                    )
-                )
-                self.compiler_version_constraints.add(spec.compiler)
-
         # compiler flags
         source = context.source if context else "none"
         for flag_type, flags in spec.compiler_flags.items():
@@ -2190,6 +2101,7 @@ def _spec_clauses(
 
         # If the spec is external and concrete, we allow all the libcs on the system
         if spec.external and spec.concrete and using_libc_compatibility():
+            clauses.append(fn.attr("needs_libc", spec.name))
             for libc in self.libcs:
                 clauses.append(fn.attr("compatible_libc", spec.name, libc.name, libc.version))
 
@@ -2203,11 +2115,17 @@ def _spec_clauses(
                     # GCC runtime is solved again by clingo, even on concrete specs, to give
                     # the possibility to reuse specs built against a different runtime.
                     if dep.name == "gcc-runtime":
+                        clauses.append(
+                            fn.attr("compatible_runtime", spec.name, dep.name, f"{dep.version}:")
+                        )
+                        constraint_spec = spack.spec.Spec(f"{dep.name}@{dep.version}")
+                        self.spec_versions(constraint_spec)
                         continue
 
                     # libc is also solved again by clingo, but in this case the compatibility
                     # is not encoded in the parent node - so we need to emit explicit facts
                     if "libc" in dspec.virtuals:
+                        clauses.append(fn.attr("needs_libc", spec.name))
                         for libc in self.libcs:
                             if libc_is_compatible(libc, dep):
                                 clauses.append(
@@ -2242,15 +2160,23 @@ def _spec_clauses(
                 # if it's concrete, then the hashes above take care of dependency
                 # constraints, but expand the hashes if asked for.
                 if not spec.concrete or expand_hashes:
-                    clauses.extend(
-                        self._spec_clauses(
-                            dep,
-                            body=body,
-                            expand_hashes=expand_hashes,
-                            concrete_build_deps=concrete_build_deps,
-                            context=context,
-                        )
+                    dependency_clauses = self._spec_clauses(
+                        dep,
+                        body=body,
+                        expand_hashes=expand_hashes,
+                        concrete_build_deps=concrete_build_deps,
+                        context=context,
                     )
+                    if dspec.depflag == dt.BUILD:
+                        clauses.append(fn.attr("depends_on", spec.name, dep.name, "build"))
+                        if body is False:
+                            for clause in dependency_clauses:
+                                clause.name = "build_requirement"
+                                clauses.append(fn.attr("build_requirement", spec.name, clause))
+                        else:
+                            clauses.extend(dependency_clauses)
+                    else:
+                        clauses.extend(dependency_clauses)
 
         return clauses
 
@@ -2348,7 +2274,9 @@ def _supported_targets(self, compiler_name, compiler_version, targets):
             try:
                 with warnings.catch_warnings():
                     warnings.simplefilter("ignore")
-                    target.optimization_flags(compiler_name, str(compiler_version))
+                    target.optimization_flags(
+                        compiler_name, compiler_version.dotted_numeric_string
+                    )
                 supported.append(target)
             except archspec.cpu.UnsupportedMicroarchitecture:
                 continue
@@ -2445,39 +2373,21 @@ def target_defaults(self, specs):
                         candidate_targets.append(ancestor)
 
         best_targets = {uarch.family.name}
-        for compiler_id, known_compiler in enumerate(self.possible_compilers):
-            if not known_compiler.available:
-                continue
-
-            compiler = known_compiler.compiler_obj
-            # Stub support for cross-compilation, to be expanded later
-            if known_compiler.target is not None and compiler.target not in (
-                str(uarch.family),
-                "any",
-            ):
-                self.gen.fact(fn.compiler_supports_target(compiler_id, compiler.target))
-                self.gen.newline()
-                continue
-
+        for compiler in self.possible_compilers:
             supported = self._supported_targets(compiler.name, compiler.version, candidate_targets)
 
-            # If we can't find supported targets it may be due to custom
-            # versions in the spec, e.g. gcc@foo. Try to match the
-            # real_version from the compiler object to get more accurate
-            # results.
-            if not supported:
-                supported = self._supported_targets(
-                    compiler.name, compiler.real_version, candidate_targets
-                )
-
             if not supported:
                 continue
 
             for target in supported:
                 best_targets.add(target.name)
-                self.gen.fact(fn.compiler_supports_target(compiler_id, target.name))
+                self.gen.fact(
+                    fn.compiler_supports_target(compiler.name, compiler.version, target.name)
+                )
 
-            self.gen.fact(fn.compiler_supports_target(compiler_id, uarch.family.name))
+            self.gen.fact(
+                fn.compiler_supports_target(compiler.name, compiler.version, uarch.family.name)
+            )
             self.gen.newline()
 
         i = 0  # TODO compute per-target offset?
@@ -2694,8 +2604,6 @@ def setup(
                 self.explicitly_required_namespaces[node.name] = node.namespace
 
         self.gen = ProblemInstanceBuilder()
-        compiler_parser = CompilerParser(configuration=spack.config.CONFIG).with_input_specs(specs)
-
         if using_libc_compatibility():
             for libc in self.libcs:
                 self.gen.fact(fn.host_libc(libc.name, libc.version))
@@ -2724,11 +2632,11 @@ def setup(
         if reuse:
             self.gen.fact(fn.optimize_for_reuse())
             for reusable_spec in reuse:
-                compiler_parser.add_compiler_from_concrete_spec(reusable_spec)
                 self.register_concrete_spec(reusable_spec, self.pkgs)
         self.concrete_specs()
 
-        self.possible_compilers = compiler_parser.possible_compilers()
+        _ = spack.compilers.config.all_compilers(init_config=True)
+        self.possible_compilers = possible_compilers(configuration=spack.config.CONFIG)
 
         self.gen.h1("Generic statements on possible packages")
         node_counter.possible_packages_facts(self.gen, fn)
@@ -2740,7 +2648,6 @@ def setup(
 
         self.gen.h1("General Constraints")
         self.config_compatible_os()
-        self.compiler_facts()
 
         # architecture defaults
         self.platform_defaults()
@@ -2794,9 +2701,8 @@ def setup(
         self.gen.h1("Variant Values defined in specs")
         self.define_variant_values()
 
-        if WITH_RUNTIME:
-            self.gen.h1("Runtimes")
-            self.define_runtime_constraints()
+        self.gen.h1("Runtimes")
+        self.define_runtime_constraints()
 
         self.gen.h1("Version Constraints")
         self.collect_virtual_constraints()
@@ -2836,35 +2742,37 @@ def define_runtime_constraints(self):
         recorder = RuntimePropertyRecorder(self)
 
         for compiler in self.possible_compilers:
-            compiler_with_different_cls_names = {
-                "oneapi": "intel-oneapi-compilers",
-                "clang": "llvm",
-            }
-            compiler_cls_name = compiler_with_different_cls_names.get(
-                compiler.spec.name, compiler.spec.name
-            )
             try:
-                compiler_cls = spack.repo.PATH.get_pkg_class(compiler_cls_name)
-                if hasattr(compiler_cls, "runtime_constraints"):
-                    compiler_cls.runtime_constraints(spec=compiler.spec, pkg=recorder)
+                compiler_cls = spack.repo.PATH.get_pkg_class(compiler.name)
             except spack.repo.UnknownPackageError:
                 pass
+            else:
+                if hasattr(compiler_cls, "runtime_constraints"):
+                    compiler_cls.runtime_constraints(spec=compiler, pkg=recorder)
+                # Inject default flags for compilers
+                recorder("*").default_flags(compiler)
 
-            # Inject libc from available compilers, on Linux
-            if not compiler.available:
+            if not using_libc_compatibility():
                 continue
 
-            current_libc = compiler.compiler_obj.default_libc
+            current_libc = CompilerPropertyDetector(compiler).default_libc()
+            # If this is a compiler yet to be built infer libc from the Python process
+            # FIXME (compiler as nodes): recover this use case
+            # if not current_libc and compiler.compiler_obj.cc is None:
+            #    current_libc = spack.util.libc.libc_from_current_python_process()
 
-            if using_libc_compatibility() and current_libc:
+            if current_libc:
                 recorder("*").depends_on(
-                    "libc", when=f"%{compiler.spec}", type="link", description="Add libc"
+                    "libc",
+                    when=f"%{compiler.name}@{compiler.versions}",
+                    type="link",
+                    description=f"Add libc when using {compiler}",
                 )
                 recorder("*").depends_on(
                     str(current_libc),
-                    when=f"%{compiler.spec}",
+                    when=f"%{compiler.name}@{compiler.versions}",
                     type="link",
-                    description="Add libc",
+                    description=f"Libc is {current_libc} when using {compiler}",
                 )
 
         recorder.consume_facts()
@@ -2900,6 +2808,9 @@ def literal_specs(self, specs):
                     # These facts are needed to compute the "condition_set" of the root
                     pkg_name = clause.args[1]
                     self.gen.fact(fn.mentioned_in_literal(trigger_id, root_name, pkg_name))
+                elif clause_name == "depends_on":
+                    pkg_name = clause.args[2]
+                    self.gen.fact(fn.mentioned_in_literal(trigger_id, root_name, pkg_name))
 
             requirements.append(fn.attr("virtual_root" if spec.virtual else "root", spec.name))
             cache[imposed_spec_key] = (effect_id, requirements)
@@ -2996,8 +2907,6 @@ class _Head:
     node_os = fn.attr("node_os_set")
     node_target = fn.attr("node_target_set")
     variant_value = fn.attr("variant_set")
-    node_compiler = fn.attr("node_compiler_set")
-    node_compiler_version = fn.attr("node_compiler_version_set")
     node_flag = fn.attr("node_flag_set")
     propagate = fn.attr("propagate")
 
@@ -3012,8 +2921,6 @@ class _Body:
     node_os = fn.attr("node_os")
     node_target = fn.attr("node_target")
     variant_value = fn.attr("variant_value")
-    node_compiler = fn.attr("node_compiler")
-    node_compiler_version = fn.attr("node_compiler_version")
     node_flag = fn.attr("node_flag")
     propagate = fn.attr("propagate")
 
@@ -3064,102 +2971,39 @@ def value(self) -> str:
         return "".join(self.asp_problem)
 
 
-class CompilerParser:
-    """Parses configuration files, and builds a list of possible compilers for the solve."""
+def possible_compilers(*, configuration) -> List["spack.spec.Spec"]:
+    result = set()
+    for c in spack.compilers.config.all_compilers_from(configuration):
+        # FIXME (compiler as nodes): Discard early specs that are not marked for this target?
 
-    def __init__(self, configuration) -> None:
-        self.compilers: Set[KnownCompiler] = set()
-        for c in spack.compilers.all_compilers_from(configuration):
-            if using_libc_compatibility() and not c_compiler_runs(c):
+        if using_libc_compatibility() and not c_compiler_runs(c):
+            try:
+                compiler = c.extra_attributes["compilers"]["c"]
                 tty.debug(
-                    f"the C compiler {c.cc} does not exist, or does not run correctly."
-                    f" The compiler {c.spec} will not be used during concretization."
+                    f"the C compiler {compiler} does not exist, or does not run correctly."
+                    f" The compiler {c} will not be used during concretization."
                 )
-                continue
+            except KeyError:
+                tty.debug(f"the spec {c} does not provide a C compiler.")
 
-            if using_libc_compatibility() and not c.default_libc:
-                warnings.warn(
-                    f"cannot detect libc from {c.spec}. The compiler will not be used "
-                    f"during concretization."
-                )
-                continue
+            continue
 
-            target = c.target if c.target != "any" else None
-            candidate = KnownCompiler(
-                spec=c.spec, os=c.operating_system, target=target, available=True, compiler_obj=c
+        if using_libc_compatibility() and not CompilerPropertyDetector(c).default_libc():
+            warnings.warn(
+                f"cannot detect libc from {c}. The compiler will not be used "
+                f"during concretization."
             )
-            if candidate in self.compilers:
-                warnings.warn(
-                    f"duplicate found for {c.spec} on {c.operating_system}/{c.target}. "
-                    f"Edit your compilers.yaml configuration to remove it."
-                )
-                continue
+            continue
 
-            self.compilers.add(candidate)
+        if c in result:
+            warnings.warn(f"duplicate {c} compiler found. Edit your packages.yaml to remove it.")
+            continue
 
-    def with_input_specs(self, input_specs: List["spack.spec.Spec"]) -> "CompilerParser":
-        """Accounts for input specs when building the list of possible compilers.
+        result.add(c)
 
-        Args:
-            input_specs: specs to be concretized
-        """
-        strict = spack.concretize.CHECK_COMPILER_EXISTENCE
-        default_os = str(spack.platforms.host().default_os)
-        default_target = str(archspec.cpu.host().family)
-        for s in traverse.traverse_nodes(input_specs):
-            # we don't need to validate compilers for already-built specs
-            if s.concrete or not s.compiler:
-                continue
-
-            version = s.compiler.versions.concrete
-
-            if not version or any(item.spec.satisfies(s.compiler) for item in self.compilers):
-                continue
-
-            # Error when a compiler is not found and strict mode is enabled
-            if strict:
-                raise spack.concretize.UnavailableCompilerVersionError(s.compiler)
-
-            # Make up a compiler matching the input spec. This is for bootstrapping.
-            compiler_cls = spack.compilers.class_for_compiler_name(s.compiler.name)
-            compiler_obj = compiler_cls(
-                s.compiler, operating_system=default_os, target=default_target, paths=[None] * 4
-            )
-            self.compilers.add(
-                KnownCompiler(
-                    spec=s.compiler,
-                    os=default_os,
-                    target=default_target,
-                    available=True,
-                    compiler_obj=compiler_obj,
-                )
-            )
-
-        return self
-
-    def add_compiler_from_concrete_spec(self, spec: "spack.spec.Spec") -> None:
-        """Account for compilers that are coming from concrete specs, through reuse.
-
-        Args:
-            spec: concrete spec to be reused
-        """
-        assert spec.concrete, "the spec argument must be concrete"
-        candidate = KnownCompiler(
-            spec=spec.compiler,
-            os=str(spec.architecture.os),
-            target=str(spec.architecture.target.family),
-            available=False,
-            compiler_obj=None,
-        )
-        self.compilers.add(candidate)
-
-    def possible_compilers(self) -> List[KnownCompiler]:
-        # Here we have to sort two times, first sort by name and ascending version
-        result = sorted(self.compilers, key=lambda x: (x.spec.name, x.spec.version), reverse=True)
-        # Then stable sort to prefer available compilers and account for preferences
-        ppk = spack.package_prefs.PackagePrefs("all", "compiler", all=False)
-        result.sort(key=lambda x: (not x.available, ppk(x.spec)))
-        return result
+    result = list(result)
+    result.sort()
+    return result
 
 
 class RuntimePropertyRecorder:
@@ -3202,15 +3046,7 @@ def reset(self):
         """Resets the current state."""
         self.current_package = None
 
-    def depends_on(
-        self,
-        dependency_str: str,
-        *,
-        when: str,
-        type: str,
-        description: str,
-        languages: Optional[List[str]] = None,
-    ) -> None:
+    def depends_on(self, dependency_str: str, *, when: str, type: str, description: str) -> None:
         """Injects conditional dependencies on packages.
 
         Conditional dependencies can be either "real" packages or virtual dependencies.
@@ -3219,7 +3055,6 @@ def depends_on(
             dependency_str: the dependency spec to inject
             when: anonymous condition to be met on a package to have the dependency
             type: dependency type
-            languages: languages needed by the package for the dependency to be considered
             description: human-readable description of the rule for adding the dependency
         """
         # TODO: The API for this function is not final, and is still subject to change. At
@@ -3235,25 +3070,10 @@ def depends_on(
         if dependency_spec.versions != vn.any_version:
             self._setup.version_constraints.add((dependency_spec.name, dependency_spec.versions))
 
-        placeholder = "XXX"
-        node_variable = "node(ID, Package)"
-        when_spec.name = placeholder
-
-        body_clauses = self._setup.spec_clauses(when_spec, body=True)
-        body_str = (
-            f"  {f',{os.linesep}  '.join(str(x) for x in body_clauses)},\n"
-            f"  not external({node_variable}),\n"
-            f"  not runtime(Package)"
-        ).replace(f'"{placeholder}"', f"{node_variable}")
-        if languages:
-            body_str += ",\n"
-            for language in languages:
-                body_str += f'  attr("language", {node_variable}, "{language}")'
+        body_str, node_variable = self.rule_body_from(when_spec)
 
         head_clauses = self._setup.spec_clauses(dependency_spec, body=False)
-
         runtime_pkg = dependency_spec.name
-
         is_virtual = head_clauses[0].args[0] == "virtual_node"
         main_rule = (
             f"% {description}\n"
@@ -3288,6 +3108,38 @@ def depends_on(
 
         self.reset()
 
+    @staticmethod
+    def node_for(name: str) -> str:
+        return f'node(ID{name.replace("-", "_")}, "{name}")'
+
+    def rule_body_from(self, when_spec: "spack.spec.Spec") -> Tuple[str, str]:
+        """Computes the rule body from a "when" spec, and returns it, along with the
+        node variable.
+        """
+
+        node_placeholder = "XXX"
+        node_variable = "node(ID, Package)"
+        when_substitutions = {}
+        for s in when_spec.traverse(root=False):
+            when_substitutions[f'"{s.name}"'] = self.node_for(s.name)
+        when_spec.name = node_placeholder
+        body_clauses = self._setup.spec_clauses(when_spec, body=True)
+        for clause in body_clauses:
+            if clause.args[0] == "virtual_on_incoming_edges":
+                # Substitute: attr("virtual_on_incoming_edges", ProviderNode, Virtual)
+                # with: attr("virtual_on_edge", ParentNode, ProviderNode, Virtual)
+                # (avoid adding virtuals everywhere, if a single edge needs it)
+                _, provider, virtual = clause.args
+                clause.args = "virtual_on_edge", node_placeholder, provider, virtual
+        body_str = (
+            f"  {f',{os.linesep}  '.join(str(x) for x in body_clauses)},\n"
+            f"  not external({node_variable}),\n"
+            f"  not runtime(Package)"
+        ).replace(f'"{node_placeholder}"', f"{node_variable}")
+        for old, replacement in when_substitutions.items():
+            body_str = body_str.replace(old, replacement)
+        return body_str, node_variable
+
     def requires(self, impose: str, *, when: str):
         """Injects conditional requirements on a given package.
 
@@ -3302,7 +3154,6 @@ def requires(self, impose: str, *, when: str):
         when_spec = spack.spec.Spec(f"{self.current_package}{when}")
 
         assert imposed_spec.versions.concrete, f"{impose} must have a concrete version"
-        assert when_spec.compiler.concrete, f"{when} must have a concrete compiler"
 
         # Add versions to possible versions
         for s in (imposed_spec, when_spec):
@@ -3323,32 +3174,54 @@ def propagate(self, constraint_str: str, *, when: str):
         when_spec = spack.spec.Spec(when)
         assert when_spec.name is None, "only anonymous when specs are accepted"
 
-        placeholder = "XXX"
-        node_variable = "node(ID, Package)"
-        when_spec.name = placeholder
-
-        body_clauses = self._setup.spec_clauses(when_spec, body=True)
-        body_str = (
-            f"  {f',{os.linesep}  '.join(str(x) for x in body_clauses)},\n"
-            f"  not external({node_variable}),\n"
-            f"  not runtime(Package)"
-        ).replace(f'"{placeholder}"', f"{node_variable}")
+        when_substitutions = {}
+        for s in when_spec.traverse(root=False):
+            when_substitutions[f'"{s.name}"'] = self.node_for(s.name)
 
+        body_str, node_variable = self.rule_body_from(when_spec)
         constraint_spec = spack.spec.Spec(constraint_str)
-        assert constraint_spec.name is None, "only anonymous constraint specs are accepted"
 
-        constraint_spec.name = placeholder
+        # constraint_spec.name = placeholder
         constraint_clauses = self._setup.spec_clauses(constraint_spec, body=False)
         for clause in constraint_clauses:
-            if clause.args[0] == "node_compiler_version_satisfies":
-                self._setup.compiler_version_constraints.add(constraint_spec.compiler)
-                args = f'"{constraint_spec.compiler.name}", "{constraint_spec.compiler.versions}"'
-                head_str = f"propagate({node_variable}, node_compiler_version_satisfies({args}))"
+            if clause.args[0] == "node_version_satisfies":
+                self._setup.version_constraints.add(
+                    (constraint_spec.name, constraint_spec.versions)
+                )
+                args = f'"{constraint_spec.name}", "{constraint_spec.versions}"'
+                head_str = f"propagate({node_variable}, node_version_satisfies({args}))"
                 rule = f"{head_str} :-\n{body_str}.\n\n"
                 self.rules.append(rule)
 
         self.reset()
 
+    def default_flags(self, spec: "spack.spec.Spec"):
+        if not spec.external or "flags" not in spec.extra_attributes:
+            self.reset()
+            return
+
+        when_spec = spack.spec.Spec(f"^[deptypes=build] {spec}")
+        body_str, node_variable = self.rule_body_from(when_spec)
+
+        node_placeholder = "XXX"
+        flags = spec.extra_attributes["flags"]
+        root_spec_str = f"{node_placeholder}"
+        for flag_type, default_values in flags.items():
+            root_spec_str = f"{root_spec_str} {flag_type}='{default_values}'"
+        root_spec = spack.spec.Spec(root_spec_str)
+        head_clauses = self._setup.spec_clauses(
+            root_spec, body=False, context=SourceContext(source="compiler")
+        )
+        self.rules.append(f"% Default compiler flags for {spec}\n")
+        for clause in head_clauses:
+            if clause.args[0] == "node":
+                continue
+            head_str = str(clause).replace(f'"{node_placeholder}"', f"{node_variable}")
+            rule = f"{head_str} :-\n{body_str}.\n\n"
+            self.rules.append(rule)
+
+        self.reset()
+
     def consume_facts(self):
         """Consume the facts collected by this object, and emits rules and
         facts for the runtimes.
@@ -3396,7 +3269,6 @@ class SpecBuilder:
                 r"^compatible_libc$",
                 r"^dependency_holds$",
                 r"^external_conditions_hold$",
-                r"^node_compiler$",
                 r"^package_hash$",
                 r"^root$",
                 r"^track_dependencies$",
@@ -3477,10 +3349,6 @@ def variant_selected(self, node, name, value, variant_type, variant_id):
     def version(self, node, version):
         self._specs[node].versions = vn.VersionList([vn.Version(version)])
 
-    def node_compiler_version(self, node, compiler, version):
-        self._specs[node].compiler = spack.spec.CompilerSpec(compiler)
-        self._specs[node].compiler.versions = vn.VersionList([vn.Version(version)])
-
     def node_flag(self, node, node_flag):
         self._specs[node].compiler_flags.add_flag(
             node_flag.flag_type, node_flag.flag, False, node_flag.flag_group, node_flag.source
@@ -3535,17 +3403,14 @@ def reorder_flags(self):
         e.g. for `y cflags="-z -a"` "-z" and "-a" should never have any intervening
         flags inserted, and should always appear in that order.
         """
-        # reverse compilers so we get highest priority compilers that share a spec
-        compilers = dict(
-            (c.spec, c) for c in reversed(spack.compilers.all_compilers_from(spack.config.CONFIG))
-        )
-        cmd_specs = dict((s.name, s) for spec in self._command_line_specs for s in spec.traverse())
+        cmd_specs = {s.name: s for spec in self._command_line_specs for s in spec.traverse()}
 
         for spec in self._specs.values():
             # if bootstrapping, compiler is not in config and has no flags
-            flagmap_from_compiler = {}
-            if spec.compiler in compilers:
-                flagmap_from_compiler = compilers[spec.compiler].flags
+            flagmap_from_compiler = {
+                flag_type: [x for x in values if x.source == "compiler"]
+                for flag_type, values in spec.compiler_flags.items()
+            }
 
             for flag_type in spec.compiler_flags.valid_compiler_flags():
                 node = SpecBuilder.make_node(pkg=spec.name)
@@ -3595,7 +3460,7 @@ def _order_index(flag_group):
 
                 for grp in prioritized_groups:
                     grp_flags = tuple(
-                        x for (x, y) in spack.compiler.tokenize_flags(grp.flag_group)
+                        x for (x, y) in spack.compilers.flags.tokenize_flags(grp.flag_group)
                     )
                     if grp_flags == from_compiler:
                         continue
@@ -3700,9 +3565,8 @@ def sort_fn(function_tuple) -> Tuple[int, int]:
             return (-1, 0)
 
     def build_specs(self, function_tuples):
-        # Functions don't seem to be in particular order in output.  Sort
-        # them here so that directives that build objects (like node and
-        # node_compiler) are called in the right order.
+        # Functions don't seem to be in particular order in output. Sort them here so that
+        # directives that build objects, like node, are called in the right order.
         self.function_tuples = sorted(set(function_tuples), key=self.sort_fn)
         self._specs = {}
         for name, args in self.function_tuples:
@@ -3766,6 +3630,14 @@ def build_specs(self, function_tuples):
         for root in roots.values():
             root._finalize_concretization()
 
+        # Unify hashes (this is to avoid duplicates of runtimes and compilers)
+        unifier = ConcreteSpecsByHash()
+        keys = list(self._specs)
+        for key in keys:
+            current_spec = self._specs[key]
+            unifier.add(current_spec)
+            self._specs[key] = unifier[current_spec.dag_hash()]
+
         self._resolve_automatic_splices()
 
         for s in self._specs.values():
@@ -3886,13 +3758,10 @@ def _is_reusable(spec: spack.spec.Spec, packages, local: bool) -> bool:
 
 
 def _has_runtime_dependencies(spec: spack.spec.Spec) -> bool:
-    if not WITH_RUNTIME:
-        return True
-
-    if spec.compiler.name == "gcc" and not spec.dependencies("gcc-runtime"):
+    if "gcc" in spec and "gcc-runtime" not in spec:
         return False
 
-    if spec.compiler.name == "oneapi" and not spec.dependencies("intel-oneapi-runtime"):
+    if "intel-oneapi-compilers" in spec and "intel-oneapi-runtime" not in spec:
         return False
 
     return True
@@ -4141,10 +4010,41 @@ def _check_input_and_extract_concrete_specs(specs):
         reusable = []
         for root in specs:
             for s in root.traverse():
+                candidates = s.edges_to_dependencies(depflag=dt.BUILD)
+                if candidates:
+                    virtuals = set()
+                    non_virtuals = spack.package_base.possible_dependencies(
+                        s, transitive=False, virtuals=virtuals
+                    )
+                    possible_direct_deps = set(non_virtuals) | virtuals
+                    not_possible = set(
+                        [
+                            x.spec.name
+                            for x in candidates
+                            if x.direct and x.spec.name not in possible_direct_deps
+                        ]
+                    )
+                    if not_possible:
+                        start_str = f"'{s}' in '{root}'"
+                        if s == root:
+                            start_str = f"'{root}'"
+                        raise UnsatisfiableSpecError(
+                            f"{start_str} cannot have a dependency on {', '.join(not_possible)}, "
+                            f"according to its recipe"
+                        )
+
                 if s.virtual:
                     continue
                 if s.concrete:
                     reusable.append(s)
+
+                try:
+                    s.package_class
+                except spack.repo.UnknownPackageError:
+                    raise UnsatisfiableSpecError(
+                        f"cannot concretize '{root}', since '{s.name}' does not exist"
+                    )
+
                 spack.spec.Spec.ensure_valid_variants(s)
         return reusable
 

lib/spack/spack/solver/concretize.lp

@@ -39,8 +39,6 @@
    internal_error("Only nodes can have node_os").
 :- attr("node_target", PackageNode, _), not attr("node", PackageNode),
    internal_error("Only nodes can have node_target").
-:- attr("node_compiler_version", PackageNode, _, _), not attr("node", PackageNode),
-   internal_error("Only nodes can have node_compiler_version").
 :- attr("variant_value", PackageNode, _, _), not attr("node", PackageNode),
    internal_error("variant_value true for a non-node").
 :- attr("node_flag", PackageNode, _), not attr("node", PackageNode),
@@ -147,6 +145,15 @@ unification_set(SetID, VirtualNode)
    max_dupes(Package, X), ID1=0..X-1, ID2=0..X-1, ID2 < ID1,
    internal_error("virtual node skipped id number").
 
+% Prefer to assign lower ID to virtuals associated with a lower penalty provider
+:- not unification_set("root", node(X, Virtual)),
+   not unification_set("root", node(Y, Virtual)),
+   X < Y,
+   provider_weight(_, node(X, Virtual), WeightX),
+   provider_weight(_, node(Y, Virtual), WeightY),
+   WeightY < WeightX.
+
+
 %-----------------------------------------------------------------------------
 % Map literal input specs to facts that drive the solve
 %-----------------------------------------------------------------------------
@@ -217,14 +224,6 @@ error(100, multiple_values_error, Attribute, Package)
      attr_single_value(Attribute),
      2 { attr(Attribute, node(ID, Package), Value) }.
 
-%-----------------------------------------------------------------------------
-% Languages used
-%-----------------------------------------------------------------------------
-
-attr("language", node(X, Package), Language) :-
-  condition_holds(ConditionID, node(X, Package)),
-  pkg_fact(Package,language(ConditionID, Language)).
-
 %-----------------------------------------------------------------------------
 % Version semantics
 %-----------------------------------------------------------------------------
@@ -317,18 +316,21 @@ possible_version_weight(node(ID, Package), Weight)
 
 % If there is at least a version that satisfy the constraint, impose a lower
 % bound on the choice rule to avoid false positives with the error below
-1 { attr("version", node(ID, Package), Version) : pkg_fact(Package, version_satisfies(Constraint, Version)) }
+{ attr("version", node(ID, Package), Version) : pkg_fact(Package, version_satisfies(Constraint, Version)) }
   :- attr("node_version_satisfies", node(ID, Package), Constraint),
-     pkg_fact(Package, version_satisfies(Constraint, _)),
-     internal_error("must choose a single version to satisfy version constraints").
+     pkg_fact(Package, version_satisfies(Constraint, _)).
 
 % More specific error message if the version cannot satisfy some constraint
 % Otherwise covered by `no_version_error` and `versions_conflict_error`.
-error(10, "Cannot satisfy '{0}@{1}'", Package, Constraint)
+error(1, "Cannot satisfy '{0}@{1}'", Package, Constraint)
   :- attr("node_version_satisfies", node(ID, Package), Constraint),
      attr("version", node(ID, Package), Version),
      not pkg_fact(Package, version_satisfies(Constraint, Version)).
 
+error(10, "Cannot satisfy '{0}@{1}'", Package, Constraint)
+  :- attr("node_version_satisfies", node(ID, Package), Constraint),
+     not attr("version", node(ID, Package), _).
+
 attr("node_version_satisfies", node(ID, Package), Constraint)
   :- attr("version", node(ID, Package), Version),
      pkg_fact(Package, version_satisfies(Constraint, Version)).
@@ -377,6 +379,7 @@ trigger_node(ID, node(PackageID, Package), node(VirtualID, Virtual)) :- pkg_fact
 condition_nodes(TriggerID, PackageNode, node(X, A1))
   :- condition_packages(TriggerID, A1),
      condition_set(PackageNode, node(X, A1)),
+     not self_build_requirement(PackageNode, node(X, A1)),
      trigger_node(TriggerID, PackageNode, _).
 
 cannot_hold(TriggerID, PackageNode)
@@ -391,6 +394,7 @@ trigger_condition_holds(ID, RequestorNode) :-
   attr(Name, node(X, A1), A2, A3)     : condition_requirement(ID, Name, A1, A2, A3),     condition_nodes(ID, PackageNode, node(X, A1)), not multiple_nodes_attribute(Name);
   attr(Name, node(X, A1), A2, A3, A4) : condition_requirement(ID, Name, A1, A2, A3, A4), condition_nodes(ID, PackageNode, node(X, A1));
   % Special cases
+  attr("depends_on", node(X, A1), node(Y, A2), A3) : condition_requirement(ID, "depends_on", A1, A2, A3), condition_nodes(ID, PackageNode, node(X, A1)), condition_nodes(ID, PackageNode, node(Y, A2));
   not cannot_hold(ID, PackageNode).
 
 condition_holds(ConditionID, node(X, Package))
@@ -420,7 +424,12 @@ imposed_nodes(EffectID, node(NodeID, Package), node(X, A1))
      pkg_fact(Package, condition_effect(ID, EffectID)),
      imposed_packages(EffectID, A1),
      condition_set(node(NodeID, Package), node(X, A1)),
-     trigger_node(TriggerID, _, node(NodeID, Package)).
+     trigger_node(TriggerID, _, node(NodeID, Package)),
+     % We don't want to add build requirements to imposed nodes, to avoid
+     % unsat problems when we deal with self-dependencies: gcc@14 %gcc@10
+     not self_build_requirement(node(NodeID, Package), node(X, A1)).
+
+self_build_requirement(node(X, Package), node(Y, Package)) :- build_requirement(node(X, Package), node(Y, Package)).
 
 imposed_nodes(ConditionID, PackageNode, node(X, A1))
   :- imposed_packages(ConditionID, A1),
@@ -456,6 +465,45 @@ provider(ProviderNode, VirtualNode) :- attr("provider_set", ProviderNode, Virtua
      imposed_constraint(ID, "depends_on", A1, A2, A3),
      internal_error("Build deps must land in exactly one duplicate").
 
+% The rule below accounts for expressions like:
+%
+% root ^dep %compiler
+%
+% where "compiler" is a dependency of "dep", but is enforced by a condition imposed by "root"
+1 { attr("depends_on", node(min_dupe_id, A1), node(0..Y-1, A2), A3) : max_dupes(A2, Y) } 1
+  :- impose(ID, RootNode),
+     unification_set("root", RootNode),
+     unification_set("root", node(min_dupe_id, A1)),
+     imposed_constraint(ID, "depends_on", A1, A2, A3),
+     internal_error("Build deps must land in exactly one duplicate").
+
+1 { build_requirement(node(X, Parent), node(0..Y-1, BuildDependency)) : max_dupes(BuildDependency, Y) } 1
+  :- attr("build_requirement", node(X, Parent), build_requirement("node", BuildDependency)),
+     impose(ID, node(X, Parent)),
+     imposed_constraint(ID,"build_requirement",Parent,_).
+
+1 { virtual_build_requirement(ParentNode, node(0..Y-1, Virtual)) : max_dupes(Virtual, Y) } 1
+  :- attr("dependency_holds", ParentNode, Virtual, "build"),
+     not attr("dependency_holds", ParentNode, Virtual,"link"),
+     not attr("dependency_holds", ParentNode, Virtual,"run"),
+     virtual(Virtual).
+
+attr("virtual_node", VirtualNode)  :- virtual_build_requirement(ParentNode, VirtualNode).
+build_requirement(ParentNode, ProviderNode) :- virtual_build_requirement(ParentNode, VirtualNode), provider(ProviderNode, VirtualNode).
+
+% From cli we can have literal expressions like:
+%
+% root %gcc@12.0 ^dep %gcc@11.2
+%
+% Adding a "build_requirement" is a way to discriminate between the incompatible
+% version constraints on "gcc" in the "imposed_constraint".
+attr("node_version_satisfies", node(X, BuildDependency), Constraint) :-
+  attr("build_requirement", ParentNode, build_requirement("node_version_satisfies", BuildDependency, Constraint)),
+  build_requirement(ParentNode, node(X, BuildDependency)).
+
+attr("depends_on",  node(X, Parent), node(Y, BuildDependency), "build") :- build_requirement(node(X, Parent), node(Y, BuildDependency)).
+
+
 % Reconstruct virtual dependencies for reused specs
 attr("virtual_on_edge", node(X, A1), node(Y, A2), Virtual)
   :- impose(ID, node(X, A1)),
@@ -495,9 +543,12 @@ virtual_condition_holds(node(Y, A2), Virtual)
 %-----------------------------------------------------------------------------
 % Concrete specs
 %-----------------------------------------------------------------------------
+
 % if a package is assigned a hash, it's concrete.
 concrete(PackageNode) :- attr("hash", PackageNode, _), attr("node", PackageNode).
 
+:- concrete(PackageNode), depends_on(PackageNode, DependencyNode), not concrete(DependencyNode).
+
 %-----------------------------------------------------------------------------
 % Dependency semantics
 %-----------------------------------------------------------------------------
@@ -519,11 +570,45 @@ attr("track_dependencies", Node) :- build(Node), not external(Node).
 % this ensures a user can't say `zlib ^libiconv` (neither of which have any
 % dependencies) and get a two-node unconnected graph
 needed(PackageNode) :- attr("root", PackageNode).
-needed(DependencyNode) :- needed(PackageNode), depends_on(PackageNode, DependencyNode).
+needed(ChildNode) :- edge_needed(ParentNode, ChildNode).
+
+edge_needed(ParentNode, node(X, Child)) :- depends_on(ParentNode, node(X, Child)), runtime(Child).
+edge_needed(ParentNode, ChildNode)      :- depends_on(ParentNode, ChildNode)     , concrete(ParentNode).
+
+edge_needed(ParentNode, node(X, Child)) :-
+   depends_on(ParentNode, node(X, Child)),
+   build(ParentNode),
+   attr("dependency_holds", ParentNode, Child, _).
+
+virtual_edge_needed(ParentNode, ChildNode, node(X, Virtual)) :-
+   depends_on(ParentNode, ChildNode),
+   build(ParentNode),
+   node_depends_on_virtual(ParentNode, Virtual),
+   provider(ChildNode, node(X, Virtual)).
+
+virtual_edge_needed(ParentNode, ChildNode, node(X, Virtual)) :-
+   concrete(ParentNode),
+   concrete(ChildNode),
+   provider(ChildNode, node(X, Virtual)),
+   attr("virtual_on_edge", ParentNode, ChildNode, Virtual).
+
+edge_needed(ParentNode, ChildNode)      :- virtual_edge_needed(ParentNode, ChildNode, _).
+provider_needed(ChildNode, VirtualNode) :- virtual_edge_needed(_, ChildNode, VirtualNode).
+provider_needed(ChildNode, VirtualNode) :- attr("virtual_root", VirtualNode), provider(ChildNode, VirtualNode).
+
 error(10, "'{0}' is not a valid dependency for any package in the DAG", Package)
   :- attr("node", node(ID, Package)),
      not needed(node(ID, Package)).
 
+:- depends_on(ParentNode, ChildNode),
+   not edge_needed(ParentNode, ChildNode),
+   build(ParentNode).
+
+:- provider(PackageNode, VirtualNode),
+   not provider_needed(PackageNode, VirtualNode),
+   not attr("virtual_root", VirtualNode).
+
+
 #defined dependency_type/2.
 
 %-----------------------------------------------------------------------------
@@ -550,14 +635,18 @@ possible_provider_weight(ProviderNode, VirtualNode, 0, "Set on the command line"
 
 % Enforces all virtuals to be provided, if multiple of them are provided together
 error(100, "Package '{0}' needs to provide both '{1}' and '{2}' together, but provides only '{1}'", Package, Virtual1, Virtual2)
-:- condition_holds(ID, node(X, Package)),
+:- % This package provides 2 or more virtuals together
+   condition_holds(ID, node(X, Package)),
    pkg_fact(Package, provided_together(ID, SetID, Virtual1)),
    pkg_fact(Package, provided_together(ID, SetID, Virtual2)),
    Virtual1 != Virtual2,
-   attr("virtual_on_incoming_edges", node(X, Package), Virtual1),
-   not attr("virtual_on_incoming_edges", node(X, Package), Virtual2),
-   attr("virtual_node", node(_, Virtual1)),
-   attr("virtual_node", node(_, Virtual2)).
+   % One node depends on those virtuals AND on this package
+   node_depends_on_virtual(ClientNode, Virtual1),
+   node_depends_on_virtual(ClientNode, Virtual2),
+   depends_on(ClientNode, node(X, Package)),
+   % But this package is a provider of only one of them
+   provider(node(X, Package), node(_, Virtual1)),
+   not provider(node(X, Package), node(_, Virtual2)).
 
 % if a package depends on a virtual, it's not external and we have a
 % provider for that virtual then it depends on the provider
@@ -636,6 +725,7 @@ do_not_impose(EffectID, node(X, Package))
    virtual_condition_holds(_, PossibleProvider, Virtual),
    PossibleProvider != ProviderNode,
    explicitly_requested_root(PossibleProvider),
+   not self_build_requirement(PossibleProvider, ProviderNode),
    not explicitly_requested_root(ProviderNode),
    internal_error("If a root can provide a virtual, it must be the provider").
 
@@ -1137,9 +1227,10 @@ error(100, "Cannot propagate the variant '{0}' from the package: {1} because pac
 propagated_flag(node(PackageID, Package), node_flag(FlagType, Flag, FlagGroup, Source), SourceNode) :-
   propagate(node(PackageID, Package), node_flag(FlagType, Flag, FlagGroup, Source), _),
   not attr("node_flag_set", node(PackageID, Package), node_flag(FlagType, _, _, "literal")),
+  % FIXME (compiler as nodes): do we need to match the compiler?
   % Same compiler as propagation source
-  node_compiler(node(PackageID, Package), CompilerID),
-  node_compiler(SourceNode, CompilerID),
+  % node_compiler(node(PackageID, Package), CompilerID),
+  % node_compiler(SourceNode, CompilerID),
   attr("propagate", SourceNode, node_flag(FlagType, Flag, FlagGroup, Source), _),
   node(PackageID, Package) != SourceNode,
   not runtime(Package).
@@ -1147,7 +1238,7 @@ propagated_flag(node(PackageID, Package), node_flag(FlagType, Flag, FlagGroup, S
 attr("node_flag", PackageNode, NodeFlag) :- propagated_flag(PackageNode, NodeFlag, _).
 
 % Cannot propagate the same flag from two distinct sources
-error(100, "{0} and {1} cannot both propagate compiler flags '{2}' to {3}", Source1, Source2, Package, FlagType) :-
+error(100, "{0} and {1} cannot both propagate compiler flags '{2}' to {3}", Source1, Source2, FlagType, Package) :-
   propagated_flag(node(ID, Package), node_flag(FlagType, _, _, _), node(_, Source1)),
   propagated_flag(node(ID, Package), node_flag(FlagType, _, _, _), node(_, Source2)),
   Source1 < Source2.
@@ -1156,12 +1247,17 @@ error(100, "{0} and {1} cannot both propagate compiler flags '{2}' to {3}", Sour
 % Compiler constraints
 %----
 
-attr("node_compiler_version_satisfies", node(ID, Package), Compiler, Version) :-
-  propagate(node(ID, Package), node_compiler_version_satisfies(Compiler, Version)),
-  node_compiler(node(ID, Package), CompilerID),
-  compiler_name(CompilerID, Compiler),
-  not runtime(Package),
-  not external(Package).
+% If a node is built, impose constraints on the compiler coming from dependents
+attr("node_version_satisfies", node(Y, Compiler), VersionRange) :-
+   propagate(node(X, Package), node_version_satisfies(Compiler, VersionRange)),
+   attr("depends_on", node(X, Package), node(Y, Compiler), "build"),
+   not external(node(X, Package)),
+   not runtime(Package).
+
+attr("node_version_satisfies", node(X, Runtime), VersionRange) :-
+   attr("node", node(X, Runtime)),
+   attr("compatible_runtime", PackageNode, Runtime, VersionRange),
+   concrete(PackageNode).
 
 %-----------------------------------------------------------------------------
 % Runtimes
@@ -1170,11 +1266,19 @@ attr("node_compiler_version_satisfies", node(ID, Package), Compiler, Version) :-
 % Check whether the DAG has any built package
 has_built_packages() :- build(X), not external(X).
 
-% If we build packages, the runtime nodes must use an available compiler
-1 { node_compiler(PackageNode, CompilerID) : build(PackageNode), not external(PackageNode) } :-
-  has_built_packages(),
-  runtime(RuntimePackage),
-  node_compiler(node(_, RuntimePackage), CompilerID).
+% "gcc-runtime" is always built
+:- concrete(node(X, "gcc-runtime")), has_built_packages().
+
+% FIXME (compiler as nodes): is this version constraint always required and better than the callback?
+% "gcc-runtime" and the "gcc" it depends on must be at the same version
+% attr("version", node(Y, "gcc"), Version) :-
+%   attr("version", node(X, "gcc-runtime"), Version),
+%   attr("depends_on", node(X, "gcc-runtime"), node(Y, "gcc"), "build").
+
+% The "gcc" linked to "gcc-runtime" must be used by at least another package
+:- attr("depends_on", node(X, "gcc-runtime"), node(Y, "gcc"), "build"),
+   not 2 { attr("depends_on", PackageNode, node(Y, "gcc"), "build") : attr("node", PackageNode) }.
+
 
 %-----------------------------------------------------------------------------
 % Platform semantics
@@ -1247,7 +1351,7 @@ attr("node_target_satisfies", PackageNode, Constraint)
 
 % If a node has a target, all of its dependencies must be compatible with that target
 error(100, "Cannot find compatible targets for {0} and {1}", Package, Dependency)
-  :- depends_on(node(X, Package), node(Y, Dependency)),
+  :- attr("depends_on", node(X, Package), node(Y, Dependency), Type), Type != "build",
      attr("node_target", node(X, Package), Target),
      not node_target_compatible(node(Y, Dependency), Target).
 
@@ -1259,29 +1363,33 @@ node_target_compatible(PackageNode, Target)
     target_compatible(Target, MyTarget).
 
 #defined target_satisfies/2.
+compiler(Compiler) :- compiler_supports_target(Compiler, _, _).
 
-% can't use targets on node if the compiler for the node doesn't support them
-error(100, "{0} compiler '{2}@{3}' incompatible with 'target={1}'", Package, Target, Compiler, Version)
+% Can't use targets on node if the compiler for the node doesn't support them
+language("c").
+language("cxx").
+language("fortran").
+
+% FIXME (compiler as nodes): remove when we lift this constraint
+error(10, "Only external compilers are allowed for the {0} language", Language)
+  :- provider(ProviderNode, node(_, Language)),
+     language(Language),
+     not external(ProviderNode).
+
+error(10, "{0} compiler '{2}@{3}' incompatible with 'target={1}'", Package, Target, Compiler, Version)
   :- attr("node_target", node(X, Package), Target),
-     node_compiler(node(X, Package), CompilerID),
-     not compiler_supports_target(CompilerID, Target),
-     compiler_name(CompilerID, Compiler),
-     compiler_version(CompilerID, Version),
+     attr("virtual_on_edge", node(X, Package), node(Y, Compiler), Language),
+     attr("version", node(Y, Compiler), Version),
+     compiler(Compiler), language(Language),
+     not compiler_supports_target(Compiler, Version, Target),
      build(node(X, Package)).
 
 #defined compiler_supports_target/2.
-#defined compiler_available/1.
 
 % if a target is set explicitly, respect it
 attr("node_target", PackageNode, Target)
  :- attr("node", PackageNode), attr("node_target_set", PackageNode, Target).
 
-% each node has the weight of its assigned target
-target_weight(Target, 0)
- :- attr("node", PackageNode),
-    attr("node_target", PackageNode, Target),
-    attr("node_target_set", PackageNode, Target).
-
 node_target_weight(PackageNode, MinWeight)
  :- attr("node", PackageNode),
     attr("node_target", PackageNode, Target),
@@ -1306,150 +1414,12 @@ error(100, "'{0} target={1}' is not compatible with this machine", Package, Targ
      attr("node_target", node(X, Package), Target),
      not target(Target).
 
-%-----------------------------------------------------------------------------
-% Compiler semantics
-%-----------------------------------------------------------------------------
-% There must be only one compiler set per built node.
-{ node_compiler(PackageNode, CompilerID) : compiler_id(CompilerID), compiler_available(CompilerID) } :-
-    attr("node", PackageNode),
-    build(PackageNode).
-
-% Infer the compiler that matches a reused node
-node_compiler(PackageNode, CompilerID)
-  :- attr("node_compiler_version", PackageNode, CompilerName, CompilerVersion),
-     attr("node", PackageNode),
-     compiler_name(CompilerID, CompilerName),
-     compiler_version(CompilerID, CompilerVersion),
-     concrete(PackageNode).
-
-% Expand the internal attribute into "attr("node_compiler_version")
-attr("node_compiler_version", PackageNode, CompilerName, CompilerVersion)
-  :- node_compiler(PackageNode, CompilerID),
-     compiler_name(CompilerID, CompilerName),
-     compiler_version(CompilerID, CompilerVersion),
-     compiler_available(CompilerID),
-     build(PackageNode).
-
-attr("node_compiler", PackageNode, CompilerName)
-  :- attr("node_compiler_version", PackageNode, CompilerName, CompilerVersion).
-
-error(100, "No valid compiler version found for '{0}'", Package)
-  :- attr("node", node(X, Package)),
-     not node_compiler(node(X, Package), _).
-
-% We can't have a compiler be enforced and select the version from another compiler
-error(100, "Cannot select a single compiler for package {0}", Package)
- :- attr("node", node(X, Package)),
-    2 { attr("node_compiler_version", node(X, Package), C, V) }.
-
-% If the compiler of a node cannot be satisfied, raise
-error(10, "No valid compiler for {0} satisfies '%{1}'", Package, Compiler)
-  :- attr("node", node(X, Package)),
-     attr("node_compiler_version_satisfies", node(X, Package), Compiler, ":"),
-     not compiler_version_satisfies(Compiler, ":", _).
-
-% If the compiler of a node must satisfy a constraint, then its version
-% must be chosen among the ones that satisfy said constraint
-error(100, "Package {0} cannot satisfy '%{1}@{2}'", Package, Compiler, Constraint)
-  :- attr("node", node(X, Package)),
-     attr("node_compiler_version_satisfies", node(X, Package), Compiler, Constraint),
-	 not compiler_version_satisfies(Compiler, Constraint, _).
-
-error(100, "Package {0} cannot satisfy '%{1}@{2}'", Package, Compiler, Constraint)
-  :- attr("node", node(X, Package)),
-     attr("node_compiler_version_satisfies", node(X, Package), Compiler, Constraint),
-     not compiler_version_satisfies(Compiler, Constraint, ID),
-     node_compiler(node(X, Package), ID).
-
-% If the node is associated with a compiler and the compiler satisfy a constraint, then
-% the compiler associated with the node satisfy the same constraint
-attr("node_compiler_version_satisfies", PackageNode, Compiler, Constraint)
-  :- node_compiler(PackageNode, CompilerID),
-     compiler_name(CompilerID, Compiler),
-     compiler_version_satisfies(Compiler, Constraint, CompilerID).
-
-#defined compiler_version_satisfies/3.
-
-% If the compiler version was set from the command line,
-% respect it verbatim
-error(100, "Cannot set the required compiler: {2}%{0}@{1}", Compiler, Version, Package)
-  :- attr("node_compiler_version_set", node(X, Package), Compiler, Version),
-     not attr("node_compiler_version", node(X, Package), Compiler, Version).
-
-error(100, "Cannot set the required compiler: {1}%{0}", Compiler, Package)
-  :- attr("node_compiler_set", node(X, Package), Compiler),
-     not attr("node_compiler_version", node(X, Package), Compiler, _).
-
-% Cannot select a compiler if it is not supported on the OS
-% Compilers that are explicitly marked as allowed
-% are excluded from this check
-error(100, "{0} compiler '%{1}@{2}' incompatible with 'os={3}'", Package, Compiler, Version, OS)
-  :- attr("node_os", node(X, Package), OS),
-     node_compiler(node(X, Package), CompilerID),
-     compiler_name(CompilerID, Compiler),
-     compiler_version(CompilerID, Version),
-     compiler_os(CompilerID, CompilerOS),
-     not os_compatible(CompilerOS, OS),
-     build(node(X, Package)).
-
-% If a package and one of its dependencies don't have the
-% same compiler there's a mismatch.
-compiler_match(PackageNode, DependencyNode)
-  :- depends_on(PackageNode, DependencyNode),
-     node_compiler(PackageNode, CompilerID),
-     node_compiler(DependencyNode, CompilerID).
-
-compiler_mismatch(PackageNode, DependencyNode)
-  :- depends_on(PackageNode, DependencyNode),
-     not attr("node_compiler_set", DependencyNode, _),
-     not compiler_match(PackageNode, DependencyNode).
-
-compiler_mismatch_required(PackageNode, DependencyNode)
-  :- depends_on(PackageNode, DependencyNode),
-     attr("node_compiler_set", DependencyNode, _),
-     not compiler_match(PackageNode, DependencyNode).
-
-#defined compiler_os/3.
-
-% compilers weighted by preference according to packages.yaml
-node_compiler_weight(node(ID, Package), Weight)
- :- node_compiler(node(ID, Package), CompilerID),
-    compiler_name(CompilerID, Compiler),
-    compiler_version(CompilerID, V),
-    compiler_weight(CompilerID, Weight).
-
-node_compiler_weight(node(ID, Package), 100)
- :- node_compiler(node(ID, Package), CompilerID),
-    compiler_name(CompilerID, Compiler),
-    compiler_version(CompilerID, V),
-    not compiler_weight(CompilerID, _).
-
-% For the time being, be strict and reuse only if the compiler match one we have on the system
-error(100, "Compiler {1}@{2} requested for {0} cannot be found.", Package, Compiler, Version)
- :- attr("node_compiler_version", node(ID, Package), Compiler, Version),
-    not node_compiler(node(ID, Package), _).
-
-#defined node_compiler_preference/4.
-#defined compiler_weight/3.
-
 %-----------------------------------------------------------------------------
 % Compiler flags
 %-----------------------------------------------------------------------------
 
-% compiler flags from compilers.yaml are put on nodes if compiler matches
-attr("node_flag", PackageNode, node_flag(FlagType, Flag, FlagGroup, CompilerID))
-  :- compiler_flag(CompilerID, FlagType, Flag, FlagGroup),
-     node_compiler(PackageNode, CompilerID),
-     flag_type(FlagType),
-     compiler_id(CompilerID),
-     compiler_name(CompilerID, CompilerName),
-     compiler_version(CompilerID, Version).
-
 attr("node_flag", PackageNode, NodeFlag) :- attr("node_flag_set", PackageNode, NodeFlag).
 
-#defined compiler_flag/4.
-
-
 %-----------------------------------------------------------------------------
 % Installed Packages
 %-----------------------------------------------------------------------------
@@ -1592,7 +1562,7 @@ opt_criterion(310, "requirement weight").
 % Try hard to reuse installed packages (i.e., minimize the number built)
 opt_criterion(110, "number of packages to build (vs. reuse)").
 #minimize { 0@110: #true }.
-#minimize { 1@110,PackageNode : build(PackageNode), optimize_for_reuse() }.
+#minimize { 1@110,PackageNode : build(PackageNode) }.
 
 opt_criterion(100, "number of nodes from the same package").
 #minimize { 0@100: #true }.
@@ -1666,6 +1636,17 @@ opt_criterion(50, "number of non-default variants (non-roots)").
       build_priority(PackageNode, Priority)
 }.
 
+% Minimize the weights of the providers, i.e. use as much as
+% possible the first providers
+opt_criterion(48, "number of duplicate virtuals needed").
+#minimize{ 0@248: #true }.
+#minimize{ 0@48: #true }.
+#minimize{
+    Weight@48+Priority,ProviderNode,Virtual
+    : provider(ProviderNode, node(Weight, Virtual)),
+      build_priority(ProviderNode, Priority)
+}.
+
 % Minimize the weights of the providers, i.e. use as much as
 % possible the most preferred providers
 opt_criterion(45, "preferred providers (non-roots)").
@@ -1678,27 +1659,6 @@ opt_criterion(45, "preferred providers (non-roots)").
       build_priority(ProviderNode, Priority)
 }.
 
-% Try to minimize the number of compiler mismatches in the DAG.
-opt_criterion(40, "compiler mismatches that are not required").
-#minimize{ 0@240: #true }.
-#minimize{ 0@40: #true }.
-#minimize{
-    1@40+Priority,PackageNode,node(ID, Dependency)
-    : compiler_mismatch(PackageNode, node(ID, Dependency)),
-      build_priority(node(ID, Dependency), Priority),
-      not runtime(Dependency)
-}.
-
-opt_criterion(39, "compiler mismatches that are required").
-#minimize{ 0@239: #true }.
-#minimize{ 0@39: #true }.
-#minimize{
-    1@39+Priority,PackageNode,node(ID, Dependency)
-    : compiler_mismatch_required(PackageNode, node(ID, Dependency)),
-      build_priority(node(ID, Dependency), Priority),
-      not runtime(Dependency)
-}.
-
 opt_criterion(30, "non-preferred OS's").
 #minimize{ 0@230: #true }.
 #minimize{ 0@30: #true }.
@@ -1731,17 +1691,6 @@ opt_criterion(20, "default values of variants not being used (non-roots)").
       build_priority(PackageNode, Priority)
 }.
 
-% Try to use preferred compilers
-opt_criterion(15, "non-preferred compilers").
-#minimize{ 0@215: #true }.
-#minimize{ 0@15: #true }.
-#minimize{
-    Weight@15+Priority,node(X, Package)
-    : node_compiler_weight(node(X, Package), Weight),
-      build_priority(node(X, Package), Priority),
-      not runtime(Package)
-}.
-
 % Minimize the number of mismatches for targets in the DAG, try
 % to select the preferred target.
 opt_criterion(10, "target mismatches").
@@ -1765,20 +1714,6 @@ opt_criterion(5, "non-preferred targets").
 }.
 
 
-% Minimize the number of compiler mismatches for runtimes
-opt_criterion(4, "compiler mismatches (runtimes)").
-#minimize{ 0@204: #true }.
-#minimize{ 0@4: #true }.
-#minimize{
-    1@4,PackageNode,node(ID, Dependency)
-    : compiler_mismatch(PackageNode, node(ID, Dependency)), runtime(Dependency)
-}.
-#minimize{
-    1@4,PackageNode,node(ID, Dependency)
-    : compiler_mismatch_required(PackageNode, node(ID, Dependency)), runtime(Dependency)
-}.
-
-
 % Choose more recent versions for runtimes
 opt_criterion(3, "version badness (runtimes)").
 #minimize{ 0@203: #true }.

lib/spack/spack/solver/counter.py

@@ -126,22 +126,28 @@ def _compute_cache_values(self):
         self._possible_dependencies = set(self._link_run) | set(self._total_build)
 
     def possible_packages_facts(self, gen, fn):
-        build_tools = spack.repo.PATH.packages_with_tags("build-tools")
+        build_tools = set()
+        for current_tag in ("build-tools", "compiler"):
+            build_tools.update(spack.repo.PATH.packages_with_tags(current_tag))
+
         gen.h2("Packages with at most a single node")
         for package_name in sorted(self.possible_dependencies() - build_tools):
             gen.fact(fn.max_dupes(package_name, 1))
         gen.newline()
 
-        gen.h2("Packages with at multiple possible nodes (build-tools)")
+        gen.h2("Packages with multiple possible nodes (build-tools)")
         for package_name in sorted(self.possible_dependencies() & build_tools):
             gen.fact(fn.max_dupes(package_name, 2))
             gen.fact(fn.multiple_unification_sets(package_name))
         gen.newline()
 
         gen.h2("Maximum number of nodes (virtual packages)")
-        for package_name in sorted(self.possible_virtuals()):
+        for package_name in sorted(self._link_run_virtuals):
             gen.fact(fn.max_dupes(package_name, 1))
         gen.newline()
+        for package_name in sorted(self.possible_virtuals() - self._link_run_virtuals):
+            gen.fact(fn.max_dupes(package_name, 2))
+        gen.newline()
 
         gen.h2("Possible package in link-run subDAG")
         for name in sorted(self._link_run):

lib/spack/spack/solver/heuristic.lp

@@ -15,6 +15,8 @@
 #heuristic attr("virtual_node", node(X, Virtual)). [60, init]
 #heuristic attr("virtual_node", node(X, Virtual)). [-1, sign]
 #heuristic attr("virtual_node", node(0, Virtual)) : node_depends_on_virtual(PackageNode, Virtual). [1@2, sign]
+#heuristic attr("virtual_node", node(0, "c")).     [1@3, sign]
+#heuristic attr("virtual_node", node(0, "cxx")).   [1@3, sign]
 
 #heuristic attr("depends_on", ParentNode, ChildNode, Type). [150, init]
 #heuristic attr("depends_on", ParentNode, ChildNode, Type). [4,  factor]
@@ -38,6 +40,3 @@
 % Use default targets
 #heuristic attr("node_target", node(PackageID, Package), Target). [-1, sign]
 #heuristic attr("node_target", node(PackageID, Package), Target) : target_weight(Target, 0), attr("node", node(PackageID, Package)). [1@2, sign]
-
-% Use the default compilers
-#heuristic node_compiler(node(PackageID, Package), ID) : compiler_weight(ID, 0), compiler_id(ID), attr("node", node(PackageID, Package)). [30, init]

lib/spack/spack/solver/libc_compatibility.lp

@@ -9,25 +9,29 @@
 % These rules are used on Linux
 %=============================================================================
 
-% A package cannot be reused if the libc is not compatible with it
+
+% A package cannot be reused if it needs a libc that is not compatible with the current one
 error(100, "Cannot reuse {0} since we cannot determine libc compatibility", ReusedPackage)
   :- provider(node(X, LibcPackage), node(0, "libc")),
      attr("version", node(X, LibcPackage), LibcVersion),
-     attr("hash", node(R, ReusedPackage), Hash),
-     % Libc packages can be reused without the "compatible_libc" attribute
-     ReusedPackage != LibcPackage,
+     concrete(node(R, ReusedPackage)),
+     attr("needs_libc", node(R, ReusedPackage)),
      not attr("compatible_libc", node(R, ReusedPackage), LibcPackage, LibcVersion).
 
-% A libc is needed in the DAG
-:- has_built_packages(), not provider(_, node(0, "libc")).
+% In case we don't need a provider for libc, ensure there's at least one compatible libc on the host
+error(100, "Cannot reuse {0} since we cannot determine libc compatibility", ReusedPackage)
+  :- not provider(_, node(0, "libc")),
+     concrete(node(R, ReusedPackage)),
+     attr("needs_libc", node(R, ReusedPackage)),
+     not attr("compatible_libc", node(R, ReusedPackage), _, _).
 
 % Non-libc reused specs must be host libc compatible. In case we build packages, we get a
 % host compatible libc provider from other rules. If nothing is built, there is no libc provider,
 % since it's pruned from reusable specs, meaning we have to explicitly impose reused specs are host
 % compatible.
-:- attr("hash", node(R, ReusedPackage), Hash),
-   not provider(node(R, ReusedPackage), node(0, "libc")),
-   not attr("compatible_libc", node(R, ReusedPackage), _, _).
+%:- attr("hash", node(R, ReusedPackage), Hash),
+%   not provider(node(R, ReusedPackage), node(0, "libc")),
+%   not attr("compatible_libc", node(R, ReusedPackage), _, _).
 
 % The libc provider must be one that a compiler can target
 :- has_built_packages(),
@@ -35,9 +39,3 @@ error(100, "Cannot reuse {0} since we cannot determine libc compatibility", Reus
    attr("node", node(X, LibcPackage)),
    attr("version", node(X, LibcPackage), LibcVersion),
    not host_libc(LibcPackage, LibcVersion).
-
-% A built node must depend on libc
-:- build(PackageNode),
-   provider(LibcNode, node(0, "libc")),
-   not external(PackageNode),
-   not depends_on(PackageNode, LibcNode).

lib/spack/spack/solver/requirements.py

@@ -10,6 +10,7 @@
 import spack.config
 import spack.error
 import spack.package_base
+import spack.repo
 import spack.spec
 from spack.config import get_mark_from_yaml_data
 
@@ -195,20 +196,30 @@ def reject_requirement_constraint(
         self, pkg_name: str, *, constraint: spack.spec.Spec, kind: RequirementKind
     ) -> bool:
         """Returns True if a requirement constraint should be rejected"""
-        if kind == RequirementKind.DEFAULT:
-            # Requirements under all: are applied only if they are satisfiable considering only
-            # package rules, so e.g. variants must exist etc. Otherwise, they are rejected.
-            try:
-                s = spack.spec.Spec(pkg_name)
-                s.constrain(constraint)
-                s.validate_or_raise()
-            except spack.error.SpackError as e:
-                tty.debug(
-                    f"[SETUP] Rejecting the default '{constraint}' requirement "
-                    f"on '{pkg_name}': {str(e)}",
-                    level=2,
-                )
-                return True
+        # If it's a specific package requirement, it's never rejected
+        if kind != RequirementKind.DEFAULT:
+            return False
+
+        # Reject default requirements for runtimes and compilers
+        if pkg_name in spack.repo.PATH.packages_with_tags("runtime"):
+            return True
+
+        if pkg_name in spack.repo.PATH.packages_with_tags("compiler"):
+            return True
+
+        # Requirements under all: are applied only if they are satisfiable considering only
+        # package rules, so e.g. variants must exist etc. Otherwise, they are rejected.
+        try:
+            s = spack.spec.Spec(pkg_name)
+            s.constrain(constraint)
+            s.validate_or_raise()
+        except spack.error.SpackError as e:
+            tty.debug(
+                f"[SETUP] Rejecting the default '{constraint}' requirement "
+                f"on '{pkg_name}': {str(e)}",
+                level=2,
+            )
+            return True
         return False
 
 

lib/spack/spack/spec.py

@@ -71,8 +71,7 @@
 import llnl.util.tty.color as clr
 
 import spack
-import spack.compiler
-import spack.compilers
+import spack.compilers.flags
 import spack.config
 import spack.deptypes as dt
 import spack.error
@@ -83,6 +82,7 @@
 import spack.provider_index
 import spack.repo
 import spack.solver
+import spack.spec
 import spack.store
 import spack.traverse as traverse
 import spack.util.executable
@@ -163,15 +163,13 @@
 #: Default format for Spec.format(). This format can be round-tripped, so that:
 #:     Spec(Spec("string").format()) == Spec("string)"
 DEFAULT_FORMAT = (
-    "{name}{@versions}"
-    "{%compiler.name}{@compiler.versions}{compiler_flags}"
+    "{name}{@versions}{compiler_flags}"
     "{variants}{ namespace=namespace_if_anonymous}{ arch=architecture}{/abstract_hash}"
 )
 
 #: Display format, which eliminates extra `@=` in the output, for readability.
 DISPLAY_FORMAT = (
-    "{name}{@version}"
-    "{%compiler.name}{@compiler.version}{compiler_flags}"
+    "{name}{@version}{compiler_flags}"
     "{variants}{ namespace=namespace_if_anonymous}{ arch=architecture}{/abstract_hash}"
 )
 
@@ -186,7 +184,7 @@
 )
 
 #: specfile format version. Must increase monotonically
-SPECFILE_FORMAT_VERSION = 4
+SPECFILE_FORMAT_VERSION = 5
 
 
 class InstallStatus(enum.Enum):
@@ -596,137 +594,82 @@ def __repr__(self):
     def __contains__(self, string):
         return string in str(self) or string in self.target
 
+    def complete_with_defaults(self) -> None:
+        default_architecture = ArchSpec.default_arch()
+        if not self.platform:
+            self.platform = default_architecture.platform
+
+        if not self.os:
+            self.os = default_architecture.os
+
+        if not self.target:
+            self.target = default_architecture.target
+
 
-@lang.lazy_lexicographic_ordering
 class CompilerSpec:
-    """The CompilerSpec field represents the compiler or range of compiler
-    versions that a package should be built with.  CompilerSpecs have a
-    name and a version list."""
+    """Adaptor to the old compiler spec interface. Exposes just a few attributes"""
 
-    __slots__ = "name", "versions"
-
-    def __init__(self, *args):
-        nargs = len(args)
-        if nargs == 1:
-            arg = args[0]
-            # If there is one argument, it's either another CompilerSpec
-            # to copy or a string to parse
-            if isinstance(arg, str):
-                spec = spack.parser.parse_one_or_raise(f"%{arg}")
-                self.name = spec.compiler.name
-                self.versions = spec.compiler.versions
-
-            elif isinstance(arg, CompilerSpec):
-                self.name = arg.name
-                self.versions = arg.versions.copy()
-
-            else:
-                raise TypeError(
-                    "Can only build CompilerSpec from string or "
-                    + "CompilerSpec. Found %s" % type(arg)
-                )
-
-        elif nargs == 2:
-            name, version = args
-            self.name = name
-            self.versions = vn.VersionList([vn.ver(version)])
-
-        else:
-            raise TypeError("__init__ takes 1 or 2 arguments. (%d given)" % nargs)
-
-    def _autospec(self, compiler_spec_like):
-        if isinstance(compiler_spec_like, CompilerSpec):
-            return compiler_spec_like
-        return CompilerSpec(compiler_spec_like)
-
-    def intersects(self, other: "CompilerSpec") -> bool:
-        """Return True if all concrete specs matching self also match other, otherwise False.
-
-        For compiler specs this means that the name of the compiler must be the same for
-        self and other, and that the versions ranges should intersect.
-
-        Args:
-            other: spec to be satisfied
-        """
-        other = self._autospec(other)
-        return self.name == other.name and self.versions.intersects(other.versions)
-
-    def satisfies(self, other: "CompilerSpec") -> bool:
-        """Return True if all concrete specs matching self also match other, otherwise False.
-
-        For compiler specs this means that the name of the compiler must be the same for
-        self and other, and that the version range of self is a subset of that of other.
-
-        Args:
-            other: spec to be satisfied
-        """
-        other = self._autospec(other)
-        return self.name == other.name and self.versions.satisfies(other.versions)
-
-    def constrain(self, other: "CompilerSpec") -> bool:
-        """Intersect self's versions with other.
-
-        Return whether the CompilerSpec changed.
-        """
-        other = self._autospec(other)
-
-        # ensure that other will actually constrain this spec.
-        if not other.intersects(self):
-            raise UnsatisfiableCompilerSpecError(other, self)
-
-        return self.versions.intersect(other.versions)
+    def __init__(self, spec):
+        self.spec = spec
 
     @property
-    def concrete(self):
-        """A CompilerSpec is concrete if its versions are concrete and there
-        is an available compiler with the right version."""
-        return self.versions.concrete
+    def name(self):
+        return self.spec.name
 
     @property
     def version(self):
-        if not self.concrete:
-            raise spack.error.SpecError("Spec is not concrete: " + str(self))
-        return self.versions[0]
+        return self.spec.version
 
-    def copy(self):
-        clone = CompilerSpec.__new__(CompilerSpec)
-        clone.name = self.name
-        clone.versions = self.versions.copy()
-        return clone
-
-    def _cmp_iter(self):
-        yield self.name
-        yield self.versions
-
-    def to_dict(self):
-        d = syaml.syaml_dict([("name", self.name)])
-        d.update(self.versions.to_dict())
-
-        return syaml.syaml_dict([("compiler", d)])
-
-    @staticmethod
-    def from_dict(d):
-        d = d["compiler"]
-        return CompilerSpec(d["name"], vn.VersionList.from_dict(d))
+    @property
+    def versions(self):
+        return self.spec.versions
 
     @property
     def display_str(self):
         """Equivalent to {compiler.name}{@compiler.version} for Specs, without extra
         @= for readability."""
-        if self.concrete:
+        if self.spec.concrete:
             return f"{self.name}@{self.version}"
         elif self.versions != vn.any_version:
             return f"{self.name}@{self.versions}"
         return self.name
 
-    def __str__(self):
-        out = self.name
-        if self.versions and self.versions != vn.any_version:
-            out += f"@{self.versions}"
-        return out
+    def __lt__(self, other):
+        if not isinstance(other, CompilerSpec):
+            return self.spec < other
+        return self.spec < other.spec
 
-    def __repr__(self):
-        return str(self)
+    def __eq__(self, other):
+        if not isinstance(other, CompilerSpec):
+            return self.spec == other
+        return self.spec == other.spec
+
+    def __hash__(self):
+        return hash(self.spec)
+
+    def __str__(self):
+        return str(self.spec)
+
+    def _cmp_iter(self):
+        return self.spec._cmp_iter()
+
+    def __bool__(self):
+        if self.spec == Spec():
+            return False
+        return bool(self.spec)
+
+
+class DeprecatedCompilerSpec(lang.DeprecatedProperty):
+    def __init__(self):
+        super().__init__(name="compiler")
+
+    def factory(self, instance, owner):
+        for language in ("c", "cxx", "fortran"):
+            deps = instance.dependencies(virtuals=language)
+            if deps:
+                return CompilerSpec(deps[0])
+
+        raise AttributeError(f"{instance} has no C, C++, or Fortran compiler")
 
 
 @lang.lazy_lexicographic_ordering
@@ -747,15 +690,22 @@ class DependencySpec:
         virtuals: virtual packages provided from child to parent node.
     """
 
-    __slots__ = "parent", "spec", "depflag", "virtuals"
+    __slots__ = "parent", "spec", "depflag", "virtuals", "direct"
 
     def __init__(
-        self, parent: "Spec", spec: "Spec", *, depflag: dt.DepFlag, virtuals: Tuple[str, ...]
+        self,
+        parent: "Spec",
+        spec: "Spec",
+        *,
+        depflag: dt.DepFlag,
+        virtuals: Tuple[str, ...],
+        direct: bool = False,
     ):
         self.parent = parent
         self.spec = spec
         self.depflag = depflag
         self.virtuals = tuple(sorted(set(virtuals)))
+        self.direct = direct
 
     def update_deptypes(self, depflag: dt.DepFlag) -> bool:
         """Update the current dependency types"""
@@ -774,7 +724,13 @@ def update_virtuals(self, virtuals: Tuple[str, ...]) -> bool:
 
     def copy(self) -> "DependencySpec":
         """Return a copy of this edge"""
-        return DependencySpec(self.parent, self.spec, depflag=self.depflag, virtuals=self.virtuals)
+        return DependencySpec(
+            self.parent,
+            self.spec,
+            depflag=self.depflag,
+            virtuals=self.virtuals,
+            direct=self.direct,
+        )
 
     def _cmp_iter(self):
         yield self.parent.name if self.parent else None
@@ -1429,12 +1385,34 @@ def tree(
     return out
 
 
+class SpecAnnotations:
+    def __init__(self) -> None:
+        self.original_spec_format = SPECFILE_FORMAT_VERSION
+        self.compiler_node_attribute: Optional["Spec"] = None
+
+    def with_spec_format(self, spec_format: int) -> "SpecAnnotations":
+        self.original_spec_format = spec_format
+        return self
+
+    def with_compiler(self, compiler: "Spec") -> "SpecAnnotations":
+        self.compiler_node_attribute = compiler
+        return self
+
+    def __repr__(self) -> str:
+        result = f"SpecAnnotations().with_spec_format({self.original_spec_format})"
+        if self.compiler_node_attribute:
+            result += f"with_compiler({str(self.compiler_node_attribute)})"
+        return result
+
+
 @lang.lazy_lexicographic_ordering(set_hash=False)
 class Spec:
     #: Cache for spec's prefix, computed lazily in the corresponding property
     _prefix = None
     abstract_hash = None
 
+    compiler = DeprecatedCompilerSpec()
+
     @staticmethod
     def default_arch():
         """Return an anonymous spec for the default architecture"""
@@ -1474,7 +1452,6 @@ def __init__(
         self.versions = vn.VersionList(":")
         self.variants = VariantMap(self)
         self.architecture = None
-        self.compiler = None
         self.compiler_flags = FlagMap(self)
         self._dependents = _EdgeMap(store_by_child=False)
         self._dependencies = _EdgeMap(store_by_child=True)
@@ -1511,12 +1488,13 @@ def __init__(
         # is deployed "as built."
         # Build spec should be the actual build spec unless marked dirty.
         self._build_spec = None
+        self.annotations = SpecAnnotations()
 
         if isinstance(spec_like, str):
             spack.parser.parse_one_or_raise(spec_like, self)
 
         elif spec_like is not None:
-            raise TypeError("Can't make spec out of %s" % type(spec_like))
+            raise TypeError(f"Can't make spec out of {type(spec_like)}")
 
     @staticmethod
     def _format_module_list(modules):
@@ -1720,7 +1698,7 @@ def _add_flag(self, name, value, propagate):
             self.namespace = value
         elif name in valid_flags:
             assert self.compiler_flags is not None
-            flags_and_propagation = spack.compiler.tokenize_flags(value, propagate)
+            flags_and_propagation = spack.compilers.flags.tokenize_flags(value, propagate)
             flag_group = " ".join(x for (x, y) in flags_and_propagation)
             for flag, propagation in flags_and_propagation:
                 self.compiler_flags.add_flag(name, flag, propagation, flag_group)
@@ -1751,10 +1729,18 @@ def _set_architecture(self, **kwargs):
                 else:
                     setattr(self.architecture, new_attr, new_value)
 
-    def _add_dependency(self, spec: "Spec", *, depflag: dt.DepFlag, virtuals: Tuple[str, ...]):
-        """Called by the parser to add another spec as a dependency."""
+    def _add_dependency(
+        self, spec: "Spec", *, depflag: dt.DepFlag, virtuals: Tuple[str, ...], direct: bool = False
+    ):
+        """Called by the parser to add another spec as a dependency.
+
+        Args:
+            depflag: dependency type for this edge
+            virtuals: virtuals on this edge
+            direct: if True denotes a direct dependency (associated with the % sigil)
+        """
         if spec.name not in self._dependencies or not spec.name:
-            self.add_dependency_edge(spec, depflag=depflag, virtuals=virtuals)
+            self.add_dependency_edge(spec, depflag=depflag, virtuals=virtuals, direct=direct)
             return
 
         # Keep the intersection of constraints when a dependency is added multiple times with
@@ -1777,7 +1763,7 @@ def _add_dependency(self, spec: "Spec", *, depflag: dt.DepFlag, virtuals: Tuple[
                     f"\t'{str(self)}' cannot depend on '{required_dep_str}'"
                 )
 
-            self.add_dependency_edge(spec, depflag=depflag, virtuals=virtuals)
+            self.add_dependency_edge(spec, depflag=depflag, virtuals=virtuals, direct=direct)
             return
 
         try:
@@ -1789,7 +1775,12 @@ def _add_dependency(self, spec: "Spec", *, depflag: dt.DepFlag, virtuals: Tuple[
             )
 
     def add_dependency_edge(
-        self, dependency_spec: "Spec", *, depflag: dt.DepFlag, virtuals: Tuple[str, ...]
+        self,
+        dependency_spec: "Spec",
+        *,
+        depflag: dt.DepFlag,
+        virtuals: Tuple[str, ...],
+        direct: bool = False,
     ):
         """Add a dependency edge to this spec.
 
@@ -1797,6 +1788,7 @@ def add_dependency_edge(
             dependency_spec: spec of the dependency
             deptypes: dependency types for this edge
             virtuals: virtuals provided by this edge
+            direct: if True denotes a direct dependency
         """
         # Check if we need to update edges that are already present
         selected = self._dependencies.select(child=dependency_spec.name)
@@ -1835,7 +1827,9 @@ def add_dependency_edge(
                 edge.update_virtuals(virtuals=virtuals)
                 return
 
-        edge = DependencySpec(self, dependency_spec, depflag=depflag, virtuals=virtuals)
+        edge = DependencySpec(
+            self, dependency_spec, depflag=depflag, virtuals=virtuals, direct=direct
+        )
         self._dependencies.add(edge)
         dependency_spec._dependents.add(edge)
 
@@ -2138,10 +2132,6 @@ def to_node_dict(self, hash=ht.dag_hash):
                         'platform_os': 'mojave',
                         'target': 'x86_64',
                     },
-                    'compiler': {
-                        'name': 'apple-clang',
-                        'version': '10.0.0',
-                    },
                     'namespace': 'builtin',
                     'parameters': {
                         'fts': 'true',
@@ -2184,9 +2174,6 @@ def to_node_dict(self, hash=ht.dag_hash):
         if self.architecture:
             d.update(self.architecture.to_dict())
 
-        if self.compiler:
-            d.update(self.compiler.to_dict())
-
         if self.namespace:
             d["namespace"] = self.namespace
 
@@ -2276,6 +2263,14 @@ def to_node_dict(self, hash=ht.dag_hash):
             d["build_spec"] = syaml.syaml_dict(
                 [("name", self.build_spec.name), (hash.name, self.build_spec._cached_hash(hash))]
             )
+
+        # Annotations
+        d["annotations"] = syaml.syaml_dict(
+            [("original_specfile_version", self.annotations.original_spec_format)]
+        )
+        if self.annotations.original_spec_format < 5:
+            d["annotations"]["compiler"] = str(self.annotations.compiler_node_attribute)
+
         return d
 
     def to_dict(self, hash=ht.dag_hash):
@@ -2432,8 +2427,6 @@ def override(init_spec, change_spec):
             else:
                 raise ValueError("{0} is not a variant of {1}".format(vname, new_spec.name))
 
-        if change_spec.compiler:
-            new_spec.compiler = change_spec.compiler
         if change_spec.compiler_flags:
             for flagname, flagvals in change_spec.compiler_flags.items():
                 new_spec.compiler_flags[flagname] = flagvals
@@ -2605,8 +2598,10 @@ def from_dict(data):
             spec = SpecfileV2.load(data)
         elif int(data["spec"]["_meta"]["version"]) == 3:
             spec = SpecfileV3.load(data)
-        else:
+        elif int(data["spec"]["_meta"]["version"]) == 4:
             spec = SpecfileV4.load(data)
+        else:
+            spec = SpecfileV5.load(data)
 
         # Any git version should
         for s in spec.traverse():
@@ -2791,12 +2786,6 @@ def inject_patches_variant(root):
     @staticmethod
     def ensure_external_path_if_external(external_spec):
         if external_spec.external_modules and not external_spec.external_path:
-            compiler = spack.compilers.compiler_for_spec(
-                external_spec.compiler, external_spec.architecture
-            )
-            for mod in compiler.modules:
-                md.load_module(mod)
-
             # Get the path from the module the package can override the default
             # (this is mostly needed for Cray)
             pkg_cls = spack.repo.PATH.get_pkg_class(external_spec.name)
@@ -2958,7 +2947,7 @@ def _finalize_concretization(self):
         for spec in self.traverse():
             spec._cached_hash(ht.dag_hash)
 
-    def concretized(self, tests: Union[bool, Iterable[str]] = False) -> "spack.spec.Spec":
+    def concretized(self, tests: Union[bool, Iterable[str]] = False) -> "Spec":
         """This is a non-destructive version of concretize().
 
         First clones, then returns a concrete version of this package
@@ -2995,9 +2984,14 @@ def validate_or_raise(self):
                 spack.repo.PATH.get_pkg_class(spec.fullname)
 
             # validate compiler in addition to the package name.
-            if spec.compiler:
-                if not spack.compilers.supported(spec.compiler):
-                    raise UnsupportedCompilerError(spec.compiler.name)
+            if spec.dependencies(deptype="build"):
+                pkg_cls = spack.repo.PATH.get_pkg_class(spec.fullname)
+                # FIXME (compiler as nodes): raise if we use %gcc on pkgs that do not depend on C
+                pkg_dependencies = pkg_cls.dependency_names()
+                if not any(x in pkg_dependencies for x in ("c", "cxx", "fortran")):
+                    raise UnsupportedCompilerError(
+                        f"{spec.fullname} does not depend on 'c', 'cxx, or 'fortran'"
+                    )
 
             # Ensure correctness of variants (if the spec is not virtual)
             if not spec.virtual:
@@ -3104,12 +3098,6 @@ def constrain(self, other, deps=True):
             self.namespace = other.namespace
             changed = True
 
-        if self.compiler is not None and other.compiler is not None:
-            changed |= self.compiler.constrain(other.compiler)
-        elif self.compiler is None:
-            changed |= self.compiler != other.compiler
-            self.compiler = other.compiler
-
         changed |= self.versions.intersect(other.versions)
         changed |= self.variants.constrain(other.variants)
 
@@ -3136,10 +3124,8 @@ def constrain(self, other, deps=True):
 
         return changed
 
-    def _constrain_dependencies(self, other):
+    def _constrain_dependencies(self, other: "Spec") -> bool:
         """Apply constraints of other spec's dependencies to this spec."""
-        other = self._autospec(other)
-
         if not other._dependencies:
             return False
 
@@ -3154,8 +3140,10 @@ def _constrain_dependencies(self, other):
 
         # Handle common first-order constraints directly
         changed = False
-        for name in self.common_dependencies(other):
-            changed |= self[name].constrain(other[name], deps=False)
+        common_dependencies = {x.name for x in self.dependencies()}
+        common_dependencies &= {x.name for x in other.dependencies()}
+        for name in common_dependencies:
+            changed |= self[name].constrain(other[name], deps=True)
             if name in self._dependencies:
                 # WARNING: This function is an implementation detail of the
                 # WARNING: original concretizer. Since with that greedy
@@ -3178,13 +3166,14 @@ def _constrain_dependencies(self, other):
                 dep_spec_copy.spec.copy(),
                 depflag=dep_spec_copy.depflag,
                 virtuals=dep_spec_copy.virtuals,
+                direct=dep_spec_copy.direct,
             )
             changed = True
 
         return changed
 
     def common_dependencies(self, other):
-        """Return names of dependencies that self an other have in common."""
+        """Return names of dependencies that self and other have in common."""
         common = set(s.name for s in self.traverse(root=False))
         common.intersection_update(s.name for s in other.traverse(root=False))
         return common
@@ -3284,10 +3273,6 @@ def intersects(self, other: Union[str, "Spec"], deps: bool = True) -> bool:
             if not self.versions.intersects(other.versions):
                 return False
 
-        if self.compiler and other.compiler:
-            if not self.compiler.intersects(other.compiler):
-                return False
-
         if not self.variants.intersects(other.variants):
             return False
 
@@ -3310,8 +3295,10 @@ def _intersects_dependencies(self, other):
             return True
 
         # Handle first-order constraints directly
-        for name in self.common_dependencies(other):
-            if not self[name].intersects(other[name], deps=False):
+        common_dependencies = {x.name for x in self.dependencies()}
+        common_dependencies &= {x.name for x in other.dependencies()}
+        for name in common_dependencies:
+            if not self[name].intersects(other[name], deps=True):
                 return False
 
         # For virtual dependencies, we need to dig a little deeper.
@@ -3388,12 +3375,6 @@ def satisfies(self, other: Union[str, "Spec"], deps: bool = True) -> bool:
         if not self.versions.satisfies(other.versions):
             return False
 
-        if self.compiler and other.compiler:
-            if not self.compiler.satisfies(other.compiler):
-                return False
-        elif other.compiler and not self.compiler:
-            return False
-
         if not self.variants.satisfies(other.variants):
             return False
 
@@ -3431,6 +3412,19 @@ def satisfies(self, other: Union[str, "Spec"], deps: bool = True) -> bool:
             if rhs_edge.spec.virtual:
                 rhs_edge.update_virtuals(virtuals=(rhs_edge.spec.name,))
 
+            if rhs_edge.direct:
+                # Note: this relies on abstract specs from string not being deeper than 2 levels
+                # e.g. in foo %fee ^bar %baz we cannot go deeper than "baz" and e.g. specify its
+                # dependencies too.
+                current_node = self if rhs_edge.parent.name is None else self[rhs_edge.parent.name]
+                candidates = current_node.dependencies(
+                    name=rhs_edge.spec.name,
+                    deptype=rhs_edge.depflag,
+                    virtuals=rhs_edge.virtuals or None,
+                )
+                if not candidates or not any(x.satisfies(rhs_edge.spec) for x in candidates):
+                    return False
+
             if not rhs_edge.virtuals:
                 continue
 
@@ -3534,7 +3528,6 @@ def _dup(self, other, deps: Union[bool, dt.DepTypes, dt.DepFlag] = True, clearde
                 self.name != other.name
                 and self.versions != other.versions
                 and self.architecture != other.architecture
-                and self.compiler != other.compiler
                 and self.variants != other.variants
                 and self._normal != other._normal
                 and self.concrete != other.concrete
@@ -3550,10 +3543,10 @@ def _dup(self, other, deps: Union[bool, dt.DepTypes, dt.DepFlag] = True, clearde
         self.name = other.name
         self.versions = other.versions.copy()
         self.architecture = other.architecture.copy() if other.architecture else None
-        self.compiler = other.compiler.copy() if other.compiler else None
         if cleardeps:
             self._dependents = _EdgeMap(store_by_child=False)
             self._dependencies = _EdgeMap(store_by_child=True)
+
         self.compiler_flags = other.compiler_flags.copy()
         self.compiler_flags.spec = self
         self.variants = other.variants.copy()
@@ -3572,6 +3565,7 @@ def _dup(self, other, deps: Union[bool, dt.DepTypes, dt.DepFlag] = True, clearde
         self.external_modules = other.external_modules
         self.extra_attributes = other.extra_attributes
         self.namespace = other.namespace
+        self.annotations = other.annotations
 
         # If we copy dependencies, preserve DAG structure in the new spec
         if deps:
@@ -3617,7 +3611,10 @@ def spid(spec):
                 new_specs[spid(edge.spec)] = edge.spec.copy(deps=False)
 
             new_specs[spid(edge.parent)].add_dependency_edge(
-                new_specs[spid(edge.spec)], depflag=edge.depflag, virtuals=edge.virtuals
+                new_specs[spid(edge.spec)],
+                depflag=edge.depflag,
+                virtuals=edge.virtuals,
+                direct=edge.direct,
             )
 
     def copy(self, deps: Union[bool, dt.DepTypes, dt.DepFlag] = True, **kwargs):
@@ -3678,21 +3675,14 @@ def __getitem__(self, name: str):
             query_parameters = re.split(r"\s*,\s*", csv)
 
         order = lambda: itertools.chain(
-            self.traverse_edges(deptype=dt.LINK, order="breadth", cover="edges"),
-            self.edges_to_dependencies(depflag=dt.BUILD | dt.RUN | dt.TEST),
-            self.traverse_edges(deptype=dt.ALL, order="breadth", cover="edges"),
+            self.traverse_edges(deptype=dt.LINK | dt.RUN, order="breadth", cover="edges"),
+            self.edges_to_dependencies(depflag=dt.BUILD | dt.TEST),
         )
 
-        # Consider runtime dependencies and direct build/test deps before transitive dependencies,
-        # and prefer matches closest to the root.
+        # Consider runtime dependencies and direct build/test deps only
         try:
             child: Spec = next(
-                e.spec
-                for e in itertools.chain(
-                    (e for e in order() if e.spec.name == name or name in e.virtuals),
-                    # for historical reasons
-                    (e for e in order() if e.spec.concrete and e.spec.package.provides(name)),
-                )
+                e.spec for e in order() if e.spec.name == name or name in e.virtuals
             )
         except StopIteration:
             raise KeyError(f"No spec with name {name} in {self}")
@@ -3716,8 +3706,11 @@ def __contains__(self, spec):
         # if anonymous or same name, we only have to look at the root
         if not spec.name or spec.name == self.name:
             return self.satisfies(spec)
-        else:
-            return any(s.satisfies(spec) for s in self.traverse(root=False))
+
+        try:
+            return self[spec.name].satisfies(spec)
+        except KeyError:
+            return False
 
     def eq_dag(self, other, deptypes=True, vs=None, vo=None):
         """True if the full dependency DAGs of specs are equal."""
@@ -3767,7 +3760,6 @@ def _cmp_node(self):
         yield self.namespace
         yield self.versions
         yield self.variants
-        yield self.compiler
         yield self.compiler_flags
         yield self.architecture
         yield self.abstract_hash
@@ -3821,9 +3813,6 @@ def format(self, format_string: str = DEFAULT_FORMAT, color: Optional[bool] = Fa
 
             name
             version
-            compiler
-            compiler.name
-            compiler.version
             compiler_flags
             variants
             architecture
@@ -3965,6 +3954,9 @@ def format_attribute(match_object: Match) -> str:
                     try:
                         current = getattr(current, part)
                     except AttributeError:
+                        if part == "compiler":
+                            return "none"
+
                         raise SpecFormatStringError(
                             f"Attempted to format attribute {attribute}. "
                             f"Spec {'.'.join(parts[:idx])} has no attribute {part}"
@@ -4066,15 +4058,28 @@ def __str__(self):
         if not self._dependencies:
             return self.format()
 
-        root_str = [self.format()]
-        sorted_dependencies = sorted(
-            self.traverse(root=False), key=lambda x: (x.name, x.abstract_hash)
+        name_conversion = {
+            "llvm": "clang",
+            "intel-oneapi-compilers": "oneapi",
+            "llvm-amdgpu": "rocmcc",
+            "intel-oneapi-compiler-classic": "intel",
+            "acfl": "arm",
+        }
+        parts = [self.format()]
+        direct, transitive = lang.stable_partition(
+            self.edges_to_dependencies(), predicate_fn=lambda x: x.direct
         )
-        sorted_dependencies = [
-            d.format("{edge_attributes} " + DEFAULT_FORMAT) for d in sorted_dependencies
-        ]
-        spec_str = " ^".join(root_str + sorted_dependencies)
-        return spec_str.strip()
+        for item in sorted(direct, key=lambda x: x.spec.name):
+            current_name = item.spec.name
+            new_name = name_conversion.get(current_name, current_name)
+            parts.append(f"%{item.spec.format()}".replace(current_name, new_name))
+        for item in sorted(transitive, key=lambda x: x.spec.name):
+            # Recurse to attach build deps in order
+            edge_attributes = ""
+            if item.virtuals or item.depflag:
+                edge_attributes = item.spec.format("{edge_attributes}") + " "
+            parts.append(f"^{edge_attributes}{str(item.spec)}")
+        return " ".join(parts).strip()
 
     @property
     def colored_str(self):
@@ -4495,6 +4500,10 @@ def attach_git_version_lookup(self):
             if isinstance(v, vn.GitVersion) and v._ref_version is None:
                 v.attach_lookup(spack.version.git_ref_lookup.GitRefLookup(self.fullname))
 
+    def original_spec_format(self) -> int:
+        """Returns the spec format originally used for this spec."""
+        return self.annotations.original_spec_format
+
 
 class VariantMap(lang.HashableMap):
     """Map containing variant instances. New values can be added only
@@ -4724,9 +4733,9 @@ def substitute_abstract_variants(spec: Spec):
         )
 
 
-def parse_with_version_concrete(spec_like: Union[str, Spec], compiler: bool = False):
+def parse_with_version_concrete(spec_like: Union[str, Spec]):
     """Same as Spec(string), but interprets @x as @=x"""
-    s: Union[CompilerSpec, Spec] = CompilerSpec(spec_like) if compiler else Spec(spec_like)
+    s = Spec(spec_like)
     interpreted_version = s.versions.concrete_range_as_version
     if interpreted_version:
         s.versions = vn.VersionList([interpreted_version])
@@ -4808,11 +4817,6 @@ def from_node_dict(cls, node):
         if "arch" in node:
             spec.architecture = ArchSpec.from_dict(node)
 
-        if "compiler" in node:
-            spec.compiler = CompilerSpec.from_dict(node)
-        else:
-            spec.compiler = None
-
         propagated_names = node.get("propagate", [])
         for name, values in node.get("parameters", {}).items():
             propagate = name in propagated_names
@@ -4853,12 +4857,28 @@ def from_node_dict(cls, node):
                 # FIXME: Monkey patches mvar to store patches order
                 mvar._patches_in_order_of_appearance = patches
 
+        # Annotate the compiler spec, might be used later
+        if "annotations" not in node:
+            # Specfile v4 and earlier
+            spec.annotations.with_spec_format(cls.SPEC_VERSION)
+            if "compiler" in node:
+                spec.annotations.with_compiler(cls.legacy_compiler(node))
+        else:
+            spec.annotations.with_spec_format(node["annotations"]["original_specfile_version"])
+            if "compiler" in node["annotations"]:
+                spec.annotations.with_compiler(Spec(f"{node['annotations']['compiler']}"))
+
         # Don't read dependencies here; from_dict() is used by
         # from_yaml() and from_json() to read the root *and* each dependency
         # spec.
 
         return spec
 
+    @classmethod
+    def legacy_compiler(cls, node):
+        d = node["compiler"]
+        return Spec(f"{d['name']}@{vn.VersionList.from_dict(d)}")
+
     @classmethod
     def _load(cls, data):
         """Construct a spec from JSON/YAML using the format version 2.
@@ -4925,6 +4945,8 @@ def read_specfile_dep_specs(cls, deps, hash_type=ht.dag_hash.name):
 
 
 class SpecfileV1(SpecfileReaderBase):
+    SPEC_VERSION = 1
+
     @classmethod
     def load(cls, data):
         """Construct a spec from JSON/YAML using the format version 1.
@@ -4994,6 +5016,8 @@ def read_specfile_dep_specs(cls, deps, hash_type=ht.dag_hash.name):
 
 
 class SpecfileV2(SpecfileReaderBase):
+    SPEC_VERSION = 2
+
     @classmethod
     def load(cls, data):
         result = cls._load(data)
@@ -5048,10 +5072,12 @@ def extract_build_spec_info_from_node_dict(cls, node, hash_type=ht.dag_hash.name
 
 
 class SpecfileV3(SpecfileV2):
-    pass
+    SPEC_VERSION = 3
 
 
 class SpecfileV4(SpecfileV2):
+    SPEC_VERSION = 4
+
     @classmethod
     def extract_info_from_dep(cls, elt, hash):
         dep_hash = elt[hash.name]
@@ -5065,6 +5091,14 @@ def load(cls, data):
         return cls._load(data)
 
 
+class SpecfileV5(SpecfileV4):
+    SPEC_VERSION = 5
+
+    @classmethod
+    def legacy_compiler(cls, node):
+        raise RuntimeError("The 'compiler' option is unexpected in specfiles at v5 or greater")
+
+
 class LazySpecCache(collections.defaultdict):
     """Cache for Specs that uses a spec_like as key, and computes lazily
     the corresponding value ``Spec(spec_like``.
@@ -5182,9 +5216,6 @@ class DuplicateCompilerSpecError(spack.error.SpecError):
 class UnsupportedCompilerError(spack.error.SpecError):
     """Raised when the user asks for a compiler spack doesn't know about."""
 
-    def __init__(self, compiler_name):
-        super().__init__("The '%s' compiler is not yet supported." % compiler_name)
-
 
 class DuplicateArchitectureError(spack.error.SpecError):
     """Raised when the same architecture occurs in a spec twice."""

lib/spack/spack/test/abi_splicing.py

@@ -14,6 +14,8 @@
 from spack.installer import PackageInstaller
 from spack.spec import Spec
 
+pytestmark = [pytest.mark.skip(reason="FIXME (compiler as nodes): fix splicing tests")]
+
 
 class CacheManager:
     def __init__(self, specs: List[str]) -> None:

lib/spack/spack/test/bindist.py

@@ -27,7 +27,7 @@
 
 import spack.binary_distribution as bindist
 import spack.caches
-import spack.compilers
+import spack.compilers.config
 import spack.config
 import spack.fetch_strategy
 import spack.hooks.sbang as sbang
@@ -84,7 +84,7 @@ def config_directory(tmp_path_factory):
         for name in [f"site/{platform.system().lower()}", "site", "user"]
     ]
     with spack.config.use_configuration(*cfg_scopes):
-        _ = spack.compilers.find_compilers(scope="site")
+        _ = spack.compilers.config.find_compilers(scope="site")
 
     yield defaults_dir
 
@@ -392,7 +392,7 @@ def test_spec_needs_rebuild(monkeypatch, tmpdir):
     s = Spec("libdwarf").concretized()
 
     # Install a package
-    install_cmd(s.name)
+    install_cmd("--fake", s.name)
 
     # Put installed package in the buildcache
     buildcache_cmd("push", "-u", mirror_dir.strpath, s.name)
@@ -421,7 +421,7 @@ def test_generate_index_missing(monkeypatch, tmpdir, mutable_config):
     s = Spec("libdwarf").concretized()
 
     # Install a package
-    install_cmd("--no-cache", s.name)
+    install_cmd("--fake", "--no-cache", s.name)
 
     # Create a buildcache and update index
     buildcache_cmd("push", "-u", mirror_dir.strpath, s.name)
@@ -573,11 +573,8 @@ def test_install_legacy_buildcache_layout(mutable_config, compiler_factory, inst
     where the .spack file contained a repeated spec.json and another
     compressed archive file containing the install tree.  This test
     makes sure we can still read that layout."""
-    mutable_config.set(
-        "compilers", [compiler_factory(spec="gcc@4.5.0", operating_system="debian6")]
-    )
     legacy_layout_dir = os.path.join(test_path, "data", "mirrors", "legacy_layout")
-    mirror_url = "file://{0}".format(legacy_layout_dir)
+    mirror_url = f"file://{legacy_layout_dir}"
     filename = (
         "test-debian6-core2-gcc-4.5.0-archive-files-2.0-"
         "l3vdiqvbobmspwyb4q2b62fz6nitd4hk.spec.json"
@@ -586,9 +583,7 @@ def test_install_legacy_buildcache_layout(mutable_config, compiler_factory, inst
     mirror_cmd("add", "--scope", "site", "test-legacy-layout", mirror_url)
     output = install_cmd("--no-check-signature", "--cache-only", "-f", spec_json_path, output=str)
     mirror_cmd("rm", "--scope=site", "test-legacy-layout")
-    expect_line = (
-        "Extracting archive-files-2.0-" "l3vdiqvbobmspwyb4q2b62fz6nitd4hk from binary cache"
-    )
+    expect_line = "Extracting archive-files-2.0-l3vdiqvbobmspwyb4q2b62fz6nitd4hk from binary cache"
     assert expect_line in output
 
 
@@ -1190,10 +1185,11 @@ def test_get_valid_spec_file_no_json(tmp_path, filename):
         bindist._get_valid_spec_file(str(tmp_path / filename), max_supported_layout=1)
 
 
-def test_download_tarball_with_unsupported_layout_fails(tmp_path, mutable_config, capsys):
+def test_download_tarball_with_unsupported_layout_fails(
+    tmp_path, mock_packages, mutable_config, capsys
+):
     layout_version = bindist.CURRENT_BUILD_CACHE_LAYOUT_VERSION + 1
-    spec = Spec("gmake@4.4.1%gcc@13.1.0 arch=linux-ubuntu23.04-zen2")
-    spec._mark_concrete()
+    spec = Spec("pkg-c").concretized()
     spec_dict = spec.to_dict()
     spec_dict["buildcache_layout_version"] = layout_version
 

lib/spack/spack/test/bootstrap.py

@@ -8,12 +8,14 @@
 import spack.bootstrap
 import spack.bootstrap.config
 import spack.bootstrap.core
-import spack.compilers
+import spack.compilers.config
 import spack.config
 import spack.environment
 import spack.store
 import spack.util.path
 
+from .conftest import _true
+
 
 @pytest.fixture
 def active_mock_environment(mutable_config, mutable_mock_env_path):
@@ -94,12 +96,14 @@ def test_raising_exception_if_bootstrap_disabled(mutable_config):
         spack.bootstrap.config.store_path()
 
 
-def test_raising_exception_module_importable():
+def test_raising_exception_module_importable(config, monkeypatch):
+    monkeypatch.setattr(spack.bootstrap.core, "source_is_enabled", _true)
     with pytest.raises(ImportError, match='cannot bootstrap the "asdf" Python module'):
         spack.bootstrap.core.ensure_module_importable_or_raise("asdf")
 
 
-def test_raising_exception_executables_in_path():
+def test_raising_exception_executables_in_path(config, monkeypatch):
+    monkeypatch.setattr(spack.bootstrap.core, "source_is_enabled", _true)
     with pytest.raises(RuntimeError, match="cannot bootstrap any of the asdf, fdsa executables"):
         spack.bootstrap.core.ensure_executables_in_path_or_raise(["asdf", "fdsa"], "python")
 
@@ -128,22 +132,22 @@ def test_bootstrap_disables_modulefile_generation(mutable_config):
 
 @pytest.mark.regression("25992")
 @pytest.mark.requires_executables("gcc")
-def test_bootstrap_search_for_compilers_with_no_environment(no_compilers_yaml):
-    assert not spack.compilers.all_compiler_specs(init_config=False)
+def test_bootstrap_search_for_compilers_with_no_environment(no_packages_yaml):
+    assert not spack.compilers.config.all_compilers(init_config=False)
     with spack.bootstrap.ensure_bootstrap_configuration():
-        assert spack.compilers.all_compiler_specs(init_config=False)
-    assert not spack.compilers.all_compiler_specs(init_config=False)
+        assert spack.compilers.config.all_compilers(init_config=False)
+    assert not spack.compilers.config.all_compilers(init_config=False)
 
 
 @pytest.mark.regression("25992")
 @pytest.mark.requires_executables("gcc")
 def test_bootstrap_search_for_compilers_with_environment_active(
-    no_compilers_yaml, active_mock_environment
+    no_packages_yaml, active_mock_environment
 ):
-    assert not spack.compilers.all_compiler_specs(init_config=False)
+    assert not spack.compilers.config.all_compilers(init_config=False)
     with spack.bootstrap.ensure_bootstrap_configuration():
-        assert spack.compilers.all_compiler_specs(init_config=False)
-    assert not spack.compilers.all_compiler_specs(init_config=False)
+        assert spack.compilers.config.all_compilers(init_config=False)
+    assert not spack.compilers.config.all_compilers(init_config=False)
 
 
 @pytest.mark.regression("26189")
@@ -219,16 +223,12 @@ def test_source_is_disabled(mutable_config):
     # Get the configuration dictionary of the current bootstrapping source
     conf = next(iter(spack.bootstrap.core.bootstrapping_sources()))
 
-    # The source is not explicitly enabled or disabled, so the following
-    # call should raise to skip using it for bootstrapping
-    with pytest.raises(ValueError):
-        spack.bootstrap.core.source_is_enabled_or_raise(conf)
+    # The source is not explicitly enabled or disabled, so the following should return False
+    assert not spack.bootstrap.core.source_is_enabled(conf)
 
-    # Try to explicitly disable the source and verify that the behavior
-    # is the same as above
+    # Try to explicitly disable the source and verify that the behavior is the same as above
     spack.config.add("bootstrap:trusted:{0}:{1}".format(conf["name"], False))
-    with pytest.raises(ValueError):
-        spack.bootstrap.core.source_is_enabled_or_raise(conf)
+    assert not spack.bootstrap.core.source_is_enabled(conf)
 
 
 @pytest.mark.regression("45247")

lib/spack/spack/test/build_environment.py

@@ -5,7 +5,6 @@
 import os
 import platform
 import posixpath
-import sys
 
 import pytest
 
@@ -15,13 +14,13 @@
 from llnl.util.filesystem import HeaderList, LibraryList
 
 import spack.build_environment
-import spack.compiler
-import spack.compilers
+import spack.build_systems.compiler
 import spack.config
 import spack.deptypes as dt
 import spack.package_base
 import spack.paths
 import spack.spec
+import spack.util.environment
 import spack.util.spack_yaml as syaml
 from spack.build_environment import UseMode, _static_to_shared_library, dso_suffix
 from spack.context import Context
@@ -59,7 +58,6 @@ def build_environment(working_env):
     os.environ["SPACK_ENV_PATH"] = "test"
     os.environ["SPACK_DEBUG_LOG_DIR"] = "."
     os.environ["SPACK_DEBUG_LOG_ID"] = "foo-hashabc"
-    os.environ["SPACK_COMPILER_SPEC"] = "gcc@4.4.7"
     os.environ["SPACK_SHORT_SPEC"] = "foo@1.2 arch=linux-rhel6-x86_64 /hashabc"
 
     os.environ["SPACK_CC_RPATH_ARG"] = "-Wl,-rpath,"
@@ -85,7 +83,6 @@ def build_environment(working_env):
         "SPACK_PREFIX",
         "SPACK_ENV_PATH",
         "SPACK_DEBUG_LOG_DIR",
-        "SPACK_COMPILER_SPEC",
         "SPACK_SHORT_SPEC",
         "SPACK_CC_RPATH_ARG",
         "SPACK_CXX_RPATH_ARG",
@@ -97,7 +94,7 @@ def build_environment(working_env):
 
 
 @pytest.fixture
-def ensure_env_variables(config, mock_packages, monkeypatch, working_env):
+def ensure_env_variables(mutable_config, mock_packages, monkeypatch, working_env):
     """Returns a function that takes a dictionary and updates os.environ
     for the test lifetime accordingly. Plugs-in mock config and repo.
     """
@@ -162,20 +159,24 @@ def test_static_to_shared_library(build_environment):
 
 
 @pytest.mark.regression("8345")
-@pytest.mark.usefixtures("config", "mock_packages")
-def test_cc_not_changed_by_modules(monkeypatch, working_env):
-    s = spack.spec.Spec("cmake")
-    s.concretize()
-    pkg = s.package
+@pytest.mark.usefixtures("mock_packages")
+@pytest.mark.not_on_windows("Module files are not supported on Windows")
+def test_cc_not_changed_by_modules(monkeypatch, mutable_config, working_env, compiler_factory):
+    """Tests that external module files that are loaded cannot change the
+    CC environment variable.
+    """
+    gcc_entry = compiler_factory(spec="gcc@14.0.1 languages=c,c++")
+    gcc_entry["modules"] = ["some_module"]
+    mutable_config.set("packages", {"gcc": {"externals": [gcc_entry]}})
 
     def _set_wrong_cc(x):
         os.environ["CC"] = "NOT_THIS_PLEASE"
         os.environ["ANOTHER_VAR"] = "THIS_IS_SET"
 
     monkeypatch.setattr(spack.build_environment, "load_module", _set_wrong_cc)
-    monkeypatch.setattr(pkg.compiler, "modules", ["some_module"])
 
-    spack.build_environment.setup_package(pkg, False)
+    s = spack.spec.Spec("cmake %gcc@14").concretized()
+    spack.build_environment.setup_package(s.package, dirty=False)
 
     assert os.environ["CC"] != "NOT_THIS_PLEASE"
     assert os.environ["ANOTHER_VAR"] == "THIS_IS_SET"
@@ -186,7 +187,7 @@ def test_setup_dependent_package_inherited_modules(
 ):
     # This will raise on regression
     s = spack.spec.Spec("cmake-client-inheritor").concretized()
-    PackageInstaller([s.package]).install()
+    PackageInstaller([s.package], fake=True).install()
 
 
 @pytest.mark.parametrize(
@@ -266,22 +267,30 @@ def test_setup_dependent_package_inherited_modules(
     ],
 )
 def test_compiler_config_modifications(
-    initial, modifications, expected, ensure_env_variables, monkeypatch
+    initial,
+    modifications,
+    expected,
+    ensure_env_variables,
+    compiler_factory,
+    mutable_config,
+    monkeypatch,
 ):
     # Set the environment as per prerequisites
     ensure_env_variables(initial)
 
+    gcc_entry = compiler_factory(spec="gcc@14.0.1 languages=c,c++")
+    gcc_entry["extra_attributes"]["environment"] = modifications
+    mutable_config.set("packages", {"gcc": {"externals": [gcc_entry]}})
+
     def platform_pathsep(pathlist):
         if Path.platform_path == Path.windows:
             pathlist = pathlist.replace(":", ";")
 
         return convert_to_platform_path(pathlist)
 
-    # Monkeypatch a pkg.compiler.environment with the required modifications
-    pkg = spack.spec.Spec("cmake").concretized().package
-    monkeypatch.setattr(pkg.compiler, "environment", modifications)
+    pkg = spack.spec.Spec("cmake %gcc@14").concretized().package
     # Trigger the modifications
-    spack.build_environment.setup_package(pkg, False)
+    spack.build_environment.setup_package(pkg, dirty=False)
 
     # Check they were applied
     for name, value in expected.items():
@@ -292,25 +301,6 @@ def platform_pathsep(pathlist):
         assert name not in os.environ
 
 
-def test_compiler_custom_env(config, mock_packages, monkeypatch, working_env):
-    if sys.platform == "win32":
-        test_path = r"C:\test\path\element\custom-env" + "\\"
-    else:
-        test_path = r"/test/path/element/custom-env/"
-
-    def custom_env(pkg, env):
-        env.prepend_path("PATH", test_path)
-        env.append_flags("ENV_CUSTOM_CC_FLAGS", "--custom-env-flag1")
-
-    pkg = spack.spec.Spec("cmake").concretized().package
-    monkeypatch.setattr(pkg.compiler, "setup_custom_environment", custom_env)
-    spack.build_environment.setup_package(pkg, False)
-
-    # Note: trailing slash may be stripped by internal logic
-    assert test_path[:-1] in os.environ["PATH"]
-    assert "--custom-env-flag1" in os.environ["ENV_CUSTOM_CC_FLAGS"]
-
-
 def test_external_config_env(mock_packages, mutable_config, working_env):
     cmake_config = {
         "externals": [
@@ -330,25 +320,27 @@ def test_external_config_env(mock_packages, mutable_config, working_env):
 
 
 @pytest.mark.regression("9107")
-def test_spack_paths_before_module_paths(config, mock_packages, monkeypatch, working_env):
-    s = spack.spec.Spec("cmake")
-    s.concretize()
-    pkg = s.package
+@pytest.mark.not_on_windows("Windows does not support module files")
+def test_spack_paths_before_module_paths(
+    mutable_config, mock_packages, compiler_factory, monkeypatch, working_env
+):
+    gcc_entry = compiler_factory(spec="gcc@14.0.1 languages=c,c++")
+    gcc_entry["modules"] = ["some_module"]
+    mutable_config.set("packages", {"gcc": {"externals": [gcc_entry]}})
 
     module_path = os.path.join("path", "to", "module")
+    spack_path = os.path.join(spack.paths.prefix, os.path.join("lib", "spack", "env"))
 
     def _set_wrong_cc(x):
         os.environ["PATH"] = module_path + os.pathsep + os.environ["PATH"]
 
     monkeypatch.setattr(spack.build_environment, "load_module", _set_wrong_cc)
-    monkeypatch.setattr(pkg.compiler, "modules", ["some_module"])
 
-    spack.build_environment.setup_package(pkg, False)
+    s = spack.spec.Spec("cmake").concretized()
 
-    spack_path = os.path.join(spack.paths.prefix, os.path.join("lib", "spack", "env"))
+    spack.build_environment.setup_package(s.package, dirty=False)
 
     paths = os.environ["PATH"].split(os.pathsep)
-
     assert paths.index(spack_path) < paths.index(module_path)
 
 
@@ -499,15 +491,13 @@ def test_parallel_false_is_not_propagating(default_mock_concretization):
         ("rpath", "" if platform.system() == "Darwin" else "--disable-new-dtags"),
     ],
 )
-def test_setting_dtags_based_on_config(config_setting, expected_flag, config, mock_packages):
+def test_setting_dtags_based_on_config(
+    config_setting, expected_flag, config, mock_packages, working_env
+):
     # Pick a random package to be able to set compiler's variables
-    s = spack.spec.Spec("cmake")
-    s.concretize()
-    pkg = s.package
-
-    env = EnvironmentModifications()
+    s = spack.spec.Spec("cmake").concretized()
     with spack.config.override("config:shared_linking", {"type": config_setting, "bind": False}):
-        spack.build_environment.set_compiler_environment_variables(pkg, env)
+        env = spack.build_environment.setup_package(s.package, dirty=False)
         modifications = env.group_by_name()
         assert "SPACK_DTAGS_TO_STRIP" in modifications
         assert "SPACK_DTAGS_TO_ADD" in modifications
@@ -770,59 +760,44 @@ def test_rpath_with_duplicate_link_deps():
 @pytest.mark.parametrize(
     "compiler_spec,target_name,expected_flags",
     [
-        # Homogeneous compilers
+        # Semver versions
         ("gcc@4.7.2", "ivybridge", "-march=core-avx-i -mtune=core-avx-i"),
         ("clang@3.5", "x86_64", "-march=x86-64 -mtune=generic"),
         ("apple-clang@9.1.0", "x86_64", "-march=x86-64"),
-        # Mixed toolchain
-        ("clang@8.0.0", "broadwell", ""),
+        ("gcc@=9.2.0", "haswell", "-march=haswell -mtune=haswell"),
+        # Check that custom string versions are accepted
+        ("gcc@=9.2.0-foo", "icelake", "-march=icelake-client -mtune=icelake-client"),
+        # Check that the special case for Apple's clang is treated correctly
+        # i.e. it won't try to detect the version again
+        ("apple-clang@=9.1.0", "x86_64", "-march=x86-64"),
+        # FIXME (compiler as nodes): Check mixed toolchain
+        # ("clang@8.0.0", "broadwell", ""),
     ],
 )
 @pytest.mark.filterwarnings("ignore:microarchitecture specific")
 @pytest.mark.not_on_windows("Windows doesn't support the compiler wrapper")
 def test_optimization_flags(compiler_spec, target_name, expected_flags, compiler_factory):
     target = archspec.cpu.TARGETS[target_name]
-    compiler_dict = compiler_factory(spec=compiler_spec, operating_system="")["compiler"]
-    if compiler_spec == "clang@8.0.0":
-        compiler_dict["paths"] = {
-            "cc": "/path/to/clang-8",
-            "cxx": "/path/to/clang++-8",
-            "f77": "/path/to/gfortran-9",
-            "fc": "/path/to/gfortran-9",
-        }
-    compiler = spack.compilers.compiler_from_dict(compiler_dict)
+    compiler = spack.spec.parse_with_version_concrete(compiler_spec)
     opt_flags = spack.build_environment.optimization_flags(compiler, target)
     assert opt_flags == expected_flags
 
 
-@pytest.mark.parametrize(
-    "compiler_str,real_version,target_str,expected_flags",
-    [
-        ("gcc@=9.2.0", None, "haswell", "-march=haswell -mtune=haswell"),
-        # Check that custom string versions are accepted
-        ("gcc@=10foo", "9.2.0", "icelake", "-march=icelake-client -mtune=icelake-client"),
-        # Check that we run version detection (4.4.0 doesn't support icelake)
-        ("gcc@=4.4.0-special", "9.2.0", "icelake", "-march=icelake-client -mtune=icelake-client"),
-        # Check that the special case for Apple's clang is treated correctly
-        # i.e. it won't try to detect the version again
-        ("apple-clang@=9.1.0", None, "x86_64", "-march=x86-64"),
-    ],
+@pytest.mark.skipif(
+    str(archspec.cpu.host().family) != "x86_64", reason="tests check specific x86_64 uarch flags"
 )
-def test_optimization_flags_with_custom_versions(
-    compiler_str,
-    real_version,
-    target_str,
-    expected_flags,
-    monkeypatch,
-    mutable_config,
-    compiler_factory,
-):
-    target = archspec.cpu.TARGETS[target_str]
-    compiler_dict = compiler_factory(spec=compiler_str, operating_system="redhat6")
-    mutable_config.set("compilers", [compiler_dict])
-    if real_version:
-        monkeypatch.setattr(spack.compiler.Compiler, "get_real_version", lambda x: real_version)
-    compiler = spack.compilers.compiler_from_dict(compiler_dict["compiler"])
+@pytest.mark.not_on_windows("Windows doesn't support the compiler wrapper")
+def test_optimization_flags_are_using_node_target(default_mock_concretization, monkeypatch):
+    """Tests that we are using the target on the node to be compiled to retrieve the uarch
+    specific flags, and not the target of the compiler.
+    """
+    monkeypatch.setattr(spack.build_systems.compiler, "_implicit_rpaths", lambda pkg: [])
+    gcc = default_mock_concretization("gcc target=core2")
+    mpileaks = default_mock_concretization("mpileaks target=x86_64")
 
-    opt_flags = spack.build_environment.optimization_flags(compiler, target)
-    assert opt_flags == expected_flags
+    env = EnvironmentModifications()
+    gcc.package.setup_dependent_build_environment(env, mpileaks)
+    actions = env.group_by_name()["SPACK_TARGET_ARGS_CC"]
+
+    assert len(actions) == 1 and isinstance(actions[0], spack.util.environment.SetEnv)
+    assert actions[0].value == "-march=x86-64 -mtune=generic"

lib/spack/spack/test/cc.py

@@ -133,6 +133,7 @@
 headerpad = ["-headerpad_max_install_names"]
 
 target_args = ["-march=znver2", "-mtune=znver2"]
+target_args_fc = ["-march=znver4", "-mtune=znver4"]
 
 # common compile arguments: includes, libs, -Wl linker args, other args
 common_compile_args = (
@@ -156,7 +157,6 @@ def wrapper_environment(working_env):
         SPACK_ENV_PATH="test",
         SPACK_DEBUG_LOG_DIR=".",
         SPACK_DEBUG_LOG_ID="foo-hashabc",
-        SPACK_COMPILER_SPEC="gcc@4.4.7",
         SPACK_SHORT_SPEC="foo@1.2 arch=linux-rhel6-x86_64 /hashabc",
         SPACK_SYSTEM_DIRS=SYSTEM_DIR_CASE_ENTRY,
         SPACK_MANAGED_DIRS="/path/to/spack-1/opt/spack/*|/path/to/spack-2/opt/spack/*",
@@ -167,7 +167,9 @@ def wrapper_environment(working_env):
         SPACK_LINK_DIRS=None,
         SPACK_INCLUDE_DIRS=None,
         SPACK_RPATH_DIRS=None,
-        SPACK_TARGET_ARGS="-march=znver2 -mtune=znver2",
+        SPACK_TARGET_ARGS_CC="-march=znver2 -mtune=znver2",
+        SPACK_TARGET_ARGS_CXX="-march=znver2 -mtune=znver2",
+        SPACK_TARGET_ARGS_FORTRAN="-march=znver4 -mtune=znver4",
         SPACK_LINKER_ARG="-Wl,",
         SPACK_DTAGS_TO_ADD="--disable-new-dtags",
         SPACK_DTAGS_TO_STRIP="--enable-new-dtags",
@@ -377,7 +379,7 @@ def test_fc_flags(wrapper_environment, wrapper_flags):
         fc,
         test_args,
         [real_cc]
-        + target_args
+        + target_args_fc
         + test_include_paths
         + ["-Lfoo"]
         + test_library_paths
@@ -424,7 +426,7 @@ def test_Wl_parsing_NAG_is_ignored(wrapper_environment):
     check_args(
         fc,
         ["-Wl,-Wl,,x,,y,,z"],
-        [real_cc] + target_args + ["-Wl,--disable-new-dtags", "-Wl,-Wl,,x,,y,,z"],
+        [real_cc] + target_args_fc + ["-Wl,--disable-new-dtags", "-Wl,-Wl,,x,,y,,z"],
     )
 
 
@@ -833,14 +835,14 @@ def test_no_ccache_prepend_for_fc(wrapper_environment):
         fc,
         test_args,
         # no ccache for Fortran
-        [real_cc] + target_args + common_compile_args,
+        [real_cc] + target_args_fc + common_compile_args,
     )
     os.environ["SPACK_SHORT_SPEC"] = "foo@1.2=darwin-x86_64"
     check_args(
         fc,
         test_args,
         # no ccache for Fortran
-        [real_cc] + target_args + lheaderpad + common_compile_args,
+        [real_cc] + target_args_fc + lheaderpad + common_compile_args,
     )
 
 

lib/spack/spack/test/ci.py

@@ -198,6 +198,7 @@ def __call__(self, *args, **kwargs):
     assert "Unable to merge {0}".format(c1) in err
 
 
+@pytest.mark.xfail(reason="FIXME (compiler as nodes): revisit this test")
 def test_get_spec_filter_list(mutable_mock_env_path, mutable_mock_repo):
     """Test that given an active environment and list of touched pkgs,
     we get the right list of possibly-changed env specs"""

lib/spack/spack/test/cmd/build_env.py

@@ -13,7 +13,7 @@
 build_env = SpackCommand("build-env")
 
 
-@pytest.mark.parametrize("pkg", [("zlib",), ("zlib", "--")])
+@pytest.mark.parametrize("pkg", [("pkg-c",), ("pkg-c", "--")])
 @pytest.mark.usefixtures("config", "mock_packages", "working_env")
 def test_it_just_runs(pkg):
     build_env(*pkg)
@@ -39,7 +39,7 @@ def test_build_env_requires_a_spec(args):
 @pytest.mark.usefixtures("config", "mock_packages", "working_env")
 def test_dump(shell_as, shell, tmpdir):
     with tmpdir.as_cwd():
-        build_env("--dump", _out_file, "zlib")
+        build_env("--dump", _out_file, "pkg-c")
         with open(_out_file) as f:
             if shell == "pwsh":
                 assert any(line.startswith("$Env:PATH") for line in f.readlines())
@@ -52,7 +52,7 @@ def test_dump(shell_as, shell, tmpdir):
 @pytest.mark.usefixtures("config", "mock_packages", "working_env")
 def test_pickle(tmpdir):
     with tmpdir.as_cwd():
-        build_env("--pickle", _out_file, "zlib")
+        build_env("--pickle", _out_file, "pkg-c")
         environment = pickle.load(open(_out_file, "rb"))
         assert isinstance(environment, dict)
         assert "PATH" in environment

lib/spack/spack/test/cmd/buildcache.py

@@ -149,7 +149,7 @@ def test_update_key_index(
     s = Spec("libdwarf").concretized()
 
     # Install a package
-    install(s.name)
+    install("--fake", s.name)
 
     # Put installed package in the buildcache, which, because we're signing
     # it, should result in the public key getting pushed to the buildcache
@@ -179,7 +179,7 @@ def test_buildcache_autopush(tmp_path, install_mockery, mock_fetch):
     s = Spec("libdwarf").concretized()
 
     # Install and generate build cache index
-    PackageInstaller([s.package], explicit=True).install()
+    PackageInstaller([s.package], fake=True, explicit=True).install()
 
     metadata_file = spack.binary_distribution.tarball_name(s, ".spec.json")
 
@@ -221,7 +221,7 @@ def verify_mirror_contents():
 
     # Install a package and put it in the buildcache
     s = Spec(out_env_pkg).concretized()
-    install(s.name)
+    install("--fake", s.name)
     buildcache("push", "-u", "-f", src_mirror_url, s.name)
 
     env("create", "test")

lib/spack/spack/test/cmd/ci.py

@@ -232,9 +232,9 @@ def test_ci_generate_with_env(ci_generate_test, tmp_path, mock_binary_index):
     assert yaml_contents["workflow"]["rules"] == [{"when": "always"}]
 
     assert "stages" in yaml_contents
-    assert len(yaml_contents["stages"]) == 5
+    assert len(yaml_contents["stages"]) == 6
     assert yaml_contents["stages"][0] == "stage-0"
-    assert yaml_contents["stages"][4] == "stage-rebuild-index"
+    assert yaml_contents["stages"][5] == "stage-rebuild-index"
 
     assert "rebuild-index" in yaml_contents
     rebuild_job = yaml_contents["rebuild-index"]
@@ -1112,7 +1112,7 @@ def test_ci_rebuild_index(
             with open(tmp_path / "spec.json", "w") as f:
                 f.write(concrete_spec.to_json(hash=ht.dag_hash))
 
-            install_cmd("--add", "-f", str(tmp_path / "spec.json"))
+            install_cmd("--fake", "--add", "-f", str(tmp_path / "spec.json"))
             buildcache_cmd("push", "-u", "-f", mirror_url, "callpath")
             ci_cmd("rebuild-index")
 

lib/spack/spack/test/cmd/compiler.py

@@ -4,15 +4,13 @@
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 import os
 import shutil
-import sys
 
 import pytest
 
 import spack.cmd.compiler
-import spack.compilers
+import spack.compilers.config
 import spack.config
 import spack.main
-import spack.spec
 import spack.util.pattern
 import spack.version
 
@@ -70,7 +68,7 @@ def compilers_dir(mock_executable):
 
 @pytest.mark.not_on_windows("Cannot execute bash script on Windows")
 @pytest.mark.regression("11678,13138")
-def test_compiler_find_without_paths(no_compilers_yaml, working_env, mock_executable):
+def test_compiler_find_without_paths(no_packages_yaml, working_env, mock_executable):
     """Tests that 'spack compiler find' looks into PATH by default, if no specific path
     is given.
     """
@@ -85,22 +83,30 @@ def test_compiler_find_without_paths(no_compilers_yaml, working_env, mock_execut
 @pytest.mark.regression("37996")
 def test_compiler_remove(mutable_config, mock_packages):
     """Tests that we can remove a compiler from configuration."""
-    assert spack.spec.CompilerSpec("gcc@=9.4.0") in spack.compilers.all_compiler_specs()
+    assert any(
+        compiler.satisfies("gcc@=9.4.0") for compiler in spack.compilers.config.all_compilers()
+    )
     args = spack.util.pattern.Bunch(all=True, compiler_spec="gcc@9.4.0", add_paths=[], scope=None)
     spack.cmd.compiler.compiler_remove(args)
-    assert spack.spec.CompilerSpec("gcc@=9.4.0") not in spack.compilers.all_compiler_specs()
+    assert not any(
+        compiler.satisfies("gcc@=9.4.0") for compiler in spack.compilers.config.all_compilers()
+    )
 
 
 @pytest.mark.regression("37996")
 def test_removing_compilers_from_multiple_scopes(mutable_config, mock_packages):
     # Duplicate "site" scope into "user" scope
-    site_config = spack.config.get("compilers", scope="site")
-    spack.config.set("compilers", site_config, scope="user")
+    site_config = spack.config.get("packages", scope="site")
+    spack.config.set("packages", site_config, scope="user")
 
-    assert spack.spec.CompilerSpec("gcc@=9.4.0") in spack.compilers.all_compiler_specs()
+    assert any(
+        compiler.satisfies("gcc@=9.4.0") for compiler in spack.compilers.config.all_compilers()
+    )
     args = spack.util.pattern.Bunch(all=True, compiler_spec="gcc@9.4.0", add_paths=[], scope=None)
     spack.cmd.compiler.compiler_remove(args)
-    assert spack.spec.CompilerSpec("gcc@=9.4.0") not in spack.compilers.all_compiler_specs()
+    assert not any(
+        compiler.satisfies("gcc@=9.4.0") for compiler in spack.compilers.config.all_compilers()
+    )
 
 
 @pytest.mark.not_on_windows("Cannot execute bash script on Windows")
@@ -120,7 +126,7 @@ def test_compiler_add(mutable_config, mock_executable):
     bin_dir = gcc_path.parent
     root_dir = bin_dir.parent
 
-    compilers_before_find = set(spack.compilers.all_compiler_specs())
+    compilers_before_find = set(spack.compilers.config.all_compilers())
     args = spack.util.pattern.Bunch(
         all=None,
         compiler_spec=None,
@@ -130,7 +136,7 @@ def test_compiler_add(mutable_config, mock_executable):
         jobs=1,
     )
     spack.cmd.compiler.compiler_find(args)
-    compilers_after_find = set(spack.compilers.all_compiler_specs())
+    compilers_after_find = set(spack.compilers.config.all_compilers())
 
     compilers_added_by_find = compilers_after_find - compilers_before_find
     assert len(compilers_added_by_find) == 1
@@ -140,45 +146,7 @@ def test_compiler_add(mutable_config, mock_executable):
 
 @pytest.mark.not_on_windows("Cannot execute bash script on Windows")
 @pytest.mark.regression("17590")
-@pytest.mark.parametrize("mixed_toolchain", [True, False])
-def test_compiler_find_mixed_suffixes(
-    mixed_toolchain, no_compilers_yaml, working_env, compilers_dir
-):
-    """Ensure that we'll mix compilers with different suffixes when necessary."""
-    os.environ["PATH"] = str(compilers_dir)
-    output = compiler(
-        "find", "--scope=site", "--mixed-toolchain" if mixed_toolchain else "--no-mixed-toolchain"
-    )
-
-    assert "clang@11.0.0" in output
-    assert "gcc@8.4.0" in output
-
-    config = spack.compilers.get_compiler_config(
-        no_compilers_yaml, scope="site", init_config=False
-    )
-    clang = next(c["compiler"] for c in config if c["compiler"]["spec"] == "clang@=11.0.0")
-    gcc = next(c["compiler"] for c in config if c["compiler"]["spec"] == "gcc@=8.4.0")
-
-    gfortran_path = str(compilers_dir / "gfortran-8")
-
-    assert clang["paths"] == {
-        "cc": str(compilers_dir / "clang"),
-        "cxx": str(compilers_dir / "clang++"),
-        "f77": gfortran_path if mixed_toolchain else None,
-        "fc": gfortran_path if mixed_toolchain else None,
-    }
-
-    assert gcc["paths"] == {
-        "cc": str(compilers_dir / "gcc-8"),
-        "cxx": str(compilers_dir / "g++-8"),
-        "f77": gfortran_path,
-        "fc": gfortran_path,
-    }
-
-
-@pytest.mark.not_on_windows("Cannot execute bash script on Windows")
-@pytest.mark.regression("17590")
-def test_compiler_find_prefer_no_suffix(no_compilers_yaml, working_env, compilers_dir):
+def test_compiler_find_prefer_no_suffix(no_packages_yaml, working_env, compilers_dir):
     """Ensure that we'll pick 'clang' over 'clang-gpu' when there is a choice."""
     clang_path = compilers_dir / "clang"
     shutil.copy(clang_path, clang_path.parent / "clang-gpu")
@@ -187,20 +155,19 @@ def test_compiler_find_prefer_no_suffix(no_compilers_yaml, working_env, compiler
     os.environ["PATH"] = str(compilers_dir)
     output = compiler("find", "--scope=site")
 
-    assert "clang@11.0.0" in output
+    assert "llvm@11.0.0" in output
     assert "gcc@8.4.0" in output
 
-    config = spack.compilers.get_compiler_config(
-        no_compilers_yaml, scope="site", init_config=False
-    )
-    clang = next(c["compiler"] for c in config if c["compiler"]["spec"] == "clang@=11.0.0")
+    compilers = spack.compilers.config.all_compilers_from(no_packages_yaml, scope="site")
+    clang = [x for x in compilers if x.satisfies("llvm@11")]
 
-    assert clang["paths"]["cc"] == str(compilers_dir / "clang")
-    assert clang["paths"]["cxx"] == str(compilers_dir / "clang++")
+    assert len(clang) == 1
+    assert clang[0].extra_attributes["compilers"]["c"] == str(compilers_dir / "clang")
+    assert clang[0].extra_attributes["compilers"]["cxx"] == str(compilers_dir / "clang++")
 
 
 @pytest.mark.not_on_windows("Cannot execute bash script on Windows")
-def test_compiler_find_path_order(no_compilers_yaml, working_env, compilers_dir):
+def test_compiler_find_path_order(no_packages_yaml, working_env, compilers_dir):
     """Ensure that we look for compilers in the same order as PATH, when there are duplicates"""
     new_dir = compilers_dir / "first_in_path"
     new_dir.mkdir()
@@ -211,19 +178,19 @@ def test_compiler_find_path_order(no_compilers_yaml, working_env, compilers_dir)
 
     compiler("find", "--scope=site")
 
-    config = spack.compilers.get_compiler_config(
-        no_compilers_yaml, scope="site", init_config=False
-    )
-    gcc = next(c["compiler"] for c in config if c["compiler"]["spec"] == "gcc@=8.4.0")
-    assert gcc["paths"] == {
-        "cc": str(new_dir / "gcc-8"),
+    compilers = spack.compilers.config.all_compilers(scope="site")
+    gcc = [x for x in compilers if x.satisfies("gcc@8.4")]
+
+    # Ensure we found both duplicates
+    assert len(gcc) == 2
+    assert gcc[0].extra_attributes["compilers"] == {
+        "c": str(new_dir / "gcc-8"),
         "cxx": str(new_dir / "g++-8"),
-        "f77": str(new_dir / "gfortran-8"),
-        "fc": str(new_dir / "gfortran-8"),
+        "fortran": str(new_dir / "gfortran-8"),
     }
 
 
-def test_compiler_list_empty(no_compilers_yaml, working_env, compilers_dir):
+def test_compiler_list_empty(no_packages_yaml, working_env, compilers_dir):
     """Spack should not automatically search for compilers when listing them and none are
     available. And when stdout is not a tty like in tests, there should be no output and
     no error exit code.
@@ -251,10 +218,10 @@ def test_compiler_list_empty(no_compilers_yaml, working_env, compilers_dir):
                     "flags": {"fflags": "-ffree-form"},
                 },
             },
-            """gcc@7.7.7:
-\tpaths:
-\t\tcc = /path/to/fake/gcc
-\t\tcxx = /path/to/fake/g++
+            """gcc@7.7.7 languages=c,cxx,fortran os=foobar target=x86_64:
+  paths:
+    cc = /path/to/fake/gcc
+    cxx = /path/to/fake/g++
 \t\tf77 = /path/to/fake/gfortran
 \t\tfc = /path/to/fake/gfortran
 \tflags:
@@ -266,7 +233,7 @@ def test_compiler_list_empty(no_compilers_yaml, working_env, compilers_dir):
     ],
 )
 def test_compilers_shows_packages_yaml(
-    external, expected, no_compilers_yaml, working_env, compilers_dir
+    external, expected, no_packages_yaml, working_env, compilers_dir
 ):
     """Spack should see a single compiler defined from packages.yaml"""
     external["prefix"] = external["prefix"].format(prefix=os.path.dirname(compilers_dir))
@@ -276,12 +243,5 @@ def test_compilers_shows_packages_yaml(
     packages["gcc"] = gcc_entry
     spack.config.set("packages", packages)
 
-    out = compiler("list")
+    out = compiler("list", fail_on_error=True)
     assert out.count("gcc@7.7.7") == 1
-
-    out = compiler("info", "gcc@7.7.7")
-    assert out == expected.format(
-        compilers_dir=str(compilers_dir),
-        sep=os.sep,
-        suffix=".bat" if sys.platform == "win32" else "",
-    )

lib/spack/spack/test/cmd/config.py

@@ -336,7 +336,7 @@ def test_config_add_override_leaf_from_file(mutable_empty_config, tmpdir):
 
 
 def test_config_add_update_dict_from_file(mutable_empty_config, tmpdir):
-    config("add", "packages:all:compiler:[gcc]")
+    config("add", "packages:all:require:['%gcc']")
 
     # contents to add to file
     contents = """spack:
@@ -358,7 +358,7 @@ def test_config_add_update_dict_from_file(mutable_empty_config, tmpdir):
     expected = """packages:
   all:
     target: [x86_64]
-    compiler: [gcc]
+    require: ['%gcc']
 """
 
     assert expected == output
@@ -608,7 +608,6 @@ def test_config_prefer_upstream(
     packages = syaml.load(open(cfg_file))["packages"]
 
     # Make sure only the non-default variants are set.
-    assert packages["all"] == {"compiler": ["gcc@=10.2.1"]}
     assert packages["boost"] == {"variants": "+debug +graph", "version": ["1.63.0"]}
     assert packages["dependency-install"] == {"version": ["2.0"]}
     # Ensure that neither variant gets listed for hdf5, since they conflict

lib/spack/spack/test/cmd/dependencies.py

@@ -14,7 +14,7 @@
 
 dependencies = SpackCommand("dependencies")
 
-mpis = [
+MPIS = [
     "intel-parallel-studio",
     "low-priority-provider",
     "mpich",
@@ -22,20 +22,21 @@
     "multi-provider-mpi",
     "zmpi",
 ]
-mpi_deps = ["fake"]
+COMPILERS = ["gcc", "llvm"]
+MPI_DEPS = ["fake"]
 
 
 def test_direct_dependencies(mock_packages):
     out = dependencies("mpileaks")
     actual = set(re.split(r"\s+", out.strip()))
-    expected = set(["callpath"] + mpis)
+    expected = set(["callpath"] + MPIS + COMPILERS)
     assert expected == actual
 
 
 def test_transitive_dependencies(mock_packages):
     out = dependencies("--transitive", "mpileaks")
     actual = set(re.split(r"\s+", out.strip()))
-    expected = set(["callpath", "dyninst", "libdwarf", "libelf"] + mpis + mpi_deps)
+    expected = set(["callpath", "dyninst", "libdwarf", "libelf"] + MPIS + MPI_DEPS + COMPILERS)
     assert expected == actual
 
 
@@ -58,12 +59,11 @@ def test_direct_installed_dependencies(mock_packages, database):
     with color_when(False):
         out = dependencies("--installed", "mpileaks^mpich")
 
-    lines = [line for line in out.strip().split("\n") if not line.startswith("--")]
-    hashes = set([re.split(r"\s+", line)[0] for line in lines])
+    root = spack.store.STORE.db.query_one("mpileaks ^mpich")
 
-    expected = set(
-        [spack.store.STORE.db.query_one(s).dag_hash(7) for s in ["mpich", "callpath^mpich"]]
-    )
+    lines = [line for line in out.strip().split("\n") if line and not line.startswith("--")]
+    hashes = {re.split(r"\s+", line)[0] for line in lines}
+    expected = {s.dag_hash(7) for s in root.dependencies()}
 
     assert expected == hashes
 
@@ -73,14 +73,10 @@ def test_transitive_installed_dependencies(mock_packages, database):
     with color_when(False):
         out = dependencies("--installed", "--transitive", "mpileaks^zmpi")
 
-    lines = [line for line in out.strip().split("\n") if not line.startswith("--")]
-    hashes = set([re.split(r"\s+", line)[0] for line in lines])
+    root = spack.store.STORE.db.query_one("mpileaks ^zmpi")
 
-    expected = set(
-        [
-            spack.store.STORE.db.query_one(s).dag_hash(7)
-            for s in ["zmpi", "callpath^zmpi", "fake", "dyninst", "libdwarf", "libelf"]
-        ]
-    )
+    lines = [line for line in out.strip().split("\n") if line and not line.startswith("--")]
+    hashes = {re.split(r"\s+", line)[0] for line in lines}
+    expected = {s.dag_hash(7) for s in root.traverse(root=False)}
 
     assert expected == hashes

lib/spack/spack/test/cmd/deprecate.py

@@ -17,16 +17,16 @@
 
 
 def test_deprecate(mock_packages, mock_archive, mock_fetch, install_mockery):
-    install("libelf@0.8.13")
-    install("libelf@0.8.10")
+    install("--fake", "libelf@0.8.13")
+    install("--fake", "libelf@0.8.10")
 
-    all_installed = spack.store.STORE.db.query()
+    all_installed = spack.store.STORE.db.query("libelf")
     assert len(all_installed) == 2
 
     deprecate("-y", "libelf@0.8.10", "libelf@0.8.13")
 
-    non_deprecated = spack.store.STORE.db.query()
-    all_available = spack.store.STORE.db.query(installed=InstallRecordStatus.ANY)
+    non_deprecated = spack.store.STORE.db.query("libelf")
+    all_available = spack.store.STORE.db.query("libelf", installed=InstallRecordStatus.ANY)
     assert all_available == all_installed
     assert non_deprecated == spack.store.STORE.db.query("libelf@0.8.13")
 
@@ -39,24 +39,24 @@ def test_deprecate_fails_no_such_package(mock_packages, mock_archive, mock_fetch
     output = deprecate("-y", "libelf@0.8.10", "libelf@0.8.13", fail_on_error=False)
     assert "Spec 'libelf@0.8.10' matches no installed packages" in output
 
-    install("libelf@0.8.10")
+    install("--fake", "libelf@0.8.10")
 
     output = deprecate("-y", "libelf@0.8.10", "libelf@0.8.13", fail_on_error=False)
     assert "Spec 'libelf@0.8.13' matches no installed packages" in output
 
 
-def test_deprecate_install(mock_packages, mock_archive, mock_fetch, install_mockery):
-    """Tests that the ```-i`` option allows us to deprecate in favor of a spec
-    that is not yet installed."""
-    install("libelf@0.8.10")
-
-    to_deprecate = spack.store.STORE.db.query()
+def test_deprecate_install(mock_packages, mock_archive, mock_fetch, install_mockery, monkeypatch):
+    """Tests that the -i option allows us to deprecate in favor of a spec
+    that is not yet installed.
+    """
+    install("--fake", "libelf@0.8.10")
+    to_deprecate = spack.store.STORE.db.query("libelf")
     assert len(to_deprecate) == 1
 
     deprecate("-y", "-i", "libelf@0.8.10", "libelf@0.8.13")
 
-    non_deprecated = spack.store.STORE.db.query()
-    deprecated = spack.store.STORE.db.query(installed=InstallRecordStatus.DEPRECATED)
+    non_deprecated = spack.store.STORE.db.query("libelf")
+    deprecated = spack.store.STORE.db.query("libelf", installed=InstallRecordStatus.DEPRECATED)
     assert deprecated == to_deprecate
     assert len(non_deprecated) == 1
     assert non_deprecated[0].satisfies("libelf@0.8.13")
@@ -64,8 +64,8 @@ def test_deprecate_install(mock_packages, mock_archive, mock_fetch, install_mock
 
 def test_deprecate_deps(mock_packages, mock_archive, mock_fetch, install_mockery):
     """Test that the deprecate command deprecates all dependencies properly."""
-    install("libdwarf@20130729 ^libelf@0.8.13")
-    install("libdwarf@20130207 ^libelf@0.8.10")
+    install("--fake", "libdwarf@20130729 ^libelf@0.8.13")
+    install("--fake", "libdwarf@20130207 ^libelf@0.8.10")
 
     new_spec = spack.spec.Spec("libdwarf@20130729^libelf@0.8.13").concretized()
     old_spec = spack.spec.Spec("libdwarf@20130207^libelf@0.8.10").concretized()
@@ -81,14 +81,14 @@ def test_deprecate_deps(mock_packages, mock_archive, mock_fetch, install_mockery
     assert all_available == all_installed
     assert sorted(all_available) == sorted(deprecated + non_deprecated)
 
-    assert sorted(non_deprecated) == sorted(list(new_spec.traverse()))
-    assert sorted(deprecated) == sorted(list(old_spec.traverse()))
+    assert sorted(non_deprecated) == sorted(new_spec.traverse())
+    assert sorted(deprecated) == sorted([old_spec, old_spec["libelf"]])
 
 
 def test_uninstall_deprecated(mock_packages, mock_archive, mock_fetch, install_mockery):
     """Tests that we can still uninstall deprecated packages."""
-    install("libelf@0.8.13")
-    install("libelf@0.8.10")
+    install("--fake", "libelf@0.8.13")
+    install("--fake", "libelf@0.8.10")
 
     deprecate("-y", "libelf@0.8.10", "libelf@0.8.13")
 
@@ -104,9 +104,9 @@ def test_uninstall_deprecated(mock_packages, mock_archive, mock_fetch, install_m
 
 def test_deprecate_already_deprecated(mock_packages, mock_archive, mock_fetch, install_mockery):
     """Tests that we can re-deprecate a spec to change its deprecator."""
-    install("libelf@0.8.13")
-    install("libelf@0.8.12")
-    install("libelf@0.8.10")
+    install("--fake", "libelf@0.8.13")
+    install("--fake", "libelf@0.8.12")
+    install("--fake", "libelf@0.8.10")
 
     deprecated_spec = spack.spec.Spec("libelf@0.8.10").concretized()
 
@@ -117,8 +117,8 @@ def test_deprecate_already_deprecated(mock_packages, mock_archive, mock_fetch, i
 
     deprecate("-y", "libelf@0.8.10", "libelf@0.8.13")
 
-    non_deprecated = spack.store.STORE.db.query()
-    all_available = spack.store.STORE.db.query(installed=InstallRecordStatus.ANY)
+    non_deprecated = spack.store.STORE.db.query("libelf")
+    all_available = spack.store.STORE.db.query("libelf", installed=InstallRecordStatus.ANY)
     assert len(non_deprecated) == 2
     assert len(all_available) == 3
 
@@ -129,9 +129,9 @@ def test_deprecate_already_deprecated(mock_packages, mock_archive, mock_fetch, i
 def test_deprecate_deprecator(mock_packages, mock_archive, mock_fetch, install_mockery):
     """Tests that when a deprecator spec is deprecated, its deprecatee specs
     are updated to point to the new deprecator."""
-    install("libelf@0.8.13")
-    install("libelf@0.8.12")
-    install("libelf@0.8.10")
+    install("--fake", "libelf@0.8.13")
+    install("--fake", "libelf@0.8.12")
+    install("--fake", "libelf@0.8.10")
 
     first_deprecated_spec = spack.spec.Spec("libelf@0.8.10").concretized()
     second_deprecated_spec = spack.spec.Spec("libelf@0.8.12").concretized()
@@ -144,8 +144,8 @@ def test_deprecate_deprecator(mock_packages, mock_archive, mock_fetch, install_m
 
     deprecate("-y", "libelf@0.8.12", "libelf@0.8.13")
 
-    non_deprecated = spack.store.STORE.db.query()
-    all_available = spack.store.STORE.db.query(installed=InstallRecordStatus.ANY)
+    non_deprecated = spack.store.STORE.db.query("libelf")
+    all_available = spack.store.STORE.db.query("libelf", installed=InstallRecordStatus.ANY)
     assert len(non_deprecated) == 1
     assert len(all_available) == 3
 
@@ -158,8 +158,8 @@ def test_deprecate_deprecator(mock_packages, mock_archive, mock_fetch, install_m
 def test_concretize_deprecated(mock_packages, mock_archive, mock_fetch, install_mockery):
     """Tests that the concretizer throws an error if we concretize to a
     deprecated spec"""
-    install("libelf@0.8.13")
-    install("libelf@0.8.10")
+    install("--fake", "libelf@0.8.13")
+    install("--fake", "libelf@0.8.10")
 
     deprecate("-y", "libelf@0.8.10", "libelf@0.8.13")
 

lib/spack/spack/test/cmd/dev_build.py

@@ -122,11 +122,12 @@ def print_spack_cc(*args):
     print(os.environ.get("CC", ""))
 
 
-def test_dev_build_drop_in(tmpdir, mock_packages, monkeypatch, install_mockery, working_env):
-    monkeypatch.setattr(os, "execvp", print_spack_cc)
-    with tmpdir.as_cwd():
-        output = dev_build("-b", "edit", "--drop-in", "sh", "dev-build-test-install@0.0.0")
-        assert os.path.join("lib", "spack", "env") in output
+# FIXME (compiler as nodes): revisit this test
+# def test_dev_build_drop_in(tmpdir, mock_packages, monkeypatch, install_mockery, working_env):
+#     monkeypatch.setattr(os, "execvp", print_spack_cc)
+#     with tmpdir.as_cwd():
+#         output = dev_build("-b", "edit", "--drop-in", "sh", "dev-build-test-install@0.0.0")
+#         assert os.path.join("lib", "spack", "env") in output
 
 
 def test_dev_build_fails_already_installed(tmpdir, install_mockery):

lib/spack/spack/test/cmd/diff.py

@@ -195,7 +195,7 @@ def test_diff_cmd(install_mockery, mock_fetch, mock_archive, mock_packages):
 
 def test_load_first(install_mockery, mock_fetch, mock_archive, mock_packages):
     """Test with and without the --first option"""
-    install_cmd("mpileaks")
+    install_cmd("--fake", "mpileaks")
 
     # Only one version of mpileaks will work
     diff_cmd("mpileaks", "mpileaks")
@@ -224,14 +224,12 @@ def test_load_first(install_mockery, mock_fetch, mock_archive, mock_packages):
         for dep in ("mpileaks", "callpath", "dyninst", "libelf", "libdwarf", "mpich")
     )
     assert all(
-        len([diff for diff in result["intersect"] if diff[0] == attr]) == 6
+        len([diff for diff in result["intersect"] if diff[0] == attr]) == 7
         for attr in (
             "version",
             "node_target",
             "node_platform",
             "node_os",
-            "node_compiler",
-            "node_compiler_version",
             "node",
             "package_hash",
             "hash",

lib/spack/spack/test/cmd/env.py

@@ -2,6 +2,7 @@
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
+import contextlib
 import filecmp
 import glob
 import io
@@ -210,6 +211,49 @@ def test_env_untrack_managed(tmp_path, capfd):
     assert f"'{env_name}' is not a tracked env" in out
 
 
+@pytest.fixture()
+def installed_environment(tmp_path, mock_fetch, mock_packages, mock_archive, install_mockery):
+    spack_yaml = tmp_path / "spack.yaml"
+
+    @contextlib.contextmanager
+    def _installed_environment(content):
+        spack_yaml.write_text(content)
+        with fs.working_dir(tmp_path):
+            env("create", "test", "./spack.yaml")
+            with ev.read("test"):
+                install("--fake")
+
+            test = ev.read("test")
+            yield test
+
+    return _installed_environment
+
+
+@pytest.fixture()
+def template_combinatorial_env(tmp_path):
+    """Returns a template base environment for tests. Since the environment configuration is
+    extended using str.format, we need double '{' escaping for the projections.
+    """
+    view_dir = tmp_path / "view"
+    return f"""\
+    spack:
+      definitions:
+        - packages: [mpileaks, callpath]
+        - targets: ['target=x86_64', 'target=core2']
+      specs:
+        - matrix:
+            - [$packages]
+            - [$targets]
+
+      view:
+        combinatorial:
+          root: {view_dir}
+          {{view_config}}
+          projections:
+            'all': '{{{{architecture.target}}}}/{{{{name}}}}-{{{{version}}}}'
+    """
+
+
 def test_add():
     e = ev.create("test")
     e.add("mpileaks")
@@ -455,7 +499,7 @@ def test_env_specs_partition(install_mockery, mock_fetch):
     assert roots_to_install[0].name == "cmake-client"
 
     # Single installed root.
-    e.install_all()
+    e.install_all(fake=True)
     roots_already_installed, roots_to_install = e._partition_roots_by_install_status()
     assert len(roots_already_installed) == 1
     assert roots_already_installed[0].name == "cmake-client"
@@ -475,7 +519,7 @@ def test_env_install_all(install_mockery, mock_fetch):
     e = ev.create("test")
     e.add("cmake-client")
     e.concretize()
-    e.install_all()
+    e.install_all(fake=True)
     env_specs = e._get_environment_specs()
     spec = next(x for x in env_specs if x.name == "cmake-client")
     assert spec.installed
@@ -487,7 +531,7 @@ def test_env_install_single_spec(install_mockery, mock_fetch):
 
     e = ev.read("test")
     with e:
-        install("--add", "cmake-client")
+        install("--fake", "--add", "cmake-client")
 
     e = ev.read("test")
     assert e.user_specs[0].name == "cmake-client"
@@ -508,7 +552,7 @@ def test_env_install_include_concrete_env(unify, install_mockery, mock_fetch, mu
     combined.write()
 
     with combined:
-        install()
+        install("--fake")
 
     test1_roots = test1.concretized_order
     test2_roots = test2.concretized_order
@@ -556,7 +600,7 @@ def test_env_modifications_error_on_activate(install_mockery, mock_fetch, monkey
 
     e = ev.read("test")
     with e:
-        install("--add", "cmake-client")
+        install("--fake", "--add", "cmake-client")
 
     def setup_error(pkg, env):
         raise RuntimeError("cmake-client had issues!")
@@ -625,12 +669,12 @@ def test_env_install_two_specs_same_dep(install_mockery, mock_fetch, tmpdir, cap
 
     with ev.read("test"):
         with capsys.disabled():
-            out = install()
+            out = install("--fake")
 
     # Ensure both packages reach install phase processing and are installed
     out = str(out)
-    assert "depb: Executing phase:" in out
-    assert "a: Executing phase:" in out
+    assert "depb: Successfully installed" in out
+    assert "pkg-a: Successfully installed" in out
 
     depb = spack.store.STORE.db.query_one("depb", installed=True)
     assert depb, "Expected depb to be installed"
@@ -1649,9 +1693,7 @@ def test_stage(mock_stage, mock_fetch, install_mockery):
     def check_stage(spec):
         spec = Spec(spec).concretized()
         for dep in spec.traverse():
-            stage_name = "{0}{1}-{2}-{3}".format(
-                stage_prefix, dep.name, dep.version, dep.dag_hash()
-            )
+            stage_name = f"{stage_prefix}{dep.name}-{dep.version}-{dep.dag_hash()}"
             assert os.path.isdir(os.path.join(root, stage_name))
 
     check_stage("mpileaks")
@@ -2821,207 +2863,75 @@ def test_stack_definition_conditional_add_write(tmpdir):
         assert "zmpi" not in packages_lists[1]["packages"]
 
 
-def test_stack_combinatorial_view(
-    tmpdir, mock_fetch, mock_packages, mock_archive, install_mockery
-):
-    filename = str(tmpdir.join("spack.yaml"))
-    viewdir = str(tmpdir.join("view"))
-    with open(filename, "w") as f:
-        f.write(
-            """\
-spack:
-  definitions:
-    - packages: [mpileaks, callpath]
-    - compilers: ['%%gcc', '%%clang']
-  specs:
-    - matrix:
-        - [$packages]
-        - [$compilers]
-
-  view:
-    combinatorial:
-      root: %s
-      projections:
-        'all': '{name}/{version}-{compiler.name}'"""
-            % viewdir
-        )
-    with tmpdir.as_cwd():
-        env("create", "test", "./spack.yaml")
-        with ev.read("test"):
-            install()
-
-        test = ev.read("test")
+def test_stack_combinatorial_view(installed_environment, template_combinatorial_env, tmp_path):
+    """Tests creating a default view for a combinatorial stack."""
+    view_dir = tmp_path / "view"
+    with installed_environment(template_combinatorial_env.format(view_config="")) as test:
         for spec in test._get_environment_specs():
-            assert os.path.exists(
-                os.path.join(viewdir, spec.name, "%s-%s" % (spec.version, spec.compiler.name))
-            )
+            if spec.name == "gcc-runtime":
+                continue
+            current_dir = view_dir / f"{spec.architecture.target}" / f"{spec.name}-{spec.version}"
+            assert current_dir.exists() and current_dir.is_dir()
 
 
-def test_stack_view_select(tmpdir, mock_fetch, mock_packages, mock_archive, install_mockery):
-    filename = str(tmpdir.join("spack.yaml"))
-    viewdir = str(tmpdir.join("view"))
-    with open(filename, "w") as f:
-        f.write(
-            """\
-spack:
-  definitions:
-    - packages: [mpileaks, callpath]
-    - compilers: ['%%gcc', '%%clang']
-  specs:
-    - matrix:
-        - [$packages]
-        - [$compilers]
-
-  view:
-    combinatorial:
-      root: %s
-      select: ['%%gcc']
-      projections:
-        'all': '{name}/{version}-{compiler.name}'"""
-            % viewdir
-        )
-    with tmpdir.as_cwd():
-        env("create", "test", "./spack.yaml")
-        with ev.read("test"):
-            install()
-
-        test = ev.read("test")
+def test_stack_view_select(installed_environment, template_combinatorial_env, tmp_path):
+    view_dir = tmp_path / "view"
+    content = template_combinatorial_env.format(view_config="select: ['target=x86_64']\n")
+    with installed_environment(content) as test:
         for spec in test._get_environment_specs():
-            if spec.satisfies("%gcc"):
-                assert os.path.exists(
-                    os.path.join(viewdir, spec.name, "%s-%s" % (spec.version, spec.compiler.name))
-                )
-            else:
-                assert not os.path.exists(
-                    os.path.join(viewdir, spec.name, "%s-%s" % (spec.version, spec.compiler.name))
-                )
+            if spec.name == "gcc-runtime":
+                continue
+            current_dir = view_dir / f"{spec.architecture.target}" / f"{spec.name}-{spec.version}"
+            assert current_dir.exists() is spec.satisfies("target=x86_64")
 
 
-def test_stack_view_exclude(tmpdir, mock_fetch, mock_packages, mock_archive, install_mockery):
-    filename = str(tmpdir.join("spack.yaml"))
-    viewdir = str(tmpdir.join("view"))
-    with open(filename, "w") as f:
-        f.write(
-            """\
-spack:
-  definitions:
-    - packages: [mpileaks, callpath]
-    - compilers: ['%%gcc', '%%clang']
-  specs:
-    - matrix:
-        - [$packages]
-        - [$compilers]
-
-  view:
-    combinatorial:
-      root: %s
-      exclude: [callpath]
-      projections:
-        'all': '{name}/{version}-{compiler.name}'"""
-            % viewdir
-        )
-    with tmpdir.as_cwd():
-        env("create", "test", "./spack.yaml")
-        with ev.read("test"):
-            install()
-
-        test = ev.read("test")
+def test_stack_view_exclude(installed_environment, template_combinatorial_env, tmp_path):
+    view_dir = tmp_path / "view"
+    content = template_combinatorial_env.format(view_config="exclude: [callpath]\n")
+    with installed_environment(content) as test:
         for spec in test._get_environment_specs():
-            if not spec.satisfies("callpath"):
-                assert os.path.exists(
-                    os.path.join(viewdir, spec.name, "%s-%s" % (spec.version, spec.compiler.name))
-                )
-            else:
-                assert not os.path.exists(
-                    os.path.join(viewdir, spec.name, "%s-%s" % (spec.version, spec.compiler.name))
-                )
+            if spec.name == "gcc-runtime":
+                continue
+            current_dir = view_dir / f"{spec.architecture.target}" / f"{spec.name}-{spec.version}"
+            assert current_dir.exists() is not spec.satisfies("callpath")
 
 
 def test_stack_view_select_and_exclude(
-    tmpdir, mock_fetch, mock_packages, mock_archive, install_mockery
+    installed_environment, template_combinatorial_env, tmp_path
 ):
-    filename = str(tmpdir.join("spack.yaml"))
-    viewdir = str(tmpdir.join("view"))
-    with open(filename, "w") as f:
-        f.write(
-            """\
-spack:
-  definitions:
-    - packages: [mpileaks, callpath]
-    - compilers: ['%%gcc', '%%clang']
-  specs:
-    - matrix:
-        - [$packages]
-        - [$compilers]
-
-  view:
-    combinatorial:
-      root: %s
-      select: ['%%gcc']
-      exclude: [callpath]
-      projections:
-        'all': '{name}/{version}-{compiler.name}'"""
-            % viewdir
-        )
-    with tmpdir.as_cwd():
-        env("create", "test", "./spack.yaml")
-        with ev.read("test"):
-            install()
-
-        test = ev.read("test")
+    view_dir = tmp_path / "view"
+    content = template_combinatorial_env.format(
+        view_config="""select: ['target=x86_64']
+          exclude: [callpath]
+"""
+    )
+    with installed_environment(content) as test:
         for spec in test._get_environment_specs():
-            if spec.satisfies("%gcc") and not spec.satisfies("callpath"):
-                assert os.path.exists(
-                    os.path.join(viewdir, spec.name, "%s-%s" % (spec.version, spec.compiler.name))
-                )
-            else:
-                assert not os.path.exists(
-                    os.path.join(viewdir, spec.name, "%s-%s" % (spec.version, spec.compiler.name))
-                )
+            if spec.name == "gcc-runtime":
+                continue
+            current_dir = view_dir / f"{spec.architecture.target}" / f"{spec.name}-{spec.version}"
+            assert current_dir.exists() is (
+                spec.satisfies("target=x86_64") and not spec.satisfies("callpath")
+            )
 
 
-def test_view_link_roots(tmpdir, mock_fetch, mock_packages, mock_archive, install_mockery):
-    filename = str(tmpdir.join("spack.yaml"))
-    viewdir = str(tmpdir.join("view"))
-    with open(filename, "w") as f:
-        f.write(
-            """\
-spack:
-  definitions:
-    - packages: [mpileaks, callpath]
-    - compilers: ['%%gcc', '%%clang']
-  specs:
-    - matrix:
-        - [$packages]
-        - [$compilers]
-
-  view:
-    combinatorial:
-      root: %s
-      select: ['%%gcc']
-      exclude: [callpath]
-      link: 'roots'
-      projections:
-        'all': '{name}/{version}-{compiler.name}'"""
-            % viewdir
-        )
-    with tmpdir.as_cwd():
-        env("create", "test", "./spack.yaml")
-        with ev.read("test"):
-            install()
-
-        test = ev.read("test")
+def test_view_link_roots(installed_environment, template_combinatorial_env, tmp_path):
+    view_dir = tmp_path / "view"
+    content = template_combinatorial_env.format(
+        view_config="""select: ['target=x86_64']
+          exclude: [callpath]
+          link: 'roots'
+    """
+    )
+    with installed_environment(content) as test:
         for spec in test._get_environment_specs():
-            if spec in test.roots() and (
-                spec.satisfies("%gcc") and not spec.satisfies("callpath")
-            ):
-                assert os.path.exists(
-                    os.path.join(viewdir, spec.name, "%s-%s" % (spec.version, spec.compiler.name))
-                )
-            else:
-                assert not os.path.exists(
-                    os.path.join(viewdir, spec.name, "%s-%s" % (spec.version, spec.compiler.name))
-                )
+            if spec.name == "gcc-runtime":
+                continue
+            current_dir = view_dir / f"{spec.architecture.target}" / f"{spec.name}-{spec.version}"
+            expected_exists = spec in test.roots() and (
+                spec.satisfies("target=x86_64") and not spec.satisfies("callpath")
+            )
+            assert current_dir.exists() == expected_exists
 
 
 def test_view_link_run(tmpdir, mock_fetch, mock_packages, mock_archive, install_mockery):
@@ -3065,169 +2975,84 @@ def test_view_link_run(tmpdir, mock_fetch, mock_packages, mock_archive, install_
 
 
 @pytest.mark.parametrize("link_type", ["hardlink", "copy", "symlink"])
-def test_view_link_type(
-    link_type, tmpdir, mock_fetch, mock_packages, mock_archive, install_mockery
-):
-    filename = str(tmpdir.join("spack.yaml"))
-    viewdir = str(tmpdir.join("view"))
-    with open(filename, "w") as f:
-        f.write(
-            """\
+def test_view_link_type(link_type, installed_environment, tmp_path):
+    view_dir = tmp_path / "view"
+    with installed_environment(
+        f"""\
 spack:
   specs:
     - mpileaks
   view:
     default:
-      root: %s
-      link_type: %s"""
-            % (viewdir, link_type)
-        )
-    with tmpdir.as_cwd():
-        env("create", "test", "./spack.yaml")
-        with ev.read("test"):
-            install()
-
-        test = ev.read("test")
-
+      root: {view_dir}
+      link_type: {link_type}"""
+    ) as test:
         for spec in test.roots():
-            file_path = test.default_view.view()._root
-            file_to_test = os.path.join(file_path, spec.name)
-            assert os.path.isfile(file_to_test)
-            assert os.path.islink(file_to_test) == (link_type == "symlink")
+            # Assertions are based on the behavior of the "--fake" install
+            bin_file = pathlib.Path(test.default_view.view()._root) / "bin" / spec.name
+            assert bin_file.exists()
+            assert bin_file.is_symlink() == (link_type == "symlink")
 
 
-def test_view_link_all(tmpdir, mock_fetch, mock_packages, mock_archive, install_mockery):
-    filename = str(tmpdir.join("spack.yaml"))
-    viewdir = str(tmpdir.join("view"))
-    with open(filename, "w") as f:
-        f.write(
-            """\
-spack:
-  definitions:
-    - packages: [mpileaks, callpath]
-    - compilers: ['%%gcc', '%%clang']
-  specs:
-    - matrix:
-        - [$packages]
-        - [$compilers]
+def test_view_link_all(installed_environment, template_combinatorial_env, tmp_path):
+    view_dir = tmp_path / "view"
+    content = template_combinatorial_env.format(
+        view_config="""select: ['target=x86_64']
+          exclude: [callpath]
+          link: 'all'
+    """
+    )
 
-  view:
-    combinatorial:
-      root: %s
-      select: ['%%gcc']
-      exclude: [callpath]
-      link: 'all'
-      projections:
-        'all': '{name}/{version}-{compiler.name}'"""
-            % viewdir
-        )
-    with tmpdir.as_cwd():
-        env("create", "test", "./spack.yaml")
-        with ev.read("test"):
-            install()
-
-        test = ev.read("test")
+    with installed_environment(content) as test:
         for spec in test._get_environment_specs():
-            if spec.satisfies("%gcc") and not spec.satisfies("callpath"):
-                assert os.path.exists(
-                    os.path.join(viewdir, spec.name, "%s-%s" % (spec.version, spec.compiler.name))
-                )
-            else:
-                assert not os.path.exists(
-                    os.path.join(viewdir, spec.name, "%s-%s" % (spec.version, spec.compiler.name))
-                )
+            if spec.name == "gcc-runtime":
+                continue
+            current_dir = view_dir / f"{spec.architecture.target}" / f"{spec.name}-{spec.version}"
+            assert current_dir.exists() == (
+                spec.satisfies("target=x86_64") and not spec.satisfies("callpath")
+            )
 
 
 def test_stack_view_activate_from_default(
-    tmpdir, mock_fetch, mock_packages, mock_archive, install_mockery
+    installed_environment, template_combinatorial_env, tmp_path
 ):
-    filename = str(tmpdir.join("spack.yaml"))
-    viewdir = str(tmpdir.join("view"))
-    with open(filename, "w") as f:
-        f.write(
-            """\
-spack:
-  definitions:
-    - packages: [mpileaks, cmake]
-    - compilers: ['%%gcc', '%%clang']
-  specs:
-    - matrix:
-        - [$packages]
-        - [$compilers]
-
-  view:
-    default:
-      root: %s
-      select: ['%%gcc']"""
-            % viewdir
-        )
-    with tmpdir.as_cwd():
-        env("create", "test", "./spack.yaml")
-        with ev.read("test"):
-            install()
-
+    view_dir = tmp_path / "view"
+    content = template_combinatorial_env.format(view_config="select: ['target=x86_64']")
+    # Replace the name of the view
+    content = content.replace("combinatorial:", "default:")
+    with installed_environment(content):
         shell = env("activate", "--sh", "test")
-
-        assert "PATH" in shell
-        assert os.path.join(viewdir, "bin") in shell
+        assert "PATH" in shell, shell
+        assert str(view_dir / "bin") in shell
         assert "FOOBAR=mpileaks" in shell
 
 
 def test_stack_view_no_activate_without_default(
-    tmpdir, mock_fetch, mock_packages, mock_archive, install_mockery
+    installed_environment, template_combinatorial_env, tmp_path
 ):
-    filename = str(tmpdir.join("spack.yaml"))
-    viewdir = str(tmpdir.join("view"))
-    with open(filename, "w") as f:
-        f.write(
-            """\
-spack:
-  definitions:
-    - packages: [mpileaks, cmake]
-    - compilers: ['%%gcc', '%%clang']
-  specs:
-    - matrix:
-        - [$packages]
-        - [$compilers]
-
-  view:
-    not-default:
-      root: %s
-      select: ['%%gcc']"""
-            % viewdir
-        )
-    with tmpdir.as_cwd():
-        env("create", "test", "./spack.yaml")
-        with ev.read("test"):
-            install()
-
+    view_dir = tmp_path / "view"
+    content = template_combinatorial_env.format(view_config="select: ['target=x86_64']")
+    with installed_environment(content):
         shell = env("activate", "--sh", "test")
         assert "PATH" not in shell
-        assert viewdir not in shell
+        assert str(view_dir) not in shell
 
 
 @pytest.mark.parametrize("include_views", [True, False, "split"])
-def test_stack_view_multiple_views(
-    tmp_path,
-    mock_fetch,
-    mock_packages,
-    mock_archive,
-    install_mockery,
-    mutable_config,
-    include_views,
-):
+def test_stack_view_multiple_views(installed_environment, tmp_path, include_views):
     """Test multiple views as both included views (True), as both environment
-    views (False), or as one included and the other in the environment."""
+    views (False), or as one included and the other in the environment.
+    """
     # Write the view configuration and or manifest file
     view_filename = tmp_path / "view.yaml"
     base_content = """\
   definitions:
     - packages: [mpileaks, cmake]
-    - compilers: ['%gcc', '%clang']
+    - targets: ['target=x86_64', 'target=core2']
   specs:
     - matrix:
         - [$packages]
-        - [$compilers]
+        - [$targets]
 """
 
     include_content = f"  include:\n    - {view_filename}\n"
@@ -3237,17 +3062,17 @@ def test_stack_view_multiple_views(
     comb_view = """\
 {0}combinatorial:
 {0}  root: {1}
-{0}  exclude: [callpath%gcc]
+{0}  exclude: [target=core2]
 {0}  projections:
 """
 
-    projection = "    'all': '{name}/{version}-{compiler.name}'"
+    projection = "    'all': '{architecture.target}/{name}-{version}'"
 
     default_dir = tmp_path / "default-view"
     default_view = """\
 {0}default:
 {0}  root: {1}
-{0}  select: ['%gcc']
+{0}  select: ['target=x86_64']
 """
 
     content = "spack:\n"
@@ -3272,22 +3097,13 @@ def test_stack_view_multiple_views(
         content += default_view.format(indent, str(default_dir))
         content += comb_view.format(indent, str(comb_dir)) + indent + projection
 
-    filename = tmp_path / ev.manifest_name
-    filename.write_text(content)
-
-    env("create", "test", str(filename))
-    with ev.read("test"):
-        install()
-
-    with ev.read("test") as e:
+    with installed_environment(content) as e:
         assert os.path.exists(str(default_dir / "bin"))
         for spec in e._get_environment_specs():
-            spec_subdir = f"{spec.version}-{spec.compiler.name}"
-            comb_spec_dir = str(comb_dir / spec.name / spec_subdir)
-            if not spec.satisfies("callpath%gcc"):
-                assert os.path.exists(comb_spec_dir)
-            else:
-                assert not os.path.exists(comb_spec_dir)
+            if spec.name == "gcc-runtime":
+                continue
+            current_dir = comb_dir / f"{spec.architecture.target}" / f"{spec.name}-{spec.version}"
+            assert current_dir.exists() is not spec.satisfies("target=core2")
 
 
 def test_env_activate_sh_prints_shell_output(tmpdir, mock_stage, mock_fetch, install_mockery):
@@ -3656,12 +3472,10 @@ def test_modules_relative_to_views(environment_from_manifest, install_mockery, m
     assert spec.prefix not in contents
 
 
-def test_modules_exist_after_env_install(
-    environment_from_manifest, install_mockery, mock_fetch, monkeypatch
-):
+def test_modules_exist_after_env_install(installed_environment, monkeypatch):
     # Some caching issue
     monkeypatch.setattr(spack.modules.tcl, "configuration_registry", {})
-    environment_from_manifest(
+    with installed_environment(
         """
 spack:
   specs:
@@ -3677,16 +3491,15 @@ def test_modules_exist_after_env_install(
       roots:
         tcl: without_view
 """
-    )
-
-    with ev.read("test") as e:
-        install()
+    ) as e:
         specs = e.all_specs()
-
         for module_set in ("uses_view", "without_view"):
             modules = glob.glob(f"{e.path}/{module_set}/**/*/*")
             assert len(modules) == len(specs), "Not all modules were generated"
             for spec in specs:
+                if spec.external:
+                    continue
+
                 module = next((m for m in modules if os.path.dirname(m).endswith(spec.name)), None)
                 assert module, f"Module for {spec} not found"
 
@@ -3728,7 +3541,7 @@ def test_install_develop_keep_stage(
         (mpileaks_spec,) = e.all_matching_specs("mpileaks")
         assert not os.path.exists(libelf_spec.package.stage.path)
         assert not os.path.exists(mpileaks_spec.package.stage.path)
-        install()
+        install("--fake")
         assert os.path.exists(libelf_spec.package.stage.path)
         assert not os.path.exists(mpileaks_spec.package.stage.path)
 
@@ -3938,7 +3751,7 @@ def test_environment_query_spec_by_hash(mock_stage, mock_fetch, install_mockery)
         concretize()
     with ev.read("test") as e:
         spec = e.matching_spec("libelf")
-        install("/{0}".format(spec.dag_hash()))
+        install("--fake", f"/{spec.dag_hash()}")
     with ev.read("test") as e:
         assert not e.matching_spec("libdwarf").installed
         assert e.matching_spec("libelf").installed
@@ -4401,7 +4214,7 @@ def test_env_include_packages_url(
         ev.activate(env)
 
         cfg = spack.config.get("packages")
-        assert "openmpi" in cfg["all"]["providers"]["mpi"]
+        assert "mpich" in cfg["all"]["providers"]["mpi"]
 
 
 def test_relative_view_path_on_command_line_is_made_absolute(tmp_path):
@@ -4525,7 +4338,7 @@ def test_env_include_mixed_views(tmp_path, mutable_mock_env_path, mutable_config
 
 
 def test_stack_view_multiple_views_same_name(
-    tmp_path, mock_fetch, mock_packages, mock_archive, install_mockery, mutable_config
+    installed_environment, template_combinatorial_env, tmp_path
 ):
     """Test multiple views with the same name combine settings with precedence
     given to the options in spack.yaml."""
@@ -4537,58 +4350,52 @@ def test_stack_view_multiple_views_same_name(
 view:
   default:
     root: {default_dir}
-    select: ['%gcc']
+    select: ['target=x86_64']
     projections:
-      all: '{{name}}/{{version}}-{{compiler.name}}'
+      all: '{{architecture.target}}/{{name}}-{{version}}-from-view'
 """
     view_filename.write_text(default_view)
 
     view_dir = tmp_path / "view"
-    content = f"""\
+    with installed_environment(
+        f"""\
 spack:
   include:
   - {view_filename}
   definitions:
     - packages: [mpileaks, cmake]
-    - compilers: ['%gcc', '%clang']
+    - targets: ['target=x86_64', 'target=core2']
+
   specs:
     - matrix:
         - [$packages]
-        - [$compilers]
+        - [$targets]
 
   view:
     default:
       root: {view_dir}
       exclude: ['cmake']
       projections:
-        all: '{{name}}/{{compiler.name}}-{{version}}'
+        all: '{{architecture.target}}/{{name}}-{{version}}'
 """
-
-    filename = tmp_path / ev.manifest_name
-    filename.write_text(content)
-
-    env("create", "test", str(filename))
-    with ev.read("test"):
-        install()
-
-    with ev.read("test") as e:
+    ) as e:
         # the view root in the included view should NOT exist
         assert not os.path.exists(str(default_dir))
 
         for spec in e._get_environment_specs():
             # no specs will exist in the included view projection
-            included_spec_subdir = f"{spec.version}-{spec.compiler.name}"
-            included_spec_dir = str(view_dir / spec.name / included_spec_subdir)
-            assert not os.path.exists(included_spec_dir)
+            base_dir = view_dir / f"{spec.architecture.target}"
+            included_dir = base_dir / f"{spec.name}-{spec.version}-from-view"
+            assert not included_dir.exists()
 
-            # only specs compiled with %gcc (selected in the included view) that
+            # only target=x86_64 specs (selected in the included view) that
             # are also not cmake (excluded in the environment view) should exist
-            env_spec_subdir = f"{spec.compiler.name}-{spec.version}"
-            env_spec_dir = str(view_dir / spec.name / env_spec_subdir)
-            if spec.satisfies("cmake") or spec.satisfies("%clang"):
-                assert not os.path.exists(env_spec_dir)
-            else:
-                assert os.path.exists(env_spec_dir)
+            if spec.name == "gcc-runtime":
+                continue
+            current_dir = view_dir / f"{spec.architecture.target}" / f"{spec.name}-{spec.version}"
+            assert current_dir.exists() is not (
+                spec.satisfies("cmake") or spec.satisfies("target=core2")
+            )
 
 
 def test_env_view_resolves_identical_file_conflicts(tmp_path, install_mockery, mock_fetch):

lib/spack/spack/test/cmd/find.py

@@ -171,7 +171,7 @@ def _check_json_output(spec_list):
 
 
 def _check_json_output_deps(spec_list):
-    assert len(spec_list) == 13
+    assert len(spec_list) == 15
 
     names = [spec["name"] for spec in spec_list]
     assert names.count("mpileaks") == 3
@@ -232,21 +232,28 @@ def test_display_json_deps(database, capsys):
 @pytest.mark.db
 def test_find_format(database, config):
     output = find("--format", "{name}-{^mpi.name}", "mpileaks")
-    assert set(output.strip().split("\n")) == set(
-        ["mpileaks-zmpi", "mpileaks-mpich", "mpileaks-mpich2"]
-    )
+    assert set(output.strip().split("\n")) == {
+        "mpileaks-zmpi",
+        "mpileaks-mpich",
+        "mpileaks-mpich2",
+    }
 
-    output = find("--format", "{name}-{version}-{compiler.name}-{^mpi.name}", "mpileaks")
-    assert "installed package" not in output
-    assert set(output.strip().split("\n")) == set(
-        ["mpileaks-2.3-gcc-zmpi", "mpileaks-2.3-gcc-mpich", "mpileaks-2.3-gcc-mpich2"]
-    )
+    # FIXME (compiler as nodes): recover the {compiler} in Spec.format
+    # output = find("--format", "{name}-{version}-{compiler.name}-{^mpi.name}", "mpileaks")
+    # assert "installed package" not in output
+    # assert set(output.strip().split("\n")) == {
+    #     "mpileaks-2.3-gcc-zmpi",
+    #     "mpileaks-2.3-gcc-mpich",
+    #     "mpileaks-2.3-gcc-mpich2",
+    # }
 
     output = find("--format", "{name}-{^mpi.name}-{hash:7}", "mpileaks")
     elements = output.strip().split("\n")
-    assert set(e[:-7] for e in elements) == set(
-        ["mpileaks-zmpi-", "mpileaks-mpich-", "mpileaks-mpich2-"]
-    )
+    assert set(e[:-7] for e in elements) == {
+        "mpileaks-zmpi-",
+        "mpileaks-mpich-",
+        "mpileaks-mpich2-",
+    }
 
     # hashes are in base32
     for e in elements:
@@ -265,6 +272,8 @@ def test_find_format_deps(database, config):
         dyninst-8.2
             libdwarf-20130729
             libelf-0.8.13
+    gcc-10.2.1
+    gcc-runtime-10.2.1
     zmpi-1.0
         fake-1.0
 
@@ -275,24 +284,21 @@ def test_find_format_deps(database, config):
 @pytest.mark.db
 def test_find_format_deps_paths(database, config):
     output = find("-dp", "--format", "{name}-{version}", "mpileaks", "^zmpi")
-
-    spec = Spec("mpileaks ^zmpi").concretized()
-    prefixes = [s.prefix for s in spec.traverse()]
-
+    mpileaks = Spec("mpileaks ^zmpi").concretized()
     assert (
         output
-        == """\
-mpileaks-2.3                   {0}
-    callpath-1.0               {1}
-        dyninst-8.2            {2}
-            libdwarf-20130729  {3}
-            libelf-0.8.13      {4}
-    zmpi-1.0                   {5}
-        fake-1.0               {6}
+        == f"""\
+mpileaks-2.3                   {mpileaks.prefix}
+    callpath-1.0               {mpileaks['callpath'].prefix}
+        dyninst-8.2            {mpileaks['dyninst'].prefix}
+            libdwarf-20130729  {mpileaks['libdwarf'].prefix}
+            libelf-0.8.13      {mpileaks['libelf'].prefix}
+    gcc-10.2.1                 {mpileaks['gcc'].prefix}
+    gcc-runtime-10.2.1         {mpileaks['gcc-runtime'].prefix}
+    zmpi-1.0                   {mpileaks['zmpi'].prefix}
+        fake-1.0               {mpileaks['fake'].prefix}
 
-""".format(
-            *prefixes
-        )
+"""
     )
 
 
@@ -309,12 +315,6 @@ def test_find_very_long(database, config):
     )
 
 
-@pytest.mark.db
-def test_find_show_compiler(database, config):
-    output = find("--no-groups", "--show-full-compiler", "mpileaks")
-    assert "mpileaks@2.3%gcc@10.2.1" in output
-
-
 @pytest.mark.db
 def test_find_not_found(database, config, capsys):
     with capsys.disabled():
@@ -346,7 +346,7 @@ def test_find_prefix_in_env(
     """Test `find` formats requiring concrete specs work in environments."""
     env("create", "test")
     with ev.read("test"):
-        install("--add", "mpileaks")
+        install("--fake", "--add", "mpileaks")
         find("-p")
         find("-l")
         find("-L")
@@ -456,7 +456,7 @@ def test_environment_with_version_range_in_compiler_doesnt_fail(tmp_path):
 
     with test_environment:
         output = find()
-    assert "zlib%gcc@12.1.0" in output
+    assert "zlib" in output
 
 
 _pkga = (

lib/spack/spack/test/cmd/gc.py

@@ -21,7 +21,8 @@
 @pytest.mark.db
 def test_gc_without_build_dependency(mutable_database):
     assert "There are no unused specs." in gc("-yb")
-    assert "There are no unused specs." in gc("-y")
+    # 'gcc' is a pure build dependency in the DB
+    assert "There are no unused specs." not in gc("-y")
 
 
 @pytest.mark.db
@@ -62,7 +63,7 @@ def test_gc_with_environment(mutable_database, mutable_mock_env_path):
         add("cmake")
         install()
         assert mutable_database.query_local("cmake")
-        output = gc("-y")
+        output = gc("-by")
     assert "Restricting garbage collection" in output
     assert "There are no unused specs" in output
 

lib/spack/spack/test/cmd/install.py

@@ -41,6 +41,16 @@
 find = SpackCommand("find")
 
 
+# @pytest.fixture(autouse=True)
+# def gcc_runtime_mock_install(mock_packages, monkeypatch):
+#     import spack.pkg.builtin.mock.gcc_runtime
+#
+#     def _mock_install(self, spec, prefix):
+#         mkdir(prefix.lib)
+#
+#     monkeypatch.setattr(spack.pkg.builtin.mock.gcc_runtime.GccRuntime, "install", _mock_install)
+
+
 @pytest.fixture()
 def noop_install(monkeypatch):
     def noop(*args, **kwargs):
@@ -54,14 +64,14 @@ def test_install_package_and_dependency(
 ):
     log = "test"
     with tmpdir.as_cwd():
-        install("--log-format=junit", "--log-file={0}".format(log), "libdwarf")
+        install("--fake", "--log-format=junit", f"--log-file={log}", "libdwarf")
 
     files = tmpdir.listdir()
-    filename = tmpdir.join("{0}.xml".format(log))
+    filename = tmpdir.join(f"{log}.xml")
     assert filename in files
 
     content = filename.open().read()
-    assert 'tests="2"' in content
+    assert 'tests="3"' in content
     assert 'failures="0"' in content
     assert 'errors="0"' in content
 
@@ -97,20 +107,21 @@ def test_install_package_already_installed(
     tmpdir, mock_packages, mock_archive, mock_fetch, install_mockery
 ):
     with tmpdir.as_cwd():
-        install("libdwarf")
-        install("--log-format=junit", "--log-file=test.xml", "libdwarf")
+        install("--fake", "libdwarf")
+        install("--fake", "--log-format=junit", "--log-file=test.xml", "libdwarf")
 
     files = tmpdir.listdir()
     filename = tmpdir.join("test.xml")
     assert filename in files
 
     content = filename.open().read()
-    assert 'tests="2"' in content
+    print(content)
+    assert 'tests="4"' in content
     assert 'failures="0"' in content
     assert 'errors="0"' in content
 
     skipped = [line for line in content.split("\n") if "skipped" in line]
-    assert len(skipped) == 2
+    assert len(skipped) == 4
 
 
 @pytest.mark.parametrize(
@@ -183,9 +194,8 @@ def test_install_with_source(mock_packages, mock_archive, mock_fetch, install_mo
 
 
 def test_install_env_variables(mock_packages, mock_archive, mock_fetch, install_mockery):
-    spec = Spec("libdwarf")
-    spec.concretize()
-    install("libdwarf")
+    spec = Spec("pkg-c").concretized()
+    install("pkg-c")
     assert os.path.isfile(spec.package.install_env_path)
 
 
@@ -204,11 +214,9 @@ def test_show_log_on_error(mock_packages, mock_archive, mock_fetch, install_mock
 
 
 def test_install_overwrite(mock_packages, mock_archive, mock_fetch, install_mockery):
-    # Try to install a spec and then to reinstall it.
-    spec = Spec("libdwarf")
-    spec.concretize()
-
-    install("libdwarf")
+    """Tests installing a spec, and then re-installing it in the same prefix."""
+    spec = Spec("pkg-c").concretized()
+    install("pkg-c")
 
     # Ignore manifest and install times
     manifest = os.path.join(
@@ -230,7 +238,7 @@ def test_install_overwrite(mock_packages, mock_archive, mock_fetch, install_mock
 
     assert bad_md5 != expected_md5
 
-    install("--overwrite", "-y", "libdwarf")
+    install("--overwrite", "-y", "pkg-c")
 
     assert os.path.exists(spec.prefix)
     assert fs.hash_directory(spec.prefix, ignore=ignores) == expected_md5
@@ -238,13 +246,10 @@ def test_install_overwrite(mock_packages, mock_archive, mock_fetch, install_mock
 
 
 def test_install_overwrite_not_installed(mock_packages, mock_archive, mock_fetch, install_mockery):
-    # Try to install a spec and then to reinstall it.
-    spec = Spec("libdwarf")
-    spec.concretize()
-
+    """Tests that overwrite doesn't fail if the package is not installed"""
+    spec = Spec("pkg-c").concretized()
     assert not os.path.exists(spec.prefix)
-
-    install("--overwrite", "-y", "libdwarf")
+    install("--overwrite", "-y", "pkg-c")
     assert os.path.exists(spec.prefix)
 
 
@@ -274,15 +279,11 @@ def test_install_commit(mock_git_version_info, install_mockery, mock_packages, m
 
 def test_install_overwrite_multiple(mock_packages, mock_archive, mock_fetch, install_mockery):
     # Try to install a spec and then to reinstall it.
-    libdwarf = Spec("libdwarf")
-    libdwarf.concretize()
+    libdwarf = Spec("libdwarf").concretized()
+    cmake = Spec("cmake").concretized()
 
-    install("libdwarf")
-
-    cmake = Spec("cmake")
-    cmake.concretize()
-
-    install("cmake")
+    install("--fake", "libdwarf")
+    install("--fake", "cmake")
 
     ld_manifest = os.path.join(
         libdwarf.prefix,
@@ -318,7 +319,7 @@ def test_install_overwrite_multiple(mock_packages, mock_archive, mock_fetch, ins
     assert bad_libdwarf_md5 != expected_libdwarf_md5
     assert bad_cmake_md5 != expected_cmake_md5
 
-    install("--overwrite", "-y", "libdwarf", "cmake")
+    install("--fake", "--overwrite", "-y", "libdwarf", "cmake")
     assert os.path.exists(libdwarf.prefix)
     assert os.path.exists(cmake.prefix)
 
@@ -555,10 +556,10 @@ def test_cdash_upload_build_error(tmpdir, mock_fetch, install_mockery, capfd):
 def test_cdash_upload_clean_build(tmpdir, mock_fetch, install_mockery, capfd):
     # capfd interferes with Spack's capturing of e.g., Build.xml output
     with capfd.disabled(), tmpdir.as_cwd():
-        install("--log-file=cdash_reports", "--log-format=cdash", "pkg-a")
+        install("--log-file=cdash_reports", "--log-format=cdash", "pkg-c")
         report_dir = tmpdir.join("cdash_reports")
         assert report_dir in tmpdir.listdir()
-        report_file = report_dir.join("pkg-a_Build.xml")
+        report_file = report_dir.join("Build.xml")
         assert report_file in report_dir.listdir()
         content = report_file.open().read()
         assert "</Build>" in content
@@ -575,14 +576,14 @@ def test_cdash_upload_extra_params(tmpdir, mock_fetch, install_mockery, capfd):
             "--cdash-build=my_custom_build",
             "--cdash-site=my_custom_site",
             "--cdash-track=my_custom_track",
-            "pkg-a",
+            "pkg-c",
         )
         report_dir = tmpdir.join("cdash_reports")
         assert report_dir in tmpdir.listdir()
-        report_file = report_dir.join("pkg-a_Build.xml")
+        report_file = report_dir.join("Build.xml")
         assert report_file in report_dir.listdir()
         content = report_file.open().read()
-        assert 'Site BuildName="my_custom_build - pkg-a"' in content
+        assert 'Site BuildName="my_custom_build"' in content
         assert 'Name="my_custom_site"' in content
         assert "-my_custom_track" in content
 
@@ -592,17 +593,17 @@ def test_cdash_buildstamp_param(tmpdir, mock_fetch, install_mockery, capfd):
     # capfd interferes with Spack's capture of e.g., Build.xml output
     with capfd.disabled(), tmpdir.as_cwd():
         cdash_track = "some_mocked_track"
-        buildstamp_format = "%Y%m%d-%H%M-{0}".format(cdash_track)
+        buildstamp_format = f"%Y%m%d-%H%M-{cdash_track}"
         buildstamp = time.strftime(buildstamp_format, time.localtime(int(time.time())))
         install(
             "--log-file=cdash_reports",
             "--log-format=cdash",
-            "--cdash-buildstamp={0}".format(buildstamp),
-            "pkg-a",
+            f"--cdash-buildstamp={buildstamp}",
+            "pkg-c",
         )
         report_dir = tmpdir.join("cdash_reports")
         assert report_dir in tmpdir.listdir()
-        report_file = report_dir.join("pkg-a_Build.xml")
+        report_file = report_dir.join("Build.xml")
         assert report_file in report_dir.listdir()
         content = report_file.open().read()
         assert buildstamp in content
@@ -616,9 +617,7 @@ def test_cdash_install_from_spec_json(
     with capfd.disabled(), tmpdir.as_cwd():
         spec_json_path = str(tmpdir.join("spec.json"))
 
-        pkg_spec = Spec("pkg-a")
-        pkg_spec.concretize()
-
+        pkg_spec = Spec("pkg-c").concretized()
         with open(spec_json_path, "w") as fd:
             fd.write(pkg_spec.to_json(hash=ht.dag_hash))
 
@@ -634,7 +633,7 @@ def test_cdash_install_from_spec_json(
 
         report_dir = tmpdir.join("cdash_reports")
         assert report_dir in tmpdir.listdir()
-        report_file = report_dir.join("pkg-a_Configure.xml")
+        report_file = report_dir.join("Configure.xml")
         assert report_file in report_dir.listdir()
         content = report_file.open().read()
         install_command_regex = re.compile(
@@ -643,7 +642,7 @@ def test_cdash_install_from_spec_json(
         m = install_command_regex.search(content)
         assert m
         install_command = m.group(1)
-        assert "pkg-a@" in install_command
+        assert "pkg-c@" in install_command
 
 
 @pytest.mark.disable_clean_stage_check
@@ -680,7 +679,7 @@ def test_cache_only_fails(tmpdir, mock_fetch, install_mockery, capfd):
     with capfd.disabled():
         out = install("--cache-only", "libdwarf", fail_on_error=False)
 
-    assert "Failed to install libelf" in out
+    assert "Failed to install gcc-runtime" in out
     assert "Skipping build of libdwarf" in out
     assert "was not installed" in out
 
@@ -814,12 +813,12 @@ def test_install_no_add_in_env(tmpdir, mock_fetch, install_mockery, mutable_mock
     # Activate the environment
     with e:
         # Assert using --no-add with a spec not in the env fails
-        inst_out = install("--no-add", "boost", fail_on_error=False, output=str)
+        inst_out = install("--fake", "--no-add", "boost", fail_on_error=False, output=str)
 
         assert "You can add specs to the environment with 'spack add " in inst_out
 
         # Without --add, ensure that two packages "a" get installed
-        inst_out = install("pkg-a", output=str)
+        inst_out = install("--fake", "pkg-a", output=str)
         assert len([x for x in e.all_specs() if x.installed and x.name == "pkg-a"]) == 2
 
         # Install an unambiguous dependency spec (that already exists as a dep
@@ -853,14 +852,14 @@ def test_install_no_add_in_env(tmpdir, mock_fetch, install_mockery, mutable_mock
         # root of the environment as well as installed.
         assert b_spec not in e.roots()
 
-        install("--add", "pkg-b")
+        install("--fake", "--add", "pkg-b")
 
         assert b_spec in e.roots()
         assert b_spec not in e.uninstalled_specs()
 
         # Install a novel spec with --add and make sure it is added  as a root
         # and installed.
-        install("--add", "bowtie")
+        install("--fake", "--add", "bowtie")
 
         assert any([s.name == "bowtie" for s in e.roots()])
         assert not any([s.name == "bowtie" for s in e.uninstalled_specs()])
@@ -888,7 +887,7 @@ def test_cdash_auth_token(tmpdir, mock_fetch, install_mockery, monkeypatch, capf
     # capfd interferes with Spack's capturing
     with tmpdir.as_cwd(), capfd.disabled():
         monkeypatch.setenv("SPACK_CDASH_AUTH_TOKEN", "asdf")
-        out = install("-v", "--log-file=cdash_reports", "--log-format=cdash", "pkg-a")
+        out = install("--fake", "-v", "--log-file=cdash_reports", "--log-format=cdash", "pkg-a")
         assert "Using CDash auth token from environment" in out
 
 
@@ -949,7 +948,7 @@ def test_install_env_with_tests_all(
     with ev.read("test"):
         test_dep = Spec("test-dependency").concretized()
         add("depb")
-        install("--test", "all")
+        install("--fake", "--test", "all")
         assert os.path.exists(test_dep.prefix)
 
 
@@ -961,7 +960,7 @@ def test_install_env_with_tests_root(
     with ev.read("test"):
         test_dep = Spec("test-dependency").concretized()
         add("depb")
-        install("--test", "root")
+        install("--fake", "--test", "root")
         assert not os.path.exists(test_dep.prefix)
 
 

lib/spack/spack/test/cmd/load.py

@@ -30,7 +30,7 @@ def test_manpath_trailing_colon(
     """Test that the commands generated by load add the MANPATH prefix
     inspections. Also test that Spack correctly preserves the default/existing
     manpath search path via a trailing colon"""
-    install("mpileaks")
+    install("--fake", "mpileaks")
 
     sh_out = load(shell, "mpileaks")
     lines = [line.strip("\n") for line in sh_out.split(commandsep)]
@@ -49,7 +49,7 @@ def test_load_recursive(install_mockery, mock_fetch, mock_archive, mock_packages
     def test_load_shell(shell, set_command):
         """Test that `spack load` applies prefix inspections of its required runtime deps in
         topo-order"""
-        install("mpileaks")
+        install("--fake", "mpileaks")
         mpileaks_spec = spack.spec.Spec("mpileaks").concretized()
 
         # Ensure our reference variable is clean.
@@ -116,7 +116,7 @@ def test_load_includes_run_env(
     """Tests that environment changes from the package's
     `setup_run_environment` method are added to the user environment in
     addition to the prefix inspections"""
-    install("mpileaks")
+    install("--fake", "mpileaks")
 
     shell_out = load(shell, "mpileaks")
 
@@ -126,8 +126,8 @@ def test_load_includes_run_env(
 def test_load_first(install_mockery, mock_fetch, mock_archive, mock_packages):
     """Test with and without the --first option"""
     shell = "--bat" if sys.platform == "win32" else "--sh"
-    install("libelf@0.8.12")
-    install("libelf@0.8.13")
+    install("--fake", "libelf@0.8.12")
+    install("--fake", "libelf@0.8.13")
 
     # Now there are two versions of libelf, which should cause an error
     out = load(shell, "libelf", fail_on_error=False)
@@ -140,7 +140,7 @@ def test_load_first(install_mockery, mock_fetch, mock_archive, mock_packages):
 
 def test_load_fails_no_shell(install_mockery, mock_fetch, mock_archive, mock_packages):
     """Test that spack load prints an error message without a shell."""
-    install("mpileaks")
+    install("--fake", "mpileaks")
 
     out = load("mpileaks", fail_on_error=False)
     assert "To set up shell support" in out
@@ -166,7 +166,7 @@ def test_unload(
 ):
     """Tests that any variables set in the user environment are undone by the
     unload command"""
-    install("mpileaks")
+    install("--fake", "mpileaks")
     mpileaks_spec = spack.spec.Spec("mpileaks").concretized()
 
     # Set so unload has something to do
@@ -187,7 +187,7 @@ def test_unload_fails_no_shell(
     install_mockery, mock_fetch, mock_archive, mock_packages, working_env
 ):
     """Test that spack unload prints an error message without a shell."""
-    install("mpileaks")
+    install("--fake", "mpileaks")
     mpileaks_spec = spack.spec.Spec("mpileaks").concretized()
     os.environ[uenv.spack_loaded_hashes_var] = mpileaks_spec.dag_hash()
 

lib/spack/spack/test/cmd/location.py

@@ -37,8 +37,8 @@ def mock_spec():
 def test_location_first(install_mockery, mock_fetch, mock_archive, mock_packages):
     """Test with and without the --first option"""
     install = SpackCommand("install")
-    install("libelf@0.8.12")
-    install("libelf@0.8.13")
+    install("--fake", "libelf@0.8.12")
+    install("--fake", "libelf@0.8.13")
     # This would normally return an error without --first
     assert location("--first", "--install-dir", "libelf")