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,7 +87,7 @@ jobs:
           fi
 
       - name: Upload Dockerfile
-        uses: actions/upload-artifact@0b2256b8c012f0828dc542b3febcab082c67f72b
+        uses: actions/upload-artifact@89ef406dd8d7e03cfd12d9e0a4a378f454709029
         with:
           name: dockerfiles_${{ matrix.dockerfile[0] }}
           path: dockerfiles
@@ -96,7 +96,7 @@ jobs:
         uses: docker/setup-qemu-action@49b3bc8e6bdd4a60e6116a5414239cba5943d3cf
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@aa33708b10e362ff993539393ff100fa93ed6a27
+        uses: docker/setup-buildx-action@988b5a0280414f521da01fcc63a27aeeb4b104db
 
       - name: Log in to GitHub Container Registry
         uses: docker/login-action@9780b0c442fbb1117ed29e0efdff1e18412f7567
@@ -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

@@ -10,4 +10,4 @@ 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/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/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()
 
 

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:

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/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/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/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/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/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/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/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/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/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/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/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/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,7 +15,7 @@ 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")

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

@@ -18,6 +18,7 @@ class Ip(CMakePackage):
     maintainers("AlexanderRichert-NOAA", "edwardhartnett", "Hang-Lei-NOAA")
 
     version("develop", branch="develop")
+    version("5.1.0", sha256="5279f11f4c12db68ece74cec392b7a2a6b5166bc505877289f34cc3149779619")
     version("5.0.0", sha256="54b2987bd4f94adc1f7595d2a384e646019c22d163bcd30840a916a6abd7df71")
     version("4.4.0", sha256="858d9201ce0bc4d16b83581ef94a4a0262f498ed1ea1b0535de2e575da7a8b8c")
     version("4.3.0", sha256="799308a868dea889d2527d96a0405af7b376869581410fe4cff681205e9212b4")
@@ -32,8 +33,8 @@ class Ip(CMakePackage):
         preferred=True,
     )
 
-    depends_on("c", type="build")  # generated
-    depends_on("fortran", type="build")  # generated
+    depends_on("c", type="build")
+    depends_on("fortran", type="build")
 
     variant("openmp", description="Enable OpenMP threading", default=True)
     variant("pic", default=True, description="Build with position-independent-code")
@@ -68,6 +69,7 @@ class Ip(CMakePackage):
     depends_on("sp precision=4", when="@4.1:4 precision=4")
     depends_on("sp precision=d", when="@4.1:4 precision=d")
     depends_on("sp precision=8", when="@4.1:4 precision=8")
+    depends_on("lapack", when="@5.1:")
 
     def cmake_args(self):
         args = [
@@ -91,6 +93,16 @@ def cmake_args(self):
         if self.spec.satisfies("@5:"):
             args.append(self.define_from_variant("BUILD_DEPRECATED", "deprecated"))
 
+        if self.spec.satisfies("@5.1:"):
+            # Use the LAPACK provider set by Spack even if the compiler supports native BLAS
+            bla_vendors = {"openblas": "OpenBLAS"}
+            lapack_provider = self.spec["lapack"].name
+            if lapack_provider in bla_vendors.keys():
+                bla_vendor = bla_vendors[lapack_provider]
+            else:
+                bla_vendor = "All"
+            args.append(self.define("BLA_VENDOR", bla_vendor))
+
         return args
 
     def setup_run_environment(self, env):

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

@@ -25,8 +25,8 @@ class Ip2(CMakePackage):
         deprecated=True,
     )
 
-    depends_on("c", type="build")  # generated
-    depends_on("fortran", type="build")  # generated
+    depends_on("c", type="build")
+    depends_on("fortran", type="build")
 
     depends_on("sp")
     requires("^sp precision=4,8,d", when="^sp@2.4:")

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

@@ -18,6 +18,9 @@ class Kakoune(MakefilePackage):
 
     license("Unlicense")
 
+    version(
+        "2024.05.18", sha256="dae8ac2e61d21d9bcd10145aa70b421234309a7b0bc57fad91bc34dbae0cb9fa"
+    )
     version(
         "2024.05.09", sha256="2190bddfd3af590c0593c38537088976547506f47bd6eb6c0e22350dbd16a229"
     )
@@ -40,4 +43,4 @@ class Kakoune(MakefilePackage):
 
     @property
     def install_targets(self):
-        return ["-e", f"PREFIX={prefix}", "install"]
+        return ["-e", f"PREFIX={prefix}", "installdirs", "install"]

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

@@ -21,7 +21,13 @@ class Landsfcutil(CMakePackage):
     version("develop", branch="develop")
     version("2.4.1", sha256="831c5005a480eabe9a8542b4deec838c2650f6966863ea2711cc0cc5db51ca14")
 
-    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):
         for suffix in ("4", "d"):
@@ -37,3 +43,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/lcio/package.py

@@ -21,6 +21,7 @@ class Lcio(CMakePackage):
     license("BSD-3-Clause")
 
     version("master", branch="master")
+    version("2.22.1", sha256="4bc3d2c83af7b1c65d6736dd14ee82f41af7ce9bfc7cfe779c5f47417e8dc326")
     version("2.22", sha256="95676977a0427f5ecc857e8504b13f332c2c2e5769dc00f6beecff3c73dab395")
     version("2.21", sha256="a9f0a9922ab2ef17c6f1b8f7187bfc341f27567745a43c0480c103b617dfcea6")
     version("2.20.2", sha256="b37cee344c28ccddc590e5317721b375ef19f4392ae067bc86583107acaf2374")
@@ -66,6 +67,7 @@ class Lcio(CMakePackage):
 
     depends_on("sio@0.0.2:", when="@2.14:")
     depends_on("sio@0.1:", when="@2.16:")
+    depends_on("sio@0.2:", when="@2.21:")
 
     depends_on("root@6.04:", when="+rootdict")
     depends_on("root@6.04: cxxstd=11", when="+rootdict cxxstd=11")

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

