llvm: Remove python bindings when >= v17 (#41160)

Co-authored-by: Tom Scogland <scogland1@llnl.gov>

.github/workflows/build-containers.yml

@@ -113,7 +113,7 @@ jobs:
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Build & Deploy ${{ matrix.dockerfile[0] }}
-        uses: docker/build-push-action@0565240e2d4ab88bba5387d719585280857ece09
+        uses: docker/build-push-action@4a13e500e55cf31b7a5d59a38ab2040ab0f42f56
         with:
           context: dockerfiles/${{ matrix.dockerfile[0] }}
           platforms: ${{ matrix.dockerfile[1] }}

.github/workflows/style/requirements.txt

@@ -1,4 +1,4 @@
-black==23.10.1
+black==23.11.0
 clingo==5.6.2
 flake8==6.1.0
 isort==5.12.0

lib/spack/docs/build_settings.rst

@@ -37,7 +37,11 @@ to enable reuse for a single installation, and you can use:
    spack install --fresh <spec>
 
 to do a fresh install if ``reuse`` is enabled by default.
-``reuse: true`` is the default.
+``reuse: dependencies`` is the default.
+
+.. seealso::
+
+   FAQ: :ref:`Why does Spack pick particular versions and variants? <faq-concretizer-precedence>`
 
 ------------------------------------------
 Selection of the target microarchitectures
@@ -99,547 +103,3 @@ while `py-numpy` still needs an older version:
 
 Up to Spack v0.20 ``duplicates:strategy:none`` was the default (and only) behavior. From Spack v0.21 the
 default behavior is ``duplicates:strategy:minimal``.
-
-.. _build-settings:
-
-================================
-Package Settings (packages.yaml)
-================================
-
-Spack allows you to customize how your software is built through the
-``packages.yaml`` file.  Using it, you can make Spack prefer particular
-implementations of virtual dependencies (e.g., MPI or BLAS/LAPACK),
-or you can make it prefer to build with particular compilers.  You can
-also tell Spack to use *external* software installations already
-present on your system.
-
-At a high level, the ``packages.yaml`` file is structured like this:
-
-.. code-block:: yaml
-
-   packages:
-     package1:
-       # settings for package1
-     package2:
-       # settings for package2
-     # ...
-     all:
-       # settings that apply to all packages.
-
-So you can either set build preferences specifically for *one* package,
-or you can specify that certain settings should apply to *all* packages.
-The types of settings you can customize are described in detail below.
-
-Spack's build defaults are in the default
-``etc/spack/defaults/packages.yaml`` file.  You can override them in
-``~/.spack/packages.yaml`` or ``etc/spack/packages.yaml``. For more
-details on how this works, see :ref:`configuration-scopes`.
-
-.. _sec-external-packages:
-
------------------
-External Packages
------------------
-
-Spack can be configured to use externally-installed
-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:
-
-.. code-block:: yaml
-
-   packages:
-     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
-
-This example lists three installations of OpenMPI, one built with GCC,
-one built with GCC and debug information, and another built with Intel.
-If Spack is asked to build a package that uses one of these MPIs as a
-dependency, it will use the pre-installed OpenMPI in
-the given directory. Note that the specified path is the top-level
-install prefix, not the ``bin`` subdirectory.
-
-``packages.yaml`` can also be used to specify modules to load instead
-of the installation prefixes.  The following example says that module
-``CMake/3.7.2`` provides cmake version 3.7.2.
-
-.. code-block:: yaml
-
-   cmake:
-     externals:
-     - spec: cmake@3.7.2
-       modules:
-       - CMake/3.7.2
-
-Each ``packages.yaml`` begins with a ``packages:`` attribute, followed
-by a list of package names.  To specify externals, add an ``externals:``
-attribute under the package name, which lists externals.
-Each external should specify a ``spec:`` string that should be as
-well-defined as reasonably possible.  If a
-package lacks a spec component, such as missing a compiler or
-package version, then Spack will guess the missing component based
-on its most-favored packages, and it may guess incorrectly.
-
-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.
-
-To prevent this, the ``packages.yaml`` configuration also allows packages
-to be flagged as non-buildable.  The previous example could be modified to
-be:
-
-.. code-block:: yaml
-
-   packages:
-     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
-       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.
-
-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.
-
-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
-other MPI implementations over the externally available OpenMPI. Spack
-can be configured with every MPI provider not buildable individually,
-but more conveniently:
-
-.. code-block:: yaml
-
-   packages:
-     mpi:
-       buildable: False
-     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
-
-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:
-
-.. 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
-
-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`.
-
-.. _cmd-spack-external-find:
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Automatically Find External Packages
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-You can run the :ref:`spack external find <spack-external-find>` command
-to search for system-provided packages and add them to ``packages.yaml``.
-After running this command your ``packages.yaml`` may include new entries:
-
-.. code-block:: yaml
-
-   packages:
-     cmake:
-       externals:
-       - spec: cmake@3.17.2
-         prefix: /usr
-
-Generally this is useful for detecting a small set of commonly-used packages;
-for now this is generally limited to finding build-only dependencies.
-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 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
-  packages that you want Spack to know about before running
-  ``spack external find``.
-* Spack does not overwrite existing entries in the package configuration:
-  If there is an external defined for a spec at any configuration scope,
-  then Spack will not add a new external entry (``spack config blame packages``
-  can help locate all external entries).
-
-.. _package-requirements:
-
---------------------
-Package Requirements
---------------------
-
-Spack can be configured to always use certain compilers, package
-versions, and variants during concretization through package
-requirements.
-
-Package requirements are useful when you find yourself repeatedly
-specifying the same constraints on the command line, and wish that
-Spack respects these constraints whether you mention them explicitly
-or not. Another use case is specifying constraints that should apply
-to all root specs in an environment, without having to repeat the
-constraint everywhere.
-
-Apart from that, requirements config is more flexible than constraints
-on the command line, because it can specify constraints on packages
-*when they occur* as a dependency. In contrast, on the command line it
-is not possible to specify constraints on dependencies while also keeping
-those dependencies optional.
-
-^^^^^^^^^^^^^^^^^^^
-Requirements syntax
-^^^^^^^^^^^^^^^^^^^
-
-The package requirements configuration is specified in ``packages.yaml``,
-keyed by package name and expressed using the Spec syntax. In the simplest
-case you can specify attributes that you always want the package to have
-by providing a single spec string to ``require``:
-
-.. code-block:: yaml
-
-   packages:
-     libfabric:
-       require: "@1.13.2"
-
-In the above example, ``libfabric`` will always build with version 1.13.2. If you
-need to compose multiple configuration scopes ``require`` accepts a list of
-strings:
-
-.. code-block:: yaml
-
-   packages:
-     libfabric:
-       require:
-       - "@1.13.2"
-       - "%gcc"
-
-In this case ``libfabric`` will always build with version 1.13.2 **and** using GCC
-as a compiler.
-
-For more complex use cases, require accepts also a list of objects. These objects
-must have either a ``any_of`` or a ``one_of`` field, containing a list of spec strings,
-and they can optionally have a ``when`` and a ``message`` attribute:
-
-.. code-block:: yaml
-
-   packages:
-     openmpi:
-       require:
-       - any_of: ["@4.1.5", "%gcc"]
-         message: "in this example only 4.1.5 can build with other compilers"
-
-``any_of`` is a list of specs. One of those specs must be satisfied
-and it is also allowed for the concretized spec to match more than one.
-In the above example, that means you could build ``openmpi@4.1.5%gcc``,
-``openmpi@4.1.5%clang`` or ``openmpi@3.9%gcc``, but
-not ``openmpi@3.9%clang``.
-
-If a custom message is provided, and the requirement is not satisfiable,
-Spack will print the custom error message:
-
-.. code-block:: console
-
-   $ spack spec openmpi@3.9%clang
-   ==> Error: in this example only 4.1.5 can build with other compilers
-
-We could express a similar requirement using the ``when`` attribute:
-
-.. code-block:: yaml
-
-   packages:
-     openmpi:
-       require:
-       - any_of: ["%gcc"]
-         when: "@:4.1.4"
-         message: "in this example only 4.1.5 can build with other compilers"
-
-In the example above, if the version turns out to be 4.1.4 or less, we require the compiler to be GCC.
-For readability, Spack also allows a ``spec`` key accepting a string when there is only a single
-constraint:
-
-.. code-block:: yaml
-
-   packages:
-     openmpi:
-       require:
-       - spec: "%gcc"
-         when: "@:4.1.4"
-         message: "in this example only 4.1.5 can build with other compilers"
-
-This code snippet and the one before it are semantically equivalent.
-
-Finally, instead of ``any_of`` you can use ``one_of`` which also takes a list of specs. The final
-concretized spec must match one and only one of them:
-
-.. code-block:: yaml
-
-   packages:
-     mpich:
-       require:
-       - one_of: ["+cuda", "+rocm"]
-
-In the example above, that means you could build ``mpich+cuda`` or ``mpich+rocm`` but not ``mpich+cuda+rocm``.
-
-.. note::
-
-   For ``any_of`` and ``one_of``, the order of specs indicates a
-   preference: items that appear earlier in the list are preferred
-   (note that these preferences can be ignored in favor of others).
-
-.. note::
-
-   When using a conditional requirement, Spack is allowed to actively avoid the triggering
-   condition (the ``when=...`` spec) if that leads to a concrete spec with better scores in
-   the optimization criteria. To check the current optimization criteria and their
-   priorities you can run ``spack solve zlib``.
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Setting default requirements
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-You can also set default requirements for all packages under ``all``
-like this:
-
-.. code-block:: yaml
-
-   packages:
-     all:
-       require: '%clang'
-
-which means every spec will be required to use ``clang`` as a compiler.
-
-Note that in this case ``all`` represents a *default set of requirements* -
-if there are specific package requirements, then the default requirements
-under ``all`` are disregarded. For example, with a configuration like this:
-
-.. code-block:: yaml
-
-   packages:
-     all:
-       require: '%clang'
-     cmake:
-       require: '%gcc'
-
-Spack requires ``cmake`` to use ``gcc`` and all other nodes (including ``cmake``
-dependencies) to use ``clang``.
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Setting requirements on virtual specs
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-A requirement on a virtual spec applies whenever that virtual is present in the DAG.
-This can be useful for fixing which virtual provider you want to use:
-
-.. code-block:: yaml
-
-   packages:
-     mpi:
-       require: 'mvapich2 %gcc'
-
-With the configuration above the only allowed ``mpi`` provider is ``mvapich2 %gcc``.
-
-Requirements on the virtual spec and on the specific provider are both applied, if
-present. For instance with a configuration like:
-
-.. code-block:: yaml
-
-   packages:
-     mpi:
-       require: 'mvapich2 %gcc'
-     mvapich2:
-       require: '~cuda'
-
-you will use ``mvapich2~cuda %gcc`` as an ``mpi`` provider.
-
-.. _package-preferences:
-
--------------------
-Package Preferences
--------------------
-
-In some cases package requirements can be too strong, and package
-preferences are the better option. Package preferences do not impose
-constraints on packages for particular versions or variants values,
-they rather only set defaults. The concretizer is free to change
-them if it must, due to other constraints, and also prefers reusing
-installed packages over building new ones that are a better match for
-preferences.
-
-Most package preferences (``compilers``, ``target`` and ``providers``)
-can only be set globally under the ``all`` section of ``packages.yaml``:
-
-.. code-block:: yaml
-
-   packages:
-     all:
-       compiler: [gcc@12.2.0, clang@12:, oneapi@2023:]
-       target: [x86_64_v3]
-       providers:
-         mpi: [mvapich2, mpich, openmpi]
-
-These preferences override Spack's default and effectively reorder priorities
-when looking for the best compiler, target or virtual package provider. Each
-preference takes an ordered list of spec constraints, with earlier entries in
-the list being preferred over later entries.
-
-In the example above all packages prefer to be compiled with ``gcc@12.2.0``,
-to target the ``x86_64_v3`` microarchitecture and to use ``mvapich2`` if they
-depend on ``mpi``.
-
-The ``variants`` and ``version`` preferences can be set under
-package specific sections of the ``packages.yaml`` file:
-
-.. code-block:: yaml
-
-   packages:
-     opencv:
-       variants: +debug
-     gperftools:
-       version: [2.2, 2.4, 2.3]
-
-In this case, the preference for ``opencv`` is to build with debug options, while
-``gperftools`` prefers version 2.2 over 2.4.
-
-Any preference can be overwritten on the command line if explicitly requested.
-
-Preferences cannot overcome explicit constraints, as they only set a preferred
-ordering among homogeneous attribute values. Going back to the example, if
-``gperftools@2.3:`` was requested, then Spack will install version 2.4
-since the most preferred version 2.2 is prohibited by the version constraint.
-
-.. _package_permissions:
-
--------------------
-Package Permissions
--------------------
-
-Spack can be configured to assign permissions to the files installed
-by a package.
-
-In the ``packages.yaml`` file under ``permissions``, the attributes
-``read``, ``write``, and ``group`` control the package
-permissions. These attributes can be set per-package, or for all
-packages under ``all``. If permissions are set under ``all`` and for a
-specific package, the package-specific settings take precedence.
-
-The ``read`` and ``write`` attributes take one of ``user``, ``group``,
-and ``world``.
-
-.. code-block:: yaml
-
-  packages:
-    all:
-      permissions:
-        write: group
-        group: spack
-    my_app:
-      permissions:
-        read: group
-        group: my_team
-
-The permissions settings describe the broadest level of access to
-installations of the specified packages. The execute permissions of
-the file are set to the same level as read permissions for those files
-that are executable. The default setting for ``read`` is ``world``,
-and for ``write`` is ``user``. In the example above, installations of
-``my_app`` will be installed with user and group permissions but no
-world permissions, and owned by the group ``my_team``. All other
-packages will be installed with user and group write privileges, and
-world read privileges. Those packages will be owned by the group
-``spack``.
-
-The ``group`` attribute assigns a Unix-style group to a package. All
-files installed by the package will be owned by the assigned group,
-and the sticky group bit will be set on the install prefix and all
-directories inside the install prefix. This will ensure that even
-manually placed files within the install prefix are owned by the
-assigned group. If no group is assigned, Spack will allow the OS
-default behavior to go as expected.
-
-----------------------------
-Assigning Package Attributes
-----------------------------
-
-You can assign class-level attributes in the configuration:
-
-.. code-block:: yaml
-
-  packages:
-    mpileaks:
-      # Override existing attributes
-      url: http://www.somewhereelse.com/mpileaks-1.0.tar.gz
-      # ... or add new ones
-      x: 1
-
-Attributes set this way will be accessible to any method executed
-in the package.py file (e.g. the ``install()`` method). Values for these
-attributes may be any value parseable by yaml.
-
-These can only be applied to specific packages, not "all" or
-virtual packages.

lib/spack/docs/build_systems/intelpackage.rst

@@ -392,7 +392,7 @@ See section
 :ref:`Configuration Scopes <configuration-scopes>`
 for an explanation about the different files
 and section
-:ref:`Build customization <build-settings>`
+:ref:`Build customization <packages-config>`
 for specifics and examples for ``packages.yaml`` files.
 
 .. If your system administrator did not provide modules for pre-installed Intel

lib/spack/docs/configuration.rst

@@ -17,7 +17,7 @@ case you want to skip directly to specific docs:
 * :ref:`config.yaml <config-yaml>`
 * :ref:`mirrors.yaml <mirrors>`
 * :ref:`modules.yaml <modules>`
-* :ref:`packages.yaml <build-settings>`
+* :ref:`packages.yaml <packages-config>`
 * :ref:`repos.yaml <repositories>`
 
 You can also add any of these as inline configuration in the YAML

lib/spack/docs/frequently_asked_questions.rst

@@ -0,0 +1,77 @@
+.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+   Spack Project Developers. See the top-level COPYRIGHT file for details.
+
+   SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+==========================
+Frequently Asked Questions
+==========================
+
+This page contains answers to frequently asked questions about Spack.
+If you have questions that are not answered here, feel free to ask on
+`Slack <https://slack.spack.io>`_ or `GitHub Discussions
+<https://github.com/spack/spack/discussions>`_. If you've learned the
+answer to a question that you think should be here, please consider
+contributing to this page.
+
+.. _faq-concretizer-precedence:
+
+-----------------------------------------------------
+Why does Spack pick particular versions and variants?
+-----------------------------------------------------
+
+This question comes up in a variety of forms:
+
+ 1. Why does Spack seem to ignore my package preferences from ``packages.yaml`` config?
+ 2. Why does Spack toggle a variant instead of using the default from the ``package.py`` file?
+
+The short answer is that Spack always picks an optimal configuration
+based on a complex set of criteria\ [#f1]_. These criteria are more nuanced
+than always choosing the latest versions or default variants.
+
+.. note::
+
+    As a rule of thumb: requirements + constraints > reuse > preferences > defaults.
+
+The following set of criteria (from lowest to highest precedence) explain
+common cases where concretization output may seem surprising at first.
+
+1. :ref:`Package preferences <package-preferences>` configured in ``packages.yaml``
+   override variant defaults from ``package.py`` files, and influence the optimal
+   ordering of versions. Preferences are specified as follows:
+
+   .. code-block:: yaml
+
+      packages:
+        foo:
+          version: [1.0, 1.1]
+          variants: ~mpi
+
+2. :ref:`Reuse concretization <concretizer-options>` configured in ``concretizer.yaml``
+   overrides preferences, since it's typically faster to reuse an existing spec than to
+   build a preferred one from sources. When build caches are enabled, specs may be reused
+   from a remote location too. Reuse concretization is configured as follows:
+
+   .. code-block:: yaml
+
+      concretizer:
+        reuse: dependencies  # other options are 'true' and 'false'
+
+3. :ref:`Package requirements <package-requirements>` configured in ``packages.yaml``,
+   and constraints from the command line as well as ``package.py`` files override all
+   of the above. Requirements are specified as follows:
+
+   .. code-block:: yaml
+
+      packages:
+        foo:
+          require:
+          - "@1.2: +mpi"
+
+Requirements and constraints restrict the set of possible solutions, while reuse
+behavior and preferences influence what an optimal solution looks like.
+
+
+.. rubric:: Footnotes
+
+.. [#f1] The exact list of criteria can be retrieved with the ``spack solve`` command

lib/spack/docs/index.rst

@@ -55,6 +55,7 @@ or refer to the full manual below.
    getting_started
    basic_usage
    replace_conda_homebrew
+   frequently_asked_questions
 
 .. toctree::
    :maxdepth: 2
@@ -70,7 +71,7 @@ or refer to the full manual below.
 
    configuration
    config_yaml
-   bootstrapping
+   packages_yaml
    build_settings
    environments
    containers
@@ -78,6 +79,7 @@ or refer to the full manual below.
    module_file_support
    repositories
    binary_caches
+   bootstrapping
    command_index
    chain
    extensions

lib/spack/docs/packages_yaml.rst

@@ -0,0 +1,559 @@
+.. Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+   Spack Project Developers. See the top-level COPYRIGHT file for details.
+
+   SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+
+.. _packages-config:
+
+================================
+Package Settings (packages.yaml)
+================================
+
+Spack allows you to customize how your software is built through the
+``packages.yaml`` file.  Using it, you can make Spack prefer particular
+implementations of virtual dependencies (e.g., MPI or BLAS/LAPACK),
+or you can make it prefer to build with particular compilers.  You can
+also tell Spack to use *external* software installations already
+present on your system.
+
+At a high level, the ``packages.yaml`` file is structured like this:
+
+.. code-block:: yaml
+
+   packages:
+     package1:
+       # settings for package1
+     package2:
+       # settings for package2
+     # ...
+     all:
+       # settings that apply to all packages.
+
+So you can either set build preferences specifically for *one* package,
+or you can specify that certain settings should apply to *all* packages.
+The types of settings you can customize are described in detail below.
+
+Spack's build defaults are in the default
+``etc/spack/defaults/packages.yaml`` file.  You can override them in
+``~/.spack/packages.yaml`` or ``etc/spack/packages.yaml``. For more
+details on how this works, see :ref:`configuration-scopes`.
+
+.. _sec-external-packages:
+
+-----------------
+External Packages
+-----------------
+
+Spack can be configured to use externally-installed
+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:
+
+.. code-block:: yaml
+
+   packages:
+     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
+
+This example lists three installations of OpenMPI, one built with GCC,
+one built with GCC and debug information, and another built with Intel.
+If Spack is asked to build a package that uses one of these MPIs as a
+dependency, it will use the pre-installed OpenMPI in
+the given directory. Note that the specified path is the top-level
+install prefix, not the ``bin`` subdirectory.
+
+``packages.yaml`` can also be used to specify modules to load instead
+of the installation prefixes.  The following example says that module
+``CMake/3.7.2`` provides cmake version 3.7.2.
+
+.. code-block:: yaml
+
+   cmake:
+     externals:
+     - spec: cmake@3.7.2
+       modules:
+       - CMake/3.7.2
+
+Each ``packages.yaml`` begins with a ``packages:`` attribute, followed
+by a list of package names.  To specify externals, add an ``externals:``
+attribute under the package name, which lists externals.
+Each external should specify a ``spec:`` string that should be as
+well-defined as reasonably possible.  If a
+package lacks a spec component, such as missing a compiler or
+package version, then Spack will guess the missing component based
+on its most-favored packages, and it may guess incorrectly.
+
+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.
+
+To prevent this, the ``packages.yaml`` configuration also allows packages
+to be flagged as non-buildable.  The previous example could be modified to
+be:
+
+.. code-block:: yaml
+
+   packages:
+     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
+       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.
+
+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.
+
+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
+other MPI implementations over the externally available OpenMPI. Spack
+can be configured with every MPI provider not buildable individually,
+but more conveniently:
+
+.. code-block:: yaml
+
+   packages:
+     mpi:
+       buildable: False
+     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
+
+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:
+
+.. 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
+
+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`.
+
+.. _cmd-spack-external-find:
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Automatically Find External Packages
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+You can run the :ref:`spack external find <spack-external-find>` command
+to search for system-provided packages and add them to ``packages.yaml``.
+After running this command your ``packages.yaml`` may include new entries:
+
+.. code-block:: yaml
+
+   packages:
+     cmake:
+       externals:
+       - spec: cmake@3.17.2
+         prefix: /usr
+
+Generally this is useful for detecting a small set of commonly-used packages;
+for now this is generally limited to finding build-only dependencies.
+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 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
+  packages that you want Spack to know about before running
+  ``spack external find``.
+* Spack does not overwrite existing entries in the package configuration:
+  If there is an external defined for a spec at any configuration scope,
+  then Spack will not add a new external entry (``spack config blame packages``
+  can help locate all external entries).
+
+.. _package-requirements:
+
+--------------------
+Package Requirements
+--------------------
+
+Spack can be configured to always use certain compilers, package
+versions, and variants during concretization through package
+requirements.
+
+Package requirements are useful when you find yourself repeatedly
+specifying the same constraints on the command line, and wish that
+Spack respects these constraints whether you mention them explicitly
+or not. Another use case is specifying constraints that should apply
+to all root specs in an environment, without having to repeat the
+constraint everywhere.
+
+Apart from that, requirements config is more flexible than constraints
+on the command line, because it can specify constraints on packages
+*when they occur* as a dependency. In contrast, on the command line it
+is not possible to specify constraints on dependencies while also keeping
+those dependencies optional.
+
+.. seealso::
+
+   FAQ: :ref:`Why does Spack pick particular versions and variants? <faq-concretizer-precedence>`
+
+
+^^^^^^^^^^^^^^^^^^^
+Requirements syntax
+^^^^^^^^^^^^^^^^^^^
+
+The package requirements configuration is specified in ``packages.yaml``,
+keyed by package name and expressed using the Spec syntax. In the simplest
+case you can specify attributes that you always want the package to have
+by providing a single spec string to ``require``:
+
+.. code-block:: yaml
+
+   packages:
+     libfabric:
+       require: "@1.13.2"
+
+In the above example, ``libfabric`` will always build with version 1.13.2. If you
+need to compose multiple configuration scopes ``require`` accepts a list of
+strings:
+
+.. code-block:: yaml
+
+   packages:
+     libfabric:
+       require:
+       - "@1.13.2"
+       - "%gcc"
+
+In this case ``libfabric`` will always build with version 1.13.2 **and** using GCC
+as a compiler.
+
+For more complex use cases, require accepts also a list of objects. These objects
+must have either a ``any_of`` or a ``one_of`` field, containing a list of spec strings,
+and they can optionally have a ``when`` and a ``message`` attribute:
+
+.. code-block:: yaml
+
+   packages:
+     openmpi:
+       require:
+       - any_of: ["@4.1.5", "%gcc"]
+         message: "in this example only 4.1.5 can build with other compilers"
+
+``any_of`` is a list of specs. One of those specs must be satisfied
+and it is also allowed for the concretized spec to match more than one.
+In the above example, that means you could build ``openmpi@4.1.5%gcc``,
+``openmpi@4.1.5%clang`` or ``openmpi@3.9%gcc``, but
+not ``openmpi@3.9%clang``.
+
+If a custom message is provided, and the requirement is not satisfiable,
+Spack will print the custom error message:
+
+.. code-block:: console
+
+   $ spack spec openmpi@3.9%clang
+   ==> Error: in this example only 4.1.5 can build with other compilers
+
+We could express a similar requirement using the ``when`` attribute:
+
+.. code-block:: yaml
+
+   packages:
+     openmpi:
+       require:
+       - any_of: ["%gcc"]
+         when: "@:4.1.4"
+         message: "in this example only 4.1.5 can build with other compilers"
+
+In the example above, if the version turns out to be 4.1.4 or less, we require the compiler to be GCC.
+For readability, Spack also allows a ``spec`` key accepting a string when there is only a single
+constraint:
+
+.. code-block:: yaml
+
+   packages:
+     openmpi:
+       require:
+       - spec: "%gcc"
+         when: "@:4.1.4"
+         message: "in this example only 4.1.5 can build with other compilers"
+
+This code snippet and the one before it are semantically equivalent.
+
+Finally, instead of ``any_of`` you can use ``one_of`` which also takes a list of specs. The final
+concretized spec must match one and only one of them:
+
+.. code-block:: yaml
+
+   packages:
+     mpich:
+       require:
+       - one_of: ["+cuda", "+rocm"]
+
+In the example above, that means you could build ``mpich+cuda`` or ``mpich+rocm`` but not ``mpich+cuda+rocm``.
+
+.. note::
+
+   For ``any_of`` and ``one_of``, the order of specs indicates a
+   preference: items that appear earlier in the list are preferred
+   (note that these preferences can be ignored in favor of others).
+
+.. note::
+
+   When using a conditional requirement, Spack is allowed to actively avoid the triggering
+   condition (the ``when=...`` spec) if that leads to a concrete spec with better scores in
+   the optimization criteria. To check the current optimization criteria and their
+   priorities you can run ``spack solve zlib``.
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Setting default requirements
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+You can also set default requirements for all packages under ``all``
+like this:
+
+.. code-block:: yaml
+
+   packages:
+     all:
+       require: '%clang'
+
+which means every spec will be required to use ``clang`` as a compiler.
+
+Note that in this case ``all`` represents a *default set of requirements* -
+if there are specific package requirements, then the default requirements
+under ``all`` are disregarded. For example, with a configuration like this:
+
+.. code-block:: yaml
+
+   packages:
+     all:
+       require: '%clang'
+     cmake:
+       require: '%gcc'
+
+Spack requires ``cmake`` to use ``gcc`` and all other nodes (including ``cmake``
+dependencies) to use ``clang``.
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Setting requirements on virtual specs
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+A requirement on a virtual spec applies whenever that virtual is present in the DAG.
+This can be useful for fixing which virtual provider you want to use:
+
+.. code-block:: yaml
+
+   packages:
+     mpi:
+       require: 'mvapich2 %gcc'
+
+With the configuration above the only allowed ``mpi`` provider is ``mvapich2 %gcc``.
+
+Requirements on the virtual spec and on the specific provider are both applied, if
+present. For instance with a configuration like:
+
+.. code-block:: yaml
+
+   packages:
+     mpi:
+       require: 'mvapich2 %gcc'
+     mvapich2:
+       require: '~cuda'
+
+you will use ``mvapich2~cuda %gcc`` as an ``mpi`` provider.
+
+.. _package-preferences:
+
+-------------------
+Package Preferences
+-------------------
+
+In some cases package requirements can be too strong, and package
+preferences are the better option. Package preferences do not impose
+constraints on packages for particular versions or variants values,
+they rather only set defaults. The concretizer is free to change
+them if it must, due to other constraints, and also prefers reusing
+installed packages over building new ones that are a better match for
+preferences.
+
+.. seealso::
+
+   FAQ: :ref:`Why does Spack pick particular versions and variants? <faq-concretizer-precedence>`
+
+
+Most package preferences (``compilers``, ``target`` and ``providers``)
+can only be set globally under the ``all`` section of ``packages.yaml``:
+
+.. code-block:: yaml
+
+   packages:
+     all:
+       compiler: [gcc@12.2.0, clang@12:, oneapi@2023:]
+       target: [x86_64_v3]
+       providers:
+         mpi: [mvapich2, mpich, openmpi]
+
+These preferences override Spack's default and effectively reorder priorities
+when looking for the best compiler, target or virtual package provider. Each
+preference takes an ordered list of spec constraints, with earlier entries in
+the list being preferred over later entries.
+
+In the example above all packages prefer to be compiled with ``gcc@12.2.0``,
+to target the ``x86_64_v3`` microarchitecture and to use ``mvapich2`` if they
+depend on ``mpi``.
+
+The ``variants`` and ``version`` preferences can be set under
+package specific sections of the ``packages.yaml`` file:
+
+.. code-block:: yaml
+
+   packages:
+     opencv:
+       variants: +debug
+     gperftools:
+       version: [2.2, 2.4, 2.3]
+
+In this case, the preference for ``opencv`` is to build with debug options, while
+``gperftools`` prefers version 2.2 over 2.4.
+
+Any preference can be overwritten on the command line if explicitly requested.
+
+Preferences cannot overcome explicit constraints, as they only set a preferred
+ordering among homogeneous attribute values. Going back to the example, if
+``gperftools@2.3:`` was requested, then Spack will install version 2.4
+since the most preferred version 2.2 is prohibited by the version constraint.
+
+.. _package_permissions:
+
+-------------------
+Package Permissions
+-------------------
+
+Spack can be configured to assign permissions to the files installed
+by a package.
+
+In the ``packages.yaml`` file under ``permissions``, the attributes
+``read``, ``write``, and ``group`` control the package
+permissions. These attributes can be set per-package, or for all
+packages under ``all``. If permissions are set under ``all`` and for a
+specific package, the package-specific settings take precedence.
+
+The ``read`` and ``write`` attributes take one of ``user``, ``group``,
+and ``world``.
+
+.. code-block:: yaml
+
+  packages:
+    all:
+      permissions:
+        write: group
+        group: spack
+    my_app:
+      permissions:
+        read: group
+        group: my_team
+
+The permissions settings describe the broadest level of access to
+installations of the specified packages. The execute permissions of
+the file are set to the same level as read permissions for those files
+that are executable. The default setting for ``read`` is ``world``,
+and for ``write`` is ``user``. In the example above, installations of
+``my_app`` will be installed with user and group permissions but no
+world permissions, and owned by the group ``my_team``. All other
+packages will be installed with user and group write privileges, and
+world read privileges. Those packages will be owned by the group
+``spack``.
+
+The ``group`` attribute assigns a Unix-style group to a package. All
+files installed by the package will be owned by the assigned group,
+and the sticky group bit will be set on the install prefix and all
+directories inside the install prefix. This will ensure that even
+manually placed files within the install prefix are owned by the
+assigned group. If no group is assigned, Spack will allow the OS
+default behavior to go as expected.
+
+----------------------------
+Assigning Package Attributes
+----------------------------
+
+You can assign class-level attributes in the configuration:
+
+.. code-block:: yaml
+
+  packages:
+    mpileaks:
+      # Override existing attributes
+      url: http://www.somewhereelse.com/mpileaks-1.0.tar.gz
+      # ... or add new ones
+      x: 1
+
+Attributes set this way will be accessible to any method executed
+in the package.py file (e.g. the ``install()`` method). Values for these
+attributes may be any value parseable by yaml.
+
+These can only be applied to specific packages, not "all" or
+virtual packages.

lib/spack/docs/packaging_guide.rst

@@ -2337,7 +2337,7 @@ window while a batch job is running ``spack install`` on the same or
 overlapping dependencies without any process trying to re-do the work of
 another.
 
-For example, if you are using SLURM, you could launch an installation
+For example, if you are using Slurm, you could launch an installation
 of ``mpich`` using the following command:
 
 .. code-block:: console

lib/spack/docs/requirements.txt

@@ -5,9 +5,9 @@ sphinx-rtd-theme==1.3.0
 python-levenshtein==0.23.0
 docutils==0.18.1
 pygments==2.16.1
-urllib3==2.0.7
+urllib3==2.1.0
 pytest==7.4.3
 isort==5.12.0
-black==23.10.1
+black==23.11.0
 flake8==6.1.0
-mypy==1.6.1
+mypy==1.7.0

lib/spack/spack/audit.py

@@ -40,6 +40,7 @@ def _search_duplicate_compilers(error_cls):
 import collections.abc
 import glob
 import inspect
+import io
 import itertools
 import pathlib
 import pickle
@@ -54,6 +55,7 @@ def _search_duplicate_compilers(error_cls):
 import spack.repo
 import spack.spec
 import spack.util.crypto
+import spack.util.spack_yaml as syaml
 import spack.variant
 
 #: Map an audit tag to a list of callables implementing checks
@@ -250,6 +252,40 @@ def _search_duplicate_specs_in_externals(error_cls):
     return errors
 
 
+@config_packages
+def _deprecated_preferences(error_cls):
+    """Search package preferences deprecated in v0.21 (and slated for removal in v0.22)"""
+    # TODO (v0.22): remove this audit as the attributes will not be allowed in config
+    errors = []
+    packages_yaml = spack.config.CONFIG.get_config("packages")
+
+    def make_error(attribute_name, config_data, summary):
+        s = io.StringIO()
+        s.write("Occurring in the following file:\n")
+        dict_view = syaml.syaml_dict((k, v) for k, v in config_data.items() if k == attribute_name)
+        syaml.dump_config(dict_view, stream=s, blame=True)
+        return error_cls(summary=summary, details=[s.getvalue()])
+
+    if "all" in packages_yaml and "version" in packages_yaml["all"]:
+        summary = "Using the deprecated 'version' attribute under 'packages:all'"
+        errors.append(make_error("version", packages_yaml["all"], summary))
+
+    for package_name in packages_yaml:
+        if package_name == "all":
+            continue
+
+        package_conf = packages_yaml[package_name]
+        for attribute in ("compiler", "providers", "target"):
+            if attribute not in package_conf:
+                continue
+            summary = (
+                f"Using the deprecated '{attribute}' attribute " f"under 'packages:{package_name}'"
+            )
+            errors.append(make_error(attribute, package_conf, summary))
+
+    return errors
+
+
 #: Sanity checks on package directives
 package_directives = AuditClass(
     group="packages",
@@ -776,7 +812,7 @@ def _version_constraints_are_satisfiable_by_some_version_in_repo(pkgs, error_cls
                 )
             except Exception:
                 summary = (
-                    "{0}: dependency on {1} cannot be satisfied " "by known versions of {1.name}"
+                    "{0}: dependency on {1} cannot be satisfied by known versions of {1.name}"
                 ).format(pkg_name, s)
                 details = ["happening in " + filename]
                 if dependency_pkg_cls is not None:
@@ -818,6 +854,53 @@ def _analyze_variants_in_directive(pkg, constraint, directive, error_cls):
     return errors
 
 
+@package_directives
+def _named_specs_in_when_arguments(pkgs, error_cls):
+    """Reports named specs in the 'when=' attribute of a directive.
+
+    Note that 'conflicts' is the only directive allowing that.
+    """
+    errors = []
+    for pkg_name in pkgs:
+        pkg_cls = spack.repo.PATH.get_pkg_class(pkg_name)
+
+        def _extracts_errors(triggers, summary):
+            _errors = []
+            for trigger in list(triggers):
+                when_spec = spack.spec.Spec(trigger)
+                if when_spec.name is not None and when_spec.name != pkg_name:
+                    details = [f"using '{trigger}', should be '^{trigger}'"]
+                    _errors.append(error_cls(summary=summary, details=details))
+            return _errors
+
+        for dname, triggers in pkg_cls.dependencies.items():
+            summary = f"{pkg_name}: wrong 'when=' condition for the '{dname}' dependency"
+            errors.extend(_extracts_errors(triggers, summary))
+
+        for vname, (variant, triggers) in pkg_cls.variants.items():
+            summary = f"{pkg_name}: wrong 'when=' condition for the '{vname}' variant"
+            errors.extend(_extracts_errors(triggers, summary))
+
+        for provided, triggers in pkg_cls.provided.items():
+            summary = f"{pkg_name}: wrong 'when=' condition for the '{provided}' virtual"
+            errors.extend(_extracts_errors(triggers, summary))
+
+        for _, triggers in pkg_cls.requirements.items():
+            triggers = [when_spec for when_spec, _, _ in triggers]
+            summary = f"{pkg_name}: wrong 'when=' condition in 'requires' directive"
+            errors.extend(_extracts_errors(triggers, summary))
+
+        triggers = list(pkg_cls.patches)
+        summary = f"{pkg_name}: wrong 'when=' condition in 'patch' directives"
+        errors.extend(_extracts_errors(triggers, summary))
+
+        triggers = list(pkg_cls.resources)
+        summary = f"{pkg_name}: wrong 'when=' condition in 'resource' directives"
+        errors.extend(_extracts_errors(triggers, summary))
+
+    return llnl.util.lang.dedupe(errors)
+
+
 #: Sanity checks on package directives
 external_detection = AuditClass(
     group="externals",

lib/spack/spack/build_systems/oneapi.py

@@ -179,6 +179,35 @@ def libs(self):
         return find_libraries("*", root=lib_path, shared=True, recursive=True)
 
 
+class IntelOneApiLibraryPackageWithSdk(IntelOneApiPackage):
+    """Base class for Intel oneAPI library packages with SDK components.
+
+    Contains some convenient default implementations for libraries
+    that expose functionality in sdk subdirectories.
+    Implement the method directly in the package if something
+    different is needed.
+
+    """
+
+    @property
+    def include(self):
+        return join_path(self.component_prefix, "sdk", "include")
+
+    @property
+    def headers(self):
+        return find_headers("*", self.include, recursive=True)
+
+    @property
+    def lib(self):
+        lib_path = join_path(self.component_prefix, "sdk", "lib64")
+        lib_path = lib_path if isdir(lib_path) else dirname(lib_path)
+        return lib_path
+
+    @property
+    def libs(self):
+        return find_libraries("*", root=self.lib, shared=True, recursive=True)
+
+
 class IntelOneApiStaticLibraryList:
     """Provides ld_flags when static linking is needed
 

lib/spack/spack/cmd/audit.py

@@ -2,6 +2,8 @@
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
+import warnings
+
 import llnl.util.tty as tty
 import llnl.util.tty.colify
 import llnl.util.tty.color as cl
@@ -52,8 +54,10 @@ def setup_parser(subparser):
 
 
 def configs(parser, args):
-    reports = spack.audit.run_group(args.subcommand)
-    _process_reports(reports)
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        reports = spack.audit.run_group(args.subcommand)
+        _process_reports(reports)
 
 
 def packages(parser, args):

lib/spack/spack/cmd/diff.py

@@ -200,6 +200,8 @@ def diff(parser, args):
 
     specs = []
     for spec in spack.cmd.parse_specs(args.specs):
+        # If the spec has a hash, check it before disambiguating
+        spec.replace_hash()
         if spec.concrete:
             specs.append(spec)
         else:

lib/spack/spack/cmd/info.py

@@ -139,7 +139,7 @@ def lines(self):
                     yield "    " + self.fmt % t
 
 
-def print_dependencies(pkg):
+def print_dependencies(pkg, args):
     """output build, link, and run package dependencies"""
 
     for deptype in ("build", "link", "run"):
@@ -152,7 +152,7 @@ def print_dependencies(pkg):
             color.cprint("    None")
 
 
-def print_detectable(pkg):
+def print_detectable(pkg, args):
     """output information on external detection"""
 
     color.cprint("")
@@ -180,7 +180,7 @@ def print_detectable(pkg):
         color.cprint("    False")
 
 
-def print_maintainers(pkg):
+def print_maintainers(pkg, args):
     """output package maintainers"""
 
     if len(pkg.maintainers) > 0:
@@ -189,7 +189,7 @@ def print_maintainers(pkg):
         color.cprint(section_title("Maintainers: ") + mnt)
 
 
-def print_phases(pkg):
+def print_phases(pkg, args):
     """output installation phases"""
 
     if hasattr(pkg.builder, "phases") and pkg.builder.phases:
@@ -201,7 +201,7 @@ def print_phases(pkg):
         color.cprint(phase_str)
 
 
-def print_tags(pkg):
+def print_tags(pkg, args):
     """output package tags"""
 
     color.cprint("")
@@ -213,7 +213,7 @@ def print_tags(pkg):
         color.cprint("    None")
 
 
-def print_tests(pkg):
+def print_tests(pkg, args):
     """output relevant build-time and stand-alone tests"""
 
     # Some built-in base packages (e.g., Autotools) define callback (e.g.,
@@ -407,12 +407,15 @@ def print_variants_by_name(pkg):
                 sys.stdout.write("\n")
 
 
-def print_variants(pkg):
+def print_variants(pkg, args):
     """output variants"""
-    print_variants_grouped_by_when(pkg)
+    if args.variants_by_name:
+        print_variants_by_name(pkg)
+    else:
+        print_variants_grouped_by_when(pkg)
 
 
-def print_versions(pkg):
+def print_versions(pkg, args):
     """output versions"""
 
     color.cprint("")
@@ -465,7 +468,7 @@ def get_url(version):
                 color.cprint(line)
 
 
-def print_virtuals(pkg):
+def print_virtuals(pkg, args):
     """output virtual packages"""
 
     color.cprint("")
@@ -488,7 +491,7 @@ def print_virtuals(pkg):
         color.cprint("    None")
 
 
-def print_licenses(pkg):
+def print_licenses(pkg, args):
     """Output the licenses of the project."""
 
     color.cprint("")
@@ -523,17 +526,13 @@ def info(parser, args):
     if getattr(pkg, "homepage"):
         color.cprint(section_title("Homepage: ") + pkg.homepage)
 
-    _print_variants = (
-        print_variants_by_name if args.variants_by_name else print_variants_grouped_by_when
-    )
-
     # Now output optional information in expected order
     sections = [
         (args.all or args.maintainers, print_maintainers),
         (args.all or args.detectable, print_detectable),
         (args.all or args.tags, print_tags),
         (args.all or not args.no_versions, print_versions),
-        (args.all or not args.no_variants, _print_variants),
+        (args.all or not args.no_variants, print_variants),
         (args.all or args.phases, print_phases),
         (args.all or not args.no_dependencies, print_dependencies),
         (args.all or args.virtuals, print_virtuals),
@@ -542,6 +541,6 @@ def info(parser, args):
     ]
     for print_it, func in sections:
         if print_it:
-            func(pkg)
+            func(pkg, args)
 
     color.cprint("")

lib/spack/spack/compilers/aocc.py

@@ -40,7 +40,6 @@ def debug_flags(self):
             "-gdwarf-5",
             "-gline-tables-only",
             "-gmodules",
-            "-gz",
             "-g",
         ]
 

lib/spack/spack/compilers/clang.py

@@ -55,7 +55,6 @@ def debug_flags(self):
             "-gdwarf-5",
             "-gline-tables-only",
             "-gmodules",
-            "-gz",
             "-g",
         ]
 

lib/spack/spack/modules/common.py

@@ -62,7 +62,7 @@
 
 #: config section for this file
 def configuration(module_set_name):
-    config_path = "modules:%s" % module_set_name
+    config_path = f"modules:{module_set_name}"
     return spack.config.get(config_path, {})
 
 
@@ -96,10 +96,10 @@ def _check_tokens_are_valid(format_string, message):
     named_tokens = re.findall(r"{(\w*)}", format_string)
     invalid_tokens = [x for x in named_tokens if x.lower() not in _valid_tokens]
     if invalid_tokens:
-        msg = message
-        msg += " [{0}]. ".format(", ".join(invalid_tokens))
-        msg += 'Did you check your "modules.yaml" configuration?'
-        raise RuntimeError(msg)
+        raise RuntimeError(
+            f"{message} [{', '.join(invalid_tokens)}]. "
+            f"Did you check your 'modules.yaml' configuration?"
+        )
 
 
 def update_dictionary_extending_lists(target, update):
@@ -219,7 +219,7 @@ def root_path(name, module_set_name):
     """
     defaults = {"lmod": "$spack/share/spack/lmod", "tcl": "$spack/share/spack/modules"}
     # Root folders where the various module files should be written
-    roots = spack.config.get("modules:%s:roots" % module_set_name, {})
+    roots = spack.config.get(f"modules:{module_set_name}:roots", {})
 
     # Merge config values into the defaults so we prefer configured values
     roots = spack.config.merge_yaml(defaults, roots)
@@ -262,7 +262,7 @@ def read_module_index(root):
     index_path = os.path.join(root, "module-index.yaml")
     if not os.path.exists(index_path):
         return {}
-    with open(index_path, "r") as index_file:
+    with open(index_path) as index_file:
         return _read_module_index(index_file)
 
 
@@ -310,21 +310,21 @@ def upstream_module(self, spec, module_type):
         if db_for_spec in self.upstream_dbs:
             db_index = self.upstream_dbs.index(db_for_spec)
         elif db_for_spec:
-            raise spack.error.SpackError("Unexpected: {0} is installed locally".format(spec))
+            raise spack.error.SpackError(f"Unexpected: {spec} is installed locally")
         else:
-            raise spack.error.SpackError("Unexpected: no install DB found for {0}".format(spec))
+            raise spack.error.SpackError(f"Unexpected: no install DB found for {spec}")
         module_index = self.module_indices[db_index]
         module_type_index = module_index.get(module_type, {})
         if not module_type_index:
             tty.debug(
-                "No {0} modules associated with the Spack instance where"
-                " {1} is installed".format(module_type, spec)
+                f"No {module_type} modules associated with the Spack instance "
+                f"where {spec} is installed"
             )
             return None
         if spec.dag_hash() in module_type_index:
             return module_type_index[spec.dag_hash()]
         else:
-            tty.debug("No module is available for upstream package {0}".format(spec))
+            tty.debug(f"No module is available for upstream package {spec}")
             return None
 
 
@@ -603,7 +603,7 @@ def filename(self):
         # Just the name of the file
         filename = self.use_name
         if self.extension:
-            filename = "{0}.{1}".format(self.use_name, self.extension)
+            filename = f"{self.use_name}.{self.extension}"
         # Architecture sub-folder
         arch_folder_conf = spack.config.get("modules:%s:arch_folder" % self.conf.name, True)
         if arch_folder_conf:
@@ -671,7 +671,7 @@ def configure_options(self):
             return msg
 
         if os.path.exists(pkg.install_configure_args_path):
-            with open(pkg.install_configure_args_path, "r") as args_file:
+            with open(pkg.install_configure_args_path) as args_file:
                 return spack.util.path.padding_filter(args_file.read())
 
         # Returning a false-like value makes the default templates skip
@@ -886,7 +886,7 @@ def _get_template(self):
         # 2. template specified in a package directly
         # 3. default template (must be defined, check in __init__)
         module_system_name = str(self.module.__name__).split(".")[-1]
-        package_attribute = "{0}_template".format(module_system_name)
+        package_attribute = f"{module_system_name}_template"
         choices = [
             self.conf.template,
             getattr(self.spec.package, package_attribute, None),
@@ -952,7 +952,7 @@ def write(self, overwrite=False):
 
         # Attribute from package
         module_name = str(self.module.__name__).split(".")[-1]
-        attr_name = "{0}_context".format(module_name)
+        attr_name = f"{module_name}_context"
         pkg_update = getattr(self.spec.package, attr_name, {})
         context.update(pkg_update)
 
@@ -1002,7 +1002,7 @@ def update_module_hiddenness(self, remove=False):
 
         if modulerc_exists:
             # retrieve modulerc content
-            with open(modulerc_path, "r") as f:
+            with open(modulerc_path) as f:
                 content = f.readlines()
                 content = "".join(content).split("\n")
                 # remove last empty item if any

lib/spack/spack/package.py

@@ -52,6 +52,7 @@
 from spack.build_systems.oneapi import (
     INTEL_MATH_LIBRARIES,
     IntelOneApiLibraryPackage,
+    IntelOneApiLibraryPackageWithSdk,
     IntelOneApiPackage,
     IntelOneApiStaticLibraryList,
 )

lib/spack/spack/schema/packages.py

@@ -69,6 +69,8 @@
     "patternProperties": {r"\w+": {}},
 }
 
+REQUIREMENT_URL = "https://spack.readthedocs.io/en/latest/packages_yaml.html#package-requirements"
+
 #: Properties for inclusion in other schemas
 properties = {
     "packages": {
@@ -117,7 +119,7 @@
                     "properties": ["version"],
                     "message": "setting version preferences in the 'all' section of packages.yaml "
                     "is deprecated and will be removed in v0.22\n\n\tThese preferences "
-                    "will be ignored by Spack. You can set them only in package specific sections "
+                    "will be ignored by Spack. You can set them only in package-specific sections "
                     "of the same file.\n",
                     "error": False,
                 },
@@ -162,10 +164,14 @@
                 },
                 "deprecatedProperties": {
                     "properties": ["target", "compiler", "providers"],
-                    "message": "setting compiler, target or provider preferences in a package "
-                    "specific section of packages.yaml is deprecated, and will be removed in "
-                    "v0.22.\n\n\tThese preferences will be ignored by Spack. You "
-                    "can set them only in the 'all' section of the same file.\n",
+                    "message": "setting 'compiler:', 'target:' or 'provider:' preferences in "
+                    "a package-specific section of packages.yaml is deprecated, and will be "
+                    "removed in v0.22.\n\n\tThese preferences will be ignored by Spack, and "
+                    "can be set only in the 'all' section of the same file. "
+                    "You can run:\n\n\t\t$ spack audit configs\n\n\tto get better diagnostics, "
+                    "including files:lines where the deprecated attributes are used.\n\n"
+                    "\tUse requirements to enforce conditions on specific packages: "
+                    f"{REQUIREMENT_URL}\n",
                     "error": False,
                 },
             }

lib/spack/spack/solver/asp.py

@@ -713,7 +713,7 @@ def _get_cause_tree(
         (condition_id, set_id) in which the latter idea means that the condition represented by
         the former held in the condition set represented by the latter.
         """
-        seen = set(seen) | set(cause)
+        seen.add(cause)
         parents = [c for e, c in condition_causes if e == cause and c not in seen]
         local = "required because %s " % conditions[cause[0]]
 
@@ -812,7 +812,14 @@ def on_model(model):
         errors = sorted(
             [(int(priority), msg, args) for priority, msg, *args in error_args], reverse=True
         )
-        msg = self.message(errors)
+        try:
+            msg = self.message(errors)
+        except Exception as e:
+            msg = (
+                f"unexpected error during concretization [{str(e)}]. "
+                f"Please report a bug at https://github.com/spack/spack/issues"
+            )
+            raise spack.error.SpackError(msg)
         raise UnsatisfiableSpecError(msg)
 
 

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

@@ -53,6 +53,7 @@
 stage = SpackCommand("stage")
 uninstall = SpackCommand("uninstall")
 find = SpackCommand("find")
+module = SpackCommand("module")
 
 sep = os.sep
 
@@ -1105,13 +1106,14 @@ def test_multi_env_remove(mutable_mock_env_path, monkeypatch, answer):
         assert all(e in env("list") for e in environments)
 
 
-def test_env_loads(install_mockery, mock_fetch):
+def test_env_loads(install_mockery, mock_fetch, mock_modules_root):
     env("create", "test")
 
     with ev.read("test"):
         add("mpileaks")
         concretize()
         install("--fake")
+        module("tcl", "refresh", "-y")
 
     with ev.read("test"):
         env("loads")

lib/spack/spack/test/cmd/info.py

@@ -33,10 +33,11 @@ def _print(*args, **kwargs):
 
 
 @pytest.mark.parametrize(
-    "pkg", ["openmpi", "trilinos", "boost", "python", "dealii", "xsdk"]  # a BundlePackage
+    "pkg", ["openmpi", "trilinos", "boost", "python", "dealii", "xsdk", "gasnet", "warpx"]
 )
-def test_it_just_runs(pkg):
-    info(pkg)
+@pytest.mark.parametrize("extra_args", [[], ["--variants-by-name"]])
+def test_it_just_runs(pkg, extra_args):
+    info(pkg, *extra_args)
 
 
 def test_info_noversion(mock_packages, print_buffer):
@@ -78,7 +79,8 @@ def test_is_externally_detectable(pkg_query, expected, parser, print_buffer):
         "gcc",  # This should ensure --test's c_names processing loop covered
     ],
 )
-def test_info_fields(pkg_query, parser, print_buffer):
+@pytest.mark.parametrize("extra_args", [[], ["--variants-by-name"]])
+def test_info_fields(pkg_query, extra_args, parser, print_buffer):
     expected_fields = (
         "Description:",
         "Homepage:",
@@ -91,7 +93,7 @@ def test_info_fields(pkg_query, parser, print_buffer):
         "Licenses:",
     )
 
-    args = parser.parse_args(["--all", pkg_query])
+    args = parser.parse_args(["--all", pkg_query] + extra_args)
     spack.cmd.info.info(parser, args)
 
     for text in expected_fields:

lib/spack/spack/test/compilers/basics.py

@@ -422,7 +422,6 @@ def test_clang_flags():
             "-gdwarf-5",
             "-gline-tables-only",
             "-gmodules",
-            "-gz",
             "-g",
         ],
         "clang@3.3",
@@ -445,7 +444,6 @@ def test_aocc_flags():
             "-gdwarf-5",
             "-gline-tables-only",
             "-gmodules",
-            "-gz",
             "-g",
         ],
         "aocc@2.2.0",

lib/spack/spack/test/conftest.py

@@ -6,6 +6,7 @@
 import collections
 import datetime
 import errno
+import functools
 import inspect
 import itertools
 import json
@@ -1967,3 +1968,14 @@ def __exit__(self, *args):
             pass
 
     monkeypatch.setattr(spack.cmd.buildcache, "_make_pool", MockPool)
+
+
+def _root_path(x, y, *, path):
+    return path
+
+
+@pytest.fixture
+def mock_modules_root(tmp_path, monkeypatch):
+    """Sets the modules root to a temporary directory, to avoid polluting configuration scopes."""
+    fn = functools.partial(_root_path, path=str(tmp_path))
+    monkeypatch.setattr(spack.modules.common, "root_path", fn)

lib/spack/spack/test/data/config/modules.yaml

@@ -14,12 +14,7 @@
 #   ~/.spack/modules.yaml
 # -------------------------------------------------------------------------
 modules:
-  default:
-    enable:
-      - tcl
-    roots:
-      tcl: $user_cache_path/tcl
-      lmod: $user_cache_path/lmod
+  default: {}
   prefix_inspections:
     bin:
       - PATH

lib/spack/spack/test/llnl/util/lock.py

@@ -18,7 +18,7 @@
     mpirun -n 7 spack test lock
 
 And it will test locking correctness among MPI processes.  Ideally, you
-want the MPI processes to span across multiple nodes, so, e.g., for SLURM
+want the MPI processes to span across multiple nodes, so, e.g., for Slurm
 you might do this::
 
     srun -N 7 -n 7 -m cyclic spack test lock

lib/spack/spack/test/modules/common.py

@@ -17,7 +17,10 @@
 from spack.modules.common import UpstreamModuleIndex
 from spack.spec import Spec
 
-pytestmark = pytest.mark.not_on_windows("does not run on windows")
+pytestmark = [
+    pytest.mark.not_on_windows("does not run on windows"),
+    pytest.mark.usefixtures("mock_modules_root"),
+]
 
 
 def test_update_dictionary_extending_list():
@@ -174,6 +177,7 @@ def test_load_installed_package_not_in_repo(install_mockery, mock_fetch, monkeyp
     """Test that installed packages that have been removed are still loadable"""
     spec = Spec("trivial-install-test-package").concretized()
     spec.package.do_install()
+    spack.modules.module_types["tcl"](spec, "default", True).write()
 
     def find_nothing(*args):
         raise spack.repo.UnknownPackageError("Repo package access is disabled for test")

lib/spack/spack/test/modules/conftest.py

@@ -2,6 +2,8 @@
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
+import pathlib
+
 import pytest
 
 import spack.config
@@ -13,26 +15,15 @@
 
 @pytest.fixture()
 def modulefile_content(request):
-    """Returns a function that generates the content of a module file
-    as a list of lines.
-    """
-
+    """Returns a function that generates the content of a module file as a list of lines."""
     writer_cls = getattr(request.module, "writer_cls")
 
     def _impl(spec_str, module_set_name="default", explicit=True):
-        # Write the module file
-        spec = spack.spec.Spec(spec_str)
-        spec.concretize()
+        spec = spack.spec.Spec(spec_str).concretized()
         generator = writer_cls(spec, module_set_name, explicit)
         generator.write(overwrite=True)
-
-        # Get its filename
-        filename = generator.layout.filename
-
-        # Retrieve the content
-        with open(filename) as f:
-            content = f.readlines()
-            content = "".join(content).split("\n")
+        written_module = pathlib.Path(generator.layout.filename)
+        content = written_module.read_text().splitlines()
         generator.remove()
         return content
 
@@ -40,27 +31,21 @@ def _impl(spec_str, module_set_name="default", explicit=True):
 
 
 @pytest.fixture()
-def factory(request):
-    """Function that, given a spec string, returns an instance of the writer
-    and the corresponding spec.
-    """
-
-    # Class of the module file writer
+def factory(request, mock_modules_root):
+    """Given a spec string, returns an instance of the writer and the corresponding spec."""
     writer_cls = getattr(request.module, "writer_cls")
 
     def _mock(spec_string, module_set_name="default", explicit=True):
-        spec = spack.spec.Spec(spec_string)
-        spec.concretize()
+        spec = spack.spec.Spec(spec_string).concretized()
         return writer_cls(spec, module_set_name, explicit), spec
 
     return _mock
 
 
 @pytest.fixture()
-def mock_module_filename(monkeypatch, tmpdir):
-    filename = str(tmpdir.join("module"))
+def mock_module_filename(monkeypatch, tmp_path):
+    filename = tmp_path / "module"
     # Set for both module types so we can test both
-    monkeypatch.setattr(spack.modules.lmod.LmodFileLayout, "filename", filename)
-    monkeypatch.setattr(spack.modules.tcl.TclFileLayout, "filename", filename)
-
-    yield filename
+    monkeypatch.setattr(spack.modules.lmod.LmodFileLayout, "filename", str(filename))
+    monkeypatch.setattr(spack.modules.tcl.TclFileLayout, "filename", str(filename))
+    yield str(filename)

lib/spack/spack/test/modules/lmod.py

@@ -21,7 +21,10 @@
 #: Class of the writer tested in this module
 writer_cls = spack.modules.lmod.LmodModulefileWriter
 
-pytestmark = pytest.mark.not_on_windows("does not run on windows")
+pytestmark = [
+    pytest.mark.not_on_windows("does not run on windows"),
+    pytest.mark.usefixtures("mock_modules_root"),
+]
 
 
 @pytest.fixture(params=["clang@=12.0.0", "gcc@=10.2.1"])

lib/spack/spack/test/modules/tcl.py

@@ -18,7 +18,10 @@
 #: Class of the writer tested in this module
 writer_cls = spack.modules.tcl.TclModulefileWriter
 
-pytestmark = pytest.mark.not_on_windows("does not run on windows")
+pytestmark = [
+    pytest.mark.not_on_windows("does not run on windows"),
+    pytest.mark.usefixtures("mock_modules_root"),
+]
 
 
 @pytest.mark.usefixtures("config", "mock_packages", "mock_module_filename")
@@ -279,7 +282,7 @@ def test_projections_all(self, factory, module_configuration):
         projection = writer.spec.format(writer.conf.projections["all"])
         assert projection in writer.layout.use_name
 
-    def test_invalid_naming_scheme(self, factory, module_configuration, mock_module_filename):
+    def test_invalid_naming_scheme(self, factory, module_configuration):
         """Tests the evaluation of an invalid naming scheme."""
 
         module_configuration("invalid_naming_scheme")
@@ -290,7 +293,7 @@ def test_invalid_naming_scheme(self, factory, module_configuration, mock_module_
         with pytest.raises(RuntimeError):
             writer.layout.use_name
 
-    def test_invalid_token_in_env_name(self, factory, module_configuration, mock_module_filename):
+    def test_invalid_token_in_env_name(self, factory, module_configuration):
         """Tests setting environment variables with an invalid name."""
 
         module_configuration("invalid_token_in_env_var_name")

share/spack/gitlab/cloud_pipelines/configs/ci.yaml

@@ -4,6 +4,7 @@ ci:
   broken-tests-packages:
     - gptune
     - superlu-dist    # srun -n 4 hangs
+    - papyrus
 
   broken-specs-url: "https://dummy.io" # s3://spack-binaries/broken-specs"
 

share/spack/gitlab/cloud_pipelines/stacks/e4s-oneapi/spack.yaml

@@ -197,14 +197,18 @@ spack:
   - amrex +sycl
   - arborx +sycl ^kokkos +sycl +openmp cxxstd=17 +tests +examples
   - cabana +sycl ^kokkos +sycl +openmp cxxstd=17 +tests +examples
+  - ginkgo +sycl
+  - heffte +sycl
   - kokkos +sycl +openmp cxxstd=17 +tests +examples
   - kokkos-kernels build_type=Release %oneapi ^kokkos +sycl +openmp cxxstd=17 +tests +examples
+  - petsc +sycl
   - slate +sycl
   - sundials +sycl cxxstd=17 +examples-install
   - tau +mpi +opencl +level_zero ~pdt +syscall   # tau: requires libdrm.so to be installed
+  - upcxx +level_zero
   # --
-  # - ginkgo +oneapi                    # InstallError: Ginkgo's oneAPI backend requires theDPC++ compiler as main CXX compiler.
   # - hpctoolkit +level_zero            # dyninst@12.3.0%gcc: /usr/bin/ld: libiberty/./d-demangle.c:142: undefined reference to `_intel_fast_memcpy'; can't mix intel-tbb@%oneapi with dyninst%gcc
+  # - warpx compute=sycl                # warpx: spack-build-wzp6vvo/_deps/fetchedamrex-src/Src/Base/AMReX_RandomEngine.H:18:10: fatal error: 'oneapi/mkl/rng/device.hpp' file not found
 
   - py-scipy
 

var/spack/repos/builtin/packages/alpgen/package.py

@@ -16,7 +16,6 @@ class Alpgen(CMakePackage, MakefilePackage):
     homepage = "http://mlm.home.cern.ch/mlm/alpgen/"
     url = "http://mlm.home.cern.ch/mlm/alpgen/V2.1/v214.tgz"
 
-    maintainers("iarspider")
     tags = ["hep"]
 
     version("2.1.4", sha256="2f43f7f526793fe5f81a3a3e1adeffe21b653a7f5851efc599ed69ea13985c5e")

var/spack/repos/builtin/packages/amrex/package.py

@@ -21,7 +21,7 @@ class Amrex(CMakePackage, CudaPackage, ROCmPackage):
 
     tags = ["ecp", "e4s"]
 
-    maintainers("WeiqunZhang", "asalmgren", "etpalmer63")
+    maintainers("WeiqunZhang", "asalmgren", "atmyers")
 
     version("develop", branch="development")
     version("23.11", sha256="49b9fea10cd2a2b6cb0fedf7eac8f7889eacc68a05ae5ac7c5702bc0eb1b3848")

var/spack/repos/builtin/packages/asio/package.py

@@ -16,6 +16,8 @@ class Asio(AutotoolsPackage):
     git = "https://github.com/chriskohlhoff/asio.git"
     maintainers("msimberg", "pauleonix")
 
+    license("BSL-1.0")
+
     # As uneven minor versions of asio are not considered stable, they wont be added anymore
     version("1.28.0", sha256="226438b0798099ad2a202563a83571ce06dd13b570d8fded4840dbc1f97fa328")
     version("1.26.0", sha256="935583f86825b7b212479277d03543e0f419a55677fa8cb73a79a927b858a72d")

var/spack/repos/builtin/packages/bfs/package.py

@@ -14,6 +14,7 @@ class Bfs(MakefilePackage):
 
     maintainers("alecbcs")
 
+    version("3.0.4", sha256="7196f5a624871c91ad051752ea21043c198a875189e08c70ab3167567a72889d")
     version("3.0.2", sha256="d3456a9aeecc031064db0dbe012e55a11eb97be88d0ab33a90e570fe66457f92")
     version("3.0.1", sha256="a38bb704201ed29f4e0b989fb2ab3791ca51c3eff90acfc31fff424579bbf962")
 

var/spack/repos/builtin/packages/bison/package.py

@@ -65,6 +65,13 @@ class Bison(AutotoolsPackage, GNUMirrorPackage):
     patch("nvhpc-3.7.patch", when="@3.7.0:3.7 %nvhpc")
 
     conflicts("%intel@:14", when="@3.4.2:", msg="Intel 14 has immature C11 support")
+    conflicts(
+        "%oneapi",
+        msg=(
+            "bison is likely miscompiled by oneapi compilers, "
+            "see https://github.com/spack/spack/issues/37172"
+        ),
+    )
 
     if sys.platform == "darwin" and macos_version() >= Version("10.13"):
         patch("secure_snprintf.patch", level=0, when="@3.0.4")

var/spack/repos/builtin/packages/brahma/package.py

@@ -15,11 +15,14 @@ class Brahma(CMakePackage):
 
     version("develop", branch="dev")
     version("master", branch="master")
+    version("0.0.2", tag="v0.0.2", commit="bac58d5aa8962a5c902d401fbf8021aff9104d3c")
     version("0.0.1", tag="v0.0.1", commit="15156036f14e36511dfc3f3751dc953540526a2b")
 
     variant("mpi", default=False, description="Enable MPI support")
-    depends_on("cpp-logger@0.0.1")
-    depends_on("gotcha@develop")
+    depends_on("cpp-logger@0.0.1", when="@:0.0.1")
+    depends_on("cpp-logger@0.0.2", when="@0.0.2:")
+    depends_on("gotcha@1.0.4", when="@:0.0.1")
+    depends_on("gotcha@1.0.5", when="@0.0.2:")
     depends_on("catch2@3.0.1")
 
     depends_on("mpi", when="+mpi")

var/spack/repos/builtin/packages/bzip2/package.py

@@ -44,6 +44,10 @@ class Bzip2(Package, SourcewarePackage):
     if sys.platform != "win32":
         depends_on("diffutils", type="build")
 
+    depends_on("gmake", type="build", when="platform=linux")
+    depends_on("gmake", type="build", when="platform=cray")
+    depends_on("gmake", type="build", when="platform=darwin")
+
     @classmethod
     def determine_version(cls, exe):
         output = Executable(exe)("--help", output=str, error=str)

var/spack/repos/builtin/packages/catch2/package.py

@@ -110,9 +110,13 @@ class Catch2(CMakePackage):
     )
     variant("shared", when="@3:", default=False, description="Build shared library")
 
+    variant(
+        "cxxstd", default="14", values=("14", "17"), multi=False, description="Define C++ standard"
+    )
+
     def cmake_args(self):
         spec = self.spec
-        args = []
+        args = [self.define_from_variant("CMAKE_CXX_STANDARD", "cxxstd")]
         # 1.7.0-1.9.3: no control over test builds
         if spec.satisfies("@1.9.4:2.1.0"):
             args.append("-DNO_SELFTEST={0}".format("OFF" if self.run_tests else "ON"))

var/spack/repos/builtin/packages/clhep/package.py

@@ -19,6 +19,8 @@ class Clhep(CMakePackage):
 
     maintainers("drbenmorgan")
 
+    version("2.4.7.1", sha256="1c8304a7772ac6b99195f1300378c6e3ddf4ad07c85d64a04505652abb8a55f9")
+    version("2.4.7.0", sha256="7fa460030bc1a804ea7da8cce7611b93261493bbb66c3cfd3ceec935d7e1b8d3")
     version("2.4.6.4", sha256="49c89330f1903ef707d3c5d79c16a7c5a6f2c90fc290e2034ee3834809489e57")
     version("2.4.6.3", sha256="fcd007f11b10ba4af28d027222b63148d0eb44ff7a082eee353bdf921f9c684a")
     version("2.4.6.2", sha256="aded73e49bac85a5b4e86f64a0ee3d6f3cfe5551b0f7731c78b6d8f9dac6e8dc")

var/spack/repos/builtin/packages/cmake/package.py

@@ -20,7 +20,7 @@ class Cmake(Package):
     url = "https://github.com/Kitware/CMake/releases/download/v3.19.0/cmake-3.19.0.tar.gz"
     git = "https://gitlab.kitware.com/cmake/cmake.git"
 
-    maintainers("alalazo")
+    maintainers("alalazo", "johnwparent")
 
     tags = ["build-tools", "windows"]
 
@@ -234,13 +234,15 @@ class Cmake(Package):
     with when("~ownlibs"):
         depends_on("expat")
         # expat/zlib are used in CMake/CTest, so why not require them in libarchive.
-        depends_on("libarchive@3.1.0: xar=expat compression=zlib")
-        depends_on("libarchive@3.3.3:", when="@3.15.0:")
-        depends_on("libuv@1.0.0:1.10", when="@3.7.0:3.10.3")
-        depends_on("libuv@1.10.0:1.10", when="@3.11.0:3.11")
-        depends_on("libuv@1.10.0:", when="@3.12.0:")
-        depends_on("rhash", when="@3.8.0:")
-        depends_on("jsoncpp build_system=meson", when="@3.2:")
+        for plat in ["darwin", "cray", "linux"]:
+            with when("platform=%s" % plat):
+                depends_on("libarchive@3.1.0: xar=expat compression=zlib")
+                depends_on("libarchive@3.3.3:", when="@3.15.0:")
+                depends_on("libuv@1.0.0:1.10", when="@3.7.0:3.10.3")
+                depends_on("libuv@1.10.0:1.10", when="@3.11.0:3.11")
+                depends_on("libuv@1.10.0:", when="@3.12.0:")
+                depends_on("rhash", when="@3.8.0:")
+                depends_on("jsoncpp build_system=meson", when="@3.2:")
 
     depends_on("ncurses", when="+ncurses")
 
@@ -248,9 +250,6 @@ class Cmake(Package):
         depends_on("python@2.7.11:", type="build")
         depends_on("py-sphinx", type="build")
 
-    # TODO: update curl package to build with Windows SSL implementation
-    # at which point we can build with +ownlibs on Windows
-    conflicts("~ownlibs", when="platform=windows")
     # Cannot build with Intel, should be fixed in 3.6.2
     # https://gitlab.kitware.com/cmake/cmake/issues/16226
     patch("intel-c-gnu11.patch", when="@3.6.0:3.6.1")

var/spack/repos/builtin/packages/conquest/package.py

@@ -49,6 +49,15 @@ class Conquest(MakefilePackage):
 
     build_directory = "src"
 
+    # The SYSTEM variable is required above version 1.2.
+    # Versions 1.2 and older should ignore it.
+    @property
+    def build_targets(self):
+        if self.version > Version("1.2"):
+            return ["SYSTEM = example", "Conquest"]
+        else:
+            return ["Conquest"]
+
     def edit(self, spec, prefix):
         fflags = "-O3 -fallow-argument-mismatch"
         ldflags = ""
@@ -63,12 +72,23 @@ def edit(self, spec, prefix):
 
         lapack_ld = self.spec["lapack"].libs.ld_flags
         blas_ld = self.spec["blas"].libs.ld_flags
+        fftw_ld = self.spec["fftw"].libs.ld_flags
+        libxc_ld = self.spec["libxc"].libs.ld_flags
 
-        defs_file = FileFilter("./src/system.make")
+        # Starting from 1.3 there's automated logic in the Makefile that picks
+        # from a list of possible files for system/compiler-specific definitions.
+        # This is useful for manual builds, but since the spack will do its own
+        # automation of compiler-specific flags, we will override it.
+        if self.version > Version("1.2"):
+            defs_file = FileFilter("./src/system/system.example.make")
+        else:
+            defs_file = FileFilter("./src/system.make")
 
-        defs_file.filter("COMPFLAGS=.*", f"COMPFLAGS= {fflags}")
-        defs_file.filter("LINKFLAGS=.*", f"LINKFLAGS= {ldflags}")
-        defs_file.filter("# BLAS=.*", f"BLAS= {lapack_ld} -llapack {blas_ld} -lblas")
+        defs_file.filter(".*COMPFLAGS=.*", f"COMPFLAGS= {fflags}")
+        defs_file.filter(".*LINKFLAGS=.*", f"LINKFLAGS= {ldflags}")
+        defs_file.filter(".*BLAS=.*", f"BLAS= {lapack_ld} {blas_ld}")
+        defs_file.filter(".*FFT_LIB=.*", f"FFT_LIB={fftw_ld}")
+        defs_file.filter(".*XC_LIB=.*", f"XC_LIB={libxc_ld} -lxcf90 -lxc")
 
         if "+openmp" in self.spec:
             defs_file.filter("OMP_DUMMY = DUMMY", "OMP_DUMMY = ")
@@ -81,3 +101,5 @@ def edit(self, spec, prefix):
     def install(self, spec, prefix):
         mkdirp(prefix.bin)
         install("./bin/Conquest", prefix.bin)
+        if self.version > Version("1.2"):
+            install_tree("./benchmarks/", join_path(prefix, "benchmarks"))

var/spack/repos/builtin/packages/cool/package.py

@@ -14,7 +14,6 @@ class Cool(CMakePackage):
     git = "https://gitlab.cern.ch/lcgcool/cool.git"
 
     tags = ["hep"]
-    maintainers("iarspider")
 
     version("3.3.10", tag="COOL_3_3_10", commit="110b51c2b50af07cbe1f64a1c67ce9f737c4421d")
     version("3.3.7", tag="COOL_3_3_7", commit="6f9a29d903e51ecbb26bdc8a694a67db9f28e234")

var/spack/repos/builtin/packages/cp2k/package.py

@@ -297,6 +297,10 @@ class Cp2k(MakefilePackage, CudaPackage, CMakePackage, ROCmPackage):
         depends_on("dbcsr+cuda", when="+cuda")
         depends_on("dbcsr+rocm", when="+rocm")
 
+    with when("@2022: +rocm"):
+        depends_on("hipblas")
+        depends_on("hipfft")
+
     # CP2K needs compiler specific compilation flags, e.g. optflags
     conflicts("%apple-clang")
     conflicts("%clang")

var/spack/repos/builtin/packages/cpr/package.py

@@ -18,7 +18,7 @@ class Cpr(CMakePackage):
     version("1.9.2", sha256="3bfbffb22c51f322780d10d3ca8f79424190d7ac4b5ad6ad896de08dbd06bf31")
 
     depends_on("curl")
-    depends_on("git", when="build")
+    depends_on("git", type="build")
 
     def cmake_args(self):
         _force = "_FORCE" if self.spec.satisfies("@:1.9") else ""

var/spack/repos/builtin/packages/dd4hep/package.py

@@ -254,7 +254,8 @@ def setup_run_environment(self, env):
         env.set("DD4HEP", self.prefix.examples)
         env.set("DD4hep_DIR", self.prefix)
         env.set("DD4hep_ROOT", self.prefix)
-        env.prepend_path("LD_LIBRARY_PATH", self.libs.directories[0])
+        if len(self.libs.directories) > 0:
+            env.prepend_path("LD_LIBRARY_PATH", self.libs.directories[0])
 
     def url_for_version(self, version):
         # dd4hep releases are dashes and padded with a leading zero

var/spack/repos/builtin/packages/dealii/package.py

@@ -23,9 +23,13 @@ class Dealii(CMakePackage, CudaPackage):
     # only add for immediate deps.
     transitive_rpaths = False
 
-    generator("ninja")
+    # FIXME nvcc_wrapper (used for +clang) doesn't handle response files
+    # correctly when ninja is used. Those are used automatically if paths get too long.
+    generator("make")
 
     version("master", branch="master")
+    version("9.5.1", sha256="a818b535e6488d3aef7853311657c7b4fadc29a9abe91b7b202b131aad630f5e")
+    version("9.5.0", sha256="a81f41565f0d3a22d491ee687957dd48053225da72e8d6d628d210358f4a0464")
     version("9.4.2", sha256="45a76cb400bfcff25cc2d9093d9a5c91545c8367985e6798811c5e9d2a6a6fd4")
     version("9.4.1", sha256="bfe5e4bf069159f93feb0f78529498bfee3da35baf5a9c6852aa59d7ea7c7a48")
     version("9.4.0", sha256="238677006cd9173658e5b69cdd1861f800556982db6005a3cc5eb8329cc1e36c")
@@ -70,10 +74,11 @@ class Dealii(CMakePackage, CudaPackage):
         values=("default", "11", "14", "17"),
     )
     variant("doc", default=False, description="Compile with documentation")
-    variant("examples", default=True, description="Compile tutorial programs")
+    variant("examples", default=True, description="Compile and install tutorial programs")
     variant("int64", default=False, description="Compile with 64 bit indices support")
     variant("mpi", default=True, description="Compile with MPI")
     variant("optflags", default=False, description="Compile using additional optimization flags")
+    variant("platform-introspection", default=True, description="Enable platform introspection")
     variant("python", default=False, description="Compile with Python bindings")
 
     # Package variants
@@ -81,11 +86,12 @@ class Dealii(CMakePackage, CudaPackage):
     variant("arborx", default=True, description="Compile with Arborx support")
     variant("arpack", default=True, description="Compile with Arpack and PArpack (only with MPI)")
     variant("adol-c", default=True, description="Compile with ADOL-C")
-    variant("cgal", default=True, when="@9.4:", description="Compile with CGAL")
+    variant("cgal", default=True, when="@9.4:~cuda", description="Compile with CGAL")
     variant("ginkgo", default=True, description="Compile with Ginkgo")
     variant("gmsh", default=True, description="Compile with GMSH")
     variant("gsl", default=True, description="Compile with GSL")
     variant("hdf5", default=True, description="Compile with HDF5 (only with MPI)")
+    variant("kokkos", default=True, when="@9.5:", description="Compile with Kokkos")
     variant("metis", default=True, description="Compile with Metis")
     variant("muparser", default=True, description="Compile with muParser")
     variant("nanoflann", default=False, description="Compile with Nanoflann")
@@ -98,14 +104,15 @@ class Dealii(CMakePackage, CudaPackage):
     variant("slepc", default=True, description="Compile with Slepc (only with Petsc and MPI)")
     variant("symengine", default=True, description="Compile with SymEngine")
     variant("simplex", default=True, description="Compile with Simplex support")
-    # TODO @9.3: enable by default, when we know what to do
-    # variant('taskflow',  default=False,
-    #        description='Compile with multi-threading via Taskflow')
-    # TODO @9.3: disable by default
-    # (NB: only if tbb is removed in 9.3, as planned!!!)
+    variant(
+        "taskflow",
+        default=True,
+        when="@9.6:",
+        description="Compile with multi-threading via Taskflow",
+    )
     variant("threads", default=True, description="Compile with multi-threading via TBB")
     variant("trilinos", default=True, description="Compile with Trilinos (only with MPI)")
-    variant("platform-introspection", default=True, description="Enable platform introspection")
+    variant("vtk", default=True, when="@9.6:", description="Compile with VTK")
 
     # Required dependencies: Light version
     depends_on("blas")
@@ -179,6 +186,8 @@ class Dealii(CMakePackage, CudaPackage):
     # TODO: next line fixes concretization with petsc
     depends_on("hdf5+mpi+hl+fortran", when="+hdf5+mpi+petsc")
     depends_on("hdf5+mpi+hl", when="+hdf5+mpi~petsc")
+    depends_on("kokkos@3.7:", when="@9.5:+kokkos~trilinos")
+    depends_on("kokkos@3.7:+cuda+cuda_lambda+wrapper", when="@9.5:+kokkos~trilinos+cuda")
     # TODO: concretizer bug. The two lines mimic what comes from PETSc
     # but we should not need it
     depends_on("metis@5:+int64", when="+metis+int64")
@@ -198,7 +207,7 @@ class Dealii(CMakePackage, CudaPackage):
     depends_on("sundials@:3~pthread", when="@9.0:9.2+sundials")
     depends_on("sundials@5:5.8", when="@9.3:9.3.3+sundials")
     depends_on("sundials@5:", when="@9.3.4:+sundials")
-    # depends_on('taskflow',         when='@9.3:+taskflow')
+    depends_on("taskflow@3.4:", when="@9.6:+taskflow")
     depends_on("trilinos gotype=int", when="+trilinos@12.18.1:")
     # TODO: next line fixes concretization with trilinos and adol-c
     depends_on("trilinos~exodus", when="@9.0:+adol-c+trilinos")
@@ -222,12 +231,11 @@ class Dealii(CMakePackage, CudaPackage):
     # do not require +rol to make concretization of xsdk possible
     depends_on("trilinos+amesos+aztec+epetra+ifpack+ml+muelu+sacado", when="+trilinos")
     depends_on("trilinos~hypre", when="+trilinos+int64")
-    # TODO: temporary disable Tpetra when using CUDA due to
-    # namespace "Kokkos::Impl" has no member "cuda_abort"
-    depends_on(
-        "trilinos@master+rol~amesos2~ifpack2~intrepid2~kokkos~tpetra~zoltan2",
-        when="+trilinos+cuda",
-    )
+    for _arch in CudaPackage.cuda_arch_values:
+        arch_str = f"+cuda cuda_arch={_arch}"
+        trilinos_spec = f"trilinos +wrapper {arch_str}"
+        depends_on(trilinos_spec, when=f"@9.5:+trilinos {arch_str}")
+    depends_on("vtk", when="@9.6:+vtk")
 
     # Explicitly provide a destructor in BlockVector,
     # otherwise deal.II may fail to build with Intel compilers.
@@ -296,44 +304,60 @@ class Dealii(CMakePackage, CudaPackage):
         msg="CGAL requires the C++ standard to be set explicitly to 17 or later.",
     )
 
