WIP

.flake8

@@ -29,7 +29,6 @@ max-line-length = 99
 #
 per-file-ignores =
   var/spack/repos/*/package.py:F403,F405,F821
-  *-ci-package.py:F403,F405,F821
 
 # exclude things we usually do not want linting for.
 # These still get linted when passed explicitly, as when spack flake8 passes

.github/ISSUE_TEMPLATE/test_error.yml

@@ -1,62 +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/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@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 # @v2
-    - uses: actions/setup-python@13ae5bb136fac2878aff31522b9efb785519f984 # @v2
-      with:
-        python-version: ${{inputs.python_version}}
-    - name: Install Python packages
-      run: |
-        pip install --upgrade pip six setuptools pytest codecov 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@d9f34f8cd5cb3b3eb79b3e4b5dae3a16df499a70 # @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@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
-        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@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
-        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@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
-        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@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
-        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@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
+        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:
+        python-version: ['3.6', '3.7', '3.8', '3.9', '3.10']
         macos-version: ['macos-11', 'macos-12']
+    if: github.repository == 'spack/spack'
     steps:
       - name: Install dependencies
         run: |
           brew install tree
       - name: Checkout
-        uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
+        uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b
+      - uses: actions/setup-python@b55428b1882923874294fa556849718a1d7f2ca5
+        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.6', '3.7', '3.8', '3.9', '3.10']
+    if: github.repository == 'spack/spack'
     steps:
       - name: Checkout
-        uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
+        uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b
+      - uses: actions/setup-python@b55428b1882923874294fa556849718a1d7f2ca5
         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 '2.7' '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@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
-        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@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
-        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@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
+        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@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
+        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:
@@ -50,7 +50,7 @@ jobs:
     if: github.repository == 'spack/spack'
     steps:
       - name: Checkout
-        uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 # @v2
+        uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b # @v2
 
       - name: Set Container Tag Normal (Nightly)
         run: |
@@ -80,19 +80,19 @@ jobs:
           fi
 
       - name: Upload Dockerfile
-        uses: actions/upload-artifact@83fd05a356d7e2593de66fc9913b3002723633cb
+        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@8c0edbc76e98fa90f69d9a2c020dcb50019dc325 # @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 }}
@@ -100,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@c56af957549030174b10d6867f20e78cfd7debc5 # @v2
+        uses: docker/build-push-action@c84f38281176d4c9cdb1626ffafcd6b3911b5d94 # @v2
         with:
           context: dockerfiles/${{ matrix.dockerfile[0] }}
           platforms: ${{ matrix.dockerfile[1] }}

.github/workflows/ci.yaml

@@ -1,92 +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 }}
-  audit-ancient-python:
-    uses: ./.github/workflows/audit.yaml
-    needs: [ changes ]
-    with:
-      with_coverage: ${{ needs.changes.outputs.core }}
-      python_version: 2.7
-  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@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 # @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, audit-ancient-python ]
-    runs-on: ubuntu-latest
-    steps:
-    - name: Success
-      run: "true"

.github/workflows/setup_git.ps1

@@ -6,10 +6,6 @@ git config --global user.email "spack@example.com"
 git config --global user.name "Test User"
 git config --global core.longpaths true
 
-# See https://github.com/git/git/security/advisories/GHSA-3wp6-j8xr-qw85 (CVE-2022-39253)
-# This is needed to let some fixture in our unit-test suite run
-git config --global protocol.file.allow always
-
 if ($(git branch --show-current) -ne "develop")
 {
     git branch develop origin/develop

.github/workflows/setup_git.sh

@@ -2,10 +2,6 @@
 git config --global user.email "spack@example.com"
 git config --global user.name "Test User"
 
-# See https://github.com/git/git/security/advisories/GHSA-3wp6-j8xr-qw85 (CVE-2022-39253)
-# This is needed to let some fixture in our unit-test suite run
-git config --global protocol.file.allow always
-
 # create a local pr base branch
 if [[ -n $GITHUB_BASE_REF ]]; then
     git fetch origin "${GITHUB_BASE_REF}:${GITHUB_BASE_REF}"

.github/workflows/unit_tests.yaml

@@ -1,49 +1,118 @@
-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:
+  # Validate that the code can be run on all the Python versions
+  # supported by Spack
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b # @v2
+    - uses: actions/setup-python@b55428b1882923874294fa556849718a1d7f2ca5 # @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.6- -vvv lib/spack/spack/ lib/spack/llnl/ bin/
+    - name: vermin (Repositories)
+      run: vermin --backport argparse --violations --backport typing -t=2.7- -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@2541b1294d2704b0964813337f33b291d3f8596b # @v2
+      with:
+        fetch-depth: 0
+    - uses: actions/setup-python@b55428b1882923874294fa556849718a1d7f2ca5 # @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
-  ubuntu:
+  unittests:
+    needs: [ validate, style, changes ]
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ['2.7', '3.6', '3.7', '3.8', '3.9', '3.10', '3.11']
+        python-version: ['2.7', '3.6', '3.7', '3.8', '3.9', '3.10']
         concretizer: ['clingo']
-        on_develop:
-        - ${{ github.ref == 'refs/heads/develop' }}
         include:
         - python-version: 2.7
           concretizer: original
-          on_develop: ${{ github.ref == 'refs/heads/develop' }}
-        - python-version: '3.11'
+        - python-version: 3.9
           concretizer: original
-          on_develop: ${{ github.ref == 'refs/heads/develop' }}
-        exclude:
-        - python-version: '3.7'
-          concretizer: 'clingo'
-          on_develop: false
-        - python-version: '3.8'
-          concretizer: 'clingo'
-          on_develop: false
-        - python-version: '3.9'
-          concretizer: 'clingo'
-          on_develop: false
-        - python-version: '3.10'
-          concretizer: 'clingo'
-          on_develop: false
-
     steps:
-    - uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 # @v2
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b # @v2
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@13ae5bb136fac2878aff31522b9efb785519f984 # @v2
+    - uses: actions/setup-python@b55428b1882923874294fa556849718a1d7f2ca5 # @v2
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install System packages
@@ -55,12 +124,7 @@ jobs:
               patchelf cmake bison libbison-dev kcov
     - name: Install Python packages
       run: |
-          pip install --upgrade pip six setuptools pytest codecov[toml] pytest-xdist 
-          # Install pytest-cov only on recent Python, to avoid stalling on Python 2.7 due
-          # to bugs on an unmaintained version of the package when used with xdist.
-          if [[ ${{ matrix.python-version }} != "2.7" ]]; then
-            pip install --upgrade pytest-cov
-          fi
+          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
@@ -69,7 +133,7 @@ jobs:
     - name: Pin pathlib for Python 2.7
       if: ${{ matrix.python-version == 2.7 }}
       run: |
-          pip install -U pathlib2==2.3.6 toml
+          pip install -U pathlib2==2.3.6
     - name: Setup git configuration
       run: |
           # Need this for the git tests to succeed.
@@ -81,30 +145,41 @@ jobs:
           SPACK_PYTHON: python
       run: |
           . share/spack/setup-env.sh
-          spack bootstrap disable spack-install
+          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@d9f34f8cd5cb3b3eb79b3e4b5dae3a16df499a70
+          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@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 # @v2
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b # @v2
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@13ae5bb136fac2878aff31522b9efb785519f984 # @v2
+    - uses: actions/setup-python@b55428b1882923874294fa556849718a1d7f2ca5 # @v2
       with:
-        python-version: '3.11'
+        python-version: '3.10'
     - name: Install System packages
       run: |
           sudo apt-get -y update
@@ -112,25 +187,33 @@ jobs:
           sudo apt-get install -y coreutils kcov csh zsh tcsh fish dash bash
     - name: Install Python packages
       run: |
-          pip install --upgrade pip six setuptools pytest codecov 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@d9f34f8cd5cb3b3eb79b3e4b5dae3a16df499a70
+    - 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
@@ -138,7 +221,7 @@ jobs:
           dnf install -y \
               bzip2 curl file gcc-c++ gcc gcc-gfortran git gnupg2 gzip \
               make patch tcl unzip which xz
-    - uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 # @v2
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b # @v2
     - name: Setup repo and non-root user
       run: |
           git --version
@@ -154,14 +237,15 @@ jobs:
           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@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 # @v2
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b # @v2
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@13ae5bb136fac2878aff31522b9efb785519f984 # @v2
+    - uses: actions/setup-python@b55428b1882923874294fa556849718a1d7f2ca5 # @v2
       with:
-        python-version: '3.11'
+        python-version: '3.10'
     - name: Install System packages
       run: |
           sudo apt-get -y update
@@ -171,53 +255,105 @@ jobs:
               patchelf kcov
     - name: Install Python packages
       run: |
-          pip install --upgrade pip six setuptools pytest codecov 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@d9f34f8cd5cb3b3eb79b3e4b5dae3a16df499a70 # @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@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 # @v2
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b # @v2
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@13ae5bb136fac2878aff31522b9efb785519f984 # @v2
+    - uses: actions/setup-python@b55428b1882923874294fa556849718a1d7f2ca5 # @v2
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install Python packages
       run: |
           pip install --upgrade pip six setuptools
-          pip install --upgrade pytest codecov coverage[toml] pytest-xdist pytest-cov
+          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@d9f34f8cd5cb3b3eb79b3e4b5dae3a16df499a70
+        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@b55428b1882923874294fa556849718a1d7f2ca5 # @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,60 +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@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 # @v2
-    - uses: actions/setup-python@13ae5bb136fac2878aff31522b9efb785519f984 # @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 argparse --violations --backport typing -t=2.7- -t=3.6- -vvv lib/spack/spack/ lib/spack/llnl/ bin/
-    - name: vermin (Repositories)
-      run: vermin --backport argparse --violations --backport typing -t=2.7- -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@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 # @v2
-      with:
-        fetch-depth: 0
-    - uses: actions/setup-python@13ae5bb136fac2878aff31522b9efb785519f984 # @v2
-      with:
-        python-version: '3.11'
-        cache: 'pip'
-    - name: Install Python packages
-      run: |
-        python3 -m pip install --upgrade pip six setuptools types-six click==8.0.2 'black==21.12b0' 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'

.github/workflows/windows_python.yml

@@ -1,10 +1,17 @@
-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:
@@ -12,64 +19,91 @@ defaults:
     shell:
      powershell Invoke-Expression -Command ".\share\spack\qa\windows_test_setup.ps1"; {0}
 jobs:
-  unit-tests:
+  validate:
     runs-on: windows-latest
     steps:
-    - uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b
+    - uses: actions/setup-python@b55428b1882923874294fa556849718a1d7f2ca5
+      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.6-' -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.6-' -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@13ae5bb136fac2878aff31522b9efb785519f984
+    - uses: actions/setup-python@b55428b1882923874294fa556849718a1d7f2ca5
       with:
         python-version: 3.9
     - name: Install Python packages
       run: |
-          python -m pip install --upgrade pip six pywin32 setuptools codecov pytest-cov clingo
+        python -m pip install --upgrade pip six setuptools flake8 "isort>=4.3.5" "mypy>=0.800" "click==8.0.4" "black<=21.12b0" pywin32 types-python-dateutil
+    - name: Create local develop
+      run: |
+        .\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@b55428b1882923874294fa556849718a1d7f2ca5
+      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: |
         echo F|xcopy .\spack\share\spack\qa\configuration\windows_config.yaml $env:USERPROFILE\.spack\windows\config.yaml
-        cd spack
-        dir
-        spack unit-test -x --verbose --cov --cov-config=pyproject.toml --ignore=lib/spack/spack/test/cmd
-        coverage combine -a
-        coverage xml
-    - uses: codecov/codecov-action@d9f34f8cd5cb3b3eb79b3e4b5dae3a16df499a70
-      with:
-        flags: unittests,windows
-  unit-tests-cmd:
+        spack unit-test --verbose --ignore=lib/spack/spack/test/cmd
+  unittest-cmd:
+    needs: [ validate, style ]
     runs-on: windows-latest
     steps:
-    - uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@13ae5bb136fac2878aff31522b9efb785519f984
+    - uses: actions/setup-python@b55428b1882923874294fa556849718a1d7f2ca5
       with:
         python-version: 3.9
     - name: Install Python packages
       run: |
-          python -m pip install --upgrade pip six pywin32 setuptools codecov coverage pytest-cov clingo
+          python -m pip install --upgrade pip six pywin32 setuptools codecov coverage
     - name: Create local develop
       run: |
         .\spack\.github\workflows\setup_git.ps1
     - name: Command Unit Test
       run: |
         echo F|xcopy .\spack\share\spack\qa\configuration\windows_config.yaml $env:USERPROFILE\.spack\windows\config.yaml
-        cd spack
-        spack unit-test -x --verbose --cov --cov-config=pyproject.toml lib/spack/spack/test/cmd
-        coverage combine -a
-        coverage xml
-    - uses: codecov/codecov-action@d9f34f8cd5cb3b3eb79b3e4b5dae3a16df499a70
-      with:
-        flags: unittests,windows
-  build-abseil:
+        spack unit-test lib/spack/spack/test/cmd --verbose
+  buildtest:
+    needs: [ validate, style ]
     runs-on: windows-latest
     steps:
-    - uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@13ae5bb136fac2878aff31522b9efb785519f984
+    - uses: actions/setup-python@b55428b1882923874294fa556849718a1d7f2ca5
       with:
         python-version: 3.9
     - name: Install Python packages
@@ -81,8 +115,9 @@ jobs:
         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
-  make-installer:
+        spack install abseil-cpp
+  generate-installer-test:
+    needs: [ validate, style ]
     runs-on: windows-latest
     steps:
     - name: Disable Windows Symlinks
@@ -90,15 +125,15 @@ jobs:
         git config --global core.symlinks false
       shell:
         powershell
-    - uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
+    - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b
       with:
         fetch-depth: 0
-    - uses: actions/setup-python@13ae5bb136fac2878aff31522b9efb785519f984
+    - uses: actions/setup-python@b55428b1882923874294fa556849718a1d7f2ca5
       with:
         python-version: 3.9
     - name: Install Python packages
       run: |
-          python -m pip install --upgrade pip six pywin32 setuptools
+          python -m pip install --upgrade pip six pywin32 setuptools codecov coverage
     - name: Add Light and Candle to Path
       run: |
         $env:WIX >> $GITHUB_PATH
@@ -109,27 +144,27 @@ jobs:
         echo "installer_root=$((pwd).Path)" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf8 -Append
       env:
         ProgressPreference: SilentlyContinue
-    - uses: actions/upload-artifact@83fd05a356d7e2593de66fc9913b3002723633cb
+    - uses: actions/upload-artifact@3cea5372237819ed00197afe530f5a7ea3e805c8
       with:
         name: Windows Spack Installer Bundle
         path: ${{ env.installer_root }}\pkg\Spack.exe
-    - uses: actions/upload-artifact@83fd05a356d7e2593de66fc9913b3002723633cb
+    - uses: actions/upload-artifact@3cea5372237819ed00197afe530f5a7ea3e805c8
       with:
         name: Windows Spack Installer
         path: ${{ env.installer_root}}\pkg\Spack.msi
   execute-installer:
-    needs: make-installer
+    needs: generate-installer-test
     runs-on: windows-latest
     defaults:
       run:
         shell: pwsh
     steps:
-    - uses: actions/setup-python@13ae5bb136fac2878aff31522b9efb785519f984
+    - uses: actions/setup-python@b55428b1882923874294fa556849718a1d7f2ca5
       with:
         python-version: 3.9
     - name: Install Python packages
       run: |
-          python -m pip install --upgrade pip six pywin32 setuptools
+          python -m pip install --upgrade pip six pywin32 setuptools codecov coverage
     - name: Setup installer directory
       run: |
         mkdir -p spack_installer

README.md

@@ -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!

bin/spack

@@ -49,8 +49,52 @@ 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: F401
+    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: E402
 
 # 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-tmpconfig

@@ -1,95 +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
-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[@]}"

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

@@ -33,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

@@ -187,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
@@ -211,7 +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

etc/spack/defaults/packages.yaml

@@ -27,8 +27,7 @@ packages:
       fuse: [libfuse]
       gl: [glx, osmesa]
       glu: [mesa-glu, openglu]
-      golang: [go, gcc]
-      go-external-or-gccgo-bootstrap: [go-bootstrap, gcc]
+      golang: [gcc]
       iconv: [libiconv]
       ipp: [intel-ipp]
       java: [openjdk, jdk, ibm-java]

etc/spack/defaults/windows/config.yaml

@@ -1,5 +1,5 @@
 config:
   locks: false
-  concretizer: clingo
+  concretizer: original
   build_stage::
     - '$spack/.staging'

lib/spack/docs/_spack_root

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

lib/spack/docs/basic_usage.rst

@@ -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
@@ -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``)
@@ -1230,23 +1226,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
 ^^^^^^^^^^^^^^
@@ -1254,15 +1233,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"``,
@@ -1464,7 +1438,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

lib/spack/docs/bootstrapping.rst

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

@@ -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
@@ -302,31 +279,88 @@ 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-preferences:
+
+-------------------
+Package Preferences
+-------------------
+
+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:
+
+.. code-block:: yaml
+
+   packages:
+     opencv:
+       compiler: [gcc@4.9]
+       variants: +debug
+     gperftools:
+       version: [2.2, 2.4, 2.3]
+     all:
+       compiler: [gcc@4.4.7, 'gcc@4.6:', intel, clang, pgi]
+       target: [sandybridge]
+       providers:
+         mpi: [mvapich2, mpich, openmpi]
+
+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
+its MPI and GCC 4.4.7 (except for opencv, which overrides this by preferring GCC 4.9).
+These options are used to fill in implicit defaults.  Any of them can be overwritten
+on the command line if explicitly requested.
+
+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
+legal concretization rule.  Going back to the example, if a user
+requests gperftools 2.3 or later, then Spack will install version 2.4
+as the 2.4 version of gperftools is preferred over 2.3.
+
+An explicit concretization rule in the preferred section will always
+take preference over unlisted concretizations.  In the above example,
+xlc isn't listed in the compiler list.  Every listed compiler from
+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
+``depend_on`` (e.g, MPI) and a list of rules for fulfilling that
+dependency.
+
 .. _package-requirements:
 
 --------------------
 Package Requirements
 --------------------
 
-Spack can be configured to always use certain compilers, package
-versions, and variants during concretization through package
-requirements.
+You can use the configuration to force the concretizer to choose
+specific properties for packages when building them. Like preferences,
+these are only applied when the package is required by some other
+request (e.g. if the package is needed as a dependency of a
+request to ``spack install``).
 
-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.
+An example of where this is useful is if you have a package that
+is normally built as a dependency but only under certain circumstances
+(e.g. only when a variant on a dependent is active): you can make
+sure that it always builds the way you want it to; this distinguishes
+package configuration requirements from constraints that you add to
+``spack install`` or to environments (in those cases, the associated
+packages are always built).
 
-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.
-
-The package requirements configuration is specified in ``packages.yaml``
-keyed by package name:
+The following is an example of how to enforce package properties in
+``packages.yaml``:
 
 .. code-block:: yaml
 
@@ -335,7 +369,7 @@ keyed by package name:
        require: "@1.13.2"
      openmpi:
        require:
-       - any_of: ["~cuda", "%gcc"]
+       - any_of: ["~cuda", "gcc"]
      mpich:
       require:
       - one_of: ["+cuda", "+rocm"]
@@ -362,16 +396,6 @@ choose between a set of options using ``any_of`` or ``one_of``:
   ``mpich`` already includes a conflict, so this is redundant but
   still demonstrates the concept).
 
-.. 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).
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Setting default requirements
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
 You can also set default requirements for all packages under ``all``
 like this:
 
@@ -395,96 +419,16 @@ under ``all`` are disregarded. For example, with a configuration like this:
      cmake:
        require: '%gcc'
 
-Spack requires ``cmake`` to use ``gcc`` and all other nodes (including ``cmake``
-dependencies) to use ``clang``.
+Spack requires ``cmake`` to use ``gcc`` and all other nodes (including cmake dependencies)
+to use ``clang``.
 
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Setting requirements on virtual specs
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Other notes about ``requires``:
 
-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.
-
-Here's an example ``packages.yaml`` file that sets preferred packages:
-
-.. code-block:: yaml
-
-   packages:
-     opencv:
-       compiler: [gcc@4.9]
-       variants: +debug
-     gperftools:
-       version: [2.2, 2.4, 2.3]
-     all:
-       compiler: [gcc@4.4.7, 'gcc@4.6:', intel, clang, pgi]
-       target: [sandybridge]
-       providers:
-         mpi: [mvapich2, mpich, openmpi]
-
-At a high level, this example is specifying how packages are preferably
-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
-its MPI and GCC 4.4.7 (except for opencv, which overrides this by preferring GCC 4.9).
-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.
-
-Sometimes a package installation may have constraints that forbid
-the first concretization rule, in which case Spack will use the first
-legal concretization rule.  Going back to the example, if a user
-requests gperftools 2.3 or later, then Spack will install version 2.4
-as the 2.4 version of gperftools is preferred over 2.3.
-
-An explicit concretization rule in the preferred section will always
-take preference over unlisted concretizations.  In the above example,
-xlc isn't listed in the compiler list.  Every listed compiler from
-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
-dependency.
+* You cannot specify requirements for virtual packages (e.g. you can
+  specify requirements for ``openmpi`` but not ``mpi``).
+* 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).
 
 .. _package_permissions:
 
@@ -534,25 +478,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

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

@@ -5,9 +5,9 @@
 
 .. _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

@@ -5,9 +5,9 @@
 
 .. _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/cmakepackage.rst

@@ -5,9 +5,9 @@
 
 .. _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/inteloneapipackage.rst

@@ -32,7 +32,7 @@ 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

lib/spack/docs/build_systems/luapackage.rst

@@ -5,11 +5,11 @@
 
 .. _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

@@ -5,9 +5,9 @@
 
 .. _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

@@ -5,9 +5,9 @@
 
 .. _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

@@ -5,9 +5,9 @@
 
 .. _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

@@ -5,9 +5,9 @@
 
 .. _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

@@ -5,9 +5,9 @@
 
 .. _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

@@ -582,19 +582,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`` explicity, 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``.

lib/spack/docs/build_systems/qmakepackage.rst

@@ -5,9 +5,9 @@
 
 .. _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

@@ -5,9 +5,9 @@
 
 .. _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/rpackage.rst

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

lib/spack/docs/build_systems/rubypackage.rst

@@ -5,9 +5,9 @@
 
 .. _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

@@ -5,9 +5,9 @@
 
 .. _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

@@ -5,9 +5,9 @@
 
 .. _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/wafpackage.rst

@@ -5,9 +5,9 @@
 
 .. _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

lib/spack/docs/conf.py

@@ -32,9 +32,6 @@
 # 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/pytest-fallback"))
 
@@ -130,7 +127,6 @@ def setup(sphinx):
     "sphinx.ext.napoleon",
     "sphinx.ext.todo",
     "sphinx.ext.viewcode",
-    "sphinx_design",
     "sphinxcontrib.programoutput",
 ]
 
@@ -205,13 +201,9 @@ def setup(sphinx):
     ("py:class", "unittest.case.TestCase"),
     ("py:class", "_frozen_importlib_external.SourceFileLoader"),
     ("py:class", "clingo.Control"),
-    ("py:class", "six.moves.urllib.parse.ParseResult"),
     # 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.VersionBase"),
 ]
 
 # The reST default role (used for this markup: `text`) to use for all documents.

lib/spack/docs/config_yaml.rst

@@ -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``.
@@ -224,9 +224,9 @@ them). Please note that we currently disable ccache's ``hash_dir``
 feature to avoid an issue with the stage directory (see
 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

@@ -405,17 +405,6 @@ Spack understands several 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``.
 
 Note that, as with shell variables, you can write these as ``$varname``
 or with braces to distinguish the variable from surrounding characters:
@@ -560,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/developer_guide.rst

@@ -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,

lib/spack/docs/environments.rst

@@ -478,21 +478,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
@@ -519,49 +512,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
 
@@ -573,11 +525,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::
 
@@ -588,10 +574,10 @@ user support groups providing a large software stack for their HPC center.
 
 .. admonition:: Re-concretization of user specs
 
-   When using *unified* concretization (when possible), the entire set of specs will be
+   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 unified concretization is
-   disabled, only the new specs will be concretized after any addition.
+   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
@@ -630,6 +616,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
 ^^^^^^^^^^^^^^^^^^^^
@@ -993,7 +1004,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
@@ -1006,6 +1017,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::
@@ -1015,17 +1027,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
 
@@ -1051,10 +1054,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.
@@ -1065,24 +1069,3 @@ the include is conditional.
    the ``--make-target-prefix`` flag and use the non-phony target
    ``<target-prefix>/env`` as prerequisite, instead of the phony target
    ``<target-prefix>/all``.
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Building a subset of the environment
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The generated ``Makefile``\s contain install targets for each spec. Given the hash
-of a particular spec, you can use the ``.install/<hash>`` target to install the
-spec with its dependencies. There is also ``.install-deps/<hash>`` 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 --make-target-prefix my_env
-
-   # Install dependencies in parallel, only show a log on error.
-   $ make -j16 my_env/.install-deps/<hash> SPACK_INSTALL_FLAGS=--show-log-on-error
-
-   # Install the root spec with verbose output.
-   $ make -j16 my_env/.install/<hash> SPACK_INSTALL_FLAGS=--verbose

lib/spack/docs/features.rst

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

@@ -23,36 +23,8 @@ be present on the machine where Spack is run:
 These requirements can be easily installed on most modern Linux systems;
 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 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
-
-         yum update -y
-         yum install -y epel-release
-         yum update -y
-         yum --enablerepo epel groupinstall -y "Development Tools"
-         yum --enablerepo epel install -y curl findutils gcc-c++ gcc gcc-gfortran git gnupg2 hostname iproute redhat-lsb-core make patch python3 python3-pip python3-setuptools unzip
-         python3 -m pip install boto3
-
-   .. tab-item:: macOS Brew
-
-      .. code-block:: console
-
-         brew update
-         brew install curl gcc git gnupg zip
+to work on all platforms.  A build matrix showing which packages are
+working on which systems is planned but not yet available.
 
 ------------
 Installation
@@ -124,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::
 
@@ -188,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
 
@@ -197,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

lib/spack/docs/index.rst

@@ -56,6 +56,7 @@ or refer to the full manual below.
    basic_usage
    Tutorial: Spack 101 <https://spack-tutorial.readthedocs.io>
    replace_conda_homebrew
+   known_issues
 
 .. toctree::
    :maxdepth: 2

lib/spack/docs/known_issues.rst

@@ -0,0 +1,40 @@
+.. 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)
+
+============
+Known Issues
+============
+
+This is a list of known issues in Spack. It provides ways of getting around these
+problems if you encounter them.
+
+------------------------------------------------
+Spack does not seem to respect ``packages.yaml``
+------------------------------------------------
+
+.. note::
+
+   This issue is **resolved** as of v0.19.0.dev0 commit
+   `8281a0c5feabfc4fe180846d6fe95cfe53420bc5`, through the introduction of package
+   requirements. See :ref:`package-requirements`.
+
+A common problem in Spack v0.18.0 up to v0.19.0.dev0 is that package, compiler and target
+preferences specified in ``packages.yaml`` do not seem to be respected. Spack picks the
+"wrong" compilers and their versions, package versions and variants, and
+micro-architectures.
+
+This is however not a bug. In order to reduce the number of builds of the same
+packages, the concretizer values reuse of installed packages higher than preferences
+set in ``packages.yaml``. Note that ``packages.yaml`` specifies only preferences, not
+hard constraints.
+
+There are multiple workarounds:
+
+1. Disable reuse during concretization: ``spack install --fresh <spec>`` when installing
+   from the command line, or ``spack concretize --fresh --force`` when using
+   environments.  
+2. Turn preferences into constrains, by moving them to the input spec. For example,
+   use ``spack spec zlib%gcc@12`` when you want to force GCC 12 even if ``zlib`` was
+   already installed with GCC 10.

lib/spack/docs/module_file_support.rst

@@ -77,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.

lib/spack/docs/packaging_guide.rst

@@ -34,155 +34,24 @@ ubiquitous in the scientific software community. Second, it's a modern
 language and has many powerful features to help make package writing
 easy.
 
-
-.. _installation_procedure:
-
---------------------------------------
-Overview of the installation procedure
---------------------------------------
-
-Whenever Spack installs software, it goes through a series of predefined steps:
-
-.. image:: images/installation_pipeline.png
-  :scale: 60 %
-  :align: center
-
-All these steps are influenced by the metadata in each ``package.py`` and
-by the current Spack configuration.
-Since build systems are different from one another, the execution of the
-last block in the figure is further expanded in a build system specific way.
-An example for ``CMake`` is, for instance:
-
-.. image:: images/builder_phases.png
-   :align: center
-   :scale: 60 %
-
-The predefined steps for each build system are called "phases".
-In general, the name and order in which the phases will be executed can be
-obtained by either reading the API docs at :py:mod:`~.spack.build_systems`, or
-using the ``spack info`` command:
-
-.. code-block:: console
-    :emphasize-lines: 13,14
-
-    $ spack info --phases m4
-    AutotoolsPackage:    m4
-    Homepage:            https://www.gnu.org/software/m4/m4.html
-
-    Safe versions:
-        1.4.17    ftp://ftp.gnu.org/gnu/m4/m4-1.4.17.tar.gz
-
-    Variants:
-        Name       Default   Description
-
-        sigsegv    on        Build the libsigsegv dependency
-
-    Installation Phases:
-        autoreconf    configure    build    install
-
-    Build Dependencies:
-        libsigsegv
-
-    ...
-
-An extensive list of available build systems and phases is provided in :ref:`installation_process`.
-
-
-------------------------
-Writing a package recipe
-------------------------
-
-Since v0.19, Spack supports  two ways of writing a package recipe. The most commonly used is to encode both the metadata
-(directives, etc.) and the build behavior in a single class, like shown in the following example:
-
-.. code-block:: python
-
-   class Openjpeg(CMakePackage):
-       """OpenJPEG is an open-source JPEG 2000 codec written in C language"""
-
-       homepage = "https://github.com/uclouvain/openjpeg"
-       url = "https://github.com/uclouvain/openjpeg/archive/v2.3.1.tar.gz"
-
-       version("2.4.0", sha256="8702ba68b442657f11aaeb2b338443ca8d5fb95b0d845757968a7be31ef7f16d")
-
-       variant("codec", default=False, description="Build the CODEC executables")
-       depends_on("libpng", when="+codec")
-
-       def url_for_version(self, version):
-           if version >= Version("2.1.1"):
-               return super(Openjpeg, self).url_for_version(version)
-           url_fmt = "https://github.com/uclouvain/openjpeg/archive/version.{0}.tar.gz"
-           return url_fmt.format(version)
-
-       def cmake_args(self):
-           args = [
-               self.define_from_variant("BUILD_CODEC", "codec"),
-               self.define("BUILD_MJ2", False),
-               self.define("BUILD_THIRDPARTY", False),
-           ]
-           return args
-
-A package encoded with a single class is backward compatible with versions of Spack
-lower than v0.19, and so are custom repositories containing only recipes of this kind.
-The downside is that *this format doesn't allow packagers to use more than one build system in a single recipe*.
-
-To do that, we have to resort to the second way Spack has of writing packages, which involves writing a
-builder class explicitly. Using the same example as above, this reads:
-
-.. code-block:: python
-
-   class Openjpeg(CMakePackage):
-       """OpenJPEG is an open-source JPEG 2000 codec written in C language"""
-
-       homepage = "https://github.com/uclouvain/openjpeg"
-       url = "https://github.com/uclouvain/openjpeg/archive/v2.3.1.tar.gz"
-
-       version("2.4.0", sha256="8702ba68b442657f11aaeb2b338443ca8d5fb95b0d845757968a7be31ef7f16d")
-
-       variant("codec", default=False, description="Build the CODEC executables")
-       depends_on("libpng", when="+codec")
-
-       def url_for_version(self, version):
-           if version >= Version("2.1.1"):
-               return super(Openjpeg, self).url_for_version(version)
-           url_fmt = "https://github.com/uclouvain/openjpeg/archive/version.{0}.tar.gz"
-           return url_fmt.format(version)
-
-   class CMakeBuilder(spack.build_systems.cmake.CMakeBuilder):
-       def cmake_args(self):
-           args = [
-               self.define_from_variant("BUILD_CODEC", "codec"),
-               self.define("BUILD_MJ2", False),
-               self.define("BUILD_THIRDPARTY", False),
-           ]
-           return args
-
-This way of writing packages allows extending the recipe to support multiple build systems,
-see :ref:`multiple_build_systems` for more details. The downside is that recipes of this kind
-are only understood by Spack since v0.19+. More information on the internal architecture of
-Spack can be found at :ref:`package_class_structure`.
-
-.. note::
-
-   If a builder is implemented in ``package.py``, all build-specific methods must be moved
-   to the builder. This means that if you have a package like
-
-   .. code-block:: python
-
-      class Foo(CmakePackage):
-          def cmake_args(self):
-              ...
-
-   and you add a builder to the ``package.py``, you must move ``cmake_args`` to the builder.
+---------------------------
+Creating & editing packages
+---------------------------
 
 .. _cmd-spack-create:
 
----------------------
-Creating new packages
----------------------
+^^^^^^^^^^^^^^^^
+``spack create``
+^^^^^^^^^^^^^^^^
 
-To help creating a new package Spack provides a command that generates a ``package.py``
-file in an existing repository, with a boilerplate package template. Here's an example:
+The ``spack create`` command creates a directory with the package name and
+generates a ``package.py`` file with a boilerplate package template. If given
+a URL pointing to a tarball or other software archive, ``spack create`` is
+smart enough to determine basic information about the package, including its name
+and build system. In most cases, ``spack create`` plus a few modifications is
+all you need to get a package working.
+
+Here's an example:
 
 .. code-block:: console
 
@@ -218,6 +87,23 @@ You do not *have* to download all of the versions up front. You can
 always choose to download just one tarball initially, and run
 :ref:`cmd-spack-checksum` later if you need more versions.
 
+Let's say you download 3 tarballs:
+
+.. code-block:: console
+
+	How many would you like to checksum? (default is 1, q to abort) 3
+	==> Downloading...
+	==> Fetching https://gmplib.org/download/gmp/gmp-6.1.2.tar.bz2
+	######################################################################## 100.0%
+	==> Fetching https://gmplib.org/download/gmp/gmp-6.1.1.tar.bz2
+	######################################################################## 100.0%
+	==> Fetching https://gmplib.org/download/gmp/gmp-6.1.0.tar.bz2
+	######################################################################## 100.0%
+	==> Checksummed 3 versions of gmp:
+	==> This package looks like it uses the autotools build system
+	==> Created template for gmp package
+	==> Created package file: /Users/Adam/spack/var/spack/repos/builtin/packages/gmp/package.py
+
 Spack automatically creates a directory in the appropriate repository,
 generates a boilerplate template for your package, and opens up the new
 ``package.py`` in your favorite ``$EDITOR``:
@@ -225,14 +111,6 @@ generates a boilerplate template for your package, and opens up the new
 .. code-block:: python
    :linenos:
 
-   # 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)
-
-   # ----------------------------------------------------------------------------
-   # If you submit this package back to Spack as a pull request,
-   # please first remove this boilerplate and all FIXME comments.
    #
    # This is a template package file for Spack.  We've put "FIXME"
    # next to all the things you'll want to change. Once you've handled
@@ -245,8 +123,9 @@ generates a boilerplate template for your package, and opens up the new
    #     spack edit gmp
    #
    # See the Spack documentation for more information on packaging.
-   # ----------------------------------------------------------------------------
-   import spack.build_systems.autotools
+   # If you submit this package back to Spack as a pull request,
+   # please first remove this boilerplate and all FIXME comments.
+   #
    from spack.package import *
 
 
@@ -254,17 +133,19 @@ generates a boilerplate template for your package, and opens up the new
        """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://gmplib.org/download/gmp/gmp-6.1.2.tar.bz2"
+       homepage = "http://www.example.com"
+       url      = "https://gmplib.org/download/gmp/gmp-6.1.2.tar.bz2"
 
        # FIXME: Add a list of GitHub accounts to
        # notify when the package is updated.
-       # maintainers = ["github_user1", "github_user2"]
+       # maintainers = ['github_user1', 'github_user2']
 
-       version("6.2.1", sha256="eae9326beb4158c386e39a356818031bd28f3124cf915f8c5b1dc4c7a36b4d7c")
+       version('6.1.2', '8ddbb26dc3bd4e2302984debba1406a5')
+       version('6.1.1', '4c175f86e11eb32d8bf9872ca3a8e11d')
+       version('6.1.0', '86ee6e54ebfc4a90b643a65e402c4048')
 
        # FIXME: Add dependencies if required.
-       # depends_on("foo")
+       # depends_on('foo')
 
        def configure_args(self):
            # FIXME: Add arguments other than --prefix
@@ -273,16 +154,15 @@ generates a boilerplate template for your package, and opens up the new
            return args
 
 The tedious stuff (creating the class, checksumming archives) has been
-done for you. Spack correctly detected that ``gmp`` uses the ``autotools``
-build system, so it created a new ``Gmp`` package that subclasses the
-``AutotoolsPackage`` base class.
-
-The default installation procedure for a package subclassing the ``AutotoolsPackage``
-is to go through the typical process of:
+done for you. You'll notice that ``spack create`` correctly detected that
+``gmp`` uses the Autotools build system. It created a new ``Gmp`` package
+that subclasses the ``AutotoolsPackage`` base class. This base class
+provides basic installation methods common to all Autotools packages:
 
 .. code-block:: bash
 
    ./configure --prefix=/path/to/installation/directory
+
    make
    make check
    make install
@@ -329,14 +209,12 @@ The rest of the tasks you need to do are as follows:
    Your new package may require specific flags during ``configure``.
    These can be added via ``configure_args``. Specifics will differ
    depending on the package and its build system.
-   :ref:`installation_process` is
+   :ref:`Implementing the install method <install-method>` is
    covered in detail later.
 
-^^^^^^^^^^^^^^^^^^^^^^^^^
-Non-downloadable software
-^^^^^^^^^^^^^^^^^^^^^^^^^
-
-If your software cannot be downloaded from a URL you can still create a boilerplate
+Passing a URL to ``spack create`` is a convenient and easy way to get
+a basic package template, but what if your software is licensed and
+cannot be downloaded from a URL? You can still create a boilerplate
 ``package.py`` by telling ``spack create`` what name you want to use:
 
 .. code-block:: console
@@ -345,23 +223,40 @@ If your software cannot be downloaded from a URL you can still create a boilerpl
 
 This will create a simple ``intel`` package with an ``install()``
 method that you can craft to install your package.
-Likewise, you can force the build system to be used with ``--template`` and,
-in case it's needed, you can overwrite a package already in the repository
-with ``--force``:
+
+What if ``spack create <url>`` guessed the wrong name or build system?
+For example, if your package uses the Autotools build system but does
+not come with a ``configure`` script, Spack won't realize it uses
+Autotools. You can overwrite the old package with ``--force`` and specify
+a name with ``--name`` or a build system template to use with ``--template``:
 
 .. code-block:: console
 
    $ spack create --name gmp https://gmplib.org/download/gmp/gmp-6.1.2.tar.bz2
    $ spack create --force --template autotools https://gmplib.org/download/gmp/gmp-6.1.2.tar.bz2
 
+.. note::
+
+   If you are creating a package that uses the Autotools build system
+   but does not come with a ``configure`` script, you'll need to add an
+   ``autoreconf`` method to your package that explains how to generate
+   the ``configure`` script. You may also need the following dependencies:
+
+   .. code-block:: python
+
+      depends_on('autoconf', type='build')
+      depends_on('automake', type='build')
+      depends_on('libtool',  type='build')
+      depends_on('m4',       type='build')
+
 A complete list of available build system templates can be found by running
 ``spack create --help``.
 
 .. _cmd-spack-edit:
 
--------------------------
-Editing existing packages
--------------------------
+^^^^^^^^^^^^^^
+``spack edit``
+^^^^^^^^^^^^^^
 
 One of the easiest ways to learn how to write packages is to look at
 existing ones.  You can edit a package file by name with the ``spack
@@ -371,15 +266,10 @@ edit`` command:
 
    $ spack edit gmp
 
-If you used ``spack create`` to create a package, you can get back to
-it later with ``spack edit``. For instance, the ``gmp`` package actually
-lives in:
-
-.. code-block:: console
-
-   $ spack location -p gmp
-   ${SPACK_ROOT}/var/spack/repos/builtin/packages/gmp/package.py
-
+So, if you used ``spack create`` to create a package, then saved and
+closed the resulting file, you can get back to it with ``spack edit``.
+The ``gmp`` package actually lives in
+``$SPACK_ROOT/var/spack/repos/builtin/packages/gmp/package.py``,
 but ``spack edit`` provides a much simpler shortcut and saves you the
 trouble of typing the full path.
 
@@ -2532,7 +2422,7 @@ Spack provides a mechanism for dependencies to influence the
 environment of their dependents by overriding  the
 :meth:`setup_dependent_run_environment <spack.package_base.PackageBase.setup_dependent_run_environment>`
 or the
-:meth:`setup_dependent_build_environment <spack.builder.Builder.setup_dependent_build_environment>`
+:meth:`setup_dependent_build_environment <spack.package_base.PackageBase.setup_dependent_build_environment>`
 methods.
 The Qt package, for instance, uses this call:
 
@@ -3390,91 +3280,67 @@ the Python extensions provided by them: once for ``+python`` and once
 for ``~python``.  Other than using a little extra disk space, that
 solution has no serious problems.
 
-.. _installation_process:
+.. _installation_procedure:
 
---------------------------------
-Overriding build system defaults
---------------------------------
+---------------------------------------
+Implementing the installation procedure
+---------------------------------------
 
-.. note::
+The last element of a package is its **installation procedure**.  This is
+where the real work of installation happens, and it's the main part of
+the package you'll need to customize for each piece of software.
 
-   If you code a single class in ``package.py`` all the functions shown in the table below
-   can be implemented with the same signature on the ``*Package`` instead of the corresponding builder.
-
-
-Most of the time the default implementation of methods or attributes in build system base classes
-is what a packager needs, and just a very few entities need to be overwritten. Typically we just
-need to override methods like ``configure_args``:
-
-.. code-block:: python
-
-   def configure_args(self):
-        args = ["--enable-cxx"] + self.enable_or_disable("libs")
-        if "libs=static" in self.spec:
-            args.append("--with-pic")
-        return args
-
-The actual set of entities available for overriding in ``package.py`` depend on
-the build system. The build systems currently supported by Spack are:
+Defining an installation procedure means overriding a set of methods or attributes
+that will be called at some point during the installation of the package.
+The package base class, usually specialized for a given build system, determines the
+actual set of entities available for overriding.
+The classes that are currently provided by Spack are:
 
 +----------------------------------------------------------+----------------------------------+
-|     **API docs**                                         |           **Description**        |
+|     **Base Class**                                       |           **Purpose**            |
 +==========================================================+==================================+
-| :class:`~spack.build_systems.generic`                    | Generic build system without any |
-|                                                          | base implementation              |
+| :class:`~spack.package_base.Package`                     | General base class not           |
+|                                                          | specialized for any build system |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack.build_systems.makefile`                   | Specialized build system for     |
-|                                                          | software built invoking          |
+| :class:`~spack.build_systems.makefile.MakefilePackage`   | Specialized class for packages   |
+|                                                          | built invoking                   |
 |                                                          | hand-written Makefiles           |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack.build_systems.autotools`                  | Specialized build system for     |
-|                                                          | software built using             |
-|                                                          | GNU Autotools                    |
+| :class:`~spack.build_systems.autotools.AutotoolsPackage` | Specialized class for packages   |
+|                                                          | built using GNU Autotools        |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack.build_systems.cmake`                      | Specialized build system for     |
-|                                                          | software built using CMake       |
+| :class:`~spack.build_systems.cmake.CMakePackage`         | Specialized class for packages   |
+|                                                          | built using CMake                |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack.build_systems.maven`                      | Specialized build system for     |
-|                                                          | software built using Maven       |
+| :class:`~spack.build_systems.cuda.CudaPackage`           | A helper class for packages that |
+|                                                          | use CUDA                         |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack.build_systems.meson`                      | Specialized build system for     |
-|                                                          | software built using Meson       |
+| :class:`~spack.build_systems.qmake.QMakePackage`         | Specialized class for packages   |
+|                                                          | built using QMake                |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack.build_systems.nmake`                      | Specialized build system for     |
-|                                                          | software built using NMake       |
+| :class:`~spack.build_systems.rocm.ROCmPackage`           | A helper class for packages that |
+|                                                          | use ROCm                         |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack.build_systems.qmake`                      | Specialized build system for     |
-|                                                          | software built using QMake       |
+| :class:`~spack.build_systems.scons.SConsPackage`         | Specialized class for packages   |
+|                                                          | built using SCons                |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack.build_systems.scons`                      | Specialized build system for     |
-|                                                          | software built using SCons       |
+| :class:`~spack.build_systems.waf.WafPackage`             | Specialized class for packages   |
+|                                                          | built using Waf                  |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack.build_systems.waf`                        | Specialized build system for     |
-|                                                          | software built using Waf         |
-+----------------------------------------------------------+----------------------------------+
-| :class:`~spack.build_systems.r`                          | Specialized build system for     |
+| :class:`~spack.build_systems.r.RPackage`                 | Specialized class for            |
 |                                                          | R extensions                     |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack.build_systems.octave`                     | Specialized build system for     |
+| :class:`~spack.build_systems.octave.OctavePackage`       | Specialized class for            |
 |                                                          | Octave packages                  |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack.build_systems.python`                     | Specialized build system for     |
+| :class:`~spack.build_systems.python.PythonPackage`       | Specialized class for            |
 |                                                          | Python extensions                |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack.build_systems.perl`                       | Specialized build system for     |
+| :class:`~spack.build_systems.perl.PerlPackage`           | Specialized class for            |
 |                                                          | Perl extensions                  |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack.build_systems.ruby`                       | Specialized build system for     |
-|                                                          | Ruby extensions                  |
-+----------------------------------------------------------+----------------------------------+
-| :class:`~spack.build_systems.intel`                      | Specialized build system for     |
-|                                                          | licensed Intel software          |
-+----------------------------------------------------------+----------------------------------+
-| :class:`~spack.build_systems.oneapi`                     | Specialized build system for     |
-|                                                          | Intel onaAPI software            |
-+----------------------------------------------------------+----------------------------------+
-| :class:`~spack.build_systems.aspell_dict`                | Specialized build system for     |
-|                                                          | Aspell dictionaries              |
+| :class:`~spack.build_systems.intel.IntelPackage`         | Specialized class for licensed   |
+|                                                          | Intel software                   |
 +----------------------------------------------------------+----------------------------------+
 
 
@@ -3487,17 +3353,52 @@ the build system. The build systems currently supported by Spack are:
         For example, a Python extension installed with CMake would ``extends('python')`` and
         subclass from :class:`~spack.build_systems.cmake.CMakePackage`.
 
-^^^^^^^^^^^^^^^^^^^^^^^^^^
-Overriding builder methods
-^^^^^^^^^^^^^^^^^^^^^^^^^^
+^^^^^^^^^^^^^^^^^^^^^
+Installation pipeline
+^^^^^^^^^^^^^^^^^^^^^
 
-Build-system "phases" have default implementations that fit most of the common cases:
+When a user runs ``spack install``, Spack:
+
+1. Fetches an archive for the correct version of the software.
+2. Expands the archive.
+3. Sets the current working directory to the root directory of the expanded archive.
+
+Then, depending on the base class of the package under consideration, it will execute
+a certain number of **phases** that reflect the way a package of that type is usually built.
+The name and order in which the phases will be executed can be obtained either reading the API
+docs at :py:mod:`~.spack.build_systems`, or using the ``spack info`` command:
+
+.. code-block:: console
+    :emphasize-lines: 13,14
+
+    $ spack info m4
+    AutotoolsPackage:    m4
+    Homepage:            https://www.gnu.org/software/m4/m4.html
+
+    Safe versions:
+        1.4.17    ftp://ftp.gnu.org/gnu/m4/m4-1.4.17.tar.gz
+
+    Variants:
+        Name       Default   Description
+
+        sigsegv    on        Build the libsigsegv dependency
+
+    Installation Phases:
+        autoreconf    configure    build    install
+
+    Build Dependencies:
+        libsigsegv
+
+    ...
+
+
+Typically, phases have default implementations that fit most of the common cases:
 
 .. literalinclude:: _spack_root/lib/spack/spack/build_systems/autotools.py
-    :pyobject: AutotoolsBuilder.configure
+    :pyobject: AutotoolsPackage.configure
     :linenos:
 
-It is usually sufficient for a packager to override a few
+It is thus just sufficient for a packager to override a few
 build system specific helper methods or attributes to provide, for instance,
 configure arguments:
 
@@ -3505,31 +3406,31 @@ configure arguments:
     :pyobject: M4.configure_args
     :linenos:
 
-Each specific build system has a list of attributes and methods that can be overridden to
-fine-tune the installation of a package without overriding an entire phase. To
-have more information on them the place to go is the API docs of the :py:mod:`~.spack.build_systems`
-module.
+.. note::
+    Each specific build system has a list of attributes that can be overridden to
+    fine-tune the installation of a package without overriding an entire phase. To
+    have more information on them the place to go is the API docs of the :py:mod:`~.spack.build_systems`
+    module.
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 Overriding an entire phase
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Sometimes it is necessary to override an entire phase. If the ``package.py`` contains
-a single class recipe, see :ref:`package_class_structure`, then the signature for a
-phase is:
+In extreme cases it may be necessary to override an entire phase. Regardless
+of the build system, the signature is the same. For example, the signature
+for the install phase is:
 
 .. code-block:: python
 
-   class Openjpeg(CMakePackage):
+   class Foo(Package):
        def install(self, spec, prefix):
            ...
 
-regardless of the build system. The arguments for the phase are:
-
 ``self``
-    This is the package object, which extends ``CMakePackage``.
-    For API docs on Package objects, see
-    :py:class:`Package <spack.package_base.PackageBase>`.
+    For those not used to Python instance methods, this is the
+    package itself.  In this case it's an instance of ``Foo``, which
+    extends ``Package``.  For API docs on Package objects, see
+    :py:class:`Package <spack.package_base.Package>`.
 
 ``spec``
     This is the concrete spec object created by Spack from an
@@ -3544,111 +3445,12 @@ regardless of the build system. The arguments for the phase are:
 The arguments ``spec`` and ``prefix`` are passed only for convenience, as they always
 correspond to ``self.spec`` and ``self.spec.prefix`` respectively.
 
-If the ``package.py`` encodes builders explicitly, the signature for a phase changes slightly:
-
-.. code-block:: python
-
-   class CMakeBuilder(spack.build_systems.cmake.CMakeBuilder):
-       def install(self, pkg, spec, prefix):
-           ...
-
-In this case the package is passed as the second argument, and ``self`` is the builder instance.
-
-.. _multiple_build_systems:
-
-^^^^^^^^^^^^^^^^^^^^^^
-Multiple build systems
-^^^^^^^^^^^^^^^^^^^^^^
-
-There are cases where a software actively supports two build systems, or changes build systems
-as it evolves, or needs different build systems on different platforms. Spack allows dealing with
-these cases natively, if a recipe is written using builders explicitly.
-
-For instance, software that supports two build systems unconditionally should derive from
-both ``*Package`` base classes, and declare the possible use of multiple build systems using
-a directive:
-
-.. code-block:: python
-
-   class ArpackNg(CMakePackage, AutotoolsPackage):
-
-       build_system("cmake", "autotools", default="cmake")
-
-In this case the software can be built with both ``autotools`` and ``cmake``. Since the package
-supports multiple build systems, it is necessary to declare which one is the default. The ``package.py``
-will likely contain some overriding of default builder methods:
-
-.. code-block:: python
-
-   class CMakeBuilder(spack.build_systems.cmake.CMakeBuilder):
-       def cmake_args(self):
-           pass
-
-   class Autotoolsbuilder(spack.build_systems.autotools.AutotoolsBuilder):
-       def configure_args(self):
-           pass
-
-In more complex cases it might happen that the build system changes according to certain conditions,
-for instance across versions. That can be expressed with conditional variant values:
-
-.. code-block:: python
-
-   class ArpackNg(CMakePackage, AutotoolsPackage):
-
-       build_system(
-           conditional("cmake", when="@0.64:"),
-           conditional("autotools", when="@:0.63"),
-           default="cmake",
-       )
-
-In the example the directive impose a change from ``Autotools`` to ``CMake`` going
-from ``v0.63`` to ``v0.64``.
-
-^^^^^^^^^^^^^^^^^^
-Mixin base classes
-^^^^^^^^^^^^^^^^^^
-
-Besides build systems, there are other cases where common metadata and behavior can be extracted
-and reused by many packages. For instance, packages that depend on ``Cuda`` or ``Rocm``, share
-common dependencies and constraints. To factor these attributes into a single place, Spack provides
-a few mixin classes in the ``spack.build_systems`` module:
-
-+---------------------------------------------------------------+----------------------------------+
-|     **API docs**                                              |           **Description**        |
-+===============================================================+==================================+
-| :class:`~spack.build_systems.cuda.CudaPackage`                | A helper class for packages that |
-|                                                               | use CUDA                         |
-+---------------------------------------------------------------+----------------------------------+
-| :class:`~spack.build_systems.rocm.ROCmPackage`                | A helper class for packages that |
-|                                                               | use ROCm                         |
-+---------------------------------------------------------------+----------------------------------+
-| :class:`~spack.build_systems.gnu.GNUMirrorPackage`            | A helper class for GNU packages  |
-+---------------------------------------------------------------+----------------------------------+
-| :class:`~spack.build_systems.python.PythonExtension`          | A helper class for Python        |
-|                                                               | extensions                       |
-+---------------------------------------------------------------+----------------------------------+
-| :class:`~spack.build_systems.sourceforge.SourceforgePackage`  | A helper class for packages      |
-|                                                               | from sourceforge.org             |
-+---------------------------------------------------------------+----------------------------------+
-| :class:`~spack.build_systems.sourceware.SourcewarePackage`    | A helper class for packages      |
-|                                                               | from sourceware.org              |
-+---------------------------------------------------------------+----------------------------------+
-| :class:`~spack.build_systems.xorg.XorgPackage`                | A helper class for x.org         |
-|                                                               | packages                         |
-+---------------------------------------------------------------+----------------------------------+
-
-These classes should be used by adding them to the inheritance tree of the package that needs them,
-for instance:
-
-.. code-block:: python
-
-   class Cp2k(MakefilePackage, CudaPackage):
-       """CP2K is a quantum chemistry and solid state physics software package
-       that can perform atomistic simulations of solid state, liquid, molecular,
-       periodic, material, crystal, and biological systems
-       """
-
-In the example above ``Cp2k`` inherits all the conflicts and variants that ``CudaPackage`` defines.
+As mentioned in :ref:`install-environment`, you will usually not need to refer
+to dependencies explicitly in your package file, as the compiler wrappers take care of most of
+the heavy lifting here.  There will be times, though, when you need to refer to
+the install locations of dependencies, or when you need to do something different
+depending on the version, compiler, dependencies, etc. that your package is
+built with.  These parameters give you access to this type of information.
 
 .. _install-environment:
 
@@ -4406,9 +4208,16 @@ In addition to invoking the right compiler, the compiler wrappers add
 flags to the compile line so that dependencies can be easily found.
 These flags are added for each dependency, if they exist:
 
-* Compile-time library search paths: ``-L$dep_prefix/lib``, ``-L$dep_prefix/lib64``
-* Runtime library search paths (RPATHs): ``$rpath_flag$dep_prefix/lib``, ``$rpath_flag$dep_prefix/lib64``
-* Include search paths: ``-I$dep_prefix/include``
+Compile-time library search paths
+* ``-L$dep_prefix/lib``
+* ``-L$dep_prefix/lib64``
+
+Runtime library search paths (RPATHs)
+* ``$rpath_flag$dep_prefix/lib``
+* ``$rpath_flag$dep_prefix/lib64``
+
+Include search paths
+* ``-I$dep_prefix/include``
 
 An example of this would be the ``libdwarf`` build, which has one
 dependency: ``libelf``.  Every call to ``cc`` in the ``libdwarf``
@@ -4752,9 +4561,6 @@ other checks.
    * - :ref:`AutotoolsPackage <autotoolspackage>`
      - ``check`` (``make test``, ``make check``)
      - ``installcheck`` (``make installcheck``)
-   * - :ref:`CachedCMakePackage <cachedcmakepackage>`
-     - ``check`` (``make check``, ``make test``)
-     - Not applicable
    * - :ref:`CMakePackage <cmakepackage>`
      - ``check`` (``make check``, ``make test``)
      - Not applicable
@@ -4779,9 +4585,6 @@ other checks.
    * - :ref:`SIPPackage <sippackage>`
      - Not applicable
      - ``test`` (module imports)
-   * - :ref:`WafPackage <wafpackage>`
-     - ``build_test`` (must be overridden)
-     - ``install_test`` (must be overridden)
 
 For example, the ``Libelf`` package inherits from ``AutotoolsPackage``
 and its ``Makefile`` has a standard ``check`` target. So Spack will
@@ -5253,16 +5056,6 @@ where each argument has the following meaning:
   will run.
 
   The default of ``None`` corresponds to the current directory (``'.'``).
-  Each call starts with the working directory set to the spec's test stage
-  directory (i.e., ``self.test_suite.test_dir_for_spec(self.spec)``).
-
-.. warning::
-
-   Use of the package spec's installation directory for building and running
-   tests is **strongly** discouraged. Doing so has caused permission errors
-   for shared spack instances *and* for facilities that install the software
-   in read-only file systems or directories.
-
 
 """""""""""""""""""""""""""""""""""""""""
 Accessing package- and test-related files
@@ -5270,10 +5063,10 @@ Accessing package- and test-related files
 
 You may need to access files from one or more locations when writing
 stand-alone tests. This can happen if the software's repository does not
-include test source files or includes files but has no way to build the
-executables using the installed headers and libraries. In these cases,
-you may need to reference the files relative to one or more root
-directory. The properties containing package- (or spec-) and test-related
+include test source files or includes files but no way to build the
+executables using the installed headers and libraries. In these
+cases, you may need to reference the files relative to one or more
+root directory. The properties containing package- and test-related
 directory paths are provided in the table below.
 
 .. list-table:: Directory-to-property mapping
@@ -5282,22 +5075,19 @@ directory paths are provided in the table below.
    * - Root Directory
      - Package Property
      - Example(s)
-   * - Package (Spec) Installation
+   * - Package Installation Files
      - ``self.prefix``
      - ``self.prefix.include``, ``self.prefix.lib``
-   * - Dependency Installation
+   * - Package Dependency's Files
      - ``self.spec['<dependency-package>'].prefix``
      - ``self.spec['trilinos'].prefix.include``
-   * - Test Suite Stage
+   * - Test Suite Stage Files
      - ``self.test_suite.stage``
      - ``join_path(self.test_suite.stage, 'results.txt')``
-   * - Spec's Test Stage
-     - ``self.test_suite.test_dir_for_spec``
-     - ``self.test_suite.test_dir_for_spec(self.spec)``
-   * - Current Spec's Build-time Files
+   * - Staged Cached Build-time Files
      - ``self.test_suite.current_test_cache_dir``
      - ``join_path(self.test_suite.current_test_cache_dir, 'examples', 'foo.c')``
-   * - Current Spec's Custom Test Files
+   * - Staged Custom Package Files
      - ``self.test_suite.current_test_data_dir``
      - ``join_path(self.test_suite.current_test_data_dir, 'hello.f90')``
 
@@ -6303,82 +6093,3 @@ might write:
    DWARF_PREFIX = $(spack location --install-dir libdwarf)
    CXXFLAGS += -I$DWARF_PREFIX/include
    CXXFLAGS += -L$DWARF_PREFIX/lib
-
-
-.. _package_class_structure:
-
---------------------------
-Package class architecture
---------------------------
-
-.. note::
-
-   This section aims to provide a high-level knowledge of how the package class architecture evolved
-   in Spack, and provides some insights on the current design.
-
-Packages in Spack were originally designed to support only a single build system. The overall
-class structure for a package looked like:
-
-.. image:: images/original_package_architecture.png
-   :scale: 60 %
-   :align: center
-
-In this architecture the base class ``AutotoolsPackage`` was responsible for both the metadata
-related to the ``autotools`` build system (e.g. dependencies or variants common to all packages
-using it), and for encoding the default installation procedure.
-
-In reality, a non-negligible number of packages are either changing their build system during the evolution of the
-project, or using different build systems for different platforms. An architecture based on a single class
-requires hacks or other workarounds to deal with these cases.
-
-To support a model more adherent to reality, Spack v0.19 changed its internal design by extracting
-the attributes and methods related to building a software into a separate hierarchy:
-
-.. image:: images/builder_package_architecture.png
-   :scale: 60 %
-   :align: center
-
-In this new format each ``package.py`` contains one ``*Package`` class that gathers all the metadata,
-and one or more ``*Builder`` classes that encode the installation procedure. A specific builder object
-is created just before the software is built, so at a time where Spack knows which build system needs
-to be used for the current installation, and receives a ``package`` object during initialization.
-
-^^^^^^^^^^^^^^^^^^^^^^^^
-``build_system`` variant
-^^^^^^^^^^^^^^^^^^^^^^^^
-
-To allow imposing conditions based on the build system, each package must a have ``build_system`` variant,
-which is usually inherited from base classes. This variant allows for writing metadata that is conditional
-on the build system:
-
-.. code-block:: python
-
-   with when("build_system=cmake"):
-       depends_on("cmake", type="build")
-
-and also for selecting a specific build system from a spec literal, like in the following command:
-
-.. code-block:: console
-
-   $ spack install arpack-ng build_system=autotools
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Compatibility with single-class format
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Internally, Spack always uses builders to perform operations related to the installation of a specific software.
-The builders are created in the ``spack.builder.create`` function
-
-.. literalinclude:: _spack_root/lib/spack/spack/builder.py
-   :pyobject: create
-
-To achieve backward compatibility with the single-class format Spack creates in this function a special
-"adapter builder", if no custom builder is detected in the recipe:
-
-.. image:: images/adapter.png
-   :scale: 60 %
-   :align: center
-
-Overall the role of the adapter is to route access to attributes of methods first through the ``*Package``
-hierarchy, and then back to the base class builder. This is schematically shown in the diagram above, where
-the adapter role is to "emulate" a method resolution order like the one represented by the red arrows.

lib/spack/docs/pipelines.rst

@@ -5,9 +5,9 @@
 
 .. _pipelines:
 
-============
-CI Pipelines
-============
+=========
+Pipelines
+=========
 
 Spack provides commands that support generating and running automated build
 pipelines designed for Gitlab CI.  At the highest level it works like this:
@@ -168,7 +168,7 @@ 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
@@ -267,64 +267,24 @@ generated by jobs in the pipeline.
 ``spack ci rebuild``
 ^^^^^^^^^^^^^^^^^^^^^
 
-The purpose of ``spack ci rebuild`` is straightforward: take its 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 ``gitlab-ci`` 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
-``gitlab-ci`` script.
-
-.. code-block:: yaml
-
-  gitlab-ci:
-    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:
 
@@ -487,7 +447,7 @@ 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).  An optional ``service-job-attributes`` section
 can be added to your ``spack.yaml`` where you can provide ``tags`` and
@@ -765,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:
 

lib/spack/docs/requirements.txt

@@ -3,7 +3,6 @@
 
 sphinx>=3.4,!=4.1.2,!=5.1.0
 sphinxcontrib-programoutput
-sphinx-design
 sphinx-rtd-theme
 python-levenshtein
 # Restrict to docutils <0.17 to workaround a list rendering issue in sphinx.

lib/spack/docs/spack.yaml

@@ -18,10 +18,7 @@ spack:
   - "py-sphinx@3.4:4.1.1,4.1.3:"
   - py-sphinxcontrib-programoutput
   - py-docutils@:0.16
-  - py-sphinx-design
   - py-sphinx-rtd-theme
-  - py-pygments@:2.12
-
   # VCS
   - git
   - mercurial

lib/spack/docs/tables/system_prerequisites.csv

@@ -1,5 +1,5 @@
 Name, Supported Versions, Notes, Requirement Reason
-Python, 2.7/3.6-3.11, , Interpreter for Spack
+Python, 2.7/3.6-3.10, , Interpreter for Spack
 C/C++ Compilers, , , Building software
 make, , , Build software
 patch, , , Build software
@@ -11,7 +11,6 @@ bzip2, , , Compress/Decompress archives
 xz, , , Compress/Decompress archives
 zstd, , Optional, Compress/Decompress archives
 file, , , Create/Use Buildcaches
-lsb-release, , , Linux: identify operating system version
 gnupg2, , , Sign/Verify Buildcaches
 git, , , Manage Software Repositories
 svn, , Optional, Manage Software Repositories

lib/spack/env/cc

@@ -241,28 +241,28 @@ case "$command" in
         mode=cpp
         debug_flags="-g"
         ;;
-    cc|c89|c99|gcc|clang|armclang|icc|icx|pgcc|nvc|xlc|xlc_r|fcc|amdclang|cl.exe|craycc)
+    cc|c89|c99|gcc|clang|armclang|icc|icx|pgcc|nvc|xlc|xlc_r|fcc|amdclang|cl.exe)
         command="$SPACK_CC"
         language="C"
         comp="CC"
         lang_flags=C
         debug_flags="-g"
         ;;
-    c++|CC|g++|clang++|armclang++|icpc|icpx|dpcpp|pgc++|nvc++|xlc++|xlc++_r|FCC|amdclang++|crayCC)
+    c++|CC|g++|clang++|armclang++|icpc|icpx|dpcpp|pgc++|nvc++|xlc++|xlc++_r|FCC|amdclang++)
         command="$SPACK_CXX"
         language="C++"
         comp="CXX"
         lang_flags=CXX
         debug_flags="-g"
         ;;
-    ftn|f90|fc|f95|gfortran|flang|armflang|ifort|ifx|pgfortran|nvfortran|xlf90|xlf90_r|nagfor|frt|amdflang|crayftn)
+    ftn|f90|fc|f95|gfortran|flang|armflang|ifort|ifx|pgfortran|nvfortran|xlf90|xlf90_r|nagfor|frt|amdflang)
         command="$SPACK_FC"
         language="Fortran 90"
         comp="FC"
         lang_flags=F
         debug_flags="-g"
         ;;
-    f77|xlf|xlf_r|pgf77)
+    f77|xlf|xlf_r|pgf77|amdflang)
         command="$SPACK_F77"
         language="Fortran 77"
         comp="F77"

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

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

lib/spack/env/cce/craycc

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

lib/spack/env/cce/crayftn

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

lib/spack/external/__init__.py

@@ -18,7 +18,7 @@
 
 * Homepage: https://pypi.python.org/pypi/archspec
 * Usage: Labeling, comparison and detection of microarchitectures
-* Version: 0.2.0 (commit 77640e572725ad97f18e63a04857155752ace045)
+* Version: 0.1.4 (commit b8eea9df2b4204ff27d204452cd46f5199a0b423)
 
 argparse
 --------

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

@@ -132,15 +132,9 @@ def sysctl(*args):
             "model name": sysctl("-n", "machdep.cpu.brand_string"),
         }
     else:
-        model = "unknown"
-        model_str = sysctl("-n", "machdep.cpu.brand_string").lower()
-        if "m2" in model_str:
-            model = "m2"
-        elif "m1" in model_str:
-            model = "m1"
-        elif "apple" in model_str:
-            model = "m1"
-
+        model = (
+            "m1" if "Apple" in sysctl("-n", "machdep.cpu.brand_string") else "unknown"
+        )
         info = {
             "vendor_id": "Apple",
             "flags": [],
@@ -328,26 +322,14 @@ def compatibility_check_for_aarch64(info, target):
     features = set(info.get("Features", "").split())
     vendor = info.get("CPU implementer", "generic")
 
-    # At the moment it's not clear how to detect compatibility with
-    # a specific version of the architecture
-    if target.vendor == "generic" and target.name != "aarch64":
-        return False
-
     arch_root = TARGETS[basename]
-    arch_root_and_vendor = arch_root == target.family and target.vendor in (
-        vendor,
-        "generic",
+    return (
+        (target == arch_root or arch_root in target.ancestors)
+        and target.vendor in (vendor, "generic")
+        # On macOS it seems impossible to get all the CPU features with syctl info
+        and (target.features.issubset(features) or platform.system() == "Darwin")
     )
 
-    # On macOS it seems impossible to get all the CPU features
-    # with syctl info, but for ARM we can get the exact model
-    if platform.system() == "Darwin":
-        model_key = info.get("model", basename)
-        model = TARGETS[model_key]
-        return arch_root_and_vendor and (target == model or target in model.ancestors)
-
-    return arch_root_and_vendor and target.features.issubset(features)
-
 
 @compatibility_check(architecture_family="riscv64")
 def compatibility_check_for_riscv64(info, target):

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

@@ -106,7 +106,7 @@ def __eq__(self, other):
             self.name == other.name
             and self.vendor == other.vendor
             and self.features == other.features
-            and self.parents == other.parents  # avoid ancestors here
+            and self.ancestors == other.ancestors
             and self.compilers == other.compilers
             and self.generation == other.generation
         )

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

@@ -85,7 +85,7 @@
         "intel": [
           {
             "versions": ":",
-            "name": "pentium4",
+            "name": "x86-64",
             "flags": "-march={name} -mtune=generic"
           }
         ],
@@ -1099,7 +1099,8 @@
         "avx512cd",
         "avx512vbmi",
         "avx512ifma",
-        "sha"
+        "sha",
+        "umip"
       ],
       "compilers": {
         "gcc": [
@@ -1262,6 +1263,7 @@
         "avx512vbmi",
         "avx512ifma",
         "sha_ni",
+        "umip",
         "clwb",
         "rdpid",
         "gfni",
@@ -2093,163 +2095,8 @@
         ]
       }
     },
-    "armv8.1a": {
-      "from": ["aarch64"],
-      "vendor": "generic",
-      "features": [],
-      "compilers": {
-        "gcc": [
-          {
-            "versions": "5:",
-            "flags": "-march=armv8.1-a -mtune=generic"
-          }
-        ],
-        "clang": [
-          {
-            "versions": ":",
-            "flags": "-march=armv8.1-a -mtune=generic"
-          }
-        ],
-        "apple-clang": [
-          {
-            "versions": ":",
-            "flags": "-march=armv8.1-a -mtune=generic"
-          }
-        ],
-        "arm": [
-          {
-            "versions": ":",
-            "flags": "-march=armv8.1-a -mtune=generic"
-          }
-        ]
-      }
-    },
-    "armv8.2a": {
-      "from": ["armv8.1a"],
-      "vendor": "generic",
-      "features": [],
-      "compilers": {
-        "gcc": [
-          {
-            "versions": "6:",
-            "flags": "-march=armv8.2-a -mtune=generic"
-          }
-        ],
-        "clang": [
-          {
-            "versions": ":",
-            "flags": "-march=armv8.2-a -mtune=generic"
-          }
-        ],
-        "apple-clang": [
-          {
-            "versions": ":",
-            "flags": "-march=armv8.2-a -mtune=generic"
-          }
-        ],
-        "arm": [
-          {
-            "versions": ":",
-            "flags": "-march=armv8.2-a -mtune=generic"
-          }
-        ]
-      }
-    },
-    "armv8.3a": {
-      "from": ["armv8.2a"],
-      "vendor": "generic",
-      "features": [],
-      "compilers": {
-        "gcc": [
-          {
-            "versions": "6:",
-            "flags": "-march=armv8.3-a -mtune=generic"
-          }
-        ],
-        "clang": [
-          {
-            "versions": "6:",
-            "flags": "-march=armv8.3-a -mtune=generic"
-          }
-        ],
-        "apple-clang": [
-          {
-            "versions": ":",
-            "flags": "-march=armv8.3-a -mtune=generic"
-          }
-        ],
-        "arm": [
-          {
-            "versions": ":",
-            "flags": "-march=armv8.3-a -mtune=generic"
-          }
-        ]
-      }
-    },
-    "armv8.4a": {
-      "from": ["armv8.3a"],
-      "vendor": "generic",
-      "features": [],
-      "compilers": {
-        "gcc": [
-          {
-            "versions": "8:",
-            "flags": "-march=armv8.4-a -mtune=generic"
-          }
-        ],
-        "clang": [
-          {
-            "versions": "8:",
-            "flags": "-march=armv8.4-a -mtune=generic"
-          }
-        ],
-        "apple-clang": [
-          {
-            "versions": ":",
-            "flags": "-march=armv8.4-a -mtune=generic"
-          }
-        ],
-        "arm": [
-          {
-            "versions": ":",
-            "flags": "-march=armv8.4-a -mtune=generic"
-          }
-        ]
-      }
-    },
-    "armv8.5a": {
-      "from": ["armv8.4a"],
-      "vendor": "generic",
-      "features": [],
-      "compilers": {
-        "gcc": [
-          {
-            "versions": "9:",
-            "flags": "-march=armv8.5-a -mtune=generic"
-          }
-        ],
-        "clang": [
-          {
-            "versions": "11:",
-            "flags": "-march=armv8.5-a -mtune=generic"
-          }
-        ],
-        "apple-clang": [
-          {
-            "versions": ":",
-            "flags": "-march=armv8.5-a -mtune=generic"
-          }
-        ],
-        "arm": [
-          {
-            "versions": ":",
-            "flags": "-march=armv8.5-a -mtune=generic"
-          }
-        ]
-      }
-    },
     "thunderx2": {
-      "from": ["armv8.1a"],
+      "from": ["aarch64"],
       "vendor": "Cavium",
       "features": [
         "fp",
@@ -2296,7 +2143,7 @@
       }
     },
     "a64fx": {
-      "from": ["armv8.2a"],
+      "from": ["aarch64"],
       "vendor": "Fujitsu",
       "features": [
         "fp",
@@ -2364,7 +2211,7 @@
         ]
       }
     },
-    "cortex_a72": {
+    "graviton": {
       "from": ["aarch64"],
       "vendor": "ARM",
       "features": [
@@ -2390,19 +2237,19 @@
               },
               {
                   "versions": "6:",
-                  "flags" : "-mcpu=cortex-a72"
+                  "flags" : "-march=armv8-a+crc+crypto -mtune=cortex-a72"
               }
           ],
           "clang" : [
               {
                   "versions": "3.9:",
-                  "flags" : "-mcpu=cortex-a72"
+                  "flags" : "-march=armv8-a+crc+crypto"
               }
           ]
       }
     },
-    "neoverse_n1": {
-      "from": ["cortex_a72", "armv8.2a"],
+    "graviton2": {
+      "from": ["aarch64"],
       "vendor": "ARM",
       "features": [
           "fp",
@@ -2451,7 +2298,7 @@
               },
               {
                   "versions": "9.0:",
-                  "flags" : "-mcpu=neoverse-n1"
+                  "flags" : "-march=armv8.2-a+fp16+rcpc+dotprod+crypto -mtune=neoverse-n1"
               }
           ],
           "clang" : [
@@ -2462,10 +2309,6 @@
               {
                   "versions": "5:",
                   "flags" : "-march=armv8.2-a+fp16+rcpc+dotprod+crypto"
-              },
-              {
-                  "versions": "10:",
-                  "flags" : "-mcpu=neoverse-n1"
               }
           ],
           "arm" : [
@@ -2476,113 +2319,8 @@
           ]
       }
     },
-    "neoverse_v1": {
-      "from": ["neoverse_n1", "armv8.4a"],
-      "vendor": "ARM",
-      "features": [
-          "fp",
-          "asimd",
-          "evtstrm",
-          "aes",
-          "pmull",
-          "sha1",
-          "sha2",
-          "crc32",
-          "atomics",
-          "fphp",
-          "asimdhp",
-          "cpuid",
-          "asimdrdm",
-          "jscvt",
-          "fcma",
-          "lrcpc",
-          "dcpop",
-          "sha3",
-          "sm3",
-          "sm4",
-          "asimddp",
-          "sha512",
-          "sve",
-          "asimdfhm",
-          "dit",
-          "uscat",
-          "ilrcpc",
-          "flagm",
-          "ssbs",
-          "paca",
-          "pacg",
-          "dcpodp",
-          "svei8mm",
-          "svebf16",
-          "i8mm",
-          "bf16",
-          "dgh",
-          "rng"
-      ],
-      "compilers" : {
-          "gcc": [
-              {
-                  "versions": "4.8:4.8.9",
-                  "flags": "-march=armv8-a"
-              },
-              {
-                  "versions": "4.9:5.9",
-                  "flags": "-march=armv8-a+crc+crypto"
-              },
-              {
-                  "versions": "6:6.9",
-                  "flags" : "-march=armv8.1-a"
-              },
-              {
-                  "versions": "7:7.9",
-                  "flags" : "-march=armv8.2-a+crypto+fp16 -mtune=cortex-a72"
-              },
-              {
-                  "versions": "8.0:8.9",
-                  "flags" : "-march=armv8.2-a+fp16+dotprod+crypto -mtune=cortex-a72"
-              },
-              {
-                  "versions": "9.0:9.9",
-                  "flags" : "-mcpu=neoverse-v1"
-              },
-	            {
-                  "versions": "10.0:",
-                  "flags" : "-mcpu=neoverse-v1"
-              }
-
-          ],
-          "clang" : [
-              {
-                  "versions": "3.9:4.9",
-                  "flags" : "-march=armv8.2-a+fp16+crc+crypto"
-              },
-              {
-                  "versions": "5:10",
-                  "flags" : "-march=armv8.2-a+fp16+rcpc+dotprod+crypto"
-              },
-              {
-                  "versions": "11:",
-                  "flags" : "-march=armv8.4-a+sve+ssbs+fp16+bf16+crypto+i8mm+rng"
-              },
-              {
-                  "versions": "12:",
-                  "flags" : "-mcpu=neoverse-v1"
-              }
-          ],
-          "arm" : [
-              {
-                  "versions": "20:21.9",
-                  "flags" : "-march=armv8.2-a+sve+fp16+rcpc+dotprod+crypto"
-              },
-	            {
-                  "versions": "22:",
-                  "flags" : "-march=armv8.4-a+sve+ssbs+fp16+bf16+crypto+i8mm+rng"
-              }
-          ]
-      }
-    },
     "m1": {
-      "from": ["armv8.4a"],
+      "from": ["aarch64"],
       "vendor": "Apple",
       "features": [
           "fp",
@@ -2647,76 +2385,6 @@
         ]
       }
     },
-    "m2": {
-      "from": ["m1", "armv8.5a"],
-      "vendor": "Apple",
-      "features": [
-          "fp",
-          "asimd",
-          "evtstrm",
-          "aes",
-          "pmull",
-          "sha1",
-          "sha2",
-          "crc32",
-          "atomics",
-          "fphp",
-          "asimdhp",
-          "cpuid",
-          "asimdrdm",
-          "jscvt",
-          "fcma",
-          "lrcpc",
-          "dcpop",
-          "sha3",
-          "asimddp",
-          "sha512",
-          "asimdfhm",
-          "dit",
-          "uscat",
-          "ilrcpc",
-          "flagm",
-          "ssbs",
-          "sb",
-          "paca",
-          "pacg",
-          "dcpodp",
-          "flagm2",
-          "frint",
-          "ecv",
-          "bf16",
-          "i8mm",
-          "bti"
-      ],
-      "compilers": {
-        "gcc": [
-          {
-            "versions": "8.0:",
-            "flags" : "-march=armv8.5-a -mtune=generic"
-          }
-        ],
-        "clang" : [
-          {
-            "versions": "9.0:12.0",
-            "flags" : "-march=armv8.5-a"
-          },
-          {
-            "versions": "13.0:",
-            "flags" : "-mcpu=apple-m1"
-          }
-        ],
-        "apple-clang": [
-          {
-            "versions": "11.0:12.5",
-            "flags" : "-march=armv8.5-a"
-          },
-          {
-            "versions": "13.0:",
-            "flags" : "-mcpu=vortex"
-          }
-        ]
-      }
-    },
     "arm": {
       "from": [],
       "vendor": "generic",

lib/spack/external/ctest_log_parser.py

@@ -71,8 +71,6 @@
 import re
 import math
 import multiprocessing
-import sys
-import threading
 import time
 from contextlib import contextmanager
 
@@ -411,12 +409,7 @@ def parse(self, stream, context=6, jobs=None):
             pool = multiprocessing.Pool(jobs)
             try:
                 # this is a workaround for a Python bug in Pool with ctrl-C
-                if sys.version_info >= (3, 2):
-                    max_timeout = threading.TIMEOUT_MAX
-                else:
-                    max_timeout = 9999999
-                results = pool.map_async(_parse_unpack, args, 1).get(max_timeout)
-
+                results = pool.map_async(_parse_unpack, args, 1).get(9999999)
                 errors, warnings, timings = zip(*results)
             finally:
                 pool.terminate()

lib/spack/llnl/util/filesystem.py

@@ -22,9 +22,9 @@
 from llnl.util import tty
 from llnl.util.compat import Sequence
 from llnl.util.lang import dedupe, memoized
-from llnl.util.symlink import islink, symlink
+from llnl.util.symlink import symlink
 
-from spack.util.executable import CommandNotFoundError, Executable, which
+from spack.util.executable import Executable
 from spack.util.path import path_to_os_path, system_path_filter
 
 is_windows = _platform == "win32"
@@ -113,69 +113,6 @@ def path_contains_subdirectory(path, root):
     return norm_path.startswith(norm_root)
 
 
-@memoized
-def file_command(*args):
-    """Creates entry point to `file` system command with provided arguments"""
-    try:
-        file_cmd = which("file", required=True)
-    except CommandNotFoundError as e:
-        if is_windows:
-            raise CommandNotFoundError("`file` utility is not available on Windows")
-        else:
-            raise e
-    for arg in args:
-        file_cmd.add_default_arg(arg)
-    return file_cmd
-
-
-@memoized
-def _get_mime_type():
-    """Generate method to call `file` system command to aquire mime type
-    for a specified path
-    """
-    return file_command("-b", "-h", "--mime-type")
-
-
-@memoized
-def _get_mime_type_compressed():
-    """Same as _get_mime_type but attempts to check for
-    compression first
-    """
-    mime_uncompressed = _get_mime_type()
-    mime_uncompressed.add_default_arg("-Z")
-    return mime_uncompressed
-
-
-def mime_type(filename):
-    """Returns the mime type and subtype of a file.
-
-    Args:
-        filename: file to be analyzed
-
-    Returns:
-        Tuple containing the MIME type and subtype
-    """
-    output = _get_mime_type()(filename, output=str, error=str).strip()
-    tty.debug("==> " + output)
-    type, _, subtype = output.partition("/")
-    return type, subtype
-
-
-def compressed_mime_type(filename):
-    """Same as mime_type but checks for type that has been compressed
-
-    Args:
-        filename (str): file to be analyzed
-
-    Returns:
-        Tuple containing the MIME type and subtype
-    """
-    output = _get_mime_type_compressed()(filename, output=str, error=str).strip()
-    tty.debug("==> " + output)
-    type, _, subtype = output.partition("/")
-    return type, subtype
-
-
 #: This generates the library filenames that may appear on any OS.
 library_extensions = ["a", "la", "so", "tbd", "dylib"]
 
@@ -233,14 +170,9 @@ def filter_file(regex, repl, *filenames, **kwargs):
 
     Keyword Arguments:
         string (bool): Treat regex as a plain string. Default it False
-        backup (bool): Make backup file(s) suffixed with ``~``. Default is False
+        backup (bool): Make backup file(s) suffixed with ``~``. Default is True
         ignore_absent (bool): Ignore any files that don't exist.
             Default is False
-        start_at (str): Marker used to start applying the replacements. If a
-            text line matches this marker filtering is started at the next line.
-            All contents before the marker and the marker itself are copied
-            verbatim. Default is to start filtering from the first line of the
-            file.
         stop_at (str): Marker used to stop scanning the file further. If a text
             line matches this marker filtering is stopped and the rest of the
             file is copied verbatim. Default is to filter until the end of the
@@ -249,7 +181,6 @@ def filter_file(regex, repl, *filenames, **kwargs):
     string = kwargs.get("string", False)
     backup = kwargs.get("backup", False)
     ignore_absent = kwargs.get("ignore_absent", False)
-    start_at = kwargs.get("start_at", None)
     stop_at = kwargs.get("stop_at", None)
 
     # Allow strings to use \1, \2, etc. for replacement, like sed
@@ -298,7 +229,6 @@ def groupid_to_group(x):
             # reached or we found a marker in the line if it was specified
             with open(tmp_filename, mode="r", **extra_kwargs) as input_file:
                 with open(filename, mode="w", **extra_kwargs) as output_file:
-                    do_filtering = start_at is None
                     # Using iter and readline is a workaround needed not to
                     # disable input_file.tell(), which will happen if we call
                     # input_file.next() implicitly via the for loop
@@ -308,12 +238,8 @@ def groupid_to_group(x):
                             if stop_at == line.strip():
                                 output_file.write(line)
                                 break
-                        if do_filtering:
-                            filtered_line = re.sub(regex, repl, line)
-                            output_file.write(filtered_line)
-                        else:
-                            do_filtering = start_at == line.strip()
-                            output_file.write(line)
+                        filtered_line = re.sub(regex, repl, line)
+                        output_file.write(filtered_line)
                     else:
                         current_position = None
 
@@ -505,15 +431,8 @@ def group_ids(uid=None):
 
     if uid is None:
         uid = getuid()
-
-    pwd_entry = pwd.getpwuid(uid)
-    user = pwd_entry.pw_name
-
-    # user's primary group id may not be listed in grp (i.e. /etc/group)
-    # you have to check pwd for that, so start the list with that
-    gids = [pwd_entry.pw_gid]
-
-    return sorted(set(gids + [g.gr_gid for g in grp.getgrall() if user in g.gr_mem]))
+    user = pwd.getpwuid(uid).pw_name
+    return [g.gr_gid for g in grp.getgrall() if user in g.gr_mem]
 
 
 @system_path_filter(arg_slice=slice(1))
@@ -718,11 +637,7 @@ def copy_tree(src, dest, symlinks=True, ignore=None, _permissions=False):
                 if symlinks:
                     target = os.readlink(s)
                     if os.path.isabs(target):
-
-                        def escaped_path(path):
-                            return path.replace("\\", r"\\")
-
-                        new_target = re.sub(escaped_path(abs_src), escaped_path(abs_dest), target)
+                        new_target = re.sub(abs_src, abs_dest, target)
                         if new_target != target:
                             tty.debug("Redirecting link {0} to {1}".format(target, new_target))
                             target = new_target
@@ -1000,45 +915,16 @@ def hash_directory(directory, ignore=[]):
     return md5_hash.hexdigest()
 
 
-def _try_unlink(path):
-    try:
-        os.unlink(path)
-    except (IOError, OSError):
-        # But if that fails, that's OK.
-        pass
-
-
 @contextmanager
 @system_path_filter
-def write_tmp_and_move(path, mode="w"):
-    """Write to a temporary file in the same directory, then move into place."""
-    # Rely on NamedTemporaryFile to give a unique file without races
-    # in the directory of the target file.
-    file = tempfile.NamedTemporaryFile(
-        prefix="." + os.path.basename(path),
-        suffix=".tmp",
-        dir=os.path.dirname(path),
-        mode=mode,
-        delete=False,  # we delete it ourselves
-    )
-    tmp_path = file.name
-
-    try:
-        yield file
-    except BaseException:
-        # On any failure, try to remove the temporary file.
-        _try_unlink(tmp_path)
-        raise
-    finally:
-        # Always close the file decriptor
-        file.close()
-
-    # Atomically move into existence.
-    try:
-        os.rename(tmp_path, path)
-    except (IOError, OSError):
-        _try_unlink(tmp_path)
-        raise
+def write_tmp_and_move(filename):
+    """Write to a temporary file, then move into place."""
+    dirname = os.path.dirname(filename)
+    basename = os.path.basename(filename)
+    tmp = os.path.join(dirname, ".%s.tmp" % basename)
+    with open(tmp, "w") as f:
+        yield f
+    shutil.move(tmp, filename)
 
 
 @contextmanager
@@ -1119,11 +1005,7 @@ def temp_cwd():
         with working_dir(tmp_dir):
             yield tmp_dir
     finally:
-        kwargs = {}
-        if is_windows:
-            kwargs["ignore_errors"] = False
-            kwargs["onerror"] = readonly_file_handler(ignore_errors=True)
-        shutil.rmtree(tmp_dir, **kwargs)
+        shutil.rmtree(tmp_dir)
 
 
 @contextmanager
@@ -2021,11 +1903,7 @@ def names(self):
                 name = x[3:]
 
             # Valid extensions include: ['.dylib', '.so', '.a']
-            # on non Windows platform
-            # Windows valid library extensions are:
-            # ['.dll', '.lib']
-            valid_exts = [".dll", ".lib"] if is_windows else [".dylib", ".so", ".a"]
-            for ext in valid_exts:
+            for ext in [".dylib", ".so", ".a"]:
                 i = name.rfind(ext)
                 if i != -1:
                     names.append(name[:i])
@@ -2135,7 +2013,7 @@ def find_system_libraries(libraries, shared=True):
     return libraries_found
 
 
-def find_libraries(libraries, root, shared=True, recursive=False, runtime=True):
+def find_libraries(libraries, root, shared=True, recursive=False):
     """Returns an iterable of full paths to libraries found in a root dir.
 
     Accepts any glob characters accepted by fnmatch:
@@ -2156,10 +2034,6 @@ def find_libraries(libraries, root, shared=True, recursive=False, runtime=True):
             otherwise for static. Defaults to True.
         recursive (bool): if False search only root folder,
             if True descends top-down from the root. Defaults to False.
-        runtime (bool): Windows only option, no-op elsewhere. If true,
-            search for runtime shared libs (.DLL), otherwise, search
-            for .Lib files. If shared is false, this has no meaning.
-            Defaults to True.
 
     Returns:
         LibraryList: The libraries that have been found
@@ -2172,25 +2046,15 @@ def find_libraries(libraries, root, shared=True, recursive=False, runtime=True):
         message = message.format(find_libraries.__name__, type(libraries))
         raise TypeError(message)
 
-    if is_windows:
-        static_ext = "lib"
-        # For linking (runtime=False) you need the .lib files regardless of
-        # whether you are doing a shared or static link
-        shared_ext = "dll" if runtime else "lib"
-    else:
-        # Used on both Linux and macOS
-        static_ext = "a"
-        shared_ext = "so"
-
     # Construct the right suffix for the library
     if shared:
         # Used on both Linux and macOS
-        suffixes = [shared_ext]
+        suffixes = ["so"]
         if sys.platform == "darwin":
             # Only used on macOS
             suffixes.append("dylib")
     else:
-        suffixes = [static_ext]
+        suffixes = ["a"]
 
     # List of libraries we are searching with suffixes
     libraries = ["{0}.{1}".format(lib, suffix) for lib in libraries for suffix in suffixes]
@@ -2203,11 +2067,7 @@ def find_libraries(libraries, root, shared=True, recursive=False, runtime=True):
     # perform first non-recursive search in root/lib then in root/lib64 and
     # finally search all of root recursively. The search stops when the first
     # match is found.
-    common_lib_dirs = ["lib", "lib64"]
-    if is_windows:
-        common_lib_dirs.extend(["bin", "Lib"])
-
-    for subdir in common_lib_dirs:
+    for subdir in ("lib", "lib64"):
         dirname = join_path(root, subdir)
         if not os.path.isdir(dirname):
             continue
@@ -2220,147 +2080,6 @@ def find_libraries(libraries, root, shared=True, recursive=False, runtime=True):
     return LibraryList(found_libs)
 
 
-def find_all_shared_libraries(root, recursive=False, runtime=True):
-    """Convenience function that returns the list of all shared libraries found
-    in the directory passed as argument.
-
-    See documentation for `llnl.util.filesystem.find_libraries` for more information
-    """
-    return find_libraries("*", root=root, shared=True, recursive=recursive, runtime=runtime)
-
-
-def find_all_static_libraries(root, recursive=False):
-    """Convenience function that returns the list of all static libraries found
-    in the directory passed as argument.
-
-    See documentation for `llnl.util.filesystem.find_libraries` for more information
-    """
-    return find_libraries("*", root=root, shared=False, recursive=recursive)
-
-
-def find_all_libraries(root, recursive=False):
-    """Convenience function that returns the list of all libraries found
-    in the directory passed as argument.
-
-    See documentation for `llnl.util.filesystem.find_libraries` for more information
-    """
-
-    return find_all_shared_libraries(root, recursive=recursive) + find_all_static_libraries(
-        root, recursive=recursive
-    )
-
-
-class WindowsSimulatedRPath(object):
-    """Class representing Windows filesystem rpath analog
-
-    One instance of this class is associated with a package (only on Windows)
-    For each lib/binary directory in an associated package, this class introduces
-    a symlink to any/all dependent libraries/binaries. This includes the packages
-    own bin/lib directories, meaning the libraries are linked to the bianry directory
-    and vis versa.
-    """
-
-    def __init__(self, package, link_install_prefix=True):
-        """
-        Args:
-            package (spack.package_base.PackageBase): Package requiring links
-            link_install_prefix (bool): Link against package's own install or stage root.
-                Packages that run their own executables during build and require rpaths to
-                the build directory during build time require this option. Default: install
-                root
-        """
-        self.pkg = package
-        self._addl_rpaths = set()
-        self.link_install_prefix = link_install_prefix
-        self._additional_library_dependents = set()
-
-    @property
-    def library_dependents(self):
-        """
-        Set of directories where package binaries/libraries are located.
-        """
-        return set([self.pkg.prefix.bin]) | self._additional_library_dependents
-
-    def add_library_dependent(self, *dest):
-        """
-        Add paths to directories or libraries/binaries to set of
-        common paths that need to link against other libraries
-
-        Specified paths should fall outside of a package's common
-        link paths, i.e. the bin
-        directories.
-        """
-        for pth in dest:
-            if os.path.isfile(pth):
-                self._additional_library_dependents.add(os.path.dirname)
-            else:
-                self._additional_library_dependents.add(pth)
-
-    @property
-    def rpaths(self):
-        """
-        Set of libraries this package needs to link against during runtime
-        These packages will each be symlinked into the packages lib and binary dir
-        """
-        dependent_libs = []
-        for path in self.pkg.rpath:
-            dependent_libs.extend(list(find_all_shared_libraries(path, recursive=True)))
-        for extra_path in self._addl_rpaths:
-            dependent_libs.extend(list(find_all_shared_libraries(extra_path, recursive=True)))
-        return set(dependent_libs)
-
-    def add_rpath(self, *paths):
-        """
-        Add libraries found at the root of provided paths to runtime linking
-
-        These are libraries found outside of the typical scope of rpath linking
-        that require manual inclusion in a runtime linking scheme.
-        These links are unidirectional, and are only
-        intended to bring outside dependencies into this package
-
-        Args:
-            *paths (str): arbitrary number of paths to be added to runtime linking
-        """
-        self._addl_rpaths = self._addl_rpaths | set(paths)
-
-    def _link(self, path, dest):
-        file_name = os.path.basename(path)
-        dest_file = os.path.join(dest, file_name)
-        if os.path.exists(dest):
-            try:
-                symlink(path, dest_file)
-            # For py2 compatibility, we have to catch the specific Windows error code
-            # associate with trying to create a file that already exists (winerror 183)
-            except OSError as e:
-                if e.winerror == 183:
-                    # We have either already symlinked or we are encoutering a naming clash
-                    # either way, we don't want to overwrite existing libraries
-                    already_linked = islink(dest_file)
-                    tty.debug(
-                        "Linking library %s to %s failed, " % (path, dest_file) + "already linked."
-                        if already_linked
-                        else "library with name %s already exists at location %s."
-                        % (file_name, dest)
-                    )
-                    pass
-                else:
-                    raise e
-
-    def establish_link(self):
-        """
-        (sym)link packages to runtime dependencies based on RPath configuration for
-        Windows heuristics
-        """
-        # from build_environment.py:463
-        # The top-level package is always RPATHed. It hasn't been installed yet
-        # so the RPATHs are added unconditionally
-
-        # for each binary install dir in self.pkg (i.e. pkg.prefix.bin, pkg.prefix.lib)
-        # install a symlink to each dependent library
-        for library, lib_dir in itertools.product(self.rpaths, self.library_dependents):
-            self._link(library, lib_dir)
-
-
 @system_path_filter
 @memoized
 def can_access_dir(path):

lib/spack/llnl/util/lang.py

@@ -749,26 +749,6 @@ def _n_xxx_ago(x):
     raise ValueError(msg)
 
 
-def pretty_seconds(seconds):
-    """Seconds to string with appropriate units
-
-    Arguments:
-        seconds (float): Number of seconds
-
-    Returns:
-        str: Time string with units
-    """
-    if seconds >= 1:
-        value, unit = seconds, "s"
-    elif seconds >= 1e-3:
-        value, unit = seconds * 1e3, "ms"
-    elif seconds >= 1e-6:
-        value, unit = seconds * 1e6, "us"
-    else:
-        value, unit = seconds * 1e9, "ns"
-    return "%.3f%s" % (value, unit)
-
-
 class RequiredAttributeError(ValueError):
     def __init__(self, message):
         super(RequiredAttributeError, self).__init__(message)
@@ -1022,14 +1002,6 @@ def stable_partition(
     return true_items, false_items
 
 
-def ensure_last(lst, *elements):
-    """Performs a stable partition of lst, ensuring that ``elements``
-    occur at the end of ``lst`` in specified order. Mutates ``lst``.
-    Raises ``ValueError`` if any ``elements`` are not already in ``lst``."""
-    for elt in elements:
-        lst.append(lst.pop(lst.index(elt)))
-
-
 class TypedMutableSequence(MutableSequence):
     """Base class that behaves like a list, just with a different type.
 
@@ -1139,3 +1111,32 @@ def __init__(self, callback):
 
     def __get__(self, instance, owner):
         return self.callback(owner)
+
+
+def dict_list_to_tuple(dlist):
+    if isinstance(dlist, (list, tuple)):
+        return tuple(dict_list_to_tuple(elt) for elt in dlist)
+    elif isinstance(dlist, dict):
+        return tuple((key, dict_list_to_tuple(val)) for key, val in dlist.items())
+    else:
+        return dlist
+
+
+class dict_list(list):
+    """A list with an interface like an ordereddict that can be turned into a tuple."""
+
+    def __setitem__(self, key, value):
+        self.append((key, value))
+
+    def update(self, dict_like):
+        if isinstance(dict_like, (list, tuple)):
+            iterable = dict_like
+        else:
+            iterable = dict_like.items()
+
+        for i in iterable:
+            self.append(i)
+
+    def items(self):
+        for i in self:
+            yield i

lib/spack/llnl/util/lock.py

@@ -12,7 +12,6 @@
 from typing import Dict, Tuple  # novm
 
 import llnl.util.tty as tty
-from llnl.util.lang import pretty_seconds
 
 import spack.util.string
 
@@ -167,7 +166,7 @@ def _attempts_str(wait_time, nattempts):
         return ""
 
     attempts = spack.util.string.plural(nattempts, "attempt")
-    return " after {} and {}".format(pretty_seconds(wait_time), attempts)
+    return " after {0:0.2f}s and {1}".format(wait_time, attempts)
 
 
 class LockType(object):
@@ -319,8 +318,8 @@ def _lock(self, op, timeout=None):
             raise LockROFileError(self.path)
 
         self._log_debug(
-            "{} locking [{}:{}]: timeout {}".format(
-                op_str.lower(), self._start, self._length, pretty_seconds(timeout or 0)
+            "{0} locking [{1}:{2}]: timeout {3} sec".format(
+                op_str.lower(), self._start, self._length, timeout
             )
         )
 
@@ -341,8 +340,7 @@ def _lock(self, op, timeout=None):
             total_wait_time = time.time() - start_time
             return total_wait_time, num_attempts
 
-        total_wait_time = time.time() - start_time
-        raise LockTimeoutError(op_str.lower(), self.path, total_wait_time, num_attempts)
+        raise LockTimeoutError("Timed out waiting for a {0} lock.".format(op_str.lower()))
 
     def _poll_lock(self, op):
         """Attempt to acquire the lock in a non-blocking manner. Return whether
@@ -388,12 +386,8 @@ def _ensure_parent_directory(self):
         try:
             os.makedirs(parent)
         except OSError as e:
-            # os.makedirs can fail in a number of ways when the directory already exists.
-            # With EISDIR, we know it exists, and others like EEXIST, EACCES, and EROFS
-            # are fine if we ensure that the directory exists.
-            # Python 3 allows an exist_ok parameter and ignores any OSError as long as
-            # the directory exists.
-            if not (e.errno == errno.EISDIR or os.path.isdir(parent)):
+            # makedirs can fail when diretory already exists.
+            if not (e.errno == errno.EEXIST and os.path.isdir(parent) or e.errno == errno.EISDIR):
                 raise
         return parent
 
@@ -782,18 +776,6 @@ class LockLimitError(LockError):
 class LockTimeoutError(LockError):
     """Raised when an attempt to acquire a lock times out."""
 
-    def __init__(self, lock_type, path, time, attempts):
-        fmt = "Timed out waiting for a {} lock after {}.\n    Made {} {} on file: {}"
-        super(LockTimeoutError, self).__init__(
-            fmt.format(
-                lock_type,
-                pretty_seconds(time),
-                attempts,
-                "attempt" if attempts == 1 else "attempts",
-                path,
-            )
-        )
-
 
 class LockUpgradeError(LockError):
     """Raised when unable to upgrade from a read to a write lock."""

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

@@ -150,17 +150,13 @@ def color_when(value):
 
 
 class match_to_ansi(object):
-    def __init__(self, color=True, enclose=False):
+    def __init__(self, color=True):
         self.color = _color_when_value(color)
-        self.enclose = enclose
 
     def escape(self, s):
         """Returns a TTY escape sequence for a color"""
         if self.color:
-            if self.enclose:
-                return r"\[\033[%sm\]" % s
-            else:
-                return "\033[%sm" % s
+            return "\033[%sm" % s
         else:
             return ""
 
@@ -205,11 +201,9 @@ def colorize(string, **kwargs):
     Keyword Arguments:
         color (bool): If False, output will be plain text without control
             codes, for output to non-console devices.
-        enclose (bool): If True, enclose ansi color sequences with
-            square brackets to prevent misestimation of terminal width.
     """
     color = _color_when_value(kwargs.get("color", get_color_when()))
-    string = re.sub(color_re, match_to_ansi(color, kwargs.get("enclose")), string)
+    string = re.sub(color_re, match_to_ansi(color), string)
     string = string.replace("}}", "}")
     return string
 

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

@@ -228,8 +228,8 @@ def __init__(self, controller_function, minion_function):
         self.minion_function = minion_function
 
         # these can be optionally set to change defaults
-        self.controller_timeout = 3
-        self.sleep_time = 0.1
+        self.controller_timeout = 1
+        self.sleep_time = 0
 
     def start(self, **kwargs):
         """Start the controller and minion processes.

lib/spack/spack/__init__.py

@@ -3,20 +3,11 @@
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
-#: PEP440 canonical <major>.<minor>.<micro>.<devN> string
-__version__ = "0.19.0.dev0"
-spack_version = __version__
-
-
-def __try_int(v):
-    try:
-        return int(v)
-    except ValueError:
-        return v
-
-
 #: (major, minor, micro, dev release) tuple
-spack_version_info = tuple([__try_int(v) for v in __version__.split(".")])
+spack_version_info = (0, 19, 0, "dev0")
 
+#: PEP440 canonical <major>.<minor>.<micro>.<devN> string
+spack_version = ".".join(str(s) for s in spack_version_info)
 
 __all__ = ["spack_version_info", "spack_version"]
+__version__ = spack_version

lib/spack/spack/audit.py

@@ -35,11 +35,9 @@ def _search_duplicate_compilers(error_cls):
 the decorator object, that will forward the keyword arguments passed
 as input.
 """
-import ast
 import collections
 import inspect
 import itertools
-import pickle
 import re
 
 from six.moves.urllib.request import urlopen
@@ -51,7 +49,6 @@ def _search_duplicate_compilers(error_cls):
 import spack.patch
 import spack.repo
 import spack.spec
-import spack.util.crypto
 import spack.variant
 
 #: Map an audit tag to a list of callables implementing checks
@@ -264,14 +261,6 @@ def _search_duplicate_specs_in_externals(error_cls):
 )
 
 
-package_properties = AuditClass(
-    group="packages",
-    tag="PKG-PROPERTIES",
-    description="Sanity checks on properties a package should maintain",
-    kwargs=("pkgs",),
-)
-
-
 #: Sanity checks on linting
 # This can take some time, so it's run separately from packages
 package_https_directives = AuditClass(
@@ -364,172 +353,6 @@ def _search_for_reserved_attributes_names_in_packages(pkgs, error_cls):
     return errors
 
 
-@package_properties
-def _ensure_all_package_names_are_lowercase(pkgs, error_cls):
-    """Ensure package names are lowercase and consistent"""
-    badname_regex, errors = re.compile(r"[_A-Z]"), []
-    for pkg_name in pkgs:
-        if badname_regex.search(pkg_name):
-            error_msg = "Package name '{}' is either lowercase or conatine '_'".format(pkg_name)
-            errors.append(error_cls(error_msg, []))
-    return errors
-
-
-@package_properties
-def _ensure_packages_are_pickeleable(pkgs, error_cls):
-    """Ensure that package objects are pickleable"""
-    errors = []
-    for pkg_name in pkgs:
-        pkg_cls = spack.repo.path.get_pkg_class(pkg_name)
-        pkg = pkg_cls(spack.spec.Spec(pkg_name))
-        try:
-            pickle.dumps(pkg)
-        except Exception as e:
-            error_msg = "Package '{}' failed to pickle".format(pkg_name)
-            details = ["{}".format(str(e))]
-            errors.append(error_cls(error_msg, details))
-    return errors
-
-
-@package_properties
-def _ensure_packages_are_unparseable(pkgs, error_cls):
-    """Ensure that all packages can unparse and that unparsed code is valid Python"""
-    import spack.util.package_hash as ph
-
-    errors = []
-    for pkg_name in pkgs:
-        try:
-            source = ph.canonical_source(pkg_name, filter_multimethods=False)
-        except Exception as e:
-            error_msg = "Package '{}' failed to unparse".format(pkg_name)
-            details = ["{}".format(str(e))]
-            errors.append(error_cls(error_msg, details))
-            continue
-
-        try:
-            compile(source, "internal", "exec", ast.PyCF_ONLY_AST)
-        except Exception as e:
-            error_msg = "The unparsed package '{}' failed to compile".format(pkg_name)
-            details = ["{}".format(str(e))]
-            errors.append(error_cls(error_msg, details))
-
-    return errors
-
-
-@package_properties
-def _ensure_all_versions_can_produce_a_fetcher(pkgs, error_cls):
-    """Ensure all versions in a package can produce a fetcher"""
-    errors = []
-    for pkg_name in pkgs:
-        pkg_cls = spack.repo.path.get_pkg_class(pkg_name)
-        pkg = pkg_cls(spack.spec.Spec(pkg_name))
-        try:
-            spack.fetch_strategy.check_pkg_attributes(pkg)
-            for version in pkg.versions:
-                assert spack.fetch_strategy.for_package_version(pkg, version)
-        except Exception as e:
-            error_msg = "The package '{}' cannot produce a fetcher for some of its versions"
-            details = ["{}".format(str(e))]
-            errors.append(error_cls(error_msg.format(pkg_name), details))
-    return errors
-
-
-@package_properties
-def _ensure_docstring_and_no_fixme(pkgs, error_cls):
-    """Ensure the package has a docstring and no fixmes"""
-    errors = []
-    fixme_regexes = [
-        re.compile(r"remove this boilerplate"),
-        re.compile(r"FIXME: Put"),
-        re.compile(r"FIXME: Add"),
-        re.compile(r"example.com"),
-    ]
-    for pkg_name in pkgs:
-        details = []
-        filename = spack.repo.path.filename_for_package_name(pkg_name)
-        with open(filename, "r") as package_file:
-            for i, line in enumerate(package_file):
-                pattern = next((r for r in fixme_regexes if r.search(line)), None)
-                if pattern:
-                    details.append(
-                        "%s:%d: boilerplate needs to be removed: %s" % (filename, i, line.strip())
-                    )
-        if details:
-            error_msg = "Package '{}' contains boilerplate that need to be removed"
-            errors.append(error_cls(error_msg.format(pkg_name), details))
-
-        pkg_cls = spack.repo.path.get_pkg_class(pkg_name)
-        if not pkg_cls.__doc__:
-            error_msg = "Package '{}' miss a docstring"
-            errors.append(error_cls(error_msg.format(pkg_name), []))
-
-    return errors
-
-
-@package_properties
-def _ensure_all_packages_use_sha256_checksums(pkgs, error_cls):
-    """Ensure no packages use md5 checksums"""
-    errors = []
-    for pkg_name in pkgs:
-        pkg_cls = spack.repo.path.get_pkg_class(pkg_name)
-        if pkg_cls.manual_download:
-            continue
-
-        pkg = pkg_cls(spack.spec.Spec(pkg_name))
-
-        def invalid_sha256_digest(fetcher):
-            if getattr(fetcher, "digest", None):
-                h = spack.util.crypto.hash_algo_for_digest(fetcher.digest)
-                if h != "sha256":
-                    return h, True
-            return None, False
-
-        error_msg = "Package '{}' does not use sha256 checksum".format(pkg_name)
-        details = []
-        for v, args in pkg.versions.items():
-            fetcher = spack.fetch_strategy.for_package_version(pkg, v)
-            digest, is_bad = invalid_sha256_digest(fetcher)
-            if is_bad:
-                details.append("{}@{} uses {}".format(pkg_name, v, digest))
-
-        for _, resources in pkg.resources.items():
-            for resource in resources:
-                digest, is_bad = invalid_sha256_digest(resource.fetcher)
-                if is_bad:
-                    details.append("Resource in '{}' uses {}".format(pkg_name, digest))
-        if details:
-            errors.append(error_cls(error_msg, details))
-
-    return errors
-
-
-@package_properties
-def _ensure_env_methods_are_ported_to_builders(pkgs, error_cls):
-    """Ensure that methods modifying the build environment are ported to builder classes."""
-    errors = []
-    for pkg_name in pkgs:
-        pkg_cls = spack.repo.path.get_pkg_class(pkg_name)
-        buildsystem_variant, _ = pkg_cls.variants["build_system"]
-        buildsystem_names = [getattr(x, "value", x) for x in buildsystem_variant.values]
-        builder_cls_names = [spack.builder.BUILDER_CLS[x].__name__ for x in buildsystem_names]
-        module = pkg_cls.module
-        has_builders_in_package_py = any(
-            getattr(module, name, False) for name in builder_cls_names
-        )
-        if not has_builders_in_package_py:
-            continue
-
-        for method_name in ("setup_build_environment", "setup_dependent_build_environment"):
-            if hasattr(pkg_cls, method_name):
-                msg = (
-                    "Package '{}' need to move the '{}' method from the package class to the"
-                    " appropriate builder class".format(pkg_name, method_name)
-                )
-                errors.append(error_cls(msg, []))
-
-    return errors
-
-
 @package_https_directives
 def _linting_package_file(pkgs, error_cls):
     """Check for correctness of links"""
@@ -667,42 +490,6 @@ def _unknown_variants_in_dependencies(pkgs, error_cls):
     return errors
 
 
-@package_directives
-def _ensure_variant_defaults_are_parsable(pkgs, error_cls):
-    """Ensures that variant defaults are present and parsable from cli"""
-    errors = []
-    for pkg_name in pkgs:
-        pkg_cls = spack.repo.path.get_pkg_class(pkg_name)
-        for variant_name, entry in pkg_cls.variants.items():
-            variant, _ = entry
-            default_is_parsable = (
-                # Permitting a default that is an instance on 'int' permits
-                # to have foo=false or foo=0. Other falsish values are
-                # not allowed, since they can't be parsed from cli ('foo=')
-                isinstance(variant.default, int)
-                or variant.default
-            )
-            if not default_is_parsable:
-                error_msg = "Variant '{}' of package '{}' has a bad default value"
-                errors.append(error_cls(error_msg.format(variant_name, pkg_name), []))
-                continue
-
-            try:
-                vspec = variant.make_default()
-            except spack.variant.MultipleValuesInExclusiveVariantError:
-                error_msg = "Cannot create a default value for the variant '{}' in package '{}'"
-                errors.append(error_cls(error_msg.format(variant_name, pkg_name), []))
-                continue
-
-            try:
-                variant.validate_or_raise(vspec, pkg_cls=pkg_cls)
-            except spack.variant.InvalidVariantValueError:
-                error_msg = "The variant '{}' default value in package '{}' cannot be validated"
-                errors.append(error_cls(error_msg.format(variant_name, pkg_name), []))
-
-    return errors
-
-
 @package_directives
 def _version_constraints_are_satisfiable_by_some_version_in_repo(pkgs, error_cls):
     """Report if version constraints used in directives are not satisfiable"""

lib/spack/spack/binary_distribution.py

@@ -7,13 +7,11 @@
 import collections
 import hashlib
 import json
-import multiprocessing.pool
 import os
 import shutil
 import sys
 import tarfile
 import tempfile
-import time
 import traceback
 import warnings
 from contextlib import closing
@@ -21,14 +19,14 @@
 import ruamel.yaml as yaml
 from six.moves.urllib.error import HTTPError, URLError
 
-import llnl.util.filesystem as fsys
 import llnl.util.lang
 import llnl.util.tty as tty
-from llnl.util.filesystem import BaseDirectoryVisitor, mkdirp, visit_directory_tree
+from llnl.util.filesystem import mkdirp
 
 import spack.cmd
 import spack.config as config
 import spack.database as spack_db
+import spack.fetch_strategy as fs
 import spack.hooks
 import spack.hooks.sbang
 import spack.mirror
@@ -43,10 +41,8 @@
 import spack.util.url as url_util
 import spack.util.web as web_util
 from spack.caches import misc_cache_location
-from spack.relocate import utf8_paths_to_single_binary_regex
 from spack.spec import Spec
 from spack.stage import Stage
-from spack.util.executable import which
 
 _build_cache_relative_path = "build_cache"
 _build_cache_keys_relative_path = "_pgp"
@@ -74,10 +70,6 @@ def __init__(self, errors):
         super(FetchCacheError, self).__init__(self.message)
 
 
-class ListMirrorSpecsError(spack.error.SpackError):
-    """Raised when unable to retrieve list of specs from the mirror"""
-
-
 class BinaryCacheIndex(object):
     """
     The BinaryCacheIndex tracks what specs are available on (usually remote)
@@ -113,10 +105,6 @@ def __init__(self, cache_root):
         # cache (_mirrors_for_spec)
         self._specs_already_associated = set()
 
-        # mapping from mirror urls to the time.time() of the last index fetch and a bool indicating
-        # whether the fetch succeeded or not.
-        self._last_fetch_times = {}
-
         # _mirrors_for_spec is a dictionary mapping DAG hashes to lists of
         # entries indicating mirrors where that concrete spec can be found.
         # Each entry is a dictionary consisting of:
@@ -149,7 +137,6 @@ def clear(self):
             self._index_file_cache = None
         self._local_index_cache = None
         self._specs_already_associated = set()
-        self._last_fetch_times = {}
         self._mirrors_for_spec = {}
 
     def _write_local_index_cache(self):
@@ -255,6 +242,7 @@ def find_built_spec(self, spec, mirrors_to_check=None):
                         }
                     ]
         """
+        self.regenerate_spec_cache()
         return self.find_by_hash(spec.dag_hash(), mirrors_to_check=mirrors_to_check)
 
     def find_by_hash(self, find_hash, mirrors_to_check=None):
@@ -265,9 +253,6 @@ def find_by_hash(self, find_hash, mirrors_to_check=None):
             mirrors_to_check: Optional mapping containing mirrors to check.  If
                 None, just assumes all configured mirrors.
         """
-        if find_hash not in self._mirrors_for_spec:
-            # Not found in the cached index, pull the latest from the server.
-            self.update(with_cooldown=True)
         if find_hash not in self._mirrors_for_spec:
             return None
         results = self._mirrors_for_spec[find_hash]
@@ -298,7 +283,7 @@ def update_spec(self, spec, found_list):
                         "spec": new_entry["spec"],
                     }
 
-    def update(self, with_cooldown=False):
+    def update(self):
         """Make sure local cache of buildcache index files is up to date.
         If the same mirrors are configured as the last time this was called
         and none of the remote buildcache indices have changed, calling this
@@ -340,41 +325,24 @@ def update(self, with_cooldown=False):
 
         fetch_errors = []
         all_methods_failed = True
-        ttl = spack.config.get("config:binary_index_ttl", 600)
-        now = time.time()
 
         for cached_mirror_url in self._local_index_cache:
             cache_entry = self._local_index_cache[cached_mirror_url]
             cached_index_hash = cache_entry["index_hash"]
             cached_index_path = cache_entry["index_path"]
             if cached_mirror_url in configured_mirror_urls:
-                # Only do a fetch if the last fetch was longer than TTL ago
-                if (
-                    with_cooldown
-                    and ttl > 0
-                    and cached_mirror_url in self._last_fetch_times
-                    and now - self._last_fetch_times[cached_mirror_url][0] < ttl
-                ):
-                    # We're in the cooldown period, don't try to fetch again
-                    # If the fetch succeeded last time, consider this update a success, otherwise
-                    # re-report the error here
-                    if self._last_fetch_times[cached_mirror_url][1]:
-                        all_methods_failed = False
-                else:
-                    # May need to fetch the index and update the local caches
-                    try:
-                        needs_regen = self._fetch_and_cache_index(
-                            cached_mirror_url, expect_hash=cached_index_hash
-                        )
-                        self._last_fetch_times[cached_mirror_url] = (now, True)
-                        all_methods_failed = False
-                    except FetchCacheError as fetch_error:
-                        needs_regen = False
-                        fetch_errors.extend(fetch_error.errors)
-                        self._last_fetch_times[cached_mirror_url] = (now, False)
-                    # The need to regenerate implies a need to clear as well.
-                    spec_cache_clear_needed |= needs_regen
-                    spec_cache_regenerate_needed |= needs_regen
+                # May need to fetch the index and update the local caches
+                try:
+                    needs_regen = self._fetch_and_cache_index(
+                        cached_mirror_url, expect_hash=cached_index_hash
+                    )
+                    all_methods_failed = False
+                except FetchCacheError as fetch_error:
+                    needs_regen = False
+                    fetch_errors.extend(fetch_error.errors)
+                # The need to regenerate implies a need to clear as well.
+                spec_cache_clear_needed |= needs_regen
+                spec_cache_regenerate_needed |= needs_regen
             else:
                 # No longer have this mirror, cached index should be removed
                 items_to_remove.append(
@@ -383,8 +351,6 @@ def update(self, with_cooldown=False):
                         "cache_key": os.path.join(self._index_cache_root, cached_index_path),
                     }
                 )
-                if cached_mirror_url in self._last_fetch_times:
-                    del self._last_fetch_times[cached_mirror_url]
                 spec_cache_clear_needed = True
                 spec_cache_regenerate_needed = True
 
@@ -403,12 +369,10 @@ def update(self, with_cooldown=False):
                 # Need to fetch the index and update the local caches
                 try:
                     needs_regen = self._fetch_and_cache_index(mirror_url)
-                    self._last_fetch_times[mirror_url] = (now, True)
                     all_methods_failed = False
                 except FetchCacheError as fetch_error:
                     fetch_errors.extend(fetch_error.errors)
                     needs_regen = False
-                    self._last_fetch_times[mirror_url] = (now, False)
                 # Generally speaking, a new mirror wouldn't imply the need to
                 # clear the spec cache, so leave it as is.
                 if needs_regen:
@@ -655,57 +619,6 @@ def read_buildinfo_file(prefix):
     return buildinfo
 
 
-class BuildManifestVisitor(BaseDirectoryVisitor):
-    """Visitor that collects a list of files and symlinks
-    that can be checked for need of relocation. It knows how
-    to dedupe hardlinks and deal with symlinks to files and
-    directories."""
-
-    def __init__(self):
-        # Save unique identifiers of files to avoid
-        # relocating hardlink files for each path.
-        self.visited = set()
-
-        # Lists of files we will check
-        self.files = []
-        self.symlinks = []
-
-    def seen_before(self, root, rel_path):
-        stat_result = os.lstat(os.path.join(root, rel_path))
-        identifier = (stat_result.st_dev, stat_result.st_ino)
-        if identifier in self.visited:
-            return True
-        else:
-            self.visited.add(identifier)
-            return False
-
-    def visit_file(self, root, rel_path, depth):
-        if self.seen_before(root, rel_path):
-            return
-        self.files.append(rel_path)
-
-    def visit_symlinked_file(self, root, rel_path, depth):
-        # Note: symlinks *can* be hardlinked, but it is unclear if
-        # symlinks can be relinked in-place (preserving inode).
-        # Therefore, we do *not* de-dupe hardlinked symlinks.
-        self.symlinks.append(rel_path)
-
-    def before_visit_dir(self, root, rel_path, depth):
-        return os.path.basename(rel_path) not in (".spack", "man")
-
-    def before_visit_symlinked_dir(self, root, rel_path, depth):
-        # Treat symlinked directories simply as symlinks.
-        self.visit_symlinked_file(root, rel_path, depth)
-        # Never recurse into symlinked directories.
-        return False
-
-
-def file_matches(path, regex):
-    with open(path, "rb") as f:
-        contents = f.read()
-    return bool(regex.search(contents))
-
-
 def get_buildfile_manifest(spec):
     """
     Return a data structure with information about a build, including
@@ -721,61 +634,57 @@ def get_buildfile_manifest(spec):
         "link_to_relocate": [],
         "other": [],
         "binary_to_relocate_fullpath": [],
-        "hardlinks_deduped": True,
     }
 
-    # Guard against filesystem footguns of hardlinks and symlinks by using
-    # a visitor to retrieve a list of files and symlinks, so we don't have
-    # to worry about hardlinks of symlinked dirs and what not.
-    visitor = BuildManifestVisitor()
-    root = spec.prefix
-    visit_directory_tree(root, visitor)
+    exclude_list = (".spack", "man")
 
-    # Collect a list of prefixes for this package and it's dependencies, Spack will
-    # look for them to decide if text file needs to be relocated or not
-    prefixes = [d.prefix for d in spec.traverse(root=True, deptype="all") if not d.external]
-    prefixes.append(spack.hooks.sbang.sbang_install_path())
-    prefixes.append(str(spack.store.layout.root))
+    # Do this at during tarball creation to save time when tarball unpacked.
+    # Used by make_package_relative to determine binaries to change.
+    for root, dirs, files in os.walk(spec.prefix, topdown=True):
+        dirs[:] = [d for d in dirs if d not in exclude_list]
 
-    # Create a giant regex that matches all prefixes
-    regex = utf8_paths_to_single_binary_regex(prefixes)
+        # Directories may need to be relocated too.
+        for directory in dirs:
+            dir_path_name = os.path.join(root, directory)
+            rel_path_name = os.path.relpath(dir_path_name, spec.prefix)
+            if os.path.islink(dir_path_name):
+                link = os.readlink(dir_path_name)
+                if os.path.isabs(link) and link.startswith(spack.store.layout.root):
+                    data["link_to_relocate"].append(rel_path_name)
 
-    # Symlinks.
+        for filename in files:
+            path_name = os.path.join(root, filename)
+            m_type, m_subtype = relocate.mime_type(path_name)
+            rel_path_name = os.path.relpath(path_name, spec.prefix)
+            added = False
 
-    # Obvious bugs:
-    #   1. relative links are not relocated.
-    #   2. paths are used as strings.
-    for rel_path in visitor.symlinks:
-        abs_path = os.path.join(root, rel_path)
-        link = os.readlink(abs_path)
-        if os.path.isabs(link) and link.startswith(spack.store.layout.root):
-            data["link_to_relocate"].append(rel_path)
+            if os.path.islink(path_name):
+                link = os.readlink(path_name)
+                if os.path.isabs(link):
+                    # Relocate absolute links into the spack tree
+                    if link.startswith(spack.store.layout.root):
+                        data["link_to_relocate"].append(rel_path_name)
+                    added = True
 
-    # Non-symlinks.
-    for rel_path in visitor.files:
-        abs_path = os.path.join(root, rel_path)
-        m_type, m_subtype = fsys.mime_type(abs_path)
+            if relocate.needs_binary_relocation(m_type, m_subtype):
+                if (
+                    (
+                        m_subtype in ("x-executable", "x-sharedlib", "x-pie-executable")
+                        and sys.platform != "darwin"
+                    )
+                    or (m_subtype in ("x-mach-binary") and sys.platform == "darwin")
+                    or (not filename.endswith(".o"))
+                ):
+                    data["binary_to_relocate"].append(rel_path_name)
+                    data["binary_to_relocate_fullpath"].append(path_name)
+                    added = True
 
-        if relocate.needs_binary_relocation(m_type, m_subtype):
-            # Why is this branch not part of needs_binary_relocation? :(
-            if (
-                (
-                    m_subtype in ("x-executable", "x-sharedlib", "x-pie-executable")
-                    and sys.platform != "darwin"
-                )
-                or (m_subtype in ("x-mach-binary") and sys.platform == "darwin")
-                or (not rel_path.endswith(".o"))
-            ):
-                data["binary_to_relocate"].append(rel_path)
-                data["binary_to_relocate_fullpath"].append(abs_path)
-                continue
-
-        elif relocate.needs_text_relocation(m_type, m_subtype) and file_matches(abs_path, regex):
-            data["text_to_relocate"].append(rel_path)
-            continue
-
-        data["other"].append(abs_path)
+            if relocate.needs_text_relocation(m_type, m_subtype):
+                data["text_to_relocate"].append(rel_path_name)
+                added = True
 
+            if not added:
+                data["other"].append(path_name)
     return data
 
 
@@ -789,7 +698,7 @@ def write_buildinfo_file(spec, workdir, rel=False):
     prefix_to_hash = dict()
     prefix_to_hash[str(spec.package.prefix)] = spec.dag_hash()
     deps = spack.build_environment.get_rpath_deps(spec.package)
-    for d in deps + spec.dependencies(deptype="run"):
+    for d in deps:
         prefix_to_hash[str(d.prefix)] = d.dag_hash()
 
     # Create buildinfo data and write it to disk
@@ -802,7 +711,6 @@ def write_buildinfo_file(spec, workdir, rel=False):
     buildinfo["relocate_textfiles"] = manifest["text_to_relocate"]
     buildinfo["relocate_binaries"] = manifest["binary_to_relocate"]
     buildinfo["relocate_links"] = manifest["link_to_relocate"]
-    buildinfo["hardlinks_deduped"] = manifest["hardlinks_deduped"]
     buildinfo["prefix_to_hash"] = prefix_to_hash
     filename = buildinfo_file_name(workdir)
     with open(filename, "w") as outfile:
@@ -887,52 +795,37 @@ def sign_specfile(key, force, specfile_path):
     spack.util.gpg.sign(key, specfile_path, signed_specfile_path, clearsign=True)
 
 
-def _read_specs_and_push_index(file_list, read_method, cache_prefix, db, temp_dir, concurrency):
-    """Read all the specs listed in the provided list, using thread given thread parallelism,
-        generate the index, and push it to the mirror.
+def _fetch_spec_from_mirror(spec_url):
+    s = None
+    tty.debug("fetching {0}".format(spec_url))
+    _, _, spec_file = web_util.read_from_url(spec_url)
+    spec_file_contents = codecs.getreader("utf-8")(spec_file).read()
+    # Need full spec.json name or this gets confused with index.json.
+    if spec_url.endswith(".json.sig"):
+        specfile_json = Spec.extract_json_from_clearsig(spec_file_contents)
+        s = Spec.from_dict(specfile_json)
+    elif spec_url.endswith(".json"):
+        s = Spec.from_json(spec_file_contents)
+    elif spec_url.endswith(".yaml"):
+        s = Spec.from_yaml(spec_file_contents)
+    return s
 
-    Args:
-        file_list (list(str)): List of urls or file paths pointing at spec files to read
-        read_method: A function taking a single argument, either a url or a file path,
-            and which reads the spec file at that location, and returns the spec.
-        cache_prefix (str): prefix of the build cache on s3 where index should be pushed.
-        db: A spack database used for adding specs and then writing the index.
-        temp_dir (str): Location to write index.json and hash for pushing
-        concurrency (int): Number of parallel processes to use when fetching
 
-    Return:
-        None
-    """
+def _read_specs_and_push_index(file_list, cache_prefix, db, db_root_dir):
+    for file_path in file_list:
+        try:
+            s = _fetch_spec_from_mirror(url_util.join(cache_prefix, file_path))
+        except (URLError, web_util.SpackWebError) as url_err:
+            tty.error("Error reading specfile: {0}".format(file_path))
+            tty.error(url_err)
 
-    def _fetch_spec_from_mirror(spec_url):
-        spec_file_contents = read_method(spec_url)
-
-        if spec_file_contents:
-            # Need full spec.json name or this gets confused with index.json.
-            if spec_url.endswith(".json.sig"):
-                specfile_json = Spec.extract_json_from_clearsig(spec_file_contents)
-                return Spec.from_dict(specfile_json)
-            if spec_url.endswith(".json"):
-                return Spec.from_json(spec_file_contents)
-            if spec_url.endswith(".yaml"):
-                return Spec.from_yaml(spec_file_contents)
-
-    tp = multiprocessing.pool.ThreadPool(processes=concurrency)
-    try:
-        fetched_specs = tp.map(
-            llnl.util.lang.star(_fetch_spec_from_mirror), [(f,) for f in file_list]
-        )
-    finally:
-        tp.terminate()
-        tp.join()
-
-    for fetched_spec in fetched_specs:
-        db.add(fetched_spec, None)
-        db.mark(fetched_spec, "in_buildcache", True)
+        if s:
+            db.add(s, None)
+            db.mark(s, "in_buildcache", True)
 
     # Now generate the index, compute its hash, and push the two files to
     # the mirror.
-    index_json_path = os.path.join(temp_dir, "index.json")
+    index_json_path = os.path.join(db_root_dir, "index.json")
     with open(index_json_path, "w") as f:
         db._write_to_file(f)
 
@@ -942,7 +835,7 @@ def _fetch_spec_from_mirror(spec_url):
         index_hash = compute_hash(index_string)
 
     # Write the hash out to a local file
-    index_hash_path = os.path.join(temp_dir, "index.json.hash")
+    index_hash_path = os.path.join(db_root_dir, "index.json.hash")
     with open(index_hash_path, "w") as f:
         f.write(index_hash)
 
@@ -963,152 +856,33 @@ def _fetch_spec_from_mirror(spec_url):
     )
 
 
-def _specs_from_cache_aws_cli(cache_prefix):
-    """Use aws cli to sync all the specs into a local temporary directory.
+def generate_package_index(cache_prefix):
+    """Create the build cache index page.
 
-    Args:
-        cache_prefix (str): prefix of the build cache on s3
-
-    Return:
-        List of the local file paths and a function that can read each one from the file system.
+    Creates (or replaces) the "index.json" page at the location given in
+    cache_prefix.  This page contains a link for each binary package (.yaml or
+    .json) under cache_prefix.
     """
-    read_fn = None
-    file_list = None
-    aws = which("aws")
-
-    def file_read_method(file_path):
-        with open(file_path) as fd:
-            return fd.read()
-
-    tmpspecsdir = tempfile.mkdtemp()
-    sync_command_args = [
-        "s3",
-        "sync",
-        "--exclude",
-        "*",
-        "--include",
-        "*.spec.json.sig",
-        "--include",
-        "*.spec.json",
-        "--include",
-        "*.spec.yaml",
-        cache_prefix,
-        tmpspecsdir,
-    ]
-
     try:
-        tty.debug(
-            "Using aws s3 sync to download specs from {0} to {1}".format(cache_prefix, tmpspecsdir)
-        )
-        aws(*sync_command_args, output=os.devnull, error=os.devnull)
-        file_list = fsys.find(tmpspecsdir, ["*.spec.json.sig", "*.spec.json", "*.spec.yaml"])
-        read_fn = file_read_method
-    except Exception:
-        tty.warn("Failed to use aws s3 sync to retrieve specs, falling back to parallel fetch")
-        shutil.rmtree(tmpspecsdir)
-
-    return file_list, read_fn
-
-
-def _specs_from_cache_fallback(cache_prefix):
-    """Use spack.util.web module to get a list of all the specs at the remote url.
-
-    Args:
-        cache_prefix (str): Base url of mirror (location of spec files)
-
-    Return:
-        The list of complete spec file urls and a function that can read each one from its
-            remote location (also using the spack.util.web module).
-    """
-    read_fn = None
-    file_list = None
-
-    def url_read_method(url):
-        contents = None
-        try:
-            _, _, spec_file = web_util.read_from_url(url)
-            contents = codecs.getreader("utf-8")(spec_file).read()
-        except (URLError, web_util.SpackWebError) as url_err:
-            tty.error("Error reading specfile: {0}".format(url))
-            tty.error(url_err)
-        return contents
-
-    try:
-        file_list = [
-            url_util.join(cache_prefix, entry)
+        file_list = (
+            entry
             for entry in web_util.list_url(cache_prefix)
             if entry.endswith(".yaml")
             or entry.endswith("spec.json")
             or entry.endswith("spec.json.sig")
-        ]
-        read_fn = url_read_method
+        )
     except KeyError as inst:
         msg = "No packages at {0}: {1}".format(cache_prefix, inst)
         tty.warn(msg)
+        return
     except Exception as err:
         # If we got some kind of S3 (access denied or other connection
         # error), the first non boto-specific class in the exception
         # hierarchy is Exception.  Just print a warning and return
         msg = "Encountered problem listing packages at {0}: {1}".format(cache_prefix, err)
         tty.warn(msg)
-
-    return file_list, read_fn
-
-
-def _spec_files_from_cache(cache_prefix):
-    """Get a list of all the spec files in the mirror and a function to
-    read them.
-
-    Args:
-        cache_prefix (str): Base url of mirror (location of spec files)
-
-    Return:
-        A tuple where the first item is a list of absolute file paths or
-        urls pointing to the specs that should be read from the mirror,
-        and the second item is a function taking a url or file path and
-        returning the spec read from that location.
-    """
-    callbacks = []
-    if cache_prefix.startswith("s3"):
-        callbacks.append(_specs_from_cache_aws_cli)
-
-    callbacks.append(_specs_from_cache_fallback)
-
-    for specs_from_cache_fn in callbacks:
-        file_list, read_fn = specs_from_cache_fn(cache_prefix)
-        if file_list:
-            return file_list, read_fn
-
-    raise ListMirrorSpecsError("Failed to get list of specs from {0}".format(cache_prefix))
-
-
-def generate_package_index(cache_prefix, concurrency=32):
-    """Create or replace the build cache index on the given mirror.  The
-    buildcache index contains an entry for each binary package under the
-    cache_prefix.
-
-    Args:
-        cache_prefix(str): Base url of binary mirror.
-        concurrency: (int): The desired threading concurrency to use when
-            fetching the spec files from the mirror.
-
-    Return:
-        None
-    """
-    try:
-        file_list, read_fn = _spec_files_from_cache(cache_prefix)
-    except ListMirrorSpecsError as err:
-        tty.error("Unabled to generate package index, {0}".format(err))
         return
 
-    if any(x.endswith(".yaml") for x in file_list):
-        msg = (
-            "The mirror in '{}' contains specs in the deprecated YAML format.\n\n\tSupport for "
-            "this format will be removed in v0.20, please regenerate the build cache with a "
-            "recent Spack\n"
-        ).format(cache_prefix)
-        warnings.warn(msg)
-
     tty.debug("Retrieving spec descriptor files from {0} to build index".format(cache_prefix))
 
     tmpdir = tempfile.mkdtemp()
@@ -1121,7 +895,7 @@ def generate_package_index(cache_prefix, concurrency=32):
     )
 
     try:
-        _read_specs_and_push_index(file_list, read_fn, cache_prefix, db, db_root_dir, concurrency)
+        _read_specs_and_push_index(file_list, cache_prefix, db, db_root_dir)
     except Exception as err:
         msg = "Encountered problem pushing package index to {0}: {1}".format(cache_prefix, err)
         tty.warn(msg)
@@ -1297,11 +1071,7 @@ def _build_tarball(
             tty.die(e)
 
     # create gzip compressed tarball of the install prefix
-    # On AMD Ryzen 3700X and an SSD disk, we have the following on compression speed:
-    # compresslevel=6 gzip default: llvm takes 4mins, roughly 2.1GB
-    # compresslevel=9 python default: llvm takes 12mins, roughly 2.1GB
-    # So we follow gzip.
-    with closing(tarfile.open(tarfile_path, "w:gz", compresslevel=6)) as tar:
+    with closing(tarfile.open(tarfile_path, "w:gz")) as tar:
         tar.add(name="%s" % workdir, arcname="%s" % os.path.basename(spec.prefix))
     # remove copy of install directory
     shutil.rmtree(workdir)
@@ -1461,7 +1231,7 @@ def try_fetch(url_to_fetch):
 
     try:
         stage.fetch()
-    except web_util.FetchError:
+    except fs.FetchError:
         stage.destroy()
         return None
 
@@ -1576,13 +1346,6 @@ def download_tarball(spec, unsigned=False, mirrors_for_spec=None):
                     #     the remaining mirrors, looking for one we can use.
                     tarball_stage = try_fetch(spackfile_url)
                     if tarball_stage:
-                        if ext == "yaml":
-                            msg = (
-                                "Reading {} from mirror.\n\n\tThe YAML format for buildcaches is "
-                                "deprecated and will be removed in v0.20\n"
-                            ).format(spackfile_url)
-                            warnings.warn(msg)
-
                         return {
                             "tarball_stage": tarball_stage,
                             "specfile_stage": local_specfile_stage,
@@ -1655,38 +1418,6 @@ def check_package_relocatable(workdir, spec, allow_root):
     relocate.raise_if_not_relocatable(cur_path_names, allow_root)
 
 
-def dedupe_hardlinks_if_necessary(root, buildinfo):
-    """Updates a buildinfo dict for old archives that did
-    not dedupe hardlinks. De-duping hardlinks is necessary
-    when relocating files in parallel and in-place. This
-    means we must preserve inodes when relocating."""
-
-    # New archives don't need this.
-    if buildinfo.get("hardlinks_deduped", False):
-        return
-
-    # Clearly we can assume that an inode is either in the
-    # textfile or binary group, but let's just stick to
-    # a single set of visited nodes.
-    visited = set()
-
-    # Note: we do *not* dedupe hardlinked symlinks, since
-    # it seems difficult or even impossible to relink
-    # symlinks while preserving inode.
-    for key in ("relocate_textfiles", "relocate_binaries"):
-        if key not in buildinfo:
-            continue
-        new_list = []
-        for rel_path in buildinfo[key]:
-            stat_result = os.lstat(os.path.join(root, rel_path))
-            identifier = (stat_result.st_dev, stat_result.st_ino)
-            if identifier in visited:
-                continue
-            visited.add(identifier)
-            new_list.append(rel_path)
-        buildinfo[key] = new_list
-
-
 def relocate_package(spec, allow_root):
     """
     Relocate the given package
@@ -1720,7 +1451,7 @@ def relocate_package(spec, allow_root):
     hash_to_prefix = dict()
     hash_to_prefix[spec.format("{hash}")] = str(spec.package.prefix)
     new_deps = spack.build_environment.get_rpath_deps(spec.package)
-    for d in new_deps + spec.dependencies(deptype="run"):
+    for d in new_deps:
         hash_to_prefix[d.format("{hash}")] = str(d.prefix)
     # Spurious replacements (e.g. sbang) will cause issues with binaries
     # For example, the new sbang can be longer than the old one.
@@ -1732,19 +1463,13 @@ def relocate_package(spec, allow_root):
         install_path = spack.hooks.sbang.sbang_install_path()
         prefix_to_prefix_text[old_sbang_install_path] = install_path
 
-    # First match specific prefix paths. Possibly the *local* install prefix
-    # of some dependency is in an upstream, so we cannot assume the original
-    # spack store root can be mapped uniformly to the new spack store root.
-    for orig_prefix, hash in prefix_to_hash.items():
-        prefix_to_prefix_text[orig_prefix] = hash_to_prefix.get(hash, None)
-        prefix_to_prefix_bin[orig_prefix] = hash_to_prefix.get(hash, None)
-
-    # Only then add the generic fallback of install prefix -> install prefix.
     prefix_to_prefix_text[old_prefix] = new_prefix
     prefix_to_prefix_bin[old_prefix] = new_prefix
     prefix_to_prefix_text[old_layout_root] = new_layout_root
     prefix_to_prefix_bin[old_layout_root] = new_layout_root
-
+    for orig_prefix, hash in prefix_to_hash.items():
+        prefix_to_prefix_text[orig_prefix] = hash_to_prefix.get(hash, None)
+        prefix_to_prefix_bin[orig_prefix] = hash_to_prefix.get(hash, None)
     # This is vestigial code for the *old* location of sbang. Previously,
     # sbang was a bash script, and it lived in the spack prefix. It is
     # now a POSIX script that lives in the install prefix. Old packages
@@ -1755,9 +1480,6 @@ def relocate_package(spec, allow_root):
 
     tty.debug("Relocating package from", "%s to %s." % (old_layout_root, new_layout_root))
 
-    # Old archives maybe have hardlinks repeated.
-    dedupe_hardlinks_if_necessary(workdir, buildinfo)
-
     def is_backup_file(file):
         return file.endswith("~")
 
@@ -1787,11 +1509,7 @@ def is_backup_file(file):
                 old_prefix,
                 new_prefix,
             )
-        elif "elf" in platform.binary_formats and not rel:
-            # The new ELF dynamic section relocation logic only handles absolute to
-            # absolute relocation.
-            relocate.new_relocate_elf_binaries(files_to_relocate, prefix_to_prefix_bin)
-        elif "elf" in platform.binary_formats and rel:
+        if "elf" in platform.binary_formats:
             relocate.relocate_elf_binaries(
                 files_to_relocate,
                 old_layout_root,
@@ -1801,23 +1519,35 @@ def is_backup_file(file):
                 old_prefix,
                 new_prefix,
             )
-
-        # Relocate links to the new install prefix
-        links = [os.path.join(workdir, f) for f in buildinfo.get("relocate_links", [])]
-        relocate.relocate_links(links, prefix_to_prefix_bin)
+            # Relocate links to the new install prefix
+            links = [link for link in buildinfo.get("relocate_links", [])]
+            relocate.relocate_links(links, old_layout_root, old_prefix, new_prefix)
 
         # For all buildcaches
         # relocate the install prefixes in text files including dependencies
-        relocate.unsafe_relocate_text(text_names, prefix_to_prefix_text)
+        relocate.relocate_text(text_names, prefix_to_prefix_text)
 
+        paths_to_relocate = [old_prefix, old_layout_root]
+        paths_to_relocate.extend(prefix_to_hash.keys())
+        files_to_relocate = list(
+            filter(
+                lambda pathname: not relocate.file_is_relocatable(
+                    pathname, paths_to_relocate=paths_to_relocate
+                ),
+                map(
+                    lambda filename: os.path.join(workdir, filename),
+                    buildinfo["relocate_binaries"],
+                ),
+            )
+        )
         # relocate the install prefixes in binary files including dependencies
-        relocate.unsafe_relocate_text_bin(files_to_relocate, prefix_to_prefix_bin)
+        relocate.relocate_text_bin(files_to_relocate, prefix_to_prefix_bin)
 
     # If we are installing back to the same location
     # relocate the sbang location if the spack directory changed
     else:
         if old_spack_prefix != new_spack_prefix:
-            relocate.unsafe_relocate_text(text_names, prefix_to_prefix_text)
+            relocate.relocate_text(text_names, prefix_to_prefix_text)
 
 
 def _extract_inner_tarball(spec, filename, extract_to, unsigned, remote_checksum):
@@ -2148,8 +1878,8 @@ def get_mirrors_for_spec(spec=None, mirrors_to_check=None, index_only=False):
 
     results = binary_index.find_built_spec(spec, mirrors_to_check=mirrors_to_check)
 
-    # The index may be out-of-date. If we aren't only considering indices, try
-    # to fetch directly since we know where the file should be.
+    # Maybe we just didn't have the latest information from the mirror, so
+    # try to fetch directly, unless we are only considering the indices.
     if not results and not index_only:
         results = try_direct_fetch(spec, mirrors=mirrors_to_check)
         # We found a spec by the direct fetch approach, we might as well
@@ -2224,7 +1954,7 @@ def get_keys(install=False, trust=False, force=False, mirrors=None):
                 if not os.path.exists(stage.save_filename):
                     try:
                         stage.fetch()
-                    except web_util.FetchError:
+                    except fs.FetchError:
                         continue
 
             tty.debug("Found key {0}".format(fingerprint))
@@ -2376,7 +2106,7 @@ def _download_buildcache_entry(mirror_root, descriptions):
             try:
                 stage.fetch()
                 break
-            except web_util.FetchError as e:
+            except fs.FetchError as e:
                 tty.debug(e)
         else:
             if fail_if_missing:

lib/spack/spack/bootstrap.py

@@ -15,7 +15,6 @@
 import re
 import sys
 import sysconfig
-import uuid
 
 import six
 
@@ -41,13 +40,10 @@
 import spack.util.path
 import spack.util.spack_yaml
 import spack.util.url
-import spack.version
 
 #: Name of the file containing metadata about the bootstrapping source
 METADATA_YAML_FILENAME = "metadata.yaml"
 
-is_windows = sys.platform == "win32"
-
 #: Map a bootstrapper type to the corresponding class
 _bootstrap_methods = {}
 
@@ -91,14 +87,6 @@ def _try_import_from_store(module, query_spec, query_info=None):
             os.path.join(candidate_spec.prefix, pkg.platlib),
         ]  # type: list[str]
         path_before = list(sys.path)
-
-        # Python 3.8+ on Windows does not search dependent DLLs in PATH,
-        # so we need to manually add it using os.add_dll_directory
-        # https://docs.python.org/3/whatsnew/3.8.html#bpo-36085-whatsnew
-        if sys.version_info[:2] >= (3, 8) and sys.platform == "win32":
-            if os.path.isdir(candidate_spec.prefix.bin):
-                os.add_dll_directory(candidate_spec.prefix.bin)  # novermin
-
         # NOTE: try module_paths first and last, last allows an existing version in path
         # to be picked up and used, possibly depending on something in the store, first
         # allows the bootstrap version to work when an incompatible version is in
@@ -272,11 +260,12 @@ def mirror_scope(self):
 class _BuildcacheBootstrapper(_BootstrapperBase):
     """Install the software needed during bootstrapping from a buildcache."""
 
+    config_scope_name = "bootstrap_buildcache"
+
     def __init__(self, conf):
         super(_BuildcacheBootstrapper, self).__init__(conf)
         self.metadata_dir = spack.util.path.canonicalize_path(conf["metadata"])
         self.last_search = None
-        self.config_scope_name = "bootstrap_buildcache-{}".format(uuid.uuid4())
 
     @staticmethod
     def _spec_and_platform(abstract_spec_str):
@@ -389,12 +378,13 @@ def try_search_path(self, executables, abstract_spec_str):
 class _SourceBootstrapper(_BootstrapperBase):
     """Install the software needed during bootstrapping from sources."""
 
+    config_scope_name = "bootstrap_source"
+
     def __init__(self, conf):
         super(_SourceBootstrapper, self).__init__(conf)
         self.metadata_dir = spack.util.path.canonicalize_path(conf["metadata"])
         self.conf = conf
         self.last_search = None
-        self.config_scope_name = "bootstrap_source-{}".format(uuid.uuid4())
 
     def try_import(self, module, abstract_spec_str):
         info = {}
@@ -665,8 +655,6 @@ def _add_externals_if_missing():
         # GnuPG
         spack.repo.path.get_pkg_class("gawk"),
     ]
-    if is_windows:
-        search_list.append(spack.repo.path.get_pkg_class("winbison"))
     detected_packages = spack.detection.by_executable(search_list)
     spack.detection.update_configuration(detected_packages, scope="bootstrap")
 
@@ -675,11 +663,6 @@ def _add_externals_if_missing():
 _REF_COUNT = 0
 
 
-def is_bootstrapping():
-    global _REF_COUNT
-    return _REF_COUNT > 0
-
-
 @contextlib.contextmanager
 def ensure_bootstrap_configuration():
     # The context manager is reference counted to ensure we don't swap multiple
@@ -805,46 +788,17 @@ def ensure_gpg_in_path_or_raise():
 
 def patchelf_root_spec():
     """Return the root spec used to bootstrap patchelf"""
-    # 0.13.1 is the last version not to require C++17.
-    return _root_spec("patchelf@0.13.1:")
-
-
-def verify_patchelf(patchelf):
-    """Older patchelf versions can produce broken binaries, so we
-    verify the version here.
-
-    Arguments:
-
-        patchelf (spack.util.executable.Executable): patchelf executable
-    """
-    out = patchelf("--version", output=str, error=os.devnull, fail_on_error=False).strip()
-    if patchelf.returncode != 0:
-        return False
-    parts = out.split(" ")
-    if len(parts) < 2:
-        return False
-    try:
-        version = spack.version.Version(parts[1])
-    except ValueError:
-        return False
-    return version >= spack.version.Version("0.13.1")
+    # TODO: patchelf is restricted to v0.13 since earlier versions have
+    # TODO: bugs that we don't to deal with, while v0.14 requires a C++17
+    # TODO: which may not be available on all platforms.
+    return _root_spec("patchelf@0.13.1:0.13.99")
 
 
 def ensure_patchelf_in_path_or_raise():
     """Ensure patchelf is in the PATH or raise."""
-    # The old concretizer is not smart and we're doing its job: if the latest patchelf
-    # does not concretize because the compiler doesn't support C++17, we try to
-    # concretize again with an upperbound @:13.
-    try:
-        return ensure_executables_in_path_or_raise(
-            executables=["patchelf"], abstract_spec=patchelf_root_spec(), cmd_check=verify_patchelf
-        )
-    except RuntimeError:
-        return ensure_executables_in_path_or_raise(
-            executables=["patchelf"],
-            abstract_spec=_root_spec("patchelf@0.13.1:0.13"),
-            cmd_check=verify_patchelf,
-        )
+    return ensure_executables_in_path_or_raise(
+        executables=["patchelf"], abstract_spec=patchelf_root_spec()
+    )
 
 
 ###

lib/spack/spack/build_environment.py

@@ -52,7 +52,6 @@
 
 import spack.build_systems.cmake
 import spack.build_systems.meson
-import spack.builder
 import spack.config
 import spack.install_test
 import spack.main
@@ -65,7 +64,6 @@
 import spack.subprocess_context
 import spack.user_environment
 import spack.util.path
-import spack.util.pattern
 from spack.error import NoHeadersError, NoLibrariesError
 from spack.installer import InstallError
 from spack.util.cpus import cpus_available
@@ -111,28 +109,21 @@
 
 
 # Platform-specific library suffix.
-if sys.platform == "darwin":
-    dso_suffix = "dylib"
-elif sys.platform == "win32":
-    dso_suffix = "dll"
-else:
-    dso_suffix = "so"
-
-stat_suffix = "lib" if sys.platform == "win32" else "a"
+dso_suffix = "dylib" if sys.platform == "darwin" else "so"
 
 
-def jobserver_enabled():
-    """Returns true if a posix jobserver (make) is detected."""
-    return "MAKEFLAGS" in os.environ and "--jobserver" in os.environ["MAKEFLAGS"]
-
-
-def get_effective_jobs(jobs, parallel=True, supports_jobserver=False):
-    """Return the number of jobs, or None if supports_jobserver and a jobserver is detected."""
-    if not parallel or jobs <= 1 or env_flag(SPACK_NO_PARALLEL_MAKE):
-        return 1
-    if supports_jobserver and jobserver_enabled():
-        return None
-    return jobs
+def should_set_parallel_jobs(jobserver_support=False):
+    """Returns true in general, except when:
+    - The env variable SPACK_NO_PARALLEL_MAKE=1 is set
+    - jobserver_support is enabled, and a jobserver was found.
+    """
+    if (
+        jobserver_support
+        and "MAKEFLAGS" in os.environ
+        and "--jobserver" in os.environ["MAKEFLAGS"]
+    ):
+        return False
+    return not env_flag(SPACK_NO_PARALLEL_MAKE)
 
 
 class MakeExecutable(Executable):
@@ -147,33 +138,26 @@ class MakeExecutable(Executable):
     """
 
     def __init__(self, name, jobs, **kwargs):
-        supports_jobserver = kwargs.pop("supports_jobserver", True)
         super(MakeExecutable, self).__init__(name, **kwargs)
-        self.supports_jobserver = supports_jobserver
         self.jobs = jobs
 
     def __call__(self, *args, **kwargs):
         """parallel, and jobs_env from kwargs are swallowed and used here;
         remaining arguments are passed through to the superclass.
         """
-        parallel = kwargs.pop("parallel", True)
-        jobs_env = kwargs.pop("jobs_env", None)
-        jobs_env_supports_jobserver = kwargs.pop("jobs_env_supports_jobserver", False)
-
-        jobs = get_effective_jobs(
-            self.jobs, parallel=parallel, supports_jobserver=self.supports_jobserver
+        # TODO: figure out how to check if we are using a jobserver-supporting ninja,
+        # the two split ninja packages make this very difficult right now
+        parallel = should_set_parallel_jobs(jobserver_support=True) and kwargs.pop(
+            "parallel", self.jobs > 1
         )
-        if jobs is not None:
-            args = ("-j{0}".format(jobs),) + args
 
-        if jobs_env:
-            # Caller wants us to set an environment variable to
-            # control the parallelism.
-            jobs_env_jobs = get_effective_jobs(
-                self.jobs, parallel=parallel, supports_jobserver=jobs_env_supports_jobserver
-            )
-            if jobs_env_jobs is not None:
-                kwargs["extra_env"] = {jobs_env: str(jobs_env_jobs)}
+        if parallel:
+            args = ("-j{0}".format(self.jobs),) + args
+            jobs_env = kwargs.pop("jobs_env", None)
+            if jobs_env:
+                # Caller wants us to set an environment variable to
+                # control the parallelism.
+                kwargs["extra_env"] = {jobs_env: str(self.jobs)}
 
         return super(MakeExecutable, self).__call__(*args, **kwargs)
 
@@ -209,8 +193,6 @@ def clean_environment():
 
     env.unset("CMAKE_PREFIX_PATH")
     env.unset("PYTHONPATH")
-    env.unset("R_HOME")
-    env.unset("R_ENVIRON")
 
     # Affects GNU make, can e.g. indirectly inhibit enabling parallel build
     # env.unset('MAKEFLAGS')
@@ -324,7 +306,7 @@ def set_compiler_environment_variables(pkg, env):
     env.set("SPACK_LINKER_ARG", compiler.linker_arg)
 
     # Check whether we want to force RPATH or RUNPATH
-    if spack.config.get("config:shared_linking:type") == "rpath":
+    if spack.config.get("config:shared_linking") == "rpath":
         env.set("SPACK_DTAGS_TO_STRIP", compiler.enable_new_dtags)
         env.set("SPACK_DTAGS_TO_ADD", compiler.disable_new_dtags)
     else:
@@ -332,11 +314,7 @@ def set_compiler_environment_variables(pkg, env):
         env.set("SPACK_DTAGS_TO_ADD", compiler.enable_new_dtags)
 
     # Set the target parameters that the compiler will add
-    # Don't set on cray platform because the targeting module handles this
-    if spec.satisfies("platform=cray"):
-        isa_arg = ""
-    else:
-        isa_arg = spec.architecture.target.optimization_flags(compiler)
+    isa_arg = spec.architecture.target.optimization_flags(compiler)
     env.set("SPACK_TARGET_ARGS", isa_arg)
 
     # Trap spack-tracked compiler flags as appropriate.
@@ -357,7 +335,7 @@ def set_compiler_environment_variables(pkg, env):
                 handler = pkg.flag_handler.__func__
             else:
                 handler = pkg.flag_handler.im_func
-        injf, envf, bsf = handler(pkg, flag, spec.compiler_flags[flag][:])
+        injf, envf, bsf = handler(pkg, flag, spec.compiler_flags[flag])
         inject_flags[flag] = injf or []
         env_flags[flag] = envf or []
         build_system_flags[flag] = bsf or []
@@ -558,7 +536,7 @@ def _set_variables_for_single_module(pkg, module):
     # TODO: make these build deps that can be installed if not found.
     m.make = MakeExecutable("make", jobs)
     m.gmake = MakeExecutable("gmake", jobs)
-    m.ninja = MakeExecutable("ninja", jobs, supports_jobserver=False)
+    m.ninja = MakeExecutable("ninja", jobs)
 
     # easy shortcut to os.environ
     m.env = os.environ
@@ -570,9 +548,9 @@ def _set_variables_for_single_module(pkg, module):
     if sys.platform == "win32":
         m.nmake = Executable("nmake")
     # Standard CMake arguments
-    m.std_cmake_args = spack.build_systems.cmake.CMakeBuilder.std_args(pkg)
-    m.std_meson_args = spack.build_systems.meson.MesonBuilder.std_args(pkg)
-    m.std_pip_args = spack.build_systems.python.PythonPipBuilder.std_args(pkg)
+    m.std_cmake_args = spack.build_systems.cmake.CMakePackage._std_args(pkg)
+    m.std_meson_args = spack.build_systems.meson.MesonPackage._std_args(pkg)
+    m.std_pip_args = spack.build_systems.python.PythonPackage._std_args(pkg)
 
     # Put spack compiler paths in module scope.
     link_dir = spack.paths.build_env_path
@@ -739,6 +717,38 @@ def get_rpaths(pkg):
     return list(dedupe(filter_system_paths(rpaths)))
 
 
+def get_std_cmake_args(pkg):
+    """List of standard arguments used if a package is a CMakePackage.
+
+    Returns:
+        list: standard arguments that would be used if this
+        package were a CMakePackage instance.
+
+    Args:
+        pkg (spack.package_base.PackageBase): package under consideration
+
+    Returns:
+        list: arguments for cmake
+    """
+    return spack.build_systems.cmake.CMakePackage._std_args(pkg)
+
+
+def get_std_meson_args(pkg):
+    """List of standard arguments used if a package is a MesonPackage.
+
+    Returns:
+        list: standard arguments that would be used if this
+        package were a MesonPackage instance.
+
+    Args:
+        pkg (spack.package_base.PackageBase): package under consideration
+
+    Returns:
+        list: arguments for meson
+    """
+    return spack.build_systems.meson.MesonPackage._std_args(pkg)
+
+
 def parent_class_modules(cls):
     """
     Get list of superclass modules that descend from spack.package_base.PackageBase
@@ -799,8 +809,7 @@ def setup_package(pkg, dirty, context="build"):
     platform.setup_platform_environment(pkg, env_mods)
 
     if context == "build":
-        builder = spack.builder.create(pkg)
-        builder.setup_build_environment(env_mods)
+        pkg.setup_build_environment(env_mods)
 
         if (not dirty) and (not env_mods.is_unset("CPATH")):
             tty.debug(
@@ -977,27 +986,10 @@ def add_modifications_for_dep(dep):
             dpkg = dep.package
             if set_package_py_globals:
                 set_module_variables_for_package(dpkg)
-
             # Allow dependencies to modify the module
-            # Get list of modules that may need updating
-            modules = []
-            for cls in inspect.getmro(type(spec.package)):
-                module = cls.module
-                if module == spack.package_base:
-                    break
-                modules.append(module)
-
-            # Execute changes as if on a single module
-            # copy dict to ensure prior changes are available
-            changes = spack.util.pattern.Bunch()
-            dpkg.setup_dependent_package(changes, spec)
-
-            for module in modules:
-                module.__dict__.update(changes.__dict__)
-
+            dpkg.setup_dependent_package(spec.package.module, spec)
             if context == "build":
-                builder = spack.builder.create(dpkg)
-                builder.setup_dependent_build_environment(env, spec)
+                dpkg.setup_dependent_build_environment(env, spec)
             else:
                 dpkg.setup_dependent_run_environment(env, spec)
 
@@ -1038,11 +1030,8 @@ def get_cmake_prefix_path(pkg):
                 spack_built.insert(0, dspec)
 
     ordered_build_link_deps = spack_built + externals
-    cmake_prefix_path_entries = []
-    for spec in ordered_build_link_deps:
-        cmake_prefix_path_entries.extend(spec.package.cmake_prefix_paths)
-
-    return filter_system_paths(cmake_prefix_path_entries)
+    build_link_prefixes = filter_system_paths(x.prefix for x in ordered_build_link_deps)
+    return build_link_prefixes
 
 
 def _setup_pkg_and_run(
@@ -1099,20 +1088,8 @@ def _setup_pkg_and_run(
                 pkg.test_suite.stage, spack.install_test.TestSuite.test_log_name(pkg.spec)
             )
 
-        error_msg = str(exc)
-        if isinstance(exc, (spack.multimethod.NoSuchMethodError, AttributeError)):
-            error_msg = (
-                "The '{}' package cannot find an attribute while trying to build "
-                "from sources. This might be due to a change in Spack's package format "
-                "to support multiple build-systems for a single package. You can fix this "
-                "by updating the build recipe, and you can also report the issue as a bug. "
-                "More information at https://spack.readthedocs.io/en/latest/packaging_guide.html#installation-procedure"
-            ).format(pkg.name)
-            error_msg = colorize("@*R{{{}}}".format(error_msg))
-            error_msg = "{}\n\n{}".format(str(exc), error_msg)
-
         # make a pickleable exception to send to parent.
-        msg = "%s: %s" % (exc_type.__name__, error_msg)
+        msg = "%s: %s" % (exc_type.__name__, str(exc))
 
         ce = ChildError(
             msg,

lib/spack/spack/build_systems/_checks.py

@@ -1,124 +0,0 @@
-# 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)
-import os
-
-import six
-
-import llnl.util.lang
-
-import spack.builder
-import spack.installer
-import spack.relocate
-import spack.store
-
-
-def sanity_check_prefix(builder):
-    """Check that specific directories and files are created after installation.
-
-    The files to be checked are in the ``sanity_check_is_file`` attribute of the
-    package object, while the directories are in the ``sanity_check_is_dir``.
-
-    Args:
-        builder (spack.builder.Builder): builder that installed the package
-    """
-    pkg = builder.pkg
-
-    def check_paths(path_list, filetype, predicate):
-        if isinstance(path_list, six.string_types):
-            path_list = [path_list]
-
-        for path in path_list:
-            abs_path = os.path.join(pkg.prefix, path)
-            if not predicate(abs_path):
-                msg = "Install failed for {0}. No such {1} in prefix: {2}"
-                msg = msg.format(pkg.name, filetype, path)
-                raise spack.installer.InstallError(msg)
-
-    check_paths(pkg.sanity_check_is_file, "file", os.path.isfile)
-    check_paths(pkg.sanity_check_is_dir, "directory", os.path.isdir)
-
-    ignore_file = llnl.util.lang.match_predicate(spack.store.layout.hidden_file_regexes)
-    if all(map(ignore_file, os.listdir(pkg.prefix))):
-        msg = "Install failed for {0}.  Nothing was installed!"
-        raise spack.installer.InstallError(msg.format(pkg.name))
-
-
-def apply_macos_rpath_fixups(builder):
-    """On Darwin, make installed libraries more easily relocatable.
-
-    Some build systems (handrolled, autotools, makefiles) can set their own
-    rpaths that are duplicated by spack's compiler wrapper. This fixup
-    interrogates, and postprocesses if necessary, all libraries installed
-    by the code.
-
-    It should be added as a @run_after to packaging systems (or individual
-    packages) that do not install relocatable libraries by default.
-
-    Args:
-        builder (spack.builder.Builder): builder that installed the package
-    """
-    spack.relocate.fixup_macos_rpaths(builder.spec)
-
-
-def ensure_build_dependencies_or_raise(spec, dependencies, error_msg):
-    """Ensure that some build dependencies are present in the concrete spec.
-
-    If not, raise a RuntimeError with a helpful error message.
-
-    Args:
-        spec (spack.spec.Spec): concrete spec to be checked.
-        dependencies (list of spack.spec.Spec): list of abstract specs to be satisfied
-        error_msg (str): brief error message to be prepended to a longer description
-
-    Raises:
-          RuntimeError: when the required build dependencies are not found
-    """
-    assert spec.concrete, "Can ensure build dependencies only on concrete specs"
-    build_deps = [d.name for d in spec.dependencies(deptype="build")]
-    missing_deps = [x for x in dependencies if x not in build_deps]
-
-    if not missing_deps:
-        return
-
-    # Raise an exception on missing deps.
-    msg = (
-        "{0}: missing dependencies: {1}.\n\nPlease add "
-        "the following lines to the package:\n\n".format(error_msg, ", ".join(missing_deps))
-    )
-
-    for dep in missing_deps:
-        msg += "    depends_on('{0}', type='build', when='@{1} {2}')\n".format(
-            dep, spec.version, "build_system=autotools"
-        )
-
-    msg += "\nUpdate the version (when='@{0}') as needed.".format(spec.version)
-    raise RuntimeError(msg)
-
-
-def execute_build_time_tests(builder):
-    """Execute the build-time tests prescribed by builder.
-
-    Args:
-        builder (Builder): builder prescribing the test callbacks. The name of the callbacks is
-            stored as a list of strings in the ``build_time_test_callbacks`` attribute.
-    """
-    builder.pkg.run_test_callbacks(builder, builder.build_time_test_callbacks, "build")
-
-
-def execute_install_time_tests(builder):
-    """Execute the install-time tests prescribed by builder.
-
-    Args:
-        builder (Builder): builder prescribing the test callbacks. The name of the callbacks is
-            stored as a list of strings in the ``install_time_test_callbacks`` attribute.
-    """
-    builder.pkg.run_test_callbacks(builder, builder.install_time_test_callbacks, "install")
-
-
-class BaseBuilder(spack.builder.Builder):
-    """Base class for builders to register common checks"""
-
-    # Check that self.prefix is there after installation
-    spack.builder.run_after("install")(sanity_check_prefix)

lib/spack/spack/build_systems/aspell_dict.py

@@ -2,36 +2,18 @@
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
-import llnl.util.filesystem as fs
 
-import spack.directives
-import spack.package_base
-import spack.util.executable
+# Why doesn't this work for me?
+# from spack import *
+from llnl.util.filesystem import filter_file
 
-from .autotools import AutotoolsBuilder, AutotoolsPackage
-
-
-class AspellBuilder(AutotoolsBuilder):
-    """The Aspell builder is close enough to an autotools builder to allow
-    specializing the builder class, so to use variables that are specific
-    to the Aspell extensions.
-    """
-
-    def configure(self, pkg, spec, prefix):
-        aspell = spec["aspell"].prefix.bin.aspell
-        prezip = spec["aspell"].prefix.bin.prezip
-        destdir = prefix
-
-        sh = spack.util.executable.which("sh")
-        sh(
-            "./configure",
-            "--vars",
-            "ASPELL={0}".format(aspell),
-            "PREZIP={0}".format(prezip),
-            "DESTDIR={0}".format(destdir),
-        )
+from spack.build_systems.autotools import AutotoolsPackage
+from spack.directives import extends
+from spack.package_base import ExtensionError
+from spack.util.executable import which
 
 
+#
 # Aspell dictionaries install their bits into their prefix.lib
 # and when activated they'll get symlinked into the appropriate aspell's
 # dict dir (see aspell's {de,}activate methods).
@@ -41,17 +23,12 @@ def configure(self, pkg, spec, prefix):
 class AspellDictPackage(AutotoolsPackage):
     """Specialized class for building aspell dictionairies."""
 
-    spack.directives.extends("aspell", when="build_system=autotools")
-
-    #: Override the default autotools builder
-    AutotoolsBuilder = AspellBuilder
+    extends("aspell")
 
     def view_destination(self, view):
         aspell_spec = self.spec["aspell"]
         if view.get_projection_for_spec(aspell_spec) != aspell_spec.prefix:
-            raise spack.package_base.ExtensionError(
-                "aspell does not support non-global extensions"
-            )
+            raise ExtensionError("aspell does not support non-global extensions")
         aspell = aspell_spec.command
         return aspell("dump", "config", "dict-dir", output=str).strip()
 
@@ -59,5 +36,19 @@ def view_source(self):
         return self.prefix.lib
 
     def patch(self):
-        fs.filter_file(r"^dictdir=.*$", "dictdir=/lib", "configure")
-        fs.filter_file(r"^datadir=.*$", "datadir=/lib", "configure")
+        filter_file(r"^dictdir=.*$", "dictdir=/lib", "configure")
+        filter_file(r"^datadir=.*$", "datadir=/lib", "configure")
+
+    def configure(self, spec, prefix):
+        aspell = spec["aspell"].prefix.bin.aspell
+        prezip = spec["aspell"].prefix.bin.prezip
+        destdir = prefix
+
+        sh = which("sh")
+        sh(
+            "./configure",
+            "--vars",
+            "ASPELL={0}".format(aspell),
+            "PREZIP={0}".format(prezip),
+            "DESTDIR={0}".format(destdir),
+        )

lib/spack/spack/build_systems/autotools.py

@@ -6,140 +6,87 @@
 import os
 import os.path
 import stat
-import subprocess
+from subprocess import PIPE, check_call
 from typing import List  # novm
 
 import llnl.util.filesystem as fs
 import llnl.util.tty as tty
+from llnl.util.filesystem import force_remove, working_dir
 
-import spack.build_environment
-import spack.builder
-import spack.package_base
-from spack.directives import build_system, conflicts, depends_on
-from spack.multimethod import when
+from spack.build_environment import InstallError
+from spack.directives import conflicts, depends_on
 from spack.operating_systems.mac_os import macos_version
+from spack.package_base import PackageBase, run_after, run_before
 from spack.util.executable import Executable
 from spack.version import Version
 
-from ._checks import (
-    BaseBuilder,
-    apply_macos_rpath_fixups,
-    ensure_build_dependencies_or_raise,
-    execute_build_time_tests,
-    execute_install_time_tests,
-)
 
+class AutotoolsPackage(PackageBase):
+    """Specialized class for packages built using GNU Autotools.
 
-class AutotoolsPackage(spack.package_base.PackageBase):
-    """Specialized class for packages built using GNU Autotools."""
+    This class provides four phases that can be overridden:
 
-    #: This attribute is used in UI queries that need to know the build
-    #: system base class
-    build_system_class = "AutotoolsPackage"
-
-    #: Legacy buildsystem attribute used to deserialize and install old specs
-    legacy_buildsystem = "autotools"
-
-    build_system("autotools")
-
-    with when("build_system=autotools"):
-        depends_on("gnuconfig", type="build", when="target=ppc64le:")
-        depends_on("gnuconfig", type="build", when="target=aarch64:")
-        depends_on("gnuconfig", type="build", when="target=riscv64:")
-        conflicts("platform=windows")
-
-    def flags_to_build_system_args(self, flags):
-        """Produces a list of all command line arguments to pass specified
-        compiler flags to configure."""
-        # Has to be dynamic attribute due to caching.
-        setattr(self, "configure_flag_args", [])
-        for flag, values in flags.items():
-            if values:
-                values_str = "{0}={1}".format(flag.upper(), " ".join(values))
-                self.configure_flag_args.append(values_str)
-        # Spack's fflags are meant for both F77 and FC, therefore we
-        # additionaly set FCFLAGS if required.
-        values = flags.get("fflags", None)
-        if values:
-            values_str = "FCFLAGS={0}".format(" ".join(values))
-            self.configure_flag_args.append(values_str)
-
-    # Legacy methods (used by too many packages to change them,
-    # need to forward to the builder)
-    def enable_or_disable(self, *args, **kwargs):
-        return self.builder.enable_or_disable(*args, **kwargs)
-
-    def with_or_without(self, *args, **kwargs):
-        return self.builder.with_or_without(*args, **kwargs)
-
-
-@spack.builder.builder("autotools")
-class AutotoolsBuilder(BaseBuilder):
-    """The autotools builder encodes the default way of installing software built
-    with autotools. It has four phases that can be overridden, if need be:
-
-        1. :py:meth:`~.AutotoolsBuilder.autoreconf`
-        2. :py:meth:`~.AutotoolsBuilder.configure`
-        3. :py:meth:`~.AutotoolsBuilder.build`
-        4. :py:meth:`~.AutotoolsBuilder.install`
-
-    They all have sensible defaults and for many packages the only thing necessary
-    is to override the helper method
-    :meth:`~spack.build_systems.autotools.AutotoolsBuilder.configure_args`.
+        1. :py:meth:`~.AutotoolsPackage.autoreconf`
+        2. :py:meth:`~.AutotoolsPackage.configure`
+        3. :py:meth:`~.AutotoolsPackage.build`
+        4. :py:meth:`~.AutotoolsPackage.install`
 
+    They all have sensible defaults and for many packages the only thing
+    necessary will be to override the helper method
+    :meth:`~spack.build_systems.autotools.AutotoolsPackage.configure_args`.
     For a finer tuning you may also override:
 
         +-----------------------------------------------+--------------------+
         | **Method**                                    | **Purpose**        |
         +===============================================+====================+
-        | :py:attr:`~.AutotoolsBuilder.build_targets`   | Specify ``make``   |
+        | :py:attr:`~.AutotoolsPackage.build_targets`   | Specify ``make``   |
         |                                               | targets for the    |
         |                                               | build phase        |
         +-----------------------------------------------+--------------------+
-        | :py:attr:`~.AutotoolsBuilder.install_targets` | Specify ``make``   |
+        | :py:attr:`~.AutotoolsPackage.install_targets` | Specify ``make``   |
         |                                               | targets for the    |
         |                                               | install phase      |
         +-----------------------------------------------+--------------------+
-        | :py:meth:`~.AutotoolsBuilder.check`           | Run  build time    |
+        | :py:meth:`~.AutotoolsPackage.check`           | Run  build time    |
         |                                               | tests if required  |
         +-----------------------------------------------+--------------------+
 
     """
 
     #: Phases of a GNU Autotools package
-    phases = ("autoreconf", "configure", "build", "install")
+    phases = ["autoreconf", "configure", "build", "install"]
+    #: This attribute is used in UI queries that need to know the build
+    #: system base class
+    build_system_class = "AutotoolsPackage"
 
-    #: Names associated with package methods in the old build-system format
-    legacy_methods = (
-        "configure_args",
-        "check",
-        "installcheck",
-    )
+    @property
+    def patch_config_files(self):
+        """
+        Whether or not to update old ``config.guess`` and ``config.sub`` files
+        distributed with the tarball. This currently only applies to
+        ``ppc64le:``, ``aarch64:``, and ``riscv64`` target architectures. The
+        substitutes are taken from the ``gnuconfig`` package, which is
+        automatically added as a build dependency for these architectures. In
+        case system versions of these config files are required, the
+        ``gnuconfig`` package can be marked external with a prefix pointing to
+        the directory containing the system ``config.guess`` and ``config.sub``
+        files.
+        """
+        return (
+            self.spec.satisfies("target=ppc64le:")
+            or self.spec.satisfies("target=aarch64:")
+            or self.spec.satisfies("target=riscv64:")
+        )
 
-    #: Names associated with package attributes in the old build-system format
-    legacy_attributes = (
-        "archive_files",
-        "patch_libtool",
-        "build_targets",
-        "install_targets",
-        "build_time_test_callbacks",
-        "install_time_test_callbacks",
-        "force_autoreconf",
-        "autoreconf_extra_args",
-        "install_libtool_archives",
-        "patch_config_files",
-        "configure_directory",
-        "configure_abs_path",
-        "build_directory",
-        "autoreconf_search_path_args",
-    )
-
-    #: Whether to update ``libtool`` (e.g. for Arm/Clang/Fujitsu/NVHPC compilers)
+    #: Whether or not to update ``libtool``
+    #: (currently only for Arm/Clang/Fujitsu/NVHPC compilers)
     patch_libtool = True
 
-    #: Targets for ``make`` during the :py:meth:`~.AutotoolsBuilder.build` phase
+    #: Targets for ``make`` during the :py:meth:`~.AutotoolsPackage.build`
+    #: phase
     build_targets = []  # type: List[str]
-    #: Targets for ``make`` during the :py:meth:`~.AutotoolsBuilder.install` phase
+    #: Targets for ``make`` during the :py:meth:`~.AutotoolsPackage.install`
+    #: phase
     install_targets = ["install"]
 
     #: Callback names for build-time test
@@ -150,40 +97,24 @@ class AutotoolsBuilder(BaseBuilder):
 
     #: Set to true to force the autoreconf step even if configure is present
     force_autoreconf = False
-
     #: Options to be passed to autoreconf when using the default implementation
     autoreconf_extra_args = []  # type: List[str]
 
-    #: If False deletes all the .la files in the prefix folder after the installation.
-    #: If True instead it installs them.
+    #: If False deletes all the .la files in the prefix folder
+    #: after the installation. If True instead it installs them.
     install_libtool_archives = False
 
-    @property
-    def patch_config_files(self):
-        """Whether to update old ``config.guess`` and ``config.sub`` files
-        distributed with the tarball.
-
-        This currently only applies to ``ppc64le:``, ``aarch64:``, and
-        ``riscv64`` target architectures.
-
-        The substitutes are taken from the ``gnuconfig`` package, which is
-        automatically added as a build dependency for these architectures. In case
-        system versions of these config files are required, the ``gnuconfig`` package
-        can be marked external, with a prefix pointing to the directory containing the
-        system ``config.guess`` and ``config.sub`` files.
-        """
-        return (
-            self.pkg.spec.satisfies("target=ppc64le:")
-            or self.pkg.spec.satisfies("target=aarch64:")
-            or self.pkg.spec.satisfies("target=riscv64:")
-        )
+    depends_on("gnuconfig", type="build", when="target=ppc64le:")
+    depends_on("gnuconfig", type="build", when="target=aarch64:")
+    depends_on("gnuconfig", type="build", when="target=riscv64:")
+    conflicts("platform=windows")
 
     @property
     def _removed_la_files_log(self):
-        """File containing the list of removed libtool archives"""
+        """File containing the list of remove libtool archives"""
         build_dir = self.build_directory
         if not os.path.isabs(self.build_directory):
-            build_dir = os.path.join(self.pkg.stage.path, build_dir)
+            build_dir = os.path.join(self.stage.path, build_dir)
         return os.path.join(build_dir, "removed_la_files.txt")
 
     @property
@@ -194,13 +125,13 @@ def archive_files(self):
             files.append(self._removed_la_files_log)
         return files
 
-    @spack.builder.run_after("autoreconf")
+    @run_after("autoreconf")
     def _do_patch_config_files(self):
-        """Some packages ship with older config.guess/config.sub files and need to
-        have these updated when installed on a newer architecture.
-
-        In particular, config.guess fails for PPC64LE for version prior to a
-        2013-06-10 build date (automake 1.13.4) and for AArch64 and RISC-V.
+        """Some packages ship with older config.guess/config.sub files and
+        need to have these updated when installed on a newer architecture.
+        In particular, config.guess fails for PPC64LE for version prior
+        to a 2013-06-10 build date (automake 1.13.4) and for ARM (aarch64) and
+        RISC-V (riscv64).
         """
         if not self.patch_config_files:
             return
@@ -208,11 +139,11 @@ def _do_patch_config_files(self):
         # TODO: Expand this to select the 'config.sub'-compatible architecture
         # for each platform (e.g. 'config.sub' doesn't accept 'power9le', but
         # does accept 'ppc64le').
-        if self.pkg.spec.satisfies("target=ppc64le:"):
+        if self.spec.satisfies("target=ppc64le:"):
             config_arch = "ppc64le"
-        elif self.pkg.spec.satisfies("target=aarch64:"):
+        elif self.spec.satisfies("target=aarch64:"):
             config_arch = "aarch64"
-        elif self.pkg.spec.satisfies("target=riscv64:"):
+        elif self.spec.satisfies("target=riscv64:"):
             config_arch = "riscv64"
         else:
             config_arch = "local"
@@ -224,7 +155,7 @@ def runs_ok(script_abs_path):
             args = [script_abs_path] + additional_args.get(script_name, [])
 
             try:
-                subprocess.check_call(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                check_call(args, stdout=PIPE, stderr=PIPE)
             except Exception as e:
                 tty.debug(e)
                 return False
@@ -232,7 +163,7 @@ def runs_ok(script_abs_path):
             return True
 
         # Get the list of files that needs to be patched
-        to_be_patched = fs.find(self.pkg.stage.path, files=["config.sub", "config.guess"])
+        to_be_patched = fs.find(self.stage.path, files=["config.sub", "config.guess"])
         to_be_patched = [f for f in to_be_patched if not runs_ok(f)]
 
         # If there are no files to be patched, return early
@@ -240,21 +171,22 @@ def runs_ok(script_abs_path):
             return
 
         # Otherwise, require `gnuconfig` to be a build dependency
-        ensure_build_dependencies_or_raise(
-            spec=self.pkg.spec, dependencies=["gnuconfig"], error_msg="Cannot patch config files"
+        self._require_build_deps(
+            pkgs=["gnuconfig"], spec=self.spec, err="Cannot patch config files"
         )
 
         # Get the config files we need to patch (config.sub / config.guess).
         to_be_found = list(set(os.path.basename(f) for f in to_be_patched))
-        gnuconfig = self.pkg.spec["gnuconfig"]
+        gnuconfig = self.spec["gnuconfig"]
         gnuconfig_dir = gnuconfig.prefix
 
         # An external gnuconfig may not not have a prefix.
         if gnuconfig_dir is None:
-            raise spack.build_environment.InstallError(
-                "Spack could not find substitutes for GNU config files because no "
-                "prefix is available for the `gnuconfig` package. Make sure you set a "
-                "prefix path instead of modules for external `gnuconfig`."
+            raise InstallError(
+                "Spack could not find substitutes for GNU config "
+                "files because no prefix is available for the "
+                "`gnuconfig` package. Make sure you set a prefix "
+                "path instead of modules for external `gnuconfig`."
             )
 
         candidates = fs.find(gnuconfig_dir, files=to_be_found, recursive=False)
@@ -271,7 +203,7 @@ def runs_ok(script_abs_path):
                 msg += (
                     " or the `gnuconfig` package prefix is misconfigured as" " an external package"
                 )
-            raise spack.build_environment.InstallError(msg)
+            raise InstallError(msg)
 
         # Filter working substitutes
         candidates = [f for f in candidates if runs_ok(f)]
@@ -296,9 +228,7 @@ def runs_ok(script_abs_path):
    and set the prefix to the directory containing the `config.guess` and
    `config.sub` files.
 """
-            raise spack.build_environment.InstallError(
-                msg.format(", ".join(to_be_found), self.name)
-            )
+            raise InstallError(msg.format(", ".join(to_be_found), self.name))
 
         # Copy the good files over the bad ones
         for abs_path in to_be_patched:
@@ -308,19 +238,16 @@ def runs_ok(script_abs_path):
             fs.copy(substitutes[name], abs_path)
             os.chmod(abs_path, mode)
 
-    @spack.builder.run_before("configure")
+    @run_before("configure")
     def _patch_usr_bin_file(self):
         """On NixOS file is not available in /usr/bin/file. Patch configure
         scripts to use file from path."""
 
         if self.spec.os.startswith("nixos"):
-            x = fs.FileFilter(
-                *filter(fs.is_exe, fs.find(self.build_directory, "configure", recursive=True))
-            )
-            with fs.keep_modification_time(*x.filenames):
-                x.filter(regex="/usr/bin/file", repl="file", string=True)
+            for configure_file in fs.find(".", files=["configure"], recursive=True):
+                fs.filter_file("/usr/bin/file", "file", configure_file, string=True)
 
-    @spack.builder.run_before("configure")
+    @run_before("configure")
     def _set_autotools_environment_variables(self):
         """Many autotools builds use a version of mknod.m4 that fails when
         running as root unless FORCE_UNSAFE_CONFIGURE is set to 1.
@@ -331,102 +258,38 @@ def _set_autotools_environment_variables(self):
         Without it, configure just fails halfway through, but it can
         still run things *before* this check. Forcing this just removes a
         nuisance -- this is not circumventing any real protection.
+
         """
         os.environ["FORCE_UNSAFE_CONFIGURE"] = "1"
 
-    @spack.builder.run_before("configure")
-    def _do_patch_libtool_configure(self):
-        """Patch bugs that propagate from libtool macros into "configure" and
-        further into "libtool". Note that patches that can be fixed by patching
-        "libtool" directly should be implemented in the _do_patch_libtool method
-        below."""
-
-        # Exit early if we are required not to patch libtool-related problems:
-        if not self.patch_libtool:
-            return
-
-        x = fs.FileFilter(
-            *filter(fs.is_exe, fs.find(self.build_directory, "configure", recursive=True))
-        )
-
-        # There are distributed automatically generated files that depend on the configure script
-        # and require additional tools for rebuilding.
-        # See https://github.com/spack/spack/pull/30768#issuecomment-1219329860
-        with fs.keep_modification_time(*x.filenames):
-            # Fix parsing of compiler output when collecting predeps and postdeps
-            # https://lists.gnu.org/archive/html/bug-libtool/2016-03/msg00003.html
-            x.filter(regex=r'^(\s*if test x-L = )("\$p" \|\|\s*)$', repl=r"\1x\2")
-            x.filter(
-                regex=r'^(\s*test x-R = )("\$p")(; then\s*)$', repl=r'\1x\2 || test x-l = x"$p"\3'
-            )
-            # Support Libtool 2.4.2 and older:
-            x.filter(regex=r'^(\s*test \$p = "-R")(; then\s*)$', repl=r'\1 || test x-l = x"$p"\2')
-
-    @spack.builder.run_after("configure")
+    @run_after("configure")
     def _do_patch_libtool(self):
         """If configure generates a "libtool" script that does not correctly
         detect the compiler (and patch_libtool is set), patch in the correct
-        values for libtool variables.
+        flags for the Arm, Clang/Flang, Fujitsu and NVHPC compilers."""
 
-        The generated libtool script supports mixed compilers through tags:
-        ``libtool --tag=CC/CXX/FC/...```. For each tag there is a block with variables,
-        which defines what flags to pass to the compiler. The default variables (which
-        are used by the default tag CC) are set in a block enclosed by
-        ``# ### {BEGIN,END} LIBTOOL CONFIG``. For non-default tags, there are
-        corresponding blocks ``# ### {BEGIN,END} LIBTOOL TAG CONFIG: {CXX,FC,F77}`` at
-        the end of the file (after the exit command). libtool evals these blocks.
-        Whenever we need to update variables that the configure script got wrong
-        (for example cause it did not recognize the compiler), we should properly scope
-        those changes to these tags/blocks so they only apply to the compiler we care
-        about. Below, ``start_at`` and ``stop_at`` are used for that."""
-
-        # Exit early if we are required not to patch libtool:
+        # Exit early if we are required not to patch libtool
         if not self.patch_libtool:
             return
 
-        x = fs.FileFilter(
-            *filter(fs.is_exe, fs.find(self.build_directory, "libtool", recursive=True))
-        )
+        for libtool_path in fs.find(self.build_directory, "libtool", recursive=True):
+            self._patch_libtool(libtool_path)
 
-        # Exit early if there is nothing to patch:
-        if not x.filenames:
-            return
-
-        markers = {"cc": "LIBTOOL CONFIG"}
-        for tag in ["cxx", "fc", "f77"]:
-            markers[tag] = "LIBTOOL TAG CONFIG: {0}".format(tag.upper())
-
-        # Replace empty linker flag prefixes:
-        if self.pkg.compiler.name == "nag":
-            # Nag is mixed with gcc and g++, which are recognized correctly.
-            # Therefore, we change only Fortran values:
-            for tag in ["fc", "f77"]:
-                marker = markers[tag]
-                x.filter(
-                    regex='^wl=""$',
-                    repl='wl="{0}"'.format(self.pkg.compiler.linker_arg),
-                    start_at="# ### BEGIN {0}".format(marker),
-                    stop_at="# ### END {0}".format(marker),
-                )
-        else:
-            x.filter(regex='^wl=""$', repl='wl="{0}"'.format(self.pkg.compiler.linker_arg))
-
-        # Replace empty PIC flag values:
-        for cc, marker in markers.items():
-            x.filter(
-                regex='^pic_flag=""$',
-                repl='pic_flag="{0}"'.format(
-                    getattr(self.pkg.compiler, "{0}_pic_flag".format(cc))
-                ),
-                start_at="# ### BEGIN {0}".format(marker),
-                stop_at="# ### END {0}".format(marker),
+    def _patch_libtool(self, libtool_path):
+        if (
+            self.spec.satisfies("%arm")
+            or self.spec.satisfies("%clang")
+            or self.spec.satisfies("%fj")
+            or self.spec.satisfies("%nvhpc")
+        ):
+            fs.filter_file('wl=""\n', 'wl="-Wl,"\n', libtool_path)
+            fs.filter_file(
+                'pic_flag=""\n', 'pic_flag="{0}"\n'.format(self.compiler.cc_pic_flag), libtool_path
             )
-
-        # Other compiler-specific patches:
-        if self.pkg.compiler.name == "fj":
-            x.filter(regex="-nostdlib", repl="", string=True)
+        if self.spec.satisfies("%fj"):
+            fs.filter_file("-nostdlib", "", libtool_path)
             rehead = r"/\S*/"