@@ -14,10 +14,19 @@ class Libspng(CMakePackage):
     homepage = "https://github.com/randy408/libspng"
     url = "https://github.com/randy408/libspng/archive/refs/tags/v0.7.2.tar.gz"
 
+    maintainers("sethrj")
+
     license("BSD-2-Clause")
 
     version("0.7.4", sha256="47ec02be6c0a6323044600a9221b049f63e1953faf816903e7383d4dc4234487")
     version("0.7.2", sha256="4acf25571d31f540d0b7ee004f5461d68158e0a13182505376805da99f4ccc4e")
 
-    depends_on("c", type="build")  # generated
-    depends_on("cxx", type="build")  # generated
+    depends_on("c", type="build")
+    depends_on("zlib")
+
+    def cmake_args(self):
+        target = self.spec.target
+        return [
+            self.define("BUILD_EXAMPLES", False),
+            self.define("ENABLE_OPT", target.vendor != "generic"),
+        ]

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

@@ -3,6 +3,8 @@
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
+import sys
+
 from spack.package import *
 
 
@@ -20,6 +22,7 @@ class Libuuid(AutotoolsPackage, SourceforgePackage):
 
     depends_on("c", type="build")  # generated
 
-    provides("uuid")
+    if sys.platform not in ["darwin", "win32"]:
+        provides("uuid")
 
     conflicts("%gcc@14:")

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

@@ -11,26 +11,26 @@ class Libvterm(MakefilePackage):
     """An abstract library implementation of a terminal emulator"""
 
     homepage = "http://www.leonerd.org.uk/code/libvterm/"
-    url = "http://www.leonerd.org.uk/code/libvterm/libvterm-0.1.3.tar.gz"
 
     license("MIT")
 
+    maintainers("fthaler")
+
     version("0.3.3", sha256="09156f43dd2128bd347cbeebe50d9a571d32c64e0cf18d211197946aff7226e0")
     version("0.3.1", sha256="25a8ad9c15485368dfd0a8a9dca1aec8fea5c27da3fa74ec518d5d3787f0c397")
     version("0.3", sha256="61eb0d6628c52bdf02900dfd4468aa86a1a7125228bab8a67328981887483358")
     version("0.2", sha256="4c5150655438cfb8c57e7bd133041140857eb04defd0e544521c0e469258e105")
     version("0.1.4", sha256="bc70349e95559c667672fc8c55b9527d9db9ada0fb80a3beda533418d782d3dd")
     version("0.1.3", sha256="e41724466a4658e0f095e8fc5aeae26026c0726dce98ee71d6920d06f7d78e2b")
-    version(
-        "0.0.0",
-        sha256="6344eca01c02e2270348b79e033c1e0957028dbcd76bc784e8106bea9ec3029d",
-        url="http://www.leonerd.org.uk/code/libvterm/libvterm-0+bzr726.tar.gz",
-    )
 
     depends_on("c", type="build")  # generated
 
     depends_on("libtool", type="build")
 
+    def url_for_version(self, version):
+        url = "https://launchpad.net/libvterm/trunk/v{0}/+download/libvterm-{1}.tar.gz"
+        return url.format(version.up_to(2), version)
+
     def setup_build_environment(self, env):
         env.set("LIBTOOL", self.spec["libtool"].prefix.bin.join("libtool"))
 

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

@@ -38,12 +38,12 @@ class Libxcb(AutotoolsPackage, XorgPackage):
     depends_on("libxdmcp")
 
     # libxcb 1.X requires xcb-proto >= 1.X
-    depends_on("xcb-proto")
-    depends_on("xcb-proto@1.17:", when="@1.17")
-    depends_on("xcb-proto@1.16:", when="@1.16")
-    depends_on("xcb-proto@1.15:", when="@1.15")
-    depends_on("xcb-proto@1.14:", when="@1.14")
-    depends_on("xcb-proto@1.13:", when="@1.13")
+    depends_on("xcb-proto", type="build")
+    depends_on("xcb-proto@1.17:", when="@1.17", type="build")
+    depends_on("xcb-proto@1.16:", when="@1.16", type="build")
+    depends_on("xcb-proto@1.15:", when="@1.15", type="build")
+    depends_on("xcb-proto@1.14:", when="@1.14", type="build")
+    depends_on("xcb-proto@1.13:", when="@1.13", type="build")
 
     depends_on("python", type="build")
     depends_on("pkgconfig", type="build")

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

@@ -0,0 +1,66 @@
+# 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 Libxfce4ui(AutotoolsPackage):
+    """Widget sharing library for XFCE4"""
+
+    homepage = "https://docs.xfce.org/xfce/libxfce4ui/start"
+    url = "https://archive.xfce.org/xfce/4.16/src/libxfce4ui-4.16.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="532247c4387c17bb9ef94a73147039b8d013c3131c95cdbd2fa85fbcc848d06b")
+    version("4.16.0", sha256="8b06c9e94f4be88a9d87c47592411b6cbc32073e7af9cbd64c7b2924ec90ceaa")
+
+    variant("glibtop", default=True, description="Build with glibtop support")
+    variant("introspection", default=True, description="Build with gobject-introspection support")
+    variant("vala", default=True, description="Build with vala support")
+    variant("notification", default=True, description="Build with startup-notification support")
+
+    depends_on("intltool@0.35.0:", type="build")
+    with default_args(type=("build", "link", "run")):
+        depends_on("libxfce4util")
+        depends_on("xfconf")
+        depends_on("glib@2:")
+        depends_on("gtkplus@3:")
+        depends_on("libgtop@2", when="+glibtop")
+        depends_on("startup-notification", when="+notification")
+        with when("+introspection"):
+            depends_on("gobject-introspection")
+            depends_on("libxfce4util+introspection")
+        with when("+vala"):
+            depends_on("vala")
+            depends_on("libxfce4util+vala")
+        with when("@4.18:"):
+            depends_on("glib@2.66:")
+            depends_on("gtkplus@3.24:")
+            depends_on("gobject-introspection@1.66:", when="+introspection")
+        with when("@4.16:"):
+            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("glibtop")
+        args += self.enable_or_disable("introspection")
+        args += self.enable_or_disable("vala")
+        args += self.enable_or_disable("notification")
+
+        return args
+
+    def setup_dependent_build_environment(self, env, dependent_spec):
+        env.prepend_path("XDG_DATA_DIRS", self.prefix.share)
+
+    def setup_dependent_run_environment(self, env, dependent_spec):
+        env.prepend_path("XDG_DATA_DIRS", self.prefix.share)

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

