bootstrap: ensure compatible libc

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

.github/workflows/requirements/style/requirements.txt

@@ -1,7 +1,7 @@
 black==25.1.0
 clingo==5.7.1
 flake8==7.1.2
-isort==6.0.0
+isort==6.0.1
 mypy==1.15.0
-types-six==1.17.0.20241205
+types-six==1.17.0.20250304
 vermin==1.6.0

.gitignore

@@ -201,7 +201,6 @@ tramp
 
 # Org-mode
 .org-id-locations
-*_archive
 
 # flymake-mode
 *_flymake.*

etc/spack/defaults/config.yaml

@@ -19,7 +19,7 @@ config:
   install_tree:
     root: $spack/opt/spack
     projections:
-      all: "{architecture.platform}-{architecture.target}/{name}-{version}-{hash}"
+      all: "{architecture}/{compiler.name}-{compiler.version}/{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/concretizer.yaml

@@ -1,2 +0,0 @@
-concretizer:
-  static_analysis: true

etc/spack/defaults/darwin/packages.yaml

@@ -15,11 +15,12 @@
 # -------------------------------------------------------------------------
 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]
@@ -49,9 +50,3 @@ packages:
     # although the version number used here isn't critical
     - spec: apple-libuuid@1353.100.2
       prefix: /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk
-  c:
-    require: apple-clang
-  cxx:
-    require: apple-clang
-  fortran:
-    require: gcc

etc/spack/defaults/packages.yaml

@@ -15,18 +15,19 @@
 # -------------------------------------------------------------------------
 packages:
   all:
+    compiler: [gcc, clang, oneapi, xl, nag, fj, aocc]
     providers:
       awk: [gawk]
       armci: [armcimpi]
       blas: [openblas, amdblis]
-      c: [gcc, llvm, intel-oneapi-compilers, xl, aocc]
-      cxx: [gcc, llvm, intel-oneapi-compilers, xl, aocc]
+      c: [gcc]
+      cxx: [gcc]
       D: [ldc]
       daal: [intel-oneapi-daal]
       elf: [elfutils]
       fftw-api: [fftw, amdfftw]
       flame: [libflame, amdlibflame]
-      fortran: [gcc, llvm]
+      fortran: [gcc]
       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/docs/configuration.rst

@@ -14,6 +14,7 @@ case you want to skip directly to specific docs:
 * :ref:`compilers.yaml <compiler-config>`
 * :ref:`concretizer.yaml <concretizer-options>`
 * :ref:`config.yaml <config-yaml>`
+* :ref:`include.yaml <include-yaml>`
 * :ref:`mirrors.yaml <mirrors>`
 * :ref:`modules.yaml <modules>`
 * :ref:`packages.yaml <packages-config>`

lib/spack/docs/environments.rst

@@ -670,24 +670,45 @@ This configuration sets the default compiler for all packages to
 Included configurations
 ^^^^^^^^^^^^^^^^^^^^^^^
 
-Spack environments allow an ``include`` heading in their yaml
-schema. This heading pulls in external configuration files and applies
-them to the environment.
+Spack environments allow an ``include`` heading in their yaml schema.
+This heading pulls in external configuration files and applies them to
+the environment.
 
 .. code-block:: yaml
 
    spack:
      include:
-     - relative/path/to/config.yaml
+     - environment/relative/path/to/config.yaml
      - https://github.com/path/to/raw/config/compilers.yaml
      - /absolute/path/to/packages.yaml
+     - path: /path/to/$os/$target/environment
+       optional: true
+     - path: /path/to/os-specific/config-dir
+       when: os == "ventura"
+
+Included configuration files are required *unless* they are explicitly optional
+or the entry's condition evaluates to ``false``. Optional includes are specified
+with the ``optional`` clause and conditional with the ``when`` clause. (See
+:ref:`include-yaml` for more information on optional and conditional entries.)
+
+Files are listed using paths to individual files or directories containing them.
+Path entries may be absolute or relative to the environment or specified as 
+URLs. URLs to individual files need link to the **raw** form of the file's 
+contents (e.g., `GitHub
+<https://docs.github.com/en/repositories/working-with-files/using-files/viewing-and-understanding-files#viewing-or-copying-the-raw-file-content>`_ 
+or `GitLab
+<https://docs.gitlab.com/ee/api/repository_files.html#get-raw-file-from-repository>`_).
+Only the ``file``, ``ftp``, ``http`` and ``https`` protocols (or schemes) are
+supported. Spack-specific, environment and user path variables can be used.
+(See :ref:`config-file-variables` for more information.)
+
+.. warning::
+
+   Recursive includes are not currently processed in a breadth-first manner
+   so the value of a configuration option that is altered by multiple included
+   files may not be what you expect. This will be addressed in a future
+   update.
 
-Environments can include files or URLs. File paths can be relative or
-absolute. URLs include the path to the text for individual files or
-can be the path to a directory containing configuration files.
-Spack supports ``file``, ``http``, ``https`` and ``ftp`` protocols (or
-schemes). Spack-specific, environment and user path variables may be
-used in these paths. See :ref:`config-file-variables` for more information.
 
 ^^^^^^^^^^^^^^^^^^^^^^^^
 Configuration precedence

lib/spack/docs/include_yaml.rst