-            for o in [
+            objfile = [
                 "fjhpctag.o",
                 "fjcrt0.o",
                 "fjlang08.o",
@@ -434,91 +297,17 @@ def _do_patch_libtool(self):
                 "crti.o",
                 "crtbeginS.o",
                 "crtendS.o",
-            ]:
-                x.filter(regex=(rehead + o), repl="", string=True)
-        elif self.pkg.compiler.name == "dpcpp":
-            # Hack to filter out spurious predep_objects when building with Intel dpcpp
-            # (see https://github.com/spack/spack/issues/32863):
-            x.filter(regex=r"^(predep_objects=.*)/tmp/conftest-[0-9A-Fa-f]+\.o", repl=r"\1")
-            x.filter(regex=r"^(predep_objects=.*)/tmp/a-[0-9A-Fa-f]+\.o", repl=r"\1")
-        elif self.pkg.compiler.name == "nag":
-            for tag in ["fc", "f77"]:
-                marker = markers[tag]
-                start_at = "# ### BEGIN {0}".format(marker)
-                stop_at = "# ### END {0}".format(marker)
-                # Libtool 2.4.2 does not know the shared flag:
-                x.filter(
-                    regex=r"\$CC -shared",
-                    repl=r"\$CC -Wl,-shared",
-                    string=True,
-                    start_at=start_at,
-                    stop_at=stop_at,
-                )
-                # Libtool does not know how to inject whole archives
-                # (e.g. https://github.com/pmodels/mpich/issues/4358):
-                x.filter(
-                    regex=r'^whole_archive_flag_spec="\\\$({?wl}?)--whole-archive'
-                    r'\\\$convenience \\\$\1--no-whole-archive"$',
-                    repl=r'whole_archive_flag_spec="\$\1--whole-archive'
-                    r"\`for conv in \$convenience\\\\\"\\\\\"; do test -n \\\\\"\$conv\\\\\" && "
-                    r"new_convenience=\\\\\"\$new_convenience,\$conv\\\\\"; done; "
-                    r'func_echo_all \\\\\"\$new_convenience\\\\\"\` \$\1--no-whole-archive"',
-                    start_at=start_at,
-                    stop_at=stop_at,
-                )
-                # The compiler requires special treatment in certain cases:
-                x.filter(
-                    regex=r"^(with_gcc=.*)$",
-                    repl="\\1\n\n# Is the compiler the NAG compiler?\nwith_nag=yes",
-                    start_at=start_at,
-                    stop_at=stop_at,
-                )
-
-            # Disable the special treatment for gcc and g++:
-            for tag in ["cc", "cxx"]:
-                marker = markers[tag]
-                x.filter(
-                    regex=r"^(with_gcc=.*)$",
-                    repl="\\1\n\n# Is the compiler the NAG compiler?\nwith_nag=no",
-                    start_at="# ### BEGIN {0}".format(marker),
-                    stop_at="# ### END {0}".format(marker),
-                )
-
-            # The compiler does not support -pthread flag, which might come
-            # from the inherited linker flags. We prepend the flag with -Wl,
-            # before using it:
-            x.filter(
-                regex=r"^(\s*)(for tmp_inherited_linker_flag in \$tmp_inherited_linker_flags; "
-                r"do\s*)$",
-                repl='\\1if test "x$with_nag" = xyes; then\n'
-                "\\1  revert_nag_pthread=$tmp_inherited_linker_flags\n"
-                "\\1  tmp_inherited_linker_flags="
-                "`$ECHO \"$tmp_inherited_linker_flags\" | $SED 's% -pthread% -Wl,-pthread%g'`\n"
-                '\\1  test x"$revert_nag_pthread" = x"$tmp_inherited_linker_flags" && '
-                "revert_nag_pthread=no || revert_nag_pthread=yes\n"
-                "\\1fi\n\\1\\2",
-                start_at='if test -n "$inherited_linker_flags"; then',
-                stop_at='case " $new_inherited_linker_flags " in',
-            )
-            # And revert the modification to produce '*.la' files that can be
-            # used with gcc (normally, we do not install the files but they can
-            # still be used during the building):
-            start_at = '# Time to change all our "foo.ltframework" stuff back to "-framework foo"'
-            stop_at = "# installed libraries to the beginning of the library search list"
-            x.filter(
-                regex=r"(\s*)(# move library search paths that coincide with paths to not "
-                r"yet\s*)$",
-                repl='\\1test x"$with_nag$revert_nag_pthread" = xyesyes &&\n'
-                '\\1  new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | '
-                "$SED 's% -Wl,-pthread% -pthread%g'`\n\\1\\2",
-                start_at=start_at,
-                stop_at=stop_at,
-            )
+            ]
+            for o in objfile:
+                fs.filter_file(rehead + o, "", libtool_path)
 
     @property
     def configure_directory(self):