@@ -0,0 +1,56 @@
+# 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 Libxfce4util(AutotoolsPackage):
+    """Libxfce4util common  non-GTK+ utilities among the Xfce applications."""
+
+    homepage = "https://docs.xfce.org/xfce/libxfce4util/start"
+    url = "https://archive.xfce.org/xfce/4.16/src/libxfce4util-4.16.0.tar.bz2"
+    list_url = "https://archive.xfce.org/xfce/"
+    list_depth = 2
+
+    maintainers("teaguesterling")
+
+    license("LGPLv2", checked_by="teague")  # https://wiki.xfce.org/licenses/audit
+
+    version("4.18.0", sha256="1157ca717fd3dd1da7724a6432a4fb24af9cd922f738e971fd1fd36dfaeac3c9")
+    version("4.16.0", sha256="60598d745d1fc81ff5ad3cecc3a8d1b85990dd22023e7743f55abd87d8b55b83")
+
+    variant("introspection", default=True, description="Build with gobject-introspection support")
+    variant("vala", default=True, description="Build with vala support")
+
+    with default_args(type="build"):
+        depends_on("intltool@0.35.0:", when="@4.16:")
+        depends_on("gettext", when="@4.18:")
+
+    with default_args(type=("run", "link", "build")):
+        depends_on("pkgconfig@0.9.0:")
+        depends_on("glib@2")
+        depends_on("gobject-introspection", when="+introspection")
+        depends_on("vala", when="+vala")
+        with when("@4.18:"):
+            depends_on("glib@2.66:")
+            depends_on("gobject-introspection@1.66:", when="+introspection")
+        with when("@4.16"):
+            depends_on("glib@2.50:")
+            depends_on("gobject-introspection@1.60:", when="+introspection")
+
+    def configure_args(self):
+        args = []
+
+        args += self.enable_or_disable("introspection")
+        args += self.enable_or_disable("vala")
+
+        return args
+
+    def setup_dependent_build_environment(self, env, dependent_spec):
+        env.prepend_path("XDG_DATA_DIRS", self.prefix.share)
+
+    def setup_dependent_run_environment(self, env, dependent_spec):
+        env.prepend_path("XDG_DATA_DIRS", self.prefix.share)

var/spack/repos/builtin/packages/linaro-forge/package.py

@@ -23,6 +23,9 @@ class LinaroForge(Package):
     maintainers("kenche-linaro")
 
     if platform.machine() in ["aarch64", "arm64"]:
+        version(
+            "24.0.3", sha256="5030c5c23824963f82e94ed606e47cce802393fa4cb7757966818baa7012aa21"
+        )
         version(
             "24.0.2", sha256="8346eb0375910498a83baff6833256c8221c2c06737670687bcf9f1497d9ede9"
         )
@@ -88,6 +91,9 @@ class LinaroForge(Package):
             "21.1.3", sha256="eecbc5686d60994c5468b2d7cd37bebe5d9ac0ba37bd1f98fbfc69b071db541e"
         )
     elif platform.machine() == "x86_64":
+        version(
+            "24.0.3", sha256="1796559fb86220d5e17777215d3820f4b04aba271782276b81601d5065284526"
+        )
         version(
             "24.0.2", sha256="e2ad12273d568560e948a9bcdd49b830a2309f247b146bf36579053f99ec59a3"
         )

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

@@ -18,52 +18,130 @@ class Meson(PythonPackage):
 
     license("Apache-2.0")
 
+    version("1.5.1", sha256="55f6acd5bf72c14d4aa5a781993633f84a1d117bdf2c2057735902ced9b81390")
+    version("1.4.2", sha256="11d1336fe35e1ade57510a846a31d7dc2e3b6ac1e2491c2831bce5a2a192ba0d")
     version("1.3.2", sha256="683082fb3c5cddf203b21d29bdf4c227e2f7964da5324a15e1a5f7db94322b4b")
     version("1.2.2", sha256="1caa0ef6082e311bdca9836e7907f548b8c3f041a42ed41f0ff916b83ac7dddd")
-    version("1.2.1", sha256="e1f3b32b636cc86496261bd89e63f00f206754697c7069788b62beed5e042713")
-    version("1.2.0", sha256="603489f0aaa6305f806c6cc4a4455a965f22290fc74f65871f589b002110c790")
     version("1.1.1", sha256="1c3b9e1a3a36b51adb5de498d582fd5cbf6763fadbcf151de9f2a762e02bd2e6")
-    version("1.1.0", sha256="f29a3e14062043d75e82d16f1e41856e6b1ed7a7c016e10c7b13afa7ee6364cc")
     version("1.0.2", sha256="1f1239c3091668643f7d2086663d6afd8cc87fbab84fe7462bc18b9ba6d65de8")
