ginkgo: revert mpi@3.1 dependency:

Currently this breaks builds with OpenMPI - as spack is resolving this to 'openmpi@1.7.4'
2024-09-09 14:26:26 -05:00
731 changed files with 5378 additions and 9913 deletions
--- a/.devcontainer/ubuntu20.04/devcontainer.json
+++ b/.devcontainer/ubuntu20.04/devcontainer.json
@@ -1,5 +1,4 @@
 {
-  "name": "Ubuntu 20.04",
  "image": "ghcr.io/spack/ubuntu20.04-runner-amd64-gcc-11.4:2023.08.01",
  "postCreateCommand": "./.devcontainer/postCreateCommand.sh"
 }
--- a/.devcontainer/ubuntu22.04/devcontainer.json
+++ b/.devcontainer/ubuntu22.04/devcontainer.json
@@ -1,5 +0,0 @@
-{
-  "name": "Ubuntu 22.04",
-  "image": "ghcr.io/spack/ubuntu-22.04:v2024-05-07",
-  "postCreateCommand": "./.devcontainer/postCreateCommand.sh"
-}
--- a/.github/workflows/audit.yaml
+++ b/.github/workflows/audit.yaml
@@ -28,7 +28,7 @@ jobs:
      run:
        shell: ${{ matrix.system.shell }}
    steps:
-    - uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938
+    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
    - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3
      with:
        python-version: ${{inputs.python_version}}
@@ -40,8 +40,6 @@ jobs:
      run: |
        python -m pip install --upgrade pywin32
    - name: Package audits (with coverage)
-      env:
-          COVERAGE_FILE: coverage/.coverage-audits-${{ matrix.system.os }}
      if: ${{ inputs.with_coverage == 'true' && runner.os != 'Windows' }}
      run: |
          . share/spack/setup-env.sh
@@ -49,26 +47,27 @@ jobs:
          coverage run $(which spack) audit configs
          coverage run $(which spack) -d audit externals
          coverage combine
+          coverage xml
    - name: Package audits (without coverage)
      if: ${{ inputs.with_coverage == 'false' && runner.os != 'Windows' }}
      run: |
-          . share/spack/setup-env.sh
+          . share/spack/setup-env.sh          
          spack -d audit packages
          spack -d audit configs
          spack -d audit externals
    - name: Package audits (without coverage)
      if: ${{ runner.os == 'Windows' }}
      run: |
-          . share/spack/setup-env.sh
+          . share/spack/setup-env.sh          
          spack -d audit packages
          ./share/spack/qa/validate_last_exit.ps1
          spack -d audit configs
          ./share/spack/qa/validate_last_exit.ps1
          spack -d audit externals
          ./share/spack/qa/validate_last_exit.ps1
-    - uses: actions/upload-artifact@50769540e7f4bd5e21e526ee35c689e35e0d6874
-      if: ${{ inputs.with_coverage == 'true' && runner.os != 'Windows' }}
+    - uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673
+      if: ${{ inputs.with_coverage == 'true' }}
      with:
-        name: coverage-audits-${{ matrix.system.os }}
-        path: coverage
-        include-hidden-files: true
+        flags: unittests,audits
+        token: ${{ secrets.CODECOV_TOKEN }}
+        verbose: true
--- a/.github/workflows/bootstrap.yml
+++ b/.github/workflows/bootstrap.yml
@@ -37,7 +37,7 @@ jobs:
              make patch unzip which xz python3 python3-devel tree \
              cmake bison
      - name: Checkout
-        uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938
+        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
        with:
          fetch-depth: 0
      - name: Bootstrap clingo
@@ -60,7 +60,7 @@ jobs:
        run: |
          brew install cmake bison tree
      - name: Checkout
-        uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938
+        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
        with:
          fetch-depth: 0
      - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3
@@ -96,7 +96,7 @@ jobs:
        if: ${{ matrix.runner == 'ubuntu-latest' }}
        run: sudo rm -rf $(command -v gpg gpg2 patchelf)
      - name: Checkout
-        uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938
+        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
        with:
          fetch-depth: 0
      - name: Bootstrap GnuPG
@@ -130,7 +130,7 @@ jobs:
          Remove-Item -Path (Get-Command gpg).Path
          Remove-Item -Path (Get-Command file).Path
      - name: Checkout
-        uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938
+        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
        with:
          fetch-depth: 0
      - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3
--- a/.github/workflows/build-containers.yml
+++ b/.github/workflows/build-containers.yml
@@ -55,7 +55,7 @@ jobs:
    if: github.repository == 'spack/spack'
    steps:
      - name: Checkout
-        uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938
+        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332

      - uses: docker/metadata-action@8e5442c4ef9f78752691e2d8f8d19755c6f78e81
        id: docker_meta
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -36,7 +36,7 @@ jobs:
      core: ${{ steps.filter.outputs.core }}
      packages: ${{ steps.filter.outputs.packages }}
    steps:
-      - uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938
+      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
        if: ${{ github.event_name == 'push' }}
        with:
          fetch-depth: 0
@@ -84,30 +84,8 @@ jobs:
    needs: [ prechecks, changes ]
    uses: ./.github/workflows/unit_tests.yaml
    secrets: inherit
-  upload-coverage:
-    needs: [ unit-tests, prechecks ]
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938
-      with:
-        fetch-depth: 0
-    - name: Download coverage files
-      uses: actions/download-artifact@fa0a91b85d4f404e444e00e005971372dc801d16
-      with:
-        pattern: coverage-*
-        path: coverage
-        merge-multiple: true
-    - run: pip install --upgrade coverage
-    - run: ls -la coverage
-    - run: coverage combine -a coverage/.coverage*
-    - run: coverage xml
-    - name: "Upload coverage"
-      uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673
-      with:
-        token: ${{ secrets.CODECOV_TOKEN }}
-        verbose: true
  all:
-    needs: [ upload-coverage, bootstrap ]
+    needs: [ unit-tests, bootstrap ]
    runs-on: ubuntu-latest
    steps:
    - name: Success
--- a/.github/workflows/nightly-win-builds.yml
+++ b/.github/workflows/nightly-win-builds.yml
@@ -14,7 +14,7 @@ jobs:
  build-paraview-deps:
    runs-on: windows-latest
    steps:
-    - uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938
+    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
      with:
        fetch-depth: 0
    - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3
--- a/.github/workflows/unit_tests.yaml
+++ b/.github/workflows/unit_tests.yaml
@@ -40,7 +40,7 @@ jobs:
          on_develop: false

    steps:
-    - uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938
+    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
      with:
        fetch-depth: 0
    - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3
@@ -76,20 +76,19 @@ jobs:
          SPACK_PYTHON: python
          SPACK_TEST_PARALLEL: 2
          COVERAGE: true
-          COVERAGE_FILE: coverage/.coverage-${{ matrix.os }}-python${{ matrix.python-version }}
          UNIT_TEST_COVERAGE: ${{ matrix.python-version == '3.11' }}
      run: |
          share/spack/qa/run-unit-tests
-    - uses: actions/upload-artifact@50769540e7f4bd5e21e526ee35c689e35e0d6874
+    - uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673
      with:
-        name: coverage-${{ matrix.os }}-python${{ matrix.python-version }}
-        path: coverage
-        include-hidden-files: true
+        flags: unittests,linux,${{ matrix.concretizer }}
+        token: ${{ secrets.CODECOV_TOKEN }}
+        verbose: true
  # Test shell integration
  shell:
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938
+    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
      with:
        fetch-depth: 0
    - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3
@@ -113,11 +112,11 @@ jobs:
          COVERAGE: true
      run: |
          share/spack/qa/run-shell-tests
-    - uses: actions/upload-artifact@50769540e7f4bd5e21e526ee35c689e35e0d6874
+    - uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673
      with:
-        name: coverage-shell
-        path: coverage
-        include-hidden-files: true
+        flags: shelltests,linux
+        token: ${{ secrets.CODECOV_TOKEN }}
+        verbose: true

  # Test RHEL8 UBI with platform Python. This job is run
  # only on PRs modifying core Spack
@@ -130,7 +129,7 @@ jobs:
          dnf install -y \
              bzip2 curl file gcc-c++ gcc gcc-gfortran git gnupg2 gzip \
              make patch tcl unzip which xz
-    - uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938
+    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
    - name: Setup repo and non-root user
      run: |
          git --version
@@ -149,7 +148,7 @@ jobs:
  clingo-cffi:
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938
+    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
      with:
        fetch-depth: 0
    - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3
@@ -171,14 +170,13 @@ jobs:
    - name: Run unit tests (full suite with coverage)
      env:
          COVERAGE: true
-          COVERAGE_FILE: coverage/.coverage-clingo-cffi
      run: |
          share/spack/qa/run-unit-tests
-    - uses: actions/upload-artifact@50769540e7f4bd5e21e526ee35c689e35e0d6874
+    - uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673
      with:
-        name: coverage-clingo-cffi
-        path: coverage
-        include-hidden-files: true
+        flags: unittests,linux,clingo
+        token: ${{ secrets.CODECOV_TOKEN }}
+        verbose: true
  # Run unit tests on MacOS
  macos:
    runs-on: ${{ matrix.os }}
@@ -187,7 +185,7 @@ jobs:
        os: [macos-13, macos-14]
        python-version: ["3.11"]
    steps:
-    - uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938
+    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
      with:
        fetch-depth: 0
    - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3
@@ -203,7 +201,6 @@ jobs:
    - name: Run unit tests
      env:
        SPACK_TEST_PARALLEL: 4
-        COVERAGE_FILE: coverage/.coverage-${{ matrix.os }}-python${{ matrix.python-version }}
      run: |
        git --version
        . .github/workflows/bin/setup_git.sh
@@ -212,11 +209,11 @@ jobs:
        $(which spack) solve zlib
        common_args=(--dist loadfile --tx '4*popen//python=./bin/spack-tmpconfig python -u ./bin/spack python' -x)
        $(which spack) unit-test --verbose --cov --cov-config=pyproject.toml --cov-report=xml:coverage.xml "${common_args[@]}"
-    - uses: actions/upload-artifact@50769540e7f4bd5e21e526ee35c689e35e0d6874
+    - uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673
      with:
-        name: coverage-${{ matrix.os }}-python${{ matrix.python-version }}
-        path: coverage
-        include-hidden-files: true
+        flags: unittests,macos
+        token: ${{ secrets.CODECOV_TOKEN }}
+        verbose: true
  # Run unit tests on Windows
  windows:
    defaults:
@@ -225,7 +222,7 @@ jobs:
          powershell Invoke-Expression -Command "./share/spack/qa/windows_test_setup.ps1"; {0}
    runs-on: windows-latest
    steps:
-    - uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938
+    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
      with:
        fetch-depth: 0
    - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3
@@ -238,13 +235,13 @@ jobs:
      run: |
        ./.github/workflows/bin/setup_git.ps1
    - name: Unit Test
-      env:
-        COVERAGE_FILE: coverage/.coverage-windows
      run: |
        spack unit-test -x --verbose --cov --cov-config=pyproject.toml
        ./share/spack/qa/validate_last_exit.ps1
-    - uses: actions/upload-artifact@50769540e7f4bd5e21e526ee35c689e35e0d6874
+        coverage combine -a
+        coverage xml
+    - uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673
      with:
-        name: coverage-windows
-        path: coverage
-        include-hidden-files: true
+        flags: unittests,windows
+        token: ${{ secrets.CODECOV_TOKEN }}
+        verbose: true
--- a/.github/workflows/valid-style.yml
+++ b/.github/workflows/valid-style.yml
@@ -18,7 +18,7 @@ jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938
+    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
    - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3
      with:
        python-version: '3.11'
@@ -35,7 +35,7 @@ jobs:
  style:
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938
+    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
      with:
        fetch-depth: 0
    - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3
@@ -70,7 +70,7 @@ jobs:
          dnf install -y \
              bzip2 curl file gcc-c++ gcc gcc-gfortran git gnupg2 gzip \
              make patch tcl unzip which xz
-      - uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938
+      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
      - name: Setup repo and non-root user
        run: |
          git --version
@@ -87,62 +87,3 @@ jobs:
          spack -d bootstrap now --dev
          spack style -t black
          spack unit-test -V
-  import-check:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: julia-actions/setup-julia@v2
-      with:
-        version: '1.10'
-    - uses: julia-actions/cache@v2
-
-    # PR: use the base of the PR as the old commit
-    - name: Checkout PR base commit
-      if: github.event_name == 'pull_request'
-      uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938
-      with:
-        ref: ${{ github.event.pull_request.base.sha }}
-        path: old
-    # not a PR: use the previous commit as the old commit
-    - name: Checkout previous commit
-      if: github.event_name != 'pull_request'
-      uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938
-      with:
-        fetch-depth: 2
-        path: old
-    - name: Checkout previous commit
-      if: github.event_name != 'pull_request'
-      run: git -C old reset --hard HEAD^
-
-    - name: Checkout new commit
-      uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938
-      with:
-        path: new
-    - name: Install circular import checker
-      uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938
-      with:
-        repository: haampie/circular-import-fighter
-        ref: 555519c6fd5564fd2eb844e7b87e84f4d12602e2
-        path: circular-import-fighter
-    - name: Install dependencies
-      working-directory: circular-import-fighter
-      run: make -j dependencies
-    - name: Import cycles before
-      working-directory: circular-import-fighter
-      run: make SPACK_ROOT=../old && cp solution solution.old
-    - name: Import cycles after
-      working-directory: circular-import-fighter
-      run: make clean-graph && make SPACK_ROOT=../new && cp solution solution.new
-    - name: Compare import cycles
-      working-directory: circular-import-fighter
-      run: |
-        edges_before="$(grep -oP 'edges to delete: \K\d+' solution.old)"
-        edges_after="$(grep -oP 'edges to delete: \K\d+' solution.new)"
-        if [ "$edges_after" -gt "$edges_before" ]; then
-          printf '\033[1;31mImport check failed: %s imports need to be deleted, ' "$edges_after"
-          printf 'previously this was %s\033[0m\n'  "$edges_before"
-          printf 'Compare \033[1;97m"Import cycles before"\033[0m and '
-          printf '\033[1;97m"Import cycles after"\033[0m to see problematic imports.\n'
-          exit 1
-        else
-          printf '\033[1;32mImport check passed: %s <= %s\033[0m\n' "$edges_after" "$edges_before"
-        fi
--- a/README.md
+++ b/README.md
@@ -46,18 +46,13 @@ See the
 [Feature Overview](https://spack.readthedocs.io/en/latest/features.html)
 for examples and highlights.

-To install spack and your first package, make sure you have Python & Git.
+To install spack and your first package, make sure you have Python.
 Then:

-    $ git clone -c feature.manyFiles=true --depth=2 https://github.com/spack/spack.git
+    $ git clone -c feature.manyFiles=true https://github.com/spack/spack.git
    $ cd spack/bin
    $ ./spack install zlib

-> [!TIP]
-> `-c feature.manyFiles=true` improves git's performance on repositories with 1,000+ files.
->
-> `--depth=2` prunes the git history to reduce the size of the Spack installation.
-
 Documentation
 ----------------

--- a/etc/spack/defaults/config.yaml
+++ b/etc/spack/defaults/config.yaml
@@ -115,6 +115,12 @@ config:
  suppress_gpg_warnings: false


+  # If set to true, Spack will attempt to build any compiler on the spec
+  # that is not already available. If set to False, Spack will only use
+  # compilers already configured in compilers.yaml
+  install_missing_compilers: false
+
+
  # If set to true, Spack will always check checksums after downloading
  # archives. If false, Spack skips the checksum step.
  checksum: true
--- a/lib/spack/docs/basic_usage.rst
+++ b/lib/spack/docs/basic_usage.rst
@@ -1175,17 +1175,6 @@ unspecified version, but packages can depend on other packages with
 could depend on ``mpich@1.2:`` if it can only build with version
 ``1.2`` or higher of ``mpich``.

-.. note:: Windows Spec Syntax Caveats
-   Windows has a few idiosyncrasies when it comes to the Spack spec syntax and the use of certain shells
-   Spack's spec dependency syntax uses the carat (``^``) character, however this is an escape string in CMD
-   so it must be escaped with an additional carat (i.e. ``^^``).
-   CMD also will attempt to interpret strings with ``=`` characters in them. Any spec including this symbol
-   must double quote the string.
-
-   Note: All of these issues are unique to CMD, they can be avoided by using Powershell.
-
-   For more context on these caveats see the related issues: `carat <https://github.com/spack/spack/issues/42833>`_ and `equals <https://github.com/spack/spack/issues/43348>`_
-
 Below are more details about the specifiers that you can add to specs.

 .. _version-specifier:
--- a/lib/spack/docs/chain.rst
+++ b/lib/spack/docs/chain.rst
@@ -5,9 +5,9 @@

 .. chain:

-=============================================
-Chaining Spack Installations (upstreams.yaml)
-=============================================
+============================
+Chaining Spack Installations
+============================

 You can point your Spack installation to another installation to use any
 packages that are installed there. To register the other Spack instance,
--- a/lib/spack/docs/conf.py
+++ b/lib/spack/docs/conf.py
@@ -218,8 +218,6 @@ def setup(sphinx):
    ("py:class", "spack.spec.SpecfileReaderBase"),
    ("py:class", "spack.install_test.Pb"),
    ("py:class", "spack.filesystem_view.SimpleFilesystemView"),
-    ("py:class", "spack.traverse.EdgeAndDepth"),
-    ("py:class", "archspec.cpu.microarchitecture.Microarchitecture"),
 ]

 # The reST default role (used for this markup: `text`) to use for all documents.