@@ -0,0 +1,51 @@
+.. Copyright Spack Project Developers. See COPYRIGHT file for details.
+
+   SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+.. _include-yaml:
+
+===============================
+Include Settings (include.yaml)
+===============================
+
+Spack allows you to include configuration files through ``include.yaml``.
+Using the ``include:`` heading results in pulling in external configuration
+information to be used by any Spack command.
+
+Included configuration files are required *unless* they are explicitly optional
+or the entry's condition evaluates to ``false``. Optional includes are specified
+with the ``optional`` clause and conditional with the ``when`` clause. For
+example,
+
+.. code-block:: yaml
+
+   include:
+   - /path/to/a/required/config.yaml
+   - path: /path/to/$os/$target/config
+     optional: true
+   - path: /path/to/os-specific/config-dir
+     when: os == "ventura"
+
+shows all three. The first entry, ``/path/to/a/required/config.yaml``,
+indicates that included ``config.yaml`` file is required (so must exist).
+Use of ``optional: true`` for ``/path/to/$os/$target/config`` means
+the path is only included if it exists. The condition ``os == "ventura"``
+in the ``when`` clause for ``/path/to/os-specific/config-dir`` means the
+path is only included when the operating system (``os``) is ``ventura``.
+
+The same conditions and variables in `Spec List References 
+<https://spack.readthedocs.io/en/latest/environments.html#spec-list-references>`_
+can be used for conditional activation in the ``when`` clauses.
+
+Included files can be specified by path or by their parent directory.
+Paths may be absolute, relative (to the configuration file including the path), 
+or specified as URLs. Only the ``file``, ``ftp``, ``http`` and ``https`` protocols (or
+schemes) are supported. Spack-specific, environment and user path variables
+can be used. (See :ref:`config-file-variables` for more information.)
+
+.. warning::
+
+   Recursive includes are not currently processed in a breadth-first manner
+   so the value of a configuration option that is altered by multiple included
+   files may not be what you expect. This will be addressed in a future
+   update.

lib/spack/docs/index.rst

@@ -71,6 +71,7 @@ or refer to the full manual below.
 
    configuration
    config_yaml
+   include_yaml
    packages_yaml
    build_settings
    environments

lib/spack/docs/pipelines.rst

@@ -330,7 +330,7 @@ that ``--tests`` is passed to ``spack ci rebuild`` as part of the
           - spack --version
           - cd ${SPACK_CONCRETE_ENV_DIR}
           - spack env activate --without-view .
-          - spack config add "config:install_tree:projections:${SPACK_JOB_SPEC_PKG_NAME}:'morepadding/{architecture.platform}-{architecture.target}/{name}-{version}-{hash}'"
+          - spack config add "config:install_tree:projections:${SPACK_JOB_SPEC_PKG_NAME}:'morepadding/{architecture}/{compiler.name}-{compiler.version}/{name}-{version}-{hash}'"
            - mkdir -p ${SPACK_ARTIFACTS_ROOT}/user_data
            - if [[ -r /mnt/key/intermediate_ci_signing_key.gpg ]]; then spack gpg trust /mnt/key/intermediate_ci_signing_key.gpg; fi
            - if [[ -r /mnt/key/spack_public_key.gpg ]]; then spack gpg trust /mnt/key/spack_public_key.gpg; fi

lib/spack/docs/requirements.txt

@@ -1,13 +1,13 @@
-sphinx==8.2.1
+sphinx==8.2.3
 sphinxcontrib-programoutput==0.18
 sphinx_design==0.6.1
 sphinx-rtd-theme==3.0.2
-python-levenshtein==0.26.1
+python-levenshtein==0.27.1
 docutils==0.21.2
 pygments==2.19.1
 urllib3==2.3.0
-pytest==8.3.4
-isort==6.0.0
+pytest==8.3.5
+isort==6.0.1
 black==25.1.0
 flake8==7.1.2
 mypy==1.11.1

lib/spack/env/aocc/clang

@@ -0,0 +1 @@
+../cc

lib/spack/env/aocc/clang++

@@ -0,0 +1 @@
+../cpp

lib/spack/env/aocc/flang

@@ -0,0 +1 @@
+../fc

lib/spack/env/arm/armclang

@@ -0,0 +1 @@
+../cc

lib/spack/env/arm/armclang++

@@ -0,0 +1 @@
+../cc

lib/spack/env/arm/armflang

@@ -0,0 +1 @@
+../cc

lib/spack/env/c++

@@ -0,0 +1 @@
+cc

lib/spack/env/c89

@@ -0,0 +1 @@
+cc

lib/spack/env/c99

@@ -0,0 +1 @@
+cc

lib/spack/env/case-insensitive/CC

@@ -0,0 +1 @@
+../cc

lib/spack/env/cc

@@ -39,6 +39,12 @@ 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
 SPACK_MANAGED_DIRS"
@@ -339,9 +345,6 @@ case "$command" in
         ;;
     ld|ld.gold|ld.lld)
         mode=ld
-        if [ -z "$SPACK_CC_RPATH_ARG" ]; then
-            comp="CXX"
-        fi
         ;;
     *)
         die "Unknown compiler: $command"
@@ -396,12 +399,10 @@ fi
 #
 dtags_to_add="${SPACK_DTAGS_TO_ADD}"
 dtags_to_strip="${SPACK_DTAGS_TO_STRIP}"
-
-linker_arg="ERROR: LINKER ARG WAS NOT SET, MAYBE THE PACKAGE DOES NOT DEPEND ON ${comp}?"
-eval "linker_arg=\${SPACK_${comp}_LINKER_ARG:?${linker_arg}}"
+linker_arg="${SPACK_LINKER_ARG}"
 
 # Set up rpath variable according to language.
-rpath="ERROR: RPATH ARG WAS NOT SET, MAYBE THE PACKAGE DOES NOT DEPEND ON ${comp}?"
+rpath="ERROR: RPATH ARG WAS NOT SET"
 eval "rpath=\${SPACK_${comp}_RPATH_ARG:?${rpath}}"
 
 # Dump the mode and exit if the command is dump-mode.
