WIP

We want to show dependencies grouped by conditions, as we already do
with variants. This takes the first step and generifies the variant
display code.

lib/spack/docs/build_systems.rst

@@ -63,6 +63,7 @@ on these ideas for each distinct build system that Spack supports:
    build_systems/cudapackage
    build_systems/custompackage
    build_systems/inteloneapipackage
+   build_systems/intelpackage
    build_systems/rocmpackage
    build_systems/sourceforgepackage
 

lib/spack/docs/build_systems/inteloneapipackage.rst

@@ -33,6 +33,9 @@ For more information on a specific package, do::
 
   spack info --all <package-name>
 
+Intel no longer releases new versions of Parallel Studio, which can be
+used in Spack via the :ref:`intelpackage`. All of its components can
+now be found in oneAPI.
 
 Examples
 ========
@@ -47,8 +50,34 @@ Install the oneAPI compilers::
 
   spack install intel-oneapi-compilers
 
+Add the compilers to your ``compilers.yaml`` so spack can use them::
 
-To build the ``patchelf`` Spack package with ``icx``, do::
+  spack compiler add `spack location -i intel-oneapi-compilers`/compiler/latest/bin
+
+Verify that the compilers are available::
+
+  spack compiler list
+
+Note that 2024 and later releases do not include ``icc``. Before 2024,
+the package layout was different::
+  
+  spack compiler add `spack location -i intel-oneapi-compilers`/compiler/latest/linux/bin/intel64
+  spack compiler add `spack location -i intel-oneapi-compilers`/compiler/latest/linux/bin
+
+The ``intel-oneapi-compilers`` package includes 2 families of
+compilers:
+
+* ``intel``: ``icc``, ``icpc``, ``ifort``. Intel's *classic*
+  compilers. 2024 and later releases contain ``ifort``, but not
+  ``icc`` and ``icpc``.
+* ``oneapi``: ``icx``, ``icpx``, ``ifx``. Intel's new generation of
+  compilers based on LLVM.
+
+To build the ``patchelf`` Spack package with ``icc``, do::
+
+  spack install patchelf%intel
+
+To build with with ``icx``, do ::
 
   spack install patchelf%oneapi
 
@@ -63,6 +92,15 @@ Install the oneAPI compilers::
 
   spack install intel-oneapi-compilers
 
+Add the compilers to your ``compilers.yaml`` so Spack can use them::
+
+  spack compiler add `spack location -i intel-oneapi-compilers`/compiler/latest/bin
+  spack compiler add `spack location -i intel-oneapi-compilers`/compiler/latest/bin
+
+Verify that the compilers are available::
+
+  spack compiler list
+
 Clone `spack-configs <https://github.com/spack/spack-configs>`_ repo and activate Intel oneAPI CPU environment::
 
   git clone https://github.com/spack/spack-configs
@@ -111,7 +149,7 @@ Compilers
 ---------
 
 To use the compilers, add some information about the installation to
-``packages.yaml``. For most users, it is sufficient to do::
+``compilers.yaml``. For most users, it is sufficient to do::
 
   spack compiler add /opt/intel/oneapi/compiler/latest/bin
 
@@ -119,7 +157,7 @@ Adapt the paths above if you did not install the tools in the default
 location. After adding the compilers, using them is the same
 as if you had installed the ``intel-oneapi-compilers`` package.
 Another option is to manually add the configuration to
-``packages.yaml`` as described in :ref:`Compiler configuration
+``compilers.yaml`` as described in :ref:`Compiler configuration
 <compiler-config>`.
 
 Before 2024, the directory structure was different::
@@ -162,5 +200,15 @@ You can also use Spack-installed libraries. For example::
 Will update your environment CPATH, LIBRARY_PATH, and other
 environment variables for building an application with oneMKL.
 
+More information
+================
+
+This section describes basic use of oneAPI, especially if it has
+changed compared to Parallel Studio. See :ref:`intelpackage` for more
+information on :ref:`intel-virtual-packages`,
+:ref:`intel-unrelated-packages`,
+:ref:`intel-integrating-external-libraries`, and
+:ref:`using-mkl-tips`.
+
 
 .. _`Intel installers`: https://software.intel.com/content/www/us/en/develop/documentation/installation-guide-for-intel-oneapi-toolkits-linux/top.html

lib/spack/docs/build_systems/rocmpackage.rst

@@ -12,7 +12,8 @@ The ``ROCmPackage`` is not a build system but a helper package. Like ``CudaPacka
 it provides standard variants, dependencies, and conflicts to facilitate building
 packages using GPUs though for AMD in this case.
 
-You can find the source for this package (and suggestions for setting up your ``packages.yaml`` file) at
+You can find the source for this package (and suggestions for setting up your
+``compilers.yaml`` and ``packages.yaml`` files) at
 `<https://github.com/spack/spack/blob/develop/lib/spack/spack/build_systems/rocm.py>`__.
 
 ^^^^^^^^

lib/spack/docs/configuration.rst

@@ -11,7 +11,7 @@ Configuration Files
 Spack has many configuration files.  Here is a quick list of them, in
 case you want to skip directly to specific docs:
 
-* :ref:`packages.yaml <compiler-config>`
+* :ref:`compilers.yaml <compiler-config>`
 * :ref:`concretizer.yaml <concretizer-options>`
 * :ref:`config.yaml <config-yaml>`
 * :ref:`include.yaml <include-yaml>`
@@ -95,7 +95,7 @@ are six configuration scopes. From lowest to highest:
    precedence over all other scopes.
 
 Each configuration directory may contain several configuration files,
-such as ``config.yaml``, ``packages.yaml``, or ``mirrors.yaml``.  When
+such as ``config.yaml``, ``compilers.yaml``, or ``mirrors.yaml``.  When
 configurations conflict, settings from higher-precedence scopes override
 lower-precedence settings.
 

lib/spack/docs/environments.rst

@@ -686,7 +686,7 @@ the environment.
    spack:
      include:
      - environment/relative/path/to/config.yaml
-     - https://github.com/path/to/raw/config/packages.yaml
+     - https://github.com/path/to/raw/config/compilers.yaml
      - /absolute/path/to/packages.yaml
      - path: /path/to/$os/$target/environment
        optional: true

lib/spack/docs/getting_started.rst

@@ -254,11 +254,12 @@ directory.
 Compiler configuration
 ----------------------
 
-Spack has the ability to build packages with multiple compilers and compiler versions.
-Compilers can be made available to Spack by specifying them manually in ``packages.yaml``,
-or automatically by running ``spack compiler find``.
-For convenience, Spack will automatically detect compilers the first time it needs them,
-if none is available.
+Spack has the ability to build packages with multiple compilers and
+compiler versions. Compilers can be made available to Spack by
+specifying them manually in ``compilers.yaml`` or ``packages.yaml``,
+or automatically by running ``spack compiler find``, but for
+convenience Spack will automatically detect compilers the first time
+it needs them.
 
 .. _cmd-spack-compilers:
 
@@ -273,11 +274,16 @@ compilers`` or ``spack compiler list``:
 
    $ spack compilers
    ==> Available compilers
-   -- gcc ubuntu20.04-x86_64 ---------------------------------------
-   gcc@9.4.0  gcc@8.4.0  gcc@10.5.0
-
-   -- llvm ubuntu20.04-x86_64 --------------------------------------
-   llvm@12.0.0  llvm@11.0.0  llvm@10.0.0
+   -- gcc ---------------------------------------------------------
+       gcc@4.9.0  gcc@4.8.0  gcc@4.7.0  gcc@4.6.2  gcc@4.4.7
+       gcc@4.8.2  gcc@4.7.1  gcc@4.6.3  gcc@4.6.1  gcc@4.1.2
+   -- intel -------------------------------------------------------
+       intel@15.0.0  intel@14.0.0  intel@13.0.0  intel@12.1.0  intel@10.0
+       intel@14.0.3  intel@13.1.1  intel@12.1.5  intel@12.0.4  intel@9.1
+       intel@14.0.2  intel@13.1.0  intel@12.1.3  intel@11.1
+       intel@14.0.1  intel@13.0.1  intel@12.1.2  intel@10.1
+   -- clang -------------------------------------------------------
+       clang@3.4  clang@3.3  clang@3.2  clang@3.1
 
 Any of these compilers can be used to build Spack packages.  More on
 how this is done is in :ref:`sec-specs`.
@@ -296,22 +302,16 @@ An alias for ``spack compiler find``.
 ``spack compiler find``
 ^^^^^^^^^^^^^^^^^^^^^^^
 
-If you do not see a compiler in the list shown by:
+Lists the compilers currently available to Spack. If you do not see
+a compiler in this list, but you want to use it with Spack, you can
+simply run ``spack compiler find`` with the path to where the
+compiler is installed.  For example:
 
 .. code-block:: console
 
-   $ spack compiler list
-
-but you want to use it with Spack, you can simply run ``spack compiler find`` with the
-path to where the compiler is installed.  For example:
-
-.. code-block:: console
-
-   $ spack compiler find /opt/intel/oneapi/compiler/2025.1/bin/
-   ==> Added 1 new compiler to /home/user/.spack/packages.yaml
-       intel-oneapi-compilers@2025.1.0
-   ==> Compilers are defined in the following files:
-       /home/user/.spack/packages.yaml
+   $ spack compiler find /usr/local/tools/ic-13.0.079
+   ==> Added 1 new compiler to ~/.spack/linux/compilers.yaml
+       intel@13.0.079
 
 Or you can run ``spack compiler find`` with no arguments to force
 auto-detection.  This is useful if you do not know where compilers are
@@ -322,7 +322,7 @@ installed, but you know that new compilers have been added to your
 
    $ module load gcc/4.9.0
    $ spack compiler find
-   ==> Added 1 new compiler to /home/user/.spack/packages.yaml
+   ==> Added 1 new compiler to ~/.spack/linux/compilers.yaml
        gcc@4.9.0
 
 This loads the environment module for gcc-4.9.0 to add it to
@@ -331,7 +331,7 @@ This loads the environment module for gcc-4.9.0 to add it to
 .. note::
 
    By default, spack does not fill in the ``modules:`` field in the
-   ``packages.yaml`` file.  If you are using a compiler from a
+   ``compilers.yaml`` file.  If you are using a compiler from a
    module, then you should add this field manually.
    See the section on :ref:`compilers-requiring-modules`.
 
@@ -341,82 +341,91 @@ This loads the environment module for gcc-4.9.0 to add it to
 ``spack compiler info``
 ^^^^^^^^^^^^^^^^^^^^^^^
 
-If you want to see additional information on some specific compilers, you can run ``spack compiler info`` on it:
+If you want to see specifics on a particular compiler, you can run
+``spack compiler info`` on it:
 
 .. code-block:: console
 
-   $ spack compiler info gcc
-   gcc@=8.4.0 languages='c,c++,fortran' arch=linux-ubuntu20.04-x86_64:
-     prefix: /usr
-     compilers:
-       c: /usr/bin/gcc-8
-       cxx: /usr/bin/g++-8
-       fortran: /usr/bin/gfortran-8
+   $ spack compiler info intel@15
+   intel@15.0.0:
+     paths:
+       cc  = /usr/local/bin/icc-15.0.090
+       cxx = /usr/local/bin/icpc-15.0.090
+       f77 = /usr/local/bin/ifort-15.0.090
+       fc  = /usr/local/bin/ifort-15.0.090
+     modules = []
+     operating_system = centos6
+   ...
 
-   gcc@=9.4.0 languages='c,c++,fortran' arch=linux-ubuntu20.04-x86_64:
-     prefix: /usr
-     compilers:
-       c: /usr/bin/gcc
-       cxx: /usr/bin/g++
-       fortran: /usr/bin/gfortran
-
-   gcc@=10.5.0 languages='c,c++,fortran' arch=linux-ubuntu20.04-x86_64:
-     prefix: /usr
-     compilers:
-       c: /usr/bin/gcc-10
-       cxx: /usr/bin/g++-10
-       fortran: /usr/bin/gfortran-10
-
-This shows the details of the compilers that were detected by Spack.
-Notice also that we didn't have to be too specific about the version. We just said ``gcc``, and we got information
-about all the matching compilers.
+This shows which C, C++, and Fortran compilers were detected by Spack.
+Notice also that we didn't have to be too specific about the
+version. We just said ``intel@15``, and information about the only
+matching Intel compiler was displayed.
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 Manual compiler configuration
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-If auto-detection fails, you can manually configure a compiler by editing your ``~/.spack/packages.yaml`` file.
-You can do this by running ``spack config edit packages``, which will open the file in
+If auto-detection fails, you can manually configure a compiler by
+editing your ``~/.spack/<platform>/compilers.yaml`` file.  You can do this by running
+``spack config edit compilers``, which will open the file in
 :ref:`your favorite editor <controlling-the-editor>`.
 
-Each compiler has an "external" entry in the file with some ``extra_attributes``:
+Each compiler configuration in the file looks like this:
 
 .. code-block:: yaml
 
-   packages:
-     gcc:
-       externals:
-       - spec: gcc@10.5.0 languages='c,c++,fortran'
-         prefix: /usr
-         extra_attributes:
    compilers:
-             c: /usr/bin/gcc-10
-             cxx: /usr/bin/g++-10
-             fortran: /usr/bin/gfortran-10
+   - compiler:
+       modules: []
+       operating_system: centos6
+       paths:
+         cc: /usr/local/bin/icc-15.0.024-beta
+         cxx: /usr/local/bin/icpc-15.0.024-beta
+         f77: /usr/local/bin/ifort-15.0.024-beta
+         fc: /usr/local/bin/ifort-15.0.024-beta
+       spec: intel@15.0.0
 
-The compiler executables are listed under ``extra_attributes:compilers``, and are keyed by language.
-Once you save the file, the configured compilers will show up in the list displayed by ``spack compilers``.
+For compilers that do not support Fortran (like ``clang``), put
+``None`` for ``f77`` and ``fc``:
 
-You can also add compiler flags to manually configured compilers. These flags should be specified in the
-``flags`` section of the compiler specification. The valid flags are ``cflags``, ``cxxflags``, ``fflags``,
+.. code-block:: yaml
+
+   compilers:
+   - compiler:
+       modules: []
+       operating_system: centos6
+       paths:
+         cc: /usr/bin/clang
+         cxx: /usr/bin/clang++
+         f77: None
+         fc: None
+       spec: clang@3.3svn
+
+Once you save the file, the configured compilers will show up in the
+list displayed by ``spack compilers``.
+
+You can also add compiler flags to manually configured compilers. These
+flags should be specified in the ``flags`` section of the compiler
+specification. The valid flags are ``cflags``, ``cxxflags``, ``fflags``,
 ``cppflags``, ``ldflags``, and ``ldlibs``. For example:
 
 .. code-block:: yaml
 
-   packages:
-     gcc:
-       externals:
-       - spec: gcc@10.5.0 languages='c,c++,fortran'
-         prefix: /usr
-         extra_attributes:
    compilers:
-             c: /usr/bin/gcc-10
-             cxx: /usr/bin/g++-10
-             fortran: /usr/bin/gfortran-10
+   - compiler:
+       modules: []
+       operating_system: centos6
+       paths:
+         cc: /usr/bin/gcc
+         cxx: /usr/bin/g++
+         f77: /usr/bin/gfortran
+         fc: /usr/bin/gfortran
        flags:
          cflags: -O3 -fPIC
          cxxflags: -O3 -fPIC
          cppflags: -O3 -fPIC
+       spec: gcc@4.7.2
 
 These flags will be treated by spack as if they were entered from
 the command line each time this compiler is used. The compiler wrappers
@@ -433,16 +442,16 @@ specification. The operations available to modify the environment are ``set``, `
 
 .. code-block:: yaml
 
-   packages:
-     intel-oneapi-compilers:
-       externals:
-       - spec: intel-oneapi-compilers@2025.1.0
-         prefix: /opt/intel/oneapi
-         extra_attributes:
    compilers:
-             c: /opt/intel/oneapi/compiler/2025.1/bin/icx
-             cxx: /opt/intel/oneapi/compiler/2025.1/bin/icpx
-             fortran: /opt/intel/oneapi/compiler/2025.1/bin/ifx
+   - compiler:
+       modules: []
+       operating_system: centos6
+       paths:
+         cc: /opt/intel/oneapi/compiler/latest/linux/bin/icx
+         cxx: /opt/intel/oneapi/compiler/latest/linux/bin/icpx
+         f77: /opt/intel/oneapi/compiler/latest/linux/bin/ifx
+         fc: /opt/intel/oneapi/compiler/latest/linux/bin/ifx
+       spec: oneapi@latest
        environment:
          set:
            MKL_ROOT: "/path/to/mkl/root"
@@ -451,24 +460,75 @@ specification. The operations available to modify the environment are ``set``, `
          prepend_path: # Similar for append|remove_path
            LD_LIBRARY_PATH: /ld/paths/added/by/setvars/sh
 
+.. note::
+
+   Spack is in the process of moving compilers from a separate
+   attribute to be handled like all other packages. As part of this
+   process, the ``compilers.yaml`` section will eventually be replaced
+   by configuration in the ``packages.yaml`` section. This new
+   configuration is now available, although it is not yet the default
+   behavior.
+
+Compilers can also be configured as external packages in the
+``packages.yaml`` config file. Any external package for a compiler
+(e.g. ``gcc`` or ``llvm``) will be treated as a configured compiler
+assuming the paths to the compiler executables are determinable from
+the prefix.
+
+If the paths to the compiler executable are not determinable from the
+prefix, you can add them to the ``extra_attributes`` field. Similarly,
+all other fields from the compilers config can be added to the
+``extra_attributes`` field for an external representing a compiler.
+
+Note that the format for the ``paths`` field in the
+``extra_attributes`` section is different than in the ``compilers``
+config. For compilers configured as external packages, the section is
+named ``compilers`` and the dictionary maps language names (``c``,
+``cxx``, ``fortran``) to paths, rather than using the names ``cc``,
+``fc``, and ``f77``.
+
+.. code-block:: yaml
+
+   packages:
+     gcc:
+       external:
+       - spec: gcc@12.2.0 arch=linux-rhel8-skylake
+         prefix: /usr
+         extra_attributes:
+           environment:
+             set:
+               GCC_ROOT: /usr
+       external:
+       - spec: llvm+clang@15.0.0 arch=linux-rhel8-skylake
+         prefix: /usr
+         extra_attributes:
+           compilers:
+             c: /usr/bin/clang-with-suffix
+             cxx: /usr/bin/clang++-with-extra-info
+             fortran: /usr/bin/gfortran
+           extra_rpaths:
+           - /usr/lib/llvm/
+
 ^^^^^^^^^^^^^^^^^^^^^^^
 Build Your Own Compiler
 ^^^^^^^^^^^^^^^^^^^^^^^
 
-If you are particular about which compiler/version you use, you might wish to have Spack build it for you.
-For example:
+If you are particular about which compiler/version you use, you might
+wish to have Spack build it for you.  For example:
 
 .. code-block:: console
 
-   $ spack install gcc@14+binutils
+   $ spack install gcc@4.9.3
 
-Once the compiler is installed, you can start using it without additional configuration:
+Once that has finished, you will need to add it to your
+``compilers.yaml`` file.  You can then set Spack to use it by default
+by adding the following to your ``packages.yaml`` file:
 
-.. code-block:: console
+.. code-block:: yaml
 
-   $ spack install hdf5~mpi %gcc@14
-
-The same holds true for compilers that are made available from buildcaches, when reusing them is allowed.
+   packages:
+     all:
+       compiler: [gcc@4.9.3]
 
 .. _compilers-requiring-modules:
 
@@ -476,26 +536,30 @@ The same holds true for compilers that are made available from buildcaches, when
 Compilers Requiring Modules
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Many installed compilers will work regardless of the environment they are called with.
-However, some installed compilers require environment variables to be set in order to run;
-this is typical for Intel and other proprietary compilers.
+Many installed compilers will work regardless of the environment they
+are called with.  However, some installed compilers require
+``$LD_LIBRARY_PATH`` or other environment variables to be set in order
+to run; this is typical for Intel and other proprietary compilers.
 
-On typical HPC clusters, these environment modifications are usually delegated to some "module" system.
-In such a case, you should tell Spack which module(s) to load in order to run the chosen compiler:
+In such a case, you should tell Spack which module(s) to load in order
+to run the chosen compiler (If the compiler does not come with a
+module file, you might consider making one by hand).  Spack will load
+this module into the environment ONLY when the compiler is run, and
+NOT in general for a package's ``install()`` method.  See, for
+example, this ``compilers.yaml`` file:
 
 .. code-block:: yaml
 
-   packages:
-     gcc:
-       externals:
-       - spec: gcc@10.5.0 languages='c,c++,fortran'
-         prefix: /opt/compilers
-         extra_attributes:
    compilers:
-             c: /opt/compilers/bin/gcc-10
-             cxx: /opt/compilers/bin/g++-10
-             fortran: /opt/compilers/bin/gfortran-10
-         modules: [gcc/10.5.0]
+   - compiler:
+       modules: [other/comp/gcc-5.3-sp3]
+       operating_system: SuSE11
+       paths:
+         cc: /usr/local/other/SLES11.3/gcc/5.3.0/bin/gcc
+         cxx: /usr/local/other/SLES11.3/gcc/5.3.0/bin/g++
+         f77: /usr/local/other/SLES11.3/gcc/5.3.0/bin/gfortran
+         fc: /usr/local/other/SLES11.3/gcc/5.3.0/bin/gfortran
+       spec: gcc@5.3.0
 
 Some compilers require special environment settings to be loaded not just
 to run, but also to execute the code they build, breaking packages that
@@ -516,7 +580,7 @@ Licensed Compilers
 ^^^^^^^^^^^^^^^^^^
 
 Some proprietary compilers require licensing to use.  If you need to
-use a licensed compiler, the process is similar to a mix of
+use a licensed compiler (eg, PGI), the process is similar to a mix of
 build your own, plus modules:
 
 #. Create a Spack package (if it doesn't exist already) to install
@@ -526,21 +590,24 @@ build your own, plus modules:
    using Spack to load the module it just created, and running simple
    builds (eg: ``cc helloWorld.c && ./a.out``)
 
-#. Add the newly-installed compiler to ``packages.yaml`` as shown above.
+#. Add the newly-installed compiler to ``compilers.yaml`` as shown
+   above.
 
 .. _mixed-toolchains:
 
-^^^^^^^^^^^^^^^^^^^^^^^^^^
-Fortran compilers on macOS
-^^^^^^^^^^^^^^^^^^^^^^^^^^
+^^^^^^^^^^^^^^^^
+Mixed Toolchains
+^^^^^^^^^^^^^^^^
 
 Modern compilers typically come with related compilers for C, C++ and
 Fortran bundled together.  When possible, results are best if the same
 compiler is used for all languages.
 
-In some cases, this is not possible.  For example, XCode on macOS provides no Fortran compilers.
-The user is therefore forced to use a mixed toolchain: XCode-provided Clang for C/C++ and e.g.
-GNU ``gfortran`` for Fortran.
+In some cases, this is not possible.  For example, starting with macOS El
+Capitan (10.11), many packages no longer build with GCC, but XCode
+provides no Fortran compilers.  The user is therefore forced to use a
+mixed toolchain: XCode-provided Clang for C/C++ and GNU ``gfortran`` for
+Fortran.
 
 #. You need to make sure that Xcode is installed. Run the following command:
 
@@ -593,25 +660,45 @@ GNU ``gfortran`` for Fortran.
 
    Note: the flag is ``-license``, not ``--license``.
 
+#. Run ``spack compiler find`` to locate Clang.
+
 #. There are different ways to get ``gfortran`` on macOS. For example, you can
    install GCC with Spack (``spack install gcc``), with Homebrew (``brew install
    gcc``), or from a `DMG installer
    <https://github.com/fxcoudert/gfortran-for-macOS/releases>`_.
 
-#. Run ``spack compiler find`` to locate both Apple-Clang and GCC.
+#. The only thing left to do is to edit ``~/.spack/darwin/compilers.yaml`` to provide
+   the path to ``gfortran``:
 
-Since languages in Spack are modeled as virtual packages, ``apple-clang`` will be used to provide
-C and C++, while GCC will be used for Fortran.
+   .. code-block:: yaml
+
+      compilers:
+      - compiler:
+        # ...
+        paths:
+          cc: /usr/bin/clang
+          cxx: /usr/bin/clang++
+          f77: /path/to/bin/gfortran
+          fc: /path/to/bin/gfortran
+        spec: apple-clang@11.0.0
+
+
+   If you used Spack to install GCC, you can get the installation prefix by
+   ``spack location -i gcc`` (this will only work if you have a single version
+   of GCC installed). Whereas for Homebrew, GCC is installed in
+   ``/usr/local/Cellar/gcc/x.y.z``. With the DMG installer, the correct path
+   will be ``/usr/local/gfortran``.
 
 ^^^^^^^^^^^^^^^^^^^^^
 Compiler Verification
 ^^^^^^^^^^^^^^^^^^^^^
 
-You can verify that your compilers are configured properly by installing a simple package. For example:
+You can verify that your compilers are configured properly by installing a
+simple package.  For example:
 
 .. code-block:: console
 
-   $ spack install zlib-ng%gcc@5.3.0
+   $ spack install zlib%gcc@5.3.0
 
 
 .. _vendor-specific-compiler-configuration:
@@ -620,7 +707,9 @@ You can verify that your compilers are configured properly by installing a simpl
 Vendor-Specific Compiler Configuration
 --------------------------------------
 
-This section provides details on how to get vendor-specific compilers working.
+With Spack, things usually "just work" with GCC.  Not so for other
+compilers.  This section provides details on how to get specific
+compilers working.
 
 ^^^^^^^^^^^^^^^
 Intel Compilers
@@ -642,8 +731,8 @@ compilers:
       you have installed from the ``PATH`` environment variable.
 
       If you want use a version of ``gcc`` or ``g++`` other than the default
