containers: update docs from centos:7 to almalinux:9

.github/dependabot.yml

@@ -5,10 +5,13 @@ updates:
     directory: "/"
     schedule:
       interval: "daily"
-  # Requirements to run style checks and build documentation
+  # Requirements to build documentation
   - package-ecosystem: "pip"
-    directories:
-     - "/.github/workflows/requirements/style/*"
-     - "/lib/spack/docs"
+    directory: "/lib/spack/docs"
+    schedule:
+      interval: "daily"
+  # Requirements to run style checks
+  - package-ecosystem: "pip"
+    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@a5ac7e51b41094c92402da3b24376905380afc29
+    - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
       with:
         python-version: ${{inputs.python_version}}
     - name: Install Python packages
@@ -44,7 +44,6 @@ jobs:
       run: |
           . share/spack/setup-env.sh
           coverage run $(which spack) audit packages
-          coverage run $(which spack) audit configs
           coverage run $(which spack) -d audit externals
           coverage combine
           coverage xml
@@ -53,7 +52,6 @@ jobs:
       run: |
           . share/spack/setup-env.sh          
           spack -d audit packages
-          spack -d audit configs
           spack -d audit externals
     - name: Package audits (without coverage)
       if: ${{ runner.os == 'Windows' }}
@@ -61,8 +59,6 @@ jobs:
           . share/spack/setup-env.sh          
           spack -d audit packages
           ./share/spack/qa/validate_last_exit.ps1
-          spack -d audit configs
-          ./share/spack/qa/validate_last_exit.ps1
           spack -d audit externals
           ./share/spack/qa/validate_last_exit.ps1
     - uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673

.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@a5ac7e51b41094c92402da3b24376905380afc29
         with:
           fetch-depth: 0
       - name: Bootstrap clingo
@@ -60,10 +60,10 @@ jobs:
         run: |
           brew install cmake bison tree
       - name: Checkout
-        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.12"
       - name: Bootstrap clingo
@@ -71,14 +71,12 @@ jobs:
           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 }}
           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/
 
   gnupg-sources:
@@ -96,7 +94,7 @@ jobs:
         if: ${{ matrix.runner == 'ubuntu-latest' }}
         run: sudo rm -rf $(command -v gpg gpg2 patchelf)
       - name: Checkout
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+        uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29
         with:
           fetch-depth: 0
       - name: Bootstrap GnuPG
@@ -125,10 +123,10 @@ jobs:
         run: |
           sudo rm -rf $(which gpg) $(which gpg2) $(which patchelf)
       - name: Checkout
-        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.8
@@ -154,7 +152,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 +166,4 @@ jobs:
           source share/spack/setup-env.sh
           spack -d gpg list
           tree ~/.spack/bootstrap/store/
+

.github/workflows/build-containers.yml

@@ -55,7 +55,7 @@ jobs:
     if: github.repository == 'spack/spack'
     steps:
       - name: Checkout
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+        uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29
 
       - uses: docker/metadata-action@8e5442c4ef9f78752691e2d8f8d19755c6f78e81
         id: docker_meta
@@ -76,7 +76,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 +87,19 @@ jobs:
           fi
 
       - name: Upload Dockerfile
-        uses: actions/upload-artifact@834a144ee995460fba8ed112a2fc961b36a5ec5a
+        uses: actions/upload-artifact@65462800fd760344b1a7b4382951275a0abb4808
         with:
           name: dockerfiles_${{ matrix.dockerfile[0] }}
           path: dockerfiles
 
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@49b3bc8e6bdd4a60e6116a5414239cba5943d3cf
+        uses: docker/setup-qemu-action@5927c834f5b4fdf503fca6f4c7eccda82949e1ee
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@988b5a0280414f521da01fcc63a27aeeb4b104db
+        uses: docker/setup-buildx-action@4fd812986e6c8c2a69e18311145f9371337f27d4
 
       - name: Log in to GitHub Container Registry
-        uses: docker/login-action@9780b0c442fbb1117ed29e0efdff1e18412f7567
+        uses: docker/login-action@e92390c5fb421da1463c202d546fed0ec5c39f20
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
@@ -107,13 +107,13 @@ jobs:
 
       - name: Log in to DockerHub
         if: github.event_name != 'pull_request'
-        uses: docker/login-action@9780b0c442fbb1117ed29e0efdff1e18412f7567
+        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@16ebe778df0e7752d2cfcbd924afdbbd89c1a755
+        uses: docker/build-push-action@1a162644f9a7e87d8f4b053101d1d9a712edc18c
         with:
           context: dockerfiles/${{ matrix.dockerfile[0] }}
           platforms: ${{ matrix.dockerfile[1] }}
@@ -126,7 +126,7 @@ jobs:
     needs: deploy-images
     steps:
       - name: Merge Artifacts
-        uses: actions/upload-artifact/merge@834a144ee995460fba8ed112a2fc961b36a5ec5a
+        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@a5ac7e51b41094c92402da3b24376905380afc29
         if: ${{ github.event_name == 'push' }}
         with:
           fetch-depth: 0

.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@a5ac7e51b41094c92402da3b24376905380afc29
       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,6 +1,6 @@
-black==24.8.0
+black==24.4.2
 clingo==5.7.1
-flake8==7.1.1
+flake8==7.1.0
 isort==5.13.2
 mypy==1.8.0
 types-six==1.16.21.20240513

.github/workflows/unit_tests.yaml

@@ -51,10 +51,10 @@ jobs:
           on_develop: false
 
     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: ${{ 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:
@@ -100,10 +100,10 @@ jobs:
   shell:
     runs-on: ubuntu-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.11'
     - name: Install System packages
@@ -118,7 +118,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: Run shell tests
       env:
           COVERAGE: true
@@ -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@a5ac7e51b41094c92402da3b24376905380afc29
     - 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@a5ac7e51b41094c92402da3b24376905380afc29
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@39cd14951b08e74b54015e9e001cdefcf80e669f
+    - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
       with:
         python-version: '3.11'
     - name: Install System packages
@@ -178,7 +178,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: Run unit tests (full suite with coverage)
       env:
           COVERAGE: true
@@ -198,10 +198,10 @@ jobs:
         os: [macos-13, macos-14]
         python-version: ["3.11"]
     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: ${{ matrix.python-version }}
     - name: Install Python packages
@@ -217,7 +217,7 @@ 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
@@ -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,7 +247,7 @@ 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

.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@a5ac7e51b41094c92402da3b24376905380afc29
+    - 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@a5ac7e51b41094c92402da3b24376905380afc29
       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@a5ac7e51b41094c92402da3b24376905380afc29
       - 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

etc/spack/defaults/linux/packages.yaml

@@ -0,0 +1,3 @@
+packages:
+  iconv:
+    require: [libiconv]

etc/spack/defaults/packages.yaml

@@ -20,7 +20,6 @@ packages:
       awk: [gawk]
       armci: [armcimpi]
       blas: [openblas, amdblis]
-      cxx: [gcc]
       D: [ldc]
       daal: [intel-oneapi-daal]
       elf: [elfutils]
@@ -62,7 +61,6 @@ packages:
       tbb: [intel-tbb]
       unwind: [libunwind]
       uuid: [util-linux-uuid, libuuid]
-      wasi-sdk: [wasi-sdk-prebuilt]
       xxd: [xxd-standalone, vim]
       yacc: [bison, byacc]
       ziglang: [zig]

lib/spack/docs/containers.rst

@@ -270,7 +270,7 @@ under the ``container`` attribute of environments:
        # Sets the base images for the stages where Spack builds the
        # software or where the software gets installed after being built..
        images:
-         os: "centos:7"
+         os: "almalinux:9"
          spack: develop
 
        # Whether or not to strip binaries
@@ -321,32 +321,33 @@ following ``spack.yaml``:
 
      container:
        images:
-         os: centos:7
-         spack: 0.15.4
+         os: almalinux:9
+         spack: 0.22.0
 
-uses ``spack/centos7:0.15.4``  and ``centos:7`` for the stages where the
+uses ``spack/almalinux9:0.22.0``  and ``almalinux:9`` for the stages where the
 software is respectively built and installed:
 
 .. code-block:: docker
 
    # Build stage with Spack pre-installed and ready to be used
-   FROM spack/centos7:0.15.4 as builder
+   FROM spack/almalinux9:0.22.0 AS builder
 
    # What we want to install and how we want to install it
    # is specified in a manifest file (spack.yaml)
-   RUN mkdir /opt/spack-environment \
-   &&  (echo "spack:" \
-   &&   echo "  specs:" \
-   &&   echo "  - gromacs+mpi" \
-   &&   echo "  - mpich" \
-   &&   echo "  concretizer:" \
-   &&   echo "    unify: true" \
-   &&   echo "  config:" \
-   &&   echo "    install_tree: /opt/software" \
-   &&   echo "  view: /opt/view") > /opt/spack-environment/spack.yaml
+   RUN mkdir -p /opt/spack-environment && \
+   set -o noclobber \
+   &&  (echo spack: \
+   &&   echo '  specs:' \
+   &&   echo '  - gromacs+mpi' \
+   &&   echo '  - mpich' \
+   &&   echo '  concretizer:' \
+   &&   echo '    unify: true' \
+   &&   echo '  config:' \
+   &&   echo '    install_tree: /opt/software' \
+   &&   echo '  view: /opt/views/view') > /opt/spack-environment/spack.yaml
    [ ... ]
    # Bare OS image to run the installed executables
-   FROM centos:7
+   FROM quay.io/almalinuxorg/almalinux:9
 
    COPY --from=builder /opt/spack-environment /opt/spack-environment
    COPY --from=builder /opt/software /opt/software

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/requirements.txt

@@ -1,13 +1,13 @@
-sphinx==7.4.7
+sphinx==7.2.6
 sphinxcontrib-programoutput==0.17
-sphinx_design==0.6.1
+sphinx_design==0.6.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.3.2
+pytest==8.2.2
 isort==5.13.2
-black==24.8.0
-flake8==7.1.1
-mypy==1.11.1
+black==24.4.2
+flake8==7.1.0
+mypy==1.10.1

lib/spack/env/cc

@@ -174,46 +174,6 @@ preextend() {
     unset IFS
 }
 
-execute() {
-    # dump the full command if the caller supplies SPACK_TEST_COMMAND=dump-args
-    if [ -n "${SPACK_TEST_COMMAND=}" ]; then
-        case "$SPACK_TEST_COMMAND" in
-            dump-args)
-                IFS="$lsep"
-                for arg in $full_command_list; do
-                    echo "$arg"
-                done
-                unset IFS
-                exit
-                ;;
-            dump-env-*)
-                var=${SPACK_TEST_COMMAND#dump-env-}
-                eval "printf '%s\n' \"\$0: \$var: \$$var\""
-                ;;
-            *)
-                die "Unknown test command: '$SPACK_TEST_COMMAND'"
-                ;;
-        esac
-    fi
-
-    #
-    # Write the input and output commands to debug logs if it's asked for.
-    #
-    if [ "$SPACK_DEBUG" = TRUE ]; then
-        input_log="$SPACK_DEBUG_LOG_DIR/spack-cc-$SPACK_DEBUG_LOG_ID.in.log"
-        output_log="$SPACK_DEBUG_LOG_DIR/spack-cc-$SPACK_DEBUG_LOG_ID.out.log"
-        echo "[$mode] $command $input_command" >> "$input_log"
-        IFS="$lsep"
-        echo "[$mode] "$full_command_list >> "$output_log"
-        unset IFS
-    fi
-
-    # Execute the full command, preserving spaces with IFS set
-    # to the alarm bell separator.
-    IFS="$lsep"; exec $full_command_list
-    exit
-}
-
 # Fail with a clear message if the input contains any bell characters.
 if eval "[ \"\${*#*${lsep}}\" != \"\$*\" ]"; then
     die "Compiler command line contains our separator ('${lsep}'). Cannot parse."
@@ -271,17 +231,12 @@ fi
 #    ld      link
 #    ccld    compile & link
 
-# Note. SPACK_ALWAYS_XFLAGS are applied for all compiler invocations,
-# including version checks (SPACK_XFLAGS variants are not applied
-# for version checks).
 command="${0##*/}"
 comp="CC"
-vcheck_flags=""
 case "$command" in
     cpp)
         mode=cpp
         debug_flags="-g"
-        vcheck_flags="${SPACK_ALWAYS_CPPFLAGS}"
         ;;
     cc|c89|c99|gcc|clang|armclang|icc|icx|pgcc|nvc|xlc|xlc_r|fcc|amdclang|cl.exe|craycc)
         command="$SPACK_CC"
@@ -289,7 +244,6 @@ case "$command" in
         comp="CC"
         lang_flags=C
         debug_flags="-g"
-        vcheck_flags="${SPACK_ALWAYS_CFLAGS}"
         ;;
     c++|CC|g++|clang++|armclang++|icpc|icpx|pgc++|nvc++|xlc++|xlc++_r|FCC|amdclang++|crayCC)
         command="$SPACK_CXX"
@@ -297,7 +251,6 @@ case "$command" in
         comp="CXX"
         lang_flags=CXX
         debug_flags="-g"
-        vcheck_flags="${SPACK_ALWAYS_CXXFLAGS}"
         ;;
     ftn|f90|fc|f95|gfortran|flang|armflang|ifort|ifx|pgfortran|nvfortran|xlf90|xlf90_r|nagfor|frt|amdflang|crayftn)
         command="$SPACK_FC"
@@ -305,7 +258,6 @@ case "$command" in
         comp="FC"
         lang_flags=F
         debug_flags="-g"
-        vcheck_flags="${SPACK_ALWAYS_FFLAGS}"
         ;;
     f77|xlf|xlf_r|pgf77)
         command="$SPACK_F77"
@@ -313,7 +265,6 @@ case "$command" in
         comp="F77"
         lang_flags=F
         debug_flags="-g"
-        vcheck_flags="${SPACK_ALWAYS_FFLAGS}"
         ;;
     ld|ld.gold|ld.lld)
         mode=ld
@@ -414,11 +365,7 @@ unset IFS
 export PATH="$new_dirs"
 
 if [ "$mode" = vcheck ]; then
-    full_command_list="$command"
-    args="$@"
-    extend full_command_list vcheck_flags
-    extend full_command_list args
-    execute
+    exec "${command}" "$@"
 fi
 
 # Darwin's linker has a -r argument that merges object files together.
@@ -775,7 +722,6 @@ case "$mode" in
     cc|ccld)
         case $lang_flags in
             F)
-                extend spack_flags_list SPACK_ALWAYS_FFLAGS
                 extend spack_flags_list SPACK_FFLAGS
                 ;;
         esac
@@ -785,7 +731,6 @@ esac
 # C preprocessor flags come before any C/CXX flags
 case "$mode" in
     cpp|as|cc|ccld)
-        extend spack_flags_list SPACK_ALWAYS_CPPFLAGS
         extend spack_flags_list SPACK_CPPFLAGS
         ;;
 esac
@@ -796,11 +741,9 @@ case "$mode" in
     cc|ccld)
         case $lang_flags in
             C)
-                extend spack_flags_list SPACK_ALWAYS_CFLAGS
                 extend spack_flags_list SPACK_CFLAGS
                 ;;
             CXX)
-                extend spack_flags_list SPACK_ALWAYS_CXXFLAGS
                 extend spack_flags_list SPACK_CXXFLAGS
                 ;;
         esac
@@ -990,4 +933,39 @@ if [ -n "$SPACK_CCACHE_BINARY" ]; then
     esac
 fi
 
-execute
+# dump the full command if the caller supplies SPACK_TEST_COMMAND=dump-args
+if [ -n "${SPACK_TEST_COMMAND=}" ]; then
+    case "$SPACK_TEST_COMMAND" in
+        dump-args)
+            IFS="$lsep"
+            for arg in $full_command_list; do
+                echo "$arg"
+            done
+            unset IFS
+            exit
+            ;;
+        dump-env-*)
+            var=${SPACK_TEST_COMMAND#dump-env-}
+            eval "printf '%s\n' \"\$0: \$var: \$$var\""
+            ;;
+        *)
+            die "Unknown test command: '$SPACK_TEST_COMMAND'"
+            ;;
+    esac
+fi
+
+#
+# Write the input and output commands to debug logs if it's asked for.
+#
+if [ "$SPACK_DEBUG" = TRUE ]; then
+    input_log="$SPACK_DEBUG_LOG_DIR/spack-cc-$SPACK_DEBUG_LOG_ID.in.log"
+    output_log="$SPACK_DEBUG_LOG_DIR/spack-cc-$SPACK_DEBUG_LOG_ID.out.log"
+    echo "[$mode] $command $input_command" >> "$input_log"
+    IFS="$lsep"
+    echo "[$mode] "$full_command_list >> "$output_log"
+    unset IFS
+fi
+
+# Execute the full command, preserving spaces with IFS set
+# to the alarm bell separator.
+IFS="$lsep"; exec $full_command_list

lib/spack/spack/audit.py

@@ -351,22 +351,6 @@ def _wrongly_named_spec(error_cls):
     return errors
 
 
-@config_packages
-def _ensure_all_virtual_packages_have_default_providers(error_cls):
-    """All virtual packages must have a default provider explicitly set."""
-    configuration = spack.config.create()
-    defaults = configuration.get("packages", scope="defaults")
-    default_providers = defaults["all"]["providers"]
-    virtuals = spack.repo.PATH.provider_index.providers
-    default_providers_filename = configuration.scopes["defaults"].get_section_filename("packages")
-
-    return [
-        error_cls(f"'{virtual}' must have a default provider in {default_providers_filename}", [])
-        for virtual in virtuals
-        if virtual not in default_providers
-    ]
-
-
 def _make_config_error(config_data, summary, error_cls):
     s = io.StringIO()
     s.write("Occurring in the following file:\n")

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

@@ -1473,7 +1473,7 @@ def long_message(self):
             out.write("  {0}\n".format(self.log_name))
 
         # Also output the test log path IF it exists
-        if self.context != "test" and have_log:
+        if self.context != "test":
             test_log = join_path(os.path.dirname(self.log_name), spack_install_test_log)
             if os.path.isfile(test_log):
                 out.write("\nSee test log for details:\n")

lib/spack/spack/build_systems/cuda.py

@@ -124,8 +124,6 @@ def cuda_flags(arch_list):
         # minimum supported versions
         conflicts("%gcc@:4", when="+cuda ^cuda@11.0:")
         conflicts("%gcc@:5", when="+cuda ^cuda@11.4:")
-        conflicts("%gcc@:7.2", when="+cuda ^cuda@12.4:")
-        conflicts("%clang@:6", when="+cuda ^cuda@12.2:")
 
         # maximum supported version
         # NOTE:
@@ -213,16 +211,12 @@ def cuda_flags(arch_list):
         conflicts("%intel@19.0:", when="+cuda ^cuda@:10.0")
         conflicts("%intel@19.1:", when="+cuda ^cuda@:10.1")
         conflicts("%intel@19.2:", when="+cuda ^cuda@:11.1.0")
-        conflicts("%intel@2021:", when="+cuda ^cuda@:11.4.0")
 
         # XL is mostly relevant for ppc64le Linux
         conflicts("%xl@:12,14:", when="+cuda ^cuda@:9.1")
         conflicts("%xl@:12,14:15,17:", when="+cuda ^cuda@9.2")
         conflicts("%xl@:12,17:", when="+cuda ^cuda@:11.1.0")
 
-        # PowerPC.
-        conflicts("target=ppc64le", when="+cuda ^cuda@12.5:")
-
         # Darwin.
         # TODO: add missing conflicts for %apple-clang cuda@:10
-        conflicts("platform=darwin", when="+cuda ^cuda@11.0.2:")
+        conflicts("platform=darwin", when="+cuda ^cuda@11.0.2: ")

lib/spack/spack/build_systems/go.py

@@ -72,7 +72,7 @@ def build_directory(self):
     def build_args(self):
         """Arguments for ``go build``."""
         # Pass ldflags -s = --strip-all and -w = --no-warnings by default
-        return ["-modcacherw", "-ldflags", "-s -w", "-o", f"{self.pkg.name}"]
+        return ["-ldflags", "-s -w", "-o", f"{self.pkg.name}"]
 
     @property
     def check_args(self):

lib/spack/spack/build_systems/python.py

@@ -354,18 +354,10 @@ def homepage(cls) -> Optional[str]:  # type: ignore[override]
         return None
 
     @lang.classproperty
-    def urls(cls) -> Optional[List[str]]:
+    def url(cls) -> Optional[str]:
         if cls.pypi:
-            urls = [f"https://files.pythonhosted.org/packages/source/{cls.pypi[0]}/{cls.pypi}"]
-            assert cls.pypi.count("/") == 1, "PyPI class attribute must include a single slash"
-            name, file = cls.pypi.split("/")
-            name_dash_count = name.count("-")
-            if name_dash_count > 0:
-                # replace all but last dash with underscores for pypi.org listing changes
-                pypi = "/".join([name, file.replace("-", "_", name_dash_count)])
-                urls.append(f"https://files.pythonhosted.org/packages/source/{pypi[0]}/{pypi}")
-            return urls
-        return [None]
+            return f"https://files.pythonhosted.org/packages/source/{cls.pypi[0]}/{cls.pypi}"
+        return None
 
     @lang.classproperty
     def list_url(cls) -> Optional[str]:  # type: ignore[override]

lib/spack/spack/build_systems/sip.py

@@ -139,10 +139,6 @@ def configure(self, pkg, spec, prefix):
         args = ["--verbose", "--target-dir", inspect.getmodule(self.pkg).python_platlib]
         args.extend(self.configure_args())
 
-        # https://github.com/Python-SIP/sip/commit/cb0be6cb6e9b756b8b0db3136efb014f6fb9b766
-        if spec["py-sip"].satisfies("@6.1.0:"):
-            args.extend(["--scripts-dir", pkg.prefix.bin])
-
         sip_build = Executable(spec["py-sip"].prefix.bin.join("sip-build"))
         sip_build(*args)
 

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

@@ -71,7 +71,7 @@
 # TODO: Remove this in Spack 0.23
 SHARED_PR_MIRROR_URL = "s3://spack-binaries-prs/shared_pr_mirror"
 JOB_NAME_FORMAT = (
-    "{name}{@version} {/hash:7} {%compiler.name}{@compiler.version}{ arch=architecture}"
+    "{name}{@version} {/hash:7} {%compiler.name}{@compiler.version}{arch=architecture}"
 )
 IS_WINDOWS = sys.platform == "win32"
 spack_gpg = spack.main.SpackCommand("gpg")
@@ -809,8 +809,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)
         ]