@@ -410,6 +411,13 @@ 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
@@ -779,17 +787,15 @@ 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/env/cce/case-insensitive/CC

@@ -0,0 +1 @@
+../../cc

lib/spack/env/cce/case-insensitive/crayCC

@@ -0,0 +1 @@
+../../cc

lib/spack/env/cce/cc

@@ -0,0 +1 @@
+../cc

lib/spack/env/cce/craycc

@@ -0,0 +1 @@
+../cc

lib/spack/env/cce/crayftn

@@ -0,0 +1 @@
+../cc

lib/spack/env/cce/ftn

@@ -0,0 +1 @@
+../cc

lib/spack/env/clang/clang

@@ -0,0 +1 @@
+../cc

lib/spack/env/clang/clang++

@@ -0,0 +1 @@
+../cc

lib/spack/env/clang/flang

@@ -0,0 +1 @@
+../cc

lib/spack/env/clang/gfortran

@@ -0,0 +1 @@
+../cc

lib/spack/env/cpp

@@ -0,0 +1 @@
+cc

lib/spack/env/f77

@@ -0,0 +1 @@
+cc

lib/spack/env/f90

@@ -0,0 +1 @@
+cc

lib/spack/env/f95

@@ -0,0 +1 @@
+cc

lib/spack/env/fc

@@ -0,0 +1 @@
+cc

lib/spack/env/fj/case-insensitive/FCC

@@ -0,0 +1 @@
+../../cc

lib/spack/env/fj/fcc

@@ -0,0 +1 @@
+../cc

lib/spack/env/fj/frt

@@ -0,0 +1 @@
+../cc

lib/spack/env/ftn

@@ -0,0 +1 @@
+cc

lib/spack/env/gcc/g++

@@ -0,0 +1 @@
+../cc

lib/spack/env/gcc/gcc

@@ -0,0 +1 @@
+../cc

lib/spack/env/gcc/gfortran

@@ -0,0 +1 @@
+../cc

lib/spack/env/intel/icc

@@ -0,0 +1 @@
+../cc

lib/spack/env/intel/icpc

@@ -0,0 +1 @@
+../cc

lib/spack/env/intel/ifort

@@ -0,0 +1 @@
+../cc

lib/spack/env/ld

@@ -0,0 +1 @@
+cc

lib/spack/env/ld.gold

@@ -0,0 +1 @@
+cc

lib/spack/env/ld.lld

@@ -0,0 +1 @@
+cc

lib/spack/env/nag/nagfor

@@ -0,0 +1 @@
+../cc

lib/spack/env/nvhpc/nvc

@@ -0,0 +1 @@
+../cc

lib/spack/env/nvhpc/nvc++

@@ -0,0 +1 @@
+../cc

lib/spack/env/nvhpc/nvfortran

@@ -0,0 +1 @@
+../cc

lib/spack/env/oneapi/dpcpp

@@ -0,0 +1 @@
+../cc

lib/spack/env/oneapi/icpx

@@ -0,0 +1 @@
+../cc

lib/spack/env/oneapi/icx

@@ -0,0 +1 @@
+../cc

lib/spack/env/oneapi/ifx

@@ -0,0 +1 @@
+../cc

lib/spack/env/pgi/pgc++

@@ -0,0 +1 @@
+../cc

lib/spack/env/pgi/pgcc

@@ -0,0 +1 @@
+../cc

lib/spack/env/pgi/pgfortran

@@ -0,0 +1 @@
+../cc

lib/spack/env/rocmcc/amdclang

@@ -0,0 +1 @@
+../cc

lib/spack/env/rocmcc/amdclang++

@@ -0,0 +1 @@
+../cpp

lib/spack/env/rocmcc/amdflang

@@ -0,0 +1 @@
+../fc

lib/spack/env/xl/xlc

@@ -0,0 +1 @@
+../cc

lib/spack/env/xl/xlc++

@@ -0,0 +1 @@
+../cc

lib/spack/env/xl/xlf

@@ -0,0 +1 @@
+../cc

lib/spack/env/xl/xlf90

@@ -0,0 +1 @@
+../cc

lib/spack/env/xl_r/xlc++_r

@@ -0,0 +1 @@
+../cc

lib/spack/env/xl_r/xlc_r

@@ -0,0 +1 @@
+../cc

lib/spack/env/xl_r/xlf90_r

@@ -0,0 +1 @@
+../cc

lib/spack/env/xl_r/xlf_r

@@ -0,0 +1 @@
+../cc

lib/spack/llnl/util/lang.py

@@ -11,6 +11,7 @@
 import re
 import sys
 import traceback
+import types
 import typing
 import warnings
 from datetime import datetime, timedelta
@@ -72,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, None) for p in funcs[0])
+        f = lambda x: tuple(getattr(x, p) for p in funcs[0])
 
     result = {}
     for o in objects:
@@ -707,14 +708,24 @@ def __init__(self, wrapped_object):
 
 
 class Singleton:
-    """Simple wrapper for lazily initialized singleton objects."""
+    """Wrapper for lazily initialized singleton objects."""
 
-    def __init__(self, factory):
+    def __init__(self, factory: Callable[[], object]):
         """Create a new singleton to be inited with the factory function.
 
+        Most factories will simply create the object to be initialized and
+        return it.
+
+        In some cases, e.g. when bootstrapping some global state, the singleton
+        may need to be initialized incrementally. If the factory returns a generator
+        instead of a regular object, the singleton will assign each result yielded by
+        the generator to the singleton instance. This allows methods called by
+        the factory in later stages to refer back to the singleton.
+
         Args:
-            factory (function): function taking no arguments that
-                creates the singleton instance.
+            factory (function): function taking no arguments that creates the
+                singleton instance.
+
         """
         self.factory = factory
         self._instance = None
