ffmpeg: update patch hashes for addition of the X-Git-Tag (#45574)

Bumps [actions/upload-artifact](https://github.com/actions/upload-artifact) from 4.3.4 to 4.3.5.
- [Release notes](https://github.com/actions/upload-artifact/releases)
- [Commits](0b2256b8c0...89ef406dd8)

---
updated-dependencies:
- dependency-name: actions/upload-artifact
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.github/workflows/audit.yaml

@@ -44,6 +44,7 @@ jobs:
       run: |
           . share/spack/setup-env.sh
           coverage run $(which spack) audit packages
+          coverage run $(which spack) audit configs
           coverage run $(which spack) -d audit externals
           coverage combine
           coverage xml
@@ -52,6 +53,7 @@ jobs:
       run: |
           . share/spack/setup-env.sh          
           spack -d audit packages
+          spack -d audit configs
           spack -d audit externals
     - name: Package audits (without coverage)
       if: ${{ runner.os == 'Windows' }}
@@ -59,6 +61,8 @@ jobs:
           . share/spack/setup-env.sh          
           spack -d audit packages
           ./share/spack/qa/validate_last_exit.ps1
+          spack -d audit configs
+          ./share/spack/qa/validate_last_exit.ps1
           spack -d audit externals
           ./share/spack/qa/validate_last_exit.ps1
     - uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673

.github/workflows/build-containers.yml

@@ -87,19 +87,19 @@ jobs:
           fi
 
       - name: Upload Dockerfile
-        uses: actions/upload-artifact@0b2256b8c012f0828dc542b3febcab082c67f72b
+        uses: actions/upload-artifact@89ef406dd8d7e03cfd12d9e0a4a378f454709029
         with:
           name: dockerfiles_${{ matrix.dockerfile[0] }}
           path: dockerfiles
 
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@5927c834f5b4fdf503fca6f4c7eccda82949e1ee
+        uses: docker/setup-qemu-action@49b3bc8e6bdd4a60e6116a5414239cba5943d3cf
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@4fd812986e6c8c2a69e18311145f9371337f27d4
+        uses: docker/setup-buildx-action@988b5a0280414f521da01fcc63a27aeeb4b104db
 
       - name: Log in to GitHub Container Registry
-        uses: docker/login-action@0d4c9c5ea7693da7b068278f7b52bda2a190a446
+        uses: docker/login-action@9780b0c442fbb1117ed29e0efdff1e18412f7567
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
@@ -107,13 +107,13 @@ jobs:
 
       - name: Log in to DockerHub
         if: github.event_name != 'pull_request'
-        uses: docker/login-action@0d4c9c5ea7693da7b068278f7b52bda2a190a446
+        uses: docker/login-action@9780b0c442fbb1117ed29e0efdff1e18412f7567
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Build & Deploy ${{ matrix.dockerfile[0] }}
-        uses: docker/build-push-action@1ca370b3a9802c92e886402e0dd88098a2533b12
+        uses: docker/build-push-action@5176d81f87c23d6fc96624dfdbcd9f3830bbe445
         with:
           context: dockerfiles/${{ matrix.dockerfile[0] }}
           platforms: ${{ matrix.dockerfile[1] }}
@@ -126,7 +126,7 @@ jobs:
     needs: deploy-images
     steps:
       - name: Merge Artifacts
-        uses: actions/upload-artifact/merge@0b2256b8c012f0828dc542b3febcab082c67f72b
+        uses: actions/upload-artifact/merge@89ef406dd8d7e03cfd12d9e0a4a378f454709029
         with:
           name: dockerfiles
           pattern: dockerfiles_*

etc/spack/defaults/packages.yaml

@@ -61,6 +61,7 @@ packages:
       tbb: [intel-tbb]
       unwind: [libunwind]
       uuid: [util-linux-uuid, libuuid]
+      wasi-sdk: [wasi-sdk-prebuilt]
       xxd: [xxd-standalone, vim]
       yacc: [bison, byacc]
       ziglang: [zig]

lib/spack/docs/requirements.txt

@@ -1,4 +1,4 @@
-sphinx==7.4.6
+sphinx==7.4.7
 sphinxcontrib-programoutput==0.17
 sphinx_design==0.6.0
 sphinx-rtd-theme==2.0.0
@@ -6,8 +6,8 @@ python-levenshtein==0.25.1
 docutils==0.20.1
 pygments==2.18.0
 urllib3==2.2.2
-pytest==8.2.2
+pytest==8.3.1
 isort==5.13.2
 black==24.4.2
 flake8==7.1.0
-mypy==1.11.0
+mypy==1.11.1

lib/spack/spack/audit.py

@@ -351,6 +351,22 @@ def _wrongly_named_spec(error_cls):
     return errors
 
 
+@config_packages
+def _ensure_all_virtual_packages_have_default_providers(error_cls):
+    """All virtual packages must have a default provider explicitly set."""
+    configuration = spack.config.create()
+    defaults = configuration.get("packages", scope="defaults")
+    default_providers = defaults["all"]["providers"]
+    virtuals = spack.repo.PATH.provider_index.providers
+    default_providers_filename = configuration.scopes["defaults"].get_section_filename("packages")
+
+    return [
+        error_cls(f"'{virtual}' must have a default provider in {default_providers_filename}", [])
+        for virtual in virtuals
+        if virtual not in default_providers
+    ]
+
+
 def _make_config_error(config_data, summary, error_cls):
     s = io.StringIO()
     s.write("Occurring in the following file:\n")

lib/spack/spack/build_systems/go.py

@@ -72,7 +72,7 @@ def build_directory(self):
     def build_args(self):
         """Arguments for ``go build``."""
         # Pass ldflags -s = --strip-all and -w = --no-warnings by default
-        return ["-ldflags", "-s -w", "-o", f"{self.pkg.name}"]
+        return ["-modcacherw", "-ldflags", "-s -w", "-o", f"{self.pkg.name}"]
 
     @property
     def check_args(self):

lib/spack/spack/ci.py

@@ -71,7 +71,7 @@
 # TODO: Remove this in Spack 0.23
 SHARED_PR_MIRROR_URL = "s3://spack-binaries-prs/shared_pr_mirror"
 JOB_NAME_FORMAT = (
-    "{name}{@version} {/hash:7} {%compiler.name}{@compiler.version}{arch=architecture}"
+    "{name}{@version} {/hash:7} {%compiler.name}{@compiler.version}{ arch=architecture}"
 )
 IS_WINDOWS = sys.platform == "win32"
 spack_gpg = spack.main.SpackCommand("gpg")

lib/spack/spack/cmd/__init__.py

@@ -237,7 +237,7 @@ def ensure_single_spec_or_die(spec, matching_specs):
     if len(matching_specs) <= 1:
         return
 
-    format_string = "{name}{@version}{%compiler.name}{@compiler.version}{arch=architecture}"
+    format_string = "{name}{@version}{%compiler.name}{@compiler.version}{ arch=architecture}"
     args = ["%s matches multiple packages." % spec, "Matching packages:"]
     args += [
         colorize("  @K{%s} " % s.dag_hash(7)) + s.cformat(format_string) for s in matching_specs

lib/spack/spack/cmd/pkg.py

@@ -169,7 +169,9 @@ def pkg_hash(args):
 
 def get_grep(required=False):
     """Get a grep command to use with ``spack pkg grep``."""
-    return exe.which(os.environ.get("SPACK_GREP") or "grep", required=required)
+    grep = exe.which(os.environ.get("SPACK_GREP") or "grep", required=required)
+    grep.ignore_quotes = True  # allow `spack pkg grep '"quoted string"'` without warning
+    return grep
 
 
 def pkg_grep(args, unknown_args):

lib/spack/spack/compilers/msvc.py

@@ -231,24 +231,55 @@ def msvc_version(self):
 
     @property
     def short_msvc_version(self):
+        """This is the shorthand VCToolset version of form
+        MSVC<short-ver>
         """
-        This is the shorthand VCToolset version of form
-        MSVC<short-ver> *NOT* the full version, for that see
+        return "MSVC" + self.vc_toolset_ver
+
+    @property
+    def vc_toolset_ver(self):
+        """
+        The toolset version is the version of the combined set of cl and link
+        This typically relates directly to VS version i.e. VS 2022 is v143
+        VS 19 is v142, etc.
+        This value is defined by the first three digits of the major + minor
+        version of the VS toolset (143 for 14.3x.bbbbb). Traditionally the
+        minor version has remained a static two digit number for a VS release
+        series, however, as of VS22, this is no longer true, both
+        14.4x.bbbbb and 14.3x.bbbbb are considered valid VS22 VC toolset
+        versions due to a change in toolset minor version sentiment.
+
+        This is *NOT* the full version, for that see
         Msvc.msvc_version or MSVC.platform_toolset_ver for the
         raw platform toolset version
+
         """
-        ver = self.platform_toolset_ver
-        return "MSVC" + ver
+        ver = self.msvc_version[:2].joined.string[:3]
+        return ver
 
     @property
     def platform_toolset_ver(self):
         """
         This is the platform toolset version of current MSVC compiler
-        i.e. 142.
+        i.e. 142. The platform toolset is the targeted MSVC library/compiler
+        versions by compilation (this is different from the VC Toolset)
+
+
         This is different from the VC toolset version as established
-        by `short_msvc_version`
+        by `short_msvc_version`, but typically are represented by the same
+        three digit value
         """
-        return self.msvc_version[:2].joined.string[:3]
+        # Typically VS toolset version and platform toolset versions match
+        # VS22 introduces the first divergence of VS toolset version
+        # (144 for "recent" releases) and platform toolset version (143)
+        # so it needs additional handling until MS releases v144
+        # (assuming v144 is also for VS22)
+        # or adds better support for detection
+        # TODO: (johnwparent) Update this logic for the next platform toolset
+        # or VC toolset version update
+        toolset_ver = self.vc_toolset_ver
+        vs22_toolset = Version(toolset_ver) > Version("142")
+        return toolset_ver if not vs22_toolset else "143"
 
     def _compiler_version(self, compiler):
         """Returns version object for given compiler"""

lib/spack/spack/directives.py

@@ -81,7 +81,17 @@ class OpenMpi(Package):
 ]
 
 #: These are variant names used by Spack internally; packages can't use them
-reserved_names = ["patches", "dev_path"]
+reserved_names = [
+    "arch",
+    "architecture",
+    "dev_path",
+    "namespace",
+    "operating_system",
+    "os",
+    "patches",
+    "platform",
+    "target",
+]
 
 #: Names of possible directives. This list is mostly populated using the @directive decorator.
 #: Some directives leverage others and in that case are not automatically added.

lib/spack/spack/parser.py

@@ -328,19 +328,26 @@ def next_spec(
         if not self.ctx.next_token:
             return initial_spec
 
+        def add_dependency(dep, **edge_properties):
+            """wrapper around root_spec._add_dependency"""
+            try:
+                root_spec._add_dependency(dep, **edge_properties)
+            except spack.error.SpecError as e:
+                raise SpecParsingError(str(e), self.ctx.current_token, self.literal_str) from e
+
         initial_spec = initial_spec or spack.spec.Spec()
-        root_spec = SpecNodeParser(self.ctx).parse(initial_spec)
+        root_spec = SpecNodeParser(self.ctx, self.literal_str).parse(initial_spec)
         while True:
             if self.ctx.accept(TokenType.START_EDGE_PROPERTIES):
                 edge_properties = EdgeAttributeParser(self.ctx, self.literal_str).parse()
                 edge_properties.setdefault("depflag", 0)
                 edge_properties.setdefault("virtuals", ())
                 dependency = self._parse_node(root_spec)
-                root_spec._add_dependency(dependency, **edge_properties)
+                add_dependency(dependency, **edge_properties)
 
             elif self.ctx.accept(TokenType.DEPENDENCY):
                 dependency = self._parse_node(root_spec)
-                root_spec._add_dependency(dependency, depflag=0, virtuals=())
+                add_dependency(dependency, depflag=0, virtuals=())
 
             else:
                 break
@@ -348,7 +355,7 @@ def next_spec(
         return root_spec
 
     def _parse_node(self, root_spec):
-        dependency = SpecNodeParser(self.ctx).parse()
+        dependency = SpecNodeParser(self.ctx, self.literal_str).parse()
         if dependency is None:
             msg = (
                 "the dependency sigil and any optional edge attributes must be followed by a "
@@ -367,10 +374,11 @@ def all_specs(self) -> List["spack.spec.Spec"]:
 class SpecNodeParser:
     """Parse a single spec node from a stream of tokens"""
 
-    __slots__ = "ctx", "has_compiler", "has_version"
+    __slots__ = "ctx", "has_compiler", "has_version", "literal_str"
 
-    def __init__(self, ctx):
+    def __init__(self, ctx, literal_str):
         self.ctx = ctx
+        self.literal_str = literal_str
         self.has_compiler = False
         self.has_version = False
 
@@ -388,7 +396,8 @@ def parse(
         if not self.ctx.next_token or self.ctx.expect(TokenType.DEPENDENCY):
             return initial_spec
 
-        initial_spec = initial_spec or spack.spec.Spec()
+        if initial_spec is None:
+            initial_spec = spack.spec.Spec()
 
         # If we start with a package name we have a named spec, we cannot
         # accept another package name afterwards in a node
@@ -405,12 +414,21 @@ def parse(
         elif self.ctx.accept(TokenType.FILENAME):
             return FileParser(self.ctx).parse(initial_spec)
 
+        def raise_parsing_error(string: str, cause: Optional[Exception] = None):
+            """Raise a spec parsing error with token context."""
+            raise SpecParsingError(string, self.ctx.current_token, self.literal_str) from cause
+
+        def add_flag(name: str, value: str, propagate: bool):
+            """Wrapper around ``Spec._add_flag()`` that adds parser context to errors raised."""
+            try:
+                initial_spec._add_flag(name, value, propagate)
+            except Exception as e:
+                raise_parsing_error(str(e), e)
+
         while True:
             if self.ctx.accept(TokenType.COMPILER):
                 if self.has_compiler:
-                    raise spack.spec.DuplicateCompilerSpecError(
-                        f"{initial_spec} cannot have multiple compilers"
-                    )
+                    raise_parsing_error("Spec cannot have multiple compilers")
 
                 compiler_name = self.ctx.current_token.value[1:]
                 initial_spec.compiler = spack.spec.CompilerSpec(compiler_name.strip(), ":")
@@ -418,9 +436,7 @@ def parse(
 
             elif self.ctx.accept(TokenType.COMPILER_AND_VERSION):
                 if self.has_compiler:
-                    raise spack.spec.DuplicateCompilerSpecError(
-                        f"{initial_spec} cannot have multiple compilers"
-                    )
+                    raise_parsing_error("Spec cannot have multiple compilers")
 
                 compiler_name, compiler_version = self.ctx.current_token.value[1:].split("@")
                 initial_spec.compiler = spack.spec.CompilerSpec(
@@ -434,9 +450,8 @@ def parse(
                 or self.ctx.accept(TokenType.VERSION)
             ):
                 if self.has_version:
-                    raise spack.spec.MultipleVersionError(
-                        f"{initial_spec} cannot have multiple versions"
-                    )
+                    raise_parsing_error("Spec cannot have multiple versions")
+
                 initial_spec.versions = spack.version.VersionList(
                     [spack.version.from_string(self.ctx.current_token.value[1:])]
                 )
@@ -445,29 +460,25 @@ def parse(
 
             elif self.ctx.accept(TokenType.BOOL_VARIANT):
                 variant_value = self.ctx.current_token.value[0] == "+"
-                initial_spec._add_flag(
-                    self.ctx.current_token.value[1:].strip(), variant_value, propagate=False
-                )
+                add_flag(self.ctx.current_token.value[1:].strip(), variant_value, propagate=False)
 
             elif self.ctx.accept(TokenType.PROPAGATED_BOOL_VARIANT):
                 variant_value = self.ctx.current_token.value[0:2] == "++"
-                initial_spec._add_flag(
-                    self.ctx.current_token.value[2:].strip(), variant_value, propagate=True
-                )
+                add_flag(self.ctx.current_token.value[2:].strip(), variant_value, propagate=True)
 
             elif self.ctx.accept(TokenType.KEY_VALUE_PAIR):
                 match = SPLIT_KVP.match(self.ctx.current_token.value)
                 assert match, "SPLIT_KVP and KEY_VALUE_PAIR do not agree."
 
-                name, delim, value = match.groups()
-                initial_spec._add_flag(name, strip_quotes_and_unescape(value), propagate=False)
+                name, _, value = match.groups()
+                add_flag(name, strip_quotes_and_unescape(value), propagate=False)
 
             elif self.ctx.accept(TokenType.PROPAGATED_KEY_VALUE_PAIR):
                 match = SPLIT_KVP.match(self.ctx.current_token.value)
                 assert match, "SPLIT_KVP and PROPAGATED_KEY_VALUE_PAIR do not agree."
 
-                name, delim, value = match.groups()
-                initial_spec._add_flag(name, strip_quotes_and_unescape(value), propagate=True)
+                name, _, value = match.groups()
+                add_flag(name, strip_quotes_and_unescape(value), propagate=True)
 
             elif self.ctx.expect(TokenType.DAG_HASH):
                 if initial_spec.abstract_hash:

lib/spack/spack/spec.py

@@ -99,7 +99,7 @@
     "CompilerSpec",
     "Spec",
     "SpecParseError",
-    "ArchitecturePropagationError",
+    "UnsupportedPropagationError",
     "DuplicateDependencyError",
     "DuplicateCompilerSpecError",
     "UnsupportedCompilerError",
@@ -129,7 +129,7 @@
     r"|"  # or
     # OPTION 2: an actual format string
     r"{"  # non-escaped open brace {
-    r"([%@/]|arch=)?"  # optional sigil (to print sigil in color)
+    r"([%@/]|[\w ][\w -]*=)?"  # optional sigil (or identifier or space) to print sigil in color
     r"(?:\^([^}\.]+)\.)?"  # optional ^depname. (to get attr from dependency)
     # after the sigil or depname, we can have a hash expression or another attribute
     r"(?:"  # one of
@@ -163,14 +163,14 @@
 DEFAULT_FORMAT = (
     "{name}{@versions}"
     "{%compiler.name}{@compiler.versions}{compiler_flags}"
-    "{variants}{arch=architecture}{/abstract_hash}"
+    "{variants}{ namespace=namespace_if_anonymous}{ arch=architecture}{/abstract_hash}"
 )
 
 #: Display format, which eliminates extra `@=` in the output, for readability.
 DISPLAY_FORMAT = (
     "{name}{@version}"
     "{%compiler.name}{@compiler.version}{compiler_flags}"
-    "{variants}{arch=architecture}{/abstract_hash}"
+    "{variants}{ namespace=namespace_if_anonymous}{ arch=architecture}{/abstract_hash}"
 )
 
 #: Regular expression to pull spec contents out of clearsigned signature
@@ -1640,19 +1640,9 @@ def _add_flag(self, name, value, propagate):
         Known flags currently include "arch"
         """
 
-        # If the == syntax is used to propagate the spec architecture
-        # This is an error
-        architecture_names = [
-            "arch",
-            "architecture",
-            "platform",
-            "os",
-            "operating_system",
-            "target",
-        ]
-        if propagate and name in architecture_names:
-            raise ArchitecturePropagationError(
-                "Unable to propagate the architecture failed." " Use a '=' instead."
+        if propagate and name in spack.directives.reserved_names:
+            raise UnsupportedPropagationError(
+                f"Propagation with '==' is not supported for '{name}'."
             )
 
         valid_flags = FlagMap.valid_compiler_flags()
@@ -1666,6 +1656,8 @@ def _add_flag(self, name, value, propagate):
             self._set_architecture(os=value)
         elif name == "target":
             self._set_architecture(target=value)
+        elif name == "namespace":
+            self.namespace = value
         elif name in valid_flags:
             assert self.compiler_flags is not None
             flags_and_propagation = spack.compiler.tokenize_flags(value, propagate)
@@ -1685,9 +1677,7 @@ def _set_architecture(self, **kwargs):
         """Called by the parser to set the architecture."""
         arch_attrs = ["platform", "os", "target"]
         if self.architecture and self.architecture.concrete:
-            raise DuplicateArchitectureError(
-                "Spec for '%s' cannot have two architectures." % self.name
-            )
+            raise DuplicateArchitectureError("Spec cannot have two architectures.")
 
         if not self.architecture:
             new_vals = tuple(kwargs.get(arg, None) for arg in arch_attrs)
@@ -1696,10 +1686,7 @@ def _set_architecture(self, **kwargs):
             new_attrvals = [(a, v) for a, v in kwargs.items() if a in arch_attrs]
             for new_attr, new_value in new_attrvals:
                 if getattr(self.architecture, new_attr):
-                    raise DuplicateArchitectureError(
-                        "Spec for '%s' cannot have two '%s' specified "
-                        "for its architecture" % (self.name, new_attr)
-                    )
+                    raise DuplicateArchitectureError(f"Cannot specify '{new_attr}' twice")
                 else:
                     setattr(self.architecture, new_attr, new_value)
 
@@ -1894,14 +1881,14 @@ def short_spec(self):
         """Returns a version of the spec with the dependencies hashed
         instead of completely enumerated."""
         spec_format = "{name}{@version}{%compiler.name}{@compiler.version}"
-        spec_format += "{variants}{arch=architecture}{/hash:7}"
+        spec_format += "{variants}{ arch=architecture}{/hash:7}"
         return self.format(spec_format)
 
     @property
     def cshort_spec(self):
         """Returns an auto-colorized version of ``self.short_spec``."""
         spec_format = "{name}{@version}{%compiler.name}{@compiler.version}"
-        spec_format += "{variants}{arch=architecture}{/hash:7}"
+        spec_format += "{variants}{ arch=architecture}{/hash:7}"
         return self.cformat(spec_format)
 
     @property
@@ -4386,14 +4373,19 @@ def deps():
 
         yield deps
 
-    def format(self, format_string: str = DEFAULT_FORMAT, color: Optional[bool] = False) -> str:
-        r"""Prints out particular pieces of a spec, depending on what is
-        in the format string.
+    @property
+    def namespace_if_anonymous(self):
+        return self.namespace if not self.name else None
 
-        Using the ``{attribute}`` syntax, any field of the spec can be
-        selected.  Those attributes can be recursive. For example,
-        ``s.format({compiler.version})`` will print the version of the
-        compiler.
+    def format(self, format_string: str = DEFAULT_FORMAT, color: Optional[bool] = False) -> str:
+        r"""Prints out attributes of a spec according to a format string.
+
+        Using an ``{attribute}`` format specifier, any field of the spec can be
+        selected. Those attributes can be recursive. For example,
+        ``s.format({compiler.version})`` will print the version of the compiler.
+
+        If the attribute in a format specifier evaluates to ``None``, then the format
+        specifier will evaluate to the empty string, ``""``.
 
         Commonly used attributes of the Spec for format strings include::
 
@@ -4409,6 +4401,7 @@ def format(self, format_string: str = DEFAULT_FORMAT, color: Optional[bool] = Fa
             architecture.os
             architecture.target
             prefix
+            namespace
 
         Some additional special-case properties can be added::
 
@@ -4417,40 +4410,51 @@ def format(self, format_string: str = DEFAULT_FORMAT, color: Optional[bool] = Fa
             spack_install The spack install directory
 
         The ``^`` sigil can be used to access dependencies by name.
-        ``s.format({^mpi.name})`` will print the name of the MPI
-        implementation in the spec.
+        ``s.format({^mpi.name})`` will print the name of the MPI implementation in the
+        spec.
 
-        The ``@``, ``%``, ``arch=``, and ``/`` sigils
-        can be used to include the sigil with the printed
-        string. These sigils may only be used with the appropriate
-        attributes, listed below::
+        The ``@``, ``%``, and ``/`` sigils can be used to include the sigil with the
+        printed string. These sigils may only be used with the appropriate attributes,
+        listed below::
 
             @        ``{@version}``, ``{@compiler.version}``
             %        ``{%compiler}``, ``{%compiler.name}``
-            arch=    ``{arch=architecture}``
             /        ``{/hash}``, ``{/hash:7}``, etc
 
-        The ``@`` sigil may also be used for any other property named
-        ``version``. Sigils printed with the attribute string are only
-        printed if the attribute string is non-empty, and are colored
-        according to the color of the attribute.
+        The ``@`` sigil may also be used for any other property named ``version``.
+        Sigils printed with the attribute string are only printed if the attribute
+        string is non-empty, and are colored according to the color of the attribute.
 
-        Sigils are not used for printing variants. Variants listed by
-        name naturally print with their sigil. For example,
-        ``spec.format('{variants.debug}')`` would print either
-        ``+debug`` or ``~debug`` depending on the name of the
-        variant. Non-boolean variants print as ``name=value``. To
-        print variant names or values independently, use
+        Variants listed by name naturally print with their sigil. For example,
+        ``spec.format('{variants.debug}')`` prints either ``+debug`` or ``~debug``
+        depending on the name of the variant. Non-boolean variants print as
+        ``name=value``. To print variant names or values independently, use
         ``spec.format('{variants.<name>.name}')`` or
         ``spec.format('{variants.<name>.value}')``.
 
-        Spec format strings use ``\`` as the escape character. Use
-        ``\{`` and ``\}`` for literal braces, and ``\\`` for the
-        literal ``\`` character.
+        There are a few attributes on specs that can be specified as key-value pairs
+        that are *not* variants, e.g.: ``os``, ``arch``, ``architecture``, ``target``,
+        ``namespace``, etc. You can format these with an optional ``key=`` prefix, e.g.
+        ``{namespace=namespace}`` or ``{arch=architecture}``, etc. The ``key=`` prefix
+        will be colorized along with the value.
+
+        When formatting specs, key-value pairs are separated from preceding parts of the
+        spec by whitespace. To avoid printing extra whitespace when the formatted
+        attribute is not set, you can add whitespace to the key *inside* the braces of
+        the format string, e.g.:
+
+            { namespace=namespace}
+
+        This evaluates to `` namespace=builtin`` if ``namespace`` is set to ``builtin``,
+        and to ``""`` if ``namespace`` is ``None``.
+
+        Spec format strings use ``\`` as the escape character. Use ``\{`` and ``\}`` for
+        literal braces, and ``\\`` for the literal ``\`` character.
 
         Args:
             format_string: string containing the format to be expanded
             color: True for colorized result; False for no color; None for auto color.
+
         """
         ensure_modern_format_string(format_string)
 
@@ -4504,10 +4508,6 @@ def format_attribute(match_object: Match) -> str:
                 raise SpecFormatSigilError(sig, "compilers", attribute)
             elif sig == "/" and attribute != "abstract_hash":
                 raise SpecFormatSigilError(sig, "DAG hashes", attribute)
-            elif sig == "arch=":
-                if attribute not in ("architecture", "arch"):
-                    raise SpecFormatSigilError(sig, "the architecture", attribute)
-                sig = " arch="  # include space as separator
 
             # Iterate over components using getattr to get next element
             for idx, part in enumerate(parts):
@@ -4552,15 +4552,19 @@ def format_attribute(match_object: Match) -> str:
 
             # Set color codes for various attributes
             color = None
-            if "variants" in parts:
-                color = VARIANT_COLOR
-            elif "architecture" in parts:
+            if "architecture" in parts:
                 color = ARCHITECTURE_COLOR
+            elif "variants" in parts or sig.endswith("="):
+                color = VARIANT_COLOR
             elif "compiler" in parts or "compiler_flags" in parts:
                 color = COMPILER_COLOR
             elif "version" in parts or "versions" in parts:
                 color = VERSION_COLOR
 
+            # return empty string if the value of the attribute is None.
+            if current is None:
+                return ""
+
             # return colored output
             return safe_color(sig, str(current), color)
 
@@ -5390,10 +5394,8 @@ def long_message(self):
         )
 
 
-class ArchitecturePropagationError(spack.error.SpecError):
-    """Raised when the double equal symbols are used to assign
-    the spec's architecture.
-    """
+class UnsupportedPropagationError(spack.error.SpecError):
+    """Raised when propagation (==) is used with reserved variant names."""
 
 
 class DuplicateDependencyError(spack.error.SpecError):
@@ -5523,7 +5525,7 @@ def __init__(self, spec):
 class AmbiguousHashError(spack.error.SpecError):
     def __init__(self, msg, *specs):
         spec_fmt = "{namespace}.{name}{@version}{%compiler}{compiler_flags}"
-        spec_fmt += "{variants}{arch=architecture}{/hash:7}"
+        spec_fmt += "{variants}{ arch=architecture}{/hash:7}"
         specs_str = "\n  " + "\n  ".join(spec.format(spec_fmt) for spec in specs)
         super().__init__(msg + specs_str)
 

lib/spack/spack/test/repo.py

@@ -131,19 +131,6 @@ def test_relative_import_spack_packages_as_python_modules(mock_packages):
     assert issubclass(Mpileaks, spack.package_base.PackageBase)
 
 
-def test_all_virtual_packages_have_default_providers():
-    """All virtual packages must have a default provider explicitly set."""
-    configuration = spack.config.create()
-    defaults = configuration.get("packages", scope="defaults")
-    default_providers = defaults["all"]["providers"]
-    providers = spack.repo.PATH.provider_index.providers
-    default_providers_filename = configuration.scopes["defaults"].get_section_filename("packages")
-    for provider in providers:
-        assert provider in default_providers, (
-            "all providers must have a default in %s" % default_providers_filename
-        )
-
-
 def test_get_all_mock_packages(mock_packages):
     """Get the mock packages once each too."""
     for name in mock_packages.all_package_names():

lib/spack/spack/test/spec_semantics.py

@@ -197,6 +197,9 @@ class TestSpecSemantics:
                 'multivalue-variant foo="baz"',
                 'multivalue-variant foo="bar,baz,barbaz"',
             ),
+            # Namespace (special case, but like variants
+            ("builtin.libelf", "namespace=builtin", "builtin.libelf"),
+            ("libelf", "namespace=builtin", "builtin.libelf"),
             # Flags
             ("mpich ", 'mpich cppflags="-O3"', 'mpich cppflags="-O3"'),
             (
@@ -317,6 +320,7 @@ def test_concrete_specs_which_satisfies_abstract(self, lhs, rhs, default_mock_co
             ("libelf debug=True", "libelf debug=False"),
             ('libelf cppflags="-O3"', 'libelf cppflags="-O2"'),
             ("libelf platform=test target=be os=be", "libelf target=fe os=fe"),
+            ("namespace=builtin.mock", "namespace=builtin"),
         ],
     )
     def test_constraining_abstract_specs_with_empty_intersection(self, lhs, rhs):
@@ -406,6 +410,25 @@ def test_indirect_unsatisfied_single_valued_variant(self):
         spec.concretize()
         assert "pkg-a@1.0" not in spec
 
+    def test_satisfied_namespace(self):
+        spec = Spec("zlib").concretized()
+        assert spec.satisfies("namespace=builtin.mock")
+        assert not spec.satisfies("namespace=builtin")
+
+    @pytest.mark.parametrize(
+        "spec_string",
+        [
+            "tcl namespace==foobar",
+            "tcl arch==foobar",
+            "tcl os==foobar",
+            "tcl patches==foobar",
+            "tcl dev_path==foobar",
+        ],
+    )
+    def test_propagate_reserved_variant_names(self, spec_string):
+        with pytest.raises(spack.parser.SpecParsingError, match="Propagation"):
+            Spec(spec_string)
+
     def test_unsatisfiable_multi_value_variant(self, default_mock_concretization):
         # Semantics for a multi-valued variant is different
         # Depending on whether the spec is concrete or not
@@ -656,6 +679,7 @@ def test_spec_formatting(self, default_mock_concretization):
             ("{@VERSIONS}", "@", "versions", lambda spec: spec),
             ("{%compiler}", "%", "compiler", lambda spec: spec),
             ("{arch=architecture}", "arch=", "architecture", lambda spec: spec),
+            ("{namespace=namespace}", "namespace=", "namespace", lambda spec: spec),
             ("{compiler.name}", "", "name", lambda spec: spec.compiler),
             ("{compiler.version}", "", "version", lambda spec: spec.compiler),
             ("{%compiler.name}", "%", "name", lambda spec: spec.compiler),
@@ -706,13 +730,40 @@ def check_prop(check_spec, fmt_str, prop, getter):
     @pytest.mark.parametrize(
         "fmt_str",
         [
-            "{@name}",
-            "{@version.concrete}",
-            "{%compiler.version}",
-            "{/hashd}",
-            "{arch=architecture.os}",
+            "{name}",
+            "{version}",
+            "{@version}",
+            "{%compiler}",
+            "{namespace}",
+            "{ namespace=namespace}",
+            "{ namespace =namespace}",
+            "{ name space =namespace}",
+            "{arch}",
+            "{architecture}",
+            "{arch=architecture}",
+            "{  arch=architecture}",
+            "{  arch =architecture}",
         ],
     )
+    def test_spec_format_null_attributes(self, fmt_str):
+        """Ensure that attributes format to empty strings when their values are null."""
+        spec = spack.spec.Spec()
+        assert spec.format(fmt_str) == ""
+
+    def test_spec_formatting_spaces_in_key(self, default_mock_concretization):
+        spec = default_mock_concretization("multivalue-variant cflags=-O2")
+
+        # test that spaces are preserved, if they come after some other text, otherwise
+        # they are trimmed.
+        # TODO: should we be trimming whitespace from formats? Probably not.
+        assert spec.format("x{ arch=architecture}") == f"x arch={spec.architecture}"
+        assert spec.format("x{ namespace=namespace}") == f"x namespace={spec.namespace}"
+        assert spec.format("x{ name space =namespace}") == f"x name space ={spec.namespace}"
+        assert spec.format("x{ os =os}") == f"x os ={spec.os}"
+
+    @pytest.mark.parametrize(
+        "fmt_str", ["{@name}", "{@version.concrete}", "{%compiler.version}", "{/hashd}"]
+    )
     def test_spec_formatting_sigil_mismatches(self, default_mock_concretization, fmt_str):
         spec = default_mock_concretization("multivalue-variant cflags=-O2")
 
@@ -740,11 +791,11 @@ def test_spec_formatting_bad_formats(self, default_mock_concretization, fmt_str)
 
     def test_combination_of_wildcard_or_none(self):
         # Test that using 'none' and another value raises
-        with pytest.raises(spack.variant.InvalidVariantValueCombinationError):
+        with pytest.raises(spack.parser.SpecParsingError, match="cannot be combined"):
             Spec("multivalue-variant foo=none,bar")
 
         # Test that using wildcard and another value raises
-        with pytest.raises(spack.variant.InvalidVariantValueCombinationError):
+        with pytest.raises(spack.parser.SpecParsingError, match="cannot be combined"):
             Spec("multivalue-variant foo=*,bar")
 
     def test_errors_in_variant_directive(self):

lib/spack/spack/test/spec_syntax.py

@@ -952,64 +952,60 @@ def test_disambiguate_hash_by_spec(spec1, spec2, constraint, mock_packages, monk
 
 
 @pytest.mark.parametrize(
-    "text,exc_cls",
+    "text,match_string",
     [
         # Duplicate variants
-        ("x@1.2+debug+debug", spack.variant.DuplicateVariantError),
-        ("x ^y@1.2+debug debug=true", spack.variant.DuplicateVariantError),
-        ("x ^y@1.2 debug=false debug=true", spack.variant.DuplicateVariantError),
-        ("x ^y@1.2 debug=false ~debug", spack.variant.DuplicateVariantError),
+        ("x@1.2+debug+debug", "variant"),
+        ("x ^y@1.2+debug debug=true", "variant"),
+        ("x ^y@1.2 debug=false debug=true", "variant"),
+        ("x ^y@1.2 debug=false ~debug", "variant"),
         # Multiple versions
-        ("x@1.2@2.3", spack.spec.MultipleVersionError),
-        ("x@1.2:2.3@1.4", spack.spec.MultipleVersionError),
-        ("x@1.2@2.3:2.4", spack.spec.MultipleVersionError),
-        ("x@1.2@2.3,2.4", spack.spec.MultipleVersionError),
-        ("x@1.2 +foo~bar @2.3", spack.spec.MultipleVersionError),
-        ("x@1.2%y@1.2@2.3:2.4", spack.spec.MultipleVersionError),
+        ("x@1.2@2.3", "version"),
+        ("x@1.2:2.3@1.4", "version"),
+        ("x@1.2@2.3:2.4", "version"),
+        ("x@1.2@2.3,2.4", "version"),
+        ("x@1.2 +foo~bar @2.3", "version"),
+        ("x@1.2%y@1.2@2.3:2.4", "version"),
         # Duplicate dependency
-        ("x ^y@1 ^y@2", spack.spec.DuplicateDependencyError),
+        ("x ^y@1 ^y@2", "Cannot depend on incompatible specs"),
         # Duplicate compiler
-        ("x%intel%intel", spack.spec.DuplicateCompilerSpecError),
-        ("x%intel%gcc", spack.spec.DuplicateCompilerSpecError),
-        ("x%gcc%intel", spack.spec.DuplicateCompilerSpecError),
-        ("x ^y%intel%intel", spack.spec.DuplicateCompilerSpecError),
-        ("x ^y%intel%gcc", spack.spec.DuplicateCompilerSpecError),
-        ("x ^y%gcc%intel", spack.spec.DuplicateCompilerSpecError),
+        ("x%intel%intel", "compiler"),
+        ("x%intel%gcc", "compiler"),
+        ("x%gcc%intel", "compiler"),
+        ("x ^y%intel%intel", "compiler"),
+        ("x ^y%intel%gcc", "compiler"),
+        ("x ^y%gcc%intel", "compiler"),
         # Duplicate Architectures
-        (
-            "x arch=linux-rhel7-x86_64 arch=linux-rhel7-x86_64",
-            spack.spec.DuplicateArchitectureError,
-        ),
-        (
-            "x arch=linux-rhel7-x86_64 arch=linux-rhel7-ppc64le",
-            spack.spec.DuplicateArchitectureError,
-        ),
-        (
-            "x arch=linux-rhel7-ppc64le arch=linux-rhel7-x86_64",
-            spack.spec.DuplicateArchitectureError,
-        ),
-        (
-            "y ^x arch=linux-rhel7-x86_64 arch=linux-rhel7-x86_64",
-            spack.spec.DuplicateArchitectureError,
-        ),
-        (
-            "y ^x arch=linux-rhel7-x86_64 arch=linux-rhel7-ppc64le",
-            spack.spec.DuplicateArchitectureError,
-        ),
-        ("x os=fe os=fe", spack.spec.DuplicateArchitectureError),
-        ("x os=fe os=be", spack.spec.DuplicateArchitectureError),
-        ("x target=fe target=fe", spack.spec.DuplicateArchitectureError),
-        ("x target=fe target=be", spack.spec.DuplicateArchitectureError),
-        ("x platform=test platform=test", spack.spec.DuplicateArchitectureError),
-        ("x os=fe platform=test target=fe os=fe", spack.spec.DuplicateArchitectureError),
-        ("x target=be platform=test os=be os=fe", spack.spec.DuplicateArchitectureError),
-        ("^[@foo] zlib", spack.parser.SpecParsingError),
+        ("x arch=linux-rhel7-x86_64 arch=linux-rhel7-x86_64", "two architectures"),
+        ("x arch=linux-rhel7-x86_64 arch=linux-rhel7-ppc64le", "two architectures"),
+        ("x arch=linux-rhel7-ppc64le arch=linux-rhel7-x86_64", "two architectures"),
+        ("y ^x arch=linux-rhel7-x86_64 arch=linux-rhel7-x86_64", "two architectures"),
+        ("y ^x arch=linux-rhel7-x86_64 arch=linux-rhel7-ppc64le", "two architectures"),
+        ("x os=fe os=fe", "'os'"),
+        ("x os=fe os=be", "'os'"),
+        ("x target=fe target=fe", "'target'"),
+        ("x target=fe target=be", "'target'"),
+        ("x platform=test platform=test", "'platform'"),
+        # TODO: these two seem wrong: need to change how arch is initialized (should fail on os)
+        ("x os=fe platform=test target=fe os=fe", "'platform'"),
+        ("x target=be platform=test os=be os=fe", "'platform'"),
+        # Dependencies
+        ("^[@foo] zlib", "edge attributes"),
         # TODO: Remove this as soon as use variants are added and we can parse custom attributes
-        ("^[foo=bar] zlib", spack.parser.SpecParsingError),
+        ("^[foo=bar] zlib", "edge attributes"),
+        # Propagating reserved names generates a parse error
+        ("x namespace==foo.bar.baz", "Propagation"),
+        ("x arch==linux-rhel9-x86_64", "Propagation"),
+        ("x architecture==linux-rhel9-x86_64", "Propagation"),
+        ("x os==rhel9", "Propagation"),
+        ("x operating_system==rhel9", "Propagation"),
+        ("x target==x86_64", "Propagation"),
+        ("x dev_path==/foo/bar/baz", "Propagation"),
+        ("x patches==abcde12345,12345abcde", "Propagation"),
     ],
 )
-def test_error_conditions(text, exc_cls):
-    with pytest.raises(exc_cls):
+def test_error_conditions(text, match_string):
+    with pytest.raises(spack.parser.SpecParsingError, match=match_string):
         SpecParser(text).next_spec()
 
 

lib/spack/spack/util/executable.py

@@ -31,6 +31,7 @@ def __init__(self, name):
 
         self.default_envmod = EnvironmentModifications()
         self.returncode = None
+        self.ignore_quotes = False
 
         if not self.exe:
             raise ProcessError("Cannot construct executable for '%s'" % name)
@@ -188,7 +189,7 @@ def process_cmd_output(out, err):
 
         fail_on_error = kwargs.pop("fail_on_error", True)
         ignore_errors = kwargs.pop("ignore_errors", ())
-        ignore_quotes = kwargs.pop("ignore_quotes", False)
+        ignore_quotes = kwargs.pop("ignore_quotes", self.ignore_quotes)
         timeout = kwargs.pop("timeout", None)
 
         # If they just want to ignore one error code, make it a tuple.

share/spack/gitlab/cloud_pipelines/.gitlab-ci.yml

@@ -376,7 +376,7 @@ e4s-neoverse_v1-build:
 
 e4s-rocm-external-generate:
   extends: [ ".e4s-rocm-external", ".generate-x86_64"]
-  image: ecpe4s/ubuntu22.04-runner-amd64-gcc-11.4-rocm6.1.1:2024.06.23
+  image: ecpe4s/ubuntu22.04-runner-amd64-gcc-11.4-rocm6.1.2:2024.07.22
 
 e4s-rocm-external-build:
   extends: [ ".e4s-rocm-external", ".build" ]
@@ -726,6 +726,29 @@ ml-linux-x86_64-cuda-build:
     - artifacts: True
       job: ml-linux-x86_64-cuda-generate
 
+########################################
+# Machine Learning - Linux x86_64 (ROCm)
+########################################
+.ml-linux-x86_64-rocm:
+  extends: [ ".linux_x86_64_v3" ]
+  variables:
+    SPACK_CI_STACK_NAME: ml-linux-x86_64-rocm
+
+ml-linux-x86_64-rocm-generate:
+  extends: [ ".generate-x86_64", .ml-linux-x86_64-rocm, ".tags-x86_64_v4" ]
+  image: ghcr.io/spack/ubuntu-22.04:v2024-05-07
+
+ml-linux-x86_64-rocm-build:
+  extends: [ ".build", ".ml-linux-x86_64-rocm" ]
+  trigger:
+    include:
+      - artifact: jobs_scratch_dir/cloud-ci-pipeline.yml
+        job: ml-linux-x86_64-rocm-generate
+    strategy: depend
+  needs:
+    - artifacts: True
+      job: ml-linux-x86_64-rocm-generate
+
 #########################################
 # Machine Learning - Darwin aarch64 (MPS)
 #########################################

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

@@ -67,14 +67,16 @@ spack:
 
   specs:
   # CPU
-  - aml
   - adios
+  - alquimia
+  - aml
   - amrex
   - arborx
   - argobots
   - axom
   - bolt
   - boost
+  - bricks ~cuda
   - butterflypack
   - cabana
   - caliper
@@ -82,15 +84,20 @@ spack:
   - charliecloud
   - conduit
   - datatransferkit
+  - dealii
   - drishti
+  - dxt-explorer
+  - ecp-data-vis-sdk ~cuda ~rocm +adios2 ~ascent +cinema +darshan +faodel +hdf5 +paraview +pnetcdf +sz +unifyfs +veloc ~visit +vtkm +zfp # +ascent: fides: fides/xgc/XGCCommon.cxx:233:10: error: no member named 'iota' in namespace 'std'; +visit: visit_vtk/lightweight/vtkSkewLookupTable.C:32:10: error: cannot initialize return object of type 'unsigned char *' with an rvalue of type 'const unsigned char *'
   - exaworks
   - flecsi
   - flit
   - flux-core
   - fortrilinos
   - gasnet
+  - geopm-service
   - ginkgo
   - globalarrays
+  - glvis ^llvm
   - gmp
   - gotcha
   - gptune ~mpispawn
@@ -106,7 +113,6 @@ spack:
   - kokkos-kernels +openmp
   - laghos
   - lammps
-  # - lbann               # 2024.2 internal compiler error
   - legion
   - libnrm
   - libpressio +bitgrooming +bzip2 ~cuda ~cusz +fpzip +hdf5 +libdistributed +lua +openmp +python +sz +sz3 +unix +zfp
@@ -116,6 +122,7 @@ spack:
   - mercury
   - metall
   - mfem
+  - mgard +serial +openmp +timing +unstructured ~cuda
   - mpark-variant
   - mpifileutils ~xattr
   - nccmp
@@ -125,12 +132,13 @@ spack:
   - omega-h
   - openfoam
   - openmpi
+  - openpmd-api
   - papi
   - papyrus
   - parsec ~cuda
+  - pdt
   - petsc
   - phist
-  # - plasma           # 2024.2 internal compiler error
   - plumed
   - precice
   - pruners-ninja
@@ -152,12 +160,15 @@ spack:
   - sundials
   - superlu
   - superlu-dist
+  - swig@4.0.2-fortran
   - sz3
   - tasmanian
+  - tau +mpi +python +syscall
   - trilinos +amesos +amesos2 +anasazi +aztec +belos +boost +epetra +epetraext +ifpack +ifpack2 +intrepid +intrepid2 +isorropia +kokkos +ml +minitensor +muelu +nox +piro +phalanx +rol +rythmos +sacado +stk +shards +shylu +stokhos +stratimikos +teko +tempus +tpetra +trilinoscouplings +zoltan +zoltan2 +superlu-dist gotype=long_long
   - turbine
   - umap
   - umpire
+  - upcxx
   - variorum
   - wannier90
   - xyce +mpi +shared +pymi +pymi_static_tpls
@@ -170,31 +181,21 @@ spack:
   - hdf5
   - libcatalyst
   - parallel-netcdf
-  # - paraview            # paraview: VTK/ThirdParty/cgns/vtkcgns/src/adfh/ADFH.c:2002:23: error: incompatible function pointer types passing 'herr_t (hid_t, const char *, const H5L_info1_t *, void *)' (aka 'int (long, const char *, const H5L_info1_t *, void *)') to parameter of type 'H5L_iterate2_t' (aka 'int (*)(long, const char *,const H5L_info2_t *, void *)') [-Wincompatible-function-pointer-types]
+  - paraview
   - py-cinemasci
   - sz
   - unifyfs
   - veloc
-  # - visit               # silo: https://github.com/spack/spack/issues/39538
-  - vtk-m ~openmp         # https://github.com/spack/spack/issues/31830
+  # - visit                                                 # visit: +visit: visit_vtk/lightweight/vtkSkewLookupTable.C:32:10: error: cannot initialize return object of type 'unsigned char *' with an rvalue of type 'const unsigned char *'
+  - vtk-m ~openmp
   - zfp
   # --
-  # - alquimia                                                # pflotran: https://github.com/spack/spack/issues/39474
-  # - bricks ~cuda                                            # bricks: /opt/intel/oneapi/compiler/2024.0/bin/sycl-post-link: error while loading shared libraries: libonnxruntime.1.12.22.721.so: cannot open shared object file: No such file or directory
-  # - cp2k +mpi                                               # dbcsr
-  # - dealii                                                  # dealii: https://github.com/spack/spack/issues/39482
-  # - dxt-explorer                                            # r: https://github.com/spack/spack/issues/40257
-  # - ecp-data-vis-sdk ~cuda ~rocm +adios2 +ascent +cinema +darshan +faodel +hdf5 +paraview +pnetcdf +sz +unifyfs +veloc +visit +vtkm +zfp # embree: CMake Error at CMakeLists.txt:215 (MESSAGE): Unsupported compiler: IntelLLVM; qt: qtbase/src/corelib/global/qendian.h:333:54: error: incomplete type 'std::numeric_limits' used in nested name specifier
-  # - geopm                                                   # geopm issue: https://github.com/spack/spack/issues/38795
-  # - glvis ^llvm                                             # glvis: https://github.com/spack/spack/issues/42839
-  # - hpctoolkit                                              # dyninst@12.3.0%gcc: /usr/bin/ld: libiberty/./d-demangle.c:142: undefined reference to `_intel_fast_memcpy'; can't mix intel-tbb@%oneapi with dyninst%gcc
-  # - mgard +serial +openmp +timing +unstructured ~cuda       # mgard: mgard.tpp:63:48: error: non-constant-expression cannot be narrowed from type 'int' to 'unsigned long' in initializer list [-Wc++11-narrowing]
-  # - openpmd-api                                             # mgard:  mgard.tpp:63:48: error: non-constant-expression cannot be narrowed from type 'int' to 'unsigned long' in initializer list [-Wc++11-narrowing]
-  # - pdt                                                     # pdt: pdbType.cc:193:21: warning: ISO C++11 does not allow conversion from string literal to 'char *' [-Wwritable-strings]
-  # - quantum-espresso                                        # quantum-espresso@7.2 /i3fqdx5: warning: <unknown>:0:0: loop not unroll-and-jammed: the optimizer was unable to perform the requested transformation; the transformation might be disabled or specified as part of an unsupported transformation ordering
-  # - swig@4.0.2-fortran                                      # ?
-  # - tau +mpi +python +syscall                               # pdt: pdbType.cc:193:21: warning: ISO C++11 does not allow conversion from string literal to 'char *' [-Wwritable-strings]
-  # - upcxx                                                   # upcxx: /opt/intel/oneapi/mpi/2021.10.0//libfabric/bin/fi_info: error while loading shared libraries: libfabric.so.1: cannot open shared object file: No such file or directory
+  # - cp2k +mpi                                             # dbcsr: dbcsr_api.F(973): #error: incomplete macro call DBCSR_ABORT.
+  # - geopm-runtime                                         # libelf: configure: error: installation or configuration problem: C compiler cannot create executables.
+  # - hpctoolkit                                            # dyninst@13.0.0%gcc: libiberty/./d-demangle.c:142: undefined reference to `_intel_fast_memcpy'
+  # - lbann                                                 # 2024.2 internal compiler error
+  # - plasma                                                # 2024.2 internal compiler error
+  # - quantum-espresso                                      # quantum-espresso: external/mbd/src/mbd_c_api.F90(392): error #6645: The name of the module procedure conflicts with a name in the encompassing scoping unit.   [F_C_STRING]
 
   # PYTHON PACKAGES
   - opencv +python3
@@ -232,8 +233,8 @@ spack:
   - upcxx +level_zero
   # --
   # - hpctoolkit +level_zero                                  # dyninst@12.3.0%gcc: /usr/bin/ld: libiberty/./d-demangle.c:142: undefined reference to `_intel_fast_memcpy'; can't mix intel-tbb@%oneapi with dyninst%gcc
-  # - slate +sycl                                             # blaspp: CMake Error at CMakeLists.txt:313 (find_package): ... set MKL_FOUND to FALSE so package "MKL" is considered to be NOT FOUND.
-  # - warpx compute=sycl                                      # warpx: spack-build-wzp6vvo/_deps/fetchedamrex-src/Src/Base/AMReX_RandomEngine.H:18:10: fatal error: 'oneapi/mkl/rng/device.hpp' file not found
+  # - slate +sycl                                             # slate: ifx: error #10426: option '-fopenmp-targets' requires '-fiopenmp'
+  # - warpx compute=sycl                                      # warpx: fetchedamrex-src/Src/Base/AMReX_RandomEngine.H:18:10: fatal error: 'oneapi/mkl/rng/device.hpp' file not found
 
 
   ci:

share/spack/gitlab/cloud_pipelines/stacks/e4s-rocm-external/spack.yaml

@@ -27,186 +27,186 @@ spack:
     comgr:
       buildable: false
       externals:
-      - spec: comgr@6.1.1
-        prefix: /opt/rocm-6.1.1/
+      - spec: comgr@6.1.2
+        prefix: /opt/rocm-6.1.2/
     hip-rocclr:
       buildable: false
       externals:
-      - spec: hip-rocclr@6.1.1
-        prefix: /opt/rocm-6.1.1/hip
+      - spec: hip-rocclr@6.1.2
+        prefix: /opt/rocm-6.1.2/hip
     hipblas:
       buildable: false
       externals:
-      - spec: hipblas@6.1.1
-        prefix: /opt/rocm-6.1.1/
+      - spec: hipblas@6.1.2
+        prefix: /opt/rocm-6.1.2/
     hipcub:
       buildable: false
       externals:
-      - spec: hipcub@6.1.1
-        prefix: /opt/rocm-6.1.1/
+      - spec: hipcub@6.1.2
+        prefix: /opt/rocm-6.1.2/
     hipfft:
       buildable: false
       externals:
-      - spec: hipfft@6.1.1
-        prefix: /opt/rocm-6.1.1/
+      - spec: hipfft@6.1.2
+        prefix: /opt/rocm-6.1.2/
     hipsparse:
       buildable: false
       externals:
-      - spec: hipsparse@6.1.1
-        prefix: /opt/rocm-6.1.1/
+      - spec: hipsparse@6.1.2
+        prefix: /opt/rocm-6.1.2/
     miopen-hip:
       buildable: false
       externals:
-      - spec: miopen-hip@6.1.1
-        prefix: /opt/rocm-6.1.1/
+      - spec: miopen-hip@6.1.2
+        prefix: /opt/rocm-6.1.2/
     miopengemm:
       buildable: false
       externals:
-      - spec: miopengemm@6.1.1
-        prefix: /opt/rocm-6.1.1/
+      - spec: miopengemm@6.1.2
+        prefix: /opt/rocm-6.1.2/
     rccl:
       buildable: false
       externals:
-      - spec: rccl@6.1.1
-        prefix: /opt/rocm-6.1.1/
+      - spec: rccl@6.1.2
+        prefix: /opt/rocm-6.1.2/
     rocblas:
       buildable: false
       externals:
-      - spec: rocblas@6.1.1
-        prefix: /opt/rocm-6.1.1/
+      - spec: rocblas@6.1.2
+        prefix: /opt/rocm-6.1.2/
     rocfft:
       buildable: false
       externals:
-      - spec: rocfft@6.1.1
-        prefix: /opt/rocm-6.1.1/
+      - spec: rocfft@6.1.2
+        prefix: /opt/rocm-6.1.2/
     rocm-clang-ocl:
       buildable: false
       externals:
-      - spec: rocm-clang-ocl@6.1.1
-        prefix: /opt/rocm-6.1.1/
+      - spec: rocm-clang-ocl@6.1.2
+        prefix: /opt/rocm-6.1.2/
     rocm-cmake:
       buildable: false
       externals:
-      - spec: rocm-cmake@6.1.1
-        prefix: /opt/rocm-6.1.1/
+      - spec: rocm-cmake@6.1.2
+        prefix: /opt/rocm-6.1.2/
     rocm-dbgapi:
       buildable: false
       externals:
-      - spec: rocm-dbgapi@6.1.1
-        prefix: /opt/rocm-6.1.1/
+      - spec: rocm-dbgapi@6.1.2
+        prefix: /opt/rocm-6.1.2/
     rocm-debug-agent:
       buildable: false
       externals:
-      - spec: rocm-debug-agent@6.1.1
-        prefix: /opt/rocm-6.1.1/
+      - spec: rocm-debug-agent@6.1.2
+        prefix: /opt/rocm-6.1.2/
     rocm-device-libs:
       buildable: false
       externals:
-      - spec: rocm-device-libs@6.1.1
-        prefix: /opt/rocm-6.1.1/
+      - spec: rocm-device-libs@6.1.2
+        prefix: /opt/rocm-6.1.2/
     rocm-gdb:
       buildable: false
       externals:
-      - spec: rocm-gdb@6.1.1
-        prefix: /opt/rocm-6.1.1/
+      - spec: rocm-gdb@6.1.2
+        prefix: /opt/rocm-6.1.2/
     rocm-opencl:
       buildable: false
       externals:
-      - spec: rocm-opencl@6.1.1
-        prefix: /opt/rocm-6.1.1/opencl
+      - spec: rocm-opencl@6.1.2
+        prefix: /opt/rocm-6.1.2/opencl
     rocm-smi-lib:
       buildable: false
       externals:
-      - spec: rocm-smi-lib@6.1.1
-        prefix: /opt/rocm-6.1.1/
+      - spec: rocm-smi-lib@6.1.2
+        prefix: /opt/rocm-6.1.2/
     hip:
       buildable: false
       externals:
-      - spec: hip@6.1.1
-        prefix: /opt/rocm-6.1.1
+      - spec: hip@6.1.2
+        prefix: /opt/rocm-6.1.2
         extra_attributes:
           compilers:
-            c: /opt/rocm-6.1.1/llvm/bin/clang++
-            c++: /opt/rocm-6.1.1/llvm/bin/clang++
-            hip: /opt/rocm-6.1.1/hip/bin/hipcc
+            c: /opt/rocm-6.1.2/llvm/bin/clang++
+            c++: /opt/rocm-6.1.2/llvm/bin/clang++
+            hip: /opt/rocm-6.1.2/hip/bin/hipcc
     hipify-clang:
       buildable: false
       externals:
-      - spec: hipify-clang@6.1.1
-        prefix: /opt/rocm-6.1.1
+      - spec: hipify-clang@6.1.2
+        prefix: /opt/rocm-6.1.2
     llvm-amdgpu:
       buildable: false
       externals:
-      - spec: llvm-amdgpu@6.1.1
-        prefix: /opt/rocm-6.1.1/llvm
+      - spec: llvm-amdgpu@6.1.2
+        prefix: /opt/rocm-6.1.2/llvm
         extra_attributes:
           compilers:
-            c: /opt/rocm-6.1.1/llvm/bin/clang++
-            cxx: /opt/rocm-6.1.1/llvm/bin/clang++
+            c: /opt/rocm-6.1.2/llvm/bin/clang++
+            cxx: /opt/rocm-6.1.2/llvm/bin/clang++
     hsakmt-roct:
       buildable: false
       externals:
-      - spec: hsakmt-roct@6.1.1
-        prefix: /opt/rocm-6.1.1/
+      - spec: hsakmt-roct@6.1.2
+        prefix: /opt/rocm-6.1.2/
     hsa-rocr-dev:
       buildable: false
       externals:
-      - spec: hsa-rocr-dev@6.1.1
-        prefix: /opt/rocm-6.1.1/
+      - spec: hsa-rocr-dev@6.1.2
+        prefix: /opt/rocm-6.1.2/
         extra_atributes:
           compilers:
-            c: /opt/rocm-6.1.1/llvm/bin/clang++
-            cxx: /opt/rocm-6.1.1/llvm/bin/clang++
+            c: /opt/rocm-6.1.2/llvm/bin/clang++
+            cxx: /opt/rocm-6.1.2/llvm/bin/clang++
     roctracer-dev-api:
       buildable: false
       externals:
-      - spec: roctracer-dev-api@6.1.1
-        prefix: /opt/rocm-6.1.1
+      - spec: roctracer-dev-api@6.1.2
+        prefix: /opt/rocm-6.1.2
     roctracer-dev:
       buildable: false
       externals:
       - spec: roctracer-dev@4.5.3
-        prefix: /opt/rocm-6.1.1
+        prefix: /opt/rocm-6.1.2
     rocprim:
       buildable: false
       externals:
-      - spec: rocprim@6.1.1
-        prefix: /opt/rocm-6.1.1
+      - spec: rocprim@6.1.2
+        prefix: /opt/rocm-6.1.2
     rocrand:
       buildable: false
       externals:
-      - spec: rocrand@6.1.1
-        prefix: /opt/rocm-6.1.1
+      - spec: rocrand@6.1.2
+        prefix: /opt/rocm-6.1.2
     hipsolver:
       buildable: false
       externals:
-      - spec: hipsolver@6.1.1
-        prefix: /opt/rocm-6.1.1
+      - spec: hipsolver@6.1.2
+        prefix: /opt/rocm-6.1.2
     rocsolver:
       buildable: false
       externals:
-      - spec: rocsolver@6.1.1
-        prefix: /opt/rocm-6.1.1
+      - spec: rocsolver@6.1.2
+        prefix: /opt/rocm-6.1.2
     rocsparse:
       buildable: false
       externals:
-      - spec: rocsparse@6.1.1
-        prefix: /opt/rocm-6.1.1
+      - spec: rocsparse@6.1.2
+        prefix: /opt/rocm-6.1.2
     rocthrust:
       buildable: false
       externals:
-      - spec: rocthrust@6.1.1
-        prefix: /opt/rocm-6.1.1
+      - spec: rocthrust@6.1.2
+        prefix: /opt/rocm-6.1.2
     rocprofiler-dev:
       buildable: false
       externals:
-      - spec: rocprofiler-dev@6.1.1
-        prefix: /opt/rocm-6.1.1
+      - spec: rocprofiler-dev@6.1.2
+        prefix: /opt/rocm-6.1.2
     rocm-core:
       buildable: false
       externals:
-      - spec: rocm-core@6.1.1
-        prefix: /opt/rocm-6.1.1
+      - spec: rocm-core@6.1.2
+        prefix: /opt/rocm-6.1.2
 
   specs:
   # ROCM NOARCH
@@ -300,7 +300,7 @@ spack:
   ci:
     pipeline-gen:
     - build-job:
-        image: ecpe4s/ubuntu22.04-runner-amd64-gcc-11.4-rocm6.1.1:2024.06.23
+        image: ecpe4s/ubuntu22.04-runner-amd64-gcc-11.4-rocm6.1.2:2024.07.22
 
   cdash:
     build-group: E4S ROCm External

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

@@ -0,0 +1,93 @@
+spack:
+  view: false
+  packages:
+    all:
+      require:
+      - target=x86_64_v3
+      - ~cuda
+      - +rocm
+      - amdgpu_target=gfx90a
+    gl:
+      require: "osmesa"
+    mpi:
+      require: openmpi
+
+  specs:
+    # Horovod
+    # - py-horovod
+
+    # Hugging Face
+    - py-transformers
+
+    # JAX
+    # Does not yet support Spack-installed ROCm
+    # - py-jax
+    # - py-jaxlib
+
+    # Keras
+    - py-keras backend=tensorflow
+    # - py-keras backend=jax
+    # - py-keras backend=torch
+    - py-keras-applications
+    - py-keras-preprocessing
+    - py-keras2onnx
+
+    # PyTorch
+    # Does not yet support Spack-installed ROCm
+    # - py-botorch
+    # - py-efficientnet-pytorch
+    # - py-gpytorch
+    # - py-kornia
+    # - py-lightning
+    # - py-pytorch-gradual-warmup-lr
+    # - py-pytorch-lightning
+    # - py-segmentation-models-pytorch
+    # - py-timm
+    # - py-torch
+    # - py-torch-cluster
+    # - py-torch-geometric
+    # - py-torch-nvidia-apex
+    # - py-torch-scatter
+    # - py-torch-sparse
+    # - py-torch-spline-conv
+    # - py-torchaudio
+    # - py-torchdata
+    # - py-torchfile
+    # - py-torchgeo
+    # - py-torchmetrics
+    # - py-torchtext
+    # - py-torchvision
+    # - py-vector-quantize-pytorch
+
+    # scikit-learn
+    - py-scikit-learn
+    - py-scikit-learn-extra
+
+    # TensorBoard
+    - py-tensorboard
+    - py-tensorboard-data-server
+    - py-tensorboard-plugin-wit
+    - py-tensorboardx
+
+    # TensorFlow
+    - py-tensorflow
+    - py-tensorflow-datasets
+    # version 2.16 is not available
+    # - py-tensorflow-estimator
+    - py-tensorflow-hub
+    - py-tensorflow-metadata
+    - py-tensorflow-probability
+
+    # XGBoost
+    # Does not yet support Spack-installed ROCm
+    # - py-xgboost
+
+  ci:
+    pipeline-gen:
+    - build-job:
+        image:
+          name: ghcr.io/spack/ubuntu-22.04:v2024-05-07
+          entrypoint: ['']
+
+  cdash:
+    build-group: Machine Learning

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

@@ -46,7 +46,7 @@ class Abacus(MakefilePackage):
     build_directory = "source"
 
     def edit(self, spec, prefix):
-        if "+openmp" in spec:
+        if spec.satisfies("+openmp"):
             inc_var = "_openmp-"
             system_var = "ELPA_LIB = -L${ELPA_LIB_DIR} -lelpa_openmp -Wl, -rpath=${ELPA_LIB_DIR}"
         else:

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

@@ -146,12 +146,12 @@ def configure_args(self):
         options += self.with_or_without("libxml2")
 
         oapp = options.append
-        if "@:8" in spec:
+        if spec.satisfies("@:8"):
             oapp(f"--enable-optim={self.spec.variants['optimization-flavor'].value}")
         else:
             oapp(f"--with-optim-flavor={self.spec.variants['optimization-flavor'].value}")
 
-        if "+wannier90" in spec:
+        if spec.satisfies("+wannier90"):
             if spec.satisfies("@:8"):
                 oapp(f"--with-wannier90-libs=-L{spec['wannier90'].prefix.lib} -lwannier -lm")
                 oapp(f"--with-wannier90-incs=-I{spec['wannier90'].prefix.modules}")
@@ -174,16 +174,16 @@ def configure_args(self):
                     ]
                 )
         else:
-            if "@:9.8" in spec:
+            if spec.satisfies("@:9.8"):
                 oapp(f"--with-fftw={spec['fftw-api'].prefix}")
                 oapp(f"--with-hdf5={spec['hdf5'].prefix}")
 
-            if "@:8" in spec:
+            if spec.satisfies("@:8"):
                 oapp("--with-dft-flavor=atompaw+libxc")
             else:
                 "--without-wannier90",
 
-        if "+mpi" in spec:
+        if spec.satisfies("+mpi"):
             oapp(f"CC={spec['mpi'].mpicc}")
             oapp(f"CXX={spec['mpi'].mpicxx}")
             oapp(f"FC={spec['mpi'].mpifc}")
@@ -192,18 +192,18 @@ def configure_args(self):
 
             # MPI version:
             # let the configure script auto-detect MPI support from mpi_prefix
-            if "@:8" in spec:
+            if spec.satisfies("@:8"):
                 oapp("--enable-mpi=yes")
             else:
                 oapp("--with-mpi")
         else:
-            if "@:8" in spec:
+            if spec.satisfies("@:8"):
                 oapp("--enable-mpi=no")
             else:
                 oapp("--without-mpi")
 
         # Activate OpenMP in Abinit Fortran code.
-        if "+openmp" in spec:
+        if spec.satisfies("+openmp"):
             oapp("--enable-openmp=yes")
         else:
             oapp("--enable-openmp=no")
@@ -213,19 +213,19 @@ def configure_args(self):
         is_using_intel_libraries = spec["lapack"].name in INTEL_MATH_LIBRARIES
         if is_using_intel_libraries:
             linalg_flavor = "mkl"
-        elif "@9:" in spec and "^openblas" in spec:
+        if spec.satisfies("@9:") and spec.satisfies("^openblas"):
             linalg_flavor = "openblas"
-        elif "@9:" in spec and "^fujitsu-ssl2" in spec:
+        if spec.satisfies("@9:") and spec.satisfies("^fujitsu-ssl2"):
             linalg_flavor = "openblas"
         else:
             linalg_flavor = "custom"
 
-        if "+scalapack" in spec:
+        if spec.satisfies("+scalapack"):
             linalg = spec["scalapack"].libs + linalg
-            if "@:8" in spec:
+            if spec.satisfies("@:8"):
                 linalg_flavor = f"scalapack+{linalg_flavor}"
 
-        if "@:8" in spec:
+        if spec.satisfies("@:8"):
             oapp(f"--with-linalg-libs={linalg.ld_flags}")
         else:
             oapp(f"LINALG_LIBS={linalg.ld_flags}")
@@ -235,14 +235,14 @@ def configure_args(self):
         if is_using_intel_libraries:
             fftflavor = "dfti"
         else:
-            if "+openmp" in spec:
+            if spec.satisfies("+openmp"):
                 fftflavor, fftlibs = "fftw3-threads", "-lfftw3_omp -lfftw3 -lfftw3f"
             else:
                 fftflavor, fftlibs = "fftw3", "-lfftw3 -lfftw3f"
 
         oapp(f"--with-fft-flavor={fftflavor}")
 
-        if "@:8" in spec:
+        if spec.satisfies("@:8"):
             if is_using_intel_libraries:
                 oapp(f"--with-fft-incs={spec['fftw-api'].headers.cpp_flags}")
                 oapp(f"--with-fft-libs={spec['fftw-api'].libs.ld_flags}")
@@ -271,7 +271,7 @@ def configure_args(self):
 
         # LibXC library
         libxc = spec["libxc:fortran"]
-        if "@:8" in spec:
+        if spec.satisfies("@:8"):
             options.extend(
                 [
                     f"--with-libxc-incs={libxc.headers.cpp_flags}",
@@ -285,7 +285,7 @@ def configure_args(self):
         hdf5 = spec["hdf5:hl"]
         netcdfc = spec["netcdf-c"]
         netcdff = spec["netcdf-fortran:shared"]
-        if "@:8" in spec:
+        if spec.satisfies("@:8"):
             oapp("--with-trio-flavor=netcdf")
             # Since version 8, Abinit started to use netcdf4 + hdf5 and we have
             # to link with the high level HDF5 library
@@ -318,7 +318,7 @@ def check(self):
         # the tests directly execute abinit. thus failing with MPI
         # TODO: run tests in tests/ via the builtin runtests.py
         #       requires Python with numpy, pyyaml, pandas
-        if "~mpi" in self.spec:
+        if self.spec.satisfies("~mpi"):
             make("tests_in")
 
     # Abinit assumes the *old* behavior of HDF5 where the library flags to link
@@ -333,5 +333,5 @@ def patch(self):
 
     def install(self, spec, prefix):
         make("install")
-        if "+install-tests" in spec:
+        if spec.satisfies("+install-tests"):
             install_tree("tests", spec.prefix.tests)

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

@@ -42,7 +42,7 @@ def cmake_args(self):
             self.define("BUILD_SHARED", str(spec.satisfies("+shared")).lower()),
         ]
 
-        if "+cuda" in spec:
+        if spec.satisfies("+cuda"):
             cuda_arch = [x for x in spec.variants["cuda_arch"].value if x]
             if cuda_arch:
                 args.append(f"-DCUDA_NVCC_FLAGS={' '.join(self.cuda_flags(cuda_arch))}")

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

@@ -353,7 +353,9 @@ class Acts(CMakePackage, CudaPackage):
     depends_on("nlohmann-json @3.9.1:", when="@0.14: +json")
     depends_on("podio @0.6:", when="@25: +edm4hep")
     depends_on("podio @0.16:", when="@30.3: +edm4hep")
+    depends_on("podio @:0", when="@:35 +edm4hep")
     depends_on("podio @0.16:", when="+podio")
+    depends_on("podio @:0", when="@:35 +podio")
     depends_on("pythia8", when="+pythia8")
     depends_on("python", when="+python")
     depends_on("python@3.8:", when="+python @19.11:19")
@@ -491,7 +493,7 @@ def plugin_cmake_variant(plugin_name, spack_variant):
             if spec.satisfies("@14: +vecmem"):
                 args.append("-DACTS_USE_SYSTEM_VECMEM=ON")
 
-        if "+cuda" in spec:
+        if spec.satisfies("+cuda"):
             cuda_arch = spec.variants["cuda_arch"].value
             if cuda_arch != "none":
                 args.append(f"-DCUDA_FLAGS=-arch=sm_{cuda_arch[0]}")

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

@@ -144,14 +144,14 @@ def configure_args(self):
         extra_args += self.enable_or_disable("shared")
         extra_args += self.enable_or_disable("fortran")
 
-        if "+mpi" in spec:
+        if spec.satisfies("+mpi"):
             env["MPICC"] = spec["mpi"].mpicc
             env["MPICXX"] = spec["mpi"].mpicxx
 
         extra_args += self.with_or_without("mpi", activation_value="prefix")
         extra_args += self.with_or_without("infiniband")
 
-        if "+zlib" in spec:
+        if spec.satisfies("+zlib"):
             extra_args.append(f"--with-zlib={spec['zlib-api'].prefix}")
         else:
             extra_args.append("--without-zlib")

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

@@ -292,7 +292,7 @@ def cmake_args(self):
             self.define("ADIOS2_USE_MGARD", False),
         ]
 
-        if "+sst" in spec:
+        if spec.satisfies("+sst"):
             args.extend(
                 [
                     # Broken dependency package
@@ -305,15 +305,15 @@ def cmake_args(self):
                 ]
             )
 
-        if "%fj" in spec:
+        if spec.satisfies("%fj"):
             args.extend(["-DCMAKE_Fortran_SUBMODULE_EXT=.smod", "-DCMAKE_Fortran_SUBMODULE_SEP=."])
 
         # hip support
-        if "+cuda" in spec:
+        if spec.satisfies("+cuda"):
             args.append(self.builder.define_cuda_architectures(self))
 
         # hip support
-        if "+rocm" in spec:
+        if spec.satisfies("+rocm"):
             args.append(self.builder.define_hip_architectures(self))
 
         return args
@@ -323,18 +323,18 @@ def libs(self):
         spec = self.spec
         libs_to_seek = set()
 
-        if "@2.6:" in spec:
+        if spec.satisfies("@2.6:"):
             libs_to_seek.add("libadios2_core")
             libs_to_seek.add("libadios2_c")
             libs_to_seek.add("libadios2_cxx11")
-            if "+fortran" in spec:
+            if spec.satisfies("+fortran"):
                 libs_to_seek.add("libadios2_fortran")
 
-            if "+mpi" in spec:
+            if spec.satisfies("+mpi"):
                 libs_to_seek.add("libadios2_core_mpi")
                 libs_to_seek.add("libadios2_c_mpi")
                 libs_to_seek.add("libadios2_cxx11_mpi")
-                if "+fortran" in spec:
+                if spec.satisfies("+fortran"):
                     libs_to_seek.add("libadios2_fortran_mpi")
 
             if "@2.7: +shared+hdf5" in spec and "@1.12:" in spec["hdf5"]:
@@ -342,7 +342,7 @@ def libs(self):
 
         else:
             libs_to_seek.add("libadios2")
-            if "+fortran" in spec:
+            if spec.satisfies("+fortran"):
                 libs_to_seek.add("libadios2_fortran")
 
         return find_libraries(
@@ -391,7 +391,7 @@ def test_examples(self):
 
         std_cmake_args = []
 
-        if "+mpi" in self.spec:
+        if self.spec.satisfies("+mpi"):
             mpi_exec = join_path(self.spec["mpi"].prefix, "bin", "mpiexec")
             std_cmake_args.append(f"-DMPIEXEC_EXECUTABLE={mpi_exec}")
 

var/spack/repos/builtin/packages/adol-c/package.py

@@ -87,12 +87,12 @@ def configure_args(self):
 
         configure_args = []
 
-        if "+boost" in spec:
+        if spec.satisfies("+boost"):
             configure_args.append(f"--with-boost={spec['boost'].prefix}")
         else:
             configure_args.append("--with-boost=no")
 
-        if "+openmp" in spec:
+        if spec.satisfies("+openmp"):
             configure_args.append(f"--with-openmp-flag={self.compiler.openmp_flag}")
 
         configure_args.extend(
@@ -107,14 +107,14 @@ def configure_args(self):
 
         # We can simply use the bundled examples to check
         # whether Adol-C works as expected
-        if "+examples" in spec:
+        if spec.satisfies("+examples"):
             configure_args.extend(
                 [
                     "--enable-docexa",  # Documented examples
                     "--enable-addexa",  # Additional examples
                 ]
             )
-            if "+openmp" in spec:
+            if spec.satisfies("+openmp"):
                 configure_args.append("--enable-parexa")  # Parallel examples
 
         return configure_args
@@ -130,11 +130,11 @@ def install_additional_files(self):
         install(config_h, join_path(prefix.include, "adolc"))
 
         # Install documentation to {prefix}/share
-        if "+doc" in spec:
+        if spec.satisfies("+doc"):
             install_tree(join_path("ADOL-C", "doc"), join_path(prefix.share, "doc"))
 
         # Install examples to {prefix}/share
-        if "+examples" in spec:
+        if spec.satisfies("+examples"):
             install_tree(join_path("ADOL-C", "examples"), join_path(prefix.share, "examples"))
 
             # Run some examples that don't require user input
@@ -148,7 +148,7 @@ def install_additional_files(self):
             ):
                 Executable("./checkpointing/checkpointing")()
 
-            if "+openmp" in spec:
+            if spec.satisfies("+openmp"):
                 with working_dir(
                     join_path(source_directory, "ADOL-C", "examples", "additional_examples")
                 ):

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

@@ -79,30 +79,30 @@ class Alpaka(CMakePackage, CudaPackage):
     def cmake_args(self):
         spec = self.spec
         args = []
-        if "backend=serial" in spec:
+        if spec.satisfies("backend=serial"):
             args.append(self.define("ALPAKA_ACC_CPU_B_SEQ_T_SEQ_ENABLE", True))
-        if "backend=threads" in self.spec:
+        if self.spec.satisfies("backend=threads"):
             args.append(self.define("ALPAKA_ACC_CPU_B_SEQ_T_THREADS_ENABLE", True))
-        if "backend=fiber" in spec:
+        if spec.satisfies("backend=fiber"):
             args.append(self.define("ALPAKA_ACC_CPU_B_SEQ_T_FIBERS_ENABLE", True))
-        if "backend=tbb" in spec:
+        if spec.satisfies("backend=tbb"):
             args.append(self.define("ALPAKA_ACC_CPU_B_TBB_T_SEQ_ENABLE", True))
-        if "backend=omp2_gridblock" in spec:
+        if spec.satisfies("backend=omp2_gridblock"):
             args.append(self.define("ALPAKA_ACC_CPU_B_OMP2_T_SEQ_ENABLE", True))
-        if "backend=omp2_blockthread" in spec:
+        if spec.satisfies("backend=omp2_blockthread"):
             args.append(self.define("ALPAKA_ACC_CPU_B_SEQ_T_OMP2_ENABLE", True))
-        if "backend=omp5" in spec:
+        if spec.satisfies("backend=omp5"):
             args.append(self.define("ALPAKA_ACC_ANY_BT_OMP5_ENABLE", True))
-        if "backend=oacc" in spec:
+        if spec.satisfies("backend=oacc"):
             args.append(self.define("ALPAKA_ACC_ANY_BT_OACC_ENABLE", True))
-        if "backend=cuda" in spec:
+        if spec.satisfies("backend=cuda"):
             args.append(self.define("ALPAKA_ACC_GPU_CUDA_ENABLE", True))
-        if "backend=cuda_only" in spec:
+        if spec.satisfies("backend=cuda_only"):
             args.append(self.define("ALPAKA_ACC_GPU_CUDA_ENABLE", True))
             args.append(self.define("ALPAKA_ACC_GPU_CUDA_ONLY_MODE", True))
-        if "backend=hip" in spec:
+        if spec.satisfies("backend=hip"):
             args.append(self.define("ALPAKA_ACC_GPU_HIP_ENABLE", True))
-        if "backend=hip_only" in spec:
+        if spec.satisfies("backend=hip_only"):
             args.append(self.define("ALPAKA_ACC_GPU_HIP_ENABLE", True))
             args.append(self.define("ALPAKA_ACC_GPU_HIP_ONLY_MODE", True))
 

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

@@ -165,11 +165,11 @@ def configure(self, spec, prefix):
         # Dynamic dispatcher builds a single portable optimized library
         # that can execute on different x86 CPU architectures.
         # It is supported for GCC compiler and Linux based systems only.
-        if "+amd-dynamic-dispatcher" in spec:
+        if spec.satisfies("+amd-dynamic-dispatcher"):
             options.append("--enable-dynamic-dispatcher")
 
         # Check if compiler is AOCC
-        if "%aocc" in spec:
+        if spec.satisfies("%aocc"):
             options.append("CC={0}".format(os.path.basename(spack_cc)))
             options.append("FC={0}".format(os.path.basename(spack_fc)))
             options.append("F77={0}".format(os.path.basename(spack_fc)))
@@ -186,10 +186,10 @@ def configure(self, spec, prefix):
                 "https://www.amd.com/content/dam/amd/en/documents/developer/version-4-2-documents/aocl/aocl-4-2-user-guide.pdf"
             )
 
-        if "+debug" in spec:
+        if spec.satisfies("+debug"):
             options.append("--enable-debug")
 
-        if "+mpi" in spec:
+        if spec.satisfies("+mpi"):
             options.append("--enable-mpi")
             options.append("--enable-amd-mpifft")
         else:
@@ -223,7 +223,7 @@ def configure(self, spec, prefix):
         simd_features = ["sse2", "avx", "avx2", "avx512"]
 
         # "avx512" is supported from amdfftw 4.0 version onwards
-        if "@2.2:3.2" in self.spec:
+        if self.spec.satisfies("@2.2:3.2"):
             simd_features.remove("avx512")
 
         simd_options = []

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

@@ -39,15 +39,15 @@ def build_targets(self):
         include_cflags = ["-DTIMER_USE_MPI"]
         include_lflags = ["-lm"]
 
-        if "+openmp" in self.spec:
+        if self.spec.satisfies("+openmp"):
             include_cflags.append("-DHYPRE_USING_OPENMP")
             include_cflags.append(self.compiler.openmp_flag)
             include_lflags.append(self.compiler.openmp_flag)
-            if "+optflags" in self.spec:
+            if self.spec.satisfies("+optflags"):
                 include_cflags.append("-DHYPRE_USING_PERSISTENT_COMM")
                 include_cflags.append("-DHYPRE_HOPSCOTCH")
 
-        if "+int64" in self.spec:
+        if self.spec.satisfies("+int64"):
             include_cflags.append("-DHYPRE_BIGINT")
 
         targets.append(f"INCLUDE_CFLAGS={' '.join(include_cflags)}")

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

@@ -45,7 +45,7 @@ def cmake_args(self):
         args = []
         args.append("-DCMAKE_NO_MPI={0}".format("1" if "+mpi" not in self.spec else "0"))
 
-        if "+cuda" in self.spec:
+        if self.spec.satisfies("+cuda"):
             args.append("-DWITH_CUDA=ON")
             cuda_arch = self.spec.variants["cuda_arch"].value
             if cuda_arch != "none":
@@ -53,10 +53,10 @@ def cmake_args(self):
         else:
             args.append("-DWITH_CUDA=OFF")
 
-        if "+mkl" in self.spec:
+        if self.spec.satisfies("+mkl"):
             args.append("-DMKL_ROOT_DIR={0}".format(self.spec["mkl"].prefix))
 
-        if "+magma" in self.spec:
+        if self.spec.satisfies("+magma"):
             args.append("-DMAGMA_ROOT_DIR={0}".format(self.spec["magma"].prefix))
 
         return args

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

@@ -70,7 +70,7 @@ def cmake_args(self):
             self.define("USE_MPI", "0"),
         ]
 
-        if "+mpi" in spec:
+        if spec.satisfies("+mpi"):
             options.extend(
                 [
                     self.define("CMAKE_C_COMPILER", spec["mpi"].mpicc),
@@ -101,7 +101,7 @@ def cmake_args(self):
             ]
         )
 
-        if "+zlib" in spec:
+        if spec.satisfies("+zlib"):
             tpl_list.append("ZLIB")
             options.append(self.define("TPL_ZLIB_INSTALL_DIR", spec["zlib-api"].prefix))
 
@@ -119,7 +119,7 @@ def cmake_args(self):
                 tpl_list.append(vname.upper())
                 options.append(self.define(f"TPL_{vname.upper()}_INSTALL_DIR", spec[vname].prefix))
 
-        if "+netcdf" in spec:
+        if spec.satisfies("+netcdf"):
             tpl_list.append("NETCDF")
             options.append(self.define("TPL_NETCDF_INSTALL_DIR", spec["netcdf-c"].prefix))
 

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

@@ -292,20 +292,20 @@ def cmake_args(self):
         if self.spec.satisfies("%fj"):
             args.append("-DCMAKE_Fortran_MODDIR_FLAG=-M")
 
-        if "+cuda" in self.spec:
+        if self.spec.satisfies("+cuda"):
             args.append("-DAMReX_GPU_BACKEND=CUDA")
             args.append("-DAMReX_CUDA_ERROR_CAPTURE_THIS=ON")
             args.append("-DAMReX_CUDA_ERROR_CROSS_EXECUTION_SPACE_CALL=ON")
             cuda_arch = self.spec.variants["cuda_arch"].value
             args.append("-DAMReX_CUDA_ARCH=" + self.get_cuda_arch_string(cuda_arch))
 
-        if "+rocm" in self.spec:
+        if self.spec.satisfies("+rocm"):
             args.append("-DCMAKE_CXX_COMPILER={0}".format(self.spec["hip"].hipcc))
             args.append("-DAMReX_GPU_BACKEND=HIP")
             targets = self.spec.variants["amdgpu_target"].value
             args.append("-DAMReX_AMD_ARCH=" + ";".join(str(x) for x in targets))
 
-        if "+sycl" in self.spec:
+        if self.spec.satisfies("+sycl"):
             args.append("-DAMReX_GPU_BACKEND=SYCL")
             # SYCL GPU backend only supported with Intel's oneAPI or DPC++ compilers
             sycl_compatible_compilers = ["icpx"]
@@ -344,7 +344,7 @@ def cmake_args(self):
         if self.spec.satisfies("%fj"):
             args.append("-DCMAKE_Fortran_MODDIR_FLAG=-M")
 
-        if "+cuda" in self.spec:
+        if self.spec.satisfies("+cuda"):
             cuda_arch = self.spec.variants["cuda_arch"].value
             args.append("-DCUDA_ARCH=" + self.get_cuda_arch_string(cuda_arch))
 
@@ -365,11 +365,11 @@ def test_run_install_test(self):
 
         args = ["-S{0}".format(join_path(".", "cache", "amrex", "Tests", "SpackSmokeTest"))]
         args.append("-DAMReX_ROOT=" + self.prefix)
-        if "+mpi" in self.spec:
+        if self.spec.satisfies("+mpi"):
             args.append("-DMPI_C_COMPILER=" + self.spec["mpi"].mpicc)
             args.append("-DMPI_CXX_COMPILER=" + self.spec["mpi"].mpicxx)
 
-        if "+cuda" in self.spec:
+        if self.spec.satisfies("+cuda"):
             args.append("-DCMAKE_CUDA_COMPILER=" + join_path(self.spec["cuda"].prefix.bin, "nvcc"))
 
         args.extend(self.cmake_args())

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

@@ -148,7 +148,7 @@ def setup_build_environment(self, env):
         # We don't want an AMREX_HOME the user may have set already
         env.unset("AMREX_HOME")
         # Help force Amrvis to not pick up random system compilers
-        if "+mpi" in self.spec:
+        if self.spec.satisfies("+mpi"):
             env.set("MPI_HOME", self.spec["mpi"].prefix)
             env.set("CC", self.spec["mpi"].mpicc)
             env.set("CXX", self.spec["mpi"].mpicxx)

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

@@ -114,31 +114,31 @@ def cmake_args(self):
             )
         )
 
-        if "+verbose" in spec:
+        if spec.satisfies("+verbose"):
             args.append("-DWITH_AMS_DEBUG=On")
 
-        if "+hdf5" in spec:
+        if spec.satisfies("+hdf5"):
             args.append("-DWITH_HDF5=On")
             args.append("-DHDF5_Dir={0}".format(spec["hdf5"].prefix))
 
-        if "+cuda" in spec:
+        if spec.satisfies("+cuda"):
             args.append("-DWITH_CUDA=On")
             cuda_arch = spec.variants["cuda_arch"].value[0]
             args.append("-DAMS_CUDA_ARCH={0}".format(cuda_arch))
 
-        if "+caliper" in spec:
+        if spec.satisfies("+caliper"):
             args.append("-DWITH_CALIPER=On")
             args.append("-DCALIPER_DIR={0}/share/cmake/caliper".format(spec["caliper"].prefix))
         else:
             args.append("-DWITH_CALIPER=Off")
 
-        if "+faiss" in spec:
+        if spec.satisfies("+faiss"):
             args.append("-DWITH_FAISS=On")
             args.append("-DFAISS_DIR={0}".format(spec["faiss"].prefix))
         else:
             args.append("-DWITH_FAISS=Off")
 
-        if "+torch" in spec:
+        if spec.satisfies("+torch"):
             args.append("-DWITH_TORCH=On")
             args.append(
                 "-DTorch_DIR={0}/lib/python{1}/site-packages"
@@ -147,15 +147,15 @@ def cmake_args(self):
                 )
             )
 
-        if "+redis" in spec:
+        if spec.satisfies("+redis"):
             args.append("-DWITH_REDIS=On")
             args.append("-DREDIS_PLUS_PLUS_DIR={0}".format(spec["redis-plus-plus"].prefix))
 
-        if "+rabbitmq" in spec:
+        if spec.satisfies("+rabbitmq"):
             args.append("-DWITH_RMQ=On")
             args.append("-Damqpcpp_DIR={0}/cmake".format(spec["amqp-cpp"].prefix))
 
-        if "+examples" in spec:
+        if spec.satisfies("+examples"):
             args.append("-DWITH_EXAMPLES=On")
             args.append("-DMFEM_DIR={0}".format(spec["mfem"].prefix))
 

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

@@ -80,7 +80,7 @@ class Aocc(Package, CompilerPackage):
 
     @run_before("install")
     def license_reminder(self):
-        if "+license-agreed" in self.spec:
+        if self.spec.satisfies("+license-agreed"):
             tty.msg(
                 "Reminder: by setting +license-agreed you are confirming you agree to the terms "
                 "of the {0} EULA (found at {1})".format(self.spec.name, self.license_url)

var/spack/repos/builtin/packages/aocl-compression/package.py

@@ -92,21 +92,21 @@ def cmake_args(self):
             "-DLZ4_FRAME_FORMAT_SUPPORT=ON",
             "-DAOCL_LZ4HC_DISABLE_PATTERN_ANALYSIS=ON",
         ]
-        if "~shared" in spec:
+        if spec.satisfies("~shared"):
             args.append("-DBUILD_STATIC_LIBS=ON")
-        if "~zlib" in spec:
+        if spec.satisfies("~zlib"):
             args.append("-DAOCL_EXCLUDE_ZLIB=ON")
-        if "~bzip2" in spec:
+        if spec.satisfies("~bzip2"):
             args.append("-DAOCL_EXCLUDE_BZIP2=ON")
-        if "~snappy" in spec:
+        if spec.satisfies("~snappy"):
             args.append("-DAOCL_EXCLUDE_SNAPPY=ON")
-        if "~zstd" in spec:
+        if spec.satisfies("~zstd"):
             args.append("-DAOCL_EXCLUDE_ZSTD=ON")
-        if "~lzma" in spec:
+        if spec.satisfies("~lzma"):
             args.append("-DAOCL_EXCLUDE_LZMA=ON")
-        if "~lz4" in spec:
+        if spec.satisfies("~lz4"):
             args.append("-DAOCL_EXCLUDE_LZ4=ON")
-        if "~lz4hc" in spec:
+        if spec.satisfies("~lz4hc"):
             args.append("-DAOCL_EXCLUDE_LZ4HC=ON")
 
         return args

var/spack/repos/builtin/packages/aocl-sparse/package.py

@@ -121,7 +121,7 @@ def cmake_args(self):
                 "-DAOCL_LIBFLAME_INCLUDE_DIR={0}".format(self.spec["amdlibflame"].prefix.include)
             )
 
-        if "@4.2:" in self.spec:
+        if self.spec.satisfies("@4.2:"):
             args.append(f"-DAOCL_UTILS_LIB={self.spec['aocl-utils'].libs}")
             args.append(
                 "-DAOCL_UTILS_INCLUDE_DIR={0}".format(self.spec["aocl-utils"].prefix.include)

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

@@ -99,7 +99,7 @@ def create_host_config(self, spec, prefix):
         # Find and record what CMake is used
         ##############################################
 
-        if "+cmake" in spec:
+        if spec.satisfies("+cmake"):
             cmake_exe = spec["cmake"].command.path
         else:
             cmake_exe = which("cmake")
@@ -133,17 +133,17 @@ def create_host_config(self, spec, prefix):
         cfg.write(cmake_cache_entry("CMAKE_CXX_COMPILER", cpp_compiler))
 
         # shared vs static libs
-        if "+shared" in spec:
+        if spec.satisfies("+shared"):
             cfg.write(cmake_cache_entry("BUILD_SHARED_LIBS", "ON"))
         else:
             cfg.write(cmake_cache_entry("BUILD_SHARED_LIBS", "OFF"))
 
-        if "+openmp" in spec:
+        if spec.satisfies("+openmp"):
             cfg.write(cmake_cache_entry("ENABLE_OPENMP", "ON"))
         else:
             cfg.write(cmake_cache_entry("ENABLE_OPENMP", "OFF"))
 
-        if "+mpi" in spec:
+        if spec.satisfies("+mpi"):
             mpicc_path = spec["mpi"].mpicc
             mpicxx_path = spec["mpi"].mpicxx
             # if we are using compiler wrappers on cray systems
@@ -156,7 +156,7 @@ def create_host_config(self, spec, prefix):
             cfg.write(cmake_cache_entry("ENABLE_MPI", "ON"))
             cfg.write(cmake_cache_entry("MPI_C_COMPILER", mpicc_path))
             cfg.write(cmake_cache_entry("MPI_CXX_COMPILER", mpicxx_path))
-            if "+blt_find_mpi" in spec:
+            if spec.satisfies("+blt_find_mpi"):
                 cfg.write(cmake_cache_entry("ENABLE_FIND_MPI", "ON"))
             else:
                 cfg.write(cmake_cache_entry("ENABLE_FIND_MPI", "OFF"))

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

@@ -146,7 +146,7 @@ def cmake_args(self):
         # CMake variables were updated in version 2.3.0, to make
         prefix = "APEX_WITH"
         test_prefix = "APEX_"
-        if "@2.2.0" in spec:
+        if spec.satisfies("@2.2.0"):
             prefix = "USE"
             test_prefix = ""
 
@@ -167,29 +167,29 @@ def cmake_args(self):
         args.append(self.define_from_variant(test_prefix + "BUILD_TESTS", "tests"))
         args.append(self.define_from_variant(test_prefix + "BUILD_EXAMPLES", "examples"))
 
-        if "+activeharmony" in spec:
+        if spec.satisfies("+activeharmony"):
             args.append("-DACTIVEHARMONY_ROOT={0}".format(spec["activeharmony"].prefix))
 
-        if "+binutils" in spec:
+        if spec.satisfies("+binutils"):
             args.append("-DBFD_ROOT={0}".format(spec["binutils"].prefix))
 
-        if "+binutils ^binutils+nls" in spec:
+        if spec.satisfies("+binutils ^binutils+nls"):
             if "intl" in self.spec["gettext"].libs.names:
                 args.append("-DCMAKE_SHARED_LINKER_FLAGS=-lintl")
 
-        if "+otf2" in spec:
+        if spec.satisfies("+otf2"):
             args.append("-DOTF2_ROOT={0}".format(spec["otf2"].prefix))
 
-        if "+papi" in spec:
+        if spec.satisfies("+papi"):
             args.append("-DPAPI_ROOT={0}".format(spec["papi"].prefix))
 
-        if "+gperftools" in spec:
+        if spec.satisfies("+gperftools"):
             args.append("-DGPERFTOOLS_ROOT={0}".format(spec["gperftools"].prefix))
 
-        if "+jemalloc" in spec:
+        if spec.satisfies("+jemalloc"):
             args.append("-DJEMALLOC_ROOT={0}".format(spec["jemalloc"].prefix))
 
-        if "+hip" in spec:
+        if spec.satisfies("+hip"):
             args.append("-DROCM_ROOT={0}".format(spec["hip"].prefix))
             args.append("-DROCTRACER_ROOT={0}".format(spec["roctracer-dev"].prefix))
             args.append("-DROCTX_ROOT={0}".format(spec["roctracer-dev"].prefix))

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

@@ -36,7 +36,10 @@ class Apptainer(SingularityBase):
     )
 
     version("main", branch="main")
-    version("1.3.1", sha256="6956c689c4a8f148789c5c34b33c15ad8f3460b4cee3f48022119fd872eacee9")
+    version("1.3.3", sha256="94a274ab4898cdb131f4e3867c4e15f7e16bc2823303d2afcbafee0242f0838d")
+    version("1.3.2", sha256="483910727e1a15843b93d9f2db1fc87e27804de9c74da13cc32cd4bd0d35e079")
+    # version "1.3.1" has security vulnerability CVE-2024-3727
+    # see also https://github.com/advisories/GHSA-6wvf-f2vw-3425
     version("1.2.5", sha256="606b67ef97683e1420401718687d258b1034fdf2edae72eeacd0828dffbfc2c2")
     version("1.1.9", sha256="c615777539154288542cf393d3fd44c04ccb3260bc6330dc324d4e4ebe902bfa")
     version("1.1.7", sha256="e6d3956a26c3965703402e17f153ba07f59bf710068806462b314d2d04e825e7")

var/spack/repos/builtin/packages/apr-util/package.py

@@ -58,22 +58,22 @@ def configure_args(self):
             "--without-oracle",
         ]
 
-        if "+crypto" in spec:
+        if spec.satisfies("+crypto"):
             args.extend(["--with-crypto", f"--with-openssl={spec['openssl'].prefix}"])
         else:
             args.append("--without-crypto")
 
-        if "+gdbm" in spec:
+        if spec.satisfies("+gdbm"):
             args.append(f"--with-gdbm={spec['gdbm'].prefix}")
         else:
             args.append("--without-gdbm")
 
-        if "+pgsql" in spec:
+        if spec.satisfies("+pgsql"):
             args.append(f"--with-pgsql={spec['postgresql'].prefix}")
         else:
             args.append("--without-pgsql")
 
-        if "+sqlite" in spec:
+        if spec.satisfies("+sqlite"):
             if spec.satisfies("^sqlite@3.0:3"):
                 args.extend([f"--with-sqlite3={spec['sqlite'].prefix}", "--without-sqlite2"])
             elif spec.satisfies("^sqlite@2.0:2"):
@@ -81,7 +81,7 @@ def configure_args(self):
         else:
             args.extend(["--without-sqlite2", "--without-sqlite3"])
 
-        if "+odbc" in spec:
+        if spec.satisfies("+odbc"):
             args.append(f"--with-odbc={spec['unixodbc'].prefix}")
         else:
             args.append("--without-odbc")

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

@@ -117,7 +117,7 @@ def cmake_args(self):
             self.define_from_variant("ARB_VECTORIZE", "vectorize"),
         ]
 
-        if "+cuda" in self.spec:
+        if self.spec.satisfies("+cuda"):
             args.append("-DARB_GPU=cuda")
             args.append(self.define_from_variant("ARB_USE_GPU_RNG", "gpu_rng"))
 

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

@@ -115,10 +115,10 @@ def cmake_args(self):
             self.define_from_variant("ARBORX_ENABLE_MPI", "mpi"),
         ]
 