-        """Return the directory where 'configure' resides."""
-        return self.pkg.stage.source_path
+        """Returns the directory where 'configure' resides.
+
+        :return: directory where to find configure
+        """
+        return self.stage.source_path
 
     @property
     def configure_abs_path(self):
@@ -531,12 +320,34 @@ def build_directory(self):
         """Override to provide another place to build the package"""
         return self.configure_directory
 
-    @spack.builder.run_before("autoreconf")
+    @run_before("autoreconf")
     def delete_configure_to_force_update(self):
         if self.force_autoreconf:
-            fs.force_remove(self.configure_abs_path)
+            force_remove(self.configure_abs_path)
 
-    def autoreconf(self, pkg, spec, prefix):
+    def _require_build_deps(self, pkgs, spec, err):
+        """Require `pkgs` to be direct build dependencies of `spec`. Raises a
+        RuntimeError with a helpful error messages when any dep is missing."""
+
+        build_deps = [d.name for d in spec.dependencies(deptype="build")]
+        missing_deps = [x for x in pkgs if x not in build_deps]
+
+        if not missing_deps:
+            return
+
+        # Raise an exception on missing deps.
+        msg = (
+            "{0}: missing dependencies: {1}.\n\nPlease add "
+            "the following lines to the package:\n\n".format(err, ", ".join(missing_deps))
+        )
+
+        for dep in missing_deps:
+            msg += "    depends_on('{0}', type='build', when='@{1}')\n".format(dep, spec.version)
+
+        msg += "\nUpdate the version (when='@{0}') as needed.".format(spec.version)
+        raise RuntimeError(msg)
+
+    def autoreconf(self, spec, prefix):
         """Not needed usually, configure should be already there"""
 
         # If configure exists nothing needs to be done