@@ -722,7 +733,16 @@ def __init__(self, factory):
     @property
     def instance(self):
         if self._instance is None:
-            self._instance = self.factory()
+            instance = self.factory()
+
+            if isinstance(instance, types.GeneratorType):
+                # if it's a generator, assign every value
+                for value in instance:
+                    self._instance = value
+            else:
+                # if not, just assign the result like a normal singleton
+                self._instance = instance
+
         return self._instance
 
     def __getattr__(self, name):
@@ -996,8 +1016,11 @@ 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 = [
-            "\n\t{0} raised {1}: {2}\n{3}".format(
-                context, exc.__class__.__name__, exc, f"\n{''.join(tb)}" if with_tracebacks else ""
+            "{0} raised {1}: {2}{3}".format(
+                context,
+                exc.__class__.__name__,
+                exc,
+                "\n{0}".format("".join(tb)) if with_tracebacks else "",
             )
             for context, exc, tb in self.exceptions
         ]

lib/spack/spack/__init__.py

@@ -10,9 +10,21 @@
 import spack.util.git
 
 #: PEP440 canonical <major>.<minor>.<micro>.<devN> string
-__version__ = "1.0.0-alpha.4"
+__version__ = "1.0.0.dev0"
 spack_version = __version__
 
+#: The current Package API version implemented by this version of Spack. The Package API defines
+#: the Python interface for packages as well as the layout of package repositories. The minor
+#: version is incremented when the package API is extended in a backwards-compatible way. The major
+#: version is incremented upon breaking changes. This version is changed independently from the
+#: Spack version.
+package_api_version = (1, 0)
+
+#: The minimum Package API version that this version of Spack is compatible with. This should
+#: always be a tuple of the form ``(major, 0)``, since compatibility with vX.Y implies
+#: compatibility with vX.0.
+min_package_api_version = (1, 0)
+
 
 def __try_int(v):
     try:
@@ -79,4 +91,6 @@ def get_short_version() -> str:
     "get_version",
     "get_spack_commit",
     "get_short_version",
+    "package_api_version",
+    "min_package_api_version",
 ]

lib/spack/spack/binary_distribution.py

@@ -110,13 +110,6 @@ def __init__(self, root):
         self._write_transaction_impl = llnl.util.lang.nullcontext
         self._read_transaction_impl = llnl.util.lang.nullcontext
 
-    def _handle_old_db_versions_read(self, check, db, *, reindex: bool):
-        if not self.is_readable():
-            raise spack_db.DatabaseNotReadableError(
-                f"cannot read buildcache v{self.db_version} at {self.root}"
-            )
-        return self._handle_current_version_read(check, db)
-
 
 class FetchCacheError(Exception):
     """Error thrown when fetching the cache failed, usually a composite error list."""
@@ -249,7 +242,7 @@ def _associate_built_specs_with_mirror(self, cache_key, mirror_url):
                 self._index_file_cache.init_entry(cache_key)
                 cache_path = self._index_file_cache.cache_path(cache_key)
                 with self._index_file_cache.read_transaction(cache_key):
-                    db._read_from_file(pathlib.Path(cache_path))
+                    db._read_from_file(cache_path)
             except spack_db.InvalidDatabaseVersionError as e:
                 tty.warn(
                     f"you need a newer Spack version to read the buildcache index for the "
@@ -636,14 +629,7 @@ def tarball_directory_name(spec):
     Return name of the tarball directory according to the convention
     <os>-<architecture>/<compiler>/<package>-<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}")
+    return spec.format_path("{architecture}/{compiler.name}-{compiler.version}/{name}-{version}")
 
 
 def tarball_name(spec, ext):
@@ -651,17 +637,9 @@ def tarball_name(spec, ext):
     Return the name of the tarfile according to the convention
     <os>-<architecture>-<package>-<dag_hash><ext>
     """
-    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()}"
-        )
+    spec_formatted = spec.format_path(
+        "{architecture}-{compiler.name}-{compiler.version}-{name}-{version}-{hash}"
+    )
     return f"{spec_formatted}{ext}"
 
 

lib/spack/spack/bootstrap/_common.py

@@ -24,6 +24,7 @@
 import spack.store
 import spack.util.environment
 import spack.util.executable
+import spack.util.libc
 
 from .config import spec_for_current_python
 
@@ -233,14 +234,21 @@ def _root_spec(spec_str: str) -> str:
     """
     # Add a compiler and platform requirement to the root spec.
     platform = str(spack.platforms.host())
-
-    if platform == "windows":
-        spec_str += " %msvc"
-    elif platform == "freebsd":
-        spec_str += " %clang"
     spec_str += f" platform={platform}"
     target = archspec.cpu.host().family
     spec_str += f" target={target}"
 
+    if platform == "darwin":
+        spec_str += " %apple-clang"
+    elif platform == "windows":
+        spec_str += " %msvc"
+    elif platform == "linux":
+        spec_str += " %gcc"
+        libc = spack.util.libc.libc_from_current_python_process()
+        if libc:
+            spec_str += f" ^[virtuals=libc] {libc.name}@:{libc.version}"
+    elif platform == "freebsd":
+        spec_str += " %clang"
+
     tty.debug(f"[BOOTSTRAP ROOT SPEC] {spec_str}")
     return spec_str

lib/spack/spack/bootstrap/clingo.py

@@ -15,13 +15,11 @@
 
 import archspec.cpu
 
-import spack.compilers.config
-import spack.compilers.libraries
-import spack.config
+import spack.compiler
+import spack.compilers
 import spack.platforms
 import spack.spec
 import spack.traverse
