WIP -- wait for 18205 to continue

* no clean -t option, use 'spack test remove'

* refactor commands to make better use of TestSuite objects

.codecov.yml

@@ -14,21 +14,3 @@ ignore:
   - share/spack/qa/.*
 
 comment: off
-
-# Inline codecov annotations make the code hard to read, and they add
-# annotations in files that seemingly have nothing to do with the PR.
-github_checks:
-    annotations: false
-
-# Attempt to fix "Missing base commit" messages in the codecov UI.
-# Because we do not run full tests on package PRs, package PRs' merge
-# commits on `develop` don't have coverage info.  It appears that
-# codecov will give you an error if the pseudo-base's coverage data
-# doesn't all apply properly to the real PR base.
-#
-# See here for docs:
-#   https://docs.codecov.com/docs/comparing-commits#pseudo-comparison
-# See here for another potential solution:
-#   https://community.codecov.com/t/2480/15
-codecov:
-  allow_coverage_offsets: true

.coveragerc

@@ -0,0 +1,36 @@
+# -*- conf -*-
+# .coveragerc to control coverage.py
+[run]
+parallel = True
+concurrency = multiprocessing
+branch = True
+source = lib
+omit =
+     lib/spack/spack/test/*
+     lib/spack/docs/*
+     lib/spack/external/*
+     share/spack/qa/*
+
+[report]
+# Regexes for lines to exclude from consideration
+exclude_lines =
+    # Have to re-enable the standard pragma
+    pragma: no cover
+
+    # Don't complain about missing debug-only code:
+    def __repr__
+    if self\.debug
+
+    # Don't complain if tests don't hit defensive assertion code:
+    raise AssertionError
+    raise NotImplementedError
+
+    # Don't complain if non-runnable code isn't run:
+    if 0:
+    if False:
+    if __name__ == .__main__.:
+
+ignore_errors = True
+
+[html]
+directory = htmlcov

.dockerignore

@@ -8,4 +8,4 @@ share/spack/dotkit/*
 share/spack/lmod/*
 share/spack/modules/*
 lib/spack/spack/test/*
-var/spack/cache/*
+

.flake8

@@ -1,56 +1,32 @@
 # -*- conf -*-
-# flake8 settings for Spack.
+# flake8 settings for Spack core files.
 #
 # These exceptions are for Spack core files. We're slightly more lenient
 # with packages.  See .flake8_packages for that.
 #
-# This is the only flake8 rule Spack violates somewhat flagrantly
+# E1: Indentation
+# - E129: visually indented line with same indent as next logical line
+#
+# E2: Whitespace
+# - E221: multiple spaces before operator
+# - E241: multiple spaces after ','
+# - E272: multiple spaces before keyword
+#
+# E7: Statement
 # - E731: do not assign a lambda expression, use a def
 #
-# This is the only flake8 exception needed when using Black.
-# - E203: white space around slice operators can be required, ignore : warn
+# W5: Line break warning
+# - W503: line break before binary operator
+# - W504: line break after binary operator
 #
-# We still allow these in packages (Would like to get rid of them or rely on mypy
-# in the future)
-# - F403: from/import * used; unable to detect undefined names
-# - F405: undefined name or from *
-# - F821: undefined name (needed with from/import *)
+# These are required to get the package.py files to test clean:
+# - F999: syntax error in doctest
+#
+# N8: PEP8-naming
+# - N801: class names should use CapWords convention
+# - N813: camelcase imported as lowercase
+# - N814: camelcase imported as constant
 #
 [flake8]
-#ignore = E129,,W503,W504,F999,N801,N813,N814,F403,F405,E203
-extend-ignore = E731,E203
-max-line-length = 99
-
-# F4: Import
-# - F405: `name` may be undefined, or undefined from star imports: `module`
-#
-# F8: Name
-# - F821: undefined name `name`
-#
-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
-# them on the command line.
-exclude =
-  .git
-  etc/
-  opt/
-  share/
-  var/spack/cache/
-  var/spack/gpg*/
-  var/spack/junit-report/
-  var/spack/mock-configs/
-  lib/spack/external
-  __pycache__
-  var
-
-format = spack
-
-[flake8:local-plugins]
-report =
-  spack = flake8_formatter:SpackFormatter
-paths =
-  ./share/spack/qa/
+ignore = E129,E221,E241,E272,E731,W503,W504,F999,N801,N813,N814
+max-line-length = 79

.flake8_packages

@@ -0,0 +1,24 @@
+# -*- conf -*-
+# flake8 settings for Spack package files.
+#
+# This should include all the same exceptions that we use for core files.
+#
+# In Spack packages, we also allow the single `from spack import *`
+# wildcard import and dependencies can set globals for their
+# dependents. So we add exceptions for checks related to undefined names.
+#
+# Note that we also add *per-line* exemptions for certain patterns in the
+# `spack flake8` command.  This is where F403 for `from spack import *`
+# is added (because we *only* allow that wildcard).
+#
+# See .flake8 for regular exceptions.
+#
+# F4: Import
+# - F405: `name` may be undefined, or undefined from star imports: `module`
+#
+# F8: Name
+# - F821: undefined name `name`
+#
+[flake8]
+ignore = E129,E221,E241,E272,E731,W503,W504,F405,F821,F999,N801,N813,N814
+max-line-length = 79

.git-blame-ignore-revs

@@ -1,3 +0,0 @@
-# .git-blame-ignore-revs
-# Formatted entire codebase with black
-f52f6e99dbf1131886a80112b8c79dfc414afb7c