@@ -544,10 +355,8 @@ def autoreconf(self, pkg, spec, prefix):
             return
 
         # Else try to regenerate it, which reuquires a few build dependencies
-        ensure_build_dependencies_or_raise(
-            spec=spec,
-            dependencies=["autoconf", "automake", "libtool"],
-            error_msg="Cannot generate configure",
+        self._require_build_deps(
+            pkgs=["autoconf", "automake", "libtool"], spec=spec, err="Cannot generate configure"
         )
 
         tty.msg("Configure script not found: trying to generate it")
@@ -555,8 +364,8 @@ def autoreconf(self, pkg, spec, prefix):
         tty.warn("* If the default procedure fails, consider implementing *")
         tty.warn("*        a custom AUTORECONF phase in the package       *")
         tty.warn("*********************************************************")
-        with fs.working_dir(self.configure_directory):
-            m = inspect.getmodule(self.pkg)
+        with working_dir(self.configure_directory):
+            m = inspect.getmodule(self)
             # This line is what is needed most of the time
             # --install, --verbose, --force
             autoreconf_args = ["-ivf"]
@@ -572,66 +381,98 @@ def autoreconf_search_path_args(self):
         spack dependencies."""
         return _autoreconf_search_path_args(self.spec)
 
-    @spack.builder.run_after("autoreconf")
+    @run_after("autoreconf")
     def set_configure_or_die(self):
-        """Ensure the presence of a "configure" script, or raise. If the "configure"
-        is found, a module level attribute is set.
+        """Checks the presence of a ``configure`` file after the
+        autoreconf phase. If it is found sets a module attribute
+        appropriately, otherwise raises an error.
 
-        Raises:
-             RuntimeError: if the "configure" script is not found
+        :raises RuntimeError: if a configure script is not found in
+            :py:meth:`~AutotoolsPackage.configure_directory`
         """
-        # Check if the "configure" script is there. If not raise a RuntimeError.
+        # Check if a configure script is there. If not raise a RuntimeError.
         if not os.path.exists(self.configure_abs_path):
             msg = "configure script not found in {0}"
             raise RuntimeError(msg.format(self.configure_directory))
 
         # Monkey-patch the configure script in the corresponding module
-        inspect.getmodule(self.pkg).configure = Executable(self.configure_abs_path)
+        inspect.getmodule(self).configure = Executable(self.configure_abs_path)
 
     def configure_args(self):
-        """Return the list of all the arguments that must be passed to configure,
-        except ``--prefix`` which will be pre-pended to the list.
+        """Produces a list containing all the arguments that must be passed to
+        configure, except ``--prefix`` which will be pre-pended to the list.
+
+        :return: list of arguments for configure
         """
         return []
 
-    def configure(self, pkg, spec, prefix):
-        """Run "configure", with the arguments specified by the builder and an
-        appropriately set prefix.
+    def flags_to_build_system_args(self, flags):
+        """Produces a list of all command line arguments to pass specified
+        compiler flags to configure."""
+        # Has to be dynamic attribute due to caching.
+        setattr(self, "configure_flag_args", [])
+        for flag, values in flags.items():
+            if values:
+                values_str = "{0}={1}".format(flag.upper(), " ".join(values))
+                self.configure_flag_args.append(values_str)
+        # Spack's fflags are meant for both F77 and FC, therefore we
+        # additionaly set FCFLAGS if required.
+        values = flags.get("fflags", None)
+        if values:
+            values_str = "FCFLAGS={0}".format(" ".join(values))
+            self.configure_flag_args.append(values_str)
+
+    def configure(self, spec, prefix):
+        """Runs configure with the arguments specified in
+        :meth:`~spack.build_systems.autotools.AutotoolsPackage.configure_args`
+        and an appropriately set prefix.
         """
-        options = getattr(self.pkg, "configure_flag_args", [])
+        options = getattr(self, "configure_flag_args", [])
         options += ["--prefix={0}".format(prefix)]
         options += self.configure_args()
 
-        with fs.working_dir(self.build_directory, create=True):
-            inspect.getmodule(self.pkg).configure(*options)
+        with working_dir(self.build_directory, create=True):
+            inspect.getmodule(self).configure(*options)
 
-    def build(self, pkg, spec, prefix):
-        """Run "make" on the build targets specified by the builder."""
+    def setup_build_environment(self, env):
+        if self.spec.platform == "darwin" and macos_version() >= Version("11"):
+            # Many configure files rely on matching '10.*' for macOS version
+            # detection and fail to add flags if it shows as version 11.
+            env.set("MACOSX_DEPLOYMENT_TARGET", "10.16")
+
+    def build(self, spec, prefix):
+        """Makes the build targets specified by
+        :py:attr:``~.AutotoolsPackage.build_targets``
+        """
         # See https://autotools.io/automake/silent.html
         params = ["V=1"]
         params += self.build_targets
-        with fs.working_dir(self.build_directory):
-            inspect.getmodule(self.pkg).make(*params)
+        with working_dir(self.build_directory):
+            inspect.getmodule(self).make(*params)
 
-    def install(self, pkg, spec, prefix):
-        """Run "make" on the install targets specified by the builder."""
-        with fs.working_dir(self.build_directory):
-            inspect.getmodule(self.pkg).make(*self.install_targets)
+    def install(self, spec, prefix):
+        """Makes the install targets specified by
+        :py:attr:``~.AutotoolsPackage.install_targets``
+        """
+        with working_dir(self.build_directory):
+            inspect.getmodule(self).make(*self.install_targets)
 
-    spack.builder.run_after("build")(execute_build_time_tests)
+    run_after("build")(PackageBase._run_default_build_time_test_callbacks)
 
     def check(self):
-        """Run "make" on the ``test`` and ``check`` targets, if found."""
-        with fs.working_dir(self.build_directory):
-            self.pkg._if_make_target_execute("test")
-            self.pkg._if_make_target_execute("check")
+        """Searches the Makefile for targets ``test`` and ``check``
+        and runs them if found.
+        """
+        with working_dir(self.build_directory):
+            self._if_make_target_execute("test")
+            self._if_make_target_execute("check")
 
     def _activate_or_not(
         self, name, activation_word, deactivation_word, activation_value=None, variant=None
     ):
-        """This function contain the current implementation details of
-        :meth:`~spack.build_systems.autotools.AutotoolsBuilder.with_or_without` and
-        :meth:`~spack.build_systems.autotools.AutotoolsBuilder.enable_or_disable`.
+        """This function contains the current implementation details of
+        :meth:`~spack.build_systems.autotools.AutotoolsPackage.with_or_without` and
+        :meth:`~spack.build_systems.autotools.AutotoolsPackage.enable_or_disable`.
 
         Args:
             name (str): name of the option that is being activated or not
@@ -687,7 +528,7 @@ def _activate_or_not(
         Raises:
             KeyError: if name is not among known variants
         """
-        spec = self.pkg.spec
+        spec = self.spec
         args = []
 
         if activation_value == "prefix":
@@ -697,16 +538,16 @@ def _activate_or_not(
 
         # Defensively look that the name passed as argument is among
         # variants
-        if variant not in self.pkg.variants:
+        if variant not in self.variants:
             msg = '"{0}" is not a variant of "{1}"'
-            raise KeyError(msg.format(variant, self.pkg.name))
+            raise KeyError(msg.format(variant, self.name))
 
         if variant not in spec.variants:
             return []
 
         # Create a list of pairs. Each pair includes a configuration
         # option and whether or not that option is activated
-        variant_desc, _ = self.pkg.variants[variant]
+        variant_desc, _ = self.variants[variant]
         if set(variant_desc.values) == set((True, False)):
             # BoolValuedVariant carry information about a single option.
             # Nonetheless, for uniformity of treatment we'll package them
@@ -734,18 +575,14 @@ def _activate_or_not(
             override_name = "{0}_or_{1}_{2}".format(
                 activation_word, deactivation_word, option_value
             )
-            line_generator = getattr(self, override_name, None) or getattr(
-                self.pkg, override_name, None
-            )
+            line_generator = getattr(self, override_name, None)
             # If not available use a sensible default
             if line_generator is None:
 
                 def _default_generator(is_activated):
                     if is_activated:
                         line = "--{0}-{1}".format(activation_word, option_value)
-                        if activation_value is not None and activation_value(
-                            option_value
-                        ):  # NOQA=ignore=E501
+                        if activation_value is not None and activation_value(option_value):
                             line += "={0}".format(activation_value(option_value))
                         return line
                     return "--{0}-{1}".format(deactivation_word, option_value)
@@ -784,7 +621,7 @@ def with_or_without(self, name, activation_value=None, variant=None):
 
     def enable_or_disable(self, name, activation_value=None, variant=None):
         """Same as
-        :meth:`~spack.build_systems.autotools.AutotoolsBuilder.with_or_without`
+        :meth:`~spack.build_systems.autotools.AutotoolsPackage.with_or_without`
         but substitute ``with`` with ``enable`` and ``without`` with ``disable``.
 
         Args:
@@ -801,14 +638,19 @@ def enable_or_disable(self, name, activation_value=None, variant=None):
         """
         return self._activate_or_not(name, "enable", "disable", activation_value, variant)
 
-    spack.builder.run_after("install")(execute_install_time_tests)
+    run_after("install")(PackageBase._run_default_install_time_test_callbacks)
 
     def installcheck(self):
-        """Run "make" on the ``installcheck`` target, if found."""
-        with fs.working_dir(self.build_directory):
-            self.pkg._if_make_target_execute("installcheck")
+        """Searches the Makefile for an ``installcheck`` target
+        and runs it if found.
+        """
+        with working_dir(self.build_directory):
+            self._if_make_target_execute("installcheck")
 
-    @spack.builder.run_after("install")
+    # Check that self.prefix is there after installation
+    run_after("install")(PackageBase.sanity_check_prefix)
+
+    @run_after("install")
     def remove_libtool_archives(self):
         """Remove all .la files in prefix sub-folders if the package sets
         ``install_libtool_archives`` to be False.
@@ -818,20 +660,14 @@ def remove_libtool_archives(self):
             return
 
         # Remove the files and create a log of what was removed
-        libtool_files = fs.find(str(self.pkg.prefix), "*.la", recursive=True)
+        libtool_files = fs.find(str(self.prefix), "*.la", recursive=True)
         with fs.safe_remove(*libtool_files):
             fs.mkdirp(os.path.dirname(self._removed_la_files_log))
             with open(self._removed_la_files_log, mode="w") as f:
                 f.write("\n".join(libtool_files))
 
-    def setup_build_environment(self, env):
-        if self.spec.platform == "darwin" and macos_version() >= Version("11"):
-            # Many configure files rely on matching '10.*' for macOS version
-            # detection and fail to add flags if it shows as version 11.
-            env.set("MACOSX_DEPLOYMENT_TARGET", "10.16")
-
     # On macOS, force rpaths for shared library IDs and remove duplicate rpaths
-    spack.builder.run_after("install", when="platform=darwin")(apply_macos_rpath_fixups)
+    run_after("install")(PackageBase.apply_macos_rpath_fixups)
 
 
 def _autoreconf_search_path_args(spec):

lib/spack/spack/build_systems/bundle.py

@@ -1,31 +0,0 @@
-# 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)
-import spack.builder
-import spack.directives
-import spack.package_base
-
-
-class BundlePackage(spack.package_base.PackageBase):
-    """General purpose bundle, or no-code, package class."""
-
-    #: This attribute is used in UI queries that require to know which
-    #: build-system class we are using
-    build_system_class = "BundlePackage"
-
-    #: Legacy buildsystem attribute used to deserialize and install old specs
-    legacy_buildsystem = "bundle"
-
-    #: Bundle packages do not have associated source or binary code.
-    has_code = False
-
-    spack.directives.build_system("bundle")
-
-
-@spack.builder.builder("bundle")
-class BundleBuilder(spack.builder.Builder):
-    phases = ("install",)
-
-    def install(self, pkg, spec, prefix):
-        pass

lib/spack/spack/build_systems/cached_cmake.py

@@ -3,14 +3,12 @@
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 import os
-from typing import Tuple
 
-import llnl.util.filesystem as fs
 import llnl.util.tty as tty
+from llnl.util.filesystem import install, mkdirp
 
-import spack.builder
-
-from .cmake import CMakeBuilder, CMakePackage
+from spack.build_systems.cmake import CMakePackage
+from spack.package_base import run_after
 
 
 def cmake_cache_path(name, value, comment=""):
@@ -30,50 +28,44 @@ def cmake_cache_option(name, boolean_value, comment=""):
     return 'set({0} {1} CACHE BOOL "{2}")\n'.format(name, value, comment)
 
 
-class CachedCMakeBuilder(CMakeBuilder):
+class CachedCMakePackage(CMakePackage):
+    """Specialized class for packages built using CMake initial cache.
 
-    #: Phases of a Cached CMake package
-    #: Note: the initconfig phase is used for developer builds as a final phase to stop on
-    phases = ("initconfig", "cmake", "build", "install")  # type: Tuple[str, ...]
+    This feature of CMake allows packages to increase reproducibility,
+    especially between Spack- and manual builds. It also allows packages to
+    sidestep certain parsing bugs in extremely long ``cmake`` commands, and to
+    avoid system limits on the length of the command line."""
 
-    #: Names associated with package methods in the old build-system format
-    legacy_methods = CMakeBuilder.legacy_methods + (
-        "initconfig_compiler_entries",
-        "initconfig_mpi_entries",
-        "initconfig_hardware_entries",
-        "std_initconfig_entries",
-        "initconfig_package_entries",
-    )  # type: Tuple[str, ...]
-
-    #: Names associated with package attributes in the old build-system format
-    legacy_attributes = CMakeBuilder.legacy_attributes + (
-        "cache_name",
-        "cache_path",
-    )  # type: Tuple[str, ...]
+    phases = ["initconfig", "cmake", "build", "install"]
 
     @property
     def cache_name(self):
         return "{0}-{1}-{2}@{3}.cmake".format(
-            self.pkg.name,
-            self.pkg.spec.architecture,
-            self.pkg.spec.compiler.name,
-            self.pkg.spec.compiler.version,
+            self.name,
+            self.spec.architecture,
+            self.spec.compiler.name,
+            self.spec.compiler.version,
         )
 
     @property
     def cache_path(self):
-        return os.path.join(self.pkg.stage.source_path, self.cache_name)
+        return os.path.join(self.stage.source_path, self.cache_name)
+
+    def flag_handler(self, name, flags):
+        if name in ("cflags", "cxxflags", "cppflags", "fflags"):
+            return (None, None, None)  # handled in the cmake cache
+        return (flags, None, None)
 
     def initconfig_compiler_entries(self):
         # This will tell cmake to use the Spack compiler wrappers when run
         # through Spack, but use the underlying compiler when run outside of
         # Spack
-        spec = self.pkg.spec
+        spec = self.spec
 
         # Fortran compiler is optional
         if "FC" in os.environ:
             spack_fc_entry = cmake_cache_path("CMAKE_Fortran_COMPILER", os.environ["FC"])
-            system_fc_entry = cmake_cache_path("CMAKE_Fortran_COMPILER", self.pkg.compiler.fc)
+            system_fc_entry = cmake_cache_path("CMAKE_Fortran_COMPILER", self.compiler.fc)
         else:
             spack_fc_entry = "# No Fortran compiler defined in spec"
             system_fc_entry = "# No Fortran compiler defined in spec"
@@ -89,8 +81,8 @@ def initconfig_compiler_entries(self):
             "  " + cmake_cache_path("CMAKE_CXX_COMPILER", os.environ["CXX"]),
             "  " + spack_fc_entry,
             "else()\n",
-            "  " + cmake_cache_path("CMAKE_C_COMPILER", self.pkg.compiler.cc),
-            "  " + cmake_cache_path("CMAKE_CXX_COMPILER", self.pkg.compiler.cxx),
+            "  " + cmake_cache_path("CMAKE_C_COMPILER", self.compiler.cc),
+            "  " + cmake_cache_path("CMAKE_CXX_COMPILER", self.compiler.cxx),
             "  " + system_fc_entry,
             "endif()\n",
         ]
@@ -134,7 +126,7 @@ def initconfig_compiler_entries(self):
         return entries
 
     def initconfig_mpi_entries(self):
-        spec = self.pkg.spec
+        spec = self.spec
 
         if not spec.satisfies("^mpi"):
             return []
@@ -168,13 +160,13 @@ def initconfig_mpi_entries(self):
                 mpiexec = os.path.join(spec["mpi"].prefix.bin, "mpiexec")
 
         if not os.path.exists(mpiexec):
-            msg = "Unable to determine MPIEXEC, %s tests may fail" % self.pkg.name
+            msg = "Unable to determine MPIEXEC, %s tests may fail" % self.name
             entries.append("# {0}\n".format(msg))
             tty.warn(msg)
         else:
             # starting with cmake 3.10, FindMPI expects MPIEXEC_EXECUTABLE
             # vs the older versions which expect MPIEXEC
-            if self.pkg.spec["cmake"].satisfies("@3.10:"):
+            if self.spec["cmake"].satisfies("@3.10:"):
                 entries.append(cmake_cache_path("MPIEXEC_EXECUTABLE", mpiexec))
             else:
                 entries.append(cmake_cache_path("MPIEXEC", mpiexec))
@@ -188,7 +180,7 @@ def initconfig_mpi_entries(self):
         return entries
 
     def initconfig_hardware_entries(self):
-        spec = self.pkg.spec
+        spec = self.spec
 
         entries = [
             "#------------------{0}".format("-" * 60),
@@ -220,7 +212,7 @@ def std_initconfig_entries(self):
             "#------------------{0}".format("-" * 60),
             "# !!!! This is a generated file, edit at own risk !!!!",
             "#------------------{0}".format("-" * 60),
-            "# CMake executable path: {0}".format(self.pkg.spec["cmake"].command.path),
+            "# CMake executable path: {0}".format(self.spec["cmake"].command.path),
             "#------------------{0}\n".format("-" * 60),
         ]
 
@@ -228,7 +220,7 @@ def initconfig_package_entries(self):
         """This method is to be overwritten by the package"""
         return []
 
-    def initconfig(self, pkg, spec, prefix):
+    def initconfig(self, spec, prefix):
         cache_entries = (
             self.std_initconfig_entries()
             + self.initconfig_compiler_entries()
@@ -244,28 +236,11 @@ def initconfig(self, pkg, spec, prefix):
 
     @property
     def std_cmake_args(self):
-        args = super(CachedCMakeBuilder, self).std_cmake_args
+        args = super(CachedCMakePackage, self).std_cmake_args
         args.extend(["-C", self.cache_path])
         return args
 
-    @spack.builder.run_after("install")
+    @run_after("install")
     def install_cmake_cache(self):
-        fs.mkdirp(self.pkg.spec.prefix.share.cmake)
-        fs.install(self.cache_path, self.pkg.spec.prefix.share.cmake)
-
-
-class CachedCMakePackage(CMakePackage):
-    """Specialized class for packages built using CMake initial cache.
-
-    This feature of CMake allows packages to increase reproducibility,
-    especially between Spack- and manual builds. It also allows packages to
-    sidestep certain parsing bugs in extremely long ``cmake`` commands, and to
-    avoid system limits on the length of the command line.
-    """
-
-    CMakeBuilder = CachedCMakeBuilder
-
-    def flag_handler(self, name, flags):
-        if name in ("cflags", "cxxflags", "cppflags", "fflags"):
-            return None, None, None  # handled in the cmake cache
-        return flags, None, None
+        mkdirp(self.spec.prefix.share.cmake)
+        install(self.cache_path, self.spec.prefix.share.cmake)

lib/spack/spack/build_systems/cmake.py

@@ -2,26 +2,24 @@
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+
 import inspect
 import os
 import platform
 import re
 import sys
-from typing import List, Tuple
+from typing import List
 
 import six
 
-import llnl.util.filesystem as fs
 from llnl.util.compat import Sequence
+from llnl.util.filesystem import working_dir
 
 import spack.build_environment
-import spack.builder
-import spack.package_base
-import spack.util.path
-from spack.directives import build_system, depends_on, variant
-from spack.multimethod import when
-
-from ._checks import BaseBuilder, execute_build_time_tests
+from spack.directives import conflicts, depends_on, variant
+from spack.package_base import InstallError, PackageBase, run_after
+from spack.util.path import convert_to_posix_path
 
 # Regex to extract the primary generator from the CMake generator
 # string.
@@ -37,141 +35,56 @@ def _extract_primary_generator(generator):
     return primary_generator
 
 
-class CMakePackage(spack.package_base.PackageBase):
+class CMakePackage(PackageBase):
     """Specialized class for packages built using CMake
 
     For more information on the CMake build system, see:
     https://cmake.org/cmake/help/latest/
-    """
 
-    #: This attribute is used in UI queries that need to know the build
-    #: system base class
-    build_system_class = "CMakePackage"
+    This class provides three phases that can be overridden:
 
-    #: Legacy buildsystem attribute used to deserialize and install old specs
-    legacy_buildsystem = "cmake"
-
-    build_system("cmake")
-
-    with when("build_system=cmake"):
-        # https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html
-        variant(
-            "build_type",
-            default="RelWithDebInfo",
-            description="CMake build type",
-            values=("Debug", "Release", "RelWithDebInfo", "MinSizeRel"),
-        )
-        # CMAKE_INTERPROCEDURAL_OPTIMIZATION only exists for CMake >= 3.9
-        # https://cmake.org/cmake/help/latest/variable/CMAKE_INTERPROCEDURAL_OPTIMIZATION.html
-        variant(
-            "ipo",
-            default=False,
-            when="^cmake@3.9:",
-            description="CMake interprocedural optimization",
-        )
-        depends_on("cmake", type="build")
-        depends_on("ninja", type="build", when="platform=windows")
-
-    def flags_to_build_system_args(self, flags):
-        """Return a list of all command line arguments to pass the specified
-        compiler flags to cmake. Note CMAKE does not have a cppflags option,
-        so cppflags will be added to cflags, cxxflags, and fflags to mimic the
-        behavior in other tools.
-        """
-        # Has to be dynamic attribute due to caching
-        setattr(self, "cmake_flag_args", [])
-
-        flag_string = "-DCMAKE_{0}_FLAGS={1}"
-        langs = {"C": "c", "CXX": "cxx", "Fortran": "f"}
-
-        # Handle language compiler flags
-        for lang, pre in langs.items():
-            flag = pre + "flags"
-            # cmake has no explicit cppflags support -> add it to all langs
-            lang_flags = " ".join(flags.get(flag, []) + flags.get("cppflags", []))
-            if lang_flags:
-                self.cmake_flag_args.append(flag_string.format(lang, lang_flags))
-
-        # Cmake has different linker arguments for different build types.
-        # We specify for each of them.
-        if flags["ldflags"]:
-            ldflags = " ".join(flags["ldflags"])
-            ld_string = "-DCMAKE_{0}_LINKER_FLAGS={1}"
-            # cmake has separate linker arguments for types of builds.
-            for type in ["EXE", "MODULE", "SHARED", "STATIC"]:
-                self.cmake_flag_args.append(ld_string.format(type, ldflags))
-
-        # CMake has libs options separated by language. Apply ours to each.
-        if flags["ldlibs"]:
-            libs_flags = " ".join(flags["ldlibs"])
-            libs_string = "-DCMAKE_{0}_STANDARD_LIBRARIES={1}"
-            for lang in langs:
-                self.cmake_flag_args.append(libs_string.format(lang, libs_flags))
-
-    # Legacy methods (used by too many packages to change them,
-    # need to forward to the builder)
-    def define(self, *args, **kwargs):
-        return self.builder.define(*args, **kwargs)
-
-    def define_from_variant(self, *args, **kwargs):
-        return self.builder.define_from_variant(*args, **kwargs)
-
-
-@spack.builder.builder("cmake")
-class CMakeBuilder(BaseBuilder):
-    """The cmake builder encodes the default way of building software with CMake. IT
-    has three phases that can be overridden:
-
-        1. :py:meth:`~.CMakeBuilder.cmake`
-        2. :py:meth:`~.CMakeBuilder.build`
-        3. :py:meth:`~.CMakeBuilder.install`
+        1. :py:meth:`~.CMakePackage.cmake`
+        2. :py:meth:`~.CMakePackage.build`
+        3. :py:meth:`~.CMakePackage.install`
 
     They all have sensible defaults and for many packages the only thing
-    necessary will be to override :py:meth:`~.CMakeBuilder.cmake_args`.
-
+    necessary will be to override :py:meth:`~.CMakePackage.cmake_args`.
     For a finer tuning you may also override:
 
         +-----------------------------------------------+--------------------+
         | **Method**                                    | **Purpose**        |
         +===============================================+====================+
-        | :py:meth:`~.CMakeBuilder.root_cmakelists_dir` | Location of the    |
+        | :py:meth:`~.CMakePackage.root_cmakelists_dir` | Location of the    |
         |                                               | root CMakeLists.txt|
         +-----------------------------------------------+--------------------+
-        | :py:meth:`~.CMakeBuilder.build_directory`     | Directory where to |
+        | :py:meth:`~.CMakePackage.build_directory`     | Directory where to |
         |                                               | build the package  |
         +-----------------------------------------------+--------------------+
 
-    The generator used by CMake can be specified by providing the ``generator``
-    attribute. Per
-    https://cmake.org/cmake/help/git-master/manual/cmake-generators.7.html,
-    the format is: [<secondary-generator> - ]<primary_generator>.
 
-    The full list of primary and secondary generators supported by CMake may be found
-    in the documentation for the version of CMake used; however, at this time Spack
-    supports only the primary generators "Unix Makefiles" and "Ninja." Spack's CMake
-    support is agnostic with respect to primary generators. Spack will generate a
-    runtime error if the generator string does not follow the prescribed format, or if
+    The generator used by CMake can be specified by providing the
+    generator attribute. Per
+    https://cmake.org/cmake/help/git-master/manual/cmake-generators.7.html,
+    the format is: [<secondary-generator> - ]<primary_generator>. The
+    full list of primary and secondary generators supported by CMake may
+    be found in the documentation for the version of CMake used;
+    however, at this time Spack supports only the primary generators
+    "Unix Makefiles" and "Ninja." Spack's CMake support is agnostic with
+    respect to primary generators. Spack will generate a runtime error
+    if the generator string does not follow the prescribed format, or if
     the primary generator is not supported.
     """
 
     #: Phases of a CMake package
-    phases = ("cmake", "build", "install")  # type: Tuple[str, ...]
+    phases = ["cmake", "build", "install"]
+    #: This attribute is used in UI queries that need to know the build
+    #: system base class
+    build_system_class = "CMakePackage"
 
-    #: Names associated with package methods in the old build-system format
-    legacy_methods = ("cmake_args", "check")  # type: Tuple[str, ...]
+    build_targets = []  # type: List[str]
+    install_targets = ["install"]
 
-    #: Names associated with package attributes in the old build-system format
-    legacy_attributes = (
-        "generator",
-        "build_targets",
-        "install_targets",
-        "build_time_test_callbacks",
-        "archive_files",
-        "root_cmakelists_dir",
-        "std_cmake_args",
-        "build_dirname",
-        "build_directory",
-    )  # type: Tuple[str, ...]
+    build_time_test_callbacks = ["check"]
 
     #: The build system generator to use.
     #:
@@ -181,14 +94,27 @@ class CMakeBuilder(BaseBuilder):
     #:
     #: See https://cmake.org/cmake/help/latest/manual/cmake-generators.7.html
     #: for more information.
-    generator = "Ninja" if sys.platform == "win32" else "Unix Makefiles"
 
-    #: Targets to be used during the build phase
-    build_targets = []  # type: List[str]
-    #: Targets to be used during the install phase
-    install_targets = ["install"]
-    #: Callback names for build-time test
-    build_time_test_callbacks = ["check"]
+    generator = "Unix Makefiles"
+
+    if sys.platform == "win32":
+        generator = "Ninja"
+        depends_on("ninja")
+
+    # https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html
+    variant(
+        "build_type",
+        default="RelWithDebInfo",
+        description="CMake build type",
+        values=("Debug", "Release", "RelWithDebInfo", "MinSizeRel"),
+    )
+
+    # https://cmake.org/cmake/help/latest/variable/CMAKE_INTERPROCEDURAL_OPTIMIZATION.html
+    variant("ipo", default=False, description="CMake interprocedural optimization")
+    # CMAKE_INTERPROCEDURAL_OPTIMIZATION only exists for CMake >= 3.9
+    conflicts("+ipo", when="^cmake@:3.8", msg="+ipo is not supported by CMake < 3.9")
+
+    depends_on("cmake", type="build")
 
     @property
     def archive_files(self):
@@ -201,30 +127,40 @@ def root_cmakelists_dir(self):
 
         This path is relative to the root of the extracted tarball,
         not to the ``build_directory``. Defaults to the current directory.
+
+        :return: directory containing CMakeLists.txt
         """
-        return self.pkg.stage.source_path
+        return self.stage.source_path
 
     @property
     def std_cmake_args(self):
         """Standard cmake arguments provided as a property for
         convenience of package writers
+
+        :return: standard cmake arguments
         """
         # standard CMake arguments
-        std_cmake_args = CMakeBuilder.std_args(self.pkg, generator=self.generator)
-        std_cmake_args += getattr(self.pkg, "cmake_flag_args", [])
+        std_cmake_args = CMakePackage._std_args(self)
+        std_cmake_args += getattr(self, "cmake_flag_args", [])
         return std_cmake_args
 
     @staticmethod
-    def std_args(pkg, generator=None):
+    def _std_args(pkg):
         """Computes the standard cmake arguments for a generic package"""
-        generator = generator or "Unix Makefiles"
+
+        try:
+            generator = pkg.generator
+        except AttributeError:
+            generator = CMakePackage.generator
+
+        # Make sure a valid generator was chosen
         valid_primary_generators = ["Unix Makefiles", "Ninja"]
         primary_generator = _extract_primary_generator(generator)
         if primary_generator not in valid_primary_generators:
             msg = "Invalid CMake generator: '{0}'\n".format(generator)
             msg += "CMakePackage currently supports the following "
             msg += "primary generators: '{0}'".format("', '".join(valid_primary_generators))
-            raise spack.package_base.InstallError(msg)
+            raise InstallError(msg)
 
         try:
             build_type = pkg.spec.variants["build_type"].value
@@ -236,11 +172,11 @@ def std_args(pkg, generator=None):
         except KeyError:
             ipo = False
 
-        define = CMakeBuilder.define
+        define = CMakePackage.define
         args = [
             "-G",
             generator,
-            define("CMAKE_INSTALL_PREFIX", pkg.prefix),
+            define("CMAKE_INSTALL_PREFIX", convert_to_posix_path(pkg.prefix)),
             define("CMAKE_BUILD_TYPE", build_type),
             define("BUILD_TESTING", pkg.run_tests),
         ]
@@ -316,7 +252,7 @@ def define_from_variant(self, cmake_var, variant=None):
         of ``cmake_var``.
 
         This utility function is similar to
-        :meth:`~spack.build_systems.autotools.AutotoolsBuilder.with_or_without`.
+        :meth:`~spack.build_systems.autotools.AutotoolsPackage.with_or_without`.
 
         Examples:
 
@@ -356,75 +292,122 @@ def define_from_variant(self, cmake_var, variant=None):
         if variant is None:
             variant = cmake_var.lower()
 
-        if variant not in self.pkg.variants:
-            raise KeyError('"{0}" is not a variant of "{1}"'.format(variant, self.pkg.name))
+        if variant not in self.variants:
+            raise KeyError('"{0}" is not a variant of "{1}"'.format(variant, self.name))
 
-        if variant not in self.pkg.spec.variants:
+        if variant not in self.spec.variants:
             return ""
 
-        value = self.pkg.spec.variants[variant].value
+        value = self.spec.variants[variant].value
         if isinstance(value, (tuple, list)):
             # Sort multi-valued variants for reproducibility
             value = sorted(value)
 
         return self.define(cmake_var, value)
 
+    def flags_to_build_system_args(self, flags):
+        """Produces a list of all command line arguments to pass the specified
+        compiler flags to cmake. Note CMAKE does not have a cppflags option,
+        so cppflags will be added to cflags, cxxflags, and fflags to mimic the
+        behavior in other tools."""
+        # Has to be dynamic attribute due to caching
+        setattr(self, "cmake_flag_args", [])
+
+        flag_string = "-DCMAKE_{0}_FLAGS={1}"
+        langs = {"C": "c", "CXX": "cxx", "Fortran": "f"}
+
+        # Handle language compiler flags
+        for lang, pre in langs.items():
+            flag = pre + "flags"
+            # cmake has no explicit cppflags support -> add it to all langs
+            lang_flags = " ".join(flags.get(flag, []) + flags.get("cppflags", []))
+            if lang_flags:
+                self.cmake_flag_args.append(flag_string.format(lang, lang_flags))
+
+        # Cmake has different linker arguments for different build types.
+        # We specify for each of them.
+        if flags["ldflags"]:
+            ldflags = " ".join(flags["ldflags"])
+            ld_string = "-DCMAKE_{0}_LINKER_FLAGS={1}"
+            # cmake has separate linker arguments for types of builds.
+            for type in ["EXE", "MODULE", "SHARED", "STATIC"]:
+                self.cmake_flag_args.append(ld_string.format(type, ldflags))
+
+        # CMake has libs options separated by language. Apply ours to each.
+        if flags["ldlibs"]:
+            libs_flags = " ".join(flags["ldlibs"])
+            libs_string = "-DCMAKE_{0}_STANDARD_LIBRARIES={1}"
+            for lang in langs:
+                self.cmake_flag_args.append(libs_string.format(lang, libs_flags))
+
     @property
     def build_dirname(self):
-        """Directory name to use when building the package."""
-        return "spack-build-%s" % self.pkg.spec.dag_hash(7)
+        """Returns the directory name to use when building the package
+
+        :return: name of the subdirectory for building the package
+        """
+        return "spack-build-%s" % self.spec.dag_hash(7)
 
     @property
     def build_directory(self):
-        """Full-path to the directory to use when building the package."""
-        return os.path.join(self.pkg.stage.path, self.build_dirname)
+        """Returns the directory to use when building the package
+
+        :return: directory where to build the package
+        """
+        return os.path.join(self.stage.path, self.build_dirname)
 
     def cmake_args(self):
-        """List of all the arguments that must be passed to cmake, except:
+        """Produces a list containing all the arguments that must be passed to
+        cmake, except:
 
             * CMAKE_INSTALL_PREFIX
             * CMAKE_BUILD_TYPE
             * BUILD_TESTING
 
         which will be set automatically.
+
+        :return: list of arguments for cmake
         """
         return []
 
-    def cmake(self, pkg, spec, prefix):
+    def cmake(self, spec, prefix):
         """Runs ``cmake`` in the build directory"""
         options = self.std_cmake_args
         options += self.cmake_args()
         options.append(os.path.abspath(self.root_cmakelists_dir))
-        with fs.working_dir(self.build_directory, create=True):
-            inspect.getmodule(self.pkg).cmake(*options)
+        with working_dir(self.build_directory, create=True):
+            inspect.getmodule(self).cmake(*options)
 
-    def build(self, pkg, spec, prefix):
+    def build(self, spec, prefix):
         """Make the build targets"""
-        with fs.working_dir(self.build_directory):
+        with working_dir(self.build_directory):
             if self.generator == "Unix Makefiles":
-                inspect.getmodule(self.pkg).make(*self.build_targets)
+                inspect.getmodule(self).make(*self.build_targets)
             elif self.generator == "Ninja":
                 self.build_targets.append("-v")
-                inspect.getmodule(self.pkg).ninja(*self.build_targets)
+                inspect.getmodule(self).ninja(*self.build_targets)
 
-    def install(self, pkg, spec, prefix):
+    def install(self, spec, prefix):
         """Make the install targets"""
-        with fs.working_dir(self.build_directory):
+        with working_dir(self.build_directory):
             if self.generator == "Unix Makefiles":
-                inspect.getmodule(self.pkg).make(*self.install_targets)
+                inspect.getmodule(self).make(*self.install_targets)
             elif self.generator == "Ninja":
-                inspect.getmodule(self.pkg).ninja(*self.install_targets)
+                inspect.getmodule(self).ninja(*self.install_targets)
 
-    spack.builder.run_after("build")(execute_build_time_tests)
+    run_after("build")(PackageBase._run_default_build_time_test_callbacks)
 
     def check(self):
-        """Search the CMake-generated files for the targets ``test`` and ``check``,
-        and runs them if found.
+        """Searches the CMake-generated Makefile for the target ``test``
+        and runs it if found.
         """
-        with fs.working_dir(self.build_directory):
+        with working_dir(self.build_directory):
             if self.generator == "Unix Makefiles":
-                self.pkg._if_make_target_execute("test", jobs_env="CTEST_PARALLEL_LEVEL")
-                self.pkg._if_make_target_execute("check")
+                self._if_make_target_execute("test", jobs_env="CTEST_PARALLEL_LEVEL")
+                self._if_make_target_execute("check")
             elif self.generator == "Ninja":
-                self.pkg._if_ninja_target_execute("test", jobs_env="CTEST_PARALLEL_LEVEL")
-                self.pkg._if_ninja_target_execute("check")
+                self._if_ninja_target_execute("test", jobs_env="CTEST_PARALLEL_LEVEL")
+                self._if_ninja_target_execute("check")
+
+    # Check that self.prefix is there after installation
+    run_after("install")(PackageBase.sanity_check_prefix)

lib/spack/spack/build_systems/cuda.py

@@ -41,9 +41,6 @@ class CudaPackage(PackageBase):
         "75",
         "80",
         "86",
-        "87",
-        "89",
-        "90",
     )
 
     # FIXME: keep cuda and cuda_arch separate to make usage easier until
@@ -103,11 +100,6 @@ def cuda_flags(arch_list):
     depends_on("cuda@11.0:", when="cuda_arch=80")
     depends_on("cuda@11.1:", when="cuda_arch=86")
 
-    depends_on("cuda@11.4:", when="cuda_arch=87")
-
-    depends_on("cuda@11.8:", when="cuda_arch=89")
-    depends_on("cuda@11.8:", when="cuda_arch=90")
-
     # From the NVIDIA install guide we know of conflicts for particular
     # platforms (linux, darwin), architectures (x86, powerpc) and compilers
     # (gcc, clang). We don't restrict %gcc and %clang conflicts to
@@ -136,11 +128,10 @@ def cuda_flags(arch_list):
         conflicts("%gcc@10:", when="+cuda ^cuda@:11.0")
         conflicts("%gcc@11:", when="+cuda ^cuda@:11.4.0")
         conflicts("%gcc@11.2:", when="+cuda ^cuda@:11.5")
-        conflicts("%gcc@12:", when="+cuda ^cuda@:11.8")
+        conflicts("%gcc@12:", when="+cuda ^cuda@:11.7")
         conflicts("%clang@12:", when="+cuda ^cuda@:11.4.0")
         conflicts("%clang@13:", when="+cuda ^cuda@:11.5")
         conflicts("%clang@14:", when="+cuda ^cuda@:11.7")
-        conflicts("%clang@15:", when="+cuda ^cuda@:11.8")
 
         # https://gist.github.com/ax3l/9489132#gistcomment-3860114
         conflicts("%gcc@10", when="+cuda ^cuda@:11.4.0")

lib/spack/spack/build_systems/generic.py

@@ -1,44 +0,0 @@
-# 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)
-from typing import Tuple
-
-import spack.builder
-import spack.directives
-import spack.package_base
-
-from ._checks import BaseBuilder, apply_macos_rpath_fixups
-
-
-class Package(spack.package_base.PackageBase):
-    """General purpose class with a single ``install`` phase that needs to be
-    coded by packagers.
-    """
-
-    #: This attribute is used in UI queries that require to know which
-    #: build-system class we are using
-    build_system_class = "Package"
-    #: Legacy buildsystem attribute used to deserialize and install old specs
-    legacy_buildsystem = "generic"
-
-    spack.directives.build_system("generic")
-
-
-@spack.builder.builder("generic")
-class GenericBuilder(BaseBuilder):
-    """A builder for a generic build system, that require packagers
-    to implement an "install" phase.
-    """
-
-    #: A generic package has only the "install" phase
-    phases = ("install",)
-
-    #: Names associated with package methods in the old build-system format
-    legacy_methods = ()  # type: Tuple[str, ...]
-
-    #: Names associated with package attributes in the old build-system format
-    legacy_attributes = ("archive_files",)  # type: Tuple[str, ...]
-
-    # On macOS, force rpaths for shared library IDs and remove duplicate rpaths
-    spack.builder.run_after("install", when="platform=darwin")(apply_macos_rpath_fixups)

lib/spack/spack/build_systems/intel.py

@@ -2,6 +2,8 @@
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+
 import glob
 import inspect
 import os
@@ -24,14 +26,12 @@
 
 import spack.error
 from spack.build_environment import dso_suffix
-from spack.package_base import InstallError
+from spack.package_base import InstallError, PackageBase, run_after
 from spack.util.environment import EnvironmentModifications
 from spack.util.executable import Executable
 from spack.util.prefix import Prefix
 from spack.version import Version, ver
 
-from .generic import Package
-
 # A couple of utility functions that might be useful in general. If so, they
 # should really be defined elsewhere, unless deemed heretical.
 # (Or na"ive on my part).
@@ -86,7 +86,7 @@ def _expand_fields(s):
     return s
 
 
-class IntelPackage(Package):
+class IntelPackage(PackageBase):
     """Specialized class for licensed Intel software.
 
     This class provides two phases that can be overridden:
@@ -99,6 +99,9 @@ class IntelPackage(Package):
     to set the appropriate environment variables.
     """
 
+    #: Phases of an Intel package
+    phases = ["configure", "install"]
+
     #: This attribute is used in UI queries that need to know the build
     #: system base class
     build_system_class = "IntelPackage"
@@ -1181,13 +1184,12 @@ def _determine_license_type(self):
         debug_print(license_type)
         return license_type
 
-    @spack.builder.run_before("install")
-    def configure(self):
+    def configure(self, spec, prefix):
         """Generates the silent.cfg file to pass to installer.sh.
 
         See https://software.intel.com/en-us/articles/configuration-file-format
         """
-        prefix = self.prefix
+
         # Both tokens AND values of the configuration file are validated during
         # the run of the underlying binary installer. Any unknown token or
         # unacceptable value will cause that installer to fail.  Notably, this
@@ -1268,7 +1270,7 @@ def install(self, spec, prefix):
         for f in glob.glob("%s/intel*log" % tmpdir):
             install(f, dst)
 
-    @spack.builder.run_after("install")
+    @run_after("install")
     def validate_install(self):
         # Sometimes the installer exits with an error but doesn't pass a
         # non-zero exit code to spack. Check for the existence of a 'bin'
@@ -1276,7 +1278,7 @@ def validate_install(self):
         if not os.path.exists(self.prefix.bin):
             raise InstallError("The installer has failed to install anything.")
 
-    @spack.builder.run_after("install")
+    @run_after("install")
     def configure_rpath(self):
         if "+rpath" not in self.spec:
             return
@@ -1294,7 +1296,7 @@ def configure_rpath(self):
             with open(compiler_cfg, "w") as fh:
                 fh.write("-Xlinker -rpath={0}\n".format(compilers_lib_dir))
 
-    @spack.builder.run_after("install")
+    @run_after("install")
     def configure_auto_dispatch(self):
         if self._has_compilers:
             if "auto_dispatch=none" in self.spec:
@@ -1318,7 +1320,7 @@ def configure_auto_dispatch(self):
                 with open(compiler_cfg, "a") as fh:
                     fh.write("-ax{0}\n".format(",".join(ad)))
 
-    @spack.builder.run_after("install")
+    @run_after("install")
     def filter_compiler_wrappers(self):
         if ("+mpi" in self.spec or self.provides("mpi")) and "~newdtags" in self.spec:
             bin_dir = self.component_bin_dir("mpi")
@@ -1326,7 +1328,7 @@ def filter_compiler_wrappers(self):
                 f = os.path.join(bin_dir, f)
                 filter_file("-Xlinker --enable-new-dtags", " ", f, string=True)
 
-    @spack.builder.run_after("install")
+    @run_after("install")
     def uninstall_ism(self):
         # The "Intel(R) Software Improvement Program" [ahem] gets installed,
         # apparently regardless of PHONEHOME_SEND_USAGE_DATA.
@@ -1358,7 +1360,7 @@ def base_lib_dir(self):
         debug_print(d)
         return d
 
-    @spack.builder.run_after("install")
+    @run_after("install")
     def modify_LLVMgold_rpath(self):
         """Add libimf.so and other required libraries to the RUNPATH of LLVMgold.so.
 
@@ -1389,3 +1391,6 @@ def modify_LLVMgold_rpath(self):
                     ]
                 )
                 patchelf("--set-rpath", rpath, lib)