-import spack.version
 
 from .config import spec_for_current_python
 
@@ -40,7 +38,7 @@ def __init__(self, configuration):
 
         self.external_cmake, self.external_bison = self._externals_from_yaml(configuration)
 
-    def _valid_compiler_or_raise(self):
+    def _valid_compiler_or_raise(self) -> "spack.compiler.Compiler":
         if str(self.host_platform) == "linux":
             compiler_name = "gcc"
         elif str(self.host_platform) == "darwin":
@@ -48,30 +46,17 @@ def _valid_compiler_or_raise(self):
         elif str(self.host_platform) == "windows":
             compiler_name = "msvc"
         elif str(self.host_platform) == "freebsd":
-            compiler_name = "llvm"
+            compiler_name = "clang"
         else:
             raise RuntimeError(f"Cannot bootstrap clingo from sources on {self.host_platform}")
-
-        candidates = [
-            x
-            for x in spack.compilers.config.CompilerFactory.from_packages_yaml(spack.config.CONFIG)
-            if x.name == compiler_name
-        ]
+        candidates = spack.compilers.compilers_for_spec(
+            compiler_name, arch_spec=self.host_architecture
+        )
         if not candidates:
             raise RuntimeError(
                 f"Cannot find any version of {compiler_name} to bootstrap clingo from sources"
             )
-        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
+        candidates.sort(key=lambda x: x.spec.version, reverse=True)
         return candidates[0]
 
     def _externals_from_yaml(
@@ -90,6 +75,9 @@ 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
 
@@ -122,14 +110,11 @@ 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.versions
-
-        # Can't use re2c@3.1 with Python 3.6
-        if self.host_python.satisfies("@3.6"):
-            s["re2c"].versions.versions = [spack.version.from_string("=2.2")]
+                node.versions = self.host_compiler.spec.versions
 
         for edge in spack.traverse.traverse_edges([s], cover="edges"):
             if edge.spec.name == "python":
@@ -141,9 +126,6 @@ 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
 
@@ -159,12 +141,12 @@ def python_external_spec(self) -> "spack.spec.Spec":
         return self._external_spec(result)
 
     def libc_external_spec(self) -> "spack.spec.Spec":
-        detector = spack.compilers.libraries.CompilerPropertyDetector(self.host_compiler)
-        result = detector.default_libc()
+        result = self.host_compiler.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

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

lib/spack/spack/build_environment.py

@@ -36,6 +36,7 @@
 import multiprocessing
 import os
 import re
+import stat
 import sys
 import traceback
 import types
@@ -70,7 +71,7 @@
 import spack.build_systems.meson
 import spack.build_systems.python
 import spack.builder
-import spack.compilers.libraries
+import spack.compilers
 import spack.config
 import spack.deptypes as dt
 import spack.error
@@ -84,6 +85,7 @@
 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
@@ -91,8 +93,6 @@
 from spack.util.environment import (
     SYSTEM_DIR_CASE_ENTRY,
     EnvironmentModifications,
-    ModificationList,
-    PrependPath,
     env_flag,
     filter_system_paths,
     get_path,
@@ -390,10 +390,62 @@ def _add_werror_handling(keep_werror, env):
     env.set("SPACK_COMPILER_FLAGS_REPLACE", " ".join(["|".join(item) for item in replace_flags]))
 
 
-def set_wrapper_environment_variables_for_flags(pkg, env):
+def set_compiler_environment_variables(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:
@@ -401,6 +453,10 @@ def set_wrapper_environment_variables_for_flags(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 = {}
@@ -433,23 +489,75 @@ def set_wrapper_environment_variables_for_flags(pkg, env):
             # implicit variables
             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)
+
     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.
-    version_number, _ = archspec.cpu.version_components(compiler.version.dotted_numeric_string)
+    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))
+
     try:
-        result = target.optimization_flags(compiler.name, version_number)
+        result = target.optimization_flags(compiler.name, compiler_version.dotted_numeric_string)
     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.
@@ -458,8 +566,39 @@ 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 compiler flags injected from the spec
-    set_wrapper_environment_variables_for_flags(pkg, env)
+    # 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)
 
     # Working directory for the spack command itself, for debug logs.
     if spack.config.get("config:debug"):
@@ -525,15 +664,22 @@ 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)
 
-    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)
+    # 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))
 
     # 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).
@@ -585,6 +731,26 @@ def set_package_py_globals(pkg, context: Context = Context.BUILD):
     # Don't use which for this; we want to find it in the current dir.
     module.configure = Executable("./configure")
 
+    # 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
+
     # Useful directories within the prefix are encapsulated in
     # a Prefix object.
     module.prefix = pkg.prefix
@@ -750,6 +916,7 @@ 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
@@ -761,24 +928,6 @@ 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")
-    env_by_name = env_mods.group_by_name()
-    for x in env_by_name["SPACK_ENV_PATH"]:
-        assert isinstance(x, PrependPath), "unexpected setting used for SPACK_ENV_PATH"
-        env_mods.prepend_path("PATH", x.value)
-
-    # Check whether we want to force RPATH or RUNPATH
-    enable_var_name, disable_var_name = "SPACK_ENABLE_NEW_DTAGS", "SPACK_DISABLE_NEW_DTAGS"
-    if enable_var_name in env_by_name and disable_var_name in env_by_name:
-        enable_new_dtags = _extract_dtags_arg(env_by_name, var_name=enable_var_name)
-        disable_new_dtags = _extract_dtags_arg(env_by_name, var_name=disable_var_name)
-        if spack.config.CONFIG.get("config:shared_linking:type") == "rpath":
-            env_mods.set("SPACK_DTAGS_TO_STRIP", enable_new_dtags)
-            env_mods.set("SPACK_DTAGS_TO_ADD", disable_new_dtags)
-        else:
-            env_mods.set("SPACK_DTAGS_TO_STRIP", disable_new_dtags)
-            env_mods.set("SPACK_DTAGS_TO_ADD", enable_new_dtags)
-
     if context == Context.TEST:
         env_mods.prepend_path("PATH", ".")
     elif context == Context.BUILD and not dirty and not env_mods.is_unset("CPATH"):