.gitattributes

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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,42 @@
+---
+name: "\U0001F41E Bug report"
+about: Report a bug in the core of Spack (command not working as expected, etc.)
+labels: "bug,triage"
+---
+
+<!-- Explain, in a clear and concise way, the command you ran and the result you were trying to achieve.
+Example: "I ran `spack find` to list all the installed packages and ..." -->
+
+### Steps to reproduce the issue
+
+```console
+$ spack <command1> <spec>
+$ spack <command2> <spec>
+...
+```
+
+### Error Message
+
+<!-- If Spack reported an error, provide the error message. If it did not report an error but the output appears incorrect, provide the incorrect output. If there was no error message and no output but the result is incorrect, describe how it does not match what you expect. -->
+```console
+$ spack --debug --stacktrace <command>
+```
+
+### Information on your system
+
+<!-- Please include the output of `spack debug report` -->
+
+<!-- If you have any relevant configuration detail (custom `packages.yaml` or `modules.yaml`, etc.) you can add that here as well. -->
+
+### Additional information
+
+<!-- These boxes can be checked by replacing [ ] with [x] or by clicking them after submitting the issue. -->
+- [ ] I have run `spack debug report` and reported the version of Spack/Python/Platform
+- [ ] I have searched the issues of this repo and believe this is not a duplicate
+- [ ] I have run the failing commands in debug mode and reported the output
+
+<!-- We encourage you to try, as much as possible, to reduce your problem to the minimal example that still reproduces the issue. That would help us a lot in fixing it quickly and effectively!
+
+If you want to ask a question about the tool (how to use it, what it can currently do, etc.), try the `#general` channel on our Slack first. We have a welcoming community and chances are you'll get your reply faster and without opening an issue.
+
+Other than that, thanks for taking the time to contribute to Spack! -->

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,58 +0,0 @@
-name: "\U0001F41E Bug report"
-description: Report a bug in the core of Spack (command not working as expected, etc.)
-labels: [bug, triage]
-body:
-  - type: textarea
-    id: reproduce
-    attributes:
-      label: Steps to reproduce
-      description: |
-        Explain, in a clear and concise way, the command you ran and the result you were trying to achieve.
-        Example: "I ran `spack find` to list all the installed packages and ..."
-      placeholder: |
-        ```console
-        $ spack <command1> <spec>
-        $ spack <command2> <spec>
-        ...
-        ```
-    validations:
-      required: true
-  - type: textarea
-    id: error
-    attributes:
-      label: Error message
-      description: |
-        If Spack reported an error, provide the error message. If it did not report an error but the output appears incorrect, provide the incorrect output. If there was no error message and no output but the result is incorrect, describe how it does not match what you expect.
-      placeholder: |
-        ```console
-        $ spack --debug --stacktrace <command>
-        ```
-  - type: textarea
-    id: information
-    attributes:
-      label: Information on your system
-      description: Please include the output of `spack debug report`
-    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: checkboxes
-    id: checks
-    attributes:
-      label: General information
-      options:
-        - label: I have run `spack debug report` and reported the version of Spack/Python/Platform
-          required: true
-        - label: I have searched the issues of this repo and believe this is not a duplicate
-          required: true
-        - label: I have run the failing commands in debug mode and reported the output
-          required: true
-  - type: markdown
-    attributes:
-      value: |
-        We encourage you to try, as much as possible, to reduce your problem to the minimal example that still reproduces the issue. That would help us a lot in fixing it quickly and effectively!
-        If you want to ask a question about the tool (how to use it, what it can currently do, etc.), try the `#general` channel on [our Slack](https://slack.spack.io/) first. We have a welcoming community and chances are you'll get your reply faster and without opening an issue.
-        
-        Other than that, thanks for taking the time to contribute to Spack!

.github/ISSUE_TEMPLATE/build_error.md

@@ -0,0 +1,43 @@
+---
+name: "\U0001F4A5 Build error"
+about: Some package in Spack didn't build correctly
+title: "Installation issue: "
+labels: "build-error"
+---
+
+<!-- Thanks for taking the time to report this build failure. To proceed with the report please:
+
+1. Title the issue "Installation issue: <name-of-the-package>".
+2. Provide the information required below.
+
+We encourage you to try, as much as possible, to reduce your problem to the minimal example that still reproduces the issue. That would help us a lot in fixing it quickly and effectively! -->
+
+### Steps to reproduce the issue
+
+<!-- Fill in the exact spec you are trying to build and the relevant part of the error message -->
+```console
+$ spack install <spec>
+...
+```
+
+### Information on your system
+
+<!-- Please include the output of `spack debug report` -->
+
+<!-- If you have any relevant configuration detail (custom `packages.yaml` or `modules.yaml`, etc.) you can add that here as well. -->
+
+### Additional information
+
+<!-- Please upload the following files. They should be present in the stage directory of the failing build. Also upload any config.log or similar file if one exists. -->
+* [spack-build-out.txt]()
+* [spack-build-env.txt]()
+
+<!-- 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. -->
+
+### General information
+
+<!-- These boxes can be checked by replacing [ ] with [x] or by clicking them after submitting the issue. -->
+- [ ] I have run `spack debug report` and reported the version of Spack/Python/Platform
+- [ ] I have run `spack maintainers <name-of-the-package>` and @mentioned any maintainers
+- [ ] I have uploaded the build log and environment files
+- [ ] I have searched the issues of this repo and believe this is not a duplicate

.github/ISSUE_TEMPLATE/build_error.yml

@@ -1,74 +0,0 @@
-name: "\U0001F4A5 Build error"
-description: Some package in Spack didn't build correctly
-title: "Installation issue: "
-labels: [build-error]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Thanks for taking the time to report this build failure. To proceed with the report please:
-        1. Title the issue `Installation issue: <name-of-the-package>`.
-        2. Provide the information required below.
-        
-        We encourage you to try, as much as possible, to reduce your problem to the minimal example that still reproduces the issue. That would help us a lot in fixing it quickly and effectively!
-  - type: textarea
-    id: reproduce
-    attributes:
-      label: Steps to reproduce the issue
-      description: |
-        Fill in the console output from the exact spec you are trying to build.
-      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
-      description: Please include the output of `spack debug report`.
-    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 the following files:
-        * **`spack-build-out.txt`**
-        * **`spack-build-env.txt`**
-        
-        They should be present in the stage directory of the failing build. Also upload any `config.log` or similar file if one exists.
-  - type: markdown
-    attributes:
-      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 run `spack debug report` and reported the version of Spack/Python/Platform
-          required: true
-        - label: I have run `spack maintainers <name-of-the-package>` and **@mentioned** any maintainers
-          required: true
-        - label: I have uploaded the build log and environment files
-          required: true
-        - label: I have searched the issues of this repo and believe this is not a duplicate
-          required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -1 +0,0 @@
-blank_issues_enabled: true

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,33 @@
+---
+name: "\U0001F38A Feature request" 
+about: Suggest adding a feature that is not yet in Spack  
+labels: feature
+
+---
+
+<!--*Please add a concise summary of your suggestion here.*-->
+
+### Rationale
+
+<!--*Is your feature request related to a problem? Please describe it!*-->
+
+### Description
+
+<!--*Describe the solution you'd like and the alternatives you have considered.*-->
+
+
+### Additional information
+<!--*Add any other context about the feature request here.*-->
+
+
+### General information
+
+- [ ] I have run `spack --version` and reported the version of Spack
+- [ ] I have searched the issues of this repo and believe this is not a duplicate
+
+
+
+<!--If you want to ask a question about the tool (how to use it, what it can currently do, etc.), try the `#general` channel on our Slack first. We have a welcoming community and chances are you'll get your reply faster and without opening an issue.
+
+Other than that, thanks for taking the time to contribute to Spack!
+-->

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -1,41 +0,0 @@
-name: "\U0001F38A Feature request" 
-description: Suggest adding a feature that is not yet in Spack
-labels: [feature]
-body:
-  - type: textarea
-    id: summary
-    attributes:
-      label: Summary
-      description: Please add a concise summary of your suggestion here.
-    validations:
-      required: true
-  - type: textarea
-    id: rationale
-    attributes:
-      label: Rationale
-      description: Is your feature request related to a problem? Please describe it!
-  - type: textarea
-    id: description
-    attributes:
-      label: Description
-      description: Describe the solution you'd like and the alternatives you have considered.
-  - type: textarea
-    id: additional_information
-    attributes:
-      label: Additional information
-      description: Add any other context about the feature request here.
-  - type: checkboxes
-    id: checks
-    attributes:
-      label: General information
-      options:
-        - label: I have run `spack --version` and reported the version of Spack
-          required: true
-        - label: I have searched the issues of this repo and believe this is not a duplicate
-          required: true
-  - type: markdown
-    attributes:
-      value: |
-        If you want to ask a question about the tool (how to use it, what it can currently do, etc.), try the `#general` channel on [our Slack](https://slack.spack.io/) first. We have a welcoming community and chances are you'll get your reply faster and without opening an issue.
-        
-        Other than that, thanks for taking the time to contribute to Spack!

.github/ISSUE_TEMPLATE/test_error.yml

@@ -1,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/actions/add-maintainers-as-reviewers/Dockerfile

@@ -0,0 +1,6 @@
+FROM python:3.7-alpine
+
+RUN pip install pygithub
+
+ADD entrypoint.py /entrypoint.py
+ENTRYPOINT ["/entrypoint.py"]

.github/actions/add-maintainers-as-reviewers/entrypoint.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+#
+# Copyright 2013-2020 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)
+
+"""Maintainer review action.
+
+This action checks which packages have changed in a PR, and adds their
+maintainers to the pull request for review.
+"""
+
+import json
+import os
+import re
+import subprocess
+
+from github import Github
+
+
+def spack(*args):
+    """Run the spack executable with arguments, and return the output split.
+
+    This does just enough to run `spack pkg` and `spack maintainers`, the
+    two commands used by this action.
+    """
+    github_workspace = os.environ['GITHUB_WORKSPACE']
+    spack = os.path.join(github_workspace, 'bin', 'spack')
+    output = subprocess.check_output([spack] + list(args))
+    split = re.split(r'\s*', output.decode('utf-8').strip())
+    return [s for s in split if s]
+
+
+def main():
+    # get these first so that we'll fail early
+    token = os.environ['GITHUB_TOKEN']
+    event_path = os.environ['GITHUB_EVENT_PATH']
+
+    with open(event_path) as file:
+        data = json.load(file)
+
+    # make sure it's a pull_request event
+    assert 'pull_request' in data
+
+    # only request reviews on open, edit, or reopen
+    action = data['action']
+    if action not in ('opened', 'edited', 'reopened'):
+        return
+
+    # get data from the event payload
+    pr_data             = data['pull_request']
+    base_branch_name    = pr_data['base']['ref']
+    full_repo_name      = pr_data['base']['repo']['full_name']
+    pr_number           = pr_data['number']
+    requested_reviewers = pr_data['requested_reviewers']
+    author              = pr_data['user']['login']
+
+    # get a list of packages that this PR modified
+    changed_pkgs = spack(
+        'pkg', 'changed', '--type', 'ac', '%s...' % base_branch_name)
+
+    # get maintainers for all modified packages
+    maintainers = set()
+    for pkg in changed_pkgs:
+        pkg_maintainers = set(spack('maintainers', pkg))
+        maintainers |= pkg_maintainers
+
+    # remove any maintainers who are already on the PR, and the author,
+    # as you can't review your own PR)
+    maintainers -= set(requested_reviewers)
+    maintainers -= set([author])
+
+    if not maintainers:
+        return
+
+    # request reviews from each maintainer
+    gh = Github(token)
+    repo = gh.get_repo(full_repo_name)
+    pr = repo.get_pull(pr_number)
+    pr.create_review_request(list(maintainers))
+
+
+if __name__ == "__main__":
+    main()

.github/dependabot.yml

@@ -1,7 +0,0 @@
-version: 2
-updates:
-  # Maintain dependencies for GitHub Actions
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "daily"

.github/workflows/audit.yaml

@@ -1,44 +0,0 @@
-name: audit
-
-on:
-  workflow_call:
-    inputs:
-      with_coverage:
-        required: true
-        type: string
-      python_version:
-        required: true
-        type: string
-
-concurrency:
-  group: audit-${{inputs.python_version}}-${{github.ref}}-${{github.event.pull_request.number || github.run_number}}
-  cancel-in-progress: true
-
-jobs:
-  # Run audits on all the packages in the built-in repository
-  package-audits:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@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]<=6.2'
-    - 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

@@ -1,352 +0,0 @@
-name: Bootstrapping
-
-on:
-  # This Workflow can be triggered manually
-  workflow_dispatch:
-  workflow_call:
-  schedule:
-    # nightly at 2:16 AM
-    - cron: '16 2 * * *'
-
-concurrency:
-  group: bootstrap-${{github.ref}}-${{github.event.pull_request.number || github.run_number}}
-  cancel-in-progress: true
-
-jobs:
-  fedora-clingo-sources:
-    runs-on: ubuntu-latest
-    container: "fedora:latest"
-    steps:
-      - name: Install dependencies
-        run: |
-          dnf install -y \
-              bzip2 curl file gcc-c++ gcc gcc-gfortran git gnupg2 gzip \
-              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
-      - name: Setup non-root user
-        run: |
-          # See [1] below
-          git config --global --add safe.directory /__w/spack/spack
-          useradd spack-test && mkdir -p ~spack-test
-          chown -R spack-test . ~spack-test
-      - name: Setup repo
-        shell: runuser -u spack-test -- bash {0}
-        run: |
-          git --version
-          . .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 external find cmake bison
-          spack -d solve zlib
-          tree ~/.spack/bootstrap/store/
-
-  ubuntu-clingo-sources:
-    runs-on: ubuntu-latest
-    container: "ubuntu:latest"
-    steps:
-      - name: Install dependencies
-        env:
-          DEBIAN_FRONTEND: noninteractive
-        run: |
-          apt-get update -y && apt-get upgrade -y
-          apt-get install -y \
-              bzip2 curl file g++ gcc gfortran git gnupg2 gzip \
-              make patch unzip xz-utils python3 python3-dev tree \
-              cmake bison
-      - name: Checkout
-        uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
-        with:
-          fetch-depth: 0
-      - name: Setup non-root user
-        run: |
-          # See [1] below
-          git config --global --add safe.directory /__w/spack/spack
-          useradd spack-test && mkdir -p ~spack-test
-          chown -R spack-test . ~spack-test
-      - name: Setup repo
-        shell: runuser -u spack-test -- bash {0}
-        run: |
-          git --version
-          . .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 external find cmake bison
-          spack -d solve zlib
-          tree ~/.spack/bootstrap/store/
-
-  ubuntu-clingo-binaries-and-patchelf:
-    runs-on: ubuntu-latest
-    container: "ubuntu:latest"
-    steps:
-      - name: Install dependencies
-        env:
-          DEBIAN_FRONTEND: noninteractive
-        run: |
-          apt-get update -y && apt-get upgrade -y
-          apt-get install -y \
-              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
-      - name: Setup non-root user
-        run: |
-          # See [1] below
-          git config --global --add safe.directory /__w/spack/spack
-          useradd spack-test && mkdir -p ~spack-test
-          chown -R spack-test . ~spack-test
-      - name: Setup repo
-        shell: runuser -u spack-test -- bash {0}
-        run: |
-          git --version
-          . .github/workflows/setup_git.sh
-      - name: Bootstrap clingo
-        shell: runuser -u spack-test -- bash {0}
-        run: |
-          source share/spack/setup-env.sh
-          spack -d solve zlib
-          tree ~/.spack/bootstrap/store/
-
-  opensuse-clingo-sources:
-    runs-on: ubuntu-latest
-    container: "opensuse/leap:latest"
-    steps:
-      - name: Install dependencies
-        run: |
-          # Harden CI by applying the workaround described here: https://www.suse.com/support/kb/doc/?id=000019505
-          zypper update -y || zypper update -y
-          zypper install -y \
-              bzip2 curl file gcc-c++ gcc gcc-fortran tar git gpg2 gzip \
-              make patch unzip which xz python3 python3-devel tree \
-              cmake bison
-      - name: Checkout
-        uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
-        with:
-          fetch-depth: 0
-      - name: Setup repo
-        run: |
-          # See [1] below
-          git config --global --add safe.directory /__w/spack/spack
-          git --version
-          . .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 external find cmake bison
-          spack -d solve zlib
-          tree ~/.spack/bootstrap/store/
-
-  macos-clingo-sources:
-    runs-on: macos-latest
-    steps:
-      - name: Install dependencies
-        run: |
-          brew install cmake bison@2.7 tree
-      - name: Checkout
-        uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
-      - 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 external find --not-buildable cmake bison
-          spack -d solve zlib
-          tree ~/.spack/bootstrap/store/
-
-  macos-clingo-binaries:
-    runs-on: ${{ matrix.macos-version }}
-    strategy:
-      matrix:
-        macos-version: ['macos-11', 'macos-12']
-    steps:
-      - name: Install dependencies
-        run: |
-          brew install tree
-      - name: Checkout
-        uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
-      - 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
-
-  ubuntu-clingo-binaries:
-    runs-on: ubuntu-20.04
-    steps:
-      - name: Checkout
-        uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
-        with:
-          fetch-depth: 0
-      - name: Setup repo
-        run: |
-          git --version
-          . .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
-
-  ubuntu-gnupg-binaries:
-    runs-on: ubuntu-latest
-    container: "ubuntu:latest"
-    steps:
-      - name: Install dependencies
-        env:
-          DEBIAN_FRONTEND: noninteractive
-        run: |
-          apt-get update -y && apt-get upgrade -y
-          apt-get install -y \
-              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
-      - name: Setup non-root user
-        run: |
-          # See [1] below
-          git config --global --add safe.directory /__w/spack/spack
-          useradd spack-test && mkdir -p ~spack-test
-          chown -R spack-test . ~spack-test
-      - name: Setup repo
-        shell: runuser -u spack-test -- bash {0}
-        run: |
-          git --version
-          . .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 -d gpg list
-          tree ~/.spack/bootstrap/store/
-
-  ubuntu-gnupg-sources:
-    runs-on: ubuntu-latest
-    container: "ubuntu:latest"
-    steps:
-      - name: Install dependencies
-        env:
-          DEBIAN_FRONTEND: noninteractive
-        run: |
-          apt-get update -y && apt-get upgrade -y
-          apt-get install -y \
-              bzip2 curl file g++ gcc patchelf gfortran git gzip \
-              make patch unzip xz-utils python3 python3-dev tree \
-              gawk
-      - name: Checkout
-        uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
-        with:
-          fetch-depth: 0
-      - name: Setup non-root user
-        run: |
-          # See [1] below
-          git config --global --add safe.directory /__w/spack/spack
-          useradd spack-test && mkdir -p ~spack-test
-          chown -R spack-test . ~spack-test
-      - name: Setup repo
-        shell: runuser -u spack-test -- bash {0}
-        run: |
-          git --version
-          . .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 -d gpg list
-          tree ~/.spack/bootstrap/store/
-
-  macos-gnupg-binaries:
-    runs-on: macos-latest
-    steps:
-      - name: Install dependencies
-        run: |
-          brew install tree
-          # Remove GnuPG since we want to bootstrap it
-          sudo rm -rf /usr/local/bin/gpg
-      - name: Checkout
-        uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
-      - name: Bootstrap GnuPG
-        run: |
-          source share/spack/setup-env.sh
-          spack bootstrap disable spack-install
-          spack -d gpg list
-          tree ~/.spack/bootstrap/store/
-
-  macos-gnupg-sources:
-    runs-on: macos-latest
-    steps:
-      - name: Install dependencies
-        run: |
-          brew install gawk tree
-          # Remove GnuPG since we want to bootstrap it
-          sudo rm -rf /usr/local/bin/gpg
-      - name: Checkout
-        uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
-      - 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 -d gpg list
-          tree ~/.spack/bootstrap/store/
-
-
-# [1] Distros that have patched git to resolve CVE-2022-24765 (e.g. Ubuntu patching v2.25.1)
-#     introduce breaking behaviorso we have to set `safe.directory` in gitconfig ourselves.
-#     See:
-#     - https://github.blog/2022-04-12-git-security-vulnerability-announced/
-#     - https://github.com/actions/checkout/issues/760
-#     - http://changelogs.ubuntu.com/changelogs/pool/main/g/git/git_2.25.1-1ubuntu3.3/changelog

.github/workflows/build-containers.yml

@@ -1,120 +0,0 @@
-name: Containers
-
-on:
-  # This Workflow can be triggered manually
-  workflow_dispatch:
-  # Build new Spack develop containers nightly.
-  schedule:
-    - cron: '34 0 * * *'
-  # Run on pull requests that modify this file
-  pull_request:
-    branches:
-      - develop
-    paths:
-      - '.github/workflows/build-containers.yml'
-      - 'share/spack/docker/*'
-      - 'share/spack/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}}
-  cancel-in-progress: true
-
-jobs:
-  deploy-images:
-    runs-on: ubuntu-latest
-    permissions:
-      packages: write
-    strategy:
-      # Even if one container fails to build we still want the others
-      # to continue their builds.
-      fail-fast: false
-      # A matrix of Dockerfile paths, associated tags, and which architectures
-      # they support.
-      matrix:
-        # Meaning of the various items in the matrix list
-        # 0: Container name (e.g. ubuntu-bionic)
-        # 1: Platforms to build for
-        # 2: Base image (e.g. ubuntu:18.04)
-        dockerfile: [[amazon-linux, 'linux/amd64,linux/arm64', 'amazonlinux:2'],
-                     [centos7, 'linux/amd64,linux/arm64,linux/ppc64le', 'centos:7'],
-                     [centos-stream, 'linux/amd64,linux/arm64,linux/ppc64le', 'centos:stream'],
-                     [leap15, 'linux/amd64,linux/arm64,linux/ppc64le', 'opensuse/leap:15'],
-                     [ubuntu-bionic, 'linux/amd64,linux/arm64,linux/ppc64le', 'ubuntu:18.04'],
-                     [ubuntu-focal, 'linux/amd64,linux/arm64,linux/ppc64le', 'ubuntu:20.04'],
-                     [ubuntu-jammy, 'linux/amd64,linux/arm64,linux/ppc64le', 'ubuntu:22.04']]
-    name: Build ${{ matrix.dockerfile[0] }}
-    if: github.repository == 'spack/spack'
-    steps:
-      - name: Checkout
-        uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 # @v2
-
-      - name: Set Container Tag Normal (Nightly)
-        run: |
-          container="${{ matrix.dockerfile[0] }}:latest"
-          echo "container=${container}" >> $GITHUB_ENV
-          echo "versioned=${container}" >> $GITHUB_ENV
-
-        # On a new release create a container with the same tag as the release.
-      - name: Set Container Tag on Release
-        if: github.event_name == 'release'
-        run: |
-          versioned="${{matrix.dockerfile[0]}}:${GITHUB_REF##*/}"
-          echo "versioned=${versioned}" >> $GITHUB_ENV
-
-      - name: Generate the Dockerfile
-        env:
-          SPACK_YAML_OS: "${{ matrix.dockerfile[2] }}"
-        run: |
-          .github/workflows/generate_spack_yaml_containerize.sh
-          . share/spack/setup-env.sh
-          mkdir -p dockerfiles/${{ matrix.dockerfile[0] }}
-          spack containerize --last-stage=bootstrap | tee dockerfiles/${{ matrix.dockerfile[0] }}/Dockerfile
-          printf "Preparing to build ${{ env.container }} from dockerfiles/${{ matrix.dockerfile[0] }}/Dockerfile"
-          if [ ! -f "dockerfiles/${{ matrix.dockerfile[0] }}/Dockerfile" ]; then
-              printf "dockerfiles/${{ matrix.dockerfile[0] }}/Dockerfile does not exist"
-              exit 1;
-          fi
-
-      - name: Upload Dockerfile
-        uses: actions/upload-artifact@3cea5372237819ed00197afe530f5a7ea3e805c8
-        with:
-          name: dockerfiles
-          path: dockerfiles
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@8b122486cedac8393e77aa9734c3528886e4a1a8 # @v1
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@c74574e6c82eeedc46366be1b0d287eff9085eb6 # @v1
-
-      - name: Log in to GitHub Container Registry
-        uses: docker/login-action@f4ef78c080cd8ba55a85445d5b36e214a81df20a # @v1
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Log in to DockerHub
-        if: github.event_name != 'pull_request'
-        uses: docker/login-action@f4ef78c080cd8ba55a85445d5b36e214a81df20a # @v1
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Build & Deploy ${{ matrix.dockerfile[0] }}
-        uses: docker/build-push-action@c84f38281176d4c9cdb1626ffafcd6b3911b5d94 # @v2
-        with:
-          context: dockerfiles/${{ matrix.dockerfile[0] }}
-          platforms: ${{ matrix.dockerfile[1] }}
-          push: ${{ github.event_name != 'pull_request' }}
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
-          tags: |
-            spack/${{ env.container }}
-            spack/${{ env.versioned }}
-            ghcr.io/spack/${{ env.container }}
-            ghcr.io/spack/${{ env.versioned }}

.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@b2feaf19c27470162a626bd6fa8438ae5b263721
-        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/execute_installer.ps1

@@ -1,7 +0,0 @@
-$ proc = Start-Process  ${{ env.spack_installer }}\spack.exe "/install /quiet" -Passthru
-$handle = $proc.Handle # cache proc.Handle
-$proc.WaitForExit();
-
-if ($proc.ExitCode -ne 0) {
-    Write-Warning "$_ exited with status code $($proc.ExitCode)"
-}

.github/workflows/generate_spack_yaml_containerize.sh

@@ -1,9 +0,0 @@
-#!/bin/bash
-    (echo "spack:" \
-&&   echo "  specs: []" \
-&&   echo "  container:" \
-&&   echo "    format: docker" \
-&&   echo "    images:" \
-&&   echo "      os: \"${SPACK_YAML_OS}\"" \
-&&   echo "      spack:" \
-&&   echo "        ref: ${GITHUB_REF}") > spack.yaml

.github/workflows/install_spack.sh

@@ -2,7 +2,19 @@
 . share/spack/setup-env.sh
 echo -e "config:\n  build_jobs: 2" > etc/spack/config.yaml
 spack config add "packages:all:target:[x86_64]"
-spack compiler find
+# TODO: remove this explicit setting once apple-clang detection is fixed
+cat <<EOF > etc/spack/compilers.yaml
+compilers:
+- compiler:
+    spec: apple-clang@11.0.3
+    paths:
+      cc: /usr/bin/clang
+      cxx: /usr/bin/clang++
+      f77: /usr/local/bin/gfortran-9
+      fc: /usr/local/bin/gfortran-9
+    modules: []
+    operating_system: catalina
+    target: x86_64
+EOF
 spack compiler info apple-clang
 spack debug report
-spack solve zlib

.github/workflows/linux_build_tests.yaml

@@ -0,0 +1,65 @@
+name: linux builds
+
+on:
+  push:
+    branches:
+    - develop
+    - releases/**
+  pull_request:
+    branches:
+    - develop
+    - releases/**
+    paths-ignore:
+      # Don't run if we only modified packages in the built-in repository
+      - 'var/spack/repos/builtin/**'
+      - '!var/spack/repos/builtin/packages/lz4/**'
+      - '!var/spack/repos/builtin/packages/mpich/**'
+      - '!var/spack/repos/builtin/packages/tut/**'
+      - '!var/spack/repos/builtin/packages/py-setuptools/**'
+      - '!var/spack/repos/builtin/packages/openjpeg/**'
+      - '!var/spack/repos/builtin/packages/r-rcpp/**'
+      - '!var/spack/repos/builtin/packages/ruby-rake/**'
+      # Don't run if we only modified documentation
+      - 'lib/spack/docs/**'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        package:
+        - lz4  # MakefilePackage
+        - mpich  # AutotoolsPackage
+        - tut  # WafPackage
+        - py-setuptools  # PythonPackage
+        - openjpeg  # CMakePackage
+        - r-rcpp  # RPackage
+        - ruby-rake  # RubyPackage
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions/cache@v2
+      with:
+        path: ~/.ccache
+        key: ccache-build-${{ matrix.package }}
+        restore-keys: |
+          ccache-build-${{ matrix.package }}
+    - uses: actions/setup-python@v2
+      with:
+        python-version: 3.8
+    - name: Install System Packages
+      run: |
+        sudo apt-get update
+        sudo apt-get -yqq install ccache gfortran perl perl-base r-base r-base-core r-base-dev ruby findutils openssl libssl-dev libpciaccess-dev
+        R --version
+        perl --version
+        ruby --version
+    - name: Copy Configuration
+      run: |
+        ccache -M 300M && ccache -z
+        # Set up external deps for build tests, b/c they take too long to compile
+        cp share/spack/qa/configuration/*.yaml etc/spack/
+    - name: Run the build test
+      run: |
+        . share/spack/setup-env.sh
+        SPEC=${{ matrix.package }} share/spack/qa/run-build-tests
+        ccache -s

.github/workflows/linux_unit_tests.yaml

@@ -0,0 +1,114 @@
+name: linux tests
+
+on:
+  push:
+    branches:
+      - develop
+      - releases/**
+  pull_request:
+    branches:
+      - develop
+      - releases/**
+jobs:
+  unittests:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [2.7, 3.5, 3.6, 3.7, 3.8]
+
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        fetch-depth: 0
+    - uses: actions/setup-python@v2
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install System packages
+      run: |
+          sudo apt-get -y update
+          sudo apt-get install -y coreutils gfortran graphviz gnupg2 mercurial ninja-build patchelf
+          # Needed for kcov
+          sudo apt-get -y install cmake binutils-dev libcurl4-openssl-dev zlib1g-dev libdw-dev libiberty-dev
+    - name: Install Python packages
+      run: |
+          pip install --upgrade pip six setuptools codecov coverage
+    - name: Setup git configuration
+      run: |
+          # Need this for the git tests to succeed.
+          git --version
+          . .github/workflows/setup_git.sh
+    - name: Install kcov for bash script coverage
+      env:
+          KCOV_VERSION: 34
+      run: |
+          KCOV_ROOT=$(mktemp -d)
+          wget --output-document=${KCOV_ROOT}/${KCOV_VERSION}.tar.gz https://github.com/SimonKagstrom/kcov/archive/v${KCOV_VERSION}.tar.gz
+          tar -C ${KCOV_ROOT} -xzvf ${KCOV_ROOT}/${KCOV_VERSION}.tar.gz
+          mkdir -p ${KCOV_ROOT}/build
+          cd ${KCOV_ROOT}/build && cmake -Wno-dev ${KCOV_ROOT}/kcov-${KCOV_VERSION} && cd -
+          make -C ${KCOV_ROOT}/build && sudo  make -C ${KCOV_ROOT}/build install
+    - name: Run unit tests
+      env:
+          COVERAGE: true
+      run: |
+          share/spack/qa/run-unit-tests
+          coverage combine
+          coverage xml
+    - uses: codecov/codecov-action@v1
+      with:
+        flags: unittests,linux
+  shell:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        fetch-depth: 0
+    - uses: actions/setup-python@v2
+      with:
+        python-version: 3.8
+    - name: Install System packages
+      run: |
+          sudo apt-get -y update
+          sudo apt-get install -y coreutils gfortran gnupg2 mercurial ninja-build patchelf zsh fish
+          # Needed for kcov
+          sudo apt-get -y install cmake binutils-dev libcurl4-openssl-dev zlib1g-dev libdw-dev libiberty-dev
+    - name: Install Python packages
+      run: |
+          pip install --upgrade pip six setuptools codecov coverage
+    - name: Setup git configuration
+      run: |
+          # Need this for the git tests to succeed.
+          git --version
+          . .github/workflows/setup_git.sh
+    - name: Install kcov for bash script coverage
+      env:
+          KCOV_VERSION: 38
+      run: |
+          KCOV_ROOT=$(mktemp -d)
+          wget --output-document=${KCOV_ROOT}/${KCOV_VERSION}.tar.gz https://github.com/SimonKagstrom/kcov/archive/v${KCOV_VERSION}.tar.gz
+          tar -C ${KCOV_ROOT} -xzvf ${KCOV_ROOT}/${KCOV_VERSION}.tar.gz
+          mkdir -p ${KCOV_ROOT}/build
+          cd ${KCOV_ROOT}/build && cmake -Wno-dev ${KCOV_ROOT}/kcov-${KCOV_VERSION} && cd -
+          make -C ${KCOV_ROOT}/build && sudo  make -C ${KCOV_ROOT}/build install
+    - name: Run shell tests
+      env:
+          COVERAGE: true
+      run: |
+          share/spack/qa/run-shell-tests
+    - uses: codecov/codecov-action@v1
+      with:
+        flags: shelltests,linux
+  centos6:
+    # Test for Python2.6 run on Centos 6
+    runs-on: ubuntu-latest
+    container: spack/github-actions:centos6
+    steps:
+    - name: Run unit tests
+      env:
+          HOME: /home/spack-test
+      run: |
+          whoami && echo $HOME && cd $HOME
+          git clone https://github.com/spack/spack.git && cd spack
+          git fetch origin ${{ github.ref }}:test-branch
+          git checkout test-branch
+          share/spack/qa/run-unit-tests

.github/workflows/macos_python.yml

@@ -0,0 +1,79 @@
+# These are nightly package tests for macOS
+# focus areas:
+# - initial user experience
+# - scientific python stack
+name: macOS builds nightly
+
+on:
+  schedule:
+    # nightly at 1 AM
+    - cron: '0 1 * * *'
+  pull_request:
+    branches:
+    - develop
+    paths:
+      # Run if we modify this yaml file
+      - '.github/workflows/macos_python.yml'
+      # TODO: run if we touch any of the recipes involved in this
+
+# GitHub Action Limits
+# https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+
+jobs:
+  install_gcc:
+    name: gcc with clang
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions/setup-python@v2
+      with:
+        python-version: 3.8
+    - name: spack install
+      run: |
+        . .github/workflows/install_spack.sh
+        # 9.2.0 is the latest version on which we apply homebrew patch
+        spack install -v --fail-fast gcc@9.2.0 %apple-clang
+
+  install_jupyter_clang:
+    name: jupyter
+    runs-on: macos-latest
+    timeout-minutes: 700
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions/setup-python@v2
+      with:
+        python-version: 3.8
+    - name: spack install
+      run: |
+        . .github/workflows/install_spack.sh
+        spack config add packages:opengl:paths:opengl@4.1:/usr/X11R6
+        spack install -v --fail-fast py-jupyter %apple-clang
+
+  install_scipy_clang:
+    name: scipy, mpl, pd
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions/setup-python@v2
+      with:
+        python-version: 3.8
+    - name: spack install
+      run: |
+        . .github/workflows/install_spack.sh
+        spack install -v --fail-fast py-scipy %apple-clang
+        spack install -v --fail-fast py-matplotlib %apple-clang
+        spack install -v --fail-fast py-pandas %apple-clang
+
+  install_mpi4py_clang:
+    name: mpi4py, petsc4py
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions/setup-python@v2
+      with:
+        python-version: 3.8
+    - name: spack install
+      run: |
+        . .github/workflows/install_spack.sh
+        spack install -v --fail-fast py-mpi4py %apple-clang
+        spack install -v --fail-fast py-petsc4py %apple-clang

.github/workflows/macos_unit_tests.yaml

@@ -0,0 +1,41 @@
+name: macos tests
+
+on:
+  push:
+    branches:
+      - develop
+      - releases/**
+  pull_request:
+    branches:
+      - develop
+      - releases/**
+jobs:
+  build:
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        fetch-depth: 0
+    - uses: actions/setup-python@v2
+      with:
+        python-version: 3.8
+    - name: Install Python packages
+      run: |
+          pip install --upgrade pip six setuptools
+          pip install --upgrade codecov coverage
+          pip install --upgrade flake8 pep8-naming
+    - name: Setup Homebrew packages
+      run: |
+        brew install gcc gnupg2 dash kcov
+    - name: Run unit tests
+      run: |
+        git --version
+        . .github/workflows/setup_git.sh
+        . share/spack/setup-env.sh
+        coverage run $(which spack) unit-test
+        coverage combine
+        coverage xml
+    - uses: codecov/codecov-action@v1
+      with:
+        file: ./coverage.xml
+        flags: unittests,macos

.github/workflows/setup_git.ps1

@@ -1,16 +0,0 @@
-# (c) 2021 Lawrence Livermore National Laboratory
-
-Set-Location spack
-
-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

@@ -1,12 +1,9 @@
-#!/bin/bash -e
+#!/usr/bin/env sh
 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}"
+# With fetch-depth: 0 we have a remote develop
+# but not a local branch. Don't do this on develop
+if [ "$(git branch --show-current)" != "develop" ]
+then
+  git branch develop origin/develop
 fi

.github/workflows/style_and_docs.yaml

@@ -0,0 +1,65 @@
+name: style and docs
+
+on:
+  push:
+    branches:
+      - develop
+      - releases/**
+  pull_request:
+    branches:
+      - develop
+      - releases/**
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions/setup-python@v2
+      with:
+        python-version: 3.8
+    - name: Install Python Packages
+      run: |
+        pip install --upgrade pip
+        pip install --upgrade vermin
+    - name: Minimum Version (Spack's Core)
+      run: vermin --backport argparse -t=2.6- -t=3.5- -v lib/spack/spack/ lib/spack/llnl/ bin/
+    - name: Minimum Version (Repositories)
+      run: vermin --backport argparse -t=2.6- -t=3.5- -v var/spack/repos
+  flake8:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        fetch-depth: 0
+    - uses: actions/setup-python@v2
+      with:
+        python-version: 3.8
+    - name: Install Python packages
+      run: |
+        pip install --upgrade pip six setuptools flake8
+    - name: Setup git configuration
+      run: |
+        # Need this for the git tests to succeed.
+        git --version
+        . .github/workflows/setup_git.sh
+    - name: Run flake8 tests
+      run: |
+          share/spack/qa/run-flake8-tests
+  documentation:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions/setup-python@v2
+      with:
+        python-version: 3.8
+    - name: Install System packages
+      run: |
+        sudo apt-get -y update
+        sudo apt-get install -y coreutils ninja-build graphviz
+    - name: Install Python packages
+      run: |
+        pip install --upgrade pip six setuptools
+        pip install --upgrade -r lib/spack/docs/requirements.txt
+    - name: Build documentation
+      run: |
+          share/spack/qa/run-doc-tests

.github/workflows/system_shortcut_check.ps1

@@ -1,4 +0,0 @@
-param ($systemFolder, $shortcut)
-
-$start = [System.Environment]::GetFolderPath("$systemFolder")
-Invoke-Item "$start\Programs\Spack\$shortcut"

.github/workflows/unit_tests.yaml

@@ -1,220 +0,0 @@
-name: unit tests
-
-on:
-  workflow_dispatch:
-  workflow_call:
-
-concurrency:
-  group: unit_tests-${{github.ref}}-${{github.event.pull_request.number || github.run_number}}
-  cancel-in-progress: true
-
-jobs:
-  # Run unit tests with different configurations on linux
-  ubuntu:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        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.10'
-          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
-
-    steps:
-    - uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 # @v2
-      with:
-        fetch-depth: 0
-    - uses: actions/setup-python@13ae5bb136fac2878aff31522b9efb785519f984 # @v2
-      with:
-        python-version: ${{ matrix.python-version }}
-    - name: Install System packages
-      run: |
-          sudo apt-get -y update
-          # Needed for unit tests
-          sudo apt-get -y install \
-              coreutils cvs gfortran graphviz gnupg2 mercurial ninja-build \
-              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
-          # ensure style checks are not skipped in unit tests for python >= 3.6
-          # note that true/false (i.e., 1/0) are opposite in conditions in python and bash
-          if python -c 'import sys; sys.exit(not sys.version_info >= (3, 6))'; then
-              pip install --upgrade flake8 "isort>=4.3.5" "mypy>=0.900" "click==8.0.4" "black<=21.12b0"
-          fi
-    - name: Pin pathlib for Python 2.7
-      if: ${{ matrix.python-version == 2.7 }}
-      run: |
-          pip install -U pathlib2==2.3.6 toml
-    - name: Setup git configuration
-      run: |
-          # Need this for the git tests to succeed.
-          git --version
-          . .github/workflows/setup_git.sh
-    - name: Bootstrap clingo
-      if: ${{ matrix.concretizer == 'clingo' }}
-      env:
-          SPACK_PYTHON: python
-      run: |
-          . share/spack/setup-env.sh
-          spack bootstrap disable spack-install
-          spack -v solve zlib
-    - name: Run unit tests
-      env:
-          SPACK_PYTHON: python
-          SPACK_TEST_SOLVER: ${{ matrix.concretizer }}
-          SPACK_TEST_PARALLEL: 2
-          COVERAGE: true
-          UNIT_TEST_COVERAGE: ${{ (matrix.python-version == '3.10') }}
-      run: |
-          share/spack/qa/run-unit-tests
-    - uses: codecov/codecov-action@d9f34f8cd5cb3b3eb79b3e4b5dae3a16df499a70
-      with:
-        flags: unittests,linux,${{ matrix.concretizer }}
-  # Test shell integration
-  shell:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 # @v2
-      with:
-        fetch-depth: 0
-    - uses: actions/setup-python@13ae5bb136fac2878aff31522b9efb785519f984 # @v2
-      with:
-        python-version: '3.10'
-    - name: Install System packages
-      run: |
-          sudo apt-get -y update
-          # Needed for shell tests
-          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]==6.2 pytest-xdist
-    - name: Setup git configuration
-      run: |
-          # Need this for the git tests to succeed.
-          git --version
-          . .github/workflows/setup_git.sh
-    - name: Run shell tests
-      env:
-          COVERAGE: true
-      run: |
-          share/spack/qa/run-shell-tests
-    - uses: codecov/codecov-action@d9f34f8cd5cb3b3eb79b3e4b5dae3a16df499a70
-      with:
-        flags: shelltests,linux
-
-  # Test RHEL8 UBI with platform Python. This job is run
-  # only on PRs modifying core Spack
-  rhel8-platform-python:
-    runs-on: ubuntu-latest
-    container: registry.access.redhat.com/ubi8/ubi
-    steps:
-    - name: Install dependencies
-      run: |
-          dnf install -y \
-              bzip2 curl file gcc-c++ gcc gcc-gfortran git gnupg2 gzip \
-              make patch tcl unzip which xz
-    - uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 # @v2
-    - name: Setup repo and non-root user
-      run: |
-          git --version
-          git fetch --unshallow
-          . .github/workflows/setup_git.sh
-          useradd spack-test
-          chown -R spack-test .
-    - name: Run unit tests
-      shell: runuser -u spack-test -- bash {0}
-      run: |
-          source share/spack/setup-env.sh
-          spack -d solve zlib
-          spack unit-test -k 'not cvs and not svn and not hg' -x --verbose
-  # Test for the clingo based solver (using clingo-cffi)
-  clingo-cffi:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 # @v2
-      with:
-        fetch-depth: 0
-    - uses: actions/setup-python@13ae5bb136fac2878aff31522b9efb785519f984 # @v2
-      with:
-        python-version: '3.10'
-    - name: Install System packages
-      run: |
-          sudo apt-get -y update
-          # Needed for unit tests
-          sudo apt-get -y install \
-              coreutils cvs gfortran graphviz gnupg2 mercurial ninja-build \
-              patchelf kcov
-    - name: Install Python packages
-      run: |
-          pip install --upgrade pip six setuptools pytest codecov coverage[toml] pytest-cov clingo pytest-xdist
-    - 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)
-      env:
-          COVERAGE: true
-          SPACK_TEST_SOLVER: clingo
-      run: |
-          share/spack/qa/run-unit-tests
-    - uses: codecov/codecov-action@d9f34f8cd5cb3b3eb79b3e4b5dae3a16df499a70 # @v2.1.0
-      with:
-        flags: unittests,linux,clingo
-  # Run unit tests on MacOS
-  macos:
-    runs-on: macos-latest
-    strategy:
-      matrix:
-        python-version: ["3.10"]
-    steps:
-    - uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 # @v2
-      with:
-        fetch-depth: 0
-    - uses: actions/setup-python@13ae5bb136fac2878aff31522b9efb785519f984 # @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
-    - 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) 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
-      with:
-        flags: unittests,macos

.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.10'
-        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.10'
-        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.10'

.github/workflows/windows_python.yml

@@ -1,158 +0,0 @@
-name: windows
-
-on:
-  workflow_call:
-
-concurrency:
-  group: windows-${{github.ref}}-${{github.event.pull_request.number || github.run_number}}
-  cancel-in-progress: true
-
-defaults:
-  run:
-    shell:
-     powershell Invoke-Expression -Command ".\share\spack\qa\windows_test_setup.ps1"; {0}
-jobs:
-  unit-tests:
-    runs-on: windows-latest
-    steps:
-    - uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
-      with:
-        fetch-depth: 0
-    - uses: actions/setup-python@13ae5bb136fac2878aff31522b9efb785519f984
-      with:
-        python-version: 3.9
-    - name: Install Python packages
-      run: |
-          python -m pip install --upgrade pip six pywin32 setuptools codecov pytest-cov clingo
-    - 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:
-    runs-on: windows-latest
-    steps:
-    - uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
-      with:
-        fetch-depth: 0
-    - uses: actions/setup-python@13ae5bb136fac2878aff31522b9efb785519f984
-      with:
-        python-version: 3.9
-    - name: Install Python packages
-      run: |
-          python -m pip install --upgrade pip six pywin32 setuptools codecov coverage pytest-cov clingo
-    - 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:
-    runs-on: windows-latest
-    steps:
-    - uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
-      with:
-        fetch-depth: 0
-    - uses: actions/setup-python@13ae5bb136fac2878aff31522b9efb785519f984
-      with:
-        python-version: 3.9
-    - name: Install Python packages
-      run: |
-          python -m pip install --upgrade pip six pywin32 setuptools codecov coverage
-    - name: Build Test
-      run: |
-        spack compiler find
-        echo F|xcopy .\spack\share\spack\qa\configuration\windows_config.yaml $env:USERPROFILE\.spack\windows\config.yaml
-        spack external find cmake
-        spack external find ninja
-        spack -d install abseil-cpp
-  make-installer:
-    runs-on: windows-latest
-    steps:
-    - name: Disable Windows Symlinks
-      run: |
-        git config --global core.symlinks false
-      shell:
-        powershell
-    - uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8
-      with:
-        fetch-depth: 0
-    - uses: actions/setup-python@13ae5bb136fac2878aff31522b9efb785519f984
-      with:
-        python-version: 3.9
-    - name: Install Python packages
-      run: |
-          python -m pip install --upgrade pip six pywin32 setuptools
-    - name: Add Light and Candle to Path
-      run: |
-        $env:WIX >> $GITHUB_PATH
-    - name: Run Installer
-      run: |
-        .\spack\share\spack\qa\setup_spack.ps1
-        spack make-installer -s spack -g SILENT pkg
-        echo "installer_root=$((pwd).Path)" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf8 -Append
-      env:
-        ProgressPreference: SilentlyContinue
-    - uses: actions/upload-artifact@3cea5372237819ed00197afe530f5a7ea3e805c8
-      with:
-        name: Windows Spack Installer Bundle
-        path: ${{ env.installer_root }}\pkg\Spack.exe
-    - uses: actions/upload-artifact@3cea5372237819ed00197afe530f5a7ea3e805c8
-      with:
-        name: Windows Spack Installer
-        path: ${{ env.installer_root}}\pkg\Spack.msi
-  execute-installer:
-    needs: make-installer
-    runs-on: windows-latest
-    defaults:
-      run:
-        shell: pwsh
-    steps:
-    - uses: actions/setup-python@13ae5bb136fac2878aff31522b9efb785519f984
-      with:
-        python-version: 3.9
-    - name: Install Python packages
-      run: |
-          python -m pip install --upgrade pip six pywin32 setuptools
-    - name: Setup installer directory
-      run: |
-        mkdir -p spack_installer
-        echo "spack_installer=$((pwd).Path)\spack_installer" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf8 -Append
-    - uses: actions/download-artifact@v3
-      with:
-        name: Windows Spack Installer Bundle
-        path: ${{ env.spack_installer }}
-    - name: Execute Bundled Installer
-      run: |
-        $proc = Start-Process  ${{ env.spack_installer }}\spack.exe "/install /quiet" -Passthru
-        $handle = $proc.Handle # cache proc.Handle
-        $proc.WaitForExit();
-        $LASTEXITCODE
-      env:
-        ProgressPreference: SilentlyContinue
-    - uses: actions/download-artifact@v3
-      with:
-        name: Windows Spack Installer
-        path: ${{ env.spack_installer }}
-    - name: Execute MSI
-      run: |
-        $proc = Start-Process  ${{ env.spack_installer }}\spack.msi "/quiet" -Passthru
-        $handle = $proc.Handle # cache proc.Handle
-        $proc.WaitForExit();
-        $LASTEXITCODE

.gitignore

@@ -1,515 +1,40 @@
-##########################
-# Spack-specific ignores #
-##########################
-
+/db
 /var/spack/stage
 /var/spack/cache
 /var/spack/environments
 /var/spack/repos/*/index.yaml
 /var/spack/repos/*/lock
+__pycache__/
+*.pyc
 /opt
+*~
+.DS_Store
+.idea
 # Ignore everything in /etc/spack except /etc/spack/defaults
 /etc/spack/*
 !/etc/spack/defaults
+/etc/spackconfig
+/share/spack/dotkit
 /share/spack/modules
 /share/spack/lmod
-# Debug logs
-spack-db.*
+/TAGS
+*.swp
+/htmlcov
+.coverage
+\#*
+.#*
+.cache
+lib/spack/spack/test/.cache
+/bin/spackc
 *.in.log
 *.out.log
+*.orig
 
-###########################
-# Python-specific ignores #
-###########################
-
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-#lib/
-#lib64/
-parts/
-sdist/
-#var/
-wheels/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py,cover
-.hypothesis/
-.pytest_cache/
-cover/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-.pybuilder/
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-#   For a library or package, you might want to ignore these files since the code is
-#   intended to run in multiple environments; otherwise, check them in:
-# .python-version
-
-# pipenv
-#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
-#   However, in case of collaboration, if having platform-specific dependencies or dependencies
-#   having no cross-platform support, pipenv may install dependencies that don't work, or not
-#   install all needed dependencies.
-#Pipfile.lock
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-!/lib/spack/env
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
-
-# pytype static type analyzer
-.pytype/
-
-# Cython debug symbols
-cython_debug/
-
-########################
-# Vim-specific ignores #
-########################
-
-# Swap
-[._]*.s[a-v][a-z]
-!*.svg  # comment out if you don't need vector files
-[._]*.sw[a-p]
-[._]s[a-rt-v][a-z]
-[._]ss[a-gi-z]
-[._]sw[a-p]
-
-# Session
-Session.vim
-Sessionx.vim
-
-# Temporary
-.netrwhist
-*~
-# Auto-generated tag files
-tags
-# Persistent undo
-[._]*.un~
-
-##########################
-# Emacs-specific ignores #
-##########################
-
-*~
-\#*\#
-/.emacs.desktop
-/.emacs.desktop.lock
-*.elc
-auto-save-list
-tramp
-.\#*
-
-# Org-mode
-.org-id-locations
-*_archive
-
-# flymake-mode
-*_flymake.*
-
-# eshell files
-/eshell/history
-/eshell/lastdir
-
-# zsh byte-compiled files
-*.zwc
-
-# elpa packages
-/elpa/
-
-# reftex files
-*.rel
-
-# AUCTeX auto folder
-/auto/
-
-# cask packages
-.cask/
-dist/
-
-# Flycheck
-flycheck_*.el
-
-# server auth directory
-/server/
-
-# projectiles files
-.projectile
-
-# directory configuration
-.dir-locals.el
-
-# network security
-/network-security.data
-
-############################
-# Eclipse-specific ignores #
-############################
-
-.metadata
-#bin/
-tmp/
-*.tmp
-*.bak
-*.swp
-*~.nib
-local.properties
-.settings/
-.loadpath
-.recommenders
-
-# External tool builders
-.externalToolBuilders/
-
-# Locally stored "Eclipse launch configurations"
-*.launch
-
-# PyDev specific (Python IDE for Eclipse)
-*.pydevproject
-
-# CDT-specific (C/C++ Development Tooling)
+# Eclipse files
+.project
 .cproject
+.pydevproject
 
-# CDT- autotools
-.autotools
-
-# Java annotation processor (APT)
-.factorypath
-
-# PDT-specific (PHP Development Tools)
-.buildpath
-
-# sbteclipse plugin
-.target
-
-# Tern plugin
-.tern-project
-
-# TeXlipse plugin
-.texlipse
-
-# STS (Spring Tool Suite)
-.springBeans
-
-# Code Recommenders
-.recommenders/
-
-# Annotation Processing
-.apt_generated/
-.apt_generated_test/
-
-# Scala IDE specific (Scala & Java development for Eclipse)
-.cache-main
-.scala_dependencies
-.worksheet
-
-# Uncomment this line if you wish to ignore the project description file.
-# Typically, this file would be tracked if it contains build/dependency configurations:
-#.project
-
-##################################
-# Visual Studio-specific ignores #
-##################################
-
-.vscode/*
-!.vscode/settings.json
-!.vscode/tasks.json
-!.vscode/launch.json
-!.vscode/extensions.json
-*.code-workspace
-
-# Local History for Visual Studio Code
-.history/
-
-#################################
-# Sublime Text-specific ignores #
-#################################
-
-# Cache files for Sublime Text
-*.tmlanguage.cache
-*.tmPreferences.cache
-*.stTheme.cache
-
-# Workspace files are user-specific
-*.sublime-workspace
-
-# Project files should be checked into the repository, unless a significant
-# proportion of contributors will probably not be using Sublime Text
-# *.sublime-project
-
-# SFTP configuration file
-sftp-config.json
-sftp-config-alt*.json
-
-# Package control specific files
-Package Control.last-run
-Package Control.ca-list
-Package Control.ca-bundle
-Package Control.system-ca-bundle
-Package Control.cache/
-Package Control.ca-certs/
-Package Control.merged-ca-bundle
-Package Control.user-ca-bundle
-oscrypto-ca-bundle.crt
-bh_unicode_properties.cache
-
-# Sublime-github package stores a github token in this file
-# https://packagecontrol.io/packages/sublime-github
-GitHub.sublime-settings
-
-##############################
-# JetBrains-specific ignores #
-##############################
-
-# Ignore the entire folder since it may conatin more files than
-# just the ones listed below
-.idea/
-
-# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
-# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
-
-# User-specific stuff
-.idea/**/workspace.xml
-.idea/**/tasks.xml
-.idea/**/usage.statistics.xml
-.idea/**/dictionaries
-.idea/**/shelf
-
-# Generated files
-.idea/**/contentModel.xml
-
-# Sensitive or high-churn files
-.idea/**/dataSources/
-.idea/**/dataSources.ids
-.idea/**/dataSources.local.xml
-.idea/**/sqlDataSources.xml
-.idea/**/dynamic.xml
-.idea/**/uiDesigner.xml
-.idea/**/dbnavigator.xml
-
-# Gradle
-.idea/**/gradle.xml
-.idea/**/libraries
-
-# Gradle and Maven with auto-import
-# When using Gradle or Maven with auto-import, you should exclude module files,
-# since they will be recreated, and may cause churn.  Uncomment if using
-# auto-import.
-# .idea/artifacts
-# .idea/compiler.xml
-# .idea/jarRepositories.xml
-# .idea/modules.xml
-# .idea/*.iml
-# .idea/modules
-# *.iml
-# *.ipr
-
-# CMake
-cmake-build-*/
-
-# Mongo Explorer plugin
-.idea/**/mongoSettings.xml
-
-# File-based project format
-*.iws
-
-# IntelliJ
-out/
-
-# mpeltonen/sbt-idea plugin
-.idea_modules/
-
-# JIRA plugin
-atlassian-ide-plugin.xml
-
-# Cursive Clojure plugin
-.idea/replstate.xml
-
-# Crashlytics plugin (for Android Studio and IntelliJ)
-com_crashlytics_export_strings.xml
-crashlytics.properties
-crashlytics-build.properties
-fabric.properties
-
-# Editor-based Rest Client
-.idea/httpRequests
-
-# Android studio 3.1+ serialized cache file
-.idea/caches/build_file_checksums.ser
-
-##########################
-# macOS-specific ignores #
-##########################
-
-# General
-.DS_Store
-.AppleDouble
-.LSOverride
-
-# Icon must end with two \r
-Icon
-
-# Thumbnails
-._*
-
-# Files that might appear in the root of a volume
-.DocumentRevisions-V100
-.fseventsd
-.Spotlight-V100
-.TemporaryItems
-.Trashes
-.VolumeIcon.icns
-.com.apple.timemachine.donotpresent
-
-# Directories potentially created on remote AFP share
-.AppleDB
-.AppleDesktop
-Network Trash Folder
-Temporary Items
-.apdisk
-
-##########################
-# Linux-specific ignores #
-##########################
-
-*~
-
-# temporary files which can be created if a process still has a handle open of a deleted file
-.fuse_hidden*
-
-# KDE directory preferences
-.directory
-
-# Linux trash folder which might appear on any partition or disk
-.Trash-*
-
-# .nfs files are created when an open file is removed but is still being accessed
-.nfs*
-
-############################
-# Windows-specific ignores #
-############################
-
-# Windows thumbnail cache files
-Thumbs.db
-Thumbs.db:encryptable
-ehthumbs.db
-ehthumbs_vista.db
-
-# Dump file
-*.stackdump
-
-# Folder config file
-[Dd]esktop.ini
-
-# Recycle Bin used on file shares
-$RECYCLE.BIN/
-
-# Windows Installer files
-*.cab
-*.msi
-*.msix
-*.msm
-*.msp
-
-# Windows shortcuts
-*.lnk
+# VSCode files
+.vscode
+.devcontainer

.mailmap

@@ -3,8 +3,7 @@ Adam Moody            <moody20@llnl.gov>                Adam T. Moody
 Alfredo Gimenez       <gimenez1@llnl.gov>               Alfredo Gimenez         <alfredo.gimenez@gmail.com>
 Alfredo Gimenez       <gimenez1@llnl.gov>               Alfredo Adolfo Gimenez  <alfredo.gimenez@gmail.com>
 Andrew Williams       <williamsa89@cardiff.ac.uk>       Andrew Williams         <andrew@alshain.org.uk>
-Axel Huebl            <axelhuebl@lbl.gov>               Axel Huebl              <a.huebl@hzdr.de>
-Axel Huebl            <axelhuebl@lbl.gov>               Axel Huebl              <axel.huebl@plasma.ninja>
+Axel Huebl            <a.huebl@hzdr.de>                 Axel Huebl              <axel.huebl@plasma.ninja>
 Ben Boeckel           <ben.boeckel@kitware.com>         Ben Boeckel             <mathstuf@gmail.com>
 Ben Boeckel           <ben.boeckel@kitware.com>         Ben Boeckel             <mathstuf@users.noreply.github.com>
 Benedikt Hegner       <hegner@cern.ch>                  Benedikt Hegner         <benedikt.hegner@cern.ch>

.readthedocs.yml

@@ -2,7 +2,6 @@ version: 2
 
 sphinx:
   configuration: lib/spack/docs/conf.py
-  fail_on_warning: true
 
 python:
   version: 3.7

CHANGELOG.md

@@ -1,623 +1,3 @@
-# v0.18.1 (2022-07-19)
-
-### Spack Bugfixes
-* Fix several bugs related to bootstrapping (#30834,#31042,#31180)
-* Fix a regression that was causing spec hashes to differ between 
-  Python 2 and Python 3 (#31092)
-* Fixed compiler flags for oneAPI and DPC++ (#30856)
-* Fixed several issues related to concretization (#31142,#31153,#31170,#31226)
-* Improved support for Cray manifest file and `spack external find` (#31144,#31201,#31173,#31186)
-* Assign a version to openSUSE Tumbleweed according to the GLIBC version
-  in the system (#19895) 
-* Improved Dockerfile generation for `spack containerize` (#29741,#31321)
-* Fixed a few bugs related to concurrent execution of commands (#31509,#31493,#31477)  
-
-### Package updates
-* WarpX: add v22.06, fixed libs property (#30866,#31102)
-* openPMD: add v0.14.5, update recipe for @develop (#29484,#31023)
-
-# v0.18.0 (2022-05-28)
-
-`v0.18.0` is a major feature release.
-
-## Major features in this release
-
-1. **Concretizer now reuses by default**
-
-   `spack install --reuse` was introduced in `v0.17.0`, and `--reuse`
-   is now the default concretization mode. Spack will try hard to
-   resolve dependencies using installed packages or binaries (#30396).
-
-   To avoid reuse and to use the latest package configurations, (the
-   old default), you can use `spack install --fresh`, or add
-   configuration like this to your environment or `concretizer.yaml`:
-
-   ```yaml
-   concretizer:
-       reuse: false
-   ```
-
-2. **Finer-grained hashes**
-
-   Spack hashes now include `link`, `run`, *and* `build` dependencies,
-   as well as a canonical hash of package recipes. Previously, hashes
-   only included `link` and `run` dependencies (though `build`
-   dependencies were stored by environments). We coarsened the hash to
-   reduce churn in user installations, but the new default concretizer
-   behavior mitigates this concern and gets us reuse *and* provenance.
-   You will be able to see the build dependencies of new installations
-   with `spack find`. Old installations will not change and their
-   hashes will not be affected. (#28156, #28504, #30717, #30861)
-
-3. **Improved error messages**
-
-   Error handling with the new concretizer is now done with
-   optimization criteria rather than with unsatisfiable cores, and
-   Spack reports many more details about conflicting constraints.
-   (#30669)
-
-4. **Unify environments when possible**
-
-   Environments have thus far supported `concretization: together` or
-   `concretization: separately`. These have been replaced by a new
-   preference in `concretizer.yaml`:
-
-   ```yaml
-   concretizer:
-       unify: [true|false|when_possible]
-   ```
-
-   `concretizer:unify:when_possible` will *try* to resolve a fully
-   unified environment, but if it cannot, it will create multiple
-   configurations of some packages where it has to. For large
-   environments that previously had to be concretized separately, this
-   can result in a huge speedup (40-50x). (#28941)
-
-5. **Automatically find externals on Cray machines**
-
-   Spack can now automatically discover installed packages in the Cray
-   Programming Environment by running `spack external find` (or `spack
-   external read-cray-manifest` to *only* query the PE). Packages from
-   the PE (e.g., `cray-mpich` are added to the database with full
-   dependency information, and compilers from the PE are added to
-   `compilers.yaml`. Available with the June 2022 release of the Cray
-   Programming Environment. (#24894, #30428)
-
-6. **New binary format and hardened signing**
-
-   Spack now has an updated binary format, with improvements for
-   security. The new format has a detached signature file, and Spack
-   verifies the signature before untarring or decompressing the binary
-   package. The previous format embedded the signature in a `tar`
-   file, which required the client to run `tar` *before* verifying
-   (#30750). Spack can still install from build caches using the old
-   format, but we encourage users to switch to the new format going
-   forward.
-
-   Production GitLab pipelines have been hardened to securely sign
-   binaries. There is now a separate signing stage so that signing
-   keys are never exposed to build system code, and signing keys are
-   ephemeral and only live as long as the signing pipeline stage.
-   (#30753)
-
-7. **Bootstrap mirror generation**
-
-   The `spack bootstrap mirror` command can automatically create a
-   mirror for bootstrapping the concretizer and other needed
-   dependencies in an air-gapped environment. (#28556)
-
-8. **Nascent Windows support**
-
-   Spack now has initial support for Windows. Spack core has been
-   refactored to run in the Windows environment, and a small number of
-   packages can now build for Windows. More details are
-   [in the documentation](https://spack.rtfd.io/en/latest/getting_started.html#spack-on-windows)
-   (#27021, #28385, many more)
-
-9. **Makefile generation**
-
-   `spack env depfile` can be used to generate a `Makefile` from an
-   environment, which can be used to build packages the environment
-   in parallel on a single node. e.g.:
-
-   ```console
-   spack -e myenv env depfile > Makefile
-   make
-   ```
-
-   Spack propagates `gmake` jobserver information to builds so that
-   their jobs can share cores. (#30039, #30254, #30302, #30526)
-
-10. **New variant features**
-
-    In addition to being conditional themselves, variants can now have
-    [conditional *values*](https://spack.readthedocs.io/en/latest/packaging_guide.html#conditional-possible-values)
-    that are only possible for certain configurations of a package. (#29530)
-
-    Variants can be
-    [declared "sticky"](https://spack.readthedocs.io/en/latest/packaging_guide.html#sticky-variants),
-    which prevents them from being enabled or disabled by the
-    concretizer. Sticky variants must be set explicitly by users
-    on the command line or in `packages.yaml`. (#28630)
-
-* Allow conditional possible values in variants
-* Add a "sticky" property to variants
-
-
-## Other new features of note
-
-* Environment views can optionally link only `run` dependencies
-  with `link:run` (#29336)
-* `spack external find --all` finds library-only packages in
-  addition to build dependencies (#28005)
-* Customizable `config:license_dir` option (#30135)
-* `spack external find --path PATH` takes a custom search path (#30479)
-* `spack spec` has a new `--format` argument like `spack find` (#27908)
-* `spack concretize --quiet` skips printing concretized specs (#30272)
-* `spack info` now has cleaner output and displays test info (#22097)
-* Package-level submodule option for git commit versions (#30085, #30037)
-* Using `/hash` syntax to refer to concrete specs in an environment
-  now works even if `/hash` is not installed. (#30276)
-
-## Major internal refactors
-
-* full hash (see above)
-* new develop versioning scheme `0.19.0-dev0`
-* Allow for multiple dependencies/dependents from the same package (#28673)
-* Splice differing virtual packages (#27919)
-
-## Performance Improvements
-
-* Concretization of large environments with `unify: when_possible` is
-  much faster than concretizing separately (#28941, see above)
-* Single-pass view generation algorithm is 2.6x faster (#29443)
-
-## Archspec improvements
-
-* `oneapi` and `dpcpp` flag support (#30783)
-* better support for `M1` and `a64fx` (#30683)
-
-## Removals and Deprecations
-
-* Spack no longer supports Python `2.6` (#27256)
-* Removed deprecated `--run-tests` option of `spack install`;
-  use `spack test` (#30461)
-* Removed deprecated `spack flake8`; use `spack style` (#27290)
-
-* Deprecate `spack:concretization` config option; use
-  `concretizer:unify` (#30038)
-* Deprecate top-level module configuration; use module sets (#28659)
-* `spack activate` and `spack deactivate` are deprecated in favor of
-  environments; will be removed in `0.19.0` (#29430; see also `link:run`
-  in #29336 above)
-
-## Notable Bugfixes
-
-* Fix bug that broke locks with many parallel builds (#27846)
-* Many bugfixes and consistency improvements for the new concretizer
-  and `--reuse` (#30357, #30092, #29835, #29933, #28605, #29694, #28848)
-
-## Packages
-
-* `CMakePackage` uses `CMAKE_INSTALL_RPATH_USE_LINK_PATH` (#29703)
-* Refactored `lua` support: `lua-lang` virtual supports both
-  `lua` and `luajit` via new `LuaPackage` build system(#28854)
-* PythonPackage: now installs packages with `pip` (#27798)
-* Python: improve site_packages_dir handling (#28346)
-* Extends: support spec, not just package name (#27754)
-* `find_libraries`: search for both .so and .dylib on macOS (#28924)
-* Use stable URLs and `?full_index=1` for all github patches (#29239)
-
-## Spack community stats
-
-* 6,416 total packages, 458 new since `v0.17.0`
-    * 219 new Python packages
-    * 60 new R packages
-* 377 people contributed to this release
-    * 337 committers to packages
-    * 85 committers to core
-
-# v0.17.3 (2022-07-14)
-
-### Spack bugfixes
-
-* Fix missing chgrp on symlinks in package installations (#30743)
-* Allow having non-existing upstreams (#30744, #30746)
-* Fix `spack stage` with custom paths (#30448)
-* Fix failing call for `spack buildcache save-specfile` (#30637)
-* Fix globbing in compiler wrapper (#30699)
-
-# v0.17.2 (2022-04-13)
-
-### Spack bugfixes
-* Fix --reuse with upstreams set in an environment (#29680)
-* config add: fix parsing of validator error to infer type from oneOf (#29475)
-* Fix spack -C command_line_scope used in conjunction with other flags (#28418)
-* Use Spec.constrain to construct spec lists for stacks (#28783)
-* Fix bug occurring when searching for inherited patches in packages (#29574)
-* Fixed a few bugs when manipulating symlinks (#28318, #29515, #29636)
-* Fixed a few minor bugs affecting command prompt, terminal title and argument completion (#28279, #28278, #28939, #29405, #29070, #29402)
-* Fixed a few bugs affecting the spack ci command (#29518, #29419)
-* Fix handling of Intel compiler environment (#29439)
-* Fix a few edge cases when reindexing the DB (#28764)
-* Remove "Known issues" from documentation (#29664)
-* Other miscellaneous bugfixes (0b72e070583fc5bcd016f5adc8a84c99f2b7805f, #28403, #29261)
-
-# v0.17.1 (2021-12-23)
-
-### Spack Bugfixes
-* Allow locks to work under high contention (#27846)
-* Improve errors messages from clingo (#27707 #27970)
-* Respect package permissions for sbang (#25764)
-* Fix --enable-locks behavior (#24675)
-* Fix log-format reporter ignoring install errors (#25961)
-* Fix overloaded argparse keys (#27379)
-* Allow style commands to run with targets other than "develop" (#27472)
-* Log lock messages to debug level, instead of verbose level (#27408)
-* Handle invalid unicode while logging (#21447)
-* spack audit: fix API calls to variants (#27713)
-* Provide meaningful message for empty environment installs (#28031)
-* Added opensuse leap containers to spack containerize (#27837)
-* Revert "patches: make re-applied patches idempotent" (#27625)
-* MANPATH can use system defaults (#21682)
-* Add "setdefault" subcommand to `spack module tcl` (#14686)
-* Regenerate views when specs already installed (#28113)
-
-### Package bugfixes
-* Fix external package detection for OpenMPI (#27255)
-* Update the UPC++ package to 2021.9.0 (#26996)
-* Added py-vermin v1.3.2 (#28072)
-
-# v0.17.0 (2021-11-05)
-
-`v0.17.0` is a major feature release.
-
-## Major features in this release
-
-1. **New concretizer is now default**
-   The new concretizer introduced as an experimental feature in `v0.16.0`
-   is now the default (#25502). The new concretizer is based on the
-   [clingo](https://github.com/potassco/clingo) logic programming system,
-   and it enables us to do much higher quality and faster dependency solving
-   The old concretizer is still available via the `concretizer: original`
-   setting, but it is deprecated and will be removed in `v0.18.0`.
-
-2. **Binary Bootstrapping**
-   To make it easier to use the new concretizer and binary packages,
-   Spack now bootstraps `clingo` and `GnuPG` from public binaries. If it
-   is not able to bootstrap them from binaries, it installs them from
-   source code. With these changes, you should still be able to clone Spack
-   and start using it almost immediately. (#21446, #22354, #22489, #22606,
-   #22720, #22720, #23677, #23946, #24003, #25138, #25607, #25964, #26029,
-   #26399, #26599).
-
-3. **Reuse existing packages (experimental)**
-   The most wanted feature from our
-   [2020 user survey](https://spack.io/spack-user-survey-2020/) and
-   the most wanted Spack feature of all time (#25310). `spack install`,
-   `spack spec`, and `spack concretize` now have a `--reuse` option, which
-   causes Spack to minimize the number of rebuilds it does. The `--reuse`
-   option will try to find existing installations and binary packages locally
-   and in registered mirrors, and will prefer to use them over building new
-   versions. This will allow users to build from source *far* less than in
-   prior versions of Spack. This feature will continue to be improved, with
-   configuration options and better CLI expected in `v0.17.1`. It will become
-   the *default* concretization mode in `v0.18.0`.
-
-4. **Better error messages**
-   We have improved the error messages generated by the new concretizer by
-   using *unsatisfiable cores*. Spack will now print a summary of the types
-   of constraints that were violated to make a spec unsatisfiable (#26719).
-
-5. **Conditional variants**
-   Variants can now have a `when="<spec>"` clause, allowing them to be
-   conditional based on the version or other attributes of a package (#24858).
-
-6. **Git commit versions**
-   In an environment and on the command-line, you can now provide a full,
-   40-character git commit as a version for any package with a top-level
-   `git` URL.  e.g., `spack install hdf5@45bb27f58240a8da7ebb4efc821a1a964d7712a8`.
-   Spack will compare the commit to tags in the git repository to understand
-   what versions it is ahead of or behind.
-
-7. **Override local config and cache directories**
-   You can now set `SPACK_DISABLE_LOCAL_CONFIG` to disable the `~/.spack` and
-   `/etc/spack` configuration scopes. `SPACK_USER_CACHE_PATH` allows you to
-   move caches out of `~/.spack`, as well (#27022, #26735). This addresses
-   common problems where users could not isolate CI environments from local
-   configuration.
-
-8. **Improvements to Spack Containerize**
-   For added reproducibility, you can now pin the Spack version used by
-   `spack containerize` (#21910). The container build will only build
-   with the Spack version pinned at build recipe creation instead of the
-   latest Spack version.
-
-9. **New commands for dealing with tags**
-   The `spack tags` command allows you to list tags on packages (#26136), and you
-   can list tests and filter tags with `spack test list` (#26842).
-
-## Other new features of note
-
-* Copy and relocate environment views as stand-alone installations (#24832)
-* `spack diff` command can diff two installed specs (#22283, #25169)
-* `spack -c <config>` can set one-off config parameters on CLI (#22251)
-* `spack load --list` is an alias for `spack find --loaded` (#27184)
-* `spack gpg` can export private key with `--secret` (#22557)
-* `spack style` automatically bootstraps dependencies (#24819)
-* `spack style --fix` automatically invokes `isort` (#24071)
-* build dependencies can be installed from build caches with `--include-build-deps` (#19955)
-* `spack audit` command for checking package constraints (#23053)
-* Spack can now fetch from `CVS` repositories (yep, really) (#23212)
-* `spack monitor` lets you upload analysis about installations to a
-  [spack monitor server](https://github.com/spack/spack-monitor) (#23804, #24321,
-  #23777, #25928))
-* `spack python --path` shows which `python` Spack is using (#22006)
-* `spack env activate --temp` can create temporary environments (#25388)
-* `--preferred` and `--latest` options for `spack checksum` (#25830)
-* `cc` is now pure posix and runs on Alpine (#26259)
-* `SPACK_PYTHON` environment variable sets which `python` spack uses (#21222)
-* `SPACK_SKIP_MODULES` lets you source `setup-env.sh` faster if you don't need modules (#24545)
-
-## Major internal refactors
-
-* `spec.yaml` files are now `spec.json`, yielding a large speed improvement (#22845)
-* Splicing allows Spack specs to store mixed build provenance (#20262)
-* More extensive hooks API for installations (#21930)
-* New internal API for getting the active environment (#25439)
-
-## Performance Improvements
-
-* Parallelize separate concretization in environments; Previously 55 min E4S solve
-    now takes 2.5 min (#26264)
-* Drastically improve YamlFilesystemView file removal performance via batching (#24355)
-* Speed up spec comparison (#21618)
-* Speed up environment activation (#25633)
-
-## Archspec improvements
-* support for new generic `x86_64_v2`, `x86_64_v3`, `x86_64_v4` targets
-    (see [archspec#31](https://github.com/archspec/archspec-json/pull/31))
-* `spack arch --generic` lets you get the best generic architecture for
-    your node (#27061)
-* added support for aocc (#20124), `arm` compiler on `graviton2` (#24904)
-    and on `a64fx` (#24524),
-
-## Infrastructure, buildcaches, and services
-
-* Add support for GCS Bucket Mirrors (#26382)
-* Add `spackbot` to help package maintainers with notifications. See
-  [spack.github.io/spackbot](https://spack.github.io/spackbot/)
-* Reproducible pipeline builds with `spack ci rebuild` (#22887)
-* Removed redundant concretizations from GitLab pipeline generation (#26622)
-* Spack CI no longer generates jobs for unbuilt specs (#20435)
-* Every pull request pipeline has its own buildcache (#25529)
-* `--no-add` installs only specified specs and only if already present in… (#22657)
-* Add environment-aware `spack buildcache sync` command (#25470)
-* Binary cache installation speedups and improvements (#19690, #20768)
-
-## Deprecations and Removals
-
-* `spack setup` was deprecated in v0.16.0, and has now been removed.
-  Use `spack develop` and `spack dev-build`.
-* Remove unused `--dependencies` flag from `spack load` (#25731)
-* Remove stubs for `spack module [refresh|find|rm|loads]`, all of which
-  were deprecated in 2018.
-
-## Notable Bugfixes
-
-* Deactivate previous env before activating new one (#25409)
-* Many fixes to error codes from `spack install` (#21319, #27012, #25314)
-* config add: infer type based on JSON schema validation errors (#27035)
-* `spack config edit` now works even if `spack.yaml` is broken (#24689)
-
-## Packages
-
-* Allow non-empty version ranges like `1.1.0:1.1` (#26402)
-* Remove `.99`'s from many version ranges (#26422)
-* Python: use platform-specific site packages dir (#25998)
-* `CachedCMakePackage` for using *.cmake initial config files (#19316)
-* `lua-lang` allows swapping `lua` and `luajit` (#22492)
-* Better support for `ld.gold` and `ld.lld` (#25626)
-* build times are now stored as metadata in `$prefix/.spack` (#21179)
-* post-install tests can be reused in smoke tests (#20298)
-* Packages can use `pypi` attribute to infer `homepage`/`url`/`list_url` (#17587)
-* Use gnuconfig package for `config.guess` file replacement (#26035)
-* patches: make re-applied patches idempotent (#26784)
-
-## Spack community stats
-
-* 5969 total packages, 920 new since `v0.16.0`
-    * 358 new Python packages, 175 new R packages
-* 513 people contributed to this release
-    * 490 committers to packages
-    * 105 committers to core
-* Lots of GPU updates:
-    * ~77 CUDA-related commits
-    * ~66 AMD-related updates
-    * ~27 OneAPI-related commits
-    * 30 commits from AMD toolchain support
-* `spack test` usage in packages is increasing
-    * 1669 packages with tests (mostly generic python tests)
-    * 93 packages with their own tests
-
-
-# v0.16.3 (2021-09-21)
-
-* clang/llvm: fix version detection (#19978)
-* Fix use of quotes in Python build system (#22279)
-* Cray: fix extracting paths from module files (#23472)
-* Use AWS CloudFront for source mirror (#23978)
-* Ensure all roots of an installed environment are marked explicit in db (#24277)
-* Fix fetching for Python 3.8 and 3.9 (#24686)
-* locks: only open lockfiles once instead of for every lock held (#24794)
-* Remove the EOL centos:6 docker image
-
-# v0.16.2 (2021-05-22)
-
-* Major performance improvement for `spack load` and other commands. (#23661)
-* `spack fetch` is now environment-aware. (#19166)
-* Numerous fixes for the new, `clingo`-based concretizer. (#23016, #23307,
-  #23090, #22896, #22534, #20644, #20537, #21148)
-* Supoprt for automatically bootstrapping `clingo` from source. (#20652, #20657
-  #21364, #21446, #21913, #22354, #22444, #22460, #22489, #22610, #22631)
-* Python 3.10 support: `collections.abc` (#20441)
-* Fix import issues by using `__import__` instead of Spack package importe.
-  (#23288, #23290)
-* Bugfixes and `--source-dir` argument for `spack location`. (#22755, #22348,
-  #22321)
-* Better support for externals in shared prefixes. (#22653)
-* `spack build-env` now prefers specs defined in the active environment.
-  (#21642)
-* Remove erroneous warnings about quotes in `from_sourcing_files`. (#22767)
-* Fix clearing cache of `InternalConfigScope`. (#22609)
-* Bugfix for active when pkg is already active error. (#22587)
-* Make `SingleFileScope` able to repopulate the cache after clearing it.
-  (#22559)
-* Channelflow: Fix the package. (#22483)
-* More descriptive error message for bugs in `package.py` (#21811)
-* Use package-supplied `autogen.sh`. (#20319)
-* Respect `-k/verify-ssl-false` in `_existing_url` method. (#21864)
-
-
-# v0.16.1 (2021-02-22)
-
-This minor release includes a new feature and associated fixes:
-* intel-oneapi support through new packages (#20411, #20686, #20693, #20717,
-  #20732, #20808, #21377, #21448)
-
-This release also contains bug fixes/enhancements for:
-* HIP/ROCm support (#19715, #20095)
-* concretization (#19988, #20020, #20082, #20086, #20099, #20102, #20128,
-  #20182, #20193, #20194, #20196, #20203, #20247, #20259, #20307, #20362,
-  #20383, #20423, #20473, #20506, #20507, #20604, #20638, #20649, #20677,
-  #20680, #20790)
-* environment install reporting fix (#20004)
-* avoid import in ABI compatibility info (#20236)
-* restore ability of dev-build to skip patches (#20351)
-* spack find -d spec grouping (#20028)
-* spack smoke test support (#19987, #20298)
-* macOS fixes (#20038, #21662)
-* abstract spec comparisons (#20341)
-* continuous integration (#17563)
-* performance improvements for binary relocation (#19690, #20768)
-* additional sanity checks for variants in builtin packages (#20373)
-* do not pollute auto-generated configuration files with empty lists or
-  dicts (#20526)
-
-plus assorted documentation (#20021, #20174) and package bug fixes/enhancements
-(#19617, #19933, #19986, #20006, #20097, #20198, #20794, #20906, #21411).
-
-
-# v0.16.0 (2020-11-18)
-
-`v0.16.0` is a major feature release.
-
-## Major features in this release
-
-1. **New concretizer (experimental)** Our new backtracking concretizer is
-   now in Spack as an experimental feature. You will need to install
-   `clingo@master+python` and set `concretizer: clingo` in `config.yaml`
-   to use it. The original concretizer is not exhaustive and is not
-   guaranteed to find a solution if one exists. We encourage you to use
-   the new concretizer and to report any bugs you find with it. We
-   anticipate making the new concretizer the default and including all
-   required dependencies for it in Spack `v0.17`. For more details, see
-   #19501.
-
-2. **spack test (experimental)** Users can add `test()` methods to their
-   packages to run smoke tests on installations with the new `spack test`
-   command (the old `spack test` is now `spack unit-test`). `spack test`
-   is environment-aware, so you can `spack install` an environment and
-   `spack test run` smoke tests on all of its packages. Historical test
-   logs can be perused with `spack test results`. Generic smoke tests for
-   MPI implementations, C, C++, and Fortran compilers as well as specific
-   smoke tests for 18 packages. This is marked experimental because the
-   test API (`self.run_test()`) is likely to be change, but we encourage
-   users to upstream tests, and we will maintain and refactor any that
-   are added to mainline packages (#15702).
-
-3. **spack develop** New `spack develop` command allows you to develop
-   several packages at once within a Spack environment. Running
-   `spack develop foo@v1` and `spack develop bar@v2` will check
-    out specific versions of `foo` and `bar` into subdirectories, which you
-    can then build incrementally with `spack install ` (#15256).
-
-4. **More parallelism** Spack previously installed the dependencies of a
-   _single_ spec in parallel. Entire environments can now be installed in
-   parallel, greatly accelerating builds of large environments. get
-   parallelism from individual specs. Spack now parallelizes entire
-   environment builds (#18131).
-
-5. **Customizable base images for spack containerize**
-    `spack containerize` previously only output a `Dockerfile` based
-    on `ubuntu`. You may now specify any base image of your choosing (#15028).
-
-6. **more external finding** `spack external find` was added in `v0.15`,
-   but only `cmake` had support. `spack external find` can now find
-   `bison`, `cuda`, `findutils`, `flex`, `git`, `lustre` `m4`, `mpich`,
-   `mvapich2`, `ncurses`, `openmpi`, `perl`, `spectrum-mpi`, `tar`, and
-   `texinfo` on your system and add them automatically to
-   `packages.yaml`.
-
-7. **Support aocc, nvhpc, and oneapi compilers** We are aggressively
-   pursuing support for the newest vendor compilers, especially those for
-   the U.S. exascale and pre-exascale systems. Compiler classes and
-   auto-detection for `aocc`, `nvhpc`, `oneapi` are now in Spack (#19345,
-   #19294, #19330).
-
-## Additional new features of note
-
-* New `spack mark` command can be used to designate packages as explicitly
-  installed, so that `spack gc` will not garbage-collect them (#16662).
-* `install_tree` can be customized with Spack's projection format (#18341)
-* `sbang` now lives in the `install_tree` so that all users can access it (#11598)
-* `csh` and `tcsh` users no longer need to set `SPACK_ROOT` before
-  sourcing `setup-env.csh` (#18225)
-* Spec syntax now supports `variant=*` syntax for finding any package
-  that has a particular variant (#19381).
-* Spack respects `SPACK_GNUPGHOME` variable for custom GPG directories (#17139)
-* Spack now recognizes Graviton chips
-
-## Major refactors
-
-* Use spawn instead of fork on Python >= 3.8 on macOS (#18205)
-* Use indexes for public build caches (#19101, #19117, #19132, #19141,  #19209)
-* `sbang` is an external package now (https://github.com/spack/sbang, #19582)
-* `archspec` is an external package now (https://github.com/archspec/archspec, #19600)
-
-## Deprecations and Removals
-
-* `spack bootstrap` was deprecated in v0.14.0, and has now been removed.
-* `spack setup` is deprecated as of v0.16.0.
-* What was `spack test` is now called `spack unit-test`. `spack test` is
-  now the smoke testing feature in (2) above.
-
-## Bugfixes
-
-Some of the most notable bugfixes in this release include:
-
-* Better warning messages for deprecated syntax in `packages.yaml` (#18013)
-* `buildcache list --allarch` now works properly (#17827)
-* Many fixes and tests for buildcaches and binary relcoation (#15687,
-  *#17455, #17418, #17455, #15687, #18110)
-
-## Package Improvements
-
-Spack now has 5050 total packages, 720 of which were added since `v0.15`.
-
-* ROCm packages (`hip`, `aomp`, more) added by AMD (#19957, #19832, others)
-* Many improvements for ARM support
-* `llvm-flang`, `flang`, and `f18` removed, as `llvm` has real `flang`
-  support since Flang was merged to LLVM mainline
-* Emerging support for `spack external find` and `spack test` in packages.
-
-## Infrastructure
-
-* Major infrastructure improvements to pipelines on `gitlab.spack.io`
-* Support for testing PRs from forks (#19248) is being enabled for all
-  forks to enable rolling, up-to-date binary builds on `develop`
-
-
 # v0.15.4 (2020-08-12)
 
 This release contains one feature addition:
@@ -1226,4 +606,4 @@ version of all the changes since `v0.9.1`.
 - Switched from `nose` to `pytest` for unit tests.
   - Unit tests take 1 minute now instead of 8
 - Massively expanded documentation
-- Docs are now hosted on [spack.readthedocs.io](https://spack.readthedocs.io)
+- Docs are now hosted on [spack.readthedocs.io](http://spack.readthedocs.io)

CITATION.cff

@@ -1,58 +0,0 @@
-# If you are referencing Spack in a publication, please cite the SC'15 paper
-# described here.
-#
-# Here's the raw citation:
-#
-#   Todd Gamblin, Matthew P. LeGendre, Michael R. Collette, Gregory L. Lee,
-#   Adam Moody, Bronis R. de Supinski, and W. Scott Futral.
-#   The Spack Package Manager: Bringing Order to HPC Software Chaos.
-#   In Supercomputing 2015 (SC’15), Austin, Texas, November 15-20 2015. LLNL-CONF-669890.
-#
-# Or, in BibTeX:
-#
-# @inproceedings{Gamblin_The_Spack_Package_2015,
-#     address = {Austin, Texas, USA},
-#     author = {Gamblin, Todd and LeGendre, Matthew and
-#               Collette, Michael R. and Lee, Gregory L. and
-#               Moody, Adam and de Supinski, Bronis R. and Futral, Scott},
-#     doi = {10.1145/2807591.2807623},
-#     month = {November 15-20},
-#     note = {LLNL-CONF-669890},
-#     series = {Supercomputing 2015 (SC’15)},
-#     title = {{The Spack Package Manager: Bringing Order to HPC Software Chaos}},
-#     url = {https://github.com/spack/spack},
-#     year = {2015}
-# }
-#
-# And here's the CITATION.cff format:
-#
-cff-version: 1.2.0
-message: "If you are referencing Spack in a publication, please cite the paper below."
-preferred-citation:
-  type: conference-paper
-  doi: "10.1145/2807591.2807623"
-  url: "https://github.com/spack/spack"
-  authors:
-  - family-names: "Gamblin"
-    given-names: "Todd"
-  - family-names: "LeGendre"
-    given-names: "Matthew"
-  - family-names: "Collette"
-    given-names: "Michael R."
-  - family-names: "Lee"
-    given-names: "Gregory L."
-  - family-names: "Moody"
-    given-names: "Adam"
-  - family-names: "de Supinski"
-    given-names: "Bronis R."
-  - family-names: "Futral"
-    given-names: "Scott"
-  title: "The Spack Package Manager: Bringing Order to HPC Software Chaos"
-  conference:
-    name: "Supercomputing 2015 (SC’15)"
-    city: "Austin"
-    region: "Texas"
-    country: "USA"
-  month: November 15-20
-  year: 2015
-  notes: LLNL-CONF-669890

COPYRIGHT

@@ -28,28 +28,14 @@ text in the license header:
 
 External Packages
 -------------------
-
-Spack bundles most external dependencies in lib/spack/external. It also
-includes the sbang tool directly in bin/sbang. These packages are covered
-by various permissive licenses. A summary listing follows. See the
-license included with each package for full details.
-
-PackageName: altgraph
-PackageHomePage: https://altgraph.readthedocs.io/en/latest/index.html
-PackageLicenseDeclared: MIT
+Spack bundles its external dependencies in lib/spack/external.  These
+packages are covered by various permissive licenses.  A summary listing
+follows.  See the license included with each package for full details.
 
 PackageName: argparse
 PackageHomePage: https://pypi.python.org/pypi/argparse
 PackageLicenseDeclared: Python-2.0
 
-PackageName: astunparse
-PackageHomePage: https://github.com/simonpercivall/astunparse
-PackageLicenseDeclared: Python-2.0
-
-PackageName: attrs
-PackageHomePage: https://github.com/python-attrs/attrs
-PackageLicenseDeclared: MIT
-
 PackageName: ctest_log_parser
 PackageHomePage: https://github.com/Kitware/CMake
 PackageLicenseDeclared: BSD-3-Clause
@@ -58,8 +44,8 @@ PackageName: distro
 PackageHomePage: https://pypi.python.org/pypi/distro
 PackageLicenseDeclared: Apache-2.0
 
-PackageName: functools32
-PackageHomePage: https://github.com/MiCHiLU/python-functools32
+PackageName: functools
+PackageHomePage: https://github.com/python/cpython/blob/2.7/Lib/functools.py
 PackageLicenseDeclared: Python-2.0
 
 PackageName: jinja2
@@ -70,10 +56,6 @@ PackageName: jsonschema
 PackageHomePage: https://pypi.python.org/pypi/jsonschema
 PackageLicenseDeclared: MIT
 
-PackageName: macholib
-PackageHomePage: https://macholib.readthedocs.io/en/latest/index.html
-PackageLicenseDeclared: MIT
-
 PackageName: markupsafe
 PackageHomePage: https://pypi.python.org/pypi/MarkupSafe
 PackageLicenseDeclared: BSD-3-Clause
@@ -86,10 +68,6 @@ PackageName: py
 PackageHomePage: https://pypi.python.org/pypi/py
 PackageLicenseDeclared: MIT
 
-PackageName: pyrsistent
-PackageHomePage: http://github.com/tobgu/pyrsistent
-PackageLicenseDeclared: MIT
-
 PackageName: pytest
 PackageHomePage: https://pypi.python.org/pypi/pytest
 PackageLicenseDeclared: MIT
@@ -98,10 +76,14 @@ PackageName: ruamel.yaml
 PackageHomePage: https://yaml.readthedocs.io/
 PackageLicenseDeclared: MIT
 
-PackageName: sbang
-PackageHomePage: https://github.com/spack/sbang
-PackageLicenseDeclared: Apache-2.0 OR MIT
-
 PackageName: six
 PackageHomePage: https://pypi.python.org/pypi/six
 PackageLicenseDeclared: MIT
+
+PackageName: macholib
+PackageHomePage: https://macholib.readthedocs.io/en/latest/index.html
+PackageLicenseDeclared: MIT
+
+PackageName: altgraph
+PackageHomePage: https://altgraph.readthedocs.io/en/latest/index.html
+PackageLicenseDeclared: MIT

LICENSE-MIT

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

README.md

@@ -1,12 +1,12 @@
 # <img src="https://cdn.rawgit.com/spack/spack/develop/share/spack/logo/spack-logo.svg" width="64" valign="middle" alt="Spack"/> Spack
 
-[![Unit Tests](https://github.com/spack/spack/workflows/linux%20tests/badge.svg)](https://github.com/spack/spack/actions)
-[![Bootstrapping](https://github.com/spack/spack/actions/workflows/bootstrap.yml/badge.svg)](https://github.com/spack/spack/actions/workflows/bootstrap.yml)
+[![MacOS Tests](https://github.com/spack/spack/workflows/macos%20tests/badge.svg)](https://github.com/spack/spack/actions)
+[![Linux Tests](https://github.com/spack/spack/workflows/linux%20tests/badge.svg)](https://github.com/spack/spack/actions)
+[![Linux Builds](https://github.com/spack/spack/workflows/linux%20builds/badge.svg)](https://github.com/spack/spack/actions)
+[![macOS Builds (nightly)](https://github.com/spack/spack/workflows/macOS%20builds%20nightly/badge.svg?branch=develop)](https://github.com/spack/spack/actions?query=workflow%3A%22macOS+builds+nightly%22)
 [![codecov](https://codecov.io/gh/spack/spack/branch/develop/graph/badge.svg)](https://codecov.io/gh/spack/spack)
-[![Containers](https://github.com/spack/spack/actions/workflows/build-containers.yml/badge.svg)](https://github.com/spack/spack/actions/workflows/build-containers.yml)
 [![Read the Docs](https://readthedocs.org/projects/spack/badge/?version=latest)](https://spack.readthedocs.io)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
-[![Slack](https://slack.spack.io/badge.svg)](https://slack.spack.io)
+[![Slack](https://spackpm.herokuapp.com/badge.svg)](https://spackpm.herokuapp.com)
 
 Spack is a multi-platform package manager that builds and installs
 multiple versions and configurations of software. It works on Linux,
@@ -21,29 +21,27 @@ builds of the same package.  With Spack, you can build your software
 *all* the ways you want to.
 
 See the
-[Feature Overview](https://spack.readthedocs.io/en/latest/features.html)
+[Feature Overview](http://spack.readthedocs.io/en/latest/features.html)
 for examples and highlights.
 
 To install spack and your first package, make sure you have Python.
 Then:
 
-    $ git clone -c feature.manyFiles=true https://github.com/spack/spack.git
+    $ git clone https://github.com/spack/spack.git
     $ cd spack/bin
     $ ./spack install zlib
 
 Documentation
 ----------------
 
-[**Full documentation**](https://spack.readthedocs.io/) is available, or
+[**Full documentation**](http://spack.readthedocs.io/) is available, or
 run `spack help` or `spack help --all`.
 
-For a cheat sheet on Spack syntax, run `spack help --spec`.
-
 Tutorial
 ----------------
 
 We maintain a
-[**hands-on tutorial**](https://spack.readthedocs.io/en/latest/tutorial.html).
+[**hands-on tutorial**](http://spack.readthedocs.io/en/latest/tutorial.html).
 It covers basic to advanced usage, packaging, developer features, and large HPC
 deployments.  You can do all of the exercises on your own laptop using a
 Docker container.
@@ -61,8 +59,7 @@ packages to bugfixes, documentation, or even new core features.
 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.
+  To get an invitation, [**click here**](https://spackpm.herokuapp.com).
 * **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!
@@ -76,9 +73,9 @@ When you send your request, make ``develop`` the destination branch on the
 
 Your PR must pass Spack's unit tests and documentation tests, and must be
 [PEP 8](https://www.python.org/dev/peps/pep-0008/) compliant.  We enforce
-these guidelines with our CI process. To run these tests locally, and for
+these guidelines with our CI process. To run these tests locally, and for 
 helpful tips on git, see our
-[Contribution Guide](https://spack.readthedocs.io/en/latest/contribution_guide.html).
+[Contribution Guide](http://spack.readthedocs.io/en/latest/contribution_guide.html).
 
 Spack's `develop` branch has the latest contributions. Pull requests
 should target `develop`, and users who want the latest package versions,
@@ -123,12 +120,9 @@ If you are referencing Spack in a publication, please cite the following paper:
 
  * Todd Gamblin, Matthew P. LeGendre, Michael R. Collette, Gregory L. Lee,
    Adam Moody, Bronis R. de Supinski, and W. Scott Futral.
-   [**The Spack Package Manager: Bringing Order to HPC Software Chaos**](https://www.computer.org/csdl/proceedings/sc/2015/3723/00/2807623.pdf).
+   [**The Spack Package Manager: Bringing Order to HPC Software Chaos**](http://www.computer.org/csdl/proceedings/sc/2015/3723/00/2807623.pdf).
    In *Supercomputing 2015 (SC’15)*, Austin, Texas, November 15-20 2015. LLNL-CONF-669890.
 
-On GitHub, you can copy this citation in APA or BibTeX format via the "Cite this repository"
-button. Or, see the comments in `CITATION.cff` for the raw BibTeX.
-
 License
 ----------------
 

SECURITY.md

@@ -1,25 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-We provide security updates for the following releases.
-For more on Spack's release structure, see
-[`README.md`](https://github.com/spack/spack#releases).
-
-
-| Version | Supported          |
-| ------- | ------------------ |
-| develop | :white_check_mark: |
-| 0.17.x  | :white_check_mark: |
-| 0.16.x  | :white_check_mark: |
-
-## Reporting a Vulnerability
-
-To report a vulnerability or other security
-issue, email maintainers@spack.io.
-
-You can expect to hear back within two days.
-If your security issue is accepted, we will do
-our best to release a fix within a week. If
-fixing the issue will take longer than this,
-we will discuss timeline options with you.

bin/haspywin.py

@@ -1,18 +0,0 @@
-# Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
-# Spack Project Developers. See the top-level COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-import subprocess
-import sys
-
-
-def getpywin():
-    try:
-        import win32con  # noqa: F401
-    except ImportError:
-        subprocess.check_call([sys.executable, "-m", "pip", "-q", "install", "--upgrade", "pip"])
-        subprocess.check_call([sys.executable, "-m", "pip", "-q", "install", "pywin32"])
-
-
-if __name__ == "__main__":
-    getpywin()

bin/sbang

@@ -1,103 +1,114 @@
-#!/bin/sh
+#!/bin/bash
 #
-# Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
-# sbang project developers. See the top-level COPYRIGHT file for details.
+# Copyright 2013-2020 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)
 
 #
 # `sbang`: Run scripts with long shebang lines.
 #
-# Many operating systems limit the length and number of possible
-# arguments in shebang lines, making it hard to use interpreters that are
-# deep in the directory hierarchy or require special arguments.
+# Many operating systems limit the length of shebang lines, making it
+# hard to use interpreters that are deep in the directory hierarchy.
+# `sbang` can run such scripts, either as a shebang interpreter, or
+# directly on the command line.
 #
-# To use, put the long shebang on the second line of your script, and
-# make sbang the interpreter, like this:
+# Usage
+# -----------------------------
+# Suppose you have a script, long-shebang.sh, like this:
 #
-#     #!/bin/sh /path/to/sbang
-#     #!/long/path/to/real/interpreter with arguments
+#     1    #!/very/long/path/to/some/interpreter
+#     2
+#     3    echo "success!"
 #
-# `sbang` will run the real interpreter with the script as its argument.
+# Invoking this script will result in an error on some OS's.  On
+# Linux, you get this:
 #
-# See https://github.com/spack/sbang for more details.
+#     $ ./long-shebang.sh
+#     -bash: ./long: /very/long/path/to/some/interp: bad interpreter:
+#            No such file or directory
+#
+# On Mac OS X, the system simply assumes the interpreter is the shell
+# and tries to run with it, which is likely not what you want.
+#
+#
+# `sbang` on the command line
+# -----------------------------
+# You can use `sbang` in two ways.  The first is to use it directly,
+# from the command line, like this:
+#
+#     $ sbang ./long-shebang.sh
+#     success!
+#
+#
+# `sbang` as the interpreter
+# -----------------------------
+# You can also use `sbang` *as* the interpreter for your script. Put
+# `#!/bin/bash /path/to/sbang` on line 1, and move the original
+# shebang to line 2 of the script:
+#
+#     1    #!/bin/bash /path/to/sbang
+#     2    #!/long/path/to/real/interpreter with arguments
+#     3
+#     4    echo "success!"
+#
+#     $ ./long-shebang.sh
+#     success!
+#
+# On Linux, you could shorten line 1 to `#!/path/to/sbang`, but other
+# operating systems like Mac OS X require the interpreter to be a
+# binary, so it's best to use `sbang` as a `bash` argument.
+# Obviously, for this to work, `sbang` needs to have a short enough
+# path that *it* will run without hitting OS limits.
+#
+# For Lua, scripts the second line can't start with #!, as # is not
+# the comment character in lua (even though lua ignores #! on the
+# *first* line of a script).  So, instrument a lua script like this,
+# using -- instead of # on the second line:
+#
+#     1    #!/bin/bash /path/to/sbang
+#     2    --!/long/path/to/lua with arguments
+#     3
+#     4    print "success!"
+#
+# How it works
+# -----------------------------
+# `sbang` is a very simple bash script. It looks at the first two
+# lines of a script argument and runs the last line starting with
+# `#!`, with the script as an argument. It also forwards arguments.
 #
-
-# Generic error handling
-die() {
-    echo "$@" 1>&2;
-    exit 1
-}
-
-# set SBANG_DEBUG to make the script print what would normally be executed.
-exec="exec"
-if [ -n "${SBANG_DEBUG}" ]; then
-    exec="echo "
-fi
 
 # First argument is the script we want to actually run.
 script="$1"
 
-# ensure that the script actually exists
-if [ -z "$script" ]; then
-    die "error: sbang requires exactly one argument"
-elif [ ! -f "$script" ]; then
-    die "$script: no such file or directory"
-fi
-
 # Search the first two lines of script for interpreters.
 lines=0
-while read -r line && [ $lines -ne 2 ]; do
-    if [ "${line#\#!}" != "$line" ]; then
-        shebang_line="${line#\#!}"
-    elif [ "${line#//!}" != "$line" ]; then      # // comments
-        shebang_line="${line#//!}"
-    elif [ "${line#--!}" != "$line" ]; then      # -- lua comments
-        shebang_line="${line#--!}"
-    elif [ "${line#<?php\ }" != "$line" ]; then  # php comments
-        shebang_line="${line#<?php\ \#!}"
-        shebang_line="${shebang_line%\ ?>}"
+while read line && ((lines < 2)) ; do
+    if [[ "$line" = '#!'* ]]; then
+        interpreter="${line#\#!}"
+    elif [[ "$line" = '//!'*node* ]]; then
+        interpreter="${line#//!}"
+    elif [[ "$line" = '--!'*lua* ]]; then
+        interpreter="${line#--!}"
     fi
     lines=$((lines+1))
 done < "$script"
+# this is ineeded for scripts with sbang parameter
+# like ones in intltool
+# #!/<spack-long-path>/perl -w
+# this is the interpreter line with all the parameters as a vector
+interpreter_v=(${interpreter})
+# this is the single interpreter path 
+interpreter_f="${interpreter_v[0]}"
 
-# error if we did not find any interpreter
-if [ -z "$shebang_line"  ]; then
-    die "error: sbang found no interpreter in $script"
-fi
-
-# parse out the interpreter and first argument
-IFS=' ' read -r interpreter arg1 rest <<EOF
-$shebang_line
-EOF
-
-# Determine if the interpreter is a particular program, accounting for the
-# '#!/usr/bin/env PROGRAM' convention. So:
-#
-#     interpreter_is perl
-#
-# will be true for '#!/usr/bin/perl' and '#!/usr/bin/env perl'
-interpreter_is() {
-    if [ "${interpreter##*/}" = "$1" ]; then
-        return 0
-    elif [ "$interpreter" = "/usr/bin/env" ] && [ "$arg1" = "$1" ]; then
-        return 0
+# Invoke any interpreter found, or raise an error if none was found.
+if [[ -n "$interpreter_f" ]]; then
+    if [[ "${interpreter_f##*/}" = "perl"* ]]; then
+        exec $interpreter -x "$@"
     else
-        return 1
+        exec $interpreter "$@"
     fi
-}
-
-if interpreter_is "sbang"; then
-    die "error: refusing to re-execute sbang to avoid infinite loop."
-fi
-
-# Finally invoke the real shebang line
-# ruby and perl need -x to ignore the first line of input (the sbang line)
-#
-if interpreter_is perl || interpreter_is ruby; then
-    # shellcheck disable=SC2086
-    $exec $shebang_line -x "$@"
 else
-    # shellcheck disable=SC2086
-    $exec $shebang_line "$@"
+    echo "error: sbang found no interpreter in $script"
+    exit 1
 fi

bin/spack

@@ -1,7 +1,7 @@
 #!/bin/sh
 # -*- python -*-
 #
-# Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
+# Copyright 2013-2020 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)
@@ -10,13 +10,9 @@
 # Following line is a shell no-op, and starts a multi-line Python comment.
 # See https://stackoverflow.com/a/47886254
 """:"
-# prefer SPACK_PYTHON environment variable, python3, python, then python2
-SPACK_PREFERRED_PYTHONS="python3 python python2 /usr/libexec/platform-python"
-for cmd in "${SPACK_PYTHON:-}" ${SPACK_PREFERRED_PYTHONS}; do
-    if command -v > /dev/null "$cmd"; then
-        export SPACK_PYTHON="$(command -v "$cmd")"
-        exec "${SPACK_PYTHON}" "$0" "$@"
-    fi
+# prefer python3, then python, then python2
+for cmd in python3 python python2; do
+   command -v > /dev/null $cmd && exec $cmd $0 "$@"
 done
 
 echo "==> Error: spack could not find a python interpreter!" >&2
@@ -28,18 +24,12 @@ exit 1
 from __future__ import print_function
 
 import os
-import os.path
 import sys
 
-min_python3 = (3, 5)
-
-if sys.version_info[:2] < (2, 7) or (
-    sys.version_info[:2] >= (3, 0) and sys.version_info[:2] < min_python3
-):
+if sys.version_info[:2] < (2, 6):
     v_info = sys.version_info[:3]
-    msg = "Spack requires Python 2.7 or %d.%d or higher " % min_python3
-    msg += "You are running spack with Python %d.%d.%d." % v_info
-    sys.exit(msg)
+    sys.exit("Spack requires Python 2.6 or higher."
+             "This is Python %d.%d.%d." % v_info)
 
 # Find spack's location and its prefix.
 spack_file = os.path.realpath(os.path.expanduser(__file__))
@@ -52,8 +42,8 @@ sys.path.insert(0, spack_lib_path)
 # 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"))
+if sys.version_info[:2] == (2, 6):
+    sys.path.insert(0, os.path.join(spack_external_libs, 'py26'))
 
 sys.path.insert(0, spack_external_libs)
 
@@ -63,38 +53,12 @@ sys.path.insert(0, spack_external_libs)
 # 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.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
+if 'ruamel' in sys.modules:
+    del sys.modules['ruamel']
 
 # Once we've set up the system path, run the spack main method
-if __name__ == "__main__":
-    sys.exit(spack.main.main())
+import spack.main  # noqa
+sys.exit(spack.main.main())

bin/spack-python

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

bin/spack-tmpconfig

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

bin/spack.bat

@@ -1,223 +0,0 @@
-:: Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
-:: Spack Project Developers. See the top-level COPYRIGHT file for details.
-::
-:: SPDX-License-Identifier: (Apache-2.0 OR MIT)
-::#######################################################################
-::
-:: This file is part of Spack and sets up the spack environment for batch,
-:: This includes environment modules and lmod support,
-:: and it also puts spack in your path. The script also checks that at least
-:: module support exists, and provides suggestions if it doesn't. Source
-:: it like this:
-::
-::    . /path/to/spack/install/spack_cmd.bat
-::
-@echo off
-
-set spack=%SPACK_ROOT%\bin\spack
-
-::#######################################################################
-:: This is a wrapper around the spack command that forwards calls to
-:: 'spack load' and 'spack unload' to shell functions.  This in turn
-:: allows them to be used to invoke environment modules functions.
-::
-:: 'spack load' is smarter than just 'load' because it converts its
-:: arguments into a unique Spack spec that is then passed to module
-:: commands.  This allows the user to use packages without knowing all
-:: their installation details.
-::
-:: e.g., rather than requiring a full spec for libelf, the user can type:
-::
-::     spack load libelf
-::
-:: This will first find the available libelf module file and use a
-:: matching one.  If there are two versions of libelf, the user would
-:: need to be more specific, e.g.:
-::
-::     spack load libelf@0.8.13
-::
-:: This is very similar to how regular spack commands work and it
-:: avoids the need to come up with a user-friendly naming scheme for
-:: spack module files.
-::#######################################################################
-
-:_sp_shell_wrapper
-set "_sp_flags="
-set "_sp_args="
-set "_sp_subcommand="
-setlocal enabledelayedexpansion
-:: commands have the form '[flags] [subcommand] [args]'
-:: flags will always start with '-', e.g. --help or -V
-:: subcommands will never start with '-'
-:: everything after the subcommand is an arg
-for %%x in (%*) do (
-    set t="%%~x"
-    if "!t:~0,1!" == "-" (
-        if defined _sp_subcommand (
-            :: We already have a subcommand, processing args now
-            set "_sp_args=!_sp_args! !t!"
-        ) else (
-            set "_sp_flags=!_sp_flags! !t!"
-            shift
-        )
-    ) else if not defined _sp_subcommand (
-        set "_sp_subcommand=!t!"
-        shift
-    ) else (
-        set "_sp_args=!_sp_args! !t!"
-        shift
-    )
-)
-
-:: --help, -h and -V flags don't require further output parsing.
-:: If we encounter, execute and exit
-if defined _sp_flags (
-    if NOT "%_sp_flags%"=="%_sp_flags:-h=%" (
-        python "%spack%" %_sp_flags%
-        exit /B 0
-    ) else if NOT "%_sp_flags%"=="%_sp_flags:--help=%" (
-        python "%spack%" %_sp_flags%
-        exit /B 0
-    ) else if NOT "%_sp_flags%"=="%_sp_flags:-V=%" (
-        python "%spack%" %_sp_flags%
-        exit /B 0
-    )
-)
-:: pass parsed variables outside of local scope. Need to do
-:: this because delayedexpansion can only be set by setlocal
-echo %_sp_flags%>flags
-echo %_sp_args%>args
-echo %_sp_subcommand%>subcmd
-endlocal
-set /p _sp_subcommand=<subcmd
-set /p _sp_flags=<flags
-set /p _sp_args=<args
-set str_subcommand=%_sp_subcommand:"='%
-set str_flags=%_sp_flags:"='%
-set str_args=%_sp_args:"='%
-if "%str_subcommand%"=="ECHO is off." (set "_sp_subcommand=")
-if "%str_flags%"=="ECHO is off." (set "_sp_flags=")
-if "%str_args%"=="ECHO is off." (set "_sp_args=")
-del subcmd
-del flags
-del args
-
-:: Filter out some commands. For any others, just run the command.
-if "%_sp_subcommand%" == "cd" (
-    goto :case_cd
-) else if "%_sp_subcommand%" == "env" (
-    goto :case_env
-) else if "%_sp_subcommand%" == "load" (
-    goto :case_load
-) else if "%_sp_subcommand%" == "unload" (
-    goto :case_load
-) else (
-    goto :default_case
-)
-
-::#######################################################################
-
-:case_cd
-:: Check for --help or -h
-:: TODO: This is not exactly the same as setup-env.
-:: In setup-env, '--help' or '-h' must follow the cd
-:: Here, they may be anywhere in the args
-if defined _sp_args (
-    if NOT "%_sp_args%"=="%_sp_args:--help=%" (
-        python "%spack%" cd -h
-        goto :end_switch
-    ) else if NOT "%_sp_args%"=="%_sp_args:-h=%" (
-        python "%spack%" cd -h
-        goto :end_switch
-    )
-)
-
-for /F "tokens=* USEBACKQ" %%F in (
-  `python "%spack%" location %_sp_args%`) do (
-    set "LOC=%%F"
-)
-for %%Z in ("%LOC%") do if EXIST %%~sZ\NUL (cd /d "%LOC%")
-goto :end_switch
-
-:case_env
-:: If no args or args contain --bat or -h/--help: just execute.
-if NOT defined _sp_args (
-    goto :default_case
-)else if NOT "%_sp_args%"=="%_sp_args:--help=%" (
-    goto :default_case
-) else if NOT "%_sp_args%"=="%_sp_args: -h=%" (
-    goto :default_case
-) else if NOT "%_sp_args%"=="%_sp_args:--bat=%" (
-    goto :default_case
-) else if NOT "%_sp_args%"=="%_sp_args:deactivate=%" (
-    for /f "tokens=* USEBACKQ" %%I in (
-        `call python "%spack%" %_sp_flags% env deactivate --bat %_sp_args:deactivate=%`
-    ) do %%I
-) else if NOT "%_sp_args%"=="%_sp_args:activate=%" (
-    for /f "tokens=* USEBACKQ" %%I in (
-        `call python "%spack%" %_sp_flags% env activate --bat %_sp_args:activate=%`
-    ) do %%I
-) else (
-    goto :default_case
-)
-goto :end_switch
-
-:case_load
-:: If args contain --sh, --csh, or -h/--help: just execute.
-if defined _sp_args (
-    if NOT "%_sp_args%"=="%_sp_args:--help=%" (
-        goto :default_case
-    ) else if NOT "%_sp_args%"=="%_sp_args: -h=%" (
-        goto :default_case
-    ) else if NOT "%_sp_args%"=="%_sp_args:--bat=%" (
-        goto :default_case
-    )
-)
-
-for /f "tokens=* USEBACKQ" %%I in (
-    `python "%spack%" %_sp_flags% %_sp_subcommand% --bat %_sp_args%`) do %%I
-)
-goto :end_switch
-
-:case_unload
-goto :case_load
-
-:default_case
-python "%spack%" %_sp_flags% %_sp_subcommand% %_sp_args%
-goto :end_switch
-
-:end_switch
-exit /B %ERRORLEVEL%
-
-
-::########################################################################
-:: Prepends directories to path, if they exist.
-::      pathadd /path/to/dir            # add to PATH
-:: or   pathadd OTHERPATH /path/to/dir  # add to OTHERPATH
-::########################################################################
-
-:_spack_pathadd
-set "_pa_varname=PATH"
-set "_pa_new_path=%~1"
-if NOT "%~2" == "" (
-    set "_pa_varname=%~1"
-    set "_pa_new_path=%~2"
-    )
-set "_pa_oldvalue=%_pa_varname%"
-for %%Z in ("%_pa_new_path%") do if EXIST %%~sZ\NUL (
-    if defined %_pa_oldvalue% (
-        set "_pa_varname=%_pa_new_path%:%_pa_oldvalue%"
-    ) else (
-        set "_pa_varname=%_pa_new_path%"
-    )
-)
-exit /b 0
-
-:: set module system roots
-:_sp_multi_pathadd 
-for %%I in (%~2) do (
-    for %%Z in (%_sp_compatible_sys_types%) do (
-        :pathadd "%~1" "%%I\%%Z"
-    )
-)
-exit /B %ERRORLEVEL%

bin/spack_cmd.bat

@@ -1,72 +0,0 @@
-@ECHO OFF
-setlocal EnableDelayedExpansion
-:: (c) 2021 Lawrence Livermore National Laboratory
-:: To use this file independently of Spack's installer, execute this script in its directory, or add the
-:: associated bin directory to your PATH. Invoke to launch Spack Shell.
-::
-:: source_dir/spack/bin/spack_cmd.bat
-::
-pushd %~dp0..
-set SPACK_ROOT=%CD%
-pushd %CD%\..
-set spackinstdir=%CD%
-popd
-
-
-:: Check if Python is on the PATH
-if not defined python_pf_ver (
-(for /f "delims=" %%F in ('where python.exe') do (
-                                                    set "python_pf_ver=%%F"
-                                                    goto :found_python
-                                                  ) ) 2> NUL
-)
-:found_python
-if not defined python_pf_ver (
-    :: If not, look for Python from the Spack installer
-    :get_builtin
-    (for /f "tokens=*" %%g in ('dir /b /a:d "!spackinstdir!\Python*"') do (
-        set "python_ver=%%g")) 2> NUL
-
-    if not defined python_ver (
-        echo Python was not found on your system.
-        echo Please install Python or add Python to your PATH.
-    ) else (
-        set "py_path=!spackinstdir!\!python_ver!"
-        set "py_exe=!py_path!\python.exe"
-    )
-    goto :exitpoint
-) else (
-    :: Python is already on the path
-    set "py_exe=!python_pf_ver!"
-    (for /F "tokens=* USEBACKQ" %%F in (
-        `"!py_exe!" --version`) do (set "output=%%F")) 2>NUL
-    if not "!output:Microsoft Store=!"=="!output!" goto :get_builtin
-    goto :exitpoint
-)
-:exitpoint
-
-set "PATH=%SPACK_ROOT%\bin\;%PATH%"
-if defined py_path (
-    set "PATH=%py_path%;%PATH%"
-)
-
-if defined py_exe (
-    "%py_exe%" "%SPACK_ROOT%\bin\haspywin.py"
-    "%py_exe%" "%SPACK_ROOT%\bin\spack" external find python >NUL
-)
-
-set "EDITOR=notepad"
-
-DOSKEY spacktivate=spack env activate $*
-
-@echo **********************************************************************
-@echo ** Spack Package Manager
-@echo **********************************************************************
-
-IF "%1"=="" GOTO CONTINUE
-set
-GOTO:EOF
-
-:continue
-set PROMPT=[spack] %PROMPT%
-%comspec% /k

bin/spack_pwsh.ps1

@@ -1,10 +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)
-
-$Env:SPACK_PS1_PATH="$PSScriptRoot\..\share\spack\setup-env.ps1"
-& (Get-Process -Id $pid).Path -NoExit {
-     . $Env:SPACK_PS1_PATH ; 
-    Push-Location $ENV:SPACK_ROOT
- }

etc/spack/defaults/bootstrap.yaml

@@ -1,23 +0,0 @@
-bootstrap:
-  # If set to false Spack will not bootstrap missing software,
-  # but will instead raise an error.
-  enable: true
-  # Root directory for bootstrapping work. The software bootstrapped
-  # by Spack is installed in a "store" subfolder of this root directory
-  root: $user_cache_path/bootstrap
-  # Methods that can be used to bootstrap software. Each method may or
-  # 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: '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
-    spack-install: true

etc/spack/defaults/concretizer.yaml

@@ -1,36 +0,0 @@
-# -------------------------------------------------------------------------
-# This is the default spack configuration file.
-#
-# Settings here are versioned with Spack and are intended to provide
-# sensible defaults out of the box. Spack maintainers should edit this
-# file to keep it current.
-#
-# Users can override these settings by editing
-# `$SPACK_ROOT/etc/spack/concretizer.yaml`, `~/.spack/concretizer.yaml`,
-# or by adding a `concretizer:` section to an environment.
-# -------------------------------------------------------------------------
-concretizer:
-  # Whether to consider installed packages or packages from buildcaches when
-  # concretizing specs. If `true`, we'll try to use as many installs/binaries
-  # as possible, rather than building. If `false`, we'll always give you a fresh
-  # concretization.
-  reuse: true
-  # Options that tune which targets are considered for concretization. The
-  # concretization process is very sensitive to the number targets, and the time
-  # needed to reach a solution increases noticeably with the number of targets
-  # considered.
-  targets:
-    # Determine whether we want to target specific or generic microarchitectures.
-    # An example of the first kind might be for instance "skylake" or "bulldozer",
-    # while generic microarchitectures are for instance "aarch64" or "x86_64_v4".
-    granularity: microarchitectures
-    # If "false" allow targets that are incompatible with the current host (for
-    # instance concretize with target "icelake" while running on "haswell").
-    # If "true" only allow targets that are compatible with the host.
-    host_compatible: true
-  # When "true" concretize root specs of environments together, so that each unique
-  # package in an environment corresponds to one concrete spec. This ensures
-  # 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: false

etc/spack/defaults/config.yaml

@@ -16,25 +16,23 @@
 config:
   # This is the path to the root of the Spack install tree.
   # You can use $spack here to refer to the root of the spack instance.
-  install_tree:
-    root: $spack/opt/spack
-    projections:
-      all: "${ARCHITECTURE}/${COMPILERNAME}-${COMPILERVER}/${PACKAGE}-${VERSION}-${HASH}"
-    # install_tree can include an optional padded length (int or boolean)
-    # default is False (do not pad)
-    # if padded_length is True, Spack will pad as close to the system max path
-    # length as possible
-    # if padded_length is an integer, Spack will pad to that many characters,
-    # assuming it is higher than the length of the install_tree root.
-    # padded_length: 128
+  install_tree: $spack/opt/spack
 
 
   # Locations where templates should be found
   template_dirs:
     - $spack/share/spack/templates
 
-  # Directory where licenses should be located
-  license_dir: $spack/etc/spack/licenses
+
+  # Default directory layout
+  install_path_scheme: "${ARCHITECTURE}/${COMPILERNAME}-${COMPILERVER}/${PACKAGE}-${VERSION}-${HASH}"
+
+
+  # Locations where different types of modules should be installed.
+  module_roots:
+    tcl:    $spack/share/spack/modules
+    lmod:   $spack/share/spack/lmod
+
 
   # Temporary locations Spack can try to use for builds.
   #
@@ -45,8 +43,8 @@ config:
   # (i.e., ``$TMP` or ``$TMPDIR``).
   #
   # Another option that prevents conflicts and potential permission issues is
-  # to specify `$user_cache_path/stage`, which ensures each user builds in their
-  # home directory.
+  # to specify `~/.spack/stage`, which ensures each user builds in their home
+  # directory.
   #
   # A more traditional path uses the value of `$spack/var/spack/stage`, which
   # builds directly inside Spack's instance without staging them in a
@@ -63,13 +61,13 @@ config:
   # identifies Spack staging to avoid accidentally wiping out non-Spack work.
   build_stage:
     - $tempdir/$user/spack-stage
-    - $user_cache_path/stage
+    - ~/.spack/stage
   # - $spack/var/spack/stage
 
   # Directory in which to run tests and store test results.
   # Tests will be stored in directories named by date/time and package
   # name/hash.
-  test_stage: $user_cache_path/test
+  test_stage: ~/.spack/test
 
   # Cache directory for already downloaded source tarballs and archived
   # repositories. This can be purged with `spack clean --downloads`.
@@ -78,7 +76,7 @@ config:
 
   # Cache directory for miscellaneous files, like the package index.
   # This can be purged with `spack clean --misc-cache`
-  misc_cache: $user_cache_path/cache
+  misc_cache: ~/.spack/cache
 
 
   # Timeout in seconds used for downloading sources etc. This only applies
@@ -103,7 +101,7 @@ config:
   # If set to true, Spack will attempt to build any compiler on the spec
   # that is not already available. If set to False, Spack will only use
   # compilers already configured in compilers.yaml
-  install_missing_compilers: false
+  install_missing_compilers: False
 
 
   # If set to true, Spack will always check checksums after downloading
@@ -111,11 +109,6 @@ config:
   checksum: true
 
 
-  # If set to true, Spack will fetch deprecated versions without warning.
-  # If false, Spack will raise an error when trying to install a deprecated version.
-  deprecated: false
-
-
   # If set to true, `spack install` and friends will NOT clean
   # potentially harmful variables from the build environment. Use wisely.
   dirty: false
@@ -137,18 +130,12 @@ config:
   # enabling locks.
   locks: true
 
-  # The default url fetch method to use.
-  # If set to 'curl', Spack will require curl on the user's system
-  # If set to 'urllib', Spack will use python built-in libs to fetch
-  url_fetch_method: urllib
 
-  # The maximum number of jobs to use for the build system (e.g. `make`), when
-  # the -j flag is not given on the command line. Defaults to 16 when not set.
-  # Note that the maximum number of jobs is limited by the number of cores
-  # available, taking thread affinity into account when supported. For instance:
-  # - With `build_jobs: 16` and 4 cores available `spack install` will run `make -j4`
-  # - With `build_jobs: 16` and 32 cores available `spack install` will run `make -j16`
-  # - With `build_jobs: 2` and 4 cores available `spack install -j6` will run `make -j6`
+  # The maximum number of jobs to use when running `make` in parallel,
+  # always limited by the number of cores available. For instance:
+  # - If set to 16 on a 4 cores machine `spack install` will run `make -j4`
+  # - If set to 16 on a 18 cores machine `spack install` will run `make -j16`
+  # If not set, Spack will use all available cores up to 16.
   # build_jobs: 16
 
 
@@ -156,22 +143,6 @@ config:
   ccache: false
 
 
-  # The concretization algorithm to use in Spack. Options are:
-  #
-  #   'clingo': Uses a logic solver under the hood to solve DAGs with full
-  #       backtracking and optimization for user preferences. Spack will
-  #       try to bootstrap the logic solver, if not already available.
-  #
-  #   'original': Spack's original greedy, fixed-point concretizer. This
-  #       algorithm can make decisions too early and will not backtrack
-  #       sufficiently for many specs. This will soon be deprecated in
-  #       favor of clingo.
-  #
-  # See `concretizer.yaml` for more settings you can fine-tune when
-  # using clingo.
-  concretizer: clingo
-
-
   # How long to wait to lock the Spack installation database. This lock is used
   # when Spack needs to manage its own package metadata and all operations are
   # expected to complete within the default time limit. The timeout should
@@ -186,32 +157,11 @@ config:
   # never succeed.
   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
   # manipulation by unprivileged user (e.g. AFS)
   allow_sgid: true
-
-  # Whether to set the terminal title to display status information during
-  # 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/cray/modules.yaml

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

etc/spack/defaults/darwin/modules.yaml

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

etc/spack/defaults/darwin/packages.yaml

@@ -21,10 +21,10 @@ packages:
     - gcc
     - intel
     providers:
-      elf: [libelf]
-      fuse: [macfuse]
-      unwind: [apple-libunwind]
-      uuid: [apple-libuuid]
+      elf:
+      - libelf
+      unwind:
+      - apple-libunwind
   apple-libunwind:
     buildable: false
     externals:
@@ -32,10 +32,3 @@ packages:
     # although the version number used here isn't critical
     - spec: apple-libunwind@35.3
       prefix: /usr
-  apple-libuuid:
-    buildable: false
-    externals:
-    # Apple bundles libuuid in libsystem_c version 1353.100.2,
-    # although the version number used here isn't critical
-    - spec: apple-libuuid@1353.100.2
-      prefix: /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk

etc/spack/defaults/linux/modules.yaml

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

etc/spack/defaults/mirrors.yaml

@@ -1,2 +1,2 @@
 mirrors:
-  spack-public: https://mirror.spack.io
+  spack-public: https://spack-llnl-mirror.s3-us-west-2.amazonaws.com/

etc/spack/defaults/modules.yaml

@@ -14,43 +14,36 @@
 #   ~/.spack/modules.yaml
 # -------------------------------------------------------------------------
 modules:
-  # This maps paths in the package install prefix to environment variables
-  # they should be added to. For example, <prefix>/bin should be in PATH.
+  enable:
+    - tcl
   prefix_inspections:
-    ./bin:
+    bin:
       - PATH
-    ./man:
+    man:
       - MANPATH
-    ./share/man:
+    share/man:
       - MANPATH
-    ./share/aclocal:
+    share/aclocal:
       - ACLOCAL_PATH
-    ./lib/pkgconfig:
+    lib:
+      - LIBRARY_PATH
+    lib64:
+      - LIBRARY_PATH
+    include:
+      - C_INCLUDE_PATH
+      - CPLUS_INCLUDE_PATH
+      # The INCLUDE env variable specifies paths to look for
+      # .mod file for Intel Fortran compilers
+      - INCLUDE
+    lib/pkgconfig:
       - PKG_CONFIG_PATH
-    ./lib64/pkgconfig:
+    lib64/pkgconfig:
       - PKG_CONFIG_PATH
-    ./share/pkgconfig:
+    share/pkgconfig:
       - PKG_CONFIG_PATH
-    ./:
+    '':
       - CMAKE_PREFIX_PATH
 
-  # These are configurations for the module set named "default"
-  default:
-    # Where to install modules
-    roots:
-     tcl:    $spack/share/spack/modules
-     lmod:   $spack/share/spack/lmod
-    # What type of modules to use
-    enable:
-      - tcl
-
-    tcl:
-      all:
-        autoload: none
-
-    # Default configurations if lmod is enabled
-    lmod:
-      all:
-        autoload: direct
-      hierarchy:
-        - mpi
+  lmod:
+    hierarchy:
+      - mpi

etc/spack/defaults/packages.yaml

@@ -15,50 +15,38 @@
 # -------------------------------------------------------------------------
 packages:
   all:
-    compiler: [gcc, intel, pgi, clang, xl, nag, fj, aocc]
+    compiler: [gcc, intel, pgi, clang, xl, nag, fj]
     providers:
-      awk: [gawk]
-      blas: [openblas, amdblis]
       D: [ldc]
+      awk: [gawk]
+      blas: [openblas]
       daal: [intel-daal]
       elf: [elfutils]
-      fftw-api: [fftw, amdfftw]
-      flame: [libflame, amdlibflame]
-      fuse: [libfuse]
-      gl: [glx, osmesa]
+      fftw-api: [fftw]
+      gl: [mesa+opengl, opengl]
+      glx: [mesa+glx, opengl]
       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]
       jpeg: [libjpeg-turbo, libjpeg]
-      lapack: [openblas, amdlibflame]
-      libglx: [mesa+glx, mesa18+glx]
-      libllvm: [llvm]
-      libosmesa: [mesa+osmesa, mesa18+osmesa]
-      lua-lang: [lua, lua-luajit-openresty, lua-luajit]
-      luajit: [lua-luajit-openresty, lua-luajit]
+      lapack: [openblas]
       mariadb-client: [mariadb-c-client, mariadb]
       mkl: [intel-mkl]
       mpe: [mpe2]
       mpi: [openmpi, mpich]
       mysql-client: [mysql, mariadb-c-client]
       opencl: [pocl]
-      onedal: [intel-oneapi-dal]
-      pbs: [openpbs, torque]
-      pil: [py-pillow]
+      pil: [py-pillow-simd]
       pkgconfig: [pkgconf, pkg-config]
       rpc: [libtirpc]
-      scalapack: [netlib-scalapack, amdscalapack]
+      scalapack: [netlib-scalapack]
       sycl: [hipsycl]
-      szip: [libaec, libszip]
+      szip: [libszip, libaec]
       tbb: [intel-tbb]
       unwind: [libunwind]
-      uuid: [util-linux-uuid, libuuid]
-      xxd: [xxd-standalone, vim]
-      yacc: [bison, byacc]
-      ziglang: [zig]
+      sycl: [hipsycl]
     permissions:
       read: world
       write: user

etc/spack/defaults/windows/config.yaml

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

lib/spack/docs/Makefile

@@ -2,7 +2,7 @@
 #
 
 # You can set these variables from the command line.
-SPHINXOPTS    = -W --keep-going
+SPHINXOPTS    = -W
 SPHINXBUILD   = sphinx-build
 PAPER         =
 BUILDDIR      = _build

lib/spack/docs/_gh_pages_redirect/index.html

@@ -1,10 +1,10 @@
 <html>
   <head>
-    <meta http-equiv="refresh" content="0; url=https://spack.readthedocs.io/" />
+    <meta http-equiv="refresh" content="0; url=http://spack.readthedocs.io/" />
   </head>
   <body>
     <p>
-      This page has moved to <a href="https://spack.readthedocs.io/">https://spack.readthedocs.io/</a>
+      This page has moved to <a href="http://spack.readthedocs.io/">http://spack.readthedocs.io/</a>
     </p>
   </body>
 </html>

lib/spack/docs/_spack_root

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

lib/spack/docs/analyze.rst

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

lib/spack/docs/basic_usage.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2020 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)
@@ -27,17 +27,11 @@ It is recommended that the following be put in your ``.bashrc`` file:
 
 If you do not see colorized output when using ``less -R`` it is because color
 is being disabled in the piped output. In this case, tell spack to force
-colorized output with a flag
+colorized output.
 
 .. code-block:: console
 
-    $ spack --color always find | less -R
-
-or an environment variable
-
-.. code-block:: console
-
-   $ SPACK_COLOR=always spack find | less -R
+    $ spack --color always | less -R 
 
 --------------------------
 Listing available packages
@@ -85,7 +79,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
@@ -138,27 +132,32 @@ If ``mpileaks`` depends on other packages, Spack will install the
 dependencies first.  It then fetches the ``mpileaks`` tarball, expands
 it, verifies that it was downloaded without errors, builds it, and
 installs it in its own directory under ``$SPACK_ROOT/opt``. You'll see
-a number of messages from Spack, a lot of build output, and a message
-that the package is installed.
+a number of messages from spack, a lot of build output, and a message
+that the packages is installed:
 
 .. code-block:: console
 
    $ spack install mpileaks
-   ... dependency build output ...
-   ==> Installing mpileaks-1.0-ph7pbnhl334wuhogmugriohcwempqry2
-   ==> No binary for mpileaks-1.0-ph7pbnhl334wuhogmugriohcwempqry2 found: installing from source
-   ==> mpileaks: Executing phase: 'autoreconf'
-   ==> mpileaks: Executing phase: 'configure'
-   ==> mpileaks: Executing phase: 'build'
-   ==> mpileaks: Executing phase: 'install'
-   [+] ~/spack/opt/linux-rhel7-broadwell/gcc-8.1.0/mpileaks-1.0-ph7pbnhl334wuhogmugriohcwempqry2
+   ==> Installing mpileaks
+   ==> mpich is already installed in ~/spack/opt/linux-debian7-x86_64/gcc@4.4.7/mpich@3.0.4.
+   ==> callpath is already installed in ~/spack/opt/linux-debian7-x86_64/gcc@4.4.7/callpath@1.0.2-5dce4318.
+   ==> adept-utils is already installed in ~/spack/opt/linux-debian7-x86_64/gcc@4.4.7/adept-utils@1.0-5adef8da.
+   ==> Trying to fetch from https://github.com/hpc/mpileaks/releases/download/v1.0/mpileaks-1.0.tar.gz
+   ######################################################################## 100.0%
+   ==> Staging archive: ~/spack/var/spack/stage/mpileaks@1.0%gcc@4.4.7 arch=linux-debian7-x86_64-59f6ad23/mpileaks-1.0.tar.gz
+   ==> Created stage in ~/spack/var/spack/stage/mpileaks@1.0%gcc@4.4.7 arch=linux-debian7-x86_64-59f6ad23.
+   ==> No patches needed for mpileaks.
+   ==> Building mpileaks.
+
+   ... build output ...
+
+   ==> Successfully installed mpileaks.
+     Fetch: 2.16s.  Build: 9.82s.  Total: 11.98s.
+   [+] ~/spack/opt/linux-debian7-x86_64/gcc@4.4.7/mpileaks@1.0-59f6ad23
 
 The last line, with the ``[+]``, indicates where the package is
 installed.
 
-Add the Spack debug option (one or more times) -- ``spack -d install
-mpileaks`` -- to get additional (and even more verbose) output.
-
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 Building a specific version
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -188,37 +187,6 @@ configuration a **spec**.  In the commands above, ``mpileaks`` and
 ``mpileaks@3.0.4`` are both valid *specs*.  We'll talk more about how
 you can use them to customize an installation in :ref:`sec-specs`.
 
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Reusing installed dependencies
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-By default, when you run ``spack install``, Spack tries hard to reuse existing installations
-as dependencies, either from a local store or from remote buildcaches if configured.
-This minimizes unwanted rebuilds of common dependencies, in particular if
-you update Spack frequently.
-
-In case you want the latest versions and configurations to be installed instead,
-you can add the ``--fresh`` option:
-
-.. code-block:: console
-
-   $ spack install --fresh mpich
-
-Reusing installations in this mode is "accidental", and happening only if
-there's a match between existing installations and what Spack would have installed
-anyhow.
-
-You can use the ``spack spec -I mpich`` command to see what
-will be reused and what will be built before you install.
-
-You can configure Spack to use the ``--fresh`` behavior by default in
-``concretizer.yaml``:
-
-.. code-block:: yaml
-
-   concretizer:
-     reuse: false
-
 .. _cmd-spack-uninstall:
 
 ^^^^^^^^^^^^^^^^^^^
@@ -316,102 +284,6 @@ and removed everything that is not either:
 You can check :ref:`cmd-spack-find-metadata` to see how to query for explicitly installed packages
 or :ref:`dependency-types` for a more thorough treatment of dependency types.
 
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Marking packages explicit or implicit
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-By default, Spack will mark packages a user installs as explicitly installed,
-while all of its dependencies will be marked as implicitly installed. Packages
-can be marked manually as explicitly or implicitly installed by using
-``spack mark``. This can be used in combination with ``spack gc`` to clean up
-packages that are no longer required.
-
-.. code-block:: console
-
-  $ spack install m4
-  ==> 29005: Installing libsigsegv
-  [...]
-  ==> 29005: Installing m4
-  [...]
-
-  $ spack install m4 ^libsigsegv@2.11
-  ==> 39798: Installing libsigsegv
-  [...]
-  ==> 39798: Installing m4
-  [...]
-
-  $ spack find -d
-  ==> 4 installed packages
-  -- linux-fedora32-haswell / gcc@10.1.1 --------------------------
-  libsigsegv@2.11
-
-  libsigsegv@2.12
-
-  m4@1.4.18
-      libsigsegv@2.12
-
-  m4@1.4.18
-      libsigsegv@2.11
-
-  $ spack gc
-  ==> There are no unused specs. Spack's store is clean.
-
-  $ spack mark -i m4 ^libsigsegv@2.11
-  ==> m4@1.4.18 : marking the package implicit
-
-  $ spack gc
-  ==> The following packages will be uninstalled:
-
-      -- linux-fedora32-haswell / gcc@10.1.1 --------------------------
-      5fj7p2o libsigsegv@2.11  c6ensc6 m4@1.4.18
-
-  ==> Do you want to proceed? [y/N]
-
-In the example above, we ended up with two versions of ``m4`` since they depend
-on different versions of ``libsigsegv``. ``spack gc`` will not remove any of
-the packages since both versions of ``m4`` have been installed explicitly
-and both versions of ``libsigsegv`` are required by the ``m4`` packages.
-
-``spack mark`` can also be used to implement upgrade workflows. The following
-example demonstrates how the ``spack mark`` and ``spack gc`` can be used to
-only keep the current version of a package installed.
-
-When updating Spack via ``git pull``, new versions for either ``libsigsegv``
-or ``m4`` might be introduced. This will cause Spack to install duplicates.
-Since we only want to keep one version, we mark everything as implicitly
-installed before updating Spack. If there is no new version for either of the
-packages, ``spack install`` will simply mark them as explicitly installed and
-``spack gc`` will not remove them.
-
-.. code-block:: console
-
-  $ spack install m4
-  ==> 62843: Installing libsigsegv
-  [...]
-  ==> 62843: Installing m4
-  [...]
-
-  $ spack mark -i -a
-  ==> m4@1.4.18 : marking the package implicit
-
-  $ git pull
-  [...]
-
-  $ spack install m4
-  [...]
-  ==> m4@1.4.18 : marking the package explicit
-  [...]
-
-  $ spack gc
-  ==> There are no unused specs. Spack's store is clean.
-
-When using this workflow for installations that contain more packages, care
-has to be taken to either only mark selected packages or issue ``spack install``
-for all packages that should be kept.
-
-You can check :ref:`cmd-spack-find-metadata` to see how to query for explicitly
-or implicitly installed packages.
-
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 Non-Downloadable Tarballs
 ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -457,6 +329,85 @@ the tarballs in question to it (see :ref:`mirrors`):
 
        $ spack install galahad
 
+-----------------------------
+Deprecating insecure packages
+-----------------------------
+
+``spack deprecate`` allows for the removal of insecure packages with
+minimal impact to their dependents.
+
+.. warning::
+
+  The ``spack deprecate`` command is designed for use only in
+  extraordinary circumstances. This is a VERY big hammer to be used
+  with care.
+
+The ``spack deprecate`` command will remove one package and replace it
+with another by replacing the deprecated package's prefix with a link
+to the deprecator package's prefix.
+
+.. warning::
+
+  The ``spack deprecate`` command makes no promises about binary
+  compatibility. It is up to the user to ensure the deprecator is
+  suitable for the deprecated package.
+
+Spack tracks concrete deprecated specs and ensures that no future packages
+concretize to a deprecated spec.
+
+The first spec given to the ``spack deprecate`` command is the package
+to deprecate. It is an abstract spec that must describe a single
+installed package. The second spec argument is the deprecator
+spec. By default it must be an abstract spec that describes a single
+installed package, but with the ``-i/--install-deprecator`` it can be
+any abstract spec that Spack will install and then use as the
+deprecator. The ``-I/--no-install-deprecator`` option will ensure
+the default behavior.
+
+By default, ``spack deprecate`` will deprecate all dependencies of the
+deprecated spec, replacing each by the dependency of the same name in
+the deprecator spec. The ``-d/--dependencies`` option will ensure the
+default, while the ``-D/--no-dependencies`` option will deprecate only
+the root of the deprecate spec in favor of the root of the deprecator
+spec.
+
+``spack deprecate`` can use symbolic links or hard links. The default
+behavior is symbolic links, but the ``-l/--link-type`` flag can take
+options ``hard`` or ``soft``.
+
+-----------------------
+Verifying installations
+-----------------------
+
+The ``spack verify`` command can be used to verify the validity of
+Spack-installed packages any time after installation.
+
+At installation time, Spack creates a manifest of every file in the
+installation prefix. For links, Spack tracks the mode, ownership, and
+destination. For directories, Spack tracks the mode, and
+ownership. For files, Spack tracks the mode, ownership, modification
+time, hash, and size. The Spack verify command will check, for every
+file in each package, whether any of those attributes have changed. It
+will also check for newly added files or deleted files from the
+installation prefix. Spack can either check all installed packages
+using the `-a,--all` or accept specs listed on the command line to
+verify.
+
+The ``spack verify`` command can also verify for individual files that
+they haven't been altered since installation time. If the given file
+is not in a Spack installation prefix, Spack will report that it is
+not owned by any package. To check individual files instead of specs,
+use the ``-f,--files`` option.
+
+Spack installation manifests are part of the tarball signed by Spack
+for binary package distribution. When installed from a binary package,
+Spack uses the packaged installation manifest instead of creating one
+at install time.
+
+The ``spack verify`` command also accepts the ``-l,--local`` option to
+check only local packages (as opposed to those used transparently from
+``upstream`` spack instances) and the ``-j,--json`` option to output
+machine-readable json data for any errors.
 
 -------------------------
 Seeing installed packages
@@ -725,242 +676,6 @@ structured the way you want:
       "hash": "zvaa4lhlhilypw5quj3akyd3apbq5gap"
     }
 
-
-^^^^^^^^^^^^^^
-``spack diff``
-^^^^^^^^^^^^^^
-
-It's often the case that you have two versions of a spec that you need to
-disambiguate. Let's say that we've installed two variants of zlib, one with
-and one without the optimize variant:
-
-.. code-block:: console
-
-   $ spack install zlib
-   $ spack install zlib -optimize
-
-When we do ``spack find`` we see the two versions.
-
-.. code-block:: console
-
-    $ spack find zlib
-    ==> 2 installed packages
-    -- linux-ubuntu20.04-skylake / gcc@9.3.0 ------------------------
-    zlib@1.2.11  zlib@1.2.11
-
-
-Let's now say that we want to uninstall zlib. We run the command, and hit a problem
-real quickly since we have two!
-
-.. code-block:: console
-
-    $ spack uninstall zlib
-    ==> Error: zlib matches multiple packages:
-
-        -- linux-ubuntu20.04-skylake / gcc@9.3.0 ------------------------
-        efzjziy zlib@1.2.11  sl7m27m zlib@1.2.11
-
-    ==> Error: You can either:
-        a) use a more specific spec, or
-        b) specify the spec by its hash (e.g. `spack uninstall /hash`), or
-        c) use `spack uninstall --all` to uninstall ALL matching specs.
-
-Oh no! We can see from the above that we have two different versions of zlib installed,
-and the only difference between the two is the hash. This is a good use case for
-``spack diff``, which can easily show us the "diff" or set difference
-between properties for two packages. Let's try it out.
-Since the only difference we see in the ``spack find`` view is the hash, let's use
-``spack diff`` to look for more detail. We will provide the two hashes:
-
-.. code-block:: console
-
-    $ spack diff /efzjziy /sl7m27m
-    ==> Warning: This interface is subject to change.
-
-    --- zlib@1.2.11efzjziyc3dmb5h5u5azsthgbgog5mj7g
-    +++ zlib@1.2.11sl7m27mzkbejtkrajigj3a3m37ygv4u2
-    @@ variant_value @@
-    -  zlib optimize False
-    +  zlib optimize True
-
-
-The output is colored, and written in the style of a git diff. This means that you
-can copy and paste it into a GitHub markdown as a code block with language "diff"
-and it will render nicely! Here is an example:
-
-.. code-block:: md
-
-    ```diff
-    --- zlib@1.2.11/efzjziyc3dmb5h5u5azsthgbgog5mj7g
-    +++ zlib@1.2.11/sl7m27mzkbejtkrajigj3a3m37ygv4u2
-    @@ variant_value @@
-    -  zlib optimize False
-    +  zlib optimize True
-    ```
-
-Awesome! Now let's read the diff. It tells us that our first zlib was built with ``~optimize``
-(``False``) and the second was built with ``+optimize`` (``True``). You can't see it in the docs
-here, but the output above is also colored based on the content being an addition (+) or
-subtraction (-).
-
-This is a small example, but you will be able to see differences for any attributes on the
-installation spec. Running ``spack diff A B`` means we'll see which spec attributes are on
-``B`` but not on ``A`` (green) and which are on ``A`` but not on ``B`` (red). Here is another
-example with an additional difference type, ``version``:
-
-.. code-block:: console
-
-    $ spack diff python@2.7.8 python@3.8.11
-    ==> Warning: This interface is subject to change.
-
-    --- python@2.7.8/tsxdi6gl4lihp25qrm4d6nys3nypufbf
-    +++ python@3.8.11/yjtseru4nbpllbaxb46q7wfkyxbuvzxx
-    @@ variant_value @@
-    -  python patches a8c52415a8b03c0e5f28b5d52ae498f7a7e602007db2b9554df28cd5685839b8
-    +  python patches 0d98e93189bc278fbc37a50ed7f183bd8aaf249a8e1670a465f0db6bb4f8cf87
-    @@ version @@
-    -  openssl 1.0.2u
-    +  openssl 1.1.1k
-    -  python 2.7.8
-    +  python 3.8.11
-
-Let's say that we were only interested in one kind of attribute above, ``version``.
-We can ask the command to only output this attribute.  To do this, you'd add
-the ``--attribute`` for attribute parameter, which defaults to all. Here is how you
-would filter to show just versions:
-
-.. code-block:: console
-
-    $ spack diff --attribute version python@2.7.8 python@3.8.11
-    ==> Warning: This interface is subject to change.
-
-    --- python@2.7.8/tsxdi6gl4lihp25qrm4d6nys3nypufbf
-    +++ python@3.8.11/yjtseru4nbpllbaxb46q7wfkyxbuvzxx
-    @@ version @@
-    -  openssl 1.0.2u
-    +  openssl 1.1.1k
-    -  python 2.7.8
-    +  python 3.8.11
-
-And you can add as many attributes as you'd like with multiple `--attribute` arguments
-(for lots of attributes, you can use ``-a`` for short). Finally, if you want to view the
-data as json (and possibly pipe into an output file) just add ``--json``:
-
-
-.. code-block:: console
-
-    $ spack diff --json python@2.7.8 python@3.8.11
-
-
-This data will be much longer because along with the differences for ``A`` vs. ``B`` and
-``B`` vs. ``A``, the JSON output also showsthe intersection.
-
-
-------------------------
-Using installed packages
-------------------------
-
-There are several different ways to use Spack packages once you have
-installed them. As you've seen, spack packages are installed into long
-paths with hashes, and you need a way to get them into your path. The
-easiest way is to use :ref:`spack load <cmd-spack-load>`, which is
-described in the next section.
-
-Some more advanced ways to use Spack packages include:
-
-* :ref:`environments <environments>`, which you can use to bundle a
-  number of related packages to "activate" all at once, and
-* :ref:`environment modules <modules>`, which are commonly used on
-  supercomputing clusters. Spack generates module files for every
-  installation automatically, and you can customize how this is done.
-
-.. _cmd-spack-load:
-
-^^^^^^^^^^^^^^^^^^^^^^^
-``spack load / unload``
-^^^^^^^^^^^^^^^^^^^^^^^
-
-If you have :ref:`shell support <shell-support>` enabled you can use the
-``spack load`` command to quickly get a package on your ``PATH``.
-
-For example this will add the ``mpich`` package built with ``gcc`` to
-your path:
-
-.. code-block:: console
-
-   $ spack install mpich %gcc@4.4.7
-
-   # ... wait for install ...
-
-   $ spack load mpich %gcc@4.4.7
-   $ which mpicc
-   ~/spack/opt/linux-debian7-x86_64/gcc@4.4.7/mpich@3.0.4/bin/mpicc
-
-These commands will add appropriate directories to your ``PATH``
-and ``MANPATH`` according to the
-:ref:`prefix inspections <customize-env-modifications>` defined in your
-modules configuration.
-When you no longer want to use a package, you can type unload or
-unuse similarly:
-
-.. code-block:: console
-
-   $ spack unload mpich %gcc@4.4.7
-
-
-"""""""""""""""
-Ambiguous specs
-"""""""""""""""
-
-If a spec used with load/unload or is ambiguous (i.e. more than one
-installed package matches it), then Spack will warn you:
-
-.. code-block:: console
-
-   $ spack load libelf
-   ==> Error: libelf matches multiple packages.
-   Matching packages:
-     qmm4kso libelf@0.8.13%gcc@4.4.7 arch=linux-debian7-x86_64
-     cd2u6jt libelf@0.8.13%intel@15.0.0 arch=linux-debian7-x86_64
-   Use a more specific spec
-
-You can either type the ``spack load`` command again with a fully
-qualified argument, or you can add just enough extra constraints to
-identify one package.  For example, above, the key differentiator is
-that one ``libelf`` is built with the Intel compiler, while the other
-used ``gcc``.  You could therefore just type:
-
-.. code-block:: console
-
-   $ spack load libelf %intel
-
-To identify just the one built with the Intel compiler. If you want to be
-*very* specific, you can load it by its hash. For example, to load the
-first ``libelf`` above, you would run:
-
-.. code-block:: console
-
-   $ spack load /qmm4kso
-
-To see which packages that you have loaded to your enviornment you would
-use ``spack find --loaded``.
-
-.. code-block:: console
-
-    $ spack find --loaded
-    ==> 2 installed packages
-    -- linux-debian7 / gcc@4.4.7 ------------------------------------
-    libelf@0.8.13
-
-    -- linux-debian7 / intel@15.0.0 ---------------------------------
-    libelf@0.8.13
-
-You can also use ``spack load --list`` to get the same output, but it
-does not have the full set of query options that ``spack find`` offers.
-
-We'll learn more about Spack's spec syntax in the next section.
-
-
 .. _sec-specs:
 
 --------------------
@@ -998,15 +713,11 @@ More formally, a spec consists of the following pieces:
 * ``%`` Optional compiler specifier, with an optional compiler version
   (``gcc`` or ``gcc@4.7.3``)
 * ``+`` or ``-`` or ``~`` Optional variant specifiers (``+debug``,
-  ``-qt``, or ``~qt``) for boolean variants. Use ``++`` or ``--`` or
-  ``~~`` to propagate variants through the dependencies (``++debug``,
-  ``--qt``, or ``~~qt``).
+  ``-qt``, or ``~qt``) for boolean variants
 * ``name=<value>`` Optional variant specifiers that are not restricted to
-  boolean variants. Use ``name==<value>`` to propagate variant through the
-  dependencies.
+  boolean variants
 * ``name=<value>`` Optional compiler flag specifiers. Valid flag names are
   ``cflags``, ``cxxflags``, ``fflags``, ``cppflags``, ``ldflags``, and ``ldlibs``.
-  Use ``name==<value>`` to propagate compiler flags through the dependencies.
 * ``target=<value> os=<value>`` Optional architecture specifier
   (``target=haswell os=CNL10``)
 * ``^`` Dependency specs (``^callpath@1.1``)
@@ -1097,8 +808,6 @@ could depend on ``mpich@1.2:`` if it can only build with version
 
 Below are more details about the specifiers that you can add to specs.
 
-.. _version-specifier:
-
 ^^^^^^^^^^^^^^^^^
 Version specifier
 ^^^^^^^^^^^^^^^^^
@@ -1114,37 +823,6 @@ set of arbitrary versions, such as ``@1.0,1.5,1.7`` (``1.0``, ``1.5``,
 or ``1.7``).  When you supply such a specifier to ``spack install``,
 it constrains the set of versions that Spack will install.
 
-For packages with a ``git`` attribute, ``git`` references 
-may be specified instead of a numerical version i.e. branches, tags 
-and commits. Spack will stage and build based off the ``git`` 
-reference provided.  Acceptable syntaxes for this are:
-
-.. code-block:: sh
-   
-    # branches and tags
-   foo@git.develop # use the develop branch
-   foo@git.0.19 # use the 0.19 tag
-   
-    # commit hashes
-   foo@abcdef1234abcdef1234abcdef1234abcdef1234    # 40 character hashes are automatically treated as git commits
-   foo@git.abcdef1234abcdef1234abcdef1234abcdef1234
-   
-Spack versions from git reference either have an associated version supplied by the user,
-or infer a relationship to known versions from the structure of the git repository. If an
-associated version is supplied by the user, Spack treats the git version as equivalent to that
-version for all version comparisons in the package logic (e.g. ``depends_on('foo', when='@1.5')``).
-
-The associated version can be assigned with ``[git ref]=[version]`` syntax, with the caveat that the specified version is known to Spack from either the package definition, or in the configuration preferences (i.e. ``packages.yaml``).
-
-.. code-block:: sh
-
-   foo@git.my_ref=3.2 # use the my_ref tag or branch, but treat it as version 3.2 for version comparisons
-   foo@git.abcdef1234abcdef1234abcdef1234abcdef1234=develop # use the given commit, but treat it as develop for version comparisons
-
-If an associated version is not supplied then the tags in the git repo are used to determine
-the most recent previous version known to Spack. Details about how versions are compared
-and how Spack determines if one version is less than another are discussed in the developer guide.
-
 If the version spec is not provided, then Spack will choose one
 according to policies set for the particular spack installation.  If
 the spec is ambiguous, i.e. it could match multiple versions, Spack
@@ -1184,7 +862,7 @@ Variants are named options associated with a particular package. They are
 optional, as each package must provide default values for each variant it
 makes available. Variants can be specified using
 a flexible parameter syntax ``name=<value>``. For example,
-``spack install mercury debug=True`` will install mercury built with debug
+``spack install libelf debug=True`` will install libelf built with debug
 flags. The names of particular variants available for a package depend on
 what was provided by the package author. ``spack info <package>`` will
 provide information on what build variants are available.
@@ -1192,11 +870,11 @@ provide information on what build variants are available.
 For compatibility with earlier versions, variants which happen to be
 boolean in nature can be specified by a syntax that represents turning
 options on and off. For example, in the previous spec we could have
-supplied ``mercury +debug`` with the same effect of enabling the debug
+supplied ``libelf +debug`` with the same effect of enabling the debug
 compile time option for the libelf package.
 
 Depending on the package a variant may have any default value.  For
-``mercury`` here, ``debug`` is ``False`` by default, and we turned it on
+``libelf`` here, ``debug`` is ``False`` by default, and we turned it on
 with ``debug=True`` or ``+debug``.  If a variant is ``True`` by default
 you can turn it off by either adding ``-name`` or ``~name`` to the spec.
 
@@ -1230,23 +908,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 +915,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"``,
@@ -1342,7 +998,7 @@ Normally users don't have to bother specifying the architecture if they
 are installing software for their current host, as in that case the
 values will be detected automatically.  If you need fine-grained control
 over which packages use which targets (or over *all* packages' default
-target), see :ref:`package-preferences`.
+target), see :ref:`concretization-preferences`.
 
 .. admonition:: Cray machines
 
@@ -1464,7 +1120,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
@@ -1578,88 +1234,6 @@ add a version specifier to the spec:
 Notice that the package versions that provide insufficient MPI
 versions are now filtered out.
 
-
------------------------------
-Deprecating insecure packages
------------------------------
-
-``spack deprecate`` allows for the removal of insecure packages with
-minimal impact to their dependents.
-
-.. warning::
-
-  The ``spack deprecate`` command is designed for use only in
-  extraordinary circumstances. This is a VERY big hammer to be used
-  with care.
-
-The ``spack deprecate`` command will remove one package and replace it
-with another by replacing the deprecated package's prefix with a link
-to the deprecator package's prefix.
-
-.. warning::
-
-  The ``spack deprecate`` command makes no promises about binary
-  compatibility. It is up to the user to ensure the deprecator is
-  suitable for the deprecated package.
-
-Spack tracks concrete deprecated specs and ensures that no future packages
-concretize to a deprecated spec.
-
-The first spec given to the ``spack deprecate`` command is the package
-to deprecate. It is an abstract spec that must describe a single
-installed package. The second spec argument is the deprecator
-spec. By default it must be an abstract spec that describes a single
-installed package, but with the ``-i/--install-deprecator`` it can be
-any abstract spec that Spack will install and then use as the
-deprecator. The ``-I/--no-install-deprecator`` option will ensure
-the default behavior.
-
-By default, ``spack deprecate`` will deprecate all dependencies of the
-deprecated spec, replacing each by the dependency of the same name in
-the deprecator spec. The ``-d/--dependencies`` option will ensure the
-default, while the ``-D/--no-dependencies`` option will deprecate only
-the root of the deprecate spec in favor of the root of the deprecator
-spec.
-
-``spack deprecate`` can use symbolic links or hard links. The default
-behavior is symbolic links, but the ``-l/--link-type`` flag can take
-options ``hard`` or ``soft``.
-
------------------------
-Verifying installations
------------------------
-
-The ``spack verify`` command can be used to verify the validity of
-Spack-installed packages any time after installation.
-
-At installation time, Spack creates a manifest of every file in the
-installation prefix. For links, Spack tracks the mode, ownership, and
-destination. For directories, Spack tracks the mode, and
-ownership. For files, Spack tracks the mode, ownership, modification
-time, hash, and size. The Spack verify command will check, for every
-file in each package, whether any of those attributes have changed. It
-will also check for newly added files or deleted files from the
-installation prefix. Spack can either check all installed packages
-using the `-a,--all` or accept specs listed on the command line to
-verify.
-
-The ``spack verify`` command can also verify for individual files that
-they haven't been altered since installation time. If the given file
-is not in a Spack installation prefix, Spack will report that it is
-not owned by any package. To check individual files instead of specs,
-use the ``-f,--files`` option.
-
-Spack installation manifests are part of the tarball signed by Spack
-for binary package distribution. When installed from a binary package,
-Spack uses the packaged installation manifest instead of creating one
-at install time.
-
-The ``spack verify`` command also accepts the ``-l,--local`` option to
-check only local packages (as opposed to those used transparently from
-``upstream`` spack instances) and the ``-j,--json`` option to output
-machine-readable json data for any errors.
-
-
 .. _extensions:
 
 ---------------------------
@@ -1756,7 +1330,6 @@ and it will be added to the ``PYTHONPATH`` in your current shell:
 
 Now ``import numpy`` will succeed for as long as you keep your current
 session open.
-The loaded packages can be checked using ``spack find --loaded``
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 Loading Extensions via Modules
@@ -1782,8 +1355,8 @@ Activating Extensions in a View
 
 Another way to use extensions is to create a view, which merges the
 python installation along with the extensions into a single prefix.
-See :ref:`configuring_environment_views` for a more in-depth description
-of views.
+See :ref:`filesystem-views` for a more in-depth description of views and
+:ref:`cmd-spack-view` for usage of the ``spack view`` command.
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 Activating Extensions Globally
@@ -1968,39 +1541,6 @@ This issue typically manifests with the error below:
 
 A nicer error message is TBD in future versions of Spack.
 
----------------
-Troubleshooting
----------------
-
-The ``spack audit`` command:
-
-.. command-output:: spack audit -h
-
-can be used to detect a number of configuration issues. This command detects
-configuration settings which might not be strictly wrong but are not likely
-to be useful outside of special cases.
-
-It can also be used to detect dependency issues with packages - for example
-cases where a package constrains a dependency with a variant that doesn't
-exist (in this case Spack could report the problem ahead of time but
-automatically performing the check would slow down most runs of Spack).
-
-A detailed list of the checks currently implemented for each subcommand can be
-printed with:
-
-.. command-output:: spack -v audit list
-
-Depending on the use case, users might run the appropriate subcommands to obtain
-diagnostics. Issues, if found, are reported to stdout:
-
-.. code-block:: console
-
-   % spack audit packages lammps
-   PKG-DIRECTIVES: 1 issue found
-   1. lammps: wrong variant in "conflicts" directive
-       the variant 'adios' does not exist
-       in /home/spack/spack/var/spack/repos/builtin/packages/lammps/package.py
-
 
 ------------
 Getting Help

lib/spack/docs/binary_caches.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2020 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -31,32 +31,9 @@ Build caches are created via:
 
 .. code-block:: console
 
-    $ spack buildcache create <spec>
+   $ spack buildcache create spec
 
 
-If you wanted to create a build cache in a local directory, you would provide
-the ``-d`` argument to target that directory, again also specifying the spec.
-Here is an example creating a local directory, "spack-cache" and creating
-build cache files for the "ninja" spec:
-
-.. code-block:: console
-
-    $ mkdir -p ./spack-cache
-    $ spack buildcache create -d ./spack-cache ninja
-    ==> Buildcache files will be output to file:///home/spackuser/spack/spack-cache/build_cache
-    gpgconf: socketdir is '/run/user/1000/gnupg'
-    gpg: using "E6DF6A8BD43208E4D6F392F23777740B7DBD643D" as default secret key for signing
-
-Note that the targeted spec must already be installed. Once you have a build cache,
-you can add it as a mirror, discussed next.
-
-.. warning::
-
-   Spack improved the format used for binary caches in v0.18. The entire v0.18 series
-   will be able to verify and install binary caches both in the new and in the old format.
-   Support for using the old format is expected to end in v0.19, so we advise users to
-   recreate relevant buildcaches using Spack v0.18 or higher.
-
 ---------------------------------------
 Finding or installing build cache files
 ---------------------------------------
@@ -66,98 +43,19 @@ with:
 
 .. code-block:: console
 
-    $ spack mirror add <name> <url>
-
-
-Note that the url can be a web url _or_ a local filesystem location. In the previous
-example, you might add the directory "spack-cache" and call it ``mymirror``:
+   $ spack mirror add <name> <url>
 
+Build caches are found via:
 
 .. code-block:: console
 
-    $ spack mirror add mymirror ./spack-cache
+   $ spack buildcache list
 
-
-You can see that the mirror is added with ``spack mirror list`` as follows:
+Build caches are installed via:
 
 .. code-block:: console
 
-
-    $ spack mirror list
-    mymirror           file:///home/spackuser/spack/spack-cache
-    spack-public       https://spack-llnl-mirror.s3-us-west-2.amazonaws.com/
-
-
-At this point, you've create a buildcache, but spack hasn't indexed it, so if
-you run ``spack buildcache list`` you won't see any results. You need to index
-this new build cache as follows:
-
-.. code-block:: console
-
-    $ spack buildcache update-index -d spack-cache/
-
-Now you can use list:
-
-.. code-block:: console
-
-    $  spack buildcache list
-    ==> 1 cached build.
-    -- linux-ubuntu20.04-skylake / gcc@9.3.0 ------------------------
-    ninja@1.10.2
-
-
-Great! So now let's say you have a different spack installation, or perhaps just
-a different environment for the same one, and you want to install a package from
-that build cache. Let's first uninstall the actual library "ninja" to see if we can
-re-install it from the cache.
-
-.. code-block:: console
-
-    $ spack uninstall ninja
-
-
-And now reinstall from the buildcache
-
-.. code-block:: console
-
-    $ spack buildcache install ninja
-    ==> buildcache spec(s) matching ninja 
-    ==> Fetching file:///home/spackuser/spack/spack-cache/build_cache/linux-ubuntu20.04-skylake/gcc-9.3.0/ninja-1.10.2/linux-ubuntu20.04-skylake-gcc-9.3.0-ninja-1.10.2-i4e5luour7jxdpc3bkiykd4imke3mkym.spack
-    ####################################################################################################################################### 100.0%
-    ==> Installing buildcache for spec ninja@1.10.2%gcc@9.3.0 arch=linux-ubuntu20.04-skylake
-    gpgconf: socketdir is '/run/user/1000/gnupg'
-    gpg: Signature made Tue 23 Mar 2021 10:16:29 PM MDT
-    gpg:                using RSA key E6DF6A8BD43208E4D6F392F23777740B7DBD643D
-    gpg: Good signature from "spackuser (GPG created for Spack) <spackuser@noreply.users.github.com>" [ultimate]
-
-
-It worked! You've just completed a full example of creating a build cache with
-a spec of interest, adding it as a mirror, updating it's index, listing the contents,
-and finally, installing from it.
-
-
-Note that the above command is intended to install a particular package to a
-build cache you have created, and not to install a package from a build cache.
-For the latter, once a mirror is added, by default when you do ``spack install`` the ``--use-cache``
-flag is set, and you will install a package from a build cache if it is available.
-If you want to always use the cache, you can do:
-
-.. code-block:: console
-
-   $ spack install --cache-only <package>
-
-For example, to combine all of the commands above to add the E4S build cache
-and then install from it exclusively, you would do:
-
-.. code-block:: console
-
-    $ spack mirror add E4S https://cache.e4s.io
-    $ spack buildcache keys --install --trust
-    $ spack install --cache-only <package>
-
-We use ``--install`` and ``--trust`` to say that we are installing keys to our
-keyring, and trusting all downloaded keys.
-
+   $ spack buildcache install
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 List of popular build caches

lib/spack/docs/bootstrapping.rst

@@ -1,173 +0,0 @@
-.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
-   Spack Project Developers. See the top-level COPYRIGHT file for details.
-
-   SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-.. _bootstrapping:
-
-=============
-Bootstrapping
-=============
-
-In the :ref:`Getting started <getting_started>` Section we already mentioned that
-Spack can bootstrap some of its dependencies, including ``clingo``. In fact, there
-is an entire command dedicated to the management of every aspect of bootstrapping:
-
-.. 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:
-
-.. code-block:: console
-
-   % spack bootstrap status
-   Spack v0.19.0 - python@3.8
-
-   [FAIL] Core Functionalities
-     [B] MISSING "clingo": required to concretize specs
-
-   [FAIL] Binary packages
-     [B] MISSING "gpg2": required to sign/verify buildcaches
-
-
-   Spack will take care of bootstrapping any missing dependency marked as [B]. Dependencies marked as [-] are instead required to be found on the system.
-
-In the case of the output shown above Spack detected that both ``clingo`` and ``gnupg``
-are missing and it's giving detailed information on why they are needed and whether
-they can be bootstrapped. Running a command that concretize a spec, like:
-
-.. code-block:: console
-
-   % spack solve zlib
-   ==> Bootstrapping clingo from pre-built binaries
-   ==> Fetching https://mirror.spack.io/bootstrap/github-actions/v0.1/build_cache/darwin-catalina-x86_64/apple-clang-12.0.0/clingo-bootstrap-spack/darwin-catalina-x86_64-apple-clang-12.0.0-clingo-bootstrap-spack-p5on7i4hejl775ezndzfdkhvwra3hatn.spack
-   ==> Installing "clingo-bootstrap@spack%apple-clang@12.0.0~docs~ipo+python build_type=Release arch=darwin-catalina-x86_64" from a buildcache
-   [ ... ]
-
-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
------------------------
-
-The software installed for bootstrapping purposes is deployed in a separate store.
-Its location can be checked with the following command:
-
-.. code-block:: console
-
-   % spack bootstrap root
-
-It can also be changed with the same command by just specifying the newly desired path:
-
-.. code-block:: console
-
-   % spack bootstrap root /opt/spack/bootstrap
-
-You can check what is installed in the bootstrapping store at any time using:
-
-.. code-block:: console
-
-   % spack find -b
-   ==> Showing internal bootstrap store at "/Users/spack/.spack/bootstrap/store"
-   ==> 11 installed packages
-   -- darwin-catalina-x86_64 / apple-clang@12.0.0 ------------------
-   clingo-bootstrap@spack  libassuan@2.5.5  libgpg-error@1.42  libksba@1.5.1  pinentry@1.1.1  zlib@1.2.11
-   gnupg@2.3.1             libgcrypt@1.9.3  libiconv@1.16      npth@1.6       python@3.8
-
-In case it is needed you can remove all the software in the current bootstrapping store with:
-
-.. code-block:: console
-
-   % spack clean -b
-   ==> Removing bootstrapped software and configuration in "/Users/spack/.spack/bootstrap"
-
-   % spack find -b
-   ==> Showing internal bootstrap store at "/Users/spack/.spack/bootstrap/store"
-   ==> 0 installed packages
-
---------------------------------------------
-Enabling and disabling bootstrapping methods
---------------------------------------------
-
-Bootstrapping is always performed by trying the methods listed by:
-
-.. command-output:: spack bootstrap list
-
-in the order they appear, from top to bottom. By default Spack is
-configured to try first bootstrapping from pre-built binaries and to
-fall-back to bootstrapping from sources if that failed.
-
-If need be, you can disable bootstrapping altogether by running:
-
-.. code-block:: console
-
-   % spack bootstrap disable
-
-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:
-
-.. code-block:: console
-
-   % spack bootstrap disable github-actions
-   ==> "github-actions" is now disabled 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
-
-There is also an option to reset the bootstrapping configuration to Spack's defaults:
-
-.. code-block:: console
-
-   % spack bootstrap reset
-   ==> Bootstrapping configuration is being reset to Spack's defaults. Current configuration will be lost.
-   Do you want to continue? [Y/n]
-   %
-
-----------------------------------------
-Creating a mirror for air-gapped systems
-----------------------------------------
-
-Spack's default configuration for bootstrapping relies on the user having
-access to the internet, either to fetch pre-compiled binaries or source tarballs.
-Sometimes though Spack is deployed on air-gapped systems where such access is denied.
-
-To help with similar situations Spack has a command that recreates, in a local folder
-of choice, a mirror containing the source tarballs and/or binary packages needed for
-bootstrapping.
-
-.. code-block:: console
-
-   % spack bootstrap mirror --binary-packages /opt/bootstrap
-   ==> Adding "clingo-bootstrap@spack+python %apple-clang target=x86_64" and dependencies to the mirror at /opt/bootstrap/local-mirror
-   ==> Adding "gnupg@2.3: %apple-clang target=x86_64" and dependencies to the mirror at /opt/bootstrap/local-mirror
-   ==> Adding "patchelf@0.13.1:0.13.99 %apple-clang target=x86_64" and dependencies to the mirror at /opt/bootstrap/local-mirror
-   ==> Adding binary packages from "https://github.com/alalazo/spack-bootstrap-mirrors/releases/download/v0.1-rc.2/bootstrap-buildcache.tar.gz" to the mirror at /opt/bootstrap/local-mirror
-
-   To register the mirror on the platform where it's supposed to be used run the following command(s):
-     % spack bootstrap add --trust local-sources /opt/bootstrap/metadata/sources
-     % spack bootstrap add --trust local-binaries /opt/bootstrap/metadata/binaries
-
-
-This command needs to be run on a machine with internet access and the resulting folder
-has to be moved over to the air-gapped system. Once the local sources are added using the
-commands suggested at the prompt, they can be used to bootstrap Spack.

lib/spack/docs/build_settings.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2020 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)
 
 .. _build-settings:
 
-================================
-Package Settings (packages.yaml)
-================================
+===================
+Build Customization
+===================
 
 Spack allows you to customize how your software is built through the
 ``packages.yaml`` file.  Using it, you can make Spack prefer particular
@@ -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
@@ -232,81 +209,11 @@ Specific limitations include:
   then Spack will not add a new external entry (``spack config blame packages``
   can help locate all external entries).
 
-.. _concretizer-options:
+.. _concretization-preferences:
 
-----------------------
-Concretizer options
-----------------------
-
-``packages.yaml`` gives the concretizer preferences for specific packages,
-but you can also use ``concretizer.yaml`` to customize aspects of the
-algorithm it uses to select the dependencies you install:
-
-.. literalinclude:: _spack_root/etc/spack/defaults/concretizer.yaml
-   :language: yaml
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Reuse already installed packages
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The ``reuse`` attribute controls whether Spack will prefer to use installed packages (``true``), or
-whether it will do a "fresh" installation and prefer the latest settings from
-``package.py`` files and ``packages.yaml`` (``false``).
-You can use:
-
-.. code-block:: console
-
-   % spack install --reuse <spec>
-
-to enable reuse for a single installation, and you can use:
-
-.. code-block:: console
-
-   spack install --fresh <spec>
-
-to do a fresh install if ``reuse`` is enabled by default.
-``reuse: true`` is the default.
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Selection of the target microarchitectures
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The options under the ``targets`` attribute control which targets are considered during a solve.
-Currently the options in this section are only configurable from the ``concretization.yaml`` file
-and there are no corresponding command line arguments to enable them for a single solve.
-
-The ``granularity`` option can take two possible values: ``microarchitectures`` and ``generic``.
-If set to:
-
-.. code-block:: yaml
-
-   concretizer:
-     targets:
-       granularity: microarchitectures
-
-Spack will consider all the microarchitectures known to ``archspec`` to label nodes for
-compatibility. If instead the option is set to:
-
-.. code-block:: yaml
-
-   concretizer:
-     targets:
-       granularity: generic
-
-Spack will consider only generic microarchitectures. For instance, when running on an
-Haswell node, Spack will consider ``haswell`` as the best target in the former case and
-``x86_64_v3`` as the best target in the latter case.
-
-The ``host_compatible`` option is a Boolean option that determines whether or not the
-microarchitectures considered during the solve are constrained to be compatible with the
-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
--------------------
+--------------------------
+Concretization Preferences
+--------------------------
 
 Spack can be configured to prefer certain compilers, package
 versions, dependencies, and variants during concretization.
@@ -362,127 +269,6 @@ 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
---------------------
-
-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``).
-
-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).
-
-The following is an example of how to enforce package properties in
-``packages.yaml``:
-
-.. code-block:: yaml
-
-   packages:
-     libfabric:
-       require: "@1.13.2"
-     openmpi:
-       require:
-       - any_of: ["~cuda", "%gcc"]
-     mpich:
-      require:
-      - one_of: ["+cuda", "+rocm"]
-
-Requirements are expressed using Spec syntax (the same as what is provided
-to ``spack install``). In the simplest case, you can specify attributes
-that you always want the package to have by providing a single spec to
-``require``; in the above example, ``libfabric`` will always build
-with version 1.13.2.
-
-You can provide a more-relaxed constraint and allow the concretizer to
-choose between a set of options using ``any_of`` or ``one_of``:
-
-* ``any_of`` is a list of specs. One of those specs must be satisfied
-  and it is also allowed for the concretized spec to match more than one.
-  In the above example, that means you could build ``openmpi+cuda%gcc``,
-  ``openmpi~cuda%clang`` or ``openmpi~cuda%gcc`` (in the last case,
-  note that both specs in the ``any_of`` for ``openmpi`` are
-  satisfied).
-* ``one_of`` is also a list of specs, and the final concretized spec
-  must match exactly one of them.  In the above example, that means
-  you could build ``mpich+cuda`` or ``mpich+rocm`` but not
-  ``mpich+cuda+rocm`` (note the current package definition for
-  ``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:
-
-.. code-block:: yaml
-
-   packages:
-     all:
-       require: '%clang'
-
-which means every spec will be required to use ``clang`` as a compiler.
-
-Note that in this case ``all`` represents a *default set of requirements* -
-if there are specific package requirements, then the default requirements
-under ``all`` are disregarded. For example, with a configuration like this:
-
-.. code-block:: yaml
-
-   packages:
-     all:
-       require: '%clang'
-     cmake:
-       require: '%gcc'
-
-Spack requires ``cmake`` to use ``gcc`` and all other nodes (including cmake dependencies)
-to use ``clang``.
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Setting requirements on virtual specs
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-A requirement on a virtual spec applies whenever that virtual is present in the DAG. This
-can be useful for fixing which virtual provider you want to use:
-
-.. code-block:: yaml
-
-   packages:
-     mpi:
-       require: 'mvapich2 %gcc'
-
-With the configuration above the only allowed ``mpi`` provider is ``mvapich2 %gcc``.
-
-Requirements on the virtual spec and on the specific provider are both applied, if present. For
-instance with a configuration like:
-
-.. code-block:: yaml
-
-   packages:
-     mpi:
-       require: 'mvapich2 %gcc'
-     mvapich2:
-       require: '~cuda'
-
-you will use ``mvapich2~cuda %gcc`` as an ``mpi`` provider.
-
 .. _package_permissions:
 
 -------------------

lib/spack/docs/build_systems.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2020 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)
@@ -39,7 +39,6 @@ on these ideas for each distinct build system that Spack supports:
 
    build_systems/autotoolspackage
    build_systems/cmakepackage
-   build_systems/cachedcmakepackage
    build_systems/mesonpackage
    build_systems/qmakepackage
    build_systems/sippackage
@@ -48,12 +47,10 @@ on these ideas for each distinct build system that Spack supports:
    :maxdepth: 1
    :caption: Language-specific
 
-   build_systems/luapackage
    build_systems/octavepackage
    build_systems/perlpackage
    build_systems/pythonpackage
    build_systems/rpackage
-   build_systems/racketpackage
    build_systems/rubypackage
 
 .. toctree::
@@ -62,11 +59,8 @@ on these ideas for each distinct build system that Spack supports:
 
    build_systems/bundlepackage
    build_systems/cudapackage
-   build_systems/custompackage
-   build_systems/inteloneapipackage
    build_systems/intelpackage
-   build_systems/rocmpackage
-   build_systems/sourceforgepackage
+   build_systems/custompackage
 
 For reference, the :py:mod:`Build System API docs <spack.build_systems>`
 provide a list of build systems and methods/attributes that can be

lib/spack/docs/build_systems/autotoolspackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2020 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _autotoolspackage:
 
----------
-Autotools
----------
+----------------
+AutotoolsPackage
+----------------
 
 Autotools is a GNU build system that provides a build-script generator.
 By running the platform-independent ``./configure`` script that comes
@@ -17,7 +17,7 @@ with the package, you can generate a platform-dependent Makefile.
 Phases
 ^^^^^^
 
-The ``AutotoolsBuilder`` and ``AutotoolsPackage`` base classes come with the following phases:
+The ``AutotoolsPackage`` base class comes with the following phases:
 
 #. ``autoreconf`` - generate the configure script
 #. ``configure`` - generate the Makefiles
@@ -112,44 +112,20 @@ phase runs:
 
 .. code-block:: console
 
-   $ autoreconf --install --verbose --force -I <aclocal-prefix>/share/aclocal
-
-In case you need to add more arguments, override ``autoreconf_extra_args``
-in your ``package.py`` on class scope like this:
-
-.. code-block:: python
-
-   autoreconf_extra_args = ["-Im4"]
+   $ libtoolize
+   $ aclocal
+   $ autoreconf --install --verbose --force
 
 All you need to do is add a few Autotools dependencies to the package.
 Most stable releases will come with a ``configure`` script, but if you
-check out a commit from the ``master`` branch, you would want to add:
+check out a commit from the ``develop`` branch, you would want to add:
 
 .. code-block:: python
 
-   depends_on('autoconf', type='build', when='@master')
-   depends_on('automake', type='build', when='@master')
-   depends_on('libtool',  type='build', when='@master')
-
-It is typically redundant to list the ``m4`` macro processor package as a
-dependency, since ``autoconf`` already depends on it.
-
-"""""""""""""""""""""""""""""""
-Using a custom autoreconf phase
-"""""""""""""""""""""""""""""""
-
-In some cases, it might be needed to replace the default implementation
-of the autoreconf phase with one running a script interpreter. In this
-example, the ``bash`` shell is used to run the ``autogen.sh`` script.
-
-.. code-block:: python
-
-   def autoreconf(self, spec, prefix):
-       which('bash')('autogen.sh')
-
-"""""""""""""""""""""""""""""""""""""""
-patching configure or Makefile.in files
-"""""""""""""""""""""""""""""""""""""""
+   depends_on('autoconf', type='build', when='@develop')
+   depends_on('automake', type='build', when='@develop')
+   depends_on('libtool',  type='build', when='@develop')
+   depends_on('m4',       type='build', when='@develop')
 
 In some cases, developers might need to distribute a patch that modifies
 one of the files used to generate ``configure`` or ``Makefile.in``.
@@ -159,57 +135,6 @@ create a new patch that directly modifies ``configure``. That way,
 Spack can use the secondary patch and additional build system
 dependencies aren't necessary.
 
-""""""""""""""""""""""""""""
-Old Autotools helper scripts
-""""""""""""""""""""""""""""
-
-Autotools based tarballs come with helper scripts such as ``config.sub`` and
-``config.guess``. It is the responsibility of the developers to keep these files
-up to date so that they run on every platform, but for very old software
-releases this is impossible. In these cases Spack can help to replace these
-files with newer ones, without having to add the heavy dependency on
-``automake``.
-
-Automatic helper script replacement is currently enabled by default on
-``ppc64le`` and ``aarch64``, as these are the known cases where old scripts fail.
-On these targets, ``AutotoolsPackage`` adds a build dependency on ``gnuconfig``,
-which is a very light-weight package with newer versions of the helper files.
-Spack then tries to run all the helper scripts it can find in the release, and
-replaces them on failure with the helper scripts from ``gnuconfig``.
-
-To opt out of this feature, use the following setting:
-
-.. code-block:: python
-
-   patch_config_files = False
-
-To enable it conditionally on different architectures, define a property and
-make the package depend on ``gnuconfig`` as a build dependency:
-
-.. code-block
-
-   depends_on('gnuconfig', when='@1.0:')
-
-   @property
-   def patch_config_files(self):
-      return self.spec.satisfies("@1.0:")
-
-.. note::
-
-    On some exotic architectures it is necessary to use system provided
-    ``config.sub`` and ``config.guess`` files. In this case, the most
-    transparent solution is to mark the ``gnuconfig`` package as external and
-    non-buildable, with a prefix set to the directory containing the files:
-
-   .. code-block:: yaml
-
-       gnuconfig:
-         buildable: false
-         externals:
-         - spec: gnuconfig@master
-           prefix: /usr/share/configure_files/
-
-
 """"""""""""""""
 force_autoreconf
 """"""""""""""""
@@ -230,7 +155,7 @@ version, this can be done like so:
 
    @property
    def force_autoreconf(self):
-       return self.version == Version('1.2.3')
+       return self.version == Version('1.2.3'):
 
 ^^^^^^^^^^^^^^^^^^^^^^^
 Finding configure flags
@@ -399,47 +324,8 @@ options:
 
    --with-libfabric=</path/to/libfabric>
 
-"""""""""""""""""""""""
-The ``variant`` keyword
-"""""""""""""""""""""""
-
-When Spack variants and configure flags do not correspond one-to-one, the
-``variant`` keyword can be passed to ``with_or_without`` and
-``enable_or_disable``. For example:
-
-.. code-block:: python
-
-   variant('debug_tools', default=False)
-   config_args += self.enable_or_disable('debug-tools', variant='debug_tools')
-
-Or when one variant controls multiple flags:
-
-.. code-block:: python
-
-   variant('debug_tools', default=False)
-   config_args += self.with_or_without('memchecker', variant='debug_tools')
-   config_args += self.with_or_without('profiler', variant='debug_tools')
-
-
 """"""""""""""""""""
-Conditional variants
-""""""""""""""""""""
-
-When a variant is conditional and its condition is not met on the concrete spec, the
-``with_or_without`` and ``enable_or_disable`` methods will simply return an empty list.
-
-For example:
-
-.. code-block:: python
-
-   variant('profiler', when='@2.0:')
-   config_args += self.with_or_without('profiler')
-
-will neither add ``--with-profiler`` nor ``--without-profiler`` when the version is
-below ``2.0``.
-
-""""""""""""""""""""
-Activation overrides
+activation overrides
 """"""""""""""""""""
 
 Finally, the behavior of either ``with_or_without`` or

lib/spack/docs/build_systems/bundlepackage.rst

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

lib/spack/docs/build_systems/cachedcmakepackage.rst

@@ -1,123 +0,0 @@
-.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
-   Spack Project Developers. See the top-level COPYRIGHT file for details.
-
-   SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-.. _cachedcmakepackage:
-
-------------------
-CachedCMakePackage
-------------------
-
-The CachedCMakePackage base class is used for CMake-based workflows
-that create a CMake cache file prior to running ``cmake``. This is
-useful for packages with arguments longer than the system limit, and
-for reproducibility.
-
-The documentation for this class assumes that the user is familiar with
-the ``CMakePackage`` class from which it inherits. See the documentation
-for :ref:`CMakePackage <cmakepackage>`.
-
-^^^^^^
-Phases
-^^^^^^
-
-The ``CachedCMakePackage`` base class comes with the following phases:
-
-#. ``initconfig`` - generate the CMake cache file
-#. ``cmake`` - generate the Makefile
-#. ``build`` - build the package
-#. ``install`` - install the package
-
-By default, these phases run:
-
-.. code-block:: console
-
-   $ mkdir spack-build
-   $ cd spack-build
-   $ cat << EOF > name-arch-compiler@version.cmake
-   # Write information on compilers and dependencies
-   # includes information on mpi and cuda if applicable
-   $ cmake .. -DCMAKE_INSTALL_PREFIX=/path/to/installation/prefix -C name-arch-compiler@version.cmake
-   $ make
-   $ make test  # optional
-   $ make install
-
-The ``CachedCMakePackage`` class inherits from the ``CMakePackage``
-class, and accepts all of the same options and adds all of the same
-flags to the ``cmake`` command. Similar to the ``CMakePAckage`` class,
-you may need to add a few arguments yourself, and the
-``CachedCMakePackage`` provides the same interface to add those
-flags.
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Adding entries to the CMake cache
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-In addition to adding flags to the ``cmake`` command, you may need to
-add entries to the CMake cache in the ``initconfig`` phase. This can
-be done by overriding one of four methods:
-
-#. ``CachedCMakePackage.initconfig_compiler_entries``
-#. ``CachedCMakePackage.initconfig_mpi_entries``
-#. ``CachedCMakePackage.initconfig_hardware_entries``
-#. ``CachedCMakePackage.initconfig_package_entries``
-
-Each of these methods returns a list of CMake cache strings. The
-distinction between these methods is merely to provide a
-well-structured and legible cmake cache file -- otherwise, entries
-from each of these methods are handled identically.
-
-Spack also provides convenience methods for generating CMake cache
-entries. These methods are available at module scope in every Spack
-package. Because CMake parses boolean options, strings, and paths
-differently, there are three such methods:
-
-#. ``cmake_cache_option``
-#. ``cmake_cache_string``
-#. ``cmake_cache_path``
-
-These methods each accept three parameters -- the name of the CMake
-variable associated with the entry, the value of the entry, and an
-optional comment -- and return strings in the appropriate format to be
-returned from any of the ``initconfig*`` methods. Additionally, these
-methods may return comments beginning with the ``#`` character.
-
-A typical usage of these methods may look something like this:
-
-.. code-block:: python
-
-   def initconfig_mpi_entries(self)
-       # Get existing MPI configurations
-       entries = super(self, Foo).initconfig_mpi_entries()
-
-       # The existing MPI configurations key on whether ``mpi`` is in the spec
-       # This spec has an MPI variant, and we need to enable MPI when it is on.
-       # This hypothetical package controls MPI with the ``FOO_MPI`` option to
-       # cmake.
-       if '+mpi' in self.spec:
-           entries.append(cmake_cache_option('FOO_MPI', True, "enable mpi"))
-       else:
-           entries.append(cmake_cache_option('FOO_MPI', False, "disable mpi"))
-
-   def initconfig_package_entries(self):
-       # Package specific options
-       entries = []
-
-       entries.append('#Entries for build options')
-
-       bar_on = '+bar' in self.spec
-       entries.append(cmake_cache_option('FOO_BAR', bar_on, 'toggle bar'))
-
-       entries.append('#Entries for dependencies')
-
-       if self.spec['blas'].name == 'baz':  # baz is our blas provider
-       entries.append(cmake_cache_string('FOO_BLAS', 'baz', 'Use baz'))
-       entries.append(cmake_cache_path('BAZ_PREFIX', self.spec['baz'].prefix))
-
-^^^^^^^^^^^^^^^^^^^^^^
-External documentation
-^^^^^^^^^^^^^^^^^^^^^^
-
-For more information on CMake cache files, see:
-https://cmake.org/cmake/help/latest/manual/cmake.1.html

lib/spack/docs/build_systems/cmakepackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2020 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _cmakepackage:
 
------
-CMake
------
+------------
+CMakePackage
+------------
 
 Like Autotools, CMake is a widely-used build-script generator. Designed
 by Kitware, CMake is the most popular build system for new C, C++, and
@@ -21,7 +21,7 @@ whereas Autotools is Unix-only.
 Phases
 ^^^^^^
 
-The ``CMakeBuilder`` and ``CMakePackage`` base classes come with the following phases:
+The ``CMakePackage`` base class comes with the following phases:
 
 #. ``cmake`` - generate the Makefile
 #. ``build`` - build the package
@@ -130,8 +130,8 @@ Adding flags to cmake
 To add additional flags to the ``cmake`` call, simply override the
 ``cmake_args`` function. The following example defines values for the flags
 ``WHATEVER``, ``ENABLE_BROKEN_FEATURE``, ``DETECT_HDF5``, and ``THREADS`` with
-and without the :meth:`~spack.build_systems.cmake.CMakeBuilder.define` and
-:meth:`~spack.build_systems.cmake.CMakeBuilder.define_from_variant` helper functions:
+and without the :py:meth:`~.CMakePackage.define` and
+:py:meth:`~.CMakePackage.define_from_variant` helper functions:
 
 .. code-block:: python
 
@@ -145,99 +145,6 @@ and without the :meth:`~spack.build_systems.cmake.CMakeBuilder.define` and
 
        return args
 
-Spack supports CMake defines from conditional variants too. Whenever the condition on
-the variant is not met, ``define_from_variant()`` will simply return an empty string,
-and CMake simply ignores the empty command line argument. For example the following
-
-.. code-block:: python
-
-   variant('example', default=True, when='@2.0:')
-
-   def cmake_args(self):
-      return [self.define_from_variant('EXAMPLE', 'example')]
-
-will generate ``'cmake' '-DEXAMPLE=ON' ...`` when `@2.0: +example` is met, but will
-result in ``'cmake' '' ...`` when the spec version is below ``2.0``.
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-CMake arguments provided by Spack
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The following default arguments are controlled by Spack:
-
-
-``CMAKE_INSTALL_PREFIX``
-------------------------
-
-Is set to the the package's install directory.
-
-
-``CMAKE_PREFIX_PATH``
----------------------
-
-CMake finds dependencies through calls to ``find_package()``, ``find_program()``,
-``find_library()``, ``find_file()``, and ``find_path()``, which use a list of search
-paths from ``CMAKE_PREFIX_PATH``. Spack sets this variable to a list of prefixes of the
-spec's transitive dependencies.
-
-For troubleshooting cases where CMake fails to find a dependency, add the
-``--debug-find`` flag to ``cmake_args``.
-
-``CMAKE_BUILD_TYPE``
---------------------
-
-Every CMake-based package accepts a ``-DCMAKE_BUILD_TYPE`` flag to
-dictate which level of optimization to use. In order to ensure
-uniformity across packages, the ``CMakePackage`` base class adds
-a variant to control this:
-
-.. code-block:: python
-
-   variant('build_type', default='RelWithDebInfo',
-           description='CMake build type',
-           values=('Debug', 'Release', 'RelWithDebInfo', 'MinSizeRel'))
-
-However, not every CMake package accepts all four of these options.
-Grep the ``CMakeLists.txt`` file to see if the default values are
-missing or replaced. For example, the
-`dealii <https://github.com/spack/spack/blob/develop/var/spack/repos/builtin/packages/dealii/package.py>`_
-package overrides the default variant with:
-
-.. code-block:: python
-
-   variant('build_type', default='DebugRelease',
-           description='The build type to build',
-           values=('Debug', 'Release', 'DebugRelease'))
-
-For more information on ``CMAKE_BUILD_TYPE``, see:
-https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html
-
-
-``CMAKE_INSTALL_RPATH`` and ``CMAKE_INSTALL_RPATH_USE_LINK_PATH=ON``
---------------------------------------------------------------------
-
-CMake uses different RPATHs during the build and after installation, so that executables
-can locate the libraries they're linked to during the build, and installed executables
-do not have RPATHs to build directories. In Spack, we have to make sure that RPATHs are
-set properly after installation.
-
-Spack sets ``CMAKE_INSTALL_RPATH`` to a list of ``<prefix>/lib`` or ``<prefix>/lib64``
-directories of the spec's link-type dependencies. Apart from that, it sets
-``-DCMAKE_INSTALL_RPATH_USE_LINK_PATH=ON``, which should add RPATHs for directories of
-linked libraries not in the directories covered by ``CMAKE_INSTALL_RPATH``.
-
-Usually it's enough to set only ``-DCMAKE_INSTALL_RPATH_USE_LINK_PATH=ON``, but the
-reason to provide both options is that packages may dynamically open shared libraries,
-which CMake cannot detect. In those cases, the RPATHs from ``CMAKE_INSTALL_RPATH`` are
-used as search paths.
-
-.. note::
-
-   Some packages provide stub libraries, which contain an interface for linking without
-   an implementation. When using such libraries, it's best to override the option
-   ``-DCMAKE_INSTALL_RPATH_USE_LINK_PATH=OFF`` in ``cmake_args``, so that stub libraries
-   are not used at runtime.
-
 
 ^^^^^^^^^^
 Generators
@@ -275,6 +182,36 @@ generators, but it should be simple to add support for alternative
 generators. For more information on CMake generators, see:
 https://cmake.org/cmake/help/latest/manual/cmake-generators.7.html
 
+^^^^^^^^^^^^^^^^
+CMAKE_BUILD_TYPE
+^^^^^^^^^^^^^^^^
+
+Every CMake-based package accepts a ``-DCMAKE_BUILD_TYPE`` flag to
+dictate which level of optimization to use. In order to ensure
+uniformity across packages, the ``CMakePackage`` base class adds
+a variant to control this:
+
+.. code-block:: python
+
+   variant('build_type', default='RelWithDebInfo',
+           description='CMake build type',
+           values=('Debug', 'Release', 'RelWithDebInfo', 'MinSizeRel'))
+
+However, not every CMake package accepts all four of these options.
+Grep the ``CMakeLists.txt`` file to see if the default values are
+missing or replaced. For example, the
+`dealii <https://github.com/spack/spack/blob/develop/var/spack/repos/builtin/packages/dealii/package.py>`_
+package overrides the default variant with:
+
+.. code-block:: python
+
+   variant('build_type', default='DebugRelease',
+           description='The build type to build',
+           values=('Debug', 'Release', 'DebugRelease'))
+
+For more information on ``CMAKE_BUILD_TYPE``, see:
+https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html
+
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 CMakeLists.txt in a sub-directory
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

lib/spack/docs/build_systems/cudapackage.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2020 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)
@@ -9,120 +9,35 @@
 CudaPackage
 -----------
 
-Different from other packages, ``CudaPackage`` does not represent a build system.
-Instead its goal is to simplify and unify usage of ``CUDA`` in other packages by providing a `mixin-class <https://en.wikipedia.org/wiki/Mixin>`_.
+Different from other packages, ``CudaPackage`` does not represent a build
+system. Instead its goal is to simplify and unify usage of ``CUDA`` in other
+packages.
 
-You can find source for the package at
-`<https://github.com/spack/spack/blob/develop/lib/spack/spack/build_systems/cuda.py>`__.
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Provided variants and dependencies
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-^^^^^^^^
-Variants
-^^^^^^^^
-
-This package provides the following variants:
-
-* **cuda**
-
-  This variant is used to enable/disable building with ``CUDA``. The default
-  is disabled (or ``False``).
-
-* **cuda_arch**
-
-  This variant supports the optional specification of the architecture.
-  Valid values are maintained in the ``cuda_arch_values`` property and
-  are the numeric character equivalent of the compute capability version
-  (e.g., '10' for version 1.0). Each provided value affects associated
-  ``CUDA`` dependencies and compiler conflicts.
-
-  GPUs and their compute capability versions are listed at
-  https://developer.nvidia.com/cuda-gpus .
-
-^^^^^^^^^
-Conflicts
-^^^^^^^^^
-
-Conflicts are used to prevent builds with known bugs or issues. While
-base ``CUDA`` conflicts have been included with this package, you may
-want to add more for your software.
-
-For example, if your package requires ``cuda_arch`` to be specified when
-``cuda`` is enabled, you can add the following conflict to your package
-to terminate such build attempts with a suitable message:
-
-.. code-block:: python
-
-    conflicts('cuda_arch=none', when='+cuda',
-              msg='CUDA architecture is required')
-
-Similarly, if your software does not support all versions of the property,
-you could add ``conflicts`` to your package for those versions.  For example,
-suppose your software does not work with CUDA compute capability versions
-prior to SM 5.0 (``50``).  You can add the following code to display a
-custom message should a user attempt such a build:
-
-.. code-block:: python
-
-    unsupported_cuda_archs = [
-        '10', '11', '12', '13',
-        '20', '21',
-        '30', '32', '35', '37'
-    ]
-    for value in unsupported_cuda_archs:
-        conflicts('cuda_arch={0}'.format(value), when='+cuda',
-                  msg='CUDA architecture {0} is not supported'.format(value))
-
-^^^^^^^
-Methods
-^^^^^^^
-
-This package provides one custom helper method, which is used to build
-standard CUDA compiler flags.
-
-**cuda_flags**
-
-    This built-in static method returns a list of command line flags 
-    for the chosen ``cuda_arch`` value(s).  The flags are intended to
-    be passed to the CUDA compiler driver (i.e., ``nvcc``).
-
-    This method must be explicitly called when you are creating the
-    arguments for your build in order to use the values.
+``CudaPackage`` provides ``cuda`` variant (default to ``off``) to enable/disable
+``CUDA``, and ``cuda_arch`` variant to optionally specify the architecture.
+It also declares dependencies on the ``CUDA`` package ``depends_on('cuda@...')``
+based on the architecture as well as specifies conflicts for certain compiler versions.
 
 ^^^^^
 Usage
 ^^^^^
 
-This helper package can be added to your package by adding it as a base
-class of your package.  For example, you can add it to your
-:ref:`CMakePackage <cmakepackage>`-based package as follows:
+In order to use it, just add another base class to your package, for example:
 
 .. code-block:: python
-   :emphasize-lines: 1,7-16
 
-    class MyCudaPackage(CMakePackage, CudaPackage):
+    class MyPackage(CMakePackage, CudaPackage):
         ...
         def cmake_args(self):
             spec = self.spec
-            args = []
-            ...
             if '+cuda' in spec:
-                # Set up the cuda macros needed by the build
-                args.append('-DWITH_CUDA=ON')
-                cuda_arch_list = spec.variants['cuda_arch'].value
-                cuda_arch = cuda_arch_list[0]
+                options.append('-DWITH_CUDA=ON')
+                cuda_arch = spec.variants['cuda_arch'].value
                 if cuda_arch != 'none':
-                    args.append('-DCUDA_FLAGS=-arch=sm_{0}'.format(cuda_arch))
+                    options.append('-DCUDA_FLAGS=-arch=sm_{0}'.format(cuda_arch[0]))
             else:
-                # Ensure build with cuda is disabled
-                args.append('-DWITH_CUDA=OFF')
-            ...
-            return args
-
-assuming only the ``WITH_CUDA`` and ``CUDA_FLAGS`` flags are required.
-You will need to customize options as needed for your build.
-
-This example also illustrates how to check for the ``cuda`` variant using
-``self.spec`` and how to retrieve the ``cuda_arch`` variant's value, which
-is a list, using ``self.spec.variants['cuda_arch'].value``.
-
-With over 70 packages using ``CudaPackage`` as of January 2021 there are
-lots of examples to choose from to get more ideas for using this package.
+                options.append('-DWITH_CUDA=OFF')

lib/spack/docs/build_systems/custompackage.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2020 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)
@@ -9,7 +9,7 @@
 Custom Build Systems
 --------------------
 
-While the built-in build systems should meet your needs for the
+While the build systems listed above should meet your needs for the
 vast majority of packages, some packages provide custom build scripts.
 This guide is intended for the following use cases:
 
@@ -31,7 +31,7 @@ installation. Both of these packages require custom build systems.
 Base class
 ^^^^^^^^^^
 
-If your package does not belong to any of the built-in build
+If your package does not belong to any of the aforementioned build
 systems that Spack already supports, you should inherit from the
 ``Package`` base class. ``Package`` is a simple base class with a
 single phase: ``install``. If your package is simple, you may be able
@@ -168,21 +168,26 @@ if and only if this flag is set, we would use the following line:
 Testing
 ^^^^^^^
 
-Let's put everything together and add unit tests to be optionally run
-during the installation of our package.
+Let's put everything together and add unit tests to our package.
 In the ``perl`` package, we can see:
 
 .. code-block:: python
 
    @run_after('build')
    @on_package_attributes(run_tests=True)
-   def test(self):
+   def build_test(self):
        make('test')
 
 As you can guess, this runs ``make test`` *after* building the package,
 if and only if testing is requested. Again, this is not specific to
 custom build systems, it can be added to existing build systems as well.
 
+Ideally, every package in Spack will have some sort of test to ensure
+that it was built correctly. It is up to the package authors to make
+sure this happens. If you are adding a package for some software and
+the developers list commands to test the installation, please add these
+tests to your ``package.py``.
+
 .. warning::
 
    The order of decorators matters. The following ordering:
@@ -202,12 +207,3 @@ custom build systems, it can be added to existing build systems as well.
    the tests will always be run regardless of whether or not
    ``--test=root`` is requested. See https://github.com/spack/spack/issues/3833
    for more information
-
-Ideally, every package in Spack will have some sort of test to ensure
-that it was built correctly. It is up to the package authors to make
-sure this happens. If you are adding a package for some software and
-the developers list commands to test the installation, please add these
-tests to your ``package.py``.
-
-For more information on other forms of package testing, refer to
-:ref:`Checking an installation <checking_an_installation>`.

lib/spack/docs/build_systems/inteloneapipackage.rst

@@ -1,155 +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)
-
-.. _inteloneapipackage:
-
-
-====================
- IntelOneapiPackage
-====================
-
-
-.. contents::
-
-
-oneAPI packages in Spack
-========================
-
-Spack can install and use the Intel oneAPI products. You may either
-use spack to install the oneAPI tools or use the `Intel
-installers`_. After installation, you may use the tools directly, or
-use Spack to build packages with the tools.
-
-The Spack Python class ``IntelOneapiPackage`` is a base class that is
-used by ``IntelOneapiCompilers``, ``IntelOneapiMkl``,
-``IntelOneapiTbb`` and other classes to implement the oneAPI
-packages. See the :ref:`package-list` for the full list of available
-oneAPI packages or use::
-
-  spack list -d oneAPI
-
-For more information on a specific package, do::
-
-  spack info --all <package-name>
-
-Intel no longer releases new versions of Parallel Studio, which can be
-used in Spack via the :ref:`intelpackage`. All of its components can
-now be found in oneAPI. 
-
-Examples
-========
-
-Building a Package With icx
----------------------------
-
-In this example, we build patchelf with ``icc`` and ``icx``. The
-compilers are installed with spack.
-
-Install the oneAPI compilers::
-
-  spack install intel-oneapi-compilers
-
-Add the compilers to your ``compilers.yaml`` so spack can use them::
-
-  spack compiler add `spack location -i intel-oneapi-compilers`/compiler/latest/linux/bin/intel64
-  spack compiler add `spack location -i intel-oneapi-compilers`/compiler/latest/linux/bin
-
-Verify that the compilers are available::
-
-  spack compiler list
-
-The ``intel-oneapi-compilers`` package includes 2 families of
-compilers:
-
-* ``intel``: ``icc``, ``icpc``, ``ifort``. Intel's *classic*
-  compilers.
-* ``oneapi``: ``icx``, ``icpx``, ``ifx``. Intel's new generation of
-  compilers based on LLVM.
-
-To build the ``patchelf`` Spack package with ``icc``, do::
-
-  spack install patchelf%intel
-
-To build with with ``icx``, do ::
-
-  spack install patchelf%oneapi
-
-Using oneAPI MPI to Satisfy a Virtual Dependence
-------------------------------------------------------
-
-The ``hdf5`` package works with any compatible MPI implementation. To
-build ``hdf5`` with Intel oneAPI MPI do::
-
-  spack install hdf5 +mpi ^intel-oneapi-mpi
-
-Using Externally Installed oneAPI Tools
-=======================================
-
-Spack can also use oneAPI tools that are manually installed with
-`Intel Installers`_.  The procedures for configuring Spack to use
-external compilers and libraries are different.
-
-Compilers
----------
-
-To use the compilers, add some information about the installation to
-``compilers.yaml``. For most users, it is sufficient to do::
-
-  spack compiler add /opt/intel/oneapi/compiler/latest/linux/bin/intel64
-  spack compiler add /opt/intel/oneapi/compiler/latest/linux/bin
-
-Adapt the paths above if you did not install the tools in the default
-location. After adding the compilers, using them is the same
-as if you had installed the ``intel-oneapi-compilers`` package.
-Another option is to manually add the configuration to
-``compilers.yaml`` as described in :ref:`Compiler configuration
-<compiler-config>`.
-
-Libraries
----------
-
-If you want Spack to use oneMKL that you have installed without Spack in
-the default location, then add the following to
-``~/.spack/packages.yaml``, adjusting the version as appropriate::
-
-  intel-oneapi-mkl:
-    externals:
-    - spec: intel-oneapi-mkl@2021.1.1
-      prefix: /opt/intel/oneapi/
-
-
-Using oneAPI Tools Installed by Spack
-=====================================
-
-Spack can be a convenient way to install and configure compilers and
-libaries, even if you do not intend to build a Spack package. If you
-want to build a Makefile project using Spack-installed oneAPI compilers,
-then use spack to configure your environment::
-
-  spack load intel-oneapi-compilers
-
-And then you can build with::
-
-  CXX=icpx make
-
-You can also use Spack-installed libraries. For example::
-
-  spack load intel-oneapi-mkl
-
-Will update your environment CPATH, LIBRARY_PATH, and other
-environment variables for building an application with oneMKL.
-
-More information
-================
-
-This section describes basic use of oneAPI, especially if it has
-changed compared to Parallel Studio. See :ref:`intelpackage` for more
-information on :ref:`intel-virtual-packages`,
-:ref:`intel-unrelated-packages`,
-:ref:`intel-integrating-external-libraries`, and
-:ref:`using-mkl-tips`.
-
-
-.. _`Intel installers`: https://software.intel.com/content/www/us/en/develop/documentation/installation-guide-for-intel-oneapi-toolkits-linux/top.html

lib/spack/docs/build_systems/intelpackage.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2020 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -15,9 +15,6 @@ IntelPackage
 Intel packages in Spack
 ^^^^^^^^^^^^^^^^^^^^^^^^
 
-This is an earlier version of Intel software development tools and has
-now been replaced by Intel oneAPI Toolkits.
-
 Spack can install and use several software development products offered by Intel.
 Some of these are available under no-cost terms, others require a paid license.
 All share the same basic steps for configuration, installation, and, where
@@ -140,7 +137,6 @@ If you need to save disk space or installation time, you could install the
 ``intel`` compilers-only subset (0.6 GB) and just the library packages you
 need, for example ``intel-mpi`` (0.5 GB) and ``intel-mkl`` (2.5 GB).
 
-.. _intel-unrelated-packages:
 
 """"""""""""""""""""
 Unrelated packages
@@ -362,8 +358,6 @@ affected by an advanced third method:
 Next, visit section `Selecting Intel Compilers`_ to learn how to tell
 Spack to use the newly configured compilers.
 
-.. _intel-integrating-external-libraries:
-
 """"""""""""""""""""""""""""""""""
 Integrating external libraries
 """"""""""""""""""""""""""""""""""
@@ -564,29 +558,43 @@ follow `the next section <intel-install-libs_>`_ instead.
              modules:    []
              spec:       intel@18.0.3
              paths:
-               cc:       /usr/bin/true
-               cxx:      /usr/bin/true
-               f77:      /usr/bin/true
-               fc:       /usr/bin/true
+               cc:       stub
+               cxx:      stub
+               f77:      stub
+               fc:       stub
 
       Replace ``18.0.3`` with the version that you determined in the preceding
-      step. The exact contents under ``paths:`` do not matter yet, but the paths must exist.
+      step. The contents under ``paths:`` do not matter yet.
 
-   This temporary stub is required such that the ``intel-parallel-studio`` package
-   can be installed for the ``intel`` compiler (which the package itself is going
-   to provide after the installation) rather than an arbitrary system compiler.
-   The paths given in ``cc``, ``cxx``, ``f77``, ``fc`` must exist, but will
-   never be used to build anything during the installation of ``intel-parallel-studio``.
+   You are right to ask: "Why on earth is that necessary?" [fn8]_.
+   The answer lies in Spack striving for strict compiler consistency.
+   Consider what happens without such a pre-declared compiler stub:
+   Say, you ask Spack to install a particular version
+   ``intel-parallel-studio@edition.V``.  Spack will apply an unrelated compiler
+   spec to concretize and install your request, resulting in
+   ``intel-parallel-studio@edition.V %X``. That compiler ``%X`` is not going to
+   be the version that this new package itself provides. Rather, it would
+   typically be ``%gcc@...`` in a default Spack installation or possibly indeed
+   ``%intel@...``, but at a version that precedes ``V``.
 
-   The reason for this stub is that ``intel-parallel-studio`` also provides the
-   ``mpi`` and ``mkl`` packages and when concretizing a spec, Spack ensures
-   strong consistency of the used compiler across all dependencies:  [fn8]_.
-   Installing a package ``foo +mkl %intel`` will make Spack look for a package
-   ``mkl %intel``, which can be provided by ``intel-parallel-studio+mkl %intel``,
-   but not by ``intel-parallel-studio+mkl %gcc``.
+   The problem comes to the fore as soon as you try to use any virtual ``mkl``
+   or ``mpi`` packages that you would expect to now be provided by
+   ``intel-parallel-studio@edition.V``.  Spack will indeed see those virtual
+   packages, but only as being tied to the compiler that the package
+   ``intel-parallel-studio@edition.V`` was concretized with *at installation*.
+   If you were to install a client package with the new compilers now available
+   to you, you would naturally run ``spack install foo +mkl %intel@V``, yet
+   Spack will either complain about ``mkl%intel@V`` being missing (because it
+   only knows about ``mkl%X``) or it will go and attempt to install *another
+   instance* of ``intel-parallel-studio@edition.V %intel@V`` so as to match the
+   compiler spec ``%intel@V`` that you gave for your client package ``foo``.
+   This will be unexpected and will quickly get annoying because each
+   reinstallation takes up time and extra disk space.
 
-   Failure to do so may result in additional installations of ``mkl``, ``intel-mpi`` or
-   even ``intel-parallel-studio`` as dependencies for other packages.
+   To escape this trap, put the compiler stub declaration shown here in place,
+   then use that pre-declared compiler spec to install the actual package, as
+   shown next.  This approach works because during installation only the
+   package's own self-sufficient installer will be used, not any compiler.
 
    .. _`verify-compiler-anticipated`:
 
@@ -637,25 +645,11 @@ follow `the next section <intel-install-libs_>`_ instead.
      want to use the ``intel64`` variant.  The ``icpc`` and ``ifort`` compilers
      will be located in the same directory as ``icc``.
 
-   * Make sure to specify ``modules: ['intel-parallel-studio-cluster2018.3-intel-18.0.3-HASH']``
-     (with ``HASH`` being the short hash as displayed when running
-     ``spack find -l intel-parallel-studio@cluster.2018.3`` and the versions adapted accordingly)
-     to ensure that the correct and complete environment for the Intel compilers gets
-     loaded when running them. With modern versions of the Intel compiler you may otherwise see
-     issues about missing libraries. Please also note that module name must exactly match
-     the name as returned by ``module avail`` (and shown in the example above).
-
-   * Use the ``modules:`` and/or ``cflags:`` tokens to further specify a suitable accompanying
+   * Use the ``modules:`` and/or ``cflags:`` tokens to specify a suitable accompanying
      ``gcc`` version to help pacify picky client packages that ask for C++
      standards more recent than supported by your system-provided ``gcc`` and its
      ``libstdc++.so``.
 
-   * If you specified a custom variant (for example ``+vtune``) you may want to add this as your
-     preferred variant in the packages configuration for the ``intel-parallel-studio`` package
-     as described in :ref:`package-preferences`. Otherwise you will have to specify
-     the variant everytime ``intel-parallel-studio`` is being used as ``mkl``, ``fftw`` or ``mpi``
-     implementation to avoid pulling in a different variant.
-
    * To set the Intel compilers for default use in Spack, instead of the usual ``%gcc``,
      follow section `Selecting Intel compilers`_.
 
@@ -814,13 +808,13 @@ by one of the following means:
      $ spack install libxc@3.0.0%intel
 
 
-* Alternatively, request Intel compilers implicitly by package preferences.
+* Alternatively, request Intel compilers implicitly by concretization preferences.
   Configure the order of compilers in the appropriate ``packages.yaml`` file,
   under either an ``all:`` or client-package-specific entry, in a
   ``compiler:`` list. Consult the Spack documentation for
   `Configuring Package Preferences <https://spack-tutorial.readthedocs.io/en/latest/tutorial_configuration.html#configuring-package-preferences>`_
   and
-  :ref:`Package Preferences <package-preferences>`.
+  :ref:`Concretization Preferences <concretization-preferences>`.
 
 Example: ``etc/spack/packages.yaml`` might simply contain:
 
@@ -840,7 +834,6 @@ for example:
       compiler: [ intel@18, intel@17, gcc@4.4.7, gcc@4.9.3, gcc@7.3.0, ]
 
 
-.. _intel-virtual-packages:
 
 """"""""""""""""""""""""""""""""""""""""""""""""
 Selecting libraries to satisfy virtual packages
@@ -870,7 +863,7 @@ virtual package, in order of decreasing preference.  To learn more about the
 ``providers:`` settings, see the Spack tutorial for
 `Configuring Package Preferences <https://spack-tutorial.readthedocs.io/en/latest/tutorial_configuration.html#configuring-package-preferences>`_
 and the section
-:ref:`Package Preferences <package-preferences>`.
+:ref:`Concretization Preferences <concretization-preferences>`.
 
 Example: The following fairly minimal example for ``packages.yaml`` shows how
 to exclusively use the standalone ``intel-mkl`` package for all the linear
@@ -914,7 +907,6 @@ With the proper installation as detailed above, no special steps should be
 required when a client package specifically (and thus deliberately) requests an
 Intel package as dependency, this being one of the target use cases for Spack.
 
-.. _using-mkl-tips:
 
 """""""""""""""""""""""""""""""""""""""""""""""
 Tips for configuring client packages to use MKL

lib/spack/docs/build_systems/luapackage.rst

@@ -1,105 +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)
-
-.. _luapackage:
-
----
-Lua
----
-
-The ``Lua`` build-system 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
-luarocks, prefer MakefilePackage.
-
-^^^^^^
-Phases
-^^^^^^
-
-The ``LuaBuilder`` and `LuaPackage`` base classes come 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
-#. ``install`` - install the project
-
-By default, these phases run:
-
-.. code-block:: console
-
-   # If the archive is a source rock
-   $ luarocks unpack <archive>.src.rock
-   $ # preprocess is a noop by default
-   $ luarocks make <name>.rockspec
-
-
-Any of these phases can be overridden in your package as necessary.
-
-^^^^^^^^^^^^^^^
-Important files
-^^^^^^^^^^^^^^^
-
-Packages that use the Lua/LuaRocks build system can be identified by the
-presence of a ``*.rockspec`` file in their sourcetree, or can be fetched as
-a source rock archive (``.src.rock``). This file declares things like build
-instructions and dependencies, the ``.src.rock`` also contains all code.
-
-It is common for the rockspec file to list the lua version required in
-a dependency. The LuaPackage class adds appropriate dependencies on a Lua
-implementation, but it is a good idea to specify the version required with
-a ``depends_on`` statement.  The block normally will be a table definition like
-this:
-
-.. code-block:: lua
-
-   dependencies = {
-      "lua >= 5.1",
-   }
-
-The LuaPackage class supports source repositories and archives containing
-a rockspec and directly downloading source rock files.  It *does not* support
-downloading dependencies listed inside a rockspec, and thus does not support
-directly downloading a rockspec as an archive.
-
-^^^^^^^^^^^^^^^^^^^^^^^^^
-Build system dependencies
-^^^^^^^^^^^^^^^^^^^^^^^^^
-
-All base dependencies are added by the build system, but LuaRocks is run to
-avoid downloading extra Lua dependencies during build.  If the package needs
-Lua libraries outside the standard set, they should be added as dependencies.
-
-To specify a Lua version constraint but allow all lua implementations, prefer
-to use ``depends_on("lua-lang@5.1:5.1.99")`` to express any 5.1 compatible
-version. If the package requires LuaJit rather than Lua,
-a ``depends_on("luajit")`` should be used to ensure a LuaJit distribution is
-used instead of the Lua interpreter. Alternately, if only interpreted Lua will
-work ``depends_on("lua")`` will express that.
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Passing arguments to luarocks make
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-If you need to pass any arguments to the ``luarocks make`` call, you can
-override the ``luarocks_args`` method like so:
-
-.. code-block:: python
-
-    def luarocks_args(self):
-        return ['flag1', 'flag2']
-
-One common use of this is to override warnings or flags for newer compilers, as in:
-
-.. code-block:: python
-
-    def luarocks_args(self):
-        return ["CFLAGS='-Wno-error=implicit-function-declaration'"]
-
-^^^^^^^^^^^^^^^^^^^^^^
-External documentation
-^^^^^^^^^^^^^^^^^^^^^^
-
-For more information on the LuaRocks build system, see:
-https://luarocks.org/

lib/spack/docs/build_systems/makefilepackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2020 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _makefilepackage:
 
---------
-Makefile
---------
+---------------
+MakefilePackage
+---------------
 
 The most primitive build system a package can use is a plain Makefile.
 Makefiles are simple to write for small projects, but they usually
@@ -18,7 +18,7 @@ variables.
 Phases
 ^^^^^^
 
-The ``MakefileBuilder`` and ``MakefilePackage`` base classes come with 3 phases:
+The ``MakefilePackage`` base class comes with 3 phases:
 
 #. ``edit`` - edit the Makefile
 #. ``build`` - build the project
@@ -147,10 +147,8 @@ and a ``filter_file`` method to help with this. For example:
    def edit(self, spec, prefix):
        makefile = FileFilter('Makefile')
 
-       makefile.filter(r'^\s*CC\s*=.*',  'CC = '  + spack_cc)
-       makefile.filter(r'^\s*CXX\s*=.*', 'CXX = ' + spack_cxx)
-       makefile.filter(r'^\s*F77\s*=.*', 'F77 = ' + spack_f77)
-       makefile.filter(r'^\s*FC\s*=.*',  'FC = '  + spack_fc)
+       makefile.filter('CC = gcc',  'CC = cc')
+       makefile.filter('CXX = g++', 'CC = c++')
 
 
 `stream <https://github.com/spack/spack/blob/develop/var/spack/repos/builtin/packages/stream/package.py>`_

lib/spack/docs/build_systems/mavenpackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2020 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _mavenpackage:
 
------
-Maven
------
+------------
+MavenPackage
+------------
 
 Apache Maven is a general-purpose build system that does not rely
 on Makefiles to build software. It is designed for building and
@@ -17,7 +17,7 @@ managing and Java-based project.
 Phases
 ^^^^^^
 
-The ``MavenBuilder`` and ``MavenPackage`` base classes come with the following phases:
+The ``MavenPackage`` base class comes with the following phases:
 
 #. ``build`` - compile code and package into a JAR file
 #. ``install`` - copy to installation prefix
@@ -76,24 +76,6 @@ should add:
    depends_on('maven@3.5.4:', type='build')
 
 
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Passing arguments to the build phase
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The default build and install phases should be sufficient to install
-most packages. However, you may want to pass additional flags to
-the build phase. For example:
-
-.. code-block:: python
-
-   def build_args(self):
-       return [
-           '-Pdist,native',
-           '-Dtar',
-           '-Dmaven.javadoc.skip=true'
-       ]
-
-
 ^^^^^^^^^^^^^^^^^^^^^^
 External documentation
 ^^^^^^^^^^^^^^^^^^^^^^

lib/spack/docs/build_systems/mesonpackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2020 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _mesonpackage:
 
------
-Meson
------
+------------
+MesonPackage
+------------
 
 Much like Autotools and CMake, Meson is a build system.  But it is
 meant to be both fast and as user friendly as possible.  GNOME's goal
@@ -17,7 +17,7 @@ is to port modules to use the Meson build system.
 Phases
 ^^^^^^
 
-The ``MesonBuilder`` and ``MesonPackage`` base classes come with the following phases:
+The ``MesonPackage`` base class comes with the following phases:
 
 #. ``meson`` - generate ninja files
 #. ``build`` - build the project
@@ -121,15 +121,11 @@ override the ``meson_args`` method like so:
 .. code-block:: python
 
    def meson_args(self):
-       return ['--warnlevel=3']
+       return ['--default-library=both']
 
 
 This method can be used to pass flags as well as variables.
 
-Note that the ``MesonPackage`` base class already defines variants for
-``buildtype``, ``default_library`` and ``strip``, which are mapped to default
-Meson arguments, meaning that you don't have to specify these.
-
 ^^^^^^^^^^^^^^^^^^^^^^
 External documentation
 ^^^^^^^^^^^^^^^^^^^^^^

lib/spack/docs/build_systems/octavepackage.rst

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

lib/spack/docs/build_systems/perlpackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2020 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _perlpackage:
 
-----
-Perl
-----
+-----------
+PerlPackage
+-----------
 
 Much like Octave, Perl has its own language-specific
 build system.
@@ -16,7 +16,7 @@ build system.
 Phases
 ^^^^^^
 
-The ``PerlBuilder`` and ``PerlPackage`` base classes come with 3 phases that can be overridden:
+The ``PerlPackage`` base class comes with 3 phases that can be overridden:
 
 #. ``configure`` - configure the package
 #. ``build`` - build the package
@@ -120,6 +120,8 @@ so ``PerlPackage`` contains:
 
    extends('perl')
 
+   depends_on('perl', type=('build', 'run'))
+
 
 If your package requires a specific version of Perl, you should
 specify this.

lib/spack/docs/build_systems/qmakepackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2020 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _qmakepackage:
 
------
-QMake
------
+------------
+QMakePackage
+------------
 
 Much like Autotools and CMake, QMake is a build-script generator
 designed by the developers of Qt. In its simplest form, Spack's
@@ -29,7 +29,7 @@ variables or edit ``*.pro`` files to get things working properly.
 Phases
 ^^^^^^
 
-The ``QMakeBuilder`` and ``QMakePackage`` base classes come with the following phases:
+The ``QMakePackage`` base class comes with the following phases:
 
 #. ``qmake`` - generate Makefiles
 #. ``build`` - build the project
@@ -108,19 +108,6 @@ override the ``qmake_args`` method like so:
 
 This method can be used to pass flags as well as variables.
 
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-``*.pro`` file in a sub-directory
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-If the ``*.pro`` file used to tell QMake how to build the package is
-found in a sub-directory, you can tell Spack to run all phases in this
-sub-directory by adding the following to the package:
-
-.. code-block:: python
-
-   build_directory = 'src'
-
-
 ^^^^^^^^^^^^^^^^^^^^^^
 External documentation
 ^^^^^^^^^^^^^^^^^^^^^^

lib/spack/docs/build_systems/racketpackage.rst

@@ -1,46 +0,0 @@
-.. Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
-   Spack Project Developers. See the top-level COPYRIGHT file for details.
-
-   SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-.. _racketpackage:
-
-------
-Racket
-------
-
-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
-`Racket Docs <https://docs.racket-lang.org/pkg/cmdline.html>`_.
-
-^^^^^^
-Phases
-^^^^^^
-
-The ``RacketBuilder`` and ``RacketPackage`` base classes provides an ``install`` phase that
-can be overridden, corresponding to the use of:
-
-.. code-block:: console
-
-   $ raco pkg install
-
-^^^^^^^
-Caveats
-^^^^^^^
-
-In principle, ``raco`` supports a second, ``setup`` phase; however, we have not
-implemented this separately, as in normal circumstances, ``install`` also handles
-running ``setup`` automatically.
-
-Unlike Python, Racket currently on supports two installation scopes for packages, user
-or system, and keeps a registry of installed packages at each scope in its configuration files.
-This means we can't simply compose a "``RACKET_PATH``" environment variable listing all of the
-places packages are installed, and update this at will.
-
-Unfortunately this means that all currently installed packages which extend Racket via ``raco pkg install``
-are accessible whenever Racket is accessible.
-
-Additionally, because Spack does not implement uninstall hooks, uninstalling a Spack  ``rkt-`` package
-will have no effect on the ``raco`` installed packages visible to your Racket installation.
-Instead, you must manually run ``raco pkg remove`` to keep the two package managers in a mutually
-consistent state.

lib/spack/docs/build_systems/rocmpackage.rst

@@ -1,122 +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)
-
-.. _rocmpackage:
-
------------
-ROCmPackage
------------
-
-The ``ROCmPackage`` is not a build system but a helper package. Like ``CudaPackage``,
-it provides standard variants, dependencies, and conflicts to facilitate building
-packages using GPUs though for AMD in this case.
-
-You can find the source for this package (and suggestions for setting up your
-``compilers.yaml`` and ``packages.yaml`` files) at
-`<https://github.com/spack/spack/blob/develop/lib/spack/spack/build_systems/rocm.py>`__.
-
-^^^^^^^^
-Variants
-^^^^^^^^
-
-This package provides the following variants:
-
-* **rocm**
-
-  This variant is used to enable/disable building with ``rocm``.  
-  The default is disabled (or ``False``).
-
-* **amdgpu_target**
-
-  This variant supports the optional specification of the AMD GPU architecture.
-  Valid values are the names of the GPUs (e.g., ``gfx701``), which are maintained
-  in the ``amdgpu_targets`` property.
-
-^^^^^^^^^^^^
-Dependencies
-^^^^^^^^^^^^
-
-This package defines basic ``rocm`` dependencies, including ``llvm`` and ``hip``.
-
-^^^^^^^^^
-Conflicts
-^^^^^^^^^
-
-Conflicts are used to prevent builds with known bugs or issues. This package
-already requires that the ``amdgpu_target`` always be specified for ``rocm``
-builds. It also defines a conflict that prevents builds with an ``amdgpu_target``
-when ``rocm`` is disabled.
-
-Refer to `Conflicts <https://spack.readthedocs.io/en/latest/packaging_guide.html?highlight=conflicts#conflicts>`__
-for more information on package conflicts.
-
-^^^^^^^
-Methods
-^^^^^^^
-
-This package provides one custom helper method, which is used to build
-standard AMD hip compiler flags.
-
-**hip_flags**
-
-    This built-in static method returns the appropriately formatted
-    ``--amdgpu-target`` build option for ``hipcc``.
-
-    This method must be explicitly called when you are creating the
-    arguments for your build in order to use the values.
-
-^^^^^
-Usage
-^^^^^
-
-This helper package can be added to your package by adding it as a base
-class of your package.  For example, you can add it to your
-:ref:`CMakePackage <cmakepackage>`-based package as follows:
-
-.. code-block:: python
-   :emphasize-lines: 1,3-7,14-25
-
-    class MyRocmPackage(CMakePackage, ROCmPackage):
-        ...
-        # Ensure +rocm and amdgpu_targets are passed to dependencies
-        depends_on('mydeppackage', when='+rocm')
-        for val in ROCmPackage.amdgpu_targets:
-            depends_on('mydeppackage amdgpu_target={0}'.format(val),
-                       when='amdgpu_target={0}'.format(val))
-        ...
-
-        def cmake_args(self):
-            spec = self.spec
-            args = []
-            ...
-            if '+rocm' in spec:
-                # Set up the hip macros needed by the build
-                args.extend([
-                    '-DENABLE_HIP=ON',
-                    '-DHIP_ROOT_DIR={0}'.format(spec['hip'].prefix)])
-                rocm_archs = spec.variants['amdgpu_target'].value
-                if 'none' not in rocm_archs:
-                    args.append('-DHIP_HIPCC_FLAGS=--amdgpu-target={0}'
-                                .format(",".join(rocm_archs)))
-            else:
-                # Ensure build with hip is disabled
-                args.append('-DENABLE_HIP=OFF')
-            ...
-            return args
-        ...
-
-assuming only on the ``ENABLE_HIP``, ``HIP_ROOT_DIR``, and ``HIP_HIPCC_FLAGS``
-macros are required to be set and the only dependency needing rocm options
-is ``mydeppackage``. You will need to customize the flags as needed for your
-build.
-
-This example also illustrates how to check for the ``rocm`` variant using
-``self.spec`` and how to retrieve the ``amdgpu_target`` variant's value
-using ``self.spec.variants['amdgpu_target'].value``.
-
-All five packages using ``ROCmPackage`` as of January 2021 also use the
-:ref:`CudaPackage <cudapackage>`. So it is worth looking at those packages
-to get ideas for creating a package that can support both ``cuda`` and
-``rocm``.

lib/spack/docs/build_systems/rpackage.rst

@@ -1,4 +1,4 @@
-.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2020 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
@@ -19,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
 
@@ -79,14 +79,12 @@ Description
 The first thing you'll need to add to your new package is a description.
 The top of the homepage for ``caret`` lists the following description:
 
-   Classification and Regression Training
+   caret: Classification and Regression Training
 
    Misc functions for training and plotting classification and regression models.
 
-The first line is a short description (title) and the second line is a long
-description. In this case the description is only one line but often the
-description is several lines. Spack makes use of both short and long
-descriptions and convention is to use both when creating an R  package.
+You can either use the short description (first line), long description
+(second line), or both depending on what you feel is most appropriate.
 
 ^^^^^^^^
 Homepage
@@ -126,67 +124,6 @@ If you only specify the URL for the latest release, your package will
 no longer be able to fetch that version as soon as a new release comes
 out. To get around this, add the archive directory as a ``list_url``.
 
-^^^^^^^^^^^^^^^^^^^^^
-Bioconductor packages
-^^^^^^^^^^^^^^^^^^^^^
-
-Bioconductor packages are set up in a similar way to CRAN packages, but there
-are some very important distinctions. Bioconductor packages can be found at:
-https://bioconductor.org/. Bioconductor packages are R packages and so follow
-the same packaging scheme as CRAN packages. What is different is that
-Bioconductor itself is versioned and released. This scheme, using the
-Bioconductor package installer, allows further specification of the minimum
-version of R as well as further restrictions on the dependencies between
-packages than what is possible with the native R packaging system. Spack can
-not replicate these extra features and thus Bioconductor packages in Spack need
-to be managed as a group during updates in order to maintain package
-consistency with Bioconductor itself.
-
-Another key difference is that, while previous versions of packages are
-available, they are not available from a site that can be programmatically set,
-thus a ``list_url`` attribute can not be used. However, each package is also
-available in a git repository, with branches corresponding to each Bioconductor
-release. Thus, it is always possible to retrieve the version of any package
-corresponding to a Bioconductor release simply by fetching the branch that
-corresponds to the Bioconductor release of the package repository. For this
-reason, spack Bioconductor R packages use the git repository, with the commit
-of the respective branch used in the ``version()`` attribute of the package.
-
-^^^^^^^^^^^^^^^^^^^^^^^^
-cran and bioc attributes
-^^^^^^^^^^^^^^^^^^^^^^^^
-
-Much like the ``pypi`` attribute for python packages, due to the fact that R
-packages are obtained from specific repositories, it is possible to set up shortcut
-attributes that can be used to set ``homepage``, ``url``, ``list_url``, and
-``git``. For example, the following ``cran`` attribute:
-
-.. code-block:: python
-
-   cran = 'caret'
-
-is equivalent to:
-
-.. code-block:: python
-
-   homepage = 'https://cloud.r-project.org/package=caret'
-   url      = 'https://cloud.r-project.org/src/contrib/caret_6.0-86.tar.gz'
-   list_url = 'https://cloud.r-project.org/src/contrib/Archive/caret'
-
-Likewise, the following ``bioc`` attribute:
-
-.. code-block:: python
-
-   bioc = 'BiocVersion'
-
-is equivalent to:
-
-.. code-block:: python
-
-   homepage = 'https://bioconductor.org/packages/BiocVersion/'
-   git      = 'https://git.bioconductor.org/packages/BiocVersion'
-
-
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 Build system dependencies
 ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -201,6 +138,7 @@ every R package needs this, the ``RPackage`` base class contains:
 .. code-block:: python
 
    extends('r')
+   depends_on('r', type=('build', 'run'))
 
 
 Take a close look at the homepage for ``caret``. If you look at the
@@ -219,7 +157,7 @@ R dependencies
 R packages are often small and follow the classic Unix philosophy
 of doing one thing well. They are modular and usually depend on
 several other packages. You may find a single package with over a
-hundred dependencies. Luckily, R packages are well-documented
+hundred dependencies. Luckily, CRAN packages are well-documented
 and list all of their dependencies in the following sections:
 
 * Depends
@@ -360,8 +298,8 @@ like so:
 
 .. code-block:: python
 
-   def configure_args(self):
-       mpi_name = self.spec['mpi'].name
+   def configure_args(self, spec, prefix):
+       mpi_name = spec['mpi'].name
 
        # The type of MPI. Supported values are:
        # OPENMPI, LAM, MPICH, MPICH2, or CRAY

lib/spack/docs/build_systems/rubypackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2020 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _rubypackage:
 
-----
-Ruby
-----
+-----------
+RubyPackage
+-----------
 
 Like Perl, Python, and R, Ruby has its own build system for
 installing Ruby gems.
@@ -16,7 +16,7 @@ installing Ruby gems.
 Phases
 ^^^^^^
 
-The ``RubyBuilder`` and ``RubyPackage`` base classes provide the following phases that
+The ``RubyPackage`` base class provides the following phases that
 can be overridden:
 
 #. ``build`` - build everything needed to install
@@ -113,6 +113,7 @@ the base class contains:
 .. code-block:: python
 
    extends('ruby')
+   depends_on('ruby', type=('build', 'run'))
 
 
 The ``*.gemspec`` file may contain something like:

lib/spack/docs/build_systems/sconspackage.rst

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

lib/spack/docs/build_systems/sippackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2020 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _sippackage:
 
----
-SIP
----
+----------
+SIPPackage
+----------
 
 SIP is a tool that makes it very easy to create Python bindings for C and C++
 libraries. It was originally developed to create PyQt, the Python bindings for
@@ -22,7 +22,7 @@ provides support functions to the automatically generated code.
 Phases
 ^^^^^^
 
-The ``SIPBuilder`` and ``SIPPackage`` base classes come with the following phases:
+The ``SIPPackage`` base class comes with the following phases:
 
 #. ``configure`` - configure the package
 #. ``build`` - build the package
@@ -93,17 +93,10 @@ in the site-packages directory:
    $ python
    >>> import setuptools
    >>> setuptools.find_packages()
-   [
-       'PyQt5', 'PyQt5.QtCore', 'PyQt5.QtGui', 'PyQt5.QtHelp',
-       'PyQt5.QtMultimedia', 'PyQt5.QtMultimediaWidgets', 'PyQt5.QtNetwork',
-       'PyQt5.QtOpenGL', 'PyQt5.QtPrintSupport', 'PyQt5.QtQml',
-       'PyQt5.QtQuick', 'PyQt5.QtSvg', 'PyQt5.QtTest', 'PyQt5.QtWebChannel',
-       'PyQt5.QtWebSockets', 'PyQt5.QtWidgets', 'PyQt5.QtXml',
-       'PyQt5.QtXmlPatterns'
-    ]
+   ['QtPy5']
 
 
-Large, complex packages like ``py-pyqt5`` will return a long list of
+Large, complex packages like ``QtPy5`` will return a long list of
 packages, while other packages may return an empty list. These packages
 only install a single ``foo.py`` file. In Python packaging lingo,
 a "package" is a directory containing files like:
@@ -115,25 +108,21 @@ a "package" is a directory containing files like:
    foo/baz.py
 
 
-whereas a "module" is a single Python file.
-
-The ``SIPPackage`` base class automatically detects these module
-names for you. If, for whatever reason, the module names detected
-are wrong, you can provide the names yourself by overriding
-``import_modules`` like so:
+whereas a "module" is a single Python file. Since ``find_packages``
+only returns packages, you'll have to determine the correct module
+names yourself. You can now add these packages and modules to the
+package like so:
 
 .. code-block:: python
 
    import_modules = ['PyQt5']
 
 
-These tests often catch missing dependencies and non-RPATHed
-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.
+When you run ``spack install --test=root py-pyqt5``, Spack will attempt
+to import the ``PyQt5`` module after installation.
 
-These tests can be triggered by running ``spack install --test=root``
-or by running ``spack test run`` after the installation has finished.
+These tests most often catch missing dependencies and non-RPATHed
+libraries.
 
 ^^^^^^^^^^^^^^^^^^^^^^
 External documentation

lib/spack/docs/build_systems/sourceforgepackage.rst

@@ -1,55 +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)
-
-.. _sourceforgepackage:
-
-------------------
-SourceforgePackage
-------------------
-
-``SourceforgePackage`` is a 
-`mixin-class <https://en.wikipedia.org/wiki/Mixin>`_. It automatically
-sets the URL based on a list of Sourceforge mirrors listed in
-`sourceforge_mirror_path`, which defaults to a half dozen known mirrors.
-Refer to the package source 
-(`<https://github.com/spack/spack/blob/develop/lib/spack/spack/build_systems/sourceforge.py>`__) for the current list of mirrors used by Spack.
-
-
-^^^^^^^
-Methods
-^^^^^^^
-
-This package provides a method for populating mirror URLs.
-
-**urls**
-
-    This method returns a list of possible URLs for package source.
-    It is decorated with `property` so its results are treated as
-    a package attribute.
-
-    Refer to 
-    `<https://spack.readthedocs.io/en/latest/packaging_guide.html#mirrors-of-the-main-url>`__
-    for information on how Spack uses the `urls` attribute during
-    fetching.
-
-^^^^^
-Usage
-^^^^^
-
-This helper package can be added to your package by adding it as a base
-class of your package and defining the relative location of an archive
-file for one version of your software.
-
-.. code-block:: python
-   :emphasize-lines: 1,3
-
-    class MyPackage(AutotoolsPackage, SourceforgePackage):
-        ...
-        sourceforge_mirror_path = "my-package/mypackage.1.0.0.tar.gz"
-        ...
-
-Over 40 packages are using ``SourceforcePackage`` this mix-in as of
-July 2022 so there are multiple packages to choose from if you want
-to see a real example.

lib/spack/docs/build_systems/wafpackage.rst

@@ -1,13 +1,13 @@
-.. Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
+.. Copyright 2013-2020 Lawrence Livermore National Security, LLC and other
    Spack Project Developers. See the top-level COPYRIGHT file for details.
 
    SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 .. _wafpackage:
 
----
-Waf
----
+----------
+WafPackage
+----------
 
 Like SCons, Waf is a general-purpose build system that does not rely
 on Makefiles to build software.
@@ -16,7 +16,7 @@ on Makefiles to build software.
 Phases
 ^^^^^^
 
-The ``WafBuilder`` and ``WafPackage`` base classes come with the following phases:
+The ``WafPackage`` base class comes with the following phases:
 
 #. ``configure`` - configure the project
 #. ``build`` - build the project

lib/spack/docs/chain.rst

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

lib/spack/docs/conf.py

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