+
+    # Check that self.prefix is there after installation
+    run_after("install")(PackageBase.sanity_check_prefix)

lib/spack/spack/build_systems/lua.py

@@ -2,82 +2,59 @@
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+
 import os
 
 from llnl.util.filesystem import find
 
-import spack.builder
-import spack.package_base
-import spack.util.executable
-from spack.directives import build_system, depends_on, extends
+from spack.directives import depends_on, extends
 from spack.multimethod import when
+from spack.package_base import PackageBase
+from spack.util.executable import Executable
 
 
-class LuaPackage(spack.package_base.PackageBase):
+class LuaPackage(PackageBase):
     """Specialized class for lua packages"""
 
+    phases = ["unpack", "generate_luarocks_config", "preprocess", "install"]
     #: This attribute is used in UI queries that need to know the build
     #: system base class
     build_system_class = "LuaPackage"
 
-    #: Legacy buildsystem attribute used to deserialize and install old specs
-    legacy_buildsystem = "lua"
-
     list_depth = 1  # LuaRocks requires at least one level of spidering to find versions
+    depends_on("lua-lang")
+    extends("lua", when="^lua")
+    with when("^lua-luajit"):
+        extends("lua-luajit")
+        depends_on("luajit")
+        depends_on("lua-luajit+lualinks")
+    with when("^lua-luajit-openresty"):
+        extends("lua-luajit-openresty")
+        depends_on("luajit")
+        depends_on("lua-luajit-openresty+lualinks")
 