@@ -792,6 +941,11 @@ 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.
@@ -803,14 +957,6 @@ def setup_package(pkg, dirty, context: Context = Context.BUILD):
     return env_base
 
 
-def _extract_dtags_arg(env_by_name: Dict[str, ModificationList], *, var_name: str) -> str:
-    try:
-        enable_new_dtags = env_by_name[var_name][0].value  # type: ignore[union-attr]
-    except (KeyError, IndexError, AttributeError):
-        enable_new_dtags = ""
-    return enable_new_dtags
-
-
 class EnvironmentVisitor:
     def __init__(self, *roots: spack.spec.Spec, context: Context):
         # For the roots (well, marked specs) we follow different edges

lib/spack/spack/build_systems/autotools.py

@@ -11,7 +11,6 @@
 
 import spack.build_environment
 import spack.builder
-import spack.compilers.libraries
 import spack.error
 import spack.package_base
 import spack.phase_callbacks
@@ -399,44 +398,33 @@ def _do_patch_libtool(self) -> None:
             markers[tag] = "LIBTOOL TAG CONFIG: {0}".format(tag.upper())
 
         # Replace empty linker flag prefixes:
-        if self.spec.satisfies("%nag"):
+        if self.pkg.compiler.name == "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=f'wl="{nag_pkg.linker_arg}"',
-                    start_at=f"# ### BEGIN {marker}",
-                    stop_at=f"# ### END {marker}",
+                    repl='wl="{0}"'.format(self.pkg.compiler.linker_arg),
+                    start_at="# ### BEGIN {0}".format(marker),
+                    stop_at="# ### END {0}".format(marker),
                 )
         else:
-            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))
+            x.filter(regex='^wl=""$', repl='wl="{0}"'.format(self.pkg.compiler.linker_arg))
 
         # Replace empty PIC flag values:
-        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
-
+        for cc, marker in markers.items():
             x.filter(
                 regex='^pic_flag=""$',
-                repl=f'pic_flag="{self.spec[language].package.pic_flag}"',
-                start_at=f"# ### BEGIN {marker}",
-                stop_at=f"# ### END {marker}",
+                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),
             )
 
         # Other compiler-specific patches:
-        if self.spec.satisfies("%fj"):
+        if self.pkg.compiler.name == "fj":
             x.filter(regex="-nostdlib", repl="", string=True)
             rehead = r"/\S*/"
             for o in [
@@ -449,7 +437,7 @@ def _do_patch_libtool(self) -> None:
                 r"crtendS\.o",
             ]:
                 x.filter(regex=(rehead + o), repl="")
-        elif self.spec.satisfies("%nag"):
+        elif self.pkg.compiler.name == "nag":
             for tag in ["fc", "f77"]:
                 marker = markers[tag]
                 start_at = "# ### BEGIN {0}".format(marker)

lib/spack/spack/build_systems/cached_cmake.py

@@ -70,8 +70,12 @@ class CachedCMakeBuilder(CMakeBuilder):
 
     @property
     def cache_name(self):
-        compiler_str = f"{self.spec['c'].name}-{self.spec['c'].version}"
-        return f"{self.pkg.name}-{self.spec.architecture.platform}-{compiler_str}.cmake"
+        return "{0}-{1}-{2}@{3}.cmake".format(
+            self.pkg.name,
+            self.pkg.spec.architecture,
+            self.pkg.spec.compiler.name,
+            self.pkg.spec.compiler.version,
+        )
 
     @property
     def cache_path(self):
@@ -114,9 +118,7 @@ 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.spec["fortran"].package.fortran
-            )
+            system_fc_entry = cmake_cache_path("CMAKE_Fortran_COMPILER", self.pkg.compiler.fc)
         else:
             spack_fc_entry = "# No Fortran compiler defined in spec"
             system_fc_entry = "# No Fortran compiler defined in spec"
@@ -132,8 +134,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.spec["c"].package.cc),
-            "  " + cmake_cache_path("CMAKE_CXX_COMPILER", self.spec["cxx"].package.cxx),
+            "  " + cmake_cache_path("CMAKE_C_COMPILER", self.pkg.compiler.cc),
+            "  " + cmake_cache_path("CMAKE_CXX_COMPILER", self.pkg.compiler.cxx),
             "  " + system_fc_entry,
             "endif()\n",
         ]

lib/spack/spack/build_systems/compiler.py

@@ -6,13 +6,12 @@
 import pathlib
 import re
 import sys
-from typing import Dict, List, Optional, Sequence, Tuple, Union
+from typing import Dict, List, Sequence, Tuple, Union
 
 import llnl.util.tty as tty
-from llnl.util.lang import classproperty, memoized
+from llnl.util.lang import classproperty
 
-import spack
-import spack.compilers.error
+import spack.compiler
 import spack.package_base
 import spack.util.executable
 
@@ -44,9 +43,6 @@ 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"
@@ -81,14 +77,14 @@ def executables(cls) -> Sequence[str]:
         ]
 
     @classmethod
-    def determine_version(cls, exe: Path) -> str:
+    def determine_version(cls, exe: Path):
         version_argument = cls.compiler_version_argument
         if isinstance(version_argument, str):
             version_argument = (version_argument,)
 
         for va in version_argument:
             try:
-                output = compiler_output(exe, version_argument=va)
+                output = spack.compiler.get_compiler_version_output(exe, va)
                 match = re.search(cls.compiler_version_regex, output)
                 if match:
                     return ".".join(match.groups())
@@ -99,11 +95,10 @@ def determine_version(cls, exe: Path) -> str:
                     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:
-        """Overridable method for the location of the compiler bindir within the prefix"""
+        """Overridable method for the location of the compiler bindir within the preifx"""
         return os.path.join(prefix, "bin")
 
     @classmethod
@@ -147,109 +142,3 @@ 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"
-
-    required_libs: List[str] = []
-
-    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")
-
-    def archspec_name(self) -> str:
-        """Name that archspec uses to refer to this compiler"""
-        return self.spec.name
-
-    @property
-    def cc(self) -> Optional[str]:
-        assert self.spec.concrete, "cannot retrieve C compiler, spec is not concrete"
-        if self.spec.external:
-            return self.spec.extra_attributes["compilers"].get("c", None)
-        return self._cc_path()
-
-    def _cc_path(self) -> Optional[str]:
-        """Returns the path to the C compiler, if the package was installed by Spack"""
-        return None
-
-    @property
-    def cxx(self) -> Optional[str]:
-        assert self.spec.concrete, "cannot retrieve C++ compiler, spec is not concrete"
-        if self.spec.external:
-            return self.spec.extra_attributes["compilers"].get("cxx", None)
-        return self._cxx_path()
-
-    def _cxx_path(self) -> Optional[str]:
-        """Returns the path to the C++ compiler, if the package was installed by Spack"""
-        return None
-
-    @property
-    def fortran(self):
-        assert self.spec.concrete, "cannot retrieve Fortran compiler, spec is not concrete"
-        if self.spec.external:
-            return self.spec.extra_attributes["compilers"].get("fortran", None)
-        return self._fortran_path()
-
-    def _fortran_path(self) -> Optional[str]:
-        """Returns the path to the Fortran compiler, if the package was installed by Spack"""
-        return None
-
-
-@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)
-    if not version_argument:
-        return compiler(
-            output=str, error=str, ignore_errors=ignore_errors, timeout=120, fail_on_error=True
-        )
-    return compiler(
-        version_argument,
-        output=str,
-        error=str,
-        ignore_errors=ignore_errors,
-        timeout=120,
-        fail_on_error=True,
-    )
-
-
-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(str(compiler_path), required=True)
-
-    return _compiler_output(
-        compiler_path, version_argument=version_argument, ignore_errors=ignore_errors
-    )

lib/spack/spack/build_systems/msbuild.py

@@ -76,7 +76,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.spec["msvc"].package.platform_toolset_ver
+        return "v" + self.pkg.compiler.platform_toolset_ver
 
     @property
     def std_msbuild_args(self):

lib/spack/spack/build_systems/python.py

@@ -278,6 +278,10 @@ 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/__init__.py

@@ -24,6 +24,7 @@
 import spack
 import spack.binary_distribution as bindist
 import spack.builder
+import spack.concretize
 import spack.config as cfg
 import spack.environment as ev
 import spack.error
@@ -379,9 +380,10 @@ def generate_pipeline(env: ev.Environment, args) -> None:
         args: (spack.main.SpackArgumentParser): Parsed arguments from the command
             line.
     """
-    with env.write_transaction():
-        env.concretize()
-        env.write()
+    with spack.concretize.disable_compiler_existence_check():
+        with env.write_transaction():
+            env.concretize()
+            env.write()
 
     options = collect_pipeline_options(env, args)
 

lib/spack/spack/ci/common.py

@@ -209,8 +209,10 @@ def build_name(self, spec: Optional[spack.spec.Spec] = None) -> Optional[str]:
 
         Returns: (str) given spec's CDash build name."""
         if spec:
-            spec_str = spec.format("{name}{@version}{%compiler} hash={hash} arch={architecture}")
-            build_name = f"{spec_str} ({self.build_group})"
+            build_name = (
+                f"{spec.name}@{spec.version}%{spec.compiler} "
+                f"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

@@ -375,13 +375,8 @@ 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, key=_key)):
+    for i, (architecture, compiler) in enumerate(sorted(index)):
         if i > 0:
             print()
 
@@ -453,6 +448,7 @@ 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)
@@ -474,7 +470,10 @@ def get_arg(name, default=None):
     if format_string is None:
         nfmt = "{fullname}" if namespaces else "{name}"
         ffmt = ""
-        if flags:
+        if full_compiler or flags:
+            ffmt += "{%compiler.name}"
+            if full_compiler:
+                ffmt += "{@compiler.version}"
             ffmt += " {compiler_flags}"
         vfmt = "{variants}" if variants else ""
         format_string = nfmt + "{@version}" + ffmt + vfmt

lib/spack/spack/cmd/compiler.py

@@ -4,14 +4,13 @@
 
 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.config
+import spack.compilers
 import spack.config
 import spack.spec
 from spack.cmd.common import arguments