lib/spack/spack/cmd/__init__.py

@@ -237,7 +237,7 @@ def ensure_single_spec_or_die(spec, matching_specs):
     if len(matching_specs) <= 1:
         return
 
-    format_string = "{name}{@version}{%compiler.name}{@compiler.version}{ arch=architecture}"
+    format_string = "{name}{@version}{%compiler.name}{@compiler.version}{arch=architecture}"
     args = ["%s matches multiple packages." % spec, "Matching packages:"]
     args += [
         colorize("  @K{%s} " % s.dag_hash(7)) + s.cformat(format_string) for s in matching_specs
@@ -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 * "    "

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.
@@ -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/commands.py

@@ -11,6 +11,7 @@
 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
@@ -866,6 +867,9 @@ 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/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/dependents.py

@@ -47,6 +47,16 @@ def inverted_dependencies():
     dependents of, e.g., `mpi`, but virtuals are not included as
     actual dependents.
     """
+    dag = {}
+    for pkg_cls in spack.repo.PATH.all_package_classes():
+        dag.setdefault(pkg_cls.name, set())
+        for dep in pkg_cls.dependencies_by_name():
+            deps = [dep]
+
+            # expand virtuals if necessary
+            if spack.repo.PATH.is_virtual(dep):
+                deps += [s.name for s in spack.repo.PATH.providers_for(dep)]
+
     dag = collections.defaultdict(set)
     for pkg_cls in spack.repo.PATH.all_package_classes():
         for _, deps_by_name in pkg_cls.dependencies.items():

lib/spack/spack/cmd/edit.py

@@ -123,7 +123,7 @@ def edit(parser, args):
         spack.util.editor.editor(*paths)
     elif names:
         if args.repo:
-            repo = spack.repo.from_path(args.repo)
+            repo = spack.repo.Repo(args.repo)
         elif args.namespace:
             repo = spack.repo.PATH.get_repo(args.namespace)
         else:

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/pkg.py

@@ -169,9 +169,7 @@ def pkg_hash(args):
 
 def get_grep(required=False):
     """Get a grep command to use with ``spack pkg grep``."""
-    grep = exe.which(os.environ.get("SPACK_GREP") or "grep", required=required)
-    grep.ignore_quotes = True  # allow `spack pkg grep '"quoted string"'` without warning
-    return grep
+    return exe.which(os.environ.get("SPACK_GREP") or "grep", required=required)
 
 
 def pkg_grep(args, unknown_args):

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/url.py

@@ -339,7 +339,7 @@ def add(self, pkg_name, fetcher):
     for pkg_cls in spack.repo.PATH.all_package_classes():
         npkgs += 1
 
-        for v in list(pkg_cls.versions):
+        for v in pkg_cls.versions:
             try:
                 pkg = pkg_cls(spack.spec.Spec(pkg_cls.name))
                 fetcher = fs.for_package_version(pkg, v)

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
@@ -278,6 +279,11 @@ def debug_flags(self):
     def opt_flags(self):
         return ["-O", "-O0", "-O1", "-O2", "-O3"]
 
+    # Cray PrgEnv name that can be used to load this compiler
+    PrgEnv: Optional[str] = None
+    # Name of module used to switch versions of this compiler
+    PrgEnv_compiler: Optional[str] = None
+
     def __init__(
         self,
         cspec,

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/aocc.py

@@ -25,6 +25,9 @@ class Aocc(Compiler):
     # Subclasses use possible names of Fortran 90 compiler
     fc_names = ["flang"]
 
+    PrgEnv = "PrgEnv-aocc"
+    PrgEnv_compiler = "aocc"
+
     version_argument = "--version"
 
     @property

lib/spack/spack/compilers/cce.py

@@ -34,9 +34,12 @@ def __init__(self, *args, **kwargs):
     # MacPorts builds gcc versions with prefixes and -mp-X.Y suffixes.
     suffixes = [r"-mp-\d\.\d"]
 
+    PrgEnv = "PrgEnv-cray"
+    PrgEnv_compiler = "cce"
+
     @property
     def link_paths(self):
-        if any("PrgEnv-cray" in m for m in self.modules):
+        if any(self.PrgEnv in m for m in self.modules):
             # Old module-based interface to cray compilers
             return {
                 "cc": os.path.join("cce", "cc"),

lib/spack/spack/compilers/gcc.py

@@ -40,6 +40,9 @@ class Gcc(spack.compiler.Compiler):
         "fc": os.path.join("gcc", "gfortran"),
     }
 
+    PrgEnv = "PrgEnv-gnu"
+    PrgEnv_compiler = "gcc"
+
     @property
     def verbose_flag(self):
         return "-v"

lib/spack/spack/compilers/intel.py

@@ -31,6 +31,9 @@ class Intel(Compiler):
         "fc": os.path.join("intel", "ifort"),
     }
 
+    PrgEnv = "PrgEnv-intel"
+    PrgEnv_compiler = "intel"
+
     if sys.platform == "win32":
         version_argument = "/QV"
     else:
@@ -123,14 +126,3 @@ def fc_pic_flag(self):
     @property
     def stdcxx_libs(self):
         return ("-cxxlib",)
-
-    def setup_custom_environment(self, pkg, env):
-        # Edge cases for Intel's oneAPI compilers when using the legacy classic compilers:
-        # Always pass flags to disable deprecation warnings, since these warnings can
-        # confuse tools that parse the output of compiler commands (e.g. version checks).
-        if self.cc and self.cc.endswith("icc") and self.real_version >= Version("2021"):
-            env.append_flags("SPACK_ALWAYS_CFLAGS", "-diag-disable=10441")
-        if self.cxx and self.cxx.endswith("icpc") and self.real_version >= Version("2021"):
-            env.append_flags("SPACK_ALWAYS_CXXFLAGS", "-diag-disable=10441")
-        if self.fc and self.fc.endswith("ifort") and self.real_version >= Version("2021"):
-            env.append_flags("SPACK_ALWAYS_FFLAGS", "-diag-disable=10448")

lib/spack/spack/compilers/msvc.py

@@ -231,55 +231,24 @@ def msvc_version(self):
 
     @property
     def short_msvc_version(self):
-        """This is the shorthand VCToolset version of form
-        MSVC<short-ver>
         """
-        return "MSVC" + self.vc_toolset_ver
-
-    @property
-    def vc_toolset_ver(self):
-        """
-        The toolset version is the version of the combined set of cl and link
-        This typically relates directly to VS version i.e. VS 2022 is v143
-        VS 19 is v142, etc.
-        This value is defined by the first three digits of the major + minor
-        version of the VS toolset (143 for 14.3x.bbbbb). Traditionally the
-        minor version has remained a static two digit number for a VS release
-        series, however, as of VS22, this is no longer true, both
-        14.4x.bbbbb and 14.3x.bbbbb are considered valid VS22 VC toolset
-        versions due to a change in toolset minor version sentiment.
-
-        This is *NOT* the full version, for that see
+        This is the shorthand VCToolset version of form
+        MSVC<short-ver> *NOT* the full version, for that see
         Msvc.msvc_version or MSVC.platform_toolset_ver for the
         raw platform toolset version
-
         """
-        ver = self.msvc_version[:2].joined.string[:3]
-        return ver
+        ver = self.platform_toolset_ver
+        return "MSVC" + ver
 
     @property
     def platform_toolset_ver(self):
         """
         This is the platform toolset version of current MSVC compiler
-        i.e. 142. The platform toolset is the targeted MSVC library/compiler
-        versions by compilation (this is different from the VC Toolset)
-
-
+        i.e. 142.
         This is different from the VC toolset version as established
-        by `short_msvc_version`, but typically are represented by the same
-        three digit value
+        by `short_msvc_version`
         """
-        # Typically VS toolset version and platform toolset versions match
-        # VS22 introduces the first divergence of VS toolset version
-        # (144 for "recent" releases) and platform toolset version (143)
-        # so it needs additional handling until MS releases v144
-        # (assuming v144 is also for VS22)
-        # or adds better support for detection
-        # TODO: (johnwparent) Update this logic for the next platform toolset
-        # or VC toolset version update
-        toolset_ver = self.vc_toolset_ver
-        vs22_toolset = Version(toolset_ver) > Version("142")
-        return toolset_ver if not vs22_toolset else "143"
+        return self.msvc_version[:2].joined.string[:3]
 
     def _compiler_version(self, compiler):
         """Returns version object for given compiler"""

lib/spack/spack/compilers/nvhpc.py

@@ -29,6 +29,9 @@ class Nvhpc(Compiler):
         "fc": os.path.join("nvhpc", "nvfortran"),
     }
 
+    PrgEnv = "PrgEnv-nvhpc"
+    PrgEnv_compiler = "nvhpc"
+
     version_argument = "--version"
     version_regex = r"nv[^ ]* (?:[^ ]+ Dev-r)?([0-9.]+)(?:-[0-9]+)?"
 

lib/spack/spack/compilers/oneapi.py

@@ -4,12 +4,11 @@
 # 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
 
 from spack.compiler import Compiler
-from spack.version import Version
 
 
 class Oneapi(Compiler):
@@ -33,6 +32,9 @@ class Oneapi(Compiler):
         "fc": os.path.join("oneapi", "ifx"),
     }
 
+    PrgEnv = "PrgEnv-oneapi"
+    PrgEnv_compiler = "oneapi"
+
     version_argument = "--version"
     version_regex = r"(?:(?:oneAPI DPC\+\+(?:\/C\+\+)? Compiler)|(?:\(IFORT\))|(?:\(IFX\))) (\S+)"
 
@@ -133,22 +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"))
-
-        # Edge cases for Intel's oneAPI compilers when using the legacy classic compilers:
-        # Always pass flags to disable deprecation warnings, since these warnings can
-        # confuse tools that parse the output of compiler commands (e.g. version checks).
-        if self.cc and self.cc.endswith("icc") and self.real_version >= Version("2021"):
-            env.append_flags("SPACK_ALWAYS_CFLAGS", "-diag-disable=10441")
-        if self.cxx and self.cxx.endswith("icpc") and self.real_version >= Version("2021"):
-            env.append_flags("SPACK_ALWAYS_CXXFLAGS", "-diag-disable=10441")
-        if self.fc and self.fc.endswith("ifort") and self.real_version >= Version("2021"):
-            env.append_flags("SPACK_ALWAYS_FFLAGS", "-diag-disable=10448")
 
         # 2024 release bumped the libsycl version because of an ABI
         # change, 2024 compilers are required.  You will see this

lib/spack/spack/compilers/pgi.py

@@ -30,6 +30,9 @@ class Pgi(Compiler):
         "fc": os.path.join("pgi", "pgfortran"),
     }
 
+    PrgEnv = "PrgEnv-pgi"
+    PrgEnv_compiler = "pgi"
+
     version_argument = "-V"
     ignore_version_errors = [2]  # `pgcc -V` on PowerPC annoyingly returns 2
     version_regex = r"pg[^ ]* ([0-9.]+)-[0-9]+ (LLVM )?[^ ]+ target on "

lib/spack/spack/compilers/rocmcc.py

@@ -23,6 +23,9 @@ class Rocmcc(spack.compilers.clang.Clang):
     # Subclasses use possible names of Fortran 90 compiler
     fc_names = ["amdflang"]
 
+    PrgEnv = "PrgEnv-amd"
+    PrgEnv_compiler = "amd"
+
     @property
     def link_paths(self):
         link_paths = {

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/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

@@ -81,17 +81,7 @@ class OpenMpi(Package):
 ]
 
 #: These are variant names used by Spack internally; packages can't use them
-reserved_names = [
-    "arch",
-    "architecture",
-    "dev_path",
-    "namespace",
-    "operating_system",
-    "os",
-    "patches",
-    "platform",
-    "target",
-]
+reserved_names = ["patches", "dev_path"]
 
 #: Names of possible directives. This list is mostly populated using the @directive decorator.
 #: Some directives leverage others and in that case are not automatically added.
@@ -100,14 +90,14 @@ 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]
 PatchesType = Optional[Union[Patcher, str, List[Union[Patcher, str]]]]
 
 
-SUPPORTED_LANGUAGES = ("fortran", "cxx", "c")
+SUPPORTED_LANGUAGES = ("fortran", "cxx")
 
 
 def _make_when_spec(value: WhenType) -> Optional["spack.spec.Spec"]:
@@ -485,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,
@@ -495,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)
 
@@ -514,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
@@ -529,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
@@ -600,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
 
@@ -676,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,7 +5,7 @@
 import collections
 import collections.abc
 import contextlib
-import errno
+import copy
 import os
 import pathlib
 import re
@@ -24,7 +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
@@ -269,7 +268,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):
@@ -528,8 +529,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):
@@ -789,23 +790,6 @@ def regenerate(self, concrete_roots: List[Spec]) -> None:
         root_dirname = os.path.dirname(self.root)
         tmp_symlink_name = os.path.join(root_dirname, "._view_link")
 
-        # Remove self.root if is it an empty dir, since we need a symlink there. Note that rmdir
-        # fails if self.root is a symlink.
-        try:
-            os.rmdir(self.root)
-        except (FileNotFoundError, NotADirectoryError):
-            pass
-        except OSError as e:
-            if e.errno == errno.ENOTEMPTY:
-                msg = "it is a non-empty directory"
-            elif e.errno == errno.EACCES:
-                msg = "of insufficient permissions"
-            else:
-                raise
-            raise SpackEnvironmentViewError(
-                f"The environment view in {self.root} cannot not be created because {msg}."
-            ) from e
-
         # Create a new view
         try:
             fs.mkdirp(new_root)
@@ -937,7 +921,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()
 
@@ -974,25 +958,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.
@@ -2565,7 +2542,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):
@@ -2574,7 +2551,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
@@ -2775,11 +2752,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
@@ -2791,8 +2767,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]:
@@ -2806,7 +2786,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)
 
@@ -2821,6 +2801,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
 
@@ -2835,6 +2816,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"
@@ -2852,6 +2834,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}"
@@ -2864,10 +2847,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
 
@@ -2881,13 +2864,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:
@@ -2901,7 +2885,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"
@@ -2914,6 +2898,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:
@@ -2928,7 +2913,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):
@@ -2939,6 +2924,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):
@@ -2970,6 +2956,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
@@ -2977,13 +2964,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
@@ -2996,12 +2985,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):
@@ -3033,11 +3027,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.
@@ -3100,22 +3095,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))
@@ -3132,10 +3129,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/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,7 +593,7 @@ 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)

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/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
@@ -200,10 +199,10 @@ def __init__(cls, name, bases, attr_dict):
         # assumed to be detectable
         if hasattr(cls, "executables") or hasattr(cls, "libraries"):
             # Append a tag to each detectable package, so that finding them is faster
-            if not hasattr(cls, "tags"):
+            if hasattr(cls, "tags"):
+                getattr(cls, "tags").append(DetectablePackageMeta.TAG)
+            else:
                 setattr(cls, "tags", [DetectablePackageMeta.TAG])
-            elif DetectablePackageMeta.TAG not in cls.tags:
-                cls.tags.append(DetectablePackageMeta.TAG)
 
             @classmethod
             def platform_executables(cls):
@@ -749,6 +748,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
@@ -2384,6 +2388,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
@@ -2426,8 +2434,9 @@ def all_urls(self) -> List[str]:
         if hasattr(self, "url") and self.url:
             urls.append(self.url)
 
+        # fetch from first entry in urls to save time
         if hasattr(self, "urls") and self.urls:
-            urls.extend(self.urls)
+            urls.append(self.urls[0])
 
         for args in self.versions.values():
             if "url" in args:

lib/spack/spack/parser.py

@@ -328,26 +328,19 @@ def next_spec(
         if not self.ctx.next_token:
             return initial_spec
 
-        def add_dependency(dep, **edge_properties):
-            """wrapper around root_spec._add_dependency"""
-            try:
-                root_spec._add_dependency(dep, **edge_properties)
-            except spack.error.SpecError as e:
-                raise SpecParsingError(str(e), self.ctx.current_token, self.literal_str) from e
-
         initial_spec = initial_spec or spack.spec.Spec()
-        root_spec = SpecNodeParser(self.ctx, self.literal_str).parse(initial_spec)
+        root_spec = SpecNodeParser(self.ctx).parse(initial_spec)
         while True:
             if self.ctx.accept(TokenType.START_EDGE_PROPERTIES):
                 edge_properties = EdgeAttributeParser(self.ctx, self.literal_str).parse()
                 edge_properties.setdefault("depflag", 0)
                 edge_properties.setdefault("virtuals", ())
                 dependency = self._parse_node(root_spec)
-                add_dependency(dependency, **edge_properties)
+                root_spec._add_dependency(dependency, **edge_properties)
 
             elif self.ctx.accept(TokenType.DEPENDENCY):
                 dependency = self._parse_node(root_spec)
-                add_dependency(dependency, depflag=0, virtuals=())
+                root_spec._add_dependency(dependency, depflag=0, virtuals=())
 
             else:
                 break
@@ -355,7 +348,7 @@ def add_dependency(dep, **edge_properties):
         return root_spec
 
     def _parse_node(self, root_spec):
-        dependency = SpecNodeParser(self.ctx, self.literal_str).parse()
+        dependency = SpecNodeParser(self.ctx).parse()
         if dependency is None:
             msg = (
                 "the dependency sigil and any optional edge attributes must be followed by a "
@@ -374,11 +367,10 @@ def all_specs(self) -> List["spack.spec.Spec"]:
 class SpecNodeParser:
     """Parse a single spec node from a stream of tokens"""
 
-    __slots__ = "ctx", "has_compiler", "has_version", "literal_str"
+    __slots__ = "ctx", "has_compiler", "has_version"
 
-    def __init__(self, ctx, literal_str):
+    def __init__(self, ctx):
         self.ctx = ctx
-        self.literal_str = literal_str
         self.has_compiler = False
         self.has_version = False
 
@@ -396,8 +388,7 @@ def parse(
         if not self.ctx.next_token or self.ctx.expect(TokenType.DEPENDENCY):
             return initial_spec
 
-        if initial_spec is None:
-            initial_spec = spack.spec.Spec()
+        initial_spec = initial_spec or spack.spec.Spec()
 
         # If we start with a package name we have a named spec, we cannot
         # accept another package name afterwards in a node
@@ -414,21 +405,12 @@ def parse(
         elif self.ctx.accept(TokenType.FILENAME):
             return FileParser(self.ctx).parse(initial_spec)
 
-        def raise_parsing_error(string: str, cause: Optional[Exception] = None):
-            """Raise a spec parsing error with token context."""
-            raise SpecParsingError(string, self.ctx.current_token, self.literal_str) from cause
-
-        def add_flag(name: str, value: str, propagate: bool):
-            """Wrapper around ``Spec._add_flag()`` that adds parser context to errors raised."""
-            try:
-                initial_spec._add_flag(name, value, propagate)
-            except Exception as e:
-                raise_parsing_error(str(e), e)
-
         while True:
             if self.ctx.accept(TokenType.COMPILER):
                 if self.has_compiler:
-                    raise_parsing_error("Spec cannot have multiple compilers")
+                    raise spack.spec.DuplicateCompilerSpecError(
+                        f"{initial_spec} cannot have multiple compilers"
+                    )
 
                 compiler_name = self.ctx.current_token.value[1:]
                 initial_spec.compiler = spack.spec.CompilerSpec(compiler_name.strip(), ":")
@@ -436,7 +418,9 @@ def add_flag(name: str, value: str, propagate: bool):
 
             elif self.ctx.accept(TokenType.COMPILER_AND_VERSION):
                 if self.has_compiler:
-                    raise_parsing_error("Spec cannot have multiple compilers")
+                    raise spack.spec.DuplicateCompilerSpecError(
+                        f"{initial_spec} cannot have multiple compilers"
+                    )
 
                 compiler_name, compiler_version = self.ctx.current_token.value[1:].split("@")
                 initial_spec.compiler = spack.spec.CompilerSpec(
@@ -450,8 +434,9 @@ def add_flag(name: str, value: str, propagate: bool):
                 or self.ctx.accept(TokenType.VERSION)
             ):
                 if self.has_version:
-                    raise_parsing_error("Spec cannot have multiple versions")
-
+                    raise spack.spec.MultipleVersionError(
+                        f"{initial_spec} cannot have multiple versions"
+                    )
                 initial_spec.versions = spack.version.VersionList(
                     [spack.version.from_string(self.ctx.current_token.value[1:])]
                 )
@@ -460,25 +445,29 @@ def add_flag(name: str, value: str, propagate: bool):
 
             elif self.ctx.accept(TokenType.BOOL_VARIANT):
                 variant_value = self.ctx.current_token.value[0] == "+"
-                add_flag(self.ctx.current_token.value[1:].strip(), variant_value, propagate=False)
+                initial_spec._add_flag(
+                    self.ctx.current_token.value[1:].strip(), variant_value, propagate=False
+                )
 
             elif self.ctx.accept(TokenType.PROPAGATED_BOOL_VARIANT):
                 variant_value = self.ctx.current_token.value[0:2] == "++"
-                add_flag(self.ctx.current_token.value[2:].strip(), variant_value, propagate=True)
+                initial_spec._add_flag(
+                    self.ctx.current_token.value[2:].strip(), variant_value, propagate=True
+                )
 
             elif self.ctx.accept(TokenType.KEY_VALUE_PAIR):
                 match = SPLIT_KVP.match(self.ctx.current_token.value)
                 assert match, "SPLIT_KVP and KEY_VALUE_PAIR do not agree."
 
-                name, _, value = match.groups()
-                add_flag(name, strip_quotes_and_unescape(value), propagate=False)
+                name, delim, value = match.groups()
+                initial_spec._add_flag(name, strip_quotes_and_unescape(value), propagate=False)
 
             elif self.ctx.accept(TokenType.PROPAGATED_KEY_VALUE_PAIR):
                 match = SPLIT_KVP.match(self.ctx.current_token.value)
                 assert match, "SPLIT_KVP and PROPAGATED_KEY_VALUE_PAIR do not agree."
 
-                name, _, value = match.groups()
-                add_flag(name, strip_quotes_and_unescape(value), propagate=True)
+                name, delim, value = match.groups()
+                initial_spec._add_flag(name, strip_quotes_and_unescape(value), propagate=True)
 
             elif self.ctx.expect(TokenType.DAG_HASH):
                 if initial_spec.abstract_hash:

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/repo.py

@@ -25,8 +25,7 @@
 import traceback
 import types
 import uuid
-import warnings
-from typing import Any, Dict, Generator, List, Optional, Set, Tuple, Type, Union
+from typing import Any, Dict, List, Set, Tuple, Union
 
 import llnl.path
 import llnl.util.filesystem as fs
@@ -127,35 +126,11 @@ def exec_module(self, module):
 
 
 class ReposFinder:
-    """MetaPathFinder class that loads a Python module corresponding to a Spack package.
+    """MetaPathFinder class that loads a Python module corresponding to a Spack package
 
-    Returns a loader based on the inspection of the current repository list.
+    Return a loader based on the inspection of the current global repository list.
     """
 
-    def __init__(self):
-        self._repo_init = _path
-        self._repo = None
-
-    @property
-    def current_repository(self):
-        if self._repo is None:
-            self._repo = self._repo_init()
-        return self._repo
-
-    @current_repository.setter
-    def current_repository(self, value):
-        self._repo = value
-
-    @contextlib.contextmanager
-    def switch_repo(self, substitute: "RepoType"):
-        """Switch the current repository list for the duration of the context manager."""
-        old = self.current_repository
-        try:
-            self.current_repository = substitute
-            yield
-        finally:
-            self.current_repository = old
-
     def find_spec(self, fullname, python_path, target=None):
         # "target" is not None only when calling importlib.reload()
         if target is not None:
@@ -174,14 +149,9 @@ def compute_loader(self, fullname):
         # namespaces are added to repo, and package modules are leaves.
         namespace, dot, module_name = fullname.rpartition(".")
 
-        # If it's a module in some repo, or if it is the repo's namespace, let the repo handle it.
-        is_repo_path = isinstance(self.current_repository, RepoPath)
-        if is_repo_path:
-            repos = self.current_repository.repos
-        else:
-            repos = [self.current_repository]
-
-        for repo in repos:
+        # If it's a module in some repo, or if it is the repo's
+        # namespace, let the repo handle it.
+        for repo in PATH.repos:
             # We are using the namespace of the repo and the repo contains the package
             if namespace == repo.full_namespace:
                 # With 2 nested conditionals we can call "repo.real_name" only once
@@ -195,7 +165,7 @@ def compute_loader(self, fullname):
 
         # No repo provides the namespace, but it is a valid prefix of
         # something in the RepoPath.
-        if is_repo_path and self.current_repository.by_namespace.is_prefix(fullname):
+        if PATH.by_namespace.is_prefix(fullname):
             return SpackNamespaceLoader()
 
         return None
@@ -590,7 +560,7 @@ def __init__(
         self,
         package_checker: FastPackageChecker,
         namespace: str,
-        cache: "spack.caches.FileCacheType",
+        cache: spack.util.file_cache.FileCache,
     ):
         self.checker = package_checker
         self.packages_path = self.checker.packages_path
@@ -675,39 +645,33 @@ class RepoPath:
     repository.
 
     Args:
-        repos: list Repo objects or paths to put in this RepoPath
-        cache: file cache associated with this repository
-        overrides: dict mapping package name to class attribute overrides for that package
+        repos (list): list Repo objects or paths to put in this RepoPath
     """
 
-    def __init__(
-        self,
-        *repos: Union[str, "Repo"],
-        cache: "spack.caches.FileCacheType",
-        overrides: Optional[Dict[str, Any]] = None,
-    ) -> None:
-        self.repos: List[Repo] = []
+    def __init__(self, *repos, **kwargs):
+        cache = kwargs.get("cache", spack.caches.MISC_CACHE)
+        self.repos = []
         self.by_namespace = nm.NamespaceTrie()
-        self._provider_index: Optional[spack.provider_index.ProviderIndex] = None
-        self._patch_index: Optional[spack.patch.PatchCache] = None
-        self._tag_index: Optional[spack.tag.TagIndex] = None
+
+        self._provider_index = None
+        self._patch_index = None
+        self._tag_index = None
 
         # Add each repo to this path.
         for repo in repos:
             try:
                 if isinstance(repo, str):
-                    repo = Repo(repo, cache=cache, overrides=overrides)
-                repo.finder(self)
+                    repo = Repo(repo, cache=cache)
                 self.put_last(repo)
             except RepoError as e:
                 tty.warn(
-                    f"Failed to initialize repository: '{repo}'.",
+                    "Failed to initialize repository: '%s'." % repo,
                     e.message,
                     "To remove the bad repository, run this command:",
-                    f"    spack repo rm {repo}",
+                    "    spack repo rm %s" % repo,
                 )
 
-    def put_first(self, repo: "Repo") -> None:
+    def put_first(self, repo):
         """Add repo first in the search path."""
         if isinstance(repo, RepoPath):
             for r in reversed(repo.repos):
@@ -735,34 +699,50 @@ def remove(self, repo):
         if repo in self.repos:
             self.repos.remove(repo)
 
-    def get_repo(self, namespace: str) -> "Repo":
-        """Get a repository by namespace."""
+    def get_repo(self, namespace, default=NOT_PROVIDED):
+        """Get a repository by namespace.
+
+        Arguments:
+
+            namespace:
+
+                Look up this namespace in the RepoPath, and return it if found.
+
+        Optional Arguments:
+
+            default:
+
+                If default is provided, return it when the namespace
+                isn't found.  If not, raise an UnknownNamespaceError.
+        """
         full_namespace = python_package_for_repo(namespace)
         if full_namespace not in self.by_namespace:
-            raise UnknownNamespaceError(namespace)
+            if default == NOT_PROVIDED:
+                raise UnknownNamespaceError(namespace)
+            return default
         return self.by_namespace[full_namespace]
 
-    def first_repo(self) -> Optional["Repo"]:
+    def first_repo(self):
         """Get the first repo in precedence order."""
         return self.repos[0] if self.repos else None
 
     @llnl.util.lang.memoized
-    def _all_package_names_set(self, include_virtuals) -> Set[str]:
+    def _all_package_names_set(self, include_virtuals):
         return {name for repo in self.repos for name in repo.all_package_names(include_virtuals)}
 
     @llnl.util.lang.memoized
-    def _all_package_names(self, include_virtuals: bool) -> List[str]:
+    def _all_package_names(self, include_virtuals):
         """Return all unique package names in all repositories."""
         return sorted(self._all_package_names_set(include_virtuals), key=lambda n: n.lower())
 
-    def all_package_names(self, include_virtuals: bool = False) -> List[str]:
+    def all_package_names(self, include_virtuals=False):
         return self._all_package_names(include_virtuals)
 
-    def package_path(self, name: str) -> str:
+    def package_path(self, name):
         """Get path to package.py file for this repo."""
         return self.repo_for_pkg(name).package_path(name)
 
-    def all_package_paths(self) -> Generator[str, None, None]:
+    def all_package_paths(self):
         for name in self.all_package_names():
             yield self.package_path(name)
 
@@ -778,52 +758,53 @@ def packages_with_tags(self, *tags: str, full: bool = False) -> Set[str]:
             for pkg in repo.packages_with_tags(*tags)
         }
 
-    def all_package_classes(self) -> Generator[Type["spack.package_base.PackageBase"], None, None]:
+    def all_package_classes(self):
         for name in self.all_package_names():
             yield self.get_pkg_class(name)
 
     @property
-    def provider_index(self) -> spack.provider_index.ProviderIndex:
+    def provider_index(self):
         """Merged ProviderIndex from all Repos in the RepoPath."""
         if self._provider_index is None:
             self._provider_index = spack.provider_index.ProviderIndex(repository=self)
             for repo in reversed(self.repos):
                 self._provider_index.merge(repo.provider_index)
+
         return self._provider_index
 
     @property
-    def tag_index(self) -> spack.tag.TagIndex:
+    def tag_index(self):
         """Merged TagIndex from all Repos in the RepoPath."""
         if self._tag_index is None:
             self._tag_index = spack.tag.TagIndex(repository=self)
             for repo in reversed(self.repos):
                 self._tag_index.merge(repo.tag_index)
+
         return self._tag_index
 
     @property
-    def patch_index(self) -> spack.patch.PatchCache:
+    def patch_index(self):
         """Merged PatchIndex from all Repos in the RepoPath."""
         if self._patch_index is None:
             self._patch_index = spack.patch.PatchCache(repository=self)
             for repo in reversed(self.repos):
                 self._patch_index.update(repo.patch_index)
+
         return self._patch_index
 
     @autospec
-    def providers_for(self, virtual_spec: "spack.spec.Spec") -> List["spack.spec.Spec"]:
+    def providers_for(self, vpkg_spec):
         providers = [
             spec
-            for spec in self.provider_index.providers_for(virtual_spec)
+            for spec in self.provider_index.providers_for(vpkg_spec)
             if spec.name in self._all_package_names_set(include_virtuals=False)
         ]
         if not providers:
-            raise UnknownPackageError(virtual_spec.fullname)
+            raise UnknownPackageError(vpkg_spec.fullname)
         return providers
 
     @autospec
-    def extensions_for(
-        self, extendee_spec: "spack.spec.Spec"
-    ) -> List["spack.package_base.PackageBase"]:
+    def extensions_for(self, extendee_spec):
         return [
             pkg_cls(spack.spec.Spec(pkg_cls.name))
             for pkg_cls in self.all_package_classes()
@@ -834,7 +815,7 @@ def last_mtime(self):
         """Time a package file in this repo was last updated."""
         return max(repo.last_mtime() for repo in self.repos)
 
-    def repo_for_pkg(self, spec: Union[str, "spack.spec.Spec"]) -> "Repo":
+    def repo_for_pkg(self, spec):
         """Given a spec, get the repository for its package."""
         # We don't @_autospec this function b/c it's called very frequently
         # and we want to avoid parsing str's into Specs unnecessarily.
@@ -859,20 +840,17 @@ def repo_for_pkg(self, spec: Union[str, "spack.spec.Spec"]) -> "Repo":
                 return repo
 
         # If the package isn't in any repo, return the one with
-        # highest precedence. This is for commands like `spack edit`
+        # highest precedence.  This is for commands like `spack edit`
         # that can operate on packages that don't exist yet.
-        selected = self.first_repo()
-        if selected is None:
-            raise UnknownPackageError(name)
-        return selected
+        return self.first_repo()
 
-    def get(self, spec: "spack.spec.Spec") -> "spack.package_base.PackageBase":
+    def get(self, spec):
         """Returns the package associated with the supplied spec."""
         msg = "RepoPath.get can only be called on concrete specs"
         assert isinstance(spec, spack.spec.Spec) and spec.concrete, msg
         return self.repo_for_pkg(spec).get(spec)
 
-    def get_pkg_class(self, pkg_name: str) -> Type["spack.package_base.PackageBase"]:
+    def get_pkg_class(self, pkg_name):
         """Find a class for the spec's package and return the class object."""
         return self.repo_for_pkg(pkg_name).get_pkg_class(pkg_name)
 
@@ -885,26 +863,26 @@ def dump_provenance(self, spec, path):
         """
         return self.repo_for_pkg(spec).dump_provenance(spec, path)
 
-    def dirname_for_package_name(self, pkg_name: str) -> str:
+    def dirname_for_package_name(self, pkg_name):
         return self.repo_for_pkg(pkg_name).dirname_for_package_name(pkg_name)
 
-    def filename_for_package_name(self, pkg_name: str) -> str:
+    def filename_for_package_name(self, pkg_name):
         return self.repo_for_pkg(pkg_name).filename_for_package_name(pkg_name)
 
-    def exists(self, pkg_name: str) -> bool:
+    def exists(self, pkg_name):
         """Whether package with the give name exists in the path's repos.
 
         Note that virtual packages do not "exist".
         """
         return any(repo.exists(pkg_name) for repo in self.repos)
 
-    def _have_name(self, pkg_name: str) -> bool:
+    def _have_name(self, pkg_name):
         have_name = pkg_name is not None
         if have_name and not isinstance(pkg_name, str):
-            raise ValueError(f"is_virtual(): expected package name, got {type(pkg_name)}")
+            raise ValueError("is_virtual(): expected package name, got %s" % type(pkg_name))
         return have_name
 
-    def is_virtual(self, pkg_name: str) -> bool:
+    def is_virtual(self, pkg_name):
         """Return True if the package with this name is virtual, False otherwise.
 
         This function use the provider index. If calling from a code block that
@@ -916,7 +894,7 @@ def is_virtual(self, pkg_name: str) -> bool:
         have_name = self._have_name(pkg_name)
         return have_name and pkg_name in self.provider_index
 
-    def is_virtual_safe(self, pkg_name: str) -> bool:
+    def is_virtual_safe(self, pkg_name):
         """Return True if the package with this name is virtual, False otherwise.
 
         This function doesn't use the provider index.
@@ -937,28 +915,18 @@ class Repo:
     Each package repository must have a top-level configuration file
     called `repo.yaml`.
 
-    Currently, `repo.yaml` must define:
+    Currently, `repo.yaml` this must define:
 
     `namespace`:
         A Python namespace where the repository's packages should live.
 
-    `subdirectory`:
-        An optional subdirectory name where packages are placed
     """
 
-    def __init__(
-        self,
-        root: str,
-        *,
-        cache: "spack.caches.FileCacheType",
-        overrides: Optional[Dict[str, Any]] = None,
-    ) -> None:
+    def __init__(self, root, cache=None):
         """Instantiate a package repository from a filesystem path.
 
         Args:
             root: the root directory of the repository
-            cache: file cache associated with this repository
-            overrides: dict mapping package name to class attribute overrides for that package
         """
         # Root directory, containing _repo.yaml and package dirs
         # Allow roots to by spack-relative by starting with '$spack'
@@ -971,20 +939,20 @@ def check(condition, msg):
 
         # Validate repository layout.
         self.config_file = os.path.join(self.root, repo_config_name)
-        check(os.path.isfile(self.config_file), f"No {repo_config_name} found in '{root}'")
+        check(os.path.isfile(self.config_file), "No %s found in '%s'" % (repo_config_name, root))
 
         # Read configuration and validate namespace
         config = self._read_config()
         check(
             "namespace" in config,
-            f"{os.path.join(root, repo_config_name)} must define a namespace.",
+            "%s must define a namespace." % os.path.join(root, repo_config_name),
         )
 
         self.namespace = config["namespace"]
         check(
             re.match(r"[a-zA-Z][a-zA-Z0-9_.]+", self.namespace),
-            f"Invalid namespace '{self.namespace}' in repo '{self.root}'. "
-            "Namespaces must be valid python identifiers separated by '.'",
+            ("Invalid namespace '%s' in repo '%s'. " % (self.namespace, self.root))
+            + "Namespaces must be valid python identifiers separated by '.'",
         )
 
         # Set up 'full_namespace' to include the super-namespace
@@ -996,26 +964,23 @@ def check(condition, msg):
         packages_dir = config.get("subdirectory", packages_dir_name)
         self.packages_path = os.path.join(self.root, packages_dir)
         check(
-            os.path.isdir(self.packages_path), f"No directory '{packages_dir}' found in '{root}'"
+            os.path.isdir(self.packages_path),
+            "No directory '%s' found in '%s'" % (packages_dir, root),
         )
 
-        # Class attribute overrides by package name
-        self.overrides = overrides or {}
-
-        # Optional reference to a RepoPath to influence module import from spack.pkg
-        self._finder: Optional[RepoPath] = None
+        # These are internal cache variables.
+        self._modules = {}
+        self._classes = {}
+        self._instances = {}
 
         # Maps that goes from package name to corresponding file stat
-        self._fast_package_checker: Optional[FastPackageChecker] = None
+        self._fast_package_checker = None
 
         # Indexes for this repository, computed lazily
-        self._repo_index: Optional[RepoIndex] = None
-        self._cache = cache
+        self._repo_index = None
+        self._cache = cache or spack.caches.MISC_CACHE
 
-    def finder(self, value: RepoPath) -> None:
-        self._finder = value
-
-    def real_name(self, import_name: str) -> Optional[str]:
+    def real_name(self, import_name):
         """Allow users to import Spack packages using Python identifiers.
 
         A python identifier might map to many different Spack package
@@ -1034,21 +999,18 @@ def real_name(self, import_name: str) -> Optional[str]:
             return import_name
 
         options = nm.possible_spack_module_names(import_name)
-        try:
-            options.remove(import_name)
-        except ValueError:
-            pass
+        options.remove(import_name)
         for name in options:
             if name in self:
                 return name
         return None
 
-    def is_prefix(self, fullname: str) -> bool:
+    def is_prefix(self, fullname):
         """True if fullname is a prefix of this Repo's namespace."""
         parts = fullname.split(".")
         return self._names[: len(parts)] == parts
 
-    def _read_config(self) -> Dict[str, str]:
+    def _read_config(self):
         """Check for a YAML config file in this db's root directory."""
         try:
             with open(self.config_file) as reponame_file:
@@ -1059,14 +1021,14 @@ def _read_config(self) -> Dict[str, str]:
                     or "repo" not in yaml_data
                     or not isinstance(yaml_data["repo"], dict)
                 ):