-    build_system("lua")
-
-    with when("build_system=lua"):
-        depends_on("lua-lang")
-        extends("lua", when="^lua")
-        with when("^lua-luajit"):
-            extends("lua-luajit")
-            depends_on("luajit")
-            depends_on("lua-luajit+lualinks")
-        with when("^lua-luajit-openresty"):
-            extends("lua-luajit-openresty")
-            depends_on("luajit")
-            depends_on("lua-luajit-openresty+lualinks")
-
-    @property
-    def lua(self):
-        return spack.util.executable.Executable(self.spec["lua-lang"].prefix.bin.lua)
-
-    @property
-    def luarocks(self):
-        lr = spack.util.executable.Executable(self.spec["lua-lang"].prefix.bin.luarocks)
-        return lr
-
-
-@spack.builder.builder("lua")
-class LuaBuilder(spack.builder.Builder):
-    phases = ("unpack", "generate_luarocks_config", "preprocess", "install")
-
-    #: Names associated with package methods in the old build-system format
-    legacy_methods = ("luarocks_args",)
-
-    #: Names associated with package attributes in the old build-system format
-    legacy_attributes = ()
-
-    def unpack(self, pkg, spec, prefix):
-        if os.path.splitext(pkg.stage.archive_file)[1] == ".rock":
-            directory = pkg.luarocks("unpack", pkg.stage.archive_file, output=str)
+    def unpack(self, spec, prefix):
+        if os.path.splitext(self.stage.archive_file)[1] == ".rock":
+            directory = self.luarocks("unpack", self.stage.archive_file, output=str)
             dirlines = directory.split("\n")
             # TODO: figure out how to scope this better
             os.chdir(dirlines[2])
 