--- a/lib/spack/docs/developer_guide.rst
+++ b/lib/spack/docs/developer_guide.rst
@@ -181,6 +181,10 @@ Spec-related modules
 :mod:`spack.parser`
  Contains :class:`~spack.parser.SpecParser` and functions related to parsing specs.

+:mod:`spack.concretize`
+  Contains :class:`~spack.concretize.Concretizer` implementation,
+  which allows site administrators to change Spack's :ref:`concretization-policies`.
+
 :mod:`spack.version`
  Implements a simple :class:`~spack.version.Version` class with simple
  comparison semantics.  Also implements :class:`~spack.version.VersionRange`
--- a/lib/spack/docs/environments.rst
+++ b/lib/spack/docs/environments.rst
@@ -414,13 +414,7 @@ default, it will also clone the package to a subdirectory in the
 environment. This package will have a special variant ``dev_path``
 set, and Spack will ensure the package and its dependents are rebuilt
 any time the environment is installed if the package's local source
-code has been modified. Spack's native implementation to check for modifications
-is to check if ``mtime`` is newer than the installation.
-A custom check can be created by overriding the ``detect_dev_src_change`` method 
-in your package class. This is particularly useful for projects using custom spack repo's 
-to drive development and want to optimize performance. 
-
-Spack ensures that all instances of a
+code has been modified. Spack ensures that all instances of a
 developed package in the environment are concretized to match the
 version (and other constraints) passed as the spec argument to the
 ``spack develop`` command.
@@ -899,8 +893,9 @@ The valid variables for a ``when`` clause are:

 #. ``env``. The user environment (usually ``os.environ`` in Python).

-#. ``hostname``. The hostname of the system (if ``hostname`` is an
-   executable in the user's PATH).
+#. ``hostname``. The hostname of the system.
+
+#. ``full_hostname``. The fully qualified hostname of the system.

 ^^^^^^^^^^^^^^^^^^^^^^^^
 SpecLists as Constraints
