Set version to v0.22.2

xdist only slows down unit tests under coverage

.github/dependabot.yml

@@ -12,7 +12,6 @@ updates:
       interval: "daily"
   # Requirements to run style checks
   - package-ecosystem: "pip"
-    directories:
-     - "/.github/workflows/requirements/*"
+    directory: "/.github/workflows/style"
     schedule:
       interval: "daily"

.github/workflows/audit.yaml

@@ -28,8 +28,8 @@ jobs:
       run:
         shell: ${{ matrix.system.shell }}
     steps:
-    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
-    - uses: actions/setup-python@39cd14951b08e74b54015e9e001cdefcf80e669f
+    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b
+    - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
       with:
         python-version: ${{inputs.python_version}}
     - name: Install Python packages
@@ -61,7 +61,7 @@ jobs:
           ./share/spack/qa/validate_last_exit.ps1
           spack -d audit externals
           ./share/spack/qa/validate_last_exit.ps1
-    - uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673
+    - uses: codecov/codecov-action@5ecb98a3c6b747ed38dc09f787459979aebb39be
       if: ${{ inputs.with_coverage == 'true' }}
       with:
         flags: unittests,audits

.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@692973e3d937129bcbf40652eb9f2f61becf3332
+        uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b
         with:
           fetch-depth: 0
       - name: Bootstrap clingo
@@ -53,33 +53,27 @@ jobs:
     runs-on: ${{ matrix.runner }}
     strategy:
       matrix:
-        runner: ['macos-13', 'macos-14', "ubuntu-latest", "windows-latest"]
+        runner: ['macos-13', 'macos-14', "ubuntu-latest"]
     steps:
       - name: Setup macOS
-        if: ${{ matrix.runner != 'ubuntu-latest' && matrix.runner != 'windows-latest' }}
+        if: ${{ matrix.runner != 'ubuntu-latest' }}
         run: |
           brew install cmake bison tree
       - name: Checkout
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+        uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b
         with:
           fetch-depth: 0
-      - uses: actions/setup-python@39cd14951b08e74b54015e9e001cdefcf80e669f
+      - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
         with:
           python-version: "3.12"
       - name: Bootstrap clingo
-        env:
-          SETUP_SCRIPT_EXT: ${{ matrix.runner == 'windows-latest' && 'ps1' || 'sh' }}
-          SETUP_SCRIPT_SOURCE: ${{ matrix.runner == 'windows-latest' && './' || 'source ' }}
-          USER_SCOPE_PARENT_DIR: ${{ matrix.runner == 'windows-latest' && '$env:userprofile' || '$HOME' }}
-          VALIDATE_LAST_EXIT: ${{ matrix.runner == 'windows-latest' && './share/spack/qa/validate_last_exit.ps1' || '' }}
         run: |
-          ${{ env.SETUP_SCRIPT_SOURCE }}share/spack/setup-env.${{ env.SETUP_SCRIPT_EXT }}
+          source share/spack/setup-env.sh
           spack bootstrap disable github-actions-v0.5
           spack bootstrap disable github-actions-v0.4
           spack external find --not-buildable cmake bison
           spack -d solve zlib
-          ${{ env.VALIDATE_LAST_EXIT }}
-          tree ${{ env.USER_SCOPE_PARENT_DIR }}/.spack/bootstrap/store/
+          tree ~/.spack/bootstrap/store/
 
   gnupg-sources:
     runs-on: ${{ matrix.runner }}
@@ -90,13 +84,15 @@ jobs:
       - name: Setup macOS
         if: ${{ matrix.runner != 'ubuntu-latest' }}
         run: |
-          brew install tree gawk
-          sudo rm -rf $(command -v gpg gpg2)
+          brew install tree
+          # Remove GnuPG since we want to bootstrap it
+          sudo rm -rf /usr/local/bin/gpg
       - name: Setup Ubuntu
         if: ${{ matrix.runner == 'ubuntu-latest' }}
-        run: sudo rm -rf $(command -v gpg gpg2 patchelf)
+        run: |
+          sudo rm -rf $(which gpg) $(which gpg2) $(which patchelf)
       - name: Checkout
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+        uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b
         with:
           fetch-depth: 0
       - name: Bootstrap GnuPG
@@ -125,10 +121,10 @@ jobs:
         run: |
           sudo rm -rf $(which gpg) $(which gpg2) $(which patchelf)
       - name: Checkout
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+        uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b
         with:
           fetch-depth: 0
-      - uses: actions/setup-python@39cd14951b08e74b54015e9e001cdefcf80e669f
+      - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
         with:
           python-version: |
             3.8
@@ -154,7 +150,7 @@ jobs:
                 not_found=0
                 old_path="$PATH"
                 export PATH="$ver_dir:$PATH"
-                ./bin/spack-tmpconfig -b ./.github/workflows/bin/bootstrap-test.sh
+                ./bin/spack-tmpconfig -b ./.github/workflows/bootstrap-test.sh
                 export PATH="$old_path"
               fi
             fi
@@ -168,3 +164,4 @@ jobs:
           source share/spack/setup-env.sh
           spack -d gpg list
           tree ~/.spack/bootstrap/store/
+

.github/workflows/build-containers.yml