-    @staticmethod
-    def _generate_tree_line(name, prefix):
+    def _generate_tree_line(self, name, prefix):
         return """{{ name = "{name}", root = "{prefix}" }};""".format(
             name=name,
             prefix=prefix,
         )
 
-    def generate_luarocks_config(self, pkg, spec, prefix):
-        spec = self.pkg.spec
+    def _luarocks_config_path(self):
+        return os.path.join(self.stage.source_path, "spack_luarocks.lua")
+
+    def generate_luarocks_config(self, spec, prefix):
+        spec = self.spec
         table_entries = []
-        for d in spec.traverse(deptype=("build", "run")):
-            if d.package.extends(self.pkg.extendee_spec):
+        for d in spec.traverse(deptypes=("build", "run"), deptype_query="run"):
+            if d.package.extends(self.extendee_spec):
                 table_entries.append(self._generate_tree_line(d.name, d.prefix))
 
         path = self._luarocks_config_path()
@@ -94,24 +71,30 @@ def generate_luarocks_config(self, pkg, spec, prefix):
             )
         return path
 
-    def preprocess(self, pkg, spec, prefix):
+    def setup_build_environment(self, env):
+        env.set("LUAROCKS_CONFIG", self._luarocks_config_path())
+
+    def preprocess(self, spec, prefix):
         """Override this to preprocess source before building with luarocks"""
         pass
 