-    version("1.0.1", sha256="4ab3a5c0060dc22bdefb04507efc6c38acb910e91bcd467a38e1fa211e5a6cfe")
-    version("1.0.0", sha256="a2ada84d43c7e57400daee80a880a1f5003d062b2cb6c9be1747b0db38f2eb8d")
-    version("0.64.1", sha256="1d12a4bc1cf3ab18946d12cf0b6452e5254ada1ad50aacc97f87e2cccd7da315")
-    version("0.64.0", sha256="6477993d781b6efea93091616a6d6a0766c0e026076dbeb11249bf1c9b49a347")
-    version("0.63.3", sha256="7c516c2099b762203e8a0a22412aa465b7396e6f9b1ab728bad6e6db44dc2659")
-    version("0.63.2", sha256="023a3f7c74e68991154c3205a6975705861eedbf8130e013d15faa1df1af216e")
-    version("0.63.1", sha256="f355829f0e8c714423f03a06604c04c216d4cbe3586f3154cb2181076b19207a")
-    version("0.62.2", sha256="97108f4d9bb16bc758c44749bd25ec7d42c6a762961efbed8b7589a2a3551ea6")
-    version("0.62.1", sha256="9fb52e66dbc613479a5f70e46cc2e8faf5aa65e09313f2c71fa63b8afd018107")
-    version("0.62.0", sha256="72ac3bab701dfd597604de29cc74baaa1cc0ad8ca26ae23d5288de26abfe1c80")
-    version("0.61.4", sha256="c9cc34bcb15c19cfd5ee0d7b07111152701f602db2b59ef6b63d3628e0bbe719")
-    version("0.61.2", sha256="33cd555314a94d52acfbb3f6f44d4e61c4ad0bfec7acf4301be7e40bb969b3a8")
-    version("0.60.3", sha256="6c191a9b4049e0c9a2a7d1275ab635b91f6ffec1912d75df4c5ec6acf35f74fe")
-    version("0.60.0", sha256="5672a560fc4094c88ca5b8be0487e099fe84357e5045f5aecf1113084800e6fd")
-    version("0.59.2", sha256="e6d5ccd503d41f938f6cfc4dc9e7326ffe28acabe091b1ff0c6535bdf09732dd")
-    version("0.59.1", sha256="f256eb15329a6064f8cc1f23b29de1fa8d21e324f939041e1a4efe77cf1362ef")
-    version("0.59.0", sha256="fdbbe8ea8a47f9e21cf4f578f85be8ec3d9c030df3d8cb17df1ae59d8683813a")
-    version("0.58.2", sha256="58115604dea9c1f70811578df3c210f4d67cf795d21a4418f6e9bb35406953f5")
-    version("0.58.1", sha256="78e0f553dd3bc632d5f96ab943b1bbccb599c2c84ff27c5fb7f7fff9c8a3f6b4")
-    version("0.58.0", sha256="991b882bfe4d37acc23c064a29ca209458764a580d52f044f3d50055a132bed4")
-    version("0.57.2", sha256="cd3773625253df4fd1c380faf03ffae3d02198d6301e7c8bc7bba6c66af66096")
-    version("0.57.1", sha256="0c043c9b5350e9087cd4f6becf6c0d10b1d618ca3f919e0dcca2cdf342360d5d")
-    version("0.57.0", sha256="fd26a27c1a509240c668ebd29d280649d9239cf8684ead51d5cb499d1e1188bd")
-    version("0.56.2", sha256="aaae961c3413033789248ffe6762589e80b6cf487c334d0b808e31a32c48f35f")
-    version("0.56.0", sha256="a9ca7adf66dc69fbb7e583f7c7aef16b9fe56ec2874a3d58747e69a3affdf300")
-    version("0.55.3", sha256="2b276df50c5b13ccdbfb14d3333141e9e7985aca31b60400b3f3e0be2ee6897e")
-    version("0.55.2", sha256="56244896e56c2b619f819d047b6de412ecc5250975ee8717f1e329113d178e06")
-    version("0.55.1", sha256="c7ebf2fff5934a974c7edd1aebb5fc9c3e1da5ae3184a29581fde917638eea39")
-    version("0.55.0", sha256="9034c943c8cf4d734c0e18e5ba038dd762fcdcc614c45b41703305da8382e90c")
-    version("0.54.3", sha256="c25caff342b5368bfe33fab6108f454fcf12e2f2cef70817205872ddef669e8b")
-    version("0.54.2", sha256="85cafdc70ae7d1d9d506e7356b917c649c4df2077bd6a0382db37648aa4ecbdb")
-    version("0.54.1", sha256="854e8b94ab36e5aece813d2b2aee8a639bd52201dfea50890722ac9128e2f59e")
-    version("0.54.0", sha256="95efdbaa7cb3e915ab9a7b26b1412475398fdc3e834842a780f1646c7764f2d9")
-    version("0.53.2", sha256="eab4f5d5dde12d002b7ddd958a9a0658589b63622b6cea2715e0235b95917888")
-    version("0.49.1", sha256="a944e7f25a2bc8e4ba3502ab5835d8a8b8f2530415c9d6fcffb53e0abaea2ced")
-    version("0.49.0", sha256="11bc959e7173e714e4a4e85dd2bd9d0149b0a51c8ba82d5f44cc63735f603c74")
-    version("0.42.0", sha256="6c318a2da3859326a37f8a380e3c50e97aaabff6990067218dffffea674ed76f")
-    version("0.41.2", sha256="2daf448d3f2479d60e30617451f09bf02d26304dd1bd12ee1de936a53e42c7a4")
-    version("0.41.1", sha256="a48901f02ffeb9ff5cf5361d71b1fca202f9cd72998043ad011fc5de0294cf8b")
+
+    with default_args(deprecated=True):
+        version("1.2.1", sha256="e1f3b32b636cc86496261bd89e63f00f206754697c7069788b62beed5e042713")
+        version("1.2.0", sha256="603489f0aaa6305f806c6cc4a4455a965f22290fc74f65871f589b002110c790")
+        version("1.1.0", sha256="f29a3e14062043d75e82d16f1e41856e6b1ed7a7c016e10c7b13afa7ee6364cc")
+        version("1.0.1", sha256="4ab3a5c0060dc22bdefb04507efc6c38acb910e91bcd467a38e1fa211e5a6cfe")
+        version("1.0.0", sha256="a2ada84d43c7e57400daee80a880a1f5003d062b2cb6c9be1747b0db38f2eb8d")
+        version(
+            "0.64.1", sha256="1d12a4bc1cf3ab18946d12cf0b6452e5254ada1ad50aacc97f87e2cccd7da315"
+        )
+        version(
+            "0.64.0", sha256="6477993d781b6efea93091616a6d6a0766c0e026076dbeb11249bf1c9b49a347"
+        )
+        version(
+            "0.63.3", sha256="7c516c2099b762203e8a0a22412aa465b7396e6f9b1ab728bad6e6db44dc2659"
+        )
+        version(
+            "0.63.2", sha256="023a3f7c74e68991154c3205a6975705861eedbf8130e013d15faa1df1af216e"
+        )
+        version(
+            "0.63.1", sha256="f355829f0e8c714423f03a06604c04c216d4cbe3586f3154cb2181076b19207a"
+        )
+        version(
+            "0.62.2", sha256="97108f4d9bb16bc758c44749bd25ec7d42c6a762961efbed8b7589a2a3551ea6"
+        )
+        version(
+            "0.62.1", sha256="9fb52e66dbc613479a5f70e46cc2e8faf5aa65e09313f2c71fa63b8afd018107"
+        )
+        version(
+            "0.62.0", sha256="72ac3bab701dfd597604de29cc74baaa1cc0ad8ca26ae23d5288de26abfe1c80"
+        )
+        version(
+            "0.61.4", sha256="c9cc34bcb15c19cfd5ee0d7b07111152701f602db2b59ef6b63d3628e0bbe719"
+        )
+        version(
+            "0.61.2", sha256="33cd555314a94d52acfbb3f6f44d4e61c4ad0bfec7acf4301be7e40bb969b3a8"
+        )
+        version(
+            "0.60.3", sha256="6c191a9b4049e0c9a2a7d1275ab635b91f6ffec1912d75df4c5ec6acf35f74fe"
+        )
+        version(
+            "0.60.0", sha256="5672a560fc4094c88ca5b8be0487e099fe84357e5045f5aecf1113084800e6fd"
+        )
+        version(
+            "0.59.2", sha256="e6d5ccd503d41f938f6cfc4dc9e7326ffe28acabe091b1ff0c6535bdf09732dd"
+        )
+        version(
+            "0.59.1", sha256="f256eb15329a6064f8cc1f23b29de1fa8d21e324f939041e1a4efe77cf1362ef"
+        )
+        version(
+            "0.59.0", sha256="fdbbe8ea8a47f9e21cf4f578f85be8ec3d9c030df3d8cb17df1ae59d8683813a"
+        )
+        version(
+            "0.58.2", sha256="58115604dea9c1f70811578df3c210f4d67cf795d21a4418f6e9bb35406953f5"
+        )
+        version(
+            "0.58.1", sha256="78e0f553dd3bc632d5f96ab943b1bbccb599c2c84ff27c5fb7f7fff9c8a3f6b4"
+        )
+        version(
+            "0.58.0", sha256="991b882bfe4d37acc23c064a29ca209458764a580d52f044f3d50055a132bed4"
+        )
+        version(
+            "0.57.2", sha256="cd3773625253df4fd1c380faf03ffae3d02198d6301e7c8bc7bba6c66af66096"
+        )
+        version(
+            "0.57.1", sha256="0c043c9b5350e9087cd4f6becf6c0d10b1d618ca3f919e0dcca2cdf342360d5d"
+        )
+        version(
+            "0.57.0", sha256="fd26a27c1a509240c668ebd29d280649d9239cf8684ead51d5cb499d1e1188bd"
+        )
+        version(
+            "0.56.2", sha256="aaae961c3413033789248ffe6762589e80b6cf487c334d0b808e31a32c48f35f"
+        )
+        version(
+            "0.56.0", sha256="a9ca7adf66dc69fbb7e583f7c7aef16b9fe56ec2874a3d58747e69a3affdf300"
+        )
+        version(
+            "0.55.3", sha256="2b276df50c5b13ccdbfb14d3333141e9e7985aca31b60400b3f3e0be2ee6897e"
+        )
+        version(
+            "0.55.2", sha256="56244896e56c2b619f819d047b6de412ecc5250975ee8717f1e329113d178e06"
+        )
+        version(
+            "0.55.1", sha256="c7ebf2fff5934a974c7edd1aebb5fc9c3e1da5ae3184a29581fde917638eea39"
+        )
+        version(
+            "0.55.0", sha256="9034c943c8cf4d734c0e18e5ba038dd762fcdcc614c45b41703305da8382e90c"
+        )
+        version(
+            "0.54.3", sha256="c25caff342b5368bfe33fab6108f454fcf12e2f2cef70817205872ddef669e8b"
+        )
+        version(
+            "0.54.2", sha256="85cafdc70ae7d1d9d506e7356b917c649c4df2077bd6a0382db37648aa4ecbdb"
+        )
+        version(
+            "0.54.1", sha256="854e8b94ab36e5aece813d2b2aee8a639bd52201dfea50890722ac9128e2f59e"
+        )
+        version(
+            "0.54.0", sha256="95efdbaa7cb3e915ab9a7b26b1412475398fdc3e834842a780f1646c7764f2d9"
+        )
+        version(
+            "0.53.2", sha256="eab4f5d5dde12d002b7ddd958a9a0658589b63622b6cea2715e0235b95917888"
+        )
+        version(
+            "0.49.1", sha256="a944e7f25a2bc8e4ba3502ab5835d8a8b8f2530415c9d6fcffb53e0abaea2ced"
+        )
+        version(
+            "0.49.0", sha256="11bc959e7173e714e4a4e85dd2bd9d0149b0a51c8ba82d5f44cc63735f603c74"
+        )
+        version(
+            "0.42.0", sha256="6c318a2da3859326a37f8a380e3c50e97aaabff6990067218dffffea674ed76f"
+        )
+        version(
+            "0.41.2", sha256="2daf448d3f2479d60e30617451f09bf02d26304dd1bd12ee1de936a53e42c7a4"
+        )
+        version(
+            "0.41.1", sha256="a48901f02ffeb9ff5cf5361d71b1fca202f9cd72998043ad011fc5de0294cf8b"
+        )
 
     depends_on("python@3.7:", when="@0.62.0:", type=("build", "run"))
     depends_on("python@3.6:", when="@0.57.0:", type=("build", "run"))

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