+    conflicts(
+        "cxxstd=14",
+        when="@9.6:",
+        msg="Deal.II 9.6 onwards requires the C++ standard to be set to 17 or later.",
+    )
+
     # Interfaces added in 8.5.0:
-    for p in ["gsl", "python"]:
+    for _package in ["gsl", "python"]:
         conflicts(
-            "+{0}".format(p),
+            "+{0}".format(_package),
             when="@:8.4.2",
             msg="The interface to {0} is supported from version 8.5.0 "
             "onwards. Please explicitly disable this variant "
-            "via ~{0}".format(p),
+            "via ~{0}".format(_package),
         )
 
     # Interfaces added in 9.0.0:
-    for p in ["assimp", "gmsh", "nanoflann", "scalapack", "sundials", "adol-c"]:
+    for _package in ["assimp", "gmsh", "nanoflann", "scalapack", "sundials", "adol-c"]:
         conflicts(
-            "+{0}".format(p),
+            "+{0}".format(_package),
             when="@:8.5.1",
             msg="The interface to {0} is supported from version 9.0.0 "
             "onwards. Please explicitly disable this variant "
-            "via ~{0}".format(p),
+            "via ~{0}".format(_package),
         )
 
     # interfaces added in 9.1.0:
-    for p in ["ginkgo", "symengine"]:
+    for _package in ["ginkgo", "symengine"]:
         conflicts(
-            "+{0}".format(p),
+            "+{0}".format(_package),
             when="@:9.0",
             msg="The interface to {0} is supported from version 9.1.0 "
             "onwards. Please explicitly disable this variant "
-            "via ~{0}".format(p),
+            "via ~{0}".format(_package),
         )
 
     # interfaces added in 9.3.0:
-    for p in ["simplex", "arborx"]:  # , 'taskflow']:
+    for _package in ["simplex", "arborx"]:
         conflicts(
-            "+{0}".format(p),
+            "+{0}".format(_package),
             when="@:9.2",
             msg="The interface to {0} is supported from version 9.3.0 "
             "onwards. Please explicitly disable this variant "
-            "via ~{0}".format(p),
+            "via ~{0}".format(_package),
+        )
+
+    # interfaces added after 9.5.0:
+    for _package in ["vtk", "taskflow"]:
+        conflicts(
+            "+{0}".format(_package),
+            when="@:9.5",
+            msg="The interface to {0} is supported from version 9.6.0 "
+            "onwards. Please explicitly disable this variant "
+            "via ~{0}".format(_package),
         )
 
     # Interfaces removed in 9.3.0:
@@ -346,18 +370,29 @@ class Dealii(CMakePackage, CudaPackage):
 
     # Check that the combination of variants makes sense
     # 64-bit BLAS:
-    for p in ["openblas", "intel-mkl", "intel-parallel-studio+mkl"]:
+    for _package in ["openblas", "intel-mkl", "intel-parallel-studio+mkl"]:
         conflicts(
-            "^{0}+ilp64".format(p), when="@:8.5.1", msg="64bit BLAS is only supported from 9.0.0"
+            "^{0}+ilp64".format(_package),
+            when="@:8.5.1",
+            msg="64bit BLAS is only supported from 9.0.0",
         )
 
     # MPI requirements:
-    for p in ["arpack", "hdf5", "netcdf", "p4est", "petsc", "scalapack", "slepc", "trilinos"]:
+    for _package in [
+        "arpack",
+        "hdf5",
+        "netcdf",
+        "p4est",
+        "petsc",
+        "scalapack",
+        "slepc",
+        "trilinos",
+    ]:
         conflicts(
-            "+{0}".format(p),
+            "+{0}".format(_package),
             when="~mpi",
             msg="To enable {0} it is necessary to build deal.II with "
-            "MPI support enabled.".format(p),
+            "MPI support enabled.".format(_package),
         )
 
     # Optional dependencies:
@@ -432,6 +467,7 @@ def cmake_args(self):
 
         # Examples / tutorial programs
         options.append(self.define_from_variant("DEAL_II_COMPONENT_EXAMPLES", "examples"))
+        options.append(self.define_from_variant("DEAL_II_COMPILE_EXAMPLES", "examples"))
 
         # Enforce the specified C++ standard
         if spec.variants["cxxstd"].value != "default":
@@ -478,9 +514,6 @@ def cmake_args(self):
         if "+mpi" in spec:
             options.extend(
                 [
-                    self.define("CMAKE_C_COMPILER", spec["mpi"].mpicc),
-                    self.define("CMAKE_CXX_COMPILER", spec["mpi"].mpicxx),
-                    self.define("CMAKE_Fortran_COMPILER", spec["mpi"].mpifc),
                     self.define("MPI_C_COMPILER", spec["mpi"].mpicc),
                     self.define("MPI_CXX_COMPILER", spec["mpi"].mpicxx),
                     self.define("MPI_Fortran_COMPILER", spec["mpi"].mpifc),
@@ -499,6 +532,9 @@ def cmake_args(self):
                         self.define("CUDA_HOST_COMPILER", spec["mpi"].mpicxx),
                     ]
                 )