-      version on your system, you need to use either the ``--gcc-install-dir``
-      or ``--gcc-toolchain`` compiler option to specify the path to the version of
+      version on your system, you need to use either the ``-gcc-name``
+      or ``-gxx-name`` compiler option to specify the path to the version of
       ``gcc`` or ``g++`` that you want to use."
 
       -- `Intel Reference Guide <https://software.intel.com/en-us/node/522750>`_
@@ -651,12 +740,76 @@ compilers:
 Intel compilers may therefore be configured in one of two ways with
 Spack: using modules, or using compiler flags.
 
+""""""""""""""""""""""""""
+Configuration with Modules
+""""""""""""""""""""""""""
+
+One can control which GCC is seen by the Intel compiler with modules.
+A module must be loaded both for the Intel Compiler (so it will run)
+and GCC (so the compiler can find the intended GCC).  The following
+configuration in ``compilers.yaml`` illustrates this technique:
+
+.. code-block:: yaml
+
+   compilers:
+   - compiler:
+       modules: [gcc-4.9.3, intel-15.0.24]
+       operating_system: centos7
+       paths:
+         cc: /opt/intel-15.0.24/bin/icc-15.0.24-beta
+         cxx: /opt/intel-15.0.24/bin/icpc-15.0.24-beta
+         f77: /opt/intel-15.0.24/bin/ifort-15.0.24-beta
+         fc: /opt/intel-15.0.24/bin/ifort-15.0.24-beta
+       spec: intel@15.0.24.4.9.3
+
+
+.. note::
+
+   The version number on the Intel compiler is a combination of
+   the "native" Intel version number and the GNU compiler it is
+   targeting.
+
+""""""""""""""""""""""""""
+Command Line Configuration
+""""""""""""""""""""""""""
+
+One can also control which GCC is seen by the Intel compiler by adding
+flags to the ``icc`` command:
+
+#. Identify the location of the compiler you just installed:
+
+   .. code-block:: console
+
+       $ spack location --install-dir gcc
+       ~/spack/opt/spack/linux-centos7-x86_64/gcc-4.9.3-iy4rw...
+
+#. Set up ``compilers.yaml``, for example:
+
+   .. code-block:: yaml
+
+       compilers:
+       - compiler:
+           modules: [intel-15.0.24]
+           operating_system: centos7
+           paths:
+             cc: /opt/intel-15.0.24/bin/icc-15.0.24-beta
+             cxx: /opt/intel-15.0.24/bin/icpc-15.0.24-beta
+             f77: /opt/intel-15.0.24/bin/ifort-15.0.24-beta
+             fc: /opt/intel-15.0.24/bin/ifort-15.0.24-beta
+           flags:
+             cflags: -gcc-name ~/spack/opt/spack/linux-centos7-x86_64/gcc-4.9.3-iy4rw.../bin/gcc
+             cxxflags: -gxx-name ~/spack/opt/spack/linux-centos7-x86_64/gcc-4.9.3-iy4rw.../bin/g++
+             fflags: -gcc-name ~/spack/opt/spack/linux-centos7-x86_64/gcc-4.9.3-iy4rw.../bin/gcc
+           spec: intel@15.0.24.4.9.3
+
+
 ^^^
 NAG
 ^^^
 
-The Numerical Algorithms Group provides a licensed Fortran compiler.
-It is recommended to use GCC for your C/C++ compilers.
+The Numerical Algorithms Group provides a licensed Fortran compiler. Like Clang,
+this requires you to set up a :ref:`mixed-toolchains`. It is recommended to use
+GCC for your C/C++ compilers.
 
 The NAG Fortran compilers are a bit more strict than other compilers, and many
 packages will fail to install with error messages like:
@@ -673,40 +826,44 @@ the command line:
 
    $ spack install openmpi fflags="-mismatch"
 
-Or it can be set permanently in your ``packages.yaml``:
+Or it can be set permanently in your ``compilers.yaml``:
 
 .. code-block:: yaml
 
-   packages:
-     nag:
-       externals:
-       - spec: nag@6.1
-         prefix: /opt/nag/bin
-         extra_attributes:
-           compilers:
-             fortran: /opt/nag/bin/nagfor
+   - compiler:
+    modules: []
+    operating_system: centos6
+    paths:
+      cc: /soft/spack/opt/spack/linux-x86_64/gcc-5.3.0/gcc-6.1.0-q2zosj3igepi3pjnqt74bwazmptr5gpj/bin/gcc
+      cxx: /soft/spack/opt/spack/linux-x86_64/gcc-5.3.0/gcc-6.1.0-q2zosj3igepi3pjnqt74bwazmptr5gpj/bin/g++
+      f77: /soft/spack/opt/spack/linux-x86_64/gcc-4.4.7/nag-6.1-jt3h5hwt5myezgqguhfsan52zcskqene/bin/nagfor
+      fc: /soft/spack/opt/spack/linux-x86_64/gcc-4.4.7/nag-6.1-jt3h5hwt5myezgqguhfsan52zcskqene/bin/nagfor
     flags:
       fflags: -mismatch
+    spec: nag@6.1
+
 
 ---------------
 System Packages
 ---------------
 
-Once compilers are configured, one needs to determine which pre-installed system packages,
-if any, to use in builds.  These are also configured in the ``~/.spack/packages.yaml`` file.
-For example, to use an OpenMPI installed in /opt/local, one would use:
+Once compilers are configured, one needs to determine which
+pre-installed system packages, if any, to use in builds.  This is
+configured in the file ``~/.spack/packages.yaml``.  For example, to use
+an OpenMPI installed in /opt/local, one would use:
 
 .. code-block:: yaml
 
     packages:
         openmpi:
-       buildable: False
             externals:
             - spec: openmpi@1.10.1
               prefix: /opt/local
+            buildable: False
 
-In general, *Spack is easier to use and more reliable if it builds all of its own dependencies*.
-However, there are several packages for which one commonly needs to use system versions:
+In general, Spack is easier to use and more reliable if it builds all of
+its own dependencies.  However, there are several packages for which one
+commonly needs to use system versions:
 
 ^^^
 MPI
@@ -719,7 +876,8 @@ you are unlikely to get a working MPI from Spack.  Instead, use an
 appropriate pre-installed MPI.
 
 If you choose a pre-installed MPI, you should consider using the
-pre-installed compiler used to build that MPI.
+pre-installed compiler used to build that MPI; see above on
+``compilers.yaml``.
 
 ^^^^^^^
 OpenSSL
@@ -1283,9 +1441,9 @@ To configure Spack, first run the following command inside the Spack console:
    spack compiler find
 
 This creates a ``.staging`` directory in our Spack prefix, along with a ``windows`` subdirectory
-containing a ``packages.yaml`` file. On a fresh Windows install with the above packages
+containing a ``compilers.yaml`` file. On a fresh Windows install with the above packages
 installed, this command should only detect Microsoft Visual Studio and the Intel Fortran
-compiler will be integrated within the first version of MSVC present in the ``packages.yaml``
+compiler will be integrated within the first version of MSVC present in the ``compilers.yaml``
 output.
 
 Spack provides a default ``config.yaml`` file for Windows that it will use unless overridden.

lib/spack/spack/build_systems/oneapi.py

@@ -311,4 +311,4 @@ def ld_flags(self):
 
 
 #: Tuple of Intel math libraries, exported to packages
-INTEL_MATH_LIBRARIES = ("intel-oneapi-mkl",)
+INTEL_MATH_LIBRARIES = ("intel-mkl", "intel-oneapi-mkl", "intel-parallel-studio")

lib/spack/spack/cmd/ci.py

@@ -4,6 +4,7 @@
 
 import json
 import os
+import re
 import shutil
 import sys
 from typing import Dict
@@ -25,10 +26,12 @@
 import spack.hash_types as ht
 import spack.mirrors.mirror
 import spack.package_base
+import spack.paths
 import spack.repo
 import spack.spec
 import spack.stage
 import spack.util.executable
+import spack.util.git
 import spack.util.gpg as gpg_util
 import spack.util.timer as timer
 import spack.util.url as url_util
@@ -42,6 +45,7 @@
 SPACK_COMMAND = "spack"
 INSTALL_FAIL_CODE = 1
 FAILED_CREATE_BUILDCACHE_CODE = 100
+BUILTIN = re.compile(r"var\/spack\/repos\/builtin\/packages\/([^\/]+)\/package\.py")
 
 
 def deindent(desc):
@@ -779,15 +783,18 @@ def ci_verify_versions(args):
     then parses the git diff between the two to determine which packages
     have been modified verifies the new checksums inside of them.
     """
-    # Get a list of all packages that have been changed or added
-    # between from_ref and to_ref
-    pkgs = spack.repo.get_all_package_diffs("AC", args.from_ref, args.to_ref)
+    with fs.working_dir(spack.paths.prefix):
+        # We use HEAD^1 explicitly on the merge commit created by
+        # GitHub Actions. However HEAD~1 is a safer default for the helper function.
+        files = spack.util.git.get_modified_files(from_ref=args.from_ref, to_ref=args.to_ref)
+
+    # Get a list of package names from the modified files.
+    pkgs = [(m.group(1), p) for p in files for m in [BUILTIN.search(p)] if m]
 
     failed_version = False
-    for pkg_name in pkgs:
+    for pkg_name, path in pkgs:
         spec = spack.spec.Spec(pkg_name)
         pkg = spack.repo.PATH.get_pkg_class(spec.name)(spec)
-        path = spack.repo.PATH.package_path(pkg_name)
 
         # Skip checking manual download packages and trust the maintainers
         if pkg.manual_download:
@@ -811,7 +818,7 @@ def ci_verify_versions(args):
             # TODO: enforce every version have a commit or a sha256 defined if not
             # an infinite version (there are a lot of package's where this doesn't work yet.)
 
-        with fs.working_dir(os.path.dirname(path)):
+        with fs.working_dir(spack.paths.prefix):
             added_checksums = spack_ci.get_added_versions(
                 checksums_version_dict, path, from_ref=args.from_ref, to_ref=args.to_ref
             )

lib/spack/spack/cmd/create.py

@@ -572,7 +572,7 @@ def edit(self, spec, prefix):
 class IntelPackageTemplate(PackageTemplate):
     """Provides appropriate overrides for licensed Intel software"""
 
-    base_class_name = "IntelOneApiPackage"
+    base_class_name = "IntelPackage"
 
     body_def = """\
     # FIXME: Override `setup_environment` if necessary."""

lib/spack/spack/cmd/info.py

@@ -5,6 +5,7 @@
 import sys
 import textwrap
 from itertools import zip_longest
+from typing import Callable, Dict, TypeVar
 
 import llnl.util.tty as tty
 import llnl.util.tty.color as color
@@ -14,11 +15,12 @@
 import spack.deptypes as dt
 import spack.fetch_strategy as fs
 import spack.install_test
+import spack.package_base
 import spack.repo
 import spack.spec
 import spack.variant
 from spack.cmd.common import arguments
-from spack.package_base import preferred_version
+from spack.util.typing import SupportsRichComparison
 
 description = "get detailed information on a particular package"
 section = "basic"
@@ -28,6 +30,44 @@
 plain_format = "@."
 
 
+class Formatter:
+    """Generic formatter for elements displayed by `spack info`.
+
+    Elements have four parts: name, values, when condition, and description. They can
+    be formatted two ways (shown here for variants)::
+
+    Grouped by when (default)::
+
+        when +cuda
+          cuda_arch [none]                            none, 10, 100, 100a, 101,
+                                                      101a, 11, 12, 120, 120a, 13
+              CUDA architecture
+
+    Or, by name (each name has a when nested under it)::
+
+        cuda_arch [none]                              none, 10, 100, 100a, 101,
+                                                      101a, 11, 12, 120, 120a, 13
+          when +cuda
+            CUDA architecture
+
+    The values and description will be wrapped if needed. the name (and any additional info)
+    will not (so they should be kept short).
+
+    Subclasses are responsible for generating colorized text, but not wrapping,
+    indentation, or other formatting, for the name, values, and description.
+
+    """
+
+    def format_name(self, element) -> str:
+        return ""
+
+    def format_values(self, element) -> str:
+        return ""
+
+    def format_description(self, element) -> str:
+        return ""
+
+
 def padder(str_list, extra=0):
     """Return a function to pad elements of a list."""
     length = max(len(str(s)) for s in str_list) + extra
@@ -140,17 +180,19 @@ def lines(self):
                     yield "    " + self.fmt % t
 
 
+class DependencyFormatter(Formatter):
+    def format_name(self, dep) -> str:
+        return str(dep.spec)
+
+    def format_values(self, dep) -> str:
+        return str(dt.flag_to_tuple(dep.depflag))
+
+
 def print_dependencies(pkg, args):
     """output build, link, and run package dependencies"""
 
-    for deptype in ("build", "link", "run"):
-        color.cprint("")
-        color.cprint(section_title("%s Dependencies:" % deptype.capitalize()))
-        deps = sorted(pkg.dependencies_of_type(dt.flag_from_string(deptype)))
-        if deps:
-            colify(deps, indent=4)
-        else:
-            color.cprint("    None")
+    print_fn = print_by_name if args.variants_by_name else print_grouped_by_when
+    print_fn("Dependencies", pkg.dependencies, DependencyFormatter())
 
 
 def print_detectable(pkg, args):
@@ -263,40 +305,21 @@ def print_tests(pkg, args):
         color.cprint("    None")
 
 
-def _fmt_value(v):
-    if v is None or isinstance(v, bool):
-        return str(v).lower()
-    else:
-        return str(v)
-
-
-def _fmt_name_and_default(variant):
-    """Print colorized name [default] for a variant."""
-    return color.colorize(f"@c{{{variant.name}}} @C{{[{_fmt_value(variant.default)}]}}")
-
-
 def _fmt_when(when: "spack.spec.Spec", indent: int):
     return color.colorize(f"{indent * ' '}@B{{when}} {color.cescape(str(when))}")
 
 