@@ -0,0 +1,30 @@
+# 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)
+
+import os
+
+from spack.package import *
+
+
+class Mpigraph(Package):
+    """LLNL mpigraph"""
+
+    homepage = "https://github.com/LLNL/mpiGraph"
+    git = "https://github.com/LLNL/mpiGraph.git"
+
+    version("main", branch="main")
+
+    depends_on("mpi")
+    maintainers("adammoody", "onewayforever", "rminnich")
+    license("BSD-3-Clause", checked_by="rminnich")
+
+    version("0.0.1")
+
+    depends_on("mpi")
+
+    def install(self, spec, prefix):
+        mkdirp(prefix.bin)
+        make()
+        install("mpiGraph", os.path.join(prefix.bin, "mpiGraph"))

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

@@ -24,7 +24,7 @@ class Ncio(CMakePackage):
     version("1.1.0", sha256="9de05cf3b8b1291010197737666cede3d621605806379b528d2146c4f02d08f6")
     version("1.0.0", sha256="2e2630b26513bf7b0665619c6c3475fe171a9d8b930e9242f5546ddf54749bd4")
 
-    depends_on("fortran", type="build")  # generated
+    depends_on("fortran", type="build")
 
     depends_on("mpi")
     depends_on("netcdf-fortran")
@@ -34,3 +34,7 @@ def setup_run_environment(self, env):
         env.set("NCIO_LIB", lib[0])
         env.set("NCIO_INC", join_path(self.prefix, "include"))
         env.set("NCIO_LIBDIR", lib[0])