--- a/lib/spack/docs/getting_started.rst
+++ b/lib/spack/docs/getting_started.rst
@@ -61,15 +61,10 @@ Getting Spack is easy.  You can clone it from the `github repository

 .. code-block:: console

-   $ git clone -c feature.manyFiles=true --depth=2 https://github.com/spack/spack.git
+   $ git clone -c feature.manyFiles=true https://github.com/spack/spack.git

 This will create a directory called ``spack``.

-.. note::
-   ``-c feature.manyFiles=true`` improves git's performance on repositories with 1,000+ files.
-
-   ``--depth=2`` prunes the git history to reduce the size of the Spack installation.
-
 .. _shell-support:

 ^^^^^^^^^^^^^
@@ -1480,14 +1475,16 @@ in a Windows CMD prompt.
 Step 3: Run and configure Spack
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

-On Windows, Spack supports both primary native shells, Powershell and the traditional command prompt.
-To use Spack, pick your favorite shell, and run ``bin\spack_cmd.bat`` or ``share/spack/setup-env.ps1``
-(you may need to Run as Administrator) from the top-level spack
-directory. This will provide a Spack enabled shell. If you receive a warning message that Python is not in your ``PATH``
+To use Spack, run ``bin\spack_cmd.bat`` (you may need to Run as Administrator) from the top-level spack
+directory. This will provide a Windows command prompt with an environment properly set up with Spack
+and its prerequisites. If you receive a warning message that Python is not in your ``PATH``
 (which may happen if you installed Python from the website and not the Windows Store) add the location
 of the Python executable to your ``PATH`` now. You can permanently add Python to your ``PATH`` variable
 by using the ``Edit the system environment variables`` utility in Windows Control Panel.

+.. note::
+   Alternatively, Powershell can be used in place of CMD
+
 To configure Spack, first run the following command inside the Spack console:

 .. code-block:: console
@@ -1552,7 +1549,7 @@ and not tabs, so ensure that this is the case when editing one directly.

 .. note:: Cygwin
   The use of Cygwin is not officially supported by Spack and is not tested.
-   However Spack will not prevent this, so use if choosing to use Spack
+   However Spack will not throw an error, so use if choosing to use Spack
   with Cygwin, know that no functionality is garunteed.

 ^^^^^^^^^^^^^^^^^
@@ -1566,12 +1563,21 @@ Spack console via:

   spack install cpuinfo

-If in the previous step, you did not have CMake or Ninja installed, running the command above should install both packages
+If in the previous step, you did not have CMake or Ninja installed, running the command above should bootstrap both packages

-.. note:: Spec Syntax Caveats
-   Windows has a few idiosyncrasies when it comes to the Spack spec syntax and the use of certain shells
-   See the Spack spec syntax doc for more information
+"""""""""""""""""""""""""""
+Windows Compatible Packages
+"""""""""""""""""""""""""""

+Not all spack packages currently have Windows support. Some are inherently incompatible with the
+platform, and others simply have yet to be ported. To view the current set of packages with Windows
+support, the list command should be used via `spack list -t windows`. If there's a package you'd like
+to install on Windows but is not in that list, feel free to reach out to request the port or contribute
+the port yourself.
+
+.. note::
+   This is by no means a comprehensive list, some packages may have ports that were not tagged
+   while others may just work out of the box on Windows and have not been tagged as such.

 ^^^^^^^^^^^^^^
 For developers
@@ -1581,3 +1587,6 @@ The intent is to provide a Windows installer that will automatically set up
 Python, Git, and Spack, instead of requiring the user to do so manually.
 Instructions for creating the installer are at
 https://github.com/spack/spack/blob/develop/lib/spack/spack/cmd/installer/README.md
+
+Alternatively a pre-built copy of the Windows installer is available as an artifact of Spack's Windows CI
+available at each run of the CI on develop or any PR.
--- a/lib/spack/docs/index.rst
+++ b/lib/spack/docs/index.rst
@@ -39,15 +39,10 @@ package:

 .. code-block:: console

-   $ git clone -c feature.manyFiles=true --depth=2 https://github.com/spack/spack.git
+   $ git clone -c feature.manyFiles=true https://github.com/spack/spack.git
   $ cd spack/bin
   $ ./spack install libelf

-.. note::
-   ``-c feature.manyFiles=true`` improves git's performance on repositories with 1,000+ files.
-
-   ``--depth=2`` prunes the git history to reduce the size of the Spack installation.
-
 If you're new to spack and want to start using it, see :doc:`getting_started`,
 or refer to the full manual below.

--- a/lib/spack/docs/pipelines.rst
+++ b/lib/spack/docs/pipelines.rst
@@ -663,7 +663,11 @@ build the package.

 When including a bootstrapping phase as in the example above, the result is that
 the bootstrapped compiler packages will be pushed to the binary mirror (and the
-local artifacts mirror) before the actual release specs are built.
+local artifacts mirror) before the actual release specs are built. In this case,
+the jobs corresponding to subsequent release specs are configured to
+``install_missing_compilers``, so that if spack is asked to install a package
+with a compiler it doesn't know about, it can be quickly installed from the
+binary mirror first.

 Since bootstrapping compilers is optional, those items can be left out of the
 environment/stack file, and in that case no bootstrapping will be done (only the
--- a/lib/spack/docs/requirements.txt
+++ b/lib/spack/docs/requirements.txt
@@ -5,8 +5,8 @@ sphinx-rtd-theme==2.0.0
 python-levenshtein==0.25.1
 docutils==0.20.1
 pygments==2.18.0
-urllib3==2.2.3
-pytest==8.3.3
+urllib3==2.2.2
+pytest==8.3.2
 isort==5.13.2
 black==24.8.0
 flake8==7.1.1
--- a/lib/spack/env/cc
+++ b/lib/spack/env/cc
@@ -101,9 +101,10 @@ setsep() {
    esac
 }

-# prepend LISTNAME ELEMENT
+# prepend LISTNAME ELEMENT [SEP]
 #
-# Prepend ELEMENT to the list stored in the variable LISTNAME.
+# Prepend ELEMENT to the list stored in the variable LISTNAME,
+# assuming the list is separated by SEP.
 # Handles empty lists and single-element lists.
 prepend() {
    varname="$1"
@@ -118,39 +119,18 @@ prepend() {
    fi
 }

-# contains LISTNAME ELEMENT
+# append LISTNAME ELEMENT [SEP]
 #
-# Test whether LISTNAME contains ELEMENT.
-# Set $? to 1 if LISTNAME does not contain ELEMENT.
-# Set $? to 0 if LISTNAME does not contain ELEMENT.
-contains() {
-    varname="$1"
-    elt="$2"
-
-    setsep "$varname"
-
-    # the list may: 1) only contain the element, 2) start with the element,
-    # 3) contain the element in the middle, or 4) end wtih the element.
-    eval "[ \"\${$varname}\" = \"$elt\" ]" \
-        || eval "[ \"\${$varname#${elt}${sep}}\" != \"\${$varname}\" ]" \
-        || eval "[ \"\${$varname#*${sep}${elt}${sep}}\" != \"\${$varname}\" ]" \
-        || eval "[ \"\${$varname%${sep}${elt}}\" != \"\${$varname}\" ]"
-}
-
-# append LISTNAME ELEMENT [unique]
-#
-# Append ELEMENT to the list stored in the variable LISTNAME.
+# Append ELEMENT to the list stored in the variable LISTNAME,
+# assuming the list is separated by SEP.
 # Handles empty lists and single-element lists.
-#
-# If the third argument is provided and if it is the string 'unique',
-# this will not append if ELEMENT is already in the list LISTNAME.
 append() {
    varname="$1"
    elt="$2"

    if empty "$varname"; then
        eval "$varname=\"\${elt}\""
-    elif [ "$3" != "unique" ] || ! contains "$varname" "$elt" ; then
+    else
        # Get the appropriate separator for the list we're appending to.
        setsep "$varname"
        eval "$varname=\"\${$varname}${sep}\${elt}\""
@@ -168,21 +148,10 @@ extend() {
    if [ "$sep" != " " ]; then
        IFS="$sep"
    fi
-    eval "for elt in \${$2}; do append $1 \"$3\${elt}\" ${_append_args}; done"
+    eval "for elt in \${$2}; do append $1 \"$3\${elt}\"; done"
    unset IFS
 }

-# extend_unique LISTNAME1 LISTNAME2 [PREFIX]
-#
-# Append the elements stored in the variable LISTNAME2 to the list
-# stored in LISTNAME1, if they are not already present.
-# If PREFIX is provided, prepend it to each element.
-extend_unique() {
-    _append_args="unique"
-    extend "$@"
-    unset _append_args
-}
-
 # preextend LISTNAME1 LISTNAME2 [PREFIX]
 #
 # Prepend the elements stored in the list at LISTNAME2
@@ -269,36 +238,6 @@ esac
 }
 "

-# path_list functions. Path_lists have 3 parts: spack_store_<list>, <list> and system_<list>,
-# which are used to prioritize paths when assembling the final command line.
-
-# init_path_lists LISTNAME
-# Set <LISTNAME>, spack_store_<LISTNAME>, and system_<LISTNAME> to "".
-init_path_lists() {
-    eval "spack_store_$1=\"\""
-    eval "$1=\"\""
-    eval "system_$1=\"\""
-}
-
-# assign_path_lists LISTNAME1 LISTNAME2
-# Copy contents of LISTNAME2 into LISTNAME1, for each path_list prefix.
-assign_path_lists() {
-    eval "spack_store_$1=\"\${spack_store_$2}\""
-    eval "$1=\"\${$2}\""
-    eval "system_$1=\"\${system_$2}\""
-}
-
-# append_path_lists LISTNAME ELT
-# Append the provided ELT to the appropriate list, based on the result of path_order().
-append_path_lists() {
-    path_order "$2"
-    case $? in
-        0) eval "append spack_store_$1 \"\$2\"" ;;
-        1) eval "append $1 \"\$2\"" ;;
-        2) eval "append system_$1 \"\$2\"" ;;
-    esac
-}
-
 # Check if optional parameters are defined
 # If we aren't asking for debug flags, don't add them
 if [ -z "${SPACK_ADD_DEBUG_FLAGS:-}" ]; then
@@ -482,6 +421,26 @@ if [ "$mode" = vcheck ]; then
    execute
 fi

+# Darwin's linker has a -r argument that merges object files together.
+# It doesn't work with -rpath.
+# This variable controls whether they are added.
+add_rpaths=true
+if [ "$mode" = ld ] || [ "$mode" = ccld ]; then
+    if [ "${SPACK_SHORT_SPEC#*darwin}" != "${SPACK_SHORT_SPEC}" ]; then
+        for arg in "$@"; do
+            if [ "$arg" = "-r" ]; then
+                if [ "$mode" = ld ] || [ "$mode" = ccld ]; then
+                    add_rpaths=false
+                    break
+                fi
+            elif [ "$arg" = "-Wl,-r" ] && [ "$mode" = ccld ]; then
+                add_rpaths=false
+                break
+            fi
+        done
+    fi
+fi
+
 # Save original command for debug logging
 input_command="$*"

@@ -511,7 +470,12 @@ input_command="$*"
 parse_Wl() {
    while [ $# -ne 0 ]; do
    if [ "$wl_expect_rpath" = yes ]; then
-        append_path_lists return_rpath_dirs_list "$1"
+        path_order "$1"
+        case $? in
+            0) append return_spack_store_rpath_dirs_list "$1" ;;
+            1) append return_rpath_dirs_list "$1" ;;
+            2) append return_system_rpath_dirs_list "$1" ;;
+        esac
        wl_expect_rpath=no
    else
        case "$1" in
@@ -520,14 +484,24 @@ parse_Wl() {
                if [ -z "$arg" ]; then
                    shift; continue
                fi
-                append_path_lists return_rpath_dirs_list "$arg"
+                path_order "$arg"
+                case $? in
+                    0) append return_spack_store_rpath_dirs_list "$arg" ;;
+                    1) append return_rpath_dirs_list "$arg" ;;
+                    2) append return_system_rpath_dirs_list "$arg" ;;
+                esac
                ;;
            --rpath=*)
                arg="${1#--rpath=}"
                if [ -z "$arg" ]; then
                    shift; continue
                fi
-                append_path_lists return_rpath_dirs_list "$arg"
+                path_order "$arg"
+                case $? in
+                    0) append return_spack_store_rpath_dirs_list "$arg" ;;
+                    1) append return_rpath_dirs_list "$arg" ;;
+                    2) append return_system_rpath_dirs_list "$arg" ;;
+                esac
                ;;
            -rpath|--rpath)
                wl_expect_rpath=yes
@@ -535,7 +509,8 @@ parse_Wl() {
            "$dtags_to_strip")
                ;;
            -Wl)
-                # Nested -Wl,-Wl means we're in NAG compiler territory. We don't support it.
+                # Nested -Wl,-Wl means we're in NAG compiler territory, we don't support
+                # it.
                return 1
                ;;
            *)
@@ -554,10 +529,21 @@ categorize_arguments() {
    return_other_args_list=""
    return_isystem_was_used=""

-    init_path_lists return_isystem_include_dirs_list
-    init_path_lists return_include_dirs_list
-    init_path_lists return_lib_dirs_list
-    init_path_lists return_rpath_dirs_list
+    return_isystem_spack_store_include_dirs_list=""
+    return_isystem_system_include_dirs_list=""
+    return_isystem_include_dirs_list=""
+
+    return_spack_store_include_dirs_list=""
+    return_system_include_dirs_list=""
+    return_include_dirs_list=""
+
+    return_spack_store_lib_dirs_list=""
+    return_system_lib_dirs_list=""
+    return_lib_dirs_list=""
+
+    return_spack_store_rpath_dirs_list=""
+    return_system_rpath_dirs_list=""
+    return_rpath_dirs_list=""

    # Global state for keeping track of -Wl,-rpath -Wl,/path
    wl_expect_rpath=no
@@ -623,17 +609,32 @@ categorize_arguments() {
                arg="${1#-isystem}"
                return_isystem_was_used=true
                if [ -z "$arg" ]; then shift; arg="$1"; fi
-                append_path_lists return_isystem_include_dirs_list "$arg"
+                path_order "$arg"
+                case $? in
+                    0) append return_isystem_spack_store_include_dirs_list "$arg" ;;
+                    1) append return_isystem_include_dirs_list "$arg" ;;
+                    2) append return_isystem_system_include_dirs_list "$arg" ;;
+                esac
                ;;
            -I*)
                arg="${1#-I}"
                if [ -z "$arg" ]; then shift; arg="$1"; fi
-                append_path_lists return_include_dirs_list "$arg"
+                path_order "$arg"
+                case $? in
+                    0) append return_spack_store_include_dirs_list "$arg" ;;
+                    1) append return_include_dirs_list "$arg" ;;
+                    2) append return_system_include_dirs_list "$arg" ;;
+                esac
                ;;
            -L*)
                arg="${1#-L}"
                if [ -z "$arg" ]; then shift; arg="$1"; fi
-                append_path_lists return_lib_dirs_list "$arg"
+                path_order "$arg"
+                case $? in
+                    0) append return_spack_store_lib_dirs_list "$arg" ;;
+                    1) append return_lib_dirs_list "$arg" ;;
+                    2) append return_system_lib_dirs_list "$arg" ;;
+                esac
                ;;
            -l*)
                # -loopopt=0 is generated erroneously in autoconf <= 2.69,
@@ -666,17 +667,32 @@ categorize_arguments() {
                    break
                elif [ "$xlinker_expect_rpath" = yes ]; then
                    # Register the path of -Xlinker -rpath <other args> -Xlinker <path>
-                    append_path_lists return_rpath_dirs_list "$1"
+                    path_order "$1"
+                    case $? in
+                        0) append return_spack_store_rpath_dirs_list "$1" ;;
+                        1) append return_rpath_dirs_list "$1" ;;
+                        2) append return_system_rpath_dirs_list "$1" ;;
+                    esac
                    xlinker_expect_rpath=no
                else
                    case "$1" in
                        -rpath=*)
                            arg="${1#-rpath=}"
-                            append_path_lists return_rpath_dirs_list "$arg"
+                            path_order "$arg"
+                            case $? in
+                                0) append return_spack_store_rpath_dirs_list "$arg" ;;
+                                1) append return_rpath_dirs_list "$arg" ;;
+                                2) append return_system_rpath_dirs_list "$arg" ;;
+                            esac
                            ;;
                        --rpath=*)
                            arg="${1#--rpath=}"
-                            append_path_lists return_rpath_dirs_list "$arg"
+                            path_order "$arg"
+                            case $? in
+                                0) append return_spack_store_rpath_dirs_list "$arg" ;;
+                                1) append return_rpath_dirs_list "$arg" ;;
+                                2) append return_system_rpath_dirs_list "$arg" ;;
+                            esac
                            ;;
                        -rpath|--rpath)
                            xlinker_expect_rpath=yes
@@ -693,32 +709,7 @@ categorize_arguments() {
            "$dtags_to_strip")
                ;;
            *)
-                # if mode is not ld, we can just add to other args
-                if [ "$mode" != "ld" ]; then
-                    append return_other_args_list "$1"
-                    shift
-                    continue
-                fi
-
-                # if we're in linker mode, we need to parse raw RPATH args
-                case "$1" in
-                    -rpath=*)
-                        arg="${1#-rpath=}"
-                        append_path_lists return_rpath_dirs_list "$arg"
-                        ;;
-                    --rpath=*)
-                        arg="${1#--rpath=}"
-                        append_path_lists return_rpath_dirs_list "$arg"
-                        ;;
-                    -rpath|--rpath)
-                        shift
-                        [ $# -eq 0 ] && break  # ignore -rpath without value
-                        append_path_lists return_rpath_dirs_list "$1"
-                        ;;
-                    *)
-                        append return_other_args_list "$1"
-                        ;;
-                esac
+                append return_other_args_list "$1"
                ;;
        esac
        shift
@@ -740,10 +731,21 @@ categorize_arguments() {

 categorize_arguments "$@"

-assign_path_lists isystem_include_dirs_list return_isystem_include_dirs_list
-assign_path_lists include_dirs_list return_include_dirs_list
-assign_path_lists lib_dirs_list return_lib_dirs_list
-assign_path_lists rpath_dirs_list return_rpath_dirs_list
+spack_store_include_dirs_list="$return_spack_store_include_dirs_list"
+system_include_dirs_list="$return_system_include_dirs_list"
+include_dirs_list="$return_include_dirs_list"
+
+spack_store_lib_dirs_list="$return_spack_store_lib_dirs_list"
+system_lib_dirs_list="$return_system_lib_dirs_list"
+lib_dirs_list="$return_lib_dirs_list"
+
+spack_store_rpath_dirs_list="$return_spack_store_rpath_dirs_list"
+system_rpath_dirs_list="$return_system_rpath_dirs_list"
+rpath_dirs_list="$return_rpath_dirs_list"
+
+isystem_spack_store_include_dirs_list="$return_isystem_spack_store_include_dirs_list"
+isystem_system_include_dirs_list="$return_isystem_system_include_dirs_list"
+isystem_include_dirs_list="$return_isystem_include_dirs_list"

 isystem_was_used="$return_isystem_was_used"
 other_args_list="$return_other_args_list"
@@ -819,10 +821,21 @@ IFS="$lsep"
    categorize_arguments $spack_flags_list
 unset IFS

-assign_path_lists spack_flags_isystem_include_dirs_list return_isystem_include_dirs_list
-assign_path_lists spack_flags_include_dirs_list return_include_dirs_list
-assign_path_lists spack_flags_lib_dirs_list return_lib_dirs_list
-assign_path_lists spack_flags_rpath_dirs_list return_rpath_dirs_list
+spack_flags_isystem_spack_store_include_dirs_list="$return_isystem_spack_store_include_dirs_list"
+spack_flags_isystem_system_include_dirs_list="$return_isystem_system_include_dirs_list"
+spack_flags_isystem_include_dirs_list="$return_isystem_include_dirs_list"
+
+spack_flags_spack_store_include_dirs_list="$return_spack_store_include_dirs_list"
+spack_flags_system_include_dirs_list="$return_system_include_dirs_list"
+spack_flags_include_dirs_list="$return_include_dirs_list"
+
+spack_flags_spack_store_lib_dirs_list="$return_spack_store_lib_dirs_list"
+spack_flags_system_lib_dirs_list="$return_system_lib_dirs_list"
+spack_flags_lib_dirs_list="$return_lib_dirs_list"
+
+spack_flags_spack_store_rpath_dirs_list="$return_spack_store_rpath_dirs_list"
+spack_flags_system_rpath_dirs_list="$return_system_rpath_dirs_list"
+spack_flags_rpath_dirs_list="$return_rpath_dirs_list"

 spack_flags_isystem_was_used="$return_isystem_was_used"
 spack_flags_other_args_list="$return_other_args_list"
@@ -841,11 +854,13 @@ if [ "$mode" = ld ] || [ "$mode" = ccld ]; then
 fi

 if [ "$mode" = ccld ] || [ "$mode" = ld ]; then
-    # Append RPATH directories. Note that in the case of the
-    # top-level package these directories may not exist yet. For dependencies
-    # it is assumed that paths have already been confirmed.
-    extend spack_store_rpath_dirs_list SPACK_STORE_RPATH_DIRS
-    extend rpath_dirs_list SPACK_RPATH_DIRS
+    if [ "$add_rpaths" != "false" ]; then
+        # Append RPATH directories. Note that in the case of the
+        # top-level package these directories may not exist yet. For dependencies
+        # it is assumed that paths have already been confirmed.
+        extend spack_store_rpath_dirs_list SPACK_STORE_RPATH_DIRS
+        extend rpath_dirs_list SPACK_RPATH_DIRS
+    fi
 fi

 if [ "$mode" = ccld ] || [ "$mode" = ld ]; then
@@ -860,10 +875,14 @@ case "$mode" in
    ld|ccld)
        # Set extra RPATHs
        extend lib_dirs_list SPACK_COMPILER_EXTRA_RPATHS
-        extend rpath_dirs_list SPACK_COMPILER_EXTRA_RPATHS
+        if [ "$add_rpaths" != "false" ]; then
+            extend rpath_dirs_list SPACK_COMPILER_EXTRA_RPATHS
+        fi

        # Set implicit RPATHs
-        extend rpath_dirs_list SPACK_COMPILER_IMPLICIT_RPATHS
+        if [ "$add_rpaths" != "false" ]; then
+            extend rpath_dirs_list SPACK_COMPILER_IMPLICIT_RPATHS
+        fi

        # Add SPACK_LDLIBS to args
        for lib in $SPACK_LDLIBS; do
@@ -875,7 +894,7 @@ esac
 case "$mode" in
    cpp|cc|as|ccld)
        if [ "$spack_flags_isystem_was_used" = "true" ] || [ "$isystem_was_used" = "true" ]; then
-            extend spack_store_isystem_include_dirs_list SPACK_STORE_INCLUDE_DIRS
+            extend isystem_spack_store_include_dirs_list SPACK_STORE_INCLUDE_DIRS
            extend isystem_include_dirs_list SPACK_INCLUDE_DIRS
        else
            extend spack_store_include_dirs_list SPACK_STORE_INCLUDE_DIRS
@@ -891,76 +910,64 @@ args_list="$flags_list"

 # Include search paths partitioned by (in store, non-sytem, system)
 # NOTE: adding ${lsep} to the prefix here turns every added element into two
-extend args_list spack_store_spack_flags_include_dirs_list -I
+extend args_list spack_flags_spack_store_include_dirs_list -I
 extend args_list spack_store_include_dirs_list -I

 extend args_list spack_flags_include_dirs_list -I
 extend args_list include_dirs_list -I

-extend args_list spack_store_spack_flags_isystem_include_dirs_list "-isystem${lsep}"
-extend args_list spack_store_isystem_include_dirs_list "-isystem${lsep}"
+extend args_list spack_flags_isystem_spack_store_include_dirs_list "-isystem${lsep}"
+extend args_list isystem_spack_store_include_dirs_list "-isystem${lsep}"

 extend args_list spack_flags_isystem_include_dirs_list "-isystem${lsep}"
 extend args_list isystem_include_dirs_list "-isystem${lsep}"

-extend args_list system_spack_flags_include_dirs_list -I
+extend args_list spack_flags_system_include_dirs_list -I
 extend args_list system_include_dirs_list -I

-extend args_list system_spack_flags_isystem_include_dirs_list "-isystem${lsep}"
-extend args_list system_isystem_include_dirs_list "-isystem${lsep}"
+extend args_list spack_flags_isystem_system_include_dirs_list "-isystem${lsep}"
+extend args_list isystem_system_include_dirs_list "-isystem${lsep}"

 # Library search paths partitioned by (in store, non-sytem, system)
-extend args_list spack_store_spack_flags_lib_dirs_list "-L"
+extend args_list spack_flags_spack_store_lib_dirs_list "-L"
 extend args_list spack_store_lib_dirs_list "-L"

 extend args_list spack_flags_lib_dirs_list "-L"
 extend args_list lib_dirs_list "-L"

-extend args_list system_spack_flags_lib_dirs_list "-L"
+extend args_list spack_flags_system_lib_dirs_list "-L"
 extend args_list system_lib_dirs_list "-L"

-# RPATH arguments
-
-rpath_prefix=""
+# RPATHs arguments
 case "$mode" in
    ccld)
        if [ -n "$dtags_to_add" ] ; then
            append args_list "$linker_arg$dtags_to_add"
        fi
-        rpath_prefix="$rpath"
+        extend args_list spack_flags_spack_store_rpath_dirs_list "$rpath"
+        extend args_list spack_store_rpath_dirs_list "$rpath"
+
+        extend args_list spack_flags_rpath_dirs_list "$rpath"
+        extend args_list rpath_dirs_list "$rpath"
+
+        extend args_list spack_flags_system_rpath_dirs_list "$rpath"
+        extend args_list system_rpath_dirs_list "$rpath"
        ;;
    ld)
        if [ -n "$dtags_to_add" ] ; then
            append args_list "$dtags_to_add"
        fi
-        rpath_prefix="-rpath${lsep}"
+        extend args_list spack_flags_spack_store_rpath_dirs_list "-rpath${lsep}"
+        extend args_list spack_store_rpath_dirs_list "-rpath${lsep}"
+
+        extend args_list spack_flags_rpath_dirs_list "-rpath${lsep}"
+        extend args_list rpath_dirs_list "-rpath${lsep}"
+
+        extend args_list spack_flags_system_rpath_dirs_list "-rpath${lsep}"
+        extend args_list system_rpath_dirs_list "-rpath${lsep}"
        ;;
 esac

-# Darwin's linker has a -r argument that merges object files together.
-# It doesn't work with -rpath. add_rpaths controls whether RPATHs are added.
-add_rpaths=true
-if [ "$mode" = ld ] || [ "$mode" = ccld ]; then
-    if [ "${SPACK_SHORT_SPEC#*darwin}" != "${SPACK_SHORT_SPEC}" ]; then
-        args="$@"
-        if contains args "-r" || contains args "-Wl,-r"; then
-            add_rpaths=false
-        fi
-    fi
-fi
-
-# if mode is ccld or ld, extend RPATH lists, adding the prefix determined above
-if [ "$add_rpaths" == "true" ] && [ -n "$rpath_prefix" ]; then
-    extend_unique args_list spack_store_spack_flags_rpath_dirs_list "$rpath_prefix"
-    extend_unique args_list spack_store_rpath_dirs_list "$rpath_prefix"
-
-    extend_unique args_list spack_flags_rpath_dirs_list "$rpath_prefix"
-    extend_unique args_list rpath_dirs_list "$rpath_prefix"
-
-    extend_unique args_list system_spack_flags_rpath_dirs_list "$rpath_prefix"
-    extend_unique args_list system_rpath_dirs_list "$rpath_prefix"
-fi
-
 # Other arguments from the input command
 extend args_list other_args_list
 extend args_list spack_flags_other_args_list
--- a/lib/spack/external/init.py
+++ b/lib/spack/external/init.py
@@ -18,7 +18,7 @@

 * Homepage: https://pypi.python.org/pypi/archspec
 * Usage: Labeling, comparison and detection of microarchitectures
-* Version: 0.2.5-dev (commit bceb39528ac49dd0c876b2e9bf3e7482e9c2be4a)
+* Version: 0.2.5-dev (commit 7e6740012b897ae4a950f0bba7e9726b767e921f)

 astunparse
 ----------------
--- a/lib/spack/external/archspec/cpu/microarchitecture.py
+++ b/lib/spack/external/archspec/cpu/microarchitecture.py
@@ -115,9 +115,6 @@ def __eq__(self, other):
            and self.cpu_part == other.cpu_part
        )

-    def __hash__(self):
-        return hash(self.name)
-
    @coerce_target_names
    def __ne__(self, other):
        return not self == other
--- a/lib/spack/external/archspec/json/cpu/microarchitectures.json
+++ b/lib/spack/external/archspec/json/cpu/microarchitectures.json
@@ -2844,7 +2844,8 @@
          "asimdrdm",
          "lrcpc",
          "dcpop",
-          "asimddp"
+          "asimddp",
+          "ssbs"
      ],
      "compilers" : {
          "gcc": [
@@ -2941,6 +2942,7 @@
          "uscat",
          "ilrcpc",
          "flagm",
+          "ssbs",
          "dcpodp",
          "svei8mm",
          "svebf16",
@@ -3008,7 +3010,7 @@
              },
              {
                  "versions": "11:",
-                  "flags" : "-march=armv8.4-a+sve+fp16+bf16+crypto+i8mm+rng"
+                  "flags" : "-march=armv8.4-a+sve+ssbs+fp16+bf16+crypto+i8mm+rng"
              },
              {
                  "versions": "12:",
@@ -3064,6 +3066,7 @@
 	  "uscat",
 	  "ilrcpc",
 	  "flagm",
+	  "ssbs",
 	  "sb",
 	  "dcpodp",
 	  "sve2",
@@ -3176,6 +3179,7 @@
 	  "uscat",
 	  "ilrcpc",
 	  "flagm",
+	  "ssbs",
 	  "sb",
 	  "dcpodp",
 	  "sve2",
--- a/lib/spack/spack/init.py
+++ b/lib/spack/spack/init.py
@@ -3,13 +3,6 @@
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)

-import os
-import re
-from typing import Optional
-
-import spack.paths
-import spack.util.git
-
 #: PEP440 canonical <major>.<minor>.<micro>.<devN> string
 __version__ = "0.23.0.dev0"
 spack_version = __version__
@@ -26,47 +19,4 @@ def __try_int(v):
 spack_version_info = tuple([__try_int(v) for v in __version__.split(".")])


-def get_spack_commit() -> Optional[str]:
-    """Get the Spack git commit sha.
-
-    Returns:
-        (str or None) the commit sha if available, otherwise None
-    """
-    git_path = os.path.join(spack.paths.prefix, ".git")
-    if not os.path.exists(git_path):
-        return None
-
-    git = spack.util.git.git()
-    if not git:
-        return None
-
-    rev = git(
-        "-C",
-        spack.paths.prefix,
-        "rev-parse",
-        "HEAD",
-        output=str,
-        error=os.devnull,
-        fail_on_error=False,
-    )
-    if git.returncode != 0:
-        return None
-
-    match = re.match(r"[a-f\d]{7,}$", rev)
-    return match.group(0) if match else None
-
-
-def get_version() -> str:
-    """Get a descriptive version of this instance of Spack.
-
-    Outputs '<PEP440 version> (<git commit sha>)'.
-
-    The commit sha is only added when available.
-    """
-    commit = get_spack_commit()
-    if commit:
-        return f"{spack_version} ({commit})"
-    return spack_version
-
-
-__all__ = ["spack_version_info", "spack_version", "get_version", "get_spack_commit"]
+__all__ = ["spack_version_info", "spack_version"]
--- a/lib/spack/spack/audit.py
+++ b/lib/spack/spack/audit.py
@@ -46,14 +46,11 @@ def _search_duplicate_compilers(error_cls):
 import pickle
 import re
 import warnings
-from typing import Iterable, List, Set, Tuple
 from urllib.request import urlopen

 import llnl.util.lang

-import spack.builder
 import spack.config
-import spack.fetch_strategy
 import spack.patch
 import spack.repo
 import spack.spec
@@ -76,9 +73,7 @@ def __init__(self, summary, details):
        self.details = tuple(details)

    def __str__(self):
-        if self.details:
-            return f"{self.summary}\n" + "\n".join(f"    {detail}" for detail in self.details)
-        return self.summary
+        return self.summary + "\n" + "\n".join(["    " + detail for detail in self.details])

    def __eq__(self, other):
        if self.summary != other.summary or self.details != other.details:
@@ -282,7 +277,7 @@ def _avoid_mismatched_variants(error_cls):
            pkg_cls = spack.repo.PATH.get_pkg_class(pkg_name)
            for variant in current_spec.variants.values():
                # Variant does not exist at all
-                if variant.name not in pkg_cls.variant_names():
+                if variant.name not in pkg_cls.variants:
                    summary = (
                        f"Setting a preference for the '{pkg_name}' package to the "
                        f"non-existing variant '{variant.name}'"
@@ -291,8 +286,9 @@ def _avoid_mismatched_variants(error_cls):
                    continue

                # Variant cannot accept this value
+                s = spack.spec.Spec(pkg_name)
                try:
-                    spack.variant.prevalidate_variant_value(pkg_cls, variant, strict=True)
+                    s.update_variant_validate(variant.name, variant.value)
                except Exception:
                    summary = (
                        f"Setting the variant '{variant.name}' of the '{pkg_name}' package "
@@ -662,15 +658,9 @@ def _ensure_env_methods_are_ported_to_builders(pkgs, error_cls):
    errors = []
    for pkg_name in pkgs:
        pkg_cls = spack.repo.PATH.get_pkg_class(pkg_name)
-
-        # values are either Value objects (for conditional values) or the values themselves
-        build_system_names = set(
-            v.value if isinstance(v, spack.variant.Value) else v
-            for _, variant in pkg_cls.variant_definitions("build_system")
-            for v in variant.values
-        )
-        builder_cls_names = [spack.builder.BUILDER_CLS[x].__name__ for x in build_system_names]
-
+        buildsystem_variant, _ = pkg_cls.variants["build_system"]
+        buildsystem_names = [getattr(x, "value", x) for x in buildsystem_variant.values]
+        builder_cls_names = [spack.builder.BUILDER_CLS[x].__name__ for x in buildsystem_names]
        module = pkg_cls.module
        has_builders_in_package_py = any(
            getattr(module, name, False) for name in builder_cls_names
@@ -689,88 +679,6 @@ def _ensure_env_methods_are_ported_to_builders(pkgs, error_cls):
    return errors


-class DeprecatedMagicGlobals(ast.NodeVisitor):
-    def __init__(self, magic_globals: Iterable[str]):
-        super().__init__()
-
-        self.magic_globals: Set[str] = set(magic_globals)
-
-        # State to track whether we're in a class function
-        self.depth: int = 0
-        self.in_function: bool = False
-        self.path = (ast.Module, ast.ClassDef, ast.FunctionDef)
-
-        # Defined locals in the current function (heuristically at least)
-        self.locals: Set[str] = set()
-
-        # List of (name, lineno) tuples for references to magic globals
-        self.references_to_globals: List[Tuple[str, int]] = []
-
-    def descend_in_function_def(self, node: ast.AST) -> None:
-        if not isinstance(node, self.path[self.depth]):
-            return
-        self.depth += 1
-        if self.depth == len(self.path):
-            self.in_function = True
-        super().generic_visit(node)
-        if self.depth == len(self.path):
-            self.in_function = False
-            self.locals.clear()
-        self.depth -= 1
-
-    def generic_visit(self, node: ast.AST) -> None:
-        # Recurse into function definitions
-        if self.depth < len(self.path):
-            return self.descend_in_function_def(node)
-        elif not self.in_function:
-            return
-        elif isinstance(node, ast.Global):
-            for name in node.names:
-                if name in self.magic_globals:
-                    self.references_to_globals.append((name, node.lineno))
-        elif isinstance(node, ast.Assign):
-            # visit the rhs before lhs
-            super().visit(node.value)
-            for target in node.targets:
-                super().visit(target)
-        elif isinstance(node, ast.Name) and node.id in self.magic_globals:
-            if isinstance(node.ctx, ast.Load) and node.id not in self.locals:
-                self.references_to_globals.append((node.id, node.lineno))
-            elif isinstance(node.ctx, ast.Store):
-                self.locals.add(node.id)
-        else:
-            super().generic_visit(node)
-
-
-@package_properties
-def _uses_deprecated_globals(pkgs, error_cls):
-    """Ensure that packages do not use deprecated globals"""
-    errors = []
-
-    for pkg_name in pkgs:
-        # some packages scheduled to be removed in v0.23 are not worth fixing.
-        pkg_cls = spack.repo.PATH.get_pkg_class(pkg_name)
-        if all(v.get("deprecated", False) for v in pkg_cls.versions.values()):
-            continue
-
-        file = spack.repo.PATH.filename_for_package_name(pkg_name)
-        tree = ast.parse(open(file).read())
-        visitor = DeprecatedMagicGlobals(("std_cmake_args",))
-        visitor.visit(tree)
-        if visitor.references_to_globals:
-            errors.append(
-                error_cls(
-                    f"Package '{pkg_name}' uses deprecated globals",
-                    [
-                        f"{file}:{line} references '{name}'"
-                        for name, line in visitor.references_to_globals
-                    ],
-                )
-            )
-
-    return errors
-
-
@package_https_directives
 def _linting_package_file(pkgs, error_cls):
    """Check for correctness of links"""
@@ -937,22 +845,20 @@ def check_virtual_with_variants(spec, msg):

                # check variants
                dependency_variants = dep.spec.variants
-                for name, variant in dependency_variants.items():
+                for name, value in dependency_variants.items():
                    try:
-                        spack.variant.prevalidate_variant_value(
-                            dependency_pkg_cls, variant, dep.spec, strict=True
-                        )
+                        v, _ = dependency_pkg_cls.variants[name]
+                        v.validate_or_raise(value, pkg_cls=dependency_pkg_cls)
                    except Exception as e:
                        summary = (
                            f"{pkg_name}: wrong variant used for dependency in 'depends_on()'"
                        )

-                        error_msg = str(e)
                        if isinstance(e, KeyError):
                            error_msg = (
                                f"variant {str(e).strip()} does not exist in package {dep_name}"
-                                f" in package '{dep_name}'"
                            )
+                        error_msg += f" in package '{dep_name}'"

                        errors.append(
                            error_cls(summary=summary, details=[error_msg, f"in {filename}"])
@@ -964,38 +870,39 @@ def check_virtual_with_variants(spec, msg):
@package_directives
 def _ensure_variant_defaults_are_parsable(pkgs, error_cls):
    """Ensures that variant defaults are present and parsable from cli"""
-
-    def check_variant(pkg_cls, variant, vname):
-        # bool is a subclass of int in python. Permitting a default that is an instance
-        # of 'int' means both foo=false and foo=0 are accepted. Other falsish values are
-        # not allowed, since they can't be parsed from CLI ('foo=')
-        default_is_parsable = isinstance(variant.default, int) or variant.default
-
-        if not default_is_parsable:
-            msg = f"Variant '{vname}' of package '{pkg_cls.name}' has an unparsable default value"
-            return [error_cls(msg, [])]
-
-        try:
-            vspec = variant.make_default()
-        except spack.variant.MultipleValuesInExclusiveVariantError:
-            msg = f"Can't create default value for variant '{vname}' in package '{pkg_cls.name}'"
-            return [error_cls(msg, [])]
-
-        try:
-            variant.validate_or_raise(vspec, pkg_cls.name)
-        except spack.variant.InvalidVariantValueError:
-            msg = "Default value of variant '{vname}' in package '{pkg.name}' is invalid"
-            question = "Is it among the allowed values?"
-            return [error_cls(msg, [question])]
-
-        return []
-
    errors = []
    for pkg_name in pkgs:
        pkg_cls = spack.repo.PATH.get_pkg_class(pkg_name)
-        for vname in pkg_cls.variant_names():
-            for _, variant_def in pkg_cls.variant_definitions(vname):
-                errors.extend(check_variant(pkg_cls, variant_def, vname))
+        for variant_name, entry in pkg_cls.variants.items():
+            variant, _ = entry
+            default_is_parsable = (
+                # Permitting a default that is an instance on 'int' permits
+                # to have foo=false or foo=0. Other falsish values are
+                # not allowed, since they can't be parsed from cli ('foo=')
+                isinstance(variant.default, int)
+                or variant.default
+            )
+            if not default_is_parsable:
+                error_msg = "Variant '{}' of package '{}' has a bad default value"
+                errors.append(error_cls(error_msg.format(variant_name, pkg_name), []))
+                continue
+
+            try:
+                vspec = variant.make_default()
+            except spack.variant.MultipleValuesInExclusiveVariantError:
+                error_msg = "Cannot create a default value for the variant '{}' in package '{}'"
+                errors.append(error_cls(error_msg.format(variant_name, pkg_name), []))
+                continue
+
+            try:
+                variant.validate_or_raise(vspec, pkg_cls=pkg_cls)
+            except spack.variant.InvalidVariantValueError:
+                error_msg = (
+                    "The default value of the variant '{}' in package '{}' failed validation"
+                )
+                question = "Is it among the allowed values?"
+                errors.append(error_cls(error_msg.format(variant_name, pkg_name), [question]))
+
    return errors


@@ -1005,11 +912,11 @@ def _ensure_variants_have_descriptions(pkgs, error_cls):
    errors = []
    for pkg_name in pkgs:
        pkg_cls = spack.repo.PATH.get_pkg_class(pkg_name)
-        for name in pkg_cls.variant_names():
-            for when, variant in pkg_cls.variant_definitions(name):
-                if not variant.description:
-                    msg = f"Variant '{name}' in package '{pkg_name}' is missing a description"
-                    errors.append(error_cls(msg, []))
+        for variant_name, entry in pkg_cls.variants.items():
+            variant, _ = entry
+            if not variant.description:
+                error_msg = "Variant '{}' in package '{}' is missing a description"
+                errors.append(error_cls(error_msg.format(variant_name, pkg_name), []))

    return errors

@@ -1066,26 +973,29 @@ def _version_constraints_are_satisfiable_by_some_version_in_repo(pkgs, error_cls


 def _analyze_variants_in_directive(pkg, constraint, directive, error_cls):
+    variant_exceptions = (
+        spack.variant.InconsistentValidationError,
+        spack.variant.MultipleValuesInExclusiveVariantError,
+        spack.variant.InvalidVariantValueError,
+        KeyError,
+    )
    errors = []
-    variant_names = pkg.variant_names()
-    summary = f"{pkg.name}: wrong variant in '{directive}' directive"
-    filename = spack.repo.PATH.filename_for_package_name(pkg.name)
-
    for name, v in constraint.variants.items():
-        if name not in variant_names:
-            msg = f"variant {name} does not exist in {pkg.name}"
-            errors.append(error_cls(summary=summary, details=[msg, f"in {filename}"]))
-            continue
-
        try:
-            spack.variant.prevalidate_variant_value(pkg, v, constraint, strict=True)
-        except (
-            spack.variant.InconsistentValidationError,
-            spack.variant.MultipleValuesInExclusiveVariantError,
-            spack.variant.InvalidVariantValueError,
-        ) as e:
-            msg = str(e).strip()
-            errors.append(error_cls(summary=summary, details=[msg, f"in {filename}"]))
+            variant, _ = pkg.variants[name]
+            variant.validate_or_raise(v, pkg_cls=pkg)
+        except variant_exceptions as e:
+            summary = pkg.name + ': wrong variant in "{0}" directive'
+            summary = summary.format(directive)
+            filename = spack.repo.PATH.filename_for_package_name(pkg.name)
+
+            error_msg = str(e).strip()
+            if isinstance(e, KeyError):
+                error_msg = "the variant {0} does not exist".format(error_msg)
+
+            err = error_cls(summary=summary, details=[error_msg, "in " + filename])
+
+            errors.append(err)

    return errors

@@ -1123,10 +1033,9 @@ def _extracts_errors(triggers, summary):
                for dname in dnames
            )

-        for when, variants_by_name in pkg_cls.variants.items():
-            for vname, variant in variants_by_name.items():
-                summary = f"{pkg_name}: wrong 'when=' condition for the '{vname}' variant"
-                errors.extend(_extracts_errors([when], summary))
+        for vname, (variant, triggers) in pkg_cls.variants.items():
+            summary = f"{pkg_name}: wrong 'when=' condition for the '{vname}' variant"
+            errors.extend(_extracts_errors(triggers, summary))

        for when, providers, details in _error_items(pkg_cls.provided):
            errors.extend(
--- a/lib/spack/spack/binary_distribution.py
+++ b/lib/spack/spack/binary_distribution.py
@@ -33,6 +33,7 @@
 from llnl.util.symlink import readlink

 import spack.caches
+import spack.cmd
 import spack.config as config
 import spack.database as spack_db
 import spack.error
@@ -43,9 +44,9 @@
 import spack.oci.image
 import spack.oci.oci
 import spack.oci.opener
-import spack.paths
 import spack.platforms
 import spack.relocate as relocate
+import spack.repo
 import spack.spec
 import spack.stage
 import spack.store
@@ -1446,9 +1447,7 @@ def _oci_push_pkg_blob(
    filename = os.path.join(tmpdir, f"{spec.dag_hash()}.tar.gz")

    # Create an oci.image.layer aka tarball of the package
-    compressed_tarfile_checksum, tarfile_checksum = _do_create_tarball(
-        filename, spec.prefix, get_buildinfo_dict(spec)
-    )
+    compressed_tarfile_checksum, tarfile_checksum = spack.oci.oci.create_tarball(spec, filename)

    blob = spack.oci.oci.Blob(
        Digest.from_sha256(compressed_tarfile_checksum),
@@ -2698,9 +2697,6 @@ def get_keys(install=False, trust=False, force=False, mirrors=None):

    for mirror in mirror_collection.values():
        fetch_url = mirror.fetch_url
-        # TODO: oci:// does not support signing.
-        if fetch_url.startswith("oci://"):
-            continue
        keys_url = url_util.join(
            fetch_url, BUILD_CACHE_RELATIVE_PATH, BUILD_CACHE_KEYS_RELATIVE_PATH
        )
--- a/lib/spack/spack/bootstrap/config.py
+++ b/lib/spack/spack/bootstrap/config.py
@@ -14,7 +14,6 @@
 import spack.compilers
 import spack.config
 import spack.environment
-import spack.modules
 import spack.paths
 import spack.platforms
 import spack.repo
--- a/lib/spack/spack/bootstrap/core.py
+++ b/lib/spack/spack/bootstrap/core.py
@@ -37,16 +37,21 @@
 import spack.binary_distribution
 import spack.config
 import spack.detection
+import spack.environment
+import spack.modules
+import spack.paths
 import spack.platforms
+import spack.platforms.linux
+import spack.repo
 import spack.spec
 import spack.store
 import spack.user_environment
+import spack.util.environment
 import spack.util.executable
 import spack.util.path
 import spack.util.spack_yaml
 import spack.util.url
 import spack.version
-from spack.installer import PackageInstaller

 from ._common import _executables_in_store, _python_import, _root_spec, _try_import_from_store
 from .clingo import ClingoBootstrapConcretizer
@@ -278,7 +283,7 @@ 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()
+            concrete_spec.package.do_install(fail_fast=True)

        if _try_import_from_store(module, query_spec=concrete_spec, query_info=info):
            self.last_search = info
@@ -301,7 +306,7 @@ def try_search_path(self, executables: Tuple[str], abstract_spec_str: str) -> bo
        msg = "[BOOTSTRAP] Try installing '{0}' from sources"
        tty.debug(msg.format(abstract_spec_str))
        with spack.config.override(self.mirror_scope):
-            PackageInstaller([concrete_spec.package], fail_fast=True).install()
+            concrete_spec.package.do_install()
        if _executables_in_store(executables, concrete_spec, query_info=info):
            self.last_search = info
            return True
--- a/lib/spack/spack/bootstrap/environment.py
+++ b/lib/spack/spack/bootstrap/environment.py
@@ -14,9 +14,9 @@
 from llnl.util import tty

 import spack.environment
-import spack.spec
 import spack.tengine
-import spack.util.path
+import spack.util.cpus
+import spack.util.executable

 from ._common import _root_spec
 from .config import root_path, spec_for_current_python, store_path
--- a/lib/spack/spack/build_environment.py
+++ b/lib/spack/spack/build_environment.py
@@ -45,8 +45,6 @@
 from itertools import chain
 from typing import Dict, List, Set, Tuple

-import archspec.cpu
-
 import llnl.util.tty as tty
 from llnl.string import plural
 from llnl.util.filesystem import join_path
@@ -55,7 +53,6 @@
 from llnl.util.tty.color import cescape, colorize
 from llnl.util.tty.log import MultiProcessFd

-import spack.build_systems._checks
 import spack.build_systems.cmake
 import spack.build_systems.meson
 import spack.build_systems.python
@@ -64,20 +61,26 @@
 import spack.config
 import spack.deptypes as dt
 import spack.error
-import spack.multimethod
+import spack.main
 import spack.package_base
 import spack.paths
 import spack.platforms
+import spack.repo
 import spack.schema.environment
 import spack.spec
 import spack.stage
 import spack.store
 import spack.subprocess_context
+import spack.user_environment
 import spack.util.executable
+import spack.util.path
+import spack.util.pattern
 from spack import traverse
 from spack.context import Context
-from spack.error import InstallError, NoHeadersError, NoLibrariesError
+from spack.error import NoHeadersError, NoLibrariesError
 from spack.install_test import spack_install_test_log
+from spack.installer import InstallError
+from spack.util.cpus import determine_number_of_jobs
 from spack.util.environment import (
    SYSTEM_DIR_CASE_ENTRY,
    EnvironmentModifications,
@@ -360,7 +363,7 @@ 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)
+    isa_arg = spec.architecture.target.optimization_flags(compiler)
    env.set("SPACK_TARGET_ARGS", isa_arg)

    # Trap spack-tracked compiler flags as appropriate.
@@ -405,36 +408,6 @@ def set_compiler_environment_variables(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))
-
-    try:
-        result = target.optimization_flags(compiler.name, compiler_version.dotted_numeric_string)
-    except (ValueError, archspec.cpu.UnsupportedMicroarchitecture):
-        result = ""
-
-    return result
-
-
 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.
@@ -482,7 +455,7 @@ def set_wrapper_variables(pkg, env):
        env.set(SPACK_DEBUG, "TRUE")
    env.set(SPACK_SHORT_SPEC, pkg.spec.short_spec)
    env.set(SPACK_DEBUG_LOG_ID, pkg.spec.format("{name}-{hash:7}"))
-    env.set(SPACK_DEBUG_LOG_DIR, spack.paths.spack_working_dir)
+    env.set(SPACK_DEBUG_LOG_DIR, spack.main.spack_working_dir)

    if spack.config.get("config:ccache"):
        # Enable ccache in the compiler wrapper
@@ -589,7 +562,7 @@ def set_package_py_globals(pkg, context: Context = Context.BUILD):
        module.std_meson_args = spack.build_systems.meson.MesonBuilder.std_args(pkg)
        module.std_pip_args = spack.build_systems.python.PythonPipBuilder.std_args(pkg)

-    jobs = spack.config.determine_number_of_jobs(parallel=pkg.parallel)
+    jobs = determine_number_of_jobs(parallel=pkg.parallel)
    module.make_jobs = jobs

    # TODO: make these build deps that can be installed if not found.
@@ -815,6 +788,7 @@ def setup_package(pkg, dirty, context: Context = Context.BUILD):
    # Platform specific setup goes before package specific setup. This is for setting
    # defaults like MACOSX_DEPLOYMENT_TARGET on macOS.
    platform = spack.platforms.by_name(pkg.spec.architecture.platform)
+    target = platform.target(pkg.spec.architecture.target)
    platform.setup_platform_environment(pkg, env_mods)

    tty.debug("setup_package: grabbing modifications from dependencies")
@@ -839,6 +813,9 @@ def setup_package(pkg, dirty, context: Context = Context.BUILD):
        for mod in pkg.compiler.modules:
            load_module(mod)

+    if target and target.module_name:
+        load_module(target.module_name)
+
    load_external_modules(pkg)

    implicit_rpaths = pkg.compiler.implicit_rpaths()
@@ -1026,7 +1003,6 @@ def set_all_package_py_globals(self):
        """Set the globals in modules of package.py files."""
        for dspec, flag in chain(self.external, self.nonexternal):
            pkg = dspec.package
-
            if self.should_set_package_py_globals & flag:
                if self.context == Context.BUILD and self.needs_build_context & flag:
                    set_package_py_globals(pkg, context=Context.BUILD)
@@ -1034,6 +1010,12 @@ def set_all_package_py_globals(self):
                    # This includes runtime dependencies, also runtime deps of direct build deps.
                    set_package_py_globals(pkg, context=Context.RUN)

+        # Looping over the set of packages a second time
+        # ensures all globals are loaded into the module space prior to
+        # any package setup. This guarantees package setup methods have
+        # access to expected module level definitions such as "spack_cc"
+        for dspec, flag in chain(self.external, self.nonexternal):
+            pkg = dspec.package
            for spec in dspec.dependents():
                # Note: some specs have dependents that are unreachable from the root, so avoid
                # setting globals for those.
@@ -1162,7 +1144,7 @@ def _setup_pkg_and_run(
        return_value = function(pkg, kwargs)
        write_pipe.send(return_value)

-    except spack.error.StopPhase as e:
+    except StopPhase as e:
        # Do not create a full ChildError from this, it's not an error
        # it's a control statement.
        write_pipe.send(e)
@@ -1323,7 +1305,7 @@ def exitcode_msg(p):
    p.join()

    # If returns a StopPhase, raise it
-    if isinstance(child_result, spack.error.StopPhase):
+    if isinstance(child_result, StopPhase):
        # do not print
        raise child_result

@@ -1532,6 +1514,17 @@ def _make_child_error(msg, module, name, traceback, log, log_type, context):
    return ChildError(msg, module, name, traceback, log, log_type, context)


+class StopPhase(spack.error.SpackError):
+    """Pickle-able exception to control stopped builds."""
+
+    def __reduce__(self):
+        return _make_stop_phase, (self.message, self.long_message)
+
+
+def _make_stop_phase(msg, long_msg):
+    return StopPhase(msg, long_msg)
+
+
 def write_log_summary(out, log_type, log, last=None):
    errors, warnings = parse_log_events(log)
    nerr = len(errors)
--- a/lib/spack/spack/build_systems/_checks.py
+++ b/lib/spack/spack/build_systems/_checks.py
@@ -8,7 +8,7 @@
 import llnl.util.lang

 import spack.builder
-import spack.error
+import spack.installer
 import spack.relocate
 import spack.spec
 import spack.store
@@ -34,7 +34,7 @@ def check_paths(path_list, filetype, predicate):
            if not predicate(abs_path):
                msg = "Install failed for {0}. No such {1} in prefix: {2}"
                msg = msg.format(pkg.name, filetype, path)
-                raise spack.error.InstallError(msg)
+                raise spack.installer.InstallError(msg)

    check_paths(pkg.sanity_check_is_file, "file", os.path.isfile)
    check_paths(pkg.sanity_check_is_dir, "directory", os.path.isdir)
@@ -42,7 +42,7 @@ def check_paths(path_list, filetype, predicate):
    ignore_file = llnl.util.lang.match_predicate(spack.store.STORE.layout.hidden_file_regexes)
    if all(map(ignore_file, os.listdir(pkg.prefix))):
        msg = "Install failed for {0}.  Nothing was installed!"
-        raise spack.error.InstallError(msg.format(pkg.name))
+        raise spack.installer.InstallError(msg.format(pkg.name))


 def apply_macos_rpath_fixups(builder: spack.builder.Builder):
--- a/lib/spack/spack/build_systems/aspell_dict.py
+++ b/lib/spack/spack/build_systems/aspell_dict.py
@@ -2,8 +2,6 @@
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
-import os
-
 import llnl.util.filesystem as fs

 import spack.directives
@@ -48,12 +46,18 @@ class AspellDictPackage(AutotoolsPackage):
    #: Override the default autotools builder
    AutotoolsBuilder = AspellBuilder

-    def patch(self):
+    def view_destination(self, view):
        aspell_spec = self.spec["aspell"]
+        if view.get_projection_for_spec(aspell_spec) != aspell_spec.prefix:
+            raise spack.package_base.ExtensionError(
+                "aspell does not support non-global extensions"
+            )
        aspell = aspell_spec.command
-        dictdir = aspell("dump", "config", "dict-dir", output=str).strip()
-        datadir = aspell("dump", "config", "data-dir", output=str).strip()
-        dictdir = os.path.relpath(dictdir, aspell_spec.prefix)
-        datadir = os.path.relpath(datadir, aspell_spec.prefix)
-        fs.filter_file(r"^dictdir=.*$", f"dictdir=/{dictdir}", "configure")
-        fs.filter_file(r"^datadir=.*$", f"datadir=/{datadir}", "configure")
+        return aspell("dump", "config", "dict-dir", output=str).strip()
+
+    def view_source(self):
+        return self.prefix.lib
+
+    def patch(self):
+        fs.filter_file(r"^dictdir=.*$", "dictdir=/lib", "configure")
+        fs.filter_file(r"^datadir=.*$", "datadir=/lib", "configure")
--- a/lib/spack/spack/build_systems/autotools.py
+++ b/lib/spack/spack/build_systems/autotools.py
@@ -13,7 +13,6 @@

 import spack.build_environment
 import spack.builder
-import spack.error
 import spack.package_base
 from spack.directives import build_system, conflicts, depends_on
 from spack.multimethod import when
@@ -249,7 +248,7 @@ def runs_ok(script_abs_path):

        # An external gnuconfig may not not have a prefix.
        if gnuconfig_dir is None:
-            raise spack.error.InstallError(
+            raise spack.build_environment.InstallError(
                "Spack could not find substitutes for GNU config files because no "
                "prefix is available for the `gnuconfig` package. Make sure you set a "
                "prefix path instead of modules for external `gnuconfig`."
@@ -269,7 +268,7 @@ def runs_ok(script_abs_path):
                msg += (
                    " or the `gnuconfig` package prefix is misconfigured as" " an external package"
                )
-            raise spack.error.InstallError(msg)
+            raise spack.build_environment.InstallError(msg)

        # Filter working substitutes
        candidates = [f for f in candidates if runs_ok(f)]
@@ -294,7 +293,9 @@ def runs_ok(script_abs_path):
   and set the prefix to the directory containing the `config.guess` and
   `config.sub` files.
 """
-            raise spack.error.InstallError(msg.format(", ".join(to_be_found), self.name))
+            raise spack.build_environment.InstallError(
+                msg.format(", ".join(to_be_found), self.name)
+            )

        # Copy the good files over the bad ones
        for abs_path in to_be_patched:
@@ -687,8 +688,9 @@ def _activate_or_not(

        variant = variant or name

-        # Defensively look that the name passed as argument is among variants
-        if not self.pkg.has_variant(variant):
+        # Defensively look that the name passed as argument is among
+        # variants
+        if variant not in self.pkg.variants:
            msg = '"{0}" is not a variant of "{1}"'
            raise KeyError(msg.format(variant, self.pkg.name))

@@ -697,19 +699,27 @@ def _activate_or_not(

        # Create a list of pairs. Each pair includes a configuration
        # option and whether or not that option is activated
-        vdef = self.pkg.get_variant(variant)
-        if set(vdef.values) == set((True, False)):
+        variant_desc, _ = self.pkg.variants[variant]
+        if set(variant_desc.values) == set((True, False)):
            # BoolValuedVariant carry information about a single option.
            # Nonetheless, for uniformity of treatment we'll package them
            # in an iterable of one element.
-            options = [(name, f"+{variant}" in spec)]
+            condition = "+{name}".format(name=variant)
+            options = [(name, condition in spec)]
        else:
+            condition = "{variant}={value}"
            # "feature_values" is used to track values which correspond to
            # features which can be enabled or disabled as understood by the
            # package's build system. It excludes values which have special
            # meanings and do not correspond to features (e.g. "none")
-            feature_values = getattr(vdef.values, "feature_values", None) or vdef.values
-            options = [(value, f"{variant}={value}" in spec) for value in feature_values]
+            feature_values = (
+                getattr(variant_desc.values, "feature_values", None) or variant_desc.values
+            )
+
+            options = [
+                (value, condition.format(variant=variant, value=value) in spec)
+                for value in feature_values
+            ]

        # For each allowed value in the list of values
        for option_value, activated in options:
--- a/lib/spack/spack/build_systems/cached_cmake.py
+++ b/lib/spack/spack/build_systems/cached_cmake.py
@@ -89,7 +89,7 @@ def define_cmake_cache_from_variant(self, cmake_var, variant=None, comment=""):
        if variant is None:
            variant = cmake_var.lower()

-        if not self.pkg.has_variant(variant):
+        if variant not in self.pkg.variants:
            raise KeyError('"{0}" is not a variant of "{1}"'.format(variant, self.pkg.name))

        if variant not in self.pkg.spec.variants:
--- a/lib/spack/spack/build_systems/cmake.py
+++ b/lib/spack/spack/build_systems/cmake.py
@@ -15,7 +15,6 @@
 import spack.build_environment
 import spack.builder
 import spack.deptypes as dt
-import spack.error
 import spack.package_base
 from spack.directives import build_system, conflicts, depends_on, variant
 from spack.multimethod import when
@@ -146,7 +145,6 @@ def _values(x):
        default=default,
        values=_values,
        description="the build system generator to use",
-        when="build_system=cmake",
    )
    for x in not_used:
        conflicts(f"generator={x}")
@@ -346,7 +344,7 @@ def std_args(pkg, generator=None):
            msg = "Invalid CMake generator: '{0}'\n".format(generator)
            msg += "CMakePackage currently supports the following "
            msg += "primary generators: '{0}'".format("', '".join(valid_primary_generators))
-            raise spack.error.InstallError(msg)
+            raise spack.package_base.InstallError(msg)

        try:
            build_type = pkg.spec.variants["build_type"].value
@@ -506,7 +504,7 @@ def define_from_variant(self, cmake_var, variant=None):
        if variant is None:
            variant = cmake_var.lower()

-        if not self.pkg.has_variant(variant):
+        if variant not in self.pkg.variants:
            raise KeyError('"{0}" is not a variant of "{1}"'.format(variant, self.pkg.name))

        if variant not in self.pkg.spec.variants:
--- a/lib/spack/spack/build_systems/compiler.py
+++ b/lib/spack/spack/build_systems/compiler.py
@@ -14,7 +14,6 @@

 import spack.compiler
 import spack.package_base
-import spack.util.executable

 # Local "type" for type hints
 Path = Union[str, pathlib.Path]
--- a/lib/spack/spack/build_systems/cuda.py
+++ b/lib/spack/spack/build_systems/cuda.py
@@ -3,9 +3,6 @@
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)

-import re
-from typing import Iterable, List
-
 import spack.variant
 from spack.directives import conflicts, depends_on, variant
 from spack.multimethod import when
@@ -47,7 +44,6 @@ class CudaPackage(PackageBase):
        "87",
        "89",
        "90",
-        "90a",
    )

    # FIXME: keep cuda and cuda_arch separate to make usage easier until
@@ -74,27 +70,6 @@ def cuda_flags(arch_list):
            for s in arch_list
        ]

-    @staticmethod
-    def compute_capabilities(arch_list: Iterable[str]) -> List[str]:
-        """Adds a decimal place to each CUDA arch.
-
-        >>> compute_capabilities(['90', '90a'])
-        ['9.0', '9.0a']
-
-        Args:
-            arch_list: A list of integer strings, optionally followed by a suffix.
-
-        Returns:
-            A list of float strings, optionally followed by a suffix
-        """
-        pattern = re.compile(r"(\d+)")
-        capabilities = []
-        for arch in arch_list:
-            _, number, letter = re.split(pattern, arch)
-            number = "{0:.1f}".format(float(number) / 10.0)
-            capabilities.append(number + letter)
-        return capabilities
-
    depends_on("cuda", when="+cuda")

    # CUDA version vs Architecture
--- a/lib/spack/spack/build_systems/intel.py
+++ b/lib/spack/spack/build_systems/intel.py
@@ -22,10 +22,9 @@
    install,
 )

-import spack.builder
 import spack.error
 from spack.build_environment import dso_suffix
-from spack.error import InstallError
+from spack.package_base import InstallError
 from spack.util.environment import EnvironmentModifications
 from spack.util.executable import Executable
 from spack.util.prefix import Prefix
--- a/lib/spack/spack/build_systems/oneapi.py
+++ b/lib/spack/spack/build_systems/oneapi.py
@@ -15,7 +15,7 @@
 import spack.util.path
 from spack.build_environment import dso_suffix
 from spack.directives import conflicts, license, redistribute, variant
-from spack.error import InstallError
+from spack.package_base import InstallError
 from spack.util.environment import EnvironmentModifications
 from spack.util.executable import Executable

--- a/lib/spack/spack/build_systems/python.py
+++ b/lib/spack/spack/build_systems/python.py
@@ -24,8 +24,6 @@
 import spack.detection
 import spack.multimethod
 import spack.package_base
-import spack.platforms
-import spack.repo
 import spack.spec
 import spack.store
 from spack.directives import build_system, depends_on, extends
--- a/lib/spack/spack/build_systems/r.py
+++ b/lib/spack/spack/build_systems/r.py
@@ -5,7 +5,6 @@
 from typing import Optional, Tuple

 import llnl.util.lang as lang
-from llnl.util.filesystem import mkdirp

 from spack.directives import extends

@@ -37,7 +36,6 @@ def configure_vars(self):

    def install(self, pkg, spec, prefix):
        """Installs an R package."""
-        mkdirp(pkg.module.r_lib_dir)

        config_args = self.configure_args()
        config_vars = self.configure_vars()
@@ -45,12 +43,12 @@ def install(self, pkg, spec, prefix):
        args = ["--vanilla", "CMD", "INSTALL"]

        if config_args:
-            args.append(f"--configure-args={' '.join(config_args)}")
+            args.append("--configure-args={0}".format(" ".join(config_args)))

        if config_vars:
-            args.append(f"--configure-vars={' '.join(config_vars)}")
+            args.append("--configure-vars={0}".format(" ".join(config_vars)))

-        args.extend([f"--library={pkg.module.r_lib_dir}", self.stage.source_path])
+        args.extend(["--library={0}".format(self.pkg.module.r_lib_dir), self.stage.source_path])

        pkg.module.R(*args)

@@ -81,21 +79,27 @@ class RPackage(Package):
    @lang.classproperty
    def homepage(cls):
        if cls.cran:
-            return f"https://cloud.r-project.org/package={cls.cran}"
+            return "https://cloud.r-project.org/package=" + cls.cran
        elif cls.bioc:
-            return f"https://bioconductor.org/packages/{cls.bioc}"
+            return "https://bioconductor.org/packages/" + cls.bioc

    @lang.classproperty
    def url(cls):
        if cls.cran:
-            return f"https://cloud.r-project.org/src/contrib/{cls.cran}_{str(list(cls.versions)[0])}.tar.gz"
+            return (
+                "https://cloud.r-project.org/src/contrib/"
+                + cls.cran
+                + "_"
+                + str(list(cls.versions)[0])
+                + ".tar.gz"
+            )

    @lang.classproperty
    def list_url(cls):
        if cls.cran:
-            return f"https://cloud.r-project.org/src/contrib/Archive/{cls.cran}/"
+            return "https://cloud.r-project.org/src/contrib/Archive/" + cls.cran + "/"

    @property
    def git(self):
        if self.bioc:
-            return f"https://git.bioconductor.org/packages/{self.bioc}"
+            return "https://git.bioconductor.org/packages/" + self.bioc
--- a/lib/spack/spack/build_systems/racket.py
+++ b/lib/spack/spack/build_systems/racket.py
@@ -11,9 +11,9 @@

 import spack.builder
 from spack.build_environment import SPACK_NO_PARALLEL_MAKE
-from spack.config import determine_number_of_jobs
 from spack.directives import build_system, extends, maintainers
 from spack.package_base import PackageBase
+from spack.util.cpus import determine_number_of_jobs
 from spack.util.environment import env_flag
 from spack.util.executable import Executable, ProcessError

--- a/lib/spack/spack/builder.py
+++ b/lib/spack/spack/builder.py
@@ -10,7 +10,7 @@

 from llnl.util import lang

-import spack.error
+import spack.build_environment
 import spack.multimethod

 #: Builder classes, as registered by the "builder" decorator
@@ -461,13 +461,15 @@ def _on_phase_start(self, instance):
        # If a phase has a matching stop_before_phase attribute,
        # stop the installation process raising a StopPhase
        if getattr(instance, "stop_before_phase", None) == self.name:
-            raise spack.error.StopPhase("Stopping before '{0}' phase".format(self.name))
+            raise spack.build_environment.StopPhase(
+                "Stopping before '{0}' phase".format(self.name)
+            )

    def _on_phase_exit(self, instance):
        # If a phase has a matching last_phase attribute,
        # stop the installation process raising a StopPhase
        if getattr(instance, "last_phase", None) == self.name:
-            raise spack.error.StopPhase("Stopping at '{0}' phase".format(self.name))
+            raise spack.build_environment.StopPhase("Stopping at '{0}' phase".format(self.name))

    def copy(self):
        return copy.deepcopy(self)
--- a/lib/spack/spack/caches.py
+++ b/lib/spack/spack/caches.py
@@ -11,7 +11,9 @@
 from llnl.util.filesystem import mkdirp

 import spack.config
+import spack.error
 import spack.fetch_strategy
+import spack.mirror
 import spack.paths
 import spack.util.file_cache
 import spack.util.path
--- a/lib/spack/spack/ci.py
+++ b/lib/spack/spack/ci.py
@@ -31,7 +31,6 @@

 import spack
 import spack.binary_distribution as bindist
-import spack.concretize
 import spack.config as cfg
 import spack.environment as ev
 import spack.main
@@ -39,6 +38,7 @@
 import spack.paths
 import spack.repo
 import spack.spec
+import spack.stage
 import spack.util.git
 import spack.util.gpg as gpg_util
 import spack.util.spack_yaml as syaml
@@ -1219,8 +1219,8 @@ def main_script_replacements(cmd):
        # Capture the version of Spack used to generate the pipeline, that can be
        # passed to `git checkout` for version consistency. If we aren't in a Git
        # repository, presume we are a Spack release and use the Git tag instead.
-        spack_version = spack.get_version()
-        version_to_clone = spack.get_spack_commit() or f"v{spack.spack_version}"
+        spack_version = spack.main.get_version()
+        version_to_clone = spack.main.get_spack_commit() or f"v{spack.spack_version}"

        output_object["variables"] = {
            "SPACK_ARTIFACTS_ROOT": rel_artifacts_root,
--- a/lib/spack/spack/cmd/init.py
+++ b/lib/spack/spack/cmd/init.py
@@ -17,7 +17,7 @@
 from llnl.util.tty.colify import colify
 from llnl.util.tty.color import colorize

-import spack.config  # breaks a cycle.
+import spack.config
 import spack.environment as ev
 import spack.error
 import spack.extensions
--- a/lib/spack/spack/cmd/arch.py
+++ b/lib/spack/spack/cmd/arch.py
@@ -11,7 +11,6 @@
 import llnl.util.tty.color as color

 import spack.platforms
-import spack.spec

 description = "print architecture information about this machine"
 section = "system"
--- a/lib/spack/spack/cmd/audit.py
+++ b/lib/spack/spack/cmd/audit.py
@@ -115,11 +115,15 @@ def audit(parser, args):
 def _process_reports(reports):
    for check, errors in reports:
        if errors:
-            status = f"{len(errors)} issue{'' if len(errors) == 1 else 's'} found"
-            print(cl.colorize(f"{check}: @*r{{{status}}}"))
-            numdigits = len(str(len(errors)))
+            msg = "{0}: {1} issue{2} found".format(
+                check, len(errors), "" if len(errors) == 1 else "s"
+            )
+            header = "@*b{" + msg + "}"
+            print(cl.colorize(header))
            for idx, error in enumerate(errors):
-                print(f"{idx + 1:>{numdigits}}. {error}")
+                print(str(idx + 1) + ". " + str(error))
            raise SystemExit(1)
        else:
-            print(cl.colorize(f"{check}: @*g{{passed}}"))
+            msg = "{0}: 0 issues found.".format(check)
+            header = "@*b{" + msg + "}"
+            print(cl.colorize(header))
--- a/lib/spack/spack/cmd/bootstrap.py
+++ b/lib/spack/spack/cmd/bootstrap.py
@@ -16,11 +16,11 @@
 import spack.bootstrap.config
 import spack.bootstrap.core
 import spack.config
+import spack.main
 import spack.mirror
 import spack.spec
 import spack.stage
 import spack.util.path
-import spack.util.spack_yaml
 from spack.cmd.common import arguments

 description = "manage bootstrap configuration"
--- a/lib/spack/spack/cmd/buildcache.py
+++ b/lib/spack/spack/cmd/buildcache.py
@@ -23,9 +23,14 @@
 import spack.error
 import spack.mirror
 import spack.oci.oci
+import spack.oci.opener
+import spack.relocate
+import spack.repo
 import spack.spec
 import spack.stage
 import spack.store
+import spack.user_environment
+import spack.util.crypto
 import spack.util.parallel
 import spack.util.url as url_util
 import spack.util.web as web_util
--- a/lib/spack/spack/cmd/change.py
+++ b/lib/spack/spack/cmd/change.py
@@ -4,7 +4,6 @@
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)

 import spack.cmd
-import spack.spec
 from spack.cmd.common import arguments

 description = "change an existing spec in an environment"
--- a/lib/spack/spack/cmd/checksum.py
+++ b/lib/spack/spack/cmd/checksum.py
@@ -15,6 +15,7 @@
 import spack.repo
 import spack.spec
 import spack.stage
+import spack.util.crypto
 import spack.util.web as web_util
 from spack.cmd.common import arguments
 from spack.package_base import (
--- a/lib/spack/spack/cmd/ci.py
+++ b/lib/spack/spack/cmd/ci.py
@@ -19,6 +19,7 @@
 import spack.cmd.buildcache as buildcache
 import spack.config as cfg
 import spack.environment as ev
+import spack.environment.depfile
 import spack.hash_types as ht
 import spack.mirror
 import spack.util.gpg as gpg_util
--- a/lib/spack/spack/cmd/clean.py
+++ b/lib/spack/spack/cmd/clean.py
@@ -10,9 +10,11 @@
 import llnl.util.filesystem
 import llnl.util.tty as tty

+import spack.bootstrap
 import spack.caches
-import spack.cmd
+import spack.cmd.test
 import spack.config
+import spack.repo
 import spack.stage
 import spack.store
 import spack.util.path
--- a/lib/spack/spack/cmd/commands.py
+++ b/lib/spack/spack/cmd/commands.py
@@ -17,7 +17,6 @@
 from llnl.util.tty.colify import colify

 import spack.cmd
-import spack.config
 import spack.main
 import spack.paths
 import spack.platforms
--- a/lib/spack/spack/cmd/common/arguments.py
+++ b/lib/spack/spack/cmd/common/arguments.py
@@ -15,6 +15,7 @@
 import spack.deptypes as dt
 import spack.environment as ev
 import spack.mirror
+import spack.modules
 import spack.reporters
 import spack.spec
 import spack.store
--- a/lib/spack/spack/cmd/common/confirmation.py
+++ b/lib/spack/spack/cmd/common/confirmation.py
@@ -9,7 +9,6 @@
 import llnl.util.tty as tty

 import spack.cmd
-import spack.spec

 display_args = {"long": True, "show_flags": False, "variants": False, "indent": 4}

--- a/lib/spack/spack/cmd/common/env_utility.py
+++ b/lib/spack/spack/cmd/common/env_utility.py
@@ -10,6 +10,7 @@
 import spack.cmd
 import spack.deptypes as dt
 import spack.error
+import spack.paths
 import spack.spec
 import spack.store
 from spack import build_environment, traverse
--- a/lib/spack/spack/cmd/config.py
+++ b/lib/spack/spack/cmd/config.py
@@ -13,9 +13,9 @@

 import spack.config
 import spack.environment as ev
-import spack.error
+import spack.repo
 import spack.schema.env
-import spack.spec
+import spack.schema.packages
 import spack.store
 import spack.util.spack_yaml as syaml
 from spack.cmd.common import arguments
@@ -256,7 +256,7 @@ def config_remove(args):
        existing.pop(value, None)
    else:
        # This should be impossible to reach
-        raise spack.error.ConfigError("Config has nested non-dict values")
+        raise spack.config.ConfigError("Config has nested non-dict values")

    spack.config.set(path, existing, scope)

@@ -340,7 +340,7 @@ def _config_change(config_path, match_spec_str=None):
        if not changed:
            existing_requirements = spack.config.get(key_path)
            if isinstance(existing_requirements, str):
-                raise spack.error.ConfigError(
+                raise spack.config.ConfigError(
                    "'config change' needs to append a requirement,"
                    " but existing require: config is not a list"
                )
@@ -536,11 +536,11 @@ def config_prefer_upstream(args):
        # Get and list all the variants that differ from the default.
        variants = []
        for var_name, variant in spec.variants.items():
-            if var_name in ["patches"] or not spec.package.has_variant(var_name):
+            if var_name in ["patches"] or var_name not in spec.package.variants:
                continue

-            vdef = spec.package.get_variant(var_name)
-            if variant.value != vdef.default:
+            variant_desc, _ = spec.package.variants[var_name]
+            if variant.value != variant_desc.default:
                variants.append(str(variant))
        variants.sort()
        variants = " ".join(variants)
--- a/lib/spack/spack/cmd/create.py
+++ b/lib/spack/spack/cmd/create.py
@@ -13,6 +13,7 @@

 import spack.repo
 import spack.stage
+import spack.util.web
 from spack.spec import Spec
 from spack.url import (
    UndetectableNameError,
--- a/lib/spack/spack/cmd/debug.py
+++ b/lib/spack/spack/cmd/debug.py
@@ -13,12 +13,11 @@
 import llnl.util.tty as tty
 from llnl.util.filesystem import working_dir

-import spack
+import spack.config
 import spack.paths
 import spack.platforms
-import spack.spec
-import spack.store
 import spack.util.git
+from spack.main import get_version
 from spack.util.executable import which

 description = "debugging commands for troubleshooting Spack"
@@ -90,7 +89,7 @@ def report(args):
    host_os = host_platform.operating_system("frontend")
    host_target = host_platform.target("frontend")
    architecture = spack.spec.ArchSpec((str(host_platform), str(host_os), str(host_target)))
-    print("* **Spack:**", spack.get_version())
+    print("* **Spack:**", get_version())
    print("* **Python:**", platform.python_version())
    print("* **Platform:**", architecture)

--- a/lib/spack/spack/cmd/dependencies.py
+++ b/lib/spack/spack/cmd/dependencies.py
@@ -11,6 +11,7 @@
 import spack.cmd
 import spack.environment as ev
 import spack.package_base
+import spack.repo
 import spack.store
 from spack.cmd.common import arguments

--- a/lib/spack/spack/cmd/deprecate.py
+++ b/lib/spack/spack/cmd/deprecate.py
@@ -20,7 +20,6 @@

 import spack.cmd
 import spack.environment as ev
-import spack.installer
 import spack.store
 from spack.cmd.common import arguments
 from spack.database import InstallStatuses
@@ -143,4 +142,4 @@ def deprecate(parser, args):
            tty.die("Will not deprecate any packages.")

    for dcate, dcator in zip(all_deprecate, all_deprecators):
-        spack.installer.deprecate(dcate, dcator, symlink)
+        dcate.package.do_deprecate(dcator, symlink)
--- a/lib/spack/spack/cmd/dev_build.py
+++ b/lib/spack/spack/cmd/dev_build.py
@@ -8,13 +8,10 @@

 import llnl.util.tty as tty

-import spack.build_environment
 import spack.cmd
-import spack.cmd.common.arguments
 import spack.config
 import spack.repo
 from spack.cmd.common import arguments
-from spack.installer import PackageInstaller

 description = "developer build: build from code in current working directory"
 section = "build"
@@ -132,9 +129,9 @@ def dev_build(self, args):
    elif args.test == "root":
        tests = [spec.name for spec in specs]

-    PackageInstaller(
-        [spec.package],
+    spec.package.do_install(
        tests=tests,
+        make_jobs=args.jobs,
        keep_prefix=args.keep_prefix,
        install_deps=not args.ignore_deps,
        verbose=not args.quiet,
@@ -142,7 +139,7 @@ def dev_build(self, args):
        stop_before=args.before,
        skip_patch=args.skip_patch,
        stop_at=args.until,
-    ).install()
+    )

    # drop into the build environment of the package?
    if args.shell is not None:
--- a/lib/spack/spack/cmd/develop.py
+++ b/lib/spack/spack/cmd/develop.py
@@ -10,6 +10,7 @@
 import spack.cmd
 import spack.config
 import spack.fetch_strategy
+import spack.package_base
 import spack.repo
 import spack.spec
 import spack.stage
--- a/lib/spack/spack/cmd/diff.py
+++ b/lib/spack/spack/cmd/diff.py
@@ -12,6 +12,7 @@
 import spack.cmd
 import spack.environment as ev
 import spack.solver.asp as asp
+import spack.util.environment
 import spack.util.spack_json as sjson
 from spack.cmd.common import arguments

--- a/lib/spack/spack/cmd/env.py
+++ b/lib/spack/spack/cmd/env.py
@@ -21,12 +21,15 @@
 import spack.cmd
 import spack.cmd.common
 import spack.cmd.common.arguments
+import spack.cmd.install
 import spack.cmd.modules
+import spack.cmd.uninstall
 import spack.config
 import spack.environment as ev
 import spack.environment.depfile as depfile
-import spack.environment.environment
 import spack.environment.shell
+import spack.schema.env
+import spack.spec
 import spack.tengine
 from spack.cmd.common import arguments
 from spack.util.environment import EnvironmentModifications
--- a/lib/spack/spack/cmd/external.py
+++ b/lib/spack/spack/cmd/external.py
@@ -18,9 +18,9 @@
 import spack.cray_manifest as cray_manifest
 import spack.detection
 import spack.error
-import spack.package_base
 import spack.repo
 import spack.spec
+import spack.util.environment
 from spack.cmd.common import arguments

 description = "manage external packages in Spack configuration"
--- a/lib/spack/spack/cmd/fetch.py
+++ b/lib/spack/spack/cmd/fetch.py
@@ -8,6 +8,7 @@
 import spack.cmd
 import spack.config
 import spack.environment as ev
+import spack.repo
 import spack.traverse
 from spack.cmd.common import arguments

--- a/lib/spack/spack/cmd/find.py
+++ b/lib/spack/spack/cmd/find.py
@@ -10,11 +10,10 @@
 import llnl.util.tty as tty
 import llnl.util.tty.color as color

+import spack.bootstrap
 import spack.cmd as cmd
-import spack.config
 import spack.environment as ev
 import spack.repo
-import spack.spec
 import spack.store
 from spack.cmd.common import arguments
 from spack.database import InstallStatuses
--- a/lib/spack/spack/cmd/info.py
+++ b/lib/spack/spack/cmd/info.py
@@ -16,7 +16,7 @@
 import spack.install_test
 import spack.repo
 import spack.spec
-import spack.variant
+import spack.version
 from spack.cmd.common import arguments
 from spack.package_base import preferred_version

@@ -48,7 +48,6 @@ def setup_parser(subparser):
    options = [
        ("--detectable", print_detectable.__doc__),
        ("--maintainers", print_maintainers.__doc__),
-        ("--namespace", print_namespace.__doc__),
        ("--no-dependencies", "do not " + print_dependencies.__doc__),
        ("--no-variants", "do not " + print_variants.__doc__),
        ("--no-versions", "do not " + print_versions.__doc__),
@@ -190,15 +189,6 @@ def print_maintainers(pkg, args):
        color.cprint(section_title("Maintainers: ") + mnt)


-def print_namespace(pkg, args):
-    """output package namespace"""
-
-    repo = spack.repo.PATH.get_repo(pkg.namespace)
-    color.cprint("")
-    color.cprint(section_title("Namespace:"))
-    color.cprint(f"    @c{{{repo.namespace}}} at {repo.root}")
-
-
 def print_phases(pkg, args):
    """output installation phases"""

@@ -333,6 +323,26 @@ def _fmt_variant(variant, max_name_default_len, indent, when=None, out=None):
    out.write("\n")


+def _variants_by_name_when(pkg):
+    """Adaptor to get variants keyed by { name: { when: { [Variant...] } }."""
+    # TODO: replace with pkg.variants_by_name(when=True) when unified directive dicts are merged.
+    variants = {}
+    for name, (variant, whens) in sorted(pkg.variants.items()):
+        for when in whens:
+            variants.setdefault(name, {}).setdefault(when, []).append(variant)
+    return variants
+
+
+def _variants_by_when_name(pkg):
+    """Adaptor to get variants keyed by { when: { name: Variant } }"""
+    # TODO: replace with pkg.variants when unified directive dicts are merged.
+    variants = {}
+    for name, (variant, whens) in pkg.variants.items():
+        for when in whens:
+            variants.setdefault(when, {})[name] = variant
+    return variants
+
+
 def _print_variants_header(pkg):
    """output variants"""

@@ -343,22 +353,32 @@ def _print_variants_header(pkg):
    color.cprint("")
    color.cprint(section_title("Variants:"))

+    variants_by_name = _variants_by_name_when(pkg)
+
    # Calculate the max length of the "name [default]" part of the variant display
    # This lets us know where to print variant values.
    max_name_default_len = max(
        color.clen(_fmt_name_and_default(variant))
-        for name in pkg.variant_names()
-        for _, variant in pkg.variant_definitions(name)
+        for name, when_variants in variants_by_name.items()
+        for variants in when_variants.values()
+        for variant in variants
    )

-    return max_name_default_len
+    return max_name_default_len, variants_by_name
+
+
+def _unconstrained_ver_first(item):
+    """sort key that puts specs with open version ranges first"""
+    spec, _ = item
+    return (spack.version.any_version not in spec.versions, spec)


 def print_variants_grouped_by_when(pkg):
-    max_name_default_len = _print_variants_header(pkg)
+    max_name_default_len, _ = _print_variants_header(pkg)

    indent = 4
-    for when, variants_by_name in pkg.variant_items():
+    variants = _variants_by_when_name(pkg)
+    for when, variants_by_name in sorted(variants.items(), key=_unconstrained_ver_first):
        padded_values = max_name_default_len + 4
        start_indent = indent

@@ -376,14 +396,15 @@ def print_variants_grouped_by_when(pkg):


 def print_variants_by_name(pkg):
-    max_name_default_len = _print_variants_header(pkg)
+    max_name_default_len, variants_by_name = _print_variants_header(pkg)
    max_name_default_len += 4

    indent = 4
-    for name in pkg.variant_names():
-        for when, variant in pkg.variant_definitions(name):
-            _fmt_variant(variant, max_name_default_len, indent, when, out=sys.stdout)
-            sys.stdout.write("\n")
+    for name, when_variants in variants_by_name.items():
+        for when, variants in sorted(when_variants.items(), key=_unconstrained_ver_first):
+            for variant in variants:
+                _fmt_variant(variant, max_name_default_len, indent, when, out=sys.stdout)
+                sys.stdout.write("\n")


 def print_variants(pkg, args):
@@ -501,7 +522,6 @@ def info(parser, args):
    # Now output optional information in expected order
    sections = [
        (args.all or args.maintainers, print_maintainers),
-        (args.all or args.namespace, print_namespace),
        (args.all or args.detectable, print_detectable),
        (args.all or args.tags, print_tags),
        (args.all or not args.no_versions, print_versions),
--- a/lib/spack/spack/cmd/install.py
+++ b/lib/spack/spack/cmd/install.py
@@ -13,15 +13,18 @@
 from llnl.string import plural
 from llnl.util import lang, tty

+import spack.build_environment
 import spack.cmd
 import spack.config
 import spack.environment as ev
+import spack.fetch_strategy
+import spack.package_base
 import spack.paths
 import spack.report
 import spack.spec
 import spack.store
 from spack.cmd.common import arguments
-from spack.error import InstallError, SpackError
+from spack.error import SpackError
 from spack.installer import PackageInstaller

 description = "build and install packages"
@@ -284,7 +287,7 @@ def require_user_confirmation_for_overwrite(concrete_specs, args):
        tty.die("Reinstallation aborted.")


-def _dump_log_on_error(e: InstallError):
+def _dump_log_on_error(e: spack.build_environment.InstallError):
    e.print_context()
    assert e.pkg, "Expected InstallError to include the associated package"
    if not os.path.exists(e.pkg.log_path):
@@ -349,7 +352,7 @@ def reporter_factory(specs):
            install_with_active_env(env, args, install_kwargs, reporter_factory)
        else:
            install_without_active_env(args, install_kwargs, reporter_factory)
-    except InstallError as e:
+    except spack.build_environment.InstallError as e:
        if args.show_log_on_error:
            _dump_log_on_error(e)
        raise
@@ -474,5 +477,5 @@ def install_without_active_env(args, install_kwargs, reporter_factory):

        installs = [s.package for s in concrete_specs]
        install_kwargs["explicit"] = [s.dag_hash() for s in concrete_specs]
-        builder = PackageInstaller(installs, **install_kwargs)
+        builder = PackageInstaller(installs, install_kwargs)
        builder.install()
--- a/lib/spack/spack/cmd/load.py
+++ b/lib/spack/spack/cmd/load.py
@@ -6,10 +6,11 @@
 import sys

 import spack.cmd
-import spack.cmd.common
+import spack.cmd.find
 import spack.environment as ev
 import spack.store
 import spack.user_environment as uenv
+import spack.util.environment
 from spack.cmd.common import arguments

 description = "add package to the user environment"
--- a/lib/spack/spack/cmd/mark.py
+++ b/lib/spack/spack/cmd/mark.py
@@ -8,6 +8,9 @@
 from llnl.util import tty

 import spack.cmd
+import spack.error
+import spack.package_base
+import spack.repo
 import spack.store
 from spack.cmd.common import arguments
 from spack.database import InstallStatuses
--- a/lib/spack/spack/cmd/mirror.py
+++ b/lib/spack/spack/cmd/mirror.py
@@ -17,6 +17,7 @@
 import spack.mirror
 import spack.repo
 import spack.spec
+import spack.util.path
 import spack.util.web as web_util
 from spack.cmd.common import arguments
 from spack.error import SpackError
--- a/lib/spack/spack/cmd/modules/init.py
+++ b/lib/spack/spack/cmd/modules/init.py
@@ -15,7 +15,6 @@

 import spack.cmd
 import spack.config
-import spack.error
 import spack.modules
 import spack.modules.common
 import spack.repo
@@ -125,13 +124,13 @@ def check_module_set_name(name):
    names = [k for k in modules if k != "prefix_inspections"]

    if not names:
-        raise spack.error.ConfigError(
+        raise spack.config.ConfigError(
            f"Module set configuration is missing. Cannot use module set '{name}'"
        )

    pretty_names = "', '".join(names)

-    raise spack.error.ConfigError(
+    raise spack.config.ConfigError(
        f"Cannot use invalid module set '{name}'.",
        f"Valid module set names are: '{pretty_names}'.",
    )
@@ -173,7 +172,7 @@ def loads(module_type, specs, args, out=None):
    modules = list(
        (
            spec,
-            spack.modules.get_module(
+            spack.modules.common.get_module(
                module_type,
                spec,
                get_full_path=False,
@@ -222,7 +221,7 @@ def find(module_type, specs, args):

    try:
        modules = [
-            spack.modules.get_module(
+            spack.modules.common.get_module(
                module_type,
                spec,
                args.full_path,
@@ -233,7 +232,7 @@ def find(module_type, specs, args):
        ]

        modules.append(
-            spack.modules.get_module(
+            spack.modules.common.get_module(
                module_type,
                single_spec,
                args.full_path,
--- a/lib/spack/spack/cmd/patch.py
+++ b/lib/spack/spack/cmd/patch.py
@@ -9,6 +9,7 @@
 import spack.config
 import spack.environment as ev
 import spack.package_base
+import spack.repo
 import spack.traverse
 from spack.cmd.common import arguments

--- a/lib/spack/spack/cmd/pkg.py
+++ b/lib/spack/spack/cmd/pkg.py
@@ -12,6 +12,7 @@
 from llnl.util.tty.colify import colify

 import spack.cmd
+import spack.paths
 import spack.repo
 import spack.util.executable as exe
 import spack.util.package_hash as ph
--- a/lib/spack/spack/cmd/python.py
+++ b/lib/spack/spack/cmd/python.py
@@ -78,8 +78,8 @@ def python(parser, args, unknown_args):

    # Run user choice of interpreter
    if args.python_interpreter == "ipython":
-        return ipython_interpreter(args)
-    return python_interpreter(args)
+        return spack.cmd.python.ipython_interpreter(args)
+    return spack.cmd.python.python_interpreter(args)


 def ipython_interpreter(args):
--- a/lib/spack/spack/cmd/restage.py
+++ b/lib/spack/spack/cmd/restage.py
@@ -6,6 +6,7 @@
 import llnl.util.tty as tty

 import spack.cmd
+import spack.repo
 from spack.cmd.common import arguments

 description = "revert checked out package source code"
--- a/lib/spack/spack/cmd/solve.py
+++ b/lib/spack/spack/cmd/solve.py
@@ -12,12 +12,11 @@

 import spack
 import spack.cmd
-import spack.cmd.common.arguments
 import spack.config
 import spack.environment
 import spack.hash_types as ht
+import spack.package_base
 import spack.solver.asp as asp
-import spack.spec
 from spack.cmd.common import arguments

 description = "concretize a specs using an ASP solver"
--- a/lib/spack/spack/cmd/spec.py
+++ b/lib/spack/spack/cmd/spec.py
@@ -14,7 +14,6 @@
 import spack.hash_types as ht
 import spack.spec
 import spack.store
-import spack.traverse
 from spack.cmd.common import arguments

 description = "show what would be installed, given a spec"
--- a/lib/spack/spack/cmd/stage.py
+++ b/lib/spack/spack/cmd/stage.py
@@ -11,6 +11,8 @@
 import spack.config
 import spack.environment as ev
 import spack.package_base
+import spack.repo
+import spack.stage
 import spack.traverse
 from spack.cmd.common import arguments

--- a/lib/spack/spack/cmd/tags.py
+++ b/lib/spack/spack/cmd/tags.py
@@ -9,8 +9,8 @@
 import llnl.util.tty as tty
 import llnl.util.tty.colify as colify

-import spack.environment
 import spack.repo
+import spack.store
 import spack.tag

 description = "show package tags and associated packages"
--- a/lib/spack/spack/cmd/test.py
+++ b/lib/spack/spack/cmd/test.py
@@ -15,12 +15,11 @@
 from llnl.util.tty import colify

 import spack.cmd
-import spack.config
 import spack.environment as ev
 import spack.install_test
+import spack.package_base
 import spack.repo
 import spack.report
-import spack.store
 from spack.cmd.common import arguments

 description = "run spack's tests for an install"
--- a/lib/spack/spack/cmd/tutorial.py
+++ b/lib/spack/spack/cmd/tutorial.py
@@ -10,7 +10,6 @@
 from llnl.util.filesystem import working_dir

 import spack
-import spack.cmd
 import spack.config
 import spack.paths
 import spack.util.git
--- a/lib/spack/spack/cmd/undevelop.py
+++ b/lib/spack/spack/cmd/undevelop.py
@@ -6,7 +6,6 @@
 import llnl.util.tty as tty

 import spack.cmd
-import spack.config
 from spack.cmd.common import arguments

 description = "remove specs from an environment"
--- a/lib/spack/spack/cmd/unit_test.py
+++ b/lib/spack/spack/cmd/unit_test.py
@@ -10,8 +10,6 @@
 import re
 import sys

-import spack.extensions
-
 try:
    import pytest
 except ImportError:
--- a/lib/spack/spack/cmd/unload.py
+++ b/lib/spack/spack/cmd/unload.py
@@ -7,10 +7,9 @@
 import sys

 import spack.cmd
-import spack.cmd.common
 import spack.error
-import spack.store
 import spack.user_environment as uenv
+import spack.util.environment
 from spack.cmd.common import arguments

 description = "remove package from the user environment"
--- a/lib/spack/spack/cmd/verify.py
+++ b/lib/spack/spack/cmd/verify.py
@@ -6,7 +6,6 @@

 import llnl.util.tty as tty

-import spack.cmd
 import spack.environment as ev
 import spack.store
 import spack.verify
--- a/lib/spack/spack/compiler.py
+++ b/lib/spack/spack/compiler.py
@@ -202,6 +202,18 @@ class Compiler:
    support for specific compilers, their possible names, arguments,
    and how to identify the particular type of compiler."""

+    # Subclasses use possible names of C compiler
+    cc_names: List[str] = []
+
+    # Subclasses use possible names of C++ compiler
+    cxx_names: List[str] = []
+
+    # Subclasses use possible names of Fortran 77 compiler
+    f77_names: List[str] = []
+
+    # Subclasses use possible names of Fortran 90 compiler
+    fc_names: List[str] = []
+
    # Optional prefix regexes for searching for this type of compiler.
    # Prefixes are sometimes used for toolchains
    prefixes: List[str] = []
@@ -607,6 +619,18 @@ def extract_version_from_output(cls, output):
    def cc_version(cls, cc):
        return cls.default_version(cc)

+    @classmethod
+    def cxx_version(cls, cxx):
+        return cls.default_version(cxx)
+
+    @classmethod
+    def f77_version(cls, f77):
+        return cls.default_version(f77)
+
+    @classmethod
+    def fc_version(cls, fc):
+        return cls.default_version(fc)
+
    @classmethod
    def search_regexps(cls, language):
        # Compile all the regular expressions used for files beforehand.
--- a/lib/spack/spack/compilers/init.py
+++ b/lib/spack/spack/compilers/init.py
@@ -8,7 +8,6 @@
 """
 import importlib
 import os
-import re
 import sys
 import warnings
 from typing import Dict, List, Optional
@@ -26,6 +25,7 @@
 import spack.platforms
 import spack.repo
 import spack.spec
+import spack.version
 from spack.operating_systems import windows_os
 from spack.util.environment import get_path
 from spack.util.naming import mod_to_class
@@ -558,7 +558,7 @@ def get_compilers(config, cspec=None, arch_spec=None):
        except KeyError:
            # TODO: Check if this exception handling makes sense, or if we
            # TODO: need to change / refactor tests
-            family = str(arch_spec.target)
+            family = arch_spec.target
        except AttributeError:
            assert arch_spec is None

@@ -632,34 +632,37 @@ def is_mixed_toolchain(compiler):
    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 ""),
-    ]
+    cc = os.path.basename(compiler.cc or "")
+    cxx = os.path.basename(compiler.cxx or "")
+    f77 = os.path.basename(compiler.f77 or "")
+    fc = os.path.basename(compiler.fc or "")

    toolchains = set()
-    finder = spack.detection.path.ExecutablesFinder()
+    for compiler_cls in all_compiler_types():
+        # Inspect all the compiler toolchain we know. If a compiler is the
+        # only compiler supported there it belongs to that toolchain.
+        def name_matches(name, name_list):
+            # This is such that 'gcc' matches variations
+            # like 'ggc-9' etc that are found in distros
+            name, _, _ = name.partition("-")
+            return len(name_list) == 1 and name and name in name_list

-    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 any(
+            [
+                name_matches(cc, compiler_cls.cc_names),
+                name_matches(cxx, compiler_cls.cxx_names),
+                name_matches(f77, compiler_cls.f77_names),
+                name_matches(fc, compiler_cls.fc_names),
+            ]
+        ):
+            tty.debug("[TOOLCHAIN] MATCH {0}".format(compiler_cls.__name__))
+            toolchains.add(compiler_cls.__name__)

    if len(toolchains) > 1:
        if (
-            toolchains == {"llvm", "apple-clang", "aocc"}
+            toolchains == set(["Clang", "AppleClang", "Aocc"])
            # Msvc toolchain uses Intel ifx
-            or toolchains == {"msvc", "intel-oneapi-compilers"}
+            or toolchains == set(["Msvc", "Dpcpp", "Oneapi"])
        ):
            return False
        tty.debug("[TOOLCHAINS] {0}".format(toolchains))
@@ -803,11 +806,12 @@ 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")
+            target = host_platform.target("default_target").microarchitecture
        else:
            target = spec.architecture.target
            if not target:
                target = spack.platforms.host().target("default_target")
+            target = target.microarchitecture

            operating_system = spec.os
            if not operating_system:
--- a/lib/spack/spack/compilers/aocc.py
+++ b/lib/spack/spack/compilers/aocc.py
@@ -13,6 +13,18 @@


 class Aocc(Compiler):
+    # Subclasses use possible names of C compiler
+    cc_names = ["clang"]
+
+    # Subclasses use possible names of C++ compiler
+    cxx_names = ["clang++"]
+
+    # Subclasses use possible names of Fortran 77 compiler
+    f77_names = ["flang"]
+
+    # Subclasses use possible names of Fortran 90 compiler
+    fc_names = ["flang"]
+
    version_argument = "--version"

    @property
--- a/lib/spack/spack/compilers/apple_clang.py
+++ b/lib/spack/spack/compilers/apple_clang.py
@@ -8,6 +8,7 @@

 import spack.compiler
 import spack.compilers.clang
+import spack.util.executable
 from spack.version import Version


--- a/lib/spack/spack/compilers/arm.py
+++ b/lib/spack/spack/compilers/arm.py
@@ -9,6 +9,18 @@


 class Arm(spack.compiler.Compiler):
+    # Subclasses use possible names of C compiler
+    cc_names = ["armclang"]
+
+    # Subclasses use possible names of C++ compiler
+    cxx_names = ["armclang++"]
+
+    # Subclasses use possible names of Fortran 77 compiler
+    f77_names = ["armflang"]
+
+    # Subclasses use possible names of Fortran 90 compiler
+    fc_names = ["armflang"]
+
    # Named wrapper links within lib/spack/env
    link_paths = {
        "cc": os.path.join("arm", "armclang"),
@@ -78,3 +90,11 @@ def fc_pic_flag(self):
        return "-fPIC"

    required_libs = ["libclang", "libflang"]
+
+    @classmethod
+    def fc_version(cls, fc):
+        return cls.default_version(fc)
+
+    @classmethod
+    def f77_version(cls, f77):
+        return cls.fc_version(f77)
--- a/lib/spack/spack/compilers/cce.py
+++ b/lib/spack/spack/compilers/cce.py
@@ -19,6 +19,18 @@ def __init__(self, *args, **kwargs):
        if not self.is_clang_based:
            self.version_argument = "-V"

+    # Subclasses use possible names of C compiler
+    cc_names = ["craycc"]
+
+    # Subclasses use possible names of C++ compiler
+    cxx_names = ["crayCC"]
+
+    # Subclasses use possible names of Fortran 77 compiler
+    f77_names = ["crayftn"]
+
+    # Subclasses use possible names of Fortran 90 compiler
+    fc_names = ["crayftn"]
+
    # MacPorts builds gcc versions with prefixes and -mp-X.Y suffixes.
    suffixes = [r"-mp-\d\.\d"]

--- a/lib/spack/spack/compilers/clang.py
+++ b/lib/spack/spack/compilers/clang.py
@@ -31,6 +31,18 @@


 class Clang(Compiler):
+    # Subclasses use possible names of C compiler
+    cc_names = ["clang"]
+
+    # Subclasses use possible names of C++ compiler
+    cxx_names = ["clang++"]
+
+    # Subclasses use possible names of Fortran 77 compiler
+    f77_names = ["flang-new", "flang"]
+
+    # Subclasses use possible names of Fortran 90 compiler
+    fc_names = ["flang-new", "flang"]
+
    version_argument = "--version"

    @property
--- a/lib/spack/spack/compilers/fj.py
+++ b/lib/spack/spack/compilers/fj.py
@@ -9,6 +9,18 @@


 class Fj(spack.compiler.Compiler):
+    # Subclasses use possible names of C compiler
+    cc_names = ["fcc"]
+
+    # Subclasses use possible names of C++ compiler
+    cxx_names = ["FCC"]
+
+    # Subclasses use possible names of Fortran 77 compiler
+    f77_names = ["frt"]
+
+    # Subclasses use possible names of Fortran 90 compiler
+    fc_names = ["frt"]
+
    # Named wrapper links within build_env_path
    link_paths = {
        "cc": os.path.join("fj", "fcc"),
--- a/lib/spack/spack/compilers/gcc.py
+++ b/lib/spack/spack/compilers/gcc.py
@@ -4,6 +4,7 @@
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)

 import os
+import re

 from llnl.util.filesystem import ancestor

@@ -14,6 +15,18 @@


 class Gcc(spack.compiler.Compiler):
+    # Subclasses use possible names of C compiler
+    cc_names = ["gcc"]
+
+    # Subclasses use possible names of C++ compiler
+    cxx_names = ["g++"]
+
+    # Subclasses use possible names of Fortran 77 compiler
+    f77_names = ["gfortran"]
+
+    # Subclasses use possible names of Fortran 90 compiler
+    fc_names = ["gfortran"]
+
    # 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.
@@ -168,6 +181,40 @@ def default_version(cls, cc):
            version = cls.extract_version_from_output(output)
        return version

+    @classmethod
+    def fc_version(cls, fc):
+        """Older versions of gfortran use the ``-dumpversion`` option.
+        Output looks like this::
+
+            GNU Fortran (GCC) 4.4.7 20120313 (Red Hat 4.4.7-18)
+            Copyright (C) 2010 Free Software Foundation, Inc.
+
+        or::
+
+            4.8.5
+
+        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
+        """
+        output = spack.compiler.get_compiler_version_output(fc, "-dumpversion")
+        match = re.search(r"(?:GNU Fortran \(GCC\) )?([\d.]+)", output)
+        version = match.group(match.lastindex) if match else "unknown"
+        if Version(version) >= Version("7"):
+            output = spack.compiler.get_compiler_version_output(fc, "-dumpfullversion")
+            version = cls.extract_version_from_output(output)
+        return version
+
+    @classmethod
+    def f77_version(cls, f77):
+        return cls.fc_version(f77)
+
    @property
    def stdcxx_libs(self):
        return ("-lstdc++",)
--- a/Show More
+++ b/Show More