-        if "+cuda" in spec:
+        if spec.satisfies("+cuda"):
             # Only Kokkos allows '+cuda' for now
             options.append("-DCMAKE_CXX_COMPILER=%s" % spec["kokkos"].kokkos_cxx)
-        if "+rocm" in spec:
+        if spec.satisfies("+rocm"):
             options.append("-DCMAKE_CXX_COMPILER=%s" % spec["hip"].hipcc)
 
         return options
@@ -152,7 +152,7 @@ def test_run_ctest(self):
             ),
             self.define("ArborX_ROOT", self.spec["arborx".prefix]),
         ]
-        if "+mpi" in self.spec:
+        if self.spec.satisfies("+mpi"):
             cmake_args.append(self.define("MPI_HOME", self.spec["mpi"].prefix))
         cmake = which(self.spec["cmake"].prefix.bin.cmake)
         make = which("make")

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

@@ -53,20 +53,20 @@ class Argobots(AutotoolsPackage):
 
     def configure_args(self):
         args = []
-        if "+perf" in self.spec:
+        if self.spec.satisfies("+perf"):
             args.append("--enable-perf-opt")
 
-        if "+valgrind" in self.spec:
+        if self.spec.satisfies("+valgrind"):
             args.append("--enable-valgrind")
         else:
             args.append("--disable-valgrind")
 