-def _fmt_variant_description(variant, width, indent):
-    """Format a variant's description, preserving explicit line breaks."""
-    return "\n".join(
-        textwrap.fill(
-            line, width=width, initial_indent=indent * " ", subsequent_indent=indent * " "
-        )
-        for line in variant.description.split("\n")
+def _fmt_variant_value(v):
+    return str(v).lower() if v is None or isinstance(v, bool) else str(v)
+
+
+class VariantFormatter(Formatter):
+    def format_name(self, variant) -> str:
+        return color.colorize(
+            f"@c{{{variant.name}}} @C{{[{_fmt_variant_value(variant.default)}]}}"
         )
 
-
-def _fmt_variant(variant, max_name_default_len, indent, when=None, out=None):
-    out = out or sys.stdout
-
-    _, cols = tty.terminal_size()
-
-    name_and_default = _fmt_name_and_default(variant)
-    name_default_len = color.clen(name_and_default)
-
+    def format_values(self, variant) -> str:
         values = variant.values
         if not isinstance(variant.values, (tuple, list, spack.variant.DisjointSetsOfValues)):
             values = [variant.values]
@@ -304,25 +327,48 @@ def _fmt_variant(variant, max_name_default_len, indent, when=None, out=None):
         # put 'none' first, sort the rest by value
         sorted_values = sorted(values, key=lambda v: (v != "none", v))
 
-    pad = 4  # min padding between 'name [default]' and values
-    value_indent = (indent + max_name_default_len + pad) * " "  # left edge of values
+        return color.colorize(f"@c{{{', '.join(_fmt_variant_value(v) for v in sorted_values)}}}")
 
-    # This preserves any formatting (i.e., newlines) from how the description was
-    # written in package.py, but still wraps long lines for small terminals.
-    # This allows some packages to provide detailed help on their variants (see, e.g., gasnet).
+    def format_description(self, variant) -> str:
+        return variant.description
+
+
+def _fmt_definition(
+    name_field, values_field, description, max_name_len, indent, when=None, out=None
+):
+    """Format a definition entry in `spack info` output.
+
+    Arguments:
+        name_field: name and optional info, e.g. a default; should be short.
+        values_field: possible values for the entry; Wrapped if long.
+        description: description of the field (wrapped if overly long)
+        indent: size of leading indent for entry
+        when: optional when condition
+        out: stream to print to
+    """
+    out = out or sys.stdout
+
+    _, cols = tty.terminal_size()
+
+    name_len = color.clen(name_field)
+
+    pad = 4  # min padding between name and values
+    value_indent = (indent + max_name_len + pad) * " "  # left edge of values
+
+    if values_field:
         formatted_values = "\n".join(
             textwrap.wrap(
-            f"{', '.join(_fmt_value(v) for v in sorted_values)}",
+                values_field,
                 width=cols - 2,
                 initial_indent=value_indent,
                 subsequent_indent=value_indent,
             )
         )
-    formatted_values = formatted_values[indent + name_default_len + pad :]
+        # trim initial indentation
+        formatted_values = formatted_values[indent + name_len + pad :]
 
         # name [default]   value1, value2, value3, ...
-    padding = pad * " "
-    color.cprint(f"{indent * ' '}{name_and_default}{padding}@c{{{formatted_values}}}", stream=out)
+        out.write(f"{indent * ' '}{name_field}{pad * ' '}{formatted_values}\n")
 
     # when <spec>
     description_indent = indent + 4
@@ -330,38 +376,65 @@ def _fmt_variant(variant, max_name_default_len, indent, when=None, out=None):
         out.write(_fmt_when(when, description_indent - 2))
         out.write("\n")
 
-    # description, preserving explicit line breaks from the way it's written in the package file
-    out.write(_fmt_variant_description(variant, cols - 2, description_indent))
+    # description, preserving explicit line breaks from the way it's written in the
+    # package file, but still wrapoing long lines for small terminals. This allows
+    # descriptions to provide detailed help in descriptions (see, e.g., gasnet's variants).
+    if description:
+        formatted_description = "\n".join(
+            textwrap.fill(
+                line,
+                width=cols - 2,
+                initial_indent=description_indent * " ",
+                subsequent_indent=description_indent * " ",
+            )
+            for line in description.split("\n")
+        )
+        out.write(formatted_description)
         out.write("\n")
 
 
-def _print_variants_header(pkg):
-    """output variants"""
+K = TypeVar("K", bound=SupportsRichComparison)
+V = TypeVar("V")
 
-    if not pkg.variants:
-        print("    None")
-        return
 
+def print_header(header: str, when_indexed_dictionary: Dict, formatter: Formatter):
     color.cprint("")
-    color.cprint(section_title("Variants:"))
+    color.cprint(section_title(f"{header}:"))
 
-    # Calculate the max length of the "name [default]" part of the variant display
-    # This lets us know where to print variant values.
-    max_name_default_len = max(
-        color.clen(_fmt_name_and_default(variant))
-        for name in pkg.variant_names()
-        for _, variant in pkg.variant_definitions(name)
+    if not when_indexed_dictionary:
+        print("    None")
+
+
+def max_name_length(when_indexed_dictionary: Dict, formatter: Formatter) -> int:
+    # Calculate the max length of the first field of the definition. Lets us know how
+    # much to pad other fields on the first line.
+    return max(
+        color.clen(formatter.format_name(definition))
+        for subkey in spack.package_base._subkeys(when_indexed_dictionary)
+        for _, definition in spack.package_base._definitions(when_indexed_dictionary, subkey)
     )
 
-    return max_name_default_len
 
+def print_grouped_by_when(header: str, when_indexed_dictionary: Dict, formatter: Formatter):
+    """Generic method to print metadata grouped by when conditions."""
 
-def print_variants_grouped_by_when(pkg):
-    max_name_default_len = _print_variants_header(pkg)
+    print_header(header, when_indexed_dictionary, formatter)
+    if not when_indexed_dictionary:
+        return
+
+    max_name_len = max_name_length(when_indexed_dictionary, formatter)
+
+    # Calculate the max length of the first field of the definition. Lets us know how
+    # much to pad other fields on the first line.
+    max_name_len = max(
+        color.clen(formatter.format_name(definition))
+        for subkey in spack.package_base._subkeys(when_indexed_dictionary)
+        for _, definition in spack.package_base._definitions(when_indexed_dictionary, subkey)
+    )
 
     indent = 4
-    for when, variants_by_name in pkg.variant_items():
-        padded_values = max_name_default_len + 4
+    for when, by_name in when_indexed_dictionary.items():
+        padded_values = max_name_len + 4
         start_indent = indent
 
         if when != spack.spec.Spec():
@@ -373,27 +446,46 @@ def print_variants_grouped_by_when(pkg):
             padded_values -= 2
             start_indent += 2
 
-        for name, variant in sorted(variants_by_name.items()):
-            _fmt_variant(variant, padded_values, start_indent, None, out=sys.stdout)
+        for subkey, definition in sorted(by_name.items()):
+            _fmt_definition(
+                formatter.format_name(definition),
+                formatter.format_values(definition),
+                formatter.format_description(definition),
+                max_name_len,
+                start_indent,
+                when=None,
+                out=sys.stdout,
+            )
 
 
-def print_variants_by_name(pkg):
-    max_name_default_len = _print_variants_header(pkg)
-    max_name_default_len += 4
+def print_by_name(header: str, when_indexed_dictionary: Dict, formatter: Formatter):
+    print_header(header, when_indexed_dictionary, formatter)
+    if not when_indexed_dictionary:
+        return
+
+    max_name_len = max_name_length(when_indexed_dictionary, formatter)
+    max_name_len += 4
 
     indent = 4
-    for name in pkg.variant_names():
-        for when, variant in pkg.variant_definitions(name):
-            _fmt_variant(variant, max_name_default_len, indent, when, out=sys.stdout)
+
+    for subkey in spack.package_base._subkeys(when_indexed_dictionary):
+        for when, definition in spack.package_base._definitions(when_indexed_dictionary, subkey):
+            _fmt_definition(
+                formatter.format_name(definition),
+                formatter.format_values(definition),
+                formatter.format_description(definition),
+                max_name_len,
+                indent,
+                when=when,
+                out=sys.stdout,
+            )
             sys.stdout.write("\n")
 
 
 def print_variants(pkg, args):
     """output variants"""
-    if args.variants_by_name:
-        print_variants_by_name(pkg)
-    else:
-        print_variants_grouped_by_when(pkg)
+    print_fn = print_by_name if args.variants_by_name else print_grouped_by_when
+    print_fn("Variants", pkg.variants, VariantFormatter())
 
 
 def print_versions(pkg, args):
@@ -413,7 +505,7 @@ def print_versions(pkg, args):
     else:
         pad = padder(pkg.versions, 4)
 
-        preferred = preferred_version(pkg)
+        preferred = spack.package_base.preferred_version(pkg)
 
         def get_url(version):
             try:

lib/spack/spack/package_base.py

@@ -444,7 +444,7 @@ def _precedence(obj) -> int:
     """Get either a 'precedence' attribute or item from an object."""
     precedence = getattr(obj, "precedence", None)
     if precedence is None:
-        raise KeyError(f"Couldn't get precedence from {type(obj)}")
+        return 0  # raise KeyError(f"Couldn't get precedence from {type(obj)}")
     return precedence
 
 

lib/spack/spack/solver/asp.py

@@ -3005,10 +3005,6 @@ def setup(
 
         # Fail if we already know an unreachable node is requested
         for spec in specs:
-            # concrete roots don't need their dependencies verified
-            if spec.concrete:
-                continue
-
             missing_deps = [
                 str(d)
                 for d in spec.traverse()

lib/spack/spack/spec.py

@@ -663,9 +663,11 @@ def versions(self):
     def display_str(self):
         """Equivalent to {compiler.name}{@compiler.version} for Specs, without extra
         @= for readability."""
-        if self.versions != vn.any_version:
-            return self.spec.format("{name}{@version}")
-        return self.spec.format("{name}")
+        if self.spec.concrete:
+            return f"{self.name}@{self.version}"
+        elif self.versions != vn.any_version:
+            return f"{self.name}@{self.versions}"
+        return self.name
 
     def __lt__(self, other):
         if not isinstance(other, CompilerSpec):

lib/spack/spack/test/ci.py

@@ -32,7 +32,7 @@ def repro_dir(tmp_path):
 
 
 def test_get_added_versions_new_checksum(mock_git_package_changes):
-    repo, filename, commits = mock_git_package_changes
+    repo_path, filename, commits = mock_git_package_changes
 
     checksum_versions = {
         "3f6576971397b379d4205ae5451ff5a68edf6c103b2f03c4188ed7075fbb5f04": Version("2.1.5"),
@@ -41,7 +41,7 @@ def test_get_added_versions_new_checksum(mock_git_package_changes):
         "86993903527d9b12fc543335c19c1d33a93797b3d4d37648b5addae83679ecd8": Version("2.0.0"),
     }
 
-    with fs.working_dir(repo.packages_path):
+    with fs.working_dir(str(repo_path)):
         added_versions = ci.get_added_versions(
             checksum_versions, filename, from_ref=commits[-1], to_ref=commits[-2]
         )
@@ -50,7 +50,7 @@ def test_get_added_versions_new_checksum(mock_git_package_changes):
 
 
 def test_get_added_versions_new_commit(mock_git_package_changes):
-    repo, filename, commits = mock_git_package_changes
+    repo_path, filename, commits = mock_git_package_changes
 
     checksum_versions = {
         "74253725f884e2424a0dd8ae3f69896d5377f325": Version("2.1.6"),
@@ -60,9 +60,9 @@ def test_get_added_versions_new_commit(mock_git_package_changes):
         "86993903527d9b12fc543335c19c1d33a93797b3d4d37648b5addae83679ecd8": Version("2.0.0"),
     }
 
-    with fs.working_dir(repo.packages_path):
+    with fs.working_dir(str(repo_path)):
         added_versions = ci.get_added_versions(
-            checksum_versions, filename, from_ref=commits[-2], to_ref=commits[-3]
+            checksum_versions, filename, from_ref=commits[2], to_ref=commits[1]
         )
         assert len(added_versions) == 1
         assert added_versions[0] == Version("2.1.6")

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

@@ -1978,13 +1978,6 @@ def test_ci_validate_git_versions_invalid(
         assert f"Invalid commit for diff-test@{version}" in err
 
 
-def mock_packages_path(path):
-    def packages_path():
-        return path
-
-    return packages_path
-
-
 @pytest.fixture
 def verify_standard_versions_valid(monkeypatch):
     def validate_standard_versions(pkg, versions):
@@ -2031,12 +2024,9 @@ def test_ci_verify_versions_valid(
     mock_git_package_changes,
     verify_standard_versions_valid,
     verify_git_versions_valid,
-    tmpdir,
 ):
-    repo, _, commits = mock_git_package_changes
-    spack.repo.PATH.put_first(repo)
-
-    monkeypatch.setattr(spack.repo, "packages_path", mock_packages_path(repo.packages_path))
+    repo_path, _, commits = mock_git_package_changes
+    monkeypatch.setattr(spack.paths, "prefix", repo_path)
 
     out = ci_cmd("verify-versions", commits[-1], commits[-3])
     assert "Validated diff-test@2.1.5" in out
@@ -2050,10 +2040,9 @@ def test_ci_verify_versions_standard_invalid(
     verify_standard_versions_invalid,
     verify_git_versions_invalid,
 ):
-    repo, _, commits = mock_git_package_changes
-    spack.repo.PATH.put_first(repo)
+    repo_path, _, commits = mock_git_package_changes
 
-    monkeypatch.setattr(spack.repo, "packages_path", mock_packages_path(repo.packages_path))
+    monkeypatch.setattr(spack.paths, "prefix", repo_path)
 
     out = ci_cmd("verify-versions", commits[-1], commits[-3], fail_on_error=False)
     assert "Invalid checksum found diff-test@2.1.5" in out
@@ -2061,10 +2050,8 @@ def test_ci_verify_versions_standard_invalid(
 
 
 def test_ci_verify_versions_manual_package(monkeypatch, mock_packages, mock_git_package_changes):
-    repo, _, commits = mock_git_package_changes
-    spack.repo.PATH.put_first(repo)
-
-    monkeypatch.setattr(spack.repo, "packages_path", mock_packages_path(repo.packages_path))
+    repo_path, _, commits = mock_git_package_changes
+    monkeypatch.setattr(spack.paths, "prefix", repo_path)
 
     pkg_class = spack.spec.Spec("diff-test").package_class
     monkeypatch.setattr(pkg_class, "manual_download", True)

lib/spack/spack/test/cmd/create.py

@@ -62,7 +62,7 @@
         (
             ["-t", "intel", "/test-intel"],
             "test-intel",
-            [r"TestIntel(IntelOneApiPackage)", r"setup_environment"],
+            [r"TestIntel(IntelPackage)", r"setup_environment"],
         ),
         (
             ["-t", "makefile", "/test-makefile"],

lib/spack/spack/test/cmd/providers.py

@@ -24,6 +24,8 @@ def test_it_just_runs(pkg):
         (
             ("mpi",),
             [
+                "intel-mpi",
+                "intel-parallel-studio",
                 "mpich",
                 "mpilander",
                 "mvapich2",

lib/spack/spack/test/conftest.py

@@ -243,11 +243,13 @@ def latest_commit():
 
 
 @pytest.fixture
-def mock_git_package_changes(git, tmpdir, override_git_repos_cache_path, monkeypatch):
+def mock_git_package_changes(git, tmpdir, override_git_repos_cache_path):
     """Create a mock git repo with known structure of package edits
 
     The structure of commits in this repo is as follows::
 
+       o diff-test: modification to make manual download package
+       |
        o diff-test: add v1.2 (from a git ref)
        |
        o diff-test: add v1.1 (from source tarball)
@@ -259,12 +261,8 @@ def mock_git_package_changes(git, tmpdir, override_git_repos_cache_path, monkeyp
     Important attributes of the repo for test coverage are: multiple package
     versions are added with some coming from a tarball and some from git refs.
     """
-    filename = "diff-test/package.py"
-
-    repo_path, _ = spack.repo.create_repo(str(tmpdir.mkdir("myrepo")))
-    repo_cache = spack.util.file_cache.FileCache(str(tmpdir.mkdir("cache")))
-
-    repo = spack.repo.Repo(repo_path, cache=repo_cache)
+    repo_path = str(tmpdir.mkdir("git_package_changes_repo"))
+    filename = "var/spack/repos/builtin/packages/diff-test/package.py"
 
     def commit(message):
         global commit_counter
@@ -278,7 +276,7 @@ def commit(message):
         )
         commit_counter += 1
 
-    with working_dir(repo.packages_path):
+    with working_dir(repo_path):
         git("init")
 
         git("config", "user.name", "Spack")
@@ -309,11 +307,17 @@ def latest_commit():
         commit("diff-test: add v2.1.6")
         commits.append(latest_commit())
 
+        # convert pkg-a to a manual download package
+        shutil.copy2(f"{spack.paths.test_path}/data/conftest/diff-test/package-3.txt", filename)
+        git("add", filename)
+        commit("diff-test: modification to make manual download package")
+        commits.append(latest_commit())
+
         # The commits are ordered with the last commit first in the list
         commits = list(reversed(commits))
 
     # Return the git directory to install, the filename used, and the commits
-    yield repo, filename, commits
+    yield repo_path, filename, commits
 
 
 @pytest.fixture(autouse=True)

lib/spack/spack/test/data/conftest/diff-test/package-3.txt

@@ -0,0 +1,23 @@
+# Copyright Spack Project Developers. See COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+from spack.package import *
+
+
+class DiffTest(AutotoolsPackage):
+    """zlib replacement with optimizations for next generation systems."""
+
+    homepage = "https://github.com/zlib-ng/zlib-ng"
+    url = "https://github.com/zlib-ng/zlib-ng/archive/2.0.0.tar.gz"
+    git = "https://github.com/zlib-ng/zlib-ng.git"
+
+    license("Zlib")
+
+    manual_download = True
+
+    version("2.1.6", tag="2.1.6", commit="74253725f884e2424a0dd8ae3f69896d5377f325")
+    version("2.1.5", sha256="3f6576971397b379d4205ae5451ff5a68edf6c103b2f03c4188ed7075fbb5f04")
+    version("2.1.4", sha256="a0293475e6a44a3f6c045229fe50f69dc0eebc62a42405a51f19d46a5541e77a")
+    version("2.0.7", sha256="6c0853bb27738b811f2b4d4af095323c3d5ce36ceed6b50e5f773204fb8f7200")
+    version("2.0.0", sha256="86993903527d9b12fc543335c19c1d33a93797b3d4d37648b5addae83679ecd8")

lib/spack/spack/test/util/git.py

@@ -7,9 +7,9 @@
 
 
 def test_modified_files(mock_git_package_changes):
-    repo, filename, commits = mock_git_package_changes
+    repo_path, filename, commits = mock_git_package_changes
 
-    with working_dir(repo.packages_path):
+    with working_dir(repo_path):
         files = get_modified_files(from_ref="HEAD~1", to_ref="HEAD")
         assert len(files) == 1
         assert files[0] == filename

share/spack/gitlab/cloud_pipelines/stacks/ml-linux-x86_64-rocm/spack.yaml

@@ -27,8 +27,9 @@ spack:
     - py-transformers
 
     # JAX
-    - py-jax
-    - py-jaxlib
+    # Does not yet support Spack-installed ROCm
+    # - py-jax
+    # - py-jaxlib
 
     # Keras
     - py-keras backend=tensorflow

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

@@ -209,7 +209,7 @@ def configure_args(self):
         linalg = spec["lapack"].libs + spec["blas"].libs
 
         # linalg_flavor is selected using the virtual lapack provider
-        is_using_intel_libraries = spec["lapack"].name == "intel-oneapi-mkl"
+        is_using_intel_libraries = spec["lapack"].name in INTEL_MATH_LIBRARIES
 
         # These *must* be elifs, otherwise spack's lapack provider is ignored
         # linalg_flavor ends up as "custom", which is not supported by abinit@9.10.3:

var/spack/repos/builtin/packages/amr-wind/package.py

@@ -257,9 +257,6 @@ class AmrWind(CMakePackage, CudaPackage, ROCmPackage):
     depends_on("fftw", when="@2.1: +waves2amr")
     depends_on("fftw", when="@3.3.1: +fft")
 
-    depends_on("rocrand", when="+rocm")
-    depends_on("rocprim", when="+rocm")
-
     for arch in CudaPackage.cuda_arch_values:
         depends_on("hypre+cuda cuda_arch=%s" % arch, when="+cuda+hypre cuda_arch=%s" % arch)
     for arch in ROCmPackage.amdgpu_targets:

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

@@ -86,7 +86,7 @@ def cmake_args(self):
             ]
             args.append(self.define("CUDA_architecture_build_targets", arch_list))
 
-        if self.spec.satisfies("^[virtuals=blas] intel-oneapi-mkl"):
+        if self.spec["blas"].name in INTEL_MATH_LIBRARIES:
             if self.version >= Version("3.8.0"):
                 args.append(self.define("AF_COMPUTE_LIBRARY", "Intel-MKL"))
             else:

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

@@ -18,7 +18,6 @@ class Asio(AutotoolsPackage):
     license("BSL-1.0")
 
     # As uneven minor versions of asio are not considered stable, they wont be added anymore
-    version("1.34.0", sha256="061ed6c8b97527756aed3e34d2cbcbcb6d3c80afd26ed6304f51119e1ef6a1cd")
     version("1.32.0", sha256="f1b94b80eeb00bb63a3c8cef5047d4e409df4d8a3fe502305976965827d95672")
     version("1.30.2", sha256="755bd7f85a4b269c67ae0ea254907c078d408cce8e1a352ad2ed664d233780e8")
     version("1.30.1", sha256="94b121cc2016680f2314ef58eadf169c2d34fff97fba01df325a192d502d3a58")

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

@@ -52,7 +52,7 @@ def edit(self, spec, prefix):
         if spec["blas"].name == "openblas":
             env["OPENBLAS"] = "1"
 
-        elif spec.satisfies("^[virtuals=blas] intel-oneapi-mkl"):
+        elif spec["blas"].name in INTEL_MATH_LIBRARIES:
             env["MKL"] = "1"
             env["MKL_BASE"] = spec["mkl"].prefix.mkl
         else:

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

@@ -26,7 +26,7 @@ class Batchedblas(MakefilePackage):
     def edit(self, spec, prefix):
         CCFLAGS = [self.compiler.openmp_flag, "-I./", "-O3"]
         BLAS = ["-lm", spec["blas"].libs.ld_flags]
-        if not spec.satisfies("^[virtuals=blas] intel-oneapi-mkl"):
+        if spec["blas"].name not in INTEL_MATH_LIBRARIES:
             CCFLAGS.append("-D_CBLAS_")
         if spec.satisfies("%intel"):
             CCFLAGS.extend(["-Os"])

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

@@ -69,8 +69,7 @@ class Beatnik(CMakePackage, CudaPackage, ROCmPackage):
     conflicts("mpich ~cuda", when="+cuda")
     conflicts("mpich ~rocm", when="+rocm")
     conflicts("openmpi ~cuda", when="+cuda")
-    # Heffte won't build with intel MPI because of needed C++ MPI support
-    conflicts("^intel-oneapi-mpi")
+    conflicts("^intel-mpi")  # Heffte won't build with intel MPI because of needed C++ MPI support
     conflicts("^spectrum-mpi", when="^cuda@11.3:")  # cuda-aware spectrum is broken with cuda 11.3:
 
     # Propagate CUDA and AMD GPU targets to cabana

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

@@ -78,7 +78,12 @@ class Berkeleygw(MakefilePackage):
         depends_on("cray-fftw+openmp", when="^[virtuals=fftw-api] cray-fftw")
         depends_on("fftw+openmp", when="^[virtuals=fftw-api] fftw")
         depends_on("fujitsu-fftw+openmp", when="^[virtuals=fftw-api] fujitsu-fftw")
+        depends_on("intel-mkl threads=openmp", when="^[virtuals=fftw-api] intel-mkl")
         depends_on("intel-oneapi-mkl threads=openmp", when="^[virtuals=fftw-api] intel-oneapi-mkl")
+        depends_on(
+            "intel-parallel-studio threads=openmp",
+            when="^[virtuals=fftw-api] intel-parallel-studio",
+        )
 
     with when("~openmp"):
         depends_on("acfl threads=none", when="^[virtuals=fftw-api] acfl")
@@ -87,7 +92,11 @@ class Berkeleygw(MakefilePackage):
         depends_on("cray-fftw~openmp", when="^[virtuals=fftw-api] cray-fftw")
         depends_on("fftw~openmp", when="^[virtuals=fftw-api] fftw")
         depends_on("fujitsu-fftw~openmp", when="^[virtuals=fftw-api] fujitsu-fftw")
+        depends_on("intel-mkl threads=none", when="^[virtuals=fftw-api] intel-mkl")
         depends_on("intel-oneapi-mkl threads=none", when="^[virtuals=fftw-api] intel-oneapi-mkl")
+        depends_on(
+            "intel-parallel-studio threads=none", when="^[virtuals=fftw-api] intel-parallel-studio"
+        )
 
     # in order to run the installed python scripts
     depends_on("python", type=("build", "run"), when="+python")

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

@@ -1,53 +0,0 @@
-# Copyright Spack Project Developers. See COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-from spack.package import *
-
-
-class Bigwhoop(CMakePackage):
-    """BigWhoop is a lossy compression algorithm for numerical
-    datasets from HPC engineering applications.
-    """
-
-    homepage = "https://github.com/ptvogler/BigWhoop"
-    url = "https://github.com/ptvogler/BigWhoop/archive/refs/tags/v0.2.0.tar.gz"
-    git = "https://github.com/ptvogler/BigWhoop.git"
-
-    maintainers("ptvogler", "gregorweiss")
-
-    license("BSD-2-Clause", checked_by="ptvogler")
-
-    version("main", branch="main")
-    version("0.2.0", sha256="48e6aeaf9c6d39c18c030397e0cb46c43491cbf64400dda1efb4293696716692")
-
-    depends_on("c", type="build")
-    depends_on("fortran", type="build")
-
-    depends_on("cmake@3.5.1:", type="build")
-    depends_on("python", type="build")
-
-    # Build targets
-    variant("shared", default=True, description="Build shared libraries")
-    variant("utilities", default=False, description="Build bigwhoop utilities")
-
-    # Execution policies
-    variant("openmp", default=True, description="Enable OpenMP execution")
-
-    # Advanced settings
-    variant("profiling", default=False, description="Enable profiling")
-    variant("precision", default="Double", description="Enable double precision")
-
-    # CMake options
-    def cmake_args(self):
-        spec = self.spec
-
-        args = [
-            self.define_from_variant("BUILD_SHARED_LIBS", "shared"),
-            self.define_from_variant("BUILD_UTILITIES", "utilities"),
-            self.define_from_variant("BIGWHOOP_WITH_OPENMP", "openmp"),
-            self.define_from_variant("BIGWHOOP_WITH_PROFILING", "profiling"),
-            self.define("BIGWHOOP_PRECISION", spec.variants["precision"].value),
-        ]
-
-        return args

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

@@ -89,20 +89,17 @@ def cosma_blas_cmake_arg(self):
         query_to_cmake_arg = [
             ("+cuda", "CUDA"),
             ("+rocm", "ROCM"),
-            ("^[virtuals=blas] intel-oneapi-mkl", "MKL"),
-            ("^[virtuals=blas] cray-libsci", "CRAY_LIBSCI"),
-            ("^[virtuals=blas] netlib-lapack", "CUSTOM"),
-            ("^[virtuals=blas] openblas", "OPENBLAS"),
-            ("^[virtuals=blas] fujitsu-ssl2", "SSL2"),
+            ("^intel-mkl", "MKL"),
+            ("^intel-oneapi-mkl", "MKL"),
+            ("^cray-libsci", "CRAY_LIBSCI"),
+            ("^netlib-lapack", "CUSTOM"),
+            ("^openblas", "OPENBLAS"),
+            ("^fujitsu-ssl2", "SSL2"),
         ]
 
         if self.version >= Version("2.4.0"):
             query_to_cmake_arg.extend(
-                [
-                    ("^[virtuals=blas] blis", "BLIS"),
-                    ("^[virtuals=blas] amdblis", "BLIS"),
-                    ("^[virtuals=blas] atlas", "ATLAS"),
-                ]
+                [("^blis", "BLIS"), ("^amdblis", "BLIS"), ("^atlas", "ATLAS")]
             )
 
         for query, cmake_arg in query_to_cmake_arg:
@@ -116,7 +113,7 @@ def cosma_scalapack_cmake_arg(self):
 
         if spec.satisfies("~scalapack"):
             return "OFF"
-        elif spec.satisfies("^[virtuals=scalapack] intel-oneapi-mkl"):
+        elif spec.satisfies("^intel-mkl") or spec.satisfies("^intel-oneapi-mkl"):
             return "MKL"
         elif spec.satisfies("^cray-libsci"):
             return "CRAY_LIBSCI"

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

@@ -58,9 +58,9 @@ def costa_scalapack_cmake_arg(self):
 
         if spec.satisfies("~scalapack"):
             return "OFF"
-        elif spec.satisfies("^[virtuals=scalapack] intel-oneapi-mkl"):
+        elif spec.satisfies("^intel-mkl") or spec.satisfies("^intel-oneapi-mkl"):
             return "MKL"
-        elif spec.satisfies("^[virtuals=scalapack] cray-libsci"):
+        elif spec.satisfies("^cray-libsci"):
             return "CRAY_LIBSCI"
 
         return "CUSTOM"

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

@@ -495,7 +495,7 @@ def edit(self, pkg, spec, prefix):
         }
 
         dflags = ["-DNDEBUG"] if spec.satisfies("@:2023.2") else []
-        if fftw.name == "intel-oneapi-mkl":
+        if fftw.name in ("intel-mkl", "intel-parallel-studio", "intel-oneapi-mkl"):
             cppflags = ["-D__FFTW3_MKL", "-I{0}".format(fftw_header_dir)]
         else:
             cppflags = ["-D__FFTW3", "-I{0}".format(fftw_header_dir)]
@@ -705,7 +705,7 @@ def edit(self, pkg, spec, prefix):
         if spec.satisfies("platform=darwin"):
             cppflags.extend(["-D__NO_STATM_ACCESS"])
 
-        if spec["blas"].name == "intel-oneapi-mkl":
+        if spec["blas"].name in ("intel-mkl", "intel-parallel-studio", "intel-oneapi-mkl"):
             cppflags += ["-D__MKL"]
         elif spec["blas"].name == "accelerate":
             cppflags += ["-D__ACCELERATE"]
@@ -725,6 +725,8 @@ def edit(self, pkg, spec, prefix):
             else:
                 mpi = spec["mpi:cxx"].libs
 
+            # while intel-mkl has a mpi variant and adds the scalapack
+            # libs to its libs, intel-oneapi-mkl does not.
             if spec["scalapack"].name == "intel-oneapi-mkl":
                 mpi_impl = "openmpi" if spec["mpi"].name in ["openmpi", "hpcx-mpi"] else "intelmpi"
                 scalapack = [
@@ -1096,7 +1098,7 @@ def cmake_args(self):
         lapack = spec["lapack"]
         blas = spec["blas"]
 
-        if blas.name == "intel-oneapi-mkl":
+        if blas.name in ["intel-mkl", "intel-parallel-studio", "intel-oneapi-mkl"]:
             args += ["-DCP2K_BLAS_VENDOR=MKL"]
             if sys.platform == "darwin":
                 args += [

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

@@ -43,7 +43,7 @@ def url_for_version(self, version):
     def configure_args(self):
         config_args = []
 
-        if self.spec.satisfies("^[virtuals=fftw-api] intel-oneapi-mkl"):
+        if self.spec["fftw-api"].name in INTEL_MATH_LIBRARIES:
             config_args.extend(
                 [
                     "--enable-mkl",

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

@@ -388,13 +388,9 @@ class Dealii(CMakePackage, CudaPackage):
 
     # Check that the combination of variants makes sense
     # 64-bit BLAS:
+    for _package in ["openblas", "intel-mkl", "intel-parallel-studio+mkl"]:
         conflicts(
-        "^[virtuals=lapack] openblas+ilp64",
-        when="@:8.5.1",
-        msg="64bit BLAS is only supported from 9.0.0",
-    )
-    conflicts(
-        "^[virtuals=lapack] intel-oneapi-mkl+ilp64",
+            "^{0}+ilp64".format(_package),
             when="@:8.5.1",
             msg="64bit BLAS is only supported from 9.0.0",
         )
@@ -509,8 +505,10 @@ def cmake_args(self):
         # 64 bit indices
         options.append(self.define_from_variant("DEAL_II_WITH_64BIT_INDICES", "int64"))
 
-        if spec.satisfies("^[virtuals=lapack] openblas+ilp64") or spec.satisfies(
-            "^[virtuals=lapack] intel-oneapi-mkl+ilp64"
+        if (
+            spec.satisfies("^openblas+ilp64")
+            or spec.satisfies("^intel-mkl+ilp64")
+            or spec.satisfies("^intel-parallel-studio+mkl+ilp64")
         ):
             options.append(self.define("LAPACK_WITH_64BIT_BLAS_INDICES", True))
 
@@ -572,8 +570,19 @@ def cmake_args(self):
             options.append(self.define_from_variant("DEAL_II_WITH_TBB", "threads"))
         else:
             options.append(self.define_from_variant("DEAL_II_WITH_THREADS", "threads"))
-
         if spec.satisfies("+threads"):
+            if spec.satisfies("^intel-parallel-studio+tbb"):
+                # deal.II/cmake will have hard time picking up TBB from Intel.
+                tbb_ver = ".".join(("%s" % spec["tbb"].version).split(".")[1:])
+                options.extend(
+                    [
+                        self.define("TBB_FOUND", True),
+                        self.define("TBB_VERSION", tbb_ver),
+                        self.define("TBB_INCLUDE_DIRS", ";".join(spec["tbb"].headers.directories)),
+                        self.define("TBB_LIBRARIES", spec["tbb"].libs.joined(";")),
+                    ]
+                )
+            else:
                 options.append(self.define("TBB_DIR", spec["tbb"].prefix))
 
         # Optional dependencies for which library names are the same as CMake

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

@@ -182,41 +182,71 @@ def cmake_args(self):
         args.append(self.define_from_variant("BUILD_SHARED_LIBS", "shared"))
 
         # BLAS/LAPACK
-        if spec.version <= Version("0.4") and spec.satisfies(
-            "^[virtuals=lapack] intel-oneapi-mkl"
-        ):
+        if spec.version <= Version("0.4") and spec["lapack"].name in INTEL_MATH_LIBRARIES:
             mkl_provider = spec["lapack"].name
 
             vmap = {
-                "threading": {"none": "sequential", "openmp": "gnu_thread", "tbb": "tbb_thread"},
-                "mpi": {"intel-oneapi-mpi": "intelmpi", "mpich": "mpich", "openmpi": "openmpi"},
+                "intel-oneapi-mkl": {
+                    "threading": {
+                        "none": "sequential",
+                        "openmp": "gnu_thread",
+                        "tbb": "tbb_thread",
+                    },
+                    "mpi": {"intel-mpi": "intelmpi", "mpich": "mpich", "openmpi": "openmpi"},
+                },
+                "intel-mkl": {
+                    "threading": {"none": "seq", "openmp": "omp", "tbb": "tbb"},
+                    "mpi": {"intel-mpi": "mpich", "mpich": "mpich", "openmpi": "ompi"},
+                },
             }
 
-            mkl_threads = vmap["threading"][spec["intel-oneapi-mkl"].variants["threads"].value]
+            if mkl_provider not in vmap.keys():
+                raise RuntimeError(
+                    f"dla-future does not support {mkl_provider} as lapack provider"
+                )
+            mkl_mapper = vmap[mkl_provider]
+
+            mkl_threads = mkl_mapper["threading"][spec[mkl_provider].variants["threads"].value]
+            if mkl_provider == "intel-oneapi-mkl":
                 args += [
                     self.define("DLAF_WITH_MKL", True),
                     self.define("MKL_INTERFACE", "lp64"),
                     self.define("MKL_THREADING", mkl_threads),
                 ]
+            elif mkl_provider == "intel-mkl":
+                args += [
+                    (
+                        self.define("DLAF_WITH_MKL", True)
+                        if spec.version <= Version("0.3")
+                        else self.define("DLAF_WITH_MKL_LEGACY", True)
+                    ),
+                    self.define("MKL_LAPACK_TARGET", f"mkl::mkl_intel_32bit_{mkl_threads}_dyn"),
+                ]
 
             if spec.satisfies("+scalapack"):
                 try:
                     mpi_provider = spec["mpi"].name
                     if mpi_provider in ["mpich", "cray-mpich", "mvapich", "mvapich2"]:
-                        mkl_mpi = vmap["mpi"]["mpich"]
+                        mkl_mpi = mkl_mapper["mpi"]["mpich"]
                     else:
-                        mkl_mpi = vmap["mpi"][mpi_provider]
+                        mkl_mpi = mkl_mapper["mpi"][mpi_provider]
                 except KeyError:
                     raise RuntimeError(
                         f"dla-future does not support {spec['mpi'].name} as mpi provider with "
                         f"the selected scalapack provider {mkl_provider}"
                     )
 
+                if mkl_provider == "intel-oneapi-mkl":
                     args.append(self.define("MKL_MPI", mkl_mpi))
-        else:
+                elif mkl_provider == "intel-mkl":
                     args.append(
-                self.define("DLAF_WITH_MKL", spec.satisfies("^[virtuals=lapack] intel-oneapi-mkl"))
+                        self.define(
+                            "MKL_SCALAPACK_TARGET",
+                            f"mkl::scalapack_{mkl_mpi}_intel_32bit_{mkl_threads}_dyn",
                         )
+                    )
+        else:
+            args.append(self.define("DLAF_WITH_MKL", spec["lapack"].name in INTEL_MATH_LIBRARIES))
             add_dlaf_prefix = lambda x: x if spec.satisfies("@:0.6") else "DLAF_" + x
             args.append(
                 self.define(

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

@@ -63,6 +63,7 @@ class Dyninst(CMakePackage):
         # package layout. Need to use tbb provided config instead.
         conflicts("^intel-tbb@2021.1:")
         conflicts("^intel-oneapi-tbb@2021.1:")
+        conflicts("^intel-parallel-studio")
 
     depends_on("tbb")
     requires("^[virtuals=tbb] intel-tbb@2019.9:", when="@13.0.0:")

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

@@ -81,7 +81,11 @@ class Elk(MakefilePackage):
 
     depends_on("mkl", when="linalg=mkl")
     with when("linalg=mkl +openmp"):
+        depends_on("intel-mkl threads=openmp", when="^[virtuals=mkl] intel-mkl")
         depends_on("intel-oneapi-mkl threads=openmp", when="^[virtuals=mkl] intel-oneapi-mkl")
+        depends_on(
+            "intel-parallel-studio threads=openmp", when="^[virtuals=mkl] intel-parallel-studio"
+        )
 
     depends_on("openblas", when="linalg=openblas")
     depends_on("openblas threads=openmp", when="linalg=openblas +openmp")
@@ -196,6 +200,8 @@ def edit(self, spec, prefix):
                 config["SRC_FFT"] += " cfftifc_mkl.f90"
             cp = which("cp")
             mkl_prefix = spec["mkl"].prefix
+            if spec.satisfies("^intel-mkl"):
+                mkl_prefix = mkl_prefix.mkl
             cp(
                 join_path(mkl_prefix.include, "mkl_dfti.f90"),
                 join_path(self.build_directory, "src"),

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

@@ -69,7 +69,7 @@ def cmake_args(self):
         else:
             args.append("-DWITH_MPI=OFF")
 
-        if self.spec.satisfies("^[virtuals=lapack] intel-oneapi-mkl"):
+        if self.spec.satisfies("^intel-mkl"):
             args.append("-DWITH_MKL:BOOL=TRUE")
 
         if spec.satisfies("+openmp"):

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

@@ -93,9 +93,14 @@ class Elpa(AutotoolsPackage, CudaPackage, ROCmPackage):
     # https://gitlab.mpcdf.mpg.de/elpa/elpa/-/blob/master/documentation/PERFORMANCE_TUNING.md?ref_type=heads#builds-with-openmp-enabled
     with when("+openmp"):
         requires("^openblas threads=openmp", when="^[virtuals=blas,lapack] openblas")
+        requires("^intel-mkl threads=openmp", when="^[virtuals=blas,lapack] intel-mkl")
         requires(
             "^intel-oneapi-mkl threads=openmp", when="^[virtuals=blas,lapack] intel-oneapi-mkl"
         )
+        requires(
+            "^intel-parallel-studio threads=openmp",
+            when="^[virtuals=blas,lapack] intel-parallel-studio",
+        )
 
     # fails to build due to broken type-bound procedures in OMP parallel regions
     conflicts(

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

@@ -24,7 +24,6 @@ class Ensmallen(CMakePackage):
     version("2.21.1", sha256="820eee4d8aa32662ff6a7d883a1bcaf4e9bf9ca0a3171d94c5398fe745008750")
     version("2.19.1", sha256="f36ad7f08b0688d2a8152e1c73dd437c56ed7a5af5facf65db6ffd977b275b2e")
 
-    depends_on("c", type="build")
     depends_on("cxx", type="build")
 
     variant("openmp", default=True, description="Use OpenMP for parallelization")

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

@@ -343,7 +343,11 @@ def setup_build_environment(self, env):
                 "^[virtuals=mpi] hpcx-mpi"
             ):
                 env.set("ESMF_COMM", "openmpi")
-            elif spec.satisfies("^[virtuals=mpi] intel-oneapi-mpi"):
+            elif (
+                spec.satisfies("^[virtuals=mpi] intel-parallel-studio+mpi")
+                or spec.satisfies("^[virtuals=mpi] intel-mpi")
+                or spec.satisfies("^[virtuals=mpi] intel-oneapi-mpi")
+            ):
                 env.set("ESMF_COMM", "intelmpi")
             elif spec.satisfies("^[virtuals=mpi] mpt"):
                 # MPT is the HPE (SGI) variant of mpich

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

@@ -30,15 +30,21 @@ class Exabayes(AutotoolsPackage):
     # GCC 7.1.0 is used.
     conflicts("%gcc@:4.5.4, 7.1.0:", when="@:1.5.0")
     conflicts("%clang@:3.1")
-    conflicts("^intel-oneapi-mpi", when="+mpi")
+    conflicts("^intel-mpi", when="+mpi")
+    conflicts("^intel-parallel-studio+mpi", when="+mpi")
     conflicts("^mvapich2", when="+mpi")
     conflicts("^spectrum-mpi", when="+mpi")
 
     def configure_args(self):
-        return self.enable_or_disable("mpi")
+        args = []
+        if self.spec.satisfies("+mpi"):
+            args.append("--enable-mpi")
+        else:
+            args.append("--disable-mpi")
+        return args
 
     def flag_handler(self, name, flags):
         if name.lower() == "cxxflags":
             # manual cites need for c++11
             flags.append(self.compiler.cxx11_flag)
-        return flags, None, None
+        return (flags, None, None)

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

@@ -42,8 +42,11 @@ class Exciting(MakefilePackage):
     depends_on("mkl", when="+mkl")
     depends_on("mpi", when="+mpi")
     depends_on("scalapack", when="+scalapack")
+    # conflicts('%gcc@10:', msg='exciting cannot be built with GCC 10')
 
-    conflicts("%intel")
+    requires("%intel", when="^mkl", msg="Intel MKL only works with the Intel compiler")
+    requires("%intel", when="^intel-mkl", msg="Intel MKL only works with the Intel compiler")
+    requires("%intel", when="^intel-mpi", msg="Intel MPI only works with the Intel compiler")
 
     def patch(self):
         """Fix bad logic in m_makespectrum.f90 for the Oxygen release"""

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

@@ -44,7 +44,10 @@ class Fds(MakefilePackage):
     )
 
     requires(
-        "^intel-oneapi-mkl", policy="one_of", msg="FDS builds require Intel oneAPI MKL library"
+        "^intel-mkl",
+        "^intel-oneapi-mkl",
+        policy="one_of",
+        msg="FDS builds require either Intel MKL or Intel oneAPI MKL library",
     )
 
     requires(
@@ -53,6 +56,12 @@ class Fds(MakefilePackage):
         msg="OpenMPI can only be used with GNU Fortran on Linux platform",
     )
 
+    requires(
+        "^intel-mpi^intel-mkl",
+        when="platform=linux %intel",
+        msg="Intel MPI and Intel MKL can only be used with Intel Fortran on Linux platform",
+    )
+
     requires(
         "^intel-oneapi-mpi^intel-oneapi-mkl",
         when="platform=linux %oneapi",
@@ -76,7 +85,7 @@ def edit(self, spec, prefix):
     @property
     def build_targets(self):
         spec = self.spec
-        mpi_mapping = {"openmpi": "ompi", "intel-oneapi-mpi": "impi"}
+        mpi_mapping = {"openmpi": "ompi", "intel-oneapi-mpi": "impi", "intel-mpi": "impi"}
         compiler_mapping = {"gcc": "gnu", "oneapi": "intel", "intel": "intel"}
         platform_mapping = {"linux": "linux", "darwin": "osx"}
         mpi_prefix = mpi_mapping[spec["mpi"].name]

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

@@ -7,7 +7,7 @@
 
 
 class G4tendl(Package):
-    """Optional Geant4 data for incident particles."""
+    """Geant4 data for incident particles [optional]"""
 
     homepage = "https://geant4.web.cern.ch"
     url = "https://geant4-data.web.cern.ch/geant4-data/datasets/G4TENDL.1.3.tar.gz"

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

@@ -142,7 +142,7 @@ class Gaudi(CMakePackage, CudaPackage):
     #       ROOT does not like being exposed to LLVM symbols.
 
     # The Intel VTune dependency is taken aside because it requires a license
-    depends_on("intel-oneapi-vtune", when="+vtune")
+    depends_on("intel-parallel-studio -mpi +vtune", when="+vtune")
 
     def patch(self):
         # ensure an empty pytest.ini is present to prevent finding one

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

@@ -21,7 +21,6 @@ class Geant4(CMakePackage):
 
     maintainers("drbenmorgan", "sethrj")
 
-    version("11.3.1", sha256="9059da076928f25cab1ff1f35e0f611a4d7fe005e374e9b8d7f3ff2434b7af54")
     version("11.3.0", sha256="d9d71daff8890a7b5e0e33ea9a65fe6308ad6713000b43ba6705af77078e7ead")
     version("11.2.2", sha256="3a8d98c63fc52578f6ebf166d7dffaec36256a186d57f2520c39790367700c8d")
     version("11.2.1", sha256="76c9093b01128ee2b45a6f4020a1bcb64d2a8141386dea4674b5ae28bcd23293")

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

@@ -41,7 +41,7 @@ class Gearshifft(CMakePackage):
     depends_on("clfft@2.12.0:", when="+clfft")
     depends_on("fftw@3.3.4:~mpi~openmp", when="+fftw~openmp")
     depends_on("fftw@3.3.4:~mpi+openmp", when="+fftw+openmp")
-    depends_on("intel-oneapi-mkl threads=openmp", when="+mkl")
+    depends_on("intel-mkl threads=openmp", when="+mkl")
     depends_on("rocfft", when="+rocfft")
 
     def cmake_args(self):

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

@@ -15,8 +15,6 @@ class Glab(GoPackage):
 
     license("MIT")
 
-    version("1.55.0", sha256="21f58698b92035461e8e8ba9040429f4b5a0f6d528d8333834ef522a973384c8")
-    version("1.54.0", sha256="99f5dd785041ad26c8463ae8630e98a657aa542a2bb02333d50243dd5cfdf9cb")
     version("1.53.0", sha256="2930aa5dd76030cc6edcc33483bb49dd6a328eb531d0685733ca7be7b906e915")
     version("1.52.0", sha256="585495e53d3994172fb927218627b7470678bc766320cb52f4b4204238677dde")
     version("1.51.0", sha256="6a95d827004fee258aacb49a427875e3b505b063cc578933d965cd56481f5a19")
@@ -36,38 +34,20 @@ class Glab(GoPackage):
     version("1.21.1", sha256="8bb35c5cf6b011ff14d1eaa9ab70ec052d296978792984250e9063b006ee4d50")
     version("1.20.0", sha256="6beb0186fa50d0dea3b05fcfe6e4bc1f9be0c07aa5fa15b37ca2047b16980412")
 
-    with default_args(type="build"):
-        depends_on("go@1.24.1:", when="@1.54:")
-        depends_on("go@1.23.4:", when="@1.52:")
-        depends_on("go@1.23.2:", when="@1.48:")
-        depends_on("go@1.23.0:", when="@1.46:")
-        depends_on("go@1.22.5:", when="@1.44:")
-        depends_on("go@1.22.4:", when="@1.42:")
-        depends_on("go@1.22.3:", when="@1.41:")
-        depends_on("go@1.21.0:", when="@1.37:")
-        depends_on("go@1.19.0:", when="@1.35:")
-        depends_on("go@1.18.0:", when="@1.23:")
-        depends_on("go@1.17.0:", when="@1.22:")
-        depends_on("go@1.13.0:")
+    depends_on("go@1.13:", type="build")
+    depends_on("go@1.17:", type="build", when="@1.22:")
+    depends_on("go@1.18:", type="build", when="@1.23:")
+    depends_on("go@1.19:", type="build", when="@1.35:")
+    depends_on("go@1.21:", type="build", when="@1.37:")
+    depends_on("go@1.22.3:", type="build", when="@1.41:")
+    depends_on("go@1.22.4:", type="build", when="@1.42:")
+    depends_on("go@1.22.5:", type="build", when="@1.44:")
+    depends_on("go@1.23:", type="build", when="@1.46:")
+    depends_on("go@1.23.2:", type="build", when="@1.48:")
+    depends_on("go@1.23.4:", type="build", when="@1.52:")
 
     build_directory = "cmd/glab"
 
-    # Required to correctly set the version
-    # https://gitlab.com/gitlab-org/cli/-/blob/v1.55.0/Makefile?ref_type=tags#L44
-    @property
-    def build_args(self):
-        extra_ldflags = [f"-X 'main.version=v{self.version}'"]
-
-        args = super().build_args
-
-        if "-ldflags" in args:
-            ldflags_index = args.index("-ldflags") + 1
-            args[ldflags_index] = args[ldflags_index] + " " + " ".join(extra_ldflags)
-        else:
-            args.extend(["-ldflags", " ".join(extra_ldflags)])
-
-        return args
-
     @run_after("install")
     def install_completions(self):
         glab = Executable(self.prefix.bin.glab)

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

@@ -75,25 +75,24 @@ def configure_args(self):
         spec = self.spec
         args = ["--with-gmp", "--with-mpfr"]
 
-        if spec.satisfies("^[virtuals=lapack] intel-oneapi-mkl") or spec.satisfies(
-            "^[virtuals=fftw-api] intel-oneapi-mkl"
-        ):
+        if spec.satisfies("^intel-mkl"):
+            if spec.satisfies("+fftw") or spec.satisfies("+lapack"):
                 args.append("--enable-mkl")
         else:
             if spec.satisfies("+fftw"):
-                args.append(f"--with-fftw={self.spec['fftw-api'].prefix}")
+                args.append("--with-fftw={0}".format(self.spec["fftw-api"].prefix))
             if spec.satisfies("+lapack"):
-                args.append(f"--enable-lapack={self.spec['lapack'].prefix}")
+                args.append("--enable-lapack={0}".format(self.spec["lapack"].prefix))
                 # lapack is searched only as `-llapack`, so anything else
                 # wouldn't be found, causing an error.
-                args.append(f"LIBS={self.spec['lapack'].libs.ld_flags}")
+                args.append("LIBS={0}".format(self.spec["lapack"].libs.ld_flags))
 
         if "comms=none" not in spec:
             # The build system can easily get very confused about MPI support
             # and what linker to use.  In many case it'd end up building the
             # code with support for MPI but without using `mpicxx` or linking to
             # `-lmpi`, wreaking havoc.  Forcing `CXX` to be mpicxx should help.
-            args.extend([f"CC={spec['mpi'].mpicc}", f"CXX={spec['mpi'].mpicxx}"])
+            args.extend(["CC={0}".format(spec["mpi"].mpicc), "CXX={0}".format(spec["mpi"].mpicxx)])
 
         args += self.enable_or_disable("timers")
         args += self.enable_or_disable("chroma")
@@ -120,11 +119,11 @@ def configure_args(self):
             args.extend(
                 [
                     "--enable-simd=GEN",
-                    f"--enable-gen-simd-width={spec.variants['gen-simd-width'].value}",
+                    "--enable-gen-simd-width={0}".format(spec.variants["gen-simd-width"].value),
                 ]
             )
 
-        args.append(f"--enable-comms={spec.variants['comms'].value}")
-        args.append(f"--enable-rng={spec.variants['rng'].value}")
+        args.append("--enable-comms={0}".format(spec.variants["comms"].value))
+        args.append("--enable-rng={0}".format(spec.variants["rng"].value))
 
         return args

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

@@ -529,8 +529,9 @@ class Gromacs(CMakePackage, CudaPackage):
     )
 
     # If the Intel suite is used for Lapack, it must be used for fftw and vice-versa
-    requires("^[virtuals=fftw-api] intel-oneapi-mkl", when="^[virtuals=lapack] intel-oneapi-mkl")
-    requires("^[virtuals=lapack] intel-oneapi-mkl", when="^[virtuals=fftw-api] intel-oneapi-mkl")
+    for _intel_pkg in INTEL_MATH_LIBRARIES:
+        requires(f"^[virtuals=fftw-api] {_intel_pkg}", when=f"^[virtuals=lapack]   {_intel_pkg}")
+        requires(f"^[virtuals=lapack]   {_intel_pkg}", when=f"^[virtuals=fftw-api] {_intel_pkg}")
 
     patch("gmxDetectCpu-cmake-3.14.patch", when="@2018:2019.3^cmake@3.14.0:")
     patch("gmxDetectSimd-cmake-3.14.patch", when="@5.0:2017^cmake@3.14.0:")
@@ -910,8 +911,9 @@ def cmake_args(self):
             )
             options.append(f"-DNVSHMEM_ROOT={nvshmem_root}")
 
-        if self.spec.satisfies("^[virtuals=lapack] intel-oneapi-mkl"):
-            # fftw-api@3 is provided by intel-oneapi-mkl
+        if self.spec["lapack"].name in INTEL_MATH_LIBRARIES:
+            # fftw-api@3 is provided by intel-mkl or intel-parallel-studio
+            # we use the mkl interface of gromacs
             options.append("-DGMX_FFT_LIBRARY=mkl")
             if self.spec.satisfies("@:2022"):
                 options.append(

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

@@ -37,11 +37,14 @@ class Gsibec(CMakePackage):
 
     depends_on("lapack", type=("build", "run"))
 
-    depends_on("ecbuild", type="build")
-    depends_on("jedi-cmake", type="build")
-    depends_on("sp", type="build")
+    depends_on("ecbuild", type=("build"))
+    depends_on("jedi-cmake", type=("build"))
+    depends_on("sp", type=("build"))
 
     def cmake_args(self):
-        return [
-            self.define("ENABLE_MKL", self.spec.satisfies("^[virtuals=lapack] intel-oneapi-mkl"))
-        ]
+        args = []
+
+        mkl_providers = ["intel-mkl", "intel-oneapi-mkl", "intel-parallel-studio"]
+        args.append(self.define("ENABLE_MKL", self.spec["lapack"].name in mkl_providers))
+
+        return args

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

@@ -12,7 +12,6 @@ class Gslib(Package):
     git = "https://github.com/gslib/gslib.git"
 
     version("develop", branch="master")
-    version("1.0.9", tag="v1.0.9", commit="95acf5b42301d6cb48fda88d662f1d784b863089")
     version("1.0.7", tag="v1.0.7", commit="88f90cb96953527e3e833f8dbf2719273fc8346d")
     version("1.0.6", tag="v1.0.6", commit="1c2f74420fec36d5abe1d75f194a457c61f0df53")
     version("1.0.5", tag="v1.0.5", commit="1de2fba1d94e27e20f3bc3af6a3a35901e223ecd")

var/spack/repos/builtin/packages/gtk-doc/package.py

@@ -14,14 +14,12 @@ class GtkDoc(AutotoolsPackage):
     pdf/man-pages with some extra work."""
 
     homepage = "https://wiki.gnome.org/DocumentationProject/GtkDoc"
-    url = "https://download.gnome.org/sources/gtk-doc/1.33/gtk-doc-1.33.2.tar.xz"
-    list_url = "https://download.gnome.org/sources/gtk-doc/"
-    list_depth = 1
+    url = "https://gitlab.gnome.org/GNOME/gtk-doc/-/archive/1.33.2/gtk-doc-1.33.2.tar.gz"
 
     license("GPL-2.0-or-later AND GFDL-1.1-or-later")
 
-    version("1.33.2", sha256="cc1b709a20eb030a278a1f9842a362e00402b7f834ae1df4c1998a723152bf43")
-    version("1.32", sha256="de0ef034fb17cb21ab0c635ec730d19746bce52984a6706e7bbec6fb5e0b907c")
+    version("1.33.2", sha256="2d1b0cbd26edfcb54694b2339106a02a81d630a7dedc357461aeb186874cc7c0")
+    version("1.32", sha256="0890c1f00d4817279be51602e67c4805daf264092adc58f9c04338566e8225ba")
 
     depends_on("c", type="build")  # generated
 
@@ -62,8 +60,14 @@ def installcheck(self):
         pass
 
     def url_for_version(self, version):
-        url = "https://download.gnome.org/sources/gtk-doc/{0}/gtk-doc-{1}.tar.xz"
-        return url.format(version.up_to(2), version)
+        """Handle gnome's version-based custom URLs."""
+
+        if version <= Version("1.32"):
+            url = "https://gitlab.gnome.org/GNOME/gtk-doc/-/archive/GTK_DOC_{0}/gtk-doc-GTK_DOC_{0}.tar.gz"
+            return url.format(version.underscored)
+
+        url = "https://gitlab.gnome.org/GNOME/gtk-doc/-/archive/{0}/gtk-doc-{0}.tar.gz"
+        return url.format(version)
 
     def configure_args(self):
         args = ["--with-xml-catalog={0}".format(self["docbook-xml"].catalog)]

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

@@ -45,16 +45,11 @@ class Hdf5(CMakePackage):
 
     # Odd versions are considered experimental releases
     # Even versions are maintenance versions
-    version(
-        "1.14.6",
-        sha256="e4defbac30f50d64e1556374aa49e574417c9e72c6b1de7a4ff88c4b1bea6e9b",
-        url="https://support.hdfgroup.org/releases/hdf5/v1_14/v1_14_6/downloads/hdf5-1.14.6.tar.gz",
-        preferred=True,
-    )
     version(
         "1.14.5",
         sha256="ec2e13c52e60f9a01491bb3158cb3778c985697131fc6a342262d32a26e58e44",
         url="https://support.hdfgroup.org/releases/hdf5/v1_14/v1_14_5/downloads/hdf5-1.14.5.tar.gz",
+        preferred=True,
     )
     version(
         "1.14.4-3",

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

@@ -120,8 +120,9 @@ def edit(self, spec, prefix):
                 lin_alg_libs.append(join_path(spec["fftw-api"].prefix.lib, "libsfftw_mpi.so"))
                 lin_alg_libs.append(join_path(spec["fftw-api"].prefix.lib, "libsfftw.so"))
 
-            elif self.spec.variants["fft"].value == "mkl" and spec.satisfies(
-                "^[virtuals=fftw-api] intel-oneapi-mkl"
+            elif (
+                self.spec.variants["fft"].value == "mkl"
+                and spec["fftw-api"].name in INTEL_MATH_LIBRARIES
             ):
                 mklroot = env["MKLROOT"]
                 self.config["@LAINC@"] += f" -I{join_path(mklroot, 'include/fftw')}"
@@ -158,6 +159,8 @@ def edit(self, spec, prefix):
 
         # Compiler flags for CPU architecture optimizations
         if spec.satisfies("%intel"):
+            # with intel-parallel-studio+mpi the '-march' arguments
+            # are not passed to icc
             arch_opt = optimization_flags(self.compiler, spec.target)
             self.config["@CCFLAGS@"] = f"-O3 -restrict -ansi-alias -ip {arch_opt}"
             self.config["@CCNOOPT@"] = "-restrict"

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

@@ -126,7 +126,11 @@ def configure_args(self):
         if self.spec.satisfies("+openmp"):
             cflags.append(self.compiler.openmp_flag)
 
-        if self.spec.satisfies("^intel-oneapi-mkl"):
+        if (
+            self.spec.satisfies("^intel-mkl")
+            or self.spec.satisfies("^intel-oneapi-mkl")
+            or self.spec.satisfies("^intel-parallel-studio+mkl")
+        ):
             ldflags.append(self.spec["blas"].libs.ld_flags)
 
         if self.spec.satisfies("%aocc"):

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

@@ -169,10 +169,6 @@ class Hpx(CMakePackage, CudaPackage, ROCmPackage):
 
     # Patches and one-off conflicts
 
-    # Asio 1.34.0 removed io_context::work, used by HPX:
-    # https://github.com/chriskohlhoff/asio/commit/a70f2df321ff40c1809773c2c09986745abf8d20.
-    conflicts("^asio@1.34:", when="@:1.10")
-
     # Certain Asio headers don't compile with nvcc from 1.17.0 onwards with
     # C++17. Starting with CUDA 11.3 they compile again.
     conflicts("^asio@1.17.0:", when="+cuda cxxstd=17 ^cuda@:11.2")

var/spack/repos/builtin/packages/intel-mkl/package.py

@@ -0,0 +1,187 @@
+# Copyright Spack Project Developers. See COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+import sys
+
+from spack.package import *
+
+
+@IntelOneApiPackage.update_description
+class IntelMkl(IntelPackage):
+    """Intel Math Kernel Library. This package has been replaced by
+    intel-oneapi-mkl.
+
+    """
+
+    maintainers("rscohn2")
+
+    homepage = "https://software.intel.com/en-us/intel-mkl"
+
+    version(
+        "2020.4.304",
+        sha256="2314d46536974dbd08f2a4e4f9e9a155dc7e79e2798c74e7ddfaad00a5917ea5",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/16917/l_mkl_2020.4.304.tgz",
+        deprecated=True,
+    )
+    version(
+        "2020.3.279",
+        sha256="2b8e434ecc9462491130ba25a053927fd1a2eca05e12acb5936b08c486857a04",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/16903/l_mkl_2020.3.279.tgz",
+        deprecated=True,
+    )
+    version(
+        "2020.2.254",
+        sha256="ed00a267af362a6c14212bd259ab1673d64337e077263033edeef8ac72c10223",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/16849/l_mkl_2020.2.254.tgz",
+        deprecated=True,
+    )
+    version(
+        "2020.1.217",
+        sha256="082a4be30bf4f6998e4d6e3da815a77560a5e66a68e254d161ab96f07086066d",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/16533/l_mkl_2020.1.217.tgz",
+        deprecated=True,
+    )
+    version(
+        "2020.0.166",
+        sha256="f6d92deb3ff10b11ba3df26b2c62bb4f0f7ae43e21905a91d553e58f0f5a8ae0",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/16232/l_mkl_2020.0.166.tgz",
+        deprecated=True,
+    )
+    version(
+        "2019.5.281",
+        sha256="9995ea4469b05360d509c9705e9309dc983c0a10edc2ae3a5384bc837326737e",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/15816/l_mkl_2019.5.281.tgz",
+        deprecated=True,
+    )
+    version(
+        "2019.4.243",
+        sha256="fcac7b0369665d93f0c4dd98afe2816aeba5410e2b760655fe55fc477f8f33d0",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/15540/l_mkl_2019.4.243.tgz",
+        deprecated=True,
+    )
+    version(
+        "2019.3.199",
+        sha256="06de2b54f4812e7c39a118536259c942029fe1d6d8918ad9df558a83c4162b8f",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/15275/l_mkl_2019.3.199.tgz",
+        deprecated=True,
+    )
+    version(
+        "2019.2.187",
+        sha256="2bf004e6b5adb4f956993d6c20ea6ce289bb630314dd501db7f2dd5b9978ed1d",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/15095/l_mkl_2019.2.187.tgz",
+        deprecated=True,
+    )
+    version(
+        "2019.1.144",
+        sha256="5205a460a9c685f7a442868367389b2d0c25e1455346bc6a37c5b8ff90a20fbb",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/14895/l_mkl_2019.1.144.tgz",
+        deprecated=True,
+    )
+    version(
+        "2019.0.117",
+        sha256="4e1fe2c705cfc47050064c0d6c4dee1a8c6740ac1c4f64dde9c7511c4989c7ad",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/13575/l_mkl_2019.0.117.tgz",
+        deprecated=True,
+    )
+    version(
+        "2018.4.274",
+        sha256="18eb3cde3e6a61a88f25afff25df762a560013f650aaf363f7d3d516a0d04881",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/13725/l_mkl_2018.4.274.tgz",
+        deprecated=True,
+    )
+    version(
+        "2018.3.222",
+        sha256="108d59c0927e58ce8c314db6c2b48ee331c3798f7102725f425d6884eb6ed241",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/13005/l_mkl_2018.3.222.tgz",
+        deprecated=True,
+    )
+    version(
+        "2018.2.199",
+        sha256="e28d12173bef9e615b0ded2f95f59a42b3e9ad0afa713a79f8801da2bfb31936",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12725/l_mkl_2018.2.199.tgz",
+        deprecated=True,
+    )
+    version(
+        "2018.1.163",
+        sha256="f6dc263fc6f3c350979740a13de1b1e8745d9ba0d0f067ece503483b9189c2ca",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12414/l_mkl_2018.1.163.tgz",
+        deprecated=True,
+    )
+    version(
+        "2018.0.128",
+        sha256="c368baa40ca88057292512534d7fad59fa24aef06da038ea0248e7cd1e280cec",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12070/l_mkl_2018.0.128.tgz",
+        deprecated=True,
+    )
+    version(
+        "2017.4.239",
+        sha256="dcac591ed1e95bd72357fd778edba215a7eab9c6993236373231cc16c200c92a",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12147/l_mkl_2017.4.239.tgz",
+        deprecated=True,
+    )
+    version(
+        "2017.3.196",
+        sha256="fd7295870fa164d6138c9818304f25f2bb263c814a6c6539c9fe4e104055f1ca",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/11544/l_mkl_2017.3.196.tgz",
+        deprecated=True,
+    )
+    version(
+        "2017.2.174",
+        sha256="0b8a3fd6bc254c3c3d9d51acf047468c7f32bf0baff22aa1e064d16d9fea389f",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/11306/l_mkl_2017.2.174.tgz",
+        deprecated=True,
+    )
+    version(
+        "2017.1.132",
+        sha256="8c6bbeac99326d59ef3afdc2a95308c317067efdaae50240d2f4a61f37622e69",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/11024/l_mkl_2017.1.132.tgz",
+        deprecated=True,
+    )
+    version(
+        "2017.0.098",
+        sha256="f2233e8e011f461d9c15a853edf7ed0ae8849aa665a1ec765c1ff196fd70c4d9",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/9662/l_mkl_2017.0.098.tgz",
+        deprecated=True,
+    )
+    # built from parallel_studio_xe_2016.3.x
+    version(
+        "11.3.3.210",
+        sha256="ff858f0951fd698e9fb30147ea25a8a810c57f0126c8457b3b0cdf625ea43372",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/9068/l_mkl_11.3.3.210.tgz",
+        deprecated=True,
+    )
+    # built from parallel_studio_xe_2016.2.062
+    version(
+        "11.3.2.181",
+        sha256="bac04a07a1fe2ae4996a67d1439ee90c54f31305e8663d1ccfce043bed84fc27",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/8711/l_mkl_11.3.2.181.tgz",
+        deprecated=True,
+    )
+
+    depends_on("cpio", type="build")
+
+    conflicts("target=ppc64:", msg="intel-mkl is only available for x86_64")
+    conflicts("target=ppc64le:", msg="intel-mkl is only available for x86_64")
+    conflicts("target=aarch64:", msg="intel-mkl is only available for x86_64")
+
+    variant("shared", default=True, description="Builds shared library")
+    variant("ilp64", default=False, description="64 bit integers")
+    variant(
+        "threads",
+        default="none",
+        description="Multithreading support",
+        values=("openmp", "tbb", "none"),
+        multi=False,
+    )
+
+    provides("blas", "lapack")
+    provides("lapack@3.9.0", when="@2020.4")
+    provides("lapack@3.7.0", when="@11.3")
+    provides("scalapack")
+    provides("mkl")
+    provides("fftw-api@3", when="@2017:")
+
+    if sys.platform == "darwin":
+        # there is no libmkl_gnu_thread on macOS
+        conflicts("threads=openmp", when="%gcc")

var/spack/repos/builtin/packages/intel-mpi-benchmarks/package.py

@@ -36,11 +36,15 @@ class IntelMpiBenchmarks(MakefilePackage):
     version("2019.2", sha256="0bc2224a913073aaa5958f6ae08341e5fcd39cedc6722a09bfd4a3d7591a340b")
     version("2019.1", sha256="fe0d065b9936b6943ea83cb3d00aede43b17565285c6b1791fee8e340853ef79")
     version("2019.0", sha256="1c7d44aa7fd86ca84ac7cae1a69a8426243048d6294582337f1de7b4ffe68d37")
+    version("2018.1", sha256="718a4eb155f18cf15a736f6496332407b5837cf1f19831723d4cfe5266c43507")
+    version("2018.0", sha256="2e60a9894a686a95791be2227bc569bf81ca3875421b5307df7d83f885b1de88")
 
     depends_on("c", type="build")  # generated
     depends_on("cxx", type="build")  # generated
 
     depends_on("mpi", when="@2019:")
+    depends_on("intel-mpi", when="@2018")
+    depends_on("gmake", type="build", when="@2018")
 
     conflicts(
         "^openmpi",

var/spack/repos/builtin/packages/intel-mpi/package.py

@@ -0,0 +1,174 @@
+# Copyright Spack Project Developers. See COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+from spack.package import *
+
+
+@IntelOneApiPackage.update_description
+class IntelMpi(IntelPackage):
+    """Intel MPI. This package has been deprecated. Use intel-oneapi-mpi instead."""
+
+    maintainers("rscohn2")
+
+    homepage = "https://software.intel.com/en-us/intel-mpi-library"
+
+    version(
+        "2019.10.317",
+        sha256="28e1b615e63d2170a99feedc75e3b0c5a7e1a07dcdaf0a4181831b07817a5346",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/17534/l_mpi_2019.10.317.tgz",
+        deprecated=True,
+    )
+    version(
+        "2019.9.304",
+        sha256="618a5dc2de54306645e6428c5eb7d267b54b11b5a83dfbcad7d0f9e0d90bb2e7",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/17263/l_mpi_2019.9.304.tgz",
+        deprecated=True,
+    )
+    version(
+        "2019.8.254",
+        sha256="fa163b4b79bd1b7509980c3e7ad81b354fc281a92f9cf2469bf4d323899567c0",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/16814/l_mpi_2019.8.254.tgz",
+        deprecated=True,
+    )
+    version(
+        "2019.7.217",
+        sha256="90383b0023f84ac003a55d8bb29dbcf0c639f43a25a2d8d8698a16e770ac9c07",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/16546/l_mpi_2019.7.217.tgz",
+        deprecated=True,
+    )
+    version(
+        "2019.6.166",
+        sha256="119be69f1117c93a9e5e9b8b4643918e55d2a55a78ad9567f77d16cdaf18cd6e",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/16120/l_mpi_2019.6.166.tgz",
+        deprecated=True,
+    )
+    version(
+        "2019.5.281",
+        sha256="9c59da051f1325b221e5bc4d8b689152e85d019f143069fa39e17989306811f4",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/15838/l_mpi_2019.5.281.tgz",
+        deprecated=True,
+    )
+    version(
+        "2019.4.243",
+        sha256="233a8660b92ecffd89fedd09f408da6ee140f97338c293146c9c080a154c5fcd",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/15553/l_mpi_2019.4.243.tgz",
+        deprecated=True,
+    )
+    version(
+        "2019.3.199",
+        sha256="5304346c863f64de797250eeb14f51c5cfc8212ff20813b124f20e7666286990",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/15260/l_mpi_2019.3.199.tgz",
+        deprecated=True,
+    )
+    version(
+        "2019.2.187",
+        sha256="6a3305933b5ef9e3f7de969e394c91620f3fa4bb815a4f439577739d04778b20",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/15040/l_mpi_2019.2.187.tgz",
+        deprecated=True,
+    )
+    version(
+        "2019.1.144",
+        sha256="dac86a5db6b86503313742b17535856a432955604f7103cb4549a9bfc256c3cd",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/14879/l_mpi_2019.1.144.tgz",
+        deprecated=True,
+    )
+    version(
+        "2019.0.117",
+        sha256="dfb403f49c1af61b337aa952b71289c7548c3a79c32c57865eab0ea0f0e1bc08",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/13584/l_mpi_2019.0.117.tgz",
+        deprecated=True,
+    )
+    version(
+        "2018.4.274",
+        sha256="a1114b3eb4149c2f108964b83cad02150d619e50032059d119ac4ffc9d5dd8e0",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/13741/l_mpi_2018.4.274.tgz",
+        deprecated=True,
+    )
+    version(
+        "2018.3.222",
+        sha256="5021d14b344fc794e89f146e4d53d70184d7048610895d7a6a1e8ac0cf258999",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/13112/l_mpi_2018.3.222.tgz",
+        deprecated=True,
+    )
+    version(
+        "2018.2.199",
+        sha256="0927f1bff90d10974433ba2892e3fd38e6fee5232ab056a9f9decf565e814460",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12748/l_mpi_2018.2.199.tgz",
+        deprecated=True,
+    )
+    version(
+        "2018.1.163",
+        sha256="130b11571c3f71af00a722fa8641db5a1552ac343d770a8304216d8f5d00e75c",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12414/l_mpi_2018.1.163.tgz",
+        deprecated=True,
+    )
+    version(
+        "2018.0.128",
+        sha256="debaf2cf80df06db9633dfab6aa82213b84a665a55ee2b0178403906b5090209",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12120/l_mpi_2018.0.128.tgz",
+        deprecated=True,
+    )
+    version(
+        "2017.4.239",
+        sha256="5a1048d284dce8bc75b45789471c83c94b3c59f8f159cab43d783fc44302510b",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12209/l_mpi_2017.4.239.tgz",
+        deprecated=True,
+    )
+    version(
+        "2017.3.196",
+        sha256="dad9efbc5bbd3fd27cce7e1e2507ad77f342d5ecc929747ae141c890e7fb87f0",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/11595/l_mpi_2017.3.196.tgz",
+        deprecated=True,
+    )
+    version(
+        "2017.2.174",
+        sha256="106a4b362c13ddc6978715e50f5f81c58c1a4c70cd2d20a99e94947b7e733b88",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/11334/l_mpi_2017.2.174.tgz",
+        deprecated=True,
+    )
+    version(
+        "2017.1.132",
+        sha256="8d30a63674fe05f17b0a908a9f7d54403018bfed2de03c208380b171ab99be82",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/11014/l_mpi_2017.1.132.tgz",
+        deprecated=True,
+    )
+    # built from parallel_studio_xe_2016.3.068
+    version(
+        "5.1.3.223",
+        sha256="544f4173b09609beba711fa3ba35567397ff3b8390e4f870a3307f819117dd9b",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/9278/l_mpi_p_5.1.3.223.tgz",
+        deprecated=True,
+    )
+
+    provides("mpi")
+
+    variant(
+        "external-libfabric", default=False, description="Enable external libfabric dependency"
+    )
+    depends_on("libfabric", when="+external-libfabric", type=("build", "link", "run"))
+    depends_on("cpio", type="build")
+
+    def setup_dependent_build_environment(self, env, dependent_spec):
+        # Handle in callback, conveying client's compilers in additional arg.
+        # CAUTION - DUP code in:
+        #   ../intel-mpi/package.py
+        #   ../intel-parallel-studio/package.py
+        dependent_module = dependent_spec.package.module
+        self._setup_dependent_env_callback(
+            env,
+            dependent_spec,
+            compilers_of_client={
+                "CC": dependent_module.spack_cc,
+                "CXX": dependent_module.spack_cxx,
+                "F77": dependent_module.spack_f77,
+                "F90": dependent_module.spack_fc,
+                "FC": dependent_module.spack_fc,
+            },
+        )
+
+    def setup_run_environment(self, env):
+        super().setup_run_environment(env)
+
+        for name, value in self.mpi_compiler_wrappers.items():
+            env.set(name, value)

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

@@ -186,13 +186,14 @@ class IntelOneapiMkl(IntelOneApiLibraryPackage):
     # If a +cluster then mpi_family must be set
     with when("+cluster"):
         conflicts("mpi_family=none")
-        requires("mpi_family=mpich", when="^[virtuals=mpi] intel-oneapi-mpi")
-        requires("mpi_family=mpich", when="^[virtuals=mpi] mpich")
-        requires("mpi_family=mpich", when="^[virtuals=mpi] mvapich")
-        requires("mpi_family=mpich", when="^[virtuals=mpi] mvapich2")
-        requires("mpi_family=mpich", when="^[virtuals=mpi] cray-mpich")
-        requires("mpi_family=openmpi", when="^[virtuals=mpi] openmpi")
-        requires("mpi_family=openmpi", when="^[virtuals=mpi] hpcx-mpi")
+        requires("mpi_family=mpich", when="^intel-oneapi-mpi")
+        requires("mpi_family=mpich", when="^intel-mpi")
+        requires("mpi_family=mpich", when="^mpich")
+        requires("mpi_family=mpich", when="^mvapich")
+        requires("mpi_family=mpich", when="^mvapich2")
+        requires("mpi_family=mpich", when="^cray-mpich")
+        requires("mpi_family=openmpi", when="^openmpi")
+        requires("mpi_family=openmpi", when="^hpcx-mpi")
 
     provides("fftw-api@3")
     provides("scalapack", when="+cluster")

var/spack/repos/builtin/packages/intel-parallel-studio/package.py

@@ -0,0 +1,690 @@
+# Copyright Spack Project Developers. See COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+from spack.package import *
+
+
+@IntelOneApiPackage.update_description
+class IntelParallelStudio(IntelPackage):
+    """This is an earlier version of Intel parallel software development
+    tools and has now been replaced by the Intel oneAPI Toolkits.
+
+    """
+
+    homepage = "https://software.intel.com/en-us/intel-parallel-studio-xe"
+
+    maintainers("rscohn2")
+
+    depends_on("patchelf", type="build")
+
+    # As of 2016, the product comes in three "editions" that vary by scope.
+    #
+    # In Spack, select the edition via the version number in the spec, e.g.:
+    #   intel-parallel-studio@cluster.2018
+
+    # NB: When updating the version numbers here, please also update them
+    # in the 'intel' package.
+
+    # Cluster Edition (top tier; all components included)
+    version(
+        "cluster.2020.4",
+        sha256="f36e49da97b6ce24d2d464d73d7ff49d71cff20e1698c20e607919819602a9f5",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/17113/parallel_studio_xe_2020_update4_cluster_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "cluster.2020.2",
+        sha256="4795c44374e8988b91da20ac8f13022d7d773461def4a26ca210a8694f69f133",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/16744/parallel_studio_xe_2020_update2_cluster_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "cluster.2020.1",
+        sha256="fd11d8de72b2bd60474f8bce7b463e4cbb2255969b9eaf24f689575aa2a2abab",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/16526/parallel_studio_xe_2020_update1_cluster_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "cluster.2020.0",
+        sha256="573b1d20707d68ce85b70934cfad15b5ad9cc14124a261c17ddd7717ba842c64",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/16225/parallel_studio_xe_2020_cluster_edition.tgz",
+        deprecated=True,
+    )
+    #
+    version(
+        "cluster.2019.5",
+        sha256="c03421de616bd4e640ed25ce4103ec9c5c85768a940a5cb5bd1e97b45be33904",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/15809/parallel_studio_xe_2019_update5_cluster_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "cluster.2019.4",
+        sha256="32aee12de3b5ca14caf7578313c06b205795c67620f4a9606ea45696ee3b3d9e",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/15533/parallel_studio_xe_2019_update4_cluster_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "cluster.2019.3",
+        sha256="b5b022366d6d1a98dbb63b60221c62bc951c9819653ad6f5142192e89f78cf63",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/15268/parallel_studio_xe_2019_update3_cluster_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "cluster.2019.2",
+        sha256="8c526bdd95d1da454e5cada00f7a2353089b86d0c9df2088ca7f842fe3ff4cae",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/15088/parallel_studio_xe_2019_update2_cluster_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "cluster.2019.1",
+        sha256="3a1eb39f15615f7a2688426b9835e5e841e0c030f21dcfc899fe23e09bd2c645",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/14850/parallel_studio_xe_2019_update1_cluster_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "cluster.2019.0",
+        sha256="1096dd4139bdd4b3abbda69a17d1e229a606759f793f5b0ba0d39623928ee4a1",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/13589/parallel_studio_xe_2019_cluster_edition.tgz",
+        deprecated=True,
+    )
+    #
+    version(
+        "cluster.2018.4",
+        sha256="210a5904a860e11b861720e68416f91fd47a459e4500976853291fa8b0478566",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/13717/parallel_studio_xe_2018_update4_cluster_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "cluster.2018.3",
+        sha256="23c64b88cea5056eaeef7b4ae0f4c6a86485c97f5e41d6c8419cb00aa4929287",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12998/parallel_studio_xe_2018_update3_cluster_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "cluster.2018.2",
+        sha256="550bc4758f7dd70e75830d329947532ad8b7cbb85225b8ec6db7e78a3f1d6d84",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12717/parallel_studio_xe_2018_update2_cluster_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "cluster.2018.1",
+        sha256="f7a94e83248d2641eb7ae2c1abf681067203a5b4372619e039861b468744774c",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12374/parallel_studio_xe_2018_update1_cluster_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "cluster.2018.0",
+        sha256="526e5e71c420dc9b557b0bae2a81abb33eedb9b6a28ac94996ccbcf71cf53774",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12058/parallel_studio_xe_2018_cluster_edition.tgz",
+        deprecated=True,
+    )
+    #
+    version(
+        "cluster.2017.7",
+        sha256="133c3aa99841a4fe48149938a90f971467452a82f033be10cd9464ba810f6360",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12856/parallel_studio_xe_2017_update7.tgz",
+        deprecated=True,
+    )
+    version(
+        "cluster.2017.6",
+        sha256="d771b00d3658934c424f294170125dc58ae9b03639aa898a2f115d7a7482dd3a",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12534/parallel_studio_xe_2017_update6.tgz",
+        deprecated=True,
+    )
+    version(
+        "cluster.2017.5",
+        sha256="36e496d1d1d7d7168cc3ba8f5bca9b52022339f30b62a87ed064b77a5cbccc09",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12138/parallel_studio_xe_2017_update5.tgz",
+        deprecated=True,
+    )
+    version(
+        "cluster.2017.4",
+        sha256="27d34625adfc635d767c136b5417a372f322fabe6701b651d858a8fe06d07f2d",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/11537/parallel_studio_xe_2017_update4.tgz",
+        deprecated=True,
+    )
+    version(
+        "cluster.2017.3",
+        sha256="856950c0493de3e8b4150e18f8821675c1cf75c2eea5ff0804f59eb301414bbe",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/11460/parallel_studio_xe_2017_update3.tgz",
+        deprecated=True,
+    )
+    version(
+        "cluster.2017.2",
+        sha256="83a655f0c2969409758488d70d6719fb5ea81a84b6da3feb641ce67bb240bc8a",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/11298/parallel_studio_xe_2017_update2.tgz",
+        deprecated=True,
+    )
+    version(
+        "cluster.2017.1",
+        sha256="c808be744c98f7471c61258144859e8e8fc92771934281a16135803e941fd9b0",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/10973/parallel_studio_xe_2017_update1.tgz",
+        deprecated=True,
+    )
+    version(
+        "cluster.2017.0",
+        sha256="f380a56a25cf17941eb691a640035e79f92516346500e0df80fbdd46c5c1b301",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/9651/parallel_studio_xe_2017.tgz",
+        deprecated=True,
+    )
+    #
+    version(
+        "cluster.2016.4",
+        sha256="ea43c150ed6f9967bc781fe4253169a0447c69bac4fe2c563016a1ad2875ae23",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/9781/parallel_studio_xe_2016_update4.tgz",
+        deprecated=True,
+    )
+    version(
+        "cluster.2016.3",
+        sha256="aa7c6f1a6603fae07c2b01409c12de0811aa5947eaa71dfb1fe9898076c2773e",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/9061/parallel_studio_xe_2016_update3.tgz",
+        deprecated=True,
+    )
+    version(
+        "cluster.2016.2",
+        sha256="280bf39c75d7f52f206759ca4d8b6334ab92d5970957b90f5aa286bb0aa8d65e",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/8676/parallel_studio_xe_2016_update2.tgz",
+        deprecated=True,
+    )
+    version(
+        "cluster.2016.1",
+        sha256="f5a3ab9fb581e19bf1bd966f7d40a11905e002a2bfae1c4a2140544288ca3e48",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/8365/parallel_studio_xe_2016_update1.tgz",
+        deprecated=True,
+    )
+    version(
+        "cluster.2016.0",
+        sha256="fd4c32352fd78fc919601bedac5658ad5ac48efbc5700d9a8d42ed7d53bd8bb7",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/7997/parallel_studio_xe_2016.tgz",
+        deprecated=True,
+    )
+    #
+    version(
+        "cluster.2015.6",
+        sha256="e604ed2bb45d227b151dd2898f3edd93526d58d1db1cb9d6b6f614907864f392",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/8469/parallel_studio_xe_2015_update6.tgz",
+        deprecated=True,
+    )
+    version(
+        "cluster.2015.1",
+        sha256="84fdf48d1de20e1d580ba5d419a5bc1c55d217a4f5dc1807190ecffe0229a62b",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/4992/parallel_studio_xe_2015_update1.tgz",
+        deprecated=True,
+    )
+
+    # Professional Edition (middle tier; excluded: MPI/TAC/Cluster Checker)
+    #
+    # NB: Pre-2018 download packages for Professional are the same as for
+    # Cluster; differences manifest only in the tokens present in the license
+    # file delivered as part of the purchase.
+    version(
+        "professional.2020.4",
+        sha256="f9679a40c63575191385837f4f1bdafbcfd3736f09ac51d0761248b9ca9cc9e6",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/17114/parallel_studio_xe_2020_update4_professional_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "professional.2020.2",
+        sha256="96f9bca551a43e09d9648e8cba357739a759423adb671d1aa5973b7a930370c5",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/16756/parallel_studio_xe_2020_update2_professional_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "professional.2020.1",
+        sha256="5b547be92ecf50cb338b3038a565f5609135b27aa98a8b7964879eb2331eb29a",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/16527/parallel_studio_xe_2020_update1_professional_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "professional.2020.0",
+        sha256="e88cad18d28da50ed9cb87b12adccf13efd91bf94731dc33290481306c6f15ac",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/16226/parallel_studio_xe_2020_professional_edition.tgz",
+        deprecated=True,
+    )
+    #
+    version(
+        "professional.2019.5",
+        sha256="0ec638330214539361f8632e20759f385a5a78013dcc980ee93743d86d354452",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/15810/parallel_studio_xe_2019_update5_professional_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "professional.2019.4",
+        sha256="9b2818ea5739ade100841e99ce79ef7f4049a2513beb2ce20fc94706f1ba0231",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/15534/parallel_studio_xe_2019_update4_professional_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "professional.2019.3",
+        sha256="92a8879106d0bdf1ecf4670cd97fbcdc67d78b13bdf484f2c516a533aa7a27f9",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/15269/parallel_studio_xe_2019_update3_professional_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "professional.2019.2",
+        sha256="cdb629d74612d135ca197f1f64e6a081e31df68cda92346a29e1223bb06e64ea",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/15089/parallel_studio_xe_2019_update2_professional_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "professional.2019.1",
+        sha256="bc83ef5a728903359ae11a2b90ad7dae4ae61194afb28bb5bb419f6a6aea225d",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/14825/parallel_studio_xe_2019_update1_professional_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "professional.2019.0",
+        sha256="94b9714e353e5c4f58d38cb236e2f8911cbef31c4b42a148d60c988e926411e2",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/13578/parallel_studio_xe_2019_professional_edition.tgz",
+        deprecated=True,
+    )
+    #
+    version(
+        "professional.2018.4",
+        sha256="54ab4320da849108602096fa7a34aa21751068467e0d1584aa8f16352b77d323",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/13718/parallel_studio_xe_2018_update4_professional_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "professional.2018.3",
+        sha256="3d8e72ccad31f243e43b72a925ad4a6908e2955682433898640ab783decf9960",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12999/parallel_studio_xe_2018_update3_professional_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "professional.2018.2",
+        sha256="fc577b29fb2c687441d4faea14a6fb6da529fc78fcb778cbface59f40e128e02",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12718/parallel_studio_xe_2018_update2_professional_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "professional.2018.1",
+        sha256="dd3e118069d87eebb614336732323b48172c8c8a653cde673a8ef02f7358e94d",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12375/parallel_studio_xe_2018_update1_professional_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "professional.2018.0",
+        sha256="72308ffa088391ea65726a79d7a73738206fbb1d8ed8563e3d06eab3120fb1a0",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12062/parallel_studio_xe_2018_professional_edition.tgz",
+        deprecated=True,
+    )
+    #
+    version(
+        "professional.2017.7",
+        sha256="133c3aa99841a4fe48149938a90f971467452a82f033be10cd9464ba810f6360",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12856/parallel_studio_xe_2017_update7.tgz",
+        deprecated=True,
+    )
+    version(
+        "professional.2017.6",
+        sha256="d771b00d3658934c424f294170125dc58ae9b03639aa898a2f115d7a7482dd3a",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12534/parallel_studio_xe_2017_update6.tgz",
+        deprecated=True,
+    )
+    version(
+        "professional.2017.5",
+        sha256="36e496d1d1d7d7168cc3ba8f5bca9b52022339f30b62a87ed064b77a5cbccc09",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12138/parallel_studio_xe_2017_update5.tgz",
+        deprecated=True,
+    )
+    version(
+        "professional.2017.4",
+        sha256="27d34625adfc635d767c136b5417a372f322fabe6701b651d858a8fe06d07f2d",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/11537/parallel_studio_xe_2017_update4.tgz",
+        deprecated=True,
+    )
+    version(
+        "professional.2017.3",
+        sha256="856950c0493de3e8b4150e18f8821675c1cf75c2eea5ff0804f59eb301414bbe",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/11460/parallel_studio_xe_2017_update3.tgz",
+        deprecated=True,
+    )
+    version(
+        "professional.2017.2",
+        sha256="83a655f0c2969409758488d70d6719fb5ea81a84b6da3feb641ce67bb240bc8a",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/11298/parallel_studio_xe_2017_update2.tgz",
+        deprecated=True,
+    )
+    version(
+        "professional.2017.1",
+        sha256="c808be744c98f7471c61258144859e8e8fc92771934281a16135803e941fd9b0",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/10973/parallel_studio_xe_2017_update1.tgz",
+        deprecated=True,
+    )
+    version(
+        "professional.2017.0",
+        sha256="f380a56a25cf17941eb691a640035e79f92516346500e0df80fbdd46c5c1b301",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/9651/parallel_studio_xe_2017.tgz",
+        deprecated=True,
+    )
+    #
+    version(
+        "professional.2016.4",
+        sha256="ea43c150ed6f9967bc781fe4253169a0447c69bac4fe2c563016a1ad2875ae23",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/9781/parallel_studio_xe_2016_update4.tgz",
+        deprecated=True,
+    )
+    version(
+        "professional.2016.3",
+        sha256="aa7c6f1a6603fae07c2b01409c12de0811aa5947eaa71dfb1fe9898076c2773e",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/9061/parallel_studio_xe_2016_update3.tgz",
+        deprecated=True,
+    )
+    version(
+        "professional.2016.2",
+        sha256="280bf39c75d7f52f206759ca4d8b6334ab92d5970957b90f5aa286bb0aa8d65e",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/8676/parallel_studio_xe_2016_update2.tgz",
+        deprecated=True,
+    )
+    version(
+        "professional.2016.1",
+        sha256="f5a3ab9fb581e19bf1bd966f7d40a11905e002a2bfae1c4a2140544288ca3e48",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/8365/parallel_studio_xe_2016_update1.tgz",
+        deprecated=True,
+    )
+    version(
+        "professional.2016.0",
+        sha256="fd4c32352fd78fc919601bedac5658ad5ac48efbc5700d9a8d42ed7d53bd8bb7",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/7997/parallel_studio_xe_2016.tgz",
+        deprecated=True,
+    )
+    #
+    version(
+        "professional.2015.6",
+        sha256="e604ed2bb45d227b151dd2898f3edd93526d58d1db1cb9d6b6f614907864f392",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/8469/parallel_studio_xe_2015_update6.tgz",
+        deprecated=True,
+    )
+    version(
+        "professional.2015.1",
+        sha256="84fdf48d1de20e1d580ba5d419a5bc1c55d217a4f5dc1807190ecffe0229a62b",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/4992/parallel_studio_xe_2015_update1.tgz",
+        deprecated=True,
+    )
+
+    # Composer Edition (basic tier; excluded: MPI/..., Advisor/Inspector/Vtune)
+    version(
+        "composer.2020.4",
+        sha256="ac1efeff608a8c3a416e6dfe20364061e8abf62d35fbaacdffe3fc9676fc1aa3",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/16759/parallel_studio_xe_2020_update2_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "composer.2020.2",
+        sha256="42af16e9a91226978bb401d9f17b628bc279aa8cb104d4a38ba0808234a79bdd",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/16759/parallel_studio_xe_2020_update2_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "composer.2020.1",
+        sha256="26c7e7da87b8a83adfd408b2a354d872be97736abed837364c1bf10f4469b01e",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/16530/parallel_studio_xe_2020_update1_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "composer.2020.0",
+        sha256="9168045466139b8e280f50f0606b9930ffc720bbc60bc76f5576829ac15757ae",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/16229/parallel_studio_xe_2020_composer_edition.tgz",
+        deprecated=True,
+    )
+    #
+    version(
+        "composer.2019.5",
+        sha256="e8c8e4b9b46826a02c49325c370c79f896858611bf33ddb7fb204614838ad56c",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/15813/parallel_studio_xe_2019_update5_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "composer.2019.4",
+        sha256="1915993445323e1e78d6de73702a88fa3df2036109cde03d74ee38fef9f1abf2",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/15537/parallel_studio_xe_2019_update4_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "composer.2019.3",
+        sha256="15373ac6df2a84e6dd9fa0eac8b5f07ab00cdbb67f494161fd0d4df7a71aff8e",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/15272/parallel_studio_xe_2019_update3_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "composer.2019.2",
+        sha256="1e0f400be1f458592a8c2e7d55c1b2a4506f68f22bacbf1175af947809a4cd87",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/15092/parallel_studio_xe_2019_update2_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "composer.2019.1",
+        sha256="db000cb2ebf411f6e91719db68a0c68b8d3f7d38ad7f2049ea5b2f1b5f006c25",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/14832/parallel_studio_xe_2019_update1_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "composer.2019.0",
+        sha256="e1a29463038b063e01f694e2817c0fcf1a8e824e24f15a26ce85f20afa3f963a",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/13581/parallel_studio_xe_2019_composer_edition.tgz",
+        deprecated=True,
+    )
+    #
+    version(
+        "composer.2018.4",
+        sha256="94aca8f091dff9535b02f022a37aef150b36925c8ef069335621496f8e4db267",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/13722/parallel_studio_xe_2018_update4_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "composer.2018.3",
+        sha256="f21f7759709a3d3e3390a8325fa89ac79b1fce8890c292e73b2ba3ec576ebd2b",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/13002/parallel_studio_xe_2018_update3_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "composer.2018.2",
+        sha256="02d2a9fb10d9810f85dd77700215c4348d2e4475e814e4f086eb1442462667ff",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12722/parallel_studio_xe_2018_update2_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "composer.2018.1",
+        sha256="db9aa417da185a03a63330c9d76ee8e88496ae6b771584d19003a29eedc7cab5",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12381/parallel_studio_xe_2018_update1_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "composer.2018.0",
+        sha256="ecad64360fdaff2548a0ea250a396faf680077c5a83c3c3ce2c55f4f4270b904",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12067/parallel_studio_xe_2018_composer_edition.tgz",
+        deprecated=True,
+    )
+    #
+    version(
+        "composer.2017.7",
+        sha256="661e33b68e47bf335694d2255f5883955234e9085c8349783a5794eed2a937ad",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12860/parallel_studio_xe_2017_update7_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "composer.2017.6",
+        sha256="771f50746fe130ea472394c42e25d2c7edae049ad809d2050945ef637becf65f",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12538/parallel_studio_xe_2017_update6_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "composer.2017.5",
+        sha256="ede4ea9351fcf263103588ae0f130b4c2a79395529cdb698b0d6e866c4871f78",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12144/parallel_studio_xe_2017_update5_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "composer.2017.4",
+        sha256="4304766f80206a27709be61641c16782fccf2b3fcf7285782cce921ddc9b10ff",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/11541/parallel_studio_xe_2017_update4_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "composer.2017.3",
+        sha256="3648578d7bba993ebb1da37c173979bfcfb47f26e7f4e17f257e78dea8fd96ab",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/11464/parallel_studio_xe_2017_update3_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "composer.2017.2",
+        sha256="abd26ab2a703e73ab93326984837818601c391782a6bce52da8b2a246798ad40",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/11302/parallel_studio_xe_2017_update2_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "composer.2017.1",
+        sha256="bc592abee829ba6e00a4f60961b486b80c15987ff1579d6560186407c84add6f",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/10978/parallel_studio_xe_2017_update1_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "composer.2017.0",
+        sha256="d218db66a5bb57569bea00821ac95d4647eda7422bf8a178d1586b0fb314935a",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/9656/parallel_studio_xe_2017_composer_edition.tgz",
+        deprecated=True,
+    )
+    #
+    version(
+        "composer.2016.4",
+        sha256="17606c52cab6f5114223a2425923c8dd69f1858f5a3bdf280e0edea49ebd430d",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/9785/parallel_studio_xe_2016_composer_edition_update4.tgz",
+        deprecated=True,
+    )
+    version(
+        "composer.2016.3",
+        sha256="fcec90ba97533e4705077e0701813b5a3bcc197b010b03e96f83191a35c26acf",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/9063/parallel_studio_xe_2016_composer_edition_update3.tgz",
+        deprecated=True,
+    )
+    version(
+        "composer.2016.2",
+        sha256="6309ef8be1abba7737d3c1e17af64ca2620672b2da57afe2c3c643235f65b4c7",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/8680/parallel_studio_xe_2016_composer_edition_update2.tgz",
+        deprecated=True,
+    )
+    #
+    # Pre-2016, the only product was "Composer XE"; dir structure is different.
+    version(
+        "composer.2015.6",
+        sha256="b1e09833469ca76a2834cd0a5bb5fea11ec9986da85abf4c6eed42cd96ec24cb",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/8432/l_compxe_2015.6.233.tgz",
+        deprecated=True,
+    )
+    version(
+        "composer.2015.1",
+        sha256="8a438fe20103e27bfda132955616d0c886aa6cfdd86dcd9764af5d937a8799d9",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/4933/l_compxe_2015.1.133.tgz",
+        deprecated=True,
+    )
+
+    # Generic Variants
+    variant("rpath", default=True, description="Add rpath to .cfg files")
+    variant(
+        "newdtags", default=False, description="Allow use of --enable-new-dtags in MPI wrappers"
+    )
+    variant("shared", default=True, description="Builds shared library")
+    variant("ilp64", default=False, description="64 bit integers")
+    variant(
+        "threads",
+        default="none",
+        description="Multithreading support",
+        values=("openmp", "none"),
+        multi=False,
+    )
+
+    auto_dispatch_options = IntelPackage.auto_dispatch_options
+    variant(
+        "auto_dispatch",
+        values=any_combination_of(*auto_dispatch_options),
+        description="Enable generation of multiple auto-dispatch code paths",
+    )
+
+    # Components available in all editions
+    variant("daal", default=True, description="Install the Intel DAAL libraries")
+    variant(
+        "gdb", default=False, description="Install the Intel Debugger for Heterogeneous Compute"
+    )
+    variant("ipp", default=True, description="Install the Intel IPP libraries")
+    variant("mkl", default=True, description="Install the Intel MKL library")
+    variant("mpi", default=True, description="Install the Intel MPI library")
+    variant("tbb", default=True, description="Install the Intel TBB libraries")
+
+    # Components only available in the Professional and Cluster Editions
+    variant("advisor", default=False, description="Install the Intel Advisor")
+    variant("clck", default=False, description="Install the Intel Cluster Checker")
+    variant("inspector", default=False, description="Install the Intel Inspector")
+    variant("itac", default=False, description="Install the Intel Trace Analyzer and Collector")
+    variant("vtune", default=False, description="Install the Intel VTune Amplifier XE")
+
+    provides("daal", when="+daal")
+    provides("ipp", when="+ipp")
+
+    provides("mkl", when="+mkl")
+    provides("blas", "lapack", when="+mkl")
+    provides("scalapack", when="+mkl")
+
+    provides("fftw-api@3", when="+mkl@professional.2017:")
+    provides("fftw-api@3", when="+mkl@cluster.2017:")
+    provides("fftw-api@3", when="+mkl@composer.2017:")
+
+    provides("mpi", when="+mpi")
+    provides("tbb", when="+tbb")
+
+    conflicts("target=ppc64:", msg="intel-parallel-studio is only available for x86_64")
+    conflicts("target=ppc64le:", msg="intel-parallel-studio is only available for x86_64")
+    conflicts("target=aarch64:", msg="intel-parallel-studio is only available for x86_64")
+
+    # For TBB, static linkage is not and has never been supported by Intel:
+    # https://www.threadingbuildingblocks.org/faq/there-version-tbb-provides-statically-linked-libraries
+    conflicts("+tbb", when="~shared")
+
+    conflicts("+advisor", when="@composer.0:composer")
+    conflicts("+clck", when="@composer.0:composer")
+    conflicts("+inspector", when="@composer.0:composer")
+    conflicts("+itac", when="@composer.0:composer")
+    conflicts("+mpi", when="@composer.0:composer")
+    conflicts("+vtune", when="@composer.0:composer")
+
+    conflicts("+clck", when="@professional.0:professional")
+    conflicts("+itac", when="@professional.0:professional")
+    conflicts("+mpi", when="@professional.0:professional")
+
+    # The following components are not available before 2016
+    conflicts("+daal", when="@professional.0:professional.2015.7")
+    conflicts("+daal", when="@cluster.0:cluster.2015.7")
+    conflicts("+daal", when="@composer.0:composer.2015.7")
+
+    # MacOS does not support some of the auto dispatch settings
+    conflicts("auto_dispatch=SSE2", "platform=darwin", msg="SSE2 is not supported on MacOS")
+    conflicts(
+        "auto_dispatch=SSE3",
+        "platform=darwin target=x86_64:",
+        msg="SSE3 is not supported on MacOS x86_64",
+    )
+
+    def setup_dependent_build_environment(self, env, dependent_spec):
+        # Handle in callback, conveying client's compilers in additional arg.
+        # CAUTION - DUP code in:
+        #   ../intel-mpi/package.py
+        #   ../intel-parallel-studio/package.py
+        dependent_module = dependent_spec.package.module
+        self._setup_dependent_env_callback(
+            env,
+            dependent_spec,
+            compilers_of_client={
+                "CC": dependent_module.spack_cc,
+                "CXX": dependent_module.spack_cxx,
+                "F77": dependent_module.spack_f77,
+                "F90": dependent_module.spack_fc,
+                "FC": dependent_module.spack_fc,
+            },
+        )
+
+    def setup_run_environment(self, env):
+        super().setup_run_environment(env)
+
+        for name, value in self.mpi_compiler_wrappers.items():
+            env.set(name, value)

var/spack/repos/builtin/packages/intel/detection_test.yaml

@@ -0,0 +1,25 @@
+paths:
+- layout:
+  - executables:
+    - "bin/intel64/icc"
+    script: |
+      echo "icc (ICC) 18.0.5 20180823"
+      echo "Copyright (C) 1985-2018 Intel Corporation.  All rights reserved."
+  - executables:
+    - "bin/intel64/icpc"
+    script: |
+      echo "icpc (ICC) 18.0.5 20180823"
+      echo "Copyright (C) 1985-2018 Intel Corporation.  All rights reserved."
+  - executables:
+    - "bin/intel64/ifort"
+    script: |
+      echo "ifort (IFORT) 18.0.5 20180823"
+      echo "Copyright (C) 1985-2018 Intel Corporation.  All rights reserved."
+  platforms: ["darwin", "linux"]
+  results:
+  - spec: 'intel@18.0.5'
+    extra_attributes:
+      compilers:
+        c: ".*/bin/intel64/icc"
+        cxx: ".*/bin/intel64/icpc"
+        fortran: ".*/bin/intel64/ifort"

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

@@ -0,0 +1,289 @@
+# Copyright Spack Project Developers. See COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+import re
+
+import llnl.util.tty as tty
+
+import spack.build_systems.compiler
+from spack.package import *
+
+
+@IntelOneApiPackage.update_description
+class Intel(IntelPackage):
+    """Intel Compilers. This package has been replaced by
+    intel-oneapi-compilers.
+
+    """
+
+    homepage = "https://software.intel.com/en-us/intel-parallel-studio-xe"
+
+    # Robert Cohn
+    maintainers("rscohn2")
+
+    depends_on("patchelf", type="build")
+
+    # Same as in ../intel-parallel-studio/package.py, Composer Edition,
+    # but the version numbering in Spack differs.
+    version(
+        "20.0.4",
+        sha256="ac1efeff608a8c3a416e6dfe20364061e8abf62d35fbaacdffe3fc9676fc1aa3",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/17117/parallel_studio_xe_2020_update4_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "20.0.2",
+        sha256="42af16e9a91226978bb401d9f17b628bc279aa8cb104d4a38ba0808234a79bdd",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/16759/parallel_studio_xe_2020_update2_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "20.0.1",
+        sha256="26c7e7da87b8a83adfd408b2a354d872be97736abed837364c1bf10f4469b01e",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/16530/parallel_studio_xe_2020_update1_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "20.0.0",
+        sha256="9168045466139b8e280f50f0606b9930ffc720bbc60bc76f5576829ac15757ae",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/16229/parallel_studio_xe_2020_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "19.1.2",
+        sha256="42af16e9a91226978bb401d9f17b628bc279aa8cb104d4a38ba0808234a79bdd",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/16759/parallel_studio_xe_2020_update2_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "19.1.1",
+        sha256="26c7e7da87b8a83adfd408b2a354d872be97736abed837364c1bf10f4469b01e",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/16530/parallel_studio_xe_2020_update1_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "19.1.0",
+        sha256="9168045466139b8e280f50f0606b9930ffc720bbc60bc76f5576829ac15757ae",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/16229/parallel_studio_xe_2020_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "19.0.5",
+        sha256="e8c8e4b9b46826a02c49325c370c79f896858611bf33ddb7fb204614838ad56c",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/15813/parallel_studio_xe_2019_update5_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "19.0.4",
+        sha256="1915993445323e1e78d6de73702a88fa3df2036109cde03d74ee38fef9f1abf2",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/15537/parallel_studio_xe_2019_update4_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "19.0.3",
+        sha256="15373ac6df2a84e6dd9fa0eac8b5f07ab00cdbb67f494161fd0d4df7a71aff8e",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/15272/parallel_studio_xe_2019_update3_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "19.0.1",
+        sha256="db000cb2ebf411f6e91719db68a0c68b8d3f7d38ad7f2049ea5b2f1b5f006c25",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/14832/parallel_studio_xe_2019_update1_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "19.0.0",
+        sha256="e1a29463038b063e01f694e2817c0fcf1a8e824e24f15a26ce85f20afa3f963a",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/13581/parallel_studio_xe_2019_composer_edition.tgz",
+        deprecated=True,
+    )
+
+    # Version 18.0.5 comes with parallel studio 2018 update 4. See:
+    # https://software.intel.com/en-us/articles/intel-compiler-and-composer-update-version-numbers-to-compiler-version-number-mapping
+    version(
+        "18.0.5",
+        sha256="94aca8f091dff9535b02f022a37aef150b36925c8ef069335621496f8e4db267",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/13722/parallel_studio_xe_2018_update4_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "18.0.3",
+        sha256="f21f7759709a3d3e3390a8325fa89ac79b1fce8890c292e73b2ba3ec576ebd2b",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/13002/parallel_studio_xe_2018_update3_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "18.0.2",
+        sha256="02d2a9fb10d9810f85dd77700215c4348d2e4475e814e4f086eb1442462667ff",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12722/parallel_studio_xe_2018_update2_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "18.0.1",
+        sha256="db9aa417da185a03a63330c9d76ee8e88496ae6b771584d19003a29eedc7cab5",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12381/parallel_studio_xe_2018_update1_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "18.0.0",
+        sha256="ecad64360fdaff2548a0ea250a396faf680077c5a83c3c3ce2c55f4f4270b904",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12067/parallel_studio_xe_2018_composer_edition.tgz",
+        deprecated=True,
+    )
+    #
+    version(
+        "17.0.7",
+        sha256="661e33b68e47bf335694d2255f5883955234e9085c8349783a5794eed2a937ad",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12860/parallel_studio_xe_2017_update7_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "17.0.6",
+        sha256="771f50746fe130ea472394c42e25d2c7edae049ad809d2050945ef637becf65f",
+        url="https://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12538/parallel_studio_xe_2017_update6_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "17.0.5",
+        sha256="ede4ea9351fcf263103588ae0f130b4c2a79395529cdb698b0d6e866c4871f78",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/12144/parallel_studio_xe_2017_update5_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "17.0.4",
+        sha256="4304766f80206a27709be61641c16782fccf2b3fcf7285782cce921ddc9b10ff",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/11541/parallel_studio_xe_2017_update4_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "17.0.3",
+        sha256="3648578d7bba993ebb1da37c173979bfcfb47f26e7f4e17f257e78dea8fd96ab",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/11464/parallel_studio_xe_2017_update3_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "17.0.2",
+        sha256="abd26ab2a703e73ab93326984837818601c391782a6bce52da8b2a246798ad40",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/11302/parallel_studio_xe_2017_update2_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "17.0.1",
+        sha256="bc592abee829ba6e00a4f60961b486b80c15987ff1579d6560186407c84add6f",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/10978/parallel_studio_xe_2017_update1_composer_edition.tgz",
+        deprecated=True,
+    )
+    version(
+        "17.0.0",
+        sha256="d218db66a5bb57569bea00821ac95d4647eda7422bf8a178d1586b0fb314935a",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/9656/parallel_studio_xe_2017_composer_edition.tgz",
+        deprecated=True,
+    )
+    #
+    version(
+        "16.0.4",
+        sha256="17606c52cab6f5114223a2425923c8dd69f1858f5a3bdf280e0edea49ebd430d",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/9785/parallel_studio_xe_2016_composer_edition_update4.tgz",
+        deprecated=True,
+    )
+    version(
+        "16.0.3",
+        sha256="fcec90ba97533e4705077e0701813b5a3bcc197b010b03e96f83191a35c26acf",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/9063/parallel_studio_xe_2016_composer_edition_update3.tgz",
+        deprecated=True,
+    )
+    version(
+        "16.0.2",
+        sha256="6309ef8be1abba7737d3c1e17af64ca2620672b2da57afe2c3c643235f65b4c7",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/8680/parallel_studio_xe_2016_composer_edition_update2.tgz",
+        deprecated=True,
+    )
+    #
+    # Grandfathered release; different directory structure.
+    version(
+        "15.0.6",
+        sha256="b1e09833469ca76a2834cd0a5bb5fea11ec9986da85abf4c6eed42cd96ec24cb",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/8432/l_compxe_2015.6.233.tgz",
+        deprecated=True,
+    )
+    version(
+        "15.0.1",
+        sha256="8a438fe20103e27bfda132955616d0c886aa6cfdd86dcd9764af5d937a8799d9",
+        url="http://registrationcenter-download.intel.com/akdlm/IRC_NAS/tec/4933/l_compxe_2015.1.133.tgz",
+        deprecated=True,
+    )
+
+    variant("rpath", default=True, description="Add rpath to .cfg files")
+
+    auto_dispatch_options = IntelPackage.auto_dispatch_options
+    variant(
+        "auto_dispatch",
+        values=any_combination_of(*auto_dispatch_options),
+        description="Enable generation of multiple auto-dispatch code paths",
+    )
+
+    # MacOS does not support some of the auto dispatch settings
+    conflicts("auto_dispatch=SSE2", "platform=darwin", msg="SSE2 is not supported on MacOS")
+    conflicts(
+        "auto_dispatch=SSE3",
+        "platform=darwin target=x86_64:",
+        msg="SSE3 is not supported on MacOS x86_64",
+    )
+
+    executables = ["^icc$", "^icpc$", "^ifort$"]
+
+    @classmethod
+    def determine_version(cls, exe):
+        version_regex = re.compile(r"\((?:IFORT|ICC)\) ([^ ]+)")
+        try:
+            output = spack.build_systems.compiler.compiler_output(
+                exe, version_argument="--version"
+            )
+            match = version_regex.search(output)
+            if match:
+                return match.group(1)
+        except ProcessError:
+            pass
+        except Exception as e:
+            tty.debug(str(e))
+
+        return None
+
+    @classmethod
+    def determine_variants(cls, exes, version_str):
+        compilers = {}
+        for exe in exes:
+            if "icc" in exe:
+                compilers["c"] = exe
+            if "icpc" in exe:
+                compilers["cxx"] = exe
+            if "ifort" in exe:
+                compilers["fortran"] = exe
+        return "", {"compilers": compilers}
+
+    @property
+    def cc(self):
+        msg = "cannot retrieve C compiler [spec is not concrete]"
+        assert self.spec.concrete, msg
+        if self.spec.external:
+            return self.spec.extra_attributes["compilers"].get("c", None)
+        return str(self.spec.prefix.bin.intel64.icc)
+
+    @property
+    def cxx(self):
+        msg = "cannot retrieve C++ compiler [spec is not concrete]"
+        assert self.spec.concrete, msg
+        if self.spec.external:
+            return self.spec.extra_attributes["compilers"].get("cxx", None)
+        return str(self.spec.prefix.bin.intel64.icpc)
+
+    @property
+    def fortran(self):
+        msg = "cannot retrieve Fortran compiler [spec is not concrete]"
+        assert self.spec.concrete, msg
+        if self.spec.external:
+            return self.spec.extra_attributes["compilers"].get("fortran", None)
+        return str(self.spec.prefix.bin.intel64.ifort)
+
+    # Since the current package is a subset of 'intel-parallel-studio',
+    # all remaining Spack actions are handled in the package class.

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

@@ -83,7 +83,7 @@ def edit(self, spec, prefix):
             vinc += " -DHAVE_LAPACK_CONFIG_H"
             vinc += " -DLAPACK_COMPLEX_STRUCTURE"
             filter_file("#PLATFORM=lapack", vinc, mf, string=True)
-        elif ltype == "intel-oneapi-mkl":
+        elif ltype == "intel-mkl":
             vpla = "PLATFORM=mkl"
             filter_file("#PLATFORM=lapack", vinc, mf, string=True)
 

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

@@ -75,7 +75,7 @@ class Itk(CMakePackage):
     )
 
     def cmake_args(self):
-        use_mkl = self.spec.satisfies("^[virtuals=fftw-api] intel-oneapi-mkl")
+        use_mkl = self.spec["fftw-api"].name in INTEL_MATH_LIBRARIES
         args = [
             self.define("BUILD_TESTING", False),
             self.define("BUILD_SHARED_LIBS", True),

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

@@ -73,7 +73,9 @@ def install(self, spec, prefix):
             configure_args.append("--atlas-root=" + spec["blas"].prefix)
             if "+pthread" in spec["blas"].variants:
                 configure_args.append("--threaded-atlas")
-        elif spec.satisfies("^[virtuals=blas] intel-oneapi-mkl"):
+        elif spec.satisfies("^[virtuals=blas] intel-parallel-studio") or spec.satisfies(
+            "^[virtuals=blas] intel-mkl"
+        ):
             configure_args.append("--mathlib=MKL")
             configure_args.append("--mkl-root=" + spec["blas"].prefix.mkl)
             if "+openmp" in spec["blas"].variants:

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

@@ -28,13 +28,14 @@ class Ldak(Package):
     depends_on("blas")
     depends_on("lapack")
     depends_on("openblas threads=openmp", when="^[virtuals=blas] openblas")
+    depends_on("intel-mkl threads=openmp", when="^[virtuals=blas] intel-mkl")
     depends_on("intel-oneapi-mkl threads=openmp", when="^[virtuals=blas] intel-oneapi-mkl")
     depends_on("glpk", when="+glpk")
 
     requires("target=x86_64:", when="~glpk", msg="bundled qsopt is only for x86_64")
     requires(
-        "^[virtuals=lapack] openblas",
-        "^[virtuals=lapack] intel-oneapi-mkl",
+        "^openblas",
+        *[f"^{intel_pkg}" for intel_pkg in INTEL_MATH_LIBRARIES],
         policy="one_of",
         msg="Only mkl or openblas are supported for blas/lapack with ldak",
     )

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

@@ -22,8 +22,6 @@ class Libfabric(AutotoolsPackage, CudaPackage):
     license("GPL-2.0-or-later")
 
     version("main", branch="main")
-    version("2.1.0", sha256="97df312779e2d937246d2f46385b700e0958ed796d6fed7aae77e2d18923e19f")
-    version("2.0.0", sha256="1a8e40f1f331d6ee2e9ace518c0088a78c8a838968f8601c2b77fd012a7bf0f5")
     version("1.22.0", sha256="485e6cafa66c9e4f6aa688d2c9526e274c47fda3a783cf1dd8f7c69a07e2d5fe")
     version("1.21.1", sha256="54befa6697352f3179c79c4a79225ae71694f29eefad5d0d5a14b5444ff986dd")
     version("1.21.0", sha256="0c1b7b830d9147f661e5d7f359250b85b5a9885c330464cd3b5e5d35b86551c7")
@@ -72,7 +70,6 @@ class Libfabric(AutotoolsPackage, CudaPackage):
         "cxi",
         "efa",
         "gni",
-        "lnx",
         "mlx",
         "mrail",
         "opx",
@@ -141,7 +138,6 @@ class Libfabric(AutotoolsPackage, CudaPackage):
 
     conflicts("@1.9.0", when="platform=darwin", msg="This distribution is missing critical files")
     conflicts("fabrics=opx", when="@:1.14.99")
-    conflicts("fabrics=lnx", when="@:1")
     conflicts(
         "fabrics=opx",
         when="@1.20.0",

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

@@ -20,7 +20,6 @@ def url_for_version(self, version):
 
     license("GPLv2", checked_by="teaguesterling")
 
-    version("43.2", sha256="55a7444ec1fbb95c086d40967388f231b5c0bbc8cffaa086bf9290ae449e51d5")
     version("43.0", sha256="905bcdb85847d6b8f8861e56b30cd6dc61eae67ecef4cd994a9f925a26a2c1fe")
     version("40.1", sha256="03134fa114ef3fbe34075aa83678f58aa2debe9fcef4ea23c0779e28601d6611")
     version("3.36.0", sha256="bc508150b3ed5d22354b0e6774ad4eee465381ebc0ace45eb0e2d3a4186c925f")

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

@@ -31,6 +31,8 @@ class Ligra(MakefilePackage):
     def setup_build_environment(self, env):
         if self.spec.satisfies("+openmp"):
             env.set("OPENMP", "1")
+        # when +mkl, MKLROOT will be defined by intel-mkl package,
+        # triggering a build with mkl support
 
     def setup_run_environment(self, env):
         env.prepend_path("PATH", self.prefix.apps)

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

@@ -65,7 +65,6 @@ class Mercury(CMakePackage):
     with when("+ofi"):
         depends_on("libfabric@1.5:", when="@:2.0.1")
         depends_on("libfabric@1.7:", when="@2.1.0:")
-        conflicts("libfabric@2:", when="@:2.4.0")
     # openpa dependency is removed in 2.1.0
     depends_on("openpa@1.0.3:", when="@:2.0.1%gcc@:4.8")
     # We only need Boost preprocessor headers

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

@@ -85,11 +85,12 @@ def edit(self, spec, prefix):
         flags["PREFIX"] = prefix
 
         # Set LAPACK and SCALAPACK
-        if spec.satisfies("^[virtuals=scalapack] intel-oneapi-mkl") or spec.satisfies(
-            "^[virtuals=lapack] intel-oneapi-mkl"
+        if (
+            spec["scalapack"].name in INTEL_MATH_LIBRARIES
+            or spec["lapack"].name in INTEL_MATH_LIBRARIES
+            or spec["blas"].name in INTEL_MATH_LIBRARIES
         ):
             flags["LAPACK"] = self._get_mkl_ld_flags(spec)
-            flags["CPPFLAGS"] = flags.get("CPPFLAGS", "") + " -DHAVE_MKL "
         else:
             flags["LAPACK"] = spec["lapack"].libs.ld_flags + " " + spec["blas"].libs.ld_flags
             if "+scalapack" in spec:
@@ -115,6 +116,13 @@ def edit(self, spec, prefix):
         if "+scalapack" in spec:
             flags["CPPFLAGS"] = flags.get("CPPFLAGS", "") + " -DHAVE_SCALAPACK -DHAVE_MPI "
 
+        if (
+            spec["lapack"].name in INTEL_MATH_LIBRARIES
+            or spec["scalapack"].name in INTEL_MATH_LIBRARIES
+            or spec["blas"].name in INTEL_MATH_LIBRARIES
+        ):
+            flags["CPPFLAGS"] = flags.get("CPPFLAGS", "") + " -DHAVE_MKL "
+
         # Write configuration file
         with open("my_machine.arch", "w") as f:
             for k, v in flags.items():

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

@@ -12,6 +12,17 @@
 import spack.version
 from spack.package import *
 
+FC_PATH: Dict[str, str] = dict()
+
+
+def get_latest_valid_fortran_pth():
+    """Assign maximum available fortran compiler version"""
+    # TODO (johnwparent): validate compatibility w/ try compiler
+    # functionality when added
+    sort_fn = lambda fc_ver: Version(fc_ver)
+    sort_fc_ver = sorted(list(FC_PATH.keys()), key=sort_fn)
+    return FC_PATH[sort_fc_ver[-1]] if sort_fc_ver else None
+
 
 class Msvc(Package, CompilerPackage):
     """
@@ -26,9 +37,10 @@ def install(self, spec, prefix):
             "detected on a system where they are externally installed"
         )
 
-    compiler_languages = ["c", "cxx"]
+    compiler_languages = ["c", "cxx", "fortran"]
     c_names = ["cl"]
     cxx_names = ["cl"]
+    fortran_names = ["ifx", "ifort"]
 
     compiler_version_argument = ""
     compiler_version_regex = r"([1-9][0-9]*\.[0-9]*\.[0-9]*)"
@@ -38,7 +50,7 @@ def install(self, spec, prefix):
     # based on proper versions of MSVC from there
     # pending acceptance of #28117 for full support using
     # compiler wrappers
-    compiler_wrapper_link_paths = {"c": "", "cxx": ""}
+    compiler_wrapper_link_paths = {"c": "", "cxx": "", "fortran": ""}
 
     provides("c", "cxx")
     requires("platform=windows", msg="MSVC is only supported on Windows")
@@ -47,6 +59,7 @@ def install(self, spec, prefix):
     def determine_version(cls, exe):
         # MSVC compiler does not have a proper version argument
         # Errors out and prints version info with no args
+        is_ifx = "ifx.exe" in str(exe)
         match = re.search(
             cls.compiler_version_regex,
             spack.build_systems.compiler.compiler_output(
@@ -54,6 +67,8 @@ def determine_version(cls, exe):
             ),
         )
         if match:
+            if is_ifx:
+                FC_PATH[match.group(1)] = str(exe)
             return match.group(1)
 
     @classmethod
@@ -61,6 +76,18 @@ def determine_variants(cls, exes, version_str):
         # MSVC uses same executable for both languages
         spec, extras = super().determine_variants(exes, version_str)
         extras["compilers"]["c"] = extras["compilers"]["cxx"]
+        # This depends on oneapi being processed before msvc
+        # which is guarunteed from detection behavior.
+        # Processing oneAPI tracks oneAPI installations within
+        # this module, which are then used to populate compatible
+        # MSVC version's fortran compiler spots
+
+        # TODO: remove this once #45189 lands
+        # TODO: interrogate intel and msvc for compatibility after
+        # #45189 lands
+        fortran_compiler = get_latest_valid_fortran_pth()
+        if fortran_compiler is not None:
+            extras["compilers"]["fortran"] = fortran_compiler
         return spec, extras
 
     def setup_dependent_build_environment(self, env, dependent_spec):
@@ -276,3 +303,15 @@ def vcvars_ver(self):
     def command_str(self):
         script = super(VCVarsInvocation, self).command_str()
         return f"{script} {self.arch} {self.sdk_ver} {self.vcvars_ver}"
+
+
+FC_PATH = {}
+
+
+def get_valid_fortran_pth():
+    """Assign maximum available fortran compiler version"""
+    # TODO (johnwparent): validate compatibility w/ try compiler
+    # functionality when added
+    sort_fn = lambda fc_ver: spack.version.Version(fc_ver)
+    sort_fc_ver = sorted(list(FC_PATH.keys()), key=sort_fn)
+    return FC_PATH[sort_fc_ver[-1]] if sort_fc_ver else None

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

@@ -236,9 +236,7 @@ def write_makefile_inc(self):
         # As of version 5.2.0, MUMPS is able to take advantage
         # of the GEMMT BLAS extension. MKL and amdblis are the only
         # known BLAS implementation supported.
-        if self.spec.satisfies("^[virtuals=blas] intel-oneapi-mkl") and self.spec.satisfies(
-            "@5.2.0:"
-        ):
+        if self.spec["blas"].name in INTEL_MATH_LIBRARIES and self.spec.satisfies("@5.2.0:"):
             optf.append("-DGEMMT_AVAILABLE")
 
         if "@5.2.0: ^amdblis@3.0:" in self.spec:

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

@@ -72,7 +72,12 @@ class Ngspice(AutotoolsPackage):
         depends_on("cray-fftw+openmp", when="^[virtuals=fftw-api] cray-fftw")
         depends_on("fftw+openmp", when="^[virtuals=fftw-api] fftw")
         depends_on("fujitsu-fftw+openmp", when="^[virtuals=fftw-api] fujitsu-fftw")
+        depends_on("intel-mkl threads=openmp", when="^[virtuals=fftw-api] intel-mkl")
         depends_on("intel-oneapi-mkl threads=openmp", when="^[virtuals=fftw-api] intel-oneapi-mkl")
+        depends_on(
+            "intel-parallel-studio threads=openmp",
+            when="^[virtuals=fftw-api] intel-parallel-studio",
+        )
 
     with when("+fft~openmp"):
         depends_on("acfl threads=none", when="^[virtuals=fftw-api] acfl")
@@ -81,7 +86,11 @@ class Ngspice(AutotoolsPackage):
         depends_on("cray-fftw~openmp", when="^[virtuals=fftw-api] cray-fftw")
         depends_on("fftw~openmp", when="^[virtuals=fftw-api] fftw")
         depends_on("fujitsu-fftw~openmp", when="^[virtuals=fftw-api] fujitsu-fftw")
+        depends_on("intel-mkl threads=none", when="^[virtuals=fftw-api] intel-mkl")
         depends_on("intel-oneapi-mkl threads=none", when="^[virtuals=fftw-api] intel-oneapi-mkl")
+        depends_on(
+            "intel-parallel-studio threads=none", when="^[virtuals=fftw-api] intel-parallel-studio"
+        )
 
     depends_on("readline", when="+readline build=bin")
 

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

@@ -44,13 +44,6 @@ class Nlcglib(CMakePackage, CudaPackage, ROCmPackage):
     depends_on("mpi")
     depends_on("lapack")
 
-    requires(
-        "^[virtuals=lapack] openblas",
-        "^[virtuals=lapack] intel-oneapi-mkl",
-        policy="one_of",
-        msg="Only mkl or openblas are supported for blas/lapack with ldak",
-    )
-
     depends_on("kokkos~cuda~rocm", when="~cuda~rocm")
     depends_on("kokkos+openmp", when="+openmp")
 
@@ -88,10 +81,13 @@ def cmake_args(self):
             self.define_from_variant("USE_CUDA", "cuda"),
         ]
 
-        if self.spec.satisfies("^[virtuals=lapack] intel-oneapi-mkl"):
+        if self.spec["blas"].name in ["intel-mkl", "intel-parallel-studio"]:
+            options += [self.define("LAPACK_VENDOR", "MKL")]
+        elif self.spec["blas"].name in ["intel-oneapi-mkl"]:
+            options += [self.define("LAPACK_VENDOR", "MKLONEAPI")]
             mkl_mapper = {
                 "threading": {"none": "sequential", "openmp": "gnu_thread", "tbb": "tbb_thread"},
-                "mpi": {"intel-oneapi-mpi": "intelmpi", "mpich": "mpich", "openmpi": "openmpi"},
+                "mpi": {"intel-mpi": "intelmpi", "mpich": "mpich", "openmpi": "openmpi"},
             }
 
             mkl_threads = mkl_mapper["threading"][
@@ -106,20 +102,23 @@ def cmake_args(self):
 
             options.extend(
                 [
-                    self.define("LAPACK_VENDOR", "MKLONEAPI"),
                     self.define("MKL_INTERFACE", "lp64"),
                     self.define("MKL_THREADING", mkl_threads),
                     self.define("MKL_MPI", mkl_mpi),
                 ]
             )
 
+        elif self.spec["blas"].name in ["openblas"]:
+            options += [self.define("LAPACK_VENDOR", "OpenBLAS")]
         else:
-            options.append(self.define("LAPACK_VENDOR", "OpenBLAS"))
+            raise Exception("blas/lapack must be either openblas or mkl.")
 
         if "+cuda%gcc" in self.spec:
-            options.append(
-                self.define("CMAKE_CXX_COMPILER", self["kokkos-nvcc-wrapper"].kokkos_cxx)
+            options += [
+                self.define(
+                    "CMAKE_CXX_COMPILER", "{0}".format(self["kokkos-nvcc-wrapper"].kokkos_cxx)
                 )
+            ]
 
         if "+cuda" in self.spec:
             cuda_archs = self.spec.variants["cuda_arch"].value
@@ -127,23 +126,19 @@ def cmake_args(self):
                 cuda_flags = " ".join(
                     ["-gencode arch=compute_{0},code=sm_{0}".format(x) for x in cuda_archs]
                 )
-                options.append(self.define("CMAKE_CUDA_FLAGS", cuda_flags))
+                options += [self.define("CMAKE_CUDA_FLAGS", cuda_flags)]
             else:
-                options.append(self.define("CMAKE_CUDA_ARCHITECTURES", cuda_archs))
+                options += [self.define("CMAKE_CUDA_ARCHITECTURES", cuda_archs)]
 
         if "^cuda+allow-unsupported-compilers" in self.spec:
-            options.append(self.define("CMAKE_CUDA_FLAGS", "--allow-unsupported-compiler"))
+            options += [self.define("CMAKE_CUDA_FLAGS", "--allow-unsupported-compiler")]
 
         if "+rocm" in self.spec:
+            options.append(self.define("CMAKE_CXX_COMPILER", self.spec["hip"].hipcc))
             archs = ",".join(self.spec.variants["amdgpu_target"].value)
-            options.extend(
-                [
-                    self.define("CMAKE_CXX_COMPILER", self.spec["hip"].hipcc),
-                    self.define("HIP_HCC_FLAGS", f"--amdgpu-target={archs}"),
-                    self.define(
-                        "CMAKE_CXX_FLAGS", f"--amdgpu-target={archs} --offload-arch={archs}"
-                    ),
-                ]
+            options.append("-DHIP_HCC_FLAGS=--amdgpu-target={0}".format(archs))
+            options.append(
+                "-DCMAKE_CXX_FLAGS=--amdgpu-target={0} --offload-arch={0}".format(archs)
             )
 
         return options

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

@@ -181,7 +181,7 @@ def configure_args(self):
 
         if "^fftw" in spec:
             args.append("--with-fftw-prefix=%s" % spec["fftw"].prefix)
-        elif spec.satisfies("^[virtuals=fftw-api] intel-oneapi-mkl"):
+        elif spec["fftw-api"].name in INTEL_MATH_LIBRARIES:
             # As of version 10.0, Octopus depends on fftw-api instead
             # of FFTW. If FFTW is not in the dependency tree, then
             # it ought to be MKL as it is currently the only providers

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

@@ -43,14 +43,11 @@ class Openmpi(AutotoolsPackage, CudaPackage):
     version("main", branch="main", submodules=True)
 
     # Current
-    version(
-        "5.0.7", sha256="119f2009936a403334d0df3c0d74d5595a32d99497f9b1d41e90019fee2fc2dd"
-    )  # libmpi.so.40.40.7
-
-    # Still supported
     version(
         "5.0.6", sha256="bd4183fcbc43477c254799b429df1a6e576c042e74a2d2f8b37d537b2ff98157"
     )  # libmpi.so.40.40.6
+
+    # Still supported
     version(
         "5.0.5", sha256="6588d57c0a4bd299a24103f4e196051b29e8b55fbda49e11d5b3d32030a32776"
     )  # libmpi.so.40.40.5

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

@@ -85,11 +85,11 @@ def cmake_args(self):
             args.extend([self.define("PASTIX_WITH_STARPU", "ON")])
             args.extend([self.define_from_variant("PASTIX_WITH_CUDA", "cuda")])
 
-        if spec.satisfies("^[virtuals=lapack] intel-oneapi-mkl"):
+        if "^intel-mkl" in spec or "^intel-parallel-studio+mkl" in spec:
             args.extend([self.define("BLA_VENDOR", "Intel10_64lp_seq")])
-        elif spec.satisfies("^[virtuals=lapack] netlib-lapack"):
+        elif "^netlib-lapack" in spec:
             args.extend([self.define("BLA_VENDOR", "Generic")])
-        elif spec.satisfies("^[virtuals=lapack] openblas"):
+        elif "^openblas" in spec:
             args.extend([self.define("BLA_VENDOR", "OpenBLAS")])
 
         if spec.satisfies("+mpi"):

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

@@ -292,6 +292,9 @@ class Petsc(Package, CudaPackage, ROCmPackage):
             when="@3.20.2:3.20.4 ^hipsparse@6.0",
         )
 
+    # 3.8.0 has a build issue with MKL - so list this conflict explicitly
+    conflicts("^intel-mkl", when="@3.8.0")
+
     # These require +mpi
     mpi_msg = "Requires +mpi"
     conflicts("+cgns", when="~mpi", msg=mpi_msg)

var/spack/repos/builtin/packages/py-contrib/package.py

@@ -1,23 +0,0 @@
-# Copyright Spack Project Developers. See COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-
-from spack.package import *
-
-
-class PyContrib(PythonPackage):
-    """A python package for making stacked area plots of contributions over time."""
-
-    homepage = "https://github.com/spack/contrib"
-    pypi = "contrib/contrib-0.3.0.tar.gz"
-
-    license("Apache-2.0 OR MIT")
-
-    version("0.3.0", sha256="55cf3a414c8b136f58588ec02e6833d1cc1d227a78f1778354ac6fcf9c2ccdda")
-
-    with default_args(type=("build", "run")):
-        depends_on("py-python-dateutil")
-        depends_on("py-jsonschema")
-        depends_on("py-matplotlib")
-        depends_on("py-pyyaml")
-        depends_on("py-setuptools")

var/spack/repos/builtin/packages/py-devito/package.py

@@ -56,6 +56,7 @@ class PyDevito(PythonPackage):
 
     depends_on("mpi", type=("build", "run"), when="+mpi")
 
+    depends_on("intel-parallel-studio", type="run", when="%intel@:2021.1.1")
     depends_on("intel-oneapi-compilers", type="run", when="%intel@2021.1.2:")
 
     patch("4.8.1.patch", when="@4.8.1")

var/spack/repos/builtin/packages/py-jax/package.py

@@ -20,13 +20,13 @@ class PyJax(PythonPackage):
     maintainers("adamjstewart", "jonas-eschle")
 
     # version("0.5.0", sha256="49df70bf293a345a7fb519f71193506d37a024c4f850b358042eb32d502c81c8")
-    version("0.4.38", sha256="43bae65881628319e0a2148e8f81a202fbc2b8d048e35c7cb1df2416672fa4a8")
-    version("0.4.37", sha256="7774f3d9e23fe199c65589c680c5a5be87a183b89598421a632d8245222b637b")
-    version("0.4.36", sha256="088bff0575d01fc82682a9af4eb07433d60de7e5164686bd2cea3439492e608a")
-    version("0.4.35", sha256="c0c986993026b10bf6f607fecb7417377460254640766ce40f1fef3fd139c12e")
-    version("0.4.34", sha256="44196854f40c5f9cea3142824b9f1051f85afc3fcf7593ec5479fc8db01c58db")
-    version("0.4.33", sha256="f0d788692fc0179653066c9e1c64e57311b8c15a389837fd7baf328abefcbb92")
-    version("0.4.32", sha256="eb703909968da161894fb6135a931c5f3d2aab64fff7cba5fcb803ce6d968e08")
+    # version("0.4.38", sha256="43bae65881628319e0a2148e8f81a202fbc2b8d048e35c7cb1df2416672fa4a8")
+    # version("0.4.37", sha256="7774f3d9e23fe199c65589c680c5a5be87a183b89598421a632d8245222b637b")
+    # version("0.4.36", sha256="088bff0575d01fc82682a9af4eb07433d60de7e5164686bd2cea3439492e608a")
+    # version("0.4.35", sha256="c0c986993026b10bf6f607fecb7417377460254640766ce40f1fef3fd139c12e")
+    # version("0.4.34", sha256="44196854f40c5f9cea3142824b9f1051f85afc3fcf7593ec5479fc8db01c58db")
+    # version("0.4.33", sha256="f0d788692fc0179653066c9e1c64e57311b8c15a389837fd7baf328abefcbb92")
+    # version("0.4.32", sha256="eb703909968da161894fb6135a931c5f3d2aab64fff7cba5fcb803ce6d968e08")
     version("0.4.31", sha256="fd2d470643a0073d822737f0788f71391656af7e62cc5b2e7995ee390ceac287")
     version("0.4.30", sha256="94d74b5b2db0d80672b61d83f1f63ebf99d2ab7398ec12b2ca0c9d1e97afe577")
     version("0.4.29", sha256="12904571eaefddcdc8c3b8d4936482b783d5a216e99ef5adcd3522fdfb4fc186")
@@ -85,13 +85,13 @@ class PyJax(PythonPackage):
         # https://github.com/google/jax/commit/8be057de1f50756fe7522f7e98b2f30fad56f7e4
         for v in [
             # "0.5.0",
-            "0.4.38",
-            "0.4.37",
-            "0.4.36",
-            "0.4.35",
-            "0.4.34",
-            "0.4.33",
-            "0.4.32",
+            # "0.4.38",
+            # "0.4.37",
+            # "0.4.36",
+            # "0.4.35",
+            # "0.4.34",
+            # "0.4.33",
+            # "0.4.32",
             "0.4.31",
             "0.4.30",
             "0.4.29",
@@ -126,12 +126,12 @@ class PyJax(PythonPackage):
 
         # See _minimum_jaxlib_version in jax/version.py
         # depends_on("py-jaxlib@0.5:", when="@0.5:")
-        depends_on("py-jaxlib@0.4.38:", when="@0.4.38:")
-        depends_on("py-jaxlib@0.4.36:", when="@0.4.36:")
-        depends_on("py-jaxlib@0.4.35:", when="@0.4.35:")
-        depends_on("py-jaxlib@0.4.34:", when="@0.4.34:")
-        depends_on("py-jaxlib@0.4.33:", when="@0.4.33:")
-        depends_on("py-jaxlib@0.4.32:", when="@0.4.32:")
+        # depends_on("py-jaxlib@0.4.38:", when="@0.4.38:")
+        # depends_on("py-jaxlib@0.4.36:", when="@0.4.36:")
+        # depends_on("py-jaxlib@0.4.35:", when="@0.4.35:")
+        # depends_on("py-jaxlib@0.4.34:", when="@0.4.34:")
+        # depends_on("py-jaxlib@0.4.33:", when="@0.4.33:")
+        # depends_on("py-jaxlib@0.4.32:", when="@0.4.32:")
         depends_on("py-jaxlib@0.4.30:", when="@0.4.31:")
         depends_on("py-jaxlib@0.4.27:", when="@0.4.28:")
         depends_on("py-jaxlib@0.4.23:", when="@0.4.27:")

var/spack/repos/builtin/packages/py-jaxlib/package.py

@@ -8,27 +8,20 @@
 from spack.package import *
 
 rocm_dependencies = [
-    "comgr",
-    "hip",
-    "hipblas",
-    "hipblaslt",
-    "hipcub",
-    "hipfft",
-    "hiprand",
-    "hipsolver",
-    "hipsparse",
     "hsa-rocr-dev",
-    "miopen-hip",
+    "hip",
     "rccl",
-    "rocblas",
-    "rocfft",
-    "rocminfo",
     "rocprim",
-    "rocrand",
-    "rocsolver",
-    "rocsparse",
+    "hipcub",
+    "rocthrust",
     "roctracer-dev",
-    "rocm-core",
+    "rocrand",
+    "hipsparse",
+    "hipfft",
+    "rocfft",
+    "rocblas",
+    "miopen-hip",
+    "rocminfo",
 ]
 
 
@@ -46,17 +39,14 @@ class PyJaxlib(PythonPackage, CudaPackage, ROCmPackage):
     license("Apache-2.0")
     maintainers("adamjstewart", "jonas-eschle")
 
-    # version("0.5.3", sha256="1094581a30ec069965f4e3e67d60262570cc3dd016adc62073bc24347b14270c")
-    # version("0.5.2", sha256="8e9de1e012dd65fc4a9eec8af4aa2bf6782767130a5d8e1c1e342b7d658280fe")
-    # version("0.5.1", sha256="e74b1209517682075933f757d646b73040d09fe39ee3e9e4cd398407dd0902d2")
     # version("0.5.0", sha256="04cc2eeb2e7ce1916674cea03a7d75a59d583ddb779d5104e103a2798a283ce9")
-    version("0.4.38", sha256="ca1e63c488d505b9c92e81499e8b06cc1977319c50d64a0e58adbd2dae1a625c")
-    version("0.4.37", sha256="17a8444a931f26edda8ccbc921ab71c6bf46857287b1db186deebd357e526870")
-    version("0.4.36", sha256="442bfdf491b509995aa160361e23a9db488d5b97c87e6648cc733501b06eda77")
-    version("0.4.35", sha256="65e086708ae56670676b7b2340ad82b901d8c9993d1241a839c8990bdb8d6212")
-    version("0.4.34", sha256="d3a75ad667772309ade81350fa70c4a78028a920028800282e46d8383c0ee6bb")
-    version("0.4.33", sha256="122a806e80fc1cd7d8ffaf9620701f2cb8e4fe22271c2cec53a9c60b30bd4c31")
-    version("0.4.32", sha256="3fe36d596e4d640443c0a5c533845c74fbc4341e024d9bb1cd75cb49f5f419c2")
+    # version("0.4.38", sha256="ca1e63c488d505b9c92e81499e8b06cc1977319c50d64a0e58adbd2dae1a625c")
+    # version("0.4.37", sha256="17a8444a931f26edda8ccbc921ab71c6bf46857287b1db186deebd357e526870")
+    # version("0.4.36", sha256="442bfdf491b509995aa160361e23a9db488d5b97c87e6648cc733501b06eda77")
+    # version("0.4.35", sha256="65e086708ae56670676b7b2340ad82b901d8c9993d1241a839c8990bdb8d6212")
+    # version("0.4.34", sha256="d3a75ad667772309ade81350fa70c4a78028a920028800282e46d8383c0ee6bb")
+    # version("0.4.33", sha256="122a806e80fc1cd7d8ffaf9620701f2cb8e4fe22271c2cec53a9c60b30bd4c31")
+    # version("0.4.32", sha256="3fe36d596e4d640443c0a5c533845c74fbc4341e024d9bb1cd75cb49f5f419c2")
     version("0.4.31", sha256="022ea1347f9b21cbea31410b3d650d976ea4452a48ea7317a5f91c238031bf94")
     version("0.4.30", sha256="0ef9635c734d9bbb44fcc87df4f1c3ccce1cfcfd243572c80d36fcdf826fe1e6")
     version("0.4.29", sha256="3a8005f4f62d35a5aad7e3dbd596890b47c81cc6e34fcfe3dcb93b3ca7cb1246")
@@ -103,10 +93,6 @@ class PyJaxlib(PythonPackage, CudaPackage, ROCmPackage):
         for pkg_dep in rocm_dependencies:
             depends_on(f"{pkg_dep}@6:", when="@0.4.28:")
             depends_on(pkg_dep)
-        depends_on("rocprofiler-register", when="^hip@6.2:")
-        depends_on("hipblas-common", when="^hip@6.3:")
-        depends_on("hsakmt-roct", when="^hip@:6.2")
-        depends_on("llvm-amdgpu")
         depends_on("py-nanobind")
 
     with default_args(type="build"):
@@ -127,7 +113,6 @@ class PyJaxlib(PythonPackage, CudaPackage, ROCmPackage):
         depends_on("python@3.9:", when="@0.4.14:")
         depends_on("python@3.8:", when="@0.4.6:")
         depends_on("python@:3.13")
-        depends_on("python@:3.12", when="+rocm")
         depends_on("python@:3.12", when="@:0.4.33")
         depends_on("python@:3.11", when="@:0.4.16")
 
@@ -182,22 +167,6 @@ class PyJaxlib(PythonPackage, CudaPackage, ROCmPackage):
     # Fails to build with freshly released CUDA (#48708).
     conflicts("^cuda@12.8:", when="@:0.4.31")
 
-    # external CUDA is not supported https://github.com/jax-ml/jax/issues/23689
-    conflicts("+cuda", when="@0.4.32:")
-
-    # aarch64 is not supported https://github.com/jax-ml/jax/issues/25598
-    conflicts("target=aarch64:", when="@0.4.32:")
-
-    resource(
-        name="xla",
-        url="https://github.com/ROCm/xla/archive/07543ab117699a57c1267b453a62f89b1d5953fd.tar.gz",
-        sha256="cee377479654201c61cc3f230d89603cd589525fea2faf44564a23c70ba1448d",
-        expand=True,
-        destination="",
-        placement="xla",
-        when="@0.4.38:0.5.2 +rocm",
-    )
-
     def url_for_version(self, version):
         url = "https://github.com/jax-ml/jax/archive/refs/tags/{}-v{}.tar.gz"
         if version >= Version("0.4.33"):
@@ -206,20 +175,6 @@ def url_for_version(self, version):
             name = "jaxlib"
         return url.format(name, version)
 
-    def setup_build_environment(self, env):
-        spec = self.spec
-        if spec.satisfies("@0.4.38: +rocm") and not spec["hip"].external:
-            if spec.satisfies("^hip@6.2:"):
-                rocm_dependencies.append("rocprofiler-register")
-            if spec.satisfies("^hip@6.3:"):
-                rocm_dependencies.append("hipblas-common")
-            else:
-                rocm_dependencies.append("hsakmt-roct")
-            env.set("LLVM_PATH", spec["llvm-amdgpu"].prefix)
-            for pkg_dep in rocm_dependencies:
-                env.prepend_path("TF_ROCM_MULTIPLE_PATHS", spec[pkg_dep].prefix)
-                env.prune_duplicate_paths("TF_ROCM_MULTIPLE_PATHS")
-
     def install(self, spec, prefix):
         # https://jax.readthedocs.io/en/latest/developer.html
         args = ["build/build.py"]
@@ -261,15 +216,7 @@ def install(self, spec, prefix):
             args.append(f"--bazel_options=--repo_env=LOCAL_NCCL_PATH={spec['nccl'].prefix}")
 
         if "+rocm" in spec:
-            args.append(f"--rocm_path={self.spec['hip'].prefix}")
-            if spec.satisfies("@:0.4.35"):
-                args.append("--enable_rocm")
-            if spec.satisfies("@0.4.38:") and not spec["hip"].external:
-                args.append("--bazel_options=--@local_config_rocm//rocm:rocm_path_type=multiple")
-            if spec.satisfies("@0.4.38:0.5.2"):
-                args.append(
-                    f"--bazel_options=--override_repository=xla={self.stage.source_path}/xla"
-                )
+            args.extend(["--enable_rocm", f"--rocm_path={self.spec['hip'].prefix}"])
 
         args.extend(
             [
@@ -280,6 +227,5 @@ def install(self, spec, prefix):
         )
 
         python(*args)
-
-        for whl in glob.glob(join_path("dist", "*.whl")):
+        whl = glob.glob(join_path("dist", "*.whl"))[0]
         pip(*PythonPipBuilder.std_args(self), f"--prefix={self.prefix}", whl)

var/spack/repos/builtin/packages/py-numpy/package.py

@@ -289,10 +289,10 @@ def blas_lapack_pkg_config(self) -> Tuple[str, str]:
         blas = spec["blas"].libs.names[0]
         lapack = spec["lapack"].libs.names[0]
 
-        if spec["blas"].name == "intel-oneapi-mkl":
+        if spec["blas"].name in ["intel-mkl", "intel-parallel-studio", "intel-oneapi-mkl"]:
             blas = "mkl-dynamic-lp64-seq"
 
-        if spec["lapack"].name == "intel-oneapi-mkl":
+        if spec["lapack"].name in ["intel-mkl", "intel-parallel-studio", "intel-oneapi-mkl"]:
             lapack = "mkl-dynamic-lp64-seq"
 
         if spec["blas"].name in ["blis", "amdblis"]:
@@ -389,7 +389,11 @@ def write_library_dirs(f, dirs):
 
         # Tell numpy where to find BLAS/LAPACK libraries
         with open("site.cfg", "w") as f:
-            if "^intel-oneapi-mkl" in spec:
+            if (
+                "^intel-mkl" in spec
+                or "^intel-parallel-studio+mkl" in spec
+                or "^intel-oneapi-mkl" in spec
+            ):
                 f.write("[mkl]\n")
                 # FIXME: as of @1.11.2, numpy does not work with separately
                 # specified threading and interface layers. A workaround is a
@@ -493,7 +497,11 @@ def setup_build_environment(self, env):
         # https://github.com/numpy/numpy/pull/13132
         # https://numpy.org/doc/1.25/user/building.html#accelerated-blas-lapack-libraries
         # https://numpy.org/doc/1.25/user/building.html#blas
-        if spec["blas"].name == "intel-oneapi-mkl":
+        if (
+            spec["blas"].name == "intel-mkl"
+            or spec["blas"].name == "intel-parallel-studio"
+            or spec["blas"].name == "intel-oneapi-mkl"
+        ):
             blas = "mkl"
         elif spec["blas"].name == "blis" or spec["blas"].name == "amdblis":
             blas = "blis"
@@ -509,7 +517,11 @@ def setup_build_environment(self, env):
         env.set("NPY_BLAS_ORDER", blas)
 
         # https://numpy.org/doc/1.25/user/building.html#lapack
-        if spec["lapack"].name == "intel-oneapi-mkl":
+        if (
+            spec["lapack"].name == "intel-mkl"
+            or spec["lapack"].name == "intel-parallel-studio"
+            or spec["lapack"].name == "intel-oneapi-mkl"
+        ):
             lapack = "mkl"
         elif spec["lapack"].name == "openblas":
             lapack = "openblas"

var/spack/repos/builtin/packages/py-tomopy/package.py

@@ -27,6 +27,8 @@ class PyTomopy(PythonPackage):
     depends_on("cuda", when="@master")
     # The shared opencv is not found by during runtest. Not using GOT/PLT is faster too
     depends_on("opencv+imgproc~shared@3.4:", when="@master")
+    # During the runtest, the shared MKL libs aren't found yet:
+    # depends_on('intel-mkl~shared')
     depends_on("cmake@3.17:", type=("build"))
     depends_on("ninja", type=("build"))
     depends_on("py-setuptools-scm", type=("build"))

var/spack/repos/builtin/packages/py-torch/package.py

@@ -662,10 +662,14 @@ def enable_or_disable(variant, keyword="USE", var=None):
         elif self.spec["lapack"].name in ["libflame", "amdlibflame"]:
             env.set("BLAS", "FLAME")
             env.set("WITH_BLAS", "FLAME")
-        elif self.spec["blas"].name == "intel-oneapi-mkl":
+        elif self.spec["blas"].name in ["intel-mkl", "intel-parallel-studio", "intel-oneapi-mkl"]:
             env.set("BLAS", "MKL")
             env.set("WITH_BLAS", "mkl")
+            # help find MKL
+            if self.spec["mkl"].name == "intel-oneapi-mkl":
                 env.set("INTEL_MKL_DIR", self.spec["mkl"].prefix.mkl.latest)
+            else:
+                env.set("INTEL_MKL_DIR", self.spec["mkl"].prefix.mkl)
         elif self.spec["blas"].name == "openblas":
             env.set("BLAS", "OpenBLAS")
             env.set("WITH_BLAS", "open")

var/spack/repos/builtin/packages/q-e-sirius/package.py

@@ -69,9 +69,9 @@ class QESirius(CMakePackage):
     depends_on("hdf5@1.8.16:+fortran+hl~mpi", when="hdf5=serial")
 
     with when("+openmp"):
-        requires("^fftw+openmp", when="^[virtuals=fftw-api] fftw")
-        requires("^openblas threads=openmp", when="^[virtuals=blas] openblas")
-        requires("^intel-oneapi-mkl threads=openmp", when="^[virtuals=blas] intel-oneapi-mkl")
+        depends_on("fftw+openmp", when="^[virtuals=fftw-api] fftw")
+        depends_on("openblas threads=openmp", when="^[virtuals=blas] openblas")
+        depends_on("intel-mkl threads=openmp", when="^[virtuals=blas] intel-mkl")
 
     def cmake_args(self):
         args = [
@@ -92,7 +92,7 @@ def cmake_args(self):
         # Work around spack issue #19970 where spack sets
         # rpaths for MKL just during make, but cmake removes
         # them during make install.
-        if self.spec.satisfies("^[virtuals=lapack] intel-oneapi-mkl"):
+        if self.spec["lapack"].name in INTEL_MATH_LIBRARIES:
             args.append("-DCMAKE_INSTALL_RPATH_USE_LINK_PATH=ON")
         spec = self.spec
         args.append(self.define("BLAS_LIBRARIES", spec["blas"].libs.joined(";")))

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

@@ -8,9 +8,9 @@
 
 class Qmcpack(CMakePackage, CudaPackage):
     """QMCPACK, is a modern high-performance open-source Quantum Monte
-    Carlo (QMC) simulation code.
-    """
+    Carlo (QMC) simulation code."""
 
+    # Package information
     homepage = "https://www.qmcpack.org/"
     git = "https://github.com/QMCPACK/qmcpack.git"
     maintainers("ye-luo")
@@ -113,8 +113,11 @@ class Qmcpack(CMakePackage, CudaPackage):
         msg="QMCPACK CUDA+SOA variant does not exist prior to v. 3.5.0.",
     )
 
-    requires("^openblas~ilp64 threads=openmp", when="^[virtuals=blas,lapack] openblas")
-    requires("^intel-oneapi-mkl ~ilp64", when="^[virtuals=blas,lapack] intel-oneapi-mkl")
+    conflicts("^openblas+ilp64", msg="QMCPACK does not support OpenBLAS 64-bit integer variant")
+
+    conflicts("^openblas threads=none", msg="QMCPACK does not support OpenBLAS without threading")
+
+    conflicts("^openblas threads=pthreads", msg="QMCPACK does not support OpenBLAS with pthreads")
 
     conflicts(
         "cuda_arch=none",
@@ -122,6 +125,10 @@ class Qmcpack(CMakePackage, CudaPackage):
         msg="A value for cuda_arch must be specified. Add cuda_arch=XX",
     )
 
+    # Omitted for now due to concretizer bug
+    # conflicts('^intel-mkl+ilp64',
+    #           msg='QMCPACK does not support MKL 64-bit integer variant')
+
     # QMCPACK 3.15.0 increased the minimum gcc to 9
     conflicts("%gcc@:8", when="@3.15.0:")
 
@@ -157,8 +164,8 @@ class Qmcpack(CMakePackage, CudaPackage):
         "QMCPACK releases prior to 3.5.0 require the "
         "Intel compiler when linking against Intel MKL"
     )
-    conflicts("%gcc", when="@:3.4.0 ^[virtuals=blas,lapack] intel-oneapi-mkl", msg=mkl_warning)
-    conflicts("%llvm", when="@:3.4.0 ^[virtuals=blas,lapack] intel-oneapi-mkl", msg=mkl_warning)
+    conflicts("%gcc", when="@:3.4.0 ^intel-mkl", msg=mkl_warning)
+    conflicts("%llvm", when="@:3.4.0 ^intel-mkl", msg=mkl_warning)
 
     # Dependencies match those in the QMCPACK manual.
     # FIXME: once concretizer can unite unconditional and conditional
@@ -371,7 +378,7 @@ def cmake_args(self):
         # Next two environment variables were introduced in QMCPACK 3.5.0
         # Prior to v3.5.0, these lines should be benign but CMake
         # may issue a warning.
-        if spec.satisfies("^[virtuals=lapack] intel-oneapi-mkl"):
+        if spec["lapack"].name in INTEL_MATH_LIBRARIES:
             args.append("-DENABLE_MKL=1")
             args.append("-DMKL_ROOT=%s" % env["MKLROOT"])
         else:

var/spack/repos/builtin/packages/quantum-espresso/package.py

@@ -80,13 +80,13 @@ class QuantumEspresso(CMakePackage, Package):
     # Need OpenMP threaded FFTW and BLAS libraries when configured
     # with OpenMP support
     with when("+openmp"):
-        requires("^fftw+openmp", when="^[virtuals=fftw-api] fftw")
-        requires("^amdfftw+openmp", when="^[virtuals=fftw-api] amdfftw")
-        requires("^openblas threads=openmp", when="^[virtuals=blas] openblas")
-        requires("^amdblis threads=openmp", when="^[virtuals=blas] amdblis")
-        requires("^intel-oneapi-mkl threads=openmp", when="^[virtuals=blas] intel-oneapi-mkl")
-        requires("^armpl-gcc threads=openmp", when="^[virtuals=blas] armpl-gcc")
-        requires("^acfl threads=openmp", when="^[virtuals=blas] acfl")
+        depends_on("fftw+openmp", when="^[virtuals=fftw-api] fftw")
+        depends_on("amdfftw+openmp", when="^[virtuals=fftw-api] amdfftw")
+        depends_on("openblas threads=openmp", when="^[virtuals=blas] openblas")
+        depends_on("amdblis threads=openmp", when="^[virtuals=blas] amdblis")
+        depends_on("intel-mkl threads=openmp", when="^[virtuals=blas] intel-mkl")
+        depends_on("armpl-gcc threads=openmp", when="^[virtuals=blas] armpl-gcc")
+        depends_on("acfl threads=openmp", when="^[virtuals=blas] acfl")
 
     # Add Cuda Fortran support
     # depends on NVHPC compiler, not directly on CUDA toolkit
@@ -250,8 +250,9 @@ class QuantumEspresso(CMakePackage, Package):
     depends_on("m4", type="build")
 
     # If the Intel suite is used for Lapack, it must be used for fftw and vice-versa
-    requires("^[virtuals=fftw-api] intel-oneapi-mkl", when="^[virtuals=lapack] intel-oneapi-mkl")
-    requires("^[virtuals=lapack] intel-oneapi-mkl", when="^[virtuals=fftw-api] intel-oneapi-mkl")
+    for _intel_pkg in INTEL_MATH_LIBRARIES:
+        requires(f"^[virtuals=fftw-api] {_intel_pkg}", when=f"^[virtuals=lapack]   {_intel_pkg}")
+        requires(f"^[virtuals=lapack]   {_intel_pkg}", when=f"^[virtuals=fftw-api] {_intel_pkg}")
 
     # CONFLICTS SECTION
     # Omitted for now due to concretizer bug
@@ -537,7 +538,7 @@ def install(self, pkg, spec, prefix):
         # you need to pass it in the FFTW_INCLUDE and FFT_LIBS directory.
         # QE supports an internal FFTW2, but only an external FFTW3 interface.
 
-        is_using_intel_libraries = spec["lapack"].name == "intel-oneapi-mkl"
+        is_using_intel_libraries = spec["lapack"].name in INTEL_MATH_LIBRARIES
         if is_using_intel_libraries:
             # A seperate FFT library is not needed when linking against MKL
             options.append("FFTW_INCLUDE={0}".format(join_path(env["MKLROOT"], "include/fftw")))
@@ -585,9 +586,9 @@ def install(self, pkg, spec, prefix):
 
         if "+scalapack" in spec:
             if is_using_intel_libraries:
-                if "^[virtuals=mpi] openmpi" in spec:
+                if "^openmpi" in spec:
                     scalapack_option = "yes"
-                else:  # mpich
+                else:  # mpich, intel-mpi
                     scalapack_option = "intel"
             else:
                 scalapack_option = "yes"

var/spack/repos/builtin/packages/r-rmpi/package.py

@@ -24,7 +24,8 @@ class RRmpi(RPackage):
     depends_on("mpi")
 
     # The following MPI types are not supported
-    conflicts("^[virtuals=mpi] intel-oneapi-mpi")
+    conflicts("^[virtuals=mpi] intel-mpi")
+    conflicts("^[virtuals=mpi] intel-parallel-studio")
     conflicts("^[virtuals=mpi] mvapich2")
     conflicts("^[virtuals=mpi] spectrum-mpi")
 

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

@@ -177,10 +177,7 @@ def configure_args(self):
 
         # R uses LAPACK in Fortran, which requires libmkl_gf_* when gfortran is used.
         # TODO: cleaning this up seem to require both compilers as dependencies and use variants.
-        if (
-            spec.satisfies("^[virtuals=lapack] intel-oneapi-mkl")
-            and "gfortran" in self.compiler.fc
-        ):
+        if spec["lapack"].name in INTEL_MATH_LIBRARIES and "gfortran" in self.compiler.fc:
             xlp64 = "ilp64" if spec["lapack"].satisfies("+ilp64") else "lp64"
             blas_flags = blas_flags.replace(f"mkl_intel_{xlp64}", f"mkl_gf_{xlp64}")
             lapack_flags = lapack_flags.replace(f"mkl_intel_{xlp64}", f"mkl_gf_{xlp64}")
@@ -194,13 +191,15 @@ def configure_args(self):
             f"LDFLAGS=-Wl,-rpath,{extra_rpath}",
             f"--with-blas={blas_flags}",
             f"--with-lapack={lapack_flags}",
+            # cannot disable docs with a normal configure option
             "ac_cv_path_PDFLATEX=",
             "ac_cv_path_PDFTEX=",
             "ac_cv_path_TEX=",
             "ac_cv_path_TEXI2DVI=",
-            f"--with-libintl-prefix={spec['gettext'].prefix}",
         ]
 
+        config_args.append("--with-libintl-prefix={0}".format(spec["gettext"].prefix))
+
         if "+X" in spec:
             config_args.append("--with-cairo")
             config_args.append("--with-jpeglib")

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

@@ -44,7 +44,6 @@ class Rocminfo(CMakePackage):
     depends_on("cxx", type="build")
 
     depends_on("cmake@3:", type="build")
-    extends("python@3:")
 
     for ver in [
         "5.3.0",

var/spack/repos/builtin/packages/scine-qcmaquis/package.py

@@ -41,12 +41,11 @@ class ScineQcmaquis(CMakePackage):
 
     depends_on("hdf5~mpi")
     depends_on("lapack")
-    depends_on("blas")
 
-    requires("^openblas +ilp64 threads=openmp", when="^[virtuals=blas,lapack] openblas")
-    requires(
-        "^intel-oneapi-mkl +ilp64 threads=openmp", when="^[virtuals=blas,lapack] intel-oneapi-mkl"
-    )
+    depends_on("blas")
+    for _pkg in ["openblas"] + list(INTEL_MATH_LIBRARIES):
+        with when(f"^[virtuals=blas] {_pkg}"):
+            depends_on(f"{_pkg}+ilp64 threads=openmp")
 
     depends_on("gsl")
     depends_on("boost+program_options+filesystem+system+thread+serialization+chrono @1.56:")

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

@@ -213,17 +213,15 @@ def configure_args(self):
         # If autodetection fails for +shmem with one of these available to spack, please add
         # a "if spec.satisfies():" clause for said package.
 
-        if spec.satisfies("^[virtuals=mpi] intel-oneapi-mpi"):
+        if spec.satisfies("^intel-mpi") or spec.satisfies("^intel-oneapi-mpi"):
             config_args.append("--with-mpi=intel3")
         elif (
-            spec.satisfies("^[virtuals=mpi] mpich")
-            or spec.satisfies("^[virtuals=mpi] mvapich2")
-            or spec.satisfies("^[virtuals=mpi] cray-mpich")
+            spec.satisfies("^mpich")
+            or spec.satisfies("^mvapich2")
+            or spec.satisfies("^cray-mpich")
         ):
             config_args.append("--with-mpi=mpich3")
-        elif spec.satisfies("^[virtuals=mpi] openmpi") or spec.satisfies(
-            "^[virtuals=mpi] hpcx-mpi"
-        ):
+        elif spec.satisfies("^openmpi") or spec.satisfies("^hpcx-mpi"):
             config_args.append("--with-mpi=openmpi")
         elif "~mpi" in spec:
             config_args.append("--without-mpi")

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

@@ -202,7 +202,7 @@ class Seissol(CMakePackage, CudaPackage, ROCmPackage):
     depends_on("easi ~asagi jit=impalajit,lua", when="~asagi")
     depends_on("easi +asagi jit=impalajit,lua", when="+asagi")
 
-    depends_on("intel-oneapi-mkl threads=none", when="gemm_tools_list=MKL")
+    depends_on("intel-mkl threads=none", when="gemm_tools_list=MKL")
     depends_on("blis threads=none", when="gemm_tools_list=BLIS")
     depends_on("openblas threads=none", when="gemm_tools_list=OpenBLAS")
     depends_on("libxsmm@main", when="gemm_tools_list=LIBXSMM_JIT")