+
+    def check(self):
+        with working_dir(self.builder.build_directory):
+            make("test")

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

@@ -28,7 +28,7 @@ class Nemsio(CMakePackage):
     version("2.5.3", sha256="3fe8a781fc96197803d369cafe0138f3a5cbbca9816a7f8fd57567a1719a4d49")
     version("2.5.2", sha256="c59e9379969690de8d030cbf4bbbbe3726faf13c304f3b88b0f6aec1496d2c08")
 
-    depends_on("fortran", type="build")  # generated
+    depends_on("fortran", type="build")
 
     depends_on("bacio")
     depends_on("mpi", when="+mpi")
@@ -46,3 +46,7 @@ def cmake_args(self):
             args.append(self.define("CMAKE_Fortran_COMPILER", self.spec["mpi"].mpifc))
 
         return args
+
+    def check(self):
+        with working_dir(self.builder.build_directory):
+            make("test")

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

@@ -21,6 +21,10 @@ class Nemsiogfs(CMakePackage):
     version("develop", branch="develop")
     version("2.5.3", sha256="bf84206b08c8779787bef33e4aba18404df05f8b2fdd20fc40b3af608ae4b9af")
 
-    depends_on("fortran", type="build")  # generated
+    depends_on("fortran", type="build")
 
     depends_on("nemsio")
+
+    def check(self):
+        with working_dir(self.builder.build_directory):
+            make("test")

var/spack/repos/builtin/packages/omega-h/package.py

@@ -47,8 +47,6 @@ class OmegaH(CMakePackage, CudaPackage):
     version("9.13.14", sha256="f617dfd024c9cc323e56800ca23df3386bfa37e1b9bd378847d1f5d32d2b8e5d")
     version("9.13.13", sha256="753702edf4bda9ae57ea21f09ca071e341604a468d8c86468c9aebba049f581c")
 
-    depends_on("cxx", type="build")  # generated
-
     variant("shared", default=True, description="Build shared libraries")
     variant("mpi", default=True, description="Activates MPI support")
     variant("zlib", default=True, description="Activates ZLib support")
@@ -61,6 +59,9 @@ class OmegaH(CMakePackage, CudaPackage):
     variant("gmsh", default=False, description="Use Gmsh C++ API")
     variant("kokkos", default=False, description="Use Kokkos")
 
+    depends_on("cxx", type="build")
+    depends_on("c", type="build", when="+mpi")
+
     depends_on("gmsh", when="+examples")
     depends_on("gmsh@4.4.1:", when="+gmsh")
     depends_on("mpi", when="+mpi")

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

@@ -570,17 +570,19 @@ def check_install(self):
         # Openblas may pass its own test but still fail to compile Lapack
         # symbols. To make sure we get working Blas and Lapack, do a small
         # test.
-        source_file = join_path(os.path.dirname(self.module.__file__), "test_cblas_dgemm.c")
-        blessed_file = join_path(os.path.dirname(self.module.__file__), "test_cblas_dgemm.output")
+        source_file = join_path(os.path.dirname(self.pkg.module.__file__), "test_cblas_dgemm.c")
+        blessed_file = join_path(
+            os.path.dirname(self.pkg.module.__file__), "test_cblas_dgemm.output"
+        )
 
         include_flags = spec["openblas"].headers.cpp_flags
         link_flags = spec["openblas"].libs.ld_flags
-        if self.compiler.name == "intel":
+        if self.pkg.compiler.name == "intel":
             link_flags += " -lifcore"
         if self.spec.satisfies("threads=pthreads"):
             link_flags += " -lpthread"
         if spec.satisfies("threads=openmp"):
-            link_flags += " -lpthread " + self.compiler.openmp_flag
+            link_flags += " -lpthread " + self.pkg.compiler.openmp_flag
 
         output = compile_c_and_execute(source_file, [include_flags], link_flags.split())
         compare_output_file(output, blessed_file)

var/spack/repos/builtin/packages/openfoam-org/package.py

@@ -106,6 +106,8 @@ class OpenfoamOrg(Package):
     depends_on("zlib-api")
     depends_on("flex")
     depends_on("cmake", type="build")
+    # The setSet tool (removed in version 10) depends on readline
+    depends_on("readline", when="@:9")
 
     # Require scotch with ptscotch - corresponds to standard OpenFOAM setup
     depends_on("scotch~metis+mpi~int64", when="+scotch~int64")

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