+            # Make sure we use the same compiler that Trilinos uses
+            if "+trilinos" in spec:
+                options.extend([self.define("CMAKE_CXX_COMPILER", spec["trilinos"].kokkos_cxx)])
 
         # Python bindings
         if spec.satisfies("@8.5.0:"):
@@ -542,23 +578,25 @@ def cmake_args(self):
         # Optional dependencies for which library names are the same as CMake
         # variables:
         for library in (
+            "arborx",
+            "assimp",
+            "cgal",
+            "ginkgo",
+            "gmsh",
             "gsl",
             "hdf5",
+            "metis",
+            "muparser",
+            "nanoflann",
             "p4est",
             "petsc",
             "slepc",
-            "trilinos",
-            "metis",
             "sundials",
-            "nanoflann",
-            "assimp",
-            "gmsh",
-            "muparser",
             "symengine",
-            "ginkgo",
-            "arborx",
-            "cgal",
-        ):  # 'taskflow'):
+            "taskflow",
+            "trilinos",
+            "vtk",
+        ):
             options.append(
                 self.define_from_variant("DEAL_II_WITH_{0}".format(library.upper()), library)
             )

var/spack/repos/builtin/packages/dla-future/package.py

@@ -14,6 +14,9 @@ class DlaFuture(CMakePackage, CudaPackage, ROCmPackage):
     git = "https://github.com/eth-cscs/DLA-Future.git"
     maintainers = ["rasolca", "albestro", "msimberg", "aurianer"]
 
+    license("BSD-3-Clause")
+
+    version("0.3.0", sha256="9887ac0b466ca03d704a8738bc89e68550ed33509578c576390e98e76b64911b")
     version("0.2.1", sha256="4c2669d58f041304bd618a9d69d9879a42e6366612c2fc932df3894d0326b7fe")
     version("0.2.0", sha256="da73cbd1b88287c86d84b1045a05406b742be924e65c52588bbff200abd81a10")
     version("0.1.0", sha256="f7ffcde22edabb3dc24a624e2888f98829ee526da384cd752b2b271c731ca9b1")
@@ -42,12 +45,12 @@ class DlaFuture(CMakePackage, CudaPackage, ROCmPackage):
     depends_on("cmake@3.22:", type="build")
     depends_on("doxygen", type="build", when="+doc")
     depends_on("mpi")
-    depends_on("blaspp@2022.05.00:")
-    depends_on("lapackpp@2022.05.00:")
 
     depends_on("blas")
     depends_on("lapack")
     depends_on("scalapack", when="+scalapack")
+    depends_on("blaspp@2022.05.00:")
+    depends_on("lapackpp@2022.05.00:")
 
     depends_on("umpire~examples")
     depends_on("umpire~cuda", when="~cuda")
@@ -58,8 +61,9 @@ class DlaFuture(CMakePackage, CudaPackage, ROCmPackage):
 
     depends_on("pika@0.15.1:", when="@0.1")
     depends_on("pika@0.16:", when="@0.2.0")
-    depends_on("pika@0.17:", when="@0.2.1:")
-    depends_on("pika-algorithms@0.1:")
+    depends_on("pika@0.17:", when="@0.2.1")
+    depends_on("pika@0.18:", when="@0.3.0:")
+    depends_on("pika-algorithms@0.1:", when="@:0.2")
     depends_on("pika +mpi")
     depends_on("pika +cuda", when="+cuda")
     depends_on("pika +rocm", when="+rocm")

var/spack/repos/builtin/packages/doxygen/package.py

@@ -18,6 +18,8 @@ class Doxygen(CMakePackage):
     homepage = "https://www.doxygen.org"
     url = "https://github.com/doxygen/doxygen/archive/refs/tags/Release_1_9_5.tar.gz"
 
+    version("1.9.8", sha256="77371e8a58d22d5e03c52729844d1043e9cbf8d0005ec5112ffa4c8f509ddde8")
+    version("1.9.7", sha256="691777992a7240ed1f822a5c2ff2c4273b57c1cf9fc143553d87f91a0c5970ee")
     version("1.9.6", sha256="2a3ee47f7276b759f74bac7614c05a1296a5b028d3f6a79a88e4c213db78e7dc")
     version("1.9.5", sha256="1c5c9cd4445f694e43f089c17529caae6fe889b732fb0b145211025a1fcda1bb")
     version("1.9.4", sha256="1b083d15b29817463129ae1ae73b930d883030eeec090ea7a99b3a04fdb51c76")

var/spack/repos/builtin/packages/dwz/package.py

@@ -13,8 +13,6 @@ class Dwz(MakefilePackage, SourcewarePackage):
     sourceware_mirror_path = "dwz/releases/dwz-0.14.tar.gz"
     git = "git://sourceware.org/git/dwz.git"
 
-    maintainers("iarspider")
-
     depends_on("elf")
 
     version("0.14-patches", branch="dwz-0.14-branch")

var/spack/repos/builtin/packages/ecflow/package.py

@@ -23,7 +23,8 @@ class Ecflow(CMakePackage):
 
     maintainers("climbfuji", "AlexanderRichert-NOAA")
 
-    # https://confluence.ecmwf.int/download/attachments/8650755/ecFlow-5.8.3-Source.tar.gz?api=v2
+    version("5.11.4", sha256="4836a876277c9a65a47a3dc87cae116c3009699f8a25bab4e3afabf160bcf212")
+    version("5.8.4", sha256="bc628556f8458c269a309e4c3b8d5a807fae7dfd415e27416fe9a3f544f88951")
     version("5.8.3", sha256="1d890008414017da578dbd5a95cb1b4d599f01d5a3bb3e0297fe94a87fbd81a6")
     version("4.13.0", sha256="c743896e0ec1d705edd2abf2ee5a47f4b6f7b1818d8c159b521bdff50a403e39")
     version("4.12.0", sha256="566b797e8d78e3eb93946b923ef540ac61f50d4a17c9203d263c4fd5c39ab1d1")
@@ -99,6 +100,9 @@ def cmake_args(self):
             ssllibs = ";".join(spec["openssl"].libs + spec["zlib"].libs)
             args.append(self.define("OPENSSL_CRYPTO_LIBRARY", ssllibs))
 
+        if self.spec.satisfies("@5.8.3:"):
+            args.append("-DCMAKE_CXX_FLAGS=-DBOOST_NO_CXX98_FUNCTION_BASE")
+
         return args
 
     # A recursive link in the ecflow source code causes the binary cache

var/spack/repos/builtin/packages/ecmwf-atlas/package.py

@@ -76,8 +76,8 @@ def cmake_args(self):
 
     @when("+fismahigh")
     def patch(self):
-        filter_file("http://www\.ecmwf\.int", "", "cmake/atlas-import.cmake.in")  # noqa: W605
-        filter_file("int\.ecmwf", "", "cmake/atlas-import.cmake.in")  # noqa: W605
+        filter_file("http://www.ecmwf.int", "", "cmake/atlas-import.cmake.in", string=True)
+        filter_file("int.ecmwf", "", "cmake/atlas-import.cmake.in", string=True)
         filter_file('http[^"]+', "", "cmake/atlas_export.cmake")
         patterns = [".travis.yml", "tools/install*.sh", "tools/github-sha.sh"]
         for pattern in patterns:

var/spack/repos/builtin/packages/elbencho/package.py

@@ -16,9 +16,13 @@ class Elbencho(MakefilePackage):
 
     homepage = "https://github.com/breuner/elbencho"
     url = "https://github.com/breuner/elbencho/archive/refs/tags/v3.0-1.tar.gz"
+    git = "https://github.com/breuner/elbencho.git"
 
     maintainers("ethanjjjjjjj")
 
+    version("master", branch="master")
+
+    version("3.0-3", sha256="5769abcdaebefe2984ac3053fb6e91a54e1863d5ea8f72daea830e10b27c0eaf")
     version("3.0-1", sha256="19dad85e1fc74419dcdf740f11a47d3f6d566770a06e40976755a3404566c11d")
     version("2.2-5", sha256="4b598639452665a8b79c4c9d8a22ae63fb9b04057635a45e686aa3939ee255b4")
     version("2.2-3", sha256="0ae2d495d2863b84f21f55b7c526674fab1be723d0697087017946647f79d0e6")

var/spack/repos/builtin/packages/epics-base/package.py

@@ -26,6 +26,7 @@ class EpicsBase(MakefilePackage):
     def patch(self):
         filter_file(r"^\s*CC\s*=.*", "CC = " + spack_cc, "configure/CONFIG.gnuCommon")
         filter_file(r"^\s*CCC\s*=.*", "CCC = " + spack_cxx, "configure/CONFIG.gnuCommon")
+        filter_file(r"\$\(PERL\)\s+\$\(XSUBPP\)", "$(XSUBPP)", "modules/ca/src/perl/Makefile")
 
     @property
     def install_targets(self):

var/spack/repos/builtin/packages/esmf/package.py

@@ -28,7 +28,8 @@ class Esmf(MakefilePackage):
 
     # Develop is a special name for spack and is always considered the newest version
     version("develop", branch="develop")
-    # generate chksum with spack checksum esmf@x.y.z
+    # generate chksum with 'spack checksum esmf@x.y.z'
+    version("8.6.0", sha256="ed057eaddb158a3cce2afc0712b49353b7038b45b29aee86180f381457c0ebe7")
     version("8.5.0", sha256="acd0b2641587007cc3ca318427f47b9cae5bfd2da8d2a16ea778f637107c29c4")
     version("8.4.2", sha256="969304efa518c7859567fa6e65efd960df2b4f6d72dbf2c3f29e39e4ab5ae594")
     version("8.4.1", sha256="1b54cee91aacaa9df400bd284614cbb0257e175f6f3ec9977a2d991ed8aa1af6")

var/spack/repos/builtin/packages/fairmq/package.py

@@ -14,31 +14,15 @@ class Fairmq(CMakePackage):
     maintainers("dennisklein", "ChristianTackeGSI")
 
     version("dev", branch="dev", submodules=True, get_full_repo=True)
-    version(
-        "1.7.0",
-        tag="v1.7.0",
-        commit="d1c99f7e150c1177dc1cab1b2adc16475cade24e",
-        submodules=True,
-        no_cache=True,
-    )
-    version(
-        "1.6.0",
-        tag="v1.6.0",
-        commit="42d27af20fb5cbbbc0b0fdfef1c981d51a8baf87",
-        submodules=True,
-        no_cache=True,
-    )
-    version(
-        "1.5.0",
-        tag="v1.5.0",
-        commit="c8fde17b6a10a467035590fd800bb693f50c4826",
-        submodules=True,
-        no_cache=True,
-    )
-    # no_cache=True is currently needed, because FairMQ's build system
-    # depends on the git metadata, see also
-    # https://github.com/spack/spack/issues/19972
-    # https://github.com/spack/spack/issues/14344
+    with default_args(submodules=True, no_cache=True):
+        # no_cache=True is currently needed, because FairMQ's build system
+        # depends on the git metadata, see also
+        # https://github.com/spack/spack/issues/19972
+        # https://github.com/spack/spack/issues/14344
+        version("1.8.1", tag="v1.8.1", commit="961eca52761a31a0200c567b44e2b2d6d6e50df3")
+        version("1.7.0", tag="v1.7.0", commit="d1c99f7e150c1177dc1cab1b2adc16475cade24e")
+        version("1.6.0", tag="v1.6.0", commit="42d27af20fb5cbbbc0b0fdfef1c981d51a8baf87")
+        version("1.5.0", tag="v1.5.0", commit="c8fde17b6a10a467035590fd800bb693f50c4826")
 
     variant(
         "autobind", default=True, when="@1.7:", description="Override the channel autoBind default"
@@ -61,9 +45,10 @@ class Fairmq(CMakePackage):
 
     generator("make", "ninja", default="ninja")
 
-    depends_on("cmake@3.15:", type="build")
-    depends_on("faircmakemodules", type="build")
-    depends_on("git", type="build")
+    with default_args(type="build"):
+        depends_on("cmake@3.15:")
+        depends_on("faircmakemodules")
+        depends_on("git")
 
     depends_on("boost@1.66: +container+program_options+filesystem+date_time+regex")
     depends_on("fairlogger@1.6: +pretty")
@@ -72,6 +57,7 @@ class Fairmq(CMakePackage):
     def cmake_args(self):
         args = [
             self.define("DISABLE_COLOR", True),
+            self.define("BUILD_TESTING", self.run_tests),
             self.define_from_variant("BUILD_EXAMPLES", "examples"),
             self.define_from_variant("FAIRMQ_CHANNEL_DEFAULT_AUTOBIND", "autobind"),
         ]

var/spack/repos/builtin/packages/flux-core/package.py

@@ -20,6 +20,7 @@ class FluxCore(AutotoolsPackage):
     maintainers("grondo")
 
     version("master", branch="master")
+    version("0.56.0", sha256="dfce5aa21bcb1f990397343cdff8a60542b2d18cbd929e46bdb444d21a961efb")
     version("0.55.0", sha256="2925b8a084e9d1069a96de7689b515ad6f2051ecfb9fbbe4d2643507de7ccd30")
     version("0.54.0", sha256="721fc3fff64b3b167ae55d0e29379ff3211729248ef97e3b9855816219063b42")
     version("0.53.0", sha256="2f14d032a2d54f34e066c8a15c79917089e9f7f8558baa03dbfe63dbf56918b7")

var/spack/repos/builtin/packages/flux-sched/package.py

@@ -22,6 +22,7 @@ class FluxSched(CMakePackage, AutotoolsPackage):
     maintainers("grondo")
 
     version("master", branch="master")
+    version("0.30.0", sha256="1ccb2e53f4caede0233f19b2707e868f0cee9d2c957a06f97c22936ba9a43552")
     version("0.29.0", sha256="b93b18788e677535aa8ef945cdbeeced6d1408a4d16cb4a816ead53f31dd78d2")
     version("0.28.0", sha256="9431c671bed5d76fd95b4a4a7f36224d4bf76f416a2a1a5c4908f3ca790d434d")
     version("0.27.0", sha256="1e131924440c904fa0c925b7aa14c47b97f4e67b43af7efd2ebc0ef7ce90eb7c")

var/spack/repos/builtin/packages/flux-security/package.py

@@ -20,6 +20,7 @@ class FluxSecurity(AutotoolsPackage):
     maintainers("grondo")
 
     version("master", branch="master")
+    version("0.11.0", sha256="d1ef78a871155a252f07e4f0a636eb272d6c2048d5e0e943860dd687c6cf808a")
     version("0.10.0", sha256="b0f39c5e32322f901454469ffd6154019b6dffafc064b55b3e593f70db6a6f68")
     version("0.9.0", sha256="2258120c6f32ca0b5b13b166bae56d9bd82a44c6eeaa6bc6187e4a4419bdbcc0")
     version("0.8.0", sha256="9963628063b4abdff6bece03208444c8f23fbfda33c20544c48b21e9f4819ce2")

var/spack/repos/builtin/packages/fmt/package.py

@@ -15,6 +15,8 @@ class Fmt(CMakePackage):
     url = "https://github.com/fmtlib/fmt/releases/download/7.1.3/fmt-7.1.3.zip"
     maintainers("msimberg")
 
+    license("MIT")
+
     version("10.1.1", sha256="b84e58a310c9b50196cda48d5678d5fa0849bca19e5fdba6b684f0ee93ed9d1b")
     version("10.1.0", sha256="d725fa83a8b57a3cedf238828fa6b167f963041e8f9f7327649bddc68ae316f4")
     version("10.0.0", sha256="4943cb165f3f587f26da834d3056ee8733c397e024145ca7d2a8a96bb71ac281")

var/spack/repos/builtin/packages/form/package.py

@@ -11,7 +11,7 @@ class Form(AutotoolsPackage):
 
     homepage = "https://www.nikhef.nl/~form/"
     url = "https://github.com/vermaseren/form/releases/download/v4.2.1/form-4.2.1.tar.gz"
-    maintainers("iarspider", "tueda")
+    maintainers("tueda")
 
     version("4.3.1", sha256="f1f512dc34fe9bbd6b19f2dfef05fcb9912dfb43c8368a75b796ec472ee8bbce")
     version("4.3.0", sha256="b234e0d095f73ecb0904cdc3b0d8d8323a9fa7f46770a52fb22267c624aafbf6")

var/spack/repos/builtin/packages/gbl/package.py

@@ -12,7 +12,6 @@ class Gbl(CMakePackage):
     homepage = "https://www.desy.de/~kleinwrt/GBL/doc/cpp/html/"
     git = "https://gitlab.desy.de/claus.kleinwort/general-broken-lines.git"
 
-    maintainers("iarspider")
     tags = ["hep"]
 
     version("V02-04-01", commit="1061b643c6656fbf7ceba579997eb43f0a9e9d3c")

var/spack/repos/builtin/packages/gdal/package.py

@@ -30,6 +30,7 @@ class Gdal(CMakePackage, AutotoolsPackage, PythonExtension):
 
     maintainers("adamjstewart")
 
+    version("3.8.0", sha256="ec0f78d9dc32352aeac6edc9c3b27a991b91f9dc6f92c452207d84431c58757d")
     version("3.7.3", sha256="e0a6f0c453ea7eb7c09967f50ac49426808fcd8f259dbc9888140eb69d7ffee6")
     version("3.7.2", sha256="40c0068591d2c711c699bbb734319398485ab169116ac28005d8302f80b923ad")
     version("3.7.1", sha256="9297948f0a8ba9e6369cd50e87c7e2442eda95336b94d2b92ef1829d260b9a06")
@@ -90,6 +91,7 @@ class Gdal(CMakePackage, AutotoolsPackage, PythonExtension):
     version("2.0.0", sha256="91704fafeea2349c5e268dc1e2d03921b3aae64b05ee01d59fdfc1a6b0ffc061")
 
     # Optional dependencies
+    variant("archive", default=False, when="@3.7:", description="Optional for vsi7z VFS driver")
     variant(
         "armadillo",
         default=False,
@@ -137,9 +139,11 @@ class Gdal(CMakePackage, AutotoolsPackage, PythonExtension):
     variant("kdu", default=False, description="Required for JP2KAK and JPIPKAK drivers")
     variant("kea", default=False, description="Required for KEA driver")
     variant("lerc", default=False, when="@2.4:", description="Required for LERC compression")
+    variant("libaec", default=False, when="@3.8:", description="Optional for GRIB driver")
     variant("libcsf", default=False, description="Required for PCRaster driver")
     variant("libkml", default=False, description="Required for LIBKML driver")
     variant("liblzma", default=False, description="Required for Zarr driver")
+    variant("libqb3", default=False, when="@3.6:", description="Required for MRF driver")
     variant(
         "libxml2", default=False, description="Required for XML validation in many OGR drivers"
     )
@@ -190,7 +194,7 @@ class Gdal(CMakePackage, AutotoolsPackage, PythonExtension):
     )
     variant("pcidsk", default=False, description="Required for PCIDSK driver")
     variant(
-        "pcre", default=False, description="Required for REGEXP operator in drivers using SQLite3"
+        "pcre2", default=False, description="Required for REGEXP operator in drivers using SQLite3"
     )
     variant("pdfium", default=False, when="@2.1:", description="Possible backend for PDF driver")
     variant("png", default=True, description="Required for PNG driver")
@@ -201,7 +205,6 @@ class Gdal(CMakePackage, AutotoolsPackage, PythonExtension):
         default=False,
         description="Required for PostgreSQL and PostGISRaster drivers",
     )
-    variant("qb3", default=False, when="@3.6:", description="Required for MRF driver")
     variant(
         "qhull",
         default=False,
@@ -262,6 +265,7 @@ class Gdal(CMakePackage, AutotoolsPackage, PythonExtension):
     depends_on("json-c@0.12.1", when="@:2.2")
 
     # Optional dependencies
+    depends_on("libarchive", when="+archive")
     depends_on("armadillo", when="+armadillo")
     depends_on("blas", when="+armadillo")
     depends_on("lapack", when="+armadillo")
@@ -303,6 +307,7 @@ class Gdal(CMakePackage, AutotoolsPackage, PythonExtension):
     # depends_on('kakadu', when='+kdu')
     depends_on("kealib", when="+kea")
     depends_on("lerc", when="+lerc")
+    depends_on("libaec", when="+libaec")
     # depends_on('libcsf', when='+libcsf')
     depends_on("libkml@1.3:", when="+libkml")
     depends_on("xz", when="+liblzma")
@@ -330,8 +335,8 @@ class Gdal(CMakePackage, AutotoolsPackage, PythonExtension):
     depends_on("oracle-instant-client", when="+oracle")
     depends_on("parquet-cpp", when="+parquet")
     # depends_on('pcidsk', when='+pcidsk')
-    depends_on("pcre2", when="@3.5:+pcre")
-    depends_on("pcre", when="@:3.4+pcre")
+    depends_on("pcre2", when="@3.5:+pcre2")
+    depends_on("pcre", when="@:3.4+pcre2")
     # depends_on('pdfium', when='+pdfium')
     depends_on("libpng", when="+png")
     # depends_on('podofo', when='+podofo')
@@ -341,7 +346,7 @@ class Gdal(CMakePackage, AutotoolsPackage, PythonExtension):
     depends_on("poppler@:0.71", when="@:2.4 +poppler")
     depends_on("poppler@:21", when="@:3.4.1 +poppler")
     depends_on("postgresql", when="+postgresql")
-    depends_on("qb3", when="+qb3")
+    depends_on("qb3", when="+libqb3")
     depends_on("qhull", when="+qhull")
     depends_on("qhull@2015:", when="@3.5:+qhull")
     depends_on("qhull@:2020.1", when="@:3.3+qhull")
@@ -490,6 +495,7 @@ def cmake_args(self):
             # be necessary.
             self.define("ENABLE_DEFLATE64", "zlib-ng" not in self.spec),
             # Optional dependencies
+            self.define_from_variant("GDAL_USE_ARCHIVE", "archive"),
             self.define_from_variant("GDAL_USE_ARMADILLO", "armadillo"),
             self.define_from_variant("GDAL_USE_ARROW", "arrow"),
             self.define_from_variant("GDAL_USE_BASISU", "basisu"),
@@ -519,9 +525,11 @@ def cmake_args(self):
             self.define_from_variant("GDAL_USE_KDU", "kdu"),
             self.define_from_variant("GDAL_USE_KEA", "kea"),
             self.define_from_variant("GDAL_USE_LERC", "lerc"),
+            self.define_from_variant("GDAL_USE_LIBAEC", "libaec"),
             self.define_from_variant("GDAL_USE_LIBCSF", "libcsf"),
             self.define_from_variant("GDAL_USE_LIBKML", "libkml"),
             self.define_from_variant("GDAL_USE_LIBLZMA", "liblzma"),
+            self.define_from_variant("GDAL_USE_LIBQB3", "libqb3"),
             self.define_from_variant("GDAL_USE_LIBXML2", "libxml2"),
             self.define_from_variant("GDAL_USE_LURATECH", "luratech"),
             self.define_from_variant("GDAL_USE_LZ4", "lz4"),
@@ -541,13 +549,12 @@ def cmake_args(self):
             self.define_from_variant("GDAL_USE_OPENSSL", "openssl"),
             self.define_from_variant("GDAL_USE_ORACLE", "oracle"),
             self.define_from_variant("GDAL_USE_PARQUET", "parquet"),
-            self.define_from_variant("GDAL_USE_PCRE2", "pcre"),
+            self.define_from_variant("GDAL_USE_PCRE2", "pcre2"),
             self.define_from_variant("GDAL_USE_PDFIUM", "pdfium"),
             self.define_from_variant("GDAL_USE_PNG", "png"),
             self.define_from_variant("GDAL_USE_PODOFO", "podofo"),
             self.define_from_variant("GDAL_USE_POPPLER", "poppler"),
             self.define_from_variant("GDAL_USE_POSTGRESQL", "postgresql"),
-            self.define_from_variant("GDAL_USE_LIBQB3", "qb3"),
             self.define_from_variant("GDAL_USE_QHULL", "qhull"),
             self.define_from_variant("GDAL_USE_RASDAMAN", "rasdaman"),
             self.define_from_variant("GDAL_USE_RASTERLITE2", "rasterlite2"),
@@ -669,7 +676,7 @@ def configure_args(self):
             self.with_or_without("crypto", variant="openssl", package="openssl"),
             self.with_or_without("oci", variant="oracle", package="oracle-instant-client"),
             self.with_or_without("pcidsk", package="pcidsk"),
-            self.with_or_without("pcre"),
+            self.with_or_without("pcre", variant="pcre2"),
             self.with_or_without("pdfium", package="pdfium"),
             self.with_or_without("png", package="libpng"),
             self.with_or_without("podofo", package="podofo"),

var/spack/repos/builtin/packages/geant4/package.py

@@ -22,6 +22,7 @@ class Geant4(CMakePackage):
 
     maintainers("drbenmorgan")
 
+    version("11.1.3", sha256="5d9a05d4ccf8b975649eab1d615fc1b8dce5937e01ab9e795bffd04149240db6")
     version("11.1.2", sha256="e9df8ad18c445d9213f028fd9537e174d6badb59d94bab4eeae32f665beb89af")
     version("11.1.1", sha256="c5878634da9ba6765ce35a469b2893044f4a6598aa948733da8436cdbfeef7d2")
     version("11.1.0", sha256="c4a23f2f502efeab56de43a4412b21f65c7ca1b0877b9bc1d7e845ee12edf70a")
@@ -152,7 +153,7 @@ def std_when(values):
     patch("geant4-10.4.3-cxx17-removed-features.patch", level=1, when="@10.4.3 cxxstd=17")
 
     # See https://bugzilla-geant4.kek.jp/show_bug.cgi?id=2556
-    patch("package-cache.patch", level=1, when="@10.7.0:11.2.0^cmake@3.17:")
+    patch("package-cache.patch", level=1, when="@10.7.0:11.1.2^cmake@3.17:")
 
     # NVHPC: "thread-local declaration follows non-thread-local declaration"
     conflicts("%nvhpc", when="+threads")

var/spack/repos/builtin/packages/geos/package.py

@@ -21,20 +21,30 @@ class Geos(CMakePackage):
 
     maintainers("adamjstewart")
 
+    version("3.12.1", sha256="d6ea7e492224b51193e8244fe3ec17c4d44d0777f3c32ca4fb171140549a0d03")
     version("3.12.0", sha256="d96db96011259178a35555a0f6d6e75a739e52a495a6b2aa5efb3d75390fbc39")
+    version("3.11.3", sha256="80d60a2bbc0cde7745a3366b9eb8c0d65a142b03e063ea0a52c364758cd5ee89")
     version("3.11.2", sha256="b1f077669481c5a3e62affc49e96eb06f281987a5d36fdab225217e5b825e4cc")
     version("3.11.1", sha256="6d0eb3cfa9f92d947731cc75f1750356b3bdfc07ea020553daf6af1c768e0be2")
     version("3.11.0", sha256="79ab8cabf4aa8604d161557b52e3e4d84575acdc0d08cb09ab3f7aaefa4d858a")
+    version("3.10.6", sha256="078403158da66cad8be39ad1ede5e2fe4b70dcf7bb292fb06a65bdfe8afa6daf")
+    version("3.10.5", sha256="cc47d95e846e2745c493d8f9f3a9913b1c61f26717a1165898da64352aec4dde")
     version("3.10.4", sha256="d6fc11bcfd265cbf2714199174e4c3392d657551e5fd84c74c07c863b29357e3")
     version("3.10.3", sha256="3c141b07d61958a758345d5f54e3c735834b2f4303edb9f67fb26914f0d44770")
     version("3.10.2", sha256="50bbc599ac386b4c2b3962dcc411f0040a61f204aaef4eba7225ecdd0cf45715")
     version("3.10.1", sha256="a8148eec9636814c8ab0f8f5266ce6f9b914ed65b0d083fc43bb0bbb01f83648")
     version("3.10.0", sha256="097d70e3c8f688e59633ceb8d38ad5c9b0d7ead5729adeb925dbc489437abe13")
+    version("3.9.5", sha256="c6c9aedfa8864fb44ba78911408442382bfd0690cf2d4091ae3805c863789036")
     version("3.9.4", sha256="70dff2530d8cd2dfaeeb91a5014bd17afb1baee8f0e3eb18e44d5b4dbea47b14")
     version("3.9.3", sha256="f8b2314e311456f7a449144efb5e3188c2a28774752bc50fc882a3cd5c89ee35")
     version("3.9.2", sha256="44a5a9be21d7d473436bf621c2ddcc3cf5a8bbe3c786e13229618a3b9d861297")
     version("3.9.1", sha256="7e630507dcac9dc07565d249a26f06a15c9f5b0c52dd29129a0e3d381d7e382a")
+    version("3.9.0", sha256="bd8082cf12f45f27630193c78bdb5a3cba847b81e72b20268356c2a4fc065269")
+    version("3.8.4", sha256="6de8c98c1ae7cb0cd2d726a8dc9b7467308c4b4e05f9df94742244e64e441499")
+    version("3.8.3", sha256="f98315d1ba35c8d1a94a2947235f9e9dfb7057fdec343683f64ff9ad1061255c")
+    version("3.8.2", sha256="5a102f4614b0c9291504bbefd847ebac18ea717843506bd251d015c7cf9726b4")
     version("3.8.1", sha256="4258af4308deb9dbb5047379026b4cd9838513627cb943a44e16c40e42ae17f7")
+    version("3.8.0", sha256="99114c3dc95df31757f44d2afde73e61b9f742f0b683fd1894cbbee05dda62d5")
     version("3.7.2", sha256="2166e65be6d612317115bfec07827c11b403c3f303e0a7420a2106bc999d7707")
     version("3.6.2", sha256="045a13df84d605a866602f6020fc6cbf8bf4c42fb50de237a08926e1d7d7652a")
     version("3.6.1", sha256="4a2e4e3a7a09a7cfda3211d0f4a235d9fd3176ddf64bd8db14b4ead266189fc5")

var/spack/repos/builtin/packages/glab/package.py

@@ -14,6 +14,7 @@ class Glab(Package):
 
     maintainers("alecbcs")
 
+    version("1.35.0", sha256="7ed31c7a9b425fc15922f83c5dd8634a2758262a4f25f92583378655fcad6303")
     version("1.33.0", sha256="447a9b76acb5377642a4975908f610a3082026c176329c7c8cfed1461d2e1570")
     version("1.31.0", sha256="5648e88e7d6cc993227f5a4e80238af189bed09c7aed1eb12be7408e9a042747")
     version("1.30.0", sha256="d3c1a9ba723d94a0be10fc343717cf7b61732644f5c42922f1c8d81047164b99")

var/spack/repos/builtin/packages/gmake/package.py

@@ -67,6 +67,8 @@ def configure_args(self):
         return [
             "--with-guile" if self.spec.satisfies("+guile") else "--without-guile",
             "--disable-nls",
+            # configure needs make to enable dependency tracking, disable explicitly
+            "--disable-dependency-tracking",
         ]
 
     def install(self, spec, prefix):

var/spack/repos/builtin/packages/gperftools/package.py

@@ -17,6 +17,8 @@ class Gperftools(AutotoolsPackage):
     url = "https://github.com/gperftools/gperftools/releases/download/gperftools-2.7/gperftools-2.7.tar.gz"
     maintainers("albestro", "eschnett", "msimberg", "teonnik")
 
+    license("BSD-3-Clause")
+
     version("2.13", sha256="4882c5ece69f8691e51ffd6486df7d79dbf43b0c909d84d3c0883e30d27323e7")
     version("2.12", sha256="fb611b56871a3d9c92ab0cc41f9c807e8dfa81a54a4a9de7f30e838756b5c7c6")
     version("2.11", sha256="8ffda10e7c500fea23df182d7adddbf378a203c681515ad913c28a64b87e24dc")

var/spack/repos/builtin/packages/gromacs/package.py

@@ -90,9 +90,26 @@ class Gromacs(CMakePackage, CudaPackage):
         default=False,
         description="Produces a double precision version of the executables",
     )