-                    tty.die(f"Invalid {repo_config_name} in repository {self.root}")
+                    tty.die("Invalid %s in repository %s" % (repo_config_name, self.root))
 
                 return yaml_data["repo"]
 
         except IOError:
-            tty.die(f"Error reading {self.config_file} when opening {self.root}")
+            tty.die("Error reading %s when opening %s" % (self.config_file, self.root))
 
-    def get(self, spec: "spack.spec.Spec") -> "spack.package_base.PackageBase":
+    def get(self, spec):
         """Returns the package associated with the supplied spec."""
         msg = "Repo.get can only be called on concrete specs"
         assert isinstance(spec, spack.spec.Spec) and spec.concrete, msg
@@ -1087,13 +1049,16 @@ def get(self, spec: "spack.spec.Spec") -> "spack.package_base.PackageBase":
             # pass these through as their error messages will be fine.
             raise
         except Exception as e:
+            tty.debug(e)
+
             # Make sure other errors in constructors hit the error
             # handler by wrapping them
-            tty.debug(e)
-            raise FailedConstructorError(spec.fullname, *sys.exc_info()) from e
+            if spack.config.get("config:debug"):
+                sys.excepthook(*sys.exc_info())
+            raise FailedConstructorError(spec.fullname, *sys.exc_info())
 
     @autospec
-    def dump_provenance(self, spec: "spack.spec.Spec", path: str) -> None:
+    def dump_provenance(self, spec, path):
         """Dump provenance information for a spec to a particular path.
 
         This dumps the package file and any associated patch files.
@@ -1101,7 +1066,7 @@ def dump_provenance(self, spec: "spack.spec.Spec", path: str) -> None:
         """
         if spec.namespace and spec.namespace != self.namespace:
             raise UnknownPackageError(
-                f"Repository {self.namespace} does not contain package {spec.fullname}."
+                "Repository %s does not contain package %s." % (self.namespace, spec.fullname)
             )
 
         package_path = self.filename_for_package_name(spec.name)
@@ -1118,13 +1083,17 @@ def dump_provenance(self, spec: "spack.spec.Spec", path: str) -> None:
                     if os.path.exists(patch.path):
                         fs.install(patch.path, path)
                     else:
-                        warnings.warn(f"Patch file did not exist: {patch.path}")
+                        tty.warn("Patch file did not exist: %s" % patch.path)
 
         # Install the package.py file itself.
         fs.install(self.filename_for_package_name(spec.name), path)
 
+    def purge(self):
+        """Clear entire package instance cache."""
+        self._instances.clear()
+
     @property
-    def index(self) -> RepoIndex:
+    def index(self):
         """Construct the index for this repo lazily."""
         if self._repo_index is None:
             self._repo_index = RepoIndex(self._pkg_checker, self.namespace, cache=self._cache)
@@ -1134,40 +1103,42 @@ def index(self) -> RepoIndex:
         return self._repo_index
 
     @property
-    def provider_index(self) -> spack.provider_index.ProviderIndex:
+    def provider_index(self):
         """A provider index with names *specific* to this repo."""
         return self.index["providers"]
 
     @property
-    def tag_index(self) -> spack.tag.TagIndex:
+    def tag_index(self):
         """Index of tags and which packages they're defined on."""
         return self.index["tags"]
 
     @property
-    def patch_index(self) -> spack.patch.PatchCache:
+    def patch_index(self):
         """Index of patches and packages they're defined on."""
         return self.index["patches"]
 
     @autospec
-    def providers_for(self, vpkg_spec: "spack.spec.Spec") -> List["spack.spec.Spec"]:
+    def providers_for(self, vpkg_spec):
         providers = self.provider_index.providers_for(vpkg_spec)
         if not providers:
             raise UnknownPackageError(vpkg_spec.fullname)
         return providers
 
     @autospec
-    def extensions_for(
-        self, extendee_spec: "spack.spec.Spec"
-    ) -> List["spack.package_base.PackageBase"]:
-        result = [pkg_cls(spack.spec.Spec(pkg_cls.name)) for pkg_cls in self.all_package_classes()]
-        return [x for x in result if x.extends(extendee_spec)]
+    def extensions_for(self, extendee_spec):
+        return [
+            pkg_cls(spack.spec.Spec(pkg_cls.name))
+            for pkg_cls in self.all_package_classes()
+            if pkg_cls(spack.spec.Spec(pkg_cls.name)).extends(extendee_spec)
+        ]
 
-    def dirname_for_package_name(self, pkg_name: str) -> str:
-        """Given a package name, get the directory containing its package.py file."""
+    def dirname_for_package_name(self, pkg_name):
+        """Get the directory name for a particular package.  This is the
+        directory that contains its package.py file."""
         _, unqualified_name = self.partition_package_name(pkg_name)
         return os.path.join(self.packages_path, unqualified_name)
 
-    def filename_for_package_name(self, pkg_name: str) -> str:
+    def filename_for_package_name(self, pkg_name):
         """Get the filename for the module we should load for a particular
         package.  Packages for a Repo live in
         ``$root/<package_name>/package.py``
@@ -1180,23 +1151,23 @@ def filename_for_package_name(self, pkg_name: str) -> str:
         return os.path.join(pkg_dir, package_file_name)
 
     @property
-    def _pkg_checker(self) -> FastPackageChecker:
+    def _pkg_checker(self):
         if self._fast_package_checker is None:
             self._fast_package_checker = FastPackageChecker(self.packages_path)
         return self._fast_package_checker
 
-    def all_package_names(self, include_virtuals: bool = False) -> List[str]:
+    def all_package_names(self, include_virtuals=False):
         """Returns a sorted list of all package names in the Repo."""
         names = sorted(self._pkg_checker.keys())
         if include_virtuals:
             return names
         return [x for x in names if not self.is_virtual(x)]
 
-    def package_path(self, name: str) -> str:
+    def package_path(self, name):
         """Get path to package.py file for this repo."""
         return os.path.join(self.packages_path, name, package_file_name)
 
-    def all_package_paths(self) -> Generator[str, None, None]:
+    def all_package_paths(self):
         for name in self.all_package_names():
             yield self.package_path(name)
 
@@ -1205,7 +1176,7 @@ def packages_with_tags(self, *tags: str) -> Set[str]:
         v.intersection_update(*(self.tag_index[tag.lower()] for tag in tags))
         return v
 
-    def all_package_classes(self) -> Generator[Type["spack.package_base.PackageBase"], None, None]:
+    def all_package_classes(self):
         """Iterator over all package *classes* in the repository.
 
         Use this with care, because loading packages is slow.