@@ -6,24 +6,43 @@
 from spack.package import *
 
 
-class Openslide(AutotoolsPackage):
+class Openslide(AutotoolsPackage, MesonPackage):
     """OpenSlide reads whole slide image files."""
 
     homepage = "https://openslide.org/"
     url = "https://github.com/openslide/openslide/releases/download/v3.4.1/openslide-3.4.1.tar.xz"
 
+    maintainers("ChristopherChristofi")
+
     license("LGPL-2.1-only")
 
+    version("4.0.0", sha256="cc227c44316abb65fb28f1c967706eb7254f91dbfab31e9ae6a48db6cf4ae562")
     version("3.4.1", sha256="9938034dba7f48fadc90a2cdf8cfe94c5613b04098d1348a5ff19da95b990564")
 
-    depends_on("c", type="build")  # generated
+    build_system(
+        conditional("meson", when="@4:"), conditional("autotools", when="@3.4.1"), default="meson"
+    )
 
+    depends_on("c", type="build")
     depends_on("pkgconfig", type="build")
-    depends_on("openjpeg")
-    depends_on("jpeg")
-    depends_on("libtiff")
-    depends_on("libxml2")
-    depends_on("sqlite@3.6:")
-    depends_on("glib")
-    depends_on("cairo+pdf")
+
+    with when("build_system=meson"):
+        depends_on("meson@0.53:", type="build")
+
+    depends_on("cairo+pdf@1.2:")
     depends_on("gdk-pixbuf")
+    depends_on("jpeg")
+    depends_on("libpng")
+    depends_on("libtiff@4.0:")
+    depends_on("libxml2")
+    depends_on("openjpeg@1,2.1:")
+    depends_on("zlib-api")
+
+    with when("@4:"):
+        depends_on("libdicom")
+        depends_on("glib@2.56:")
+        depends_on("sqlite@3.14:")
+
+    with when("@3.4.1"):
+        depends_on("glib@2.16:")
+        depends_on("sqlite@3.6:")

var/spack/repos/builtin/packages/ossp-uuid/package.py

@@ -3,6 +3,8 @@
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
+import sys
+
 from spack.package import *
 
 
@@ -22,7 +24,8 @@ class OsspUuid(AutotoolsPackage):
     depends_on("c", type="build")  # generated
     depends_on("cxx", type="build")  # generated
 
-    provides("uuid")
+    if sys.platform not in ["darwin", "win32"]:
+        provides("uuid")
 
     @property
     def libs(self):

var/spack/repos/builtin/packages/perl-bio-ensembl-funcgen/package.py

@@ -0,0 +1,37 @@
+# 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 PerlBioEnsemblFuncgen(Package):
+    """Ensembl Funcgen Perl API and SQL schema."""
+
+    homepage = "http://ensembl.org/info/docs/api/funcgen/index.html"
+    url = "https://github.com/Ensembl/ensembl-funcgen/archive/release/111.zip"
+
+    maintainers("teaguesterling")
+
+    license("APACHE-2.0", checked_by="teaguesterling")
+
+    version("112", sha256="d7398921779a6865b5e2f0269d51d268f9b8cd96e4ca3577c88e6f34593e683d")
+    version("111", sha256="67b1b7d6efde9e8be7b4ef73c54c0b5e7e3eadcd590a94bc980984514ef746d0")
+    version("110", sha256="c9e85a423a8c8653741aed799aea9762fa1dfb301f50dc11d291925e81d7aeee")
+
+    extends("perl")
+
+    depends_on("perl-role-tiny", type=("build", "run"))
+    depends_on("perl-bio-ensembl")
+
+    variant("sql", default=False, description="Install SQL files")
+    variant("scripts", default=False, description="Install scripts")
+    variant("templates", default=False, description="Install templates")
+
+    def install(self, spec, prefix):
+        install_tree("modules", prefix.lib.perl5)
+        mkdirp(prefix.share.ensembl.variation)
+        for extra in ["sql", "scripts", "templates"]:
+            if spec.satisfies(f"+{extra}"):
+                target = join_path(prefix.share.ensembl, extra)
+                install_tree(extra, target)

var/spack/repos/builtin/packages/perl-bio-ensembl/package.py

@@ -0,0 +1,46 @@
+# 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 PerlBioEnsembl(Package):
+    """The Ensembl Core Perl API and SQL schema"""
+
+    homepage = "https://useast.ensembl.org/info/docs/api/index.html"
+    url = "https://github.com/Ensembl/ensembl/archive/release/111.zip"
+
+    def url_for_version(self, version):
+        return f"https://github.com/Ensembl/ensembl/archive/release/{version.up_to(1)}.zip"
+
+    maintainers("teaguesterling")
+
+    license("APACHE-2.0", checked_by="teaguesterling")
+
+    version("112", sha256="8a6b46840df71c4332d2de6027596ed4417a26111800d7ff0636199363568235")
+    version("111", sha256="346c47c75a6fa8dcfd9f9d22e9f1e0ccc35b2fb99f75980a0c74d892e4ab2b6d")
+    version("110", sha256="fdf725cad1a980ddf900f1af1a72bf1de355f15e408664930ed84aeccfefad15")
+
+    extends("perl")
+
+    variant("sql", default=False, description="Install SQL files")
+    variant("misc_scripts", default=False, description="Install misc Ensembl scripts")
+
+    depends_on("perl-dbi")
+    depends_on("perl-dbd-mysql@:4")
+    depends_on("perl-http-tiny")
+    depends_on("perl-io-compress")
+    depends_on("perl-uri")
+    depends_on("perl-config-inifiles")
+    depends_on("perl-gzip-faster")
+    depends_on("perl-list-moreutils")
+
+    def install(self, spec, prefix):
+        install_tree("modules", prefix.lib.perl5)
+        mkdirp(prefix.share.ensembl)
+        for extra in ["sql", "misc_scripts"]:
+            if spec.satisfies(f"+{extra}"):
+                extra = extra.replace("_", "-")
+                target = join_path(prefix.share.ensembl, extra)
+                install_tree(extra, target)

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