-    variant("cufftmp", default=False, when="+cuda+mpi", description="Enable Multi GPU FFT support")
+    variant(
+        "cufftmp",
+        default=False,
+        when="@2022: +cuda+mpi",
+        description="Enable multi-GPU FFT support with cuFFTMp",
+    )
+    variant(
+        "heffte",
+        default=False,
+        when="@2021: +sycl+mpi",
+        description="Enable multi-GPU FFT support with HeFFTe",
+    )
     variant("opencl", default=False, description="Enable OpenCL support")
-    variant("sycl", default=False, description="Enable SYCL support")
+    variant("sycl", default=False, when="@2021:", description="Enable SYCL support")
+    variant(
+        "intel-data-center-gpu-max",
+        default=False,
+        when="@2022:",
+        description="Enable support for Intel Data Center GPU Max",
+    )
     variant("nosuffix", default=False, description="Disable default suffixes")
     variant(
         "build_type",
@@ -108,6 +125,18 @@ class Gromacs(CMakePackage, CudaPackage):
             "Profile",
         ),
     )
+    variant(
+        "nblib",
+        default=True,
+        when="@2021:",
+        description="Build and install the NB-LIB C++ API for GROMACS",
+    )
+    variant(
+        "gmxapi",
+        default=True,
+        when="@2019:",
+        description="Build and install the gmxlib python API for GROMACS",
+    )
     variant(
         "mdrun_only",
         default=False,
@@ -254,6 +283,7 @@ class Gromacs(CMakePackage, CudaPackage):
     depends_on("cp2k@8.1:", when="+cp2k")
 
     depends_on("nvhpc", when="+cufftmp")
+    depends_on("heffte", when="+heffte")
 
     requires(
         "%intel",
@@ -516,6 +546,19 @@ def cmake_args(self):
                 + f'/{self.spec["nvhpc"].version}/math_libs'
             )
 
+        if "+heffte" in self.spec:
+            options.append("-DGMX_USE_HEFFTE=on")
+            options.append(f'-DHeffte_ROOT={self.spec["heffte"].prefix}')
+
+        if "+intel-data-center-gpu-max" in self.spec:
+            options.append("-DGMX_GPU_NB_CLUSTER_SIZE=8")
+            options.append("-DGMX_GPU_NB_NUM_CLUSTER_PER_CELL_X=1")
+
+        if "~nblib" in self.spec:
+            options.append("-DGMX_INSTALL_NBLIB_API=OFF")
+        if "~gmxapi" in self.spec:
+            options.append("-DGMXAPI=OFF")
+
         # Activate SIMD based on properties of the target
         target = self.spec.target
         if target >= "zen4":

var/spack/repos/builtin/packages/gzip/package.py

@@ -12,9 +12,22 @@ class Gzip(AutotoolsPackage):
     homepage = "https://www.gnu.org/software/gzip/"
     url = "https://ftp.gnu.org/gnu/gzip/gzip-1.10.tar.gz"
 
-    version("1.12", sha256="5b4fb14d38314e09f2fc8a1c510e7cd540a3ea0e3eb9b0420046b82c3bf41085")
-    version("1.11", sha256="3e8a0e0c45bad3009341dce17d71536c4c655d9313039021ce7554a26cd50ed9")
-    version("1.10", sha256="c91f74430bf7bc20402e1f657d0b252cb80aa66ba333a25704512af346633c68")
+    version("1.13", sha256="20fc818aeebae87cdbf209d35141ad9d3cf312b35a5e6be61bfcfbf9eddd212a")
+    version(
+        "1.12",
+        sha256="5b4fb14d38314e09f2fc8a1c510e7cd540a3ea0e3eb9b0420046b82c3bf41085",
+        deprecated=True,
+    )
+    version(
+        "1.11",
+        sha256="3e8a0e0c45bad3009341dce17d71536c4c655d9313039021ce7554a26cd50ed9",
+        deprecated=True,
+    )
+    version(
+        "1.10",
+        sha256="c91f74430bf7bc20402e1f657d0b252cb80aa66ba333a25704512af346633c68",
+        deprecated=True,
+    )
 
     # Gzip makes a recursive symlink if built in-source
     build_directory = "spack-build"

var/spack/repos/builtin/packages/hdf5/package.py

@@ -207,6 +207,7 @@ class Hdf5(CMakePackage):
     variant("hl", default=False, description="Enable the high-level library")
     variant("cxx", default=False, description="Enable C++ support")
     variant("map", when="@1.14:", default=False, description="Enable MAP API support")
+    variant("subfiling", when="@1.14:", default=False, description="Enable Subfiling VFD support")
     variant("fortran", default=False, description="Enable Fortran support")
     variant("java", when="@1.10:", default=False, description="Enable Java support")
     variant("threadsafe", default=False, description="Enable thread-safe capabilities")
@@ -329,7 +330,7 @@ class Hdf5(CMakePackage):
 
     patch("fortran-kinds.patch", when="@1.10.7")
 
-    # This patch may only be needed with GCC11.2 on macOS, but it's valid for
+    # This patch may only be needed with GCC 11.2 on macOS, but it's valid for
     # any of the head HDF5 versions as of 12/2021. Since it's impossible to
     # tell what Fortran version is part of a mixed apple-clang toolchain on
     # macOS (which is the norm), and this might be an issue for other compilers
@@ -607,6 +608,7 @@ def cmake_args(self):
                 # are enabled but the tests are disabled.
                 spec.satisfies("@1.8.22+shared+tools"),
             ),
+            self.define_from_variant("HDF5_ENABLE_SUBFILING_VFD", "subfiling"),
             self.define_from_variant("HDF5_ENABLE_MAP_API", "map"),
             self.define("HDF5_ENABLE_Z_LIB_SUPPORT", True),
             self.define_from_variant("HDF5_ENABLE_SZIP_SUPPORT", "szip"),

var/spack/repos/builtin/packages/heffte/package.py

@@ -38,6 +38,12 @@ class Heffte(CMakePackage, CudaPackage, ROCmPackage):
 
     variant("shared", default=True, description="Builds with shared libraries")
     variant("fftw", default=False, description="Builds with support for FFTW backend")
+    variant(
+        "sycl",
+        default=False,
+        when="%oneapi",
+        description="Builds with support for oneAPI SYCL+oneMKL backend",
+    )
     variant("mkl", default=False, description="Builds with support for MKL backend")
     variant("magma", default=False, description="Use helper methods from the UTK MAGMA library")
     variant("python", default=False, description="Install the Python bindings")
@@ -68,6 +74,8 @@ class Heffte(CMakePackage, CudaPackage, ROCmPackage):
     depends_on("rocsparse@3.8:", when="+magma+rocm", type=("build", "run"))
     depends_on("hipblas@3.8:", when="+magma+rocm", type=("build", "run"))
     depends_on("hipsparse@3.8:", when="+magma+rocm", type=("build", "run"))
+    depends_on("intel-oneapi-mkl@2023.2.0:", when="+sycl", type=("build", "run"))
+    depends_on("intel-oneapi-mpi@2021.10.0:", when="+sycl", type=("build", "run"))
 
     examples_src_dir = "examples"
 
@@ -78,6 +86,7 @@ def cmake_args(self):
             self.define_from_variant("BUILD_SHARED_LIBS", "shared"),
             self.define_from_variant("Heffte_ENABLE_CUDA", "cuda"),
             self.define_from_variant("Heffte_ENABLE_ROCM", "rocm"),
+            self.define_from_variant("Heffte_ENABLE_ONEAPI", "sycl"),
             self.define_from_variant("Heffte_ENABLE_FFTW", "fftw"),
             self.define_from_variant("Heffte_ENABLE_MKL", "mkl"),
             self.define_from_variant("Heffte_ENABLE_MAGMA", "magma"),

var/spack/repos/builtin/packages/hpctoolkit/package.py

@@ -109,6 +109,11 @@ class Hpctoolkit(AutotoolsPackage):
         "python", default=False, description="Support unwinding Python source.", when="@2023.03:"
     )
 
+    with when("@develop build_system=autotools"):
+        depends_on("autoconf", type="build")
+        depends_on("automake", type="build")
+        depends_on("libtool", type="build")
+
     boost_libs = (
         "+atomic +chrono +date_time +filesystem +system +thread +timer"
         " +graph +regex +shared +multithreaded visibility=global"

var/spack/repos/builtin/packages/hpx-kokkos/package.py

@@ -16,6 +16,8 @@ class HpxKokkos(CMakePackage, CudaPackage, ROCmPackage):
     git = "https://github.com/STEllAR-GROUP/hpx-kokkos.git"
     maintainers("G-071", "msimberg")
 
+    license("BSL-1.0")
+
     version("master", branch="master")
     version("0.4.0", sha256="dafef55521cf4bf7ab28ebad546ea1d3fb83fac3a9932e292db4ab3666cd833f")
     version("0.3.0", sha256="83c1d11dab95552ad0abdae767c71f757811d7b51d82bd231653dc942e89a45d")

var/spack/repos/builtin/packages/hpx/package.py

@@ -18,6 +18,8 @@ class Hpx(CMakePackage, CudaPackage, ROCmPackage):
     git = "https://github.com/STEllAR-GROUP/hpx.git"
     maintainers("msimberg", "albestro", "teonnik", "hkaiser")
 
+    license("BSL-1.0")
+
     tags = ["e4s"]
 
     version("master", branch="master")

var/spack/repos/builtin/packages/hydrogen/package.py

@@ -39,7 +39,7 @@ class Hydrogen(CachedCMakePackage, CudaPackage, ROCmPackage):
         values=("Debug", "Release"),
     )
     variant("int64", default=False, description="Use 64-bit integers")
-    variant("al", default=False, description="Use Aluminum communication library")
+    variant("al", default=True, sticky=True, description="Use Aluminum communication library")
     variant(
         "cub", default=True, when="+cuda", description="Use CUB/hipCUB for GPU memory management"
     )
@@ -90,6 +90,7 @@ class Hydrogen(CachedCMakePackage, CudaPackage, ROCmPackage):
     # Note that this forces us to use OpenBLAS until #1712 is fixed
     depends_on("openblas", when="blas=openblas")
     depends_on("openblas +ilp64", when="blas=openblas +int64_blas")
+    depends_on("openblas@0.3.21:0.3.23", when="blas=openblas arch=ppc64le:")
 
     depends_on("intel-mkl", when="blas=mkl")
     depends_on("intel-mkl +ilp64", when="blas=mkl +int64_blas")

var/spack/repos/builtin/packages/intel-oneapi-advisor/package.py

@@ -7,7 +7,7 @@
 
 
 @IntelOneApiPackage.update_description
-class IntelOneapiAdvisor(IntelOneApiPackage):
+class IntelOneapiAdvisor(IntelOneApiLibraryPackageWithSdk):
     """Intel Advisor is a design and analysis tool for developing
     performant code. The tool supports C, C++, Fortran, SYCL, OpenMP,
     OpenCL code, and Python. It helps with the following: Performant

var/spack/repos/builtin/packages/intel-oneapi-inspector/package.py

@@ -7,7 +7,7 @@
 
 
 @IntelOneApiPackage.update_description
-class IntelOneapiInspector(IntelOneApiPackage):
+class IntelOneapiInspector(IntelOneApiLibraryPackageWithSdk):
     """Intel Inspector is a dynamic memory and threading error debugger
     for C, C++, and Fortran applications that run on Windows and Linux
     operating systems.  Save money: locate the root cause of memory,

var/spack/repos/builtin/packages/intel-oneapi-vtune/package.py

@@ -7,7 +7,7 @@
 
 
 @IntelOneApiPackage.update_description