-        if "+debug" in self.spec:
+        if self.spec.satisfies("+debug"):
             args.append("--enable-debug=yes")
         else:
             args.append("--disable-debug")
 
-        if "+stackunwind" in self.spec:
+        if self.spec.satisfies("+stackunwind"):
             args.append("--enable-stack-unwind")
             args.append("--with-libunwind={0}".format(self.spec["libunwind"].prefix))
 
@@ -74,10 +74,10 @@ def configure_args(self):
         if stackguard != "none":
             args.append("--enable-stack-overflow-check={0}".format(stackguard))
 
-        if "+tool" in self.spec:
+        if self.spec.satisfies("+tool"):
             args.append("--enable-tool")
 
-        if "+affinity" in self.spec:
+        if self.spec.satisfies("+affinity"):
             args.append("--enable-affinity")
 
         return args

var/spack/repos/builtin/packages/arpack-ng/package.py

@@ -110,7 +110,7 @@ def libs(self):
         # query_parameters = self.spec.last_query.extra_parameters
         libraries = ["libarpack"]
 
-        if "+mpi" in self.spec:
+        if self.spec.satisfies("+mpi"):
             libraries = ["libparpack"] + libraries
 
         return find_libraries(libraries, root=self.prefix, shared=True, recursive=True)
@@ -160,7 +160,7 @@ def configure_args(self):
             + self.enable_or_disable("shared")
         )
 
