simmodsuite: depends on rpc

Sun RPC support was optional starting with glibc version 2.26 and was removed in version 2.32. On newer operating systems (e.g., RHEL8) libtirpc is required to satisfy the xdr symbols.

.flake8

@@ -1,25 +1,43 @@
 # -*- conf -*-
-# flake8 settings for Spack.
+# flake8 settings for Spack core files.
 #
 # These exceptions are for Spack core files. We're slightly more lenient
 # with packages.  See .flake8_packages for that.
 #
-# This is the only flake8 rule Spack violates somewhat flagrantly
+# E1: Indentation
+# - E129: visually indented line with same indent as next logical line
+#
+# E2: Whitespace
+# - E221: multiple spaces before operator
+# - E241: multiple spaces after ','
+# - E272: multiple spaces before keyword
+#
+# E7: Statement
 # - E731: do not assign a lambda expression, use a def
 #
-# This is the only flake8 exception needed when using Black.
-# - E203: white space around slice operators can be required, ignore : warn
+# W5: Line break warning
+# - W503: line break before binary operator
+# - W504: line break after binary operator
 #
-# We still allow these in packages (Would like to get rid of them or rely on mypy
-# in the future)
-# - F403: from/import * used; unable to detect undefined names
+# These are required to get the package.py files to test clean:
+# - F999: syntax error in doctest
+#
+# N8: PEP8-naming
+# - N801: class names should use CapWords convention
+# - N813: camelcase imported as lowercase
+# - N814: camelcase imported as constant
+#
+# F4: pyflakes import checks, these are now checked by mypy more precisely
+# - F403: from module import *
 # - F405: undefined name or from *
-# - F821: undefined name (needed with from/import *)
+#
+# Black ignores, these are incompatible with black style and do not follow PEP-8
+# - E203: white space around slice operators can be required, ignore : warn
+# - W503: see above, already ignored for line-breaks
 #
 [flake8]
-#ignore = E129,,W503,W504,F999,N801,N813,N814,F403,F405,E203
-extend-ignore = E731,E203
-max-line-length = 99
+ignore = E129,E221,E241,E272,E731,W503,W504,F999,N801,N813,N814,F403,F405
+max-line-length = 88
 
 # F4: Import
 # - F405: `name` may be undefined, or undefined from star imports: `module`
@@ -28,8 +46,7 @@ max-line-length = 99
 # - F821: undefined name `name`
 #
 per-file-ignores =
-  var/spack/repos/*/package.py:F403,F405,F821
-  *-ci-package.py:F403,F405,F821
+  var/spack/repos/*/package.py:F405,F821
 
 # exclude things we usually do not want linting for.
 # These still get linted when passed explicitly, as when spack flake8 passes

.git-blame-ignore-revs

@@ -1,5 +0,0 @@
-# .git-blame-ignore-revs
-# Formatted entire codebase with black 23
-603569e321013a1a63a637813c94c2834d0a0023
-# Formatted entire codebase with black 22
-f52f6e99dbf1131886a80112b8c79dfc414afb7c

.gitattributes

@@ -1,4 +1,3 @@
 *.py diff=python
 *.lp linguist-language=Prolog
 lib/spack/external/* linguist-vendored
-*.bat text eol=crlf

.github/ISSUE_TEMPLATE/build_error.yml

@@ -9,7 +9,7 @@ body:
         Thanks for taking the time to report this build failure. To proceed with the report please:
         1. Title the issue `Installation issue: <name-of-the-package>`.
         2. Provide the information required below.
-
+        
         We encourage you to try, as much as possible, to reduce your problem to the minimal example that still reproduces the issue. That would help us a lot in fixing it quickly and effectively!
   - type: textarea
     id: reproduce
@@ -29,9 +29,7 @@ body:
       description: |
         Please post the error message from spack inside the `<details>` tag below:
       value: |
-        <details><summary>Error message</summary>
-
-        <pre>
+        <details><summary>Error message</summary><pre>
         ...
         </pre></details>
     validations:
@@ -55,7 +53,7 @@ body:
         Please upload the following files:
         * **`spack-build-out.txt`**
         * **`spack-build-env.txt`**
-
+        
         They should be present in the stage directory of the failing build. Also upload any `config.log` or similar file if one exists.
   - type: markdown
     attributes:

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -1,4 +1,4 @@
-name: "\U0001F38A Feature request"
+name: "\U0001F38A Feature request" 
 description: Suggest adding a feature that is not yet in Spack
 labels: [feature]
 body:
@@ -29,11 +29,13 @@ body:
     attributes:
       label: General information
       options:
+        - label: I have run `spack --version` and reported the version of Spack
+          required: true
         - label: I have searched the issues of this repo and believe this is not a duplicate
           required: true
   - type: markdown
     attributes:
       value: |
         If you want to ask a question about the tool (how to use it, what it can currently do, etc.), try the `#general` channel on [our Slack](https://slack.spack.io/) first. We have a welcoming community and chances are you'll get your reply faster and without opening an issue.
-
+        
         Other than that, thanks for taking the time to contribute to Spack!

.github/ISSUE_TEMPLATE/test_error.yml

@@ -1,64 +0,0 @@
-name: "\U0001F4A5 Tests error"
-description: Some package in Spack had stand-alone tests that didn't pass
-title: "Testing issue: "
-labels: [test-error]
-body:
-  - type: textarea
-    id: reproduce
-    attributes:
-      label: Steps to reproduce the failure(s) or link(s) to test output(s)
-      description: |
-        Fill in the test output from the exact spec that is having stand-alone test failures. Links to test outputs (e.g., CDash) can also be provided.
-      value: |
-        ```console
-        $ spack spec -I <spec>
-        ...
-        ```
-  - type: textarea
-    id: error
-    attributes:
-      label: Error message
-      description: |
-        Please post the error message from spack inside the `<details>` tag below:
-      value: |
-        <details><summary>Error message</summary>
-
-        <pre>
-        ...
-        </pre></details>
-    validations:
-      required: true
-  - type: textarea
-    id: information
-    attributes:
-      label: Information on your system or the test runner
-      description: Please include the output of `spack debug report` for your system.
-    validations:
-      required: true
-  - type: markdown
-    attributes:
-      value: |
-        If you have any relevant configuration detail (custom `packages.yaml` or `modules.yaml`, etc.) you can add that here as well.
-  - type: textarea
-    id: additional_information
-    attributes:
-      label: Additional information
-      description: |
-        Please upload test logs or any additional information about the problem.
-  - type: markdown
-    attributes:
-      value: |
-        Some packages have maintainers who have volunteered to debug build failures. Run `spack maintainers <name-of-the-package>` and **@mention** them here if they exist.
-  - type: checkboxes
-    id: checks
-    attributes:
-      label: General information
-      options:
-        - label: I have reported the version of Spack/Python/Platform/Runner
-          required: true
-        - label: I have run `spack maintainers <name-of-the-package>` and **@mentioned** any maintainers
-          required: true
-        - label: I have uploaded any available logs
-          required: true
-        - label: I have searched the issues of this repo and believe this is not a duplicate
-          required: true

.github/dependabot.yml

@@ -5,8 +5,3 @@ updates:
     directory: "/"
     schedule:
       interval: "daily"
-  # Requirements to build documentation
-  - package-ecosystem: "pip"
-    directory: "/lib/spack/docs"
-    schedule:
-      interval: "daily"

.github/workflows/audit.yaml

@@ -1,44 +0,0 @@
-name: audit
-
-on:
-  workflow_call:
-    inputs:
-      with_coverage:
-        required: true
-        type: string
-      python_version:
-        required: true
-        type: string
-
-concurrency:
-  group: audit-${{inputs.python_version}}-${{github.ref}}-${{github.event.pull_request.number || github.run_number}}
-  cancel-in-progress: true
-
-jobs:
-  # Run audits on all the packages in the built-in repository
-  package-audits:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # @v2
-    - uses: actions/setup-python@57ded4d7d5e986d7296eab16560982c6dd7c923b # @v2
-      with:
-        python-version: ${{inputs.python_version}}
-    - name: Install Python packages
-      run: |
-        pip install --upgrade pip setuptools pytest coverage[toml]
-    - name: Package audits (with coverage)
-      if: ${{ inputs.with_coverage == 'true' }}
-      run: |
-          . share/spack/setup-env.sh
-          coverage run $(which spack) audit packages
-          coverage combine
-          coverage xml
-    - name: Package audits (without coverage)
-      if: ${{ inputs.with_coverage == 'false' }}
-      run: |
-          . share/spack/setup-env.sh
-          $(which spack) audit packages
-    - uses: codecov/codecov-action@894ff025c7b54547a9a2a1e9f228beae737ad3c2 # @v2.1.0
-      if: ${{ inputs.with_coverage == 'true' }}
-      with:
-        flags: unittests,linux,audits

.github/workflows/bootstrap-test.sh

@@ -1,7 +0,0 @@
-#!/bin/bash
-set -ex
-source share/spack/setup-env.sh
-$PYTHON bin/spack bootstrap disable spack-install
-$PYTHON bin/spack -d solve zlib
-tree $BOOTSTRAP/store
-exit 0

.github/workflows/bootstrap.yml

@@ -3,19 +3,33 @@ name: Bootstrapping
 on:
   # This Workflow can be triggered manually
   workflow_dispatch:
-  workflow_call:
+  pull_request:
+    branches:
+      - develop
+      - releases/**
+    paths-ignore:
+      # Don't run if we only modified packages in the
+      # built-in repository or documentation
+      - 'var/spack/repos/builtin/**'
+      - '!var/spack/repos/builtin/packages/clingo-bootstrap/**'
+      - '!var/spack/repos/builtin/packages/clingo/**'
+      - '!var/spack/repos/builtin/packages/python/**'
+      - '!var/spack/repos/builtin/packages/re2c/**'
+      - 'lib/spack/docs/**'
   schedule:
     # nightly at 2:16 AM
     - cron: '16 2 * * *'
 
 concurrency:
-  group: bootstrap-${{github.ref}}-${{github.event.pull_request.number || github.run_number}}
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.run_number }}
   cancel-in-progress: true
 
 jobs:
+
   fedora-clingo-sources:
     runs-on: ubuntu-latest
     container: "fedora:latest"
+    if: github.repository == 'spack/spack'
     steps:
       - name: Install dependencies
         run: |
@@ -24,9 +38,7 @@ jobs:
               make patch unzip which xz python3 python3-devel tree \
               cmake bison bison-devel libstdc++-static
       - name: Checkout
-        uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab
-        with:
-          fetch-depth: 0
+        uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b
       - name: Setup non-root user
         run: |
           # See [1] below
@@ -37,13 +49,13 @@ jobs:
         shell: runuser -u spack-test -- bash {0}
         run: |
           git --version
+          git fetch --unshallow
           . .github/workflows/setup_git.sh
       - name: Bootstrap clingo
         shell: runuser -u spack-test -- bash {0}
         run: |
           source share/spack/setup-env.sh
-          spack bootstrap disable github-actions-v0.4
-          spack bootstrap disable github-actions-v0.3
+          spack bootstrap untrust github-actions-v0.2
           spack external find cmake bison
           spack -d solve zlib
           tree ~/.spack/bootstrap/store/
@@ -51,6 +63,7 @@ jobs:
   ubuntu-clingo-sources:
     runs-on: ubuntu-latest
     container: "ubuntu:latest"
+    if: github.repository == 'spack/spack'
     steps:
       - name: Install dependencies
         env:
@@ -62,9 +75,7 @@ jobs:
               make patch unzip xz-utils python3 python3-dev tree \
               cmake bison
       - name: Checkout
-        uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab
-        with:
-          fetch-depth: 0
+        uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b
       - name: Setup non-root user
         run: |
           # See [1] below
@@ -75,13 +86,13 @@ jobs:
         shell: runuser -u spack-test -- bash {0}
         run: |
           git --version
+          git fetch --unshallow
           . .github/workflows/setup_git.sh
       - name: Bootstrap clingo
         shell: runuser -u spack-test -- bash {0}
         run: |
           source share/spack/setup-env.sh
-          spack bootstrap disable github-actions-v0.4
-          spack bootstrap disable github-actions-v0.3
+          spack bootstrap untrust github-actions-v0.2
           spack external find cmake bison
           spack -d solve zlib
           tree ~/.spack/bootstrap/store/
@@ -89,6 +100,7 @@ jobs:
   ubuntu-clingo-binaries-and-patchelf:
     runs-on: ubuntu-latest
     container: "ubuntu:latest"
+    if: github.repository == 'spack/spack'
     steps:
       - name: Install dependencies
         env:
@@ -99,9 +111,7 @@ jobs:
               bzip2 curl file g++ gcc gfortran git gnupg2 gzip \
               make patch unzip xz-utils python3 python3-dev tree
       - name: Checkout
-        uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab
-        with:
-          fetch-depth: 0
+        uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b
       - name: Setup non-root user
         run: |
           # See [1] below
@@ -112,6 +122,7 @@ jobs:
         shell: runuser -u spack-test -- bash {0}
         run: |
           git --version
+          git fetch --unshallow
           . .github/workflows/setup_git.sh
       - name: Bootstrap clingo
         shell: runuser -u spack-test -- bash {0}
@@ -123,6 +134,7 @@ jobs:
   opensuse-clingo-sources:
     runs-on: ubuntu-latest
     container: "opensuse/leap:latest"
+    if: github.repository == 'spack/spack'
     steps:
       - name: Install dependencies
         run: |
@@ -133,38 +145,36 @@ jobs:
               make patch unzip which xz python3 python3-devel tree \
               cmake bison
       - name: Checkout
-        uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab
-        with:
-          fetch-depth: 0
+        uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b
       - name: Setup repo
         run: |
           # See [1] below
           git config --global --add safe.directory /__w/spack/spack
           git --version
+          git fetch --unshallow
           . .github/workflows/setup_git.sh
       - name: Bootstrap clingo
         run: |
           source share/spack/setup-env.sh
-          spack bootstrap disable github-actions-v0.4
-          spack bootstrap disable github-actions-v0.3
+          spack bootstrap untrust github-actions-v0.2
           spack external find cmake bison
           spack -d solve zlib
           tree ~/.spack/bootstrap/store/
 
   macos-clingo-sources:
     runs-on: macos-latest
+    if: github.repository == 'spack/spack'
     steps:
       - name: Install dependencies
         run: |
           brew install cmake bison@2.7 tree
       - name: Checkout
-        uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab
+        uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b
       - name: Bootstrap clingo
         run: |
           source share/spack/setup-env.sh
           export PATH=/usr/local/opt/bison@2.7/bin:$PATH
-          spack bootstrap disable github-actions-v0.4
-          spack bootstrap disable github-actions-v0.3
+          spack bootstrap untrust github-actions-v0.2
           spack external find --not-buildable cmake bison
           spack -d solve zlib
           tree ~/.spack/bootstrap/store/
@@ -173,70 +183,53 @@ jobs:
     runs-on: ${{ matrix.macos-version }}
     strategy:
       matrix:
-        macos-version: ['macos-11', 'macos-12']
+        python-version: ['3.5', '3.6', '3.7', '3.8', '3.9', '3.10']
+        macos-version: ['macos-10.15', 'macos-11', 'macos-12']
+    if: github.repository == 'spack/spack'
     steps:
       - name: Install dependencies
         run: |
           brew install tree
       - name: Checkout
-        uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab
+        uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b
+      - uses: actions/setup-python@c4e89fac7e8767b327bbad6cb4d859eda999cf08
+        with:
+          python-version: ${{ matrix.python-version }}
       - name: Bootstrap clingo
         run: |
-          set -ex
-          for ver in '3.6' '3.7' '3.8' '3.9' '3.10' ; do
-            not_found=1
-            ver_dir="$(find $RUNNER_TOOL_CACHE/Python -wholename "*/${ver}.*/*/bin" | grep . || true)"
-            echo "Testing $ver_dir"
-            if [[ -d "$ver_dir" ]] ; then
-              if $ver_dir/python --version ; then
-                export PYTHON="$ver_dir/python"
-                not_found=0
-                old_path="$PATH"
-                export PATH="$ver_dir:$PATH"
-                ./bin/spack-tmpconfig -b ./.github/workflows/bootstrap-test.sh
-                export PATH="$old_path"
-              fi
-            fi
-            # NOTE: test all pythons that exist, not all do on 12
-          done
+          source share/spack/setup-env.sh
+          spack bootstrap untrust spack-install
+          spack -d solve zlib
+          tree ~/.spack/bootstrap/store/
 
   ubuntu-clingo-binaries:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['2.7', '3.5', '3.6', '3.7', '3.8', '3.9', '3.10']
+    if: github.repository == 'spack/spack'
     steps:
       - name: Checkout
-        uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab
+        uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b
+      - uses: actions/setup-python@c4e89fac7e8767b327bbad6cb4d859eda999cf08
         with:
-          fetch-depth: 0
+          python-version: ${{ matrix.python-version }}
       - name: Setup repo
         run: |
           git --version
+          git fetch --unshallow
           . .github/workflows/setup_git.sh
       - name: Bootstrap clingo
         run: |
-          set -ex
-          for ver in '3.6' '3.7' '3.8' '3.9' '3.10' ; do
-            not_found=1
-            ver_dir="$(find $RUNNER_TOOL_CACHE/Python -wholename "*/${ver}.*/*/bin" | grep . || true)"
-            echo "Testing $ver_dir"
-            if [[ -d "$ver_dir" ]] ; then
-              if $ver_dir/python --version ; then
-                export PYTHON="$ver_dir/python"
-                not_found=0
-                old_path="$PATH"
-                export PATH="$ver_dir:$PATH"
-                ./bin/spack-tmpconfig -b ./.github/workflows/bootstrap-test.sh
-                export PATH="$old_path"
-              fi
-            fi
-            if (($not_found)) ; then
-              echo Required python version $ver not found in runner!
-              exit 1
-            fi
-          done
+          source share/spack/setup-env.sh
+          spack bootstrap untrust spack-install
+          spack -d solve zlib
+          tree ~/.spack/bootstrap/store/
 
   ubuntu-gnupg-binaries:
     runs-on: ubuntu-latest
     container: "ubuntu:latest"
+    if: github.repository == 'spack/spack'
     steps:
       - name: Install dependencies
         env:
@@ -247,9 +240,7 @@ jobs:
               bzip2 curl file g++ gcc patchelf gfortran git gzip \
               make patch unzip xz-utils python3 python3-dev tree
       - name: Checkout
-        uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab
-        with:
-          fetch-depth: 0
+        uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b
       - name: Setup non-root user
         run: |
           # See [1] below
@@ -260,18 +251,20 @@ jobs:
         shell: runuser -u spack-test -- bash {0}
         run: |
           git --version
+          git fetch --unshallow
           . .github/workflows/setup_git.sh
       - name: Bootstrap GnuPG
         shell: runuser -u spack-test -- bash {0}
         run: |
           source share/spack/setup-env.sh
-          spack bootstrap disable spack-install
+          spack bootstrap untrust spack-install
           spack -d gpg list
           tree ~/.spack/bootstrap/store/
 
   ubuntu-gnupg-sources:
     runs-on: ubuntu-latest
     container: "ubuntu:latest"
+    if: github.repository == 'spack/spack'
     steps:
       - name: Install dependencies
         env:
@@ -283,9 +276,7 @@ jobs:
               make patch unzip xz-utils python3 python3-dev tree \
               gawk
       - name: Checkout
-        uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab
-        with:
-          fetch-depth: 0
+        uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b
       - name: Setup non-root user
         run: |
           # See [1] below
@@ -296,19 +287,20 @@ jobs:
         shell: runuser -u spack-test -- bash {0}
         run: |
           git --version
+          git fetch --unshallow
           . .github/workflows/setup_git.sh
       - name: Bootstrap GnuPG
         shell: runuser -u spack-test -- bash {0}
         run: |
           source share/spack/setup-env.sh
           spack solve zlib
-          spack bootstrap disable github-actions-v0.4
-          spack bootstrap disable github-actions-v0.3
+          spack bootstrap untrust github-actions-v0.2
           spack -d gpg list
           tree ~/.spack/bootstrap/store/
 
   macos-gnupg-binaries:
     runs-on: macos-latest
+    if: github.repository == 'spack/spack'
     steps:
       - name: Install dependencies
         run: |
@@ -316,16 +308,17 @@ jobs:
           # Remove GnuPG since we want to bootstrap it
           sudo rm -rf /usr/local/bin/gpg
       - name: Checkout
-        uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab
+        uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b
       - name: Bootstrap GnuPG
         run: |
           source share/spack/setup-env.sh
-          spack bootstrap disable spack-install
+          spack bootstrap untrust spack-install
           spack -d gpg list
           tree ~/.spack/bootstrap/store/
 
   macos-gnupg-sources:
     runs-on: macos-latest
+    if: github.repository == 'spack/spack'
     steps:
       - name: Install dependencies
         run: |
@@ -333,13 +326,12 @@ jobs:
           # Remove GnuPG since we want to bootstrap it
           sudo rm -rf /usr/local/bin/gpg
       - name: Checkout
-        uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab
+        uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b
       - name: Bootstrap GnuPG
         run: |
           source share/spack/setup-env.sh
           spack solve zlib
-          spack bootstrap disable github-actions-v0.4
-          spack bootstrap disable github-actions-v0.3
+          spack bootstrap untrust github-actions-v0.2
           spack -d gpg list
           tree ~/.spack/bootstrap/store/
 

.github/workflows/build-containers.yml

@@ -13,14 +13,14 @@ on:
     paths:
       - '.github/workflows/build-containers.yml'
       - 'share/spack/docker/*'
-      - 'share/spack/templates/container/*'
+      - 'share/templates/container/*'
       - 'lib/spack/spack/container/*'
   # Let's also build & tag Spack containers on releases.
   release:
     types: [published]
 
 concurrency:
-  group: build_containers-${{github.ref}}-${{github.event.pull_request.number || github.run_number}}
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.run_number }}
   cancel-in-progress: true
 
 jobs:
@@ -45,18 +45,12 @@ jobs:
                      [leap15, 'linux/amd64,linux/arm64,linux/ppc64le', 'opensuse/leap:15'],
                      [ubuntu-bionic, 'linux/amd64,linux/arm64,linux/ppc64le', 'ubuntu:18.04'],
                      [ubuntu-focal, 'linux/amd64,linux/arm64,linux/ppc64le', 'ubuntu:20.04'],
-                     [ubuntu-jammy, 'linux/amd64,linux/arm64,linux/ppc64le', 'ubuntu:22.04'],
-                     [almalinux8, 'linux/amd64,linux/arm64,linux/ppc64le', 'almalinux:8'],
-                     [almalinux9, 'linux/amd64,linux/arm64,linux/ppc64le', 'almalinux:9'],
-                     [rockylinux8, 'linux/amd64,linux/arm64', 'rockylinux:8'],
-                     [rockylinux9, 'linux/amd64,linux/arm64,linux/ppc64le', 'rockylinux:9'],
-                     [fedora37, 'linux/amd64,linux/arm64,linux/ppc64le', 'fedora:37'],
-                     [fedora38, 'linux/amd64,linux/arm64,linux/ppc64le', 'fedora:38']]
+                     [ubuntu-jammy, 'linux/amd64,linux/arm64,linux/ppc64le', 'ubuntu:22.04']]
     name: Build ${{ matrix.dockerfile[0] }}
     if: github.repository == 'spack/spack'
     steps:
       - name: Checkout
-        uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # @v2
+        uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b # @v2
 
       - name: Set Container Tag Normal (Nightly)
         run: |
@@ -86,19 +80,19 @@ jobs:
           fi
 
       - name: Upload Dockerfile
-        uses: actions/upload-artifact@0b7f8abb1508181956e8e162db84b466c27e18ce
+        uses: actions/upload-artifact@3cea5372237819ed00197afe530f5a7ea3e805c8
         with:
           name: dockerfiles
           path: dockerfiles
 
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@e81a89b1732b9c48d79cd809d8d81d79c4647a18 # @v1
+        uses: docker/setup-qemu-action@8b122486cedac8393e77aa9734c3528886e4a1a8 # @v1
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@4b4e9c3e2d4531116a6f8ba8e71fc6e2cb6e6c8c # @v1
+        uses: docker/setup-buildx-action@dc7b9719a96d48369863986a06765841d7ea23f6 # @v1
 
       - name: Log in to GitHub Container Registry
-        uses: docker/login-action@f4ef78c080cd8ba55a85445d5b36e214a81df20a # @v1
+        uses: docker/login-action@49ed152c8eca782a232dede0303416e8f356c37b # @v1
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
@@ -106,13 +100,13 @@ jobs:
 
       - name: Log in to DockerHub
         if: github.event_name != 'pull_request'
-        uses: docker/login-action@f4ef78c080cd8ba55a85445d5b36e214a81df20a # @v1
+        uses: docker/login-action@49ed152c8eca782a232dede0303416e8f356c37b # @v1
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Build & Deploy ${{ matrix.dockerfile[0] }}
-        uses: docker/build-push-action@3b5e8027fcad23fda98b2e3ac259d8d67585f671 # @v2
+        uses: docker/build-push-action@e551b19e49efd4e98792db7592c17c09b89db8d8 # @v2
         with:
           context: dockerfiles/${{ matrix.dockerfile[0] }}
           platforms: ${{ matrix.dockerfile[1] }}

.github/workflows/ci.yaml

@@ -1,86 +0,0 @@
-name: ci
-
-on:
-  push:
-    branches:
-      - develop
-      - releases/**
-  pull_request:
-    branches:
-      - develop
-      - releases/**
-
-concurrency:
-  group: ci-${{github.ref}}-${{github.event.pull_request.number || github.run_number}}
-  cancel-in-progress: true
-
-jobs:
-  prechecks:
-    needs: [ changes ]
-    uses: ./.github/workflows/valid-style.yml
-    with:
-      with_coverage: ${{ needs.changes.outputs.core }}
-  all-prechecks:
-    needs: [ prechecks ]
-    runs-on: ubuntu-latest
-    steps:
-    - name: Success
-      run: "true"
-  # Check which files have been updated by the PR
-  changes:
-    runs-on: ubuntu-latest
-      # Set job outputs to values from filter step
-    outputs:
-      bootstrap: ${{ steps.filter.outputs.bootstrap }}
-      core: ${{ steps.filter.outputs.core }}
-      packages: ${{ steps.filter.outputs.packages }}
-    steps:
-      - uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # @v2
-        if: ${{ github.event_name == 'push' }}
-        with:
-          fetch-depth: 0
-            # For pull requests it's not necessary to checkout the code
-      - uses: dorny/paths-filter@4512585405083f25c027a35db413c2b3b9006d50
-        id: filter
-        with:
-          # See https://github.com/dorny/paths-filter/issues/56 for the syntax used below
-          # Don't run if we only modified packages in the
-          # built-in repository or documentation
-          filters: |
-            bootstrap:
-            - 'var/spack/repos/builtin/packages/clingo-bootstrap/**'
-            - 'var/spack/repos/builtin/packages/clingo/**'
-            - 'var/spack/repos/builtin/packages/python/**'
-            - 'var/spack/repos/builtin/packages/re2c/**'
-            - 'lib/spack/**'
-            - 'share/spack/**'
-            - '.github/workflows/bootstrap.yml'
-            - '.github/workflows/ci.yaml'
-            core:
-            - './!(var/**)/**'
-            packages:
-            - 'var/**'
-      # Some links for easier reference:
-      #
-      # "github" context: https://docs.github.com/en/actions/reference/context-and-expression-syntax-for-github-actions#github-context
-      # job outputs: https://docs.github.com/en/actions/reference/workflow-syntax-for-github-actions#jobsjob_idoutputs
-      # setting environment variables from earlier steps: https://docs.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-an-environment-variable
-      #
-  bootstrap:
-    if: ${{ github.repository == 'spack/spack' && needs.changes.outputs.bootstrap == 'true' }}
-    needs: [ prechecks, changes ]
-    uses: ./.github/workflows/bootstrap.yml
-  unit-tests:
-    if: ${{ github.repository == 'spack/spack' && needs.changes.outputs.core == 'true' }}
-    needs: [ prechecks, changes ]
-    uses: ./.github/workflows/unit_tests.yaml
-  windows:
-    if: ${{ github.repository == 'spack/spack' && needs.changes.outputs.core == 'true' }}
-    needs: [ prechecks ]
-    uses: ./.github/workflows/windows_python.yml
-  all:
-    needs: [ windows, unit-tests, bootstrap ]
-    runs-on: ubuntu-latest
-    steps:
-    - name: Success
-      run: "true"

.github/workflows/macos_python.yml

@@ -0,0 +1,71 @@
+# These are nightly package tests for macOS
+# focus areas:
+# - initial user experience
+# - scientific python stack
+name: macOS builds nightly
+
+on:
+  schedule:
+    # nightly at 1 AM
+    - cron: '0 1 * * *'
+  pull_request:
+    branches:
+    - develop
+    paths:
+      # Run if we modify this yaml file
+      - '.github/workflows/macos_python.yml'
+      # TODO: run if we touch any of the recipes involved in this
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.run_number }}
+  cancel-in-progress: true
+
+# GitHub Action Limits
+# https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+
+jobs:
+  install_gcc:
+    name: gcc with clang
+    if: github.repository == 'spack/spack'
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b # @v2
+    - uses: actions/setup-python@c4e89fac7e8767b327bbad6cb4d859eda999cf08 # @v2
+      with:
+        python-version: 3.9
+    - name: spack install
+      run: |
+        . .github/workflows/install_spack.sh
+        # 9.2.0 is the latest version on which we apply homebrew patch
+        spack install -v --fail-fast gcc@11.2.0 %apple-clang
+
+  install_jupyter_clang:
+    name: jupyter
+    if: github.repository == 'spack/spack'
+    runs-on: macos-latest
+    timeout-minutes: 700
+    steps:
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b # @v2
+    - uses: actions/setup-python@c4e89fac7e8767b327bbad6cb4d859eda999cf08 # @v2
+      with:
+        python-version: 3.9
+    - name: spack install
+      run: |
+        . .github/workflows/install_spack.sh
+        spack install -v --fail-fast py-jupyterlab %apple-clang
+
+  install_scipy_clang:
+    name: scipy, mpl, pd
+    if: github.repository == 'spack/spack'
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b # @v2
+    - uses: actions/setup-python@c4e89fac7e8767b327bbad6cb4d859eda999cf08 # @v2
+      with:
+        python-version: 3.9
+    - name: spack install
+      run: |
+        . .github/workflows/install_spack.sh
+        spack install -v --fail-fast py-scipy %apple-clang
+        spack install -v --fail-fast py-matplotlib %apple-clang
+        spack install -v --fail-fast py-pandas %apple-clang

.github/workflows/setup_git.ps1

@@ -1,4 +1,6 @@
-# (c) 2022 Lawrence Livermore National Laboratory
+# (c) 2021 Lawrence Livermore National Laboratory
+
+Set-Location spack
 
 git config --global user.email "spack@example.com"
 git config --global user.name "Test User"

.github/workflows/unit_tests.yaml

@@ -1,56 +1,120 @@
-name: unit tests
+name: linux tests
 
 on:
-  workflow_dispatch:
-  workflow_call:
+  push:
+    branches:
+      - develop
+      - releases/**
+  pull_request:
+    branches:
+      - develop
+      - releases/**
 
 concurrency:
-  group: unit_tests-${{github.ref}}-${{github.event.pull_request.number || github.run_number}}
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.run_number }}
   cancel-in-progress: true
 
 jobs:
-  # Run unit tests with different configurations on linux
-  ubuntu:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest]
-        python-version: ['3.7', '3.8', '3.9', '3.10', '3.11']
-        concretizer: ['clingo']
-        on_develop:
-        - ${{ github.ref == 'refs/heads/develop' }}
-        include:
-        - python-version: '3.11'
-          os: ubuntu-latest
-          concretizer: original
-          on_develop: ${{ github.ref == 'refs/heads/develop' }}
-        - python-version: '3.6'
-          os: ubuntu-20.04
-          concretizer: clingo
-          on_develop: ${{ github.ref == 'refs/heads/develop' }}
-        exclude:
-        - python-version: '3.7'
-          os: ubuntu-latest
-          concretizer: 'clingo'
-          on_develop: false
-        - python-version: '3.8'
-          os: ubuntu-latest
-          concretizer: 'clingo'
-          on_develop: false
-        - python-version: '3.9'
-          os: ubuntu-latest
-          concretizer: 'clingo'
-          on_develop: false
-        - python-version: '3.10'
-          os: ubuntu-latest
-          concretizer: 'clingo'
-          on_develop: false
-
+  # Validate that the code can be run on all the Python versions
+  # supported by Spack
+  validate:
+    runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # @v2
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b # @v2
+    - uses: actions/setup-python@c4e89fac7e8767b327bbad6cb4d859eda999cf08 # @v2
+      with:
+        python-version: '3.10'
+    - name: Install Python Packages
+      run: |
+        pip install --upgrade pip
+        pip install --upgrade vermin
+    - name: vermin (Spack's Core)
+      run: vermin --backport argparse --violations --backport typing -t=2.7- -t=3.5- -vvv lib/spack/spack/ lib/spack/llnl/ bin/
+    - name: vermin (Repositories)
+      run: vermin --backport argparse --violations --backport typing -t=2.7- -t=3.5- -vvv var/spack/repos
+  # Run style checks on the files that have been changed
+  style:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b # @v2
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@57ded4d7d5e986d7296eab16560982c6dd7c923b # @v2
+    - uses: actions/setup-python@c4e89fac7e8767b327bbad6cb4d859eda999cf08 # @v2
+      with:
+        python-version: '3.10'
+    - name: Install Python packages
+      run: |
+        pip install --upgrade pip six setuptools types-six
+    - name: Setup git configuration
+      run: |
+        # Need this for the git tests to succeed.
+        git --version
+        . .github/workflows/setup_git.sh
+    - name: Run style tests
+      run: |
+          share/spack/qa/run-style-tests
+  # Check which files have been updated by the PR
+  changes:
+    runs-on: ubuntu-latest
+    # Set job outputs to values from filter step
+    outputs:
+      core: ${{ steps.filter.outputs.core }}
+      packages: ${{ steps.filter.outputs.packages }}
+      with_coverage: ${{ steps.coverage.outputs.with_coverage }}
+    steps:
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b # @v2
+      if: ${{ github.event_name == 'push' }}
+      with:
+        fetch-depth: 0
+    # For pull requests it's not necessary to checkout the code
+    - uses: dorny/paths-filter@b2feaf19c27470162a626bd6fa8438ae5b263721
+      id: filter
+      with:
+        # See https://github.com/dorny/paths-filter/issues/56 for the syntax used below
+        filters: |
+          core:
+          - './!(var/**)/**'
+          packages:
+          - 'var/**'
+    # Some links for easier reference:
+    #
+    # "github" context: https://docs.github.com/en/actions/reference/context-and-expression-syntax-for-github-actions#github-context
+    # job outputs: https://docs.github.com/en/actions/reference/workflow-syntax-for-github-actions#jobsjob_idoutputs
+    # setting environment variables from earlier steps: https://docs.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-an-environment-variable
+    #
+    - id: coverage
+      # Run the subsequent jobs with coverage if core has been modified,
+      # regardless of whether this is a pull request or a push to a branch
+      run: |
+        echo Core changes: ${{ steps.filter.outputs.core }}
+        echo Event name: ${{ github.event_name }}
+        if [ "${{ steps.filter.outputs.core }}" == "true" ]
+        then
+          echo "::set-output name=with_coverage::true"
+        else
+          echo "::set-output name=with_coverage::false"
+        fi
+
+  # Run unit tests with different configurations on linux
+  unittests:
+    needs: [ validate, style, changes ]
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['2.7', '3.5', '3.6', '3.7', '3.8', '3.9', '3.10']
+        concretizer: ['clingo']
+        include:
+        - python-version: 2.7
+          concretizer: original
+        - python-version: 3.6
+          concretizer: original
+        - python-version: 3.9
+          concretizer: original
+    steps:
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b # @v2
+      with:
+        fetch-depth: 0
+    - uses: actions/setup-python@c4e89fac7e8767b327bbad6cb4d859eda999cf08 # @v2
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install System packages
@@ -59,11 +123,19 @@ jobs:
           # Needed for unit tests
           sudo apt-get -y install \
               coreutils cvs gfortran graphviz gnupg2 mercurial ninja-build \
-              cmake bison libbison-dev kcov
+              patchelf cmake bison libbison-dev kcov
     - name: Install Python packages
       run: |
-          pip install --upgrade pip setuptools pytest pytest-xdist pytest-cov
-          pip install --upgrade flake8 "isort>=4.3.5" "mypy>=0.900" "click" "black"
+          pip install --upgrade pip six setuptools pytest codecov "coverage[toml]<=6.2"
+          # ensure style checks are not skipped in unit tests for python >= 3.6
+          # note that true/false (i.e., 1/0) are opposite in conditions in python and bash
+          if python -c 'import sys; sys.exit(not sys.version_info >= (3, 6))'; then
+              pip install --upgrade flake8 isort>=4.3.5 mypy>=0.900 black
+          fi
+    - name: Pin pathlib for Python 2.7
+      if: ${{ matrix.python-version == 2.7 }}
+      run: |
+          pip install -U pathlib2==2.3.6
     - name: Setup git configuration
       run: |
           # Need this for the git tests to succeed.
@@ -75,31 +147,41 @@ jobs:
           SPACK_PYTHON: python
       run: |
           . share/spack/setup-env.sh
-          spack bootstrap disable spack-install
-          spack bootstrap now
+          spack bootstrap untrust spack-install
           spack -v solve zlib
-    - name: Run unit tests
+    - name: Run unit tests (full suite with coverage)
+      if: ${{ needs.changes.outputs.with_coverage == 'true' }}
       env:
           SPACK_PYTHON: python
-          SPACK_TEST_SOLVER: ${{ matrix.concretizer }}
-          SPACK_TEST_PARALLEL: 2
           COVERAGE: true
-          UNIT_TEST_COVERAGE: ${{ matrix.python-version == '3.11' }}
+          SPACK_TEST_SOLVER: ${{ matrix.concretizer }}
       run: |
           share/spack/qa/run-unit-tests
-    - uses: codecov/codecov-action@894ff025c7b54547a9a2a1e9f228beae737ad3c2
+          coverage combine
+          coverage xml
+    - name: Run unit tests (reduced suite without coverage)
+      if: ${{ needs.changes.outputs.with_coverage == 'false' }}
+      env:
+          SPACK_PYTHON: python
+          ONLY_PACKAGES: true
+          SPACK_TEST_SOLVER: ${{ matrix.concretizer }}
+      run: |
+          share/spack/qa/run-unit-tests
+    - uses: codecov/codecov-action@81cd2dc8148241f03f5839d295e000b8f761e378 # @v2.1.0
+      if: ${{ needs.changes.outputs.with_coverage == 'true' }}
       with:
         flags: unittests,linux,${{ matrix.concretizer }}
   # Test shell integration
   shell:
+    needs: [ validate, style, changes ]
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # @v2
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b # @v2
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@57ded4d7d5e986d7296eab16560982c6dd7c923b # @v2
+    - uses: actions/setup-python@c4e89fac7e8767b327bbad6cb4d859eda999cf08 # @v2
       with:
-        python-version: '3.11'
+        python-version: '3.10'
     - name: Install System packages
       run: |
           sudo apt-get -y update
@@ -107,25 +189,33 @@ jobs:
           sudo apt-get install -y coreutils kcov csh zsh tcsh fish dash bash
     - name: Install Python packages
       run: |
-          pip install --upgrade pip setuptools pytest coverage[toml] pytest-xdist
+          pip install --upgrade pip six setuptools pytest codecov coverage[toml]==6.2
     - name: Setup git configuration
       run: |
           # Need this for the git tests to succeed.
           git --version
           . .github/workflows/setup_git.sh
-    - name: Run shell tests
+    - name: Run shell tests (without coverage)
+      if: ${{ needs.changes.outputs.with_coverage == 'false' }}
+      run: |
+          share/spack/qa/run-shell-tests
+    - name: Run shell tests (with coverage)
+      if: ${{ needs.changes.outputs.with_coverage == 'true' }}
       env:
           COVERAGE: true
       run: |
           share/spack/qa/run-shell-tests
-    - uses: codecov/codecov-action@894ff025c7b54547a9a2a1e9f228beae737ad3c2
+    - uses: codecov/codecov-action@81cd2dc8148241f03f5839d295e000b8f761e378 # @v2.1.0
+      if: ${{ needs.changes.outputs.with_coverage == 'true' }}
       with:
         flags: shelltests,linux
 
   # Test RHEL8 UBI with platform Python. This job is run
   # only on PRs modifying core Spack
   rhel8-platform-python:
+    needs: [ validate, style, changes ]
     runs-on: ubuntu-latest
+    if: ${{ needs.changes.outputs.with_coverage == 'true' }}
     container: registry.access.redhat.com/ubi8/ubi
     steps:
     - name: Install dependencies
@@ -133,11 +223,10 @@ jobs:
           dnf install -y \
               bzip2 curl file gcc-c++ gcc gcc-gfortran git gnupg2 gzip \
               make patch tcl unzip which xz
-    - uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # @v2
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b # @v2
     - name: Setup repo and non-root user
       run: |
           git --version
-          git config --global --add safe.directory /__w/spack/spack
           git fetch --unshallow
           . .github/workflows/setup_git.sh
           useradd spack-test
@@ -146,71 +235,127 @@ jobs:
       shell: runuser -u spack-test -- bash {0}
       run: |
           source share/spack/setup-env.sh
-          spack -d bootstrap now --dev
+          spack -d solve zlib
           spack unit-test -k 'not cvs and not svn and not hg' -x --verbose
   # Test for the clingo based solver (using clingo-cffi)
   clingo-cffi:
+    needs: [ validate, style, changes ]
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # @v2
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b # @v2
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@57ded4d7d5e986d7296eab16560982c6dd7c923b # @v2
+    - uses: actions/setup-python@c4e89fac7e8767b327bbad6cb4d859eda999cf08 # @v2
       with:
-        python-version: '3.11'
+        python-version: '3.10'
     - name: Install System packages
       run: |
           sudo apt-get -y update
-          sudo apt-get -y install coreutils cvs gfortran graphviz gnupg2 mercurial ninja-build kcov
+          # Needed for unit tests
+          sudo apt-get -y install \
+              coreutils cvs gfortran graphviz gnupg2 mercurial ninja-build \
+              patchelf kcov
     - name: Install Python packages
       run: |
-          pip install --upgrade pip setuptools pytest coverage[toml] pytest-cov clingo pytest-xdist
+          pip install --upgrade pip six setuptools pytest codecov coverage[toml]==6.2 clingo
     - name: Setup git configuration
       run: |
           # Need this for the git tests to succeed.
           git --version
           . .github/workflows/setup_git.sh
     - name: Run unit tests (full suite with coverage)
+      if: ${{ needs.changes.outputs.with_coverage == 'true' }}
       env:
           COVERAGE: true
           SPACK_TEST_SOLVER: clingo
       run: |
           share/spack/qa/run-unit-tests
-    - uses: codecov/codecov-action@894ff025c7b54547a9a2a1e9f228beae737ad3c2 # @v2.1.0
+          coverage combine
+          coverage xml
+    - name: Run unit tests (reduced suite without coverage)
+      if: ${{ needs.changes.outputs.with_coverage == 'false' }}
+      env:
+          ONLY_PACKAGES: true
+          SPACK_TEST_SOLVER: clingo
+      run: |
+          share/spack/qa/run-unit-tests
+    - uses: codecov/codecov-action@81cd2dc8148241f03f5839d295e000b8f761e378 # @v2.1.0
+      if: ${{ needs.changes.outputs.with_coverage == 'true' }}
       with:
         flags: unittests,linux,clingo
   # Run unit tests on MacOS
-  macos:
+  build:
+    needs: [ validate, style, changes ]
     runs-on: macos-latest
     strategy:
       matrix:
-        python-version: ["3.10"]
+        python-version: [3.8]
     steps:
-    - uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # @v2
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b # @v2
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@57ded4d7d5e986d7296eab16560982c6dd7c923b # @v2
+    - uses: actions/setup-python@c4e89fac7e8767b327bbad6cb4d859eda999cf08 # @v2
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install Python packages
       run: |
-          pip install --upgrade pip setuptools
-          pip install --upgrade pytest coverage[toml] pytest-xdist pytest-cov
+          pip install --upgrade pip six setuptools
+          pip install --upgrade pytest codecov coverage[toml]==6.2
     - name: Setup Homebrew packages
       run: |
         brew install dash fish gcc gnupg2 kcov
     - name: Run unit tests
       env:
         SPACK_TEST_SOLVER: clingo
-        SPACK_TEST_PARALLEL: 4
       run: |
         git --version
         . .github/workflows/setup_git.sh
         . share/spack/setup-env.sh
-        $(which spack) bootstrap disable spack-install
+        $(which spack) bootstrap untrust spack-install
         $(which spack) solve zlib
-        common_args=(--dist loadfile --tx '4*popen//python=./bin/spack-tmpconfig python -u ./bin/spack python' -x)
-        $(which spack) unit-test --cov --cov-config=pyproject.toml --cov-report=xml:coverage.xml "${common_args[@]}"
-    - uses: codecov/codecov-action@894ff025c7b54547a9a2a1e9f228beae737ad3c2
+        if [ "${{ needs.changes.outputs.with_coverage }}" == "true" ]
+        then
+          coverage run $(which spack) unit-test -x
+          coverage combine
+          coverage xml
+          # Delete the symlink going from ./lib/spack/docs/_spack_root back to
+          # the initial directory, since it causes ELOOP errors with codecov/actions@2
+          rm lib/spack/docs/_spack_root
+        else
+          echo "ONLY PACKAGE RECIPES CHANGED [skipping coverage]"
+          $(which spack) unit-test -x -m "not maybeslow" -k "package_sanity"
+        fi
+    - uses: codecov/codecov-action@81cd2dc8148241f03f5839d295e000b8f761e378 # @v2.1.0
+      if: ${{ needs.changes.outputs.with_coverage == 'true' }}
       with:
+        files: ./coverage.xml
         flags: unittests,macos
+
+  # Run audits on all the packages in the built-in repository
+  package-audits:
+    needs: [ validate, style, changes ]
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b # @v2
+    - uses: actions/setup-python@c4e89fac7e8767b327bbad6cb4d859eda999cf08 # @v2
+      with:
+        python-version: '3.10'
+    - name: Install Python packages
+      run: |
+        pip install --upgrade pip six setuptools pytest codecov coverage[toml]==6.2
+    - name: Package audits (with coverage)
+      if: ${{ needs.changes.outputs.with_coverage == 'true' }}
+      run: |
+          . share/spack/setup-env.sh
+          coverage run $(which spack) audit packages
+          coverage combine
+          coverage xml
+    - name: Package audits (without coverage)
+      if: ${{ needs.changes.outputs.with_coverage == 'false' }}
+      run: |
+          . share/spack/setup-env.sh
+          $(which spack) audit packages
+    - uses: codecov/codecov-action@81cd2dc8148241f03f5839d295e000b8f761e378 # @v2.1.0
+      if: ${{ needs.changes.outputs.with_coverage == 'true' }}
+      with:
+        flags: unittests,linux,audits

.github/workflows/valid-style.yml

@@ -1,86 +0,0 @@
-name: style
-
-on:
-  workflow_call:
-    inputs:
-      with_coverage:
-        required: true
-        type: string
-
-concurrency:
-  group: style-${{github.ref}}-${{github.event.pull_request.number || github.run_number}}
-  cancel-in-progress: true
-
-
-jobs:
-  # Validate that the code can be run on all the Python versions
-  # supported by Spack
-  validate:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # @v2
-    - uses: actions/setup-python@57ded4d7d5e986d7296eab16560982c6dd7c923b # @v2
-      with:
-        python-version: '3.11'
-        cache: 'pip'
-    - name: Install Python Packages
-      run: |
-        pip install --upgrade pip
-        pip install --upgrade vermin
-    - 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)
-      run: vermin --backport importlib --backport argparse --violations --backport typing -t=3.6- -vvv var/spack/repos
-  # Run style checks on the files that have been changed
-  style:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # @v2
-      with:
-        fetch-depth: 0
-    - uses: actions/setup-python@57ded4d7d5e986d7296eab16560982c6dd7c923b # @v2
-      with:
-        python-version: '3.11'
-        cache: 'pip'
-    - name: Install Python packages
-      run: |
-        python3 -m pip install --upgrade pip setuptools types-six black==23.1.0 mypy isort clingo flake8
-    - name: Setup git configuration
-      run: |
-        # Need this for the git tests to succeed.
-        git --version
-        . .github/workflows/setup_git.sh
-    - name: Run style tests
-      run: |
-          share/spack/qa/run-style-tests
-  audit:
-    uses: ./.github/workflows/audit.yaml
-    with:
-      with_coverage: ${{ inputs.with_coverage }}
-      python_version: '3.11'
-  # Check that spack can bootstrap the development environment on Python 3.6 - RHEL8
-  bootstrap-dev-rhel8:
-    runs-on: ubuntu-latest
-    container: registry.access.redhat.com/ubi8/ubi
-    steps:
-      - name: Install dependencies
-        run: |
-          dnf install -y \
-              bzip2 curl file gcc-c++ gcc gcc-gfortran git gnupg2 gzip \
-              make patch tcl unzip which xz
-      - uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # @v2
-      - name: Setup repo and non-root user
-        run: |
-          git --version
-          git config --global --add safe.directory /__w/spack/spack
-          git fetch --unshallow
-          . .github/workflows/setup_git.sh
-          useradd spack-test
-          chown -R spack-test .
-      - name: Bootstrap Spack development environment
-        shell: runuser -u spack-test -- bash {0}
-        run: |
-          source share/spack/setup-env.sh
-          spack -d bootstrap now --dev
-          spack style -t black
-          spack unit-test -V

.github/workflows/windows_python.yml

@@ -1,80 +1,193 @@
-name: windows
+name: windows tests
 
 on:
-  workflow_call:
+  push:
+    branches:
+      - develop
+      - releases/**
+  pull_request:
+    branches:
+      - develop
+      - releases/**
 
 concurrency:
-  group: windows-${{github.ref}}-${{github.event.pull_request.number || github.run_number}}
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.run_number }}
   cancel-in-progress: true
 
 defaults:
   run:
     shell:
-     powershell Invoke-Expression -Command "./share/spack/qa/windows_test_setup.ps1"; {0}
+     powershell Invoke-Expression -Command ".\share\spack\qa\windows_test_setup.ps1"; {0}
 jobs:
-  unit-tests:
+  validate:
     runs-on: windows-latest
     steps:
-    - uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b
+    - uses: actions/setup-python@c4e89fac7e8767b327bbad6cb4d859eda999cf08
+      with:
+        python-version: 3.9
+    - name: Install Python Packages
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install --upgrade vermin
+    - name: vermin (Spack's Core)
+      run: vermin --backport argparse --backport typing -t='2.7-' -t='3.5-' -v spack/lib/spack/spack/ spack/lib/spack/llnl/ spack/bin/
+    - name: vermin (Repositories)
+      run: vermin --backport argparse --backport typing -t='2.7-' -t='3.5-' -v spack/var/spack/repos
+  # Run style checks on the files that have been changed
+  style:
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@57ded4d7d5e986d7296eab16560982c6dd7c923b
+    - uses: actions/setup-python@c4e89fac7e8767b327bbad6cb4d859eda999cf08
       with:
         python-version: 3.9
     - name: Install Python packages
       run: |
-          python -m pip install --upgrade pip pywin32 setuptools pytest-cov clingo
+        python -m pip install --upgrade pip six setuptools flake8 isort>=4.3.5 mypy>=0.800 black pywin32 types-python-dateutil
     - name: Create local develop
       run: |
-        ./.github/workflows/setup_git.ps1
+        .\spack\.github\workflows\setup_git.ps1
+    - name: Run style tests
+      run: |
+        spack style
+    - name: Verify license headers
+      run: |
+        python spack\bin\spack license verify
+  unittest:
+    needs: [ validate, style ]
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b
+      with:
+        fetch-depth: 0
+    - uses: actions/setup-python@c4e89fac7e8767b327bbad6cb4d859eda999cf08
+      with:
+        python-version: 3.9
+    - name: Install Python packages
+      run: |
+          python -m pip install --upgrade pip six pywin32 setuptools codecov coverage
+    - name: Create local develop
+      run: |
+        .\spack\.github\workflows\setup_git.ps1
     - name: Unit Test
       run: |
-        spack unit-test -x --verbose --cov --cov-config=pyproject.toml --ignore=lib/spack/spack/test/cmd
-        ./share/spack/qa/validate_last_exit.ps1
-        coverage combine -a
-        coverage xml
-    - uses: codecov/codecov-action@894ff025c7b54547a9a2a1e9f228beae737ad3c2
-      with:
-        flags: unittests,windows
-  unit-tests-cmd:
+        echo F|xcopy .\spack\share\spack\qa\configuration\windows_config.yaml $env:USERPROFILE\.spack\windows\config.yaml
+        spack unit-test --verbose --ignore=lib/spack/spack/test/cmd
+  unittest-cmd:
+    needs: [ validate, style ]
     runs-on: windows-latest
     steps:
-    - uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@57ded4d7d5e986d7296eab16560982c6dd7c923b
+    - uses: actions/setup-python@c4e89fac7e8767b327bbad6cb4d859eda999cf08
       with:
         python-version: 3.9
     - name: Install Python packages
       run: |
-          python -m pip install --upgrade pip pywin32 setuptools coverage pytest-cov clingo
+          python -m pip install --upgrade pip six pywin32 setuptools codecov coverage
     - name: Create local develop
       run: |
-        ./.github/workflows/setup_git.ps1
+        .\spack\.github\workflows\setup_git.ps1
     - name: Command Unit Test
       run: |
-        spack unit-test -x --verbose --cov --cov-config=pyproject.toml lib/spack/spack/test/cmd
-        ./share/spack/qa/validate_last_exit.ps1
-        coverage combine -a
-        coverage xml
-    - uses: codecov/codecov-action@894ff025c7b54547a9a2a1e9f228beae737ad3c2
-      with:
-        flags: unittests,windows
-  build-abseil:
+        echo F|xcopy .\spack\share\spack\qa\configuration\windows_config.yaml $env:USERPROFILE\.spack\windows\config.yaml
+        spack unit-test lib/spack/spack/test/cmd --verbose
+  buildtest:
+    needs: [ validate, style ]
     runs-on: windows-latest
     steps:
-    - uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@57ded4d7d5e986d7296eab16560982c6dd7c923b
+    - uses: actions/setup-python@c4e89fac7e8767b327bbad6cb4d859eda999cf08
       with:
         python-version: 3.9
     - name: Install Python packages
       run: |
-          python -m pip install --upgrade pip pywin32 setuptools coverage
+          python -m pip install --upgrade pip six pywin32 setuptools codecov coverage
     - name: Build Test
       run: |
         spack compiler find
+        echo F|xcopy .\spack\share\spack\qa\configuration\windows_config.yaml $env:USERPROFILE\.spack\windows\config.yaml
         spack external find cmake
         spack external find ninja
-        spack -d install abseil-cpp
+        spack install abseil-cpp
+  generate-installer-test:
+    needs: [ validate, style ]
+    runs-on: windows-latest
+    steps:
+    - name: Disable Windows Symlinks
+      run: |
+        git config --global core.symlinks false
+      shell:
+        powershell
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b
+      with:
+        fetch-depth: 0
+    - uses: actions/setup-python@c4e89fac7e8767b327bbad6cb4d859eda999cf08
+      with:
+        python-version: 3.9
+    - name: Install Python packages
+      run: |
+          python -m pip install --upgrade pip six pywin32 setuptools codecov coverage
+    - name: Add Light and Candle to Path
+      run: |
+        $env:WIX >> $GITHUB_PATH
+    - name: Run Installer
+      run: |
+        .\spack\share\spack\qa\setup_spack.ps1
+        spack make-installer -s spack -g SILENT pkg
+        echo "installer_root=$((pwd).Path)" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf8 -Append
+      env:
+        ProgressPreference: SilentlyContinue
+    - uses: actions/upload-artifact@3cea5372237819ed00197afe530f5a7ea3e805c8
+      with:
+        name: Windows Spack Installer Bundle
+        path: ${{ env.installer_root }}\pkg\Spack.exe
+    - uses: actions/upload-artifact@3cea5372237819ed00197afe530f5a7ea3e805c8
+      with:
+        name: Windows Spack Installer
+        path: ${{ env.installer_root}}\pkg\Spack.msi
+  execute-installer:
+    needs: generate-installer-test
+    runs-on: windows-latest
+    defaults:
+      run:
+        shell: pwsh
+    steps:
+    - uses: actions/setup-python@c4e89fac7e8767b327bbad6cb4d859eda999cf08
+      with:
+        python-version: 3.9
+    - name: Install Python packages
+      run: |
+          python -m pip install --upgrade pip six pywin32 setuptools codecov coverage
+    - name: Setup installer directory
+      run: |
+        mkdir -p spack_installer
+        echo "spack_installer=$((pwd).Path)\spack_installer" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf8 -Append
+    - uses: actions/download-artifact@v3
+      with:
+        name: Windows Spack Installer Bundle
+        path: ${{ env.spack_installer }}
+    - name: Execute Bundled Installer
+      run: |
+        $proc = Start-Process  ${{ env.spack_installer }}\spack.exe "/install /quiet" -Passthru
+        $handle = $proc.Handle # cache proc.Handle
+        $proc.WaitForExit();
+        $LASTEXITCODE
+      env:
+        ProgressPreference: SilentlyContinue
+    - uses: actions/download-artifact@v3
+      with:
+        name: Windows Spack Installer
+        path: ${{ env.spack_installer }}
+    - name: Execute MSI
+      run: |
+        $proc = Start-Process  ${{ env.spack_installer }}\spack.msi "/quiet" -Passthru
+        $handle = $proc.Handle # cache proc.Handle
+        $proc.WaitForExit();
+        $LASTEXITCODE

.readthedocs.yml

@@ -1,16 +1,10 @@
 version: 2
 
-build:
-  os: "ubuntu-22.04"
-  apt_packages:
-    - graphviz
-  tools:
-    python: "3.11"
-
 sphinx:
   configuration: lib/spack/docs/conf.py
   fail_on_warning: true
 
 python:
+  version: 3.7
   install:
     - requirements: lib/spack/docs/requirements.txt

CHANGELOG.md

@@ -1,532 +1,3 @@
-# v0.20.0 (2023-05-21)
-
-`v0.20.0` is a major feature release.
-
-## Features in this release
-
-1. **`requires()` directive and enhanced package requirements**
-
-   We've added some more enhancements to requirements in Spack (#36286).
-
-   There is a new `requires()` directive for packages. `requires()` is the opposite of
-   `conflicts()`. You can use it to impose constraints on this package when certain
-   conditions are met:
-
-   ```python
-   requires(
-       "%apple-clang",
-       when="platform=darwin",
-       msg="This package builds only with clang on macOS"
-   )
-   ```
-
-   More on this in [the docs](
-     https://spack.rtfd.io/en/latest/packaging_guide.html#conflicts-and-requirements).
-
-   You can also now add a `when:` clause to `requires:` in your `packages.yaml`
-   configuration or in an environment:
-
-   ```yaml
-   packages:
-     openmpi:
-       require:
-       - any_of: ["%gcc"]
-         when: "@:4.1.4"
-         message: "Only OpenMPI 4.1.5 and up can build with fancy compilers"
-   ```
-
-   More details can be found [here](
-     https://spack.readthedocs.io/en/latest/build_settings.html#package-requirements)
-
-2. **Exact versions**
-
-   Spack did not previously have a way to distinguish a version if it was a prefix of
-   some other version. For example, `@3.2` would match `3.2`, `3.2.1`, `3.2.2`, etc. You
-   can now match *exactly* `3.2` with `@=3.2`. This is useful, for example, if you need
-   to patch *only* the `3.2` version of a package. The new syntax is described in [the docs](
-     https://spack.readthedocs.io/en/latest/basic_usage.html#version-specifier).
-
-   Generally, when writing packages, you should prefer to use ranges like `@3.2` over
-   the specific versions, as this allows the concretizer more leeway when selecting
-   versions of dependencies. More details and recommendations are in the [packaging guide](
-     https://spack.readthedocs.io/en/latest/packaging_guide.html#ranges-versus-specific-versions).
-
-   See #36273 for full details on the version refactor.
-
-3. **New testing interface**
-
-   Writing package tests is now much simpler with a new [test interface](
-     https://spack.readthedocs.io/en/latest/packaging_guide.html#stand-alone-tests).
-
-   Writing a test is now as easy as adding a method that starts with `test_`:
-
-   ```python
-   class MyPackage(Package):
-       ...
-
-       def test_always_fails(self):
-           """use assert to always fail"""
-           assert False
-
-       def test_example(self):
-           """run installed example"""
-           example = which(self.prefix.bin.example)
-           example()
-    ```
-
-    You can use Python's native `assert` statement to implement your checks -- no more
-    need to fiddle with `run_test` or other test framework methods. Spack will
-    introspect the class and run `test_*` methods when you run `spack test`,
-
-4. **More stable concretization**
-
-   * Now, `spack concretize` will *only* concretize the new portions of the environment
-     and will not change existing parts of an environment unless you specify `--force`.
-     This has always been true for `unify:false`, but not for `unify:true` and
-     `unify:when_possible` environments. Now it is true for all of them (#37438, #37681).
-
-   * The concretizer has a new `--reuse-deps` argument that *only* reuses dependencies.
-     That is, it will always treat the *roots* of your environment as it would with
-     `--fresh`. This allows you to upgrade just the roots of your environment while
-     keeping everything else stable (#30990).
-
-5. **Weekly develop snapshot releases**
-
-   Since last year, we have maintained a buildcache of `develop` at
-   https://binaries.spack.io/develop, but the cache can grow to contain so many builds
-   as to be unwieldy. When we get a stable `develop` build, we snapshot the release and
-   add a corresponding tag the Spack repository. So, you can use a stack from a specific
-   day. There are now tags in the spack repository like:
-
-   * `develop-2023-05-14`
-   * `develop-2023-05-18`
-
-   that correspond to build caches like:
-
-   * https://binaries.spack.io/develop-2023-05-14/e4s
-   * https://binaries.spack.io/develop-2023-05-18/e4s
-
-   We plan to store these snapshot releases weekly.
-
-6. **Specs in buildcaches can be referenced by hash.**
-
-   * Previously, you could run `spack buildcache list` and see the hashes in
-     buildcaches, but referring to them by hash would fail.
-   * You can now run commands like `spack spec` and `spack install` and refer to
-     buildcache hashes directly, e.g. `spack install /abc123` (#35042)
-
-7. **New package and buildcache index websites**
-
-   Our public websites for searching packages have been completely revamped and updated.
-   You can check them out here:
-
-   * *Package Index*: https://packages.spack.io
-   * *Buildcache Index*: https://cache.spack.io
-
-   Both are searchable and more interactive than before. Currently major releases are
-   shown; UI for browsing `develop` snapshots is coming soon.
-
-8. **Default CMake and Meson build types are now Release**
-
-   Spack has historically defaulted to building with optimization and debugging, but
-   packages like `llvm` can be enormous with debug turned on. Our default build type for
-   all Spack packages is now `Release` (#36679, #37436). This has a number of benefits:
-
-   * much smaller binaries;
-   * higher default optimization level; and
-   * defining `NDEBUG` disables assertions, which may lead to further speedups.
-
-   You can still get the old behavior back through requirements and package preferences.
-
-## Other new commands and directives
-
-* `spack checksum` can automatically add new versions to package (#24532)
-* new command: `spack pkg grep` to easily search package files (#34388)
-* New `maintainers` directive (#35083)
-* Add `spack buildcache push` (alias to `buildcache create`) (#34861)
-* Allow using `-j` to control the parallelism of concretization (#37608)
-* Add `--exclude` option to 'spack external find' (#35013)
-
-## Other new features of note
-
-* editing: add higher-precedence `SPACK_EDITOR` environment variable
-* Many YAML formatting improvements from updating `ruamel.yaml` to the latest version
-  supporting Python 3.6. (#31091, #24885, #37008).
-* Requirements and preferences should not define (non-git) versions (#37687, #37747)
-* Environments now store spack version/commit in `spack.lock` (#32801)
-* User can specify the name of the `packages` subdirectory in repositories (#36643)
-* Add container images supporting RHEL alternatives (#36713)
-* make version(...) kwargs explicit (#36998)
-
-## Notable refactors
-
-* buildcache create: reproducible tarballs (#35623)
-* Bootstrap most of Spack dependencies using environments (#34029)
-* Split `satisfies(..., strict=True/False)` into two functions (#35681)
-* spack install: simplify behavior when inside environments (#35206)
-
-## Binary cache and stack updates
-
-* Major simplification of CI boilerplate in stacks (#34272, #36045)
-* Many improvements to our CI pipeline's reliability
-
-## Removals, Deprecations, and disablements
-* Module file generation is disabled by default; you'll need to enable it to use it (#37258)
-* Support for Python 2 was deprecated in `v0.19.0` and has been removed. `v0.20.0` only
-  supports Python 3.6 and higher.
-* Deprecated target names are no longer recognized by Spack. Use generic names instead:
-  * `graviton` is now `cortex_a72`
-  * `graviton2` is now `neoverse_n1`
-  * `graviton3` is now `neoverse_v1`
-* `blacklist` and `whitelist` in module configuration were deprecated in `v0.19.0` and are
-  removed in this release. Use `exclude` and `include` instead.
-* The `ignore=` parameter of the `extends()` directive has been removed. It was not used by
-  any builtin packages and is no longer needed to avoid conflicts in environment views (#35588).
-* Support for the old YAML buildcache format has been removed. It was deprecated in `v0.19.0` (#34347).
-* `spack find --bootstrap` has been removed. It was deprecated in `v0.19.0`. Use `spack
-  --bootstrap find` instead (#33964).
-* `spack bootstrap trust` and `spack bootstrap untrust` are now removed, having been
-  deprecated in `v0.19.0`. Use `spack bootstrap enable` and `spack bootstrap disable`.
-* The `--mirror-name`, `--mirror-url`, and `--directory` options to buildcache and
-  mirror commands were deprecated in `v0.19.0` and have now been removed. They have been
-  replaced by positional arguments (#37457).
-* Deprecate `env:` as top level environment key (#37424)
-* deprecate buildcache create --rel, buildcache install --allow-root (#37285)
-* Support for very old perl-like spec format strings (e.g., `$_$@$%@+$+$=`) has been
-  removed (#37425). This was deprecated in in `v0.15` (#10556).
-
-## Notable Bugfixes
-
-* bugfix: don't fetch package metadata for unknown concrete specs (#36990)
-* Improve package source code context display on error  (#37655)
-* Relax environment manifest filename requirements and lockfile identification criteria (#37413)
-* `installer.py`: drop build edges of installed packages by default (#36707)
-* Bugfix: package requirements with git commits (#35057, #36347)
-* Package requirements: allow single specs in requirement lists (#36258)
-* conditional variant values: allow boolean (#33939)
-* spack uninstall: follow run/link edges on --dependents (#34058)
-
-## Spack community stats
-
-* 7,179 total packages, 499 new since `v0.19.0`
-    * 329 new Python packages
-    * 31 new R packages
-* 336 people contributed to this release
-    * 317 committers to packages
-    * 62 committers to core
-
-
-# v0.19.1 (2023-02-07)
-
-### Spack Bugfixes
-
-* `buildcache create`: make "file exists" less verbose (#35019)
-* `spack mirror create`: don't change paths to urls (#34992)
-* Improve error message for requirements (#33988)
-* uninstall: fix accidental cubic complexity (#34005)
-* scons: fix signature for `install_args` (#34481)
-* Fix `combine_phase_logs` text encoding issues (#34657)
-* Use a module-like object to propagate changes in the MRO, when setting build env (#34059)
-* PackageBase should not define builder legacy attributes (#33942)
-* Forward lookup of the "run_tests" attribute (#34531)
-* Bugfix for timers (#33917, #33900)
-* Fix path handling in prefix inspections (#35318)
-* Fix libtool filter for Fujitsu compilers (#34916)
-* Bug fix for duplicate rpath errors on macOS when creating build caches (#34375)
-* FileCache: delete the new cache file on exception (#34623)
-* Propagate exceptions from Spack python console (#34547)
-* Tests: Fix a bug/typo in a `config_values.py` fixture (#33886)
-* Various CI fixes (#33953, #34560, #34560, #34828)
-* Docs: remove monitors and analyzers, typos (#34358, #33926)
-* bump release version for tutorial command (#33859)
-
-
-# v0.19.0 (2022-11-11)
-
-`v0.19.0` is a major feature release.
-
-## Major features in this release
-
-1. **Package requirements**
-
-   Spack's traditional [package preferences](
-     https://spack.readthedocs.io/en/latest/build_settings.html#package-preferences)
-   are soft, but we've added hard requriements to `packages.yaml` and `spack.yaml`
-   (#32528, #32369). Package requirements use the same syntax as specs:
-
-   ```yaml
-   packages:
-     libfabric:
-       require: "@1.13.2"
-     mpich:
-       require:
-       - one_of: ["+cuda", "+rocm"]
-   ```
-
-   More details in [the docs](
-     https://spack.readthedocs.io/en/latest/build_settings.html#package-requirements).
-
-2. **Environment UI Improvements**
-
-   * Fewer surprising modifications to `spack.yaml` (#33711):
-
-     * `spack install` in an environment will no longer add to the `specs:` list; you'll
-       need to either use `spack add <spec>` or `spack install --add <spec>`.
-
-     * Similarly, `spack uninstall` will not remove from your environment's `specs:`
-       list; you'll need to use `spack remove` or `spack uninstall --remove`.
-
-     This will make it easier to manage an environment, as there is clear separation
-     between the stack to be installed (`spack.yaml`/`spack.lock`) and which parts of
-     it should be installed (`spack install` / `spack uninstall`).
-
-   * `concretizer:unify:true` is now the default mode for new environments (#31787)
-
-     We see more users creating `unify:true` environments now. Users who need
-     `unify:false` can add it to their environment to get the old behavior. This will
-     concretize every spec in the environment independently.
-
-   * Include environment configuration from URLs (#29026, [docs](
-       https://spack.readthedocs.io/en/latest/environments.html#included-configurations))
-
-     You can now include configuration in your environment directly from a URL:
-
-     ```yaml
-     spack:
-       include:
-       - https://github.com/path/to/raw/config/compilers.yaml
-     ```
-
-4. **Multiple Build Systems**
-
-   An increasing number of packages in the ecosystem need the ability to support
-   multiple build systems (#30738, [docs](
-     https://spack.readthedocs.io/en/latest/packaging_guide.html#multiple-build-systems)),
-   either across versions, across platforms, or within the same version of the software.
-   This has been hard to support through multiple inheritance, as methods from different
-   build system superclasses would conflict. `package.py` files can now define separate
-   builder classes with installation logic for different build systems, e.g.:
-
-   ```python
-   class ArpackNg(CMakePackage, AutotoolsPackage):
-
-       build_system(
-           conditional("cmake", when="@0.64:"),
-           conditional("autotools", when="@:0.63"),
-           default="cmake",
-       )
-
-   class CMakeBuilder(spack.build_systems.cmake.CMakeBuilder):
-       def cmake_args(self):
-           pass
-
-   class Autotoolsbuilder(spack.build_systems.autotools.AutotoolsBuilder):
-       def configure_args(self):
-           pass
-   ```
-
-5. **Compiler and variant propagation**
-
-   Currently, compiler flags and variants are inconsistent: compiler flags set for a
-   package are inherited by its dependencies, while variants are not. We should have
-   these be consistent by allowing for inheritance to be enabled or disabled for both
-   variants and compiler flags.
-
-   Example syntax:
-   - `package ++variant`:
-         enabled variant that will be propagated to dependencies
-   - `package +variant`:
-         enabled variant that will NOT be propagated to dependencies
-   - `package ~~variant`:
-         disabled variant that will be propagated to dependencies
-   - `package ~variant`:
-         disabled variant that will NOT be propagated to dependencies
-   - `package cflags==-g`:
-         `cflags` will be propagated to dependencies
-   - `package cflags=-g`:
-         `cflags` will NOT be propagated to dependencies
-
-   Syntax for non-boolan variants is similar to compiler flags. More in the docs for
-   [variants](
-     https://spack.readthedocs.io/en/latest/basic_usage.html#variants) and [compiler flags](
-     https://spack.readthedocs.io/en/latest/basic_usage.html#compiler-flags).
-
-6. **Enhancements to git version specifiers**
-
-   * `v0.18.0` added the ability to use git commits as versions. You can now use the
-     `git.` prefix to specify git tags or branches as versions. All of these are valid git
-     versions in `v0.19` (#31200):
-
-     ```console
-     foo@abcdef1234abcdef1234abcdef1234abcdef1234      # raw commit
-     foo@git.abcdef1234abcdef1234abcdef1234abcdef1234  # commit with git prefix
-     foo@git.develop                                   # the develop branch
-     foo@git.0.19                                      # use the 0.19 tag
-     ```
-
-   * `v0.19` also gives you more control over how Spack interprets git versions, in case
-     Spack cannot detect the version from the git repository. You can suffix a git
-     version with `=<version>` to force Spack to concretize it as a particular version
-     (#30998, #31914, #32257):
-
-     ```console
-     # use mybranch, but treat it as version 3.2 for version comparison
-     foo@git.mybranch=3.2
-
-     # use the given commit, but treat it as develop for version comparison
-     foo@git.abcdef1234abcdef1234abcdef1234abcdef1234=develop
-     ```
-
-     More in [the docs](
-       https://spack.readthedocs.io/en/latest/basic_usage.html#version-specifier)
-
-7. **Changes to Cray EX Support**
-
-   Cray machines have historically had their own "platform" within Spack, because we
-   needed to go through the module system to leverage compilers and MPI installations on
-   these machines. The Cray EX programming environment now provides standalone `craycc`
-   executables and proper `mpicc` wrappers, so Spack can treat EX machines like Linux
-   with extra packages (#29392).
-
-   We expect this to greatly reduce bugs, as external packages and compilers can now be
-   used by prefix instead of through modules. We will also no longer be subject to
-   reproducibility issues when modules change from Cray PE release to release and from
-   site to site. This also simplifies dealing with the underlying Linux OS on cray
-   systems, as Spack will properly model the machine's OS as either SuSE or RHEL.
-
-8. **Improvements to tests and testing in CI**
-
-   * `spack ci generate --tests` will generate a `.gitlab-ci.yml` file that not only does
-     builds but also runs tests for built packages (#27877). Public GitHub pipelines now
-     also run tests in CI.
-
-   * `spack test run --explicit` will only run tests for packages that are explicitly
-     installed, instead of all packages.
-
-9. **Experimental binding link model**
-
-   You can add a new option to `config.yaml` to make Spack embed absolute paths to
-   needed shared libraries in ELF executables and shared libraries on Linux (#31948, [docs](
-     https://spack.readthedocs.io/en/latest/config_yaml.html#shared-linking-bind)):
-
-   ```yaml
-   config:
-     shared_linking:
-       type: rpath
-       bind: true
-   ```
-
-   This can improve launch time at scale for parallel applications, and it can make
-   installations less susceptible to environment variables like `LD_LIBRARY_PATH`, even
-   especially when dealing with external libraries that use `RUNPATH`. You can think of
-   this as a faster, even higher-precedence version of `RPATH`.
-
-## Other new features of note
-
-* `spack spec` prints dependencies more legibly. Dependencies in the output now appear
-  at the *earliest* level of indentation possible (#33406)
-* You can override `package.py` attributes like `url`, directly in `packages.yaml`
-  (#33275, [docs](
-    https://spack.readthedocs.io/en/latest/build_settings.html#assigning-package-attributes))
-* There are a number of new architecture-related format strings you can use in Spack
-  configuration files to specify paths (#29810, [docs](
-    https://spack.readthedocs.io/en/latest/configuration.html#config-file-variables))
-* Spack now supports bootstrapping Clingo on Windows (#33400)
-* There is now support for an `RPATH`-like library model on Windows (#31930)
-
-## Performance Improvements
-
-* Major performance improvements for installation from binary caches (#27610, #33628,
-  #33636, #33608, #33590, #33496)
-* Test suite can now be parallelized using `xdist` (used in GitHub Actions) (#32361)
-* Reduce lock contention for parallel builds in environments (#31643)
-
-## New binary caches and stacks
-
-* We now build nearly all of E4S with `oneapi` in our buildcache (#31781, #31804,
-  #31804, #31803, #31840, #31991, #32117, #32107, #32239)
-* Added 3 new machine learning-centric stacks to binary cache: `x86_64_v3`, CUDA, ROCm
-  (#31592, #33463)
-
-## Removals and Deprecations
-
-* Support for Python 3.5 is dropped (#31908). Only Python 2.7 and 3.6+ are officially
-  supported.
-
-* This is the last Spack release that will support Python 2 (#32615). Spack `v0.19`
-  will emit a deprecation warning if you run it with Python 2, and Python 2 support will
-  soon be removed from the `develop` branch.
-
-* `LD_LIBRARY_PATH` is no longer set by default by `spack load` or module loads.
-
-  Setting `LD_LIBRARY_PATH` in Spack environments/modules can cause binaries from
-  outside of Spack to crash, and Spack's own builds use `RPATH` and do not need
-  `LD_LIBRARY_PATH` set in order to run. If you still want the old behavior, you
-  can run these commands to configure Spack to set `LD_LIBRARY_PATH`:
-
-  ```console
-  spack config add modules:prefix_inspections:lib64:[LD_LIBRARY_PATH]
-  spack config add modules:prefix_inspections:lib:[LD_LIBRARY_PATH]
-  ```
-
-* The `spack:concretization:[together|separately]` has been removed after being
-  deprecated in `v0.18`. Use `concretizer:unify:[true|false]`.
-* `config:module_roots` is no longer supported after being deprecated in `v0.18`. Use
-  configuration in module sets instead (#28659, [docs](
-    https://spack.readthedocs.io/en/latest/module_file_support.html)).
-* `spack activate` and `spack deactivate` are no longer supported, having been
-  deprecated in `v0.18`. Use an environment with a view instead of
-  activating/deactivating ([docs](
-    https://spack.readthedocs.io/en/latest/environments.html#configuration-in-spack-yaml)).
-* The old YAML format for buildcaches is now deprecated (#33707). If you are using an
-  old buildcache with YAML metadata you will need to regenerate it with JSON metadata.
-* `spack bootstrap trust` and `spack bootstrap untrust` are deprecated in favor of
-  `spack bootstrap enable` and `spack bootstrap disable` and will be removed in `v0.20`.
-  (#33600)
-* The `graviton2` architecture has been renamed to `neoverse_n1`, and `graviton3`
-  is now `neoverse_v1`. Buildcaches using the old architecture names will need to be rebuilt.
-* The terms `blacklist` and `whitelist` have been replaced with `include` and `exclude`
-  in all configuration files (#31569). You can use `spack config update` to
-  automatically fix your configuration files.
-
-## Notable Bugfixes
-
-* Permission setting on installation now handles effective uid properly (#19980)
-* `buildable:true` for an MPI implementation now overrides `buildable:false` for `mpi` (#18269)
-* Improved error messages when attempting to use an unconfigured compiler (#32084)
-* Do not punish explicitly requested compiler mismatches in the solver (#30074)
-* `spack stage`: add missing --fresh and --reuse (#31626)
-* Fixes for adding build system executables like `cmake` to package scope (#31739)
-* Bugfix for binary relocation with aliased strings produced by newer `binutils` (#32253)
-
-## Spack community stats
-
-* 6,751 total packages, 335 new since `v0.18.0`
-    * 141 new Python packages
-    * 89 new R packages
-* 303 people contributed to this release
-    * 287 committers to packages
-    * 57 committers to core
-
-
-# v0.18.1 (2022-07-19)
-
-### Spack Bugfixes
-* Fix several bugs related to bootstrapping (#30834,#31042,#31180)
-* Fix a regression that was causing spec hashes to differ between
-  Python 2 and Python 3 (#31092)
-* Fixed compiler flags for oneAPI and DPC++ (#30856)
-* Fixed several issues related to concretization (#31142,#31153,#31170,#31226)
-* Improved support for Cray manifest file and `spack external find` (#31144,#31201,#31173,#31186)
-* Assign a version to openSUSE Tumbleweed according to the GLIBC version
-  in the system (#19895)
-* Improved Dockerfile generation for `spack containerize` (#29741,#31321)
-* Fixed a few bugs related to concurrent execution of commands (#31509,#31493,#31477)
-
-### Package updates
-* WarpX: add v22.06, fixed libs property (#30866,#31102)
-* openPMD: add v0.14.5, update recipe for @develop (#29484,#31023)
-
 # v0.18.0 (2022-05-28)
 
 `v0.18.0` is a major feature release.
@@ -728,15 +199,6 @@
     * 337 committers to packages
     * 85 committers to core
 
-# v0.17.3 (2022-07-14)
-
-### Spack bugfixes
-
-* Fix missing chgrp on symlinks in package installations (#30743)
-* Allow having non-existing upstreams (#30744, #30746)
-* Fix `spack stage` with custom paths (#30448)
-* Fix failing call for `spack buildcache save-specfile` (#30637)
-* Fix globbing in compiler wrapper (#30699)
 
 # v0.17.2 (2022-04-13)
 

LICENSE-MIT

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2013-2023 LLNS, LLC and other Spack Project Developers.
+Copyright (c) 2013-2022 LLNS, LLC and other Spack Project Developers.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -2,10 +2,10 @@
 
 [![Unit Tests](https://github.com/spack/spack/workflows/linux%20tests/badge.svg)](https://github.com/spack/spack/actions)
 [![Bootstrapping](https://github.com/spack/spack/actions/workflows/bootstrap.yml/badge.svg)](https://github.com/spack/spack/actions/workflows/bootstrap.yml)
+[![macOS Builds (nightly)](https://github.com/spack/spack/workflows/macOS%20builds%20nightly/badge.svg?branch=develop)](https://github.com/spack/spack/actions?query=workflow%3A%22macOS+builds+nightly%22)
 [![codecov](https://codecov.io/gh/spack/spack/branch/develop/graph/badge.svg)](https://codecov.io/gh/spack/spack)
 [![Containers](https://github.com/spack/spack/actions/workflows/build-containers.yml/badge.svg)](https://github.com/spack/spack/actions/workflows/build-containers.yml)
 [![Read the Docs](https://readthedocs.org/projects/spack/badge/?version=latest)](https://spack.readthedocs.io)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 [![Slack](https://slack.spack.io/badge.svg)](https://slack.spack.io)
 
 Spack is a multi-platform package manager that builds and installs
@@ -62,7 +62,6 @@ Resources:
 
 * **Slack workspace**: [spackpm.slack.com](https://spackpm.slack.com).
   To get an invitation, visit [slack.spack.io](https://slack.spack.io).
-* [**Github Discussions**](https://github.com/spack/spack/discussions): not just for discussions, also Q&A.
 * **Mailing list**: [groups.google.com/d/forum/spack](https://groups.google.com/d/forum/spack)
 * **Twitter**: [@spackpm](https://twitter.com/spackpm). Be sure to
   `@mention` us!

SECURITY.md

@@ -10,8 +10,8 @@ For more on Spack's release structure, see
 | Version | Supported          |
 | ------- | ------------------ |
 | develop | :white_check_mark: |
-| 0.19.x  | :white_check_mark: |
-| 0.18.x  | :white_check_mark: |
+| 0.17.x  | :white_check_mark: |
+| 0.16.x  | :white_check_mark: |
 
 ## Reporting a Vulnerability
 

bin/haspywin.py

@@ -1,4 +1,4 @@
-# Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+# Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -8,12 +8,13 @@
 
 def getpywin():
     try:
-        import win32con  # noqa: F401
+        import win32con  # noqa
     except ImportError:
-        print("pyWin32 not installed but is required...\nInstalling via pip:")
-        subprocess.check_call([sys.executable, "-m", "pip", "-q", "install", "--upgrade", "pip"])
-        subprocess.check_call([sys.executable, "-m", "pip", "-q", "install", "pywin32"])
+        subprocess.check_call(
+            [sys.executable, "-m", "pip", "-q", "install", "--upgrade", "pip"])
+        subprocess.check_call(
+            [sys.executable, "-m", "pip", "-q", "install", "pywin32"])
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     getpywin()

bin/sbang

@@ -1,6 +1,6 @@
 #!/bin/sh
 #
-# Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+# Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
 # sbang project developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)

bin/spack

@@ -1,7 +1,7 @@
 #!/bin/sh
 # -*- python -*-
 #
-# Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+# Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -31,11 +31,13 @@ import os
 import os.path
 import sys
 
-min_python3 = (3, 6)
+min_python3 = (3, 5)
 
-if sys.version_info[:2] < min_python3:
+if sys.version_info[:2] < (2, 7) or (
+    sys.version_info[:2] >= (3, 0) and sys.version_info[:2] < min_python3
+):
     v_info = sys.version_info[:3]
-    msg = "Spack requires Python %d.%d or higher " % min_python3
+    msg = "Spack requires Python 2.7 or %d.%d or higher " % min_python3
     msg += "You are running spack with Python %d.%d.%d." % v_info
     sys.exit(msg)
 
@@ -47,8 +49,50 @@ spack_prefix = os.path.dirname(os.path.dirname(spack_file))
 spack_lib_path = os.path.join(spack_prefix, "lib", "spack")
 sys.path.insert(0, spack_lib_path)
 
-from spack_installable.main import main  # noqa: E402
+# Add external libs
+spack_external_libs = os.path.join(spack_lib_path, "external")
+
+if sys.version_info[:2] <= (2, 7):
+    sys.path.insert(0, os.path.join(spack_external_libs, "py2"))
+
+sys.path.insert(0, spack_external_libs)
+
+# Here we delete ruamel.yaml in case it has been already imported from site
+# (see #9206 for a broader description of the issue).
+#
+# Briefly: ruamel.yaml produces a .pth file when installed with pip that
+# makes the site installed package the preferred one, even though sys.path
+# is modified to point to another version of ruamel.yaml.
+if "ruamel.yaml" in sys.modules:
+    del sys.modules["ruamel.yaml"]
+
+if "ruamel" in sys.modules:
+    del sys.modules["ruamel"]
+
+# The following code is here to avoid failures when updating
+# the develop version, due to spurious argparse.pyc files remaining
+# in the libs/spack/external directory, see:
+# https://github.com/spack/spack/pull/25376
+# TODO: Remove in v0.18.0 or later
+try:
+    import argparse
+except ImportError:
+    argparse_pyc = os.path.join(spack_external_libs, 'argparse.pyc')
+    if not os.path.exists(argparse_pyc):
+        raise
+    try:
+        os.remove(argparse_pyc)
+        import argparse  # noqa
+    except Exception:
+        msg = ('The file\n\n\t{0}\n\nis corrupted and cannot be deleted by Spack. '
+               'Either delete it manually or ask some administrator to '
+               'delete it for you.')
+        print(msg.format(argparse_pyc))
+        sys.exit(1)
+
+
+import spack.main  # noqa
 
 # Once we've set up the system path, run the spack main method
 if __name__ == "__main__":
-    sys.exit(main())
+    sys.exit(spack.main.main())

bin/spack-python

@@ -1,6 +1,6 @@
 #!/bin/sh
 #
-# Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+# Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)

bin/spack-tmpconfig

@@ -1,96 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-[[ -n "${TMPCONFIG_DEBUG:=}" ]] && set -x
-DIR="$(cd -P "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-mkdir -p "${XDG_RUNTIME_DIR:=/tmp}/spack-tests"
-export TMPDIR="${XDG_RUNTIME_DIR}"
-export TMP_DIR="$(mktemp -d -t spack-test-XXXXX)"
-clean_up() {
-    [[ -n "$TMPCONFIG_DEBUG" ]] && printf "cleaning up: $TMP_DIR\n"
-    rm -rf "$TMP_DIR"
-}
-trap clean_up EXIT
-trap clean_up ERR
-
-[[ -n "$TMPCONFIG_DEBUG" ]] && printf "Redirecting TMP_DIR and spack directories to $TMP_DIR\n"
-
-export BOOTSTRAP="${SPACK_USER_CACHE_PATH:=$HOME/.spack}/bootstrap"
-export SPACK_USER_CACHE_PATH="$TMP_DIR/user_cache"
-mkdir -p "$SPACK_USER_CACHE_PATH"
-
-private_bootstrap="$SPACK_USER_CACHE_PATH/bootstrap"
-use_spack=''
-use_bwrap=''
-# argument handling
-while (($# >= 1)) ; do
-    case "$1" in
-        -b) # privatize bootstrap too, useful for CI but not always cheap
-            shift
-            export BOOTSTRAP="$private_bootstrap"
-            ;;
-        -B) # use specified bootstrap dir
-            export BOOTSTRAP="$2"
-            shift 2
-            ;;
-        -s) # run spack directly with remaining args
-            shift
-            use_spack=1
-            ;;
-        --contain=bwrap)
-            if bwrap --help 2>&1 > /dev/null ; then
-                use_bwrap=1
-            else
-                echo Bubblewrap containment requested, but no bwrap command found
-                exit 1
-            fi
-            shift
-            ;;
-        --)
-            shift
-            break
-            ;;
-        *)
-            break
-            ;;
-    esac
-done
-typeset -a CMD
-if [[ -n "$use_spack" ]] ; then
-    CMD=("$DIR/spack" "$@")
-else
-    CMD=("$@")
-fi
-
-mkdir -p "$BOOTSTRAP"
-
-export SPACK_SYSTEM_CONFIG_PATH="$TMP_DIR/sys_conf"
-export SPACK_USER_CONFIG_PATH="$TMP_DIR/user_conf"
-mkdir -p "$SPACK_USER_CONFIG_PATH"
-cat >"$SPACK_USER_CONFIG_PATH/config.yaml" <<EOF
-config:
-  install_tree:
-    root: $TMP_DIR/install
-  misc_cache: $$user_cache_path/cache
-  source_cache: $$user_cache_path/source
-  environments_root: $TMP_DIR/envs
-EOF
-cat >"$SPACK_USER_CONFIG_PATH/bootstrap.yaml" <<EOF
-bootstrap:
-  root: $BOOTSTRAP
-EOF
-
-if [[ -n "$use_bwrap" ]] ; then
-    CMD=(
-        bwrap
-        --dev-bind / /
-        --ro-bind "$DIR/.." "$DIR/.." # do not touch spack root
-        --ro-bind $HOME/.spack $HOME/.spack # do not touch user config/cache dir
-        --bind "$TMP_DIR" "$TMP_DIR"
-        --bind "$BOOTSTRAP" "$BOOTSTRAP"
-        --die-with-parent
-        "${CMD[@]}"
-    )
-fi
-
-(( ${TMPCONFIG_DEBUG:=0} > 1)) && echo "Running: ${CMD[@]}"
-"${CMD[@]}"

bin/spack.bat

@@ -1,4 +1,4 @@
-:: Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+:: Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
 :: Spack Project Developers. See the top-level COPYRIGHT file for details.
 ::
 :: SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -50,69 +50,24 @@ setlocal enabledelayedexpansion
 :: flags will always start with '-', e.g. --help or -V
 :: subcommands will never start with '-'
 :: everything after the subcommand is an arg
-
-:: we cannot allow batch "for" loop to directly process CL args
-:: a number of batch reserved characters are commonly passed to
-:: spack and allowing batch's "for" method to process the raw inputs
-:: results in a large number of formatting issues
-:: instead, treat the entire CLI as one string
-:: and split by space manually
-:: capture cl args in variable named cl_args
-set cl_args=%*
-:process_cl_args
-rem  tokens=1* returns the first processed token produced
-rem  by tokenizing the input string cl_args on spaces into
-rem  the named variable %%g
-rem  While this make look like a for loop, it only
-rem  executes a single time for each of the cl args
-rem  the actual iterative loop is performed by the
-rem  goto process_cl_args stanza
-rem  we are simply leveraging the "for" method's string
-rem  tokenization
-for /f "tokens=1*" %%g in ("%cl_args%") do (
-    set t=%%~g
-    rem  remainder of string is composed into %%h
-    rem  these are the cl args yet to be processed
-    rem  assign cl_args var to only the args to be processed
-    rem  effectively discarding the current arg %%g
-    rem  this will be nul when we have no further tokens to process
-    set cl_args=%%h
-    rem  process the first space delineated cl arg
-    rem  of this iteration
+for %%x in (%*) do (
+    set t="%%~x"
     if "!t:~0,1!" == "-" (
         if defined _sp_subcommand (
-            rem  We already have a subcommand, processing args now
-            if not defined _sp_args (
-                set "_sp_args=!t!"
-            ) else (
-                set "_sp_args=!_sp_args! !t!"
-            )
+            :: We already have a subcommand, processing args now
+            set "_sp_args=!_sp_args! !t!"
         ) else (
-            if not defined _sp_flags (
-                set "_sp_flags=!t!"
-                shift
-            ) else (
-                set "_sp_flags=!_sp_flags! !t!"
-                shift
-            )
+            set "_sp_flags=!_sp_flags! !t!"
+            shift
         )
     ) else if not defined _sp_subcommand (
         set "_sp_subcommand=!t!"
         shift
     ) else (
-        if not defined _sp_args (
-            set "_sp_args=!t!"
-            shift
-        ) else (
-            set "_sp_args=!_sp_args! !t!"
-            shift
-        )
+        set "_sp_args=!_sp_args! !t!"
+        shift
     )
 )
-rem  if this is not nil, we have more tokens to process
-rem  start above process again with remaining unprocessed cl args
-if defined cl_args goto :process_cl_args
-
 
 :: --help, -h and -V flags don't require further output parsing.
 :: If we encounter, execute and exit
@@ -128,24 +83,24 @@ if defined _sp_flags (
         exit /B 0
     )
 )
-if not defined _sp_subcommand (
-   if not defined _sp_args (
-      if not defined _sp_flags (
-         python "%spack%" --help
-         exit /B 0
-      )
-   )
-)
-
-
 :: pass parsed variables outside of local scope. Need to do
 :: this because delayedexpansion can only be set by setlocal
-endlocal & (
-    set "_sp_flags=%_sp_flags%"
-    set "_sp_args=%_sp_args%"
-    set "_sp_subcommand=%_sp_subcommand%"
-)
-
+echo %_sp_flags%>flags
+echo %_sp_args%>args
+echo %_sp_subcommand%>subcmd
+endlocal
+set /p _sp_subcommand=<subcmd
+set /p _sp_flags=<flags
+set /p _sp_args=<args
+set str_subcommand=%_sp_subcommand:"='%
+set str_flags=%_sp_flags:"='%
+set str_args=%_sp_args:"='%
+if "%str_subcommand%"=="ECHO is off." (set "_sp_subcommand=")
+if "%str_flags%"=="ECHO is off." (set "_sp_flags=")
+if "%str_args%"=="ECHO is off." (set "_sp_args=")
+del subcmd
+del flags
+del args
 
 :: Filter out some commands. For any others, just run the command.
 if "%_sp_subcommand%" == "cd" (
@@ -188,9 +143,7 @@ goto :end_switch
 :: If no args or args contain --bat or -h/--help: just execute.
 if NOT defined _sp_args (
     goto :default_case
-)
-
-if NOT "%_sp_args%"=="%_sp_args:--help=%" (
+)else if NOT "%_sp_args%"=="%_sp_args:--help=%" (
     goto :default_case
 ) else if NOT "%_sp_args%"=="%_sp_args: -h=%" (
     goto :default_case
@@ -198,11 +151,11 @@ if NOT "%_sp_args%"=="%_sp_args:--help=%" (
     goto :default_case
 ) else if NOT "%_sp_args%"=="%_sp_args:deactivate=%" (
     for /f "tokens=* USEBACKQ" %%I in (
-        `call python %spack% %_sp_flags% env deactivate --bat %_sp_args:deactivate=%`
+        `call python "%spack%" %_sp_flags% env deactivate --bat %_sp_args:deactivate=%`
     ) do %%I
 ) else if NOT "%_sp_args%"=="%_sp_args:activate=%" (
     for /f "tokens=* USEBACKQ" %%I in (
-        `python %spack% %_sp_flags% env activate --bat %_sp_args:activate=%`
+        `call python "%spack%" %_sp_flags% env activate --bat %_sp_args:activate=%`
     ) do %%I
 ) else (
     goto :default_case
@@ -223,7 +176,7 @@ if defined _sp_args (
 
 for /f "tokens=* USEBACKQ" %%I in (
     `python "%spack%" %_sp_flags% %_sp_subcommand% --bat %_sp_args%`) do %%I
-
+)
 goto :end_switch
 
 :case_unload
@@ -261,10 +214,10 @@ for %%Z in ("%_pa_new_path%") do if EXIST %%~sZ\NUL (
 exit /b 0
 
 :: set module system roots
-:_sp_multi_pathadd
+:_sp_multi_pathadd 
 for %%I in (%~2) do (
     for %%Z in (%_sp_compatible_sys_types%) do (
         :pathadd "%~1" "%%I\%%Z"
     )
 )
-exit /B %ERRORLEVEL%
+exit /B %ERRORLEVEL%

bin/spack_cmd.bat

@@ -52,6 +52,7 @@ if defined py_path (
 
 if defined py_exe (
     "%py_exe%" "%SPACK_ROOT%\bin\haspywin.py"
+    "%py_exe%" "%SPACK_ROOT%\bin\spack" external find python >NUL
 )
 
 set "EDITOR=notepad"

bin/spack_pwsh.ps1

@@ -1,4 +1,4 @@
-# Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+# Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)

etc/spack/defaults/bootstrap.yaml

@@ -9,15 +9,14 @@ bootstrap:
   # may not be able to bootstrap all the software that Spack needs,
   # depending on its type.
   sources:
-  - name: 'github-actions-v0.4'
-    metadata: $spack/share/spack/bootstrap/github-actions-v0.4
-  - name: 'github-actions-v0.3'
-    metadata: $spack/share/spack/bootstrap/github-actions-v0.3
+  - name: 'github-actions-v0.2'
+    metadata: $spack/share/spack/bootstrap/github-actions-v0.2
+  - name: 'github-actions-v0.1'
+    metadata: $spack/share/spack/bootstrap/github-actions-v0.1
   - name: 'spack-install'
     metadata: $spack/share/spack/bootstrap/spack-install
   trusted:
     # By default we trust bootstrapping from sources and from binaries
     # produced on Github via the workflow
-    github-actions-v0.4: true
-    github-actions-v0.3: true
+    github-actions-v0.2: true
     spack-install: true

etc/spack/defaults/concretizer.yaml

@@ -13,18 +13,16 @@ concretizer:
   # Whether to consider installed packages or packages from buildcaches when
   # concretizing specs. If `true`, we'll try to use as many installs/binaries
   # as possible, rather than building. If `false`, we'll always give you a fresh
-  # concretization. If `dependencies`, we'll only reuse dependencies but
-  # give you a fresh concretization for your root specs.
-  reuse: dependencies
+  # concretization.
+  reuse: true
   # Options that tune which targets are considered for concretization. The
   # concretization process is very sensitive to the number targets, and the time
   # needed to reach a solution increases noticeably with the number of targets
   # considered.
   targets:
-    # Determine whether we want to target specific or generic
-    # microarchitectures. Valid values are: "microarchitectures" or "generic".
-    # An example of "microarchitectures" would be "skylake" or "bulldozer",
-    # while an example of "generic" would be "aarch64" or "x86_64_v4".
+    # Determine whether we want to target specific or generic microarchitectures.
+    # An example of the first kind might be for instance "skylake" or "bulldozer",
+    # while generic microarchitectures are for instance "aarch64" or "x86_64_v4".
     granularity: microarchitectures
     # If "false" allow targets that are incompatible with the current host (for
     # instance concretize with target "icelake" while running on "haswell").
@@ -35,4 +33,4 @@ concretizer:
   # environments can always be activated. When "false" perform concretization separately
   # on each root spec, allowing different versions and variants of the same package in
   # an environment.
-  unify: true
+  unify: false

etc/spack/defaults/config.yaml

@@ -19,7 +19,7 @@ config:
   install_tree:
     root: $spack/opt/spack
     projections:
-      all: "{architecture}/{compiler.name}-{compiler.version}/{name}-{version}-{hash}"
+      all: "${ARCHITECTURE}/${COMPILERNAME}-${COMPILERVER}/${PACKAGE}-${VERSION}-${HASH}"
     # install_tree can include an optional padded length (int or boolean)
     # default is False (do not pad)
     # if padded_length is True, Spack will pad as close to the system max path
@@ -54,11 +54,6 @@ config:
   # are that it precludes its use as a system package and its ability to be
   # pip installable.
   #
-  # In Spack environment files, chaining onto existing system Spack
-  # installations, the $env variable can be used to download, cache and build
-  # into user-writable paths that are relative to the currently active
-  # environment.
-  #
   # In any case, if the username is not already in the path, Spack will append
   # the value of `$user` in an attempt to avoid potential conflicts between
   # users in shared temporary spaces.
@@ -81,10 +76,6 @@ config:
   source_cache: $spack/var/spack/cache
 
 
-  ## Directory where spack managed environments are created and stored
-  # environments_root: $spack/var/spack/environments
-
-
   # Cache directory for miscellaneous files, like the package index.
   # This can be purged with `spack clean --misc-cache`
   misc_cache: $user_cache_path/cache
@@ -185,7 +176,7 @@ config:
   # when Spack needs to manage its own package metadata and all operations are
   # expected to complete within the default time limit. The timeout should
   # therefore generally be left untouched.
-  db_lock_timeout: 60
+  db_lock_timeout: 3
 
 
   # How long to wait when attempting to modify a package (e.g. to install it).
@@ -196,20 +187,10 @@ config:
   package_lock_timeout: null
 
 
-  # Control how shared libraries are located at runtime on Linux. See the
-  # the Spack documentation for details.
-  shared_linking:
-    # Spack automatically embeds runtime search paths in ELF binaries for their
-    # dependencies. Their type can either be "rpath" or "runpath". For glibc, rpath is
-    # inherited and has precedence over LD_LIBRARY_PATH; runpath is not inherited
-    # and of lower precedence. DO NOT MIX these within the same install tree.
-    type: rpath
-
-
-    # (Experimental) Embed absolute paths of dependent libraries directly in ELF
-    # binaries to avoid runtime search. This can improve startup time of
-    # executables with many dependencies, in particular on slow filesystems.
-    bind: false
+  # Control whether Spack embeds RPATH or RUNPATH attributes in ELF binaries.
+  # Has no effect on macOS. DO NOT MIX these within the same install tree.
+  # See the Spack documentation for details.
+  shared_linking: 'rpath'
 
 
   # Set to 'false' to allow installation on filesystems that doesn't allow setgid bit
@@ -220,11 +201,3 @@ config:
   # building and installing packages. This gives information about Spack's
   # current progress as well as the current and total number of packages.
   terminal_title: false
-
-  # Number of seconds a buildcache's index.json is cached locally before probing
-  # for updates, within a single Spack invocation. Defaults to 10 minutes.
-  binary_index_ttl: 600
-
-  flags:
-    # Whether to keep -Werror flags active in package builds.
-    keep_werror: 'none'

etc/spack/defaults/cray/modules.yaml

@@ -13,4 +13,9 @@
 # Per-user settings (overrides default and site settings):
 #   ~/.spack/modules.yaml
 # -------------------------------------------------------------------------
-modules: {}
+modules:
+  prefix_inspections:
+    lib:
+      - LD_LIBRARY_PATH
+    lib64:
+      - LD_LIBRARY_PATH

etc/spack/defaults/darwin/modules.yaml

@@ -15,7 +15,7 @@
 # -------------------------------------------------------------------------
 modules:
   prefix_inspections:
-    ./lib:
+    lib:
       - DYLD_FALLBACK_LIBRARY_PATH
-    ./lib64:
+    lib64:
       - DYLD_FALLBACK_LIBRARY_PATH

etc/spack/defaults/darwin/packages.yaml

@@ -23,20 +23,8 @@ packages:
     providers:
       elf: [libelf]
       fuse: [macfuse]
-      gl: [apple-gl]
-      glu: [apple-glu]
       unwind: [apple-libunwind]
       uuid: [apple-libuuid]
-  apple-gl:
-    buildable: false
-    externals:
-    - spec: apple-gl@4.1.0
-      prefix: /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk
-  apple-glu:
-    buildable: false
-    externals:
-    - spec: apple-glu@1.3.0
-      prefix: /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk
   apple-libunwind:
     buildable: false
     externals:

etc/spack/defaults/linux/modules.yaml

@@ -13,4 +13,9 @@
 # Per-user settings (overrides default and site settings):
 #   ~/.spack/modules.yaml
 # -------------------------------------------------------------------------
-modules: {}
+modules:
+  prefix_inspections:
+    lib:
+      - LD_LIBRARY_PATH
+    lib64:
+      - LD_LIBRARY_PATH

etc/spack/defaults/modules.yaml

@@ -14,24 +14,23 @@
 #   ~/.spack/modules.yaml
 # -------------------------------------------------------------------------
 modules:
-  # This maps paths in the package install prefix to environment variables
-  # they should be added to. For example, <prefix>/bin should be in PATH.
+  # Paths to check when creating modules for all module sets
   prefix_inspections:
-    ./bin:
+    bin:
       - PATH
-    ./man:
+    man:
       - MANPATH
-    ./share/man:
+    share/man:
       - MANPATH
-    ./share/aclocal:
+    share/aclocal:
       - ACLOCAL_PATH
-    ./lib/pkgconfig:
+    lib/pkgconfig:
       - PKG_CONFIG_PATH
-    ./lib64/pkgconfig:
+    lib64/pkgconfig:
       - PKG_CONFIG_PATH
-    ./share/pkgconfig:
+    share/pkgconfig:
       - PKG_CONFIG_PATH
-    ./:
+    '':
       - CMAKE_PREFIX_PATH
 
   # These are configurations for the module set named "default"
@@ -40,12 +39,13 @@ modules:
     roots:
      tcl:    $spack/share/spack/modules
      lmod:   $spack/share/spack/lmod
-    # What type of modules to use ("tcl" and/or "lmod")
-    enable: []
+    # What type of modules to use
+    enable:
+      - tcl
 
     tcl:
       all:
-        autoload: direct
+        autoload: none
 
     # Default configurations if lmod is enabled
     lmod:

etc/spack/defaults/packages.yaml

@@ -20,32 +20,31 @@ packages:
       awk: [gawk]
       blas: [openblas, amdblis]
       D: [ldc]
-      daal: [intel-oneapi-daal]
+      daal: [intel-daal]
       elf: [elfutils]
       fftw-api: [fftw, amdfftw]
       flame: [libflame, amdlibflame]
       fuse: [libfuse]
-      gl: [glx, osmesa]
+      gl: [mesa+opengl, mesa18, opengl]
       glu: [mesa-glu, openglu]
-      golang: [go, gcc]
-      go-or-gccgo-bootstrap: [go-bootstrap, gcc]
+      glx: [mesa+glx, mesa18+glx, opengl]
+      golang: [gcc]
       iconv: [libiconv]
-      ipp: [intel-oneapi-ipp]
+      ipp: [intel-ipp]
       java: [openjdk, jdk, ibm-java]
       jpeg: [libjpeg-turbo, libjpeg]
       lapack: [openblas, amdlibflame]
-      libglx: [mesa+glx, mesa18+glx]
-      libllvm: [llvm]
-      libosmesa: [mesa+osmesa, mesa18+osmesa]
+      libllvm: [llvm, llvm-amdgpu]
       lua-lang: [lua, lua-luajit-openresty, lua-luajit]
       luajit: [lua-luajit-openresty, lua-luajit]
       mariadb-client: [mariadb-c-client, mariadb]
-      mkl: [intel-oneapi-mkl]
+      mkl: [intel-mkl]
       mpe: [mpe2]
       mpi: [openmpi, mpich]
       mysql-client: [mysql, mariadb-c-client]
       opencl: [pocl]
       onedal: [intel-oneapi-dal]
+      osmesa: [mesa+osmesa, mesa18+osmesa]
       pbs: [openpbs, torque]
       pil: [py-pillow]
       pkgconfig: [pkgconf, pkg-config]

etc/spack/defaults/windows/config.yaml

@@ -1,6 +1,5 @@
 config:
   locks: false
-  concretizer: clingo
+  concretizer: original
   build_stage::
     - '$spack/.staging'
-  stage_name: '{name}-{version}-{hash:7}'

etc/spack/defaults/windows/packages.yaml

@@ -1,22 +0,0 @@
-# -------------------------------------------------------------------------
-# This file controls default concretization preferences for Spack.
-#
-# Settings here are versioned with Spack and are intended to provide
-# sensible defaults out of the box. Spack maintainers should edit this
-# file to keep it current.
-#
-# Users can override these settings by editing the following files.
-#
-# Per-spack-instance settings (overrides defaults):
-#   $SPACK_ROOT/etc/spack/packages.yaml
-#
-# Per-user settings (overrides default and site settings):
-#   ~/.spack/packages.yaml
-# -------------------------------------------------------------------------
-packages:
-  all:
-    compiler:
-    - msvc
-    providers:
-      mpi: [msmpi]
-      gl: [wgl]

lib/spack/docs/.gitignore

@@ -5,4 +5,3 @@ llnl*.rst
 _build
 .spack-env
 spack.lock
-_spack_root

lib/spack/docs/_pygments/style.py

@@ -1,16 +0,0 @@
-# Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
-# Spack Project Developers. See the top-level COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-# The name of the Pygments (syntax highlighting) style to use.
-# We use our own extension of the default style with a few modifications
-from pygments.styles.default import DefaultStyle
-from pygments.token import Generic
-
-
-class SpackStyle(DefaultStyle):
-    styles = DefaultStyle.styles.copy()
-    background_color = "#f4f4f8"
-    styles[Generic.Output] = "#355"
-    styles[Generic.Prompt] = "bold #346ec9"

lib/spack/docs/_spack_root

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

lib/spack/docs/analyze.rst

@@ -0,0 +1,162 @@
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
+   Spack Project Developers. See the top-level COPYRIGHT file for details.
+
+   SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+.. _analyze:
+
+=======
+Analyze
+=======
+
+
+The analyze command is a front-end to various tools that let us analyze
+package installations. Each analyzer is a module for a different kind
+of analysis that can be done on a package installation, including (but not
+limited to) binary, log, or text analysis. Thus, the analyze command group
+allows you to take an existing package install, choose an analyzer,
+and extract some output for the package using it.
+
+
+-----------------
+Analyzer Metadata
+-----------------
+
+For all analyzers, we write to an ``analyzers`` folder in ``~/.spack``, or the
+value that you specify in your spack config at ``config:analyzers_dir``. 
+For example, here we see the results of running an analysis on zlib:
+
+.. code-block:: console
+
+    $ tree ~/.spack/analyzers/
+    └── linux-ubuntu20.04-skylake
+        └── gcc-9.3.0
+            └── zlib-1.2.11-sl7m27mzkbejtkrajigj3a3m37ygv4u2
+                ├── environment_variables
+                │   └── spack-analyzer-environment-variables.json
+                ├── install_files
+                │   └── spack-analyzer-install-files.json
+                └── libabigail
+                    └── spack-analyzer-libabigail-libz.so.1.2.11.xml
+    
+
+This means that you can always find analyzer output in this folder, and it
+is organized with the same logic as the package install it was run for. 
+If you want to customize this top level folder, simply provide the ``--path``
+argument to ``spack analyze run``. The nested organization will be maintained
+within your custom root.
+
+-----------------
+Listing Analyzers
+-----------------
+
+If you aren't familiar with Spack's analyzers, you can quickly list those that 
+are available:
+
+.. code-block:: console
+
+    $ spack analyze list-analyzers
+    install_files            : install file listing read from install_manifest.json
+    environment_variables    : environment variables parsed from spack-build-env.txt
+    config_args              : config args loaded from spack-configure-args.txt
+    libabigail               : Application Binary Interface (ABI) features for objects
+
+
+In the above, the first three are fairly simple - parsing metadata files from
+a package install directory to save
+
+-------------------
+Analyzing a Package
+-------------------
+
+The analyze command, akin to install, will accept a package spec to perform
+an analysis for. The package must be installed. Let's walk through an example
+with zlib. We first ask to analyze it. However, since we have more than one
+install, we are asked to disambiguate:
+
+.. code-block:: console
+
+    $ spack analyze run zlib
+    ==> Error: zlib matches multiple packages.
+      Matching packages:
+        fz2bs56 zlib@1.2.11%gcc@7.5.0 arch=linux-ubuntu18.04-skylake
+        sl7m27m zlib@1.2.11%gcc@9.3.0 arch=linux-ubuntu20.04-skylake
+      Use a more specific spec.
+
+
+We can then specify the spec version that we want to analyze:
+
+.. code-block:: console
+
+    $ spack analyze run zlib/fz2bs56
+
+If you don't provide any specific analyzer names, by default all analyzers 
+(shown in the ``list-analyzers`` subcommand list) will be run. If an analyzer does not
+have any result, it will be skipped. For example, here is a result running for
+zlib:
+
+.. code-block:: console
+
+    $ ls ~/.spack/analyzers/linux-ubuntu20.04-skylake/gcc-9.3.0/zlib-1.2.11-sl7m27mzkbejtkrajigj3a3m37ygv4u2/
+    spack-analyzer-environment-variables.json
+    spack-analyzer-install-files.json
+    spack-analyzer-libabigail-libz.so.1.2.11.xml
+
+If you want to run a specific analyzer, ask for it with `--analyzer`. Here we run
+spack analyze on libabigail (already installed) _using_ libabigail1
+
+.. code-block:: console
+
+    $ spack analyze run --analyzer abigail libabigail
+
+
+.. _analyze_monitoring:
+
+----------------------
+Monitoring An Analysis
+----------------------
+
+For any kind of analysis, you can
+use a `spack monitor <https://github.com/spack/spack-monitor>`_ "Spackmon"
+as a server to upload the same run metadata to. You can
+follow the instructions in the `spack monitor documentation <https://spack-monitor.readthedocs.org>`_
+to first create a server along with a username and token for yourself.
+You can then use this guide to interact with the server.
+
+You should first export our spack monitor token and username to the environment:
+
+.. code-block:: console
+ 
+    $ export SPACKMON_TOKEN=50445263afd8f67e59bd79bff597836ee6c05438
+    $ export SPACKMON_USER=spacky
+
+
+By default, the host for your server is expected to be at ``http://127.0.0.1``
+with a prefix of ``ms1``, and if this is the case, you can simply add the
+``--monitor`` flag to the install command:
+
+.. code-block:: console
+
+    $ spack analyze run --monitor wget
+
+If you need to customize the host or the prefix, you can do that as well:
+
+.. code-block:: console
+
+    $ spack analyze run --monitor --monitor-prefix monitor --monitor-host https://monitor-service.io wget
+
+If your server doesn't have authentication, you can skip it:
+
+.. code-block:: console
+
+    $ spack analyze run --monitor --monitor-disable-auth wget
+    
+Regardless of your choice, when you run analyze on an installed package (whether
+it was installed with ``--monitor`` or not, you'll see the results generating as they did
+before, and a message that the monitor server was pinged:
+
+.. code-block:: console
+
+    $ spack analyze --monitor wget
+    ...
+    ==> Sending result for wget bin/wget to monitor.

lib/spack/docs/basic_usage.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -85,7 +85,7 @@ All packages whose names or descriptions contain documentation:
 To get more information on a particular package from `spack list`, use
 `spack info`.  Just supply the name of a package:
 
-.. command-output:: spack info --all mpich
+.. command-output:: spack info mpich
 
 Most of the information is self-explanatory.  The *safe versions* are
 versions that Spack knows the checksum for, and it will use the
@@ -896,8 +896,8 @@ your path:
    $ which mpicc
    ~/spack/opt/linux-debian7-x86_64/gcc@4.4.7/mpich@3.0.4/bin/mpicc
 
-These commands will add appropriate directories to your ``PATH``
-and ``MANPATH`` according to the
+These commands will add appropriate directories to your ``PATH``,
+``MANPATH``, ``CPATH``, and ``LD_LIBRARY_PATH`` according to the
 :ref:`prefix inspections <customize-env-modifications>` defined in your
 modules configuration.
 When you no longer want to use a package, you can type unload or
@@ -942,7 +942,7 @@ first ``libelf`` above, you would run:
 
    $ spack load /qmm4kso
 
-To see which packages that you have loaded to your environment you would
+To see which packages that you have loaded to your enviornment you would
 use ``spack find --loaded``.
 
 .. code-block:: console
@@ -998,15 +998,11 @@ More formally, a spec consists of the following pieces:
 * ``%`` Optional compiler specifier, with an optional compiler version
   (``gcc`` or ``gcc@4.7.3``)
 * ``+`` or ``-`` or ``~`` Optional variant specifiers (``+debug``,
-  ``-qt``, or ``~qt``) for boolean variants. Use ``++`` or ``--`` or
-  ``~~`` to propagate variants through the dependencies (``++debug``,
-  ``--qt``, or ``~~qt``).
+  ``-qt``, or ``~qt``) for boolean variants
 * ``name=<value>`` Optional variant specifiers that are not restricted to
-  boolean variants. Use ``name==<value>`` to propagate variant through the
-  dependencies.
+  boolean variants
 * ``name=<value>`` Optional compiler flag specifiers. Valid flag names are
   ``cflags``, ``cxxflags``, ``fflags``, ``cppflags``, ``ldflags``, and ``ldlibs``.
-  Use ``name==<value>`` to propagate compiler flags through the dependencies.
 * ``target=<value> os=<value>`` Optional architecture specifier
   (``target=haswell os=CNL10``)
 * ``^`` Dependency specs (``^callpath@1.1``)
@@ -1097,73 +1093,26 @@ could depend on ``mpich@1.2:`` if it can only build with version
 
 Below are more details about the specifiers that you can add to specs.
 
-.. _version-specifier:
-
 ^^^^^^^^^^^^^^^^^
 Version specifier
 ^^^^^^^^^^^^^^^^^
 
-A version specifier ``pkg@<specifier>`` comes after a package name
-and starts with ``@``. It can be something abstract that matches
-multiple known versions, or a specific version. During concretization,
-Spack will pick the optimal version within the spec's constraints
-according to policies set for the particular Spack installation.
+A version specifier comes somewhere after a package name and starts
+with ``@``.  It can be a single version, e.g. ``@1.0``, ``@3``, or
+``@1.2a7``.  Or, it can be a range of versions, such as ``@1.0:1.5``
+(all versions between ``1.0`` and ``1.5``, inclusive).  Version ranges
+can be open, e.g. ``:3`` means any version up to and including ``3``.
+This would include ``3.4`` and ``3.4.2``.  ``4.2:`` means any version
+above and including ``4.2``.  Finally, a version specifier can be a
+set of arbitrary versions, such as ``@1.0,1.5,1.7`` (``1.0``, ``1.5``,
+or ``1.7``).  When you supply such a specifier to ``spack install``,
+it constrains the set of versions that Spack will install.
 
-The version specifier can be *a specific version*, such as ``@=1.0.0`` or
-``@=1.2a7``. Or, it can be *a range of versions*, such as ``@1.0:1.5``.
-Version ranges are inclusive, so this example includes both ``1.0``
-and any ``1.5.x`` version. Version ranges can be unbounded, e.g. ``@:3``
-means any version up to and including ``3``. This would include ``3.4``
-and ``3.4.2``.  Similarly, ``@4.2:`` means any version above and including
-``4.2``.  As a short-hand, ``@3`` is equivalent to the range ``@3:3`` and
-includes any version with major version ``3``.
-
-Notice that you can distinguish between the specific version ``@=3.2`` and
-the range ``@3.2``. This is useful for packages that follow a versioning
-scheme that omits the zero patch version number: ``3.2``, ``3.2.1``,
-``3.2.2``, etc. In general it is preferable to use the range syntax
-``@3.2``, since ranges also match versions with one-off suffixes, such as
-``3.2-custom``.
-
-A version specifier can also be a list of ranges and specific versions,
-separated by commas.  For example, ``@1.0:1.5,=1.7.1`` matches any version
-in the range ``1.0:1.5`` and the specific version ``1.7.1``.
-
-For packages with a ``git`` attribute, ``git`` references
-may be specified instead of a numerical version i.e. branches, tags
-and commits. Spack will stage and build based off the ``git``
-reference provided.  Acceptable syntaxes for this are:
-
-.. code-block:: sh
-
-    # commit hashes
-   foo@abcdef1234abcdef1234abcdef1234abcdef1234    # 40 character hashes are automatically treated as git commits
-   foo@git.abcdef1234abcdef1234abcdef1234abcdef1234
-
-    # branches and tags
-   foo@git.develop # use the develop branch
-   foo@git.0.19 # use the 0.19 tag
-
-Spack always needs to associate a Spack version with the git reference,
-which is used for version comparison. This Spack version is heuristically
-taken from the closest valid git tag among ancestors of the git ref.
-
-Once a Spack version is associated with a git ref, it always printed with
-the git ref.  For example, if the commit ``@git.abcdefg`` is tagged
-``0.19``, then the spec will be shown as ``@git.abcdefg=0.19``.
-
-If the git ref is not exactly a tag, then the distance to the nearest tag
-is also part of the resolved version. ``@git.abcdefg=0.19.git.8`` means
-that the commit is 8 commits away from the ``0.19`` tag.
-
-In cases where Spack cannot resolve a sensible version from a git ref,
-users can specify the Spack version to use for the git ref. This is done
-by appending ``=`` and the Spack version to the git ref. For example:
-
-.. code-block:: sh
-
-   foo@git.my_ref=3.2 # use the my_ref tag or branch, but treat it as version 3.2 for version comparisons
-   foo@git.abcdef1234abcdef1234abcdef1234abcdef1234=develop # use the given commit, but treat it as develop for version comparisons
+If the version spec is not provided, then Spack will choose one
+according to policies set for the particular spack installation.  If
+the spec is ambiguous, i.e. it could match multiple versions, Spack
+will choose a version within the spec's constraints according to
+policies set for the particular Spack installation.
 
 Details about how versions are compared and how Spack determines if
 one version is less than another are discussed in the developer guide.
@@ -1244,23 +1193,6 @@ variants using the backwards compatibility syntax and uses only ``~``
 for disabled boolean variants.  The ``-`` and spaces on the command
 line are provided for convenience and legibility.
 
-Spack allows variants to propagate their value to the package's
-dependency by using ``++``, ``--``, and ``~~`` for boolean variants.
-For example, for a ``debug`` variant:
-
-.. code-block:: sh
-
-    mpileaks ++debug   # enabled debug will be propagated to dependencies
-    mpileaks +debug    # only mpileaks will have debug enabled
-
-To propagate the value of non-boolean variants Spack uses ``name==value``.
-For example, for the ``stackstart`` variant:
-
-.. code-block:: sh
-
-    mpileaks stackstart==4   # variant will be propagated to dependencies
-    mpileaks stackstart=4    # only mpileaks will have this variant value
-
 ^^^^^^^^^^^^^^
 Compiler Flags
 ^^^^^^^^^^^^^^
@@ -1268,15 +1200,10 @@ Compiler Flags
 Compiler flags are specified using the same syntax as non-boolean variants,
 but fulfill a different purpose. While the function of a variant is set by
 the package, compiler flags are used by the compiler wrappers to inject
-flags into the compile line of the build. Additionally, compiler flags can
-be inherited by dependencies by using ``==``.
-``spack install libdwarf cppflags=="-g"`` will install both libdwarf and
-libelf with the ``-g`` flag injected into their compile line.
-
-.. note::
-
-   versions of spack prior to 0.19.0 will propagate compiler flags using
-   the ``=`` syntax.
+flags into the compile line of the build. Additionally, compiler flags are
+inherited by dependencies. ``spack install libdwarf cppflags="-g"`` will
+install both libdwarf and libelf with the ``-g`` flag injected into their
+compile line.
 
 Notice that the value of the compiler flags must be quoted if it
 contains any spaces. Any of ``cppflags=-O3``, ``cppflags="-O3"``,
@@ -1478,7 +1405,7 @@ built.
 You can see what virtual packages a particular package provides by
 getting info on it:
 
-.. command-output:: spack info --virtuals mpich
+.. command-output:: spack info mpich
 
 Spack is unique in that its virtual packages can be versioned, just
 like regular packages.  A particular version of a package may provide
@@ -1686,13 +1613,9 @@ own install prefix.  However, certain packages are typically installed
 `Python <https://www.python.org>`_ packages are typically installed in the
 ``$prefix/lib/python-2.7/site-packages`` directory.
 
-In Spack, installation prefixes are immutable, so this type of installation
-is not directly supported. However, it is possible to create views that
-allow you to merge install prefixes of multiple packages into a single new prefix.
-Views are a convenient way to get a more traditional filesystem structure.
-Using *extensions*, you can ensure that Python packages always share the
-same prefix in the view as Python itself. Suppose you have
-Python installed like so:
+Spack has support for this type of installation as well.  In Spack,
+a package that can live inside the prefix of another package is called
+an *extension*.  Suppose you have Python installed like so:
 
 .. code-block:: console
 
@@ -1730,6 +1653,8 @@ You can find extensions for your Python installation like this:
    py-ipython@2.3.1     py-pygments@2.0.1   py-setuptools@11.3.1
    py-matplotlib@1.4.2  py-pyparsing@2.0.3  py-six@1.9.0
 
+   ==> None activated.
+
 The extensions are a subset of what's returned by ``spack list``, and
 they are packages like any other.  They are installed into their own
 prefixes, and you can see this with ``spack find --paths``:
@@ -1757,72 +1682,32 @@ directly when you run ``python``:
    ImportError: No module named numpy
    >>>
 
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Using Extensions in Environments
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+^^^^^^^^^^^^^^^^
+Using Extensions
+^^^^^^^^^^^^^^^^
 
-The recommended way of working with extensions such as ``py-numpy``
-above is through :ref:`Environments <environments>`. For example,
-the following creates an environment in the current working directory
-with a filesystem view in the ``./view`` directory:
-
-.. code-block:: console
-
-   $ spack env create --with-view view --dir .
-   $ spack -e . add py-numpy
-   $ spack -e . concretize
-   $ spack -e . install
-
-We recommend environments for two reasons. Firstly, environments
-can be activated (requires :ref:`shell-support`):
-
-.. code-block:: console
-
-   $ spack env activate .
-
-which sets all the right environment variables such as ``PATH`` and
-``PYTHONPATH``. This ensures that
-
-.. code-block:: console
-
-   $ python
-   >>> import numpy
-
-works. Secondly, even without shell support, the view ensures
-that Python can locate its extensions:
-
-.. code-block:: console
-
-   $ ./view/bin/python
-   >>> import numpy
-
-See :ref:`environments` for a more in-depth description of Spack
-environments and customizations to views.
-
-^^^^^^^^^^^^^^^^^^^^
-Using ``spack load``
-^^^^^^^^^^^^^^^^^^^^
-
-A more traditional way of using Spack and extensions is ``spack load``
-(requires :ref:`shell-support`). This will add the extension to ``PYTHONPATH``
-in your current shell, and Python itself will be available in the ``PATH``:
+There are four ways to get ``numpy`` working in Python.  The first is
+to use :ref:`shell-support`.  You can simply ``load`` the extension,
+and it will be added to the ``PYTHONPATH`` in your current shell:
 
 .. code-block:: console
 
+   $ spack load python
    $ spack load py-numpy
-   $ python
-   >>> import numpy
 
+Now ``import numpy`` will succeed for as long as you keep your current
+session open.
 The loaded packages can be checked using ``spack find --loaded``
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 Loading Extensions via Modules
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Apart from ``spack env activate`` and ``spack load``, you can load numpy
-through your environment modules (using ``environment-modules`` or
-``lmod``). This will also add the extension to the ``PYTHONPATH`` in
-your current shell.
+Instead of using Spack's environment modification capabilities through
+the ``spack load`` command, you can load numpy through your
+environment modules (using ``environment-modules`` or ``lmod``). This
+will also add the extension to the ``PYTHONPATH`` in your current
+shell.
 
 .. code-block:: console
 
@@ -1832,6 +1717,130 @@ If you do not know the name of the specific numpy module you wish to
 load, you can use the ``spack module tcl|lmod loads`` command to get
 the name of the module from the Spack spec.
 
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Activating Extensions in a View
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Another way to use extensions is to create a view, which merges the
+python installation along with the extensions into a single prefix.
+See :ref:`configuring_environment_views` for a more in-depth description
+of views.
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Activating Extensions Globally
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+As an alternative to creating a merged prefix with Python and its extensions,
+and prior to support for views, Spack has provided a means to install the
+extension into the Spack installation prefix for the extendee. This has
+typically been useful since extendable packages typically search their own
+installation path for addons by default.
+
+Global activations are performed with the ``spack activate`` command:
+
+.. _cmd-spack-activate:
+
+^^^^^^^^^^^^^^^^^^
+``spack activate``
+^^^^^^^^^^^^^^^^^^
+
+.. code-block:: console
+
+   $ spack activate py-numpy
+   ==> Activated extension py-setuptools@11.3.1%gcc@4.4.7 arch=linux-debian7-x86_64-3c74eb69 for python@2.7.8%gcc@4.4.7.
+   ==> Activated extension py-nose@1.3.4%gcc@4.4.7 arch=linux-debian7-x86_64-5f70f816 for python@2.7.8%gcc@4.4.7.
+   ==> Activated extension py-numpy@1.9.1%gcc@4.4.7 arch=linux-debian7-x86_64-66733244 for python@2.7.8%gcc@4.4.7.
+
+Several things have happened here.  The user requested that
+``py-numpy`` be activated in the ``python`` installation it was built
+with.  Spack knows that ``py-numpy`` depends on ``py-nose`` and
+``py-setuptools``, so it activated those packages first.  Finally,
+once all dependencies were activated in the ``python`` installation,
+``py-numpy`` was activated as well.
+
+If we run ``spack extensions`` again, we now see the three new
+packages listed as activated:
+
+.. code-block:: console
+
+   $ spack extensions python
+   ==> python@2.7.8%gcc@4.4.7  arch=linux-debian7-x86_64-703c7a96
+   ==> 36 extensions:
+   geos          py-ipython     py-pexpect    py-pyside            py-sip
+   py-basemap    py-libxml2     py-pil        py-pytz              py-six
+   py-biopython  py-mako        py-pmw        py-rpy2              py-sympy
+   py-cython     py-matplotlib  py-pychecker  py-scientificpython  py-virtualenv
+   py-dateutil   py-mpi4py      py-pygments   py-scikit-learn
+   py-epydoc     py-mx          py-pylint     py-scipy
+   py-gnuplot    py-nose        py-pyparsing  py-setuptools
+   py-h5py       py-numpy       py-pyqt       py-shiboken
+
+   ==> 12 installed:
+   -- linux-debian7-x86_64 / gcc@4.4.7 --------------------------------
+   py-dateutil@2.4.0    py-nose@1.3.4       py-pyside@1.2.2
+   py-dateutil@2.4.0    py-numpy@1.9.1      py-pytz@2014.10
+   py-ipython@2.3.1     py-pygments@2.0.1   py-setuptools@11.3.1
+   py-matplotlib@1.4.2  py-pyparsing@2.0.3  py-six@1.9.0
+
+   ==> 3 currently activated:
+   -- linux-debian7-x86_64 / gcc@4.4.7 --------------------------------
+   py-nose@1.3.4  py-numpy@1.9.1  py-setuptools@11.3.1
+
+Now, when a user runs python, ``numpy`` will be available for import
+*without* the user having to explicitly load it.  ``python@2.7.8`` now
+acts like a system Python installation with ``numpy`` installed inside
+of it.
+
+Spack accomplishes this by symbolically linking the *entire* prefix of
+the ``py-numpy`` package into the prefix of the ``python`` package.  To the
+python interpreter, it looks like ``numpy`` is installed in the
+``site-packages`` directory.
+
+The only limitation of global activation is that you can only have a *single*
+version of an extension activated at a time.  This is because multiple
+versions of the same extension would conflict if symbolically linked
+into the same prefix.  Users who want a different version of a package
+can still get it by using environment modules or views, but they will have to
+explicitly load their preferred version.
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+``spack activate --force``
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+If, for some reason, you want to activate a package *without* its
+dependencies, you can use ``spack activate --force``:
+
+.. code-block:: console
+
+   $ spack activate --force py-numpy
+   ==> Activated extension py-numpy@1.9.1%gcc@4.4.7 arch=linux-debian7-x86_64-66733244 for python@2.7.8%gcc@4.4.7.
+
+.. _cmd-spack-deactivate:
+
+^^^^^^^^^^^^^^^^^^^^
+``spack deactivate``
+^^^^^^^^^^^^^^^^^^^^
+
+We've seen how activating an extension can be used to set up a default
+version of a Python module.  Obviously, you may want to change that at
+some point.  ``spack deactivate`` is the command for this.  There are
+several variants:
+
+* ``spack deactivate <extension>`` will deactivate a single
+  extension.  If another activated extension depends on this one,
+  Spack will warn you and exit with an error.
+* ``spack deactivate --force <extension>`` deactivates an extension
+  regardless of packages that depend on it.
+* ``spack deactivate --all <extension>`` deactivates an extension and
+  all of its dependencies.  Use ``--force`` to disregard dependents.
+* ``spack deactivate --all <extendee>`` deactivates *all* activated
+  extensions of a package.  For example, to deactivate *all* python
+  extensions, use:
+
+  .. code-block:: console
+
+     $ spack deactivate --all python
+
 -----------------------
 Filesystem requirements
 -----------------------

lib/spack/docs/binary_caches.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -13,51 +13,49 @@ Some sites may encourage users to set up their own test environments
 before carrying out central installations, or some users may prefer to set
 up these environments on their own motivation. To reduce the load of
 recompiling otherwise identical package specs in different installations,
-installed packages can be put into build cache tarballs, pushed to
+installed packages can be put into build cache tarballs, uploaded to
 your Spack mirror and then downloaded and installed by others.
 
-Whenever a mirror provides prebuilt packages, Spack will take these packages
-into account during concretization and installation, making ``spack install``
-significantly faster.
 
+--------------------------
+Creating build cache files
+--------------------------
 
-.. note::
-
-    We use the terms "build cache" and "mirror" often interchangeably. Mirrors
-    are used during installation both for sources and prebuilt packages. Build
-    caches refer to mirrors that provide prebuilt packages.
-
-
-----------------------
-Creating a build cache
-----------------------
+A compressed tarball of an installed package is created. Tarballs are created
+for all of its link and run dependency packages as well. Compressed tarballs are
+signed with gpg and signature and tarball and put in a ``.spack`` file. Optionally,
+the rpaths (and ids and deps on macOS) can be changed to paths relative to
+the Spack install tree before the tarball is created.
 
 Build caches are created via:
 
 .. code-block:: console
 
-    $ spack buildcache push <path/url/mirror name> <spec>
+    $ spack buildcache create <spec>
 
-This command takes the locally installed spec and its dependencies, and
-creates tarballs of their install prefixes. It also generates metadata files,
-signed with GPG. These tarballs and metadata files are then pushed to the
-provided binary cache, which can be a local directory or a remote URL.
 
-Here is an example where a build cache is created in a local directory named
-"spack-cache", to which we push the "ninja" spec:
+If you wanted to create a build cache in a local directory, you would provide
+the ``-d`` argument to target that directory, again also specifying the spec.
+Here is an example creating a local directory, "spack-cache" and creating
+build cache files for the "ninja" spec:
 
 .. code-block:: console
 
-    $ spack buildcache push --allow-root ./spack-cache ninja
-    ==> Pushing binary packages to file:///home/spackuser/spack/spack-cache/build_cache
+    $ mkdir -p ./spack-cache
+    $ spack buildcache create -d ./spack-cache ninja
+    ==> Buildcache files will be output to file:///home/spackuser/spack/spack-cache/build_cache
+    gpgconf: socketdir is '/run/user/1000/gnupg'
+    gpg: using "E6DF6A8BD43208E4D6F392F23777740B7DBD643D" as default secret key for signing
 
-Not that ``ninja`` must be installed locally for this to work.
+Note that the targeted spec must already be installed. Once you have a build cache,
+you can add it as a mirror, discussed next.
 
-We're using the ``--allow-root`` flag to tell Spack that is OK when any of
-the binaries we're pushing contain references to the local Spack install
-directory.
+.. warning::
 
-Once you have a build cache, you can add it as a mirror, discussed next.
+   Spack improved the format used for binary caches in v0.18. The entire v0.18 series
+   will be able to verify and install binary caches both in the new and in the old format.
+   Support for using the old format is expected to end in v0.19, so we advise users to
+   recreate relevant buildcaches using Spack v0.18 or higher.
 
 ---------------------------------------
 Finding or installing build cache files
@@ -68,10 +66,10 @@ with:
 
 .. code-block:: console
 
-    $ spack mirror add <name> <url or path>
+    $ spack mirror add <name> <url>
 
 
-Both web URLs and local paths on the filesystem can be specified. In the previous
+Note that the url can be a web url _or_ a local filesystem location. In the previous
 example, you might add the directory "spack-cache" and call it ``mymirror``:
 
 
@@ -96,7 +94,7 @@ this new build cache as follows:
 
 .. code-block:: console
 
-    $ spack buildcache update-index ./spack-cache
+    $ spack buildcache update-index -d spack-cache/
 
 Now you can use list:
 
@@ -107,38 +105,46 @@ Now you can use list:
     -- linux-ubuntu20.04-skylake / gcc@9.3.0 ------------------------
     ninja@1.10.2
 
-With ``mymirror`` configured and an index available, Spack will automatically
-use it during concretization and installation. That means that you can expect
-``spack install ninja`` to fetch prebuilt packages from the mirror. Let's
-verify by re-installing ninja:
+
+Great! So now let's say you have a different spack installation, or perhaps just
+a different environment for the same one, and you want to install a package from
+that build cache. Let's first uninstall the actual library "ninja" to see if we can
+re-install it from the cache.
 
 .. code-block:: console
 
     $ spack uninstall ninja
-    $ spack install ninja
-    ==> Installing ninja-1.11.1-yxferyhmrjkosgta5ei6b4lqf6bxbscz
-    ==> Fetching file:///home/spackuser/spack/spack-cache/build_cache/linux-ubuntu20.04-skylake-gcc-9.3.0-ninja-1.10.2-yxferyhmrjkosgta5ei6b4lqf6bxbscz.spec.json.sig
-    gpg: Signature made Do 12 Jan 2023 16:01:04 CET
-    gpg:                using RSA key 61B82B2B2350E171BD17A1744E3A689061D57BF6
-    gpg: Good signature from "example (GPG created for Spack) <example@example.com>" [ultimate]
-    ==> Fetching file:///home/spackuser/spack/spack-cache/build_cache/linux-ubuntu20.04-skylake/gcc-9.3.0/ninja-1.10.2/linux-ubuntu20.04-skylake-gcc-9.3.0-ninja-1.10.2-yxferyhmrjkosgta5ei6b4lqf6bxbscz.spack
-    ==> Extracting ninja-1.10.2-yxferyhmrjkosgta5ei6b4lqf6bxbscz from binary cache
-    ==> ninja: Successfully installed ninja-1.11.1-yxferyhmrjkosgta5ei6b4lqf6bxbscz
-    Search: 0.00s.  Fetch: 0.17s.  Install: 0.12s.  Total: 0.29s
-    [+] /home/harmen/spack/opt/spack/linux-ubuntu20.04-skylake/gcc-9.3.0/ninja-1.11.1-yxferyhmrjkosgta5ei6b4lqf6bxbscz
 
 
-It worked! You've just completed a full example of creating a build cache with
-a spec of interest, adding it as a mirror, updating its index, listing the contents,
-and finally, installing from it.
-
-By default Spack falls back to building from sources when the mirror is not available
-or when the package is simply not already available. To force Spack to only install
-prebuilt packages, you can use
+And now reinstall from the buildcache
 
 .. code-block:: console
 
-   $ spack install --use-buildcache only <package>
+    $ spack buildcache install ninja
+    ==> buildcache spec(s) matching ninja 
+    ==> Fetching file:///home/spackuser/spack/spack-cache/build_cache/linux-ubuntu20.04-skylake/gcc-9.3.0/ninja-1.10.2/linux-ubuntu20.04-skylake-gcc-9.3.0-ninja-1.10.2-i4e5luour7jxdpc3bkiykd4imke3mkym.spack
+    ####################################################################################################################################### 100.0%
+    ==> Installing buildcache for spec ninja@1.10.2%gcc@9.3.0 arch=linux-ubuntu20.04-skylake
+    gpgconf: socketdir is '/run/user/1000/gnupg'
+    gpg: Signature made Tue 23 Mar 2021 10:16:29 PM MDT
+    gpg:                using RSA key E6DF6A8BD43208E4D6F392F23777740B7DBD643D
+    gpg: Good signature from "spackuser (GPG created for Spack) <spackuser@noreply.users.github.com>" [ultimate]
+
+
+It worked! You've just completed a full example of creating a build cache with
+a spec of interest, adding it as a mirror, updating it's index, listing the contents,
+and finally, installing from it.
+
+
+Note that the above command is intended to install a particular package to a
+build cache you have created, and not to install a package from a build cache.
+For the latter, once a mirror is added, by default when you do ``spack install`` the ``--use-cache``
+flag is set, and you will install a package from a build cache if it is available.
+If you want to always use the cache, you can do:
+
+.. code-block:: console
+
+   $ spack install --cache-only <package>
 
 For example, to combine all of the commands above to add the E4S build cache
 and then install from it exclusively, you would do:
@@ -147,7 +153,7 @@ and then install from it exclusively, you would do:
 
     $ spack mirror add E4S https://cache.e4s.io
     $ spack buildcache keys --install --trust
-    $ spack install --use-buildache only <package>
+    $ spack install --cache-only <package>
 
 We use ``--install`` and ``--trust`` to say that we are installing keys to our
 keyring, and trusting all downloaded keys.
@@ -177,7 +183,7 @@ need to be adjusted for better re-locatability.
 --------------------
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-``spack buildcache push``
+``spack buildcache create``
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Create tarball of installed Spack package and all dependencies.

lib/spack/docs/bootstrapping.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -15,13 +15,15 @@ is an entire command dedicated to the management of every aspect of bootstrappin
 
 .. command-output:: spack bootstrap --help
 
-Spack is configured to bootstrap its dependencies lazily by default; i.e. the first time they are needed and
-can't be found. You can readily check if any prerequisite for using Spack is missing by running:
+The first thing to know to understand bootstrapping in Spack is that each of
+Spack's dependencies is bootstrapped lazily; i.e. the first time it is needed and
+can't be found. You can readily check if any prerequisite for using Spack
+is missing by running:
 
 .. code-block:: console
 
    % spack bootstrap status
-   Spack v0.19.0 - python@3.8
+   Spack v0.17.1 - python@3.8
 
    [FAIL] Core Functionalities
      [B] MISSING "clingo": required to concretize specs
@@ -46,21 +48,6 @@ they can be bootstrapped. Running a command that concretize a spec, like:
 
 triggers the bootstrapping of clingo from pre-built binaries as expected.
 
-Users can also bootstrap all the dependencies needed by Spack in a single command, which
-might be useful to setup containers or other similar environments:
-
-.. code-block:: console
-
-   $ spack bootstrap now
-   ==> Bootstrapping clingo from pre-built binaries
-   ==> Fetching https://mirror.spack.io/bootstrap/github-actions/v0.3/build_cache/linux-centos7-x86_64-gcc-10.2.1-clingo-bootstrap-spack-shqedxgvjnhiwdcdrvjhbd73jaevv7wt.spec.json
-   ==> Fetching https://mirror.spack.io/bootstrap/github-actions/v0.3/build_cache/linux-centos7-x86_64/gcc-10.2.1/clingo-bootstrap-spack/linux-centos7-x86_64-gcc-10.2.1-clingo-bootstrap-spack-shqedxgvjnhiwdcdrvjhbd73jaevv7wt.spack
-   ==> Installing "clingo-bootstrap@spack%gcc@10.2.1~docs~ipo+python+static_libstdcpp build_type=Release arch=linux-centos7-x86_64" from a buildcache
-   ==> Bootstrapping patchelf from pre-built binaries
-   ==> Fetching https://mirror.spack.io/bootstrap/github-actions/v0.3/build_cache/linux-centos7-x86_64-gcc-10.2.1-patchelf-0.15.0-htk62k7efo2z22kh6kmhaselru7bfkuc.spec.json
-   ==> Fetching https://mirror.spack.io/bootstrap/github-actions/v0.3/build_cache/linux-centos7-x86_64/gcc-10.2.1/patchelf-0.15.0/linux-centos7-x86_64-gcc-10.2.1-patchelf-0.15.0-htk62k7efo2z22kh6kmhaselru7bfkuc.spack
-   ==> Installing "patchelf@0.15.0%gcc@10.2.1 ldflags="-static-libstdc++ -static-libgcc"  arch=linux-centos7-x86_64" from a buildcache
-
 -----------------------
 The Bootstrapping store
 -----------------------
@@ -120,19 +107,19 @@ If need be, you can disable bootstrapping altogether by running:
 
 in which case it's your responsibility to ensure Spack runs in an
 environment where all its prerequisites are installed. You can
-also configure Spack to skip certain bootstrapping methods by disabling
-them specifically:
+also configure Spack to skip certain bootstrapping methods by *untrusting*
+them. For instance:
 
 .. code-block:: console
 
-   % spack bootstrap disable github-actions
-   ==> "github-actions" is now disabled and will not be used for bootstrapping
+   % spack bootstrap untrust github-actions
+   ==> "github-actions" is now untrusted and will not be used for bootstrapping
 
 tells Spack to skip trying to bootstrap from binaries. To add the "github-actions" method back you can:
 
 .. code-block:: console
 
-   % spack bootstrap enable github-actions
+   % spack bootstrap trust github-actions
 
 There is also an option to reset the bootstrapping configuration to Spack's defaults:
 

lib/spack/docs/build_settings.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -49,8 +49,9 @@ packages rather than building its own packages. This may be desirable
 if machines ship with system packages, such as a customized MPI
 that should be used instead of Spack building its own MPI.
 
-External packages are configured through the ``packages.yaml`` file.
-Here's an example of an external configuration:
+External packages are configured through the ``packages.yaml`` file found
+in a Spack installation's ``etc/spack/`` or a user's ``~/.spack/``
+directory. Here's an example of an external configuration:
 
 .. code-block:: yaml
 
@@ -96,14 +97,11 @@ Each package version and compiler listed in an external should
 have entries in Spack's packages and compiler configuration, even
 though the package and compiler may not ever be built.
 
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Prevent packages from being built from sources
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Adding an external spec in ``packages.yaml`` allows Spack to use an external location,
-but it does not prevent Spack from building packages from sources. In the above example,
-Spack might choose for many valid reasons to start building and linking with the
-latest version of OpenMPI rather than continue using the pre-installed OpenMPI versions.
+The packages configuration can tell Spack to use an external location
+for certain package versions, but it does not restrict Spack to using
+external packages.  In the above example, since newer versions of OpenMPI
+are available, Spack will choose to start building and linking with the
+latest version rather than continue using the pre-installed OpenMPI versions.
 
 To prevent this, the ``packages.yaml`` configuration also allows packages
 to be flagged as non-buildable.  The previous example could be modified to
@@ -123,15 +121,9 @@ be:
        buildable: False
 
 The addition of the ``buildable`` flag tells Spack that it should never build
-its own version of OpenMPI from sources, and it will instead always rely on a pre-built
-OpenMPI.
-
-.. note::
-
-   If ``concretizer:reuse`` is on (see :ref:`concretizer-options` for more information on that flag)
-   pre-built specs include specs already available from a local store, an upstream store, a registered
-   buildcache or specs marked as externals in ``packages.yaml``. If ``concretizer:reuse`` is off, only
-   external specs in ``packages.yaml`` are included in the list of pre-built specs.
+its own version of OpenMPI, and it will instead always rely on a pre-built
+OpenMPI.  Similar to ``paths``, ``buildable`` is specified as a property under
+a package name.
 
 If an external module is specified as not buildable, then Spack will load the
 external module into the build environment which can be used for linking.
@@ -140,10 +132,6 @@ The ``buildable`` does not need to be paired with external packages.
 It could also be used alone to forbid packages that may be
 buggy or otherwise undesirable.
 
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Non-buildable virtual packages
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
 Virtual packages in Spack can also be specified as not buildable, and
 external implementations can be provided. In the example above,
 OpenMPI is configured as not buildable, but Spack will often prefer
@@ -165,37 +153,21 @@ but more conveniently:
        - spec: "openmpi@1.6.5%intel@10.1 arch=linux-debian7-x86_64"
          prefix: /opt/openmpi-1.6.5-intel
 
-Spack can then use any of the listed external implementations of MPI
-to satisfy a dependency, and will choose depending on the compiler and
-architecture.
-
-In cases where the concretizer is configured to reuse specs, and other ``mpi`` providers
-(available via stores or buildcaches) are not wanted, Spack can be configured to require
-specs matching only the available externals:
+Implementations can also be listed immediately under the virtual they provide:
 
 .. code-block:: yaml
 
    packages:
      mpi:
        buildable: False
-       require:
-       - one_of: [
-           "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64",
-           "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64+debug",
-           "openmpi@1.6.5%intel@10.1 arch=linux-debian7-x86_64"
-         ]
-     openmpi:
-       externals:
-       - spec: "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64"
-         prefix: /opt/openmpi-1.4.3
-       - spec: "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64+debug"
-         prefix: /opt/openmpi-1.4.3-debug
-       - spec: "openmpi@1.6.5%intel@10.1 arch=linux-debian7-x86_64"
-         prefix: /opt/openmpi-1.6.5-intel
+         openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64: /opt/openmpi-1.4.3
+         openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64+debug: /opt/openmpi-1.4.3-debug
+         openmpi@1.6.5%intel@10.1 arch=linux-debian7-x86_64: /opt/openmpi-1.6.5-intel
+         mpich@3.3 %clang@9.0.0 arch=linux-debian7-x86_64: /opt/mpich-3.3-intel
 
-This configuration prevents any spec using MPI and originating from stores or buildcaches to be reused,
-unless it matches the requirements under ``packages:mpi:require``. For more information on requirements see
-:ref:`package-requirements`.
+Spack can then use any of the listed external implementations of MPI
+to satisfy a dependency, and will choose depending on the compiler and
+architecture.
 
 .. _cmd-spack-external-find:
 
@@ -222,6 +194,11 @@ Specific limitations include:
 * Packages are not discoverable by default: For a package to be
   discoverable with ``spack external find``, it needs to add special
   logic. See :ref:`here <make-package-findable>` for more details.
+* The current implementation only collects and examines executable files,
+  so it is typically only useful for build/run dependencies (in some cases
+  if a library package also provides an executable, it may be possible to
+  extract a meaningful Spec by running the executable - for example the
+  compiler wrappers in MPI implementations).
 * The logic does not search through module files, it can only detect
   packages with executables defined in ``PATH``; you can help Spack locate
   externals which use module files by loading any associated modules for
@@ -272,7 +249,7 @@ Selection of the target microarchitectures
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 The options under the ``targets`` attribute control which targets are considered during a solve.
-Currently the options in this section are only configurable from the ``concretizer.yaml`` file
+Currently the options in this section are only configurable from the ``concretization.yaml`` file
 and there are no corresponding command line arguments to enable them for a single solve.
 
 The ``granularity`` option can take two possible values: ``microarchitectures`` and ``generic``.
@@ -302,207 +279,17 @@ microarchitectures considered during the solve are constrained to be compatible
 host Spack is currently running on. For instance, if this option is set to ``true``, a
 user cannot concretize for ``target=icelake`` while running on an Haswell node.
 
-.. _package-requirements:
-
---------------------
-Package Requirements
---------------------
-
-Spack can be configured to always use certain compilers, package
-versions, and variants during concretization through package
-requirements.
-
-Package requirements are useful when you find yourself repeatedly
-specifying the same constraints on the command line, and wish that
-Spack respects these constraints whether you mention them explicitly
-or not. Another use case is specifying constraints that should apply
-to all root specs in an environment, without having to repeat the
-constraint everywhere.
-
-Apart from that, requirements config is more flexible than constraints
-on the command line, because it can specify constraints on packages
-*when they occur* as a dependency. In contrast, on the command line it
-is not possible to specify constraints on dependencies while also keeping
-those dependencies optional.
-
-^^^^^^^^^^^^^^^^^^^
-Requirements syntax
-^^^^^^^^^^^^^^^^^^^
-
-The package requirements configuration is specified in ``packages.yaml``,
-keyed by package name and expressed using the Spec syntax. In the simplest
-case you can specify attributes that you always want the package to have
-by providing a single spec string to ``require``:
-
-.. code-block:: yaml
-
-   packages:
-     libfabric:
-       require: "@1.13.2"
-
-In the above example, ``libfabric`` will always build with version 1.13.2. If you
-need to compose multiple configuration scopes ``require`` accepts a list of
-strings:
-
-.. code-block:: yaml
-
-   packages:
-     libfabric:
-       require:
-       - "@1.13.2"
-       - "%gcc"
-
-In this case ``libfabric`` will always build with version 1.13.2 **and** using GCC
-as a compiler.
-
-For more complex use cases, require accepts also a list of objects. These objects
-must have either a ``any_of`` or a ``one_of`` field, containing a list of spec strings,
-and they can optionally have a ``when`` and a ``message`` attribute:
-
-.. code-block:: yaml
-
-   packages:
-     openmpi:
-       require:
-       - any_of: ["@4.1.5", "%gcc"]
-         message: "in this example only 4.1.5 can build with other compilers"
-
-``any_of`` is a list of specs. One of those specs must be satisfied
-and it is also allowed for the concretized spec to match more than one.
-In the above example, that means you could build ``openmpi@4.1.5%gcc``,
-``openmpi@4.1.5%clang`` or ``openmpi@3.9%gcc``, but
-not ``openmpi@3.9%clang``.
-
-If a custom message is provided, and the requirement is not satisfiable,
-Spack will print the custom error message:
-
-.. code-block:: console
-
-   $ spack spec openmpi@3.9%clang
-   ==> Error: in this example only 4.1.5 can build with other compilers
-
-We could express a similar requirement using the ``when`` attribute:
-
-.. code-block:: yaml
-
-   packages:
-     openmpi:
-       require:
-       - any_of: ["%gcc"]
-         when: "@:4.1.4"
-         message: "in this example only 4.1.5 can build with other compilers"
-
-In the example above, if the version turns out to be 4.1.4 or less, we require the compiler to be GCC.
-For readability, Spack also allows a ``spec`` key accepting a string when there is only a single
-constraint:
-
-.. code-block:: yaml
-
-   packages:
-     openmpi:
-       require:
-       - spec: "%gcc"
-         when: "@:4.1.4"
-         message: "in this example only 4.1.5 can build with other compilers"
-
-This code snippet and the one before it are semantically equivalent.
-
-Finally, instead of ``any_of`` you can use ``one_of`` which also takes a list of specs. The final
-concretized spec must match one and only one of them:
-
-.. code-block:: yaml
-
-   packages:
-     mpich:
-       require:
-       - one_of: ["+cuda", "+rocm"]
-
-In the example above, that means you could build ``mpich+cuda`` or ``mpich+rocm`` but not ``mpich+cuda+rocm``.
-
-.. note::
-
-   For ``any_of`` and ``one_of``, the order of specs indicates a
-   preference: items that appear earlier in the list are preferred
-   (note that these preferences can be ignored in favor of others).
-
-.. note::
-
-   When using a conditional requirement, Spack is allowed to actively avoid the triggering
-   condition (the ``when=...`` spec) if that leads to a concrete spec with better scores in
-   the optimization criteria. To check the current optimization criteria and their
-   priorities you can run ``spack solve zlib``.
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Setting default requirements
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-You can also set default requirements for all packages under ``all``
-like this:
-
-.. code-block:: yaml
-
-   packages:
-     all:
-       require: '%clang'
-
-which means every spec will be required to use ``clang`` as a compiler.
-
-Note that in this case ``all`` represents a *default set of requirements* -
-if there are specific package requirements, then the default requirements
-under ``all`` are disregarded. For example, with a configuration like this:
-
-.. code-block:: yaml
-
-   packages:
-     all:
-       require: '%clang'
-     cmake:
-       require: '%gcc'
-
-Spack requires ``cmake`` to use ``gcc`` and all other nodes (including ``cmake``
-dependencies) to use ``clang``.
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Setting requirements on virtual specs
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-A requirement on a virtual spec applies whenever that virtual is present in the DAG.
-This can be useful for fixing which virtual provider you want to use:
-
-.. code-block:: yaml
-
-   packages:
-     mpi:
-       require: 'mvapich2 %gcc'
-
-With the configuration above the only allowed ``mpi`` provider is ``mvapich2 %gcc``.
-
-Requirements on the virtual spec and on the specific provider are both applied, if
-present. For instance with a configuration like:
-
-.. code-block:: yaml
-
-   packages:
-     mpi:
-       require: 'mvapich2 %gcc'
-     mvapich2:
-       require: '~cuda'
-
-you will use ``mvapich2~cuda %gcc`` as an ``mpi`` provider.
-
 .. _package-preferences:
 
 -------------------
 Package Preferences
 -------------------
 
-In some cases package requirements can be too strong, and package
-preferences are the better option. Package preferences do not impose
-constraints on packages for particular versions or variants values,
-they rather only set defaults -- the concretizer is free to change
-them if it must due to other constraints. Also note that package
-preferences are of lower priority than reuse of already installed
-packages.
+Spack can be configured to prefer certain compilers, package
+versions, dependencies, and variants during concretization.
+The preferred configuration can be controlled via the
+``~/.spack/packages.yaml`` file for user configurations, or the
+``etc/spack/packages.yaml`` site configuration.
 
 Here's an example ``packages.yaml`` file that sets preferred packages:
 
@@ -520,7 +307,7 @@ Here's an example ``packages.yaml`` file that sets preferred packages:
        providers:
          mpi: [mvapich2, mpich, openmpi]
 
-At a high level, this example is specifying how packages are preferably
+At a high level, this example is specifying how packages should be
 concretized.  The opencv package should prefer using GCC 4.9 and
 be built with debug options.  The gperftools package should prefer version
 2.2 over 2.4.  Every package on the system should prefer mvapich2 for
@@ -528,11 +315,13 @@ its MPI and GCC 4.4.7 (except for opencv, which overrides this by preferring GCC
 These options are used to fill in implicit defaults.  Any of them can be overwritten
 on the command line if explicitly requested.
 
-Package preferences accept the follow keys or components under
-the specific package (or ``all``) section: ``compiler``, ``variants``,
-``version``, ``providers``, and ``target``.  Each component has an
-ordered list of spec ``constraints``, with earlier entries in the
-list being preferred over later entries.
+Each ``packages.yaml`` file begins with the string ``packages:`` and
+package names are specified on the next level. The special string ``all``
+applies settings to *all* packages. Underneath each package name is one
+or more components: ``compiler``, ``variants``, ``version``,
+``providers``, and ``target``.  Each component has an ordered list of
+spec ``constraints``, with earlier entries in the list being preferred
+over later entries.
 
 Sometimes a package installation may have constraints that forbid
 the first concretization rule, in which case Spack will use the first
@@ -547,9 +336,10 @@ gcc to pgi will thus be preferred over the xlc compiler.
 
 The syntax for the ``provider`` section differs slightly from other
 concretization rules.  A provider lists a value that packages may
-``depends_on`` (e.g, MPI) and a list of rules for fulfilling that
+``depend_on`` (e.g, MPI) and a list of rules for fulfilling that
 dependency.
 
+
 .. _package_permissions:
 
 -------------------
@@ -598,25 +388,3 @@ directories inside the install prefix. This will ensure that even
 manually placed files within the install prefix are owned by the
 assigned group. If no group is assigned, Spack will allow the OS
 default behavior to go as expected.
-
-----------------------------
-Assigning Package Attributes
-----------------------------
-
-You can assign class-level attributes in the configuration:
-
-.. code-block:: yaml
-
-  packages:
-    mpileaks:
-      # Override existing attributes
-      url: http://www.somewhereelse.com/mpileaks-1.0.tar.gz
-      # ... or add new ones
-      x: 1
-
-Attributes set this way will be accessible to any method executed
-in the package.py file (e.g. the ``install()`` method). Values for these
-attributes may be any value parseable by yaml.
-
-These can only be applied to specific packages, not "all" or
-virtual packages.

lib/spack/docs/build_systems.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -65,6 +65,7 @@ on these ideas for each distinct build system that Spack supports:
    build_systems/custompackage
    build_systems/inteloneapipackage
    build_systems/intelpackage
+   build_systems/multiplepackage
    build_systems/rocmpackage
    build_systems/sourceforgepackage
 

lib/spack/docs/build_systems/autotoolspackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _autotoolspackage:
 
----------
-Autotools
----------
+----------------
+AutotoolsPackage
+----------------
 
 Autotools is a GNU build system that provides a build-script generator.
 By running the platform-independent ``./configure`` script that comes
@@ -17,7 +17,7 @@ with the package, you can generate a platform-dependent Makefile.
 Phases
 ^^^^^^
 
-The ``AutotoolsBuilder`` and ``AutotoolsPackage`` base classes come with the following phases:
+The ``AutotoolsPackage`` base class comes with the following phases:
 
 #. ``autoreconf`` - generate the configure script
 #. ``configure`` - generate the Makefiles

lib/spack/docs/build_systems/bundlepackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _bundlepackage:
 
-------
-Bundle
-------
+-------------
+BundlePackage
+-------------
 
 ``BundlePackage`` represents a set of packages that are expected to work well
 together, such as a collection of commonly used software libraries.  The

lib/spack/docs/build_systems/cachedcmakepackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _cachedcmakepackage:
 
------------
-CachedCMake
------------
+------------------
+CachedCMakePackage
+------------------
 
 The CachedCMakePackage base class is used for CMake-based workflows
 that create a CMake cache file prior to running ``cmake``. This is

lib/spack/docs/build_systems/cmakepackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _cmakepackage:
 
------
-CMake
------
+------------
+CMakePackage
+------------
 
 Like Autotools, CMake is a widely-used build-script generator. Designed
 by Kitware, CMake is the most popular build system for new C, C++, and
@@ -21,7 +21,7 @@ whereas Autotools is Unix-only.
 Phases
 ^^^^^^
 
-The ``CMakeBuilder`` and ``CMakePackage`` base classes come with the following phases:
+The ``CMakePackage`` base class comes with the following phases:
 
 #. ``cmake`` - generate the Makefile
 #. ``build`` - build the package
@@ -130,8 +130,8 @@ Adding flags to cmake
 To add additional flags to the ``cmake`` call, simply override the
 ``cmake_args`` function. The following example defines values for the flags
 ``WHATEVER``, ``ENABLE_BROKEN_FEATURE``, ``DETECT_HDF5``, and ``THREADS`` with
-and without the :meth:`~spack.build_systems.cmake.CMakeBuilder.define` and
-:meth:`~spack.build_systems.cmake.CMakeBuilder.define_from_variant` helper functions:
+and without the :meth:`~spack.build_systems.cmake.CMakePackage.define` and
+:meth:`~spack.build_systems.cmake.CMakePackage.define_from_variant` helper functions:
 
 .. code-block:: python
 

lib/spack/docs/build_systems/cudapackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _cudapackage:
 
-----
-Cuda
-----
+-----------
+CudaPackage
+-----------
 
 Different from other packages, ``CudaPackage`` does not represent a build system.
 Instead its goal is to simplify and unify usage of ``CUDA`` in other packages by providing a `mixin-class <https://en.wikipedia.org/wiki/Mixin>`_.
@@ -28,14 +28,11 @@ This package provides the following variants:
 
 * **cuda_arch**
 
-  This variant supports the optional specification of one or multiple architectures.
+  This variant supports the optional specification of the architecture.
   Valid values are maintained in the ``cuda_arch_values`` property and
   are the numeric character equivalent of the compute capability version
   (e.g., '10' for version 1.0). Each provided value affects associated
   ``CUDA`` dependencies and compiler conflicts.
-  
-  The variant builds both PTX code for the _virtual_ architecture
-  (e.g. ``compute_10``) and binary code for the _real_ architecture (e.g. ``sm_10``).
 
   GPUs and their compute capability versions are listed at
   https://developer.nvidia.com/cuda-gpus .
@@ -83,7 +80,7 @@ standard CUDA compiler flags.
 
 **cuda_flags**
 
-    This built-in static method returns a list of command line flags
+    This built-in static method returns a list of command line flags 
     for the chosen ``cuda_arch`` value(s).  The flags are intended to
     be passed to the CUDA compiler driver (i.e., ``nvcc``).
 

lib/spack/docs/build_systems/custompackage.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)

lib/spack/docs/build_systems/inteloneapipackage.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -6,9 +6,9 @@
 .. _inteloneapipackage:
 
 
-===========
-IntelOneapi
-===========
+====================
+ IntelOneapiPackage
+====================
 
 
 .. contents::
@@ -32,11 +32,11 @@ oneAPI packages or use::
 
 For more information on a specific package, do::
 
-  spack info --all <package-name>
+  spack info <package-name>
 
 Intel no longer releases new versions of Parallel Studio, which can be
 used in Spack via the :ref:`intelpackage`. All of its components can
-now be found in oneAPI.
+now be found in oneAPI. 
 
 Examples
 ========
@@ -124,7 +124,7 @@ Using oneAPI Tools Installed by Spack
 =====================================
 
 Spack can be a convenient way to install and configure compilers and
-libraries, even if you do not intend to build a Spack package. If you
+libaries, even if you do not intend to build a Spack package. If you
 want to build a Makefile project using Spack-installed oneAPI compilers,
 then use spack to configure your environment::
 

lib/spack/docs/build_systems/intelpackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _intelpackage:
 
------
-Intel
------
+------------
+IntelPackage
+------------
 
 .. contents::
 
@@ -397,7 +397,7 @@ for specifics and examples for ``packages.yaml`` files.
 
 .. If your system administrator did not provide modules for pre-installed Intel
    tools, you could do well to ask for them, because installing multiple copies
-   of the Intel tools, as is won't to happen once Spack is in the picture, is
+   of the Intel tools, as is wont to happen once Spack is in the picture, is
    bound to stretch disk space and patience thin. If you *are* the system
    administrator and are still new to modules, then perhaps it's best to follow
    the `next section <Installing Intel tools within Spack_>`_ and install the tools
@@ -653,7 +653,7 @@ follow `the next section <intel-install-libs_>`_ instead.
    * If you specified a custom variant (for example ``+vtune``) you may want to add this as your
      preferred variant in the packages configuration for the ``intel-parallel-studio`` package
      as described in :ref:`package-preferences`. Otherwise you will have to specify
-     the variant every time ``intel-parallel-studio`` is being used as ``mkl``, ``fftw`` or ``mpi``
+     the variant everytime ``intel-parallel-studio`` is being used as ``mkl``, ``fftw`` or ``mpi``
      implementation to avoid pulling in a different variant.
 
    * To set the Intel compilers for default use in Spack, instead of the usual ``%gcc``,

lib/spack/docs/build_systems/luapackage.rst

@@ -1,15 +1,15 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _luapackage:
 
----
-Lua
----
+------------
+LuaPackage
+------------
 
-The ``Lua`` build-system is a helper for the common case of Lua packages that provide
+LuaPackage is a helper for the common case of Lua packages that provide
 a rockspec file.  This is not meant to take a rock archive, but to build
 a source archive or repository that provides a rockspec, which should cover
 most lua packages. In the case a Lua package builds by Make rather than
@@ -19,7 +19,7 @@ luarocks, prefer MakefilePackage.
 Phases
 ^^^^^^
 
-The ``LuaBuilder`` and `LuaPackage`` base classes come with the following phases:
+The ``LuaPackage`` base class comes with the following phases:
 
 #. ``unpack`` - if using a rock, unpacks the rock and moves into the source directory
 #. ``preprocess`` - adjust sources or rockspec to fix build

lib/spack/docs/build_systems/makefilepackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _makefilepackage:
 
---------
-Makefile
---------
+---------------
+MakefilePackage
+---------------
 
 The most primitive build system a package can use is a plain Makefile.
 Makefiles are simple to write for small projects, but they usually
@@ -18,7 +18,7 @@ variables.
 Phases
 ^^^^^^
 
-The ``MakefileBuilder`` and ``MakefilePackage`` base classes come with 3 phases:
+The ``MakefilePackage`` base class comes with 3 phases:
 
 #. ``edit`` - edit the Makefile
 #. ``build`` - build the project

lib/spack/docs/build_systems/mavenpackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _mavenpackage:
 
------
-Maven
------
+------------
+MavenPackage
+------------
 
 Apache Maven is a general-purpose build system that does not rely
 on Makefiles to build software. It is designed for building and
@@ -17,7 +17,7 @@ managing and Java-based project.
 Phases
 ^^^^^^
 
-The ``MavenBuilder`` and ``MavenPackage`` base classes come with the following phases:
+The ``MavenPackage`` base class comes with the following phases:
 
 #. ``build`` - compile code and package into a JAR file
 #. ``install`` - copy to installation prefix

lib/spack/docs/build_systems/mesonpackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _mesonpackage:
 
------
-Meson
------
+------------
+MesonPackage
+------------
 
 Much like Autotools and CMake, Meson is a build system.  But it is
 meant to be both fast and as user friendly as possible.  GNOME's goal
@@ -17,7 +17,7 @@ is to port modules to use the Meson build system.
 Phases
 ^^^^^^
 
-The ``MesonBuilder`` and ``MesonPackage`` base classes come with the following phases:
+The ``MesonPackage`` base class comes with the following phases:
 
 #. ``meson`` - generate ninja files
 #. ``build`` - build the project

lib/spack/docs/build_systems/multiplepackage.rst

@@ -0,0 +1,350 @@
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
+   Spack Project Developers. See the top-level COPYRIGHT file for details.
+
+   SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+.. _multiplepackage:
+
+----------------------
+Multiple Build Systems
+----------------------
+
+Quite frequently, a package will change build systems from one version to the
+next. For example, a small project that once used a single Makefile to build
+may now require Autotools to handle the increased number of files that need to
+be compiled. Or, a package that once used Autotools may switch to CMake for
+Windows support. In this case, it becomes a bit more challenging to write a
+single build recipe for this package in Spack.
+
+There are several ways that this can be handled in Spack:
+
+#. Subclass the new build system, and override phases as needed (preferred)
+#. Subclass ``Package`` and implement ``install`` as needed
+#. Create separate ``*-cmake``, ``*-autotools``, etc. packages for each build system
+#. Rename the old package to ``*-legacy`` and create a new package
+#. Move the old package to a ``legacy`` repository and create a new package
+#. Drop older versions that only support the older build system
+
+Of these options, 1 is preferred, and will be demonstrated in this
+documentation. Options 3-5 have issues with concretization, so shouldn't be
+used. Options 4-5 also don't support more than two build systems. Option 6 only
+works if the old versions are no longer needed. Option 1 is preferred over 2
+because it makes it easier to drop the old build system entirely.
+
+The exact syntax of the package depends on which build systems you need to
+support. Below are a couple of common examples.
+
+^^^^^^^^^^^^^^^^^^^^^
+Makefile -> Autotools
+^^^^^^^^^^^^^^^^^^^^^
+
+Let's say we have the following package:
+
+.. code-block:: python
+
+   class Foo(MakefilePackage):
+       version("1.2.0", sha256="...")
+
+       def edit(self, spec, prefix):
+           filter_file("CC=", "CC=" + spack_cc, "Makefile")
+
+       def install(self, spec, prefix):
+           install_tree(".", prefix)
+
+
+The package subclasses from :ref:`makefilepackage`, which has three phases:
+
+#. ``edit`` (does nothing by default)
+#. ``build`` (runs ``make`` by default)
+#. ``install`` (runs ``make install`` by default)
+
+In this case, the ``install`` phase needed to be overridden because the
+Makefile did not have an install target. We also modify the Makefile to use
+Spack's compiler wrappers. The default ``build`` phase is not changed.
+
+Starting with version 1.3.0, we want to use Autotools to build instead.
+:ref:`autotoolspackage` has four phases:
+
+#. ``autoreconf`` (does not if a configure script already exists)
+#. ``configure`` (runs ``./configure --prefix=...`` by default)
+#. ``build`` (runs ``make`` by default)
+#. ``install`` (runs ``make install`` by default)
+
+If the only version we need to support is 1.3.0, the package would look as
+simple as:
+
+.. code-block:: python
+
+   class Foo(AutotoolsPackage):
+       version("1.3.0", sha256="...")
+
+       def configure_args(self):
+           return ["--enable-shared"]
+
+
+In this case, we use the default methods for each phase and only override
+``configure_args`` to specify additional flags to pass to ``./configure``.
+
+If we wanted to write a single package that supports both versions 1.2.0 and
+1.3.0, it would look something like:
+
+.. code-block:: python
+
+   class Foo(AutotoolsPackage):
+       version("1.3.0", sha256="...")
+       version("1.2.0", sha256="...", deprecated=True)
+
+       def configure_args(self):
+           return ["--enable-shared"]
+
+       # Remove the following once version 1.2.0 is dropped
+       @when("@:1.2")
+       def patch(self):
+           filter_file("CC=", "CC=" + spack_cc, "Makefile")
+
+       @when("@:1.2")
+       def autoreconf(self, spec, prefix):
+           pass
+
+       @when("@:1.2")
+       def configure(self, spec, prefix):
+           pass
+
+       @when("@:1.2")
+       def install(self, spec, prefix):
+           install_tree(".", prefix)
+
+
+There are a few interesting things to note here:
+
+* We added ``deprecated=True`` to version 1.2.0. This signifies that version
+  1.2.0 is deprecated and shouldn't be used. However, if a user still relies
+  on version 1.2.0, it's still there and builds just fine.
+* We moved the contents of the ``edit`` phase to the ``patch`` function. Since
+  ``AutotoolsPackage`` doesn't have an ``edit`` phase, the only way for this
+  step to be executed is to move it to the ``patch`` function, which always
+  gets run.
+* The ``autoreconf`` and ``configure`` phases become no-ops. Since the old
+  Makefile-based build system doesn't use these, we ignore these phases when
+  building ``foo@1.2.0``.
+* The ``@when`` decorator is used to override these phases only for older
+  versions. The default methods are used for ``foo@1.3:``.
+
+Once a new Spack release comes out, version 1.2.0 and everything below the
+comment can be safely deleted. The result is the same as if we had written a
+package for version 1.3.0 from scratch.
+
+^^^^^^^^^^^^^^^^^^
+Autotools -> CMake
+^^^^^^^^^^^^^^^^^^
+
+Let's say we have the following package:
+
+.. code-block:: python
+
+   class Bar(AutotoolsPackage):
+       version("1.2.0", sha256="...")
+
+       def configure_args(self):
+           return ["--enable-shared"]
+
+
+The package subclasses from :ref:`autotoolspackage`, which has four phases:
+
+#. ``autoreconf`` (does not if a configure script already exists)
+#. ``configure`` (runs ``./configure --prefix=...`` by default)
+#. ``build`` (runs ``make`` by default)
+#. ``install`` (runs ``make install`` by default)
+
+In this case, we use the default methods for each phase and only override
+``configure_args`` to specify additional flags to pass to ``./configure``.
+
+Starting with version 1.3.0, we want to use CMake to build instead.
+:ref:`cmakepackage` has three phases:
+
+#. ``cmake`` (runs ``cmake ...`` by default)
+#. ``build`` (runs ``make`` by default)
+#. ``install`` (runs ``make install`` by default)
+
+If the only version we need to support is 1.3.0, the package would look as
+simple as:
+
+.. code-block:: python
+
+   class Bar(CMakePackage):
+       version("1.3.0", sha256="...")
+
+       def cmake_args(self):
+           return [self.define("BUILD_SHARED_LIBS", True)]
+
+
+In this case, we use the default methods for each phase and only override
+``cmake_args`` to specify additional flags to pass to ``cmake``.
+
+If we wanted to write a single package that supports both versions 1.2.0 and
+1.3.0, it would look something like:
+
+.. code-block:: python
+
+   class Bar(CMakePackage):
+       version("1.3.0", sha256="...")
+       version("1.2.0", sha256="...", deprecated=True)
+
+       def cmake_args(self):
+           return [self.define("BUILD_SHARED_LIBS", True)]
+
+       # Remove the following once version 1.2.0 is dropped
+       def configure_args(self):
+           return ["--enable-shared"]
+
+       @when("@:1.2")
+       def cmake(self, spec, prefix):
+           configure("--prefix=" + prefix, *self.configure_args())
+
+
+There are a few interesting things to note here:
+
+* We added ``deprecated=True`` to version 1.2.0. This signifies that version
+  1.2.0 is deprecated and shouldn't be used. However, if a user still relies
+  on version 1.2.0, it's still there and builds just fine.
+* Since CMake and Autotools are so similar, we only need to override the
+  ``cmake`` phase, we can use the default ``build`` and ``install`` phases.
+* We override ``cmake`` to run ``./configure`` for older versions.
+  ``configure_args`` remains the same.
+* The ``@when`` decorator is used to override these phases only for older
+  versions. The default methods are used for ``bar@1.3:``.
+
+Once a new Spack release comes out, version 1.2.0 and everything below the
+comment can be safely deleted. The result is the same as if we had written a
+package for version 1.3.0 from scratch.
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Multiple build systems for the same version
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+During the transition from one build system to another, developers often
+support multiple build systems at the same time. Spack can only use a single
+build system for a single version. To decide which build system to use for a
+particular version, take the following things into account:
+
+1. If the developers explicitly state that one build system is preferred over
+   another, use that one.
+2. If one build system is considered "experimental" while another is considered
+   "stable", use the stable build system.
+3. Otherwise, use the newer build system.
+
+The developer preference for which build system to use can change over time as
+a newer build system becomes stable/recommended.
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Dropping support for old build systems
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+When older versions of a package don't support a newer build system, it can be
+tempting to simply delete them from a package. This significantly reduces
+package complexity and makes the build recipe much easier to maintain. However,
+other packages or Spack users may rely on these older versions. The recommended
+approach is to first support both build systems (as demonstrated above),
+:ref:`deprecate <deprecate>` versions that rely on the old build system, and
+remove those versions and any phases that needed to be overridden in the next
+Spack release.
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Three or more build systems
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+In rare cases, a package may change build systems multiple times. For example,
+a package may start with Makefiles, then switch to Autotools, then switch to
+CMake. The same logic used above can be extended to any number of build systems.
+For example:
+
+.. code-block:: python
+
+   class Baz(CMakePackage):
+       version("1.4.0", sha256="...")  # CMake
+       version("1.3.0", sha256="...")  # Autotools
+       version("1.2.0", sha256="...")  # Makefile
+
+       def cmake_args(self):
+           return [self.define("BUILD_SHARED_LIBS", True)]
+
+       # Remove the following once version 1.3.0 is dropped
+       def configure_args(self):
+           return ["--enable-shared"]
+
+       @when("@1.3")
+       def cmake(self, spec, prefix):
+           configure("--prefix=" + prefix, *self.configure_args())
+
+       # Remove the following once version 1.2.0 is dropped
+       @when("@:1.2")
+       def patch(self):
+           filter_file("CC=", "CC=" + spack_cc, "Makefile")
+
+       @when("@:1.2")
+       def cmake(self, spec, prefix):
+           pass
+
+       @when("@:1.2")
+       def install(self, spec, prefix):
+           install_tree(".", prefix)
+
+
+^^^^^^^^^^^^^^^^^^^
+Additional examples
+^^^^^^^^^^^^^^^^^^^
+
+When writing new packages, it often helps to see examples of existing packages.
+Here is an incomplete list of existing Spack packages that have changed build
+systems before:
+
+================  =====================  ================
+Package           Previous Build System  New Build System
+================  =====================  ================
+amber             custom                 CMake
+arpack-ng         Autotools              CMake
+atk               Autotools              Meson
+blast             None                   Autotools
+dyninst           Autotools              CMake
+evtgen            Autotools              CMake
+fish              Autotools              CMake
+gdk-pixbuf        Autotools              Meson
+glib              Autotools              Meson
+glog              Autotools              CMake
+gmt               Autotools              CMake
+gtkplus           Autotools              Meson
+hpl               Makefile               Autotools
+interproscan      Perl                   Maven
+jasper            Autotools              CMake
+kahip             SCons                  CMake
+kokkos            Makefile               CMake
+kokkos-kernels    Makefile               CMake
+leveldb           Makefile               CMake
+libdrm            Autotools              Meson
+libjpeg-turbo     Autotools              CMake
+mesa              Autotools              Meson
+metis             None                   CMake
+mpifileutils      Autotools              CMake
+muparser          Autotools              CMake
+mxnet             Makefile               CMake
+nest              Autotools              CMake
+neuron            Autotools              CMake
+nsimd             CMake                  nsconfig
+opennurbs         Makefile               CMake
+optional-lite     None                   CMake
+plasma            Makefile               CMake
+preseq            Makefile               Autotools
+protobuf          Autotools              CMake
+py-pygobject      Autotools              Python
+singularity       Autotools              Makefile
+span-lite         None                   CMake
+ssht              Makefile               CMake
+string-view-lite  None                   CMake
+superlu           Makefile               CMake
+superlu-dist      Makefile               CMake
+uncrustify        Autotools              CMake
+================  =====================  ================
+
+Packages that support multiple build systems can be a bit confusing to write.
+Don't hesitate to open an issue or draft pull request and ask for advice from
+other Spack developers!

lib/spack/docs/build_systems/octavepackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _octavepackage:
 
-------
-Octave
-------
+-------------
+OctavePackage
+-------------
 
 Octave has its own build system for installing packages.
 
@@ -15,7 +15,7 @@ Octave has its own build system for installing packages.
 Phases
 ^^^^^^
 
-The ``OctaveBuilder`` and ``OctavePackage`` base classes have a single phase:
+The ``OctavePackage`` base class has a single phase:
 
 #. ``install`` - install the package
 

lib/spack/docs/build_systems/perlpackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _perlpackage:
 
-----
-Perl
-----
+-----------
+PerlPackage
+-----------
 
 Much like Octave, Perl has its own language-specific
 build system.
@@ -16,7 +16,7 @@ build system.
 Phases
 ^^^^^^
 
-The ``PerlBuilder`` and ``PerlPackage`` base classes come with 3 phases that can be overridden:
+The ``PerlPackage`` base class comes with 3 phases that can be overridden:
 
 #. ``configure`` - configure the package
 #. ``build`` - build the package

lib/spack/docs/build_systems/pythonpackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _pythonpackage:
 
-------
-Python
-------
+-------------
+PythonPackage
+-------------
 
 Python packages and modules have their own special build system. This
 documentation covers everything you'll need to know in order to write
@@ -48,11 +48,9 @@ important to understand.
 **build backend**
    Libraries used to define how to build a wheel. Examples
    include `setuptools <https://setuptools.pypa.io/>`__,
-   `flit <https://flit.pypa.io/>`_,
-   `poetry <https://python-poetry.org/>`_,
-   `hatchling <https://hatch.pypa.io/latest/>`_,
-   `meson <https://meson-python.readthedocs.io/>`_, and
-   `pdm <https://pdm.fming.dev/latest/>`_.
+   `flit <https://flit.readthedocs.io/>`_,
+   `poetry <https://python-poetry.org/>`_, and
+   `hatchling <https://hatch.pypa.io/latest/>`_.
 
 ^^^^^^^^^^^
 Downloading
@@ -176,9 +174,9 @@ package. The "Project description" tab may also contain a longer
 description of the package. Either of these can be used to populate
 the package docstring.
 
-^^^^^^^^^^^^
-Dependencies
-^^^^^^^^^^^^
+^^^^^^^^^^^^^
+Build backend
+^^^^^^^^^^^^^
 
 Once you've determined the basic metadata for a package, the next
 step is to determine the build backend. ``PythonPackage`` uses
@@ -216,33 +214,12 @@ Note that ``py-wheel`` is already listed as a build dependency in the
 need to specify a specific version requirement or change the
 dependency type.
 
-See `PEP 517 <https://www.python.org/dev/peps/pep-0517/>`__ and
+See `PEP 517 <https://www.python.org/dev/peps/pep-0517/>`_ and
 `PEP 518 <https://www.python.org/dev/peps/pep-0518/>`_ for more
 information on the design of ``pyproject.toml``.
 
 Depending on which build backend a project uses, there are various
-places that run-time dependencies can be listed. Most modern build
-backends support listing dependencies directly in ``pyproject.toml``.
-Look for dependencies under the following keys:
-
-* ``requires-python`` under ``[project]``
-
-  This specifies the version of Python that is required
-
-* ``dependencies`` under ``[project]``
-
-  These packages are required for building and installation. You can
-  add them with ``type=('build', 'run')``.
-
-* ``[project.optional-dependencies]``
-
-  This section includes keys with lists of optional dependencies
-  needed to enable those features. You should add a variant that
-  optionally adds these dependencies. This variant should be ``False``
-  by default.
-
-Some build backends may have additional locations where dependencies
-can be found.
+places that run-time dependencies can be listed.
 
 """""""""
 distutils
@@ -268,9 +245,9 @@ If the ``pyproject.toml`` lists ``setuptools.build_meta`` as a
 ``build-backend``, or if the package has a ``setup.py`` that imports
 ``setuptools``, or if the package has a ``setup.cfg`` file, then it
 uses setuptools to build. Setuptools is a replacement for the
-distutils library, and has almost the exact same API. In addition to
-``pyproject.toml``, dependencies can be listed in the ``setup.py`` or
-``setup.cfg`` file. Look for the following arguments:
+distutils library, and has almost the exact same API. Dependencies
+can be listed in the ``setup.py`` or ``setup.cfg`` file. Look for the
+following arguments:
 
 * ``python_requires``
 
@@ -315,22 +292,25 @@ listed directly in the ``pyproject.toml`` file. Older versions of
 flit used to store this info in a ``flit.ini`` file, so check for
 this too.
 
-In addition to the default ``pyproject.toml`` keys listed above,
-older versions of flit may use the following keys:
+Either of these files may contain keys like:
 
-* ``requires`` under ``[tool.flit.metadata]``
+* ``requires-python``
+
+  This specifies the version of Python that is required
+
+* ``dependencies`` or ``requires``
 
   These packages are required for building and installation. You can
   add them with ``type=('build', 'run')``.
 
-* ``[tool.flit.metadata.requires-extra]``
+* ``project.optional-dependencies`` or ``requires-extra``
 
   This section includes keys with lists of optional dependencies
   needed to enable those features. You should add a variant that
   optionally adds these dependencies. This variant should be False
   by default.
 
-See https://flit.pypa.io/en/latest/pyproject_toml.html for
+See https://flit.readthedocs.io/en/latest/pyproject_toml.html for
 more information.
 
 """"""
@@ -352,33 +332,28 @@ hatchling
 """""""""
 
 If the ``pyproject.toml`` lists ``hatchling.build`` as the
-``build-backend``, it uses the hatchling build system. Hatchling
-uses the default ``pyproject.toml`` keys to list dependencies.
+``build-backend``, it uses the hatchling build system. Look for
+dependencies under the following keys:
+
+* ``requires-python``
+
+  This specifies the version of Python that is required
+
+* ``project.dependencies``
+
+  These packages are required for building and installation. You can
+  add them with ``type=('build', 'run')``.
+
+* ``project.optional-dependencies``
+
+  This section includes keys with lists of optional dependencies
+  needed to enable those features. You should add a variant that
+  optionally adds these dependencies. This variant should be ``False``
+  by default.
 
 See https://hatch.pypa.io/latest/config/dependency/ for more
 information.
 
-"""""
-meson
-"""""
-
-If the ``pyproject.toml`` lists ``mesonpy`` as the ``build-backend``,
-it uses the meson build system. Meson uses the default
-``pyproject.toml`` keys to list dependencies.
-
-See https://meson-python.readthedocs.io/en/latest/tutorials/introduction.html
-for more information.
-
-"""
-pdm
-"""
-
-If the ``pyproject.toml`` lists ``pdm.pep517.api`` as the ``build-backend``,
-it uses the PDM build system. PDM uses the default ``pyproject.toml``
-keys to list dependencies.
-
-See https://pdm.fming.dev/latest/ for more information.
-
 """"""
 wheels
 """"""
@@ -423,34 +398,6 @@ packages. However, the installation instructions for a package may
 suggest passing certain flags to the ``setup.py`` call. The
 ``PythonPackage`` class has two techniques for doing this.
 
-"""""""""""""""
-Config settings
-"""""""""""""""
-
-These settings are passed to
-`PEP 517 <https://peps.python.org/pep-0517/>`__ build backends.
-For example, ``py-scipy`` package allows you to specify the name of
-the BLAS/LAPACK library you want pkg-config to search for:
-
-.. code-block:: python
-
-   depends_on('py-pip@22.1:', type='build')
-
-   def config_settings(self, spec, prefix):
-       return {
-           'blas': spec['blas'].libs.names[0],
-           'lapack': spec['lapack'].libs.names[0],
-       }
-
-
-.. note::
-
-   This flag only works for packages that define a ``build-backend``
-   in ``pyproject.toml``. Also, it is only supported by pip 22.1+,
-   which requires Python 3.7+. For packages that still support Python
-   3.6 and older, ``install_options`` should be used instead.
-
-
 """"""""""""""
 Global options
 """"""""""""""
@@ -470,16 +417,6 @@ has an optional dependency on ``libyaml`` that can be enabled like so:
        return options
 
 
-.. note::
-
-   Direct invocation of ``setup.py`` is
-   `deprecated <https://blog.ganssle.io/articles/2021/10/setup-py-deprecated.html>`_.
-   This flag forces pip to use a deprecated installation procedure.
-   It should only be used in packages that don't define a
-   ``build-backend`` in ``pyproject.toml`` or packages that still
-   support Python 3.6 and older.
-
-
 """""""""""""""
 Install options
 """""""""""""""
@@ -500,16 +437,6 @@ allows you to specify the directories to search for ``libyaml``:
        return options
 
 
-.. note::
-
-   Direct invocation of ``setup.py`` is
-   `deprecated <https://blog.ganssle.io/articles/2021/10/setup-py-deprecated.html>`_.
-   This flag forces pip to use a deprecated installation procedure.
-   It should only be used in packages that don't define a
-   ``build-backend`` in ``pyproject.toml`` or packages that still
-   support Python 3.6 and older.
-
-
 ^^^^^^^
 Testing
 ^^^^^^^
@@ -582,19 +509,6 @@ libraries. Make sure not to add modules/packages containing the word
 "test", as these likely won't end up in the installation directory,
 or may require test dependencies like pytest to be installed.
 
-Instead of defining the ``import_modules`` explicitly, only the subset
-of module names to be skipped can be defined by using ``skip_modules``.
-If a defined module has submodules, they are skipped as well, e.g.,
-in case the ``plotting`` modules should be excluded from the
-automatically detected ``import_modules`` ``['nilearn', 'nilearn.surface',
-'nilearn.plotting', 'nilearn.plotting.data']`` set:
-
-.. code-block:: python
-
-        skip_modules = ['nilearn.plotting']
-
-This will set ``import_modules`` to ``['nilearn', 'nilearn.surface']``
-
 Import tests can be run during the installation using ``spack install
 --test=root`` or at any time after the installation using
 ``spack test run``.
@@ -724,9 +638,10 @@ extends vs. depends_on
 
 This is very similar to the naming dilemma above, with a slight twist.
 As mentioned in the :ref:`Packaging Guide <packaging_extensions>`,
-``extends`` and ``depends_on`` are very similar, but ``extends`` ensures
-that the extension and extendee share the same prefix in views.
-This allows the user to import a Python module without
+``extends`` and ``depends_on`` are very similar, but ``extends`` adds
+the ability to *activate* the package. Activation involves symlinking
+everything in the installation prefix of the package to the installation
+prefix of Python. This allows the user to import a Python module without
 having to add that module to ``PYTHONPATH``.
 
 When deciding between ``extends`` and ``depends_on``, the best rule of
@@ -734,7 +649,7 @@ thumb is to check the installation prefix. If Python libraries are
 installed to ``<prefix>/lib/pythonX.Y/site-packages``, then you
 should use ``extends``. If Python libraries are installed elsewhere
 or the only files that get installed reside in ``<prefix>/bin``, then
-don't use ``extends``.
+don't use ``extends``, as symlinking the package wouldn't be useful.
 
 ^^^^^^^^^^^^^^^^^^^^^
 Alternatives to Spack
@@ -777,8 +692,6 @@ For more information on build and installation frontend tools, see:
 For more information on build backend tools, see:
 
 * setuptools: https://setuptools.pypa.io/
-* flit: https://flit.pypa.io/
+* flit: https://flit.readthedocs.io/
 * poetry: https://python-poetry.org/
 * hatchling: https://hatch.pypa.io/latest/
-* meson: https://meson-python.readthedocs.io/
-* pdm: https://pdm.fming.dev/latest/

lib/spack/docs/build_systems/qmakepackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _qmakepackage:
 
------
-QMake
------
+------------
+QMakePackage
+------------
 
 Much like Autotools and CMake, QMake is a build-script generator
 designed by the developers of Qt. In its simplest form, Spack's
@@ -29,7 +29,7 @@ variables or edit ``*.pro`` files to get things working properly.
 Phases
 ^^^^^^
 
-The ``QMakeBuilder`` and ``QMakePackage`` base classes come with the following phases:
+The ``QMakePackage`` base class comes with the following phases:
 
 #. ``qmake`` - generate Makefiles
 #. ``build`` - build the project

lib/spack/docs/build_systems/racketpackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _racketpackage:
 
-------
-Racket
-------
+-------------
+RacketPackage
+-------------
 
 Much like Python, Racket packages and modules have their own special build system.
 To learn more about the specifics of Racket package system, please refer to the
@@ -17,7 +17,7 @@ To learn more about the specifics of Racket package system, please refer to the
 Phases
 ^^^^^^
 
-The ``RacketBuilder`` and ``RacketPackage`` base classes provides an ``install`` phase that
+The ``RacketPackage`` base class provides an ``install`` phase that
 can be overridden, corresponding to the use of:
 
 .. code-block:: console

lib/spack/docs/build_systems/rocmpackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _rocmpackage:
 
-----
-ROCm
-----
+-----------
+ROCmPackage
+-----------
 
 The ``ROCmPackage`` is not a build system but a helper package. Like ``CudaPackage``,
 it provides standard variants, dependencies, and conflicts to facilitate building
@@ -25,7 +25,7 @@ This package provides the following variants:
 
 * **rocm**
 
-  This variant is used to enable/disable building with ``rocm``.
+  This variant is used to enable/disable building with ``rocm``.  
   The default is disabled (or ``False``).
 
 * **amdgpu_target**

lib/spack/docs/build_systems/rpackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _rpackage:
 
---
-R
---
+--------
+RPackage
+--------
 
 Like Python, R has its own built-in build system.
 
@@ -19,7 +19,7 @@ new Spack packages for.
 Phases
 ^^^^^^
 
-The ``RBuilder`` and ``RPackage`` base classes have a single phase:
+The ``RPackage`` base class has a single phase:
 
 #. ``install`` - install the package
 
@@ -193,10 +193,10 @@ Build system dependencies
 
 As an extension of the R ecosystem, your package will obviously depend
 on R to build and run. Normally, we would use ``depends_on`` to express
-this, but for R packages, we use ``extends``. This implies a special
-dependency on R, which is used to set environment variables such as
-``R_LIBS`` uniformly. Since every R package needs this, the ``RPackage``
-base class contains:
+this, but for R packages, we use ``extends``. ``extends`` is similar to
+``depends_on``, but adds an additional feature: the ability to "activate"
+the package by symlinking it to the R installation directory. Since
+every R package needs this, the ``RPackage`` base class contains:
 
 .. code-block:: python
 

lib/spack/docs/build_systems/rubypackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _rubypackage:
 
-----
-Ruby
-----
+-----------
+RubyPackage
+-----------
 
 Like Perl, Python, and R, Ruby has its own build system for
 installing Ruby gems.
@@ -16,7 +16,7 @@ installing Ruby gems.
 Phases
 ^^^^^^
 
-The ``RubyBuilder`` and ``RubyPackage`` base classes provide the following phases that
+The ``RubyPackage`` base class provides the following phases that
 can be overridden:
 
 #. ``build`` - build everything needed to install

lib/spack/docs/build_systems/sconspackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _sconspackage:
 
------
-SCons
------
+------------
+SConsPackage
+------------
 
 SCons is a general-purpose build system that does not rely on
 Makefiles to build software. SCons is written in Python, and handles
@@ -42,7 +42,7 @@ As previously mentioned, SCons allows developers to add subcommands like
    $ scons install
 
 
-To facilitate this, the ``SConsBuilder`` and ``SconsPackage`` base classes provide the
+To facilitate this, the ``SConsPackage`` base class provides the
 following phases:
 
 #. ``build`` - build the package

lib/spack/docs/build_systems/sippackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _sippackage:
 
----
-SIP
----
+----------
+SIPPackage
+----------
 
 SIP is a tool that makes it very easy to create Python bindings for C and C++
 libraries. It was originally developed to create PyQt, the Python bindings for
@@ -22,7 +22,7 @@ provides support functions to the automatically generated code.
 Phases
 ^^^^^^
 
-The ``SIPBuilder`` and ``SIPPackage`` base classes come with the following phases:
+The ``SIPPackage`` base class comes with the following phases:
 
 #. ``configure`` - configure the package
 #. ``build`` - build the package

lib/spack/docs/build_systems/sourceforgepackage.rst

@@ -1,19 +1,19 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _sourceforgepackage:
 
------------
-Sourceforge
------------
+------------------
+SourceforgePackage
+------------------
 
-``SourceforgePackage`` is a
+``SourceforgePackage`` is a 
 `mixin-class <https://en.wikipedia.org/wiki/Mixin>`_. It automatically
 sets the URL based on a list of Sourceforge mirrors listed in
 `sourceforge_mirror_path`, which defaults to a half dozen known mirrors.
-Refer to the package source
+Refer to the package source 
 (`<https://github.com/spack/spack/blob/develop/lib/spack/spack/build_systems/sourceforge.py>`__) for the current list of mirrors used by Spack.
 
 
@@ -29,7 +29,7 @@ This package provides a method for populating mirror URLs.
     It is decorated with `property` so its results are treated as
     a package attribute.
 
-    Refer to
+    Refer to 
     `<https://spack.readthedocs.io/en/latest/packaging_guide.html#mirrors-of-the-main-url>`__
     for information on how Spack uses the `urls` attribute during
     fetching.

lib/spack/docs/build_systems/wafpackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _wafpackage:
 
----
-Waf
----
+----------
+WafPackage
+----------
 
 Like SCons, Waf is a general-purpose build system that does not rely
 on Makefiles to build software.
@@ -16,7 +16,7 @@ on Makefiles to build software.
 Phases
 ^^^^^^
 
-The ``WafBuilder`` and ``WafPackage`` base classes come with the following phases:
+The ``WafPackage`` base class comes with the following phases:
 
 #. ``configure`` - configure the project
 #. ``build`` - build the project
@@ -58,7 +58,9 @@ Testing
 ``WafPackage`` also provides ``test`` and ``installtest`` methods,
 which are run after the ``build`` and ``install`` phases, respectively.
 By default, these phases do nothing, but you can override them to
-run package-specific unit tests.
+run package-specific unit tests. For example, the
+`py-py2cairo <https://github.com/spack/spack/blob/develop/var/spack/repos/builtin/packages/py-py2cairo/package.py>`_
+package uses:
 
 .. code-block:: python
 

lib/spack/docs/chain.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)

lib/spack/docs/conf.py

@@ -1,4 +1,4 @@
-# Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+# Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -32,36 +32,37 @@
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
-link_name = os.path.abspath("_spack_root")
-if not os.path.exists(link_name):
-    os.symlink(os.path.abspath("../../.."), link_name, target_is_directory=True)
-sys.path.insert(0, os.path.abspath("_spack_root/lib/spack/external"))
-sys.path.insert(0, os.path.abspath("_spack_root/lib/spack/external/_vendoring"))
-sys.path.append(os.path.abspath("_spack_root/lib/spack/"))
+sys.path.insert(0, os.path.abspath('_spack_root/lib/spack/external'))
+sys.path.insert(0, os.path.abspath('_spack_root/lib/spack/external/pytest-fallback'))
+
+if sys.version_info[0] < 3:
+    sys.path.insert(
+        0, os.path.abspath('_spack_root/lib/spack/external/yaml/lib'))
+else:
+    sys.path.insert(
+        0, os.path.abspath('_spack_root/lib/spack/external/yaml/lib3'))
+
+sys.path.append(os.path.abspath('_spack_root/lib/spack/'))
 
 # Add the Spack bin directory to the path so that we can use its output in docs.
-os.environ["SPACK_ROOT"] = os.path.abspath("_spack_root")
-os.environ["PATH"] += "%s%s" % (os.pathsep, os.path.abspath("_spack_root/bin"))
+os.environ['SPACK_ROOT'] = os.path.abspath('_spack_root')
+os.environ['PATH'] += "%s%s" % (os.pathsep, os.path.abspath('_spack_root/bin'))
 
 # Set an environment variable so that colify will print output like it would to
 # a terminal.
-os.environ["COLIFY_SIZE"] = "25x120"
-os.environ["COLUMNS"] = "120"
+os.environ['COLIFY_SIZE'] = '25x120'
+os.environ['COLUMNS'] = '120'
 
 # Generate full package list if needed
-subprocess.call(["spack", "list", "--format=html", "--update=package_list.html"])
+subprocess.call([
+    'spack', 'list', '--format=html', '--update=package_list.html'])
 
 # Generate a command index if an update is needed
-subprocess.call(
-    [
-        "spack",
-        "commands",
-        "--format=rst",
-        "--header=command_index.in",
-        "--update=command_index.rst",
-    ]
-    + glob("*rst")
-)
+subprocess.call([
+    'spack', 'commands',
+    '--format=rst',
+    '--header=command_index.in',
+    '--update=command_index.rst'] + glob('*rst'))
 
 #
 # Run sphinx-apidoc
@@ -71,36 +72,25 @@
 # Without this, the API Docs will never actually update
 #
 apidoc_args = [
-    "--force",  # Overwrite existing files
-    "--no-toc",  # Don't create a table of contents file
-    "--output-dir=.",  # Directory to place all output
-    "--module-first",  # emit module docs before submodule docs
+    '--force',         # Overwrite existing files
+    '--no-toc',        # Don't create a table of contents file
+    '--output-dir=.',  # Directory to place all output
 ]
-sphinx_apidoc(
-    apidoc_args
-    + [
-        "_spack_root/lib/spack/spack",
-        "_spack_root/lib/spack/spack/test/*.py",
-        "_spack_root/lib/spack/spack/test/cmd/*.py",
-    ]
-)
-sphinx_apidoc(apidoc_args + ["_spack_root/lib/spack/llnl"])
+sphinx_apidoc(apidoc_args + ['_spack_root/lib/spack/spack'])
+sphinx_apidoc(apidoc_args + ['_spack_root/lib/spack/llnl'])
 
 # Enable todo items
 todo_include_todos = True
 
-
 #
 # Disable duplicate cross-reference warnings.
 #
 class PatchedPythonDomain(PythonDomain):
     def resolve_xref(self, env, fromdocname, builder, typ, target, node, contnode):
-        if "refspecific" in node:
-            del node["refspecific"]
+        if 'refspecific' in node:
+            del node['refspecific']
         return super(PatchedPythonDomain, self).resolve_xref(
-            env, fromdocname, builder, typ, target, node, contnode
-        )
-
+            env, fromdocname, builder, typ, target, node, contnode)
 
 #
 # Disable tabs to space expansion in code blocks
@@ -113,57 +103,51 @@ def parse(self, inputstring, document):
             inputstring = StringList(lines, document.current_source)
         super().parse(inputstring, document)
 
-
 def setup(sphinx):
     sphinx.add_domain(PatchedPythonDomain, override=True)
     sphinx.add_source_parser(NoTabExpansionRSTParser, override=True)
 
-
 # -- General configuration -----------------------------------------------------
 
 # If your documentation needs a minimal Sphinx version, state it here.
-needs_sphinx = "3.4"
+needs_sphinx = '3.4'
 
 # Add any Sphinx extension module names here, as strings. They can be extensions
 # coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
 extensions = [
-    "sphinx.ext.autodoc",
-    "sphinx.ext.graphviz",
-    "sphinx.ext.intersphinx",
-    "sphinx.ext.napoleon",
-    "sphinx.ext.todo",
-    "sphinx.ext.viewcode",
-    "sphinx_design",
-    "sphinxcontrib.programoutput",
+    'sphinx.ext.autodoc',
+    'sphinx.ext.graphviz',
+    'sphinx.ext.intersphinx',
+    'sphinx.ext.napoleon',
+    'sphinx.ext.todo',
+    'sphinx.ext.viewcode',
+    'sphinxcontrib.programoutput',
 ]
 
 # Set default graphviz options
 graphviz_dot_args = [
-    "-Grankdir=LR",
-    "-Gbgcolor=transparent",
-    "-Nshape=box",
-    "-Nfontname=monaco",
-    "-Nfontsize=10",
-]
+    '-Grankdir=LR', '-Gbgcolor=transparent',
+    '-Nshape=box', '-Nfontname=monaco', '-Nfontsize=10']
 
 # Get nice vector graphics
 graphviz_output_format = "svg"
 
+
 # Add any paths that contain templates here, relative to this directory.
-templates_path = ["_templates"]
+templates_path = ['_templates']
 
 # The suffix of source filenames.
-source_suffix = ".rst"
+source_suffix = '.rst'
 
 # The encoding of source files.
-source_encoding = "utf-8-sig"
+source_encoding = 'utf-8-sig'
 
 # The master toctree document.
-master_doc = "index"
+master_doc = 'index'
 
 # General information about the project.
-project = "Spack"
-copyright = "2013-2023, Lawrence Livermore National Laboratory."
+project = u'Spack'
+copyright = u'2013-2021, Lawrence Livermore National Laboratory.'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
@@ -172,16 +156,16 @@ def setup(sphinx):
 # The short X.Y version.
 import spack
 
-version = ".".join(str(s) for s in spack.spack_version_info[:2])
+version = '.'.join(str(s) for s in spack.spack_version_info[:2])
 # The full version, including alpha/beta/rc tags.
 release = spack.spack_version
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
-# language = None
+#language = None
 
 # Places to look for .po/.mo files for doc translations
-# locale_dirs = []
+#locale_dirs = []
 
 # Sphinx gettext settings
 gettext_compact = True
@@ -189,179 +173,201 @@ def setup(sphinx):
 
 # There are two options for replacing |today|: either, you set today to some
 # non-false value, then it is used:
-# today = ''
+#today = ''
 # Else, today_fmt is used as the format for a strftime call.
-# today_fmt = '%B %d, %Y'
+#today_fmt = '%B %d, %Y'
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
-exclude_patterns = ["_build", "_spack_root", ".spack-env"]
+exclude_patterns = ['_build', '_spack_root', '.spack-env']
 
 nitpicky = True
 nitpick_ignore = [
     # Python classes that intersphinx is unable to resolve
-    ("py:class", "argparse.HelpFormatter"),
-    ("py:class", "contextlib.contextmanager"),
-    ("py:class", "module"),
-    ("py:class", "_io.BufferedReader"),
-    ("py:class", "unittest.case.TestCase"),
-    ("py:class", "_frozen_importlib_external.SourceFileLoader"),
-    ("py:class", "clingo.Control"),
-    ("py:class", "six.moves.urllib.parse.ParseResult"),
-    ("py:class", "TextIO"),
+    ('py:class', 'argparse.HelpFormatter'),
+    ('py:class', 'contextlib.contextmanager'),
+    ('py:class', 'module'),
+    ('py:class', '_io.BufferedReader'),
+    ('py:class', 'unittest.case.TestCase'),
+    ('py:class', '_frozen_importlib_external.SourceFileLoader'),
     # Spack classes that are private and we don't want to expose
-    ("py:class", "spack.provider_index._IndexBase"),
-    ("py:class", "spack.repo._PrependFileLoader"),
-    ("py:class", "spack.build_systems._checks.BaseBuilder"),
-    # Spack classes that intersphinx is unable to resolve
-    ("py:class", "spack.version.StandardVersion"),
-    ("py:class", "spack.spec.DependencySpec"),
-    ("py:class", "spack.install_test.Pb"),
+    ('py:class', 'spack.provider_index._IndexBase'),
+    ('py:class', 'spack.repo._PrependFileLoader'),
 ]
 
 # The reST default role (used for this markup: `text`) to use for all documents.
-# default_role = None
+#default_role = None
 
 # If true, '()' will be appended to :func: etc. cross-reference text.
-# add_function_parentheses = True
+#add_function_parentheses = True
 
 # If true, the current module name will be prepended to all description
 # unit titles (such as .. function::).
-# add_module_names = True
+#add_module_names = True
 
 # If true, sectionauthor and moduleauthor directives will be shown in the
 # output. They are ignored by default.
-# show_authors = False
-sys.path.append("./_pygments")
-pygments_style = "style.SpackStyle"
+#show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+# We use our own extension of the default style with a few modifications
+from pygments.style import Style
+from pygments.styles.default import DefaultStyle
+from pygments.token import Comment, Generic, Text
+
+
+class SpackStyle(DefaultStyle):
+    styles = DefaultStyle.styles.copy()
+    background_color       = "#f4f4f8"
+    styles[Generic.Output] = "#355"
+    styles[Generic.Prompt] = "bold #346ec9"
+
+import pkg_resources
+
+dist = pkg_resources.Distribution(__file__)
+sys.path.append('.')  # make 'conf' module findable
+ep = pkg_resources.EntryPoint.parse('spack = conf:SpackStyle', dist=dist)
+dist._ep_map = {'pygments.styles': {'plugin1': ep}}
+pkg_resources.working_set.add(dist)
+
+pygments_style = 'spack'
 
 # A list of ignored prefixes for module index sorting.
-# modindex_common_prefix = []
+#modindex_common_prefix = []
 
 
 # -- Options for HTML output ---------------------------------------------------
 
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
-html_theme = "sphinx_rtd_theme"
+html_theme = 'sphinx_rtd_theme'
 
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
 # documentation.
-html_theme_options = {"logo_only": True}
+html_theme_options = { 'logo_only' : True }
 
 # Add any paths that contain custom themes here, relative to this directory.
 # html_theme_path = ["_themes"]
 
 # The name for this set of Sphinx documents.  If None, it defaults to
 # "<project> v<release> documentation".
-# html_title = None
+#html_title = None
 
 # A shorter title for the navigation bar.  Default is the same as html_title.
-# html_short_title = None
+#html_short_title = None
 
 # The name of an image file (relative to this directory) to place at the top
 # of the sidebar.
-html_logo = "_spack_root/share/spack/logo/spack-logo-white-text.svg"
+html_logo = '_spack_root/share/spack/logo/spack-logo-white-text.svg'
 
 # The name of an image file (within the static path) to use as favicon of the
 # docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
 # pixels large.
-html_favicon = "_spack_root/share/spack/logo/favicon.ico"
+html_favicon = '_spack_root/share/spack/logo/favicon.ico'
 
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ["_static"]
+html_static_path = ['_static']
 
 # If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
 # using the given strftime format.
-html_last_updated_fmt = "%b %d, %Y"
+html_last_updated_fmt = '%b %d, %Y'
 
 # If true, SmartyPants will be used to convert quotes and dashes to
 # typographically correct entities.
-# html_use_smartypants = True
+#html_use_smartypants = True
 
 # Custom sidebar templates, maps document names to template names.
-# html_sidebars = {}
+#html_sidebars = {}
 
 # Additional templates that should be rendered to pages, maps page names to
 # template names.
-# html_additional_pages = {}
+#html_additional_pages = {}
 
 # If false, no module index is generated.
-# html_domain_indices = True
+#html_domain_indices = True
 
 # If false, no index is generated.
-# html_use_index = True
+#html_use_index = True
 
 # If true, the index is split into individual pages for each letter.
-# html_split_index = False
+#html_split_index = False
 
 # If true, links to the reST sources are added to the pages.
-# html_show_sourcelink = True
+#html_show_sourcelink = True
 
 # If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
-# html_show_sphinx = False
+#html_show_sphinx = False
 
 # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
-# html_show_copyright = True
+#html_show_copyright = True
 
 # If true, an OpenSearch description file will be output, and all pages will
 # contain a <link> tag referring to it.  The value of this option must be the
 # base URL from which the finished HTML is served.
-# html_use_opensearch = ''
+#html_use_opensearch = ''
 
 # This is the file name suffix for HTML files (e.g. ".xhtml").
-# html_file_suffix = None
+#html_file_suffix = None
 
 # Output file base name for HTML help builder.
-htmlhelp_basename = "Spackdoc"
+htmlhelp_basename = 'Spackdoc'
+
 
 # -- Options for LaTeX output --------------------------------------------------
 
 latex_elements = {
-    # The paper size ('letterpaper' or 'a4paper').
-    # 'papersize': 'letterpaper',
-    # The font size ('10pt', '11pt' or '12pt').
-    # 'pointsize': '10pt',
-    # Additional stuff for the LaTeX preamble.
-    # 'preamble': '',
+# The paper size ('letterpaper' or 'a4paper').
+#'papersize': 'letterpaper',
+
+# The font size ('10pt', '11pt' or '12pt').
+#'pointsize': '10pt',
+
+# Additional stuff for the LaTeX preamble.
+#'preamble': '',
 }
 
 # Grouping the document tree into LaTeX files. List of tuples
 # (source start file, target name, title, author, documentclass [howto/manual]).
-latex_documents = [("index", "Spack.tex", "Spack Documentation", "Todd Gamblin", "manual")]
+latex_documents = [
+  ('index', 'Spack.tex', u'Spack Documentation',
+   u'Todd Gamblin', 'manual'),
+]
 
 # The name of an image file (relative to this directory) to place at the top of
 # the title page.
-# latex_logo = None
+#latex_logo = None
 
 # For "manual" documents, if this is true, then toplevel headings are parts,
 # not chapters.
-# latex_use_parts = False
+#latex_use_parts = False
 
 # If true, show page references after internal links.
-# latex_show_pagerefs = False
+#latex_show_pagerefs = False
 
 # If true, show URL addresses after external links.
-# latex_show_urls = False
+#latex_show_urls = False
 
 # Documents to append as an appendix to all manuals.
-# latex_appendices = []
+#latex_appendices = []
 
 # If false, no module index is generated.
-# latex_domain_indices = True
+#latex_domain_indices = True
 
 
 # -- Options for manual page output --------------------------------------------
 
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
-man_pages = [("index", "spack", "Spack Documentation", ["Todd Gamblin"], 1)]
+man_pages = [
+    ('index', 'spack', u'Spack Documentation',
+     [u'Todd Gamblin'], 1)
+]
 
 # If true, show URL addresses after external links.
-# man_show_urls = False
+#man_show_urls = False
 
 
 # -- Options for Texinfo output ------------------------------------------------
@@ -370,28 +376,24 @@ def setup(sphinx):
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-    (
-        "index",
-        "Spack",
-        "Spack Documentation",
-        "Todd Gamblin",
-        "Spack",
-        "One line description of project.",
-        "Miscellaneous",
-    )
+  ('index', 'Spack', u'Spack Documentation',
+   u'Todd Gamblin', 'Spack', 'One line description of project.',
+   'Miscellaneous'),
 ]
 
 # Documents to append as an appendix to all manuals.
-# texinfo_appendices = []
+#texinfo_appendices = []
 
 # If false, no module index is generated.
-# texinfo_domain_indices = True
+#texinfo_domain_indices = True
 
 # How to display URL addresses: 'footnote', 'no', or 'inline'.
-# texinfo_show_urls = 'footnote'
+#texinfo_show_urls = 'footnote'
 
 
 # -- Extension configuration -------------------------------------------------
 
 # sphinx.ext.intersphinx
-intersphinx_mapping = {"python": ("https://docs.python.org/3", None)}
+intersphinx_mapping = {
+    "python": ("https://docs.python.org/3", None),
+}

lib/spack/docs/config_yaml.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -19,9 +19,9 @@ see the default settings by looking at
 These settings can be overridden in ``etc/spack/config.yaml`` or
 ``~/.spack/config.yaml``.  See :ref:`configuration-scopes` for details.
 
----------------------
-``install_tree:root``
----------------------
+--------------------
+``install_tree``
+--------------------
 
 The location where Spack will install packages and their dependencies.
 Default is ``$spack/opt/spack``.
@@ -222,11 +222,11 @@ and location. (See the *Configuration settings* section of ``man
 ccache`` to learn more about the default settings and how to change
 them). Please note that we currently disable ccache's ``hash_dir``
 feature to avoid an issue with the stage directory (see
-https://github.com/spack/spack/pull/3761#issuecomment-294352232).
+https://github.com/LLNL/spack/pull/3761#issuecomment-294352232).
 
------------------------
-``shared_linking:type``
------------------------
+------------------
+``shared_linking``
+------------------
 
 Control whether Spack embeds ``RPATH`` or ``RUNPATH`` attributes in ELF binaries
 so that they can find their dependencies. Has no effect on macOS.
@@ -245,52 +245,6 @@ the loading object.
 
 DO NOT MIX the two options within the same install tree.
 
------------------------
-``shared_linking:bind``
------------------------
-
-This is an *experimental option* that controls whether Spack embeds absolute paths
-to needed shared libraries in ELF executables and shared libraries on Linux. Setting
-this option to ``true`` has two advantages:
-
-1. **Improved startup time**: when running an executable, the dynamic loader does not
-   have to perform a search for needed libraries, they are loaded directly.
-2. **Reliability**: libraries loaded at runtime are those that were linked to. This
-   minimizes the risk of accidentally picking up system libraries.
-
-In the current implementation, Spack sets the soname (shared object name) of
-libraries to their install path upon installation. This has two implications:
-
-1. binding does not apply to libraries installed *before* the option was enabled;
-2. toggling the option off does *not* prevent binding of libraries installed when
-   the option was still enabled.
-
-It is also worth noting that:
-
-1. Applications relying on ``dlopen(3)`` will continue to work, even when they open
-   a library by name. This is because ``RPATH``\s are retained in binaries also
-   when ``bind`` is enabled.
-2. ``LD_PRELOAD`` continues to work for the typical use case of overriding
-   symbols, such as preloading a library with a more efficient ``malloc``.
-   However, the preloaded library will be loaded *additionally to*, instead of
-   *in place of* another library with the same name --- this can be problematic
-   in very rare cases where libraries rely on a particular ``init`` or ``fini``
-   order.
-
-.. note::
-
-   In some cases packages provide *stub libraries* that only contain an interface
-   for linking, but lack an implementation for runtime. An example of this is
-   ``libcuda.so``, provided by the CUDA toolkit; it can be used to link against,
-   but the library needed at runtime is the one installed with the CUDA driver.
-   To avoid binding those libraries, they can be marked as non-bindable using
-   a property in the package:
-
-   .. code-block:: python
-
-      class Example(Package):
-         non_bindable_shared_objects = ["libinterface.so"]
-
 ----------------------
 ``terminal_title``
 ----------------------

lib/spack/docs/configuration.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -20,9 +20,8 @@ case you want to skip directly to specific docs:
 * :ref:`packages.yaml <build-settings>`
 * :ref:`repos.yaml <repositories>`
 
-You can also add any of these as inline configuration in the YAML
-manifest file (``spack.yaml``) describing an :ref:`environment
-<environment-configuration>`.
+You can also add any of these as inline configuration in ``spack.yaml``
+in an :ref:`environment <environment-configuration>`.
 
 -----------
 YAML Format
@@ -228,9 +227,6 @@ You can get the name to use for ``<platform>`` by running ``spack arch
 --platform``. The system config scope has a ``<platform>`` section for
 sites at which ``/etc`` is mounted on multiple heterogeneous machines.
 
-
-.. _config-scope-precedence:
-
 ----------------
 Scope Precedence
 ----------------
@@ -243,11 +239,6 @@ lower-precedence settings. Completely ignoring higher-level configuration
 options is supported with the ``::`` notation for keys (see
 :ref:`config-overrides` below).
 
-There are also special notations for string concatenation and precendense override.
-Using the ``+:`` notation  can be used to force *prepending* strings or lists. For lists, this is identical
-to the default behavior. Using the ``-:`` works similarly, but for *appending* values.
-:ref:`config-prepend-append`
-
 ^^^^^^^^^^^
 Simple keys
 ^^^^^^^^^^^
@@ -288,47 +279,6 @@ command:
        - ~/.spack/stage
 
 
-.. _config-prepend-append:
-
-^^^^^^^^^^^^^^^^^^^^
-String Concatenation
-^^^^^^^^^^^^^^^^^^^^
-
-Above, the user ``config.yaml`` *completely* overrides specific settings in the
-default ``config.yaml``. Sometimes, it is useful to add a suffix/prefix
-to a path or name. To do this, you can use the ``-:`` notation for *append*
-string concatenation at the end of a key in a configuration file. For example:
-
-.. code-block:: yaml
-   :emphasize-lines: 1
-   :caption: ~/.spack/config.yaml
-
-   config:
-     install_tree-: /my/custom/suffix/
-
-Spack will then append to the lower-precedence configuration under the
-``install_tree-:`` section:
-
-.. code-block:: console
-
-   $ spack config get config
-   config:
-     install_tree: /some/other/directory/my/custom/suffix
-     build_stage:
-       - $tempdir/$user/spack-stage
-       - ~/.spack/stage
-
-
-Similarly, ``+:`` can be used to *prepend* to a path or name:
-
-.. code-block:: yaml
-   :emphasize-lines: 1
-   :caption: ~/.spack/config.yaml
-
-   config:
-     install_tree+: /my/custom/suffix/
-
-
 .. _config-overrides:
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -444,7 +394,7 @@ are indicated at the start of the path with ``~`` or ``~user``.
 Spack-specific variables
 ^^^^^^^^^^^^^^^^^^^^^^^^
 
-Spack understands over a dozen special variables. These are:
+Spack understands several special variables. These are:
 
 * ``$env``: name of the currently active :ref:`environment <environments>`
 * ``$spack``: path to the prefix of this Spack installation
@@ -455,19 +405,6 @@ Spack understands over a dozen special variables. These are:
 * ``$user``: name of the current user
 * ``$user_cache_path``: user cache directory (``~/.spack`` unless
   :ref:`overridden <local-config-overrides>`)
-* ``$architecture``: the architecture triple of the current host, as
-  detected by Spack.
-* ``$arch``: alias for ``$architecture``.
-* ``$platform``: the platform of the current host, as detected by Spack.
-* ``$operating_system``: the operating system of the current host, as
-  detected by the ``distro`` python module.
-* ``$os``: alias for ``$operating_system``.
-* ``$target``: the ISA target for the current host, as detected by
-  ArchSpec. E.g. ``skylake`` or ``neoverse-n1``.
-* ``$target_family``. The target family for the current host, as
-  detected by ArchSpec. E.g. ``x86_64`` or ``aarch64``.
-* ``$date``: the current date in the format YYYY-MM-DD
-
 
 Note that, as with shell variables, you can write these as ``$varname``
 or with braces to distinguish the variable from surrounding characters:
@@ -612,7 +549,7 @@ down the problem:
 
 You can see above that the ``build_jobs`` and ``debug`` settings are
 built in and are not overridden by a configuration file. The
-``verify_ssl`` setting comes from the ``--insecure`` option on the
+``verify_ssl`` setting comes from the ``--insceure`` option on the
 command line. ``dirty`` and ``install_tree`` come from the custom
 scopes ``./my-scope`` and ``./my-scope-2``, and all other configuration
 options come from the default configuration files that ship with Spack.

lib/spack/docs/containers.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -59,7 +59,7 @@ other techniques to minimize the size of the final image:
    &&   echo "  specs:" \
    &&   echo "  - gromacs+mpi" \
    &&   echo "  - mpich" \
-   &&   echo "  concretizer:" \
+   &&   echo "  concretizer: together" \
    &&   echo "    unify: true" \
    &&   echo "  config:" \
    &&   echo "    install_tree: /opt/software" \
@@ -444,120 +444,6 @@ attribute:
 The minimum version of Singularity required to build a SIF (Singularity Image Format)
 image from the recipes generated by Spack is ``3.5.3``.
 
-------------------------------
-Extending the Jinja2 Templates
-------------------------------
-
-The Dockerfile and the Singularity definition file that Spack can generate are based on
-a few Jinja2 templates that are rendered according to the environment being containerized.
-Even though Spack allows a great deal of customization by just setting appropriate values for
-the configuration options, sometimes that is not enough.
-
-In those cases, a user can directly extend the template that Spack uses to render the image
-to e.g. set additional environment variables or perform specific operations either before or
-after a given stage of the build. Let's consider as an example the following structure:
-
-.. code-block:: console
-
-   $ tree /opt/environment
-   /opt/environment
-   ├── data
-   │     └── data.csv
-   ├── spack.yaml
-   ├── data
-   └── templates
-       └── container
-           └── CustomDockerfile
-
-containing both the custom template extension and the environment manifest file. To use a custom
-template, the environment must register the directory containing it, and declare its use under the
-``container`` configuration:
-
-.. code-block:: yaml
-   :emphasize-lines: 7-8,12
-
-   spack:
-     specs:
-     - hdf5~mpi
-     concretizer:
-       unify: true
-     config:
-       template_dirs:
-       - /opt/environment/templates
-     container:
-       format: docker
-       depfile: true
-       template: container/CustomDockerfile
-
-The template extension can override two blocks, named ``build_stage`` and ``final_stage``, similarly to
-the example below:
-
-.. code-block::
-   :emphasize-lines: 3,8
-
-   {% extends "container/Dockerfile" %}
-   {% block build_stage %}
-   RUN echo "Start building"
-   {{ super() }}
-   {% endblock %}
-   {% block final_stage %}
-   {{ super() }}
-   COPY data /share/myapp/data
-   {% endblock %}
-
-The recipe that gets generated contains the two extra instruction that we added in our template extension:
-
-.. code-block:: Dockerfile
-   :emphasize-lines: 4,43
-
-   # Build stage with Spack pre-installed and ready to be used
-   FROM spack/ubuntu-jammy:latest as builder
-
-   RUN echo "Start building"
-
-   # 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 "  - hdf5~mpi" \
-   &&   echo "  concretizer:" \
-   &&   echo "    unify: true" \
-   &&   echo "  config:" \
-   &&   echo "    template_dirs:" \
-   &&   echo "    - /tmp/environment/templates" \
-   &&   echo "    install_tree: /opt/software" \
-   &&   echo "  view: /opt/view") > /opt/spack-environment/spack.yaml
-
-   # Install the software, remove unnecessary deps
-   RUN cd /opt/spack-environment && spack env activate . && spack concretize && spack env depfile -o Makefile && make -j $(nproc) && spack gc -y
-
-   # Strip all the binaries
-   RUN find -L /opt/view/* -type f -exec readlink -f '{}' \; | \
-       xargs file -i | \
-       grep 'charset=binary' | \
-       grep 'x-executable\|x-archive\|x-sharedlib' | \
-       awk -F: '{print $1}' | xargs strip -s
-
-   # Modifications to the environment that are necessary to run
-   RUN cd /opt/spack-environment && \
-       spack env activate --sh -d . >> /etc/profile.d/z10_spack_environment.sh
-
-   # Bare OS image to run the installed executables
-   FROM ubuntu:22.04
-
-   COPY --from=builder /opt/spack-environment /opt/spack-environment
-   COPY --from=builder /opt/software /opt/software
-   COPY --from=builder /opt/._view /opt/._view
-   COPY --from=builder /opt/view /opt/view
-   COPY --from=builder /etc/profile.d/z10_spack_environment.sh /etc/profile.d/z10_spack_environment.sh
-
-   COPY data /share/myapp/data
-
-   ENTRYPOINT ["/bin/bash", "--rcfile", "/etc/profile", "-l", "-c", "$*", "--" ]
-   CMD [ "/bin/bash" ]
-
-
 .. _container_config_options:
 
 -----------------------
@@ -578,10 +464,6 @@ to customize the generation of container recipes:
      - The format of the recipe
      - ``docker`` or ``singularity``
      - Yes
-   * - ``depfile``
-     - Whether to use a depfile for installation, or not
-     - True or False (default)
-     - No
    * - ``images:os``
      - Operating system used as a base for the image
      - See :ref:`containers-supported-os`
@@ -616,7 +498,7 @@ to customize the generation of container recipes:
      - No
    * - ``os_packages:command``
      - Tool used to manage system packages
-     - ``apt``, ``yum``, ``dnf``, ``dnf_epel``, ``zypper``, ``apk``, ``yum_amazon``
+     - ``apt``, ``yum``
      - Only with custom base images
    * - ``os_packages:update``
      - Whether or not to update the list of available packages
@@ -630,6 +512,14 @@ to customize the generation of container recipes:
      - System packages needed at run-time
      - Valid packages for the current OS
      - No
+   * - ``extra_instructions:build``
+     - Extra instructions (e.g. `RUN`, `COPY`, etc.) at the end of the ``build`` stage
+     - Anything understood by the current ``format``
+     - No
+   * - ``extra_instructions:final``
+     - Extra instructions (e.g. `RUN`, `COPY`, etc.) at the end of the ``final`` stage
+     - Anything understood by the current ``format``
+     - No
    * - ``labels``
      - Labels to tag the image
      - Pairs of key-value strings

lib/spack/docs/contribution_guide.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -71,7 +71,7 @@ locally to speed up the review process.
    new release that is causing problems. If this is the case, please file an issue.
 
 
-We currently test against Python 2.7 and 3.6-3.10 on both macOS and Linux and
+We currently test against Python 2.7 and 3.5-3.9 on both macOS and Linux and
 perform 3 types of tests:
 
 .. _cmd-spack-unit-test:
@@ -118,7 +118,7 @@ make another change, test that change, etc.  We use `pytest
 <http://pytest.org/>`_ as our tests framework, and these types of
 arguments are just passed to the ``pytest`` command underneath. See `the
 pytest docs
-<https://doc.pytest.org/en/latest/how-to/usage.html#specifying-which-tests-to-run>`_
+<http://doc.pytest.org/en/latest/usage.html#specifying-tests-selecting-tests>`_
 for more details on test selection syntax.
 
 ``spack unit-test`` has a few special options that can help you
@@ -147,7 +147,7 @@ you want to know about.  For example, to see just the tests in
 
 You can also combine any of these options with a ``pytest`` keyword
 search.  See the `pytest usage docs
-<https://doc.pytest.org/en/latest/how-to/usage.html#specifying-which-tests-to-run>`_
+<https://docs.pytest.org/en/stable/usage.html#specifying-tests-selecting-tests>`_:
 for more details on test selection syntax. For example, to see the names of all tests that have "spec"
 or "concretize" somewhere in their names:
 
@@ -253,6 +253,27 @@ to update them.
    multiple runs of ``spack style`` just to re-compute line numbers and
    makes it much easier to fix errors directly off of the CI output.
 
+.. warning::
+
+   Flake8 and ``pep8-naming`` require a number of dependencies in order
+   to run.  If you installed ``py-flake8`` and ``py-pep8-naming``, the
+   easiest way to ensure the right packages are on your ``PYTHONPATH`` is
+   to run::
+
+     spack activate py-flake8
+     spack activate pep8-naming
+
+   so that all of the dependencies are symlinked to a central
+   location. If you see an error message like:
+
+   .. code-block:: console
+
+      Traceback (most recent call last):
+        File: "/usr/bin/flake8", line 5, in <module>
+          from pkg_resources import load_entry_point
+      ImportError: No module named pkg_resources
+
+   that means Flake8 couldn't find setuptools in your ``PYTHONPATH``.
 
 ^^^^^^^^^^^^^^^^^^^
 Documentation Tests
@@ -288,9 +309,13 @@ All of these can be installed with Spack, e.g.
 
    .. code-block:: console
 
-      $ spack load py-sphinx py-sphinx-rtd-theme py-sphinxcontrib-programoutput
+      $ spack activate py-sphinx
+      $ spack activate py-sphinx-rtd-theme
+      $ spack activate py-sphinxcontrib-programoutput
 
-   so that all of the dependencies are added to PYTHONPATH.  If you see an error message
+   so that all of the dependencies are symlinked into that Python's
+   tree.  Alternatively, you could arrange for their library
+   directories to be added to PYTHONPATH.  If you see an error message
    like:
 
    .. code-block:: console

lib/spack/docs/developer_guide.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -149,9 +149,11 @@ grouped by functionality.
 Package-related modules
 ^^^^^^^^^^^^^^^^^^^^^^^
 
-:mod:`spack.package_base`
-  Contains the :class:`~spack.package_base.PackageBase` class, which
-  is the superclass for all packages in Spack.
+:mod:`spack.package`
+  Contains the :class:`~spack.package_base.Package` class, which
+  is the superclass for all packages in Spack.  Methods on ``Package``
+  implement all phases of the :ref:`package lifecycle
+  <package-lifecycle>` and manage the build process.
 
 :mod:`spack.util.naming`
   Contains functions for mapping between Spack package names,
@@ -175,11 +177,14 @@ Spec-related modules
 ^^^^^^^^^^^^^^^^^^^^
 
 :mod:`spack.spec`
-  Contains :class:`~spack.spec.Spec`. Also implements most of the logic for concretization
+  Contains :class:`~spack.spec.Spec` and :class:`~spack.spec.SpecParser`.
+  Also implements most of the logic for normalization and concretization
   of specs.
 
-:mod:`spack.parser`
-  Contains :class:`~spack.parser.SpecParser` and functions related to parsing specs.
+:mod:`spack.parse`
+  Contains some base classes for implementing simple recursive descent
+  parsers: :class:`~spack.parse.Parser` and :class:`~spack.parse.Lexer`.
+  Used by :class:`~spack.spec.SpecParser`.
 
 :mod:`spack.concretize`
   Contains :class:`~spack.concretize.Concretizer` implementation,
@@ -232,7 +237,7 @@ Spack Subcommands
 Unit tests
 ^^^^^^^^^^
 
-``spack.test``
+:mod:`spack.test`
   Implements Spack's test suite.  Add a module and put its name in
   the test suite in ``__init__.py`` to add more unit tests.
 
@@ -472,7 +477,7 @@ use my new hook as follows:
 .. code-block:: python
 
     def post_log_write(message, level):
-        """Do something custom with the message and level every time we write
+        """Do something custom with the messsage and level every time we write
         to the log
         """
         print('running post_log_write!')
@@ -960,13 +965,8 @@ completed, the steps to make the point release are:
 
       $ git checkout releases/v0.15
 
-#. If a pull request to the release branch named ``Backports vX.Y.Z`` is not already
-   in the project, create it. This pull request ought to be created as early as
-   possible when working on a release project, so that we can build the release
-   commits incrementally, and identify potential conflicts at an early stage.
-
 #. Cherry-pick each pull request in the ``Done`` column of the release
-   project board onto the ``Backports vX.Y.Z`` pull request.
+   project board onto the release branch.
 
    This is **usually** fairly simple since we squash the commits from the
    vast majority of pull requests. That means there is only one commit
@@ -991,7 +991,7 @@ completed, the steps to make the point release are:
 
       It is important to cherry-pick commits in the order they happened,
       otherwise you can get conflicts while cherry-picking. When
-      cherry-picking look at the merge date,
+      cherry-picking onto a point release, look at the merge date,
       **not** the number of the pull request or the date it was opened.
 
       Sometimes you may **still** get merge conflicts even if you have
@@ -1012,19 +1012,15 @@ completed, the steps to make the point release are:
          branch if neither of the above options makes sense, but this can
          require a lot of work. It's seldom the right choice.
 
-#. When all the commits from the project board are cherry-picked into
-   the ``Backports vX.Y.Z`` pull request, you can push a commit to:
+#. Bump the version in ``lib/spack/spack/__init__.py``.
 
-   1. Bump the version in ``lib/spack/spack/__init__.py``.
-   2. Update ``CHANGELOG.md`` with a list of the changes.
+#. Update ``CHANGELOG.md`` with a list of the changes.
 
    This is typically a summary of the commits you cherry-picked onto the
    release branch. See `the changelog from 0.14.1
    <https://github.com/spack/spack/commit/ff0abb9838121522321df2a054d18e54b566b44a>`_.
 
-#. Merge the ``Backports vX.Y.Z`` PR with the **Rebase and merge** strategy. This
-   is needed to keep track in the release branch of all the commits that were
-   cherry-picked.
+#. Push the release branch to GitHub.
 
 #. Make sure CI passes on the release branch, including:
 
@@ -1043,8 +1039,6 @@ completed, the steps to make the point release are:
 
 #. Follow the steps in :ref:`announcing-releases`.
 
-#. Submit a PR to update the CHANGELOG in the `develop` branch
-   with the addition of this point release.
 
 .. _publishing-releases:
 

lib/spack/docs/environments.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -58,9 +58,9 @@ Using Environments
 Here we follow a typical use case of creating, concretizing,
 installing and loading an environment.
 
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Creating a managed Environment
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Creating a named Environment
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 An environment is created by:
 
@@ -72,8 +72,7 @@ Spack then creates the directory ``var/spack/environments/myenv``.
 
 .. note::
 
-   All managed environments by default are stored in the ``var/spack/environments`` folder.
-   This location can be changed by setting the ``environments_root`` variable in ``config.yaml``.
+   All named environments are stored in the ``var/spack/environments`` folder.
 
 In the ``var/spack/environments/myenv`` directory, Spack creates the
 file ``spack.yaml`` and the hidden directory ``.spack-env``.
@@ -94,9 +93,9 @@ an Environment, the ``.spack-env`` directory also contains:
   * ``logs/``: A directory containing the build logs for the packages
     in this Environment.
 
-Spack Environments can also be created from either a manifest file
-(usually but not necessarily named, ``spack.yaml``) or a lockfile.
-To create an Environment from a manifest:
+Spack Environments can also be created from either a ``spack.yaml``
+manifest or a ``spack.lock`` lockfile. To create an Environment from a
+``spack.yaml`` manifest:
 
 .. code-block:: console
 
@@ -174,7 +173,7 @@ Anonymous specs can be created in place using the command:
 
    $ spack env create -d .
 
-In this case Spack simply creates a ``spack.yaml`` file in the requested
+In this case Spack simply creates a spack.yaml file in the requested
 directory.
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -234,8 +233,8 @@ packages will be listed as roots of the Environment.
 
 All of the Spack commands that act on the list of installed specs are
 Environment-sensitive in this way, including ``install``,
-``uninstall``, ``find``, ``extensions``, and more. In the
-:ref:`environment-configuration` section we will discuss
+``uninstall``, ``activate``, ``deactivate``, ``find``, ``extensions``,
+and more. In the :ref:`environment-configuration` section we will discuss
 Environment-sensitive commands further.
 
 ^^^^^^^^^^^^^^^^^^^^^
@@ -347,7 +346,7 @@ the Environment and then install the concretized specs.
    (see :ref:`build-jobs`). To speed up environment builds further, independent
    packages can be installed in parallel by launching more Spack instances. For
    example, the following will build at most four packages in parallel using
-   three background jobs:
+   three background jobs: 
 
    .. code-block:: console
 
@@ -377,30 +376,6 @@ from being added again.  At the same time, a spec that already exists in the
 environment, but only as a dependency, will be added to the environment as a
 root spec without the ``--no-add`` option.
 
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Developing Packages in a Spack Environment
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The ``spack develop`` command allows one to develop Spack packages in
-an environment. It requires a spec containing a concrete version, and
-will configure Spack to install the package from local source. By
-default, it will also clone the package to a subdirectory in the
-environment. This package will have a special variant ``dev_path``
-set, and Spack will ensure the package and its dependents are rebuilt
-any time the environment is installed if the package's local source
-code has been modified. Spack ensures that all instances of a
-developed package in the environment are concretized to match the
-version (and other constraints) passed as the spec argument to the
-``spack develop`` command.
-
-For packages with ``git`` attributes, git branches, tags, and commits can
-also be used as valid concrete versions (see :ref:`version-specifier`).
-This means that for a package ``foo``, ``spack develop foo@git.main`` will clone
-the ``main`` branch of the package, and ``spack install`` will install from
-that git clone if ``foo`` is in the environment.
-Further development on ``foo`` can be tested by reinstalling the environment,
-and eventually committed and pushed to the upstream git repo.
-
 ^^^^^^^
 Loading
 ^^^^^^^
@@ -479,21 +454,14 @@ them to the Environment.
    spack:
      include:
      - relative/path/to/config.yaml
-     - https://github.com/path/to/raw/config/compilers.yaml
      - /absolute/path/to/packages.yaml
 
-Environments can include files or URLs. File paths can be relative or
-absolute. URLs include the path to the text for individual files or
-can be the path to a directory containing configuration files.
-
-^^^^^^^^^^^^^^^^^^^^^^^^
-Configuration precedence
-^^^^^^^^^^^^^^^^^^^^^^^^
-
-Inline configurations take precedence over included configurations, so
-you don't have to change shared configuration files to make small changes
-to an individual environment. Included configurations listed earlier will
-have higher precedence, as the included configs are applied in reverse order.
+Environments can include files with either relative or absolute
+paths. Inline configurations take precedence over included
+configurations, so you don't have to change shared configuration files
+to make small changes to an individual Environment. Included configs
+listed earlier will have higher precedence, as the included configs are
+applied in reverse order.
 
 -------------------------------
 Manually Editing the Specs List
@@ -520,49 +488,8 @@ available from the yaml file.
 ^^^^^^^^^^^^^^^^^^^
 Spec concretization
 ^^^^^^^^^^^^^^^^^^^
-An environment can be concretized in three different modes and the behavior active under
-any environment is determined by the ``concretizer:unify`` configuration option.
-
-The *default* mode is to unify all specs:
-
-.. code-block:: yaml
-
-   spack:
-       specs:
-         - hdf5+mpi
-         - zlib@1.2.8
-       concretizer:
-         unify: true
-
-This means that any package in the environment corresponds to a single concrete spec. In
-the above example, when ``hdf5`` depends down the line of ``zlib``, it is required to
-take ``zlib@1.2.8`` instead of a newer version. This mode of concretization is
-particularly useful when environment views are used: if every package occurs in
-only one flavor, it is usually possible to merge all install directories into a view.
-
-A downside of unified concretization is that it can be overly strict. For example, a
-concretization error would happen when both ``hdf5+mpi`` and ``hdf5~mpi`` are specified
-in an environment.
-
-The second mode is to *unify when possible*: this makes concretization of root specs
-more independendent. Instead of requiring reuse of dependencies across different root
-specs, it is only maximized:
-
-.. code-block:: yaml
-
-   spack:
-       specs:
-         - hdf5~mpi
-         - hdf5+mpi
-         - zlib@1.2.8
-       concretizer:
-         unify: when_possible
-
-This means that both ``hdf5`` installations will use ``zlib@1.2.8`` as a dependency even
-if newer versions of that library are available.
-
-The third mode of operation is to concretize root specs entirely independently by
-disabling unified concretization:
+An environment can be concretized in three different modes and the behavior active under any environment
+is determined by the ``concretizer:unify`` property. By default specs are concretized *separately*, one after the other:
 
 .. code-block:: yaml
 
@@ -574,11 +501,45 @@ disabling unified concretization:
        concretizer:
          unify: false
 
-In this example ``hdf5`` is concretized separately, and does not consider ``zlib@1.2.8``
-as a constraint or preference. Instead, it will take the latest possible version.
+This mode of operation permits to deploy a full software stack where multiple configurations of the same package
+need to be installed alongside each other using the best possible selection of transitive dependencies. The downside
+is that redundancy of installations is disregarded completely, and thus environments might be more bloated than
+strictly needed. In the example above, for instance, if a version of ``zlib`` newer than ``1.2.8`` is known to Spack,
+then it will be used for both ``hdf5`` installations.
 
-The last two concretization options are typically useful for system administrators and
-user support groups providing a large software stack for their HPC center.
+If redundancy of the environment is a concern, Spack provides a way to install it *together where possible*,
+i.e. trying to maximize reuse of dependencies across different specs:
+
+.. code-block:: yaml
+
+   spack:
+       specs:
+         - hdf5~mpi
+         - hdf5+mpi
+         - zlib@1.2.8
+       concretizer:
+         unify: when_possible
+
+Also in this case Spack allows having multiple configurations of the same package, but privileges the reuse of
+specs over other factors. Going back to our example, this means that both ``hdf5`` installations will use
+``zlib@1.2.8`` as a dependency even if newer versions of that library are available.
+Central installations done at HPC centers by system administrators or user support groups are a common case
+that fits either of these two modes.
+
+Environments can also be configured to concretize all the root specs *together*, in a self-consistent way, to
+ensure that each package in the environment comes with a single configuration:
+
+.. code-block:: yaml
+
+   spack:
+       specs:
+         - hdf5+mpi
+         - zlib@1.2.8
+       concretizer:
+         unify: true
+
+This mode of operation is usually what is required by software developers that want to deploy their development
+environment and have a single view of it in the filesystem.
 
 .. note::
 
@@ -589,11 +550,10 @@ user support groups providing a large software stack for their HPC center.
 
 .. admonition:: Re-concretization of user specs
 
-   The ``spack concretize`` command without additional arguments will *not* change any
-   previously concretized specs. This may prevent it from finding a solution when using
-   ``unify: true``, and it may prevent it from finding a minimal solution when using
-   ``unify: when_possible``. You can force Spack to ignore the existing concrete environment
-   with ``spack concretize -f``.
+   When concretizing specs *together* or *together where possible* the entire set of specs will be
+   re-concretized after any addition of new user specs, to ensure that
+   the environment remains consistent / minimal. When instead the specs are concretized
+   separately only the new specs will be re-concretized after any addition.
 
 ^^^^^^^^^^^^^
 Spec Matrices
@@ -632,6 +592,31 @@ The following two Environment manifests are identical:
 Spec matrices can be used to install swaths of software across various
 toolchains.
 
+The concretization logic for spec matrices differs slightly from the
+rest of Spack. If a variant or dependency constraint from a matrix is
+invalid, Spack will reject the constraint and try again without
+it. For example, the following two Environment manifests will produce
+the same specs:
+
+.. code-block:: yaml
+
+   spack:
+     specs:
+       - matrix:
+           - [zlib, libelf, hdf5+mpi]
+           - [^mvapich2@2.2, ^openmpi@3.1.0]
+
+   spack:
+     specs:
+       - zlib
+       - libelf
+       - hdf5+mpi ^mvapich2@2.2
+       - hdf5+mpi ^openmpi@3.1.0
+
+This allows one to create toolchains out of combinations of
+constraints and apply them somewhat indiscriminately to packages,
+without regard for the applicability of the constraint.
+
 ^^^^^^^^^^^^^^^^^^^^
 Spec List References
 ^^^^^^^^^^^^^^^^^^^^
@@ -916,9 +901,9 @@ function, as shown in the example below:
 .. code-block:: yaml
 
    projections:
-     zlib: "{name}-{version}"
-     ^mpi: "{name}-{version}/{^mpi.name}-{^mpi.version}-{compiler.name}-{compiler.version}"
-     all: "{name}-{version}/{compiler.name}-{compiler.version}"
+     zlib: {name}-{version}
+     ^mpi: {name}-{version}/{^mpi.name}-{^mpi.version}-{compiler.name}-{compiler.version}
+     all: {name}-{version}/{compiler.name}-{compiler.version}
 
 The entries in the projections configuration file must all be either
 specs or the keyword ``all``. For each spec, the projection used will
@@ -963,6 +948,9 @@ Variable            Paths
 PATH                bin
 MANPATH             man, share/man
 ACLOCAL_PATH        share/aclocal
+LD_LIBRARY_PATH     lib, lib64
+LIBRARY_PATH        lib, lib64
+CPATH               include
 PKG_CONFIG_PATH     lib/pkgconfig, lib64/pkgconfig, share/pkgconfig
 CMAKE_PREFIX_PATH   .
 =================== =========
@@ -995,7 +983,7 @@ A typical workflow is as follows:
    spack env create -d .
    spack -e . add perl
    spack -e . concretize
-   spack -e . env depfile -o Makefile
+   spack -e . env depfile > Makefile
    make -j64
 
 This generates a ``Makefile`` from a concretized environment in the
@@ -1008,6 +996,7 @@ load, even when packages are built in parallel.
 By default the following phony convenience targets are available:
 
 - ``make all``: installs the environment (default target);
+- ``make fetch-all``: only fetch sources of all packages;
 - ``make clean``: cleans files used by make, but does not uninstall packages.
 
 .. tip::
@@ -1017,17 +1006,8 @@ By default the following phony convenience targets are available:
    printed orderly per package install. To get synchronized output with colors,
    use ``make -j<N> SPACK_COLOR=always --output-sync=recurse``.
 
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Specifying dependencies on generated ``make`` targets
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-An interesting question is how to include generated ``Makefile``\s in your own
-``Makefile``\s. This comes up when you want to install an environment that provides
-executables required in a command for a make target of your own.
-
-The example below shows how to accomplish this: the ``env`` target specifies
-the generated ``spack/env`` target as a prerequisite, meaning that the environment
-gets installed and is available for use in the ``env`` target.
+The following advanced example shows how generated targets can be used in a
+``Makefile``:
 
 .. code:: Makefile
 
@@ -1041,7 +1021,7 @@ gets installed and is available for use in the ``env`` target.
    	$(SPACK) -e . concretize -f
 
    env.mk: spack.lock
-   	$(SPACK) -e . env depfile -o $@ --make-prefix spack
+   	$(SPACK) -e . env depfile -o $@ --make-target-prefix spack
 
    env: spack/env
    	$(info Environment installed!)
@@ -1053,10 +1033,11 @@ gets installed and is available for use in the ``env`` target.
    include env.mk
    endif
 
-This works as follows: when ``make`` is invoked, it first "remakes" the missing
-include ``env.mk`` as there is a target for it. This triggers concretization of
-the environment and makes spack output ``env.mk``. At that point the
-generated target ``spack/env`` becomes available through ``include env.mk``.
+When ``make`` is invoked, it first "remakes" the missing include ``env.mk``
+from its rule, which triggers concretization. When done, the generated target
+``spack/env`` is available. In the above example, the ``env`` target uses this generated
+target as a prerequisite, meaning that it can make use of the installed packages in
+its commands.
 
 As it is typically undesirable to remake ``env.mk`` as part of ``make clean``,
 the include is conditional.
@@ -1064,79 +1045,6 @@ the include is conditional.
 .. note::
 
    When including generated ``Makefile``\s, it is important to use
-   the ``--make-prefix`` flag and use the non-phony target
-   ``<prefix>/env`` as prerequisite, instead of the phony target
-   ``<prefix>/all``.
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Building a subset of the environment
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The generated ``Makefile``\s contain install targets for each spec, identified
-by ``<name>-<version>-<hash>``. This allows you to install only a subset of the
-packages in the environment. When packages are unique in the environment, it's
-enough to know the name and let tab-completion fill out the version and hash.
-
-The following phony targets are available: ``install/<spec>`` to install the
-spec with its dependencies, and ``install-deps/<spec>`` to *only* install
-its dependencies. This can be useful when certain flags should only apply to
-dependencies. Below we show a use case where a spec is installed with verbose
-output (``spack install --verbose``) while its dependencies are installed silently:
-
-.. code:: console
-
-   $ spack env depfile -o Makefile
-
-   # Install dependencies in parallel, only show a log on error.
-   $ make -j16 install-deps/python-3.11.0-<hash> SPACK_INSTALL_FLAGS=--show-log-on-error
-
-   # Install the root spec with verbose output.
-   $ make -j16 install/python-3.11.0-<hash> SPACK_INSTALL_FLAGS=--verbose
-
-^^^^^^^^^^^^^^^^^^^^^^^^^
-Adding post-install hooks
-^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Another advanced use-case of generated ``Makefile``\s is running a post-install
-command for each package. These "hooks" could be anything from printing a
-post-install message, running tests, or pushing just-built binaries to a buildcache.
-
-This can be accomplished through the generated ``[<prefix>/]SPACK_PACKAGE_IDS``
-variable. Assuming we have an active and concrete environment, we generate the
-associated ``Makefile`` with a prefix ``example``:
-
-.. code:: console
-
-   $ spack env depfile -o env.mk --make-prefix example
-
-And we now include it in a different ``Makefile``, in which we create a target
-``example/push/%`` with ``%`` referring to a package identifier. This target
-depends on the particular package installation. In this target we automatically
-have the target-specific ``HASH`` and ``SPEC`` variables at our disposal. They
-are respectively the spec hash (excluding leading ``/``), and a human-readable spec.
-Finally, we have an entrypoint target ``push`` that will update the buildcache
-index once every package is pushed. Note how this target uses the generated
-``example/SPACK_PACKAGE_IDS`` variable to define its prerequisites.
-
-.. code:: Makefile
-
-   SPACK ?= spack
-   BUILDCACHE_DIR = $(CURDIR)/tarballs
-
-   .PHONY: all
-
-   all: push
-
-   include env.mk
-
-   example/push/%: example/install/%
-   	@mkdir -p $(dir $@)
-   	$(info About to push $(SPEC) to a buildcache)
-   	$(SPACK) -e . buildcache create --allow-root --only=package --directory $(BUILDCACHE_DIR) /$(HASH)
-   	@touch $@
-
-   push: $(addprefix example/push/,$(example/SPACK_PACKAGE_IDS))
-   	$(info Updating the buildcache index)
-   	$(SPACK) -e . buildcache update-index --directory $(BUILDCACHE_DIR)
-   	$(info Done!)
-   	@touch $@
+   the ``--make-target-prefix`` flag and use the non-phony target
+   ``<target-prefix>/env`` as prerequisite, instead of the phony target
+   ``<target-prefix>/all``.

lib/spack/docs/extensions.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)

lib/spack/docs/features.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -98,42 +98,40 @@ For example, this command:
 
 .. code-block:: console
 
-   $ spack create https://ftp.osuosl.org/pub/blfs/conglomeration/libelf/libelf-0.8.13.tar.gz
+   $ spack create http://www.mr511.de/software/libelf-0.8.13.tar.gz
 
 creates a simple python file:
 
 .. code-block:: python
 
-   from spack.package import *
+   from spack import *
 
 
-   class Libelf(AutotoolsPackage):
+   class Libelf(Package):
        """FIXME: Put a proper description of your package here."""
 
        # FIXME: Add a proper url for your package's homepage here.
-       homepage = "https://www.example.com"
-       url = "https://ftp.osuosl.org/pub/blfs/conglomeration/libelf/libelf-0.8.13.tar.gz"
+       homepage = "http://www.example.com"
+       url      = "http://www.mr511.de/software/libelf-0.8.13.tar.gz"
 
-       # FIXME: Add a list of GitHub accounts to
-       # notify when the package is updated.
-       # maintainers("github_user1", "github_user2")
-
-       version("0.8.13", sha256="591a9b4ec81c1f2042a97aa60564e0cb79d041c52faa7416acb38bc95bd2c76d")
+       version('0.8.13', '4136d7b4c04df68b686570afa26988ac')
 
        # FIXME: Add dependencies if required.
-       # depends_on("foo")
+       # depends_on('foo')
 
-       def configure_args(self):
-           # FIXME: Add arguments other than --prefix
-           # FIXME: If not needed delete this function
-           args = []
-           return args
+       def install(self, spec, prefix):
+           # FIXME: Modify the configure line to suit your build system here.
+           configure('--prefix={0}'.format(prefix))
+
+           # FIXME: Add logic to build and install here.
+           make()
+           make('install')
 
 It doesn't take much python coding to get from there to a working
 package:
 
 .. literalinclude:: _spack_root/var/spack/repos/builtin/packages/libelf/package.py
-   :lines: 5-
+   :lines: 6-
 
 Spack also provides wrapper functions around common commands like
 ``configure``, ``make``, and ``cmake`` to make writing packages

lib/spack/docs/getting_started.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -21,36 +21,10 @@ be present on the machine where Spack is run:
    :header-rows: 1
 
 These requirements can be easily installed on most modern Linux systems;
-on macOS, the Command Line Tools package is required, and a full XCode suite
-may be necessary for some packages such as Qt and apple-gl. Spack is designed
-to run on HPC platforms like Cray.  Not all packages should be expected
-to work on all platforms.
-
-A build matrix showing which packages are working on which systems is shown below.
-
-.. tab-set::
-
-   .. tab-item:: Debian/Ubuntu
-
-      .. code-block:: console
-
-         apt update
-         apt install build-essential ca-certificates coreutils curl environment-modules gfortran git gpg lsb-release python3 python3-distutils python3-venv unzip zip
-
-   .. tab-item:: RHEL
-
-      .. code-block:: console
-
-         dnf install epel-release
-         dnf group install "Development Tools"
-         dnf install curl findutils gcc-gfortran gnupg2 hostname iproute redhat-lsb-core python3 python3-pip python3-setuptools unzip python3-boto3
-
-   .. tab-item:: macOS Brew
-
-      .. code-block:: console
-
-         brew update
-         brew install curl gcc git gnupg zip
+on macOS, XCode is required.  Spack is designed to run on HPC
+platforms like Cray.  Not all packages should be expected
+to work on all platforms.  A build matrix showing which packages are
+working on which systems is planned but not yet available.
 
 ------------
 Installation
@@ -122,41 +96,88 @@ Spack provides two ways of bootstrapping ``clingo``: from pre-built binaries
 (default), or from sources. The fastest way to get started is to bootstrap from
 pre-built binaries.
 
-The first time you concretize a spec, Spack will bootstrap automatically:
+.. note::
+
+   When bootstrapping from pre-built binaries, Spack currently requires 
+   ``patchelf`` on Linux and ``otool`` on macOS. If ``patchelf`` is not in the
+   ``PATH``, Spack will build it from sources, and a C++ compiler is required.
+
+The first time you concretize a spec, Spack will bootstrap in the background:
 
 .. code-block:: console
 
-   $ spack spec zlib
-   ==> Bootstrapping clingo from pre-built binaries
-   ==> Fetching https://mirror.spack.io/bootstrap/github-actions/v0.4/build_cache/linux-centos7-x86_64-gcc-10.2.1-clingo-bootstrap-spack-ba5ijauisd3uuixtmactc36vps7yfsrl.spec.json
-   ==> Fetching https://mirror.spack.io/bootstrap/github-actions/v0.4/build_cache/linux-centos7-x86_64/gcc-10.2.1/clingo-bootstrap-spack/linux-centos7-x86_64-gcc-10.2.1-clingo-bootstrap-spack-ba5ijauisd3uuixtmactc36vps7yfsrl.spack
-   ==> Installing "clingo-bootstrap@spack%gcc@10.2.1~docs~ipo+python+static_libstdcpp build_type=Release arch=linux-centos7-x86_64" from a buildcache
-   ==> Bootstrapping patchelf from pre-built binaries
-   ==> Fetching https://mirror.spack.io/bootstrap/github-actions/v0.4/build_cache/linux-centos7-x86_64-gcc-10.2.1-patchelf-0.16.1-p72zyan5wrzuabtmzq7isa5mzyh6ahdp.spec.json
-   ==> Fetching https://mirror.spack.io/bootstrap/github-actions/v0.4/build_cache/linux-centos7-x86_64/gcc-10.2.1/patchelf-0.16.1/linux-centos7-x86_64-gcc-10.2.1-patchelf-0.16.1-p72zyan5wrzuabtmzq7isa5mzyh6ahdp.spack
-   ==> Installing "patchelf@0.16.1%gcc@10.2.1 ldflags="-static-libstdc++ -static-libgcc"  build_system=autotools arch=linux-centos7-x86_64" from a buildcache
+   $ time spack spec zlib
    Input spec
    --------------------------------
    zlib
 
    Concretized
    --------------------------------
-   zlib@1.2.13%gcc@9.4.0+optimize+pic+shared build_system=makefile arch=linux-ubuntu20.04-icelake
+   zlib@1.2.11%gcc@7.5.0+optimize+pic+shared arch=linux-ubuntu18.04-zen
 
-If for security concerns you cannot bootstrap ``clingo`` from pre-built
-binaries, you have to disable fetching the binaries we generated with Github Actions.
+   real	0m20.023s
+   user	0m18.351s
+   sys	0m0.784s
+
+After this command you'll see that ``clingo`` has been installed for Spack's own use:
 
 .. code-block:: console
 
-   $ spack bootstrap disable github-actions-v0.4
-   ==> "github-actions-v0.4" is now disabled and will not be used for bootstrapping
-   $ spack bootstrap disable github-actions-v0.3
-   ==> "github-actions-v0.3" is now disabled and will not be used for bootstrapping
+   $ spack find -b
+   ==> Showing internal bootstrap store at "/root/.spack/bootstrap/store"
+   ==> 3 installed packages
+   -- linux-rhel5-x86_64 / gcc@9.3.0 -------------------------------
+   clingo-bootstrap@spack  python@3.6
+
+   -- linux-ubuntu18.04-zen / gcc@7.5.0 ----------------------------
+   patchelf@0.13
+
+Subsequent calls to the concretizer will then be much faster:
+
+.. code-block:: console
+
+   $ time spack spec zlib
+   [ ... ]
+   real	0m0.490s
+   user	0m0.431s
+   sys	0m0.041s
+
+
+If for security concerns you cannot bootstrap ``clingo`` from pre-built
+binaries, you have to mark this bootstrapping method as untrusted. This makes
+Spack fall back to bootstrapping from sources:
+
+.. code-block:: console
+
+   $ spack bootstrap untrust github-actions-v0.2
+   ==> "github-actions-v0.2" is now untrusted and will not be used for bootstrapping
 
 You can verify that the new settings are effective with:
 
-.. command-output:: spack bootstrap list
+.. code-block:: console
 
+   $ spack bootstrap list
+   Name: github-actions-v0.2 UNTRUSTED
+
+     Type: buildcache
+
+     Info:
+       url: https://mirror.spack.io/bootstrap/github-actions/v0.2
+       homepage: https://github.com/spack/spack-bootstrap-mirrors
+       releases: https://github.com/spack/spack-bootstrap-mirrors/releases
+
+     Description:
+       Buildcache generated from a public workflow using Github Actions.
+       The sha256 checksum of binaries is checked before installation.
+
+   [ ... ]
+
+   Name: spack-install TRUSTED
+
+     Type: install
+
+     Description:
+       Specs built from sources by Spack. May take a long time.
 
 .. note::
 
@@ -186,7 +207,9 @@ under the ``${HOME}/.spack`` directory. The software installed there can be quer
 
 .. code-block:: console
 
-   $ spack -b find
+   $ spack find --bootstrap
+   ==> Showing internal bootstrap store at "/home/spack/.spack/bootstrap/store"
+   ==> 3 installed packages
    -- linux-ubuntu18.04-x86_64 / gcc@10.1.0 ------------------------
    clingo-bootstrap@spack  python@3.6.9  re2c@1.2.1
 
@@ -195,7 +218,7 @@ In case it's needed the bootstrap store can also be cleaned with:
 .. code-block:: console
 
    $ spack clean -b
-   ==> Removing bootstrapped software and configuration in "/home/spack/.spack/bootstrap"
+   ==> Removing software in "/home/spack/.spack/bootstrap/store"
 
 ^^^^^^^^^^^^^^^^^^
 Check Installation
@@ -365,8 +388,7 @@ Manual compiler configuration
 
 If auto-detection fails, you can manually configure a compiler by
 editing your ``~/.spack/<platform>/compilers.yaml`` file.  You can do this by running
-``spack config edit compilers``, which will open the file in
-:ref:`your favorite editor <controlling-the-editor>`.
+``spack config edit compilers``, which will open the file in your ``$EDITOR``.
 
 Each compiler configuration in the file looks like this:
 
@@ -1504,7 +1526,7 @@ Spack On Windows
 
 Windows support for Spack is currently under development. While this work is still in an early stage,
 it is currently possible to set up Spack and perform a few operations on Windows.  This section will guide
-you through the steps needed to install Spack and start running it on a fresh Windows machine.
+you through the steps needed to install Spack and start running it on a fresh Windows machine. 
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 Step 1: Install prerequisites
@@ -1514,7 +1536,7 @@ To use Spack on Windows, you will need the following packages:
 
 Required:
 * Microsoft Visual Studio
-* Python
+* Python 
 * Git
 
 Optional:
@@ -1545,8 +1567,8 @@ Intel Fortran
 """""""""""""
 
 For Fortran-based packages on Windows, we strongly recommend Intel's oneAPI Fortran compilers.
-The suite is free to download from Intel's website, located at
-https://software.intel.com/content/www/us/en/develop/tools/oneapi/components/fortran-compiler.html.
+The suite is free to download from Intel's website, located at 
+https://software.intel.com/content/www/us/en/develop/tools/oneapi/components/fortran-compiler.html#gs.70t5tw.
 The executable of choice for Spack will be Intel's Beta Compiler, ifx, which supports the classic
 compiler's (ifort's) frontend and runtime libraries by using LLVM.
 
@@ -1595,8 +1617,8 @@ in a Windows CMD prompt.
 
 .. note::
    If you chose to install Spack into a directory on Windows that is set up to require Administrative
-   Privileges, Spack will require elevated privileges to run.
-   Administrative Privileges can be denoted either by default such as
+   Privleges, Spack will require elevated privleges to run.
+   Administrative Privleges can be denoted either by default such as
    ``C:\Program Files``, or aministrator applied administrative restrictions
    on a directory that spack installs files to such as ``C:\Users``
 
@@ -1692,21 +1714,33 @@ Spack console via:
 
    spack install cpuinfo
 
-If in the previous step, you did not have CMake or Ninja installed, running the command above should bootstrap both packages
+If in the previous step, you did not have CMake or Ninja installed, running the command above should boostrap both packages
 
 """""""""""""""""""""""""""
 Windows Compatible Packages
 """""""""""""""""""""""""""
 
-Not all spack packages currently have Windows support. Some are inherently incompatible with the
-platform, and others simply have yet to be ported. To view the current set of packages with Windows
-support, the list command should be used via `spack list -t windows`. If there's a package you'd like
-to install on Windows but is not in that list, feel free to reach out to request the port or contribute
-the port yourself.
+Many Spack packages are not currently compatible with Windows, due to Unix
+dependencies or incompatible build tools like autoconf. Here are several
+packages known to work on Windows:
+
+* abseil-cpp
+* clingo
+* cpuinfo
+* cmake
+* glm
+* nasm
+* netlib-lapack (requires Intel Fortran)
+* ninja
+* openssl
+* perl
+* python
+* ruby
+* wrf
+* zlib
 
 .. note::
-   This is by no means a comprehensive list, some packages may have ports that were not tagged
-   while others may just work out of the box on Windows and have not been tagged as such.
+   This is by no means a comprehensive list
 
 ^^^^^^^^^^^^^^
 For developers
@@ -1718,4 +1752,3 @@ Instructions for creating the installer are at
 https://github.com/spack/spack/blob/develop/lib/spack/spack/cmd/installer/README.md
 
 Alternatively a pre-built copy of the Windows installer is available as an artifact of Spack's Windows CI
-available at each run of the CI on develop or any PR.

lib/spack/docs/index.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -67,6 +67,7 @@ or refer to the full manual below.
    build_settings
    environments
    containers
+   monitoring
    mirrors
    module_file_support
    repositories
@@ -77,6 +78,12 @@ or refer to the full manual below.
    extensions
    pipelines
 
+.. toctree::
+   :maxdepth: 2
+   :caption: Research
+
+   analyze
+
 .. toctree::
    :maxdepth: 2
    :caption: Contributing

lib/spack/docs/mirrors.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -163,7 +163,7 @@ your site.
 Mirror environment
 ^^^^^^^^^^^^^^^^^^
 
-To create a mirror of all packages required by a concrete environment, activate the environment and call ``spack mirror create -a``.
+To create a mirror of all packages required by a concerte environment, activate the environment and call ``spack mirror create -a``.
 This is especially useful to create a mirror of an environment concretized on another machine.
 
 .. code-block:: console

lib/spack/docs/module_file_support.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -13,7 +13,7 @@ The use of module systems to manage user environment in a controlled way
 is a common practice at HPC centers that is often embraced also by
 individual programmers on their development machines. To support this
 common practice Spack integrates with `Environment Modules
-<http://modules.sourceforge.net/>`_ and `Lmod
+<http://modules.sourceforge.net/>`_ and `LMod
 <http://lmod.readthedocs.io/en/latest/>`_ by providing post-install hooks
 that generate module files and commands to manipulate them.
 
@@ -26,8 +26,8 @@ Using module files via Spack
 ----------------------------
 
 If you have installed a supported module system you should be able to
-run ``module avail`` to see what module
-files have been installed. Here is sample output of those programs,
+run either ``module avail`` or ``use -l spack`` to see what module
+files have been installed.  Here is sample output of those programs,
 showing lots of installed packages:
 
 .. code-block:: console
@@ -51,7 +51,12 @@ showing lots of installed packages:
    help2man-1.47.4-gcc-4.8-kcnqmau     lua-luaposix-33.4.0-gcc-4.8-mdod2ry        netlib-scalapack-2.0.2-gcc-6.3.0-rgqfr6d    py-scipy-0.19.0-gcc-6.3.0-kr7nat4        zlib-1.2.11-gcc-6.3.0-7cqp6cj
 
 The names should look familiar, as they resemble the output from ``spack find``.
-For example, you could type the following command to load the ``cmake`` module:
+You *can* use the modules here directly.  For example, you could type either of these commands
+to load the ``cmake`` module:
+
+.. code-block:: console
+
+   $ use cmake-3.7.2-gcc-6.3.0-fowuuby
 
 .. code-block:: console
 
@@ -72,7 +77,7 @@ installation of a package.
 
    Spack only generates modulefiles when a package is installed. If
    you attempt to install a package and it is already installed, Spack
-   will not regenerate modulefiles for the package. This may lead to
+   will not regenerate modulefiles for the package. This may to
    inconsistent modulefiles if the Spack module configuration has
    changed since the package was installed, either by editing a file
    or changing scopes or environments.
@@ -88,9 +93,9 @@ the different file formats that can be generated by Spack:
   +-----------------------------+--------------------+-------------------------------+----------------------------------------------+----------------------+
   |                             | **Hook name**      |  **Default root directory**   | **Default template file**                    | **Compatible tools** |
   +=============================+====================+===============================+==============================================+======================+
-  |  **Tcl - Non-Hierarchical** | ``tcl``            |  share/spack/modules          | share/spack/templates/modules/modulefile.tcl | Env. Modules/Lmod    |
+  |  **TCL - Non-Hierarchical** | ``tcl``            |  share/spack/modules          | share/spack/templates/modules/modulefile.tcl | Env. Modules/LMod    |
   +-----------------------------+--------------------+-------------------------------+----------------------------------------------+----------------------+
-  |  **Lua - Hierarchical**     | ``lmod``           |  share/spack/lmod             | share/spack/templates/modules/modulefile.lua | Lmod                 |
+  |  **Lua - Hierarchical**     | ``lmod``           |  share/spack/lmod             | share/spack/templates/modules/modulefile.lua | LMod                 |
   +-----------------------------+--------------------+-------------------------------+----------------------------------------------+----------------------+
 
 
@@ -108,8 +113,6 @@ from language interpreters into their extensions. The latter two instead permit
 fine tune the filesystem layout, content and creation of module files to meet
 site specific conventions.
 
-.. _overide-api-calls-in-package-py:
-
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 Override API calls in ``package.py``
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -131,7 +134,7 @@ The second method:
        pass
 
 can instead inject run-time environment modifications in the module files of packages
-that depend on it. In both cases you need to fill ``env`` with the desired
+that depend on it. In both cases you need to fill ``run_env`` with the desired
 list of environment modifications.
 
 .. admonition:: The ``r`` package and callback APIs
@@ -391,13 +394,13 @@ name and version for all packages that depend on mpi.
 
 When specifying module names by projection for Lmod modules, we
 recommend NOT including names of dependencies (e.g., MPI, compilers)
-that are already in the Lmod hierarchy.
+that are already in the LMod hierarchy.
 
 
 
 .. note::
-   Tcl modules
-     Tcl modules also allow for explicit conflicts between modulefiles.
+   TCL modules
+     TCL modules also allow for explicit conflicts between modulefiles.
 
      .. code-block:: yaml
 
@@ -421,9 +424,9 @@ that are already in the Lmod hierarchy.
 
 
 .. note::
-   Lmod hierarchical module files
+   LMod hierarchical module files
      When ``lmod`` is activated Spack will generate a set of hierarchical lua module
-     files that are understood by Lmod. The hierarchy will always contain the
+     files that are understood by LMod. The hierarchy will always contain the
      two layers ``Core`` / ``Compiler`` but can be further extended to
      any of the virtual dependencies present in Spack. A case that could be useful in
      practice is for instance:
@@ -445,7 +448,7 @@ that are already in the Lmod hierarchy.
 
      that will generate a hierarchy in which the ``lapack`` and ``mpi`` layer can be switched
      independently. This allows a site to build the same libraries or applications against different
-     implementations of ``mpi`` and ``lapack``, and let Lmod switch safely from one to the
+     implementations of ``mpi`` and ``lapack``, and let LMod switch safely from one to the
      other.
 
      All packages built with a compiler in ``core_compilers`` and all
@@ -455,12 +458,12 @@ that are already in the Lmod hierarchy.
 .. warning::
   Consistency of Core packages
    The user is responsible for maintining consistency among core packages, as ``core_specs``
-   bypasses the hierarchy that allows Lmod to safely switch between coherent software stacks.
+   bypasses the hierarchy that allows LMod to safely switch between coherent software stacks.
 
 .. warning::
   Deep hierarchies and ``lmod spider``
    For hierarchies that are deeper than three layers ``lmod spider`` may have some issues.
-   See `this discussion on the Lmod project <https://github.com/TACC/Lmod/issues/114>`_.
+   See `this discussion on the LMod project <https://github.com/TACC/Lmod/issues/114>`_.
 
 """"""""""""""""""""""
 Select default modules
@@ -515,33 +518,18 @@ inspections and customize them per-module-set.
     prefix_inspections:
       bin:
         - PATH
-      man:
-        - MANPATH
+      lib:
+        - LIBRARY_PATH
       '':
         - CMAKE_PREFIX_PATH
 
 Prefix inspections are only applied if the relative path inside the
 installation prefix exists. In this case, for a Spack package ``foo``
 installed to ``/spack/prefix/foo``, if ``foo`` installs executables to
-``bin`` but no manpages in ``man``, the generated module file for
+``bin`` but no libraries in ``lib``, the generated module file for
 ``foo`` would update ``PATH`` to contain ``/spack/prefix/foo/bin`` and
 ``CMAKE_PREFIX_PATH`` to contain ``/spack/prefix/foo``, but would not
-update ``MANPATH``.
-
-The default list of environment variables in this config section
-includes ``PATH``, ``MANPATH``, ``ACLOCAL_PATH``, ``PKG_CONFIG_PATH``
-and ``CMAKE_PREFIX_PATH``, as well as ``DYLD_FALLBACK_LIBRARY_PATH``
-on macOS. On Linux however, the corresponding ``LD_LIBRARY_PATH``
-variable is *not* set, because it affects the behavior of
-system executables too.
-
-.. note::
-
-   In general, the ``LD_LIBRARY_PATH`` variable is not required
-   when using packages built with Spack, thanks to the use of RPATH.
-   Some packages may still need the variable, which is best handled
-   on a per-package basis instead of globally, as explained in
-   :ref:`overide-api-calls-in-package-py`.
+update ``LIBRARY_PATH``.
 
 There is a special case for prefix inspections relative to environment
 views. If all of the following conditions hold for a module set
@@ -629,9 +617,8 @@ by its dependency; when the dependency is autoloaded, the executable will be in
 PATH. Similarly for scripting languages such as Python, packages and their dependencies
 have to be loaded together.
 
-Autoloading is enabled by default for Lmod and Environment Modules. The former
-has builtin support for through the ``depends_on`` function. The latter uses
-``module load`` statement to load and track dependencies.
+Autoloading is enabled by default for LMod, as it has great builtin support for through
+the ``depends_on`` function. For Environment Modules it is disabled by default.
 
 Autoloading can also be enabled conditionally:
 
@@ -651,14 +638,12 @@ The allowed values for the ``autoload`` statement are either ``none``,
 ``direct`` or ``all``.
 
 .. note::
-  Tcl prerequisites
+  TCL prerequisites
      In the ``tcl`` section of the configuration file it is possible to use
      the ``prerequisites`` directive that accepts the same values as
      ``autoload``. It will produce module files that have a ``prereq``
-     statement, which autoloads dependencies on Environment Modules when its
-     ``auto_handling`` configuration option is enabled. If Environment Modules
-     is installed with Spack, ``auto_handling`` is enabled by default starting
-     version 4.2. Otherwise it is enabled by default since version 5.0.
+     statement, which can be used to autoload dependencies in some versions
+     of Environment Modules.
 
 ------------------------
 Maintaining Module Files

lib/spack/docs/monitoring.rst

@@ -0,0 +1,265 @@
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
+   Spack Project Developers. See the top-level COPYRIGHT file for details.
+
+   SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+.. _monitoring:
+
+==========
+Monitoring
+==========
+
+You can use a `spack monitor <https://github.com/spack/spack-monitor>`_ "Spackmon"
+server to store a database of your packages, builds, and associated metadata 
+for provenance, research, or some other kind of development. You should
+follow the instructions in the `spack monitor documentation <https://spack-monitor.readthedocs.org>`_
+to first create a server along with a username and token for yourself.
+You can then use this guide to interact with the server.
+
+-------------------
+Analysis Monitoring
+-------------------
+
+To read about how to monitor an analysis (meaning you want to send analysis results
+to a server) see :ref:`analyze_monitoring`.
+
+---------------------
+Monitoring An Install
+---------------------
+
+Since an install is typically when you build packages, we logically want
+to tell spack to monitor during this step. Let's start with an example
+where we want to monitor the install of hdf5. Unless you have disabled authentication
+for the server, we first want to export our spack monitor token and username to the environment:
+
+.. code-block:: console
+ 
+    $ export SPACKMON_TOKEN=50445263afd8f67e59bd79bff597836ee6c05438
+    $ export SPACKMON_USER=spacky
+
+
+By default, the host for your server is expected to be at ``http://127.0.0.1``
+with a prefix of ``ms1``, and if this is the case, you can simply add the
+``--monitor`` flag to the install command:
+
+.. code-block:: console
+
+    $ spack install --monitor hdf5
+
+
+If you need to customize the host or the prefix, you can do that as well:
+
+.. code-block:: console
+
+    $ spack install --monitor --monitor-prefix monitor --monitor-host https://monitor-service.io hdf5
+
+
+As a precaution, we cut out early in the spack client if you have not provided
+authentication credentials. For example, if you run the command above without
+exporting your username or token, you'll see:
+
+.. code-block:: console
+
+    ==> Error: You are required to export SPACKMON_TOKEN and SPACKMON_USER
+
+This extra check is to ensure that we don't start any builds,
+and then discover that you forgot to export your token. However, if 
+your monitoring server has authentication disabled, you can tell this to
+the client to skip this step:
+
+.. code-block:: console
+
+    $ spack install --monitor --monitor-disable-auth hdf5
+
+If the service is not running, you'll cleanly exit early - the install will
+not continue if you've asked it to monitor and there is no service.
+For example, here is what you'll see if the monitoring service is not running:
+
+.. code-block:: console
+
+    [Errno 111] Connection refused
+
+
+If you want to continue builds (and stop monitoring) you can set the ``--monitor-keep-going``
+flag. 
+
+.. code-block:: console
+
+    $ spack install --monitor --monitor-keep-going hdf5
+
+This could mean that if a request fails, you only have partial or no data
+added to your monitoring database. This setting will not be applied to the
+first request to check if the server is running, but to subsequent requests.
+If you don't have a monitor server running and you want to build, simply
+don't provide the ``--monitor`` flag! Finally, if you want to provide one or
+more tags to your build, you can do:
+
+.. code-block:: console
+
+    # Add one tag, "pizza"
+    $ spack install --monitor --monitor-tags pizza hdf5
+
+    # Add two tags, "pizza" and "pasta"
+    $ spack install --monitor --monitor-tags pizza,pasta hdf5
+
+
+----------------------------
+Monitoring with Containerize
+----------------------------
+
+The same argument group is available to add to a containerize command. 
+
+^^^^^^
+Docker
+^^^^^^
+
+To add monitoring to a Docker container recipe generation using the defaults,
+and assuming a monitor server running on localhost, you would
+start with a spack.yaml in your present working directory:
+
+.. code-block:: yaml
+
+   spack:
+     specs:
+       - samtools
+
+And then do:
+
+.. code-block:: console
+
+    # preview first
+    spack containerize --monitor
+    
+    # and then write to a Dockerfile
+    spack containerize --monitor > Dockerfile
+    
+    
+The install command will be edited to include commands for enabling monitoring.
+However, getting secrets into the container for your monitor server is something
+that should be done carefully. Specifically you should:
+
+ - Never try to define secrets as ENV, ARG, or using ``--build-arg``
+ - Do not try to get the secret into the container via a "temporary" file that you remove (it in fact will still exist in a layer)
+
+Instead, it's recommended to use buildkit `as explained here <https://pythonspeed.com/articles/docker-build-secrets/>`_.
+You'll need to again export environment variables for your spack monitor server:
+
+.. code-block:: console
+
+    $ export SPACKMON_TOKEN=50445263afd8f67e59bd79bff597836ee6c05438
+    $ export SPACKMON_USER=spacky
+
+And then use buildkit along with your build and identifying the name of the secret:
+
+.. code-block:: console
+
+    $ DOCKER_BUILDKIT=1 docker build --secret id=st,env=SPACKMON_TOKEN --secret id=su,env=SPACKMON_USER -t spack/container . 
+    
+The secrets are expected to come from your environment, and then will be temporarily mounted and available
+at ``/run/secrets/<name>``. If you forget to supply them (and authentication is required) the build
+will fail. If you need to build on your host (and interact with a spack monitor at localhost) you'll
+need to tell Docker to use the host network:
+
+.. code-block:: console
+
+    $ DOCKER_BUILDKIT=1 docker build --network="host" --secret id=st,env=SPACKMON_TOKEN --secret id=su,env=SPACKMON_USER -t spack/container . 
+    
+
+^^^^^^^^^^^
+Singularity
+^^^^^^^^^^^
+
+To add monitoring to a Singularity container build, the spack.yaml needs to
+be modified slightly to specify wanting a different format:
+
+
+.. code-block:: yaml
+
+   spack:
+     specs:
+       - samtools
+     container:
+       format: singularity
+       
+       
+Again, generate the recipe:
+
+
+.. code-block:: console
+
+    # preview first
+    $ spack containerize --monitor
+    
+    # then write to a Singularity recipe
+    $ spack containerize --monitor > Singularity
+
+
+Singularity doesn't have a direct way to define secrets at build time, so we have
+to do a bit of a manual command to add a file, source secrets in it, and remove it.
+Since Singularity doesn't have layers like Docker, deleting a file will truly
+remove it from the container and history. So let's say we have this file,
+``secrets.sh``:
+
+.. code-block:: console
+
+    # secrets.sh
+    export SPACKMON_USER=spack
+    export SPACKMON_TOKEN=50445263afd8f67e59bd79bff597836ee6c05438
+
+
+We would then generate the Singularity recipe, and add a files section,
+a source of that file at the start of ``%post``, and **importantly**
+a removal of the final at the end of that same section.
+
+.. code-block::
+
+    Bootstrap: docker
+    From: spack/ubuntu-bionic:latest
+    Stage: build
+
+    %files
+      secrets.sh /opt/secrets.sh 
+
+    %post
+      . /opt/secrets.sh
+
+      # spack install commands are here
+      ...
+      
+      # Don't forget to remove here!
+      rm /opt/secrets.sh
+
+
+You can then build the container as your normally would.
+
+.. code-block:: console
+
+    $ sudo singularity build container.sif Singularity 
+
+
+------------------
+Monitoring Offline
+------------------
+
+In the case that you want to save monitor results to your filesystem
+and then upload them later (perhaps you are in an environment where you don't
+have credentials or it isn't safe to use them) you can use the ``--monitor-save-local``
+flag.
+
+.. code-block:: console
+
+    $ spack install --monitor --monitor-save-local hdf5 
+
+This will save results in a subfolder, "monitor" in your designated spack
+reports folder, which defaults to ``$HOME/.spack/reports/monitor``. When
+you are ready to upload them to a spack monitor server:
+
+
+.. code-block:: console
+
+    $ spack monitor upload ~/.spack/reports/monitor 
+
+
+You can choose the root directory of results as shown above, or a specific
+subdirectory. The command accepts other arguments to specify configuration
+for the monitor.

lib/spack/docs/package_list.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)

lib/spack/docs/pipelines.rst

@@ -1,40 +1,35 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _pipelines:
 
-============
-CI Pipelines
-============
+=========
+Pipelines
+=========
 
-Spack provides commands that support generating and running automated build pipelines in CI instances.  At the highest
-level it works like this: provide a spack environment describing the set of packages you care about, and include a
-description of how those packages should be mapped to Gitlab runners.  Spack can then generate a ``.gitlab-ci.yml``
-file containing job descriptions for all your packages that can be run by a properly configured CI instance.  When
-run, the generated pipeline will build and deploy binaries, and it can optionally report to a CDash instance
+Spack provides commands that support generating and running automated build
+pipelines designed for Gitlab CI.  At the highest level it works like this:
+provide a spack environment describing the set of packages you care about,
+and include within that environment file a description of how those packages
+should be mapped to Gitlab runners.  Spack can then generate a ``.gitlab-ci.yml``
+file containing job descriptions for all your packages that can be run by a
+properly configured Gitlab CI instance.  When run, the generated pipeline will
+build and deploy binaries, and it can optionally report to a CDash instance
 regarding the health of the builds as they evolve over time.
 
 ------------------------------
 Getting started with pipelines
 ------------------------------
 
-To get started with automated build pipelines a Gitlab instance with version ``>= 12.9``
-(more about Gitlab CI `here <https://about.gitlab.com/product/continuous-integration/>`_)
-with at least one `runner <https://docs.gitlab.com/runner/>`_ configured is required. This
-can be done quickly by setting up a local Gitlab instance.
+It is fairly straightforward to get started with automated build pipelines.  At
+a minimum, you'll need to set up a Gitlab instance (more about Gitlab CI
+`here <https://about.gitlab.com/product/continuous-integration/>`_) and configure
+at least one `runner <https://docs.gitlab.com/runner/>`_.  Then the basic steps
+for setting up a build pipeline are as follows:
 
-It is possible to set up pipelines on gitlab.com, but the builds there are limited to
-60 minutes and generic hardware.  It is possible to
-`hook up <https://about.gitlab.com/blog/2018/04/24/getting-started-gitlab-ci-gcp>`_
-Gitlab to Google Kubernetes Engine (`GKE <https://cloud.google.com/kubernetes-engine/>`_)
-or Amazon Elastic Kubernetes Service (`EKS <https://aws.amazon.com/eks>`_), though those
-topics are outside the scope of this document.
-
-After setting up a Gitlab instance for running CI, the basic steps for setting up a build pipeline are as follows:
-
-#. Create a repository in the Gitlab instance with CI and a runner enabled.
+#. Create a repository on your gitlab instance
 #. Add a ``spack.yaml`` at the root containing your pipeline environment
 #. Add a ``.gitlab-ci.yml`` at the root containing two jobs (one to generate
    the pipeline dynamically, and one to run the generated jobs).
@@ -45,6 +40,13 @@ See the :ref:`functional_example` section for a minimal working example.  See al
 the :ref:`custom_Workflow` section for a link to an example of a custom workflow
 based on spack pipelines.
 
+While it is possible to set up pipelines on gitlab.com, as illustrated above, the
+builds there are limited to 60 minutes and generic hardware.  It is also possible to
+`hook up <https://about.gitlab.com/blog/2018/04/24/getting-started-gitlab-ci-gcp>`_
+Gitlab to Google Kubernetes Engine (`GKE <https://cloud.google.com/kubernetes-engine/>`_)
+or Amazon Elastic Kubernetes Service (`EKS <https://aws.amazon.com/eks>`_), though those
+topics are outside the scope of this document.
+
 Spack's pipelines are now making use of the
 `trigger <https://docs.gitlab.com/ee/ci/yaml/#trigger>`_ syntax to run
 dynamically generated
@@ -130,35 +132,29 @@ And here's the spack environment built by the pipeline represented as a
 
      mirrors: { "mirror": "s3://spack-public/mirror" }
 
-     ci:
+     gitlab-ci:
+       before_script:
+         - git clone ${SPACK_REPO}
+         - pushd spack && git checkout ${SPACK_CHECKOUT_VERSION} && popd
+         - . "./spack/share/spack/setup-env.sh"
+       script:
+         - pushd ${SPACK_CONCRETE_ENV_DIR} && spack env activate --without-view . && popd
+         - spack -d ci rebuild
+       mappings:
+         - match: ["os=ubuntu18.04"]
+           runner-attributes:
+             image:
+               name: ghcr.io/scottwittenburg/ecpe4s-ubuntu18.04-runner-x86_64:2020-09-01
+               entrypoint: [""]
+             tags:
+               - docker
        enable-artifacts-buildcache: True
        rebuild-index: False
-       pipeline-gen:
-       - any-job:
-           before_script:
-             - git clone ${SPACK_REPO}
-             - pushd spack && git checkout ${SPACK_CHECKOUT_VERSION} && popd
-             - . "./spack/share/spack/setup-env.sh"
-       - build-job:
-           tags: [docker]
-           image:
-             name: ghcr.io/scottwittenburg/ecpe4s-ubuntu18.04-runner-x86_64:2020-09-01
-             entrypoint: [""]
-
 
 The elements of this file important to spack ci pipelines are described in more
 detail below, but there are a couple of things to note about the above working
 example:
 
-.. note::
-   There is no ``script`` attribute specified for here. The reason for this is
-   Spack CI will automatically generate reasonable default scripts. More
-   detail on what is in these scripts can be found below.
-
-   Also notice the ``before_script`` section. It is required when using any of the
-   default scripts to source the ``setup-env.sh`` script in order to inform
-   the default scripts where to find the ``spack`` executable.
-
 Normally ``enable-artifacts-buildcache`` is not recommended in production as it
 results in large binary artifacts getting transferred back and forth between
 gitlab and the runners.  But in this example on gitlab.com where there is no
@@ -172,13 +168,13 @@ which specs are up to date and which need to be rebuilt (it's a good idea for ot
 reasons as well, but those are out of scope for this discussion).  In this case we
 have disabled it (using ``rebuild-index: False``) because the index would only be
 generated in the artifacts mirror anyway, and consequently would not be available
-during subsequent pipeline runs.
+during subesequent pipeline runs.
 
 .. note::
    With the addition of reproducible builds (#22887) a previously working
    pipeline will require some changes:
 
-   * In the build-jobs, the environment location changed.
+   * In the build jobs (``runner-attributes``), the environment location changed.
      This will typically show as a ``KeyError`` in the failing job. Be sure to
      point to ``${SPACK_CONCRETE_ENV_DIR}``.
 
@@ -200,9 +196,9 @@ ci pipelines.  These commands are covered in more detail in this section.
 
 .. _cmd-spack-ci:
 
-^^^^^^^^^^^^
+^^^^^^^^^^^^^^^^^^
 ``spack ci``
-^^^^^^^^^^^^
+^^^^^^^^^^^^^^^^^^
 
 Super-command for functionality related to generating pipelines and executing
 pipeline jobs.
@@ -231,7 +227,7 @@ Using ``--prune-dag`` or ``--no-prune-dag`` configures whether or not jobs are
 generated for specs that are already up to date on the mirror.   If enabling
 DAG pruning using ``--prune-dag``, more information may be required in your
 ``spack.yaml`` file, see the :ref:`noop_jobs` section below regarding
-``noop-job``.
+``service-job-attributes``.
 
 The optional ``--check-index-only`` argument can be used to speed up pipeline
 generation by telling spack to consider only remote buildcache indices when
@@ -267,70 +263,28 @@ generated by jobs in the pipeline.
 
 .. _cmd-spack-ci-rebuild:
 
-^^^^^^^^^^^^^^^^^^^^
+^^^^^^^^^^^^^^^^^^^^^
 ``spack ci rebuild``
-^^^^^^^^^^^^^^^^^^^^
+^^^^^^^^^^^^^^^^^^^^^
 
-The purpose of ``spack ci rebuild`` is to take an assigned
-spec and ensure a binary of a successful build exists on the target mirror.
-If the binary does not already exist, it is built from source and pushed
-to the mirror. The associated stand-alone tests are optionally run against
-the new build. Additionally, files for reproducing the build outside of the
-CI environment are created to facilitate debugging.
+The purpose of the ``spack ci rebuild`` is straightforward: take its assigned
+spec job, check whether the target mirror already has a binary for that spec,
+and if not, build the spec from source and push the binary to the mirror.  To
+accomplish this in a reproducible way, the sub-command prepares a ``spack install``
+command line to build a single spec in the DAG, saves that command in a
+shell script, ``install.sh``, in the current working directory, and then runs
+it to install the spec.  The shell script is also exported as an artifact to
+aid in reproducing the build outside of the CI environment.
 
-If a binary for the spec does not exist on the target mirror, an install
-shell script, ``install.sh``, is created and saved in the current working
-directory. The script is run in a job to install the spec from source. The
-resulting binary package is pushed to the mirror. If ``cdash`` is configured
-for the environment, then the build results will be uploaded to the site.
+If it was necessary to install the spec from source, ``spack ci rebuild`` will
+also subsequently create a binary package for the spec and try to push it to the
+mirror.
 
-Environment variables and values in the ``ci::pipeline-gen`` section of the
-``spack.yaml`` environment file provide inputs to this process. The
-two main sources of environment variables are variables written into
-``.gitlab-ci.yml`` by ``spack ci generate`` and the GitLab CI runtime.
-Several key CI pipeline variables are described in
-:ref:`ci_environment_variables`.
-
-If the ``--tests`` option is provided, stand-alone tests are performed but
-only if the build was successful *and* the package does not appear in the
-list of ``broken-tests-packages``. A shell script, ``test.sh``, is created
-and run to perform the tests. On completion, test logs are exported as job
-artifacts for review and to facilitate debugging. If `cdash` is configured,
-test results are also uploaded to the site.
-
-A snippet from an example ``spack.yaml`` file illustrating use of this
-option *and* specification of a package with broken tests is given below.
-The inclusion of a spec for building ``gptune`` is not shown here. Note
-that ``--tests`` is passed to ``spack ci rebuild`` as part of the
-``build-job`` script.
-
-.. code-block:: yaml
-
-  ci:
-    pipeline-gen:
-    - build-job
-        script:
-          - . "./share/spack/setup-env.sh"
-          - spack --version
-          - cd ${SPACK_CONCRETE_ENV_DIR}
-          - spack env activate --without-view .
-          - spack config add "config:install_tree:projections:${SPACK_JOB_SPEC_PKG_NAME}:'morepadding/{architecture}/{compiler.name}-{compiler.version}/{name}-{version}-{hash}'"
-           - mkdir -p ${SPACK_ARTIFACTS_ROOT}/user_data
-           - if [[ -r /mnt/key/intermediate_ci_signing_key.gpg ]]; then spack gpg trust /mnt/key/intermediate_ci_signing_key.gpg; fi
-           - if [[ -r /mnt/key/spack_public_key.gpg ]]; then spack gpg trust /mnt/key/spack_public_key.gpg; fi
-           - spack -d ci rebuild --tests > >(tee ${SPACK_ARTIFACTS_ROOT}/user_data/pipeline_out.txt) 2> >(tee ${SPACK_ARTIFACTS_ROOT}/user_data/pipeline_err.txt >&2)
-
-     broken-tests-packages:
-       - gptune
-
-In this case, even if ``gptune`` is successfully built from source, the
-pipeline will *not* run its stand-alone tests since the package is listed
-under ``broken-tests-packages``.
-
-Spack's cloud pipelines provide actual, up-to-date examples of the CI/CD
-configuration and environment files used by Spack. You can find them
-under Spack's `stacks
-<https://github.com/spack/spack/tree/develop/share/spack/gitlab/cloud_pipelines/stacks>`_ repository directory.
+The ``spack ci rebuild`` sub-command mainly expects its "input" to come either
+from environment variables or from the ``gitlab-ci`` section of the ``spack.yaml``
+environment file.  There are two main sources of the environment variables, some
+are written into ``.gitlab-ci.yml`` by ``spack ci generate``, and some are
+provided by the GitLab CI runtime.
 
 .. _cmd-spack-ci-rebuild-index:
 
@@ -360,31 +314,113 @@ arguments you can pass to ``spack ci reproduce-build`` in order to reproduce
 a particular build locally.
 
 ------------------------------------
-Job Types
+A pipeline-enabled spack environment
 ------------------------------------
 
-^^^^^^^^^^^^^^^
-Rebuild (build)
-^^^^^^^^^^^^^^^
+Here's an example of a spack environment file that has been enhanced with
+sections describing a build pipeline:
 
-Rebuild jobs, denoted as ``build-job``'s in the ``pipeline-gen`` list, are jobs
-associated with concrete specs that have been marked for rebuild. By default a simple
-script for doing rebuild is generated, but may be modified as needed.
+.. code-block:: yaml
 
-The default script does three main steps, change directories to the pipelines concrete
-environment, activate the concrete environment, and run the ``spack ci rebuild`` command:
+   spack:
+     definitions:
+     - pkgs:
+       - readline@7.0
+     - compilers:
+       - '%gcc@5.5.0'
+     - oses:
+       - os=ubuntu18.04
+       - os=centos7
+     specs:
+     - matrix:
+       - [$pkgs]
+       - [$compilers]
+       - [$oses]
+     mirrors:
+       cloud_gitlab: https://mirror.spack.io
+     gitlab-ci:
+       mappings:
+         - match:
+             - os=ubuntu18.04
+           runner-attributes:
+             tags:
+               - spack-kube
+             image: spack/ubuntu-bionic
+         - match:
+             - os=centos7
+           runner-attributes:
+             tags:
+               - spack-kube
+             image: spack/centos7
+     cdash:
+       build-group: Release Testing
+       url: https://cdash.spack.io
+       project: Spack
+       site: Spack AWS Gitlab Instance
 
-.. code-block:: bash
+Hopefully, the ``definitions``, ``specs``, ``mirrors``, etc. sections are already
+familiar, as they are part of spack :ref:`environments`.  So let's take a more
+in-depth look some of the pipeline-related sections in that environment file
+that might not be as familiar.
 
-  cd ${concrete_environment_dir}
-  spack env activate --without-view .
-  spack ci rebuild
+The ``gitlab-ci`` section is used to configure how the pipeline workload should be
+generated, mainly how the jobs for building specs should be assigned to the
+configured runners on your instance.  Each entry within the list of ``mappings``
+corresponds to a known gitlab runner, where the ``match`` section is used
+in assigning a release spec to one of the runners, and the ``runner-attributes``
+section is used to configure the spec/job for that particular runner.
+
+Both the top-level ``gitlab-ci`` section as well as each ``runner-attributes``
+section can also contain the following keys: ``image``, ``tags``, ``variables``,
+``before_script``, ``script``, and ``after_script``.  If any of these keys are
+provided at the ``gitlab-ci`` level, they will be used as the defaults for any
+``runner-attributes``, unless they are overridden in those sections.  Specifying
+any of these keys at the ``runner-attributes`` level generally overrides the
+keys specified at the higher level, with a couple exceptions.  Any ``variables``
+specified at both levels result in those dictionaries getting merged in the
+resulting generated job, and any duplicate variable names get assigned the value
+provided in the specific ``runner-attributes``.  If ``tags`` are specified both
+at the ``gitlab-ci`` level as well as the ``runner-attributes`` level, then the
+lists of tags are combined, and any duplicates are removed.
+
+See the section below on using a custom spack for an example of how these keys
+could be used.
+
+There are other pipeline options you can configure within the ``gitlab-ci`` section
+as well.
+
+The ``bootstrap`` section allows you to specify lists of specs from
+your ``definitions`` that should be staged ahead of the environment's ``specs`` (this
+section is described in more detail below).  The ``enable-artifacts-buildcache`` key
+takes a boolean and determines whether the pipeline uses artifacts to store and
+pass along the buildcaches from one stage to the next (the default if you don't
+provide this option is ``False``).
+
+The optional ``broken-specs-url`` key tells Spack to check against a list of
+specs that are known to be currently broken in ``develop``. If any such specs
+are found, the ``spack ci generate`` command will fail with an error message
+informing the user what broken specs were encountered. This allows the pipeline
+to fail early and avoid wasting compute resources attempting to build packages
+that will not succeed.
+
+The optional ``cdash`` section provides information that will be used by the
+``spack ci generate`` command (invoked by ``spack ci start``) for reporting
+to CDash.  All the jobs generated from this environment will belong to a
+"build group" within CDash that can be tracked over time.  As the release
+progresses, this build group may have jobs added or removed. The url, project,
+and site are used to specify the CDash instance to which build results should
+be reported.
+
+Take a look at the
+`schema <https://github.com/spack/spack/blob/develop/lib/spack/spack/schema/gitlab_ci.py>`_
+for the gitlab-ci section of the spack environment file, to see precisely what
+syntax is allowed there.
 
 .. _rebuild_index:
 
-^^^^^^^^^^^^^^^^^^^^^^
-Update Index (reindex)
-^^^^^^^^^^^^^^^^^^^^^^
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Note about rebuilding buildcache index
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 By default, while a pipeline job may rebuild a package, create a buildcache
 entry, and push it to the mirror, it does not automatically re-generate the
@@ -399,44 +435,21 @@ not correctly reflect the mirror's contents at the end of a pipeline.
 To make sure the buildcache index is up to date at the end of your pipeline,
 spack generates a job to update the buildcache index of the target mirror
 at the end of each pipeline by default.  You can disable this behavior by
-adding ``rebuild-index: False`` inside the ``ci`` section of your
-spack environment.
-
-Reindex jobs do not allow modifying the ``script`` attribute since it is automatically
-generated using the target mirror listed in the ``mirrors::mirror`` configuration.
-
-^^^^^^^^^^^^^^^^^
-Signing (signing)
-^^^^^^^^^^^^^^^^^
-
-This job is run after all of the rebuild jobs are completed and is intended to be used
-to sign the package binaries built by a protected CI run. Signing jobs are generated
-only if a signing job ``script`` is specified and the spack CI job type is protected.
-Note, if an ``any-job`` section contains a script, this will not implicitly create a
-``signing`` job, a signing job may only exist if it is explicitly specified in the
-configuration with a ``script`` attribute. Specifying a signing job without a script
-does not create a signing job and the job configuration attributes will be ignored.
-Signing jobs are always assigned the runner tags ``aws``, ``protected``, and ``notary``.
-
-^^^^^^^^^^^^^^^^^
-Cleanup (cleanup)
-^^^^^^^^^^^^^^^^^
-
-When using ``temporary-storage-url-prefix`` the cleanup job will destroy the mirror
-created for the associated Gitlab pipeline. Cleanup jobs do not allow modifying the
-script, but do expect that the spack command is in the path and require a
-``before_script`` to be specified that sources the ``setup-env.sh`` script.
+adding ``rebuild-index: False`` inside the ``gitlab-ci`` section of your
+spack environment.  Spack will assign the job any runner attributes found
+on the ``service-job-attributes``, if you have provided that in your
+``spack.yaml``.
 
 .. _noop_jobs:
 
-^^^^^^^^^^^^
-No Op (noop)
-^^^^^^^^^^^^
+^^^^^^^^^^^^^^^^^^^^^^^
+Note about "no-op" jobs
+^^^^^^^^^^^^^^^^^^^^^^^
 
 If no specs in an environment need to be rebuilt during a given pipeline run
-(meaning all are already up to date on the mirror), a single successful job
+(meaning all are already up to date on the mirror), a single succesful job
 (a NO-OP) is still generated to avoid an empty pipeline (which GitLab
-considers to be an error).  The ``noop-job*`` sections
+considers to be an error).  An optional ``service-job-attributes`` section
 can be added to your ``spack.yaml`` where you can provide ``tags`` and
 ``image`` or ``variables`` for the generated NO-OP job.  This section also
 supports providing ``before_script``, ``script``, and ``after_script``, in
@@ -446,100 +459,51 @@ Following is an example of this section added to a ``spack.yaml``:
 
 .. code-block:: yaml
 
-  spack:
-     ci:
-       pipeline-gen:
-       - noop-job:
-           tags: ['custom', 'tag']
-           image:
-             name: 'some.image.registry/custom-image:latest'
-             entrypoint: ['/bin/bash']
-           script::
-             - echo "Custom message in a custom script"
+   spack:
+     specs:
+       - openmpi
+     mirrors:
+       cloud_gitlab: https://mirror.spack.io
+     gitlab-ci:
+       mappings:
+         - match:
+             - os=centos8
+           runner-attributes:
+             tags:
+               - custom
+               - tag
+             image: spack/centos7
+       service-job-attributes:
+         tags: ['custom', 'tag']
+         image:
+           name: 'some.image.registry/custom-image:latest'
+           entrypoint: ['/bin/bash']
+         script:
+           - echo "Custom message in a custom script"
 
 The example above illustrates how you can provide the attributes used to run
 the NO-OP job in the case of an empty pipeline.  The only field for the NO-OP
 job that might be generated for you is ``script``, but that will only happen
-if you do not provide one yourself. Notice in this example the ``script``
-uses the ``::`` notation to prescribe override behavior. Without this, the
-``echo`` command would have been prepended to the automatically generated script
-rather than replacing it.
+if you do not provide one yourself.
 
-------------------------------------
-ci.yaml
-------------------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Assignment of specs to runners
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Here's an example of a spack configuration file describing a build pipeline:
+The ``mappings`` section corresponds to a list of runners, and during assignment
+of specs to runners, the list is traversed in order looking for matches, the
+first runner that matches a release spec is assigned to build that spec.  The
+``match`` section within each runner mapping section is a list of specs, and
+if any of those specs match the release spec (the ``spec.satisfies()`` method
+is used), then that runner is considered a match.
 
-.. code-block:: yaml
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Configuration of specs/jobs for a runner
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-  ci:
-    target: gitlab
-
-    rebuild_index: True
-
-    broken-specs-url: https://broken.specs.url
-
-    broken-tests-packages:
-    - gptune
-
-    pipeline-gen:
-    - submapping:
-      - match:
-          - os=ubuntu18.04
-        build-job:
-          tags:
-            - spack-kube
-          image: spack/ubuntu-bionic
-      - match:
-          - os=centos7
-        build-job:
-          tags:
-            - spack-kube
-          image: spack/centos7
-
-  cdash:
-    build-group: Release Testing
-    url: https://cdash.spack.io
-    project: Spack
-    site: Spack AWS Gitlab Instance
-
-The ``ci`` config section is used to configure how the pipeline workload should be
-generated, mainly how the jobs for building specs should be assigned to the
-configured runners on your instance. The main section for configuring pipelines
-is ``pipeline-gen``, which is a list of job attribute sections that are merged,
-using the same rules as Spack configs (:ref:`config-scope-precedence`), from the bottom up.
-The order sections are applied is to be consistent with how spack orders scope precedence when merging lists.
-There are two main section types, ``<type>-job`` sections and ``submapping``
-sections.
-
-
-^^^^^^^^^^^^^^^^^^^^^^
-Job Attribute Sections
-^^^^^^^^^^^^^^^^^^^^^^
-
-Each type of job may have attributes added or removed via sections in the ``pipeline-gen``
-list. Job type specific attributes may be specified using the keys ``<type>-job`` to
-add attributes to all jobs of type ``<type>`` or ``<type>-job-remove`` to remove attributes
-of type ``<type>``. Each section may only contain one type of job attribute specification, ie. ,
-``build-job`` and ``noop-job`` may not coexist but ``build-job`` and ``build-job-remove`` may.
-
-.. note::
-    The ``*-remove`` specifications are applied before the additive attribute specification.
-    For example, in the case where both ``build-job`` and ``build-job-remove`` are listed in
-    the same ``pipeline-gen`` section, the value will still exist in the merged build-job after
-    applying the section.
-
-All of the attributes specified are forwarded to the generated CI jobs, however special
-treatment is applied to the attributes ``tags``, ``image``, ``variables``, ``script``,
-``before_script``, and ``after_script`` as they are components recognized explicitly by the
-Spack CI generator. For the ``tags`` attribute, Spack will remove reserved tags
-(:ref:`reserved_tags`) from all jobs specified in the config. In some cases, such as for
-``signing`` jobs, reserved tags will be added back based on the type of CI that is being run.
-
-Once a runner has been chosen to build a release spec, the ``build-job*``
-sections provide information determining details of the job in the context of
-the runner.  At lease one of the ``build-job*`` sections must contain a ``tags`` key, which
+Once a runner has been chosen to build a release spec, the ``runner-attributes``
+section provides information determining details of the job in the context of
+the runner.  The ``runner-attributes`` section must have a ``tags`` key, which
 is a list containing at least one tag used to select the runner from among the
 runners known to the gitlab instance.  For Docker executor type runners, the
 ``image`` key is used to specify the Docker image used to build the release spec
@@ -550,7 +514,7 @@ information on to the runner that it needs to do its work (e.g. scheduler
 parameters, etc.).  Any ``variables`` provided here will be added, verbatim, to
 each job.
 
-The ``build-job`` section also allows users to supply custom ``script``,
+The ``runner-attributes`` section also allows users to supply custom ``script``,
 ``before_script``, and ``after_script`` sections to be applied to every job
 scheduled on that runner.  This allows users to do any custom preparation or
 cleanup tasks that fit their particular workflow, as well as completely
@@ -561,45 +525,46 @@ environment directory is located within your ``--artifacts_root`` (or if not
 provided, within your ``$CI_PROJECT_DIR``), activates that environment for
 you, and invokes ``spack ci rebuild``.
 
-Sections that specify scripts (``script``, ``before_script``, ``after_script``) are all
-read as lists of commands or lists of lists of commands. It is recommended to write scripts
-as lists of lists if scripts will be composed via merging. The default behavior of merging
-lists will remove duplicate commands and potentially apply unwanted reordering, whereas
-merging lists of lists will preserve the local ordering and never removes duplicate
-commands. When writing commands to the CI target script, all lists are expanded and
-flattened into a single list.
+.. _staging_algorithm:
 
-^^^^^^^^^^^^^^^^^^^
-Submapping Sections
-^^^^^^^^^^^^^^^^^^^
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Summary of ``.gitlab-ci.yml`` generation algorithm
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-A special case of attribute specification is the ``submapping`` section which may be used
-to apply job attributes to build jobs based on the package spec associated with the rebuild
-job. Submapping is specified as a list of spec ``match`` lists associated with
-``build-job``/``build-job-remove`` sections. There are two options for ``match_behavior``,
-either ``first`` or ``merge`` may be specified. In either case, the ``submapping`` list is
-processed from the bottom up, and then each ``match`` list is searched for a string that
-satisfies the check ``spec.satisfies({match_item})`` for each concrete spec.
+All specs yielded by the matrix (or all the specs in the environment) have their
+dependencies computed, and the entire resulting set of specs are staged together
+before being run through the ``gitlab-ci/mappings`` entries, where each staged
+spec is assigned a runner.  "Staging" is the name given to the process of
+figuring out in what order the specs should be built, taking into consideration
+Gitlab CI rules about jobs/stages.  In the staging process the goal is to maximize
+the number of jobs in any stage of the pipeline, while ensuring that the jobs in
+any stage only depend on jobs in previous stages (since those jobs are guaranteed
+to have completed already).  As a runner is determined for a job, the information
+in the ``runner-attributes`` is used to populate various parts of the job
+description that will be used by Gitlab CI. Once all the jobs have been assigned
+a runner, the ``.gitlab-ci.yml`` is written to disk.
 
-The the case of ``match_behavior: first``, the first ``match`` section in the list of
-``submappings`` that contains a string that satisfies the spec will apply it's
-``build-job*`` attributes to the rebuild job associated with that spec. This is the
-default behavior and will be the method if no ``match_behavior`` is specified.
+The short example provided above would result in the ``readline``, ``ncurses``,
+and ``pkgconf`` packages getting staged and built on the runner chosen by the
+``spack-k8s`` tag.  In this example, spack assumes the runner is a Docker executor
+type runner, and thus certain jobs will be run in the ``centos7`` container,
+and others in the ``ubuntu-18.04`` container.  The resulting ``.gitlab-ci.yml``
+will contain 6 jobs in three stages.  Once the jobs have been generated, the
+presence of a ``SPACK_CDASH_AUTH_TOKEN`` environment variable during the
+``spack ci generate`` command would result in all of the jobs being put in a
+build group on CDash called "Release Testing" (that group will be created if
+it didn't already exist).
 
-The the case of ``merge`` match, all of the ``match`` sections in the list of
-``submappings`` that contain a string that satisfies the spec will have the associated
-``build-job*`` attributes applied to the rebuild job associated with that spec. Again,
-the attributes will be merged starting from the bottom match going up to the top match.
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Optional compiler bootstrapping
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-In the case that no match is found in a submapping section, no additional attributes will be applied.
-
-^^^^^^^^^^^^^
-Bootstrapping
-^^^^^^^^^^^^^
-
-
-The ``bootstrap`` section allows you to specify lists of specs from
-your ``definitions`` that should be staged ahead of the environment's ``specs``. At the moment
+Spack pipelines also have support for bootstrapping compilers on systems that
+may not already have the desired compilers installed. The idea here is that
+you can specify a list of things to bootstrap in your ``definitions``, and
+spack will guarantee those will be installed in a phase of the pipeline before
+your release specs, so that you can rely on those packages being available in
+the binary mirror when you need them later on in the pipeline.  At the moment
 the only viable use-case for bootstrapping is to install compilers.
 
 Here's an example of what bootstrapping some compilers might look like:
@@ -632,18 +597,18 @@ Here's an example of what bootstrapping some compilers might look like:
        exclude:
          - '%gcc@7.3.0 os=centos7'
          - '%gcc@5.5.0 os=ubuntu18.04'
-     ci:
+     gitlab-ci:
        bootstrap:
          - name: compiler-pkgs
            compiler-agnostic: true
-       pipeline-gen:
-         # similar to the example higher up in this description
+       mappings:
+         # mappings similar to the example higher up in this description
          ...
 
 The example above adds a list to the ``definitions`` called ``compiler-pkgs``
 (you can add any number of these), which lists compiler packages that should
 be staged ahead of the full matrix of release specs (in this example, only
-readline).  Then within the ``ci`` section, note the addition of a
+readline).  Then within the ``gitlab-ci`` section, note the addition of a
 ``bootstrap`` section, which can contain a list of items, each referring to
 a list in the ``definitions`` section.  These items can either
 be a dictionary or a string.  If you supply a dictionary, it must have a name
@@ -675,86 +640,6 @@ environment/stack file, and in that case no bootstrapping will be done (only the
 specs will be staged for building) and the runners will be expected to already
 have all needed compilers installed and configured for spack to use.
 
-^^^^^^^^^^^^^^^^^^^
-Pipeline Buildcache
-^^^^^^^^^^^^^^^^^^^
-
-The ``enable-artifacts-buildcache`` key
-takes a boolean and determines whether the pipeline uses artifacts to store and
-pass along the buildcaches from one stage to the next (the default if you don't
-provide this option is ``False``).
-
-^^^^^^^^^^^^^^^^
-Broken Specs URL
-^^^^^^^^^^^^^^^^
-
-The optional ``broken-specs-url`` key tells Spack to check against a list of
-specs that are known to be currently broken in ``develop``. If any such specs
-are found, the ``spack ci generate`` command will fail with an error message
-informing the user what broken specs were encountered. This allows the pipeline
-to fail early and avoid wasting compute resources attempting to build packages
-that will not succeed.
-
-^^^^^
-CDash
-^^^^^
-
-The optional ``cdash`` section provides information that will be used by the
-``spack ci generate`` command (invoked by ``spack ci start``) for reporting
-to CDash.  All the jobs generated from this environment will belong to a
-"build group" within CDash that can be tracked over time.  As the release
-progresses, this build group may have jobs added or removed. The url, project,
-and site are used to specify the CDash instance to which build results should
-be reported.
-
-Take a look at the
-`schema <https://github.com/spack/spack/blob/develop/lib/spack/spack/schema/ci.py>`_
-for the ci section of the spack environment file, to see precisely what
-syntax is allowed there.
-
-.. _reserved_tags:
-
-^^^^^^^^^^^^^
-Reserved Tags
-^^^^^^^^^^^^^
-
-Spack has a subset of tags (``public``, ``protected``, and ``notary``) that it reserves
-for classifying runners that may require special permissions or access. The tags
-``public`` and ``protected`` are used to distinguish between runners that use public
-permissions and runners with protected permissions. The ``notary`` tag is a special tag
-that is used to indicate runners that have access to the highly protected information
-used for signing binaries using the ``signing`` job.
-
-.. _staging_algorithm:
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Summary of ``.gitlab-ci.yml`` generation algorithm
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-All specs yielded by the matrix (or all the specs in the environment) have their
-dependencies computed, and the entire resulting set of specs are staged together
-before being run through the ``ci/pipeline-gen`` entries, where each staged
-spec is assigned a runner.  "Staging" is the name given to the process of
-figuring out in what order the specs should be built, taking into consideration
-Gitlab CI rules about jobs/stages.  In the staging process the goal is to maximize
-the number of jobs in any stage of the pipeline, while ensuring that the jobs in
-any stage only depend on jobs in previous stages (since those jobs are guaranteed
-to have completed already).  As a runner is determined for a job, the information
-in the merged ``any-job*`` and ``build-job*`` sections is used to populate various parts of the job
-description that will be used by the target CI pipelines. Once all the jobs have been assigned
-a runner, the ``.gitlab-ci.yml`` is written to disk.
-
-The short example provided above would result in the ``readline``, ``ncurses``,
-and ``pkgconf`` packages getting staged and built on the runner chosen by the
-``spack-k8s`` tag.  In this example, spack assumes the runner is a Docker executor
-type runner, and thus certain jobs will be run in the ``centos7`` container,
-and others in the ``ubuntu-18.04`` container.  The resulting ``.gitlab-ci.yml``
-will contain 6 jobs in three stages.  Once the jobs have been generated, the
-presence of a ``SPACK_CDASH_AUTH_TOKEN`` environment variable during the
-``spack ci generate`` command would result in all of the jobs being put in a
-build group on CDash called "Release Testing" (that group will be created if
-it didn't already exist).
-
 -------------------------------------
 Using a custom spack in your pipeline
 -------------------------------------
@@ -801,21 +686,23 @@ generated by ``spack ci generate``.  You also want your generated rebuild jobs
 
    spack:
      ...
-     ci:
-       pipeline-gen:
-       - build-job:
-           tags:
-             - spack-kube
-           image: spack/ubuntu-bionic
-           before_script:
-             - git clone ${SPACK_REPO}
-             - pushd spack && git checkout ${SPACK_REF} && popd
-             - . "./spack/share/spack/setup-env.sh"
-           script:
-             - spack env activate --without-view ${SPACK_CONCRETE_ENV_DIR}
-             - spack -d ci rebuild
-           after_script:
-             - rm -rf ./spack
+     gitlab-ci:
+       mappings:
+         - match:
+             - os=ubuntu18.04
+           runner-attributes:
+             tags:
+               - spack-kube
+             image: spack/ubuntu-bionic
+             before_script:
+               - git clone ${SPACK_REPO}
+               - pushd spack && git checkout ${SPACK_REF} && popd
+               - . "./spack/share/spack/setup-env.sh"
+             script:
+               - spack env activate --without-view ${SPACK_CONCRETE_ENV_DIR}
+               - spack -d ci rebuild
+             after_script:
+               - rm -rf ./spack
 
 Now all of the generated rebuild jobs will use the same shell script to clone
 spack before running their actual workload.
@@ -838,7 +725,7 @@ above with ``git checkout ${SPACK_CHECKOUT_VERSION}``.
 On the other hand, if you're pointing to a spack repository and branch under your
 control, there may be no benefit in using the captured ``SPACK_CHECKOUT_VERSION``,
 and you can instead just clone using the variables you define (``SPACK_REPO``
-and ``SPACK_REF`` in the example above).
+and ``SPACK_REF`` in the example aboves).
 
 .. _custom_workflow:
 
@@ -904,4 +791,3 @@ verify binary packages (when installing or creating buildcaches).  You could
 also have already trusted a key spack know about, or if no key is present anywhere,
 spack will install specs using ``--no-check-signature`` and create buildcaches
 using ``-u`` (for unsigned binaries).
-

lib/spack/docs/replace_conda_homebrew.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -184,48 +184,13 @@ simply run the following commands:
 .. code-block:: console
 
    $ spack env activate myenv
-   $ spack concretize --fresh --force
+   $ spack concretize --force
    $ spack install
 
-The ``--fresh`` flag tells Spack to use the latest version of every package
-where possible instead of trying to optimize for reuse of existing installed
-packages.
-
-The ``--force`` flag in addition tells Spack to overwrite its previous 
-concretization decisions, allowing you to choose a new version of Python. 
-If any of the new packages like Bash are already installed, ``spack install`` 
-won't re-install them, it will keep the symlinks in place.
-
------------------------------------
-Updating & Cleaning Up Old Packages
------------------------------------
-
-If you're looking to mimic the behavior of Homebrew, you may also want to 
-clean up out-of-date packages from your environment after an upgrade. To 
-upgrade your entire software stack within an environment and clean up old 
-package versions, simply run the following commands:
-
-.. code-block:: console
-
-   $ spack env activate myenv
-   $ spack mark -i --all
-   $ spack concretize --fresh --force
-   $ spack install
-   $ spack gc
-   
-Running ``spack mark -i --all`` tells Spack to mark all of the existing 
-packages within an environment as "implicitly" installed. This tells 
-spack's garbage collection system that these packages should be cleaned up.
-
-Don't worry however, this will not remove your entire environment.
-Running ``spack install`` will reexamine your spack environment after
-a fresh concretization and will re-mark any packages that should remain
-installed as "explicitly" installed.
-
-**Note:** if you use multiple spack environments you should re-run ``spack install``
-in each of your environments prior to running ``spack gc`` to prevent spack 
-from uninstalling any shared packages that are no longer required by the 
-environment you just upgraded.
+The ``--force`` flag tells Spack to overwrite its previous concretization
+decisions, allowing you to choose a new version of Python. If any of the new
+packages like Bash are already installed, ``spack install`` won't re-install
+them, it will keep the symlinks in place.
 
 --------------
 Uninstallation