@@ -34,20 +33,20 @@ def setup_parser(subparser):
     mixed_toolchain_group.add_argument(
         "--mixed-toolchain",
         action="store_true",
-        default=False,
-        help="(DEPRECATED) Allow mixed toolchains (for example: clang, clang++, gfortran)",
+        default=sys.platform == "darwin",
+        help="Allow mixed toolchains (for example: clang, clang++, gfortran)",
     )
     mixed_toolchain_group.add_argument(
         "--no-mixed-toolchain",
         action="store_false",
         dest="mixed_toolchain",
-        help="(DEPRECATED) Do not allow mixed toolchains (for example: clang, clang++, gfortran)",
+        help="Do not allow mixed toolchains (for example: clang, clang++, gfortran)",
     )
     find_parser.add_argument("add_paths", nargs=argparse.REMAINDER)
     find_parser.add_argument(
         "--scope",
         action=arguments.ConfigScope,
-        default=lambda: spack.config.default_modify_scope("packages"),
+        default=lambda: spack.config.default_modify_scope("compilers"),
         help="configuration scope to modify",
     )
     arguments.add_common_arguments(find_parser, ["jobs"])
@@ -80,97 +79,77 @@ 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 v1.1"
-        )
-
     paths = args.add_paths or None
-    new_compilers = spack.compilers.config.find_compilers(
-        path_hints=paths, scope=args.scope, max_workers=args.jobs
+    new_compilers = spack.compilers.find_compilers(
+        path_hints=paths,
+        scope=args.scope,
+        mixed_toolchain=args.mixed_toolchain,
+        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, "packages")
+        filename = spack.config.CONFIG.get_config_filename(args.scope, "compilers")
         tty.msg(f"Added {n:d} new compiler{s} to {filename}")
-        compiler_strs = sorted(f"{spec.name}@{spec.versions}" for spec in new_compilers)
+        compiler_strs = sorted(f"{c.spec.name}@{c.spec.version}" for c 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.config.compiler_config_files(), indent=4)
+    colify(spack.compilers.compiler_config_files(), indent=4)
 
 
 def compiler_remove(args):
-    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}'")
+    compiler_spec = spack.spec.CompilerSpec(args.compiler_spec)
+    candidate_compilers = spack.compilers.compilers_for_spec(compiler_spec, scope=args.scope)
 
-    compiler_strs = reversed(sorted(f"{spec.name}@{spec.versions}" for spec in candidates))
+    if not candidate_compilers:
+        tty.die("No compilers match spec %s" % compiler_spec)
 
-    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."
-        )
+    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.")
         sys.exit(1)
 
-    remover.flush()
-    tty.msg("The following compilers have been removed:")
-    print()
-    colify(compiler_strs, indent=4)
-    print()
+    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")
 
 
 def compiler_info(args):
     """Print info about all compilers matching a spec."""
-    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)]
+    cspec = spack.spec.CompilerSpec(args.compiler_spec)
+    compilers = spack.compilers.compilers_for_spec(cspec, scope=args.scope)
 
     if not compilers:
-        tty.die(f"No compilers match spec {query.cformat()}")
+        tty.die("No compilers match spec %s" % cspec)
     else:
         for c in compilers:
-            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}")
-            if "environment" in extra_attributes:
-                environment = extra_attributes["environment"]
-                if len(environment.get("set", {})) != 0:
+            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 environment["set"].items():
-                        print(f"\t        {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()
+                    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)
 
 
 def compiler_list(args):
-    compilers = spack.compilers.config.all_compilers(scope=args.scope, init_config=False)
+    compilers = spack.compilers.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.
@@ -183,7 +162,7 @@ def compiler_list(args):
         tty.msg(msg)
         return
 
-    index = index_by(compilers, spack.compilers.config.name_os_target)
+    index = index_by(compilers, lambda c: (c.spec.name, c.operating_system, c.target))
 
     tty.msg("Available compilers")
 
@@ -202,10 +181,10 @@ def compiler_list(args):
         name, os, target = key
         os_str = os
         if target:
-            os_str += f"-{target}"
-        cname = f"{spack.spec.COMPILER_COLOR}{{{name}}} {os_str}"
+            os_str += "-%s" % target
+        cname = "%s{%s} %s" % (spack.spec.COMPILER_COLOR, name, os_str)
         tty.hline(colorize(cname), char="-")
-        colify(reversed(sorted(c.format("{name}@{version}") for c in compilers)))
+        colify(reversed(sorted(c.spec.display_str for c in compilers)))
 
 
 def compiler(parser, args):

lib/spack/spack/cmd/config.py

@@ -350,9 +350,12 @@ def _config_change(config_path, match_spec_str=None):
                 if spack.config.get(key_path, scope=scope):
                     ideal_scope_to_modify = scope
                     break
+            # If we find our key in a specific scope, that's the one we want
+            # to modify. Otherwise we use the default write scope.
+            write_scope = ideal_scope_to_modify or spack.config.default_modify_scope()
 
             update_path = f"{key_path}:[{str(spec)}]"
-            spack.config.add(update_path, scope=ideal_scope_to_modify)
+            spack.config.add(update_path, scope=write_scope)
     else:
         raise ValueError("'config change' can currently only change 'require' sections")
 
@@ -518,6 +521,8 @@ 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.
@@ -527,6 +532,10 @@ 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

@@ -98,7 +98,7 @@ def setup_parser(subparser):
         "--show-full-compiler",
         action="store_true",
         dest="show_full_compiler",
-        help="(DEPRECATED) show full compiler specs. Currently it's a no-op",
+        help="show full compiler specs",
     )
     implicit_explicit = subparser.add_mutually_exclusive_group()
     implicit_explicit.add_argument(
@@ -278,6 +278,7 @@ 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,
         )
@@ -300,6 +301,7 @@ 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/license.py

@@ -38,6 +38,7 @@
     r"^lib/spack/spack/.*\.sh$",
     r"^lib/spack/spack/.*\.lp$",
     r"^lib/spack/llnl/.*\.py$",
+    r"^lib/spack/env/cc$",
     # special case some test data files that have license headers
     r"^lib/spack/spack/test/data/style/broken.dummy",
     r"^lib/spack/spack/test/data/unparse/.*\.txt",