-        if "+mpi" in spec:
+        if spec.satisfies("+mpi"):
             options.append(f"F77={spec['mpi'].mpif77}")
 
         return options

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

@@ -80,7 +80,7 @@ def cmake_args(self):
             ]
         )
 
-        if "+cuda" in self.spec:
+        if self.spec.satisfies("+cuda"):
             arch_list = [
                 "{}.{}".format(arch[:-1], arch[-1])
                 for arch in self.spec.variants["cuda_arch"].value

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

@@ -396,7 +396,7 @@ def hostconfig(self):
         #######################
         c_compiler = env["SPACK_CC"]
         cpp_compiler = env["SPACK_CXX"]
-        if "+fortran" in spec:
+        if spec.satisfies("+fortran"):
             f_compiler = env["SPACK_FC"]
         else:
             f_compiler = None
@@ -414,7 +414,7 @@ def hostconfig(self):
         # Find and record what CMake is used
         ##############################################
 
-        if "+cmake" in spec:
+        if spec.satisfies("+cmake"):
             cmake_exe = spec["cmake"].command.path
         else:
             cmake_exe = which("cmake")
@@ -449,14 +449,14 @@ def hostconfig(self):
         cfg.write(cmake_cache_entry("CMAKE_CXX_COMPILER", cpp_compiler))
 
         cfg.write("# fortran compiler used by spack\n")
-        if "+fortran" in spec:
+        if spec.satisfies("+fortran"):
             cfg.write(cmake_cache_entry("ENABLE_FORTRAN", "ON"))
             cfg.write(cmake_cache_entry("CMAKE_Fortran_COMPILER", f_compiler))
         else:
             cfg.write(cmake_cache_entry("ENABLE_FORTRAN", "OFF"))
 
         # shared vs static libs
-        if "+shared" in spec:
+        if spec.satisfies("+shared"):
             cfg.write(cmake_cache_entry("BUILD_SHARED_LIBS", "ON"))
         else:
             cfg.write(cmake_cache_entry("BUILD_SHARED_LIBS", "OFF"))
@@ -481,7 +481,7 @@ def hostconfig(self):
         #######################
         # Unit Tests
         #######################
-        if "+test" in spec:
+        if spec.satisfies("+test"):
             cfg.write(cmake_cache_entry("ENABLE_TESTS", "ON"))
         else:
             cfg.write(cmake_cache_entry("ENABLE_TESTS", "OFF"))
@@ -534,7 +534,7 @@ def hostconfig(self):
         # Serial
         #######################
 
-        if "+serial" in spec:
+        if spec.satisfies("+serial"):
             cfg.write(cmake_cache_entry("ENABLE_SERIAL", "ON"))
         else:
             cfg.write(cmake_cache_entry("ENABLE_SERIAL", "OFF"))
@@ -545,7 +545,7 @@ def hostconfig(self):
 
         cfg.write("# MPI Support\n")
 
-        if "+mpi" in spec:
+        if spec.satisfies("+mpi"):
             mpicc_path = spec["mpi"].mpicc
             mpicxx_path = spec["mpi"].mpicxx
             mpifc_path = spec["mpi"].mpifc if "+fortran" in spec else None
@@ -560,7 +560,7 @@ def hostconfig(self):
             cfg.write(cmake_cache_entry("ENABLE_MPI", "ON"))
             cfg.write(cmake_cache_entry("MPI_C_COMPILER", mpicc_path))
             cfg.write(cmake_cache_entry("MPI_CXX_COMPILER", mpicxx_path))
-            if "+fortran" in spec:
+            if spec.satisfies("+fortran"):
                 cfg.write(cmake_cache_entry("MPI_Fortran_COMPILER", mpifc_path))
             mpiexe_bin = join_path(spec["mpi"].prefix.bin, "mpiexec")
             if os.path.isfile(mpiexe_bin):
@@ -571,14 +571,14 @@ def hostconfig(self):
                 else:
                     cfg.write(cmake_cache_entry("MPIEXEC", mpiexe_bin))
 
-            if "+blt_find_mpi" in spec:
+            if spec.satisfies("+blt_find_mpi"):
                 cfg.write(cmake_cache_entry("ENABLE_FIND_MPI", "ON"))
             else:
                 cfg.write(cmake_cache_entry("ENABLE_FIND_MPI", "OFF"))
             ###################################
             # BABELFLOW (also depends on mpi)
             ###################################
-            if "+babelflow" in spec:
+            if spec.satisfies("+babelflow"):
                 cfg.write(cmake_cache_entry("ENABLE_BABELFLOW", "ON"))
                 cfg.write(cmake_cache_entry("BabelFlow_DIR", spec["babelflow"].prefix))
                 cfg.write(cmake_cache_entry("PMT_DIR", spec["parallelmergetree"].prefix))
@@ -591,12 +591,12 @@ def hostconfig(self):
 
         cfg.write("# CUDA Support\n")
 
-        if "+cuda" in spec:
+        if spec.satisfies("+cuda"):
             cfg.write(cmake_cache_entry("ENABLE_CUDA", "ON"))
         else:
             cfg.write(cmake_cache_entry("ENABLE_CUDA", "OFF"))
 
-        if "+openmp" in spec:
+        if spec.satisfies("+openmp"):
             cfg.write(cmake_cache_entry("ENABLE_OPENMP", "ON"))
         else:
             cfg.write(cmake_cache_entry("ENABLE_OPENMP", "OFF"))
@@ -606,7 +606,7 @@ def hostconfig(self):
         #######################
         cfg.write("# vtk-h support \n")
 
-        if "+vtkh" in spec:
+        if spec.satisfies("+vtkh"):
             cfg.write("# vtk-h\n")
             if self.spec.satisfies("@0.8.1:"):
                 cfg.write(cmake_cache_entry("ENABLE_VTKH", "ON"))
@@ -616,7 +616,7 @@ def hostconfig(self):
             cfg.write("# vtk-m from spack\n")
             cfg.write(cmake_cache_entry("VTKM_DIR", spec["vtk-m"].prefix))
 
-            if "+cuda" in spec:
+            if spec.satisfies("+cuda"):
                 cfg.write(cmake_cache_entry("VTKm_ENABLE_CUDA", "ON"))
                 cfg.write(cmake_cache_entry("CMAKE_CUDA_HOST_COMPILER", env["SPACK_CXX"]))
             else:
@@ -632,7 +632,7 @@ def hostconfig(self):
         #######################
         # RAJA
         #######################
-        if "+raja" in spec:
+        if spec.satisfies("+raja"):
             cfg.write("# RAJA from spack \n")
             cfg.write(cmake_cache_entry("RAJA_DIR", spec["raja"].prefix))
         else:
@@ -641,7 +641,7 @@ def hostconfig(self):
         #######################
         # Umpire
         #######################
-        if "+umpire" in spec:
+        if spec.satisfies("+umpire"):
             cfg.write("# umpire from spack \n")
             cfg.write(cmake_cache_entry("UMPIRE_DIR", spec["umpire"].prefix))
         else:
@@ -659,7 +659,7 @@ def hostconfig(self):
         #######################
         # MFEM
         #######################
-        if "+mfem" in spec:
+        if spec.satisfies("+mfem"):
             cfg.write("# mfem from spack \n")
             cfg.write(cmake_cache_entry("MFEM_DIR", spec["mfem"].prefix))
         else:
@@ -668,7 +668,7 @@ def hostconfig(self):
         #######################
         # OCCA
         #######################
-        if "+occa" in spec:
+        if spec.satisfies("+occa"):
             cfg.write("# occa from spack \n")
             cfg.write(cmake_cache_entry("OCCA_DIR", spec["occa"].prefix))
         else:
@@ -677,7 +677,7 @@ def hostconfig(self):
         #######################
         # Devil Ray
         #######################
-        if "+dray" in spec:
+        if spec.satisfies("+dray"):
             cfg.write("# devil ray\n")
             if self.spec.satisfies("@0.8.1:"):
                 cfg.write(cmake_cache_entry("ENABLE_DRAY", "ON"))
@@ -698,7 +698,7 @@ def hostconfig(self):
         #######################
         cfg.write("# adios2 support\n")
 
-        if "+adios2" in spec:
+        if spec.satisfies("+adios2"):
             cfg.write(cmake_cache_entry("ADIOS2_DIR", spec["adios2"].prefix))
         else:
             cfg.write("# adios2 not built by spack \n")
@@ -708,7 +708,7 @@ def hostconfig(self):
         #######################
         cfg.write("# Fides support\n")
 
-        if "+fides" in spec:
+        if spec.satisfies("+fides"):
             cfg.write(cmake_cache_entry("FIDES_DIR", spec["fides"].prefix))
         else:
             cfg.write("# fides not built by spack \n")
@@ -717,7 +717,7 @@ def hostconfig(self):
         # Caliper
         #######################
         cfg.write("# caliper from spack \n")
-        if "+caliper" in spec:
+        if spec.satisfies("+caliper"):
             cfg.write(cmake_cache_entry("CALIPER_DIR", spec["caliper"].prefix))
             cfg.write(cmake_cache_entry("ADIAK_DIR", spec["adiak"].prefix))
         else:

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

@@ -6,7 +6,7 @@
 from spack.package import *
 
 
-class Asciidoc(AutotoolsPackage):
+class Asciidoc(AutotoolsPackage, PythonPackage):
     """A presentable text document format for writing articles, UNIX man
     pages and other small to medium sized documents."""
 
@@ -17,6 +17,12 @@ class Asciidoc(AutotoolsPackage):
 
     license("GPL-2.0-only", checked_by="tgamblin")
 
+    build_system(
+        conditional("autotools", when="@:9"),
+        conditional("python_pip", when="@10:"),
+        default="python_pip",
+    )
+
     version("master", branch="master")
     version("10.2.0", sha256="684ea53c1f5b71d6d1ac6086bbc96906b1f709ecc7ab536615b0f0c9e1baa3cc")
     version("9.1.0", sha256="5056c20157349f8dc74f005b6e88ccbf1078c4e26068876f13ca3d1d7d045fe7")
@@ -31,6 +37,9 @@ class Asciidoc(AutotoolsPackage):
     depends_on("docbook-xml", type=("build", "run"))
     depends_on("docbook-xsl", type=("build", "run"))
     depends_on("python@3.5:", type=("build", "run"))
-    depends_on("autoconf", type="build")
-    depends_on("automake", type="build")
-    depends_on("libtool", type="build")
+    with when("build_system=python_pip"):
+        depends_on("py-setuptools", type="build")
+    with when("build_system=autotools"):
+        depends_on("autoconf", type="build")
+        depends_on("automake", type="build")
+        depends_on("libtool", type="build")

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

@@ -62,7 +62,7 @@ class Asio(AutotoolsPackage):
     version("1.16.1", sha256="e40bbd531530f08318b7c7d7e84e457176d8eae6f5ad2e3714dc27b9131ecd35")
     version("1.16.0", sha256="c87410ea62de6245aa239b9ed2057edf01d7f66acc3f5e50add9a29343c87512")
 
-    depends_on("cxx", type="build")  # generated
+    depends_on("cxx", type="build")
 
     depends_on("autoconf", type="build")
     depends_on("automake", type="build")

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

@@ -185,7 +185,7 @@ def setup_build_environment(self, env):
 
         env.set("OPT", "-O3")
 
-        if "+mpi" in spec:
+        if spec.satisfies("+mpi"):
             env.set("CC", spec["mpi"].mpicc)
             env.set("LDR", spec["mpi"].mpicc)
             env.set("MPILIB", spec["mpi"].libs.ld_flags)
@@ -194,7 +194,7 @@ def setup_build_environment(self, env):
             env.set("CC", spack_cc)
             env.set("LDR", spack_cc)
 
-        if "+fft" in spec:
+        if spec.satisfies("+fft"):
             env.set("FFTWLIB", spec["fftw"].libs.ld_flags)
             env.set("FFTWINC", spec["fftw"].headers.include_flags)
 
@@ -202,82 +202,82 @@ def configure_args(self):
         spec = self.spec
         args = []
 
-        if "+conduction" in spec:
+        if spec.satisfies("+conduction"):
             args.append("--enable-conduction")
         else:
             args.append("--disable-conduction")
 
-        if "+resistivity" in spec:
+        if spec.satisfies("+resistivity"):
             args.append("--enable-resistivity")
         else:
             args.append("--disable-resistivity")
 
-        if "+special_relativity" in spec:
+        if spec.satisfies("+special_relativity"):
             args.append("--enable-special-relativity")
         else:
             args.append("--disable-special-relativity")
 
-        if "+viscosity" in spec:
+        if spec.satisfies("+viscosity"):
             args.append("--enable-viscosity")
         else:
             args.append("--disable-viscosity")
 
-        if "+single" in spec:
+        if spec.satisfies("+single"):
             args.append("--enable-single")
         else:
             args.append("--disable-single")
 
-        if "+ghost" in spec:
+        if spec.satisfies("+ghost"):
             args.append("--enable-ghost")
         else:
             args.append("--disable-ghost")
 
-        if "+mpi" in spec:
+        if spec.satisfies("+mpi"):
             args.append("--enable-mpi")
         else:
             args.append("--disable-mpi")
 
-        if "+h_correction" in spec:
+        if spec.satisfies("+h_correction"):
             args.append("--enable-h-correction")
         else:
             args.append("--disable-h-correction")
 
-        if "+fft" in spec:
+        if spec.satisfies("+fft"):
             args.append("--enable-fft")
         else:
             args.append("--disable-fft")
 
-        if "+shearing_box" in spec:
+        if spec.satisfies("+shearing_box"):
             args.append("--enable-shearing-box")
         else:
             args.append("--disable-shearing-box")
 
-        if "+fargo" in spec:
+        if spec.satisfies("+fargo"):
             args.append("--enable-fargo")
         else:
             args.append("--disable-fargo")
 
-        if "+sts" in spec:
+        if spec.satisfies("+sts"):
             args.append("--enable-sts")
         else:
             args.append("--disable-sts")
 
-        if "+smr" in spec:
+        if spec.satisfies("+smr"):
             args.append("--enable-smr")
         else:
             args.append("--disable-smr")
 
-        if "+fofc" in spec:
+        if spec.satisfies("+fofc"):
             args.append("--enable-fofc")
         else:
             args.append("--disable-fofc")
 
-        if "+rotating_frame" in spec:
+        if spec.satisfies("+rotating_frame"):
             args.append("--enable-rotating_frame")
         else:
             args.append("--disable-rotating_frame")
 
-        if "+l1_inflow" in spec:
+        if spec.satisfies("+l1_inflow"):
             args.append("--enable-l1_inflow")
         else:
             args.append("--disable-l1_inflow")

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

@@ -100,7 +100,7 @@ def install(self, spec, prefix):
         # https://github.com/macports/macports-ports/blob/master/math/atlas/Portfile
         # https://github.com/Homebrew/homebrew-science/pull/3571
         options = []
-        if "+shared" in spec:
+        if spec.satisfies("+shared"):
             options.extend(["--shared"])
             # TODO: for non GNU add '-Fa', 'alg', '-fPIC' ?
 
@@ -129,7 +129,7 @@ def install(self, spec, prefix):
             make("check")
             make("ptcheck")
             make("time")
-            if "+shared" in spec:
+            if spec.satisfies("+shared"):
                 with working_dir("lib"):
                     make("shared_all")
 
@@ -143,7 +143,7 @@ def libs(self):
         # serial BLAS), and all ATLAS symbols needed to support them. Whereas
         # libtatlas.[so,dylib,dll ] is parallel (multithreaded) version.
         is_threaded = self.spec.satisfies("threads=pthreads")
-        if "+shared" in self.spec:
+        if self.spec.satisfies("+shared"):
             to_find = ["libtatlas"] if is_threaded else ["libsatlas"]
             shared = True
         else:

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

@@ -69,7 +69,7 @@ class Augustus(MakefilePackage):
     def edit(self, spec, prefix):
         # Set compile commands for each compiler and
         # Fix for using 'boost' on Spack. (only after ver.3.3.1-tag1)
-        if "@3.3.1-tag1:3.4.0" in spec:
+        if spec.satisfies("@3.3.1-tag1:3.4.0"):
             with working_dir(join_path("auxprogs", "utrrnaseq", "Debug")):
                 filter_file("g++", spack_cxx, "makefile", string=True)
                 filter_file(
@@ -108,22 +108,22 @@ def edit(self, spec, prefix):
             makefile = FileFilter("Makefile")
             makefile.filter("BAMTOOLS = .*", f"BAMTOOLS = {bamtools}")
             makefile.filter("INCLUDES = *", "INCLUDES = -I$(BAMTOOLS)/include/bamtools ")
-            if "bamtools@2.5:" in spec:
+            if spec.satisfies("bamtools@2.5:"):
                 makefile.filter(
                     "LIBS = -lbamtools -lz", "LIBS = $(BAMTOOLS)/lib64" "/libbamtools.a -lz"
                 )
-            if "bamtools@:2.4" in spec:
+            if spec.satisfies("bamtools@:2.4"):
                 makefile.filter(
                     "LIBS = -lbamtools -lz", "LIBS = $(BAMTOOLS)/lib/bamtools" "/libbamtools.a -lz"
                 )
         with working_dir(join_path("auxprogs", "bam2hints")):
             makefile = FileFilter("Makefile")
             makefile.filter("/usr/include/bamtools", f"{bamtools}/include/bamtools")
-            if "bamtools@2.5:" in spec:
+            if spec.satisfies("bamtools@2.5:"):
                 makefile.filter(
                     "LIBS = -lbamtools -lz", f"LIBS = {bamtools}/lib64/libbamtools.a -lz"
                 )
-            if "bamtools@:2.4" in spec:
+            if spec.satisfies("bamtools@:2.4"):
                 makefile.filter(
                     "LIBS = -lbamtools -lz", f"LIBS = {bamtools}/lib/bamtools/libbamtools.a -lz"
                 )
@@ -151,7 +151,7 @@ def edit(self, spec, prefix):
             with working_dir("src"):
                 makefile = FileFilter("Makefile")
                 makefile.filter(r"/usr/include/mysql\+\+", f"{mysqlpp}/include/mysql++")
-                if "^mariadb-c-client" in spec:
+                if spec.satisfies("^mariadb-c-client"):
                     makefile.filter("/usr/include/mysql", f"{mysql}/include/mariadb")
                 else:
                     makefile.filter("/usr/include/mysql", f"{mysql}/include/mysql")
@@ -180,10 +180,10 @@ def setup_build_environment(self, env):
         htslib = self.spec["htslib"].prefix
         bamtools = self.spec["bamtools"].prefix
 
-        if "@3.4.0" in self.spec:
+        if self.spec.satisfies("@3.4.0"):
             env.set("HTSLIBDIR", htslib)
 
-        if "@3.5.0:" in self.spec:
+        if self.spec.satisfies("@3.5.0:"):
             env.set("HTSLIB_INSTALL_DIR", htslib)
             env.set("BAMTOOLS_INSTALL_DIR", bamtools)
 

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

@@ -84,7 +84,7 @@ def patch(self):
         # We save and restore the modification timestamp of the file to prevent
         # regeneration of the respective man page:
         with keep_modification_time(patched_file):
-            if "@2.70:" in self.spec:
+            if self.spec.satisfies("@2.70:"):
                 shebang_string = "^#! @PERL@"
             else:
                 shebang_string = "^#! @PERL@ -w"
@@ -104,7 +104,7 @@ def filter_sbang(self):
         # target will try to rebuild the binaries (filter_file updates the
         # timestamps)
 
-        if "@2.70:" in self.spec:
+        if self.spec.satisfies("@2.70:"):
             shebang_string = "#! {0}"
         else:
             shebang_string = "#! {0} -w"

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

@@ -39,7 +39,7 @@ def configure_args(self):
             "--disable-nls"
         ]
 
-        if "+xml" in spec:
+        if spec.satisfies("+xml"):
             args.append(f"--with-libxml2={spec['libxml2'].prefix}")
         else:
             args.append("--without-libxml2")

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

@@ -45,10 +45,10 @@ def determine_version(cls, exe):
     def patch(self):
         # The full perl shebang might be too long
         files_to_be_patched_fmt = "bin/{0}.in"
-        if "@:1.15.1" in self.spec:
+        if self.spec.satisfies("@:1.15.1"):
             files_to_be_patched_fmt = "t/wrap/{0}.in"
 
-        if "@1.16.3:" in self.spec:
+        if self.spec.satisfies("@1.16.3:"):
             shebang_string = "^#!@PERL@"
         else:
             shebang_string = "^#!@PERL@ -w"

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

@@ -243,11 +243,11 @@ def cache_name(self):
             # Are we on a LLNL system then strip node number
             hostname = hostname.rstrip("1234567890")
         special_case = ""
-        if "+cuda" in self.spec:
+        if self.spec.satisfies("+cuda"):
             special_case += "_cuda"
-        if "~fortran" in self.spec:
+        if self.spec.satisfies("~fortran"):
             special_case += "_nofortran"
-        if "+rocm" in self.spec:
+        if self.spec.satisfies("+rocm"):
             special_case += "_hip"
         return "{0}-{1}-{2}@{3}{4}.cmake".format(
             hostname,
@@ -261,7 +261,7 @@ def initconfig_compiler_entries(self):
         spec = self.spec
         entries = super().initconfig_compiler_entries()
 
-        if "+fortran" in spec:
+        if spec.satisfies("+fortran"):
             entries.append(cmake_cache_option("ENABLE_FORTRAN", True))
             if self.is_fortran_compiler("gfortran") and "clang" in self.compiler.cxx:
                 libdir = pjoin(os.path.dirname(os.path.dirname(self.compiler.cxx)), "lib")
@@ -282,7 +282,7 @@ def initconfig_compiler_entries(self):
             entries.append(cmake_cache_string("BLT_CXX_STD", "c++14", ""))
 
         # Add optimization flag workaround for Debug builds with cray compiler or newer HIP
-        if "+rocm" in spec:
+        if spec.satisfies("+rocm"):
             entries.append(cmake_cache_string("CMAKE_CXX_FLAGS_DEBUG", "-O1 -g -DNDEBUG"))
 
         return entries
@@ -291,7 +291,7 @@ def initconfig_hardware_entries(self):
         spec = self.spec
         entries = super().initconfig_hardware_entries()
 
-        if "+cuda" in spec:
+        if spec.satisfies("+cuda"):
             entries.append(cmake_cache_option("ENABLE_CUDA", True))
             entries.append(cmake_cache_option("CMAKE_CUDA_SEPARABLE_COMPILATION", True))
 
@@ -304,7 +304,7 @@ def initconfig_hardware_entries(self):
 
             if spec.satisfies("^blt@:0.5.1"):
                 # This is handled internally by BLT now
-                if "+cpp14" in spec:
+                if spec.satisfies("+cpp14"):
                     cudaflags += " -std=c++14"
                 else:
                     cudaflags += " -std=c++11"
@@ -313,7 +313,7 @@ def initconfig_hardware_entries(self):
             entries.append("# nvcc does not like gtest's 'pthreads' flag\n")
             entries.append(cmake_cache_option("gtest_disable_pthreads", True))
 
-        if "+rocm" in spec:
+        if spec.satisfies("+rocm"):
             entries.append("#------------------{0}\n".format("-" * 60))
             entries.append("# Axom ROCm specifics\n")
             entries.append("#------------------{0}\n\n".format("-" * 60))
@@ -385,7 +385,7 @@ def initconfig_hardware_entries(self):
 
             entries.append(cmake_cache_string("BLT_EXE_LINKER_FLAGS", linker_flags, description))
 
-            if "+shared" in spec:
+            if spec.satisfies("+shared"):
                 linker_flags = "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-rpath," + libdir
                 entries.append(
                     cmake_cache_string("CMAKE_SHARED_LINKER_FLAGS", linker_flags, description)
@@ -440,7 +440,7 @@ def initconfig_mpi_entries(self):
         spec = self.spec
         entries = super().initconfig_mpi_entries()
 
-        if "+mpi" in spec:
+        if spec.satisfies("+mpi"):
             entries.append(cmake_cache_option("ENABLE_MPI", True))
             if spec["mpi"].name == "spectrum-mpi":
                 entries.append(cmake_cache_string("BLT_MPI_COMMAND_APPEND", "mpibind"))
@@ -496,7 +496,7 @@ def initconfig_package_entries(self):
             else:
                 entries.append("# %s not built\n" % dep.upper())
 
-        if "+profiling" in spec:
+        if spec.satisfies("+profiling"):
             dep_dir = get_spec_path(spec, "adiak", path_replacements)
             entries.append(cmake_cache_path("ADIAK_DIR", dep_dir))
 
@@ -508,7 +508,7 @@ def initconfig_package_entries(self):
             entries.append(cmake_cache_path("CAMP_DIR", dep_dir))
 
         # SCR does not export it's targets so we need to pull in its dependencies
-        if "+scr" in spec:
+        if spec.satisfies("+scr"):
             dep_dir = get_spec_path(spec, "scr", path_replacements)
             entries.append(cmake_cache_path("SCR_DIR", dep_dir))
 
@@ -541,7 +541,7 @@ def initconfig_package_entries(self):
         entries.append("#------------------{0}\n".format("-" * 60))
 
         # Add common prefix to path replacement list
-        if "+devtools" in spec:
+        if spec.satisfies("+devtools"):
             # Grab common devtools root and strip the trailing slash
             path1 = os.path.realpath(spec["cppcheck"].prefix)
             path2 = os.path.realpath(spec["doxygen"].prefix)

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

@@ -56,7 +56,7 @@ class Babelstream(CMakePackage, CudaPackage, ROCmPackage):
 
     # ACC conflict
     variant("cpu_arch", values=str, default="none", description="Enable CPU Target for ACC")
-    variant("target", values=str, default="none", description="Enable CPU Target for ACC")
+    variant("acc_target", values=str, default="none", description="Enable CPU Target for ACC")
 
     # STD conflicts
     conflicts("+stddata", when="%gcc@:10.1.0", msg="STD-data requires newer version of GCC")
@@ -77,7 +77,7 @@ class Babelstream(CMakePackage, CudaPackage, ROCmPackage):
     conflicts(
         "offload=none",
         when="+raja",
-        msg="RAJA requires architecture to be specfied by target=[CPU,NVIDIA]",
+        msg="RAJA requires architecture to be specfied by acc_target=[CPU,NVIDIA]",
     )
 
     # download raja from https://github.com/LLNL/RAJA

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

@@ -7,7 +7,7 @@
 
 
 class Bacio(CMakePackage):
-    """The bacio ibrary performs binary I/O for the NCEP models, processing
+    """The bacio library performs binary I/O for the NCEP models, processing
     unformatted byte-addressable data records, and transforming the little
     endian files and big endian files."""
 
@@ -15,15 +15,15 @@ class Bacio(CMakePackage):
     url = "https://github.com/NOAA-EMC/NCEPLIBS-bacio/archive/refs/tags/v2.4.1.tar.gz"
     git = "https://github.com/NOAA-EMC/NCEPLIBS-bacio"
 
-    maintainers("t-brown", "edwardhartnett", "AlexanderRichert-NOAA", "Hang-Lei-NOAA")
+    maintainers("edwardhartnett", "AlexanderRichert-NOAA", "Hang-Lei-NOAA")
 
     version("develop", branch="develop")
     version("2.6.0", sha256="03fef581e1bd3710fb8d2f2659a6c3e01a0437c1350ba53958d2ff1ffef47bcb")
     version("2.5.0", sha256="540a0ed73941d70dbf5d7b21d5d0a441e76fad2bfe37dfdfea0db3e98fc0fbfb")
     version("2.4.1", sha256="7b9b6ba0a288f438bfba6a08b6e47f8133f7dba472a74ac56a5454e2260a7200")
 
-    depends_on("c", type="build")  # generated
-    depends_on("fortran", type="build")  # generated
+    depends_on("c", type="build")
+    depends_on("fortran", type="build")
 
     variant("pic", default=True, description="Build with position-independent-code")
     variant("shared", default=False, description="Build shared library", when="@2.6.0:")

var/spack/repos/builtin/packages/blast-plus/package.py

@@ -14,6 +14,8 @@ class BlastPlus(AutotoolsPackage):
 
     maintainers("weijianwen")
 
+    version("2.16.0", sha256="17c93cf009721023e5aecf5753f9c6a255d157561638b91b3ad7276fd6950c2b")
+    version("2.15.0", sha256="6918c370524c8d44e028bf491e8f245a895e07c66c77b261ce3b38d6058216e0")
     version("2.14.1", sha256="712c2dbdf0fb13cc1c2d4f4ef5dd1ce4b06c3b57e96dfea8f23e6e99f5b1650e")
     version("2.13.0", sha256="89553714d133daf28c477f83d333794b3c62e4148408c072a1b4620e5ec4feb2")
     version("2.12.0", sha256="fda3c9c9d488cad6c1880a98a236d842bcf3610e3e702af61f7a48cf0a714b88")

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

@@ -17,12 +17,13 @@ class Bufr(CMakePackage):
     """
 
     homepage = "https://noaa-emc.github.io/NCEPLIBS-bufr"
-    url = "https://github.com/NOAA-EMC/NCEPLIBS-bufr/archive/refs/tags/bufr_v11.5.0.tar.gz"
+    url = "https://github.com/NOAA-EMC/NCEPLIBS-bufr/archive/refs/tags/v12.1.0.tar.gz"
     git = "https://github.com/NOAA-EMC/NCEPLIBS-bufr"
 
     maintainers("AlexanderRichert-NOAA", "edwardhartnett", "Hang-Lei-NOAA", "jbathegit")
 
     version("develop", branch="develop")
+    version("12.1.0", sha256="b5eae61b50d4132b2933b6e6dfc607e5392727cdc4f46ec7a94a19109d91dcf3")
     version("12.0.1", sha256="525f26238dba6511a453fc71cecc05f59e4800a603de2abbbbfb8cbb5adf5708")
     version("12.0.0", sha256="d01c02ea8e100e51fd150ff1c4a1192ca54538474acb1b7f7a36e8aeab76ee75")
     version("11.7.1", sha256="6533ce6eaa6b02c0cb5424cfbc086ab120ccebac3894980a4daafd4dfadd71f8")
@@ -31,8 +32,8 @@ class Bufr(CMakePackage):
     version("11.5.0", sha256="d154839e29ef1fe82e58cf20232e9f8a4f0610f0e8b6a394b7ca052e58f97f43")
     version("11.4.0", sha256="946482405e675b99e8e0c221d137768f246076f5e9ba92eed6cae47fb68b7a26")
 
-    depends_on("c", type="build")  # generated
-    depends_on("fortran", type="build")  # generated
+    depends_on("c", type="build")
+    depends_on("fortran", type="build")
 
     # Patch to not add "-c" to ranlib flags when using llvm-ranlib on Apple systems
     patch("cmakelists-apple-llvm-ranlib.patch", when="@11.5.0:11.6.0")
@@ -41,8 +42,10 @@ class Bufr(CMakePackage):
     # Patch to identify Python version correctly
     patch("python-version.patch", when="@11.5:12.0.0 +python")
 
-    variant("python", default=False, description="Enable Python interface?")
+    variant("python", default=False, description="Enable Python interface")
     variant("shared", default=True, description="Build shared libraries", when="@11.5:")
+    variant("test_files", default="none", description="Path to test files")
+    variant("utils", default=True, description="Build utilities", when="@12.1:")
 
     extends("python", when="+python")
 
@@ -52,6 +55,8 @@ class Bufr(CMakePackage):
     depends_on("py-pip", type="build", when="+python")
     depends_on("py-wheel", type="build", when="+python")
 
+    conflicts("%oneapi@:2024.1", msg="Requires oneapi 2024.2 or later")
+
     def url_for_version(self, version):
         pre = "bufr_" if version < Version("12.0.1") else ""
         return (
@@ -68,8 +73,13 @@ def cmake_args(self):
             self.define_from_variant("ENABLE_PYTHON", "python"),
             self.define_from_variant("BUILD_SHARED_LIBS", "shared"),
             self.define("BUILD_TESTS", self.run_tests),
+            self.define("BUILD_TESTING", self.run_tests),
+            self.define_from_variant("BUILD_UTILS", "utils"),
         ]
 
+        if not self.spec.satisfies("test_files=none"):
+            args.append(self.define_from_variant("TEST_FILE_DIR", "test_files"))
+
         return args
 
     def flag_handler(self, name, flags):
@@ -119,6 +129,5 @@ def setup_run_environment(self, env):
             self._setup_bufr_environment(env, suffix)
 
     def check(self):
-        if self.spec.satisfies("~python"):
-            with working_dir(self.builder.build_directory):
-                make("test")
+        with working_dir(self.builder.build_directory):
+            make("test")

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

@@ -21,5 +21,8 @@ class Capstone(CMakePackage):
     version("4.0.2", sha256="7c81d798022f81e7507f1a60d6817f63aa76e489aa4e7055255f21a22f5e526a")
     version("4.0.1", sha256="79bbea8dbe466bd7d051e037db5961fdb34f67c9fac5c3471dd105cfb1e05dc7")
 
-    depends_on("c", type="build")  # generated
-    depends_on("cxx", type="build")  # generated
+    depends_on("c", type="build")
+    depends_on("cxx", type="build")
+
+    def cmake_args(self):
+        return ["-DCMAKE_POSITION_INDEPENDENT_CODE:BOOL=TRUE"]

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

@@ -6,6 +6,7 @@
 import os
 import subprocess
 
+import spack.platforms.cray
 from spack.package import *
 from spack.util.environment import is_system_path, set_env
 
@@ -58,7 +59,6 @@ class Chapel(AutotoolsPackage, CudaPackage, ROCmPackage):
 
     depends_on("c", type="build")  # generated
     depends_on("cxx", type="build")  # generated
-    depends_on("fortran", type="build")  # generated
 
     patch("fix_spack_cc_wrapper_in_cray_prgenv.patch", when="@2.0.0:")
 
@@ -178,6 +178,14 @@ class Chapel(AutotoolsPackage, CudaPackage, ROCmPackage):
         values=("ibv", "ofi", "udp", "smp", "unset"),
         multi=False,
         sticky=True,  # never allow the concretizer to choose this
+        when="comm=gasnet",
+    )
+
+    variant(
+        "pshm",
+        default=False,
+        description="Build Chapel with fast shared-memory comms between co-locales",
+        when="comm=gasnet",
     )
 
     # Chapel depends on GASNet whenever comm=gasnet.
@@ -190,6 +198,7 @@ class Chapel(AutotoolsPackage, CudaPackage, ROCmPackage):
         default="bundled",
         values=("bundled", "spack"),
         multi=False,
+        when="comm=gasnet",
     )
 
     variant(
@@ -199,6 +208,7 @@ class Chapel(AutotoolsPackage, CudaPackage, ROCmPackage):
         "supplied CHPL_GASNET_SEGMENT",
         values=("everything", "fast", "large", "unset"),
         multi=False,
+        when="comm=gasnet",
     )
 
     variant(
@@ -281,9 +291,25 @@ class Chapel(AutotoolsPackage, CudaPackage, ROCmPackage):
     variant(
         "libfabric",
         default="unset",
-        description="When building with ofi support, specify libfabric option",
+        description="Control the libfabric version used for multi-locale communication",
         values=("bundled", "spack", "unset"),
         multi=False,
+        when="comm=ofi",
+    )
+
+    variant(
+        "libfabric",
+        default="unset",
+        description="Control the libfabric version used for multi-locale communication",
+        values=("bundled", "spack", "unset"),
+        multi=False,
+        when="comm=gasnet comm_substrate=ofi",
+    )
+
+    requires(
+        "^libfabric" + (" fabrics=cxi" if spack.platforms.cray.slingshot_network() else ""),
+        when="libfabric=spack",
+        msg="libfabric requires cxi fabric provider on HPE-Cray EX machines",
     )
 
     variant(
@@ -361,7 +387,7 @@ class Chapel(AutotoolsPackage, CudaPackage, ROCmPackage):
             ),
             default=True,
         )
-        depends_on(dep, when="+{0}".format(variant_name))
+        depends_on(dep, when="+{0}".format(variant_name), type=("build", "link", "run", "test"))
 
     # TODO: for CHPL_X_CC and CHPL_X_CXX, can we capture an arbitrary path, possibly
     # with arguments?
@@ -410,7 +436,14 @@ class Chapel(AutotoolsPackage, CudaPackage, ROCmPackage):
     conflicts("platform=windows")  # Support for windows is through WSL only
 
     conflicts("+rocm", when="+cuda", msg="Chapel must be built with either CUDA or ROCm, not both")
-    conflicts("+rocm", when="@:2.0.0", msg="ROCm support in spack requires Chapel 2.0.0 or later")
+    conflicts(
+        "+rocm", when="@:1.99.99", msg="ROCm support in spack requires Chapel 2.0.0 or later"
+    )
+    # Chapel restricts the allowable ROCm versions
+    with when("+rocm"):
+        depends_on("hsa-rocr-dev@4:5.4")
+        depends_on("hip@4:5.4")
+        depends_on("llvm-amdgpu@4:5.4")
 
     conflicts(
         "comm_substrate=unset",
@@ -418,9 +451,19 @@ class Chapel(AutotoolsPackage, CudaPackage, ROCmPackage):
         msg="comm=gasnet requires you to also set comm_substrate= to the appropriate network",
     )
 
+    conflicts(
+        "gasnet_segment=everything",
+        when="+pshm",
+        msg="gasnet_segment=everything does not support +pshm",
+    )
+
+    # comm_substrate=udp gasnet_segment=unset defaults to everything,
+    # which is incompatible with +pshm
+    requires("gasnet_segment=fast", when="+pshm comm_substrate=udp")
+
     conflicts(
         "^python@3.12:",
-        when="@:2.1.0",
+        when="@:2.0.99",
         msg="Chapel versions prior to 2.1.0 may produce SyntaxWarnings with Python >= 3.12",
     )
 
@@ -447,20 +490,18 @@ class Chapel(AutotoolsPackage, CudaPackage, ROCmPackage):
     depends_on("doxygen@1.8.17:", when="+chpldoc")
 
     # TODO: keep up to date with util/chplenv/chpl_llvm.py
-    with when("llvm=spack"):
+    with when("llvm=spack ~rocm"):
         depends_on("llvm@11:17", when="@:2.0.1")
         depends_on("llvm@11:18", when="@2.1.0:")
 
     # Based on docs https://chapel-lang.org/docs/technotes/gpu.html#requirements
-    depends_on("llvm@16:", when="llvm=spack ^cuda@12:")
+    depends_on("llvm@16:", when="llvm=spack +cuda ^cuda@12:")
     requires(
         "^llvm targets=all",
         msg="llvm=spack +cuda requires LLVM support the nvptx target",
         when="llvm=spack +cuda",
     )
 
-    depends_on("cuda@11:", when="+cuda", type=("build", "link", "run", "test"))
-
     # This is because certain systems have binutils installed as a system package
     # but do not include the headers. Spack incorrectly supplies those external
     # packages as proper dependencies for LLVM, but then LLVM will fail to build
@@ -469,11 +510,17 @@ class Chapel(AutotoolsPackage, CudaPackage, ROCmPackage):
 
     depends_on("m4")
 
-    depends_on("gmp", when="gmp=spack", type=("build", "link", "run", "test"))
-    depends_on("hwloc", when="hwloc=spack", type=("build", "link", "run", "test"))
-    depends_on("libfabric", when="libfabric=spack", type=("build", "link", "run", "test"))
-    depends_on("libunwind", when="unwind=spack", type=("build", "link", "run", "test"))
-    depends_on("jemalloc", when="host_jemalloc=spack", type=("build", "link", "run", "test"))
+    # Runtime dependencies:
+    # Note here "run" is run of the Chapel compiler built by this package,
+    # but many of these are ALSO run-time dependencies of the executable
+    # application built by that Chapel compiler from user-provided sources.
+    with default_args(type=("build", "link", "run", "test")):
+        depends_on("cuda@11:", when="+cuda")
+        depends_on("gmp", when="gmp=spack")
+        depends_on("hwloc", when="hwloc=spack")
+        depends_on("libfabric", when="libfabric=spack")
+        depends_on("libunwind", when="unwind=spack")
+        depends_on("jemalloc", when="host_jemalloc=spack")
 
     depends_on("gasnet conduits=none", when="gasnet=spack")
     depends_on("gasnet@2024.5.0: conduits=none", when="@2.1.0: gasnet=spack")
@@ -523,13 +570,25 @@ def setup_chpl_compilers(self, env):
 
         # Undo spack compiler wrappers:
         # the C/C++ compilers must work post-install
-        if self.spec.satisfies("+cuda") or self.spec.satisfies("+rocm"):
+        if self.spec.satisfies("+rocm"):
             env.set("CHPL_TARGET_COMPILER", "llvm")
+            env.set(
+                "CHPL_LLVM_CONFIG",
+                join_path(self.spec["llvm-amdgpu"].prefix, "bin", "llvm-config"),
+            )
+            real_cc = join_path(self.spec["llvm-amdgpu"].prefix, "bin", "clang")
+            real_cxx = join_path(self.spec["llvm-amdgpu"].prefix, "bin", "clang++")
+
+            # +rocm appears to also require a matching LLVM host compiler to guarantee linkage
+            env.set("CHPL_HOST_COMPILER", "llvm")
+            env.set("CHPL_HOST_CC", real_cc)
+            env.set("CHPL_HOST_CXX", real_cxx)
+
+        elif self.spec.satisfies("llvm=spack"):
+            env.set("CHPL_TARGET_COMPILER", "llvm")
+            env.set("CHPL_LLVM_CONFIG", join_path(self.spec["llvm"].prefix, "bin", "llvm-config"))
             real_cc = join_path(self.spec["llvm"].prefix, "bin", "clang")
             real_cxx = join_path(self.spec["llvm"].prefix, "bin", "clang++")
-        elif is_CrayEX() and os.environ.get("CRAYPE_DIR"):
-            real_cc = join_path(os.environ["CRAYPE_DIR"], "bin", "cc")
-            real_cxx = join_path(os.environ["CRAYPE_DIR"], "bin", "CC")
         else:
             real_cc = self.compiler.cc
             real_cxx = self.compiler.cxx
@@ -539,6 +598,9 @@ def setup_chpl_compilers(self, env):
     def setup_chpl_comm(self, env, spec):
         env.set("CHPL_COMM", spec.variants["comm"].value)
 
+        if self.spec.satisfies("+pshm"):
+            env.set("CHPL_GASNET_MORE_CFG_OPTIONS", "--enable-pshm")
+
     @run_before("configure", when="gasnet=spack")
     def setup_gasnet(self):
         dst = join_path(self.stage.source_path, "third-party", "gasnet", "gasnet-src")
@@ -546,12 +608,6 @@ def setup_gasnet(self):
         os.rmdir(dst)
         symlink(self.spec["gasnet"].prefix.src, dst)
 
-    def setup_chpl_llvm(self, env):
-        if self.spec.variants["llvm"].value == "spack":
-            env.set(
-                "CHPL_LLVM_CONFIG", "{0}/{1}".format(self.spec["llvm"].prefix, "bin/llvm-config")
-            )
-
     def setup_if_not_unset(self, env, var, value):
         if value != "unset":
             if value == "spack":
@@ -562,12 +618,18 @@ def prepend_cpath_include(self, env, prefix):
         if not is_system_path(prefix):
             env.prepend_path("CPATH", prefix.include)
 
+    def set_lib_path(self, env, prefix):
+        if not is_system_path(prefix):
+            env.prepend_path("LD_LIBRARY_PATH", prefix.lib)
+            env.prepend_path("LIBRARY_PATH", prefix.lib)
+            if prefix.lib.pkgconfig is not None:
+                env.prepend_path("PKG_CONFIG_PATH", prefix.lib.pkgconfig)
+
     def setup_env_vars(self, env):
         # variants that appear unused by Spack typically correspond directly to
         # a CHPL_<variant> variable which will be used by the Chapel build system
         for v in self.spec.variants.keys():
             self.setup_if_not_unset(env, "CHPL_" + v.upper(), self.spec.variants[v].value)
-        self.setup_chpl_llvm(env)
         self.setup_chpl_compilers(env)
         self.setup_chpl_platform(env)
 
@@ -578,47 +640,51 @@ def setup_env_vars(self, env):
         if self.spec.satisfies("+developer"):
             env.set("CHPL_DEVELOPER", "true")
 
+        if not self.spec.satisfies("llvm=none"):
+            # workaround Spack issue #44746:
+            # Chapel does not directly utilize lua, but many of its
+            # launchers depend on system installs of batch schedulers
+            # (notably Slurm on Cray EX) which depend on a system Lua.
+            # LLVM includes lua as a dependency, but a barebones lua
+            # install lacks many packages provided by a system Lua,
+            # which are often required by system services like Slurm.
+            # Disable the incomplete Spack lua package directory to
+            # allow the system one to function.
+            env.unset("LUA_PATH")
+            env.unset("LUA_CPATH")
+
         if self.spec.variants["gmp"].value == "spack":
             # TODO: why must we add to CPATH to find gmp.h
             # TODO: why must we add to LIBRARY_PATH to find lgmp
             self.prepend_cpath_include(env, self.spec["gmp"].prefix)
-            env.prepend_path("LIBRARY_PATH", self.spec["gmp"].prefix.lib)
-            # Need this for the test env, where it does not appear automatic:
-            env.prepend_path("PKG_CONFIG_PATH", self.spec["gmp"].prefix.lib.pkgconfig)
+            self.set_lib_path(env, self.spec["gmp"].prefix)
 
         if self.spec.variants["hwloc"].value == "spack":
-            env.prepend_path("LD_LIBRARY_PATH", self.spec["hwloc"].prefix.lib)
+            self.set_lib_path(env, self.spec["hwloc"].prefix)
             # Need this for the test env, where it does not appear automatic:
-            env.prepend_path("PKG_CONFIG_PATH", self.spec["hwloc"].prefix.lib.pkgconfig)
             env.prepend_path("PKG_CONFIG_PATH", self.spec["libpciaccess"].prefix.lib.pkgconfig)
 
+        # TODO: unwind builds but resulting binaries fail to run, producing linker errors
         if self.spec.variants["unwind"].value == "spack":
             # chapel package would not build without cpath, missing libunwind.h
             self.prepend_cpath_include(env, self.spec["libunwind"].prefix)
             env.prepend_path("LD_LIBRARY_PATH", self.spec["libunwind"].prefix.lib)
 
         if self.spec.satisfies("+yaml"):
-            env.prepend_path("PKG_CONFIG_PATH", self.spec["libyaml"].prefix.lib.pkgconfig)
             self.prepend_cpath_include(env, self.spec["libyaml"].prefix)
             # could not compile test/library/packages/Yaml/writeAndParse.chpl without this
-            env.prepend_path("LIBRARY_PATH", self.spec["libyaml"].prefix.lib)
+            self.set_lib_path(env, self.spec["libyaml"].prefix)
 
         if self.spec.satisfies("+zmq"):
             self.prepend_cpath_include(env, self.spec["libzmq"].prefix)
             # could not compile test/library/packages/ZMQ/hello.chpl without this
-            env.prepend_path("LIBRARY_PATH", self.spec["libzmq"].prefix.lib)
-            env.prepend_path("LD_LIBRARY_PATH", self.spec["libzmq"].prefix.lib)
-            # could not compile test/library/packages/ZMQ/hello.chpl without this
-            env.prepend_path("LIBRARY_PATH", self.spec["libzmq"].prefix.lib)
-            env.prepend_path("PKG_CONFIG_PATH", self.spec["libzmq"].prefix.lib.pkgconfig)
+            self.set_lib_path(env, self.spec["libzmq"].prefix)
             env.prepend_path("PKG_CONFIG_PATH", self.spec["libsodium"].prefix.lib.pkgconfig)
 
         if self.spec.satisfies("+curl"):
             self.prepend_cpath_include(env, self.spec["curl"].prefix)
             # could not compile test/library/packages/Curl/check-http.chpl without this
-            env.prepend_path("LIBRARY_PATH", self.spec["curl"].prefix.lib)
-            env.prepend_path("LD_LIBRARY_PATH", self.spec["curl"].prefix.lib)
-            env.prepend_path("PKG_CONFIG_PATH", self.spec["curl"].prefix.lib.pkgconfig)
+            self.set_lib_path(env, self.spec["curl"].prefix)
 
         if self.spec.satisfies("+cuda"):
             # TODO: why must we add to LD_LIBRARY_PATH to find libcudart?
@@ -629,18 +695,11 @@ def setup_env_vars(self, env):
         if self.spec.satisfies("+rocm"):
             env.set("CHPL_LOCALE_MODEL", "gpu")
             env.set("CHPL_GPU", "amd")
-            env.set("CHPL_HOST_COMPILER", "llvm")
             env.set("CHPL_GPU_ARCH", self.spec.variants["amdgpu_target"].value[0])
-            env.set(
-                "CHPL_LLVM_CONFIG",
-                "{0}/{1}".format(self.spec["llvm-amdgpu"].prefix, "bin/llvm-config"),
-            )
             self.prepend_cpath_include(env, self.spec["hip"].prefix)
             env.set("CHPL_ROCM_PATH", self.spec["llvm-amdgpu"].prefix)
-            env.prepend_path("LIBRARY_PATH", self.spec["hip"].prefix.lib)
-            env.prepend_path("LIBRARY_PATH", self.spec["hsa-rocr-dev"].prefix.lib)
-            env.prepend_path("LD_LIBRARY_PATH", self.spec["hip"].prefix.lib)
-            env.prepend_path("LD_LIBRARY_PATH", self.spec["hsa-rocr-dev"].prefix.lib)
+            self.set_lib_path(env, self.spec["hip"].prefix)
+            self.set_lib_path(env, self.spec["hsa-rocr-dev"].prefix)
         self.setup_chpl_comm(env, self.spec)
 
     def setup_build_environment(self, env):
@@ -735,11 +794,9 @@ def test_chpldoc(self):
         if not self.spec.satisfies("+chpldoc"):
             print("Skipping chpldoc test as chpldoc variant is not set")
             return
-        with working_dir(self.test_suite.current_test_cache_dir):
-            with set_env(CHPL_HOME=self.test_suite.current_test_cache_dir):
-                with test_part(self, "test_chpldoc", purpose="test chpldoc"):
-                    res = subprocess.run(["util/test/checkChplDoc"])
-                    assert res.returncode == 0
+        else:
+            # TODO: Need to update checkChplDoc to work in the spack testing environment
+            pass
 
     # TODO: In order to run these tests, there's a lot of infrastructure to copy
     # from the Chapel test suite and there are conflicts with CHPL_HOME needing
@@ -799,6 +856,7 @@ def copy_test_files(self):
             "util/test",
             "util/chplenv",
             "util/config",
+            "util/printchplenv",
             #   "test/library/packages/Curl",
             #   "test/library/packages/URL/",
             #   "test/library/packages/ProtobufProtocolSupport/",

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

@@ -29,6 +29,8 @@ class Cmake(Package):
     license("BSD-3-Clause")
 
     version("master", branch="master")
+    version("3.30.1", sha256="df9b3c53e3ce84c3c1b7c253e5ceff7d8d1f084ff0673d048f260e04ccb346e1")
+    version("3.30.0", sha256="157e5be6055c154c34f580795fe5832f260246506d32954a971300ed7899f579")
     version("3.29.6", sha256="1391313003b83d48e2ab115a8b525a557f78d8c1544618b48d1d90184a10f0af")
     version("3.29.5", sha256="dd63da7d763c0db455ca232f2c443f5234fe0b11f8bd6958a81d29cc987dfd6e")
     version("3.29.4", sha256="b1b48d7100bdff0b46e8c8f6a3c86476dbe872c8df39c42b8d104298b3d56a2c")

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

@@ -12,14 +12,12 @@ class Cpr(CMakePackage):
     homepage = "https://docs.libcpr.org/"
     url = "https://github.com/libcpr/cpr/archive/refs/tags/1.10.4.tar.gz"
 
-    maintainers("sethrj")
-
     license("MIT")
 
     version("1.10.4", sha256="88462d059cd3df22c4d39ae04483ed50dfd2c808b3effddb65ac3b9aa60b542d")
     version("1.9.2", sha256="3bfbffb22c51f322780d10d3ca8f79424190d7ac4b5ad6ad896de08dbd06bf31")
 
-    depends_on("cxx", type="build")  # generated
+    depends_on("cxx", type="build")
 
     depends_on("curl")
     depends_on("git", type="build")

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

@@ -17,6 +17,10 @@ class DamaskGrid(CMakePackage):
 
     license("AGPL-3.0-or-later")
 
+    version("3.0.0", sha256="aaebc65b3b10e6c313132ee97cfed427c115079b7e438cc0727c5207e159019f")
+    version(
+        "3.0.0-beta2", sha256="513567b4643f39e27ae32b9f75463fc6f388c1548d42f0393cc87ba02d075f6a"
+    )
     version(
         "3.0.0-beta", sha256="1e25e409ac559fc437d1887c6ca930677a732db89a3a32499d545dd75e93925c"
     )
@@ -39,8 +43,9 @@ class DamaskGrid(CMakePackage):
     depends_on("c", type="build")  # generated
     depends_on("fortran", type="build")  # generated
 
-    depends_on("petsc@3.20.3:3.21", when="@3.0.0-beta")
-    depends_on("petsc@3.20.2:3.21", when="@3.0.0-alpha8")
+    depends_on("petsc@3.21", when="@3.0.0-beta2:")
+    depends_on("petsc@3.20.3:3.20", when="@3.0.0-beta")
+    depends_on("petsc@3.20.2:3.20", when="@3.0.0-alpha8")
     depends_on("petsc@3.17.1:3.18", when="@3.0.0-alpha7")
     depends_on("petsc@3.16.5:3.16", when="@3.0.0-alpha6")
     depends_on("petsc@3.14.0:3.14,3.15.1:3.16", when="@3.0.0-alpha5")

var/spack/repos/builtin/packages/damask-mesh/package.py

@@ -17,6 +17,10 @@ class DamaskMesh(CMakePackage):
 
     license("AGPL-3.0-or-later")
 
+    version("3.0.0", sha256="aaebc65b3b10e6c313132ee97cfed427c115079b7e438cc0727c5207e159019f")
+    version(
+        "3.0.0-beta2", sha256="513567b4643f39e27ae32b9f75463fc6f388c1548d42f0393cc87ba02d075f6a"
+    )
     version(
         "3.0.0-beta", sha256="1e25e409ac559fc437d1887c6ca930677a732db89a3a32499d545dd75e93925c"
     )
@@ -39,8 +43,9 @@ class DamaskMesh(CMakePackage):
     depends_on("c", type="build")  # generated
     depends_on("fortran", type="build")  # generated
 
-    depends_on("petsc@3.20.3:3.21", when="@3.0.0-beta")
-    depends_on("petsc@3.20.2:3.21", when="@3.0.0-alpha8")
+    depends_on("petsc@3.21", when="@3.0.0-beta2:")
+    depends_on("petsc@3.20.3:3.20", when="@3.0.0-beta")
+    depends_on("petsc@3.20.2:3.20", when="@3.0.0-alpha8")
     depends_on("petsc@3.17.1:3.18", when="@3.0.0-alpha7")
     depends_on("petsc@3.16.5:3.16", when="@3.0.0-alpha6")
     depends_on("petsc@3.14.0:3.14,3.15.1:3.16", when="@3.0.0-alpha5")

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

@@ -28,6 +28,8 @@ class Damask(BundlePackage):
 
     maintainers("MarDiehl")
 
+    version("3.0.0")
+    version("3.0.0-beta2")
     version("3.0.0-beta")
     version("3.0.0-alpha8")
     version("3.0.0-alpha7")
@@ -35,6 +37,14 @@ class Damask(BundlePackage):
     version("3.0.0-alpha5")
     version("3.0.0-alpha4")
 
+    depends_on("damask-grid@3.0.0", when="@3.0.0", type="run")
+    depends_on("damask-mesh@3.0.0", when="@3.0.0", type="run")
+    depends_on("py-damask@3.0.0", when="@3.0.0", type="run")
+
+    depends_on("damask-grid@3.0.0-beta2", when="@3.0.0-beta2", type="run")
+    depends_on("damask-mesh@3.0.0-beta2", when="@3.0.0-beta2", type="run")
+    depends_on("py-damask@3.0.0-beta2", when="@3.0.0-beta2", type="run")
+
     depends_on("damask-grid@3.0.0-beta", when="@3.0.0-beta", type="run")
     depends_on("damask-mesh@3.0.0-beta", when="@3.0.0-beta", type="run")
     depends_on("py-damask@3.0.0-beta", when="@3.0.0-beta", type="run")

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

@@ -123,6 +123,7 @@ class Dd4hep(CMakePackage):
     depends_on("podio@:0.16.03", when="@:1.23 +edm4hep")
     depends_on("podio@0.16:", when="@1.24: +edm4hep")
     depends_on("podio@0.16.3:", when="@1.26: +edm4hep")
+    depends_on("podio@:0", when="@:1.29 +edm4hep")
     depends_on("py-pytest", type=("build", "test"))
 
     # See https://github.com/AIDASoft/DD4hep/pull/771 and https://github.com/AIDASoft/DD4hep/pull/876

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

@@ -36,10 +36,10 @@ def edit(self, spec, prefix):
         makefile.filter(r"^\s*INSTALL_DIR\s*\?=.*", "INSTALL_DIR ?= " + prefix)
 
     @run_before("install")
-    def preinstall(self, spec, prefix):
+    def preinstall(self):
         # The $PREFIX/dedisp/include and $PREFIX/dedisp/lib directories don't seem
         # to be created automatically by the software's Makefile so manually create them
-        libdir = join_path(prefix, "lib")
-        incdir = join_path(prefix, "include")
+        libdir = join_path(self.prefix, "lib")
+        incdir = join_path(self.prefix, "include")
         mkdirp(libdir)
         mkdirp(incdir)

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

@@ -20,6 +20,9 @@ class Detray(CMakePackage):
 
     license("MPL-2.0", checked_by="stephenswat")
 
+    version("0.72.1", sha256="6cc8d34bc0d801338e9ab142c4a9884d19d9c02555dbb56972fab86b98d0f75b")
+    version("0.71.0", sha256="2be2b3dac6f77aa8cea033eba841378dc3703ff93c99e4d05ea03df685e6d508")
+    version("0.70.0", sha256="14fa1d478d44d5d987caea6f4b365bce870aa8e140c21b802c527afa3a5db869")
     version("0.69.1", sha256="7100ec86a47458a35f5943cd6c7da07c68b8c1c2f62d36d13b8bb50568d0abe5")
     version("0.68.0", sha256="6d57835f22ced9243fbcc29b84ea4c01878a46bfa5910e320c933e9bf8e96612")
     version("0.67.0", sha256="87b1b29f333c955ea6160f9dda89628490d85a9e5186c2f35f57b322bbe27e18")

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

@@ -27,8 +27,8 @@ class DlaFuture(CMakePackage, CudaPackage, ROCmPackage):
     version("0.1.0", sha256="f7ffcde22edabb3dc24a624e2888f98829ee526da384cd752b2b271c731ca9b1")
     version("master", branch="master")
 
-    depends_on("c", type="build")  # generated
-    depends_on("cxx", type="build")  # generated
+    depends_on("c", type="build")
+    depends_on("cxx", type="build")
 
     variant("shared", default=True, description="Build shared libraries.")
 

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

@@ -21,16 +21,33 @@ class Edm4hep(CMakePackage):
     license("Apache-2.0")
 
     version("main", branch="main")
+    version("0.99", sha256="3636e8c14474237029bf1a8be11c53b57ad3ed438fd70a7e9b87c5d08f1f2ea6")
     version("0.10.5", sha256="003c8e0c8e1d1844592d43d41384f4320586fbfa51d4d728ae0870b9c4f78d81")
     version(
         "0.10.4",
         sha256="76d51947525bc8a27b62f567033255da2e632d42d07a32ff578887948d56bd6f",
         deprecated=True,
     )
-    version("0.10.3", sha256="0ba5e4e90376f750f9531831909160e3d7b9c2d1f020d7556f0d3977b7eaafcc")
-    version("0.10.2", sha256="c22c5c2f0fd1d09da9b734c1fa7ee546675fd2b047406db6ab8266e7657486d2")
-    version("0.10.1", sha256="28a3bd4df899309b14ec0d441f8b6ed0065206a08a0018113bb490e9d008caed")
-    version("0.10", sha256="a95c917c19793cfad6b0959854a653c5ce698c965598cabd649d544da07712c0")
+    version(
+        "0.10.3",
+        sha256="0ba5e4e90376f750f9531831909160e3d7b9c2d1f020d7556f0d3977b7eaafcc",
+        deprecated=True,
+    )
+    version(
+        "0.10.2",
+        sha256="c22c5c2f0fd1d09da9b734c1fa7ee546675fd2b047406db6ab8266e7657486d2",
+        deprecated=True,
+    )
+    version(
+        "0.10.1",
+        sha256="28a3bd4df899309b14ec0d441f8b6ed0065206a08a0018113bb490e9d008caed",
+        deprecated=True,
+    )
+    version(
+        "0.10",
+        sha256="a95c917c19793cfad6b0959854a653c5ce698c965598cabd649d544da07712c0",
+        deprecated=True,
+    )
 
     depends_on("cxx", type="build")  # generated
 
@@ -48,8 +65,9 @@ class Edm4hep(CMakePackage):
     depends_on("python", type="build")
 
     depends_on("root@6.08:")
-    depends_on("nlohmann-json@3.10:")
-    depends_on("podio@0.15:")
+    depends_on("nlohmann-json@3.10.5:")
+    depends_on("podio@1:", when="@0.99:")
+    depends_on("podio@0.15:", when="@:0.10.5")
     for _std in _cxxstd_values:
         depends_on("podio cxxstd=" + _std, when="cxxstd=" + _std)
 

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

@@ -24,6 +24,7 @@ class Enzyme(CMakePackage):
     root_cmakelists_dir = "enzyme"
 
     version("main", branch="main")
+    version("0.0.135", sha256="49c798534faec7ba524a3ed053dd4352d690a44d3cad5a14915c9398dc9b175b")
     version("0.0.100", sha256="fbc53ec02adc0303ff200d7699afface2d9fbc7350664e6c6d4c527ef11c2e82")
     version("0.0.81", sha256="4c17d0c28f0572a3ab97a60f1e56bbc045ed5dd64c2daac53ae34371ca5e8b34")
     version("0.0.69", sha256="144d964187551700fdf0a4807961ceab1480d4e4cd0bb0fc7bbfab48fe053aa2")

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

@@ -0,0 +1,54 @@
+# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+# Spack Project Developers. See the top-level COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+
+from spack.package import *
+
+
+class Exo(AutotoolsPackage):
+    """Helper applications for XFCE4"""
+
+    homepage = "https://docs.xfce.org/xfce/exo/start"
+    url = "https://archive.xfce.org/xfce/4.16/src/exo-4.16.0.tar.bz2"
+    list_url = "https://archive.xfce.org/xfce/"
+    list_depth = 2
+
+    maintainers("teaguesterling")
+
+    license("GPLv2", checked_by="teaguesterling")  # https://wiki.xfce.org/licenses/audit
+
+    version("4.18.0", sha256="4f2c61d045a888cdb64297fd0ae20cc23da9b97ffb82562ed12806ed21da7d55")
+    version("4.16.0", sha256="1975b00eed9a8aa1f899eab2efaea593731c19138b83fdff2f13bdca5275bacc")
+
+    variant("introspection", default=True, description="Build with gobject-introspection support")
+
+    # Base requirements
+    with default_args(type=("build", "run")):
+        depends_on("libxfce4util")
+        depends_on("libxfce4ui")
+        depends_on("glib@2:")
+        depends_on("gtkplus@3:")
+        depends_on("perl-uri")
+
+    with when("+introspection"):
+        depends_on("libxfce4util+introspection")
+        depends_on("libxfce4ui+introspection")
+        depends_on("gobject-introspection")
+
+    depends_on("intltool@0.51.0:", type="build")
+    with default_args(type=("build", "link", "run")):
+        with when("@4.18.0:"):
+            depends_on("glib@2.66:")
+            depends_on("gtkplus@3.24:")
+            depends_on("gobject-introspection@1.66:", when="+introspection")
+        with when("@4.16.0:"):
+            depends_on("glib@2.50:")
+            depends_on("gtkplus@3.22:")
+            depends_on("gobject-introspection@1.60:", when="+introspection")
+
+    def configure_args(self):
+        args = []
+        args += self.enable_or_disable("introspection")
+        return args

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

@@ -135,7 +135,7 @@ class Ffmpeg(AutotoolsPackage):
     # Solve build failure against vulkan headers 1.3.279
     patch(
         "https://git.ffmpeg.org/gitweb/ffmpeg.git/commitdiff_plain/fef22c87ada4",
-        sha256="856bdc2b6e2a7066cf683a235193b9025d4d73dd7686eda2fbcf83e7e65f8bf9",
+        sha256="5726e8e999e3fc7a5ae4c4c846c9151246e5846c54dc3b8ff8326ee31c59631a",
         when="@6.1.1",
     )
 
@@ -162,12 +162,12 @@ class Ffmpeg(AutotoolsPackage):
     # fix incompatibility with texinfo@7, especially @7.1:
     patch(
         "https://git.ffmpeg.org/gitweb/ffmpeg.git/commitdiff_plain/f01fdedb69e4accb1d1555106d8f682ff1f1ddc7",
-        sha256="416751f41cfbf086c28b4bbf01ace4c08e5651e59911dca6240292bb1b5c6b53",
+        sha256="673813d13f5c37b75ff5bcb56790ccd6b16962fdb9bddcbbeeead979d47d31b3",
         when="@6.0",
     )
     patch(
         "https://git.ffmpeg.org/gitweb/ffmpeg.git/commitdiff_plain/f01fdedb69e4accb1d1555106d8f682ff1f1ddc7",
-        sha256="416751f41cfbf086c28b4bbf01ace4c08e5651e59911dca6240292bb1b5c6b53",
+        sha256="673813d13f5c37b75ff5bcb56790ccd6b16962fdb9bddcbbeeead979d47d31b3",
         when="@5:5.1.3",
     )
 

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

@@ -181,6 +181,12 @@ def setup_build_environment(self, env):
         env.append_path("LUA_PATH", "./?.lua", separator=";")
 
     def setup_run_environment(self, env):
+        # If this package is external, we expect the external provider to set things
+        # like LUA paths. So, we early return. If the package is not external,
+        # properly set these environment variables to make sure the user environment
+        # is configured correctly
+        if self.spec.external:
+            return
         env.prepend_path(
             "LUA_PATH", os.path.join(self.spec.prefix, self.lua_share_dir, "?.lua"), separator=";"
         )

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

@@ -166,6 +166,12 @@ def lua_lib_dir(self):
         return os.path.join("lib", "lua", str(self.lua_version))
 
     def setup_run_environment(self, env):
+        # If this package is external, we expect the external provider to set
+        # things like LUA paths. So, we early return. If the package is not
+        # external, properly set these environment variables to make sure the
+        # user environment is configured correctly
+        if self.spec.external:
+            return
         env.prepend_path(
             "LUA_PATH", os.path.join(self.spec.prefix, self.lua_share_dir, "?.lua"), separator=";"
         )

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

@@ -18,6 +18,7 @@ class Fmt(CMakePackage):
 
     license("MIT")
 
+    version("11.0.2", sha256="40fc58bebcf38c759e11a7bd8fdc163507d2423ef5058bba7f26280c5b9c5465")
     version("11.0.1", sha256="62ca45531814109b5d6cef0cf2fd17db92c32a30dd23012976e768c685534814")
     version("11.0.0", sha256="583ce480ef07fad76ef86e1e2a639fc231c3daa86c4aa6bcba524ce908f30699")
     version("10.2.1", sha256="312151a2d13c8327f5c9c586ac6cf7cddc1658e8f53edae0ec56509c8fa516c9")
@@ -46,6 +47,8 @@ class Fmt(CMakePackage):
     version("3.0.0", sha256="1b050b66fa31b74f1d75a14f15e99e728ab79572f176a53b2f8ad7c201c30ceb")
     version("master", branch="master")
 
+    depends_on("cxx", type="build")
+
     variant(
         "cxxstd",
         default="11",

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

@@ -27,8 +27,8 @@ class G2(CMakePackage):
     version("3.4.5", sha256="c18e991c56964953d778632e2d74da13c4e78da35e8d04cb742a2ca4f52737b6")
     version("3.4.3", sha256="679ea99b225f08b168cbf10f4b29f529b5b011232f298a5442ce037ea84de17c")
 
-    depends_on("c", type="build")  # generated
-    depends_on("fortran", type="build")  # generated
+    depends_on("c", type="build")
+    depends_on("fortran", type="build")
 
     variant("pic", default=True, description="Build with position-independent-code")
     variant(
@@ -40,22 +40,43 @@ class G2(CMakePackage):
         when="@3.4.6:",
     )
     variant("w3emc", default=True, description="Enable GRIB1 through w3emc", when="@3.4.6:")
+    variant("shared", default="False", description="Build shared library", when="@3.4.7:")
+    variant("openmp", default=False, description="Use OpenMP multithreading", when="@develop")
+    variant("utils", default=False, description="Build grib utilities", when="@develop")
+    variant(
+        "g2c_compare",
+        default=False,
+        description="Enable copygb2 tests using g2c_compare",
+        when="@develop",
+    )
 
     depends_on("jasper@:2.0.32", when="@:3.4.7")
     depends_on("jasper")
     depends_on("libpng")
+    depends_on("zlib-api", when="@develop")
     depends_on("bacio", when="@3.4.6:")
+    depends_on("ip", when="@develop")
+    requires("^ip precision=d", when="^ip@4.1:")
+    depends_on("sp", when="^ip@:4")
+    requires("^sp precision=d", when="^ip@:4 ^sp@2.4:")
+    depends_on("g2c@1.8: +utils", when="+g2c_compare")
     with when("+w3emc"):
         depends_on("w3emc")
         depends_on("w3emc precision=4", when="precision=4")
         depends_on("w3emc precision=d", when="precision=d")
+        depends_on("w3emc +extradeps", when="+utils")
+        depends_on("w3emc precision=4,d", when="+utils")
 
     def cmake_args(self):
         args = [
+            self.define_from_variant("OPENMP", "openmp"),
             self.define_from_variant("CMAKE_POSITION_INDEPENDENT_CODE", "pic"),
             self.define_from_variant("BUILD_WITH_W3EMC", "w3emc"),
+            self.define_from_variant("BUILD_SHARED_LIBS", "shared"),
             self.define("BUILD_4", self.spec.satisfies("precision=4")),
             self.define("BUILD_D", self.spec.satisfies("precision=d")),
+            self.define_from_variant("G2C_COMPARE", "g2c_compare"),
+            self.define_from_variant("BUILD_UTILS", "utils"),
         ]
 
         return args
@@ -65,7 +86,12 @@ def setup_run_environment(self, env):
             self.spec.variants["precision"].value if self.spec.satisfies("@3.4.6:") else ("4", "d")
         )
         for suffix in precisions:
-            lib = find_libraries("libg2_" + suffix, root=self.prefix, shared=False, recursive=True)
+            lib = find_libraries(
+                "libg2_" + suffix,
+                root=self.prefix,
+                shared=self.spec.satisfies("+shared"),
+                recursive=True,
+            )
             env.set("G2_LIB" + suffix, lib[0])
             env.set("G2_INC" + suffix, join_path(self.prefix, "include_" + suffix))
 

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

@@ -24,7 +24,7 @@ class G2c(CMakePackage):
     version("1.6.4", sha256="5129a772572a358296b05fbe846bd390c6a501254588c6a223623649aefacb9d")
     version("1.6.2", sha256="b5384b48e108293d7f764cdad458ac8ce436f26be330b02c69c2a75bb7eb9a2c")
 
-    depends_on("c", type="build")  # generated
+    depends_on("c", type="build")
 
     variant("aec", default=True, description="Use AEC library")
     variant("png", default=True, description="Use PNG library")

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

@@ -24,8 +24,8 @@ class G2tmpl(CMakePackage):
     version("1.10.1", sha256="0be425e5128fabb89915a92261aa75c27a46a3e115e00c686fc311321e5d1e2a")
     version("1.10.0", sha256="dcc0e40b8952f91d518c59df7af64e099131c17d85d910075bfa474c8822649d")
 
-    depends_on("c", type="build")  # generated
-    depends_on("fortran", type="build")  # generated
+    depends_on("c", type="build")
+    depends_on("fortran", type="build")
 
     variant("shared", default=False, description="Build shared library")
 

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

@@ -0,0 +1,51 @@
+# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+# Spack Project Developers. See the top-level COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+
+from spack.package import *
+
+
+class Garcon(AutotoolsPackage):
+    """Menu library for XFCE4"""
+
+    homepage = "https://docs.xfce.org/xfce/garcon/start"
+    url = "https://archive.xfce.org/xfce/4.16/src/garcon-0.8.0.tar.bz2"
+    list_url = "https://archive.xfce.org/xfce/"
+    list_depth = 2
+
+    maintainers("teaguesterling")
+
+    license("LGPLv2", checked_by="teaguesterling")  # https://wiki.xfce.org/licenses/audit
+
+    version("4.18.0", sha256="54633487566a8b8502b71c11a7f719efe27c069bd5773cc95f11ff4ea8f11a14")
+    version("0.8.0", sha256="4811d89ee5bc48dbdeffd69fc3eec6c112bbf01fde98a9e848335b374a4aa1bb")
+
+    variant("introspection", default=True, description="Build with gobject-introspection support")
+
+    # Base requirements
+    depends_on("intltool@0.51.0:", type="build")
+    with default_args(type=("build", "link", "run")):
+        depends_on("libxfce4util")
+        depends_on("xfconf")
+        depends_on("libxfce4ui")
+        depends_on("glib@2:")
+        depends_on("gtkplus@3:")
+        with when("@4.18.0:"):
+            depends_on("glib@2.66:")
+            depends_on("gtkplus@3.24:")
+            depends_on("gobject-introspection@1.66:", when="+introspection")
+        with when("@4.16.0:"):
+            depends_on("glib@2.50:")
+            depends_on("gtkplus@3.22:")
+            depends_on("gobject-introspection@1.60:", when="+introspection")
+
+    def configure_args(self):
+        args = []
+        args += self.enable_or_disable("introspection")
+        return args
+
+    def setup_dependent_build_environment(self, env, dep_spec):
+        if self.spec.satisfies("+introspection") and dep_spec.satisfies("+introspection"):
+            env.append_path("XDG_DATA_DIRS", self.prefix.share)

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

@@ -17,6 +17,8 @@ class Gaudi(CMakePackage):
     tags = ["hep"]
 
     version("master", branch="master")
+    version("38.3", sha256="47e8c65ea446656d2dae54a32205525e08257778cf80f9f029cd244d6650486e")
+    version("38.2", sha256="08759b1398336987ad991602e37079f0744e8d8e4e3d5df2d253b8dedf925068")
     version("38.1", sha256="79d42833edcebc2099f91badb6f72708640c05f678cc4521a86e857f112486dc")
     version("38.0", sha256="52f2733fa0af760c079b3438bb9c7e36b28ea704f78b0085458e1918c11e1653")
     version("37.2", sha256="9b866caab46e182de98b59eddbde80d6fa0e670fe4a35906f1518b04bd99b2d2")
@@ -87,6 +89,7 @@ class Gaudi(CMakePackage):
     depends_on("cppgsl")
     depends_on("fmt")
     depends_on("fmt@:8", when="@:36.9")
+    depends_on("fmt@:10", when="@:39.0")
     depends_on("intel-tbb@:2020.3", when="@:37.0")
     depends_on("tbb", when="@37.1:")
     depends_on("uuid")

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

@@ -166,8 +166,13 @@ def std_when(values):
     depends_on("libxmu", when="+x11")
     depends_on("motif", when="+motif")
     with when("+qt"):
-        depends_on("qt@5: +opengl")
-        depends_on("qt@5.9:", when="@11.2:")
+        depends_on("qmake")
+        with when("^[virtuals=qmake] qt-base"):
+            depends_on("qt-base +accessibility +gui +opengl")
+        with when("^[virtuals=qmake] qt"):
+            depends_on("qt@5: +opengl")
+            depends_on("qt@5.9:", when="@11.2:")
+    conflicts("@:11.1 ^[virtuals=qmake] qt-base", msg="Qt6 not supported before 11.2")
 
     # As released, 10.0.4 has inconsistently capitalised filenames
     # in the cmake files; this patch also enables cxxstd 14
@@ -307,7 +312,9 @@ def cmake_args(self):
 
         if "+qt" in spec:
             options.append(self.define("GEANT4_USE_QT", True))
-            options.append(self.define("QT_QMAKE_EXECUTABLE", spec["qt"].prefix.bin.qmake))
+            if "^[virtuals=qmake] qt-base" in spec:
+                options.append(self.define("GEANT4_USE_QT_QT6", True))
+            options.append(self.define("QT_QMAKE_EXECUTABLE", spec["qmake"].prefix.bin.qmake))
 
         options.append(self.define_from_variant("GEANT4_USE_VTK", "vtk"))
 

var/spack/repos/builtin/packages/generate-ninja/package.py

@@ -0,0 +1,50 @@
+# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other
+# Spack Project Developers. See the top-level COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+from spack.package import *
+
+
+class GenerateNinja(Package):
+    """
+    A meta-build system that generates build files for Ninja.
+    This is a fork of the Google GN package with some minor features and bug fixes
+    """
+
+    homepage = "https://github.com/o-lim/generate-ninja"
+    url = "https://github.com/o-lim/generate-ninja/archive/refs/tags/v0.4.1.tar.gz"
+
+    license("BSD", checked_by="teaguesterling")
+
+    version("0.4.1", sha256="1b2bec9dd18602a4af9dc8782ca809e44305f1435d43c55f35ec9eec50ca7e9a")
+    version("0.4.0", sha256="3575ed41eec49fe756dbd2c402f70cd80ba2952cc59ce2091d0a82b7bd3ce8a0")
+    version("0.3.2", sha256="82e949c3970d77b28c9df7cf3f3df409798b65848e05ff415009e7e2118460a8")
+    version("0.3.1", sha256="ed0112b434b80c322fcc9203646eaef17c306a804bf2ff5e5df91677c4e58678")
+    version("0.3.0", sha256="e6091d34cfc6bc625bfad4bbdc001e10ed951651d0ae98785b509bdfadad6822")
+    version("0.2.2", sha256="3146bdef1db9dfdc2d48bb5ee5e8e4ef9642ebea7cf39c432681685db8a11c86")
+    version("0.2.1", sha256="bf27ddde69bd0791ce86bd3ab9ead51dcfb00d3f202168057b721fdc39d417c5")
+    version("0.2.0", sha256="6cfd6f4a2f6d656e8d5f64d7f03a575a569b2c0f662d1d828ee790c9d9c2be25")
+    version("0.1.0", sha256="eb94e0bb170416010d3efa296fce63e7fec19f1e3e9b5988b2418166ec068896")
+
+    depends_on("ninja")
+    depends_on("python", type="build")
+    depends_on("llvm+clang", type="build")
+
+    def setup_build_environment(self, env):
+        env.set("DEPLOY", "1")
+        env.set("CC", self.spec["llvm"].home.bin.clang)
+        env.set("CXX", self.spec["llvm"].home.bin.join("clang++"))
+
+    phases = ["configure", "build", "install"]
+    #    build_targets = ["bootstrap", "gn"]
+    out_dir = "out"
+
+    def configure(self, spec, prefix):
+        python("build/gen.py")
+
+    def build(self, spec, prefix):
+        ninja("-C", self.out_dir)
+
+    def install(self, spec, prefix):
+        mkdir(prefix.bin)
+        install(join_path(self.out_dir, "gn"), prefix.bin.gn)

var/spack/repos/builtin/packages/geopm-runtime/package.py

@@ -15,13 +15,14 @@ class GeopmRuntime(AutotoolsPackage):
 
     homepage = "https://geopm.github.io"
     git = "https://github.com/geopm/geopm.git"
-    url = "https://github.com/geopm/geopm/tarball/v3.0.1"
+    url = "https://github.com/geopm/geopm/tarball/v3.1.0"
 
     maintainers("bgeltz", "cmcantalupo")
     license("BSD-3-Clause")
     tags = ["e4s"]
 
     version("develop", branch="dev", get_full_repo=True)
+    version("3.1.0", sha256="2d890cad906fd2008dc57f4e06537695d4a027e1dc1ed92feed4d81bb1a1449e")
     version("3.0.1", sha256="32ba1948de58815ee055470dcdea64593d1113a6cad70ce00ab0286c127f8234")
 
     depends_on("c", type="build")  # generated
@@ -29,7 +30,7 @@ class GeopmRuntime(AutotoolsPackage):
     depends_on("fortran", type="build")  # generated
 
     variant("debug", default=False, description="Enable debug")
-    variant("docs", default=False, description="Create man pages with Sphinx")
+    variant("docs", default=False, when="@3.0.1", description="Create man pages with Sphinx")
     variant("overhead", default=False, description="Track time spent in GEOPM API calls")
     variant("beta", default=False, description="Enable beta features")
     variant("mpi", default=True, description="Enable MPI dependent components")
@@ -60,30 +61,36 @@ class GeopmRuntime(AutotoolsPackage):
     depends_on("libtool", type="build")
     depends_on("file")
 
-    # Docs dependencies
-    depends_on("doxygen", type="build", when="+docs")
-    depends_on("py-sphinx", type="build", when="+docs")
-    depends_on("py-sphinx-rtd-theme@1:", type="build", when="+docs")
-    depends_on("py-sphinxemoji@0.2.0:", type="build", when="+docs")
-    depends_on("py-sphinx-tabs@3.3.1:", type="build", when="+docs")
-    depends_on("py-pygments@2.13.0:", type="build", when="+docs")
+    with when("@3.0.1"):
+        # Docs dependencies
+        #   Moved to python3-geopm-doc as of v3.1
+        depends_on("doxygen", type="build", when="+docs")
+        depends_on("py-sphinx", type="build", when="+docs")
+        depends_on("py-sphinx-rtd-theme@1:", type="build", when="+docs")
+        depends_on("py-sphinxemoji@0.2.0:", type="build", when="+docs")
+        depends_on("py-sphinx-tabs@3.3.1:", type="build", when="+docs")
+        depends_on("py-pygments@2.13.0:", type="build", when="+docs")
 
-    # Other Python dependencies - from scripts/setup.py
-    depends_on("python@3.6:3", type=("build", "run"))
-    depends_on("py-setuptools@53.0.0:", type="build")
-    depends_on("py-cffi@1.14.5:", type="run")
-    depends_on("py-natsort@8.2.0:", type="run")
-    depends_on("py-numpy@1.19.5:", type="run")
-    depends_on("py-pandas@1.1.5:", type="run")
-    depends_on("py-tables@3.7.0:", type="run")
-    depends_on("py-psutil@5.8.0:", type="run")
-    depends_on("py-pyyaml@6.0:", type="run")
-    depends_on("py-docutils@0.18:", type="run", when="+checkprogs")
+        # Other Python dependencies - from scripts/setup.py
+        #   Moved to python3-geopmdpy as of v3.1
+        depends_on("python@3.6:3", type=("build", "run"))
+        depends_on("py-setuptools@53.0.0:", type="build")
+        depends_on("py-cffi@1.14.5:", type="run")
+        depends_on("py-natsort@8.2.0:", type="run")
+        depends_on("py-numpy@1.19.5:", type="run")
+        depends_on("py-pandas@1.1.5:", type="run")
+        depends_on("py-tables@3.7.0:", type="run")
+        depends_on("py-psutil@5.8.0:", type="run")
+        depends_on("py-pyyaml@6.0:", type="run")
+        depends_on("py-docutils@0.18:", type="run", when="+checkprogs")
 
     # Other dependencies
-    for ver in ["3.0.1", "develop"]:
-        depends_on(f"geopm-service@{ver}", type="build", when=f"@{ver}")
+    for ver in ["3.0.1", "3.1.0", "develop"]:
+        depends_on(f"geopm-service@{ver}", type=("build", "run"), when=f"@{ver}")
         depends_on(f"py-geopmdpy@{ver}", type="run", when=f"@{ver}")
+        if ver != "3.0.1":  # geopmpy integrated into autotools build until 3.1
+            depends_on(f"py-geopmpy@{ver}", type="run", when=f"@{ver}")
+    depends_on("py-setuptools-scm@7.0.3:", when="@3.1:", type="build")
     depends_on("bash-completion")
     depends_on("unzip")
     depends_on("mpi@2.2:", when="+mpi")
@@ -96,6 +103,13 @@ class GeopmRuntime(AutotoolsPackage):
 
     extends("python")
 
+    @property
+    def configure_directory(self):
+        if self.version == Version("3.0.1"):
+            return "."
+        else:
+            return "libgeopm"
+
     @property
     def install_targets(self):
         target = ["install"]
@@ -105,20 +119,26 @@ def install_targets(self):
 
     def autoreconf(self, spec, prefix):
         bash = which("bash")
-        if not spec.version.isdevelop():
-            # Required to workaround missing VERSION files
-            # from GitHub generated source tarballs
-            with open("VERSION_OVERRIDE", "w") as fd:
-                fd.write(f"{spec.version}")
-        bash("./autogen.sh")
+        with working_dir(self.configure_directory):
+            if not spec.version.isdevelop():
+                if self.version == Version("3.0.1"):
+                    version_file = "VERSION_OVERRIDE"
+                else:
+                    version_file = "VERSION"
+                # Required to workaround missing VERSION files
+                # from GitHub generated source tarballs
+                with open(version_file, "w") as fd:
+                    fd.write(f"{spec.version}")
+            bash("./autogen.sh")
 
     def configure_args(self):
-        args = [
-            "--with-bash-completion-dir="
-            + join_path(self.spec.prefix, "share", "bash-completion", "completions"),
-            "--disable-geopmd-local",
-            f"--with-geopmd={self.spec['geopm-service'].prefix}",
-        ]
+
+        with when("@3.0.1"):
+            args = [
+                "--with-bash-completion-dir="
+                + join_path(self.spec.prefix, "share", "bash-completion", "completions")
+            ]
+        args += ["--disable-geopmd-local", f"--with-geopmd={self.spec['geopm-service'].prefix}"]
 
         args += self.enable_or_disable("debug")
         args += self.enable_or_disable("docs")

var/spack/repos/builtin/packages/geopm-service/package.py

@@ -18,13 +18,14 @@ class GeopmService(AutotoolsPackage):
 
     homepage = "https://geopm.github.io"
     git = "https://github.com/geopm/geopm.git"
-    url = "https://github.com/geopm/geopm/tarball/v3.0.1"
+    url = "https://github.com/geopm/geopm/tarball/v3.1.0"
 
     maintainers("bgeltz", "cmcantalupo")
     license("BSD-3-Clause")
     tags = ["e4s"]
 
     version("develop", branch="dev", get_full_repo=True)
+    version("3.1.0", sha256="2d890cad906fd2008dc57f4e06537695d4a027e1dc1ed92feed4d81bb1a1449e")
     version("3.0.1", sha256="32ba1948de58815ee055470dcdea64593d1113a6cad70ce00ab0286c127f8234")
 
     depends_on("c", type="build")  # generated
@@ -32,7 +33,7 @@ class GeopmService(AutotoolsPackage):
     depends_on("fortran", type="build")  # generated
 
     variant("debug", default=False, description="Enable debug")
-    variant("docs", default=True, description="Create man pages with Sphinx")
+    variant("docs", default=True, when="@3.0.1", description="Create man pages with Sphinx")
     variant("systemd", default=True, description="Enable use of systemd/DBus")
     variant("liburing", default=True, description="Enables the use of liburing for batch I/O")
     variant(
@@ -69,24 +70,30 @@ class GeopmService(AutotoolsPackage):
     depends_on("libtool", type="build")
     depends_on("file")
 
-    # Docs dependencies
-    depends_on("doxygen", type="build", when="+docs")
-    depends_on("py-docstring-parser@0.13.0:", type="build", when="+docs")
-    depends_on("py-sphinx", type="build", when="+docs")
-    depends_on("py-sphinx-rtd-theme@1:", type="build", when="+docs")
-    depends_on("py-sphinxemoji@0.2.0:", type="build", when="+docs")
-    depends_on("py-sphinx-tabs@3.3.1:", type="build", when="+docs")
-    depends_on("py-pygments@2.13.0:", type="build", when="+docs")
+    with when("@3.0.1"):
+        # Docs dependencies
+        #   Moved to python3-geopm-doc as of v3.1
+        depends_on("doxygen", type="build", when="+docs")
+        depends_on("py-docstring-parser@0.13.0:", type="build", when="+docs")
+        depends_on("py-sphinx", type="build", when="+docs")
+        depends_on("py-sphinx-rtd-theme@1:", type="build", when="+docs")
+        depends_on("py-sphinxemoji@0.2.0:", type="build", when="+docs")
+        depends_on("py-sphinx-tabs@3.3.1:", type="build", when="+docs")
+        depends_on("py-pygments@2.13.0:", type="build", when="+docs")
 
-    # Other Python dependencies - from service/setup.py
-    depends_on("py-dasbus@1.6.0:", type=("build", "run"))
-    depends_on("py-cffi@1.14.5:", type="run")
-    depends_on("py-psutil@5.8.0:", type="run")
-    depends_on("py-jsonschema@3.2.0:", type="run")
-    depends_on("py-pyyaml@6.0:", type="run")
-    depends_on("py-setuptools@53.0.0:", type="build")
+        # Other Python dependencies - from service/setup.py
+        #   Moved to python3-geopmdpy as of v3.1
+        depends_on("py-setuptools@53.0.0:", type="build")
+        depends_on("py-dasbus@1.6.0:", type=("build", "run"))
+        depends_on("py-psutil@5.8.0:", type=("build", "run"))
+        depends_on("py-jsonschema@3.2.0:", type=("build", "run"))
+        depends_on("py-pyyaml@6.0:", type=("build", "run"))
+        depends_on("py-cffi@1.14.5:", type="run")
 
     # Other dependencies
+    for ver in ["3.1.0", "develop"]:
+        depends_on(f"py-geopmdpy@{ver}", type="run", when=f"@{ver}")
+    depends_on("py-setuptools-scm@7.0.3:", when="@3.1:", type="build")
     depends_on("bash-completion")
     depends_on("unzip")
     depends_on("systemd", when="+systemd")
@@ -97,15 +104,24 @@ class GeopmService(AutotoolsPackage):
 
     extends("python")
 
-    configure_directory = "service"
+    @property
+    def configure_directory(self):
+        if self.version == Version("3.0.1"):
+            return "service"
+        else:
+            return "libgeopmd"
 
     def autoreconf(self, spec, prefix):
         bash = which("bash")
-        with working_dir("service"):
+        with working_dir(self.configure_directory):
             if not spec.version.isdevelop():
+                if self.version == Version("3.0.1"):
+                    version_file = "VERSION_OVERRIDE"
+                else:
+                    version_file = "VERSION"
                 # Required to workaround missing VERSION files
                 # from GitHub generated source tarballs
-                with open("VERSION_OVERRIDE", "w") as fd:
+                with open(version_file, "w") as fd:
                     fd.write(f"{spec.version}")
             bash("./autogen.sh")
 

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

@@ -21,7 +21,13 @@ class Gfsio(CMakePackage):
     version("develop", branch="develop")
     version("1.4.1", sha256="eab106302f520600decc4f9665d7c6a55e7b4901fab6d9ef40f29702b89b69b1")
 
-    depends_on("fortran", type="build")  # generated
+    depends_on("fortran", type="build")
+
+    depends_on("pfunit", type="test")
+
+    def cmake_args(self):
+        args = [self.define("ENABLE_TESTS", self.run_tests)]
+        return args
 
     def setup_run_environment(self, env):
         lib = find_libraries("libgfsio", root=self.prefix, shared=False, recursive=True)
@@ -35,3 +41,7 @@ def flag_handler(self, name, flags):
             if name == "fflags":
                 flags.append("-Free")
         return (None, None, flags)
+
+    def check(self):
+        with working_dir(self.builder.build_directory):
+            make("test")

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

@@ -6,7 +6,7 @@
 from spack.package import *
 
 
-class Gh(Package):
+class Gh(GoPackage):
     """GitHub's official command line tool."""
 
     homepage = "https://github.com/cli/cli"
@@ -43,14 +43,10 @@ class Gh(Package):
     depends_on("go@1.21:", type="build", when="@2.33.0:")
     depends_on("go@1.22:", type="build", when="@2.47.0:")
 
-    phases = ["build", "install"]
 
-    def setup_build_environment(self, env):
-        # Point GOPATH at the top of the staging dir for the build step.
-        env.prepend_path("GOPATH", self.stage.path)
-
-    def build(self, spec, prefix):
-        make()
-
-    def install(self, spec, prefix):
-        make("install", "prefix=" + prefix)
+class GoBuilder(spack.build_systems.go.GoBuilder):
+    @property
+    def build_args(self):
+        args = super().build_args
+        args.extend(["-trimpath", "./cmd/gh"])
+        return args

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

@@ -15,11 +15,9 @@ class Gnds(CMakePackage):
     homepage = "https://code.ornl.gov/RNSD/gnds"
     url = "https://code.ornl.gov/RNSD/gnds/-/archive/v0.0.1/gnds-v0.0.1.tar.gz"
 
-    maintainers("sethrj")
-
     version("0.0.1", sha256="4c8faaa01a3e6fb08ec3e8e126a76f75b5442509a46b993e325ec79dd9f04879")
 
-    depends_on("cxx", type="build")  # generated
+    depends_on("cxx", type="build")
 
     variant("shared", default=True, description="Build shared libraries")
 

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

@@ -34,8 +34,8 @@ class Gperftools(AutotoolsPackage, CMakePackage):
     version("2.4", sha256="982a37226eb42f40714e26b8076815d5ea677a422fb52ff8bfca3704d9c30a2d")
     version("2.3", sha256="093452ad45d639093c144b4ec732a3417e8ee1f3744f2b0f8d45c996223385ce")
 
-    depends_on("c", type="build")  # generated
-    depends_on("cxx", type="build")  # generated
+    depends_on("c", type="build")
+    depends_on("cxx", type="build")
 
     variant("sized_delete", default=False, description="Build sized delete operator")
     variant(

var/spack/repos/builtin/packages/grib-util/package.py

@@ -18,13 +18,14 @@ class GribUtil(CMakePackage):
     maintainers("AlexanderRichert-NOAA", "Hang-Lei-NOAA", "edwardhartnett")
 
     version("develop", branch="develop")
+    version("1.5.0", tag="v1.5.0", commit="b84e877a62efe6695546a4b7a02e7adb6e1ece25")
     version("1.4.0", tag="v1.4.0", commit="eeacc9ec93dfe6379f576191883c84a4a1202cc8")
     version("1.3.0", commit="9d3c68a")
     version("1.2.4", sha256="f021d6df3186890b0b1781616dabf953581d71db63e7c2913360336985ccaec7")
     version("1.2.3", sha256="b17b08e12360bb8ad01298e615f1b4198e304b0443b6db35fe990a817e648ad5")
 
-    depends_on("c", type="build")  # generated
-    depends_on("fortran", type="build")  # generated
+    depends_on("c", type="build")
+    depends_on("fortran", type="build")
 
     variant("openmp", default=False, description="Use OpenMP multithreading")
     variant("tests", default=False, description="Enable this variant when installing with --test")
@@ -36,7 +37,8 @@ class GribUtil(CMakePackage):
     requires("^w3emc precision=4,d", when="^w3emc@2.10:")
     depends_on("w3nco", when="@:1.2.3")
     depends_on("g2")
-    depends_on("g2@3.4.9:", when="@1.4:")
+    depends_on("g2@3.4.9:", when="@1.4")
+    depends_on("g2@3.5:", when="@1.5:")
     depends_on("g2c@1.8: +utils", when="+tests")
     depends_on("bacio")
     depends_on("ip")

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

@@ -44,6 +44,7 @@ class Groff(AutotoolsPackage, GNUMirrorPackage):
 
     conflicts("+uchardet", when="@:1.22.3")
 
+    depends_on("m4", type="build")
     depends_on("gawk", type="build")
     depends_on("gmake", type="build")
     depends_on("sed", type="build")

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

@@ -15,16 +15,17 @@ class Halide(CMakePackage, PythonExtension):
 
     license("MIT")
 
-    maintainers("wraith1995")
+    maintainers("wraith1995", "alexreinking")
     version("main", branch="main")
+    version("18.0.0", sha256="1176b42a3e2374ab38555d9316c78e39b157044b5a8e765c748bf3afd2edb351")
+    version("17.0.2", sha256="5f3a43ba27b47d3dcbcee963faabf1d633d4151031e60b6ff7cc62472e5677a0")
+    version("17.0.1", sha256="beb18331d9e4b6f69943bcc75fb9d923a250ae689f09f6940a01636243289727")
+    version("17.0.0", sha256="7e5a526b4074887b528d25b0265ddfa92c0a6d8bfdfbbba536313ecddf352da3")
+    version("16.0.0", sha256="a0cccee762681ea697124b8172dd65595856d0fa5bd4d1af7933046b4a085b04")
     version("15.0.0", sha256="6680424f80c5731a85d977c06327096afe5af31da3667e91d4d36a25fabdda15")
     version("14.0.0", sha256="f9fc9765217cbd10e3a3e3883a60fc8f2dbbeaac634b45c789577a8a87999a01")
-    version("16.0.0", sha256="a0cccee762681ea697124b8172dd65595856d0fa5bd4d1af7933046b4a085b04")
-    version("17.0.0", sha256="7e5a526b4074887b528d25b0265ddfa92c0a6d8bfdfbbba536313ecddf352da3")
-    version("17.0.1", sha256="beb18331d9e4b6f69943bcc75fb9d923a250ae689f09f6940a01636243289727")
-
-    depends_on("c", type="build")  # generated
-    depends_on("cxx", type="build")  # generated
+    depends_on("c", type="build")
+    depends_on("cxx", type="build")
     variant(
         "build_type",
         default="Release",
@@ -68,6 +69,8 @@ class Halide(CMakePackage, PythonExtension):
     depends_on("llvm@15.0.0:15", type=("link", "run"), when="@15.0.0:15")
     depends_on("llvm@16.0.0:16", type=("link", "run"), when="@16.0.0:16")
     depends_on("llvm@17.0.0:17", type=("link", "run"), when="@17.0.0:17")
+    depends_on("llvm@17.0.0:18", type=("link", "run"), when="@18.0.0:18")
+
     for v in _values:
         depends_on(
             "llvm targets={0}".format(v), type=("link", "run"), when="targets={0}".format(v)
@@ -79,7 +82,8 @@ class Halide(CMakePackage, PythonExtension):
 
     depends_on("python@3.8:", type=("build", "link", "run"), when="+python")
     # See https://github.com/halide/Halide/blob/main/requirements.txt
-    depends_on("py-pybind11@2.6.2", type="build", when="+python")
+    depends_on("py-pybind11@2.6.2", type="build", when="@14.0.0:17+python")
+    depends_on("py-pybind11@2.10.4", type="build", when="@18.0.0:+python")
     depends_on("py-setuptools@43:", type="build", when="+python")
     depends_on("py-scikit-build", type="build", when="+python")
     depends_on("py-wheel", type="build", when="+python")

var/spack/repos/builtin/packages/hdf-eos2/package.py

@@ -120,9 +120,11 @@ def fix_configure(self):
         filter_file("CC=./\\$SZIP_CC", "", "configure")
 
     def flag_handler(self, name, flags):
-        if self.spec.compiler.name == "apple-clang":
-            if name == "cflags":
+        if name == "cflags":
+            flags.append(self.compiler.cc_pic_flag)
+            if self.spec.compiler.name in ["apple-clang", "oneapi"]:
                 flags.append("-Wno-error=implicit-function-declaration")
+                flags.append("-Wno-error=implicit-int")
 
         return flags, None, None
 
@@ -160,15 +162,4 @@ def configure_args(self):
         if "zlib" in self.spec:
             extra_args.append("--with-zlib={0}".format(self.spec["zlib-api"].prefix))
 
-        # https://forum.hdfgroup.org/t/help-building-hdf4-with-clang-error-implicit-declaration-of-function-test-mgr-szip-is-invalid-in-c99/7680
-        # -fPIC: https://github.com/spack/spack/issues/43792
-        if self.spec.satisfies("%apple-clang"):
-            extra_args.append(
-                "CFLAGS=-Wno-error=implicit-function-declaration {0}".format(
-                    self.compiler.cc_pic_flag
-                )
-            )
-        else:
-            extra_args.append("CFLAGS={0}".format(self.compiler.cc_pic_flag))
-
         return extra_args

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

@@ -18,6 +18,11 @@ class Heyoka(CMakePackage):
     # SPDX identifier of the project's license.
     license("MPL-2.0")
 
+    version("5.0.0", sha256="e9a4b5683a08706addc1b448e232f1e269d78586859fe3f4d93d4c5eee3bc8ae")
+    version("4.0.3", sha256="47608e785607782d896ae2347a29a143cdb7e5c602f48f5ea795cf682051dbee")
+    version("4.0.2", sha256="8eba8fe0626c3d48affad3055e490e5d21430a420af867d7d52c18ed6b602ae0")
+    version("4.0.1", sha256="25ad39a716c5d548260d505225a13b7fa86534761b6e3d3de991d9d097ec615f")
+    version("4.0.0", sha256="bc375271773993bd89d604a269c4931e54fb8508c8235397d47f0b60b78f3cdf")
     version("3.2.0", sha256="37db24fbaf0e65d740ffb20f76ac1c8ab9fbd6893dc87dfd483c965b71dbf465")
     version("3.1.0", sha256="7eecab47f44a9fff022cf24f226763dab8b075a9fdaa543a42f64bb2634b3ad8")
     version("3.0.0", sha256="03ccb6fb015ad43877781763c0f2f49bd6db64c8b9493174e589c970ef00d7f2")
@@ -49,7 +54,8 @@ class Heyoka(CMakePackage):
     depends_on("cmake@3.18:", type="build")
 
     # Required dependencies
-    depends_on("llvm@13:17")
+    depends_on("llvm@13:17", when="@:4")
+    depends_on("llvm@13:18", when="@5")
     depends_on("boost@1.69: +serialization")
     depends_on("fmt@9:10")
     depends_on("spdlog")

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

@@ -24,7 +24,7 @@ class HpxKokkos(CMakePackage, CudaPackage, ROCmPackage):
     version("0.2.0", sha256="289b711cea26afe80be002fc521234c9194cd0e8f69863f3b08b654674dbe5d5")
     version("0.1.0", sha256="24edb817d0969f4aea1b68eab4984c2ea9a58f4760a9b8395e20f85b178f0850")
 
-    depends_on("cxx", type="build")  # generated
+    depends_on("cxx", type="build")
 
     cxxstds = ("14", "17", "20")
     variant(

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

@@ -41,7 +41,7 @@ class Hpx(CMakePackage, CudaPackage, ROCmPackage):
     version("1.2.0", sha256="20942314bd90064d9775f63b0e58a8ea146af5260a4c84d0854f9f968077c170")
     version("1.1.0", sha256="1f28bbe58d8f0da600d60c3a74a644d75ac777b20a018a5c1c6030a470e8a1c9")
 
-    depends_on("cxx", type="build")  # generated
+    depends_on("cxx", type="build")
 
     generator("ninja")