-class IntelOneapiVtune(IntelOneApiPackage):
+class IntelOneapiVtune(IntelOneApiLibraryPackageWithSdk):
     """Intel VTune Profiler is a profiler to optimize application
     performance, system performance, and system configuration for HPC,
     cloud, IoT, media, storage, and more.  CPU, GPU, and FPGA: Tune

var/spack/repos/builtin/packages/interproscan/package.py

@@ -45,21 +45,21 @@ class Interproscan(Package):
     )
 
     resource(
-        when="5.56-89.0 +databases",
+        when="@5.56-89.0 +databases",
         name="databases",
         url="https://ftp.ebi.ac.uk/pub/databases/interpro/iprscan/5/5.56-89.0/alt/interproscan-data-5.56-89.0.tar.gz",
         sha256="49cd0c69711f9469f3b68857f4581b23ff12765ca2b12893d18e5a9a5cd8032d",
     )
 
     resource(
-        when="5.38-76.0 +databases",
+        when="@5.38-76.0 +databases",
         name="databases",
         url="https://ftp.ebi.ac.uk/pub/databases/interpro/iprscan/5/5.38-76.0/alt/interproscan-data-5.38-76.0.tar.gz",
         sha256="e05e15d701037504f92ecf849c20317e70df28e78ff1945826b3c1e16d9b9cce",
     )
 
     resource(
-        when="5.36-75.0 +databases",
+        when="@5.36-75.0 +databases",
         name="databases",
         url="https://ftp.ebi.ac.uk/pub/databases/interpro/iprscan/5/5.36-75.0/alt/interproscan-data-5.36-75.0.tar.gz",
         sha256="e9b1e6f2d1c20d06661a31a08c973bc8ddf039a4cf1e45ec4443200375e5d6a4",

var/spack/repos/builtin/packages/ispc/package.py

@@ -25,6 +25,8 @@ class Ispc(CMakePackage):
     executables = ["^ispc$"]
 
     version("main", branch="main")
+    version("1.21.1", sha256="99bbb1d1f15bc4433d6a63b5bb35b321af3e3af753c3b28a61850d1748e8a89f")
+    version("1.21.0", sha256="023782f721bfb5893bac24bc2153a8214c916be82c290bf63a3ec6678949b5ef")
     version("1.20.0", sha256="8bd30ded7f96859451ead1cecf6f58ac8e937288fe0e5b98c56f6eba4be370b4")
     version("1.19.0", sha256="c1aeae4bdfb28004a6949394ea1b3daa3fdf12f646e17fcc0614861077dc8b6a")
     version("1.18.1", sha256="fee76d42fc0129f81489b7c2b9143e22a44c281940693c1c13cf1e3dd2ab207f")
@@ -45,15 +47,17 @@ class Ispc(CMakePackage):
     depends_on("tbb", type="link", when="platform=linux @1.20:")
     depends_on("llvm+clang")
     depends_on("llvm libcxx=none", when="platform=darwin")
-    depends_on("llvm@13:15", when="@1.19:")
-    depends_on("llvm@11.0:14.0", when="@1.18")
-    depends_on("llvm@11:14", when="@1.17")
-    depends_on("llvm@:12", when="@:1.16")
-    depends_on("llvm@11:", when="@1.16")
-    depends_on("llvm@10:11", when="@1.15.0:1.15")
-    depends_on("llvm@10.0:10", when="@1.13:1.14")
     depends_on("llvm targets=arm,aarch64", when="target=arm:")
     depends_on("llvm targets=arm,aarch64", when="target=aarch64:")
+    depends_on("llvm@:17", when="@:1.21")
+    depends_on("llvm@:15", when="@:1.20")
+    depends_on("llvm@:14", when="@:1.18")
+    depends_on("llvm@:12", when="@:1.16")
+    depends_on("llvm@:11", when="@:1.15")
+    depends_on("llvm@:10", when="@:1.14")
+    depends_on("llvm@13:", when="@1.19:")
+    depends_on("llvm@11:", when="@1.16:")
+    depends_on("llvm@10:", when="@1.13:")
 
     patch(
         "don-t-assume-that-ncurses-zlib-are-system-libraries.patch",

var/spack/repos/builtin/packages/jemalloc/package.py

@@ -13,8 +13,6 @@ class Jemalloc(AutotoolsPackage):
     homepage = "http://jemalloc.net/"
     url = "https://github.com/jemalloc/jemalloc/releases/download/4.0.4/jemalloc-4.0.4.tar.bz2"
 
-    maintainers("iarspider")
-
     version("5.3.0", sha256="2db82d1e7119df3e71b7640219b6dfe84789bc0537983c3b7ac4f7189aecfeaa")
     version("5.2.1", sha256="34330e5ce276099e2e8950d9335db5a875689a4c6a56751ef3b1d8c537f887f6")
     version("5.2.0", sha256="74be9f44a60d2a99398e706baa921e4efde82bf8fd16e5c0643c375c5851e3b4")

var/spack/repos/builtin/packages/justbuild/package.py

@@ -22,6 +22,7 @@ class Justbuild(Package):
     maintainers("asartori86")
 
     version("master", branch="master")
+    version("1.2.3", tag="v1.2.3", commit="45e9c1c85399f00372ad8b72894979a0002d8f95")
     version("1.2.2", tag="v1.2.2", commit="e1ee04684c34ae30ac3c91b6753e99a81a9dc51c")
     version("1.2.1", tag="v1.2.1", commit="959cd90083d0c783389cd09e187c98322c16469f")
     version("1.1.4", tag="v1.1.4", commit="32e96afd159f2158ca129fd00bf02c273d8e1e48")

var/spack/repos/builtin/packages/lbann/package.py

@@ -209,7 +209,7 @@ class Lbann(CachedCMakePackage, CudaPackage, ROCmPackage):
     depends_on("py-protobuf+cpp@3.10.0:4.21.12", type=("build", "run"), when="+pfe")
 
     depends_on("protobuf+shared@3.10.0:3.21.12")
-    depends_on("zlib-api", when="protobuf@3.11.0:")
+    depends_on("zlib-api", when="^protobuf@3.11.0:")
 
     # using cereal@1.3.1 and above requires changing the
     # find_package call to lowercase, so stick with :1.3.0

var/spack/repos/builtin/packages/lcio/package.py

@@ -19,6 +19,7 @@ class Lcio(CMakePackage):
     maintainers("gaede", "vvolkl", "jmcarcell")
 
     version("master", branch="master")
+    version("2.20.1", sha256="125f657297de12b40694cb0dddec1d1ce3379058492f2a6a2a6f992ee51604d6")
     version("2.20", sha256="5ef92c9ef04ce468ffb48be0ec6010377a400b064e352cb50f9f4c9599e7e990")
     version("2.19", sha256="2d6b37094d8d556ab0ba0efa632f10d8b851f533ca5c767e436397df18cb57c7")
     version("2.18", sha256="e722df7f4a6adcc2459ea1c6488a2a6e40bb04f7ee99536fdc60b51e6c80f565")

var/spack/repos/builtin/packages/lemon/package.py

@@ -16,3 +16,30 @@ class Lemon(CMakePackage):
     url = "https://lemon.cs.elte.hu/pub/sources/lemon-1.3.1.tar.gz"
 
     version("1.3.1", sha256="71b7c725f4c0b4a8ccb92eb87b208701586cf7a96156ebd821ca3ed855bad3c8")
+
+    # variant("coin", default=False, description="Enable Coin solver backend") #TODO build fails
+    variant("ilog", default=False, description="Enable ILOG (CPLEX) solver backend")
+    variant("glpk", default=True, description="Enable GLPK solver backend")
+    # soplex not mentioned in docs but shown in cmakecache
+    # variant("soplex", default=False, description="Enable SOPLEX solver backend") #TODO
+
+    depends_on("glpk", when="+glpk")
+    depends_on("cplex", when="+ilog")
+    # depends_on("coinutils", when="+coin")  # just a guess
+    # depends_on("cbc", when="+coin")
+    # depends_on("clp", when="+coin")
+    # depends_on("bzip2", when="+coin")
+    # depends_on("soplex", when="+soplex") # no such package in Spack yet. TODO
+
+    def cmake_args(self):
+        spec = self.spec
+        args = []
+        args.extend(
+            [
+                # f"-DLEMON_ENABLE_COIN={spec.variants['coin'].value}", #TODO
+                f"-DLEMON_ENABLE_ILOG={spec.variants['ilog'].value}",
+                f"-DLEMON_ENABLE_GLPK={spec.variants['glpk'].value}",
+                # f"-DLEMON_ENABLE_SOPLEX={spec.variants['soplex'].value}", #TODO
+            ]
+        )
+        return args

var/spack/repos/builtin/packages/libevent/package.py

@@ -59,7 +59,7 @@ def libs(self):
         return LibraryList(libs)
 
     def autoreconf(self, spec, prefix):
-        Executable("./autogen.sh")()
+        autoreconf("--force", "--install", "--symlink")
 
     def configure_args(self):
         spec = self.spec

var/spack/repos/builtin/packages/libffi/package.py

@@ -32,6 +32,11 @@ class Libffi(AutotoolsPackage):
     patch("clang-powerpc-3.2.1.patch", when="@3.2.1%clang platform=linux")
     # ref.: https://github.com/libffi/libffi/pull/561
     patch("powerpc-3.3.patch", when="@3.3")
+    patch(
+        "https://github.com/libffi/libffi/commit/ce077e5565366171aa1b4438749b0922fce887a4.patch?full_index=1",
+        sha256="070b1f3aa87f2b56f83aff38afc42157e1692bfaa580276ecdbad2048b818ed7",
+        when="@3.4.3:3.4.4",
+    )
 
     @property
     def headers(self):

var/spack/repos/builtin/packages/libgcrypt/package.py

@@ -14,6 +14,7 @@ class Libgcrypt(AutotoolsPackage):
 
     maintainers("alalazo")
 
+    version("1.10.3", sha256="8b0870897ac5ac67ded568dcfadf45969cfa8a6beb0fd60af2a9eadc2a3272aa")
     version("1.10.2", sha256="3b9c02a004b68c256add99701de00b383accccf37177e0d6c58289664cce0c03")
     version("1.10.1", sha256="ef14ae546b0084cd84259f61a55e07a38c3b53afc0f546bffcef2f01baffe9de")
     version("1.10.0", sha256="6a00f5c05caa4c4acc120c46b63857da0d4ff61dc4b4b03933fa8d46013fae81")

var/spack/repos/builtin/packages/libjpeg-turbo/package.py

@@ -59,6 +59,22 @@ class LibjpegTurbo(CMakePackage, AutotoolsPackage):
     variant("shared", default=True, description="Build shared libs")
     variant("static", default=True, description="Build static libs")
     variant("jpeg8", default=False, description="Emulate libjpeg v8 API/ABI")
+    variant(
+        "partial_decoder",
+        default=False,
+        description="add partial_decode_scale functionality required for rocAL",
+    )
+
+    patch(
+        "https://github.com/libjpeg-turbo/libjpeg-turbo/commit/09c71da06a6346dca132db66f26f959f7e4dd5ad.patch?full_index=1",
+        sha256="4d5bdfb5de5b04399144254ea383f5357ab7beb830b398aeb35b65f21dd6b4b0",
+        when="@2.0.6 +partial_decoder",
+    )
+    patch(
+        "https://github.com/libjpeg-turbo/libjpeg-turbo/commit/640d7ee1917fcd3b6a5271aa6cf4576bccc7c5fb.patch?full_index=1",
+        sha256="dc1ec567c2356b652100ecdc28713bbf25f544e46f7d2947f31a2395c362cc48",
+        when="@2.0.6 +partial_decoder",
+    )
 
     # Can use either of these. But in the current version of the package
     # only nasm is used. In order to use yasm an environmental variable

var/spack/repos/builtin/packages/libksba/package.py

@@ -17,6 +17,7 @@ class Libksba(AutotoolsPackage):
 
     maintainers("alalazo")
 
+    version("1.6.5", sha256="a564628c574c99287998753f98d750babd91a4e9db451f46ad140466ef2a6d16")
     version("1.6.4", sha256="bbb43f032b9164d86c781ffe42213a83bf4f2fee91455edfa4654521b8b03b6b")
     version("1.6.3", sha256="3f72c68db30971ebbf14367527719423f0a4d5f8103fc9f4a1c01a9fa440de5c")
 

var/spack/repos/builtin/packages/likwid/package.py

@@ -24,6 +24,7 @@ class Likwid(Package):
     git = "https://github.com/RRZE-HPC/likwid.git"
     maintainers("TomTheBear")
 
+    version("5.3.0", sha256="c290e554c4253124ac2ab8b056e14ee4d23966b8c9fbfa10ba81f75ae543ce4e")
     version("5.2.2", sha256="7dda6af722e04a6c40536fc9f89766ce10f595a8569b29e80563767a6a8f940e")
     version("5.2.1", sha256="1b8e668da117f24302a344596336eca2c69d2bc2f49fa228ca41ea0688f6cbc2")
     version("5.2.0", sha256="aa6dccacfca59e52d8f3be187ffcf292b2a2fa1f51a81bf8912b9d48e5a257e0")
@@ -65,6 +66,7 @@ class Likwid(Package):
     )
     variant("fortran", default=True, description="with fortran interface")
     variant("cuda", default=False, description="with Nvidia GPU profiling support")
+    variant("rocm", default=False, description="with AMD GPU profiling support")
 
     variant(
         "accessmode",
@@ -83,6 +85,10 @@ class Likwid(Package):
     depends_on("lua", when="@5.0.2:")
     depends_on("cuda", when="@5: +cuda")
     depends_on("hwloc", when="@5.2.0:")
+    depends_on("rocprofiler-dev", when="@5.3: +rocm")
+    depends_on("rocm-core", when="@5.3: +rocm")
+    depends_on("rocm-smi", when="@5.3: +rocm")
+    depends_on("rocm-smi-lib", when="@5.3: +rocm")
 
     # TODO: check
     # depends_on('gnuplot', type='run')
@@ -103,6 +109,31 @@ def setup_run_environment(self, env):
             )
             for lib in libs.directories:
                 env.append_path("LD_LIBRARY_PATH", lib)
+        if "+rocm" in self.spec:
+            libs = find_libraries(
+                "librocprofiler64.so.1",
+                root=self.spec["rocprofiler-dev"].prefix,
+                shared=True,
+                recursive=True,
+            )
+            for lib in libs.directories:
+                env.append_path("LD_LIBRARY_PATH", lib)
+            libs = find_libraries(
+                "libhsa-runtime64.so",
+                root=self.spec["rocm-core"].prefix,
+                shared=True,
+                recursive=True,
+            )
+            for lib in libs.directories:
+                env.append_path("LD_LIBRARY_PATH", lib)
+            libs = find_libraries(
+                "librocm_smi64.so",
+                root=self.spec["rocm-smi-lib"].prefix,
+                shared=True,
+                recursive=True,
+            )
+            for lib in libs.directories:
+                env.append_path("LD_LIBRARY_PATH", lib)
 
     @run_before("install")
     def filter_sbang(self):
@@ -170,6 +201,13 @@ def install(self, spec, prefix):
         else:
             filter_file("^NVIDIA_INTERFACE.*", "NVIDIA_INTERFACE = false", "config.mk")
 
+        if "+rocm" in self.spec:
+            env["ROCM_HOME"] = spec["rocm-core"].prefix
+            filter_file("^ROCM_INTERFACE.*", "ROCM_INTERFACE = true", "config.mk")
+            filter_file("^BUILDAPPDAEMON.*", "BUILDAPPDAEMON = true", "config.mk")
+        else:
+            filter_file("^ROCM_INTERFACE.*", "ROCM_INTERFACE = false", "config.mk")
+
         if spec.satisfies("^lua"):
             filter_file(
                 "^#LUA_INCLUDE_DIR.*",

var/spack/repos/builtin/packages/llvm/package.py

@@ -428,6 +428,12 @@ class Llvm(CMakePackage, CudaPackage):
         when="@14:15",
     )
 
+    # missing <cstdint> include
+    patch(
+        "https://github.com/llvm/llvm-project/commit/ff1681ddb303223973653f7f5f3f3435b48a1983.patch?full_index=1",
+        sha256="c6ca6b925f150e8644ce756023797b7f94c9619c62507231f979edab1c09af78",
+        when="@6:13",
+    )
     # fix building of older versions of llvm with newer versions of glibc
     for compiler_rt_as in ["project", "runtime"]:
         with when("compiler-rt={0}".format(compiler_rt_as)):
@@ -977,7 +983,10 @@ def post_install(self):
                 ninja()
                 ninja("install")
         if "+python" in self.spec:
-            install_tree("llvm/bindings/python", python_platlib)
+            if spec.version < Version("17.0.0"):
+                # llvm bindings were removed in v17:
+                # https://releases.llvm.org/17.0.1/docs/ReleaseNotes.html#changes-to-the-python-bindings
+                install_tree("llvm/bindings/python", python_platlib)
 
             if "+clang" in self.spec:
                 install_tree("clang/bindings/python", python_platlib)

var/spack/repos/builtin/packages/metkit/package.py

@@ -15,6 +15,8 @@ class Metkit(CMakePackage):
 
     maintainers("skosukhin")
 
+    version("1.10.17", sha256="1c525891d77ed28cd4c87b065ba4d1aea24d0905452c18d885ccbd567bbfc9b1")
+    version("1.10.2", sha256="a038050962aecffda27b755c40b0a6ed0db04a2c22cad3d8c93e6109c8ab4b34")
     version("1.9.2", sha256="35d5f67196197cc06e5c2afc6d1354981e7c85a441df79a2fbd774e0c343b0b4")
     version("1.7.0", sha256="8c34f6d8ea5381bd1bcfb22462349d03e1592e67d8137e76b3cecf134a9d338c")
 
@@ -26,8 +28,10 @@ class Metkit(CMakePackage):
     depends_on("ecbuild@3.4:", type="build")
 
     depends_on("eckit@1.16:")
+    depends_on("eckit@1.21:", when="@1.10:")
 
     depends_on("eccodes@2.5:", when="+grib")
+    depends_on("eccodes@2.27:", when="@1.10.2: +grib")
 
     depends_on("odc", when="+odb")
 

var/spack/repos/builtin/packages/migraphx/package.py

@@ -131,6 +131,7 @@ def url_for_version(self, version):
     depends_on("py-pybind11", type="build", when="@:4.0.0")
     depends_on("py-pybind11@2.6:", type="build", when="@4.1.0:")
     depends_on("pkgconfig", type="build", when="@5.3.0:")
+    depends_on("abseil-cpp")
 
     for ver in [
         "3.5.0",

var/spack/repos/builtin/packages/millepede/package.py

@@ -14,8 +14,6 @@ class Millepede(MakefilePackage):
     homepage = "https://gitlab.desy.de/claus.kleinwort/millepede-ii"
     url = "https://gitlab.desy.de/claus.kleinwort/millepede-ii/-/archive/V04-11-01/millepede-ii-V04-11-01.tar.gz"
 
-    maintainers("iarspider")
-
     parallel = False
 
     version("04-13-03", sha256="669a6e46a6f02ba3c78b2760e2ffb2c90d25b582ccd1a5c0770eef81c7bcbbe9")

var/spack/repos/builtin/packages/mimalloc/package.py

@@ -14,6 +14,8 @@ class Mimalloc(CMakePackage):
     git = "https://github.com/microsoft/mimalloc.git"
     maintainers("msimberg")
 
+    license("MIT")
+
     version("dev-slice", branch="dev-slice")
     version("dev", branch="dev")
     version("master", branch="master")

var/spack/repos/builtin/packages/mivisionx/0001-add-half-include-path-5.6.patch

@@ -0,0 +1,13 @@
+diff --git a/rocAL/rocAL/CMakeLists.txt b/rocAL/rocAL/CMakeLists.txt
+index 7ae8cb8..195f387 100644
+--- a/rocAL/rocAL/CMakeLists.txt
++++ b/rocAL/rocAL/CMakeLists.txt
+@@ -122,6 +122,8 @@ if(NOT Threads_FOUND)
+ endif()
+
+ if(${BUILD_ROCAL})
++    find_path(HALF_INCLUDE_DIR half.hpp)
++    include_directories(${HALF_INCLUDE_DIR})
+     # AMD OpenVX & VX_RPP
+     set(LINK_LIBRARY_LIST ${LINK_LIBRARY_LIST} openvx vx_rpp)
+     # AMD RPP