@@ -1213,7 +1184,7 @@ def all_package_classes(self) -> Generator[Type["spack.package_base.PackageBase"
         for name in self.all_package_names():
             yield self.get_pkg_class(name)
 
-    def exists(self, pkg_name: str) -> bool:
+    def exists(self, pkg_name):
         """Whether a package with the supplied name exists."""
         if pkg_name is None:
             return False
@@ -1230,22 +1201,28 @@ def last_mtime(self):
         """Time a package file in this repo was last updated."""
         return self._pkg_checker.last_mtime()
 
-    def is_virtual(self, pkg_name: str) -> bool:
+    def is_virtual(self, pkg_name):
         """Return True if the package with this name is virtual, False otherwise.
 
         This function use the provider index. If calling from a code block that
         is used to construct the provider index use the ``is_virtual_safe`` function.
+
+        Args:
+            pkg_name (str): name of the package we want to check
         """
         return pkg_name in self.provider_index
 
-    def is_virtual_safe(self, pkg_name: str) -> bool:
+    def is_virtual_safe(self, pkg_name):
         """Return True if the package with this name is virtual, False otherwise.
 
         This function doesn't use the provider index.
+
+        Args:
+            pkg_name (str): name of the package we want to check
         """
         return not self.exists(pkg_name) or self.get_pkg_class(pkg_name).virtual
 
-    def get_pkg_class(self, pkg_name: str) -> Type["spack.package_base.PackageBase"]:
+    def get_pkg_class(self, pkg_name):
         """Get the class for the package out of its module.
 
         First loads (or fetches from cache) a module for the
@@ -1257,8 +1234,7 @@ def get_pkg_class(self, pkg_name: str) -> Type["spack.package_base.PackageBase"]
         fullname = f"{self.full_namespace}.{pkg_name}"
 
         try:
-            with REPOS_FINDER.switch_repo(self._finder or self):
-                module = importlib.import_module(fullname)
+            module = importlib.import_module(fullname)
         except ImportError:
             raise UnknownPackageError(fullname)
         except Exception as e:
@@ -1269,21 +1245,26 @@ def get_pkg_class(self, pkg_name: str) -> Type["spack.package_base.PackageBase"]
         if not inspect.isclass(cls):
             tty.die(f"{pkg_name}.{class_name} is not a class")
 
-        # Clear any prior changes to class attributes in case the class was loaded from the
-        # same repo, but with different overrides
+        new_cfg_settings = (
+            spack.config.get("packages").get(pkg_name, {}).get("package_attributes", {})
+        )
+
         overridden_attrs = getattr(cls, "overridden_attrs", {})
         attrs_exclusively_from_config = getattr(cls, "attrs_exclusively_from_config", [])
+        # Clear any prior changes to class attributes in case the config has
+        # since changed
         for key, val in overridden_attrs.items():
             setattr(cls, key, val)
         for key in attrs_exclusively_from_config:
             delattr(cls, key)
 
-        # Keep track of every class attribute that is overridden: if different overrides
-        # dictionaries are used on the same physical repo, we make sure to restore the original
-        # config values
+        # Keep track of every class attribute that is overridden by the config:
+        # if the config changes between calls to this method, we make sure to
+        # restore the original config values (in case the new config no longer
+        # sets attributes that it used to)
         new_overridden_attrs = {}
         new_attrs_exclusively_from_config = set()
-        for key, val in self.overrides.get(pkg_name, {}).items():
+        for key, val in new_cfg_settings.items():
             if hasattr(cls, key):
                 new_overridden_attrs[key] = getattr(cls, key)
             else:
@@ -1310,13 +1291,13 @@ def partition_package_name(self, pkg_name: str) -> Tuple[str, str]:
 
         return namespace, pkg_name
 
-    def __str__(self) -> str:
-        return f"Repo '{self.namespace}' at {self.root}"
+    def __str__(self):
+        return "[Repo '%s' at '%s']" % (self.namespace, self.root)
 
-    def __repr__(self) -> str:
+    def __repr__(self):
         return self.__str__()
 
-    def __contains__(self, pkg_name: str) -> bool:
+    def __contains__(self, pkg_name):
         return self.exists(pkg_name)
 
 
@@ -1392,17 +1373,12 @@ def create_repo(root, namespace=None, subdir=packages_dir_name):
     return full_path, namespace
 
 
-def from_path(path: str) -> "Repo":
-    """Returns a repository from the path passed as input. Injects the global misc cache."""
-    return Repo(path, cache=spack.caches.MISC_CACHE)
-
-
 def create_or_construct(path, namespace=None):
     """Create a repository, or just return a Repo if it already exists."""
     if not os.path.exists(path):
         fs.mkdirp(path)
         create_repo(path, namespace)
-    return from_path(path)
+    return Repo(path)
 
 
 def _path(configuration=None):
@@ -1411,9 +1387,7 @@ def _path(configuration=None):
     return create(configuration=configuration)
 
 
-def create(
-    configuration: Union["spack.config.Configuration", llnl.util.lang.Singleton]
-) -> RepoPath:
+def create(configuration):
     """Create a RepoPath from a configuration object.
 
     Args:
@@ -1422,17 +1396,7 @@ def create(
     repo_dirs = configuration.get("repos")
     if not repo_dirs:
         raise NoRepoConfiguredError("Spack configuration contains no package repositories.")
-
-    overrides = {}
-    for pkg_name, data in configuration.get("packages").items():
-        if pkg_name == "all":
-            continue
-        value = data.get("package_attributes", {})
-        if not value:
-            continue
-        overrides[pkg_name] = value
-
-    return RepoPath(*repo_dirs, cache=spack.caches.MISC_CACHE, overrides=overrides)
+    return RepoPath(*repo_dirs)
 
 
 #: Singleton repo path instance
@@ -1449,20 +1413,20 @@ def all_package_names(include_virtuals=False):
 
 
 @contextlib.contextmanager
-def use_repositories(
-    *paths_and_repos: Union[str, Repo], override: bool = True
-) -> Generator[RepoPath, None, None]:
+def use_repositories(*paths_and_repos, **kwargs):
     """Use the repositories passed as arguments within the context manager.
 
     Args:
         *paths_and_repos: paths to the repositories to be used, or
             already constructed Repo objects
-        override: if True use only the repositories passed as input,
+        override (bool): if True use only the repositories passed as input,
             if False add them to the top of the list of current repositories.
     Returns:
         Corresponding RepoPath object
     """
     global PATH
+    # TODO (Python 2.7): remove this kwargs on deprecation of Python 2.7 support
+    override = kwargs.get("override", True)
     paths = [getattr(x, "root", x) for x in paths_and_repos]
     scope_name = "use-repo-{}".format(uuid.uuid4())
     repos_key = "repos:" if override else "repos"
@@ -1471,8 +1435,7 @@ def use_repositories(
     )
     PATH, saved = create(configuration=spack.config.CONFIG), PATH
     try:
-        with REPOS_FINDER.switch_repo(PATH):  # type: ignore
-            yield PATH
+        yield PATH
     finally:
         spack.config.CONFIG.remove_scope(scope_name=scope_name)
         PATH = saved
@@ -1572,9 +1535,10 @@ class UnknownNamespaceError(UnknownEntityError):
     """Raised when we encounter an unknown namespace"""
 
     def __init__(self, namespace, name=None):
-        msg, long_msg = f"Unknown namespace: {namespace}", None
+        msg, long_msg = "Unknown namespace: {}".format(namespace), None
         if name == "yaml":
-            long_msg = f"Did you mean to specify a filename with './{namespace}.{name}'?"
+            long_msg = "Did you mean to specify a filename with './{}.{}'?"
+            long_msg = long_msg.format(namespace, name)
         super().__init__(msg, long_msg)
 
 

lib/spack/spack/solver/asp.py

@@ -23,7 +23,6 @@
 
 import llnl.util.lang
 import llnl.util.tty as tty
-from llnl.util.lang import elide_list
 
 import spack
 import spack.binary_distribution
@@ -622,9 +621,8 @@ def _external_config_with_implicit_externals(configuration):
 
 
 class ErrorHandler:
-    def __init__(self, model, input_specs: List[spack.spec.Spec]):
+    def __init__(self, model):
         self.model = model
-        self.input_specs = input_specs
         self.full_model = None
 
     def multiple_values_error(self, attribute, pkg):
@@ -711,13 +709,12 @@ def handle_error(self, msg, *args):
         return msg
 
     def message(self, errors) -> str:
-        input_specs = ", ".join(elide_list([f"`{s}`" for s in self.input_specs], 5))
-        header = f"failed to concretize {input_specs} for the following reasons:"
-        messages = (
-            f"    {idx+1:2}. {self.handle_error(msg, *args)}"
+        messages = [
+            f"  {idx+1: 2}. {self.handle_error(msg, *args)}"
             for idx, (_, msg, args) in enumerate(errors)
-        )
-        return "\n".join((header, *messages))
+        ]
+        header = "concretization failed for the following reasons:\n"
+        return "\n".join([header] + messages)
 
     def raise_if_errors(self):
         initial_error_args = extract_args(self.model, "error")
@@ -753,7 +750,7 @@ def on_model(model):
                 f"unexpected error during concretization [{str(e)}]. "
                 f"Please report a bug at https://github.com/spack/spack/issues"
             )
-            raise spack.error.SpackError(msg) from e
+            raise spack.error.SpackError(msg)
         raise UnsatisfiableSpecError(msg)
 
 
@@ -897,7 +894,7 @@ def on_model(model):
             min_cost, best_model = min(models)
 
             # first check for errors
-            error_handler = ErrorHandler(best_model, specs)
+            error_handler = ErrorHandler(best_model)
             error_handler.raise_if_errors()
 
             # build specs from spec attributes in the model
@@ -1438,14 +1435,16 @@ def condition(
             # caller, we won't emit partial facts.
 
             condition_id = next(self._id_counter)
+            self.gen.fact(fn.pkg_fact(required_spec.name, fn.condition(condition_id)))
+            self.gen.fact(fn.condition_reason(condition_id, msg))
+
             trigger_id = self._get_condition_id(
                 required_spec, cache=self._trigger_cache, body=True, transform=transform_required
             )
-            self.gen.fact(fn.pkg_fact(required_spec.name, fn.condition(condition_id)))
-            self.gen.fact(fn.condition_reason(condition_id, msg))
             self.gen.fact(
                 fn.pkg_fact(required_spec.name, fn.condition_trigger(condition_id, trigger_id))
             )
+
             if not imposed_spec:
                 return condition_id
 
@@ -1694,43 +1693,19 @@ def external_packages(self):
                 spack.spec.parse_with_version_concrete(x["spec"]) for x in externals
             ]
 
-            selected_externals = set()
+            external_specs = []
             if spec_filters:
                 for current_filter in spec_filters:
                     current_filter.factory = lambda: candidate_specs
-                    selected_externals.update(current_filter.selected_specs())
-
-            # Emit facts for externals specs. Note that "local_idx" is the index of the spec
-            # in packages:<pkg_name>:externals. This means:
-            #
-            # packages:<pkg_name>:externals[local_idx].spec == spec
-            external_versions = []
-            for local_idx, spec in enumerate(candidate_specs):
-                msg = f"{spec.name} available as external when satisfying {spec}"
-
-                if spec_filters and spec not in selected_externals:
-                    continue
-
-                if not spec.versions.concrete:
-                    warnings.warn(f"cannot use the external spec {spec}: needs a concrete version")
-                    continue
-
-                def external_imposition(input_spec, requirements):
-                    return requirements + [
-                        fn.attr("external_conditions_hold", input_spec.name, local_idx)
-                    ]
-
-                try:
-                    self.condition(spec, spec, msg=msg, transform_imposed=external_imposition)
-                except (spack.error.SpecError, RuntimeError) as e:
-                    warnings.warn(f"while setting up external spec {spec}: {e}")
-                    continue
-                external_versions.append((spec.version, local_idx))
-                self.possible_versions[spec.name].add(spec.version)
-                self.gen.newline()
+                    external_specs.extend(current_filter.selected_specs())
+            else:
+                external_specs.extend(candidate_specs)
 
             # Order the external versions to prefer more recent versions
             # even if specs in packages.yaml are not ordered that way
+            external_versions = [
+                (x.version, external_id) for external_id, x in enumerate(external_specs)
+            ]
             external_versions = [
                 (v, idx, external_id)
                 for idx, (v, external_id) in enumerate(sorted(external_versions, reverse=True))
@@ -1740,6 +1715,19 @@ def external_imposition(input_spec, requirements):
                     DeclaredVersion(version=version, idx=idx, origin=Provenance.EXTERNAL)
                 )
 
+            # Declare external conditions with a local index into packages.yaml
+            for local_idx, spec in enumerate(external_specs):
+                msg = "%s available as external when satisfying %s" % (spec.name, spec)
+
+                def external_imposition(input_spec, requirements):
+                    return requirements + [
+                        fn.attr("external_conditions_hold", input_spec.name, local_idx)
+                    ]
+
+                self.condition(spec, spec, msg=msg, transform_imposed=external_imposition)
+                self.possible_versions[spec.name].add(spec.version)
+                self.gen.newline()
+
             self.trigger_rules()
             self.effect_rules()
 
@@ -1851,8 +1839,6 @@ def _spec_clauses(
 
         if spec.name:
             clauses.append(f.node(spec.name) if not spec.virtual else f.virtual_node(spec.name))
-        if spec.namespace:
-            clauses.append(f.namespace(spec.name, spec.namespace))
 
         clauses.extend(self.spec_versions(spec))
 
@@ -2750,7 +2736,6 @@ class _Head:
     """ASP functions used to express spec clauses in the HEAD of a rule"""
 
     node = fn.attr("node")
-    namespace = fn.attr("namespace_set")
     virtual_node = fn.attr("virtual_node")
     node_platform = fn.attr("node_platform_set")
     node_os = fn.attr("node_os_set")
@@ -2766,7 +2751,6 @@ class _Body:
     """ASP functions used to express spec clauses in the BODY of a rule"""
 
     node = fn.attr("node")
-    namespace = fn.attr("namespace")
     virtual_node = fn.attr("virtual_node")
     node_platform = fn.attr("node_platform")
     node_os = fn.attr("node_os")

lib/spack/spack/solver/concretize.lp

@@ -18,79 +18,38 @@
 { attr("virtual_node", node(0..X-1, Package)) } :- max_dupes(Package, X), virtual(Package).
 
 % Integrity constraints on DAG nodes
-:- attr("root", PackageNode),
-   not attr("node", PackageNode),
-   internal_error("Every root must be a node").
-:- attr("version", PackageNode, _),
-   not attr("node", PackageNode),
-   not attr("virtual_node", PackageNode),
-   internal_error("Only nodes and virtual_nodes can have versions").
-:- attr("node_version_satisfies", PackageNode, _),
-   not attr("node", PackageNode),
-   not attr("virtual_node", PackageNode),
-   internal_error("Only nodes and virtual_nodes can have version satisfaction").
-:- attr("hash", PackageNode, _),
-   not attr("node", PackageNode),
-   internal_error("Only nodes can have hashes").
-:- attr("node_platform", PackageNode, _),
-   not attr("node", PackageNode),
-   internal_error("Only nodes can have platforms").
-:- attr("node_os", PackageNode, _), not attr("node", PackageNode),
-   internal_error("Only nodes can have node_os").
-:- attr("node_target", PackageNode, _), not attr("node", PackageNode),
-   internal_error("Only nodes can have node_target").
-:- attr("node_compiler_version", PackageNode, _, _), not attr("node", PackageNode),
-   internal_error("Only nodes can have node_compiler_version").
-:- attr("variant_value", PackageNode, _, _), not attr("node", PackageNode),
-   internal_error("variant_value true for a non-node").
-:- attr("node_flag_compiler_default", PackageNode), not attr("node", PackageNode),
-   internal_error("node_flag_compiler_default true for non-node").
-:- attr("node_flag", PackageNode, _, _), not attr("node", PackageNode),
-   internal_error("node_flag assigned for non-node").
-:- attr("external_spec_selected", PackageNode, _), not attr("node", PackageNode),
-   internal_error("external_spec_selected for non-node").
-:- attr("depends_on", ParentNode, _, _), not attr("node", ParentNode),
-   internal_error("non-node depends on something").
-:- attr("depends_on", _, ChildNode, _), not attr("node", ChildNode),
-   internal_error("something depends_on a non-node").
-:- attr("node_flag_source", Node, _, _), not attr("node", Node),
-   internal_error("node_flag_source assigned for a non-node").
-:- attr("node_flag_source", _, _, SourceNode), not attr("node", SourceNode),
-   internal_error("node_flag_source assigned with a non-node source").
-:- attr("virtual_node", VirtualNode), not provider(_, VirtualNode),
-   internal_error("virtual node with no provider").
-:- provider(_, VirtualNode), not attr("virtual_node", VirtualNode),
-   internal_error("provider with no virtual node").
-:- provider(PackageNode, _), not attr("node", PackageNode),
-   internal_error("provider with no real node").
+:- attr("root", PackageNode), not attr("node", PackageNode).
+:- attr("version", PackageNode, _), not attr("node", PackageNode), not attr("virtual_node", PackageNode).
+:- attr("node_version_satisfies", PackageNode, _), not attr("node", PackageNode), not attr("virtual_node", PackageNode).
+:- attr("hash", PackageNode, _), not attr("node", PackageNode).
+:- attr("node_platform", PackageNode, _), not attr("node", PackageNode).
+:- attr("node_os", PackageNode, _), not attr("node", PackageNode).
+:- attr("node_target", PackageNode, _), not attr("node", PackageNode).
+:- attr("node_compiler_version", PackageNode, _, _), not attr("node", PackageNode).
+:- attr("variant_value", PackageNode, _, _), not attr("node", PackageNode).
+:- attr("node_flag_compiler_default", PackageNode), not attr("node", PackageNode).
+:- attr("node_flag", PackageNode, _, _), not attr("node", PackageNode).
+:- attr("external_spec_selected", PackageNode, _), not attr("node", PackageNode).
+:- attr("depends_on", ParentNode, _, _), not attr("node", ParentNode).
+:- attr("depends_on", _, ChildNode, _), not attr("node", ChildNode).
+:- attr("node_flag_source", ParentNode, _, _), not attr("node", ParentNode).
+:- attr("node_flag_source", _, _, ChildNode), not attr("node", ChildNode).
+:- attr("virtual_node", VirtualNode), not provider(_, VirtualNode), internal_error("virtual node with no provider").
+:- provider(_, VirtualNode), not attr("virtual_node", VirtualNode), internal_error("provider with no virtual node").
+:- provider(PackageNode, _), not attr("node", PackageNode), internal_error("provider with no real node").
 
-:- attr("root", node(ID, PackageNode)), ID > min_dupe_id,
-   internal_error("root with a non-minimal duplicate ID").
+:- attr("root", node(ID, PackageNode)), ID > min_dupe_id, internal_error("root with a non-minimal duplicate ID").
 
 % Nodes in the "root" unification set cannot depend on non-root nodes if the dependency is "link" or "run"
 :- attr("depends_on", node(min_dupe_id, Package), node(ID, _), "link"), ID != min_dupe_id, unification_set("root", node(min_dupe_id, Package)), internal_error("link dependency out of the root unification set").
 :- attr("depends_on", node(min_dupe_id, Package), node(ID, _), "run"),  ID != min_dupe_id, unification_set("root", node(min_dupe_id, Package)), internal_error("run dependency out of the root unification set").
 
-% Namespaces are statically assigned by a package fact if not otherwise set
-error(100, "{0} does not have a namespace", Package) :- attr("node", node(ID, Package)),
-   not attr("namespace", node(ID, Package), _),
-   internal_error("A node must have a namespace").
-error(100, "{0} cannot come from both {1} and {2} namespaces", Package, NS1, NS2) :- attr("node", node(ID, Package)),
-   attr("namespace", node(ID, Package), NS1),
-   attr("namespace", node(ID, Package), NS2),
-   NS1 != NS2,
-   internal_error("A node cannot have two namespaces").
-
-attr("namespace", node(ID, Package), Namespace) :- attr("namespace_set", node(ID, Package), Namespace).
-attr("namespace", node(ID, Package), Namespace)
-  :- attr("node", node(ID, Package)),
-     not attr("namespace_set", node(ID, Package), _),
-     pkg_fact(Package, namespace(Namespace)).
+% Namespaces are statically assigned by a package fact
+attr("namespace", node(ID, Package), Namespace) :- attr("node", node(ID, Package)), pkg_fact(Package, namespace(Namespace)).
 
 % Rules on "unification sets", i.e. on sets of nodes allowing a single configuration of any given package
 unify(SetID, PackageName) :- unification_set(SetID, node(_, PackageName)).
-:- 2 { unification_set(SetID, node(_, PackageName)) }, unify(SetID, PackageName),
-   internal_error("Cannot have multiple unification sets IDs for one set").
+:- 2 { unification_set(SetID, node(_, PackageName)) }, unify(SetID, PackageName).
 
 unification_set("root", PackageNode) :- attr("root", PackageNode).
 unification_set(SetID, ChildNode) :- attr("depends_on", ParentNode, ChildNode, Type), Type != "build", unification_set(SetID, ParentNode).
@@ -116,8 +75,7 @@ unification_set(SetID, VirtualNode)
 % as a build dependency.
 %
 % We'll need to relax the rule before we get to actual cross-compilation
-:- depends_on(ParentNode, node(X, Dependency)), depends_on(ParentNode, node(Y, Dependency)), X < Y,
-   internal_error("Cannot split link/build deptypes for a single edge (yet)").
+:- depends_on(ParentNode, node(X, Dependency)), depends_on(ParentNode, node(Y, Dependency)), X < Y.
 
 
 #defined multiple_unification_sets/1.
@@ -173,8 +131,7 @@ mentioned_in_literal(Root, Mentioned) :- mentioned_in_literal(TriggerID, Root, M
 condition_set(node(min_dupe_id, Root), node(min_dupe_id, Root)) :-  mentioned_in_literal(Root, Root).
 
 1 { condition_set(node(min_dupe_id, Root), node(0..Y-1, Mentioned)) : max_dupes(Mentioned, Y) } 1 :-
-  mentioned_in_literal(Root, Mentioned), Mentioned != Root,
-  internal_error("must have exactly one condition_set for literals").
+  mentioned_in_literal(Root, Mentioned), Mentioned != Root.
 
 % Discriminate between "roots" that have been explicitly requested, and roots that are deduced from "virtual roots"
 explicitly_requested_root(node(min_dupe_id, Package)) :-
@@ -194,8 +151,7 @@ associated_with_root(RootNode, ChildNode) :-
 :- attr("root", RootNode),
    condition_set(RootNode, node(X, Package)),
    not virtual(Package),
-   not associated_with_root(RootNode, node(X, Package)),
-   internal_error("nodes in root condition set must be associated with root").
+   not associated_with_root(RootNode, node(X, Package)).
 
 #defined concretize_everything/0.
 #defined literal/1.
@@ -429,10 +385,8 @@ imposed_nodes(ConditionID, PackageNode, node(X, A1))
      condition_set(PackageNode, node(X, A1)),
      attr("hash", PackageNode, ConditionID).
 
-:- imposed_packages(ID, A1), impose(ID, PackageNode), not condition_set(PackageNode, node(_, A1)),
-   internal_error("Imposing constraint outside of condition set").
-:- imposed_packages(ID, A1), impose(ID, PackageNode), not imposed_nodes(ID, PackageNode, node(_, A1)),
-   internal_error("Imposing constraint outside of imposed_nodes").
+:- imposed_packages(ID, A1), impose(ID, PackageNode), not condition_set(PackageNode, node(_, A1)).
+:- imposed_packages(ID, A1), impose(ID, PackageNode), not imposed_nodes(ID, PackageNode, node(_, A1)).
 
 % Conditions that hold impose may impose constraints on other specs
 attr(Name, node(X, A1))             :- impose(ID, PackageNode), imposed_constraint(ID, Name, A1),             imposed_nodes(ID, PackageNode, node(X, A1)).
@@ -462,8 +416,7 @@ provider(ProviderNode, VirtualNode) :- attr("provider_set", ProviderNode, Virtua
 % satisfy the dependency.
 1 { attr("depends_on", node(X, A1), node(0..Y-1, A2), A3) : max_dupes(A2, Y) } 1
   :- impose(ID, node(X, A1)),
-     imposed_constraint(ID, "depends_on", A1, A2, A3),
-     internal_error("Build deps must land in exactly one duplicate").
+     imposed_constraint(ID, "depends_on", A1, A2, A3).
 
 % Reconstruct virtual dependencies for reused specs
 attr("virtual_on_edge", node(X, A1), node(Y, A2), Virtual)
@@ -658,18 +611,25 @@ do_not_impose(EffectID, node(X, Package))
 % Virtual dependency weights
 %-----------------------------------------------------------------------------
 
-% A provider has different possible weights depending on its preference. This rule ensures that
+% A provider may have different possible weights depending on whether it's an external
+% or not, or on preferences expressed in packages.yaml etc. This rule ensures that
 % we select the weight, among the possible ones, that minimizes the overall objective function.
 1 { provider_weight(DependencyNode, VirtualNode, Weight) :
     possible_provider_weight(DependencyNode, VirtualNode, Weight, _) } 1
  :- provider(DependencyNode, VirtualNode), internal_error("Package provider weights must be unique").
 
-% Any configured provider has a weight based on index in the preference list
+% A provider that is an external can use a weight of 0
+possible_provider_weight(DependencyNode, VirtualNode, 0, "external")
+  :- provider(DependencyNode, VirtualNode),
+     external(DependencyNode).
+
+% A provider mentioned in the default configuration can use a weight
+% according to its priority in the list of providers
 possible_provider_weight(node(ProviderID, Provider), node(VirtualID, Virtual), Weight, "default")
   :- provider(node(ProviderID, Provider), node(VirtualID, Virtual)),
      default_provider_preference(Virtual, Provider, Weight).
 
-% Any non-configured provider has a default weight of 100
+% Any provider can use 100 as a weight, which is very high and discourage its use
 possible_provider_weight(node(ProviderID, Provider), VirtualNode, 100, "fallback")
   :- provider(node(ProviderID, Provider), VirtualNode).
 
@@ -1202,11 +1162,8 @@ target_weight(Target, 0)
 node_target_weight(PackageNode, MinWeight)
  :- attr("node", PackageNode),
     attr("node_target", PackageNode, Target),
-    target(Target),
     MinWeight = #min { Weight : target_weight(Target, Weight) }.
 
-:- attr("node_target", PackageNode, Target), not node_target_weight(PackageNode, _).
-
 % compatibility rules for targets among nodes
 node_target_match(ParentNode, DependencyNode)
   :- attr("depends_on", ParentNode, DependencyNode, Type), Type != "build",

lib/spack/spack/solver/os_compatibility.lp

@@ -12,7 +12,6 @@
 %=============================================================================
 
 % macOS
-os_compatible("sequoia", "sonoma").
 os_compatible("sonoma", "ventura").
 os_compatible("ventura", "monterey").
 os_compatible("monterey", "bigsur").

lib/spack/spack/spec.py

@@ -99,7 +99,7 @@
     "CompilerSpec",
     "Spec",
     "SpecParseError",
-    "UnsupportedPropagationError",
+    "ArchitecturePropagationError",
     "DuplicateDependencyError",
     "DuplicateCompilerSpecError",
     "UnsupportedCompilerError",
@@ -129,7 +129,7 @@
     r"|"  # or
     # OPTION 2: an actual format string
     r"{"  # non-escaped open brace {
-    r"([%@/]|[\w ][\w -]*=)?"  # optional sigil (or identifier or space) to print sigil in color
+    r"([%@/]|arch=)?"  # optional sigil (to print sigil in color)
     r"(?:\^([^}\.]+)\.)?"  # optional ^depname. (to get attr from dependency)
     # after the sigil or depname, we can have a hash expression or another attribute
     r"(?:"  # one of
@@ -163,14 +163,14 @@
 DEFAULT_FORMAT = (
     "{name}{@versions}"
     "{%compiler.name}{@compiler.versions}{compiler_flags}"
-    "{variants}{ namespace=namespace_if_anonymous}{ arch=architecture}{/abstract_hash}"
+    "{variants}{arch=architecture}{/abstract_hash}"
 )
 
 #: Display format, which eliminates extra `@=` in the output, for readability.
 DISPLAY_FORMAT = (
     "{name}{@version}"
     "{%compiler.name}{@compiler.version}{compiler_flags}"
-    "{variants}{ namespace=namespace_if_anonymous}{ arch=architecture}{/abstract_hash}"
+    "{variants}{arch=architecture}{/abstract_hash}"
 )
 
 #: Regular expression to pull spec contents out of clearsigned signature
@@ -1332,12 +1332,6 @@ def tree(
     if color is None:
         color = clr.get_color_when()
 
-    # reduce deptypes over all in-edges when covering nodes
-    if show_types and cover == "nodes":
-        deptype_lookup: Dict[str, dt.DepFlag] = collections.defaultdict(dt.DepFlag)
-        for edge in traverse.traverse_edges(specs, cover="edges", deptype=deptypes, root=False):
-            deptype_lookup[edge.spec.dag_hash()] |= edge.depflag
-
     for d, dep_spec in traverse.traverse_tree(
         sorted(specs), cover=cover, deptype=deptypes, depth_first=depth_first, key=key
     ):
@@ -1364,7 +1358,11 @@ def tree(
 
         if show_types:
             if cover == "nodes":
-                depflag = deptype_lookup[dep_spec.spec.dag_hash()]
+                # when only covering nodes, we merge dependency types
+                # from all dependents before showing them.
+                depflag = 0
+                for ds in node.edges_from_dependents():
+                    depflag |= ds.depflag
             else:
                 # when covering edges or paths, we show dependency
                 # types only for the edge through which we visited
@@ -1640,9 +1638,19 @@ def _add_flag(self, name, value, propagate):
         Known flags currently include "arch"
         """
 
-        if propagate and name in spack.directives.reserved_names:
-            raise UnsupportedPropagationError(
-                f"Propagation with '==' is not supported for '{name}'."
+        # If the == syntax is used to propagate the spec architecture
+        # This is an error
+        architecture_names = [
+            "arch",
+            "architecture",
+            "platform",
+            "os",
+            "operating_system",
+            "target",
+        ]
+        if propagate and name in architecture_names:
+            raise ArchitecturePropagationError(
+                "Unable to propagate the architecture failed." " Use a '=' instead."
             )
 
         valid_flags = FlagMap.valid_compiler_flags()
@@ -1656,8 +1664,6 @@ def _add_flag(self, name, value, propagate):
             self._set_architecture(os=value)
         elif name == "target":
             self._set_architecture(target=value)
-        elif name == "namespace":
-            self.namespace = value
         elif name in valid_flags:
             assert self.compiler_flags is not None
             flags_and_propagation = spack.compiler.tokenize_flags(value, propagate)
@@ -1677,7 +1683,9 @@ def _set_architecture(self, **kwargs):
         """Called by the parser to set the architecture."""
         arch_attrs = ["platform", "os", "target"]
         if self.architecture and self.architecture.concrete:
-            raise DuplicateArchitectureError("Spec cannot have two architectures.")
+            raise DuplicateArchitectureError(
+                "Spec for '%s' cannot have two architectures." % self.name
+            )
 
         if not self.architecture:
             new_vals = tuple(kwargs.get(arg, None) for arg in arch_attrs)
@@ -1686,7 +1694,10 @@ def _set_architecture(self, **kwargs):
             new_attrvals = [(a, v) for a, v in kwargs.items() if a in arch_attrs]
             for new_attr, new_value in new_attrvals:
                 if getattr(self.architecture, new_attr):
-                    raise DuplicateArchitectureError(f"Cannot specify '{new_attr}' twice")
+                    raise DuplicateArchitectureError(
+                        "Spec for '%s' cannot have two '%s' specified "
+                        "for its architecture" % (self.name, new_attr)
+                    )
                 else:
                     setattr(self.architecture, new_attr, new_value)
 
@@ -1881,14 +1892,14 @@ def short_spec(self):
         """Returns a version of the spec with the dependencies hashed
         instead of completely enumerated."""
         spec_format = "{name}{@version}{%compiler.name}{@compiler.version}"
-        spec_format += "{variants}{ arch=architecture}{/hash:7}"
+        spec_format += "{variants}{arch=architecture}{/hash:7}"
         return self.format(spec_format)
 
     @property
     def cshort_spec(self):
         """Returns an auto-colorized version of ``self.short_spec``."""
         spec_format = "{name}{@version}{%compiler.name}{@compiler.version}"
-        spec_format += "{variants}{ arch=architecture}{/hash:7}"
+        spec_format += "{variants}{arch=architecture}{/hash:7}"
         return self.cformat(spec_format)
 
     @property
@@ -4247,21 +4258,29 @@ def __getitem__(self, name: str):
             csv = query_parameters.pop().strip()
             query_parameters = re.split(r"\s*,\s*", csv)
 
+        # In some cases a package appears multiple times in the same DAG for *distinct*
+        # specs. For example, a build-type dependency may itself depend on a package
+        # the current spec depends on, but their specs may differ. Therefore we iterate
+        # in an order here that prioritizes the build, test and runtime dependencies;
+        # only when we don't find the package do we consider the full DAG.
         order = lambda: itertools.chain(
-            self.traverse_edges(deptype=dt.LINK, order="breadth", cover="edges"),
-            self.edges_to_dependencies(depflag=dt.BUILD | dt.RUN | dt.TEST),
-            self.traverse_edges(deptype=dt.ALL, order="breadth", cover="edges"),
+            self.traverse(deptype="link"),
+            self.dependencies(deptype=dt.BUILD | dt.RUN | dt.TEST),
+            self.traverse(),  # fall back to a full search
         )
 
-        # Consider runtime dependencies and direct build/test deps before transitive dependencies,
-        # and prefer matches closest to the root.
         try:
             child: Spec = next(
-                e.spec
-                for e in itertools.chain(
-                    (e for e in order() if e.spec.name == name or name in e.virtuals),
-                    # for historical reasons
-                    (e for e in order() if e.spec.concrete and e.spec.package.provides(name)),
+                itertools.chain(
+                    # Regular specs
+                    (x for x in order() if x.name == name),
+                    (
+                        x
+                        for x in order()
+                        if (not x.virtual)
+                        and any(name in edge.virtuals for edge in x.edges_from_dependents())
+                    ),
+                    (x for x in order() if (not x.virtual) and x.package.provides(name)),
                 )
             )
         except StopIteration:
@@ -4373,19 +4392,14 @@ def deps():
 
         yield deps
 
-    @property
-    def namespace_if_anonymous(self):
-        return self.namespace if not self.name else None
-
     def format(self, format_string: str = DEFAULT_FORMAT, color: Optional[bool] = False) -> str:
-        r"""Prints out attributes of a spec according to a format string.
+        r"""Prints out particular pieces of a spec, depending on what is
+        in the format string.
 
-        Using an ``{attribute}`` format specifier, any field of the spec can be
-        selected. Those attributes can be recursive. For example,
-        ``s.format({compiler.version})`` will print the version of the compiler.
-
-        If the attribute in a format specifier evaluates to ``None``, then the format
-        specifier will evaluate to the empty string, ``""``.
+        Using the ``{attribute}`` syntax, any field of the spec can be
+        selected.  Those attributes can be recursive. For example,
+        ``s.format({compiler.version})`` will print the version of the
+        compiler.
 
         Commonly used attributes of the Spec for format strings include::
 
@@ -4401,7 +4415,6 @@ def format(self, format_string: str = DEFAULT_FORMAT, color: Optional[bool] = Fa
             architecture.os
             architecture.target
             prefix
-            namespace
 
         Some additional special-case properties can be added::
 
@@ -4410,51 +4423,40 @@ def format(self, format_string: str = DEFAULT_FORMAT, color: Optional[bool] = Fa
             spack_install The spack install directory
 
         The ``^`` sigil can be used to access dependencies by name.
-        ``s.format({^mpi.name})`` will print the name of the MPI implementation in the
-        spec.
+        ``s.format({^mpi.name})`` will print the name of the MPI
+        implementation in the spec.
 
-        The ``@``, ``%``, and ``/`` sigils can be used to include the sigil with the
-        printed string. These sigils may only be used with the appropriate attributes,
-        listed below::
+        The ``@``, ``%``, ``arch=``, and ``/`` sigils
+        can be used to include the sigil with the printed
+        string. These sigils may only be used with the appropriate
+        attributes, listed below::
 
             @        ``{@version}``, ``{@compiler.version}``
             %        ``{%compiler}``, ``{%compiler.name}``
+            arch=    ``{arch=architecture}``
             /        ``{/hash}``, ``{/hash:7}``, etc
 
-        The ``@`` sigil may also be used for any other property named ``version``.
-        Sigils printed with the attribute string are only printed if the attribute
-        string is non-empty, and are colored according to the color of the attribute.
+        The ``@`` sigil may also be used for any other property named
+        ``version``. Sigils printed with the attribute string are only
+        printed if the attribute string is non-empty, and are colored
+        according to the color of the attribute.
 
-        Variants listed by name naturally print with their sigil. For example,
-        ``spec.format('{variants.debug}')`` prints either ``+debug`` or ``~debug``
-        depending on the name of the variant. Non-boolean variants print as
-        ``name=value``. To print variant names or values independently, use
+        Sigils are not used for printing variants. Variants listed by
+        name naturally print with their sigil. For example,
+        ``spec.format('{variants.debug}')`` would print either
+        ``+debug`` or ``~debug`` depending on the name of the
+        variant. Non-boolean variants print as ``name=value``. To
+        print variant names or values independently, use
         ``spec.format('{variants.<name>.name}')`` or
         ``spec.format('{variants.<name>.value}')``.
 
-        There are a few attributes on specs that can be specified as key-value pairs
-        that are *not* variants, e.g.: ``os``, ``arch``, ``architecture``, ``target``,
-        ``namespace``, etc. You can format these with an optional ``key=`` prefix, e.g.
-        ``{namespace=namespace}`` or ``{arch=architecture}``, etc. The ``key=`` prefix
-        will be colorized along with the value.
-
-        When formatting specs, key-value pairs are separated from preceding parts of the
-        spec by whitespace. To avoid printing extra whitespace when the formatted
-        attribute is not set, you can add whitespace to the key *inside* the braces of
-        the format string, e.g.:
-
-            { namespace=namespace}
-
-        This evaluates to `` namespace=builtin`` if ``namespace`` is set to ``builtin``,
-        and to ``""`` if ``namespace`` is ``None``.
-
-        Spec format strings use ``\`` as the escape character. Use ``\{`` and ``\}`` for
-        literal braces, and ``\\`` for the literal ``\`` character.
+        Spec format strings use ``\`` as the escape character. Use
+        ``\{`` and ``\}`` for literal braces, and ``\\`` for the
+        literal ``\`` character.
 
         Args:
             format_string: string containing the format to be expanded
             color: True for colorized result; False for no color; None for auto color.
-
         """
         ensure_modern_format_string(format_string)
 
@@ -4508,6 +4510,10 @@ def format_attribute(match_object: Match) -> str:
                 raise SpecFormatSigilError(sig, "compilers", attribute)
             elif sig == "/" and attribute != "abstract_hash":
                 raise SpecFormatSigilError(sig, "DAG hashes", attribute)
+            elif sig == "arch=":
+                if attribute not in ("architecture", "arch"):
+                    raise SpecFormatSigilError(sig, "the architecture", attribute)
+                sig = " arch="  # include space as separator
 
             # Iterate over components using getattr to get next element
             for idx, part in enumerate(parts):
@@ -4552,19 +4558,15 @@ def format_attribute(match_object: Match) -> str:
 
             # Set color codes for various attributes
             color = None
-            if "architecture" in parts:
-                color = ARCHITECTURE_COLOR
-            elif "variants" in parts or sig.endswith("="):
+            if "variants" in parts:
                 color = VARIANT_COLOR
+            elif "architecture" in parts:
+                color = ARCHITECTURE_COLOR
             elif "compiler" in parts or "compiler_flags" in parts:
                 color = COMPILER_COLOR
             elif "version" in parts or "versions" in parts:
                 color = VERSION_COLOR
 
-            # return empty string if the value of the attribute is None.
-            if current is None:
-                return ""
-
             # return colored output
             return safe_color(sig, str(current), color)
 
@@ -4654,7 +4656,7 @@ def colored_str(self):
         spec_str = " ^".join(root_str + sorted_dependencies)
         return spec_str.strip()
 
-    def install_status(self) -> InstallStatus:
+    def install_status(self):
         """Helper for tree to print DB install status."""
         if not self.concrete:
             return InstallStatus.absent
@@ -5394,8 +5396,10 @@ def long_message(self):
         )
 
 
-class UnsupportedPropagationError(spack.error.SpecError):
-    """Raised when propagation (==) is used with reserved variant names."""
+class ArchitecturePropagationError(spack.error.SpecError):
+    """Raised when the double equal symbols are used to assign
+    the spec's architecture.
+    """
 
 
 class DuplicateDependencyError(spack.error.SpecError):
@@ -5525,7 +5529,7 @@ def __init__(self, spec):
 class AmbiguousHashError(spack.error.SpecError):
     def __init__(self, msg, *specs):
         spec_fmt = "{namespace}.{name}{@version}{%compiler}{compiler_flags}"
-        spec_fmt += "{variants}{ arch=architecture}{/hash:7}"
+        spec_fmt += "{variants}{arch=architecture}{/hash:7}"
         specs_str = "\n  " + "\n  ".join(spec.format(spec_fmt) for spec in specs)
         super().__init__(msg + specs_str)
 

lib/spack/spack/store.py

@@ -371,6 +371,7 @@ def use_store(
         data.update(extra_data)
 
     # Swap the store with the one just constructed and return it
+    ensure_singleton_created()
     spack.config.CONFIG.push_scope(
         spack.config.InternalConfigScope(name=scope_name, data={"config": {"install_tree": data}})
     )

lib/spack/spack/subprocess_context.py

@@ -79,11 +79,9 @@ def restore(self):
         self.test_state.restore()
         spack.main.spack_working_dir = self.spack_working_dir
         env = pickle.load(self.serialized_env) if _SERIALIZE else self.env
+        pkg = pickle.load(self.serialized_pkg) if _SERIALIZE else self.pkg
         if env:
             spack.environment.activate(env)
-        # Order of operation is important, since the package might be retrieved
-        # from a repo defined within the environment configuration
-        pkg = pickle.load(self.serialized_pkg) if _SERIALIZE else self.pkg
         return pkg
 
 

lib/spack/spack/test/architecture.py

@@ -213,9 +213,7 @@ def test_satisfy_strict_constraint_when_not_concrete(architecture_tuple, constra
     str(archspec.cpu.host().family) != "x86_64", reason="tests are for x86_64 uarch ranges"
 )
 def test_concretize_target_ranges(root_target_range, dep_target_range, result, monkeypatch):
-    spec = Spec(
-        f"pkg-a %gcc@10 foobar=bar target={root_target_range} ^pkg-b target={dep_target_range}"
-    )
+    spec = Spec(f"a %gcc@10 foobar=bar target={root_target_range} ^b target={dep_target_range}")
     with spack.concretize.disable_compiler_existence_check():
         spec.concretize()
-    assert spec.target == spec["pkg-b"].target == result
+    assert spec.target == spec["b"].target == result

lib/spack/spack/test/bindist.py

@@ -105,18 +105,18 @@ def config_directory(tmpdir_factory):
 
 
 @pytest.fixture(scope="function")
-def default_config(tmpdir, config_directory, monkeypatch, install_mockery):
-    # This fixture depends on install_mockery to ensure
+def default_config(tmpdir, config_directory, monkeypatch, install_mockery_mutable_config):
+    # This fixture depends on install_mockery_mutable_config to ensure
     # there is a clear order of initialization. The substitution of the
     # config scopes here is done on top of the substitution that comes with
-    # install_mockery
+    # install_mockery_mutable_config
     mutable_dir = tmpdir.mkdir("mutable_config").join("tmp")
     config_directory.copy(mutable_dir)
 
     cfg = spack.config.Configuration(
         *[
-            spack.config.DirectoryConfigScope(name, str(mutable_dir))
-            for name in [f"site/{platform.system().lower()}", "site", "user"]
+            spack.config.ConfigScope(name, str(mutable_dir))
+            for name in ["site/%s" % platform.system().lower(), "site", "user"]
         ]
     )
 
@@ -398,7 +398,9 @@ def fake_dag_hash(spec, length=None):
     return "tal4c7h4z0gqmixb1eqa92mjoybxn5l6"[:length]
 
 
-@pytest.mark.usefixtures("install_mockery", "mock_packages", "mock_fetch", "test_mirror")
+@pytest.mark.usefixtures(
+    "install_mockery_mutable_config", "mock_packages", "mock_fetch", "test_mirror"
+)
 def test_spec_needs_rebuild(monkeypatch, tmpdir):
     """Make sure needs_rebuild properly compares remote hash
     against locally computed one, avoiding unnecessary rebuilds"""
@@ -427,7 +429,7 @@ def test_spec_needs_rebuild(monkeypatch, tmpdir):
     assert rebuild
 
 
-@pytest.mark.usefixtures("install_mockery", "mock_packages", "mock_fetch")
+@pytest.mark.usefixtures("install_mockery_mutable_config", "mock_packages", "mock_fetch")
 def test_generate_index_missing(monkeypatch, tmpdir, mutable_config):
     """Ensure spack buildcache index only reports available packages"""
 
@@ -585,7 +587,9 @@ def test_update_sbang(tmpdir, test_mirror):
     str(archspec.cpu.host().family) != "x86_64",
     reason="test data uses gcc 4.5.0 which does not support aarch64",
 )
-def test_install_legacy_buildcache_layout(mutable_config, compiler_factory, install_mockery):
+def test_install_legacy_buildcache_layout(
+    mutable_config, compiler_factory, install_mockery_mutable_config
+):
     """Legacy buildcache layout involved a nested archive structure
     where the .spack file contained a repeated spec.json and another
     compressed archive file containing the install tree.  This test

lib/spack/spack/test/bootstrap.py

@@ -228,25 +228,3 @@ def test_source_is_disabled(mutable_config):
     spack.config.add("bootstrap:trusted:{0}:{1}".format(conf["name"], False))
     with pytest.raises(ValueError):
         spack.bootstrap.core.source_is_enabled_or_raise(conf)
-
-
-@pytest.mark.regression("45247")
-def test_use_store_does_not_try_writing_outside_root(tmp_path, monkeypatch, mutable_config):
-    """Tests that when we use the 'use_store' context manager, there is no attempt at creating
-    a Store outside the given root.
-    """
-    initial_store = mutable_config.get("config:install_tree:root")
-    user_store = tmp_path / "store"
-
-    fn = spack.store.Store.__init__
-
-    def _checked_init(self, root, *args, **kwargs):
-        fn(self, root, *args, **kwargs)
-        assert self.root == str(user_store)
-
-    monkeypatch.setattr(spack.store.Store, "__init__", _checked_init)
-
-    spack.store.reinitialize()
-    with spack.store.use_store(user_store):
-        assert spack.config.CONFIG.get("config:install_tree:root") == str(user_store)
-    assert spack.config.CONFIG.get("config:install_tree:root") == initial_store

lib/spack/spack/test/build_environment.py

@@ -6,7 +6,6 @@
 import os
 import platform
 import posixpath
-import sys
 
 import pytest
 
@@ -178,7 +177,7 @@ def _set_wrong_cc(x):
 
 
 def test_setup_dependent_package_inherited_modules(
-    working_env, mock_packages, install_mockery, mock_fetch
+    config, working_env, mock_packages, install_mockery, mock_fetch
 ):
     # This will raise on regression
     s = spack.spec.Spec("cmake-client-inheritor").concretized()
@@ -288,25 +287,6 @@ def platform_pathsep(pathlist):
         assert name not in os.environ
 
 
-def test_compiler_custom_env(config, mock_packages, monkeypatch, working_env):
-    if sys.platform == "win32":
-        test_path = r"C:\test\path\element\custom-env" + "\\"
-    else:
-        test_path = r"/test/path/element/custom-env/"
-
-    def custom_env(pkg, env):
-        env.prepend_path("PATH", test_path)
-        env.append_flags("ENV_CUSTOM_CC_FLAGS", "--custom-env-flag1")
-
-    pkg = spack.spec.Spec("cmake").concretized().package
-    monkeypatch.setattr(pkg.compiler, "setup_custom_environment", custom_env)
-    spack.build_environment.setup_package(pkg, False)
-
-    # Note: trailing slash may be stripped by internal logic
-    assert test_path[:-1] in os.environ["PATH"]
-    assert "--custom-env-flag1" in os.environ["ENV_CUSTOM_CC_FLAGS"]
-
-
 def test_external_config_env(mock_packages, mutable_config, working_env):
     cmake_config = {
         "externals": [
@@ -477,14 +457,14 @@ def test_parallel_false_is_not_propagating(default_mock_concretization):
     # a foobar=bar (parallel = False)
     # |
     # b (parallel =True)
-    s = default_mock_concretization("pkg-a foobar=bar")
+    s = default_mock_concretization("a foobar=bar")
 
     spack.build_environment.set_package_py_globals(s.package, context=Context.BUILD)
-    assert s["pkg-a"].package.module.make_jobs == 1
+    assert s["a"].package.module.make_jobs == 1
 
-    spack.build_environment.set_package_py_globals(s["pkg-b"].package, context=Context.BUILD)
-    assert s["pkg-b"].package.module.make_jobs == spack.build_environment.determine_number_of_jobs(
-        parallel=s["pkg-b"].package.parallel
+    spack.build_environment.set_package_py_globals(s["b"].package, context=Context.BUILD)
+    assert s["b"].package.module.make_jobs == spack.build_environment.determine_number_of_jobs(
+        parallel=s["b"].package.parallel
     )
 
 

lib/spack/spack/test/build_systems.py

@@ -94,10 +94,10 @@ def test_negative_ninja_check(self, input_dir, test_dir, concretize_and_setup):
 
 
 @pytest.mark.not_on_windows("autotools not available on windows")
-@pytest.mark.usefixtures("mock_packages")
+@pytest.mark.usefixtures("config", "mock_packages")
 class TestAutotoolsPackage:
     def test_with_or_without(self, default_mock_concretization):
-        s = default_mock_concretization("pkg-a")
+        s = default_mock_concretization("a")
         options = s.package.with_or_without("foo")
 
         # Ensure that values that are not representing a feature
@@ -129,7 +129,7 @@ def activate(value):
         assert "--without-lorem-ipsum" in options
 
     def test_none_is_allowed(self, default_mock_concretization):
-        s = default_mock_concretization("pkg-a foo=none")
+        s = default_mock_concretization("a foo=none")
         options = s.package.with_or_without("foo")
 
         # Ensure that values that are not representing a feature
@@ -139,9 +139,11 @@ def test_none_is_allowed(self, default_mock_concretization):
         assert "--without-baz" in options
         assert "--no-fee" in options
 
-    def test_libtool_archive_files_are_deleted_by_default(self, mutable_database):
+    def test_libtool_archive_files_are_deleted_by_default(
+        self, default_mock_concretization, mutable_database
+    ):
         # Install a package that creates a mock libtool archive
-        s = Spec("libtool-deletion").concretized()
+        s = default_mock_concretization("libtool-deletion")
         s.package.do_install(explicit=True)
 
         # Assert the libtool archive is not there and we have
@@ -152,23 +154,25 @@ def test_libtool_archive_files_are_deleted_by_default(self, mutable_database):
         assert libtool_deletion_log
 
     def test_libtool_archive_files_might_be_installed_on_demand(
-        self, mutable_database, monkeypatch
+        self, mutable_database, monkeypatch, default_mock_concretization
     ):
         # Install a package that creates a mock libtool archive,
         # patch its package to preserve the installation
-        s = Spec("libtool-deletion").concretized()
+        s = default_mock_concretization("libtool-deletion")
         monkeypatch.setattr(type(s.package.builder), "install_libtool_archives", True)
         s.package.do_install(explicit=True)
 
         # Assert libtool archives are installed
         assert os.path.exists(s.package.builder.libtool_archive_file)
 
-    def test_autotools_gnuconfig_replacement(self, mutable_database):
+    def test_autotools_gnuconfig_replacement(self, default_mock_concretization, mutable_database):
         """
         Tests whether only broken config.sub and config.guess are replaced with
         files from working alternatives from the gnuconfig package.
         """
-        s = Spec("autotools-config-replacement +patch_config_files +gnuconfig").concretized()
+        s = default_mock_concretization(
+            "autotools-config-replacement +patch_config_files +gnuconfig"
+        )
         s.package.do_install()
 
         with open(os.path.join(s.prefix.broken, "config.sub")) as f:
@@ -183,11 +187,15 @@ def test_autotools_gnuconfig_replacement(self, mutable_database):
         with open(os.path.join(s.prefix.working, "config.guess")) as f:
             assert "gnuconfig version of config.guess" not in f.read()
 
-    def test_autotools_gnuconfig_replacement_disabled(self, mutable_database):
+    def test_autotools_gnuconfig_replacement_disabled(
+        self, default_mock_concretization, mutable_database
+    ):
         """
         Tests whether disabling patch_config_files
         """
-        s = Spec("autotools-config-replacement ~patch_config_files +gnuconfig").concretized()
+        s = default_mock_concretization(
+            "autotools-config-replacement ~patch_config_files +gnuconfig"
+        )
         s.package.do_install()
 
         with open(os.path.join(s.prefix.broken, "config.sub")) as f:

lib/spack/spack/test/cc.py

@@ -355,15 +355,6 @@ def test_fc_flags(wrapper_environment, wrapper_flags):
     )
 
 
-def test_always_cflags(wrapper_environment, wrapper_flags):
-    with set_env(SPACK_ALWAYS_CFLAGS="-always1 -always2"):
-        check_args(
-            cc,
-            ["-v", "--cmd-line-v-opt"],
-            [real_cc] + ["-always1", "-always2"] + ["-v", "--cmd-line-v-opt"],
-        )
-
-
 def test_Wl_parsing(wrapper_environment):
     check_args(
         cc,

lib/spack/spack/test/ci.py

@@ -199,7 +199,7 @@ def __call__(self, *args, **kwargs):
     assert "Unable to merge {0}".format(c1) in err
 
 
-def test_get_spec_filter_list(mutable_mock_env_path, mutable_mock_repo):
+def test_get_spec_filter_list(mutable_mock_env_path, config, mutable_mock_repo):
     """Test that given an active environment and list of touched pkgs,
     we get the right list of possibly-changed env specs"""
     e1 = ev.create("test")
@@ -253,7 +253,7 @@ def test_get_spec_filter_list(mutable_mock_env_path, mutable_mock_repo):
 
 
 @pytest.mark.regression("29947")
-def test_affected_specs_on_first_concretization(mutable_mock_env_path, mock_packages):
+def test_affected_specs_on_first_concretization(mutable_mock_env_path, mock_packages, config):
     e = ev.create("first_concretization")
     e.add("mpileaks~shared")
     e.add("mpileaks+shared")
@@ -322,12 +322,12 @@ def test_ci_run_standalone_tests_missing_requirements(
 
 @pytest.mark.not_on_windows("Reliance on bash script not supported on Windows")
 def test_ci_run_standalone_tests_not_installed_junit(
-    tmp_path, repro_dir, working_env, mock_test_stage, capfd, mock_packages
+    tmp_path, repro_dir, working_env, default_mock_concretization, mock_test_stage, capfd
 ):
     log_file = tmp_path / "junit.xml"
     args = {
         "log_file": str(log_file),
-        "job_spec": spack.spec.Spec("printing-package").concretized(),
+        "job_spec": default_mock_concretization("printing-package"),
         "repro_dir": str(repro_dir),
         "fail_fast": True,
     }
@@ -340,13 +340,13 @@ def test_ci_run_standalone_tests_not_installed_junit(
 
 @pytest.mark.not_on_windows("Reliance on bash script not supported on Windows")
 def test_ci_run_standalone_tests_not_installed_cdash(
-    tmp_path, repro_dir, working_env, mock_test_stage, capfd, mock_packages
+    tmp_path, repro_dir, working_env, default_mock_concretization, mock_test_stage, capfd
 ):
     """Test run_standalone_tests with cdash and related options."""
     log_file = tmp_path / "junit.xml"
     args = {
         "log_file": str(log_file),
-        "job_spec": spack.spec.Spec("printing-package").concretized(),
+        "job_spec": default_mock_concretization("printing-package"),
         "repro_dir": str(repro_dir),
     }
 

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

@@ -48,6 +48,11 @@ def mock_get_specs_multiarch(database, monkeypatch):
     monkeypatch.setattr(spack.binary_distribution, "update_cache_and_get_specs", lambda: specs)
 
 
+def test_buildcache_preview_just_runs():
+    # TODO: remove in Spack 0.21
+    buildcache("preview", "mpileaks")
+
+
 @pytest.mark.db
 @pytest.mark.regression("13757")
 def test_buildcache_list_duplicates(mock_get_specs, capsys):
@@ -184,7 +189,12 @@ def test_buildcache_autopush(tmp_path, install_mockery, mock_fetch):
 
 
 def test_buildcache_sync(
-    mutable_mock_env_path, install_mockery, mock_packages, mock_fetch, mock_stage, tmpdir
+    mutable_mock_env_path,
+    install_mockery_mutable_config,
+    mock_packages,
+    mock_fetch,
+    mock_stage,
+    tmpdir,
 ):
     """
     Make sure buildcache sync works in an environment-aware manner, ignoring
@@ -313,7 +323,7 @@ def manifest_insert(manifest, spec, dest_url):
 
 def test_buildcache_create_install(
     mutable_mock_env_path,
-    install_mockery,
+    install_mockery_mutable_config,
     mock_packages,
     mock_fetch,
     mock_stage,

lib/spack/spack/test/cmd/checksum.py

@@ -83,6 +83,7 @@ def test_checksum_args(arguments, expected):
     assert check == expected
 
 
+@pytest.mark.not_on_windows("Not supported on Windows (yet)")
 @pytest.mark.parametrize(
     "arguments,expected",
     [

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

@@ -106,24 +106,24 @@ def test_specs_staging(config, tmpdir):
 
 """
     builder = repo.MockRepositoryBuilder(tmpdir)
-    builder.add_package("pkg-g")
-    builder.add_package("pkg-f")
-    builder.add_package("pkg-e")
-    builder.add_package("pkg-d", dependencies=[("pkg-f", None, None), ("pkg-g", None, None)])
-    builder.add_package("pkg-c")
-    builder.add_package("pkg-b", dependencies=[("pkg-d", None, None), ("pkg-e", None, None)])
-    builder.add_package("pkg-a", dependencies=[("pkg-b", None, None), ("pkg-c", None, None)])
+    builder.add_package("g")
+    builder.add_package("f")
+    builder.add_package("e")
+    builder.add_package("d", dependencies=[("f", None, None), ("g", None, None)])
+    builder.add_package("c")
+    builder.add_package("b", dependencies=[("d", None, None), ("e", None, None)])
+    builder.add_package("a", dependencies=[("b", None, None), ("c", None, None)])
 
     with repo.use_repositories(builder.root):
-        spec_a = Spec("pkg-a").concretized()
+        spec_a = Spec("a").concretized()
 
         spec_a_label = ci._spec_ci_label(spec_a)
-        spec_b_label = ci._spec_ci_label(spec_a["pkg-b"])
-        spec_c_label = ci._spec_ci_label(spec_a["pkg-c"])
-        spec_d_label = ci._spec_ci_label(spec_a["pkg-d"])
-        spec_e_label = ci._spec_ci_label(spec_a["pkg-e"])
-        spec_f_label = ci._spec_ci_label(spec_a["pkg-f"])
-        spec_g_label = ci._spec_ci_label(spec_a["pkg-g"])
+        spec_b_label = ci._spec_ci_label(spec_a["b"])
+        spec_c_label = ci._spec_ci_label(spec_a["c"])
+        spec_d_label = ci._spec_ci_label(spec_a["d"])
+        spec_e_label = ci._spec_ci_label(spec_a["e"])
+        spec_f_label = ci._spec_ci_label(spec_a["f"])
+        spec_g_label = ci._spec_ci_label(spec_a["g"])
 
         spec_labels, dependencies, stages = ci.stage_spec_jobs([spec_a])
 
@@ -748,7 +748,7 @@ def test_ci_rebuild_mock_success(
     tmpdir,
     working_env,
     mutable_mock_env_path,
-    install_mockery,
+    install_mockery_mutable_config,
     mock_gnupghome,
     mock_stage,
     mock_fetch,
@@ -782,7 +782,7 @@ def test_ci_rebuild_mock_failure_to_push(
     tmpdir,
     working_env,
     mutable_mock_env_path,
-    install_mockery,
+    install_mockery_mutable_config,
     mock_gnupghome,
     mock_stage,
     mock_fetch,
@@ -820,7 +820,7 @@ def test_ci_rebuild(
     tmpdir,
     working_env,
     mutable_mock_env_path,
-    install_mockery,
+    install_mockery_mutable_config,
     mock_packages,
     monkeypatch,
     mock_gnupghome,
@@ -1019,7 +1019,7 @@ def fake_dl_method(spec, *args, **kwargs):
 def test_ci_generate_mirror_override(
     tmpdir,
     mutable_mock_env_path,
-    install_mockery,
+    install_mockery_mutable_config,
     mock_packages,
     mock_fetch,
     mock_stage,
@@ -1104,7 +1104,7 @@ def test_ci_generate_mirror_override(
 def test_push_to_build_cache(
     tmpdir,
     mutable_mock_env_path,
-    install_mockery,
+    install_mockery_mutable_config,
     mock_packages,
     mock_fetch,
     mock_stage,
@@ -1290,7 +1290,7 @@ def test_ci_generate_override_runner_attrs(
 spack:
   specs:
     - flatten-deps
-    - pkg-a
+    - a
   mirrors:
     some-mirror: https://my.fake.mirror
   ci:
@@ -1307,12 +1307,12 @@ def test_ci_generate_override_runner_attrs(
         - match:
             - dependency-install
         - match:
-            - pkg-a
+            - a
           build-job:
             tags:
               - specific-a-2
         - match:
-            - pkg-a
+            - a
           build-job-remove:
             tags:
               - toplevel2
@@ -1372,8 +1372,8 @@ def test_ci_generate_override_runner_attrs(
             assert global_vars["SPACK_CHECKOUT_VERSION"] == git_version or "v0.20.0.test0"
 
             for ci_key in yaml_contents.keys():
-                if ci_key.startswith("pkg-a"):
-                    # Make sure pkg-a's attributes override variables, and all the
+                if ci_key.startswith("a"):
+                    # Make sure a's attributes override variables, and all the
                     # scripts.  Also, make sure the 'toplevel' tag doesn't
                     # appear twice, but that a's specific extra tag does appear
                     the_elt = yaml_contents[ci_key]
@@ -1781,7 +1781,7 @@ def test_ci_generate_read_broken_specs_url(
     tmpdir, mutable_mock_env_path, install_mockery, mock_packages, monkeypatch, ci_base_environment
 ):
     """Verify that `broken-specs-url` works as intended"""
-    spec_a = Spec("pkg-a")
+    spec_a = Spec("a")
     spec_a.concretize()
     a_dag_hash = spec_a.dag_hash()
 
@@ -1807,7 +1807,7 @@ def test_ci_generate_read_broken_specs_url(
 spack:
   specs:
     - flatten-deps
-    - pkg-a
+    - a
   mirrors:
     some-mirror: https://my.fake.mirror
   ci:
@@ -1815,9 +1815,9 @@ def test_ci_generate_read_broken_specs_url(
     pipeline-gen:
     - submapping:
       - match:
-          - pkg-a
+          - a
           - flatten-deps
-          - pkg-b
+          - b
           - dependency-install
         build-job:
           tags:

lib/spack/spack/test/cmd/common/arguments.py

@@ -72,6 +72,7 @@ def test_parse_spec_flags_with_spaces(specs, cflags, propagation, negated_varian
         assert "~{0}".format(v) in s
 
 
+@pytest.mark.usefixtures("config")
 def test_match_spec_env(mock_packages, mutable_mock_env_path):
     """
     Concretize a spec with non-default options in an environment. Make
@@ -80,42 +81,44 @@ def test_match_spec_env(mock_packages, mutable_mock_env_path):
     """
     # Initial sanity check: we are planning on choosing a non-default
     # value, so make sure that is in fact not the default.
-    check_defaults = spack.cmd.parse_specs(["pkg-a"], concretize=True)[0]
+    check_defaults = spack.cmd.parse_specs(["a"], concretize=True)[0]
     assert not check_defaults.satisfies("foobar=baz")
 
     e = ev.create("test")
-    e.add("pkg-a foobar=baz")
+    e.add("a foobar=baz")
     e.concretize()
     with e:
-        env_spec = spack.cmd.matching_spec_from_env(spack.cmd.parse_specs(["pkg-a"])[0])
+        env_spec = spack.cmd.matching_spec_from_env(spack.cmd.parse_specs(["a"])[0])
         assert env_spec.satisfies("foobar=baz")
         assert env_spec.concrete
 
 
+@pytest.mark.usefixtures("config")
 def test_multiple_env_match_raises_error(mock_packages, mutable_mock_env_path):
     e = ev.create("test")
-    e.add("pkg-a foobar=baz")
-    e.add("pkg-a foobar=fee")
+    e.add("a foobar=baz")
+    e.add("a foobar=fee")
     e.concretize()
     with e:
         with pytest.raises(ev.SpackEnvironmentError) as exc_info:
-            spack.cmd.matching_spec_from_env(spack.cmd.parse_specs(["pkg-a"])[0])
+            spack.cmd.matching_spec_from_env(spack.cmd.parse_specs(["a"])[0])
 
     assert "matches multiple specs" in exc_info.value.message
 
 
+@pytest.mark.usefixtures("config")
 def test_root_and_dep_match_returns_root(mock_packages, mutable_mock_env_path):
     e = ev.create("test")
-    e.add("pkg-b@0.9")
-    e.add("pkg-a foobar=bar")  # Depends on b, should choose b@1.0
+    e.add("b@0.9")
+    e.add("a foobar=bar")  # Depends on b, should choose b@1.0
     e.concretize()
     with e:
         # This query matches the root b and b as a dependency of a. In that
         # case the root instance should be preferred.
-        env_spec1 = spack.cmd.matching_spec_from_env(spack.cmd.parse_specs(["pkg-b"])[0])
+        env_spec1 = spack.cmd.matching_spec_from_env(spack.cmd.parse_specs(["b"])[0])
         assert env_spec1.satisfies("@0.9")
 
-        env_spec2 = spack.cmd.matching_spec_from_env(spack.cmd.parse_specs(["pkg-b@1.0"])[0])
+        env_spec2 = spack.cmd.matching_spec_from_env(spack.cmd.parse_specs(["b@1.0"])[0])
         assert env_spec2
 
 

lib/spack/spack/test/cmd/concretize.py

@@ -10,7 +10,7 @@
 from spack import spack_version
 from spack.main import SpackCommand
 
-pytestmark = pytest.mark.usefixtures("mutable_config", "mutable_mock_repo")
+pytestmark = pytest.mark.usefixtures("config", "mutable_mock_repo")
 
 env = SpackCommand("env")
 add = SpackCommand("add")
@@ -51,8 +51,8 @@ def test_concretize_root_test_dependencies_are_concretized(unify, mutable_mock_e
 
     with ev.read("test") as e:
         e.unify = unify
-        add("pkg-a")
-        add("pkg-b")
+        add("a")
+        add("b")
         concretize("--test", "root")
         assert e.matching_spec("test-dependency")
 

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

@@ -640,4 +640,4 @@ def update_config(data):
         config("update", "-y", "config")
 
     with ev.Environment(str(tmpdir)) as e:
-        assert not e.manifest.yaml_content["spack"]["config"]["ccache"]
+        assert not e.manifest.pristine_yaml_content["spack"]["config"]["ccache"]

lib/spack/spack/test/cmd/deconcretize.py

@@ -12,29 +12,29 @@
 
 
 @pytest.fixture(scope="function")
-def test_env(mutable_mock_env_path, mock_packages):
+def test_env(mutable_mock_env_path, config, mock_packages):
     ev.create("test")
     with ev.read("test") as e:
-        e.add("pkg-a@2.0 foobar=bar ^pkg-b@1.0")
-        e.add("pkg-a@1.0 foobar=bar ^pkg-b@0.9")
+        e.add("a@2.0 foobar=bar ^b@1.0")
+        e.add("a@1.0 foobar=bar ^b@0.9")
         e.concretize()
         e.write()
 
 
 def test_deconcretize_dep(test_env):
     with ev.read("test") as e:
-        deconcretize("-y", "pkg-b@1.0")
+        deconcretize("-y", "b@1.0")
         specs = [s for s, _ in e.concretized_specs()]
 
     assert len(specs) == 1
-    assert specs[0].satisfies("pkg-a@1.0")
+    assert specs[0].satisfies("a@1.0")
 
 
 def test_deconcretize_all_dep(test_env):
     with ev.read("test") as e:
         with pytest.raises(SpackCommandError):
-            deconcretize("-y", "pkg-b")
-        deconcretize("-y", "--all", "pkg-b")
+            deconcretize("-y", "b")
+        deconcretize("-y", "--all", "b")
         specs = [s for s, _ in e.concretized_specs()]
 
     assert len(specs) == 0
@@ -42,27 +42,27 @@ def test_deconcretize_all_dep(test_env):
 
 def test_deconcretize_root(test_env):
     with ev.read("test") as e:
-        output = deconcretize("-y", "--root", "pkg-b@1.0")
+        output = deconcretize("-y", "--root", "b@1.0")
         assert "No matching specs to deconcretize" in output
         assert len(e.concretized_order) == 2
 
-        deconcretize("-y", "--root", "pkg-a@2.0")
+        deconcretize("-y", "--root", "a@2.0")
         specs = [s for s, _ in e.concretized_specs()]
 
     assert len(specs) == 1
-    assert specs[0].satisfies("pkg-a@1.0")
+    assert specs[0].satisfies("a@1.0")
 
 
 def test_deconcretize_all_root(test_env):
     with ev.read("test") as e:
         with pytest.raises(SpackCommandError):
-            deconcretize("-y", "--root", "pkg-a")
+            deconcretize("-y", "--root", "a")
 
-        output = deconcretize("-y", "--root", "--all", "pkg-b")
+        output = deconcretize("-y", "--root", "--all", "b")
         assert "No matching specs to deconcretize" in output
         assert len(e.concretized_order) == 2
 
-        deconcretize("-y", "--root", "--all", "pkg-a")
+        deconcretize("-y", "--root", "--all", "a")
         specs = [s for s, _ in e.concretized_specs()]
 
     assert len(specs) == 0

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

@@ -14,6 +14,8 @@
 deprecate = SpackCommand("deprecate")
 find = SpackCommand("find")
 
+pytestmark = pytest.mark.not_on_windows("does not run on windows")
+
 
 def test_deprecate(mock_packages, mock_archive, mock_fetch, install_mockery):
     install("libelf@0.8.13")

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

@@ -20,7 +20,10 @@
 install = SpackCommand("install")
 env = SpackCommand("env")
 
-pytestmark = [pytest.mark.disable_clean_stage_check]
+pytestmark = [
+    pytest.mark.not_on_windows("does not run on windows"),
+    pytest.mark.disable_clean_stage_check,
+]
 
 
 def test_dev_build_basics(tmpdir, install_mockery):
@@ -93,7 +96,7 @@ def test_dev_build_until_last_phase(tmpdir, install_mockery):
     assert os.path.exists(str(tmpdir))
 
 
-def test_dev_build_before_until(tmpdir, install_mockery):
+def test_dev_build_before_until(tmpdir, install_mockery, capsys):
     spec = spack.spec.Spec(f"dev-build-test-install@0.0.0 dev_path={tmpdir}").concretized()
 
     with tmpdir.as_cwd():
@@ -126,7 +129,7 @@ def test_dev_build_drop_in(tmpdir, mock_packages, monkeypatch, install_mockery,
     monkeypatch.setattr(os, "execvp", print_spack_cc)
     with tmpdir.as_cwd():
         output = dev_build("-b", "edit", "--drop-in", "sh", "dev-build-test-install@0.0.0")
-        assert os.path.join("lib", "spack", "env") in output
+        assert "lib/spack/env" in output
 
 
 def test_dev_build_fails_already_installed(tmpdir, install_mockery):

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

@@ -181,6 +181,7 @@ def test_diff_cmd(install_mockery, mock_fetch, mock_archive, mock_packages):
     assert ["hash", "mpileaks %s" % specB.dag_hash()] in c["b_not_a"]
 
 
+@pytest.mark.not_on_windows("Not supported on Windows (yet)")
 def test_load_first(install_mockery, mock_fetch, mock_archive, mock_packages):
     """Test with and without the --first option"""
     install_cmd("mpileaks")

lib/spack/spack/test/cmd/edit.py

@@ -15,9 +15,9 @@
 
 
 def test_edit_packages(monkeypatch, mock_packages: spack.repo.RepoPath):
-    """Test spack edit pkg-a pkg-b"""
-    path_a = mock_packages.filename_for_package_name("pkg-a")
-    path_b = mock_packages.filename_for_package_name("pkg-b")
+    """Test spack edit a b"""
+    path_a = mock_packages.filename_for_package_name("a")
+    path_b = mock_packages.filename_for_package_name("b")
     called = False
 
     def editor(*args: str, **kwargs):
@@ -27,7 +27,7 @@ def editor(*args: str, **kwargs):
         assert args[1] == path_b
 
     monkeypatch.setattr(spack.util.editor, "editor", editor)
-    edit("pkg-a", "pkg-b")
+    edit("a", "b")
     assert called
 
 

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

@@ -28,9 +28,7 @@
 import spack.package_base
 import spack.paths
 import spack.repo
-import spack.store
 import spack.util.spack_json as sjson
-import spack.util.spack_yaml
 from spack.cmd.env import _env_create
 from spack.main import SpackCommand, SpackCommandError
 from spack.spec import Spec
@@ -42,7 +40,7 @@
 # TODO-27021
 # everything here uses the mock_env_path
 pytestmark = [
-    pytest.mark.usefixtures("mutable_config", "mutable_mock_env_path", "mutable_mock_repo"),
+    pytest.mark.usefixtures("mutable_mock_env_path", "config", "mutable_mock_repo"),
     pytest.mark.maybeslow,
     pytest.mark.not_on_windows("Envs unsupported on Window"),
 ]
@@ -503,7 +501,7 @@ def test_env_install_two_specs_same_dep(install_mockery, mock_fetch, tmpdir, cap
                 """\
 spack:
   specs:
-  - pkg-a
+  - a
   - depb
 """
             )
@@ -522,8 +520,8 @@ def test_env_install_two_specs_same_dep(install_mockery, mock_fetch, tmpdir, cap
     depb = spack.store.STORE.db.query_one("depb", installed=True)
     assert depb, "Expected depb to be installed"
 
-    a = spack.store.STORE.db.query_one("pkg-a", installed=True)
-    assert a, "Expected pkg-a to be installed"
+    a = spack.store.STORE.db.query_one("a", installed=True)
+    assert a, "Expected a to be installed"
 
 
 def test_remove_after_concretize():
@@ -814,6 +812,7 @@ def test_init_from_yaml(environment_from_manifest):
     assert not e2.specs_by_hash
 
 
+@pytest.mark.usefixtures("config")
 def test_env_view_external_prefix(tmp_path, mutable_database, mock_packages):
     fake_prefix = tmp_path / "a-prefix"
     fake_bin = fake_prefix / "bin"
@@ -826,7 +825,7 @@ def test_env_view_external_prefix(tmp_path, mutable_database, mock_packages):
         """\
 spack:
   specs:
-  - pkg-a
+  - a
   view: true
 """
     )
@@ -834,9 +833,9 @@ def test_env_view_external_prefix(tmp_path, mutable_database, mock_packages):
     external_config = io.StringIO(
         """\
 packages:
-  pkg-a:
+  a:
     externals:
-    - spec: pkg-a@2.0
+    - spec: a@2.0
       prefix: {a_prefix}
     buildable: false
 """.format(
@@ -1560,6 +1559,7 @@ def test_uninstall_removes_from_env(mock_stage, mock_fetch, install_mockery):
     assert not test.user_specs
 
 
+@pytest.mark.usefixtures("config")
 def test_indirect_build_dep(tmp_path):
     """Simple case of X->Y->Z where Y is a build/link dep and Z is a
     build-only dep. Make sure this concrete DAG is preserved when writing the
@@ -1587,6 +1587,7 @@ def test_indirect_build_dep(tmp_path):
         assert x_env_spec == x_concretized
 
 
+@pytest.mark.usefixtures("config")
 def test_store_different_build_deps(tmp_path):
     r"""Ensure that an environment can store two instances of a build-only
     dependency::
@@ -2327,7 +2328,7 @@ def test_stack_yaml_force_remove_from_matrix(tmpdir):
             assert mpileaks_spec not in after_conc
 
 
-def test_stack_concretize_extraneous_deps(tmpdir, mock_packages):
+def test_stack_concretize_extraneous_deps(tmpdir, config, mock_packages):
     # FIXME: The new concretizer doesn't handle yet soft
     # FIXME: constraints for stacks
     # FIXME: This now works for statically-determinable invalid deps
@@ -2366,7 +2367,7 @@ def test_stack_concretize_extraneous_deps(tmpdir, mock_packages):
                 assert concrete.satisfies("^mpi")
 
 
-def test_stack_concretize_extraneous_variants(tmpdir, mock_packages):
+def test_stack_concretize_extraneous_variants(tmpdir, config, mock_packages):
     filename = str(tmpdir.join("spack.yaml"))
     with open(filename, "w") as f:
         f.write(
@@ -2398,7 +2399,7 @@ def test_stack_concretize_extraneous_variants(tmpdir, mock_packages):
                 assert concrete.variants["shared"].value == user.variants["shared"].value
 
 
-def test_stack_concretize_extraneous_variants_with_dash(tmpdir, mock_packages):
+def test_stack_concretize_extraneous_variants_with_dash(tmpdir, config, mock_packages):
     filename = str(tmpdir.join("spack.yaml"))
     with open(filename, "w") as f:
         f.write(
@@ -3749,7 +3750,7 @@ def test_environment_query_spec_by_hash(mock_stage, mock_fetch, install_mockery)
 
 
 @pytest.mark.parametrize("lockfile", ["v1", "v2", "v3"])
-def test_read_old_lock_and_write_new(tmpdir, lockfile):
+def test_read_old_lock_and_write_new(config, tmpdir, lockfile):
     # v1 lockfiles stored by a coarse DAG hash that did not include build deps.
     # They could not represent multiple build deps with different build hashes.
     #
@@ -3815,7 +3816,7 @@ def test_read_old_lock_and_write_new(tmpdir, lockfile):
     assert old_hashes == hashes
 
 
-def test_read_v1_lock_creates_backup(tmp_path):
+def test_read_v1_lock_creates_backup(config, tmp_path):
     """When reading a version-1 lockfile, make sure that a backup of that file
     is created.
     """
@@ -4198,7 +4199,7 @@ def test_env_include_packages_url(
         assert "openmpi" in cfg["all"]["providers"]["mpi"]
 
 
-def test_relative_view_path_on_command_line_is_made_absolute(tmp_path):
+def test_relative_view_path_on_command_line_is_made_absolute(tmp_path, config):
     with fs.working_dir(str(tmp_path)):
         env("create", "--with-view", "view", "--dir", "env")
         environment = ev.Environment(os.path.join(".", "env"))

lib/spack/spack/test/cmd/extensions.py

@@ -24,7 +24,7 @@ def python_database(mock_packages, mutable_database):
 
 @pytest.mark.not_on_windows("All Fetchers Failed")
 @pytest.mark.db
-def test_extensions(mock_packages, python_database, capsys):
+def test_extensions(mock_packages, python_database, config, capsys):
     ext2 = Spec("py-extension2").concretized()
 
     def check_output(ni):

lib/spack/spack/test/cmd/external.py

@@ -11,7 +11,6 @@
 from llnl.util.filesystem import getuid, touch
 
 import spack
-import spack.cmd.external
 import spack.detection
 import spack.detection.path
 from spack.main import SpackCommand
@@ -312,29 +311,3 @@ def test_failures_in_scanning_do_not_result_in_an_error(
     assert "cmake" in output
     assert "3.23.3" in output
     assert "3.19.1" not in output
-
-
-def test_detect_virtuals(mock_executable, mutable_config, monkeypatch):
-    """Test whether external find --not-buildable sets virtuals as non-buildable (unless user
-    config sets them to buildable)"""
-    mpich = mock_executable("mpichversion", output="echo MPICH Version:    4.0.2")
-    prefix = os.path.dirname(mpich)
-    external("find", "--path", prefix, "--not-buildable", "mpich")
-
-    # Check that mpich was correctly detected
-    mpich = mutable_config.get("packages:mpich")
-    assert mpich["buildable"] is False
-    assert Spec(mpich["externals"][0]["spec"]).satisfies("mpich@4.0.2")
-
-    # Check that the virtual package mpi was marked as non-buildable
-    assert mutable_config.get("packages:mpi:buildable") is False
-
-    # Delete the mpich entry, and set mpi explicitly to buildable
-    mutable_config.set("packages:mpich", {})
-    mutable_config.set("packages:mpi:buildable", True)
-
-    # Run the detection again
-    external("find", "--path", prefix, "--not-buildable", "mpich")
-
-    # Check that the mpi:buildable entry was not overwritten
-    assert mutable_config.get("packages:mpi:buildable") is True

lib/spack/spack/test/cmd/fetch.py

@@ -9,9 +9,7 @@
 from spack.main import SpackCommand, SpackCommandError
 
 # everything here uses the mock_env_path
-pytestmark = pytest.mark.usefixtures(
-    "mutable_mock_env_path", "mutable_config", "mutable_mock_repo"
-)
+pytestmark = pytest.mark.usefixtures("mutable_mock_env_path", "config", "mutable_mock_repo")
 
 
 @pytest.mark.disable_clean_stage_check

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

@@ -337,7 +337,7 @@ def test_find_command_basic_usage(database):
 @pytest.mark.not_on_windows("envirnment is not yet supported on windows")
 @pytest.mark.regression("9875")
 def test_find_prefix_in_env(
-    mutable_mock_env_path, install_mockery, mock_fetch, mock_packages, mock_archive
+    mutable_mock_env_path, install_mockery, mock_fetch, mock_packages, mock_archive, config
 ):
     """Test `find` formats requiring concrete specs work in environments."""
     env("create", "test")
@@ -349,7 +349,7 @@ def test_find_prefix_in_env(
         # Would throw error on regression
 
 
-def test_find_specs_include_concrete_env(mutable_mock_env_path, mutable_mock_repo, tmpdir):
+def test_find_specs_include_concrete_env(mutable_mock_env_path, config, mutable_mock_repo, tmpdir):
     path = tmpdir.join("spack.yaml")
 
     with tmpdir.as_cwd():
@@ -393,7 +393,9 @@ def test_find_specs_include_concrete_env(mutable_mock_env_path, mutable_mock_rep
     assert "libelf" in output
 
 
-def test_find_specs_nested_include_concrete_env(mutable_mock_env_path, mutable_mock_repo, tmpdir):
+def test_find_specs_nested_include_concrete_env(
+    mutable_mock_env_path, config, mutable_mock_repo, tmpdir
+):
     path = tmpdir.join("spack.yaml")
 
     with tmpdir.as_cwd():

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

@@ -20,13 +20,13 @@
 
 
 @pytest.mark.db
-def test_gc_without_build_dependency(mutable_database):
+def test_gc_without_build_dependency(config, mutable_database):
     assert "There are no unused specs." in gc("-yb")
     assert "There are no unused specs." in gc("-y")
 
 
 @pytest.mark.db
-def test_gc_with_build_dependency(mutable_database):
+def test_gc_with_build_dependency(config, mutable_database):
     s = spack.spec.Spec("simple-inheritance")
     s.concretize()
     s.package.do_install(fake=True, explicit=True)
@@ -37,7 +37,7 @@ def test_gc_with_build_dependency(mutable_database):
 
 
 @pytest.mark.db
-def test_gc_with_environment(mutable_database, mutable_mock_env_path):
+def test_gc_with_environment(config, mutable_database, mutable_mock_env_path):
     s = spack.spec.Spec("simple-inheritance")
     s.concretize()
     s.package.do_install(fake=True, explicit=True)
@@ -53,7 +53,7 @@ def test_gc_with_environment(mutable_database, mutable_mock_env_path):
 
 
 @pytest.mark.db
-def test_gc_with_build_dependency_in_environment(mutable_database, mutable_mock_env_path):
+def test_gc_with_build_dependency_in_environment(config, mutable_database, mutable_mock_env_path):
     s = spack.spec.Spec("simple-inheritance")
     s.concretize()
     s.package.do_install(fake=True, explicit=True)
@@ -78,7 +78,7 @@ def test_gc_with_build_dependency_in_environment(mutable_database, mutable_mock_
 
 
 @pytest.mark.db
-def test_gc_except_any_environments(mutable_database, mutable_mock_env_path):
+def test_gc_except_any_environments(config, mutable_database, mutable_mock_env_path):
     """Tests whether the garbage collector can remove all specs except those still needed in some
     environment (needed in the sense of roots + link/run deps)."""
     assert mutable_database.query_local("zmpi")
@@ -105,7 +105,7 @@ def test_gc_except_any_environments(mutable_database, mutable_mock_env_path):
 
 
 @pytest.mark.db
-def test_gc_except_specific_environments(mutable_database, mutable_mock_env_path):
+def test_gc_except_specific_environments(config, mutable_database, mutable_mock_env_path):
     s = spack.spec.Spec("simple-inheritance")
     s.concretize()
     s.package.do_install(fake=True, explicit=True)
@@ -125,14 +125,14 @@ def test_gc_except_specific_environments(mutable_database, mutable_mock_env_path
 
 
 @pytest.mark.db
-def test_gc_except_nonexisting_dir_env(mutable_database, mutable_mock_env_path, tmpdir):
+def test_gc_except_nonexisting_dir_env(config, mutable_database, mutable_mock_env_path, tmpdir):
     output = gc("-ye", tmpdir.strpath, fail_on_error=False)
     assert "No such environment" in output
     gc.returncode == 1
 
 
 @pytest.mark.db
-def test_gc_except_specific_dir_env(mutable_database, mutable_mock_env_path, tmpdir):
+def test_gc_except_specific_dir_env(config, mutable_database, mutable_mock_env_path, tmpdir):
     s = spack.spec.Spec("simple-inheritance")
     s.concretize()
     s.package.do_install(fake=True, explicit=True)

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

@@ -49,7 +49,7 @@ def noop(*args, **kwargs):
 
 
 def test_install_package_and_dependency(
-    tmpdir, mock_packages, mock_archive, mock_fetch, install_mockery
+    tmpdir, mock_packages, mock_archive, mock_fetch, config, install_mockery
 ):
     log = "test"
     with tmpdir.as_cwd():
@@ -89,11 +89,11 @@ def check(pkg):
         assert pkg.run_tests
 
     monkeypatch.setattr(spack.package_base.PackageBase, "unit_test_check", check)
-    install("--test=all", "pkg-a")
+    install("--test=all", "a")
 
 
 def test_install_package_already_installed(
-    tmpdir, mock_packages, mock_archive, mock_fetch, install_mockery
+    tmpdir, mock_packages, mock_archive, mock_fetch, config, install_mockery
 ):
     with tmpdir.as_cwd():
         install("libdwarf")
@@ -149,7 +149,7 @@ def test_package_output(tmpdir, capsys, install_mockery, mock_fetch):
 
 @pytest.mark.disable_clean_stage_check
 def test_install_output_on_build_error(
-    mock_packages, mock_archive, mock_fetch, install_mockery, capfd
+    mock_packages, mock_archive, mock_fetch, config, install_mockery, capfd
 ):
     """
     This test used to assume receiving full output, but since we've updated
@@ -163,7 +163,9 @@ def test_install_output_on_build_error(
 
 
 @pytest.mark.disable_clean_stage_check
-def test_install_output_on_python_error(mock_packages, mock_archive, mock_fetch, install_mockery):
+def test_install_output_on_python_error(
+    mock_packages, mock_archive, mock_fetch, config, install_mockery
+):
     out = install("failing-build", fail_on_error=False)
     assert isinstance(install.error, spack.build_environment.ChildError)
     assert install.error.name == "InstallError"
@@ -171,7 +173,7 @@ def test_install_output_on_python_error(mock_packages, mock_archive, mock_fetch,
 
 
 @pytest.mark.disable_clean_stage_check
-def test_install_with_source(mock_packages, mock_archive, mock_fetch, install_mockery):
+def test_install_with_source(mock_packages, mock_archive, mock_fetch, config, install_mockery):
     """Verify that source has been copied into place."""
     install("--source", "--keep-stage", "trivial-install-test-package")
     spec = Spec("trivial-install-test-package").concretized()
@@ -181,7 +183,7 @@ def test_install_with_source(mock_packages, mock_archive, mock_fetch, install_mo
     )
 
 
-def test_install_env_variables(mock_packages, mock_archive, mock_fetch, install_mockery):
+def test_install_env_variables(mock_packages, mock_archive, mock_fetch, config, install_mockery):
     spec = Spec("libdwarf")
     spec.concretize()
     install("libdwarf")
@@ -189,7 +191,9 @@ def test_install_env_variables(mock_packages, mock_archive, mock_fetch, install_
 
 
 @pytest.mark.disable_clean_stage_check
-def test_show_log_on_error(mock_packages, mock_archive, mock_fetch, install_mockery, capfd):
+def test_show_log_on_error(
+    mock_packages, mock_archive, mock_fetch, config, install_mockery, capfd
+):
     """
     Make sure --show-log-on-error works.
     """
@@ -202,7 +206,7 @@ def test_show_log_on_error(mock_packages, mock_archive, mock_fetch, install_mock
     assert "See build log for details:" in out
 
 
-def test_install_overwrite(mock_packages, mock_archive, mock_fetch, install_mockery):
+def test_install_overwrite(mock_packages, mock_archive, mock_fetch, config, install_mockery):
     # Try to install a spec and then to reinstall it.
     spec = Spec("libdwarf")
     spec.concretize()
@@ -236,7 +240,9 @@ def test_install_overwrite(mock_packages, mock_archive, mock_fetch, install_mock
     assert fs.hash_directory(spec.prefix, ignore=ignores) != bad_md5
 
 
-def test_install_overwrite_not_installed(mock_packages, mock_archive, mock_fetch, install_mockery):
+def test_install_overwrite_not_installed(
+    mock_packages, mock_archive, mock_fetch, config, install_mockery
+):
     # Try to install a spec and then to reinstall it.
     spec = Spec("libdwarf")
     spec.concretize()
@@ -271,7 +277,9 @@ def test_install_commit(mock_git_version_info, install_mockery, mock_packages, m
     assert content == "[0]"  # contents are weird for another test
 
 
-def test_install_overwrite_multiple(mock_packages, mock_archive, mock_fetch, install_mockery):
+def test_install_overwrite_multiple(
+    mock_packages, mock_archive, mock_fetch, config, install_mockery
+):
     # Try to install a spec and then to reinstall it.
     libdwarf = Spec("libdwarf")
     libdwarf.concretize()
@@ -329,14 +337,18 @@ def test_install_overwrite_multiple(mock_packages, mock_archive, mock_fetch, ins
     assert cm_hash != bad_cmake_md5
 
 
-@pytest.mark.usefixtures("mock_packages", "mock_archive", "mock_fetch", "install_mockery")
+@pytest.mark.usefixtures(
+    "mock_packages", "mock_archive", "mock_fetch", "config", "install_mockery"
+)
 def test_install_conflicts(conflict_spec):
     # Make sure that spec with conflicts raises a SpackError
     with pytest.raises(SpackError):
         install(conflict_spec)
 
 
-@pytest.mark.usefixtures("mock_packages", "mock_archive", "mock_fetch", "install_mockery")
+@pytest.mark.usefixtures(
+    "mock_packages", "mock_archive", "mock_fetch", "config", "install_mockery"
+)
 def test_install_invalid_spec(invalid_spec):
     # Make sure that invalid specs raise a SpackError
     with pytest.raises(SpecSyntaxError, match="unexpected tokens"):
@@ -378,7 +390,9 @@ def test_install_from_file(spec, concretize, error_code, tmpdir):
 
 
 @pytest.mark.disable_clean_stage_check
-@pytest.mark.usefixtures("mock_packages", "mock_archive", "mock_fetch", "install_mockery")
+@pytest.mark.usefixtures(
+    "mock_packages", "mock_archive", "mock_fetch", "config", "install_mockery"
+)
 @pytest.mark.parametrize(
     "exc_typename,msg",
     [("RuntimeError", "something weird happened"), ("ValueError", "spec is not concrete")],
@@ -434,6 +448,7 @@ def test_junit_output_with_errors(
     mock_archive,
     mock_fetch,
     install_mockery,
+    config,
     tmpdir,
     monkeypatch,
 ):
@@ -494,7 +509,9 @@ def test_install_mix_cli_and_files(clispecs, filespecs, tmpdir):
     assert install.returncode == 0
 
 
-def test_extra_files_are_archived(mock_packages, mock_archive, mock_fetch, install_mockery):
+def test_extra_files_are_archived(
+    mock_packages, mock_archive, mock_fetch, config, install_mockery
+):
     s = Spec("archive-files")
     s.concretize()
 
@@ -553,96 +570,100 @@ def test_cdash_upload_build_error(tmpdir, mock_fetch, install_mockery, capfd):
 @pytest.mark.disable_clean_stage_check
 def test_cdash_upload_clean_build(tmpdir, mock_fetch, install_mockery, capfd):
     # capfd interferes with Spack's capturing of e.g., Build.xml output
-    with capfd.disabled(), tmpdir.as_cwd():
-        install("--log-file=cdash_reports", "--log-format=cdash", "pkg-a")
-        report_dir = tmpdir.join("cdash_reports")
-        assert report_dir in tmpdir.listdir()
-        report_file = report_dir.join("pkg-a_Build.xml")
-        assert report_file in report_dir.listdir()
-        content = report_file.open().read()
-        assert "</Build>" in content
-        assert "<Text>" not in content
+    with capfd.disabled():
+        with tmpdir.as_cwd():
+            install("--log-file=cdash_reports", "--log-format=cdash", "a")
+            report_dir = tmpdir.join("cdash_reports")
+            assert report_dir in tmpdir.listdir()
+            report_file = report_dir.join("a_Build.xml")
+            assert report_file in report_dir.listdir()
+            content = report_file.open().read()
+            assert "</Build>" in content
+            assert "<Text>" not in content
 
 
 @pytest.mark.disable_clean_stage_check
 def test_cdash_upload_extra_params(tmpdir, mock_fetch, install_mockery, capfd):
     # capfd interferes with Spack's capture of e.g., Build.xml output
-    with capfd.disabled(), tmpdir.as_cwd():
-        install(
-            "--log-file=cdash_reports",
-            "--log-format=cdash",
-            "--cdash-build=my_custom_build",
-            "--cdash-site=my_custom_site",
-            "--cdash-track=my_custom_track",
-            "pkg-a",
-        )
-        report_dir = tmpdir.join("cdash_reports")
-        assert report_dir in tmpdir.listdir()
-        report_file = report_dir.join("pkg-a_Build.xml")
-        assert report_file in report_dir.listdir()
-        content = report_file.open().read()
-        assert 'Site BuildName="my_custom_build - pkg-a"' in content
-        assert 'Name="my_custom_site"' in content
-        assert "-my_custom_track" in content
+    with capfd.disabled():
+        with tmpdir.as_cwd():
+            install(
+                "--log-file=cdash_reports",
+                "--log-format=cdash",
+                "--cdash-build=my_custom_build",
+                "--cdash-site=my_custom_site",
+                "--cdash-track=my_custom_track",
+                "a",
+            )
+            report_dir = tmpdir.join("cdash_reports")
+            assert report_dir in tmpdir.listdir()
+            report_file = report_dir.join("a_Build.xml")
+            assert report_file in report_dir.listdir()
+            content = report_file.open().read()
+            assert 'Site BuildName="my_custom_build - a"' in content
+            assert 'Name="my_custom_site"' in content
+            assert "-my_custom_track" in content
 
 
 @pytest.mark.disable_clean_stage_check
 def test_cdash_buildstamp_param(tmpdir, mock_fetch, install_mockery, capfd):
     # capfd interferes with Spack's capture of e.g., Build.xml output
-    with capfd.disabled(), tmpdir.as_cwd():
-        cdash_track = "some_mocked_track"
-        buildstamp_format = "%Y%m%d-%H%M-{0}".format(cdash_track)
-        buildstamp = time.strftime(buildstamp_format, time.localtime(int(time.time())))
-        install(
-            "--log-file=cdash_reports",
-            "--log-format=cdash",
-            "--cdash-buildstamp={0}".format(buildstamp),
-            "pkg-a",
-        )
-        report_dir = tmpdir.join("cdash_reports")
-        assert report_dir in tmpdir.listdir()
-        report_file = report_dir.join("pkg-a_Build.xml")
-        assert report_file in report_dir.listdir()
-        content = report_file.open().read()
-        assert buildstamp in content
+    with capfd.disabled():
+        with tmpdir.as_cwd():
+            cdash_track = "some_mocked_track"
+            buildstamp_format = "%Y%m%d-%H%M-{0}".format(cdash_track)
+            buildstamp = time.strftime(buildstamp_format, time.localtime(int(time.time())))
+            install(
+                "--log-file=cdash_reports",
+                "--log-format=cdash",
+                "--cdash-buildstamp={0}".format(buildstamp),
+                "a",
+            )
+            report_dir = tmpdir.join("cdash_reports")
+            assert report_dir in tmpdir.listdir()
+            report_file = report_dir.join("a_Build.xml")
+            assert report_file in report_dir.listdir()
+            content = report_file.open().read()
+            assert buildstamp in content
 
 
 @pytest.mark.disable_clean_stage_check
 def test_cdash_install_from_spec_json(
-    tmpdir, mock_fetch, install_mockery, capfd, mock_packages, mock_archive
+    tmpdir, mock_fetch, install_mockery, capfd, mock_packages, mock_archive, config
 ):
     # capfd interferes with Spack's capturing
-    with capfd.disabled(), tmpdir.as_cwd():
-        spec_json_path = str(tmpdir.join("spec.json"))
+    with capfd.disabled():
+        with tmpdir.as_cwd():
+            spec_json_path = str(tmpdir.join("spec.json"))
 
-        pkg_spec = Spec("pkg-a")
-        pkg_spec.concretize()
+            pkg_spec = Spec("a")
+            pkg_spec.concretize()
 
-        with open(spec_json_path, "w") as fd:
-            fd.write(pkg_spec.to_json(hash=ht.dag_hash))
+            with open(spec_json_path, "w") as fd:
+                fd.write(pkg_spec.to_json(hash=ht.dag_hash))
 
-        install(
-            "--log-format=cdash",
-            "--log-file=cdash_reports",
-            "--cdash-build=my_custom_build",
-            "--cdash-site=my_custom_site",
-            "--cdash-track=my_custom_track",
-            "-f",
-            spec_json_path,
-        )
+            install(
+                "--log-format=cdash",
+                "--log-file=cdash_reports",
+                "--cdash-build=my_custom_build",
+                "--cdash-site=my_custom_site",
+                "--cdash-track=my_custom_track",
+                "-f",
+                spec_json_path,
+            )
 
-        report_dir = tmpdir.join("cdash_reports")
-        assert report_dir in tmpdir.listdir()
-        report_file = report_dir.join("pkg-a_Configure.xml")
-        assert report_file in report_dir.listdir()
-        content = report_file.open().read()
-        install_command_regex = re.compile(
-            r"<ConfigureCommand>(.+)</ConfigureCommand>", re.MULTILINE | re.DOTALL
-        )
-        m = install_command_regex.search(content)
-        assert m
-        install_command = m.group(1)
-        assert "pkg-a@" in install_command
+            report_dir = tmpdir.join("cdash_reports")
+            assert report_dir in tmpdir.listdir()
+            report_file = report_dir.join("a_Configure.xml")
+            assert report_file in report_dir.listdir()
+            content = report_file.open().read()
+            install_command_regex = re.compile(
+                r"<ConfigureCommand>(.+)</ConfigureCommand>", re.MULTILINE | re.DOTALL
+            )
+            m = install_command_regex.search(content)
+            assert m
+            install_command = m.group(1)
+            assert "a@" in install_command
 
 
 @pytest.mark.disable_clean_stage_check
@@ -774,15 +795,15 @@ def test_install_no_add_in_env(tmpdir, mock_fetch, install_mockery, mutable_mock
     #                 ^libdwarf
     #         ^mpich
     #     libelf@0.8.10
-    #     pkg-a~bvv
-    #         ^pkg-b
-    #     pkg-a
-    #         ^pkg-b
+    #     a~bvv
+    #         ^b
+    #     a
+    #         ^b
     e = ev.create("test", with_view=False)
     e.add("mpileaks")
     e.add("libelf@0.8.10")  # so env has both root and dep libelf specs
-    e.add("pkg-a")
-    e.add("pkg-a ~bvv")
+    e.add("a")
+    e.add("a ~bvv")
     e.concretize()
     e.write()
     env_specs = e.all_specs()
@@ -793,9 +814,9 @@ def test_install_no_add_in_env(tmpdir, mock_fetch, install_mockery, mutable_mock
 
     # First find and remember some target concrete specs in the environment
     for e_spec in env_specs:
-        if e_spec.satisfies(Spec("pkg-a ~bvv")):
+        if e_spec.satisfies(Spec("a ~bvv")):
             a_spec = e_spec
-        elif e_spec.name == "pkg-b":
+        elif e_spec.name == "b":
             b_spec = e_spec
         elif e_spec.satisfies(Spec("mpi")):
             mpi_spec = e_spec
@@ -818,8 +839,8 @@ def test_install_no_add_in_env(tmpdir, mock_fetch, install_mockery, mutable_mock
         assert "You can add specs to the environment with 'spack add " in inst_out
 
         # Without --add, ensure that two packages "a" get installed
-        inst_out = install("pkg-a", output=str)
-        assert len([x for x in e.all_specs() if x.installed and x.name == "pkg-a"]) == 2
+        inst_out = install("a", output=str)
+        assert len([x for x in e.all_specs() if x.installed and x.name == "a"]) == 2
 
         # Install an unambiguous dependency spec (that already exists as a dep
         # in the environment) and make sure it gets installed (w/ deps),
@@ -852,7 +873,7 @@ def test_install_no_add_in_env(tmpdir, mock_fetch, install_mockery, mutable_mock
         # root of the environment as well as installed.
         assert b_spec not in e.roots()
 
-        install("--add", "pkg-b")
+        install("--add", "b")
 
         assert b_spec in e.roots()
         assert b_spec not in e.uninstalled_specs()
@@ -887,7 +908,7 @@ def test_cdash_auth_token(tmpdir, mock_fetch, install_mockery, monkeypatch, capf
     # capfd interferes with Spack's capturing
     with tmpdir.as_cwd(), capfd.disabled():
         monkeypatch.setenv("SPACK_CDASH_AUTH_TOKEN", "asdf")
-        out = install("-v", "--log-file=cdash_reports", "--log-format=cdash", "pkg-a")
+        out = install("-v", "--log-file=cdash_reports", "--log-format=cdash", "a")
         assert "Using CDash auth token from environment" in out
 
 
@@ -895,42 +916,54 @@ def test_cdash_auth_token(tmpdir, mock_fetch, install_mockery, monkeypatch, capf
 @pytest.mark.disable_clean_stage_check
 def test_cdash_configure_warning(tmpdir, mock_fetch, install_mockery, capfd):
     # capfd interferes with Spack's capturing of e.g., Build.xml output
-    with capfd.disabled(), tmpdir.as_cwd():
-        # Test would fail if install raised an error.
+    with capfd.disabled():
+        with tmpdir.as_cwd():
+            # Test would fail if install raised an error.
 
-        # Ensure that even on non-x86_64 architectures, there are no
-        # dependencies installed
-        spec = Spec("configure-warning").concretized()
-        spec.clear_dependencies()
-        specfile = "./spec.json"
-        with open(specfile, "w") as f:
-            f.write(spec.to_json())
+            # Ensure that even on non-x86_64 architectures, there are no
+            # dependencies installed
+            spec = spack.spec.Spec("configure-warning").concretized()
+            spec.clear_dependencies()
+            specfile = "./spec.json"
+            with open(specfile, "w") as f:
+                f.write(spec.to_json())
 
-        install("--log-file=cdash_reports", "--log-format=cdash", specfile)
-        # Verify Configure.xml exists with expected contents.
-        report_dir = tmpdir.join("cdash_reports")
-        assert report_dir in tmpdir.listdir()
-        report_file = report_dir.join("Configure.xml")
-        assert report_file in report_dir.listdir()
-        content = report_file.open().read()
-        assert "foo: No such file or directory" in content
+            install("--log-file=cdash_reports", "--log-format=cdash", specfile)
+            # Verify Configure.xml exists with expected contents.
+            report_dir = tmpdir.join("cdash_reports")
+            assert report_dir in tmpdir.listdir()
+            report_file = report_dir.join("Configure.xml")
+            assert report_file in report_dir.listdir()
+            content = report_file.open().read()
+            assert "foo: No such file or directory" in content
 
 
 @pytest.mark.not_on_windows("ArchSpec gives test platform debian rather than windows")
 def test_compiler_bootstrap(
-    install_mockery, mock_packages, mock_fetch, mock_archive, mutable_config, monkeypatch
+    install_mockery_mutable_config,
+    mock_packages,
+    mock_fetch,
+    mock_archive,
+    mutable_config,
+    monkeypatch,
 ):
     monkeypatch.setattr(spack.concretize.Concretizer, "check_for_compiler_existence", False)
     spack.config.set("config:install_missing_compilers", True)
     assert CompilerSpec("gcc@=12.0") not in compilers.all_compiler_specs()
 
     # Test succeeds if it does not raise an error
-    install("pkg-a%gcc@=12.0")
+    install("a%gcc@=12.0")
 
 
 @pytest.mark.not_on_windows("Binary mirrors not supported on windows")
 def test_compiler_bootstrap_from_binary_mirror(
-    install_mockery, mock_packages, mock_fetch, mock_archive, mutable_config, monkeypatch, tmpdir
+    install_mockery_mutable_config,
+    mock_packages,
+    mock_fetch,
+    mock_archive,
+    mutable_config,
+    monkeypatch,
+    tmpdir,
 ):
     """
     Make sure installing compiler from buildcache registers compiler
@@ -959,14 +992,19 @@ def test_compiler_bootstrap_from_binary_mirror(
     # Now make sure that when the compiler is installed from binary mirror,
     # it also gets configured as a compiler.  Test succeeds if it does not
     # raise an error
-    install("--no-check-signature", "--cache-only", "--only", "dependencies", "pkg-b%gcc@=10.2.0")
-    install("--no-cache", "--only", "package", "pkg-b%gcc@10.2.0")
+    install("--no-check-signature", "--cache-only", "--only", "dependencies", "b%gcc@=10.2.0")
+    install("--no-cache", "--only", "package", "b%gcc@10.2.0")
 
 
 @pytest.mark.not_on_windows("ArchSpec gives test platform debian rather than windows")
 @pytest.mark.regression("16221")
 def test_compiler_bootstrap_already_installed(
-    install_mockery, mock_packages, mock_fetch, mock_archive, mutable_config, monkeypatch
+    install_mockery_mutable_config,
+    mock_packages,
+    mock_fetch,
+    mock_archive,
+    mutable_config,
+    monkeypatch,
 ):
     monkeypatch.setattr(spack.concretize.Concretizer, "check_for_compiler_existence", False)
     spack.config.set("config:install_missing_compilers", True)
@@ -975,7 +1013,7 @@ def test_compiler_bootstrap_already_installed(
 
     # Test succeeds if it does not raise an error
     install("gcc@=12.0")
-    install("pkg-a%gcc@=12.0")
+    install("a%gcc@=12.0")
 
 
 def test_install_fails_no_args(tmpdir):
@@ -1066,7 +1104,13 @@ def test_installation_fail_tests(install_mockery, mock_fetch, name, method):
 
 @pytest.mark.not_on_windows("Buildcache not supported on windows")
 def test_install_use_buildcache(
-    capsys, mock_packages, mock_fetch, mock_archive, mock_binary_index, tmpdir, install_mockery
+    capsys,
+    mock_packages,
+    mock_fetch,
+    mock_archive,
+    mock_binary_index,
+    tmpdir,
+    install_mockery_mutable_config,
 ):
     """
     Make sure installing with use-buildcache behaves correctly.
@@ -1139,19 +1183,19 @@ def install_use_buildcache(opt):
 @pytest.mark.not_on_windows("Windows logger I/O operation on closed file when install fails")
 @pytest.mark.regression("34006")
 @pytest.mark.disable_clean_stage_check
-def test_padded_install_runtests_root(install_mockery, mock_fetch):
+def test_padded_install_runtests_root(install_mockery_mutable_config, mock_fetch):
     spack.config.set("config:install_tree:padded_length", 255)
     output = install("--test=root", "--no-cache", "test-build-callbacks", fail_on_error=False)
     assert output.count("method not implemented") == 1
 
 
 @pytest.mark.regression("35337")
-def test_report_filename_for_cdash(install_mockery, mock_fetch):
+def test_report_filename_for_cdash(install_mockery_mutable_config, mock_fetch):
     """Test that the temporary file used to write the XML for CDash is not the upload URL"""
     parser = argparse.ArgumentParser()
     spack.cmd.install.setup_parser(parser)
     args = parser.parse_args(
-        ["--cdash-upload-url", "https://blahblah/submit.php?project=debugging", "pkg-a"]
+        ["--cdash-upload-url", "https://blahblah/submit.php?project=debugging", "a"]
     )
     specs = spack.cmd.install.concrete_specs_from_cli(args, {})
     filename = spack.cmd.install.report_filename(args, specs)

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

@@ -3,6 +3,7 @@
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
+import os
 import shutil
 
 import pytest
@@ -15,8 +16,10 @@
 from spack.main import SpackCommand, SpackCommandError
 
 # Everything here uses (or can use) the mock config and database.
-pytestmark = [pytest.mark.usefixtures("mutable_config", "mutable_database")]
-
+pytestmark = [
+    pytest.mark.usefixtures("config", "database"),
+    pytest.mark.not_on_windows("does not run on windows"),
+]
 # location prints out "locations of packages and spack directories"
 location = SpackCommand("location")
 env = SpackCommand("env")
@@ -62,7 +65,7 @@ def test_location_source_dir_missing():
     prefix = "==> Error: "
     expected = (
         "%sSource directory does not exist yet. Run this to create it:"
-        "%s  spack stage %s" % (prefix, "\n", spec)
+        "%s  spack stage %s" % (prefix, os.linesep, spec)
     )
     out = location("--source-dir", spec, fail_on_error=False).strip()
     assert out == expected
@@ -123,7 +126,6 @@ def test_location_env_missing():
 
 
 @pytest.mark.db
-@pytest.mark.not_on_windows("Broken on Windows")
 def test_location_install_dir(mock_spec):
     """Tests spack location --install-dir."""
     spec, _ = mock_spec