+    @property
+    def lua(self):
+        return Executable(self.spec["lua-lang"].prefix.bin.lua)
+
+    @property
+    def luarocks(self):
+        lr = Executable(self.spec["lua-lang"].prefix.bin.luarocks)
+        return lr
+
     def luarocks_args(self):
         return []
 
-    def install(self, pkg, spec, prefix):
+    def install(self, spec, prefix):
         rock = "."
         specs = find(".", "*.rockspec", recursive=False)
         if specs:
             rock = specs[0]
         rocks_args = self.luarocks_args()
         rocks_args.append(rock)
-        self.pkg.luarocks("--tree=" + prefix, "make", *rocks_args)
-
-    def _luarocks_config_path(self):
-        return os.path.join(self.pkg.stage.source_path, "spack_luarocks.lua")
-
-    def setup_build_environment(self, env):
-        env.set("LUAROCKS_CONFIG", self._luarocks_config_path())
+        self.luarocks("--tree=" + prefix, "make", *rocks_args)

lib/spack/spack/build_systems/makefile.py

@@ -2,85 +2,62 @@
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+
 import inspect
 from typing import List  # novm
 
-import llnl.util.filesystem as fs
+import llnl.util.tty as tty
+from llnl.util.filesystem import working_dir
 
-import spack.builder
-import spack.package_base
-from spack.directives import build_system, conflicts
-
-from ._checks import (
-    BaseBuilder,
-    apply_macos_rpath_fixups,
-    execute_build_time_tests,
-    execute_install_time_tests,
-)
+from spack.directives import conflicts
+from spack.package_base import PackageBase, run_after
 
 
-class MakefilePackage(spack.package_base.PackageBase):
-    """Specialized class for packages built using a Makefiles."""
+class MakefilePackage(PackageBase):
+    """Specialized class for packages that are built using editable Makefiles
 
-    #: This attribute is used in UI queries that need to know the build
-    #: system base class
-    build_system_class = "MakefilePackage"
-    #: Legacy buildsystem attribute used to deserialize and install old specs
-    legacy_buildsystem = "makefile"
+    This class provides three phases that can be overridden:
 
-    build_system("makefile")
-    conflicts("platform=windows", when="build_system=makefile")
-
-
-@spack.builder.builder("makefile")
-class MakefileBuilder(BaseBuilder):
-    """The Makefile builder encodes the most common way of building software with
-    Makefiles. It has three phases that can be overridden, if need be:
-
-            1. :py:meth:`~.MakefileBuilder.edit`
-            2. :py:meth:`~.MakefileBuilder.build`
-            3. :py:meth:`~.MakefileBuilder.install`
-
-    It is usually necessary to override the :py:meth:`~.MakefileBuilder.edit`
-    phase (which is by default a no-op), while the other two have sensible defaults.
+        1. :py:meth:`~.MakefilePackage.edit`
+        2. :py:meth:`~.MakefilePackage.build`
+        3. :py:meth:`~.MakefilePackage.install`
 
+    It is usually necessary to override the :py:meth:`~.MakefilePackage.edit`
+    phase, while :py:meth:`~.MakefilePackage.build` and
+    :py:meth:`~.MakefilePackage.install` have sensible defaults.
     For a finer tuning you may override:
 
         +-----------------------------------------------+--------------------+
         | **Method**                                    | **Purpose**        |
         +===============================================+====================+
-        | :py:attr:`~.MakefileBuilder.build_targets`    | Specify ``make``   |
+        | :py:attr:`~.MakefilePackage.build_targets`    | Specify ``make``   |
         |                                               | targets for the    |
         |                                               | build phase        |
         +-----------------------------------------------+--------------------+
-        | :py:attr:`~.MakefileBuilder.install_targets`  | Specify ``make``   |
+        | :py:attr:`~.MakefilePackage.install_targets`  | Specify ``make``   |
         |                                               | targets for the    |
         |                                               | install phase      |
         +-----------------------------------------------+--------------------+
-        | :py:meth:`~.MakefileBuilder.build_directory`  | Directory where the|
+        | :py:meth:`~.MakefilePackage.build_directory`  | Directory where the|
         |                                               | Makefile is located|
         +-----------------------------------------------+--------------------+
     """
 
-    phases = ("edit", "build", "install")
+    #: Phases of a package that is built with an hand-written Makefile
+    phases = ["edit", "build", "install"]
+    #: This attribute is used in UI queries that need to know the build
+    #: system base class
+    build_system_class = "MakefilePackage"
 
-    #: Names associated with package methods in the old build-system format
-    legacy_methods = ("check", "installcheck")
-
-    #: Names associated with package attributes in the old build-system format
-    legacy_attributes = (
-        "build_targets",
-        "install_targets",
-        "build_time_test_callbacks",
-        "install_time_test_callbacks",
-        "build_directory",
-    )
-
-    #: Targets for ``make`` during the :py:meth:`~.MakefileBuilder.build` phase
+    #: Targets for ``make`` during the :py:meth:`~.MakefilePackage.build`
+    #: phase
     build_targets = []  # type: List[str]
-    #: Targets for ``make`` during the :py:meth:`~.MakefileBuilder.install` phase
+    #: Targets for ``make`` during the :py:meth:`~.MakefilePackage.install`
+    #: phase
     install_targets = ["install"]
 
+    conflicts("platform=windows")
     #: Callback names for build-time test
     build_time_test_callbacks = ["check"]
 
@@ -89,39 +66,53 @@ class MakefileBuilder(BaseBuilder):
 
     @property
     def build_directory(self):
-        """Return the directory containing the main Makefile."""
-        return self.pkg.stage.source_path
+        """Returns the directory containing the main Makefile
 
-    def edit(self, pkg, spec, prefix):
-        """Edit the Makefile before calling make. The default is a no-op."""
-        pass
+        :return: build directory
+        """
+        return self.stage.source_path
 
-    def build(self, pkg, spec, prefix):
-        """Run "make" on the build targets specified by the builder."""
-        with fs.working_dir(self.build_directory):
-            inspect.getmodule(self.pkg).make(*self.build_targets)
+    def edit(self, spec, prefix):
+        """Edits the Makefile before calling make. This phase cannot
+        be defaulted.
+        """
+        tty.msg("Using default implementation: skipping edit phase.")
 
-    def install(self, pkg, spec, prefix):
-        """Run "make" on the install targets specified by the builder."""
-        with fs.working_dir(self.build_directory):
-            inspect.getmodule(self.pkg).make(*self.install_targets)
+    def build(self, spec, prefix):
+        """Calls make, passing :py:attr:`~.MakefilePackage.build_targets`
+        as targets.
+        """
+        with working_dir(self.build_directory):
+            inspect.getmodule(self).make(*self.build_targets)
 
-    spack.builder.run_after("build")(execute_build_time_tests)
+    def install(self, spec, prefix):
+        """Calls make, passing :py:attr:`~.MakefilePackage.install_targets`
+        as targets.
+        """
+        with working_dir(self.build_directory):
+            inspect.getmodule(self).make(*self.install_targets)
+
+    run_after("build")(PackageBase._run_default_build_time_test_callbacks)
 
     def check(self):
-        """Run "make" on the ``test`` and ``check`` targets, if found."""
-        with fs.working_dir(self.build_directory):
-            self.pkg._if_make_target_execute("test")
-            self.pkg._if_make_target_execute("check")
+        """Searches the Makefile for targets ``test`` and ``check``
+        and runs them if found.
+        """
+        with working_dir(self.build_directory):
+            self._if_make_target_execute("test")
+            self._if_make_target_execute("check")
 
-    spack.builder.run_after("install")(execute_install_time_tests)
+    run_after("install")(PackageBase._run_default_install_time_test_callbacks)
 
     def installcheck(self):
         """Searches the Makefile for an ``installcheck`` target
         and runs it if found.
         """
-        with fs.working_dir(self.build_directory):
-            self.pkg._if_make_target_execute("installcheck")
+        with working_dir(self.build_directory):
+            self._if_make_target_execute("installcheck")
+
+    # Check that self.prefix is there after installation
+    run_after("install")(PackageBase.sanity_check_prefix)
 
     # On macOS, force rpaths for shared library IDs and remove duplicate rpaths
-    spack.builder.run_after("install", when="platform=darwin")(apply_macos_rpath_fixups)
+    run_after("install")(PackageBase.apply_macos_rpath_fixups)

lib/spack/spack/build_systems/maven.py

@@ -2,73 +2,60 @@
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
-import llnl.util.filesystem as fs
 
-import spack.builder
-import spack.package_base
-from spack.directives import build_system, depends_on
-from spack.multimethod import when
+
+from llnl.util.filesystem import install_tree, working_dir
+
+from spack.directives import depends_on
+from spack.package_base import PackageBase, run_after
 from spack.util.executable import which
 
-from ._checks import BaseBuilder
 
-
-class MavenPackage(spack.package_base.PackageBase):
+class MavenPackage(PackageBase):
     """Specialized class for packages that are built using the
     Maven build system. See https://maven.apache.org/index.html
     for more information.
+
+    This class provides the following phases that can be overridden:
+
+    * build
+    * install
     """
 
+    # Default phases
+    phases = ["build", "install"]
+
     # To be used in UI queries that require to know which
     # build-system class we are using
     build_system_class = "MavenPackage"
 
-    #: Legacy buildsystem attribute used to deserialize and install old specs
-    legacy_buildsystem = "maven"
-
-    build_system("maven")
-
-    with when("build_system=maven"):
-        depends_on("java", type=("build", "run"))
-        depends_on("maven", type="build")
-
-
-@spack.builder.builder("maven")
-class MavenBuilder(BaseBuilder):
-    """The Maven builder encodes the default way to build software with Maven.
-    It has two phases that can be overridden, if need be:
-
-        1. :py:meth:`~.MavenBuilder.build`
-        2. :py:meth:`~.MavenBuilder.install`
-    """
-
-    phases = ("build", "install")
-
-    #: Names associated with package methods in the old build-system format
-    legacy_methods = ("build_args",)
-
-    #: Names associated with package attributes in the old build-system format
-    legacy_attributes = ("build_directory",)
+    depends_on("java", type=("build", "run"))
+    depends_on("maven", type="build")
 
     @property
     def build_directory(self):
         """The directory containing the ``pom.xml`` file."""
-        return self.pkg.stage.source_path
+        return self.stage.source_path
 
     def build_args(self):
         """List of args to pass to build phase."""
         return []
 
-    def build(self, pkg, spec, prefix):
+    def build(self, spec, prefix):
         """Compile code and package into a JAR file."""
-        with fs.working_dir(self.build_directory):
+
+        with working_dir(self.build_directory):
             mvn = which("mvn")
-            if self.pkg.run_tests:
+            if self.run_tests:
                 mvn("verify", *self.build_args())
             else:
                 mvn("package", "-DskipTests", *self.build_args())
 
-    def install(self, pkg, spec, prefix):
+    def install(self, spec, prefix):
         """Copy to installation prefix."""
-        with fs.working_dir(self.build_directory):
-            fs.install_tree(".", prefix)
+
+        with working_dir(self.build_directory):
+            install_tree(".", prefix)
+
+    # Check that self.prefix is there after installation
+    run_after("install")(PackageBase.sanity_check_prefix)

lib/spack/spack/build_systems/meson.py

@@ -2,131 +2,108 @@
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+
 import inspect
 import os
 from typing import List  # novm
 
-import llnl.util.filesystem as fs
+from llnl.util.filesystem import working_dir
 
-import spack.builder
-import spack.package_base
-from spack.directives import build_system, depends_on, variant
-from spack.multimethod import when
-
-from ._checks import BaseBuilder, execute_build_time_tests
+from spack.directives import depends_on, variant
+from spack.package_base import PackageBase, run_after
 
 
-class MesonPackage(spack.package_base.PackageBase):
-    """Specialized class for packages built using Meson. For more information
-    on the Meson build system, see https://mesonbuild.com/
-    """
+class MesonPackage(PackageBase):
+    """Specialized class for packages built using Meson
 
-    #: This attribute is used in UI queries that need to know the build
-    #: system base class
-    build_system_class = "MesonPackage"
+    For more information on the Meson build system, see:
+    https://mesonbuild.com/
 
-    #: Legacy buildsystem attribute used to deserialize and install old specs
-    legacy_buildsystem = "meson"
+    This class provides three phases that can be overridden:
 
-    build_system("meson")
-
-    with when("build_system=meson"):
-        variant(
-            "buildtype",
-            default="debugoptimized",
-            description="Meson build type",
-            values=("plain", "debug", "debugoptimized", "release", "minsize"),
-        )
-        variant(
-            "default_library",
-            default="shared",
-            values=("shared", "static"),
-            multi=True,
-            description="Build shared libs, static libs or both",
-        )
-        variant("strip", default=False, description="Strip targets on install")
-        depends_on("meson", type="build")
-        depends_on("ninja", type="build")
-
-    def flags_to_build_system_args(self, flags):
-        """Produces a list of all command line arguments to pass the specified
-        compiler flags to meson."""
-        # Has to be dynamic attribute due to caching
-        setattr(self, "meson_flag_args", [])
-
-
-@spack.builder.builder("meson")
-class MesonBuilder(BaseBuilder):
-    """The Meson builder encodes the default way to build software with Meson.
-    The builder has three phases that can be overridden, if need be:
-
-            1. :py:meth:`~.MesonBuilder.meson`
-            2. :py:meth:`~.MesonBuilder.build`
-            3. :py:meth:`~.MesonBuilder.install`
+        1. :py:meth:`~.MesonPackage.meson`
+        2. :py:meth:`~.MesonPackage.build`
+        3. :py:meth:`~.MesonPackage.install`
 
     They all have sensible defaults and for many packages the only thing
-    necessary will be to override :py:meth:`~.MesonBuilder.meson_args`.
-
+    necessary will be to override :py:meth:`~.MesonPackage.meson_args`.
     For a finer tuning you may also override:
 
         +-----------------------------------------------+--------------------+
         | **Method**                                    | **Purpose**        |
         +===============================================+====================+
-        | :py:meth:`~.MesonBuilder.root_mesonlists_dir` | Location of the    |
+        | :py:meth:`~.MesonPackage.root_mesonlists_dir` | Location of the    |
         |                                               | root MesonLists.txt|
         +-----------------------------------------------+--------------------+
-        | :py:meth:`~.MesonBuilder.build_directory`     | Directory where to |
+        | :py:meth:`~.MesonPackage.build_directory`     | Directory where to |
         |                                               | build the package  |
         +-----------------------------------------------+--------------------+
+
+
     """
 
-    phases = ("meson", "build", "install")
-
-    #: Names associated with package methods in the old build-system format
-    legacy_methods = ("meson_args", "check")
-
-    #: Names associated with package attributes in the old build-system format
-    legacy_attributes = (
-        "build_targets",
-        "install_targets",
-        "build_time_test_callbacks",
-        "root_mesonlists_dir",
-        "std_meson_args",
-        "build_directory",
-    )
+    #: Phases of a Meson package
+    phases = ["meson", "build", "install"]
+    #: This attribute is used in UI queries that need to know the build
+    #: system base class
+    build_system_class = "MesonPackage"
 
     build_targets = []  # type: List[str]
     install_targets = ["install"]
 
     build_time_test_callbacks = ["check"]
 
+    variant(
+        "buildtype",
+        default="debugoptimized",
+        description="Meson build type",
+        values=("plain", "debug", "debugoptimized", "release", "minsize"),
+    )
+    variant(
+        "default_library",
+        default="shared",
+        values=("shared", "static"),
+        multi=True,
+        description="Build shared libs, static libs or both",
+    )
+    variant("strip", default=False, description="Strip targets on install")
+
+    depends_on("meson", type="build")
+    depends_on("ninja", type="build")
+
     @property
     def archive_files(self):
         """Files to archive for packages based on Meson"""
-        return [os.path.join(self.build_directory, "meson-logs", "meson-log.txt")]
+        return [os.path.join(self.build_directory, "meson-logs/meson-log.txt")]
 
     @property
     def root_mesonlists_dir(self):
-        """Relative path to the directory containing meson.build
+        """The relative path to the directory containing meson.build
 
         This path is relative to the root of the extracted tarball,
         not to the ``build_directory``. Defaults to the current directory.
+
+        :return: directory containing meson.build
         """
-        return self.pkg.stage.source_path
+        return self.stage.source_path
 
     @property
     def std_meson_args(self):
-        """Standard meson arguments provided as a property for convenience
-        of package writers.
+        """Standard meson arguments provided as a property for
+        convenience of package writers
+
+        :return: standard meson arguments
         """
         # standard Meson arguments
-        std_meson_args = MesonBuilder.std_args(self.pkg)
+        std_meson_args = MesonPackage._std_args(self)
         std_meson_args += getattr(self, "meson_flag_args", [])
         return std_meson_args
 
     @staticmethod
-    def std_args(pkg):
-        """Standard meson arguments for a generic package."""
+    def _std_args(pkg):
+        """Computes the standard meson arguments for a generic package"""
+
         try:
             build_type = pkg.spec.variants["buildtype"].value
         except KeyError:
@@ -142,33 +119,44 @@ def std_args(pkg):
             default_library = "shared"
 
         args = [
-            "-Dprefix={0}".format(pkg.prefix),
+            "--prefix={0}".format(pkg.prefix),
             # If we do not specify libdir explicitly, Meson chooses something
             # like lib/x86_64-linux-gnu, which causes problems when trying to
             # find libraries and pkg-config files.
             # See https://github.com/mesonbuild/meson/issues/2197
-            "-Dlibdir={0}".format(pkg.prefix.lib),
+            "--libdir={0}".format(pkg.prefix.lib),
             "-Dbuildtype={0}".format(build_type),
             "-Dstrip={0}".format(strip),
             "-Ddefault_library={0}".format(default_library),
-            # Do not automatically download and install dependencies
-            "-Dwrap_mode=nodownload",
         ]
 
         return args
 
+    def flags_to_build_system_args(self, flags):
+        """Produces a list of all command line arguments to pass the specified
+        compiler flags to meson."""
+        # Has to be dynamic attribute due to caching
+        setattr(self, "meson_flag_args", [])
+
     @property
     def build_dirname(self):
-        """Returns the directory name to use when building the package."""
-        return "spack-build-{}".format(self.spec.dag_hash(7))
+        """Returns the directory name to use when building the package
+
+        :return: name of the subdirectory for building the package
+        """
+        return "spack-build-%s" % self.spec.dag_hash(7)
 
     @property
     def build_directory(self):
-        """Directory to use when building the package."""
-        return os.path.join(self.pkg.stage.path, self.build_dirname)
+        """Returns the directory to use when building the package
+
+        :return: directory where to build the package
+        """
+        return os.path.join(self.stage.path, self.build_dirname)
 
     def meson_args(self):
-        """List of arguments that must be passed to meson, except:
+        """Produces a list containing all the arguments that must be passed to
+        meson, except:
 
         * ``--prefix``
         * ``--libdir``
@@ -177,33 +165,40 @@ def meson_args(self):
         * ``--default_library``
 
         which will be set automatically.
+
+        :return: list of arguments for meson
         """
         return []
 
-    def meson(self, pkg, spec, prefix):
-        """Run ``meson`` in the build directory"""
+    def meson(self, spec, prefix):
+        """Runs ``meson`` in the build directory"""
         options = [os.path.abspath(self.root_mesonlists_dir)]
         options += self.std_meson_args
         options += self.meson_args()
-        with fs.working_dir(self.build_directory, create=True):
-            inspect.getmodule(self.pkg).meson(*options)
+        with working_dir(self.build_directory, create=True):
+            inspect.getmodule(self).meson(*options)
 
-    def build(self, pkg, spec, prefix):
+    def build(self, spec, prefix):
         """Make the build targets"""
         options = ["-v"]
         options += self.build_targets
-        with fs.working_dir(self.build_directory):
-            inspect.getmodule(self.pkg).ninja(*options)
+        with working_dir(self.build_directory):
+            inspect.getmodule(self).ninja(*options)
 
-    def install(self, pkg, spec, prefix):
+    def install(self, spec, prefix):
         """Make the install targets"""
-        with fs.working_dir(self.build_directory):
-            inspect.getmodule(self.pkg).ninja(*self.install_targets)
+        with working_dir(self.build_directory):
+            inspect.getmodule(self).ninja(*self.install_targets)
 
-    spack.builder.run_after("build")(execute_build_time_tests)
+    run_after("build")(PackageBase._run_default_build_time_test_callbacks)
 
     def check(self):
-        """Search Meson-generated files for the target ``test`` and run it if found."""
-        with fs.working_dir(self.build_directory):
+        """Searches the Meson-generated file for the target ``test``
+        and runs it if found.
+        """
+        with working_dir(self.build_directory):
             self._if_ninja_target_execute("test")
             self._if_ninja_target_execute("check")
+
+    # Check that self.prefix is there after installation
+    run_after("install")(PackageBase.sanity_check_prefix)

lib/spack/spack/build_systems/nmake.py

@@ -1,102 +0,0 @@
-# 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)
-import inspect
-from typing import List  # novm
-
-import llnl.util.filesystem as fs
-
-import spack.builder
-import spack.package_base
-from spack.directives import build_system, conflicts
-
-from ._checks import BaseBuilder
-
-
-class NMakePackage(spack.package_base.PackageBase):
-    """Specialized class for packages built using a Makefiles."""
-
-    #: This attribute is used in UI queries that need to know the build
-    #: system base class
-    build_system_class = "NmakePackage"
-
-    build_system("nmake")
-    conflicts("platform=linux", when="build_system=nmake")
-    conflicts("platform=darwin", when="build_system=nmake")
-    conflicts("platform=cray", when="build_system=nmake")
-
-
-@spack.builder.builder("nmake")
-class NMakeBuilder(BaseBuilder):
-    """The NMake builder encodes the most common way of building software with
-    NMake on Windows. It has three phases that can be overridden, if need be:
-
-            1. :py:meth:`~.NMakeBuilder.edit`
-            2. :py:meth:`~.NMakeBuilder.build`
-            3. :py:meth:`~.NMakeBuilder.install`
-
-    It is usually necessary to override the :py:meth:`~.NMakeBuilder.edit`
-    phase (which is by default a no-op), while the other two have sensible defaults.
-
-    For a finer tuning you may override:
-
-            +--------------------------------------------+--------------------+
-            | **Method**                                 | **Purpose**        |
-            +============================================+====================+
-            | :py:attr:`~.NMakeBuilder.build_targets`    | Specify ``nmake``  |
-            |                                            | targets for the    |
-            |                                            | build phase        |
-            +--------------------------------------------+--------------------+
-            | :py:attr:`~.NMakeBuilder.install_targets`  | Specify ``nmake``  |
-            |                                            | targets for the    |
-            |                                            | install phase      |
-            +--------------------------------------------+--------------------+
-            | :py:meth:`~.NMakeBuilder.build_directory`  | Directory where the|
-            |                                            | Makefile is located|
-            +--------------------------------------------+--------------------+
-    """
-
-    phases = ("edit", "build", "install")
-
-    #: Names associated with package methods in the old build-system format
-    legacy_methods = ("check", "installcheck")
-
-    #: Names associated with package attributes in the old build-system format
-    legacy_attributes = (
-        "build_targets",
-        "install_targets",
-        "build_time_test_callbacks",
-        "install_time_test_callbacks",
-        "build_directory",
-    )
-
-    #: Targets for ``make`` during the :py:meth:`~.NMakeBuilder.build` phase
-    build_targets = []  # type: List[str]
-    #: Targets for ``make`` during the :py:meth:`~.NMakeBuilder.install` phase
-    install_targets = ["install"]
-
-    #: Callback names for build-time test
-    build_time_test_callbacks = ["check"]
-
-    #: Callback names for install-time test
-    install_time_test_callbacks = ["installcheck"]
-
-    @property
-    def build_directory(self):
-        """Return the directory containing the main Makefile."""
-        return self.pkg.stage.source_path
-
-    def edit(self, pkg, spec, prefix):
-        """Edit the Makefile before calling make. The default is a no-op."""
-        pass
-
-    def build(self, pkg, spec, prefix):
-        """Run "make" on the build targets specified by the builder."""
-        with fs.working_dir(self.build_directory):
-            inspect.getmodule(self.pkg).nmake(*self.build_targets)
-
-    def install(self, pkg, spec, prefix):
-        """Run "make" on the install targets specified by the builder."""
-        with fs.working_dir(self.build_directory):
-            inspect.getmodule(self.pkg).nmake(*self.install_targets)

lib/spack/spack/build_systems/octave.py

@@ -2,62 +2,51 @@
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
 import inspect
 
-import spack.builder
-import spack.package_base
-from spack.directives import build_system, extends
-from spack.multimethod import when
-
-from ._checks import BaseBuilder
+from spack.directives import extends
+from spack.package_base import PackageBase, run_after
 
 
-class OctavePackage(spack.package_base.PackageBase):
+class OctavePackage(PackageBase):
     """Specialized class for Octave packages. See
     https://www.gnu.org/software/octave/doc/v4.2.0/Installing-and-Removing-Packages.html
     for more information.
+
+    This class provides the following phases that can be overridden:
+
+    1. :py:meth:`~.OctavePackage.install`
+
     """
 
+    # Default phases
+    phases = ["install"]
+
     # To be used in UI queries that require to know which
     # build-system class we are using
     build_system_class = "OctavePackage"
-    #: Legacy buildsystem attribute used to deserialize and install old specs
-    legacy_buildsystem = "octave"
 
-    build_system("octave")
-
-    with when("build_system=octave"):
-        extends("octave")
-
-
-@spack.builder.builder("octave")
-class OctaveBuilder(BaseBuilder):
-    """The octave builder provides the following phases that can be overridden:
-
-    1. :py:meth:`~.OctaveBuilder.install`
-    """
-
-    phases = ("install",)
-
-    #: Names associated with package methods in the old build-system format
-    legacy_methods = ()
-
-    #: Names associated with package attributes in the old build-system format
-    legacy_attributes = ()
-
-    def install(self, pkg, spec, prefix):
-        """Install the package from the archive file"""
-        inspect.getmodule(self.pkg).octave(
-            "--quiet",
-            "--norc",
-            "--built-in-docstrings-file=/dev/null",
-            "--texi-macros-file=/dev/null",
-            "--eval",
-            "pkg prefix %s; pkg install %s" % (prefix, self.pkg.stage.archive_file),
-        )
+    extends("octave")
 
     def setup_build_environment(self, env):
         # octave does not like those environment variables to be set:
         env.unset("CC")
         env.unset("CXX")
         env.unset("FC")
+
+    def install(self, spec, prefix):
+        """Install the package from the archive file"""
+        inspect.getmodule(self).octave(
+            "--quiet",
+            "--norc",
+            "--built-in-docstrings-file=/dev/null",
+            "--texi-macros-file=/dev/null",
+            "--eval",
+            "pkg prefix %s; pkg install %s" % (prefix, self.stage.archive_file),
+        )
+
+    # Testing
+
+    # Check that self.prefix is there after installation
+    run_after("install")(PackageBase.sanity_check_prefix)

lib/spack/spack/build_systems/oneapi.py

@@ -2,7 +2,11 @@
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
-"""Common utilities for managing intel oneapi packages."""
+
+"""Common utilities for managing intel oneapi packages.
+
+"""
+
 import getpass
 import platform
 import shutil
@@ -10,17 +14,18 @@
 
 from llnl.util.filesystem import find_headers, find_libraries, join_path
 
+from spack.package_base import Package
 from spack.util.environment import EnvironmentModifications
 from spack.util.executable import Executable
 
-from .generic import Package
-
 
 class IntelOneApiPackage(Package):
     """Base class for Intel oneAPI packages."""
 
     homepage = "https://software.intel.com/oneapi"
 
+    phases = ["install"]
+
     # oneAPI license does not allow mirroring outside of the
     # organization (e.g. University/Company).
     redistribute_source = False