@@ -34,32 +34,13 @@ class Perl(Package):  # Perl doesn't use Autotools, it should subclass Package
     # see https://www.cpan.org/src/README.html for
     # explanation of version numbering scheme
 
-    # Maintenance releases (even numbers, preferred)
-    version(
-        "5.38.2",
-        sha256="a0a31534451eb7b83c7d6594a497543a54d488bc90ca00f5e34762577f40655e",
-        preferred=True,
-    )
-    version(
-        "5.38.0",
-        sha256="213ef58089d2f2c972ea353517dc60ec3656f050dcc027666e118b508423e517",
-        preferred=True,
-    )
-    version(
-        "5.36.3",
-        sha256="f2a1ad88116391a176262dd42dfc52ef22afb40f4c0e9810f15d561e6f1c726a",
-        preferred=True,
-    )
-    version(
-        "5.36.1",
-        sha256="68203665d8ece02988fc77dc92fccbb297a83a4bb4b8d07558442f978da54cc1",
-        preferred=True,
-    )
-    version(
-        "5.36.0",
-        sha256="e26085af8ac396f62add8a533c3a0ea8c8497d836f0689347ac5abd7b7a4e00a",
-        preferred=True,
-    )
+    # Maintenance releases (even numbers)
+    version("5.40.0", sha256="c740348f357396327a9795d3e8323bafd0fe8a5c7835fc1cbaba0cc8dfe7161f")
+    version("5.38.2", sha256="a0a31534451eb7b83c7d6594a497543a54d488bc90ca00f5e34762577f40655e")
+    version("5.38.0", sha256="213ef58089d2f2c972ea353517dc60ec3656f050dcc027666e118b508423e517")
+    version("5.36.3", sha256="f2a1ad88116391a176262dd42dfc52ef22afb40f4c0e9810f15d561e6f1c726a")
+    version("5.36.1", sha256="68203665d8ece02988fc77dc92fccbb297a83a4bb4b8d07558442f978da54cc1")
+    version("5.36.0", sha256="e26085af8ac396f62add8a533c3a0ea8c8497d836f0689347ac5abd7b7a4e00a")
 
     # End of life releases (deprecated)
     version(

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

@@ -19,6 +19,7 @@ class Pika(CMakePackage, CudaPackage, ROCmPackage):
 
     license("BSL-1.0")
 
+    version("0.26.1", sha256="d7cc842238754019abdb536e22325e9a57186cd2ac8cc9c7140a5385f9d730f6")
     version("0.26.0", sha256="bbec5472c71006c1f55e7946c8dc517dae76c41cacb36fa98195312c74a1bb9a")
     version("0.25.0", sha256="6646e12f88049116d84ce0caeedaa039a13caaa0431964caea4660b739767b2e")
     version("0.24.0", sha256="3b97c684107f892a633f598d94bcbd1e238d940e88e1c336f205e81b99326cc3")

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

@@ -27,8 +27,8 @@ class ProdUtil(CMakePackage):
         deprecated=True,
     )
 
-    depends_on("c", type="build")  # generated
-    depends_on("fortran", type="build")  # generated
+    depends_on("c", type="build")
+    depends_on("fortran", type="build")
 
     depends_on("w3nco", when="@1")
     depends_on("w3emc", when="@2:")

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

@@ -15,7 +15,7 @@ class Pthreadpool(CMakePackage):
     license("BSD-2-Clause")
 
     version("master", branch="master")
-    version("2023-08-29", commit="4fe0e1e183925bf8cfa6aae24237e724a96479b8")  # py-torch@2.2
+    version("2023-08-29", commit="4fe0e1e183925bf8cfa6aae24237e724a96479b8")  # py-torch@2.2:
     version("2021-04-13", commit="a134dd5d4cee80cce15db81a72e7f929d71dd413")  # py-torch@1.9:2.1
     version("2020-10-05", commit="fa75e65a58a5c70c09c30d17a1fe1c1dff1093ae")  # py-torch@1.8
     version("2020-06-15", commit="029c88620802e1361ccf41d1970bd5b07fd6b7bb")  # py-torch@1.6:1.7
@@ -23,8 +23,8 @@ class Pthreadpool(CMakePackage):
     version("2018-10-08", commit="13da0b4c21d17f94150713366420baaf1b5a46f4")  # py-torch@1.0:1.4
     version("2018-02-25", commit="2b06b31f6a315162348e1f3c24325eedaf6cc559")  # py-torch@:0.4
 
-    depends_on("c", type="build")  # generated
-    depends_on("cxx", type="build")  # generated
+    depends_on("c", type="build")
+    depends_on("cxx", type="build")
 
     generator("ninja")
     depends_on("cmake@3.5:", type="build")
@@ -54,7 +54,6 @@ class Pthreadpool(CMakePackage):
 
     def cmake_args(self):
         return [
-            self.define("BUILD_SHARED_LIBS", True),
             self.define("FXDIV_SOURCE_DIR", join_path(self.stage.source_path, "deps", "fxdiv")),
             self.define(
                 "GOOGLETEST_SOURCE_DIR", join_path(self.stage.source_path, "deps", "googletest")
@@ -63,6 +62,9 @@ def cmake_args(self):
                 "GOOGLEBENCHMARK_SOURCE_DIR",
                 join_path(self.stage.source_path, "deps", "googlebenchmark"),
             ),
-            self.define("PTHREADPOOL_BUILD_TESTS", self.run_tests),
-            self.define("PTHREADPOOL_BUILD_BENCHMARKS", self.run_tests),
+            # https://github.com/pytorch/pytorch/blob/main/cmake/Dependencies.cmake
+            self.define("PTHREADPOOL_BUILD_TESTS", False),
+            self.define("PTHREADPOOL_BUILD_BENCHMARKS", False),
+            self.define("PTHREADPOOL_LIBRARY_TYPE", "static"),
+            self.define("PTHREADPOOL_ALLOW_DEPRECATED_API", True),
         ]