@@ -40,7 +40,8 @@ jobs:
         # 1: Platforms to build for
         # 2: Base image (e.g. ubuntu:22.04)
         dockerfile: [[amazon-linux, 'linux/amd64,linux/arm64', 'amazonlinux:2'],
-                     [centos-stream9, 'linux/amd64,linux/arm64,linux/ppc64le', 'centos:stream9'],
+                     [centos7, 'linux/amd64,linux/arm64,linux/ppc64le', 'centos:7'],
+                     [centos-stream, 'linux/amd64,linux/arm64,linux/ppc64le', 'centos:stream'],
                      [leap15, 'linux/amd64,linux/arm64,linux/ppc64le', 'opensuse/leap:15'],
                      [ubuntu-focal, 'linux/amd64,linux/arm64,linux/ppc64le', 'ubuntu:20.04'],
                      [ubuntu-jammy, 'linux/amd64,linux/arm64,linux/ppc64le', 'ubuntu:22.04'],
@@ -55,7 +56,7 @@ jobs:
     if: github.repository == 'spack/spack'
     steps:
       - name: Checkout
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+        uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b
 
       - uses: docker/metadata-action@8e5442c4ef9f78752691e2d8f8d19755c6f78e81
         id: docker_meta
@@ -76,7 +77,7 @@ jobs:
         env:
           SPACK_YAML_OS: "${{ matrix.dockerfile[2] }}"
         run: |
-          .github/workflows/bin/generate_spack_yaml_containerize.sh
+          .github/workflows/generate_spack_yaml_containerize.sh
           . share/spack/setup-env.sh
           mkdir -p dockerfiles/${{ matrix.dockerfile[0] }}
           spack containerize --last-stage=bootstrap | tee dockerfiles/${{ matrix.dockerfile[0] }}/Dockerfile
@@ -87,19 +88,19 @@ jobs:
           fi
 
       - name: Upload Dockerfile
-        uses: actions/upload-artifact@0b2256b8c012f0828dc542b3febcab082c67f72b
+        uses: actions/upload-artifact@65462800fd760344b1a7b4382951275a0abb4808
         with:
           name: dockerfiles_${{ matrix.dockerfile[0] }}
           path: dockerfiles
 
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@5927c834f5b4fdf503fca6f4c7eccda82949e1ee
+        uses: docker/setup-qemu-action@68827325e0b33c7199eb31dd4e31fbe9023e06e3
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@4fd812986e6c8c2a69e18311145f9371337f27d4
+        uses: docker/setup-buildx-action@d70bba72b1f3fd22344832f00baa16ece964efeb
 
       - name: Log in to GitHub Container Registry
-        uses: docker/login-action@0d4c9c5ea7693da7b068278f7b52bda2a190a446
+        uses: docker/login-action@e92390c5fb421da1463c202d546fed0ec5c39f20
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
@@ -107,13 +108,13 @@ jobs:
 
       - name: Log in to DockerHub
         if: github.event_name != 'pull_request'
-        uses: docker/login-action@0d4c9c5ea7693da7b068278f7b52bda2a190a446
+        uses: docker/login-action@e92390c5fb421da1463c202d546fed0ec5c39f20
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Build & Deploy ${{ matrix.dockerfile[0] }}
-        uses: docker/build-push-action@1a162644f9a7e87d8f4b053101d1d9a712edc18c
+        uses: docker/build-push-action@2cdde995de11925a030ce8070c3d77a52ffcf1c0
         with:
           context: dockerfiles/${{ matrix.dockerfile[0] }}
           platforms: ${{ matrix.dockerfile[1] }}
@@ -126,7 +127,7 @@ jobs:
     needs: deploy-images
     steps:
       - name: Merge Artifacts
-        uses: actions/upload-artifact/merge@0b2256b8c012f0828dc542b3febcab082c67f72b
+        uses: actions/upload-artifact/merge@65462800fd760344b1a7b4382951275a0abb4808
         with:
           name: dockerfiles
           pattern: dockerfiles_*

.github/workflows/ci.yaml

@@ -36,7 +36,7 @@ jobs:
       core: ${{ steps.filter.outputs.core }}
       packages: ${{ steps.filter.outputs.packages }}
     steps:
-      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+      - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b
         if: ${{ github.event_name == 'push' }}
         with:
           fetch-depth: 0
@@ -53,13 +53,6 @@ jobs:
             - 'var/spack/repos/builtin/packages/clingo/**'
             - 'var/spack/repos/builtin/packages/python/**'
             - 'var/spack/repos/builtin/packages/re2c/**'
-            - 'var/spack/repos/builtin/packages/gnupg/**'
-            - 'var/spack/repos/builtin/packages/libassuan/**'
-            - 'var/spack/repos/builtin/packages/libgcrypt/**'
-            - 'var/spack/repos/builtin/packages/libgpg-error/**'
-            - 'var/spack/repos/builtin/packages/libksba/**'
-            - 'var/spack/repos/builtin/packages/npth/**'
-            - 'var/spack/repos/builtin/packages/pinentry/**'
             - 'lib/spack/**'
             - 'share/spack/**'
             - '.github/workflows/bootstrap.yml'

.github/workflows/install_spack.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/env sh
+. share/spack/setup-env.sh
+echo -e "config:\n  build_jobs: 2" > etc/spack/config.yaml
+spack config add "packages:all:target:[x86_64]"
+spack compiler find
+spack compiler info apple-clang
+spack debug report
+spack solve zlib

.github/workflows/nightly-win-builds.yml

@@ -14,10 +14,10 @@ jobs:
   build-paraview-deps:
     runs-on: windows-latest
     steps:
-    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@39cd14951b08e74b54015e9e001cdefcf80e669f
+    - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
       with:
         python-version: 3.9
     - name: Install Python packages

.github/workflows/style/requirements.txt

@@ -1,7 +1,7 @@
 black==24.4.2
 clingo==5.7.1
-flake8==7.1.0
+flake8==7.0.0
 isort==5.13.2
 mypy==1.8.0
-types-six==1.16.21.20240513
+types-six==1.16.21.9
 vermin==1.6.0

.github/workflows/unit_tests.yaml

@@ -51,10 +51,10 @@ jobs:
           on_develop: false
 
     steps:
-    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@39cd14951b08e74b54015e9e001cdefcf80e669f
+    - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install System packages
@@ -72,7 +72,7 @@ jobs:
       run: |
           # Need this for the git tests to succeed.
           git --version
-          . .github/workflows/bin/setup_git.sh
+          . .github/workflows/setup_git.sh
     - name: Bootstrap clingo
       if: ${{ matrix.concretizer == 'clingo' }}
       env:
@@ -91,7 +91,7 @@ jobs:
           UNIT_TEST_COVERAGE: ${{ matrix.python-version == '3.11' }}
       run: |
           share/spack/qa/run-unit-tests
-    - uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673
+    - uses: codecov/codecov-action@5ecb98a3c6b747ed38dc09f787459979aebb39be
       with:
         flags: unittests,linux,${{ matrix.concretizer }}
         token: ${{ secrets.CODECOV_TOKEN }}
@@ -100,10 +100,10 @@ jobs:
   shell:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@39cd14951b08e74b54015e9e001cdefcf80e669f
+    - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
       with:
         python-version: '3.11'
     - name: Install System packages
@@ -118,13 +118,13 @@ jobs:
       run: |
           # Need this for the git tests to succeed.
           git --version
-          . .github/workflows/bin/setup_git.sh
+          . .github/workflows/setup_git.sh
     - name: Run shell tests
       env:
           COVERAGE: true
       run: |
           share/spack/qa/run-shell-tests
-    - uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673
+    - uses: codecov/codecov-action@5ecb98a3c6b747ed38dc09f787459979aebb39be
       with:
         flags: shelltests,linux
         token: ${{ secrets.CODECOV_TOKEN }}
@@ -141,13 +141,13 @@ jobs:
           dnf install -y \
               bzip2 curl file gcc-c++ gcc gcc-gfortran git gnupg2 gzip \
               make patch tcl unzip which xz
-    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b
     - name: Setup repo and non-root user
       run: |
           git --version
           git config --global --add safe.directory /__w/spack/spack
           git fetch --unshallow
-          . .github/workflows/bin/setup_git.sh
+          . .github/workflows/setup_git.sh
           useradd spack-test
           chown -R spack-test .
     - name: Run unit tests
@@ -160,10 +160,10 @@ jobs:
   clingo-cffi:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@39cd14951b08e74b54015e9e001cdefcf80e669f
+    - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
       with:
         python-version: '3.11'
     - name: Install System packages
@@ -178,14 +178,14 @@ jobs:
       run: |
           # Need this for the git tests to succeed.
           git --version
-          . .github/workflows/bin/setup_git.sh
+          . .github/workflows/setup_git.sh
     - name: Run unit tests (full suite with coverage)
       env:
           COVERAGE: true
           SPACK_TEST_SOLVER: clingo
       run: |
           share/spack/qa/run-unit-tests
-    - uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673
+    - uses: codecov/codecov-action@5ecb98a3c6b747ed38dc09f787459979aebb39be
       with:
         flags: unittests,linux,clingo
         token: ${{ secrets.CODECOV_TOKEN }}
@@ -198,10 +198,10 @@ jobs:
         os: [macos-13, macos-14]
         python-version: ["3.11"]
     steps:
-    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@39cd14951b08e74b54015e9e001cdefcf80e669f
+    - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install Python packages
@@ -217,13 +217,13 @@ jobs:
         SPACK_TEST_PARALLEL: 4
       run: |
         git --version
-        . .github/workflows/bin/setup_git.sh
+        . .github/workflows/setup_git.sh
         . share/spack/setup-env.sh
         $(which spack) bootstrap disable spack-install
         $(which spack) solve zlib
         common_args=(--dist loadfile --tx '4*popen//python=./bin/spack-tmpconfig python -u ./bin/spack python' -x)
         $(which spack) unit-test --verbose --cov --cov-config=pyproject.toml --cov-report=xml:coverage.xml "${common_args[@]}"
-    - uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673
+    - uses: codecov/codecov-action@5ecb98a3c6b747ed38dc09f787459979aebb39be
       with:
         flags: unittests,macos
         token: ${{ secrets.CODECOV_TOKEN }}
@@ -236,10 +236,10 @@ jobs:
           powershell Invoke-Expression -Command "./share/spack/qa/windows_test_setup.ps1"; {0}
     runs-on: windows-latest
     steps:
-    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+    - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@39cd14951b08e74b54015e9e001cdefcf80e669f
+    - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
       with:
         python-version: 3.9
     - name: Install Python packages
@@ -247,14 +247,14 @@ jobs:
           python -m pip install --upgrade pip pywin32 setuptools pytest-cov clingo
     - name: Create local develop
       run: |
-        ./.github/workflows/bin/setup_git.ps1
+        ./.github/workflows/setup_git.ps1
     - name: Unit Test
       run: |
         spack unit-test -x --verbose --cov --cov-config=pyproject.toml
         ./share/spack/qa/validate_last_exit.ps1
         coverage combine -a
         coverage xml
-    - uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673
+    - uses: codecov/codecov-action@125fc84a9a348dbcf27191600683ec096ec9021c
       with:
         flags: unittests,windows
         token: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/valid-style.yml

@@ -18,15 +18,15 @@ jobs:
   validate:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
-    - uses: actions/setup-python@39cd14951b08e74b54015e9e001cdefcf80e669f
+    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b
+    - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
       with:
         python-version: '3.11'
         cache: 'pip'
     - name: Install Python Packages
       run: |
         pip install --upgrade pip setuptools
-        pip install -r .github/workflows/requirements/style/requirements.txt
+        pip install -r .github/workflows/style/requirements.txt
     - name: vermin (Spack's Core)
       run: vermin --backport importlib --backport argparse --violations --backport typing -t=3.6- -vvv lib/spack/spack/ lib/spack/llnl/ bin/
     - name: vermin (Repositories)
@@ -35,22 +35,22 @@ jobs:
   style:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@39cd14951b08e74b54015e9e001cdefcf80e669f
+    - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
       with:
         python-version: '3.11'
         cache: 'pip'
     - name: Install Python packages
       run: |
         pip install --upgrade pip setuptools
-        pip install -r .github/workflows/requirements/style/requirements.txt
+        pip install -r .github/workflows/style/requirements.txt
     - name: Setup git configuration
       run: |
         # Need this for the git tests to succeed.
         git --version
-        . .github/workflows/bin/setup_git.sh
+        . .github/workflows/setup_git.sh
     - name: Run style tests
       run: |
           share/spack/qa/run-style-tests
@@ -70,13 +70,13 @@ jobs:
           dnf install -y \
               bzip2 curl file gcc-c++ gcc gcc-gfortran git gnupg2 gzip \
               make patch tcl unzip which xz
-      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+      - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b
       - name: Setup repo and non-root user
         run: |
           git --version
           git config --global --add safe.directory /__w/spack/spack
           git fetch --unshallow
-          . .github/workflows/bin/setup_git.sh
+          . .github/workflows/setup_git.sh
           useradd spack-test
           chown -R spack-test .
       - name: Bootstrap Spack development environment

CHANGELOG.md

@@ -1,3 +1,65 @@
+# v0.22.2 (2024-09-21)
+
+## Bugfixes
+- Forward compatibility with Spack 0.23 packages with language dependencies (#45205, #45191)
+- Forward compatibility with `urllib` from Python 3.12.6+ (#46453, #46483)
+- Bump vendored `archspec` for better aarch64 support (#45721, #46445)
+- Support macOS Sequoia (#45018, #45127)
+- Fix regression in `{variants.X}` and `{variants.X.value}` format strings (#46206)
+- Ensure shell escaping of environment variable values in load and activate commands (#42780)
+- Fix an issue where `spec[pkg]` considers specs outside the current DAG (#45090)
+- Do not halt concretization on unknown variants in externals (#45326)
+- Improve validation of `develop` config section (#46485)
+- Explicitly disable `ccache` if turned off in config, to avoid cache pollution (#45275)
+- Improve backwards compatibility in `include_concrete` (#45766)
+- Fix issue where package tags were sometimes repeated (#45160)
+- Make `setup-env.sh` "sourced only" by dropping execution bits (#45641)
+- Make certain source/binary fetch errors recoverable instead of a hard error (#45683)
+- Remove debug statements in package hash computation (#45235)
+- Remove redundant clingo warnings (#45269)
+- Remove hard-coded layout version (#45645)
+- Do not initialize previous store state in `use_store` (#45268)
+- Docs improvements (#46475)
+
+## Package updates
+- `chapel` major update (#42197, #44931, #45304)
+
+# v0.22.1 (2024-07-04)
+
+## Bugfixes
+- Fix reuse of externals on Linux (#44316)
+- Ensure parent gcc-runtime version >= child (#44834, #44870)
+- Ensure the latest gcc-runtime is rpath'ed when multiple exist among link deps (#44219)
+- Improve version detection of glibc (#44154)
+- Improve heuristics for solver (#44893, #44976, #45023)
+- Make strong preferences override reuse (#44373)
+- Reduce verbosity when C compiler is missing (#44182)
+- Make missing ccache executable an error when required (#44740)
+- Make every environment view containing `python` a `venv` (#44382)
+- Fix external detection for compilers with os but no target (#44156)
+- Fix version optimization for roots (#44272)
+- Handle common implementations of pagination of tags in OCI build caches (#43136)
+- Apply fetched patches to develop specs (#44950)
+- Avoid Windows wrappers for filesystem utilities on non-Windows (#44126)
+- Fix issue with long filenames in build caches on Windows (#43851)
+- Fix formatting issue in `spack audit` (#45045)
+- CI fixes (#44582, #43965, #43967, #44279, #44213)
+
+## Package updates
+- protobuf: fix 3.4:3.21 patch checksum (#44443)
+- protobuf: update hash for patch needed when="@3.4:3.21" (#44210)
+- git: bump v2.39 to 2.45; deprecate unsafe versions (#44248)
+- gcc: use -rpath {rpath_dir} not -rpath={rpath dir} (#44315)
+- Remove mesa18 and libosmesa (#44264)
+- Enforce consistency of `gl` providers (#44307)
+- Require libiconv for iconv (#44335, #45026).
+  Notice that glibc/musl also provide iconv, but are not guaranteed to be
+  complete. Set `packages:iconv:require:[glibc]` to restore the old behavior.
+- py-matplotlib: qualify when to do a post install (#44191)
+- rust: fix v1.78.0 instructions (#44127)
+- suite-sparse: improve setting of the `libs` property (#44214)
+- netlib-lapack: provide blas and lapack together (#44981)
+
 
 # v0.22.0 (2024-05-12)
 
@@ -319,6 +381,7 @@
     * 344 committers to packages
     * 45 committers to core
 
+
 # v0.21.2 (2024-03-01)
 
 ## Bugfixes
@@ -348,7 +411,7 @@
 - spack graph: fix coloring with environments (#41240)
 - spack info: sort variants in --variants-by-name (#41389)
 - Spec.format: error on old style format strings (#41934)
-- ASP-based solver: 
+- ASP-based solver:
   - fix infinite recursion when computing concretization errors (#41061)
   - don't error for type mismatch on preferences (#41138)
   - don't emit spurious debug output (#41218)

README.md

@@ -32,7 +32,7 @@
 
 Spack is a multi-platform package manager that builds and installs
 multiple versions and configurations of software. It works on Linux,
-macOS, Windows, and many supercomputers. Spack is non-destructive: installing a
+macOS, and many supercomputers. Spack is non-destructive: installing a
 new version of a package does not break existing installations, so many
 configurations of the same package can coexist.
 

bin/spack-python

@@ -22,4 +22,4 @@
 #
 # This is compatible across platforms.
 #
-exec spack python "$@"
+exec /usr/bin/env spack python "$@"

bin/spack.bat

@@ -188,27 +188,25 @@ if NOT "%_sp_args%"=="%_sp_args:--help=%" (
 goto :end_switch
 
 :case_load
-if NOT defined _sp_args (
-   exit /B 0
-)
-
-:: If args contain --bat, or -h/--help: just execute.
-if NOT "%_sp_args%"=="%_sp_args:--help=%" (
-    goto :default_case
-) else if NOT "%_sp_args%"=="%_sp_args:-h=%" (
-    goto :default_case
-) else if NOT "%_sp_args%"=="%_sp_args:--bat=%" (
-    goto :default_case
-) else if NOT "%_sp_args%"=="%_sp_args:--list=%" (
-    goto :default_case
+:: If args contain --sh, --csh, or -h/--help: just execute.
+if defined _sp_args (
+    if NOT "%_sp_args%"=="%_sp_args:--help=%" (
+        goto :default_case
+    ) else if NOT "%_sp_args%"=="%_sp_args:-h=%" (
+        goto :default_case
+    ) else if NOT "%_sp_args%"=="%_sp_args:--bat=%" (
+        goto :default_case
+    )
 )
 
 for /f "tokens=* USEBACKQ" %%I in (
-    `python "%spack%" %_sp_flags% %_sp_subcommand% --bat %_sp_args%`
-    ) do %%I
+    `python "%spack%" %_sp_flags% %_sp_subcommand% --bat %_sp_args%`) do %%I
 
 goto :end_switch
 
+:case_unload
+goto :case_load
+
 :default_case
 python "%spack%" %_sp_flags% %_sp_subcommand% %_sp_args%
 goto :end_switch

etc/spack/defaults/cray/modules.yaml

@@ -0,0 +1,16 @@
+# -------------------------------------------------------------------------
+# This is the default configuration for Spack's module file generation.
+#
+# Settings here are versioned with Spack and are intended to provide
+# sensible defaults out of the box. Spack maintainers should edit this
+# file to keep it current.
+#
+# Users can override these settings by editing the following files.
+#
+# Per-spack-instance settings (overrides defaults):
+#   $SPACK_ROOT/etc/spack/modules.yaml
+#
+# Per-user settings (overrides default and site settings):
+#   ~/.spack/modules.yaml
+# -------------------------------------------------------------------------
+modules: {}

lib/spack/docs/basic_usage.rst

@@ -1433,12 +1433,22 @@ the reserved keywords ``platform``, ``os`` and ``target``:
    $ spack install libelf os=ubuntu18.04
    $ spack install libelf target=broadwell
 
+or together by using the reserved keyword ``arch``:
+
+.. code-block:: console
+
+   $ spack install libelf arch=cray-CNL10-haswell
+
 Normally users don't have to bother specifying the architecture if they
 are installing software for their current host, as in that case the
 values will be detected automatically.  If you need fine-grained control
 over which packages use which targets (or over *all* packages' default
 target), see :ref:`package-preferences`.
 
+.. admonition:: Cray machines
+
+  The situation is a little bit different for Cray machines and a detailed
+  explanation on how the architecture can be set on them can be found at :ref:`cray-support`
 
 .. _support-for-microarchitectures:
 

lib/spack/docs/build_systems/autotoolspackage.rst

@@ -147,15 +147,6 @@ example, the ``bash`` shell is used to run the ``autogen.sh`` script.
    def autoreconf(self, spec, prefix):
        which("bash")("autogen.sh")
 
-If the ``package.py`` has build instructions in a separate
-:ref:`builder class <multiple_build_systems>`, the signature for a phase changes slightly:
-
-.. code-block:: python
-
-   class AutotoolsBuilder(AutotoolsBuilder):
-      def autoreconf(self, pkg, spec, prefix):
-         which("bash")("autogen.sh")
-
 """""""""""""""""""""""""""""""""""""""
 patching configure or Makefile.in files
 """""""""""""""""""""""""""""""""""""""

lib/spack/docs/build_systems/inteloneapipackage.rst

@@ -25,7 +25,7 @@ use Spack to build packages with the tools.
 The Spack Python class ``IntelOneapiPackage`` is a base class that is
 used by ``IntelOneapiCompilers``, ``IntelOneapiMkl``,
 ``IntelOneapiTbb`` and other classes to implement the oneAPI
-packages. Search for ``oneAPI`` at `packages.spack.io <https://packages.spack.io>`_ for the full
+packages. Search for ``oneAPI`` at `<packages.spack.io>`_ for the full
 list of available oneAPI packages, or use::
 
   spack list -d oneAPI

lib/spack/docs/chain.rst

@@ -5,14 +5,13 @@
 
 .. chain:
 
-============================
-Chaining Spack Installations
-============================
+=============================================
+Chaining Spack Installations (upstreams.yaml)
+=============================================
 
 You can point your Spack installation to another installation to use any
 packages that are installed there. To register the other Spack instance,
-you can add it as an entry to ``upstreams.yaml`` at any of the
-:ref:`configuration-scopes`:
+you can add it as an entry to ``upstreams.yaml``:
 
 .. code-block:: yaml
 
@@ -23,8 +22,7 @@ you can add it as an entry to ``upstreams.yaml`` at any of the
       install_tree: /path/to/another/spack/opt/spack
 
 ``install_tree`` must point to the ``opt/spack`` directory inside of the
-Spack base directory, or the location of the ``install_tree`` defined
-in :ref:`config.yaml <config-yaml>`.
+Spack base directory.
 
 Once the upstream Spack instance has been added, ``spack find`` will
 automatically check the upstream instance when querying installed packages,

lib/spack/docs/containers.rst

@@ -203,9 +203,12 @@ The OS that are currently supported are summarized in the table below:
    * - Ubuntu 24.04
      - ``ubuntu:24.04``
      - ``spack/ubuntu-noble``
-   * - CentOS Stream9
-     - ``quay.io/centos/centos:stream9``
-     - ``spack/centos-stream9``
+   * - CentOS 7
+     - ``centos:7``
+     - ``spack/centos7``
+   * - CentOS Stream
+     - ``quay.io/centos/centos:stream``
+     - ``spack/centos-stream``
    * - openSUSE Leap
      - ``opensuse/leap``
      - ``spack/leap15``

lib/spack/docs/environments.rst

@@ -931,84 +931,32 @@ This allows for a much-needed reduction in redundancy between packages
 and constraints.
 
 
------------------
-Environment Views
------------------
+----------------
+Filesystem Views
+----------------
 
-Spack Environments can have an associated filesystem view, which is a directory
-with a more traditional structure ``<view>/bin``, ``<view>/lib``, ``<view>/include``
-in which all files of the installed packages are linked.
-
-By default a view is created for each environment, thanks to the ``view: true``
-option in the ``spack.yaml`` manifest file:
-
-.. code-block:: yaml
-
-   spack:
-     specs: [perl, python]
-     view: true
-
-The view is created in a hidden directory ``.spack-env/view`` relative to the environment.
-If you've used ``spack env activate``, you may have already interacted with this view. Spack
-prepends its ``<view>/bin`` dir to ``PATH`` when the environment is activated, so that
-you can directly run executables from all installed packages in the environment.
-
-Views are highly customizable: you can control where they are put, modify their structure,
-include and exclude specs, change how files are linked, and you can even generate multiple
-views for a single environment.
+Spack Environments can define filesystem views, which provide a direct access point
+for software similar to the directory hierarchy that might exist under ``/usr/local``.
+Filesystem views are updated every time the environment is written out to the lock
+file ``spack.lock``, so the concrete environment and the view are always compatible.
+The files of the view's installed packages are brought into the view by symbolic or
+hard links, referencing the original Spack installation, or by copy.
 
 .. _configuring_environment_views:
 
-^^^^^^^^^^^^^^^^^^^^^^^^^^
-Minimal view configuration
-^^^^^^^^^^^^^^^^^^^^^^^^^^
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Configuration in ``spack.yaml``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-The minimal configuration
-
-.. code-block:: yaml
-
-   spack:
-     # ...
-     view: true
-
-lets Spack generate a single view with default settings under the
-``.spack-env/view`` directory of the environment.
-
-Another short way to configure a view is to specify just where to put it:
-
-.. code-block:: yaml
-
-   spack:
-     # ...
-     view: /path/to/view
-
-Views can also be disabled by setting ``view: false``.
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Advanced view configuration
-^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-One or more **view descriptors** can be defined under ``view``, keyed by a name.
-The example from the previous section with ``view: /path/to/view`` is equivalent
-to defining a view descriptor named ``default`` with a ``root`` attribute:
-
-.. code-block:: yaml
-
-   spack:
-     # ...
-     view:
-       default:  # name of the view
-         root: /path/to/view  # view descriptor attribute
-
-The ``default`` view descriptor name is special: when you ``spack env activate`` your
-environment, this view will be used to update (among other things) your ``PATH``
-variable.
-
-View descriptors must contain the root of the view, and optionally projections,
-``select`` and ``exclude`` lists and link information via ``link`` and
+The Spack Environment manifest file has a top-level keyword
+``view``. Each entry under that heading is a **view descriptor**, headed
+by a name. Any number of views may be defined under the ``view`` heading.
+The view descriptor contains the root of the view, and
+optionally the projections for the view, ``select`` and
+``exclude`` lists for the view and link information via ``link`` and
 ``link_type``.
 
-As a more advanced example, in the following manifest
+For example, in the following manifest
 file snippet we define a view named ``mpis``, rooted at
 ``/path/to/view`` in which all projections use the package name,
 version, and compiler name to determine the path for a given
@@ -1053,10 +1001,59 @@ of ``hardlink`` or ``copy``.
    when the environment is not activated, and linked libraries will be located
    *outside* of the view thanks to rpaths.
 
+
+There are two shorthands for environments with a single view. If the
+environment at ``/path/to/env`` has a single view, with a root at
+``/path/to/env/.spack-env/view``, with default selection and exclusion
+and the default projection, we can put ``view: True`` in the
+environment manifest. Similarly, if the environment has a view with a
+different root, but default selection, exclusion, and projections, the
+manifest can say ``view: /path/to/view``. These views are
+automatically named ``default``, so that
+
+.. code-block:: yaml
+
+   spack:
+     # ...
+     view: True
+
+is equivalent to
+
+.. code-block:: yaml
+
+   spack:
+     # ...
+     view:
+       default:
+         root: .spack-env/view
+
+and
+
+.. code-block:: yaml
+
+   spack:
+     # ...
+     view: /path/to/view
+
+is equivalent to
+
+.. code-block:: yaml
+
+   spack:
+     # ...
+     view:
+       default:
+         root: /path/to/view
+
+By default, Spack environments are configured with ``view: True`` in
+the manifest. Environments can be configured without views using
+``view: False``. For backwards compatibility reasons, environments
+with no ``view`` key are treated the same as ``view: True``.
+
 From the command line, the ``spack env create`` command takes an
 argument ``--with-view [PATH]`` that sets the path for a single, default
 view. If no path is specified, the default path is used (``view:
-true``). The argument ``--without-view`` can be used to create an
+True``). The argument ``--without-view`` can be used to create an
 environment without any view configured.
 
 The ``spack env view`` command can be used to change the manage views
@@ -1122,18 +1119,11 @@ the projection under ``all`` before reaching those entries.
 Activating environment views
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-The ``spack env activate <env>`` has two effects:
-
-1. It activates the environment so that further Spack commands such
-   as ``spack install`` will run in the context of the environment.
-2. It activates the view so that environment variables such as
-   ``PATH`` are updated to include the view.
-
-Without further arguments, the ``default`` view of the environment is
-activated. If a view with a different name has to be activated,
-``spack env activate --with-view <name> <env>`` can be
-used instead. You can also activate the environment without modifying
-further environment variables using ``--without-view``.
+The ``spack env activate`` command will put the default view for the
+environment into the user's path, in addition to activating the
+environment for Spack commands. The arguments ``-v,--with-view`` and
+``-V,--without-view`` can be used to tune this behavior. The default
+behavior is to activate with the environment view if there is one.
 
 The environment variables affected by the ``spack env activate``
 command and the paths that are used to update them are determined by
@@ -1156,8 +1146,8 @@ relevant variable if the path exists. For this reason, it is not
 recommended to use non-default projections with the default view of an
 environment.
 
-The ``spack env deactivate`` command will remove the active view of
-the Spack environment from the user's environment variables.
+The ``spack env deactivate`` command will remove the default view of
+the environment from the user's path.
 
 
 .. _env-generate-depfile:
@@ -1316,7 +1306,7 @@ index once every package is pushed. Note how this target uses the generated
    example/push/%: example/install/%
    	@mkdir -p $(dir $@)
    	$(info About to push $(SPEC) to a buildcache)
-   	$(SPACK) -e . buildcache push --only=package $(BUILDCACHE_DIR) /$(HASH)
+   	$(SPACK) -e . buildcache push --allow-root --only=package $(BUILDCACHE_DIR) /$(HASH)
    	@touch $@
 
    push: $(addprefix example/push/,$(example/SPACK_PACKAGE_IDS))

lib/spack/docs/getting_started.rst

@@ -1364,6 +1364,187 @@ This will write the private key to the file `dinosaur.priv`.
     or for help on an issue or the Spack slack.
 
 
+.. _cray-support:
+
+-------------
+Spack on Cray
+-------------
+
+Spack differs slightly when used on a Cray system. The architecture spec
+can differentiate between the front-end and back-end processor and operating system.
+For example, on Edison at NERSC, the back-end target processor
+is "Ivy Bridge", so you can specify to use the back-end this way:
+
+.. code-block:: console
+
+   $ spack install zlib target=ivybridge
+
+You can also use the operating system to build against the back-end:
+
+.. code-block:: console
+
+   $ spack install zlib os=CNL10
+
+Notice that the name includes both the operating system name and the major
+version number concatenated together.
+
+Alternatively, if you want to build something for the front-end,
+you can specify the front-end target processor. The processor for a login node
+on Edison is "Sandy bridge" so we specify on the command line like so:
+
+.. code-block:: console
+
+   $ spack install zlib target=sandybridge
+
+And the front-end operating system is:
+
+.. code-block:: console
+
+   $ spack install zlib os=SuSE11
+
+^^^^^^^^^^^^^^^^^^^^^^^
+Cray compiler detection
+^^^^^^^^^^^^^^^^^^^^^^^
+
+Spack can detect compilers using two methods. For the front-end, we treat
+everything the same. The difference lies in back-end compiler detection.
+Back-end compiler detection is made via the Tcl module avail command.
+Once it detects the compiler it writes the appropriate PrgEnv and compiler
+module name to compilers.yaml and sets the paths to each compiler with Cray\'s
+compiler wrapper names (i.e. cc, CC, ftn). During build time, Spack will load
+the correct PrgEnv and compiler module and will call appropriate wrapper.
+
+The compilers.yaml config file will also differ. There is a
+modules section that is filled with the compiler's Programming Environment
+and module name. On other systems, this field is empty []:
+
+.. code-block:: yaml
+
+   - compiler:
+       modules:
+         - PrgEnv-intel
+         - intel/15.0.109
+
+As mentioned earlier, the compiler paths will look different on a Cray system.
+Since most compilers are invoked using cc, CC and ftn, the paths for each
+compiler are replaced with their respective Cray compiler wrapper names:
+
+.. code-block:: yaml
+
+     paths:
+       cc: cc
+       cxx: CC
+       f77: ftn
+       fc: ftn
+
+As opposed to an explicit path to the compiler executable. This allows Spack
+to call the Cray compiler wrappers during build time.
+
+For more on compiler configuration, check out :ref:`compiler-config`.
+
+Spack sets the default Cray link type to dynamic, to better match other
+other platforms. Individual packages can enable static linking (which is the
+default outside of Spack on cray systems) using the ``-static`` flag.
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Setting defaults and using Cray modules
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+If you want to use default compilers for each PrgEnv and also be able
+to load cray external modules, you will need to set up a ``packages.yaml``.
+
+Here's an example of an external configuration for cray modules:
+
+.. code-block:: yaml
+
+   packages:
+     mpich:
+       externals:
+       - spec: "mpich@7.3.1%gcc@5.2.0 arch=cray_xc-haswell-CNL10"
+         modules:
+         - cray-mpich
+       - spec: "mpich@7.3.1%intel@16.0.0.109 arch=cray_xc-haswell-CNL10"
+         modules:
+         - cray-mpich
+     all:
+       providers:
+         mpi: [mpich]
+
+This tells Spack that for whatever package that depends on mpi, load the
+cray-mpich module into the environment. You can then be able to use whatever
+environment variables, libraries, etc, that are brought into the environment
+via module load.
+
+.. note::
+
+    For Cray-provided packages, it is best to use ``modules:`` instead of ``prefix:``
+    in ``packages.yaml``, because the Cray Programming Environment heavily relies on
+    modules (e.g., loading the ``cray-mpich`` module adds MPI libraries to the
+    compiler wrapper link line).
+
+You can set the default compiler that Spack can use for each compiler type.
+If you want to use the Cray defaults, then set them under ``all:`` in packages.yaml.
+In the compiler field, set the compiler specs in your order of preference.
+Whenever you build with that compiler type, Spack will concretize to that version.
+
+Here is an example of a full packages.yaml used at NERSC
+
+.. code-block:: yaml
+
+   packages:
+     mpich:
+       externals:
+       - spec: "mpich@7.3.1%gcc@5.2.0 arch=cray_xc-CNL10-ivybridge"
+         modules:
+         - cray-mpich
+       - spec: "mpich@7.3.1%intel@16.0.0.109 arch=cray_xc-SuSE11-ivybridge"
+         modules:
+         - cray-mpich
+       buildable: False
+     netcdf:
+       externals:
+       - spec: "netcdf@4.3.3.1%gcc@5.2.0 arch=cray_xc-CNL10-ivybridge"
+         modules:
+         - cray-netcdf
+       - spec: "netcdf@4.3.3.1%intel@16.0.0.109 arch=cray_xc-CNL10-ivybridge"
+         modules:
+         - cray-netcdf
+       buildable: False
+     hdf5:
+       externals:
+       - spec: "hdf5@1.8.14%gcc@5.2.0 arch=cray_xc-CNL10-ivybridge"
+         modules:
+         - cray-hdf5
+       - spec: "hdf5@1.8.14%intel@16.0.0.109 arch=cray_xc-CNL10-ivybridge"
+         modules:
+         - cray-hdf5
+       buildable: False
+     all:
+       compiler: [gcc@5.2.0, intel@16.0.0.109]
+       providers:
+         mpi: [mpich]
+
+Here we tell spack that whenever we want to build with gcc use version 5.2.0 or
+if we want to build with intel compilers, use version 16.0.0.109. We add a spec
+for each compiler type for each cray modules. This ensures that for each
+compiler on our system we can use that external module.
+
+For more on external packages check out the section :ref:`sec-external-packages`.
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Using Linux containers on Cray machines
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Spack uses environment variables particular to the Cray programming
+environment to determine which systems are Cray platforms. These
+environment variables may be propagated into containers that are not
+using the Cray programming environment.
+
+To ensure that Spack does not autodetect the Cray programming
+environment, unset the environment variable ``MODULEPATH``. This
+will cause Spack to treat a linux container on a Cray system as a base
+linux distro.
+
 .. _windows_support:
 
 ----------------

lib/spack/docs/packaging_guide.rst

@@ -2344,27 +2344,6 @@ you set ``parallel`` to ``False`` at the package level, then each call
 to ``make()`` will be sequential by default, but packagers can call
 ``make(parallel=True)`` to override it.
 
-Note that the ``--jobs`` option works out of the box for all standard
-build systems. If you are using a non-standard build system instead, you
-can use the variable ``make_jobs`` to extract the number of jobs specified
-by the ``--jobs`` option:
-
-.. code-block:: python
-   :emphasize-lines: 7, 11
-   :linenos:
- 
-   class Xios(Package):
-      ...
-      def install(self, spec, prefix):
-         ...
-         options = [
-            ...
-            '--jobs', str(make_jobs),
-        ]
-        ...
-        make_xios = Executable("./make_xios")
-        make_xios(*options)
-
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 Install-level build parallelism
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -5194,6 +5173,12 @@ installed executable. The check is implemented as follows:
                 reframe = Executable(self.prefix.bin.reframe)
                 reframe("-l")
 
+.. warning::
+
+    The API for adding tests is not yet considered stable and may change
+    in future releases.
+
+
 """"""""""""""""""""""""""""""""
 Checking build-time test results
 """"""""""""""""""""""""""""""""
@@ -5231,42 +5216,38 @@ be left in the build stage directory as illustrated below:
 Stand-alone tests
 ^^^^^^^^^^^^^^^^^
 
-While build-time tests are integrated with the installation process, stand-alone
+While build-time tests are integrated with the build process, stand-alone
 tests are expected to run days, weeks, even months after the software is
 installed. The goal is to provide a mechanism for gaining confidence that
 packages work as installed **and** *continue* to work as the underlying
 software evolves. Packages can add and inherit stand-alone tests. The
-``spack test`` command is used for stand-alone testing.
+`spack test`` command is used to manage stand-alone testing.
 
-.. admonition:: Stand-alone test methods should complete within a few minutes.
+.. note::
 
     Execution speed is important since these tests are intended to quickly
-    assess whether installed specs work on the system. Spack cannot spare
-    resources for more extensive testing of packages included in CI stacks.
+    assess whether installed specs work on the system. Consequently, they
+    should run relatively quickly -- as in on the order of at most a few
+    minutes -- while ideally executing all, or at least key aspects of the
+    installed software.
 
-    Consequently, stand-alone tests should run relatively quickly -- as in
-    on the order of at most a few minutes -- while testing at least key aspects
-    of the installed software. Save more extensive testing for other tools.
+.. note::
+
+    Failing stand-alone tests indicate problems with the installation and,
+    therefore, there is no reason to proceed with more resource-intensive
+    tests until those have been investigated.
+
+    Passing stand-alone tests indicate that more thorough testing, such
+    as running extensive unit or regression tests, or tests that run at
+    scale can proceed without wasting resources on a problematic installation.
 
 Tests are defined in the package using methods with names beginning ``test_``.
 This allows Spack to support multiple independent checks, or parts. Files
 needed for testing, such as source, data, and expected outputs, may be saved
 from the build and or stored with the package in the repository. Regardless
 of origin, these files are automatically copied to the spec's test stage
-directory prior to execution of the test method(s). Spack also provides helper
-functions to facilitate common processing.
-
-.. tip::
-
-    **The status of stand-alone tests can be used to guide follow-up testing efforts.**
-
-    Passing stand-alone tests justify performing more thorough testing, such
-    as running extensive unit or regression tests or tests that run at scale,
-    when available. These tests are outside of the scope of Spack packaging.
-
-    Failing stand-alone tests indicate problems with the installation and,
-    therefore, no reason to proceed with more resource-intensive tests until
-    the failures have been investigated.
+directory prior to execution of the test method(s). Spack also provides some
+helper functions to facilitate processing.
 
 .. _configure-test-stage:
 
@@ -5274,26 +5255,30 @@ functions to facilitate common processing.
 Configuring the test stage directory
 """"""""""""""""""""""""""""""""""""
 
-Stand-alone tests utilize a test stage directory to build, run, and track
-tests in the same way Spack uses a build stage directory to install software.
-The default test stage root directory, ``$HOME/.spack/test``, is defined in
-:ref:`config.yaml <config-yaml>`. This location is customizable by adding or
-changing the ``test_stage`` path such that:
+Stand-alone tests utilize a test stage directory for building, running,
+and tracking results in the same way Spack uses a build stage directory.
+The default test stage root directory, ``~/.spack/test``, is defined in
+:ref:`etc/spack/defaults/config.yaml <config-yaml>`. This location is
+customizable by adding or changing the ``test_stage`` path in the high-level
+``config`` of the appropriate ``config.yaml`` file such that:
 
 .. code-block:: yaml
 
    config:
      test_stage: /path/to/test/stage
 
-Packages can use the ``self.test_suite.stage`` property to access the path.
+Packages can use the ``self.test_suite.stage`` property to access this setting.
+Other package properties that provide access to spec-specific subdirectories
+and files are described in :ref:`accessing staged files <accessing-files>`.
 
-.. admonition:: Each spec being tested has its own test stage directory.
+.. note::
 
-   The ``config:test_stage`` option is the path to the root of a
-   **test suite**'s stage directories.
+   The test stage path is the root directory for the **entire suite**.
+   In other words, it is the root directory for **all specs** being
+   tested by the ``spack test run`` command. Each spec gets its own
+   stage subdirectory. Use ``self.test_suite.test_dir_for_spec(self.spec)``
+   to access the spec-specific test stage directory.
 
-   Other package properties that provide paths to spec-specific subdirectories
-   and files are described in :ref:`accessing-files`.
 
 .. _adding-standalone-tests:
 
@@ -5306,144 +5291,61 @@ Test recipes are defined in the package using methods with names beginning
 Each method has access to the information Spack tracks on the package, such
 as options, compilers, and dependencies, supporting the customization of tests
 to the build. Standard python ``assert`` statements and other error reporting
-mechanisms can be used. These exceptions are automatically caught and reported
+mechanisms are available. Such exceptions are automatically caught and reported
 as test failures.
 
-Each test method is an *implicit test part* named by the method. Its purpose
-is the method's docstring. Providing a meaningful purpose for the test gives
-context that can aid debugging. Spack outputs both the name and purpose at the
-start of test execution so it's also important that the docstring/purpose be
-brief.
-
-.. tip::
-
-    We recommend naming test methods so it is clear *what* is being tested.
-    For example, if a test method is building and or running an executable
-    called ``example``, then call the method ``test_example``. This, together
-    with a similarly meaningful test purpose, will aid test comprehension,
-    debugging, and maintainability.
-
-Stand-alone tests run in an environment that provides access to information
-on the installed software, such as build options, dependencies, and compilers.
-Build options and dependencies are accessed using the same spec checks used
-by build recipes. Examples of checking :ref:`variant settings <variants>` and
-:ref:`spec constraints <testing-specs>` can be found at the provided links.
-
-.. admonition:: Spack automatically sets up the test stage directory and environment.
-
-    Spack automatically creates the test stage directory and copies
-    relevant files *prior to* running tests. It can also ensure build
-    dependencies are available **if** necessary.
-
-    The path to the test stage is configurable (see :ref:`configure-test-stage`).
-
-    Files that Spack knows to copy are those saved from the build (see
-    :ref:`cache_extra_test_sources`) and those added to the package repository
-    (see :ref:`cache_custom_files`).
-
-    Spack will use the value of the ``test_requires_compiler`` property to
-    determine whether it needs to also set up build dependencies (see
-    :ref:`test-build-tests`).
-
-The ``MyPackage`` package below provides two basic test examples: 
-``test_example`` and ``test_example2``.  The first runs the installed
-``example`` and ensures its output contains an expected string. The second
-runs ``example2`` without checking output so is only concerned with confirming
-the executable runs successfully. If the installed spec is not expected to have
-``example2``, then the check at the top of the method will raise a special
-``SkipTest`` exception, which is captured to facilitate reporting skipped test
-parts to tools like CDash.
+Each test method is an implicit test part named by the method and whose
+purpose is the method's docstring. Providing a purpose gives context for
+aiding debugging. A test method may contain embedded test parts. Spack
+outputs the test name and purpose prior to running each test method and
+any embedded test parts. For example, ``MyPackage`` below provides two basic
+examples of installation tests: ``test_always_fails`` and ``test_example``.
+As the name indicates, the first always fails. The second simply runs the
+installed example.
 
 .. code-block:: python
 
    class MyPackage(Package):
        ...
 
+       def test_always_fails(self):
+           """use assert to always fail"""
+           assert False
+
        def test_example(self):
-           """ensure installed example works"""
-           expected = "Done."
+           """run installed example"""
            example = which(self.prefix.bin.example)
-
-           # Capture stdout and stderr from running the Executable
-           # and check that the expected output was produced.
-           out = example(output=str.split, error=str.split)
-           assert expected in out, f"Expected '{expected}' in the output"
-
-       def test_example2(self):
-           """run installed example2"""
-           if self.spec.satisfies("@:1.0"):
-               # Raise SkipTest to ensure flagging the test as skipped for
-               # test reporting purposes.
-               raise SkipTest("Test is only available for v1.1 on")
-
-           example2 = which(self.prefix.bin.example2)
-           example2()
+           example()
 
 Output showing the identification of each test part after running the tests
 is illustrated below.
 
 .. code-block:: console
 
-   $ spack test run --alias mypackage mypackage@2.0
+   $ spack test run --alias mypackage mypackage@1.0
    ==> Spack test mypackage
    ...
    $ spack test results -l mypackage
    ==> Results for test suite 'mypackage':
    ...
-   ==> [2024-03-10-16:03:56.625439] test: test_example: ensure installed example works
+   ==> [2023-03-10-16:03:56.625204] test: test_always_fails: use assert to always fail
    ...
-   PASSED: MyPackage::test_example
-   ==> [2024-03-10-16:03:56.625439] test: test_example2: run installed example2
+   FAILED
+   ==> [2023-03-10-16:03:56.625439] test: test_example: run installed example
    ...
-   PASSED: MyPackage::test_example2
+   PASSED
 
-.. admonition:: Do NOT implement tests that must run in the installation prefix.
 
-   Use of the package spec's installation prefix for building and running
-   tests is **strongly discouraged**. Doing so causes permission errors for
-   shared spack instances *and* facilities that install the software in
-   read-only file systems or directories.
+.. note::
 
-   Instead, start these test methods by explicitly copying the needed files
-   from the installation prefix to the test stage directory. Note the test
-   stage directory is the current directory when the test is executed with
-   the ``spack test run`` command.
+   If ``MyPackage`` were a recipe for a library, the tests should build
+   an example or test program that is then executed.
 
-.. admonition:: Test methods for library packages should build test executables.
+A test method can include test parts using the ``test_part`` context manager.
+Each part is treated as an independent check to allow subsequent test parts
+to execute even after a test part fails.
 
-   Stand-alone tests for library packages *should* build test executables
-   that utilize the *installed* library. Doing so ensures the tests follow
-   a similar build process that users of the library would follow.
-
-   For more information on how to do this, see :ref:`test-build-tests`.
-
-.. tip::
-
-   If you want to see more examples from packages with stand-alone tests, run
-   ``spack pkg grep "def\stest" | sed "s/\/package.py.*//g" | sort -u``
-   from the command line to get a list of the packages.
-
-.. _adding-standalone-test-parts:
-
-"""""""""""""""""""""""""""""
-Adding stand-alone test parts
-"""""""""""""""""""""""""""""
-
-Sometimes dependencies between steps of a test lend themselves to being
-broken into parts. Tracking the pass/fail status of each part may aid
-debugging. Spack provides a ``test_part`` context manager for use within
-test methods.
-
-Each test part is independently run, tracked, and reported. Test parts are
-executed in the order they appear. If one fails, subsequent test parts are
-still performed even if they would also fail. This allows tools like CDash
-to track and report the status of test parts across runs. The pass/fail status
-of the enclosing test is derived from the statuses of the embedded test parts.
-
-.. admonition:: Test method and test part names **must** be unique.
-
-   Test results reporting requires that test methods and embedded test parts
-   within a package have unique names.
+.. _test-part:
 
 The signature for ``test_part`` is:
 
@@ -5465,68 +5367,40 @@ where each argument has the following meaning:
 * ``work_dir`` is the path to the directory in which the test will run.
 
   The default of ``None``, or ``"."``, corresponds to the the spec's test
-  stage (i.e., ``self.test_suite.test_dir_for_spec(self.spec)``).
+  stage (i.e., ``self.test_suite.test_dir_for_spec(self.spec)``.
 
-.. admonition:: Start test part names with the name of the enclosing test.
+.. admonition:: Tests should **not** run under the installation directory.
 
-   We **highly recommend** starting the names of test parts with the name
-   of the enclosing test. Doing so helps with the comprehension, readability
-   and debugging of test results.
+   Use of the package spec's installation directory for building and running
+   tests is **strongly** discouraged. Doing so causes permission errors for
+   shared spack instances *and* facilities that install the software in
+   read-only file systems or directories.
 
-Suppose ``MyPackage`` installs multiple executables that need to run in a
-specific order since the outputs from one are inputs of others. Further suppose
-we want to add an integration test that runs the executables in order. We can
-accomplish this goal by implementing a stand-alone test method consisting of
-test parts for each executable as follows:
+Suppose ``MyPackage`` actually installs two examples we want to use for tests.
+These checks can be implemented as separate checks or, as illustrated below,
+embedded test parts.
 
 .. code-block:: python
 
    class MyPackage(Package):
        ...
 
-       def test_series(self):
-           """run setup, perform, and report"""
+       def test_example(self):
+           """run installed examples"""
+           for example in ["ex1", "ex2"]:
+               with test_part(
+                   self,
+                   f"test_example_{example}",
+                   purpose=f"run installed {example}",
+                ):
+                    exe = which(join_path(self.prefix.bin, example))
+                    exe()
 
-           with test_part(self, "test_series_setup", purpose="setup operation"):
-                exe = which(self.prefix.bin.setup))
-                exe()
-
-           with test_part(self, "test_series_run", purpose="perform operation"):
-                exe = which(self.prefix.bin.run))
-                exe()
-
-           with test_part(self, "test_series_report", purpose="generate report"):
-                exe = which(self.prefix.bin.report))
-                exe()
-
-The result is ``test_series`` runs the following executable in order: ``setup``,
-``run``, and ``report``. In this case no options are passed to any of the
-executables and no outputs from running them are checked. Consequently, the
-implementation could be simplified with a for-loop as follows:
-
-.. code-block:: python
-
-   class MyPackage(Package):
-       ...
-
-       def test_series(self):
-           """execute series setup, run, and report"""
-
-           for exe, reason in [
-               ("setup", "setup operation"),
-               ("run", "perform operation"),
-               ("report", "generate report")
-           ]:
-               with test_part(self, f"test_series_{exe}", purpose=reason):
-                   exe = which(self.prefix.bin.join(exe))
-                   exe()
-
-In both cases, since we're using a context manager, each test part in
-``test_series`` will execute regardless of the status of the other test
-parts.
-
-Now let's look at the output from running the stand-alone tests where
-the second test part, ``test_series_run``, fails.
+In this case, there will be an implicit test part for ``test_example``
+and separate sub-parts for ``ex1`` and ``ex2``. The second sub-part
+will be executed regardless of whether the first passes. The test
+log for a run where the first executable fails and the second passes
+is illustrated below.
 
 .. code-block:: console
 
@@ -5536,68 +5410,50 @@ the second test part, ``test_series_run``, fails.
    $ spack test results -l mypackage
    ==> Results for test suite 'mypackage':
    ...
-   ==> [2024-03-10-16:03:56.625204] test: test_series: execute series setup, run, and report
-   ==> [2024-03-10-16:03:56.625439] test: test_series_setup: setup operation
+   ==> [2023-03-10-16:03:56.625204] test: test_example: run installed examples
+   ==> [2023-03-10-16:03:56.625439] test: test_example_ex1: run installed ex1
    ...
-   PASSED: MyPackage::test_series_setup
-   ==> [2024-03-10-16:03:56.625555] test: test_series_run: perform operation
+   FAILED
+   ==> [2023-03-10-16:03:56.625555] test: test_example_ex2: run installed ex2
    ...
-   FAILED: MyPackage::test_series_run
-   ==> [2024-03-10-16:03:57.003456] test: test_series_report: generate report
-   ...
-   FAILED: MyPackage::test_series_report
-   FAILED: MyPackage::test_series
+   PASSED
    ...
 
-Since test parts depended on the success of previous parts, we see that the
-failure of one results in the failure of subsequent checks and the overall
-result of the test method, ``test_series``, is failure.
+.. warning::
 
-.. tip::
+   Test results reporting requires that each test method and embedded
+   test part for a package have a unique name.
 
-   If you want to see more examples from packages using ``test_part``, run
-   ``spack pkg grep "test_part(" | sed "s/\/package.py.*//g" | sort -u``
-   from the command line to get a list of the packages.
+Stand-alone tests run in an environment that provides access to information
+Spack has on how the software was built, such as build options, dependencies,
+and compilers. Build options and dependencies are accessed with the normal
+spec checks. Examples of checking :ref:`variant settings <variants>` and
+:ref:`spec constraints <testing-specs>` can be found at the provided links.
+Accessing compilers in stand-alone tests that are used by the build requires
+setting a package property as described :ref:`below <test-compilation>`.
 
-.. _test-build-tests:
 
-"""""""""""""""""""""""""""""""""""""
-Building and running test executables
-"""""""""""""""""""""""""""""""""""""
+.. _test-compilation:
 
-.. admonition:: Re-use build-time sources and (small) input data sets when possible.
+"""""""""""""""""""""""""
+Enabling test compilation
+"""""""""""""""""""""""""
 
-    We **highly recommend** re-using build-time test sources and pared down
-    input files for testing installed software. These files are easier
-    to keep synchronized with software capabilities when they reside
-    within the software's repository. More information on saving files from
-    the installation process can be found at :ref:`cache_extra_test_sources`.
+If you want to build and run binaries in tests, then you'll need to tell
+Spack to load the package's compiler configuration. This is accomplished
+by setting the package's ``test_requires_compiler`` property to ``True``.
 
-    If that is not possible, you can add test-related files to the package
-    repository (see :ref:`cache_custom_files`). It will be important to
-    remember to maintain them so they work across listed or supported versions
-    of the package.
+Setting the property to ``True`` ensures access to the compiler through
+canonical environment variables (e.g., ``CC``, ``CXX``, ``FC``, ``F77``).
+It also gives access to build dependencies like ``cmake`` through their
+``spec objects`` (e.g., ``self.spec["cmake"].prefix.bin.cmake``).
 
-Packages that build libraries are good examples of cases where you'll want
-to build test executables from the installed software before running them.
-Doing so requires you to let Spack know it needs to load the package's
-compiler configuration. This is accomplished by setting the package's
-``test_requires_compiler`` property to ``True``.
+.. note::
 
-.. admonition:: ``test_requires_compiler = True`` is required to build test executables.
+   The ``test_requires_compiler`` property should be added at the top of
+   the package near other attributes, such as the ``homepage`` and ``url``.
 
-   Setting the property to ``True`` ensures access to the compiler through
-   canonical environment variables (e.g., ``CC``, ``CXX``, ``FC``, ``F77``).
-   It also gives access to build dependencies like ``cmake`` through their
-   ``spec objects`` (e.g., ``self.spec["cmake"].prefix.bin.cmake`` for the
-   path or ``self.spec["cmake"].command`` for the ``Executable`` instance).
-
-   Be sure to add the property at the top of the package class under other
-   properties like the ``homepage``.
-
-The example below, which ignores how ``cxx-example.cpp`` is acquired,
-illustrates the basic process of compiling a test executable using the
-installed library before running it.
+Below illustrates using this feature to compile an example.
 
 .. code-block:: python
 
@@ -5621,22 +5477,28 @@ installed library before running it.
            cxx_example = which(exe)
            cxx_example()
 
-Typically the files used to build and or run test executables are either
-cached from the installation (see :ref:`cache_extra_test_sources`) or added
-to the package repository (see :ref:`cache_custom_files`). There is nothing
-preventing the use of both.
 
 .. _cache_extra_test_sources:
 
-""""""""""""""""""""""""""""""""""""
-Saving build- and install-time files
-""""""""""""""""""""""""""""""""""""
+"""""""""""""""""""""""
+Saving build-time files
+"""""""""""""""""""""""
 
-You can use the ``cache_extra_test_sources`` helper routine to copy
-directories and or files from the source build stage directory to the
-package's installation directory. Spack will automatically copy these
-files for you when it sets up the test stage directory and before it
-begins running the tests.
+.. note::
+
+    We highly recommend re-using build-time test sources and pared down
+    input files for testing installed software. These files are easier
+    to keep synchronized with software capabilities since they reside
+    within the software's repository.
+
+    If that is not possible, you can add test-related files to the package
+    repository (see :ref:`adding custom files <cache_custom_files>`). It
+    will be important to maintain them so they work across listed or supported
+    versions of the package.
+
+You can use the ``cache_extra_test_sources`` helper to copy directories
+and or files from the source build stage directory to the package's
+installation directory.
 
 The signature for ``cache_extra_test_sources`` is:
 
@@ -5651,69 +5513,46 @@ where each argument has the following meaning:
 * ``srcs`` is a string *or* a list of strings corresponding to the
   paths of subdirectories and or files needed for stand-alone testing.
 
-.. warning::
+The paths must be relative to the staged source directory. Contents of
+subdirectories and files are copied to a special test cache subdirectory
+of the installation prefix. They are automatically copied to the appropriate
+relative paths under the test stage directory prior to executing stand-alone
+tests.
 
-   Paths provided in the ``srcs`` argument **must be relative** to the
-   staged source directory. They will be copied to the equivalent relative
-   location under the test stage directory prior to test execution.
-
-Contents of subdirectories and files are copied to a special test cache
-subdirectory of the installation prefix. They are automatically copied to
-the appropriate relative paths under the test stage directory prior to
-executing stand-alone tests.
-
-.. tip:: 
-
-    *Perform test-related conversions once when copying files.*
-
-    If one or more of the copied files needs to be modified to reference
-    the installed software, it is recommended that those changes be made
-    to the cached files **once** in the post-``install`` copy method
-    **after** the call to ``cache_extra_test_sources``. This will reduce
-    the amount of unnecessary work in the test method **and** avoid problems
-    running stand-alone tests in shared instances and facility deployments.
-
-    The ``filter_file`` function can be quite useful for such changes
-    (see :ref:`file-filtering`).
-
-Below is a basic example of a test that relies on files from the installation.
-This package method re-uses the contents of the ``examples`` subdirectory,
-which is assumed to have all of the files implemented to allow ``make`` to
-compile and link ``foo.c`` and ``bar.c`` against the package's installed
-library.
+For example, a package method for copying everything in the ``tests``
+subdirectory plus the ``foo.c`` and ``bar.c`` files from ``examples``
+and using ``foo.c`` in a test method is illustrated below.
 
 .. code-block:: python
 
-   class MyLibPackage(MakefilePackage):
+   class MyLibPackage(Package):
        ...
 
        @run_after("install")
        def copy_test_files(self):
-           cache_extra_test_sources(self, "examples")
+           srcs = ["tests",
+                   join_path("examples", "foo.c"),
+                   join_path("examples", "bar.c")]
+           cache_extra_test_sources(self, srcs)
 
-       def test_example(self):
-           """build and run the examples"""
-           examples_dir = self.test_suite.current_test_cache_dir.examples
-           with working_dir(examples_dir):
-               make = which("make")
-               make()
+       def test_foo(self):
+           exe = "foo"
+           src_dir = self.test_suite.current_test_cache_dir.examples
+           with working_dir(src_dir):
+               cc = which(os.environ["CC"])
+               cc(
+                   f"-L{self.prefix.lib}",
+                   f"-I{self.prefix.include}",
+                   f"{exe}.c",
+                   "-o", exe
+               )
+               foo = which(exe)
+               foo()
 
-               for program in ["foo", "bar"]:
-                   with test_part(
-                       self,
-                       f"test_example_{program}",
-                       purpose=f"ensure {program} runs"
-                   ):
-                       exe = Executable(program)
-                       exe()
-
-In this case, ``copy_test_files`` copies the associated files from the
-build stage to the package's test cache directory under the installation
-prefix. Running ``spack test run`` for the package results in Spack copying
-the directory and its contents to the the test stage directory. The
-``working_dir`` context manager ensures the commands within it are executed
-from the ``examples_dir``. The test builds the software using ``make`` before
-running each executable, ``foo`` and ``bar``, as independent test parts.
+In this case, the method copies the associated files from the build
+stage, **after** the software is installed, to the package's test
+cache directory. Then ``test_foo`` builds ``foo`` using ``foo.c``
+before running the program.
 
 .. note::
 
@@ -5722,18 +5561,43 @@ running each executable, ``foo`` and ``bar``, as independent test parts.
 
    The key to copying files for stand-alone testing at build time is use
    of the ``run_after`` directive, which ensures the associated files are
-   copied **after** the provided build stage (``install``) when the installation
-   prefix **and** files are available.
+   copied **after** the provided build stage where the files **and**
+   installation prefix are available.
 
-   The test method uses the path contained in the package's
-   ``self.test_suite.current_test_cache_dir`` property for the root directory
-   of the copied files. In this case, that's the ``examples`` subdirectory.
+These paths are **automatically copied** from cache to the test stage
+directory prior to the execution of any stand-alone tests. Tests access
+the files using the ``self.test_suite.current_test_cache_dir`` property.
+In our example above, test methods can use the following paths to reference
+the copy of each entry listed in ``srcs``, respectively:
 
-.. tip::
+* ``self.test_suite.current_test_cache_dir.tests``
+* ``join_path(self.test_suite.current_test_cache_dir.examples, "foo.c")``
+* ``join_path(self.test_suite.current_test_cache_dir.examples, "bar.c")``
+
+.. admonition:: Library packages should build stand-alone tests
+
+    Library developers will want to build the associated tests
+    against their **installed** libraries before running them.
+
+.. note::
+
+    While source and input files are generally recommended, binaries
+    **may** also be cached by the build process. Only you, as the package
+    writer or maintainer, know whether these files would be appropriate
+    for testing the installed software weeks to months later.
+
+.. note::
+
+    If one or more of the copied files needs to be modified to reference
+    the installed software, it is recommended that those changes be made
+    to the cached files **once** in the ``copy_test_sources`` method and
+    ***after** the call to ``cache_extra_test_sources()``. This will
+    reduce the amount of unnecessary work in the test method **and** avoid
+    problems testing in shared instances and facility deployments.
+
+    The ``filter_file`` function can be quite useful for such changes.
+    See :ref:`file manipulation <file-manipulation>`.
 
-   If you want to see more examples from packages that cache build files, run
-   ``spack pkg grep cache_extra_test_sources | sed "s/\/package.py.*//g" | sort -u``
-   from the command line to get a list of the packages.
 
 .. _cache_custom_files:
 
@@ -5741,9 +5605,8 @@ running each executable, ``foo`` and ``bar``, as independent test parts.
 Adding custom files
 """""""""""""""""""
 
-Sometimes it is helpful or necessary to include custom files for building and
-or checking the results of tests as part of the package. Examples of the types
-of files that might be useful are:
+In some cases it can be useful to have files that can be used to build or
+check the results of tests.  Examples include:
 
 - test source files
 - test input files
@@ -5751,15 +5614,17 @@ of files that might be useful are:
 - expected test outputs
 
 While obtaining such files from the software repository is preferred (see
-:ref:`cache_extra_test_sources`), there are circumstances where doing so is not
-feasible such as when the software is not being actively maintained. When test
-files cannot be obtained from the repository or there is a need to supplement
-files that can, Spack supports the inclusion of additional files under the
-``test`` subdirectory of the package in the Spack repository.
+:ref:`adding build-time files  <cache_extra_test_sources>`), there are
+circumstances where that is not feasible (e.g., the software is not being
+actively maintained). When test files can't be obtained from the repository
+or as a supplement to files that can, Spack supports the inclusion of
+additional files under the ``test`` subdirectory of the package in the
+Spack repository.
 
-The following example assumes a ``custom-example.c`` is saved in ``MyLibary``
-package's ``test`` subdirectory. It also assumes the program simply needs to
-be compiled and linked against the installed ``MyLibrary`` software.
+Spack **automatically copies** the contents of that directory to the
+test staging directory prior to running stand-alone tests. Test methods
+access those files using the ``self.test_suite.current_test_data_dir``
+property as shown below.
 
 .. code-block:: python
 
@@ -5769,29 +5634,17 @@ be compiled and linked against the installed ``MyLibrary`` software.
        test_requires_compiler = True
        ...
 
-       def test_custom_example(self):
+       def test_example(self):
            """build and run custom-example"""
-           src_dir = self.test_suite.current_test_data_dir
+           data_dir = self.test_suite.current_test_data_dir
            exe = "custom-example"
+           src = datadir.join(f"{exe}.cpp")
+           ...
+           # TODO: Build custom-example using src and exe
+           ...
+           custom_example = which(exe)
+           custom_example()
 
-           with working_dir(src_dir):
-               cc = which(os.environ["CC"])
-               cc(
-                   f"-L{self.prefix.lib}",
-                   f"-I{self.prefix.include}",
-                   f"{exe}.cpp",
-                   "-o", exe
-               )
-
-               custom_example = Executable(exe)
-               custom_example()
-
-In this case, ``spack test run`` for the package results in Spack copying
-the contents of the ``test`` subdirectory to the test stage directory path
-in ``self.test_suite.current_test_data_dir`` before calling
-``test_custom_example``. Use of the ``working_dir`` context manager
-ensures the commands to build and run the program are performed from
-within the appropriate subdirectory of the test stage.
 
 .. _expected_test_output_from_file:
 
@@ -5800,8 +5653,9 @@ Reading expected output from a file
 """""""""""""""""""""""""""""""""""
 
 The helper function ``get_escaped_text_output`` is available for packages
-to retrieve properly formatted text from a file potentially containing
-special characters.
+to retrieve and properly format the text from a file that contains the
+expected output from running an executable that may contain special
+characters.
 
 The signature for ``get_escaped_text_output`` is:
 
@@ -5811,13 +5665,10 @@ The signature for ``get_escaped_text_output`` is:
 
 where ``filename`` is the path to the file containing the expected output.
 
-The path provided to ``filename`` for one of the copied custom files
-(:ref:`custom file <cache_custom_files>`) is in the path rooted at
-``self.test_suite.current_test_data_dir``.
-
-The example below shows how to reference both the custom database
-(``packages.db``) and expected output (``dump.out``) files Spack copies
-to the test stage:
+The ``filename`` for a :ref:`custom file <cache_custom_files>` can be
+accessed by tests using the ``self.test_suite.current_test_data_dir``
+property. The example below illustrates how to read a file that was
+added to the package's ``test`` subdirectory.
 
 .. code-block:: python
 
@@ -5839,9 +5690,8 @@ to the test stage:
            for exp in expected:
                assert re.search(exp, out), f"Expected '{exp}' in output"
 
-If the files were instead cached from installing the software, the paths to the
-two files would be found under the ``self.test_suite.current_test_cache_dir``
-directory as shown below:
+If the file was instead copied from the ``tests`` subdirectory of the staged
+source code, the path would be obtained as shown below.
 
 .. code-block:: python
 
@@ -5849,24 +5699,17 @@ directory as shown below:
            """check example table dump"""
            test_cache_dir = self.test_suite.current_test_cache_dir
            db_filename = test_cache_dir.join("packages.db")
-           ..
-           expected = get_escaped_text_output(test_cache_dir.join("dump.out"))
-           ...
 
-Alternatively, if both files had been installed by the software into the
-``share/tests`` subdirectory of the installation prefix, the paths to the
-two files would be referenced as follows:
+Alternatively, if the file was copied to the ``share/tests`` subdirectory
+as part of the installation process, the test could access the path as
+follows:
 
 .. code-block:: python
 
        def test_example(self):
            """check example table dump"""
-           db_filename = self.prefix.share.tests.join("packages.db")
-           ..
-           expected = get_escaped_text_output(
-               self.prefix.share.tests.join("dump.out")
-           )
-           ...
+           db_filename = join_path(self.prefix.share.tests, "packages.db")
+
 
 .. _check_outputs:
 
@@ -5874,9 +5717,9 @@ two files would be referenced as follows:
 Comparing expected to actual outputs
 """"""""""""""""""""""""""""""""""""
 
-The ``check_outputs`` helper routine is available for packages to ensure
-multiple expected outputs from running an executable are contained within
-the actual outputs.
+The helper function ``check_outputs`` is available for packages to ensure
+the expected outputs from running an executable are contained within the
+actual outputs.
 
 The signature for ``check_outputs`` is:
 
@@ -5902,17 +5745,11 @@ Invoking the method is the equivalent of:
    if errors:
        raise RuntimeError("\n ".join(errors))
 
-.. tip::
-
-   If you want to see more examples from packages that use this helper, run
-   ``spack pkg grep check_outputs | sed "s/\/package.py.*//g" | sort -u``
-   from the command line to get a list of the packages.
-
 
 .. _accessing-files:
 
 """""""""""""""""""""""""""""""""""""""""
-Finding package- and test-related files
+Accessing package- and test-related files
 """""""""""""""""""""""""""""""""""""""""
 
 You may need to access files from one or more locations when writing
@@ -5921,7 +5758,8 @@ include test source files or includes them but has no way to build the
 executables using the installed headers and libraries. In these cases
 you may need to reference the files relative to one or more root directory.
 The table below lists relevant path properties and provides additional
-examples of their use. See :ref:`expected_test_output_from_file` for
+examples of their use.
+:ref:`Reading expected output <expected_test_output_from_file>` provides
 examples of accessing files saved from the software repository, package
 repository, and installation.
 
@@ -5950,6 +5788,7 @@ repository, and installation.
      - ``self.test_suite.current_test_data_dir``
      - ``join_path(self.test_suite.current_test_data_dir, "hello.f90")``
 
+
 .. _inheriting-tests:
 
 """"""""""""""""""""""""""""
@@ -5992,7 +5831,7 @@ maintainers provide additional stand-alone tests customized to the package.
 .. warning::
 
    Any package that implements a test method with the same name as an
-   inherited method will override the inherited method. If that is not the
+   inherited method overrides the inherited method. If that is not the
    goal and you are not explicitly calling and adding functionality to
    the inherited method for the test, then make sure that all test methods
    and embedded test parts have unique test names.
@@ -6157,8 +5996,6 @@ running:
 This is already part of the boilerplate for packages created with
 ``spack create``.
 
-.. _file-filtering:
-
 ^^^^^^^^^^^^^^^^^^^
 Filtering functions
 ^^^^^^^^^^^^^^^^^^^

lib/spack/docs/pipelines.rst

@@ -253,6 +253,17 @@ can easily happen if it is not updated frequently, this behavior ensures that
 spack has a way to know for certain about the status of any concrete spec on
 the remote mirror, but can slow down pipeline generation significantly.
 
+The ``--optimize`` argument is experimental and runs the generated pipeline
+document through a series of optimization passes designed to reduce the size
+of the generated file.
+
+The ``--dependencies`` is also experimental and disables what in Gitlab is
+referred to as DAG scheduling, internally using the ``dependencies`` keyword
+rather than ``needs`` to list dependency jobs.  The drawback of using this option
+is that before any job can begin, all jobs in previous stages must first
+complete.  The benefit is that Gitlab allows more dependencies to be listed
+when using ``dependencies`` instead of ``needs``.
+
 The optional ``--output-file`` argument should be an absolute path (including
 file name) to the generated pipeline, and if not given, the default is
 ``./.gitlab-ci.yml``.

lib/spack/docs/repositories.rst

@@ -476,3 +476,9 @@ implemented using Python's built-in `sys.path
 :py:mod:`spack.repo` module implements a custom `Python importer
 <https://docs.python.org/2/library/imp.html>`_.
 
+.. warning::
+
+   The mechanism for extending packages is not yet extensively tested,
+   and extending packages across repositories imposes inter-repo
+   dependencies, which may be hard to manage.  Use this feature at your
+   own risk, but let us know if you have a use case for it.

lib/spack/docs/requirements.txt

@@ -1,13 +1,13 @@
 sphinx==7.2.6
 sphinxcontrib-programoutput==0.17
-sphinx_design==0.6.0
+sphinx_design==0.5.0
 sphinx-rtd-theme==2.0.0
 python-levenshtein==0.25.1
 docutils==0.20.1
-pygments==2.18.0
-urllib3==2.2.2
-pytest==8.2.2
+pygments==2.17.2
+urllib3==2.2.1
+pytest==8.2.0
 isort==5.13.2
 black==24.4.2
-flake8==7.1.0
-mypy==1.10.1
+flake8==7.0.0
+mypy==1.10.0

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.4 (commit 48b92512b9ce203ded0ebd1ac41b42593e931f7c)
+* Version: 0.2.5-dev (commit cbb1fd5eb397a70d466e5160b393b87b0dbcc78f)
 
 astunparse
 ----------------

lib/spack/external/archspec/cpu/detect.py

@@ -47,7 +47,11 @@ def decorator(factory):
 
 
 def partial_uarch(
-    name: str = "", vendor: str = "", features: Optional[Set[str]] = None, generation: int = 0
+    name: str = "",
+    vendor: str = "",
+    features: Optional[Set[str]] = None,
+    generation: int = 0,
+    cpu_part: str = "",
 ) -> Microarchitecture:
     """Construct a partial microarchitecture, from information gathered during system scan."""
     return Microarchitecture(
@@ -57,6 +61,7 @@ def partial_uarch(
         features=features or set(),
         compilers={},
         generation=generation,
+        cpu_part=cpu_part,
     )
 
 
@@ -90,6 +95,7 @@ def proc_cpuinfo() -> Microarchitecture:
         return partial_uarch(
             vendor=_canonicalize_aarch64_vendor(data),
             features=_feature_set(data, key="Features"),
+            cpu_part=data.get("CPU part", ""),
         )
 
     if architecture in (PPC64LE, PPC64):
@@ -345,6 +351,10 @@ def sorting_fn(item):
     generic_candidates = [c for c in candidates if c.vendor == "generic"]
     best_generic = max(generic_candidates, key=sorting_fn)
 
+    # Relevant for AArch64. Filter on "cpu_part" if we have any match
+    if info.cpu_part != "" and any(c for c in candidates if info.cpu_part == c.cpu_part):
+        candidates = [c for c in candidates if info.cpu_part == c.cpu_part]
+
     # Filter the candidates to be descendant of the best generic candidate.
     # This is to avoid that the lack of a niche feature that can be disabled
     # from e.g. BIOS prevents detection of a reasonably performant architecture

lib/spack/external/archspec/cpu/microarchitecture.py

@@ -2,9 +2,7 @@
 # Archspec Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
-"""Types and functions to manage information
-on CPU microarchitectures.
-"""
+"""Types and functions to manage information on CPU microarchitectures."""
 import functools
 import platform
 import re
@@ -65,21 +63,24 @@ class Microarchitecture:
                 passed in as argument above.
             * versions: versions that support this micro-architecture.
 
-        generation (int): generation of the micro-architecture, if
-            relevant.
+        generation (int): generation of the micro-architecture, if relevant.
+        cpu_part (str): cpu part of the architecture, if relevant.
     """
 
-    # pylint: disable=too-many-arguments
+    # pylint: disable=too-many-arguments,too-many-instance-attributes
     #: Aliases for micro-architecture's features
     feature_aliases = FEATURE_ALIASES
 
-    def __init__(self, name, parents, vendor, features, compilers, generation=0):
+    def __init__(self, name, parents, vendor, features, compilers, generation=0, cpu_part=""):
         self.name = name
         self.parents = parents
         self.vendor = vendor
         self.features = features
         self.compilers = compilers
+        # Only relevant for PowerPC
         self.generation = generation
+        # Only relevant for AArch64
+        self.cpu_part = cpu_part
         # Cache the ancestor computation
         self._ancestors = None
 
@@ -111,6 +112,7 @@ def __eq__(self, other):
             and self.parents == other.parents  # avoid ancestors here
             and self.compilers == other.compilers
             and self.generation == other.generation
+            and self.cpu_part == other.cpu_part
         )
 
     @coerce_target_names
@@ -143,7 +145,8 @@ def __repr__(self):
         cls_name = self.__class__.__name__
         fmt = (
             cls_name + "({0.name!r}, {0.parents!r}, {0.vendor!r}, "
-            "{0.features!r}, {0.compilers!r}, {0.generation!r})"
+            "{0.features!r}, {0.compilers!r}, generation={0.generation!r}, "
+            "cpu_part={0.cpu_part!r})"
         )
         return fmt.format(self)
 
@@ -190,6 +193,7 @@ def to_dict(self):
             "generation": self.generation,
             "parents": [str(x) for x in self.parents],
             "compilers": self.compilers,
+            "cpupart": self.cpu_part,
         }
 
     @staticmethod
@@ -202,6 +206,7 @@ def from_dict(data) -> "Microarchitecture":
             features=set(data["features"]),
             compilers=data.get("compilers", {}),
             generation=data.get("generation", 0),
+            cpu_part=data.get("cpupart", ""),
         )
 
     def optimization_flags(self, compiler, version):
@@ -360,8 +365,11 @@ def fill_target_from_dict(name, data, targets):
         features = set(values["features"])
         compilers = values.get("compilers", {})
         generation = values.get("generation", 0)
+        cpu_part = values.get("cpupart", "")
 
-        targets[name] = Microarchitecture(name, parents, vendor, features, compilers, generation)
+        targets[name] = Microarchitecture(
+            name, parents, vendor, features, compilers, generation=generation, cpu_part=cpu_part
+        )
 
     known_targets = {}
     data = archspec.cpu.schema.TARGETS_JSON["microarchitectures"]

lib/spack/external/archspec/json/cpu/microarchitectures.json

@@ -2225,10 +2225,14 @@
         ],
         "nvhpc": [
           {
-            "versions": "21.11:",
+            "versions": "21.11:23.8",
 	    "name": "zen3",
             "flags": "-tp {name}",
-	    "warnings": "zen4 is not fully supported by nvhpc yet, falling back to zen3"
+	    "warnings": "zen4 is not fully supported by nvhpc versions < 23.9, falling back to zen3"
+          },
+          {
+            "versions": "23.9:",
+            "flags": "-tp {name}"
           }
 	]
       }
@@ -2711,7 +2715,8 @@
             "flags": "-mcpu=thunderx2t99"
           }
         ]
-      }
+      },
+      "cpupart": "0x0af"
     },
     "a64fx": {
       "from": ["armv8.2a"],
@@ -2779,7 +2784,8 @@
             "flags": "-march=armv8.2-a+crc+crypto+fp16+sve"
           }
         ]
-      }
+      },
+      "cpupart": "0x001"
     },
     "cortex_a72": {
       "from": ["aarch64"],
@@ -2816,7 +2822,8 @@
                   "flags" : "-mcpu=cortex-a72"
               }
           ]
-      }
+      },
+      "cpupart": "0xd08"
     },
     "neoverse_n1": {
       "from": ["cortex_a72", "armv8.2a"],
@@ -2837,8 +2844,7 @@
           "asimdrdm",
           "lrcpc",
           "dcpop",
-          "asimddp",
-          "ssbs"
+          "asimddp"
       ],
       "compilers" : {
           "gcc": [
@@ -2902,7 +2908,8 @@
                   "flags": "-tp {name}"
               }
           ]
-      }
+      },
+      "cpupart": "0xd0c"
     },
     "neoverse_v1": {
       "from": ["neoverse_n1", "armv8.4a"],
@@ -2926,8 +2933,6 @@
           "lrcpc",
           "dcpop",
           "sha3",
-          "sm3",
-          "sm4",
           "asimddp",
           "sha512",
           "sve",
@@ -2936,7 +2941,6 @@
           "uscat",
           "ilrcpc",
           "flagm",
-          "ssbs",
           "dcpodp",
           "svei8mm",
           "svebf16",
@@ -3004,7 +3008,7 @@
               },
               {
                   "versions": "11:",
-                  "flags" : "-march=armv8.4-a+sve+ssbs+fp16+bf16+crypto+i8mm+rng"
+                  "flags" : "-march=armv8.4-a+sve+fp16+bf16+crypto+i8mm+rng"
               },
               {
                   "versions": "12:",
@@ -3028,7 +3032,8 @@
                   "flags": "-tp {name}"
               }
           ]
-      }
+      },
+      "cpupart": "0xd40"
     },
     "neoverse_v2": {
       "from": ["neoverse_n1", "armv9.0a"],
@@ -3052,32 +3057,22 @@
 	  "lrcpc",
 	  "dcpop",
 	  "sha3",
-	  "sm3",
-	  "sm4",
 	  "asimddp",
 	  "sha512",
 	  "sve",
 	  "asimdfhm",
-	  "dit",
 	  "uscat",
 	  "ilrcpc",
 	  "flagm",
-	  "ssbs",
 	  "sb",
 	  "dcpodp",
 	  "sve2",
-	  "sveaes",
-	  "svepmull",
-	  "svebitperm",
-	  "svesha3",
-	  "svesm4",
 	  "flagm2",
 	  "frint",
 	  "svei8mm",
 	  "svebf16",
 	  "i8mm",
-	  "bf16",
-	  "dgh"
+	  "bf16"
       ],
       "compilers" : {
           "gcc": [
@@ -3102,15 +3097,19 @@
                   "flags" : "-march=armv8.5-a+sve -mtune=cortex-a76"
               },
               {
-                  "versions": "10.0:11.99",
+                  "versions": "10.0:11.3.99",
                   "flags" : "-march=armv8.5-a+sve+sve2+i8mm+bf16 -mtune=cortex-a77"
               },
+	      {
+                  "versions": "11.4:11.99",
+                  "flags" : "-mcpu=neoverse-v2"
+              },
               {
-                  "versions": "12.0:12.99",
+                  "versions": "12.0:12.2.99",
                   "flags" : "-march=armv9-a+i8mm+bf16 -mtune=cortex-a710"
               },
 	      {
-                  "versions": "13.0:",
+                  "versions": "12.3:",
                   "flags" : "-mcpu=neoverse-v2"
               }
           ],
@@ -3145,7 +3144,112 @@
                   "flags": "-tp {name}"
               }
           ]
-      }
+      },
+      "cpupart": "0xd4f"
+    },
+    "neoverse_n2": {
+      "from": ["neoverse_n1", "armv9.0a"],
+      "vendor": "ARM",
+      "features": [
+          "fp",
+	  "asimd",
+	  "evtstrm",
+	  "aes",
+	  "pmull",
+	  "sha1",
+	  "sha2",
+	  "crc32",
+	  "atomics",
+	  "fphp",
+	  "asimdhp",
+	  "cpuid",
+	  "asimdrdm",
+	  "jscvt",
+	  "fcma",
+	  "lrcpc",
+	  "dcpop",
+	  "sha3",
+	  "asimddp",
+	  "sha512",
+	  "sve",
+	  "asimdfhm",
+	  "uscat",
+	  "ilrcpc",
+	  "flagm",
+	  "sb",
+	  "dcpodp",
+	  "sve2",
+	  "flagm2",
+	  "frint",
+	  "svei8mm",
+	  "svebf16",
+	  "i8mm",
+	  "bf16"
+      ],
+      "compilers" : {
+          "gcc": [
+              {
+                  "versions": "4.8:5.99",
+                  "flags": "-march=armv8-a"
+              },
+              {
+                  "versions": "6:6.99",
+                  "flags" : "-march=armv8.1-a"
+              },
+              {
+                  "versions": "7.0:7.99",
+                  "flags" : "-march=armv8.2-a -mtune=cortex-a72"
+              },
+              {
+                  "versions": "8.0:8.99",
+                  "flags" : "-march=armv8.4-a+sve -mtune=cortex-a72"
+              },
+              {
+                  "versions": "9.0:9.99",
+                  "flags" : "-march=armv8.5-a+sve -mtune=cortex-a76"
+              },
+              {
+                  "versions": "10.0:10.99",
+                  "flags" : "-march=armv8.5-a+sve+sve2+i8mm+bf16 -mtune=cortex-a77"
+              },
+              {
+                  "versions": "11.0:",
+                  "flags" : "-mcpu=neoverse-n2"
+              }
+          ],
+          "clang" : [
+              {
+                  "versions": "9.0:10.99",
+                  "flags" : "-march=armv8.5-a+sve"
+              },
+              {
+                  "versions": "11.0:13.99",
+                  "flags" : "-march=armv8.5-a+sve+sve2+i8mm+bf16"
+              },
+              {
+                  "versions": "14.0:15.99",
+                  "flags" : "-march=armv9-a+i8mm+bf16"
+              },
+              {
+                  "versions": "16.0:",
+                  "flags" : "-mcpu=neoverse-n2"
+              }
+          ],
+          "arm" : [
+              {
+                  "versions": "23.04.0:",
+                  "flags" : "-mcpu=neoverse-n2"
+              }
+          ],
+          "nvhpc" : [
+              {
+                  "versions": "23.3:",
+                  "name": "neoverse-n1",
+                  "flags": "-tp {name}"
+              }
+          ]
+      },
+      "cpupart": "0xd49"
     },
     "m1": {
       "from": ["armv8.4a"],
@@ -3211,7 +3315,8 @@
             "flags" : "-mcpu=apple-m1"
           }
         ]
-      }
+      },
+      "cpupart": "0x022"
     },
     "m2": {
       "from": ["m1", "armv8.5a"],
@@ -3289,7 +3394,8 @@
             "flags" : "-mcpu=apple-m2"
           }
         ]
-      }
+      },
+      "cpupart": "0x032"
     },
     "arm": {
       "from": [],

lib/spack/external/archspec/json/cpu/microarchitectures_schema.json

@@ -52,6 +52,9 @@
                   }
                 }
               }
+            },
+            "cpupart": {
+              "type": "string"
             }
           },
           "required": [
@@ -107,4 +110,4 @@
       "additionalProperties": false
     }
   }
-}
+}

lib/spack/llnl/util/filesystem.py

@@ -766,6 +766,7 @@ def copy_tree(
     src: str,
     dest: str,
     symlinks: bool = True,
+    allow_broken_symlinks: bool = sys.platform != "win32",
     ignore: Optional[Callable[[str], bool]] = None,
     _permissions: bool = False,
 ):
@@ -788,6 +789,8 @@ def copy_tree(
         src (str): the directory to copy
         dest (str): the destination directory
         symlinks (bool): whether or not to preserve symlinks
+        allow_broken_symlinks (bool): whether or not to allow broken (dangling) symlinks,
+            On Windows, setting this to True will raise an exception. Defaults to true on unix.
         ignore (typing.Callable): function indicating which files to ignore
         _permissions (bool): for internal use only
 
@@ -795,6 +798,8 @@ def copy_tree(
         IOError: if *src* does not match any files or directories
         ValueError: if *src* is a parent directory of *dest*
     """
+    if allow_broken_symlinks and sys.platform == "win32":
+        raise llnl.util.symlink.SymlinkError("Cannot allow broken symlinks on Windows!")
     if _permissions:
         tty.debug("Installing {0} to {1}".format(src, dest))
     else:
@@ -867,14 +872,16 @@ def escaped_path(path):
                 copy_mode(s, d)
 
     for target, d, s in links:
-        symlink(target, d)
+        symlink(target, d, allow_broken_symlinks=allow_broken_symlinks)
         if _permissions:
             set_install_permissions(d)
             copy_mode(s, d)
 
 
 @system_path_filter
-def install_tree(src, dest, symlinks=True, ignore=None):
+def install_tree(
+    src, dest, symlinks=True, ignore=None, allow_broken_symlinks=sys.platform != "win32"
+):
     """Recursively install an entire directory tree rooted at *src*.
 
     Same as :py:func:`copy_tree` with the addition of setting proper
@@ -885,12 +892,21 @@ def install_tree(src, dest, symlinks=True, ignore=None):
         dest (str): the destination directory
         symlinks (bool): whether or not to preserve symlinks
         ignore (typing.Callable): function indicating which files to ignore
+        allow_broken_symlinks (bool): whether or not to allow broken (dangling) symlinks,
+            On Windows, setting this to True will raise an exception.
 
     Raises:
         IOError: if *src* does not match any files or directories
         ValueError: if *src* is a parent directory of *dest*
     """
-    copy_tree(src, dest, symlinks=symlinks, ignore=ignore, _permissions=True)
+    copy_tree(
+        src,
+        dest,
+        symlinks=symlinks,
+        allow_broken_symlinks=allow_broken_symlinks,
+        ignore=ignore,
+        _permissions=True,
+    )
 
 
 @system_path_filter

lib/spack/llnl/util/symlink.py

@@ -8,7 +8,6 @@
 import subprocess
 import sys
 import tempfile
-from typing import Union
 
 from llnl.util import lang, tty
 
@@ -17,66 +16,92 @@
 if sys.platform == "win32":
     from win32file import CreateHardLink
 
+is_windows = sys.platform == "win32"
 
-def _windows_symlink(
-    src: str, dst: str, target_is_directory: bool = False, *, dir_fd: Union[int, None] = None
-):
-    """On Windows with System Administrator privileges this will be a normal symbolic link via
-    os.symlink. On Windows without privledges the link will be a junction for a directory and a
-    hardlink for a file. On Windows the various link types are:
 
-    Symbolic Link: A link to a file or directory on the same or different volume (drive letter) or
-    even to a remote file or directory (using UNC in its path). Need System Administrator
-    privileges to make these.
+def symlink(source_path: str, link_path: str, allow_broken_symlinks: bool = not is_windows):
+    """
+    Create a link.
 
-    Hard Link: A link to a file on the same volume (drive letter) only. Every file (file's data)
-    has at least 1 hard link (file's name). But when this method creates a new hard link there will
-    be 2. Deleting all hard links effectively deletes the file. Don't need System Administrator
-    privileges.
+    On non-Windows and Windows with System Administrator
+    privleges this will be a normal symbolic link via
+    os.symlink.
 
-    Junction: A link to a directory on the same or different volume (drive letter) but not to a
-    remote directory. Don't need System Administrator privileges."""
-    source_path = os.path.normpath(src)
+    On Windows without privledges the link will be a
+    junction for a directory and a hardlink for a file.
+    On Windows the various link types are:
+
+    Symbolic Link: A link to a file or directory on the
+    same or different volume (drive letter) or even to
+    a remote file or directory (using UNC in its path).
+    Need System Administrator privileges to make these.
+
+    Hard Link: A link to a file on the same volume (drive
+    letter) only. Every file (file's data) has at least 1
+    hard link (file's name). But when this method creates
+    a new hard link there will be 2. Deleting all hard
+    links effectively deletes the file. Don't need System
+    Administrator privileges.
+
+    Junction: A link to a directory on the same or different
+    volume (drive letter) but not to a remote directory. Don't
+    need System Administrator privileges.
+
+    Parameters:
+        source_path (str): The real file or directory that the link points to.
+            Must be absolute OR relative to the link.
+        link_path (str): The path where the link will exist.
+        allow_broken_symlinks (bool): On Linux or Mac, don't raise an exception if the source_path
+            doesn't exist. This will still raise an exception on Windows.
+    """
+    source_path = os.path.normpath(source_path)
     win_source_path = source_path
-    link_path = os.path.normpath(dst)
+    link_path = os.path.normpath(link_path)
 
-    # Perform basic checks to make sure symlinking will succeed
-    if os.path.lexists(link_path):
-        raise AlreadyExistsError(f"Link path ({link_path}) already exists. Cannot create link.")
+    # Never allow broken links on Windows.
+    if sys.platform == "win32" and allow_broken_symlinks:
+        raise ValueError("allow_broken_symlinks parameter cannot be True on Windows.")
 
-    if not os.path.exists(source_path):
-        if os.path.isabs(source_path):
-            # An absolute source path that does not exist will result in a broken link.
-            raise SymlinkError(
-                f"Source path ({source_path}) is absolute but does not exist. Resulting "
-                f"link would be broken so not making link."
+    if not allow_broken_symlinks:
+        # Perform basic checks to make sure symlinking will succeed
+        if os.path.lexists(link_path):
+            raise AlreadyExistsError(
+                f"Link path ({link_path}) already exists. Cannot create link."
             )
-        else:
-            # os.symlink can create a link when the given source path is relative to
-            # the link path. Emulate this behavior and check to see if the source exists
-            # relative to the link path ahead of link creation to prevent broken
-            # links from being made.
-            link_parent_dir = os.path.dirname(link_path)
-            relative_path = os.path.join(link_parent_dir, source_path)
-            if os.path.exists(relative_path):
-                # In order to work on windows, the source path needs to be modified to be
-                # relative because hardlink/junction dont resolve relative paths the same
-                # way as os.symlink. This is ignored on other operating systems.
-                win_source_path = relative_path
-            else:
+
+        if not os.path.exists(source_path):
+            if os.path.isabs(source_path) and not allow_broken_symlinks:
+                # An absolute source path that does not exist will result in a broken link.
                 raise SymlinkError(
-                    f"The source path ({source_path}) is not relative to the link path "
-                    f"({link_path}). Resulting link would be broken so not making link."
+                    f"Source path ({source_path}) is absolute but does not exist. Resulting "
+                    f"link would be broken so not making link."
                 )
+            else:
+                # os.symlink can create a link when the given source path is relative to
+                # the link path. Emulate this behavior and check to see if the source exists
+                # relative to the link path ahead of link creation to prevent broken
+                # links from being made.
+                link_parent_dir = os.path.dirname(link_path)
+                relative_path = os.path.join(link_parent_dir, source_path)
+                if os.path.exists(relative_path):
+                    # In order to work on windows, the source path needs to be modified to be
+                    # relative because hardlink/junction dont resolve relative paths the same
+                    # way as os.symlink. This is ignored on other operating systems.
+                    win_source_path = relative_path
+                elif not allow_broken_symlinks:
+                    raise SymlinkError(
+                        f"The source path ({source_path}) is not relative to the link path "
+                        f"({link_path}). Resulting link would be broken so not making link."
+                    )
 
     # Create the symlink
-    if not _windows_can_symlink():
+    if sys.platform == "win32" and not _windows_can_symlink():
         _windows_create_link(win_source_path, link_path)
     else:
         os.symlink(source_path, link_path, target_is_directory=os.path.isdir(source_path))
 
 
-def _windows_islink(path: str) -> bool:
+def islink(path: str) -> bool:
     """Override os.islink to give correct answer for spack logic.
 
     For Non-Windows: a link can be determined with the os.path.islink method.
@@ -244,7 +269,7 @@ def _windows_create_hard_link(path: str, link: str):
         CreateHardLink(link, path)
 
 
-def _windows_readlink(path: str, *, dir_fd=None):
+def readlink(path: str, *, dir_fd=None):
     """Spack utility to override of os.readlink method to work cross platform"""
     if _windows_is_hardlink(path):
         return _windows_read_hard_link(path)
@@ -313,16 +338,6 @@ def resolve_link_target_relative_to_the_link(link):
     return os.path.join(link_dir, target)
 
 
-if sys.platform == "win32":
-    symlink = _windows_symlink
-    readlink = _windows_readlink
-    islink = _windows_islink
-else:
-    symlink = os.symlink
-    readlink = os.readlink
-    islink = os.path.islink
-
-
 class SymlinkError(RuntimeError):
     """Exception class for errors raised while creating symlinks,
     junctions and hard links

lib/spack/llnl/util/tty/log.py

@@ -33,23 +33,8 @@
     pass
 
 
-esc, bell, lbracket, bslash, newline = r"\x1b", r"\x07", r"\[", r"\\", r"\n"
-# Ansi Control Sequence Introducers (CSI) are a well-defined format
-# Standard ECMA-48: Control Functions for Character-Imaging I/O Devices, section 5.4
-# https://www.ecma-international.org/wp-content/uploads/ECMA-48_5th_edition_june_1991.pdf
-csi_pre = f"{esc}{lbracket}"
-csi_param, csi_inter, csi_post = r"[0-?]", r"[ -/]", r"[@-~]"
-ansi_csi = f"{csi_pre}{csi_param}*{csi_inter}*{csi_post}"
-# General ansi escape sequences have well-defined prefixes,
-#  but content and suffixes are less reliable.
-# Conservatively assume they end with either "<ESC>\" or "<BELL>",
-#  with no intervening "<ESC>"/"<BELL>" keys or newlines
-esc_pre = f"{esc}[@-_]"
-esc_content = f"[^{esc}{bell}{newline}]"
-esc_post = f"(?:{esc}{bslash}|{bell})"
-ansi_esc = f"{esc_pre}{esc_content}*{esc_post}"
 # Use this to strip escape sequences
-_escape = re.compile(f"{ansi_csi}|{ansi_esc}")
+_escape = re.compile(r"\x1b[^m]*m|\x1b\[?1034h|\x1b\][0-9]+;[^\x07]*\x07")
 
 # control characters for enabling/disabling echo
 #

lib/spack/spack/__init__.py

@@ -4,7 +4,7 @@
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 #: PEP440 canonical <major>.<minor>.<micro>.<devN> string
-__version__ = "0.23.0.dev0"
+__version__ = "0.22.2"
 spack_version = __version__
 
 

lib/spack/spack/audit.py

@@ -421,10 +421,6 @@ def _check_patch_urls(pkgs, error_cls):
         r"^https?://(?:patch-diff\.)?github(?:usercontent)?\.com/"
         r".+/.+/(?:commit|pull)/[a-fA-F0-9]+\.(?:patch|diff)"
     )
-    github_pull_commits_re = (
-        r"^https?://(?:patch-diff\.)?github(?:usercontent)?\.com/"
-        r".+/.+/pull/\d+/commits/[a-fA-F0-9]+\.(?:patch|diff)"
-    )
     # Only .diff URLs have stable/full hashes:
     # https://forum.gitlab.com/t/patches-with-full-index/29313
     gitlab_patch_url_re = (
@@ -440,24 +436,14 @@ def _check_patch_urls(pkgs, error_cls):
                 if not isinstance(patch, spack.patch.UrlPatch):
                     continue
 
-                if re.match(github_pull_commits_re, patch.url):
-                    url = re.sub(r"/pull/\d+/commits/", r"/commit/", patch.url)
-                    url = re.sub(r"^(.*)(?<!full_index=1)$", r"\1?full_index=1", url)
-                    errors.append(
-                        error_cls(
-                            f"patch URL in package {pkg_cls.name} "
-                            + "must not be a pull request commit; "
-                            + f"instead use {url}",
-                            [patch.url],
-                        )
-                    )
-                elif re.match(github_patch_url_re, patch.url):
+                if re.match(github_patch_url_re, patch.url):
                     full_index_arg = "?full_index=1"
                     if not patch.url.endswith(full_index_arg):
                         errors.append(
                             error_cls(
-                                f"patch URL in package {pkg_cls.name} "
-                                + f"must end with {full_index_arg}",
+                                "patch URL in package {0} must end with {1}".format(
+                                    pkg_cls.name, full_index_arg
+                                ),
                                 [patch.url],
                             )
                         )
@@ -465,7 +451,9 @@ def _check_patch_urls(pkgs, error_cls):
                     if not patch.url.endswith(".diff"):
                         errors.append(
                             error_cls(
-                                f"patch URL in package {pkg_cls.name} must end with .diff",
+                                "patch URL in package {0} must end with .diff".format(
+                                    pkg_cls.name
+                                ),
                                 [patch.url],
                             )
                         )

lib/spack/spack/binary_distribution.py

@@ -23,7 +23,6 @@
 import warnings
 from contextlib import closing
 from typing import Dict, Iterable, List, NamedTuple, Optional, Set, Tuple
-from urllib.error import HTTPError, URLError
 
 import llnl.util.filesystem as fsys
 import llnl.util.lang
@@ -899,9 +898,8 @@ def url_read_method(url):
         try:
             _, _, spec_file = web_util.read_from_url(url)
             contents = codecs.getreader("utf-8")(spec_file).read()
-        except (URLError, web_util.SpackWebError) as url_err:
-            tty.error("Error reading specfile: {0}".format(url))
-            tty.error(url_err)
+        except web_util.SpackWebError as e:
+            tty.error(f"Error reading specfile: {url}: {e}")
         return contents
 
     try:
@@ -2041,21 +2039,17 @@ def try_direct_fetch(spec, mirrors=None):
         try:
             _, _, fs = web_util.read_from_url(buildcache_fetch_url_signed_json)
             specfile_is_signed = True
-        except (URLError, web_util.SpackWebError, HTTPError) as url_err:
+        except web_util.SpackWebError as e1:
             try:
                 _, _, fs = web_util.read_from_url(buildcache_fetch_url_json)
-            except (URLError, web_util.SpackWebError, HTTPError) as url_err_x:
+            except web_util.SpackWebError as e2:
                 tty.debug(
-                    "Did not find {0} on {1}".format(
-                        specfile_name, buildcache_fetch_url_signed_json
-                    ),
-                    url_err,
+                    f"Did not find {specfile_name} on {buildcache_fetch_url_signed_json}",
+                    e1,
                     level=2,
                 )
                 tty.debug(
-                    "Did not find {0} on {1}".format(specfile_name, buildcache_fetch_url_json),
-                    url_err_x,
-                    level=2,
+                    f"Did not find {specfile_name} on {buildcache_fetch_url_json}", e2, level=2
                 )
                 continue
         specfile_contents = codecs.getreader("utf-8")(fs).read()
@@ -2140,6 +2134,9 @@ 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
         )
@@ -2150,19 +2147,12 @@ def get_keys(install=False, trust=False, force=False, mirrors=None):
         try:
             _, _, json_file = web_util.read_from_url(keys_index)
             json_index = sjson.load(codecs.getreader("utf-8")(json_file))
-        except (URLError, web_util.SpackWebError) as url_err:
+        except web_util.SpackWebError as url_err:
             if web_util.url_exists(keys_index):
-                err_msg = [
-                    "Unable to find public keys in {0},",
-                    " caught exception attempting to read from {1}.",
-                ]
-
                 tty.error(
-                    "".join(err_msg).format(
-                        url_util.format(fetch_url), url_util.format(keys_index)
-                    )
+                    f"Unable to find public keys in {url_util.format(fetch_url)},"
+                    f" caught exception attempting to read from {url_util.format(keys_index)}."
                 )
-
                 tty.debug(url_err)
 
             continue
@@ -2442,7 +2432,7 @@ def get_remote_hash(self):
         url_index_hash = url_util.join(self.url, BUILD_CACHE_RELATIVE_PATH, "index.json.hash")
         try:
             response = self.urlopen(urllib.request.Request(url_index_hash, headers=self.headers))
-        except urllib.error.URLError:
+        except (TimeoutError, urllib.error.URLError):
             return None
 
         # Validate the hash
@@ -2464,7 +2454,7 @@ def conditional_fetch(self) -> FetchIndexResult:
 
         try:
             response = self.urlopen(urllib.request.Request(url_index, headers=self.headers))
-        except urllib.error.URLError as e:
+        except (TimeoutError, urllib.error.URLError) as e:
             raise FetchIndexError("Could not fetch index from {}".format(url_index), e) from e
 
         try:
@@ -2505,10 +2495,7 @@ def __init__(self, url, etag, urlopen=web_util.urlopen):
     def conditional_fetch(self) -> FetchIndexResult:
         # Just do a conditional fetch immediately
         url = url_util.join(self.url, BUILD_CACHE_RELATIVE_PATH, "index.json")
-        headers = {
-            "User-Agent": web_util.SPACK_USER_AGENT,
-            "If-None-Match": '"{}"'.format(self.etag),
-        }
+        headers = {"User-Agent": web_util.SPACK_USER_AGENT, "If-None-Match": f'"{self.etag}"'}
 
         try:
             response = self.urlopen(urllib.request.Request(url, headers=headers))
@@ -2516,14 +2503,14 @@ def conditional_fetch(self) -> FetchIndexResult:
             if e.getcode() == 304:
                 # Not modified; that means fresh.
                 return FetchIndexResult(etag=None, hash=None, data=None, fresh=True)
-            raise FetchIndexError("Could not fetch index {}".format(url), e) from e
-        except urllib.error.URLError as e:
-            raise FetchIndexError("Could not fetch index {}".format(url), e) from e
+            raise FetchIndexError(f"Could not fetch index {url}", e) from e
+        except (TimeoutError, urllib.error.URLError) as e:
+            raise FetchIndexError(f"Could not fetch index {url}", e) from e
 
         try:
             result = codecs.getreader("utf-8")(response).read()
         except ValueError as e:
-            raise FetchIndexError("Remote index {} is invalid".format(url), e) from e
+            raise FetchIndexError(f"Remote index {url} is invalid", e) from e
 
         headers = response.headers
         etag_header_value = headers.get("Etag", None) or headers.get("etag", None)
@@ -2554,21 +2541,19 @@ def conditional_fetch(self) -> FetchIndexResult:
                     headers={"Accept": "application/vnd.oci.image.manifest.v1+json"},
                 )
             )
-        except urllib.error.URLError as e:
-            raise FetchIndexError(
-                "Could not fetch manifest from {}".format(url_manifest), e
-            ) from e
+        except (TimeoutError, urllib.error.URLError) as e:
+            raise FetchIndexError(f"Could not fetch manifest from {url_manifest}", e) from e
 
         try:
             manifest = json.loads(response.read())
         except Exception as e:
-            raise FetchIndexError("Remote index {} is invalid".format(url_manifest), e) from e
+            raise FetchIndexError(f"Remote index {url_manifest} is invalid", e) from e
 
         # Get first blob hash, which should be the index.json
         try:
             index_digest = spack.oci.image.Digest.from_string(manifest["layers"][0]["digest"])
         except Exception as e:
-            raise FetchIndexError("Remote index {} is invalid".format(url_manifest), e) from e
+            raise FetchIndexError(f"Remote index {url_manifest} is invalid", e) from e
 
         # Fresh?
         if index_digest.digest == self.local_hash:

lib/spack/spack/bootstrap/_common.py

@@ -213,18 +213,15 @@ def _root_spec(spec_str: str) -> str:
     Args:
         spec_str: spec to be bootstrapped. Must be without compiler and target.
     """
-    # Add a compiler and platform requirement to the root spec.
+    # Add a compiler requirement to the root spec.
     platform = str(spack.platforms.host())
-
     if platform == "darwin":
         spec_str += " %apple-clang"
-    elif platform == "windows":
-        spec_str += " %msvc"
     elif platform == "linux":
         spec_str += " %gcc"
     elif platform == "freebsd":
         spec_str += " %clang"
-    spec_str += f" platform={platform}"
+
     target = archspec.cpu.host().family
     spec_str += f" target={target}"
 

lib/spack/spack/bootstrap/config.py

@@ -129,10 +129,10 @@ def _bootstrap_config_scopes() -> Sequence["spack.config.ConfigScope"]:
     configuration_paths = (spack.config.CONFIGURATION_DEFAULTS_PATH, ("bootstrap", _config_path()))
     for name, path in configuration_paths:
         platform = spack.platforms.host().name
-        platform_scope = spack.config.DirectoryConfigScope(
-            f"{name}/{platform}", os.path.join(path, platform)
+        platform_scope = spack.config.ConfigScope(
+            "/".join([name, platform]), os.path.join(path, platform)
         )
-        generic_scope = spack.config.DirectoryConfigScope(name, path)
+        generic_scope = spack.config.ConfigScope(name, path)
         config_scopes.extend([generic_scope, platform_scope])
         msg = "[BOOTSTRAP CONFIG SCOPE] name={0}, path={1}"
         tty.debug(msg.format(generic_scope.name, generic_scope.path))

lib/spack/spack/build_environment.py

@@ -92,7 +92,7 @@
 )
 from spack.util.executable import Executable
 from spack.util.log_parse import make_log_context, parse_log_events
-from spack.util.module_cmd import load_module, path_from_modules
+from spack.util.module_cmd import load_module, module, path_from_modules
 
 #
 # This can be set by the user to globally disable parallel builds.
@@ -191,6 +191,14 @@ def __call__(self, *args, **kwargs):
         return super().__call__(*args, **kwargs)
 
 
+def _on_cray():
+    host_platform = spack.platforms.host()
+    host_os = host_platform.operating_system("default_os")
+    on_cray = str(host_platform) == "cray"
+    using_cnl = re.match(r"cnl\d+", str(host_os))
+    return on_cray, using_cnl
+
+
 def clean_environment():
     # Stuff in here sanitizes the build environment to eliminate
     # anything the user has set that may interfere. We apply it immediately
@@ -234,6 +242,17 @@ def clean_environment():
         if varname.endswith("_ROOT") and varname != "SPACK_ROOT":
             env.unset(varname)
 
+    # On Cray "cluster" systems, unset CRAY_LD_LIBRARY_PATH to avoid
+    # interference with Spack dependencies.
+    # CNL requires these variables to be set (or at least some of them,
+    # depending on the CNL version).
+    on_cray, using_cnl = _on_cray()
+    if on_cray and not using_cnl:
+        env.unset("CRAY_LD_LIBRARY_PATH")
+        for varname in os.environ.keys():
+            if "PKGCONF" in varname:
+                env.unset(varname)
+
     # Unset the following variables because they can affect installation of
     # Autotools and CMake packages.
     build_system_vars = [
@@ -363,7 +382,11 @@ def set_compiler_environment_variables(pkg, env):
     _add_werror_handling(keep_werror, env)
 
     # Set the target parameters that the compiler will add
-    isa_arg = spec.architecture.target.optimization_flags(compiler)
+    # Don't set on cray platform because the targeting module handles this
+    if spec.satisfies("platform=cray"):
+        isa_arg = ""
+    else:
+        isa_arg = spec.architecture.target.optimization_flags(compiler)
     env.set("SPACK_TARGET_ARGS", isa_arg)
 
     # Trap spack-tracked compiler flags as appropriate.
@@ -457,9 +480,12 @@ def set_wrapper_variables(pkg, env):
     env.set(SPACK_DEBUG_LOG_ID, pkg.spec.format("{name}-{hash:7}"))
     env.set(SPACK_DEBUG_LOG_DIR, spack.main.spack_working_dir)
 
-    # Find ccache binary and hand it to build environment
     if spack.config.get("config:ccache"):
+        # Enable ccache in the compiler wrapper
         env.set(SPACK_CCACHE_BINARY, spack.util.executable.which_string("ccache", required=True))
+    else:
+        # Avoid cache pollution if a build system forces `ccache <compiler wrapper invocation>`.
+        env.set("CCACHE_DISABLE", "1")
 
     # Gather information about various types of dependencies
     link_deps = set(pkg.spec.traverse(root=False, deptype=("link")))
@@ -738,9 +764,7 @@ def get_rpaths(pkg):
     # Second module is our compiler mod name. We use that to get rpaths from
     # module show output.
     if pkg.compiler.modules and len(pkg.compiler.modules) > 1:
-        mod_rpath = path_from_modules([pkg.compiler.modules[1]])
-        if mod_rpath:
-            rpaths.append(mod_rpath)
+        rpaths.append(path_from_modules([pkg.compiler.modules[1]]))
     return list(dedupe(filter_system_paths(rpaths)))
 
 
@@ -810,6 +834,14 @@ def setup_package(pkg, dirty, context: Context = Context.BUILD):
         for mod in pkg.compiler.modules:
             load_module(mod)
 
+    # kludge to handle cray mpich and libsci being automatically loaded by
+    # PrgEnv modules on cray platform. Module unload does no damage when
+    # unnecessary
+    on_cray, _ = _on_cray()
+    if on_cray and not dirty:
+        for mod in ["cray-mpich", "cray-libsci"]:
+            module("unload", mod)
+
     if target and target.module_name:
         load_module(target.module_name)
 

lib/spack/spack/build_systems/cached_cmake.py

@@ -162,9 +162,7 @@ def initconfig_compiler_entries(self):
             ld_flags = " ".join(flags["ldflags"])
             ld_format_string = "CMAKE_{0}_LINKER_FLAGS"
             # CMake has separate linker arguments for types of builds.
-            # 'ldflags' should not be used with CMAKE_STATIC_LINKER_FLAGS which
-            # is used by the archiver, so don't include "STATIC" in this loop:
-            for ld_type in ["EXE", "MODULE", "SHARED"]:
+            for ld_type in ["EXE", "MODULE", "SHARED", "STATIC"]:
                 ld_string = ld_format_string.format(ld_type)
                 entries.append(cmake_cache_string(ld_string, ld_flags))
 

lib/spack/spack/build_systems/cuda.py

@@ -110,8 +110,9 @@ def cuda_flags(arch_list):
     # From the NVIDIA install guide we know of conflicts for particular
     # platforms (linux, darwin), architectures (x86, powerpc) and compilers
     # (gcc, clang). We don't restrict %gcc and %clang conflicts to
-    # platform=linux, since they may apply to platform=darwin. We currently
-    # do not provide conflicts for platform=darwin with %apple-clang.
+    # platform=linux, since they should also apply to platform=cray, and may
+    # apply to platform=darwin. We currently do not provide conflicts for
+    # platform=darwin with %apple-clang.
 
     # Linux x86_64 compiler conflicts from here:
     # https://gist.github.com/ax3l/9489132
@@ -136,14 +137,11 @@ def cuda_flags(arch_list):
         conflicts("%gcc@11.2:", when="+cuda ^cuda@:11.5")
         conflicts("%gcc@12:", when="+cuda ^cuda@:11.8")
         conflicts("%gcc@13:", when="+cuda ^cuda@:12.3")
-        conflicts("%gcc@14:", when="+cuda ^cuda@:12.5")
         conflicts("%clang@12:", when="+cuda ^cuda@:11.4.0")
         conflicts("%clang@13:", when="+cuda ^cuda@:11.5")
         conflicts("%clang@14:", when="+cuda ^cuda@:11.7")
         conflicts("%clang@15:", when="+cuda ^cuda@:12.0")
-        conflicts("%clang@16:", when="+cuda ^cuda@:12.1")
-        conflicts("%clang@17:", when="+cuda ^cuda@:12.3")
-        conflicts("%clang@18:", when="+cuda ^cuda@:12.5")
+        conflicts("%clang@16:", when="+cuda ^cuda@:12.3")
 
         # https://gist.github.com/ax3l/9489132#gistcomment-3860114
         conflicts("%gcc@10", when="+cuda ^cuda@:11.4.0")

lib/spack/spack/build_systems/intel.py

@@ -846,7 +846,6 @@ def scalapack_libs(self):
             "^mpich@2:" in spec_root
             or "^cray-mpich" in spec_root
             or "^mvapich2" in spec_root
-            or "^mvapich" in spec_root
             or "^intel-mpi" in spec_root
             or "^intel-oneapi-mpi" in spec_root
             or "^intel-parallel-studio" in spec_root
@@ -937,15 +936,32 @@ def mpi_setup_dependent_build_environment(self, env, dependent_spec, compilers_o
             "I_MPI_ROOT": self.normalize_path("mpi"),
         }
 
-        compiler_wrapper_commands = self.mpi_compiler_wrappers
-        wrapper_vars.update(
-            {
-                "MPICC": compiler_wrapper_commands["MPICC"],
-                "MPICXX": compiler_wrapper_commands["MPICXX"],
-                "MPIF77": compiler_wrapper_commands["MPIF77"],
-                "MPIF90": compiler_wrapper_commands["MPIF90"],
-            }
-        )
+        # CAUTION - SIMILAR code in:
+        #   var/spack/repos/builtin/packages/mpich/package.py
+        #   var/spack/repos/builtin/packages/openmpi/package.py
+        #   var/spack/repos/builtin/packages/mvapich2/package.py
+        #
+        # On Cray, the regular compiler wrappers *are* the MPI wrappers.
+        if "platform=cray" in self.spec:
+            # TODO: Confirm
+            wrapper_vars.update(
+                {
+                    "MPICC": compilers_of_client["CC"],
+                    "MPICXX": compilers_of_client["CXX"],
+                    "MPIF77": compilers_of_client["F77"],
+                    "MPIF90": compilers_of_client["F90"],
+                }
+            )
+        else:
+            compiler_wrapper_commands = self.mpi_compiler_wrappers
+            wrapper_vars.update(
+                {
+                    "MPICC": compiler_wrapper_commands["MPICC"],
+                    "MPICXX": compiler_wrapper_commands["MPICXX"],
+                    "MPIF77": compiler_wrapper_commands["MPIF77"],
+                    "MPIF90": compiler_wrapper_commands["MPIF90"],
+                }
+            )
 
         # Ensure that the directory containing the compiler wrappers is in the
         # PATH. Spack packages add `prefix.bin` to their dependents' paths,

lib/spack/spack/build_systems/msbuild.py

@@ -24,6 +24,7 @@ class MSBuildPackage(spack.package_base.PackageBase):
     build_system("msbuild")
     conflicts("platform=linux", when="build_system=msbuild")
     conflicts("platform=darwin", when="build_system=msbuild")
+    conflicts("platform=cray", when="build_system=msbuild")
 
 
 @spack.builder.builder("msbuild")

lib/spack/spack/build_systems/nmake.py

@@ -24,6 +24,7 @@ class NMakePackage(spack.package_base.PackageBase):
     build_system("nmake")
     conflicts("platform=linux", when="build_system=nmake")
     conflicts("platform=darwin", when="build_system=nmake")
+    conflicts("platform=cray", when="build_system=nmake")
 
 
 @spack.builder.builder("nmake")

lib/spack/spack/build_systems/oneapi.py

@@ -36,8 +36,9 @@ class IntelOneApiPackage(Package):
         "target=ppc64:",
         "target=ppc64le:",
         "target=aarch64:",
-        "platform=darwin",
-        "platform=windows",
+        "platform=darwin:",
+        "platform=cray:",
+        "platform=windows:",
     ]:
         conflicts(c, msg="This package in only available for x86_64 and Linux")
 

lib/spack/spack/caches.py

@@ -34,8 +34,6 @@ def _misc_cache():
     return spack.util.file_cache.FileCache(path)
 
 
-FileCacheType = Union[spack.util.file_cache.FileCache, llnl.util.lang.Singleton]
-
 #: Spack's cache for small data
 MISC_CACHE: Union[spack.util.file_cache.FileCache, llnl.util.lang.Singleton] = (
     llnl.util.lang.Singleton(_misc_cache)

lib/spack/spack/ci.py

@@ -22,8 +22,6 @@
 from urllib.parse import urlencode
 from urllib.request import HTTPHandler, Request, build_opener
 
-import ruamel.yaml
-
 import llnl.util.filesystem as fs
 import llnl.util.tty as tty
 from llnl.util.lang import memoized
@@ -553,9 +551,10 @@ def generate_gitlab_ci_yaml(
     env,
     print_summary,
     output_file,
-    *,
     prune_dag=False,
     check_index_only=False,
+    run_optimizer=False,
+    use_dependencies=False,
     artifacts_root=None,
     remote_mirror_override=None,
 ):
@@ -576,6 +575,12 @@ def generate_gitlab_ci_yaml(
             this mode results in faster yaml generation time). Otherwise, also
             check each spec directly by url (useful if there is no index or it
             might be out of date).
+        run_optimizer (bool): If True, post-process the generated yaml to try
+            try to reduce the size (attempts to collect repeated configuration
+            and replace with definitions).)
+        use_dependencies (bool): If true, use "dependencies" rather than "needs"
+            ("needs" allows DAG scheduling).  Useful if gitlab instance cannot
+            be configured to handle more than a few "needs" per job.
         artifacts_root (str): Path where artifacts like logs, environment
             files (spack.yaml, spack.lock), etc should be written.  GitLab
             requires this to be within the project directory.
@@ -809,8 +814,7 @@ def ensure_expected_target_path(path):
         cli_scopes = [
             os.path.relpath(s.path, concrete_env_dir)
             for s in cfg.scopes().values()
-            if not s.writable
-            and isinstance(s, (cfg.DirectoryConfigScope))
+            if isinstance(s, cfg.ImmutableConfigScope)
             and s.path not in env_includes
             and os.path.exists(s.path)
         ]
@@ -1107,7 +1111,7 @@ def main_script_replacements(cmd):
     if cdash_handler and cdash_handler.auth_token:
         try:
             cdash_handler.populate_buildgroup(all_job_names)
-        except (SpackError, HTTPError, URLError) as err:
+        except (SpackError, HTTPError, URLError, TimeoutError) as err:
             tty.warn(f"Problem populating buildgroup: {err}")
     else:
         tty.warn("Unable to populate buildgroup without CDash credentials")
@@ -1267,6 +1271,17 @@ def main_script_replacements(cmd):
             with open(copy_specs_file, "w") as fd:
                 fd.write(json.dumps(buildcache_copies))
 
+        # TODO(opadron): remove this or refactor
+        if run_optimizer:
+            import spack.ci_optimization as ci_opt
+
+            output_object = ci_opt.optimizer(output_object)
+
+        # TODO(opadron): remove this or refactor
+        if use_dependencies:
+            import spack.ci_needs_workaround as cinw
+
+            output_object = cinw.needs_to_dependencies(output_object)
     else:
         # No jobs were generated
         noop_job = spack_ci_ir["jobs"]["noop"]["attributes"]
@@ -1295,11 +1310,8 @@ def main_script_replacements(cmd):
         if not rebuild_everything:
             sys.exit(1)
 
-    # Minimize yaml output size through use of anchors
-    syaml.anchorify(sorted_output)
-
-    with open(output_file, "w") as f:
-        ruamel.yaml.YAML().dump(sorted_output, f)
+    with open(output_file, "w") as outf:
+        outf.write(syaml.dump(sorted_output, default_flow_style=True))
 
 
 def _url_encode_string(input_string):
@@ -2083,7 +2095,7 @@ def read_broken_spec(broken_spec_url):
     """
     try:
         _, _, fs = web_util.read_from_url(broken_spec_url)
-    except (URLError, web_util.SpackWebError, HTTPError):
+    except web_util.SpackWebError:
         tty.warn(f"Unable to read broken spec from {broken_spec_url}")
         return None
 

lib/spack/spack/ci_needs_workaround.py

@@ -0,0 +1,34 @@
+# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+# Spack Project Developers. See the top-level COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+import collections.abc
+
+get_job_name = lambda needs_entry: (
+    needs_entry.get("job")
+    if (isinstance(needs_entry, collections.abc.Mapping) and needs_entry.get("artifacts", True))
+    else needs_entry if isinstance(needs_entry, str) else None
+)
+
+
+def convert_job(job_entry):
+    if not isinstance(job_entry, collections.abc.Mapping):
+        return job_entry
+
+    needs = job_entry.get("needs")
+    if needs is None:
+        return job_entry
+
+    new_job = {}
+    new_job.update(job_entry)
+    del new_job["needs"]
+
+    new_job["dependencies"] = list(
+        filter((lambda x: x is not None), (get_job_name(needs_entry) for needs_entry in needs))
+    )
+
+    return new_job
+
+
+def needs_to_dependencies(yaml):
+    return dict((k, convert_job(v)) for k, v in yaml.items())

lib/spack/spack/ci_optimization.py

@@ -0,0 +1,363 @@
+# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+# Spack Project Developers. See the top-level COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+import collections
+import collections.abc
+import copy
+import hashlib
+
+import spack.util.spack_yaml as syaml
+
+
+def sort_yaml_obj(obj):
+    if isinstance(obj, collections.abc.Mapping):
+        return syaml.syaml_dict(
+            (k, sort_yaml_obj(v)) for k, v in sorted(obj.items(), key=(lambda item: str(item[0])))
+        )
+
+    if isinstance(obj, collections.abc.Sequence) and not isinstance(obj, str):
+        return syaml.syaml_list(sort_yaml_obj(x) for x in obj)
+
+    return obj
+
+
+def matches(obj, proto):
+    """Returns True if the test object "obj" matches the prototype object
+    "proto".
+
+    If obj and proto are mappings, obj matches proto if (key in obj) and
+    (obj[key] matches proto[key]) for every key in proto.
+
+    If obj and proto are sequences, obj matches proto if they are of the same
+    length and (a matches b) for every (a,b) in zip(obj, proto).
+
+    Otherwise, obj matches proto if obj == proto.
+
+    Precondition: proto must not have any reference cycles
+    """
+    if isinstance(obj, collections.abc.Mapping):
+        if not isinstance(proto, collections.abc.Mapping):
+            return False
+
+        return all((key in obj and matches(obj[key], val)) for key, val in proto.items())
+
+    if isinstance(obj, collections.abc.Sequence) and not isinstance(obj, str):
+        if not (isinstance(proto, collections.abc.Sequence) and not isinstance(proto, str)):
+            return False
+
+        if len(obj) != len(proto):
+            return False
+
+        return all(matches(obj[index], val) for index, val in enumerate(proto))
+
+    return obj == proto
+
+
+def subkeys(obj, proto):
+    """Returns the test mapping "obj" after factoring out the items it has in
+    common with the prototype mapping "proto".
+
+    Consider a recursive merge operation, merge(a, b) on mappings a and b, that
+    returns a mapping, m, whose keys are the union of the keys of a and b, and
+    for every such key, "k", its corresponding value is:
+
+      - merge(a[key], b[key])  if a[key] and b[key] are mappings, or
+      - b[key]                 if (key in b) and not matches(a[key], b[key]),
+                               or
+      - a[key]                 otherwise
+
+
+    If obj and proto are mappings, the returned object is the smallest object,
+    "a", such that merge(a, proto) matches obj.
+
+    Otherwise, obj is returned.
+    """
+    if not (
+        isinstance(obj, collections.abc.Mapping) and isinstance(proto, collections.abc.Mapping)
+    ):
+        return obj
+
+    new_obj = {}
+    for key, value in obj.items():
+        if key not in proto:
+            new_obj[key] = value
+            continue
+
+        if matches(value, proto[key]) and matches(proto[key], value):
+            continue
+
+        if isinstance(value, collections.abc.Mapping):
+            new_obj[key] = subkeys(value, proto[key])
+            continue
+
+        new_obj[key] = value
+
+    return new_obj
+
+
+def add_extends(yaml, key):
+    """Modifies the given object "yaml" so that it includes an "extends" key
+    whose value features "key".
+
+    If "extends" is not in yaml, then yaml is modified such that
+    yaml["extends"] == key.
+
+    If yaml["extends"] is a str, then yaml is modified such that
+    yaml["extends"] == [yaml["extends"], key]
+
+    If yaml["extends"] is a list that does not include key, then key is
+    appended to the list.
+
+    Otherwise, yaml is left unchanged.
+    """
+
+    has_key = "extends" in yaml
+    extends = yaml.get("extends")
+
+    if has_key and not isinstance(extends, (str, collections.abc.Sequence)):
+        return
+
+    if extends is None:
+        yaml["extends"] = key
+        return
+
+    if isinstance(extends, str):
+        if extends != key:
+            yaml["extends"] = [extends, key]
+        return
+
+    if key not in extends:
+        extends.append(key)
+
+
+def common_subobject(yaml, sub):
+    """Factor prototype object "sub" out of the values of mapping "yaml".
+
+    Consider a modified copy of yaml, "new", where for each key, "key" in yaml:
+
+      - If yaml[key] matches sub, then new[key] = subkeys(yaml[key], sub).
+      - Otherwise, new[key] = yaml[key].
+
+    If the above match criteria is not satisfied for any such key, then (yaml,
+    None) is returned. The yaml object is returned unchanged.
+
+    Otherwise, each matching value in new is modified as in
+    add_extends(new[key], common_key), and then new[common_key] is set to sub.
+    The common_key value is chosen such that it does not match any preexisting
+    key in new. In this case, (new, common_key) is returned.
+    """
+    match_list = set(k for k, v in yaml.items() if matches(v, sub))
+
+    if not match_list:
+        return yaml, None
+
+    common_prefix = ".c"
+    common_index = 0
+
+    while True:
+        common_key = "".join((common_prefix, str(common_index)))
+        if common_key not in yaml:
+            break
+        common_index += 1
+
+    new_yaml = {}
+
+    for key, val in yaml.items():
+        new_yaml[key] = copy.deepcopy(val)
+
+        if not matches(val, sub):
+            continue
+
+        new_yaml[key] = subkeys(new_yaml[key], sub)
+        add_extends(new_yaml[key], common_key)
+
+    new_yaml[common_key] = sub
+
+    return new_yaml, common_key
+
+
+def print_delta(name, old, new, applied=None):
+    delta = new - old
+    reldelta = (1000 * delta) // old
+    reldelta = (reldelta // 10, reldelta % 10)
+
+    if applied is None:
+        applied = new <= old
+
+    print(
+        "\n".join(
+            (
+                "{0} {1}:",
+                "  before: {2: 10d}",
+                "  after : {3: 10d}",
+                "  delta : {4:+10d} ({5:=+3d}.{6}%)",
+            )
+        ).format(name, ("+" if applied else "x"), old, new, delta, reldelta[0], reldelta[1])
+    )
+
+
+def try_optimization_pass(name, yaml, optimization_pass, *args, **kwargs):
+    """Try applying an optimization pass and return information about the
+    result
+
+    "name" is a string describing the nature of the pass. If it is a non-empty
+    string, summary statistics are also printed to stdout.
+
+    "yaml" is the object to apply the pass to.
+
+    "optimization_pass" is the function implementing the pass to be applied.
+
+    "args" and "kwargs" are the additional arguments to pass to optimization
+    pass. The pass is applied as
+
+    >>> (new_yaml, *other_results) = optimization_pass(yaml, *args, **kwargs)
+
+    The pass's results are greedily rejected if it does not modify the original
+    yaml document, or if it produces a yaml document that serializes to a
+    larger string.
+
+    Returns (new_yaml, yaml, applied, other_results) if applied, or
+    (yaml, new_yaml, applied, other_results) otherwise.
+    """
+    result = optimization_pass(yaml, *args, **kwargs)
+    new_yaml, other_results = result[0], result[1:]
+
+    if new_yaml is yaml:
+        # pass was not applied
+        return (yaml, new_yaml, False, other_results)
+
+    pre_size = len(syaml.dump_config(sort_yaml_obj(yaml), default_flow_style=True))
+    post_size = len(syaml.dump_config(sort_yaml_obj(new_yaml), default_flow_style=True))
+
+    # pass makes the size worse: not applying
+    applied = post_size <= pre_size
+    if applied:
+        yaml, new_yaml = new_yaml, yaml
+
+    if name:
+        print_delta(name, pre_size, post_size, applied)
+
+    return (yaml, new_yaml, applied, other_results)
+
+
+def build_histogram(iterator, key):
+    """Builds a histogram of values given an iterable of mappings and a key.
+
+    For each mapping "m" with key "key" in iterator, the value m[key] is
+    considered.
+
+    Returns a list of tuples (hash, count, proportion, value), where
+
+      - "hash" is a sha1sum hash of the value.
+      - "count" is the number of occurences of values that hash to "hash".
+      - "proportion" is the proportion of all values considered above that
+        hash to "hash".
+      - "value" is one of the values considered above that hash to "hash".
+        Which value is chosen when multiple values hash to the same "hash" is
+        undefined.
+
+    The list is sorted in descending order by count, yielding the most
+    frequently occuring hashes first.
+    """
+    buckets = collections.defaultdict(int)
+    values = {}
+
+    num_objects = 0
+    for obj in iterator:
+        num_objects += 1
+
+        try:
+            val = obj[key]
+        except (KeyError, TypeError):
+            continue
+
+        value_hash = hashlib.sha1()
+        value_hash.update(syaml.dump_config(sort_yaml_obj(val)).encode())
+        value_hash = value_hash.hexdigest()
+
+        buckets[value_hash] += 1
+        values[value_hash] = val
+
+    return [
+        (h, buckets[h], float(buckets[h]) / num_objects, values[h])
+        for h in sorted(buckets.keys(), key=lambda k: -buckets[k])
+    ]
+
+
+def optimizer(yaml):
+    original_size = len(syaml.dump_config(sort_yaml_obj(yaml), default_flow_style=True))
+
+    # try factoring out commonly repeated portions
+    common_job = {
+        "variables": {"SPACK_COMPILER_ACTION": "NONE"},
+        "after_script": ['rm -rf "./spack"'],
+        "artifacts": {"paths": ["jobs_scratch_dir", "cdash_report"], "when": "always"},
+    }
+
+    # look for a list of tags that appear frequently
+    _, count, proportion, tags = next(iter(build_histogram(yaml.values(), "tags")), (None,) * 4)
+
+    # If a list of tags is found, and there are more than one job that uses it,
+    # *and* the jobs that do use it represent at least 70% of all jobs, then
+    # add the list to the prototype object.
+    if tags and count > 1 and proportion >= 0.70:
+        common_job["tags"] = tags
+
+    # apply common object factorization
+    yaml, other, applied, rest = try_optimization_pass(
+        "general common object factorization", yaml, common_subobject, common_job
+    )
+
+    # look for a common script, and try factoring that out
+    _, count, proportion, script = next(
+        iter(build_histogram(yaml.values(), "script")), (None,) * 4
+    )
+
+    if script and count > 1 and proportion >= 0.70:
+        yaml, other, applied, rest = try_optimization_pass(
+            "script factorization", yaml, common_subobject, {"script": script}
+        )
+
+    # look for a common before_script, and try factoring that out
+    _, count, proportion, script = next(
+        iter(build_histogram(yaml.values(), "before_script")), (None,) * 4
+    )
+
+    if script and count > 1 and proportion >= 0.70:
+        yaml, other, applied, rest = try_optimization_pass(
+            "before_script factorization", yaml, common_subobject, {"before_script": script}
+        )
+
+    # Look specifically for the SPACK_ROOT_SPEC environment variables.
+    # Try to factor them out.
+    h = build_histogram(
+        (getattr(val, "get", lambda *args: {})("variables") for val in yaml.values()),
+        "SPACK_ROOT_SPEC",
+    )
+
+    # In this case, we try to factor out *all* instances of the SPACK_ROOT_SPEC
+    # environment variable; not just the one that appears with the greatest
+    # frequency. We only require that more than 1 job uses a given instance's
+    # value, because we expect the value to be very large, and so expect even
+    # few-to-one factorizations to yield large space savings.
+    counter = 0
+    for _, count, proportion, spec in h:
+        if count <= 1:
+            continue
+
+        counter += 1
+
+        yaml, other, applied, rest = try_optimization_pass(
+            "SPACK_ROOT_SPEC factorization ({count})".format(count=counter),
+            yaml,
+            common_subobject,
+            {"variables": {"SPACK_ROOT_SPEC": spec}},
+        )
+
+    new_size = len(syaml.dump_config(sort_yaml_obj(yaml), default_flow_style=True))
+
+    print("\n")
+    print_delta("overall summary", original_size, new_size)
+    print("\n")
+    return yaml

lib/spack/spack/cmd/__init__.py

@@ -336,7 +336,6 @@ def display_specs(specs, args=None, **kwargs):
         groups (bool): display specs grouped by arch/compiler (default True)
         decorator (typing.Callable): function to call to decorate specs
         all_headers (bool): show headers even when arch/compiler aren't defined
-        status_fn (typing.Callable): if provided, prepend install-status info
         output (typing.IO): A file object to write to. Default is ``sys.stdout``
 
     """
@@ -360,7 +359,6 @@ def get_arg(name, default=None):
     groups = get_arg("groups", True)
     all_headers = get_arg("all_headers", False)
     output = get_arg("output", sys.stdout)
-    status_fn = get_arg("status_fn", None)
 
     decorator = get_arg("decorator", None)
     if decorator is None:
@@ -388,13 +386,6 @@ def get_arg(name, default=None):
     def fmt(s, depth=0):
         """Formatter function for all output specs"""
         string = ""
-
-        if status_fn:
-            # This was copied from spec.tree's colorization logic
-            # then shortened because it seems like status_fn should
-            # always return an InstallStatus
-            string += colorize(status_fn(s).value)
-
         if hashes:
             string += gray_hash(s, hlen) + " "
         string += depth * "    "
@@ -453,7 +444,7 @@ def format_list(specs):
 def filter_loaded_specs(specs):
     """Filter a list of specs returning only those that are
     currently loaded."""
-    hashes = os.environ.get(uenv.spack_loaded_hashes_var, "").split(os.pathsep)
+    hashes = os.environ.get(uenv.spack_loaded_hashes_var, "").split(":")
     return [x for x in specs if x.dag_hash() in hashes]
 
 

lib/spack/spack/cmd/bootstrap.py

@@ -165,7 +165,7 @@ def _reset(args):
         if not ok_to_continue:
             raise RuntimeError("Aborting")
 
-    for scope in spack.config.CONFIG.writable_scopes:
+    for scope in spack.config.CONFIG.file_scopes:
         # The default scope should stay untouched
         if scope.name == "defaults":
             continue

lib/spack/spack/cmd/buildcache.py

@@ -70,6 +70,12 @@ def setup_parser(subparser: argparse.ArgumentParser):
 
     push = subparsers.add_parser("push", aliases=["create"], help=push_fn.__doc__)
     push.add_argument("-f", "--force", action="store_true", help="overwrite tarball if it exists")
+    push.add_argument(
+        "--allow-root",
+        "-a",
+        action="store_true",
+        help="allow install root string in binary files after RPATH substitution",
+    )
     push_sign = push.add_mutually_exclusive_group(required=False)
     push_sign.add_argument(
         "--unsigned",
@@ -184,6 +190,10 @@ def setup_parser(subparser: argparse.ArgumentParser):
     keys.add_argument("-f", "--force", action="store_true", help="force new download of keys")
     keys.set_defaults(func=keys_fn)
 
+    preview = subparsers.add_parser("preview", help=preview_fn.__doc__)
+    arguments.add_common_arguments(preview, ["installed_specs"])
+    preview.set_defaults(func=preview_fn)
+
     # Check if binaries need to be rebuilt on remote mirror
     check = subparsers.add_parser("check", help=check_fn.__doc__)
     check.add_argument(
@@ -394,6 +404,11 @@ def push_fn(args):
     else:
         roots = spack.cmd.require_active_env(cmd_name="buildcache push").concrete_roots()
 
+    if args.allow_root:
+        tty.warn(
+            "The flag `--allow-root` is the default in Spack 0.21, will be removed in Spack 0.22"
+        )
+
     mirror: spack.mirror.Mirror = args.mirror
 
     # Check if this is an OCI image.
@@ -798,7 +813,7 @@ def _push_oci(
 
     def extra_config(spec: Spec):
         spec_dict = spec.to_dict(hash=ht.dag_hash)
-        spec_dict["buildcache_layout_version"] = 1
+        spec_dict["buildcache_layout_version"] = bindist.CURRENT_BUILD_CACHE_LAYOUT_VERSION
         spec_dict["binary_cache_checksum"] = {
             "hash_algorithm": "sha256",
             "hash": checksums[spec.dag_hash()].compressed_digest.digest,
@@ -945,6 +960,14 @@ def keys_fn(args):
     bindist.get_keys(args.install, args.trust, args.force)
 
 
+def preview_fn(args):
+    """analyze an installed spec and reports whether executables and libraries are relocatable"""
+    tty.warn(
+        "`spack buildcache preview` is deprecated since `spack buildcache push --allow-root` is "
+        "now the default. This command will be removed in Spack 0.22"
+    )
+
+
 def check_fn(args: argparse.Namespace):
     """check specs against remote binary mirror(s) to see if any need to be rebuilt
 

lib/spack/spack/cmd/ci.py

@@ -6,7 +6,6 @@
 import json
 import os
 import shutil
-import warnings
 from urllib.parse import urlparse, urlunparse
 
 import llnl.util.filesystem as fs
@@ -74,7 +73,7 @@ def setup_parser(subparser):
         "--optimize",
         action="store_true",
         default=False,
-        help="(DEPRECATED) optimize the gitlab yaml file for size\n\n"
+        help="(experimental) optimize the gitlab yaml file for size\n\n"
         "run the generated document through a series of optimization passes "
         "designed to reduce the size of the generated file",
     )
@@ -82,7 +81,7 @@ def setup_parser(subparser):
         "--dependencies",
         action="store_true",
         default=False,
-        help="(DEPRECATED) disable DAG scheduling (use 'plain' dependencies)",
+        help="(experimental) disable DAG scheduling (use 'plain' dependencies)",
     )
     generate.add_argument(
         "--buildcache-destination",
@@ -201,18 +200,6 @@ def ci_generate(args):
     before invoking this command. the value must be the CDash authorization token needed to create
     a build group and register all generated jobs under it
     """
-    if args.optimize:
-        warnings.warn(
-            "The --optimize option has been deprecated, and currently has no effect. "
-            "It will be removed in Spack v0.24."
-        )
-
-    if args.dependencies:
-        warnings.warn(
-            "The --dependencies option has been deprecated, and currently has no effect. "
-            "It will be removed in Spack v0.24."
-        )
-
     env = spack.cmd.require_active_env(cmd_name="ci generate")
 
     if args.copy_to:
@@ -225,6 +212,8 @@ def ci_generate(args):
 
     output_file = args.output_file
     copy_yaml_to = args.copy_to
+    run_optimizer = args.optimize
+    use_dependencies = args.dependencies
     prune_dag = args.prune_dag
     index_only = args.index_only
     artifacts_root = args.artifacts_root
@@ -245,6 +234,8 @@ def ci_generate(args):
         output_file,
         prune_dag=prune_dag,
         check_index_only=index_only,
+        run_optimizer=run_optimizer,
+        use_dependencies=use_dependencies,
         artifacts_root=artifacts_root,
         remote_mirror_override=buildcache_destination,
     )

lib/spack/spack/cmd/clean.py

@@ -106,8 +106,7 @@ def clean(parser, args):
 
     # Then do the cleaning falling through the cases
     if args.specs:
-        specs = spack.cmd.parse_specs(args.specs, concretize=False)
-        specs = list(spack.cmd.matching_spec_from_env(x) for x in specs)
+        specs = spack.cmd.parse_specs(args.specs, concretize=True)
         for spec in specs:
             msg = "Cleaning build stage [{0}]"
             tty.msg(msg.format(spec.short_spec))

lib/spack/spack/cmd/commands.py

@@ -11,7 +11,6 @@
 from argparse import ArgumentParser, Namespace
 from typing import IO, Any, Callable, Dict, Iterable, List, Optional, Sequence, Set, Tuple, Union
 
-import llnl.util.filesystem as fs
 import llnl.util.tty as tty
 from llnl.util.argparsewriter import ArgparseRstWriter, ArgparseWriter, Command
 from llnl.util.tty.colify import colify
@@ -867,9 +866,6 @@ def _commands(parser: ArgumentParser, args: Namespace) -> None:
             prepend_header(args, f)
             formatter(args, f)
 
-        if args.update_completion:
-            fs.set_executable(args.update)
-
     else:
         prepend_header(args, sys.stdout)
         formatter(args, sys.stdout)

lib/spack/spack/cmd/concretize.py

@@ -3,9 +3,6 @@
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
-import llnl.util.tty as tty
-from llnl.string import plural
-
 import spack.cmd
 import spack.cmd.common.arguments
 import spack.environment as ev
@@ -46,9 +43,5 @@ def concretize(parser, args):
     with env.write_transaction():
         concretized_specs = env.concretize(force=args.force, tests=tests)
         if not args.quiet:
-            if concretized_specs:
-                tty.msg(f"Concretized {plural(len(concretized_specs), 'spec')}:")
-                ev.display_specs([concrete for _, concrete in concretized_specs])
-            else:
-                tty.msg("No new specs to concretize.")
+            ev.display_specs(concretized_specs)
         env.write()

lib/spack/spack/cmd/config.py

@@ -156,7 +156,7 @@ def print_flattened_configuration(*, blame: bool) -> None:
     """
     env = ev.active_environment()
     if env is not None:
-        pristine = env.manifest.yaml_content
+        pristine = env.manifest.pristine_yaml_content
         flattened = pristine.copy()
         flattened[spack.schema.env.TOP_LEVEL_KEY] = pristine[spack.schema.env.TOP_LEVEL_KEY].copy()
     else:
@@ -264,9 +264,7 @@ def config_remove(args):
 def _can_update_config_file(scope: spack.config.ConfigScope, cfg_file):
     if isinstance(scope, spack.config.SingleFileScope):
         return fs.can_access(cfg_file)
-    elif isinstance(scope, spack.config.DirectoryConfigScope):
-        return fs.can_write_to_dir(scope.path) and fs.can_access(cfg_file)
-    return False
+    return fs.can_write_to_dir(scope.path) and fs.can_access(cfg_file)
 
 
 def _config_change_requires_scope(path, spec, scope, match_spec=None):
@@ -364,11 +362,14 @@ def config_change(args):
 def config_update(args):
     # Read the configuration files
     spack.config.CONFIG.get_config(args.section, scope=args.scope)
-    updates: List[spack.config.ConfigScope] = [
-        x
-        for x in spack.config.CONFIG.format_updates[args.section]
-        if not isinstance(x, spack.config.InternalConfigScope) and x.writable
-    ]
+    updates: List[spack.config.ConfigScope] = list(
+        filter(
+            lambda s: not isinstance(
+                s, (spack.config.InternalConfigScope, spack.config.ImmutableConfigScope)
+            ),
+            spack.config.CONFIG.format_updates[args.section],
+        )
+    )
 
     cannot_overwrite, skip_system_scope = [], False
     for scope in updates:
@@ -446,7 +447,7 @@ def _can_revert_update(scope_dir, cfg_file, bkp_file):
 
 
 def config_revert(args):
-    scopes = [args.scope] if args.scope else [x.name for x in spack.config.CONFIG.writable_scopes]
+    scopes = [args.scope] if args.scope else [x.name for x in spack.config.CONFIG.file_scopes]
 
     # Search for backup files in the configuration scopes
     Entry = collections.namedtuple("Entry", ["scope", "cfg", "bkp"])

lib/spack/spack/cmd/create.py

@@ -2,6 +2,7 @@
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
 import os
 import re
 import sys
@@ -933,7 +934,7 @@ def get_repository(args, name):
     # Figure out where the new package should live
     repo_path = args.repo
     if repo_path is not None:
-        repo = spack.repo.from_path(repo_path)
+        repo = spack.repo.Repo(repo_path)
         if spec.namespace and spec.namespace != repo.namespace:
             tty.die(
                 "Can't create package with namespace {0} in repo with "
@@ -941,7 +942,9 @@ def get_repository(args, name):
             )
     else:
         if spec.namespace:
-            repo = spack.repo.PATH.get_repo(spec.namespace)
+            repo = spack.repo.PATH.get_repo(spec.namespace, None)
+            if not repo:
+                tty.die("Unknown namespace: '{0}'".format(spec.namespace))
         else:
             repo = spack.repo.PATH.first_repo()
 

lib/spack/spack/cmd/develop.py

@@ -9,8 +9,6 @@
 
 import spack.cmd
 import spack.config
-import spack.fetch_strategy
-import spack.repo
 import spack.spec
 import spack.util.path
 import spack.version
@@ -71,15 +69,13 @@ def _retrieve_develop_source(spec, abspath):
     # We construct a package class ourselves, rather than asking for
     # Spec.package, since Spec only allows this when it is concrete
     package = pkg_cls(spec)
-    source_stage = package.stage[0]
-    if isinstance(source_stage.fetcher, spack.fetch_strategy.GitFetchStrategy):
-        source_stage.fetcher.get_full_repo = True
+    if isinstance(package.stage[0].fetcher, spack.fetch_strategy.GitFetchStrategy):
+        package.stage[0].fetcher.get_full_repo = True
         # If we retrieved this version before and cached it, we may have
         # done so without cloning the full git repo; likewise, any
         # mirror might store an instance with truncated history.
-        source_stage.disable_mirrors()
+        package.stage[0].disable_mirrors()
 
-    source_stage.fetcher.set_package(package)
     package.stage.steal_source(abspath)
 
 

lib/spack/spack/cmd/edit.py

@@ -3,7 +3,6 @@
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
-import errno
 import glob
 import os
 
@@ -12,13 +11,43 @@
 import spack.cmd
 import spack.paths
 import spack.repo
-import spack.util.editor
+from spack.spec import Spec
+from spack.util.editor import editor
 
 description = "open package files in $EDITOR"
 section = "packaging"
 level = "short"
 
 
+def edit_package(name, repo_path, namespace):
+    """Opens the requested package file in your favorite $EDITOR.
+
+    Args:
+        name (str): The name of the package
+        repo_path (str): The path to the repository containing this package
+        namespace (str): A valid namespace registered with Spack
+    """
+    # Find the location of the package
+    if repo_path:
+        repo = spack.repo.Repo(repo_path)
+    elif namespace:
+        repo = spack.repo.PATH.get_repo(namespace)
+    else:
+        repo = spack.repo.PATH
+    path = repo.filename_for_package_name(name)
+
+    spec = Spec(name)
+    if os.path.exists(path):
+        if not os.path.isfile(path):
+            tty.die("Something is wrong. '{0}' is not a file!".format(path))
+        if not os.access(path, os.R_OK):
+            tty.die("Insufficient permissions on '%s'!" % path)
+    else:
+        raise spack.repo.UnknownPackageError(spec.name)
+
+    editor(path)
+
+
 def setup_parser(subparser):
     excl_args = subparser.add_mutually_exclusive_group()
 
@@ -69,67 +98,41 @@ def setup_parser(subparser):
     excl_args.add_argument("-r", "--repo", default=None, help="path to repo to edit package in")
     excl_args.add_argument("-N", "--namespace", default=None, help="namespace of package to edit")
 
-    subparser.add_argument("package", nargs="*", default=None, help="package name")
-
-
-def locate_package(name: str, repo: spack.repo.Repo) -> str:
-    path = repo.filename_for_package_name(name)
-
-    try:
-        with open(path, "r"):
-            return path
-    except OSError as e:
-        if e.errno == errno.ENOENT:
-            raise spack.repo.UnknownPackageError(name) from e
-        tty.die(f"Cannot edit package: {e}")
-
-
-def locate_file(name: str, path: str) -> str:
-    # convert command names to python module name
-    if path == spack.paths.command_path:
-        name = spack.cmd.python_name(name)
-
-    file_path = os.path.join(path, name)
-
-    # Try to open direct match.
-    try:
-        with open(file_path, "r"):
-            return file_path
-    except OSError as e:
-        if e.errno != errno.ENOENT:
-            tty.die(f"Cannot edit file: {e}")
-        pass
-
-    # Otherwise try to find a file that starts with the name
-    candidates = glob.glob(file_path + "*")
-    exclude_list = [".pyc", "~"]  # exclude binaries and backups
-    files = [f for f in candidates if not any(f.endswith(ext) for ext in exclude_list)]
-    if len(files) > 1:
-        tty.die(
-            f"Multiple files start with `{name}`:\n"
-            + "\n".join(f"        {os.path.basename(f)}" for f in files)
-        )
-    elif not files:
-        tty.die(f"No file for '{name}' was found in {path}")
-    return files[0]
+    subparser.add_argument("package", nargs="?", default=None, help="package name")
 
 
 def edit(parser, args):
-    names = args.package
+    name = args.package
+
+    # By default, edit package files
+    path = spack.paths.packages_path
 
     # If `--command`, `--test`, or `--module` is chosen, edit those instead
     if args.path:
-        paths = [locate_file(name, args.path) for name in names] if names else [args.path]
-        spack.util.editor.editor(*paths)
-    elif names:
-        if args.repo:
-            repo = spack.repo.from_path(args.repo)
-        elif args.namespace:
-            repo = spack.repo.PATH.get_repo(args.namespace)
-        else:
-            repo = spack.repo.PATH
-        paths = [locate_package(name, repo) for name in names]
-        spack.util.editor.editor(*paths)
+        path = args.path
+        if name:
+            # convert command names to python module name
+            if path == spack.paths.command_path:
+                name = spack.cmd.python_name(name)
+
+            path = os.path.join(path, name)
+            if not os.path.exists(path):
+                files = glob.glob(path + "*")
+                exclude_list = [".pyc", "~"]  # exclude binaries and backups
+                files = list(filter(lambda x: all(s not in x for s in exclude_list), files))
+                if len(files) > 1:
+                    m = "Multiple files exist with the name {0}.".format(name)
+                    m += " Please specify a suffix. Files are:\n\n"
+                    for f in files:
+                        m += "        " + os.path.basename(f) + "\n"
+                    tty.die(m)
+                if not files:
+                    tty.die("No file for '{0}' was found in {1}".format(name, path))
+                path = files[0]  # already confirmed only one entry in files
+
+        editor(path)
+    elif name:
+        edit_package(name, args.repo, args.namespace)
     else:
         # By default open the directory where packages live
-        spack.util.editor.editor(spack.paths.packages_path)
+        editor(path)

lib/spack/spack/cmd/env.py

@@ -468,32 +468,30 @@ def env_remove(args):
     This removes an environment managed by Spack. Directory environments
     and manifests embedded in repositories should be removed manually.
     """
-    read_envs = []
+    remove_envs = []
     valid_envs = []
     bad_envs = []
-    invalid_envs = []
 
     for env_name in ev.all_environment_names():
         try:
             env = ev.read(env_name)
-            valid_envs.append(env_name)
+            valid_envs.append(env)
 
             if env_name in args.rm_env:
-                read_envs.append(env)
+                remove_envs.append(env)
         except (spack.config.ConfigFormatError, ev.SpackEnvironmentConfigError):
-            invalid_envs.append(env_name)
-
             if env_name in args.rm_env:
                 bad_envs.append(env_name)
 
-        # Check if env is linked to another before trying to remove
-        for name in valid_envs:
+    # Check if remove_env is included from another env before trying to remove
+    for env in valid_envs:
+        for remove_env in remove_envs:
             # don't check if environment is included to itself
-            if name == env_name:
+            if env.name == remove_env.name:
                 continue
-            environ = ev.Environment(ev.root(name))
-            if ev.root(env_name) in environ.included_concrete_envs:
-                msg = f'Environment "{env_name}" is being used by environment "{name}"'
+
+            if remove_env.path in env.included_concrete_envs:
+                msg = f'Environment "{remove_env.name}" is being used by environment "{env.name}"'
                 if args.force:
                     tty.warn(msg)
                 else:
@@ -506,7 +504,7 @@ def env_remove(args):
         if not answer:
             tty.die("Will not remove any environments")
 
-    for env in read_envs:
+    for env in remove_envs:
         name = env.name
         if env.active:
             tty.die(f"Environment {name} can't be removed while activated.")

lib/spack/spack/cmd/external.py

@@ -7,7 +7,7 @@
 import os
 import re
 import sys
-from typing import List, Optional, Set
+from typing import List, Optional
 
 import llnl.util.tty as tty
 import llnl.util.tty.colify as colify
@@ -19,7 +19,6 @@
 import spack.detection
 import spack.error
 import spack.repo
-import spack.spec
 import spack.util.environment
 from spack.cmd.common import arguments
 
@@ -139,26 +138,14 @@ def external_find(args):
         candidate_packages, path_hints=args.path, max_workers=args.jobs
     )
 
-    new_specs = spack.detection.update_configuration(
+    new_entries = spack.detection.update_configuration(
         detected_packages, scope=args.scope, buildable=not args.not_buildable
     )
-
-    # If the user runs `spack external find --not-buildable mpich` we also mark `mpi` non-buildable
-    # to avoid that the concretizer picks a different mpi provider.
-    if new_specs and args.not_buildable:
-        virtuals: Set[str] = {
-            virtual.name
-            for new_spec in new_specs
-            for virtual_specs in spack.repo.PATH.get_pkg_class(new_spec.name).provided.values()
-            for virtual in virtual_specs
-        }
-        new_virtuals = spack.detection.set_virtuals_nonbuildable(virtuals, scope=args.scope)
-        new_specs.extend(spack.spec.Spec(name) for name in new_virtuals)
-
-    if new_specs:
+    if new_entries:
         path = spack.config.CONFIG.get_config_filename(args.scope, "packages")
-        tty.msg(f"The following specs have been detected on this system and added to {path}")
-        spack.cmd.display_specs(new_specs)
+        msg = "The following specs have been detected on this system and added to {0}"
+        tty.msg(msg.format(path))
+        spack.cmd.display_specs(new_entries)
     else:
         tty.msg("No new external packages detected")
 

lib/spack/spack/cmd/find.py

@@ -46,10 +46,6 @@ def setup_parser(subparser):
         help="output specs as machine-readable json records",
     )
 
-    subparser.add_argument(
-        "-I", "--install-status", action="store_true", help="show install status of packages"
-    )
-
     subparser.add_argument(
         "-d", "--deps", action="store_true", help="output dependencies along with found specs"
     )
@@ -297,24 +293,25 @@ def root_decorator(spec, string):
         )
         print()
 
+    if args.show_concretized:
+        tty.msg("Concretized roots")
+        cmd.display_specs(env.specs_by_hash.values(), args, decorator=decorator)
+        print()
+
+    # Display a header for the installed packages section IF there are installed
+    # packages. If there aren't any, we'll just end up printing "0 installed packages"
+    # later.
+    if results and not args.only_roots:
+        tty.msg("Installed packages")
+
 
 def find(parser, args):
-    env = ev.active_environment()
+    q_args = query_arguments(args)
+    results = args.specs(**q_args)
 
+    env = ev.active_environment()
     if not env and args.only_roots:
         tty.die("-r / --only-roots requires an active environment")
-    if not env and args.show_concretized:
-        tty.die("-c / --show-concretized requires an active environment")
-
-    if env:
-        if args.constraint:
-            init_specs = spack.cmd.parse_specs(args.constraint)
-            results = env.all_matching_specs(*init_specs)
-        else:
-            results = env.all_specs()
-    else:
-        q_args = query_arguments(args)
-        results = args.specs(**q_args)
 
     decorator = make_env_decorator(env) if env else lambda s, f: f
 
@@ -335,11 +332,6 @@ def find(parser, args):
     if args.loaded:
         results = spack.cmd.filter_loaded_specs(results)
 
-    if args.install_status or args.show_concretized:
-        status_fn = spack.spec.Spec.install_status
-    else:
-        status_fn = None
-
     # Display the result
     if args.json:
         cmd.display_specs_as_json(results, deps=args.deps)
@@ -348,34 +340,12 @@ def find(parser, args):
             if env:
                 display_env(env, args, decorator, results)
 
+        count_suffix = " (not shown)"
         if not args.only_roots:
-            display_results = results
-            if not args.show_concretized:
-                display_results = list(x for x in results if x.installed)
-            cmd.display_specs(
-                display_results, args, decorator=decorator, all_headers=True, status_fn=status_fn
-            )
+            cmd.display_specs(results, args, decorator=decorator, all_headers=True)
+            count_suffix = ""
 
         # print number of installed packages last (as the list may be long)
         if sys.stdout.isatty() and args.groups:
-            installed_suffix = ""
-            concretized_suffix = " to be installed"
-
-            if args.only_roots:
-                installed_suffix += " (not shown)"
-                concretized_suffix += " (not shown)"
-            else:
-                if env and not args.show_concretized:
-                    concretized_suffix += " (show with `spack find -c`)"
-
             pkg_type = "loaded" if args.loaded else "installed"
-            spack.cmd.print_how_many_pkgs(
-                list(x for x in results if x.installed), pkg_type, suffix=installed_suffix
-            )
-
-            if env:
-                spack.cmd.print_how_many_pkgs(
-                    list(x for x in results if not x.installed),
-                    "concretized",
-                    suffix=concretized_suffix,
-                )
+            spack.cmd.print_how_many_pkgs(results, pkg_type, suffix=count_suffix)

lib/spack/spack/cmd/gc.py

@@ -56,6 +56,7 @@ def roots_from_environments(args, active_env):
 
     # -e says "also preserve things needed by this particular env"
     for env_name_or_dir in args.except_environment:
+        print("HMM", env_name_or_dir)
         if ev.exists(env_name_or_dir):
             env = ev.read(env_name_or_dir)
         elif ev.is_env_dir(env_name_or_dir):

lib/spack/spack/cmd/help.py

@@ -50,7 +50,7 @@
       @B{++}, @r{--}, @r{~~}, @B{==}                propagate variants to package dependencies
 
     architecture variants:
-      @m{platform=platform}             linux, darwin, freebsd, windows
+      @m{platform=platform}             linux, darwin, cray, etc.
       @m{os=operating_system}           specific <operating_system>
       @m{target=target}                 specific <target> processor
       @m{arch=platform-os-target}       shortcut for all three above

lib/spack/spack/cmd/install.py

@@ -10,7 +10,6 @@
 from typing import List
 
 import llnl.util.filesystem as fs
-from llnl.string import plural
 from llnl.util import lang, tty
 
 import spack.build_environment
@@ -62,6 +61,7 @@ def install_kwargs_from_args(args):
         "dependencies_use_cache": cache_opt(args.use_cache, dep_use_bc),
         "dependencies_cache_only": cache_opt(args.cache_only, dep_use_bc),
         "include_build_deps": args.include_build_deps,
+        "explicit": True,  # Use true as a default for install command
         "stop_at": args.until,
         "unsigned": args.unsigned,
         "install_deps": ("dependencies" in args.things_to_install),
@@ -376,9 +376,7 @@ def _maybe_add_and_concretize(args, env, specs):
         # `spack concretize`
         tests = compute_tests_install_kwargs(env.user_specs, args.test)
         concretized_specs = env.concretize(tests=tests)
-        if concretized_specs:
-            tty.msg(f"Concretized {plural(len(concretized_specs), 'spec')}")
-            ev.display_specs([concrete for _, concrete in concretized_specs])
+        ev.display_specs(concretized_specs)
 
         # save view regeneration for later, so that we only do it
         # once, as it can be slow.
@@ -475,7 +473,6 @@ def install_without_active_env(args, install_kwargs, reporter_factory):
             require_user_confirmation_for_overwrite(concrete_specs, args)
             install_kwargs["overwrite"] = [spec.dag_hash() for spec in concrete_specs]
 
-        installs = [s.package for s in concrete_specs]
-        install_kwargs["explicit"] = [s.dag_hash() for s in concrete_specs]
-        builder = PackageInstaller(installs, install_kwargs)
+        installs = [(s.package, install_kwargs) for s in concrete_specs]
+        builder = PackageInstaller(installs)
         builder.install()

lib/spack/spack/cmd/repo.py

@@ -91,7 +91,7 @@ def repo_add(args):
         tty.die("Not a Spack repository: %s" % path)
 
     # Make sure it's actually a spack repository by constructing it.
-    repo = spack.repo.from_path(canon_path)
+    repo = spack.repo.Repo(canon_path)
 
     # If that succeeds, finally add it to the configuration.
     repos = spack.config.get("repos", scope=args.scope)
@@ -124,7 +124,7 @@ def repo_remove(args):
     # If it is a namespace, remove corresponding repo
     for path in repos:
         try:
-            repo = spack.repo.from_path(path)
+            repo = spack.repo.Repo(path)
             if repo.namespace == namespace_or_path:
                 repos.remove(path)
                 spack.config.set("repos", repos, args.scope)
@@ -142,7 +142,7 @@ def repo_list(args):
     repos = []
     for r in roots:
         try:
-            repos.append(spack.repo.from_path(r))
+            repos.append(spack.repo.Repo(r))
         except spack.repo.RepoError:
             continue
 

lib/spack/spack/cmd/solve.py

@@ -114,16 +114,15 @@ def _process_result(result, show, required_format, kwargs):
 
     # dump the solutions as concretized specs
     if "solutions" in show:
-        if required_format:
-            for spec in result.specs:
-                # With -y, just print YAML to output.
-                if required_format == "yaml":
-                    # use write because to_yaml already has a newline.
-                    sys.stdout.write(spec.to_yaml(hash=ht.dag_hash))
-                elif required_format == "json":
-                    sys.stdout.write(spec.to_json(hash=ht.dag_hash))
-        else:
-            sys.stdout.write(spack.spec.tree(result.specs, color=sys.stdout.isatty(), **kwargs))
+        for spec in result.specs:
+            # With -y, just print YAML to output.
+            if required_format == "yaml":
+                # use write because to_yaml already has a newline.
+                sys.stdout.write(spec.to_yaml(hash=ht.dag_hash))
+            elif required_format == "json":
+                sys.stdout.write(spec.to_json(hash=ht.dag_hash))
+            else:
+                sys.stdout.write(spec.tree(color=sys.stdout.isatty(), **kwargs))
         print()
 
     if result.unsolved_specs and "solutions" in show:

lib/spack/spack/cmd/spec.py

@@ -105,19 +105,11 @@ def spec(parser, args):
         if env:
             env.concretize()
             specs = env.concretized_specs()
-
-            # environments are printed together in a combined tree() invocation,
-            # except when using --yaml or --json, which we print spec by spec below.
-            if not args.format:
-                tree_kwargs["key"] = spack.traverse.by_dag_hash
-                tree_kwargs["hashes"] = args.long or args.very_long
-                print(spack.spec.tree([concrete for _, concrete in specs], **tree_kwargs))
-                return
         else:
             tty.die("spack spec requires at least one spec or an active environment")
 
     for input, output in specs:
-        # With --yaml or --json, just print the raw specs to output
+        # With -y, just print YAML to output.
         if args.format:
             if args.format == "yaml":
                 # use write because to_yaml already has a newline.

lib/spack/spack/cmd/uninstall.py

@@ -151,8 +151,7 @@ def is_installed(spec):
         key=lambda s: s.dag_hash(),
     )
 
-    with spack.store.STORE.db.read_transaction():
-        return [spec for spec in specs if is_installed(spec)]
+    return [spec for spec in specs if is_installed(spec)]
 
 
 def dependent_environments(
@@ -240,8 +239,6 @@ def get_uninstall_list(args, specs: List[spack.spec.Spec], env: Optional[ev.Envi
             print()
             tty.info("The following environments still reference these specs:")
             colify([e.name for e in other_dependent_envs.keys()], indent=4)
-            if env:
-                msgs.append("use `spack remove` to remove the spec from the current environment")
             msgs.append("use `spack env remove` to remove environments")
         msgs.append("use `spack uninstall --force` to override")
         print()

lib/spack/spack/cmd/unload.py

@@ -71,7 +71,7 @@ def unload(parser, args):
             "Cannot specify specs on command line when unloading all specs with '--all'"
         )
 
-    hashes = os.environ.get(uenv.spack_loaded_hashes_var, "").split(os.pathsep)
+    hashes = os.environ.get(uenv.spack_loaded_hashes_var, "").split(":")
     if args.specs:
         specs = [
             spack.cmd.disambiguate_spec_from_hashes(spec, hashes)

lib/spack/spack/compiler.py

@@ -18,6 +18,7 @@
 import llnl.util.tty as tty
 from llnl.util.filesystem import path_contains_subdirectory, paths_containing_libs
 
+import spack.compilers
 import spack.error
 import spack.schema.environment
 import spack.spec
@@ -694,6 +695,10 @@ def compiler_environment(self):
         try:
             # load modules and set env variables
             for module in self.modules:
+                # On cray, mic-knl module cannot be loaded without cce module
+                # See: https://github.com/spack/spack/issues/3153
+                if os.environ.get("CRAY_CPU_TARGET") == "mic-knl":
+                    spack.util.module_cmd.load_module("cce")
                 spack.util.module_cmd.load_module(module)
 
             # apply other compiler environment changes

lib/spack/spack/compilers/__init__.py

@@ -260,7 +260,7 @@ def _init_compiler_config(
 def compiler_config_files():
     config_files = list()
     config = spack.config.CONFIG
-    for scope in config.writable_scopes:
+    for scope in config.file_scopes:
         name = scope.name
         compiler_config = config.get("compilers", scope=name)
         if compiler_config:
@@ -488,7 +488,7 @@ def supported_compilers_for_host_platform() -> List[str]:
     return supported_compilers_for_platform(host_plat)
 
 
-def supported_compilers_for_platform(platform: "spack.platforms.Platform") -> List[str]:
+def supported_compilers_for_platform(platform: spack.platforms.Platform) -> List[str]:
     """Return a set of compiler class objects supported by Spack
     that are also supported by the provided platform
 

lib/spack/spack/compilers/clang.py

@@ -96,8 +96,6 @@ def verbose_flag(self):
 
     openmp_flag = "-fopenmp"
 
-    # C++ flags based on CMake Modules/Compiler/Clang.cmake
-
     @property
     def cxx11_flag(self):
         if self.real_version < Version("3.3"):
@@ -122,24 +120,6 @@ def cxx17_flag(self):
 
         return "-std=c++17"
 
-    @property
-    def cxx20_flag(self):
-        if self.real_version < Version("5.0"):
-            raise UnsupportedCompilerFlag(self, "the C++20 standard", "cxx20_flag", "< 5.0")
-        elif self.real_version < Version("11.0"):
-            return "-std=c++2a"
-        else:
-            return "-std=c++20"
-
-    @property
-    def cxx23_flag(self):
-        if self.real_version < Version("12.0"):
-            raise UnsupportedCompilerFlag(self, "the C++23 standard", "cxx23_flag", "< 12.0")
-        elif self.real_version < Version("17.0"):
-            return "-std=c++2b"
-        else:
-            return "-std=c++23"
-
     @property
     def c99_flag(self):
         return "-std=c99"
@@ -162,10 +142,7 @@ def c17_flag(self):
     def c23_flag(self):
         if self.real_version < Version("9.0"):
             raise UnsupportedCompilerFlag(self, "the C23 standard", "c23_flag", "< 9.0")
-        elif self.real_version < Version("18.0"):
-            return "-std=c2x"
-        else:
-            return "-std=c23"
+        return "-std=c2x"
 
     @property
     def cc_pic_flag(self):

lib/spack/spack/compilers/oneapi.py

@@ -4,7 +4,7 @@
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 import os
-from os.path import dirname, join
+from os.path import dirname
 
 from llnl.util import tty
 
@@ -135,12 +135,8 @@ def setup_custom_environment(self, pkg, env):
         # It is located in the same directory as the driver. Error message:
         #   clang++: error: unable to execute command:
         #   Executable "sycl-post-link" doesn't exist!
-        # also ensures that shared objects and libraries required by the compiler,
-        # e.g. libonnx, can be found succesfully
-        # due to a fix, this is no longer required for OneAPI versions >= 2024.2
-        if self.cxx and pkg.spec.satisfies("%oneapi@:2024.1"):
+        if self.cxx:
             env.prepend_path("PATH", dirname(self.cxx))
-            env.prepend_path("LD_LIBRARY_PATH", join(dirname(dirname(self.cxx)), "lib"))
 
         # 2024 release bumped the libsycl version because of an ABI
         # change, 2024 compilers are required.  You will see this

lib/spack/spack/config.py

@@ -35,10 +35,11 @@
 import os
 import re
 import sys
-from typing import Any, Callable, Dict, Generator, List, Optional, Tuple, Union
+from typing import Any, Callable, Dict, Generator, List, Optional, Tuple, Type, Union
 
 from llnl.util import filesystem, lang, tty
 
+import spack.compilers
 import spack.paths
 import spack.platforms
 import spack.schema
@@ -116,39 +117,21 @@
 
 
 class ConfigScope:
-    def __init__(self, name: str) -> None:
-        self.name = name
-        self.writable = False
-        self.sections = syaml.syaml_dict()
+    """This class represents a configuration scope.
 
-    def get_section_filename(self, section: str) -> str:
-        raise NotImplementedError
+    A scope is one directory containing named configuration files.
+    Each file is a config "section" (e.g., mirrors, compilers, etc.).
+    """
 
-    def get_section(self, section: str) -> Optional[YamlConfigDict]:
-        raise NotImplementedError
-
-    def _write_section(self, section: str) -> None:
-        raise NotImplementedError
+    def __init__(self, name, path) -> None:
+        self.name = name  # scope name.
+        self.path = path  # path to directory containing configs.
+        self.sections = syaml.syaml_dict()  # sections read from config files.
 
     @property
     def is_platform_dependent(self) -> bool:
-        return False
-
-    def clear(self) -> None:
-        """Empty cached config information."""
-        self.sections = syaml.syaml_dict()
-
-    def __repr__(self) -> str:
-        return f"<ConfigScope: {self.name}>"
-
-
-class DirectoryConfigScope(ConfigScope):
-    """Config scope backed by a directory containing one file per section."""
-
-    def __init__(self, name: str, path: str, *, writable: bool = True) -> None:
-        super().__init__(name)
-        self.path = path
-        self.writable = writable
+        """Returns true if the scope name is platform specific"""
+        return os.sep in self.name
 
     def get_section_filename(self, section: str) -> str:
         """Returns the filename associated with a given section"""
@@ -165,15 +148,14 @@ def get_section(self, section: str) -> Optional[YamlConfigDict]:
         return self.sections[section]
 
     def _write_section(self, section: str) -> None:
-        if not self.writable:
-            raise ConfigError(f"Cannot write to immutable scope {self}")
-
         filename = self.get_section_filename(section)
         data = self.get_section(section)
         if data is None:
             return
 
-        validate(data, SECTION_SCHEMAS[section])
+        # We copy data here to avoid adding defaults at write time
+        validate_data = copy.deepcopy(data)
+        validate(validate_data, SECTION_SCHEMAS[section])
 
         try:
             filesystem.mkdirp(self.path)
@@ -182,23 +164,19 @@ def _write_section(self, section: str) -> None:
         except (syaml.SpackYAMLError, OSError) as e:
             raise ConfigFileError(f"cannot write to '{filename}'") from e
 
-    @property
-    def is_platform_dependent(self) -> bool:
-        """Returns true if the scope name is platform specific"""
-        return "/" in self.name
+    def clear(self) -> None:
+        """Empty cached config information."""
+        self.sections = syaml.syaml_dict()
+
+    def __repr__(self) -> str:
+        return f"<ConfigScope: {self.name}: {self.path}>"
 
 
 class SingleFileScope(ConfigScope):
     """This class represents a configuration scope in a single YAML file."""
 
     def __init__(
-        self,
-        name: str,
-        path: str,
-        schema: YamlConfigDict,
-        *,
-        yaml_path: Optional[List[str]] = None,
-        writable: bool = True,
+        self, name: str, path: str, schema: YamlConfigDict, yaml_path: Optional[List[str]] = None
     ) -> None:
         """Similar to ``ConfigScope`` but can be embedded in another schema.
 
@@ -217,13 +195,15 @@ def __init__(
                        config:
                          install_tree: $spack/opt/spack
         """
-        super().__init__(name)
+        super().__init__(name, path)
         self._raw_data: Optional[YamlConfigDict] = None
         self.schema = schema
-        self.path = path
-        self.writable = writable
         self.yaml_path = yaml_path or []
 
+    @property
+    def is_platform_dependent(self) -> bool:
+        return False
+
     def get_section_filename(self, section) -> str:
         return self.path
 
@@ -277,8 +257,6 @@ def get_section(self, section: str) -> Optional[YamlConfigDict]:
         return self.sections.get(section, None)
 
     def _write_section(self, section: str) -> None:
-        if not self.writable:
-            raise ConfigError(f"Cannot write to immutable scope {self}")
         data_to_write: Optional[YamlConfigDict] = self._raw_data
 
         # If there is no existing data, this section SingleFileScope has never
@@ -323,6 +301,19 @@ def __repr__(self) -> str:
         return f"<SingleFileScope: {self.name}: {self.path}>"
 
 
+class ImmutableConfigScope(ConfigScope):
+    """A configuration scope that cannot be written to.
+
+    This is used for ConfigScopes passed on the command line.
+    """
+
+    def _write_section(self, section) -> None:
+        raise ConfigError(f"Cannot write to immutable scope {self}")
+
+    def __repr__(self) -> str:
+        return f"<ImmutableConfigScope: {self.name}: {self.path}>"
+
+
 class InternalConfigScope(ConfigScope):
     """An internal configuration scope that is not persisted to a file.
 
@@ -332,7 +323,7 @@ class InternalConfigScope(ConfigScope):
     """
 
     def __init__(self, name: str, data: Optional[YamlConfigDict] = None) -> None:
-        super().__init__(name)
+        super().__init__(name, None)
         self.sections = syaml.syaml_dict()
 
         if data is not None:
@@ -342,6 +333,9 @@ def __init__(self, name: str, data: Optional[YamlConfigDict] = None) -> None:
                 validate({section: dsec}, SECTION_SCHEMAS[section])
                 self.sections[section] = _mark_internal(syaml.syaml_dict({section: dsec}), name)
 
+    def get_section_filename(self, section: str) -> str:
+        raise NotImplementedError("Cannot get filename for InternalConfigScope.")
+
     def get_section(self, section: str) -> Optional[YamlConfigDict]:
         """Just reads from an internal dictionary."""
         if section not in self.sections:
@@ -446,21 +440,27 @@ def remove_scope(self, scope_name: str) -> Optional[ConfigScope]:
         return scope
 
     @property
-    def writable_scopes(self) -> Generator[ConfigScope, None, None]:
-        """Generator of writable scopes with an associated file."""
-        return (s for s in self.scopes.values() if s.writable)
+    def file_scopes(self) -> List[ConfigScope]:
+        """List of writable scopes with an associated file."""
+        return [
+            s
+            for s in self.scopes.values()
+            if (type(s) is ConfigScope or type(s) is SingleFileScope)
+        ]
 
     def highest_precedence_scope(self) -> ConfigScope:
-        """Writable scope with highest precedence."""
-        return next(s for s in reversed(self.scopes.values()) if s.writable)  # type: ignore
+        """Non-internal scope with highest precedence."""
+        return next(reversed(self.file_scopes))
 
     def highest_precedence_non_platform_scope(self) -> ConfigScope:
-        """Writable non-platform scope with highest precedence"""
-        return next(
-            s
-            for s in reversed(self.scopes.values())  # type: ignore
-            if s.writable and not s.is_platform_dependent
-        )
+        """Non-internal non-platform scope with highest precedence
+
+        Platform-specific scopes are of the form scope/platform"""
+        generator = reversed(self.file_scopes)
+        highest = next(generator)
+        while highest and highest.is_platform_dependent:
+            highest = next(generator)
+        return highest
 
     def matching_scopes(self, reg_expr) -> List[ConfigScope]:
         """
@@ -755,14 +755,13 @@ def override(
 
 
 def _add_platform_scope(
-    cfg: Union[Configuration, lang.Singleton], name: str, path: str, writable: bool = True
+    cfg: Union[Configuration, lang.Singleton], scope_type: Type[ConfigScope], name: str, path: str
 ) -> None:
     """Add a platform-specific subdirectory for the current platform."""
     platform = spack.platforms.host().name
-    scope = DirectoryConfigScope(
-        f"{name}/{platform}", os.path.join(path, platform), writable=writable
-    )
-    cfg.push_scope(scope)
+    plat_name = os.path.join(name, platform)
+    plat_path = os.path.join(path, platform)
+    cfg.push_scope(scope_type(plat_name, plat_path))
 
 
 def config_paths_from_entry_points() -> List[Tuple[str, str]]:
@@ -793,27 +792,22 @@ def config_paths_from_entry_points() -> List[Tuple[str, str]]:
 def _add_command_line_scopes(
     cfg: Union[Configuration, lang.Singleton], command_line_scopes: List[str]
 ) -> None:
-    """Add additional scopes from the --config-scope argument, either envs or dirs."""
-    import spack.environment.environment as env  # circular import
+    """Add additional scopes from the --config-scope argument.
 
+    Command line scopes are named after their position in the arg list.
+    """
     for i, path in enumerate(command_line_scopes):
-        name = f"cmd_scope_{i}"
+        # We ensure that these scopes exist and are readable, as they are
+        # provided on the command line by the user.
+        if not os.path.isdir(path):
+            raise ConfigError(f"config scope is not a directory: '{path}'")
+        elif not os.access(path, os.R_OK):
+            raise ConfigError(f"config scope is not readable: '{path}'")
 
-        if env.exists(path):  # managed environment
-            manifest = env.EnvironmentManifestFile(env.root(path))
-        elif env.is_env_dir(path):  # anonymous environment
-            manifest = env.EnvironmentManifestFile(path)
-        elif os.path.isdir(path):  # directory with config files
-            cfg.push_scope(DirectoryConfigScope(name, path, writable=False))
-            _add_platform_scope(cfg, name, path, writable=False)
-            continue
-        else:
-            raise ConfigError(f"Invalid configuration scope: {path}")
-
-        for scope in manifest.env_config_scopes:
-            scope.name = f"{name}:{scope.name}"
-            scope.writable = False
-            cfg.push_scope(scope)
+        # name based on order on the command line
+        name = f"cmd_scope_{i:d}"
+        cfg.push_scope(ImmutableConfigScope(name, path))
+        _add_platform_scope(cfg, ImmutableConfigScope, name, path)
 
 
 def create() -> Configuration:
@@ -857,10 +851,10 @@ def create() -> Configuration:
 
     # add each scope and its platform-specific directory
     for name, path in configuration_paths:
-        cfg.push_scope(DirectoryConfigScope(name, path))
+        cfg.push_scope(ConfigScope(name, path))
 
         # Each scope can have per-platfom overrides in subdirectories
-        _add_platform_scope(cfg, name, path)
+        _add_platform_scope(cfg, ConfigScope, name, path)
 
     # add command-line scopes
     _add_command_line_scopes(cfg, COMMAND_LINE_SCOPES)
@@ -975,7 +969,7 @@ def set(path: str, value: Any, scope: Optional[str] = None) -> None:
 def add_default_platform_scope(platform: str) -> None:
     plat_name = os.path.join("defaults", platform)
     plat_path = os.path.join(CONFIGURATION_DEFAULTS_PATH[1], platform)
-    CONFIG.push_scope(DirectoryConfigScope(plat_name, plat_path))
+    CONFIG.push_scope(ConfigScope(plat_name, plat_path))
 
 
 def scopes() -> Dict[str, ConfigScope]:
@@ -984,10 +978,19 @@ def scopes() -> Dict[str, ConfigScope]:
 
 
 def writable_scopes() -> List[ConfigScope]:
-    """Return list of writable scopes. Higher-priority scopes come first in the list."""
-    scopes = [x for x in CONFIG.scopes.values() if x.writable]
-    scopes.reverse()
-    return scopes
+    """
+    Return list of writable scopes. Higher-priority scopes come first in the
+    list.
+    """
+    return list(
+        reversed(
+            list(
+                x
+                for x in CONFIG.scopes.values()
+                if not isinstance(x, (InternalConfigScope, ImmutableConfigScope))
+            )
+        )
+    )
 
 
 def writable_scope_names() -> List[str]:
@@ -1077,8 +1080,11 @@ def validate(
     """
     import jsonschema
 
+    # Validate a copy to avoid adding defaults
+    # This allows us to round-trip data without adding to it.
+    test_data = syaml.deepcopy(data)
     try:
-        spack.schema.Validator(schema).validate(data)
+        spack.schema.Validator(schema).validate(test_data)
     except jsonschema.ValidationError as e:
         if hasattr(e.instance, "lc"):
             line_number = e.instance.lc.line + 1
@@ -1087,7 +1093,7 @@ def validate(
         raise ConfigFormatError(e, data, filename, line_number) from e
     # return the validated data so that we can access the raw data
     # mostly relevant for environments
-    return data
+    return test_data
 
 
 def read_config_file(
@@ -1593,7 +1599,7 @@ def _config_from(scopes_or_paths: List[Union[ConfigScope, str]]) -> Configuratio
         path = os.path.normpath(scope_or_path)
         assert os.path.isdir(path), f'"{path}" must be a directory'
         name = os.path.basename(path)
-        scopes.append(DirectoryConfigScope(name, path))
+        scopes.append(ConfigScope(name, path))
 
     configuration = Configuration(*scopes)
     return configuration

lib/spack/spack/container/images.json

@@ -78,17 +78,24 @@
         "image": "quay.io/almalinuxorg/almalinux:8"
       }
     },
-    "centos:stream9": {
+    "centos:stream": {
       "bootstrap": {
-        "template": "container/centos_stream9.dockerfile",
-        "image": "quay.io/centos/centos:stream9"
+        "template": "container/centos_stream.dockerfile",
+        "image": "quay.io/centos/centos:stream"
       },
       "os_package_manager": "dnf_epel",
-      "build": "spack/centos-stream9",
+      "build": "spack/centos-stream",
       "final": {
-        "image": "quay.io/centos/centos:stream9"
+        "image": "quay.io/centos/centos:stream"
       }
     },
+    "centos:7": {
+      "bootstrap": {
+        "template": "container/centos_7.dockerfile"
+      },
+      "os_package_manager": "yum",
+      "build": "spack/centos7"
+    },
     "opensuse/leap:15": {
       "bootstrap": {
         "template": "container/leap-15.dockerfile"

lib/spack/spack/detection/__init__.py

@@ -2,12 +2,7 @@
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
-from .common import (
-    DetectedPackage,
-    executable_prefix,
-    set_virtuals_nonbuildable,
-    update_configuration,
-)
+from .common import DetectedPackage, executable_prefix, update_configuration
 from .path import by_path, executables_in_path
 from .test import detection_tests
 
@@ -17,6 +12,5 @@
     "executables_in_path",
     "executable_prefix",
     "update_configuration",
-    "set_virtuals_nonbuildable",
     "detection_tests",
 ]

lib/spack/spack/detection/common.py

@@ -252,27 +252,6 @@ def update_configuration(
     return all_new_specs
 
 
-def set_virtuals_nonbuildable(virtuals: Set[str], scope: Optional[str] = None) -> List[str]:
-    """Update packages:virtual:buildable:False for the provided virtual packages, if the property
-    is not set by the user. Returns the list of virtual packages that have been updated."""
-    packages = spack.config.get("packages")
-    new_config = {}
-    for virtual in virtuals:
-        # If the user has set the buildable prop do not override it
-        if virtual in packages and "buildable" in packages[virtual]:
-            continue
-        new_config[virtual] = {"buildable": False}
-
-    # Update the provided scope
-    spack.config.set(
-        "packages",
-        spack.config.merge_yaml(spack.config.get("packages", scope=scope), new_config),
-        scope=scope,
-    )
-
-    return list(new_config.keys())
-
-
 def _windows_drive() -> str:
     """Return Windows drive string extracted from the PROGRAMFILES environment variable,
     which is guaranteed to be defined for all logins.

lib/spack/spack/detection/path.py

@@ -12,7 +12,7 @@
 import re
 import sys
 import warnings
-from typing import Dict, List, Optional, Set, Tuple, Type
+from typing import Dict, List, Optional, Set, Tuple
 
 import llnl.util.filesystem
 import llnl.util.lang
@@ -200,7 +200,7 @@ class Finder:
     def default_path_hints(self) -> List[str]:
         return []
 
-    def search_patterns(self, *, pkg: Type["spack.package_base.PackageBase"]) -> List[str]:
+    def search_patterns(self, *, pkg: "spack.package_base.PackageBase") -> List[str]:
         """Returns the list of patterns used to match candidate files.
 
         Args:
@@ -226,7 +226,7 @@ def prefix_from_path(self, *, path: str) -> str:
         raise NotImplementedError("must be implemented by derived classes")
 
     def detect_specs(
-        self, *, pkg: Type["spack.package_base.PackageBase"], paths: List[str]
+        self, *, pkg: "spack.package_base.PackageBase", paths: List[str]
     ) -> List[DetectedPackage]:
         """Given a list of files matching the search patterns, returns a list of detected specs.
 
@@ -327,7 +327,7 @@ class ExecutablesFinder(Finder):
     def default_path_hints(self) -> List[str]:
         return spack.util.environment.get_path("PATH")
 
-    def search_patterns(self, *, pkg: Type["spack.package_base.PackageBase"]) -> List[str]:
+    def search_patterns(self, *, pkg: "spack.package_base.PackageBase") -> List[str]:
         result = []
         if hasattr(pkg, "executables") and hasattr(pkg, "platform_executables"):
             result = pkg.platform_executables()
@@ -356,7 +356,7 @@ class LibrariesFinder(Finder):
     DYLD_LIBRARY_PATH, DYLD_FALLBACK_LIBRARY_PATH, and standard system library paths
     """
 
-    def search_patterns(self, *, pkg: Type["spack.package_base.PackageBase"]) -> List[str]:
+    def search_patterns(self, *, pkg: "spack.package_base.PackageBase") -> List[str]:
         result = []
         if hasattr(pkg, "libraries"):
             result = pkg.libraries

lib/spack/spack/directives.py

@@ -90,7 +90,7 @@ class OpenMpi(Package):
 _patch_order_index = 0
 
 
-SpecType = str
+SpecType = Union["spack.spec.Spec", str]
 DepType = Union[Tuple[str, ...], str]
 WhenType = Optional[Union["spack.spec.Spec", str, bool]]
 Patcher = Callable[[Union["spack.package_base.PackageBase", Dependency]], None]
@@ -475,7 +475,7 @@ def _execute_version(pkg, ver, **kwargs):
 
 def _depends_on(
     pkg: "spack.package_base.PackageBase",
-    spec: "spack.spec.Spec",
+    spec: SpecType,
     *,
     when: WhenType = None,
     type: DepType = dt.DEFAULT_TYPES,
@@ -485,10 +485,11 @@ def _depends_on(
     if not when_spec:
         return
 
-    if not spec.name:
-        raise DependencyError(f"Invalid dependency specification in package '{pkg.name}':", spec)
-    if pkg.name == spec.name:
-        raise CircularReferenceError(f"Package '{pkg.name}' cannot depend on itself.")
+    dep_spec = spack.spec.Spec(spec)
+    if not dep_spec.name:
+        raise DependencyError("Invalid dependency specification in package '%s':" % pkg.name, spec)
+    if pkg.name == dep_spec.name:
+        raise CircularReferenceError("Package '%s' cannot depend on itself." % pkg.name)
 
     depflag = dt.canonicalize(type)
 
@@ -504,7 +505,7 @@ def _depends_on(
     # ensure `Spec.virtual` is a valid thing to call in a directive.
     # For now, we comment out the following check to allow for virtual packages
     # with package files.
-    # if patches and spec.virtual:
+    # if patches and dep_spec.virtual:
     #     raise DependencyPatchError("Cannot patch a virtual dependency.")
 
     # ensure patches is a list
@@ -519,13 +520,13 @@ def _depends_on(
 
     # this is where we actually add the dependency to this package
     deps_by_name = pkg.dependencies.setdefault(when_spec, {})
-    dependency = deps_by_name.get(spec.name)
+    dependency = deps_by_name.get(dep_spec.name)
 
     if not dependency:
-        dependency = Dependency(pkg, spec, depflag=depflag)
-        deps_by_name[spec.name] = dependency
+        dependency = Dependency(pkg, dep_spec, depflag=depflag)
+        deps_by_name[dep_spec.name] = dependency
     else:
-        dependency.spec.constrain(spec, deps=False)
+        dependency.spec.constrain(dep_spec, deps=False)
         dependency.depflag |= depflag
 
     # apply patches to the dependency
@@ -590,13 +591,12 @@ def depends_on(
     @see The section "Dependency specs" in the Spack Packaging Guide.
 
     """
-    dep_spec = spack.spec.Spec(spec)
-    if dep_spec.name in SUPPORTED_LANGUAGES:
+    if spack.spec.Spec(spec).name in SUPPORTED_LANGUAGES:
         assert type == "build", "languages must be of 'build' type"
         return _language(lang_spec_str=spec, when=when)
 
     def _execute_depends_on(pkg: "spack.package_base.PackageBase"):
-        _depends_on(pkg, dep_spec, when=when, type=type, patches=patches)
+        _depends_on(pkg, spec, when=when, type=type, patches=patches)
 
     return _execute_depends_on
 
@@ -666,24 +666,25 @@ def extends(spec, when=None, type=("build", "run"), patches=None):
 
     keyword arguments can be passed to extends() so that extension
     packages can pass parameters to the extendee's extension
-    mechanism."""
+    mechanism.
+
+    """
 
     def _execute_extends(pkg):
         when_spec = _make_when_spec(when)
         if not when_spec:
             return
 
-        dep_spec = spack.spec.Spec(spec)
-
-        _depends_on(pkg, dep_spec, when=when, type=type, patches=patches)
+        _depends_on(pkg, spec, when=when, type=type, patches=patches)
+        spec_obj = spack.spec.Spec(spec)
 
         # When extending python, also add a dependency on python-venv. This is done so that
         # Spack environment views are Python virtual environments.
-        if dep_spec.name == "python" and not pkg.name == "python-venv":
-            _depends_on(pkg, spack.spec.Spec("python-venv"), when=when, type=("build", "run"))
+        if spec_obj.name == "python" and not pkg.name == "python-venv":
+            _depends_on(pkg, "python-venv", when=when, type=("build", "run"))
 
         # TODO: the values of the extendees dictionary are not used. Remove in next refactor.
-        pkg.extendees[dep_spec.name] = (dep_spec, None)
+        pkg.extendees[spec_obj.name] = (spec_obj, None)
 
     return _execute_extends
 

lib/spack/spack/environment/environment.py

@@ -5,6 +5,7 @@
 import collections
 import collections.abc
 import contextlib
+import copy
 import os
 import pathlib
 import re
@@ -23,8 +24,6 @@
 from llnl.util.link_tree import ConflictingSpecsError
 from llnl.util.symlink import readlink, symlink
 
-import spack.caches
-import spack.cmd
 import spack.compilers
 import spack.concretize
 import spack.config
@@ -268,7 +267,9 @@ def root(name):
 
 def exists(name):
     """Whether an environment with this name exists or not."""
-    return valid_env_name(name) and os.path.isdir(_root(name))
+    if not valid_env_name(name):
+        return False
+    return os.path.isdir(root(name))
 
 
 def active(name):
@@ -527,8 +528,8 @@ def _read_yaml(str_or_file):
         )
 
     filename = getattr(str_or_file, "name", None)
-    spack.config.validate(data, spack.schema.env.schema, filename)
-    return data
+    default_data = spack.config.validate(data, spack.schema.env.schema, filename)
+    return data, default_data
 
 
 def _write_yaml(data, str_or_file):
@@ -919,7 +920,7 @@ def __init__(self, manifest_dir: Union[str, pathlib.Path]) -> None:
     def _load_manifest_file(self):
         """Instantiate and load the manifest file contents into memory."""
         with lk.ReadTransaction(self.txlock):
-            self.manifest = EnvironmentManifestFile(self.path, self.name)
+            self.manifest = EnvironmentManifestFile(self.path)
             with self.manifest.use_config():
                 self._read()
 
@@ -956,25 +957,18 @@ def write_transaction(self):
         """Get a write lock context manager for use in a `with` block."""
         return lk.WriteTransaction(self.txlock, acquire=self._re_read)
 
-    def _process_definition(self, entry):
+    def _process_definition(self, item):
         """Process a single spec definition item."""
-        when_string = entry.get("when")
-        if when_string is not None:
-            when = _eval_conditional(when_string)
-            assert len([x for x in entry if x != "when"]) == 1
-        else:
-            when = True
-            assert len(entry) == 1
-
+        entry = copy.deepcopy(item)
+        when = _eval_conditional(entry.pop("when", "True"))
+        assert len(entry) == 1
         if when:
-            for name, spec_list in entry.items():
-                if name == "when":
-                    continue
-                user_specs = SpecList(name, spec_list, self.spec_lists.copy())
-                if name in self.spec_lists:
-                    self.spec_lists[name].extend(user_specs)
-                else:
-                    self.spec_lists[name] = user_specs
+            name, spec_list = next(iter(entry.items()))
+            user_specs = SpecList(name, spec_list, self.spec_lists.copy())
+            if name in self.spec_lists:
+                self.spec_lists[name].extend(user_specs)
+            else:
+                self.spec_lists[name] = user_specs
 
     def _process_view(self, env_view: Optional[Union[bool, str, Dict]]):
         """Process view option(s), which can be boolean, string, or None.
@@ -1196,7 +1190,6 @@ def scope_name(self):
     def include_concrete_envs(self):
         """Copy and save the included envs' specs internally"""
 
-        lockfile_meta = None
         root_hash_seen = set()
         concrete_hash_seen = set()
         self.included_concrete_spec_data = {}
@@ -1207,37 +1200,26 @@ def include_concrete_envs(self):
                 raise SpackEnvironmentError(f"Unable to find env at {env_path}")
 
             env = Environment(env_path)
-
-            with open(env.lock_path) as f:
-                lockfile_as_dict = env._read_lockfile(f)
-
-            # Lockfile_meta must match each env and use at least format version 5
-            if lockfile_meta is None:
-                lockfile_meta = lockfile_as_dict["_meta"]
-            elif lockfile_meta != lockfile_as_dict["_meta"]:
-                raise SpackEnvironmentError("All lockfile _meta values must match")
-            elif lockfile_meta["lockfile-version"] < 5:
-                raise SpackEnvironmentError("The lockfile format must be at version 5 or higher")
+            self.included_concrete_spec_data[env_path] = {"roots": [], "concrete_specs": {}}
 
             # Copy unique root specs from env
-            self.included_concrete_spec_data[env_path] = {"roots": []}
-            for root_dict in lockfile_as_dict["roots"]:
+            for root_dict in env._concrete_roots_dict():
                 if root_dict["hash"] not in root_hash_seen:
                     self.included_concrete_spec_data[env_path]["roots"].append(root_dict)
                     root_hash_seen.add(root_dict["hash"])
 
             # Copy unique concrete specs from env
-            for concrete_spec in lockfile_as_dict["concrete_specs"]:
-                if concrete_spec not in concrete_hash_seen:
-                    self.included_concrete_spec_data[env_path].update(
-                        {"concrete_specs": lockfile_as_dict["concrete_specs"]}
+            for dag_hash, spec_details in env._concrete_specs_dict().items():
+                if dag_hash not in concrete_hash_seen:
+                    self.included_concrete_spec_data[env_path]["concrete_specs"].update(
+                        {dag_hash: spec_details}
                     )
-                    concrete_hash_seen.add(concrete_spec)
+                    concrete_hash_seen.add(dag_hash)
 
-            if "include_concrete" in lockfile_as_dict.keys():
-                self.included_concrete_spec_data[env_path]["include_concrete"] = lockfile_as_dict[
-                    "include_concrete"
-                ]
+            # Copy transitive include data
+            transitive = env.included_concrete_spec_data
+            if transitive:
+                self.included_concrete_spec_data[env_path]["include_concrete"] = transitive
 
         self._read_lockfile_dict(self._to_lockfile_dict())
         self.write()
@@ -1954,19 +1936,13 @@ def install_specs(self, specs: Optional[List[Spec]] = None, **install_args):
         specs = specs if specs is not None else roots
 
         # Extend the set of specs to overwrite with modified dev specs and their parents
-        overwrite: Set[str] = set()
-        overwrite.update(install_args.get("overwrite", []), self._dev_specs_that_need_overwrite())
-        install_args["overwrite"] = overwrite
-
-        explicit: Set[str] = set()
-        explicit.update(
-            install_args.get("explicit", []),
-            (s.dag_hash() for s in specs),
-            (s.dag_hash() for s in roots),
+        install_args["overwrite"] = (
+            install_args.get("overwrite", []) + self._dev_specs_that_need_overwrite()
         )
-        install_args["explicit"] = explicit
 
-        PackageInstaller([spec.package for spec in specs], install_args).install()
+        installs = [(spec.package, {**install_args, "explicit": spec in roots}) for spec in specs]
+
+        PackageInstaller(installs).install()
 
     def all_specs_generator(self) -> Iterable[Spec]:
         """Returns a generator for all concrete specs"""
@@ -2156,16 +2132,23 @@ def _get_environment_specs(self, recurse_dependencies=True):
 
         return specs
 
-    def _to_lockfile_dict(self):
-        """Create a dictionary to store a lockfile for this environment."""
+    def _concrete_specs_dict(self):
         concrete_specs = {}
         for s in traverse.traverse_nodes(self.specs_by_hash.values(), key=traverse.by_dag_hash):
             spec_dict = s.node_dict_with_hashes(hash=ht.dag_hash)
             # Assumes no legacy formats, since this was just created.
             spec_dict[ht.dag_hash.name] = s.dag_hash()
             concrete_specs[s.dag_hash()] = spec_dict
+        return concrete_specs
 
+    def _concrete_roots_dict(self):
         hash_spec_list = zip(self.concretized_order, self.concretized_user_specs)
+        return [{"hash": h, "spec": str(s)} for h, s in hash_spec_list]
+
+    def _to_lockfile_dict(self):
+        """Create a dictionary to store a lockfile for this environment."""
+        concrete_specs = self._concrete_specs_dict()
+        root_specs = self._concrete_roots_dict()
 
         spack_dict = {"version": spack.spack_version}
         spack_commit = spack.main.get_spack_commit()
@@ -2186,7 +2169,7 @@ def _to_lockfile_dict(self):
             # spack version information
             "spack": spack_dict,
             # users specs + hashes are the 'roots' of the environment
-            "roots": [{"hash": h, "spec": str(s)} for h, s in hash_spec_list],
+            "roots": root_specs,
             # Concrete specs by hash, including dependencies
             "concrete_specs": concrete_specs,
         }
@@ -2479,21 +2462,27 @@ def _equiv_dict(first, second):
     return same_values and same_keys_with_same_overrides
 
 
-def display_specs(specs):
-    """Displays a list of specs traversed breadth-first, covering nodes, with install status.
+def display_specs(concretized_specs):
+    """Displays the list of specs returned by `Environment.concretize()`.
 
     Args:
-        specs (list): list of specs
+        concretized_specs (list): list of specs returned by
+            `Environment.concretize()`
     """
-    tree_string = spack.spec.tree(
-        specs,
-        format=spack.spec.DISPLAY_FORMAT,
-        hashes=True,
-        hashlen=7,
-        status_fn=spack.spec.Spec.install_status,
-        key=traverse.by_dag_hash,
-    )
-    print(tree_string)
+
+    def _tree_to_display(spec):
+        return spec.tree(
+            recurse_dependencies=True,
+            format=spack.spec.DISPLAY_FORMAT,
+            status_fn=spack.spec.Spec.install_status,
+            hashlen=7,
+            hashes=True,
+        )
+
+    for user_spec, concrete_spec in concretized_specs:
+        tty.msg("Concretized {0}".format(user_spec))
+        sys.stdout.write(_tree_to_display(concrete_spec))
+        print("")
 
 
 def _concretize_from_constraints(spec_constraints, tests=False):
@@ -2547,7 +2536,7 @@ def _concretize_task(packed_arguments) -> Tuple[int, Spec, float]:
 
 def make_repo_path(root):
     """Make a RepoPath from the repo subdirectories in an environment."""
-    path = spack.repo.RepoPath(cache=spack.caches.MISC_CACHE)
+    path = spack.repo.RepoPath()
 
     if os.path.isdir(root):
         for repo_root in os.listdir(root):
@@ -2556,7 +2545,7 @@ def make_repo_path(root):
             if not os.path.isdir(repo_root):
                 continue
 
-            repo = spack.repo.from_path(repo_root)
+            repo = spack.repo.Repo(repo_root)
             path.put_last(repo)
 
     return path
@@ -2757,11 +2746,10 @@ def from_lockfile(manifest_dir: Union[pathlib.Path, str]) -> "EnvironmentManifes
         manifest.flush()
         return manifest
 
-    def __init__(self, manifest_dir: Union[pathlib.Path, str], name: Optional[str] = None) -> None:
+    def __init__(self, manifest_dir: Union[pathlib.Path, str]) -> None:
         self.manifest_dir = pathlib.Path(manifest_dir)
-        self.name = name or str(manifest_dir)
         self.manifest_file = self.manifest_dir / manifest_name
-        self.scope_name = f"env:{self.name}"
+        self.scope_name = f"env:{environment_name(self.manifest_dir)}"
         self.config_stage_dir = os.path.join(env_subdir_path(manifest_dir), "config")
 
         #: Configuration scopes associated with this environment. Note that these are not
@@ -2773,8 +2761,12 @@ def __init__(self, manifest_dir: Union[pathlib.Path, str], name: Optional[str] =
             raise SpackEnvironmentError(msg)
 
         with self.manifest_file.open() as f:
-            self.yaml_content = _read_yaml(f)
+            raw, with_defaults_added = _read_yaml(f)
 
+        #: Pristine YAML content, without defaults being added
+        self.pristine_yaml_content = raw
+        #: YAML content with defaults added by Spack, if they're missing
+        self.yaml_content = with_defaults_added
         self.changed = False
 
     def _all_matches(self, user_spec: str) -> List[str]:
@@ -2788,7 +2780,7 @@ def _all_matches(self, user_spec: str) -> List[str]:
             ValueError: if no equivalent match is found
         """
         result = []
-        for yaml_spec_str in self.configuration["specs"]:
+        for yaml_spec_str in self.pristine_configuration["specs"]:
             if Spec(yaml_spec_str) == Spec(user_spec):
                 result.append(yaml_spec_str)
 
@@ -2803,6 +2795,7 @@ def add_user_spec(self, user_spec: str) -> None:
         Args:
             user_spec: user spec to be appended
         """
+        self.pristine_configuration.setdefault("specs", []).append(user_spec)
         self.configuration.setdefault("specs", []).append(user_spec)
         self.changed = True
 
@@ -2817,6 +2810,7 @@ def remove_user_spec(self, user_spec: str) -> None:
         """
         try:
             for key in self._all_matches(user_spec):
+                self.pristine_configuration["specs"].remove(key)
                 self.configuration["specs"].remove(key)
         except ValueError as e:
             msg = f"cannot remove {user_spec} from {self}, no such spec exists"
@@ -2834,6 +2828,7 @@ def override_user_spec(self, user_spec: str, idx: int) -> None:
             SpackEnvironmentError: when the user spec cannot be overridden
         """
         try:
+            self.pristine_configuration["specs"][idx] = user_spec
             self.configuration["specs"][idx] = user_spec
         except ValueError as e:
             msg = f"cannot override {user_spec} from {self}"
@@ -2846,10 +2841,10 @@ def set_include_concrete(self, include_concrete: List[str]) -> None:
         Args:
             include_concrete: list of already existing concrete environments to include
         """
-        self.configuration[included_concrete_name] = []
+        self.pristine_configuration[included_concrete_name] = []
 
         for env_path in include_concrete:
-            self.configuration[included_concrete_name].append(env_path)
+            self.pristine_configuration[included_concrete_name].append(env_path)
 
         self.changed = True
 
@@ -2863,13 +2858,14 @@ def add_definition(self, user_spec: str, list_name: str) -> None:
         Raises:
             SpackEnvironmentError: is no valid definition exists already
         """
-        defs = self.configuration.get("definitions", [])
+        defs = self.pristine_configuration.get("definitions", [])
         msg = f"cannot add {user_spec} to the '{list_name}' definition, no valid list exists"
 
         for idx, item in self._iterate_on_definitions(defs, list_name=list_name, err_msg=msg):
             item[list_name].append(user_spec)
             break
 
+        self.configuration["definitions"][idx][list_name].append(user_spec)
         self.changed = True
 
     def remove_definition(self, user_spec: str, list_name: str) -> None:
@@ -2883,7 +2879,7 @@ def remove_definition(self, user_spec: str, list_name: str) -> None:
             SpackEnvironmentError: if the user spec cannot be removed from the list,
                 or the list does not exist
         """
-        defs = self.configuration.get("definitions", [])
+        defs = self.pristine_configuration.get("definitions", [])
         msg = (
             f"cannot remove {user_spec} from the '{list_name}' definition, "
             f"no valid list exists"
@@ -2896,6 +2892,7 @@ def remove_definition(self, user_spec: str, list_name: str) -> None:
             except ValueError:
                 pass
 
+        self.configuration["definitions"][idx][list_name].remove(user_spec)
         self.changed = True
 
     def override_definition(self, user_spec: str, *, override: str, list_name: str) -> None:
@@ -2910,7 +2907,7 @@ def override_definition(self, user_spec: str, *, override: str, list_name: str)
         Raises:
             SpackEnvironmentError: if the user spec cannot be overridden
         """
-        defs = self.configuration.get("definitions", [])
+        defs = self.pristine_configuration.get("definitions", [])
         msg = f"cannot override {user_spec} with {override} in the '{list_name}' definition"
 
         for idx, item in self._iterate_on_definitions(defs, list_name=list_name, err_msg=msg):
@@ -2921,6 +2918,7 @@ def override_definition(self, user_spec: str, *, override: str, list_name: str)
             except ValueError:
                 pass
 
+        self.configuration["definitions"][idx][list_name][sub_index] = override
         self.changed = True
 
     def _iterate_on_definitions(self, definitions, *, list_name, err_msg):
@@ -2952,6 +2950,7 @@ def set_default_view(self, view: Union[bool, str, pathlib.Path, Dict[str, str]])
                 True the default view is used for the environment, if False there's no view.
         """
         if isinstance(view, dict):
+            self.pristine_configuration["view"][default_view_name].update(view)
             self.configuration["view"][default_view_name].update(view)
             self.changed = True
             return
@@ -2959,13 +2958,15 @@ def set_default_view(self, view: Union[bool, str, pathlib.Path, Dict[str, str]])
         if not isinstance(view, bool):
             view = str(view)
 
+        self.pristine_configuration["view"] = view
         self.configuration["view"] = view
         self.changed = True
 
     def remove_default_view(self) -> None:
         """Removes the default view from the manifest file"""
-        view_data = self.configuration.get("view")
+        view_data = self.pristine_configuration.get("view")
         if isinstance(view_data, collections.abc.Mapping):
+            self.pristine_configuration["view"].pop(default_view_name)
             self.configuration["view"].pop(default_view_name)
             self.changed = True
             return
@@ -2978,12 +2979,17 @@ def flush(self) -> None:
             return
 
         with fs.write_tmp_and_move(os.path.realpath(self.manifest_file)) as f:
-            _write_yaml(self.yaml_content, f)
+            _write_yaml(self.pristine_yaml_content, f)
         self.changed = False
 
     @property
-    def configuration(self):
+    def pristine_configuration(self):
         """Return the dictionaries in the pristine YAML, without the top level attribute"""
+        return self.pristine_yaml_content[TOP_LEVEL_KEY]
+
+    @property
+    def configuration(self):
+        """Return the dictionaries in the YAML, without the top level attribute"""
         return self.yaml_content[TOP_LEVEL_KEY]
 
     def __len__(self):
@@ -3015,11 +3021,12 @@ def included_config_scopes(self) -> List[spack.config.ConfigScope]:
             SpackEnvironmentError: if the manifest includes a remote file but
                 no configuration stage directory has been identified
         """
-        scopes: List[spack.config.ConfigScope] = []
+        scopes = []
 
         # load config scopes added via 'include:', in reverse so that
         # highest-precedence scopes are last.
         includes = self[TOP_LEVEL_KEY].get("include", [])
+        env_name = environment_name(self.manifest_dir)
         missing = []
         for i, config_path in enumerate(reversed(includes)):
             # allow paths to contain spack config/environment variables, etc.
@@ -3082,22 +3089,24 @@ def included_config_scopes(self) -> List[spack.config.ConfigScope]:
 
             if os.path.isdir(config_path):
                 # directories are treated as regular ConfigScopes
-                config_name = f"env:{self.name}:{os.path.basename(config_path)}"
-                tty.debug(f"Creating DirectoryConfigScope {config_name} for '{config_path}'")
-                scopes.append(spack.config.DirectoryConfigScope(config_name, config_path))
+                config_name = "env:%s:%s" % (env_name, os.path.basename(config_path))
+                tty.debug("Creating ConfigScope {0} for '{1}'".format(config_name, config_path))
+                scope = spack.config.ConfigScope(config_name, config_path)
             elif os.path.exists(config_path):
                 # files are assumed to be SingleFileScopes
-                config_name = f"env:{self.name}:{config_path}"
-                tty.debug(f"Creating SingleFileScope {config_name} for '{config_path}'")
-                scopes.append(
-                    spack.config.SingleFileScope(
-                        config_name, config_path, spack.schema.merged.schema
-                    )
+                config_name = "env:%s:%s" % (env_name, config_path)
+                tty.debug(
+                    "Creating SingleFileScope {0} for '{1}'".format(config_name, config_path)
+                )
+                scope = spack.config.SingleFileScope(
+                    config_name, config_path, spack.schema.merged.schema
                 )
             else:
                 missing.append(config_path)
                 continue
 
+            scopes.append(scope)
+
         if missing:
             msg = "Detected {0} missing include path(s):".format(len(missing))
             msg += "\n   {0}".format("\n   ".join(missing))
@@ -3114,10 +3123,7 @@ def env_config_scopes(self) -> List[spack.config.ConfigScope]:
         scopes: List[spack.config.ConfigScope] = [
             *self.included_config_scopes,
             spack.config.SingleFileScope(
-                self.scope_name,
-                str(self.manifest_file),
-                spack.schema.env.schema,
-                yaml_path=[TOP_LEVEL_KEY],
+                self.scope_name, str(self.manifest_file), spack.schema.env.schema, [TOP_LEVEL_KEY]
             ),
         ]
         ensure_no_disallowed_env_config_mods(scopes)

lib/spack/spack/fetch_strategy.py

@@ -554,7 +554,7 @@ def fetch(self):
 
         try:
             response = self._urlopen(self.url)
-        except urllib.error.URLError as e:
+        except (TimeoutError, urllib.error.URLError) as e:
             # clean up archive on failure.
             if self.archive_file:
                 os.remove(self.archive_file)

lib/spack/spack/hooks/absolutify_elf_sonames.py

@@ -13,6 +13,7 @@
 import spack.config
 import spack.relocate
 from spack.util.elf import ElfParsingError, parse_elf
+from spack.util.executable import Executable
 
 
 def is_shared_library_elf(filepath):
@@ -140,7 +141,7 @@ def post_install(spec, explicit=None):
         return
 
     # Only enable on platforms using ELF.
-    if not spec.satisfies("platform=linux"):
+    if not spec.satisfies("platform=linux") and not spec.satisfies("platform=cray"):
         return
 
     # Disable this hook when bootstrapping, to avoid recursion.
@@ -148,9 +149,10 @@ def post_install(spec, explicit=None):
         return
 
     # Should failing to locate patchelf be a hard error?
-    patchelf = spack.relocate._patchelf()
-    if not patchelf:
+    patchelf_path = spack.relocate._patchelf()
+    if not patchelf_path:
         return
+    patchelf = Executable(patchelf_path)
 
     fixes = find_and_patch_sonames(spec.prefix, spec.package.non_bindable_shared_objects, patchelf)
 

lib/spack/spack/hooks/drop_redundant_rpaths.py

@@ -117,7 +117,7 @@ def post_install(spec, explicit=None):
         return
 
     # Only enable on platforms using ELF.
-    if not spec.satisfies("platform=linux"):
+    if not spec.satisfies("platform=linux") and not spec.satisfies("platform=cray"):
         return
 
     visit_directory_tree(spec.prefix, ElfFilesWithRPathVisitor())

lib/spack/spack/installer.py

@@ -582,7 +582,7 @@ def dump_packages(spec: "spack.spec.Spec", path: str) -> None:
 
             # Create a source repo and get the pkg directory out of it.
             try:
-                source_repo = spack.repo.from_path(source_repo_root)
+                source_repo = spack.repo.Repo(source_repo_root)
                 source_pkg_dir = source_repo.dirname_for_package_name(node.name)
             except spack.repo.RepoError as err:
                 tty.debug(f"Failed to create source repo for {node.name}: {str(err)}")
@@ -593,14 +593,16 @@ def dump_packages(spec: "spack.spec.Spec", path: str) -> None:
         dest_repo_root = os.path.join(path, node.namespace)
         if not os.path.exists(dest_repo_root):
             spack.repo.create_repo(dest_repo_root)
-        repo = spack.repo.from_path(dest_repo_root)
+        repo = spack.repo.Repo(dest_repo_root)
 
         # Get the location of the package in the dest repo.
         dest_pkg_dir = repo.dirname_for_package_name(node.name)
         if node is spec:
             spack.repo.PATH.dump_provenance(node, dest_pkg_dir)
         elif source_pkg_dir:
-            fs.install_tree(source_pkg_dir, dest_pkg_dir)
+            fs.install_tree(
+                source_pkg_dir, dest_pkg_dir, allow_broken_symlinks=(sys.platform != "win32")
+            )
 
 
 def get_dependent_ids(spec: "spack.spec.Spec") -> List[str]:
@@ -759,8 +761,12 @@ def __init__(self, pkg: "spack.package_base.PackageBase", install_args: dict):
         if not self.pkg.spec.concrete:
             raise ValueError(f"{self.pkg.name} must have a concrete spec")
 
-        self.pkg.stop_before_phase = install_args.get("stop_before")  # type: ignore[attr-defined] # noqa: E501
-        self.pkg.last_phase = install_args.get("stop_at")  # type: ignore[attr-defined]
+        # Cache the package phase options with the explicit package,
+        # popping the options to ensure installation of associated
+        # dependencies is NOT affected by these options.
+
+        self.pkg.stop_before_phase = install_args.pop("stop_before", None)  # type: ignore[attr-defined] # noqa: E501
+        self.pkg.last_phase = install_args.pop("stop_at", None)  # type: ignore[attr-defined]
 
         # Cache the package id for convenience
         self.pkg_id = package_id(pkg.spec)
@@ -1070,17 +1076,19 @@ def flag_installed(self, installed: List[str]) -> None:
 
     @property
     def explicit(self) -> bool:
-        return self.pkg.spec.dag_hash() in self.request.install_args.get("explicit", [])
+        """The package was explicitly requested by the user."""
+        return self.is_root and self.request.install_args.get("explicit", True)
 
     @property
-    def is_build_request(self) -> bool:
-        """The package was requested directly"""
+    def is_root(self) -> bool:
+        """The package was requested directly, but may or may not be explicit
+        in an environment."""
         return self.pkg == self.request.pkg
 
     @property
     def use_cache(self) -> bool:
         _use_cache = True
-        if self.is_build_request:
+        if self.is_root:
             return self.request.install_args.get("package_use_cache", _use_cache)
         else:
             return self.request.install_args.get("dependencies_use_cache", _use_cache)
@@ -1088,7 +1096,7 @@ def use_cache(self) -> bool:
     @property
     def cache_only(self) -> bool:
         _cache_only = False
-        if self.is_build_request:
+        if self.is_root:
             return self.request.install_args.get("package_cache_only", _cache_only)
         else:
             return self.request.install_args.get("dependencies_cache_only", _cache_only)
@@ -1114,17 +1122,24 @@ def priority(self):
 
 class PackageInstaller:
     """
-    Class for managing the install process for a Spack instance based on a bottom-up DAG approach.
+    Class for managing the install process for a Spack instance based on a
+    bottom-up DAG approach.
 
-    This installer can coordinate concurrent batch and interactive, local and distributed (on a
-    shared file system) builds for the same Spack instance.
+    This installer can coordinate concurrent batch and interactive, local
+    and distributed (on a shared file system) builds for the same Spack
+    instance.
     """
 
-    def __init__(
-        self, packages: List["spack.package_base.PackageBase"], install_args: dict
-    ) -> None:
+    def __init__(self, installs: List[Tuple["spack.package_base.PackageBase", dict]] = []) -> None:
+        """Initialize the installer.
+
+        Args:
+            installs (list): list of tuples, where each
+                tuple consists of a package (PackageBase) and its associated
+                 install arguments (dict)
+        """
         # List of build requests
-        self.build_requests = [BuildRequest(pkg, install_args) for pkg in packages]
+        self.build_requests = [BuildRequest(pkg, install_args) for pkg, install_args in installs]
 
         # Priority queue of build tasks
         self.build_pq: List[Tuple[Tuple[int, int], BuildTask]] = []
@@ -1542,6 +1557,17 @@ def _add_tasks(self, request: BuildRequest, all_deps):
             tty.warn(f"Installation request refused: {str(err)}")
             return
 
+        # Skip out early if the spec is not being installed locally (i.e., if
+        # external or upstream).
+        #
+        # External and upstream packages need to get flagged as installed to
+        # ensure proper status tracking for environment build.
+        explicit = request.install_args.get("explicit", True)
+        not_local = _handle_external_and_upstream(request.pkg, explicit)
+        if not_local:
+            self._flag_installed(request.pkg)
+            return
+
         install_compilers = spack.config.get("config:install_missing_compilers", False)
 
         install_deps = request.install_args.get("install_deps")
@@ -1657,6 +1683,10 @@ def _install_task(self, task: BuildTask, install_status: InstallStatus) -> None:
         if not pkg.unit_test_check():
             return
 
+        # Injecting information to know if this installation request is the root one
+        # to determine in BuildProcessInstaller whether installation is explicit or not
+        install_args["is_root"] = task.is_root
+
         try:
             self._setup_install_dir(pkg)
 
@@ -1968,8 +1998,8 @@ def install(self) -> None:
 
         self._init_queue()
         fail_fast_err = "Terminating after first install failure"
-        single_requested_spec = len(self.build_requests) == 1
-        failed_build_requests = []
+        single_explicit_spec = len(self.build_requests) == 1
+        failed_explicits = []
 
         install_status = InstallStatus(len(self.build_pq))
 
@@ -2018,10 +2048,11 @@ def install(self) -> None:
             # Skip the installation if the spec is not being installed locally
             # (i.e., if external or upstream) BUT flag it as installed since
             # some package likely depends on it.
-            if _handle_external_and_upstream(pkg, task.explicit):
-                term_status.clear()
-                self._flag_installed(pkg, task.dependents)
-                continue
+            if not task.explicit:
+                if _handle_external_and_upstream(pkg, False):
+                    term_status.clear()
+                    self._flag_installed(pkg, task.dependents)
+                    continue
 
             # Flag a failed spec.  Do not need an (install) prefix lock since
             # assume using a separate (failed) prefix lock file.
@@ -2166,11 +2197,14 @@ def install(self) -> None:
                 if self.fail_fast:
                     raise InstallError(f"{fail_fast_err}: {str(exc)}", pkg=pkg)
 
-                # Terminate when a single build request has failed, or summarize errors later.
-                if task.is_build_request:
-                    if single_requested_spec:
-                        raise
-                    failed_build_requests.append((pkg, pkg_id, str(exc)))
+                # Terminate at this point if the single explicit spec has
+                # failed to install.
+                if single_explicit_spec and task.explicit:
+                    raise
+
+                # Track explicit spec id and error to summarize when done
+                if task.explicit:
+                    failed_explicits.append((pkg, pkg_id, str(exc)))
 
             finally:
                 # Remove the install prefix if anything went wrong during
@@ -2193,16 +2227,16 @@ def install(self) -> None:
             if request.install_args.get("install_package") and request.pkg_id not in self.installed
         ]
 
-        if failed_build_requests or missing:
-            for _, pkg_id, err in failed_build_requests:
+        if failed_explicits or missing:
+            for _, pkg_id, err in failed_explicits:
                 tty.error(f"{pkg_id}: {err}")
 
             for _, pkg_id in missing:
                 tty.error(f"{pkg_id}: Package was not installed")
 
-            if len(failed_build_requests) > 0:
-                pkg = failed_build_requests[0][0]
-                ids = [pkg_id for _, pkg_id, _ in failed_build_requests]
+            if len(failed_explicits) > 0:
+                pkg = failed_explicits[0][0]
+                ids = [pkg_id for _, pkg_id, _ in failed_explicits]
                 tty.debug(
                     "Associating installation failure with first failed "
                     f"explicit package ({ids[0]}) from {', '.join(ids)}"
@@ -2261,7 +2295,7 @@ def __init__(self, pkg: "spack.package_base.PackageBase", install_args: dict):
         self.verbose = bool(install_args.get("verbose", False))
 
         # whether installation was explicitly requested by the user
-        self.explicit = pkg.spec.dag_hash() in install_args.get("explicit", [])
+        self.explicit = install_args.get("is_root", False) and install_args.get("explicit", True)
 
         # env before starting installation
         self.unmodified_env = install_args.get("unmodified_env", {})
@@ -2346,7 +2380,9 @@ def _install_source(self) -> None:
         src_target = os.path.join(pkg.spec.prefix, "share", pkg.name, "src")
         tty.debug(f"{self.pre} Copying source to {src_target}")
 
-        fs.install_tree(pkg.stage.source_path, src_target)
+        fs.install_tree(
+            pkg.stage.source_path, src_target, allow_broken_symlinks=(sys.platform != "win32")
+        )
 
     def _real_install(self) -> None:
         import spack.builder

lib/spack/spack/main.py

@@ -444,9 +444,8 @@ def make_argument_parser(**kwargs):
         "--config-scope",
         dest="config_scopes",
         action="append",
-        metavar="DIR|ENV",
-        help="add directory or environment as read-only configuration scope, without activating "
-        "the environment.",
+        metavar="DIR",
+        help="add a custom configuration scope",
     )
     parser.add_argument(
         "-d",

lib/spack/spack/operating_systems/__init__.py

@@ -3,12 +3,22 @@
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 from ._operating_system import OperatingSystem
+from .cray_backend import CrayBackend
+from .cray_frontend import CrayFrontend
 from .freebsd import FreeBSDOs
 from .linux_distro import LinuxDistro
 from .mac_os import MacOs
 from .windows_os import WindowsOs
 
-__all__ = ["OperatingSystem", "LinuxDistro", "MacOs", "WindowsOs", "FreeBSDOs"]
+__all__ = [
+    "OperatingSystem",
+    "LinuxDistro",
+    "MacOs",
+    "CrayFrontend",
+    "CrayBackend",
+    "WindowsOs",
+    "FreeBSDOs",
+]
 
 #: List of all the Operating Systems known to Spack
-operating_systems = [LinuxDistro, MacOs, WindowsOs, FreeBSDOs]
+operating_systems = [LinuxDistro, MacOs, CrayFrontend, CrayBackend, WindowsOs, FreeBSDOs]

lib/spack/spack/operating_systems/cray_backend.py

@@ -0,0 +1,172 @@
+# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+# Spack Project Developers. See the top-level COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+import os
+import re
+
+import llnl.util.tty as tty
+
+import spack.error
+import spack.version
+from spack.util.module_cmd import module
+
+from .linux_distro import LinuxDistro
+
+#: Possible locations of the Cray CLE release file,
+#: which we look at to get the CNL OS version.
+_cle_release_file = "/etc/opt/cray/release/cle-release"
+_clerelease_file = "/etc/opt/cray/release/clerelease"
+
+
+def read_cle_release_file():
+    """Read the CLE release file and return a dict with its attributes.
+
+    This file is present on newer versions of Cray.
+
+    The release file looks something like this::
+
+        RELEASE=6.0.UP07
+        BUILD=6.0.7424
+        ...
+
+    The dictionary we produce looks like this::
+
+        {
+          "RELEASE": "6.0.UP07",
+          "BUILD": "6.0.7424",
+          ...
+        }
+
+    Returns:
+        dict: dictionary of release attributes
+    """
+    with open(_cle_release_file) as release_file:
+        result = {}
+        for line in release_file:
+            # use partition instead of split() to ensure we only split on
+            # the first '=' in the line.
+            key, _, value = line.partition("=")
+            result[key] = value.strip()
+        return result
+
+
+def read_clerelease_file():
+    """Read the CLE release file and return the Cray OS version.
+
+    This file is present on older versions of Cray.
+
+    The release file looks something like this::
+
+        5.2.UP04
+
+    Returns:
+        str: the Cray OS version
+    """
+    with open(_clerelease_file) as release_file:
+        for line in release_file:
+            return line.strip()
+
+
+class CrayBackend(LinuxDistro):
+    """Compute Node Linux (CNL) is the operating system used for the Cray XC
+    series super computers. It is a very stripped down version of GNU/Linux.
+    Any compilers found through this operating system will be used with
+    modules. If updated, user must make sure that version and name are
+    updated to indicate that OS has been upgraded (or downgraded)
+    """
+
+    def __init__(self):
+        name = "cnl"
+        version = self._detect_crayos_version()
+        if version:
+            # If we found a CrayOS version, we do not want the information
+            # from LinuxDistro. In order to skip the logic from
+            # distro.linux_distribution, while still calling __init__
+            # methods further up the MRO, we skip LinuxDistro in the MRO and
+            # call the OperatingSystem superclass __init__ method
+            super(LinuxDistro, self).__init__(name, version)
+        else:
+            super().__init__()
+        self.modulecmd = module
+
+    def __str__(self):
+        return self.name + str(self.version)
+
+    @classmethod
+    def _detect_crayos_version(cls):
+        if os.path.isfile(_cle_release_file):
+            release_attrs = read_cle_release_file()
+            if "RELEASE" not in release_attrs:
+                # This Cray system uses a base OS not CLE/CNL
+                return None
+            v = spack.version.Version(release_attrs["RELEASE"])
+            return v[0]
+        elif os.path.isfile(_clerelease_file):
+            v = read_clerelease_file()
+            return spack.version.Version(v)[0]
+        else:
+            # Not all Cray systems run CNL on the backend.
+            # Systems running in what Cray calls "cluster" mode run other
+            # linux OSs under the Cray PE.
+            # So if we don't detect any Cray OS version on the system,
+            # we return None. We can't ever be sure we will get a Cray OS
+            # version.
+            # Returning None allows the calling code to test for the value
+            # being "True-ish" rather than requiring a try/except block.
+            return None
+
+    def arguments_to_detect_version_fn(self, paths):
+        import spack.compilers
+
+        command_arguments = []
+        for compiler_name in spack.compilers.supported_compilers():
+            cmp_cls = spack.compilers.class_for_compiler_name(compiler_name)
+
+            # If the compiler doesn't have a corresponding
+            # Programming Environment, skip to the next
+            if cmp_cls.PrgEnv is None:
+                continue
+
+            if cmp_cls.PrgEnv_compiler is None:
+                tty.die("Must supply PrgEnv_compiler with PrgEnv")
+
+            compiler_id = spack.compilers.CompilerID(self, compiler_name, None)
+            detect_version_args = spack.compilers.DetectVersionArgs(
+                id=compiler_id, variation=(None, None), language="cc", path="cc"
+            )
+            command_arguments.append(detect_version_args)
+        return command_arguments
+
+    def detect_version(self, detect_version_args):
+        import spack.compilers
+
+        modulecmd = self.modulecmd
+        compiler_name = detect_version_args.id.compiler_name
+        compiler_cls = spack.compilers.class_for_compiler_name(compiler_name)
+        output = modulecmd("avail", compiler_cls.PrgEnv_compiler)
+        version_regex = r"({0})/([\d\.]+[\d]-?[\w]*)".format(compiler_cls.PrgEnv_compiler)
+        matches = re.findall(version_regex, output)
+        version = tuple(version for _, version in matches if "classic" not in version)
+        compiler_id = detect_version_args.id
+        value = detect_version_args._replace(id=compiler_id._replace(version=version))
+        return value, None
+
+    def make_compilers(self, compiler_id, paths):
+        import spack.spec
+
+        name = compiler_id.compiler_name
+        cmp_cls = spack.compilers.class_for_compiler_name(name)
+        compilers = []
+        for v in compiler_id.version:
+            comp = cmp_cls(
+                spack.spec.CompilerSpec(name + "@=" + v),
+                self,
+                "any",
+                ["cc", "CC", "ftn"],
+                [cmp_cls.PrgEnv, name + "/" + v],
+            )
+
+            compilers.append(comp)
+        return compilers

lib/spack/spack/operating_systems/cray_frontend.py

@@ -0,0 +1,105 @@
+# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+# Spack Project Developers. See the top-level COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+import contextlib
+import os
+import re
+
+import llnl.util.filesystem as fs
+import llnl.util.lang
+import llnl.util.tty as tty
+
+from spack.util.environment import get_path
+from spack.util.module_cmd import module
+
+from .linux_distro import LinuxDistro
+
+
+@contextlib.contextmanager
+def unload_programming_environment():
+    """Context manager that unloads Cray Programming Environments."""
+    env_bu = None
+
+    # We rely on the fact that the PrgEnv-* modules set the PE_ENV
+    # environment variable.
+    if "PE_ENV" in os.environ:
+        # Copy environment variables to restore them after the compiler
+        # detection. We expect that the only thing PrgEnv-* modules do is
+        # the environment variables modifications.
+        env_bu = os.environ.copy()
+
+        # Get the name of the module from the environment variable.
+        prg_env = "PrgEnv-" + os.environ["PE_ENV"].lower()
+
+        # Unload the PrgEnv-* module. By doing this we intentionally
+        # provoke errors when the Cray's compiler wrappers are executed
+        # (Error: A PrgEnv-* modulefile must be loaded.) so they will not
+        # be detected as valid compilers by the overridden method. We also
+        # expect that the modules that add the actual compilers' binaries
+        # into the PATH environment variable (i.e. the following modules:
+        # 'intel', 'cce', 'gcc', etc.) will also be unloaded since they are
+        # specified as prerequisites in the PrgEnv-* modulefiles.
+        module("unload", prg_env)
+
+    yield
+
+    # Restore the environment.
+    if env_bu is not None:
+        os.environ.clear()
+        os.environ.update(env_bu)
+
+
+class CrayFrontend(LinuxDistro):
+    """Represents OS that runs on login and service nodes of the Cray platform.
+    It acts as a regular Linux without Cray-specific modules and compiler
+    wrappers."""
+
+    @property
+    def compiler_search_paths(self):
+        """Calls the default function but unloads Cray's programming
+        environments first.
+
+        This prevents from detecting Cray compiler wrappers and avoids
+        possible false detections.
+        """
+        import spack.compilers
+
+        with unload_programming_environment():
+            search_paths = get_path("PATH")
+
+        extract_path_re = re.compile(r"prepend-path[\s]*PATH[\s]*([/\w\.:-]*)")
+
+        for compiler_cls in spack.compilers.all_compiler_types():
+            # Check if the compiler class is supported on Cray
+            prg_env = getattr(compiler_cls, "PrgEnv", None)
+            compiler_module = getattr(compiler_cls, "PrgEnv_compiler", None)
+            if not (prg_env and compiler_module):
+                continue
+
+            # It is supported, check which versions are available
+            output = module("avail", compiler_cls.PrgEnv_compiler)
+            version_regex = r"({0})/([\d\.]+[\d]-?[\w]*)".format(compiler_cls.PrgEnv_compiler)
+            matches = re.findall(version_regex, output)
+            versions = tuple(version for _, version in matches if "classic" not in version)
+
+            # Now inspect the modules and add to paths
+            msg = "[CRAY FE] Detected FE compiler [name={0}, versions={1}]"
+            tty.debug(msg.format(compiler_module, versions))
+            for v in versions:
+                try:
+                    current_module = compiler_module + "/" + v
+                    out = module("show", current_module)
+                    match = extract_path_re.search(out)
+                    search_paths += match.group(1).split(":")
+                except Exception as e:
+                    msg = (
+                        "[CRAY FE] An unexpected error occurred while "
+                        "detecting FE compiler [compiler={0}, "
+                        " version={1}, error={2}]"
+                    )
+                    tty.debug(msg.format(compiler_cls.name, v, str(e)))
+
+        search_paths = list(llnl.util.lang.dedupe(search_paths))
+        return fs.search_paths_for_executables(*search_paths)

lib/spack/spack/package_base.py

@@ -35,7 +35,6 @@
 
 import spack.compilers
 import spack.config
-import spack.dependency
 import spack.deptypes as dt
 import spack.directives
 import spack.directory_layout
@@ -622,6 +621,10 @@ class PackageBase(WindowsRPath, PackageViewMixin, RedistributionMixin, metaclass
     #: By default do not run tests within package's install()
     run_tests = False
 
+    #: Keep -Werror flags, matches config:flags:keep_werror to override config
+    # NOTE: should be type Optional[Literal['all', 'specific', 'none']] in 3.8+
+    keep_werror: Optional[str] = None
+
     #: Most packages are NOT extendable. Set to True if you want extensions.
     extendable = False
 
@@ -749,6 +752,11 @@ def __init__(self, spec):
         self._fetch_time = 0.0
 
         self.win_rpath = fsys.WindowsSimulatedRPath(self)
+
+        if self.is_extension:
+            pkg_cls = spack.repo.PATH.get_pkg_class(self.extendee_spec.name)
+            pkg_cls(self.extendee_spec)._check_extendable()
+
         super().__init__()
 
     @classmethod
@@ -922,32 +930,6 @@ def global_license_file(self):
             self.global_license_dir, self.name, os.path.basename(self.license_files[0])
         )
 
-    # NOTE: return type should be Optional[Literal['all', 'specific', 'none']] in
-    # Python 3.8+, but we still support 3.6.
-    @property
-    def keep_werror(self) -> Optional[str]:
-        """Keep ``-Werror`` flags, matches ``config:flags:keep_werror`` to override config.
-
-        Valid return values are:
-        * ``"all"``: keep all ``-Werror`` flags.
-        * ``"specific"``: keep only ``-Werror=specific-warning`` flags.
-        * ``"none"``: filter out all ``-Werror*`` flags.
-        * ``None``: respect the user's configuration (``"none"`` by default).
-        """
-        if self.spec.satisfies("%nvhpc@:23.3") or self.spec.satisfies("%pgi"):
-            # Filtering works by replacing -Werror with -Wno-error, but older nvhpc and
-            # PGI do not understand -Wno-error, so we disable filtering.
-            return "all"
-
-        elif self.spec.satisfies("%nvhpc@23.4:"):
-            # newer nvhpc supports -Wno-error but can't disable specific warnings with
-            # -Wno-error=warning. Skip -Werror=warning, but still filter -Werror.
-            return "specific"
-
-        else:
-            # use -Werror disablement by default for other compilers
-            return None
-
     @property
     def version(self):
         if not self.spec.versions.concrete:
@@ -1894,10 +1876,7 @@ def do_install(self, **kwargs):
             verbose (bool): Display verbose build output (by default,
                 suppresses it)
         """
-        explicit = kwargs.get("explicit", True)
-        if isinstance(explicit, bool):
-            kwargs["explicit"] = {self.spec.dag_hash()} if explicit else set()
-        PackageInstaller([self], kwargs).install()
+        PackageInstaller([(self, kwargs)]).install()
 
     # TODO (post-34236): Update tests and all packages that use this as a
     # TODO (post-34236): package method to the routine made available to
@@ -2384,6 +2363,10 @@ def do_deprecate(self, deprecator, link_fn):
         PackageBase.uninstall_by_spec(spec, force=True, deprecator=deprecator)
         link_fn(deprecator.prefix, spec.prefix)
 
+    def _check_extendable(self):
+        if not self.extendable:
+            raise ValueError("Package %s is not extendable!" % self.name)
+
     def view(self):
         """Create a view with the prefix of this package as the root.
         Extensions added to this view will modify the installation prefix of

lib/spack/spack/patch.py

@@ -9,7 +9,7 @@
 import os.path
 import pathlib
 import sys
-from typing import Any, Dict, Optional, Tuple, Type, Union
+from typing import Any, Dict, Optional, Tuple, Type
 
 import llnl.util.filesystem
 from llnl.url import allowed_archive
@@ -65,9 +65,6 @@ def apply_patch(
         patch(*args)
 
 
-PatchPackageType = Union["spack.package_base.PackageBase", Type["spack.package_base.PackageBase"]]
-
-
 class Patch:
     """Base class for patches.
 
@@ -80,7 +77,7 @@ class Patch:
 
     def __init__(
         self,
-        pkg: PatchPackageType,
+        pkg: "spack.package_base.PackageBase",
         path_or_url: str,
         level: int,
         working_dir: str,
@@ -162,7 +159,7 @@ class FilePatch(Patch):
 
     def __init__(
         self,
-        pkg: PatchPackageType,
+        pkg: "spack.package_base.PackageBase",
         relative_path: str,
         level: int,
         working_dir: str,
@@ -186,7 +183,7 @@ def __init__(
         abs_path: Optional[str] = None
         # At different times we call FilePatch on instances and classes
         pkg_cls = pkg if inspect.isclass(pkg) else pkg.__class__
-        for cls in inspect.getmro(pkg_cls):  # type: ignore
+        for cls in inspect.getmro(pkg_cls):
             if not hasattr(cls, "module"):
                 # We've gone too far up the MRO
                 break
@@ -245,7 +242,7 @@ class UrlPatch(Patch):
 
     def __init__(
         self,
-        pkg: PatchPackageType,
+        pkg: "spack.package_base.PackageBase",
         url: str,
         level: int = 1,
         *,
@@ -364,9 +361,8 @@ def from_dict(
     """
     repository = repository or spack.repo.PATH
     owner = dictionary.get("owner")
-    if owner is None:
-        raise ValueError(f"Invalid patch dictionary: {dictionary}")
-    assert isinstance(owner, str)
+    if "owner" not in dictionary:
+        raise ValueError("Invalid patch dictionary: %s" % dictionary)
     pkg_cls = repository.get_pkg_class(owner)
 
     if "url" in dictionary:

lib/spack/spack/platforms/__init__.py

@@ -6,6 +6,7 @@
 
 from ._functions import _host, by_name, platforms, prevent_cray_detection, reset
 from ._platform import Platform
+from .cray import Cray
 from .darwin import Darwin
 from .freebsd import FreeBSD
 from .linux import Linux
@@ -14,6 +15,7 @@
 
 __all__ = [
     "Platform",
+    "Cray",
     "Darwin",
     "Linux",
     "FreeBSD",