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

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

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

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

.github/workflows/audit.yaml

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

.github/workflows/build-containers.yml

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

etc/spack/defaults/linux/packages.yaml

@@ -1,3 +0,0 @@
-packages:
-  iconv:
-    require: [libiconv]

etc/spack/defaults/packages.yaml

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

lib/spack/docs/requirements.txt

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

lib/spack/spack/audit.py

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

lib/spack/spack/build_environment.py

@@ -1473,7 +1473,7 @@ def long_message(self):
             out.write("  {0}\n".format(self.log_name))
 
         # Also output the test log path IF it exists
-        if self.context != "test":
+        if self.context != "test" and have_log:
             test_log = join_path(os.path.dirname(self.log_name), spack_install_test_log)
             if os.path.isfile(test_log):
                 out.write("\nSee test log for details:\n")

lib/spack/spack/build_systems/cuda.py

@@ -124,6 +124,8 @@ def cuda_flags(arch_list):
         # minimum supported versions
         conflicts("%gcc@:4", when="+cuda ^cuda@11.0:")
         conflicts("%gcc@:5", when="+cuda ^cuda@11.4:")
+        conflicts("%gcc@:7.2", when="+cuda ^cuda@12.4:")
+        conflicts("%clang@:6", when="+cuda ^cuda@12.2:")
 
         # maximum supported version
         # NOTE:
@@ -211,12 +213,16 @@ def cuda_flags(arch_list):
         conflicts("%intel@19.0:", when="+cuda ^cuda@:10.0")
         conflicts("%intel@19.1:", when="+cuda ^cuda@:10.1")
         conflicts("%intel@19.2:", when="+cuda ^cuda@:11.1.0")
+        conflicts("%intel@2021:", when="+cuda ^cuda@:11.4.0")
 
         # XL is mostly relevant for ppc64le Linux
         conflicts("%xl@:12,14:", when="+cuda ^cuda@:9.1")
         conflicts("%xl@:12,14:15,17:", when="+cuda ^cuda@9.2")
         conflicts("%xl@:12,17:", when="+cuda ^cuda@:11.1.0")
 
+        # PowerPC.
+        conflicts("target=ppc64le", when="+cuda ^cuda@12.5:")
+
         # Darwin.
         # TODO: add missing conflicts for %apple-clang cuda@:10
-        conflicts("platform=darwin", when="+cuda ^cuda@11.0.2: ")
+        conflicts("platform=darwin", when="+cuda ^cuda@11.0.2:")

lib/spack/spack/build_systems/go.py

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

lib/spack/spack/ci.py

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

lib/spack/spack/cmd/__init__.py

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

lib/spack/spack/cmd/dependents.py

@@ -47,16 +47,6 @@ def inverted_dependencies():
     dependents of, e.g., `mpi`, but virtuals are not included as
     actual dependents.
     """
-    dag = {}
-    for pkg_cls in spack.repo.PATH.all_package_classes():
-        dag.setdefault(pkg_cls.name, set())
-        for dep in pkg_cls.dependencies_by_name():
-            deps = [dep]
-
-            # expand virtuals if necessary
-            if spack.repo.PATH.is_virtual(dep):
-                deps += [s.name for s in spack.repo.PATH.providers_for(dep)]
-
     dag = collections.defaultdict(set)
     for pkg_cls in spack.repo.PATH.all_package_classes():
         for _, deps_by_name in pkg_cls.dependencies.items():

lib/spack/spack/cmd/pkg.py

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

lib/spack/spack/compilers/msvc.py

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

lib/spack/spack/directives.py

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

lib/spack/spack/environment/environment.py

@@ -5,6 +5,7 @@
 import collections
 import collections.abc
 import contextlib
+import errno
 import os
 import pathlib
 import re
@@ -788,6 +789,23 @@ def regenerate(self, concrete_roots: List[Spec]) -> None:
         root_dirname = os.path.dirname(self.root)
         tmp_symlink_name = os.path.join(root_dirname, "._view_link")
 
+        # Remove self.root if is it an empty dir, since we need a symlink there. Note that rmdir
+        # fails if self.root is a symlink.
+        try:
+            os.rmdir(self.root)
+        except (FileNotFoundError, NotADirectoryError):
+            pass
+        except OSError as e:
+            if e.errno == errno.ENOTEMPTY:
+                msg = "it is a non-empty directory"
+            elif e.errno == errno.EACCES:
+                msg = "of insufficient permissions"
+            else:
+                raise
+            raise SpackEnvironmentViewError(
+                f"The environment view in {self.root} cannot not be created because {msg}."
+            ) from e
+
         # Create a new view
         try:
             fs.mkdirp(new_root)

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/solver/asp.py

@@ -23,6 +23,7 @@
 
 import llnl.util.lang
 import llnl.util.tty as tty
+from llnl.util.lang import elide_list
 
 import spack
 import spack.binary_distribution
@@ -621,8 +622,9 @@ def _external_config_with_implicit_externals(configuration):
 
 
 class ErrorHandler:
-    def __init__(self, model):
+    def __init__(self, model, input_specs: List[spack.spec.Spec]):
         self.model = model
+        self.input_specs = input_specs
         self.full_model = None
 
     def multiple_values_error(self, attribute, pkg):
@@ -709,12 +711,13 @@ def handle_error(self, msg, *args):
         return msg
 
     def message(self, errors) -> str:
-        messages = [
-            f"  {idx+1: 2}. {self.handle_error(msg, *args)}"
+        input_specs = ", ".join(elide_list([f"`{s}`" for s in self.input_specs], 5))
+        header = f"failed to concretize {input_specs} for the following reasons:"
+        messages = (
+            f"    {idx+1:2}. {self.handle_error(msg, *args)}"
             for idx, (_, msg, args) in enumerate(errors)
-        ]
-        header = "concretization failed for the following reasons:\n"
-        return "\n".join([header] + messages)
+        )
+        return "\n".join((header, *messages))
 
     def raise_if_errors(self):
         initial_error_args = extract_args(self.model, "error")
@@ -750,7 +753,7 @@ def on_model(model):
                 f"unexpected error during concretization [{str(e)}]. "
                 f"Please report a bug at https://github.com/spack/spack/issues"
             )
-            raise spack.error.SpackError(msg)
+            raise spack.error.SpackError(msg) from e
         raise UnsatisfiableSpecError(msg)
 
 
@@ -894,7 +897,7 @@ def on_model(model):
             min_cost, best_model = min(models)
 
             # first check for errors
-            error_handler = ErrorHandler(best_model)
+            error_handler = ErrorHandler(best_model, specs)
             error_handler.raise_if_errors()
 
             # build specs from spec attributes in the model

lib/spack/spack/solver/concretize.lp

@@ -1155,8 +1155,11 @@ target_weight(Target, 0)
 node_target_weight(PackageNode, MinWeight)
  :- attr("node", PackageNode),
     attr("node_target", PackageNode, Target),
+    target(Target),
     MinWeight = #min { Weight : target_weight(Target, Weight) }.
 
+:- attr("node_target", PackageNode, Target), not node_target_weight(PackageNode, _).
+
 % compatibility rules for targets among nodes
 node_target_match(ParentNode, DependencyNode)
   :- attr("depends_on", ParentNode, DependencyNode, Type), Type != "build",

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/store.py

@@ -371,7 +371,6 @@ def use_store(
         data.update(extra_data)
 
     # Swap the store with the one just constructed and return it
-    ensure_singleton_created()
     spack.config.CONFIG.push_scope(
         spack.config.InternalConfigScope(name=scope_name, data={"config": {"install_tree": data}})
     )

lib/spack/spack/subprocess_context.py

@@ -79,9 +79,11 @@ def restore(self):
         self.test_state.restore()
         spack.main.spack_working_dir = self.spack_working_dir
         env = pickle.load(self.serialized_env) if _SERIALIZE else self.env
-        pkg = pickle.load(self.serialized_pkg) if _SERIALIZE else self.pkg
         if env:
             spack.environment.activate(env)
+        # Order of operation is important, since the package might be retrieved
+        # from a repo defined within the environment configuration
+        pkg = pickle.load(self.serialized_pkg) if _SERIALIZE else self.pkg
         return pkg
 
 

lib/spack/spack/test/bootstrap.py

@@ -228,3 +228,25 @@ def test_source_is_disabled(mutable_config):
     spack.config.add("bootstrap:trusted:{0}:{1}".format(conf["name"], False))
     with pytest.raises(ValueError):
         spack.bootstrap.core.source_is_enabled_or_raise(conf)
+
+
+@pytest.mark.regression("45247")
+def test_use_store_does_not_try_writing_outside_root(tmp_path, monkeypatch, mutable_config):
+    """Tests that when we use the 'use_store' context manager, there is no attempt at creating
+    a Store outside the given root.
+    """
+    initial_store = mutable_config.get("config:install_tree:root")
+    user_store = tmp_path / "store"
+
+    fn = spack.store.Store.__init__
+
+    def _checked_init(self, root, *args, **kwargs):
+        fn(self, root, *args, **kwargs)
+        assert self.root == str(user_store)
+
+    monkeypatch.setattr(spack.store.Store, "__init__", _checked_init)
+
+    spack.store.reinitialize()
+    with spack.store.use_store(user_store):
+        assert spack.config.CONFIG.get("config:install_tree:root") == str(user_store)
+    assert spack.config.CONFIG.get("config:install_tree:root") == initial_store

lib/spack/spack/test/cmd/checksum.py

@@ -83,7 +83,6 @@ def test_checksum_args(arguments, expected):
     assert check == expected
 
 
-@pytest.mark.not_on_windows("Not supported on Windows (yet)")
 @pytest.mark.parametrize(
     "arguments,expected",
     [

lib/spack/spack/test/cmd/deprecate.py

@@ -14,8 +14,6 @@
 deprecate = SpackCommand("deprecate")
 find = SpackCommand("find")
 
-pytestmark = pytest.mark.not_on_windows("does not run on windows")
-
 
 def test_deprecate(mock_packages, mock_archive, mock_fetch, install_mockery):
     install("libelf@0.8.13")

lib/spack/spack/test/cmd/diff.py

@@ -181,7 +181,6 @@ def test_diff_cmd(install_mockery, mock_fetch, mock_archive, mock_packages):
     assert ["hash", "mpileaks %s" % specB.dag_hash()] in c["b_not_a"]
 
 
-@pytest.mark.not_on_windows("Not supported on Windows (yet)")
 def test_load_first(install_mockery, mock_fetch, mock_archive, mock_packages):
     """Test with and without the --first option"""
     install_cmd("mpileaks")

lib/spack/spack/test/cmd/location.py

@@ -3,7 +3,6 @@
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
-import os
 import shutil
 
 import pytest
@@ -16,10 +15,8 @@
 from spack.main import SpackCommand, SpackCommandError
 
 # Everything here uses (or can use) the mock config and database.
-pytestmark = [
-    pytest.mark.usefixtures("mutable_config", "mutable_database"),
-    pytest.mark.not_on_windows("does not run on windows"),
-]
+pytestmark = [pytest.mark.usefixtures("mutable_config", "mutable_database")]
+
 # location prints out "locations of packages and spack directories"
 location = SpackCommand("location")
 env = SpackCommand("env")
@@ -65,7 +62,7 @@ def test_location_source_dir_missing():
     prefix = "==> Error: "
     expected = (
         "%sSource directory does not exist yet. Run this to create it:"
-        "%s  spack stage %s" % (prefix, os.linesep, spec)
+        "%s  spack stage %s" % (prefix, "\n", spec)
     )
     out = location("--source-dir", spec, fail_on_error=False).strip()
     assert out == expected
@@ -126,6 +123,7 @@ def test_location_env_missing():
 
 
 @pytest.mark.db
+@pytest.mark.not_on_windows("Broken on Windows")
 def test_location_install_dir(mock_spec):
     """Tests spack location --install-dir."""
     spec, _ = mock_spec

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

@@ -10,8 +10,6 @@
 
 providers = SpackCommand("providers")
 
-pytestmark = pytest.mark.not_on_windows("Providers not currently supported on Windows")
-
 
 @pytest.mark.parametrize(
     "pkg",

lib/spack/spack/test/cmd/reindex.py

@@ -4,8 +4,6 @@
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 import os
 
-import pytest
-
 import spack.store
 from spack.main import SpackCommand
 
@@ -13,8 +11,6 @@
 deprecate = SpackCommand("deprecate")
 reindex = SpackCommand("reindex")
 
-pytestmark = pytest.mark.not_on_windows("does not run on windows")
-
 
 def test_reindex_basic(mock_packages, mock_archive, mock_fetch, install_mockery):
     install("libelf@0.8.13")

lib/spack/spack/test/cmd/stage.py

@@ -22,7 +22,6 @@
 pytestmark = pytest.mark.usefixtures("install_mockery", "mock_packages")
 
 
-@pytest.mark.not_on_windows("not implemented on windows")
 @pytest.mark.disable_clean_stage_check
 def test_stage_spec(monkeypatch):
     """Verify that staging specs works."""
@@ -63,7 +62,6 @@ def test_stage_path_errors_multiple_specs(check_stage_path):
         stage(f"--path={check_stage_path}", "trivial-install-test-package", "mpileaks")
 
 
-@pytest.mark.not_on_windows("not implemented on windows")
 @pytest.mark.disable_clean_stage_check
 def test_stage_with_env_outside_env(mutable_mock_env_path, monkeypatch):
     """Verify that stage concretizes specs not in environment instead of erroring."""
@@ -82,7 +80,6 @@ def fake_stage(pkg, mirror_only=False):
         stage("trivial-install-test-package")
 
 
-@pytest.mark.not_on_windows("not implemented on windows")
 @pytest.mark.disable_clean_stage_check
 def test_stage_with_env_inside_env(mutable_mock_env_path, monkeypatch):
     """Verify that stage filters specs in environment instead of reconcretizing."""
@@ -101,7 +98,6 @@ def fake_stage(pkg, mirror_only=False):
         stage("mpileaks")
 
 
-@pytest.mark.not_on_windows("not implemented on windows")
 @pytest.mark.disable_clean_stage_check
 def test_stage_full_env(mutable_mock_env_path, monkeypatch):
     """Verify that stage filters specs in environment."""

lib/spack/spack/test/cmd/url.py

@@ -3,7 +3,6 @@
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 import re
-import sys
 
 import pytest
 
@@ -117,7 +116,6 @@ def test_url_summary(mock_packages):
     assert out_correct_versions == correct_versions
 
 
-@pytest.mark.skipif(sys.platform.startswith("win"), reason="Unsupported on Windows for now")
 def test_url_stats(capfd, mock_packages):
     with capfd.disabled():
         output = url("stats")

lib/spack/spack/test/env.py

@@ -841,3 +841,28 @@ def test_root_version_weights_for_old_versions(mutable_mock_env_path, mock_packa
 
     assert bowtie.satisfies("@=1.3.0")
     assert gcc.satisfies("@=1.0")
+
+
+def test_env_view_on_empty_dir_is_fine(tmp_path, config, mock_packages, temporary_store):
+    """Tests that creating a view pointing to an empty dir is not an error."""
+    view_dir = tmp_path / "view"
+    view_dir.mkdir()
+    env = ev.create_in_dir(tmp_path, with_view="view")
+    env.add("mpileaks")
+    env.concretize()
+    env.install_all(fake=True)
+    env.regenerate_views()
+    assert view_dir.is_symlink()
+
+
+def test_env_view_on_non_empty_dir_errors(tmp_path, config, mock_packages, temporary_store):
+    """Tests that creating a view pointing to a non-empty dir errors."""
+    view_dir = tmp_path / "view"
+    view_dir.mkdir()
+    (view_dir / "file").write_text("")
+    env = ev.create_in_dir(tmp_path, with_view="view")
+    env.add("mpileaks")
+    env.concretize()
+    env.install_all(fake=True)
+    with pytest.raises(ev.SpackEnvironmentError, match="because it is a non-empty dir"):
+        env.regenerate_views()

lib/spack/spack/test/repo.py

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

lib/spack/spack/test/spec_semantics.py

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

lib/spack/spack/test/spec_syntax.py

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

lib/spack/spack/util/environment.py

@@ -718,9 +718,9 @@ def from_sourcing_file(
                 (default: ``&> /dev/null``)
             concatenate_on_success (str): operator used to execute a command
                 only when the previous command succeeds (default: ``&&``)
-            exclude ([str or re]): ignore any modifications of these
+            exclude ([str or re.Pattern[str]]): ignore any modifications of these
                 variables (default: [])
-            include ([str or re]): always respect modifications of these
+            include ([str or re.Pattern[str]]): always respect modifications of these
                 variables (default: []). Supersedes any excluded variables.
             clean (bool): in addition to removing empty entries,
                 also remove duplicate entries (default: False).

lib/spack/spack/util/executable.py

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

lib/spack/spack/util/unparse/unparser.py

@@ -554,9 +554,7 @@ def visit_FormattedValue(self, node):
 
     def _fstring_JoinedStr(self, node, write):
         for value in node.values:
-            print("   ", value)
             meth = getattr(self, "_fstring_" + type(value).__name__)
-            print(meth)
             meth(value, write)
 
     def _fstring_Str(self, node, write):

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

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

share/spack/gitlab/cloud_pipelines/stacks/aws-pcluster-x86_64_v4/spack.yaml

@@ -7,7 +7,7 @@ spack:
     - lammps %intel
     - mpas-model %intel
     - openfoam %gcc
-    - palace %oneapi
+    - palace %oneapi ^superlu-dist%oneapi # hack: force fortran-rt provider through superlu-dist
     - quantum-espresso %intel
     # - wrf : While building hdf5 cmake errors out with Detecting Fortran/C Interface: Failed to compile
     # Root cause: ifort cannot deal with arbitrarily long file names.

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

@@ -215,9 +215,13 @@ spack:
   # CUDA 75
   - amrex +cuda cuda_arch=75
   - arborx +cuda cuda_arch=75 ^kokkos +wrapper
+  - axom +cuda cuda_arch=75
   - cabana +cuda cuda_arch=75 ^kokkos +wrapper +cuda_lambda +cuda cuda_arch=75
   - caliper +cuda cuda_arch=75
   - chai +cuda cuda_arch=75 ^umpire ~shared
+  - cusz +cuda cuda_arch=75
+  - dealii +cuda cuda_arch=75
+  - ecp-data-vis-sdk +adios2 +hdf5 +vtkm +zfp ~paraview +cuda cuda_arch=75  # # +paraview: job killed oom?
   - flecsi +cuda cuda_arch=75
   - ginkgo +cuda cuda_arch=75
   - gromacs +cuda cuda_arch=75
@@ -232,8 +236,10 @@ spack:
   - omega-h +cuda cuda_arch=75
   - parsec +cuda cuda_arch=75
   - petsc +cuda cuda_arch=75
+  - py-torch +cuda cuda_arch=75
   - raja +cuda cuda_arch=75
   - slate +cuda cuda_arch=75
+  - slepc +cuda cuda_arch=75
   - strumpack ~slate +cuda cuda_arch=75
   - sundials +cuda cuda_arch=75
   - superlu-dist +cuda cuda_arch=75
@@ -246,25 +252,23 @@ spack:
   - vtk-m +cuda cuda_arch=75
   - zfp +cuda cuda_arch=75
   # --
-  # - axom +cuda cuda_arch=75         # axom: https://github.com/spack/spack/issues/29520
   # - cp2k +mpi +cuda cuda_arch=75    # cp2k: cp2k only supports cuda_arch ('35', '37', '60', '70', '80')
-  # - cusz +cuda cuda_arch=75         # cusz: https://github.com/spack/spack/issues/38787
-  # - dealii +cuda cuda_arch=75       # slepc: make[1]: *** internal error: invalid --jobserver-auth string 'fifo:/tmp/GMfifo1313'.
-  # - ecp-data-vis-sdk +adios2 +hdf5 +vtkm +zfp +paraview +cuda cuda_arch=75  # embree: https://github.com/spack/spack/issues/39534
   # - lammps +cuda cuda_arch=75       # lammps: needs NVIDIA driver
-  # - lbann +cuda cuda_arch=75        # lbann: https://github.com/spack/spack/issues/38788
+  # - lbann +cuda cuda_arch=75        # aluminum: include/aluminum/base.hpp:53: multiple definition of `cub::CUB_200400___CUDA_ARCH_LIST___NS::Debug(cudaError,char const*, int)'; lbann: https://github.com/spack/spack/issues/38788
   # - libpressio +bitgrooming +bzip2 +fpzip +hdf5 +libdistributed +lua +openmp +python +sz +sz3 +unix +zfp +json +remote +netcdf ~cusz +mgard +cuda cuda_arch=75 # libpressio: CMake Error at CMakeLists.txt:498 (find_library): Could not find CUFile_LIBRARY using the following names: cufile ; +cusz: https://github.com/spack/spack/issues/38787
-  # - paraview +cuda cuda_arch=75     # Error building some cuda componets in paraview
-  # - py-torch +cuda cuda_arch=75     # skipped, installed by other means
-  # - slepc +cuda cuda_arch=75        # slepc: make[1]: *** internal error: invalid --jobserver-auth string 'fifo:/tmp/GMfifo1313'.
+  # - paraview +cuda cuda_arch=75     # paraview: killed oom?
   # - upcxx +cuda cuda_arch=75        # upcxx: needs NVIDIA driver
 
   # CUDA 80
   - amrex +cuda cuda_arch=80
   - arborx +cuda cuda_arch=80 ^kokkos +wrapper
+  - axom +cuda cuda_arch=80
   - cabana +cuda cuda_arch=80 ^kokkos +wrapper +cuda_lambda +cuda cuda_arch=80
   - caliper +cuda cuda_arch=80
   - chai +cuda cuda_arch=80 ^umpire ~shared
+  - cusz +cuda cuda_arch=80
+  - dealii +cuda cuda_arch=80
+  - ecp-data-vis-sdk +adios2 +hdf5 +vtkm +zfp ~paraview +cuda cuda_arch=80 # +paraview: job killed oom?
   - flecsi +cuda cuda_arch=80
   - ginkgo +cuda cuda_arch=80
   - gromacs +cuda cuda_arch=80
@@ -279,8 +283,10 @@ spack:
   - omega-h +cuda cuda_arch=80
   - parsec +cuda cuda_arch=80
   - petsc +cuda cuda_arch=80
+  - py-torch +cuda cuda_arch=80
   - raja +cuda cuda_arch=80
   - slate +cuda cuda_arch=80
+  - slepc +cuda cuda_arch=80
   - strumpack ~slate +cuda cuda_arch=80
   - sundials +cuda cuda_arch=80
   - superlu-dist +cuda cuda_arch=80
@@ -293,30 +299,27 @@ spack:
   - vtk-m +cuda cuda_arch=80
   - zfp +cuda cuda_arch=80
   # --
-  # - axom +cuda cuda_arch=80         # axom: https://github.com/spack/spack/issues/29520
   # - cp2k +mpi +cuda cuda_arch=80    # cp2k: Error: KeyError: 'Point environment variable LIBSMM_PATH to the absolute path of the libsmm.a file'
-  # - cusz +cuda cuda_arch=80         # cusz: https://github.com/spack/spack/issues/38787
-  # - dealii +cuda cuda_arch=80       # slepc: make[1]: *** internal error: invalid --jobserver-auth string 'fifo:/tmp/GMfifo1313'.
-  # - ecp-data-vis-sdk +adios2 +hdf5 +vtkm +zfp +paraview +cuda cuda_arch=80 # embree: https://github.com/spack/spack/issues/39534
   # - lammps +cuda cuda_arch=80       # lammps: needs NVIDIA driver
-  # - lbann +cuda cuda_arch=80        # lbann: https://github.com/spack/spack/issues/38788
+  # - lbann +cuda cuda_arch=80        # aluminum: include/aluminum/base.hpp:53: multiple definition of `cub::CUB_200400___CUDA_ARCH_LIST___NS::Debug(cudaError,char const*, int)'; lbann: https://github.com/spack/spack/issues/38788
   # - libpressio +bitgrooming +bzip2 +fpzip +hdf5 +libdistributed +lua +openmp +python +sz +sz3 +unix +zfp +json +remote +netcdf ~cusz +mgard +cuda cuda_arch=80 # libpressio: CMake Error at CMakeLists.txt:498 (find_library): Could not find CUFile_LIBRARY using the following names: cufile ; +cusz: https://github.com/spack/spack/issues/38787
-  # - paraview +cuda cuda_arch=80     # Error building some cuda componets in paraview
-  # - py-torch +cuda cuda_arch=80     # skipped, installed by other means
-  # - slepc +cuda cuda_arch=80        # slepc: make[1]: *** internal error: invalid --jobserver-auth string 'fifo:/tmp/GMfifo1313'.
+  # - paraview +cuda cuda_arch=80     # paraview: killed oom?
   # - upcxx +cuda cuda_arch=80        # upcxx: needs NVIDIA driver
 
   # CUDA 90
   - amrex +cuda cuda_arch=90
   - arborx +cuda cuda_arch=90 ^kokkos +wrapper
+  - axom +cuda cuda_arch=90
   - cabana +cuda cuda_arch=90  ^kokkos +wrapper +cuda_lambda +cuda cuda_arch=90
   - caliper +cuda cuda_arch=90
   - chai +cuda cuda_arch=90 ^umpire ~shared
+  - ecp-data-vis-sdk +adios2 +hdf5 +vtkm +zfp ~paraview +cuda cuda_arch=90 # +paraview: vtkm/exec/cuda/internal/ThrustPatches.h(213): error: this declaration has no storage class or type specifier
   - flecsi +cuda cuda_arch=90
   - ginkgo +cuda cuda_arch=90
   - gromacs +cuda cuda_arch=90
   - heffte +cuda cuda_arch=90
   - hpx +cuda cuda_arch=90
+  - hypre +cuda cuda_arch=90
   - kokkos +wrapper +cuda cuda_arch=90
   - kokkos-kernels +cuda cuda_arch=90 ^kokkos +wrapper +cuda cuda_arch=90
   - magma +cuda cuda_arch=90
@@ -324,11 +327,14 @@ spack:
   - mgard +serial +openmp +timing +unstructured +cuda cuda_arch=90
   - parsec +cuda cuda_arch=90
   - petsc +cuda cuda_arch=90
+  - py-torch +cuda cuda_arch=90
   - raja +cuda cuda_arch=90
   - slate +cuda cuda_arch=90
+  - slepc +cuda cuda_arch=90
   - strumpack ~slate +cuda cuda_arch=90
   - sundials +cuda cuda_arch=90
   - superlu-dist +cuda cuda_arch=90
+  - tasmanian +cuda cuda_arch=90
   - trilinos +cuda cuda_arch=90
   - umpire ~shared +cuda cuda_arch=90
   # INCLUDED IN ECP DAV CUDA
@@ -338,19 +344,13 @@ spack:
   - zfp +cuda cuda_arch=90
   # --
   # - ascent +cuda cuda_arch=90       # ascent: https://github.com/spack/spack/issues/38045
-  # - axom +cuda cuda_arch=90         # axom: https://github.com/spack/spack/issues/29520
   # - cp2k +mpi +cuda cuda_arch=90    # cp2k: cp2k only supports cuda_arch ('35', '37', '60', '70', '80')
-  # - cusz +cuda cuda_arch=90         # cusz: https://github.com/spack/spack/issues/38787
-  # - dealii +cuda cuda_arch=90       # dealii: https://github.com/spack/spack/issues/39532
-  # - ecp-data-vis-sdk +adios2 +hdf5 +vtkm +zfp +paraview +cuda cuda_arch=90 # embree: https://github.com/spack/spack/issues/39534
-  # - hypre +cuda cuda_arch=90        # concretizer: hypre +cuda requires cuda@:11, but cuda_arch=90 requires cuda@12:
+  # - cusz +cuda cuda_arch=90         # cusz: cuda-12.5.1-pil77yk7gsseyqitybr47qmhdtszbcwa/targets/sbsa-linux/include/cub/util_device.cuh:160:63: error: 'blockIdx' was not declared in this scope
+  # - dealii +cuda cuda_arch=90       # dealii: concretize conflict + https://github.com/spack/spack/issues/39532
   # - lammps +cuda cuda_arch=90       # lammps: needs NVIDIA driver
-  # - lbann +cuda cuda_arch=90        # concretizer: Cannot select a single "version" for package "lbann"
+  # - lbann +cuda cuda_arch=90        # aluminum: include/aluminum/base.hpp:53: multiple definition of `cub::CUB_200400___CUDA_ARCH_LIST___NS::Debug(cudaError,char const*, int)'; 
   # - libpressio +bitgrooming +bzip2 +fpzip +hdf5 +libdistributed +lua +openmp +python +sz +sz3 +unix +zfp +json +remote +netcdf ~cusz +mgard +cuda cuda_arch=90 # libpressio: CMake Error at CMakeLists.txt:498 (find_library): Could not find CUFile_LIBRARY using the following names: cufile ; +cusz: https://github.com/spack/spack/issues/38787
   # - omega-h +cuda cuda_arch=90      # omega-h: https://github.com/spack/spack/issues/39535
-  # - py-torch +cuda cuda_arch=90     # skipped, installed by other means
-  # - slepc +cuda cuda_arch=90        # slepc: make[1]: *** internal error: invalid --jobserver-auth string 'fifo:/tmp/GMfifo1313'.
-  # - tasmanian +cuda cuda_arch=90    # tasmanian: conflicts with cuda@12
   # - upcxx +cuda cuda_arch=90        # upcxx: needs NVIDIA driver
 
   ci:

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

@@ -21,7 +21,6 @@ spack:
     gcc-runtime:
       require: "%gcc target=x86_64_v3"
     hdf5:
-      require: "%gcc target=x86_64_v3"
       variants: +fortran +hl +shared
     libfabric:
       variants: fabrics=sockets,tcp,udp,rxm
@@ -68,14 +67,16 @@ spack:
 
   specs:
   # CPU
-  - aml
   - adios
+  - alquimia
+  - aml
   - amrex
   - arborx
   - argobots
   - axom
   - bolt
   - boost
+  - bricks ~cuda
   - butterflypack
   - cabana
   - caliper
@@ -83,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
@@ -107,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
@@ -117,6 +122,7 @@ spack:
   - mercury
   - metall
   - mfem
+  - mgard +serial +openmp +timing +unstructured ~cuda
   - mpark-variant
   - mpifileutils ~xattr
   - nccmp
@@ -126,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
@@ -153,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
@@ -171,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
@@ -233,8 +233,8 @@ spack:
   - upcxx +level_zero
   # --
   # - hpctoolkit +level_zero                                  # dyninst@12.3.0%gcc: /usr/bin/ld: libiberty/./d-demangle.c:142: undefined reference to `_intel_fast_memcpy'; can't mix intel-tbb@%oneapi with dyninst%gcc
-  # - slate +sycl                                             # blaspp: CMake Error at CMakeLists.txt:313 (find_package): ... set MKL_FOUND to FALSE so package "MKL" is considered to be NOT FOUND.
-  # - warpx compute=sycl                                      # warpx: spack-build-wzp6vvo/_deps/fetchedamrex-src/Src/Base/AMReX_RandomEngine.H:18:10: fatal error: 'oneapi/mkl/rng/device.hpp' file not found
+  # - slate +sycl                                             # slate: ifx: error #10426: option '-fopenmp-targets' requires '-fiopenmp'
+  # - warpx compute=sycl                                      # warpx: fetchedamrex-src/Src/Base/AMReX_RandomEngine.H:18:10: fatal error: 'oneapi/mkl/rng/device.hpp' file not found
 
 
   ci:

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

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

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

@@ -185,7 +185,7 @@ spack:
   - sz
   - unifyfs
   - veloc
-  # - visit                           # silo: https://github.com/spack/spack/issues/39538
+  - visit                           # silo: https://github.com/spack/spack/issues/39538
   - vtk-m
   - zfp
   # --
@@ -227,11 +227,11 @@ spack:
   # CUDA 80
   - amrex +cuda cuda_arch=80
   - arborx +cuda cuda_arch=80 ^kokkos +wrapper
+  - axom +cuda cuda_arch=80
   - cabana +cuda cuda_arch=80 ^kokkos +wrapper +cuda_lambda +cuda cuda_arch=80
   - caliper +cuda cuda_arch=80
   - chai +cuda cuda_arch=80 ^umpire ~shared
   - cusz +cuda cuda_arch=80
-  - dealii +cuda cuda_arch=80
   - ecp-data-vis-sdk ~rocm +adios2 ~ascent +hdf5 +vtkm +zfp +paraview +cuda cuda_arch=80 # +ascent fails because fides fetch error
   - exago +mpi +python +raja +hiop ~rocm +cuda cuda_arch=80 ~ipopt ^hiop@1.0.0 ~sparse +mpi +raja ~rocm +cuda cuda_arch=80 #^raja@0.14.0
   - flecsi +cuda cuda_arch=80
@@ -259,109 +259,68 @@ spack:
   - trilinos +cuda cuda_arch=80
   - umpire ~shared +cuda cuda_arch=80
   # INCLUDED IN ECP DAV CUDA
-  # - adios2 +cuda cuda_arch=80
-  # - ascent +cuda cuda_arch=80       # ascent: https://github.com/spack/spack/issues/38045
-  # - paraview +cuda cuda_arch=80
-  # - vtk-m +cuda cuda_arch=80
-  # - zfp +cuda cuda_arch=80
+  - adios2 +cuda cuda_arch=80
+  # - ascent +cuda cuda_arch=80     # ascent: https://github.com/spack/spack/issues/38045
+  - paraview +cuda cuda_arch=80
+  - vtk-m +cuda cuda_arch=80
+  - zfp +cuda cuda_arch=80
   # --
-  # - axom +cuda cuda_arch=80         # axom: https://github.com/spack/spack/issues/29520
-  # - lammps +cuda cuda_arch=80       # lammps: needs NVIDIA driver
-  # - lbann +cuda cuda_arch=80        # lbann: https://github.com/spack/spack/issues/38788
+  # - dealii +cuda cuda_arch=80     # dealii: conflicts with '+cuda ^cuda@12:'
+  # - lammps +cuda cuda_arch=80     # lammps: needs NVIDIA driver
+  # - lbann +cuda cuda_arch=80      # lbann: layers/transform/cereal_registration/../permute/cutensor_support.hpp:95:18: error: 'cutensorInit' was not declared in this scope; did you mean 'cutensorPlan_t'?
   # - mgard +serial +openmp +timing +unstructured +cuda cuda_arch=80 # mgard: https://github.com/spack/spack/issues/44833
-  # - upcxx +cuda cuda_arch=80        # upcxx: needs NVIDIA driver
+  # - upcxx +cuda cuda_arch=80      # upcxx: needs NVIDIA driver
 
-  # # CUDA 90
-  # - amrex +cuda cuda_arch=90
-  # - arborx +cuda cuda_arch=90 ^kokkos +wrapper
-  # - cabana +cuda cuda_arch=90 ^kokkos +wrapper +cuda_lambda +cuda cuda_arch=90
-  # - caliper +cuda cuda_arch=90
-  # - chai +cuda cuda_arch=90 ^umpire ~shared
-  # - cusz +cuda cuda_arch=90
-  # - flecsi +cuda cuda_arch=90
-  # - ginkgo +cuda cuda_arch=90
-  # - gromacs +cuda cuda_arch=90
-  # - heffte +cuda cuda_arch=90
-  # - hpx +cuda cuda_arch=90
-  # - kokkos +wrapper +cuda cuda_arch=90
-  # - kokkos-kernels +cuda cuda_arch=90 ^kokkos +wrapper +cuda cuda_arch=90
-  # - libpressio +bitgrooming +bzip2 +fpzip +hdf5 +libdistributed +lua +openmp +python +sz +sz3 +unix +zfp +json +remote +netcdf +cusz +mgard +cuda cuda_arch=90 ^cusz +cuda cuda_arch=90
-  # - magma +cuda cuda_arch=90
-  # - mfem +cuda cuda_arch=90
-  # - mgard +serial +openmp +timing +unstructured +cuda cuda_arch=90
-  # - parsec +cuda cuda_arch=90
-  # - petsc +cuda cuda_arch=90
-  # - py-torch +cuda cuda_arch=90
-  # - raja +cuda cuda_arch=90
-  # - slate +cuda cuda_arch=90
-  # - slepc +cuda cuda_arch=90
-  # - strumpack ~slate +cuda cuda_arch=90
-  # - sundials +cuda cuda_arch=90
-  # - superlu-dist +cuda cuda_arch=90
-  # - trilinos +cuda cuda_arch=90
-  # - umpire ~shared +cuda cuda_arch=90
-  # # INCLUDED IN ECP DAV CUDA
-  # - adios2 +cuda cuda_arch=90
-  # # - ascent +cuda cuda_arch=90       # ascent: https://github.com/spack/spack/issues/38045
-  # # - paraview +cuda cuda_arch=90     # paraview: InstallError: Incompatible cuda_arch=90
-  # - vtk-m +cuda cuda_arch=90
-  # - zfp +cuda cuda_arch=90
-  # # --
-  # # - axom +cuda cuda_arch=90         # axom: https://github.com/spack/spack/issues/29520
-  # # - dealii +cuda cuda_arch=90       # dealii: https://github.com/spack/spack/issues/39532
-  # # - ecp-data-vis-sdk ~rocm +adios2 +ascent +hdf5 +vtkm +zfp +paraview +cuda cuda_arch=90 # paraview: incompatible cuda_arch; vtk-m: CMake Error at CMake/VTKmWrappers.cmake:413 (message): vtkm_cont needs to be built STATIC as CUDA doesn't support virtual methods across dynamic library boundaries.  You need to set the CMake opt ion BUILD_SHARED_LIBS to `OFF` or (better) turn VTKm_NO_DEPRECATED_VIRTUAL to `ON`.
-  # # - hypre +cuda cuda_arch=90        # concretizer: hypre +cuda requires cuda@:11, but cuda_arch=90 requires cuda@12:
-  # # - lammps +cuda cuda_arch=90       # lammps: needs NVIDIA driver
-  # # - lbann +cuda cuda_arch=90        # concretizer: Cannot select a single "version" for package "lbann"
-  # # - omega-h +cuda cuda_arch=90      # omega-h: https://github.com/spack/spack/issues/39535
-  # # - tasmanian +cuda cuda_arch=90    # tasmanian: conflicts with cuda@12
-  # # - upcxx +cuda cuda_arch=90        # upcxx: needs NVIDIA driver
+  # CUDA 90
+  - amrex +cuda cuda_arch=90
+  - arborx +cuda cuda_arch=90 ^kokkos +wrapper
+  - axom +cuda cuda_arch=90
+  - cabana +cuda cuda_arch=90 ^kokkos +wrapper +cuda_lambda +cuda cuda_arch=90
+  - caliper +cuda cuda_arch=90
+  - chai +cuda cuda_arch=90 ^umpire ~shared
+  - flecsi +cuda cuda_arch=90
+  - ginkgo +cuda cuda_arch=90
+  - gromacs +cuda cuda_arch=90
+  - heffte +cuda cuda_arch=90
+  - hpx +cuda cuda_arch=90
+  - hypre +cuda cuda_arch=90
+  - kokkos +wrapper +cuda cuda_arch=90
+  - kokkos-kernels +cuda cuda_arch=90 ^kokkos +wrapper +cuda cuda_arch=90
+  - magma +cuda cuda_arch=90
+  - mfem +cuda cuda_arch=90
+  - mgard +serial +openmp +timing +unstructured +cuda cuda_arch=90
+  - parsec +cuda cuda_arch=90
+  - petsc +cuda cuda_arch=90
+  - raja +cuda cuda_arch=90
+  - slate +cuda cuda_arch=90
+  - slepc +cuda cuda_arch=90
+  - strumpack ~slate +cuda cuda_arch=90
+  - sundials +cuda cuda_arch=90
+  - superlu-dist +cuda cuda_arch=90
+  - tasmanian +cuda cuda_arch=90
+  - trilinos +cuda cuda_arch=90
+  - umpire ~shared +cuda cuda_arch=90
+  # INCLUDED IN ECP DAV CUDA
+  - adios2 +cuda cuda_arch=90
+  # - ascent +cuda cuda_arch=90       # ascent: https://github.com/spack/spack/issues/38045
+  # - paraview +cuda cuda_arch=90     # paraview: InstallError: Incompatible cuda_arch=90
+  - vtk-m +cuda cuda_arch=90
+  - zfp +cuda cuda_arch=90
+  # --
+  # - cusz +cuda cuda_arch=90         # cusz: cuda-12.5.0-ndrzb7undvancjdj3fi6bhthdxdo7gr5/targets/x86_64-linux/include/cub/util_device.cuh:202:50: error: 'blockDim' was not declared in this scope
+  # - dealii +cuda cuda_arch=90       # dealii: conflicts with '+cuda ^cuda@12:'; dealii: https://github.com/spack/spack/issues/39532
+  # - ecp-data-vis-sdk ~rocm +adios2 +ascent +hdf5 +vtkm +zfp +paraview +cuda cuda_arch=90 # +ascent: # ascent: https://github.com/spack/spack/issues/38045; +paraview: VTK/ThirdParty/vtkm/vtkvtkm/vtk-m/vtkm/exec/cuda/internal/ExecutionPolicy.h(121): error: namespace "thrust" has no member "sort"
+  # - lammps +cuda cuda_arch=90       # lammps: needs NVIDIA driver
+  # - lbann +cuda cuda_arch=90        # aluminum: /usr/include/c++/11/bits/basic_string.h:1260: multiple definition of `cub::CUB_200400___CUDA_ARCH_LIST___NS::Debug(cudaError, char const*, int)'; 
+  # - libpressio +bitgrooming +bzip2 +fpzip +hdf5 +libdistributed +lua +openmp +python +sz +sz3 +unix +zfp +json +remote +netcdf +cusz +mgard +cuda cuda_arch=90 ^cusz +cuda cuda_arch=90 # cusz: cuda-12.5.0-e3rny44pq5z5x3nnoljynbsq5on5fnl3/targets/x86_64-linux/include/cub/util_device.cuh:202:50: error: 'blockDim' was not declared in this scope
+  # - omega-h +cuda cuda_arch=90      # omega-h: https://github.com/spack/spack/issues/39535
+  # - py-torch +cuda cuda_arch=90     # py-torch: FAILED: caffe2/CMakeFiles/torch_cuda.dir/__/aten/src/ATen/native/transformers/cuda/flash_attn/kernels/flash_bwd_hdim256_bf16_sm80.cu.o
+  # - upcxx +cuda cuda_arch=90        # upcxx: needs NVIDIA driver
 
   # ROCM NOARCH
   - hpctoolkit +rocm
   - tau +mpi +rocm +syscall           # tau: has issue with `spack env depfile` build
 
-  # # ROCM 908
-  # - adios2 +kokkos +rocm amdgpu_target=gfx908
-  # - amrex +rocm amdgpu_target=gfx908
-  # - arborx +rocm amdgpu_target=gfx908
-  # - cabana +rocm amdgpu_target=gfx908
-  # - caliper +rocm amdgpu_target=gfx908
-  # - chai +rocm amdgpu_target=gfx908
-  # - ecp-data-vis-sdk +paraview +vtkm +rocm amdgpu_target=gfx908
-  # - gasnet +rocm amdgpu_target=gfx908
-  # - ginkgo +rocm amdgpu_target=gfx908
-  # - heffte +rocm amdgpu_target=gfx908
-  # - hpx +rocm amdgpu_target=gfx908
-  # - hypre +rocm amdgpu_target=gfx908
-  # - kokkos +rocm amdgpu_target=gfx908
-  # - legion +rocm amdgpu_target=gfx908
-  # - magma ~cuda +rocm amdgpu_target=gfx908
-  # - mfem +rocm amdgpu_target=gfx908
-  # - petsc +rocm amdgpu_target=gfx908
-  # - raja ~openmp +rocm amdgpu_target=gfx908
-  # - slate +rocm amdgpu_target=gfx908
-  # - slepc +rocm amdgpu_target=gfx908 ^petsc +rocm amdgpu_target=gfx908
-  # - strumpack ~slate +rocm amdgpu_target=gfx908
-  # - sundials +rocm amdgpu_target=gfx908
-  # - superlu-dist +rocm amdgpu_target=gfx908
-  # - tasmanian ~openmp +rocm amdgpu_target=gfx908
-  # - 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 +rocm amdgpu_target=gfx908
-  # - umpire +rocm amdgpu_target=gfx908
-  # - upcxx +rocm amdgpu_target=gfx908
-  # # INCLUDED IN ECP DAV ROCM
-  # # - hdf5
-  # # - hdf5-vol-async
-  # # - hdf5-vol-cache
-  # # - hdf5-vol-log
-  # # - libcatalyst
-  # - paraview +rocm amdgpu_target=gfx908
-  # # - vtk-m ~openmp +rocm amdgpu_target=gfx908  # vtk-m: https://github.com/spack/spack/issues/40268
-  # # --
-  # # - exago +mpi +python +raja +hiop +rocm amdgpu_target=gfx908 ~ipopt cxxflags="-Wno-error=non-pod-varargs" ^hiop@1.0.0 ~sparse +mpi +raja +rocm amdgpu_target=gfx908 # hiop: CMake Error at cmake/FindHiopHipLibraries.cmake:23 (find_package)
-  # # - lbann ~cuda +rocm amdgpu_target=gfx908    # aluminum: https://github.com/spack/spack/issues/38807
-  # # - papi +rocm amdgpu_target=gfx908           # papi: https://github.com/spack/spack/issues/27898
-
   # ROCM 90a
   - amrex +rocm amdgpu_target=gfx90a
   - caliper +rocm amdgpu_target=gfx90a
@@ -396,17 +355,17 @@ spack:
   # - arborx +rocm amdgpu_target=gfx90a         # kokkos: https://github.com/spack/spack/issues/44832
   # - cabana +rocm amdgpu_target=gfx90a         # kokkos: https://github.com/spack/spack/issues/44832
   # - exago +mpi +python +raja +hiop +rocm amdgpu_target=gfx90a ~ipopt cxxflags="-Wno-error=non-pod-varargs" ^hiop@1.0.0 ~sparse +mpi +raja +rocm amdgpu_target=gfx90a # hiop: CMake Error at cmake/FindHiopHipLibraries.cmake:23 (find_package)
-  # - kokkos +rocm amdgpu_target=gfx90a # kokkos: https://github.com/spack/spack/issues/44832
+  # - kokkos +rocm amdgpu_target=gfx90a         # kokkos: https://github.com/spack/spack/issues/44832
   # - lbann ~cuda +rocm amdgpu_target=gfx90a    # aluminum: https://github.com/spack/spack/issues/38807
   # - legion +rocm amdgpu_target=gfx90a         # kokkos: https://github.com/spack/spack/issues/44832
   # - papi +rocm amdgpu_target=gfx90a           # papi: https://github.com/spack/spack/issues/27898
   # - petsc +rocm amdgpu_target=gfx90a          # petsc: https://github.com/spack/spack/issues/44600
   # - slepc +rocm amdgpu_target=gfx90a ^petsc +rocm amdgpu_target=gfx90a # petsc: https://github.com/spack/spack/issues/44600
 
-  # - cp2k +mpi +cuda cuda_arch=80    # cp2k: spack-stage-libxsmm-1.17-ml4asr3rsb5biw34x6m764cbrp3zrwyk/spack-src/./src/libxsmm_gemm.c:223: undefined reference to `dgemv_'
-  # - cp2k +mpi +cuda cuda_arch=90 # cp2k: cp2k only supports cuda_arch ('35', '37', '60', '70', '80')
-  # - cp2k +mpi +rocm amdgpu_target=gfx908 # cp2k: Error: KeyError: 'No spec with name rocm in... "-L{}".format(spec["rocm"].libs.directories[0]),
-  # - cp2k +mpi +rocm amdgpu_target=gfx90a # cp2k: Error: KeyError: 'No spec with name rocm in... "-L{}".format(spec["rocm"].libs.directories[0]),
+  # - cp2k +mpi +cuda cuda_arch=80              # cp2k: spack-stage-libxsmm-1.17-r2zqxa24bhufaj5i3ili5se25cw7tioo/spack-src/./src/libxsmm_gemm.c:238: undefined reference to `sgemv_'
+  # - cp2k +mpi +cuda cuda_arch=90              # cp2k: cp2k only supports cuda_arch ('35', '37', '60', '70', '80')
+  # - cp2k +mpi +rocm amdgpu_target=gfx908      # cp2k: "-L{}".format(spec["rocm"].libs.directories[0]),
+  # - cp2k +mpi +rocm amdgpu_target=gfx90a      # cp2k: "-L{}".format(spec["rocm"].libs.directories[0]),
 
   ci:
     pipeline-gen:

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

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

var/spack/repos/builtin/packages/3proxy/package.py

@@ -18,6 +18,8 @@ class _3proxy(MakefilePackage):
     version("0.8.12", sha256="c2ad3798b4f0df06cfcc7b49f658304e451d60e4834e2705ef83ddb85a03f849")
     version("0.8.11", sha256="fc4295e1a462baa61977fcc21747db7861c4e3d0dcca86cbaa3e06017e5c66c9")
 
+    depends_on("c", type="build")  # generated
+
     depends_on("autoconf", type="build")
     depends_on("automake", type="build")
     depends_on("libtool", type="build")

var/spack/repos/builtin/packages/7zip/package.py

@@ -25,6 +25,9 @@ class _7zip(SourceforgePackage, Package):
 
     version("21.07", sha256="213d594407cb8efcba36610b152ca4921eda14163310b43903d13e68313e1e39")
 
+    depends_on("c", type="build")  # generated
+    depends_on("cxx", type="build")  # generated
+
     variant(
         "link_type",
         default="shared",

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

@@ -29,6 +29,9 @@ class Abacus(MakefilePackage):
     version("2.2.1", sha256="14feca1d8d1ce025d3f263b85ebfbebc1a1efff704b6490e95b07603c55c1d63")
     version("2.2.0", sha256="09d4a2508d903121d29813a85791eeb3a905acbe1c5664b8a88903f8eda64b8f")
 
+    depends_on("c", type="build")  # generated
+    depends_on("cxx", type="build")  # generated
+
     variant("openmp", default=True, description="Enable OpenMP support")
 
     depends_on("elpa+openmp", when="+openmp")
@@ -43,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/abduco/package.py

@@ -22,5 +22,7 @@ class Abduco(MakefilePackage):
     version("0.5", sha256="bf22226a4488355a7001a5dabbd1e8e3b7e7645efd1519274b956fcb8bcff086")
     version("0.4", sha256="bda3729df116ce41f9a087188d71d934da2693ffb1ebcf33b803055eb478bcbb")
 
+    depends_on("c", type="build")  # generated
+
     def install(self, spec, prefix):
         make(f"PREFIX={prefix}", "install")

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

@@ -25,10 +25,11 @@ class Abinit(AutotoolsPackage):
     """
 
     homepage = "https://www.abinit.org/"
-    url = "https://www.abinit.org/sites/default/files/packages/abinit-8.6.3.tar.gz"
+    url = "https://www.abinit.org/sites/default/files/packages/abinit-10.0.7.tar.gz"
     license("Apache-2.0")
 
     maintainers("downloadico")
+    version("10.0.7", sha256="a9fc044b33861b7defd50fafd19a73eb6f225e18ae30b23bc731d9c8009c881c")
     version("9.10.5", sha256="a9e0f0e058baa6088ea93d26ada369ccf0fe52dc9d4a865b1c38c20620148cd5")
     version("9.10.3", sha256="3f2a9aebbf1fee9855a09dd687f88d2317b8b8e04f97b2628ab96fb898dce49b")
     version("9.8.4", sha256="a086d5045f0093b432e6a044d5f71f7edf5a41a62d67b3677cb0751d330c564a")
@@ -43,6 +44,10 @@ class Abinit(AutotoolsPackage):
     # Versions before 8.0.8b are not supported.
     version("8.0.8b", sha256="37ad5f0f215d2a36e596383cb6e54de3313842a0390ce8d6b48a423d3ee25af2")
 
+    depends_on("c", type="build")  # generated
+    depends_on("cxx", type="build")  # generated
+    depends_on("fortran", type="build")  # generated
+
     variant("mpi", default=True, description="Builds with MPI support. Requires MPI2+")
     variant("openmp", default=False, description="Enables OpenMP threads. Use threaded FFTW3")
     variant("scalapack", default=False, description="Enables scalapack support. Requires MPI")
@@ -126,7 +131,7 @@ class Abinit(AutotoolsPackage):
     )
 
     patch("rm_march_settings.patch", when="@:8")
-    patch("rm_march_settings_v9.patch", when="@9:")
+    patch("rm_march_settings_v9.patch", when="@9")
 
     # Fix detection of Fujitsu compiler
     # Fix configure not to collect the option that causes an error
@@ -141,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}")
@@ -169,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}")
@@ -187,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")
@@ -208,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}")
@@ -230,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}")
@@ -266,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}",
@@ -280,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
@@ -313,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
@@ -328,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/abseil-cpp/package.py

@@ -66,6 +66,15 @@ class AbseilCpp(CMakePackage):
     version("20181200", sha256="e2b53bfb685f5d4130b84c4f3050c81bf48c497614dc85d91dbd3ed9129bce6d")
     version("20180600", sha256="794d483dd9a19c43dc1fbbe284ce8956eb7f2600ef350dac4c602f9b4eb26e90")
 
+    depends_on("cxx", type="build")  # generated
+
+    # Avoid export of testonly target absl::test_allocator in CMake builds
+    patch(
+        "https://github.com/abseil/abseil-cpp/commit/779a3565ac6c5b69dd1ab9183e500a27633117d5.patch?full_index=1",
+        sha256="14ad7abbc20b10d57e00d0940e8338f69fd69f58d8285214848998e8687688cc",
+        when="@20240116",
+    )
+
     variant("shared", default=True, description="Build shared instead of static libraries")
 
     conflicts("+shared", when="@:20190808")

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

@@ -36,6 +36,9 @@ class Abyss(AutotoolsPackage):
     version("2.0.2", sha256="d87b76edeac3a6fb48f24a1d63f243d8278a324c9a5eb29027b640f7089422df")
     version("1.5.2", sha256="8a52387f963afb7b63db4c9b81c053ed83956ea0a3981edcad554a895adf84b1")
 
+    depends_on("c", type="build")  # generated
+    depends_on("cxx", type="build")  # generated
+
     variant(
         "maxk", default=128, values=is_multiple_32, description="set the maximum k-mer length."
     )

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

@@ -18,6 +18,8 @@ class Accfft(CMakePackage, CudaPackage):
 
     version("develop", branch="master")
 
+    depends_on("cxx", type="build")  # generated
+
     variant("pnetcdf", default=True, description="Add support for parallel NetCDF")
     variant("shared", default=True, description="Enables the build of shared libraries")
 
@@ -40,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/acct/package.py

@@ -18,6 +18,9 @@ class Acct(AutotoolsPackage):
     version("6.6.3", sha256="5eae79323bf1ce403704d2b70483c46e7c853276ee7b5ad561ec3ccae9fca093")
     version("6.6.2", sha256="8ed47b2f893b08f0d67720880adbb48b835a826c314fa52fd52af1cee6870101")
 
+    depends_on("c", type="build")  # generated
+    depends_on("cxx", type="build")  # generated
+
     def setup_run_environment(self, env):
         env.prepend_path("PATH", self.prefix.sbin)
 

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

@@ -21,5 +21,8 @@ class Accumulo(MavenPackage):
     version("1.9.3", sha256="d9548d5b9cf9f494f027f0fe59d5d6d45d09064359d7761cade62991ce2a5d0c")
     version("1.9.2", sha256="11ab028143ad6313cd5fc701b36b4c35e46a4a3fa2ce663869860b9f6bf5ee4d")
 
+    depends_on("c", type="build")  # generated
+    depends_on("cxx", type="build")  # generated
+
     depends_on("java@8:", type=("build", "run"))
     depends_on("maven@3.5.0:", type="build")

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

@@ -26,6 +26,9 @@ class Ace(MakefilePackage):
     version("6.5.1", sha256="1f318adadb19da23c9be570a9c600a330056b18950fe0bf0eb1cf5cac8b72a32")
     version("6.5.0", sha256="b6f9ec922fbdcecb4348e16d851d0d1f135df1836dfe77d2e0b64295ddb83066")
 
+    depends_on("c", type="build")  # generated
+    depends_on("cxx", type="build")  # generated
+
     def edit(self, spec, prefix):
         # Dictionary mapping: compiler-name : ACE config-label
         supported = {"intel": "_icc", "gcc": ""}

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

@@ -21,6 +21,8 @@ class Acl(AutotoolsPackage):
     version("2.2.49", sha256="c6e01460cac4e47673dd60a7f57b970b49f6998bb564eff141cca129aa8940d1")
     version("2.2.48", sha256="877eaeccc1500baec58391935b46ac7dfc5ffd8c54fbc0385ccd8b2b18ac3fa6")
 
+    depends_on("c", type="build")  # generated
+
     depends_on("m4", type="build")
     depends_on("autoconf", type="build")
     depends_on("automake", type="build")

var/spack/repos/builtin/packages/acpica-tools/package.py

@@ -15,6 +15,8 @@ class AcpicaTools(MakefilePackage):
     version("20200528", sha256="07cd3e370b695ab787d25a7165e37eb7b150dca7908f047a6a6486d216cf05a8")
     version("20200430", sha256="e3118583bf6e4bb4745d642a863cce1b4fcfdf67558e4ae53df367b7e26b89ac")
 
+    depends_on("c", type="build")  # generated
+
     depends_on("flex", type="build")
     depends_on("bison", type="build")
 

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

@@ -24,6 +24,8 @@ class Acpid(AutotoolsPackage):
     version("2.0.25", sha256="947d2e4f9b2d61a728ce5d6139901f1b666dcef5e2a48833cb33d82895e261cf")
     version("2.0.24", sha256="05903901369c4ebea1d24e445b4a1d516dd3b07e7864cc752a2d09b4147e1985")
 
+    depends_on("c", type="build")  # generated
+
     depends_on("autoconf", type="build")
     depends_on("automake", type="build")
     depends_on("libtool", type="build")

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

@@ -26,6 +26,8 @@ class Activemq(Package):
         deprecated=True,
     )
 
+    depends_on("cxx", type="build")  # generated
+
     depends_on("java")
 
     def install(self, spec, prefix):

var/spack/repos/builtin/packages/acts-algebra-plugins/package.py

@@ -19,6 +19,8 @@ class ActsAlgebraPlugins(CMakePackage):
 
     version("0.24.0", sha256="f44753e62b1ba29c28ab86b282ab67ac6028a0f9fe41e599b7fc6fc50b586b62")
 
+    depends_on("cxx", type="build")  # generated
+
     variant(
         "cxxstd",
         default="17",

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

@@ -17,4 +17,6 @@ class ActsDd4hep(CMakePackage):
     version("1.0.1", sha256="e40f34ebc30b3c33a6802c9d94136e65072d8dcee0b7db57a645f08a64ea5334")
     version("1.0.0", sha256="991f996944c88efa837880f919239e50d12c5c9361e220bc9422438dd608308c")
 
+    depends_on("cxx", type="build")  # generated
+
     depends_on("dd4hep@1.11: +dddetectors")

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

@@ -180,6 +180,8 @@ class Acts(CMakePackage, CudaPackage):
     version("0.08.1", commit="289bdcc320f0b3ff1d792e29e462ec2d3ea15df6")
     version("0.08.0", commit="99eedb38f305e3a1cd99d9b4473241b7cd641fa9")
 
+    depends_on("cxx", type="build")  # generated
+
     # Variants that affect the core Acts library
     variant(
         "benchmarks", default=False, description="Build the performance benchmarks", when="@0.16:"
@@ -351,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")
@@ -489,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/additivefoam/package.py

@@ -25,6 +25,8 @@ class Additivefoam(Package):
     version("main", branch="main")
     version("1.0.0", sha256="abbdf1b0230cd2f26f526be76e973f508978611f404fe8ec4ecdd7d5df88724c")
 
+    depends_on("cxx", type="build")  # generated
+
     depends_on("openfoam-org@10")
 
     common = ["spack-derived-Allwmake"]

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

@@ -18,5 +18,7 @@ class Addrwatch(AutotoolsPackage):
     version("1.0.2", sha256="f04e143da881cd63c299125b592cfb85e4812abbd146f419a1894c00f2ae6208")
     version("1.0.1", sha256="f772b62b1c6570b577473e7c98614dad1124352b377324cbebb36360d8f4ce5a")
 
+    depends_on("c", type="build")  # generated
+
     depends_on("libevent")
     depends_on("libpcap")

var/spack/repos/builtin/packages/adept-utils/package.py

@@ -15,6 +15,9 @@ class AdeptUtils(CMakePackage):
     version("1.0.1", sha256="259f777aeb368ede3583d3617bb779f0fde778319bf2122fdd216bdf223c015e")
     version("1.0", sha256="fed29366c9bcf5f3799220ae3b351d2cb338e2aa42133d61584ea650aa8d6ff7")
 
+    depends_on("c", type="build")  # generated
+    depends_on("cxx", type="build")  # generated
+
     depends_on("boost@:1.72.0")
     depends_on("mpi")
     depends_on("cmake@2.8:", type="build")

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

@@ -34,6 +34,10 @@ class Adiak(CMakePackage):
     version("0.2.1", commit="950e3bfb91519ecb7b7ee7fa3063bfab23c0e2c9", submodules=True)
     version("0.1.1", sha256="438e4652e15e206cd0019423d829fd4f2329323ff0c8861d9586bae051d9624b")
 
+    depends_on("c", type="build")  # generated
+    depends_on("cxx", type="build")  # generated
+    depends_on("fortran", type="build")  # generated
+
     depends_on("mpi", when="+mpi")
 
     def cmake_args(self):

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

@@ -28,6 +28,10 @@ class Adios(AutotoolsPackage):
     version("1.10.0", sha256="6713069259ee7bfd4d03f47640bf841874e9114bab24e7b0c58e310c42a0ec48")
     version("1.9.0", sha256="23b2bb70540d51ab0855af0b205ca484fd1bd963c39580c29e3133f9e6fffd46")
 
+    depends_on("c", type="build")  # generated
+    depends_on("cxx", type="build")  # generated
+    depends_on("fortran", type="build")  # generated
+
     variant("shared", default=True, description="Builds a shared version of the library")
 
     variant("fortran", default=False, description="Enable Fortran bindings support")
@@ -140,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

@@ -45,6 +45,10 @@ class Adios2(CMakePackage, CudaPackage, ROCmPackage):
     version("2.4.0", sha256="50ecea04b1e41c88835b4b3fd4e7bf0a0a2a3129855c9cc4ba6cf6a1575106e2")
     version("2.3.1", sha256="3bf81ccc20a7f2715935349336a76ba4c8402355e1dc3848fcd6f4c3c5931893")
 
+    depends_on("c", type="build")  # generated
+    depends_on("cxx", type="build")  # generated
+    depends_on("fortran", type="build")  # generated
+
     # There's not really any consistency about how static and shared libs are
     # implemented across spack.  What we're trying to support is specifically three
     # library build types:
@@ -288,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
@@ -301,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
@@ -319,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"]:
@@ -338,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(
@@ -387,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/adlbx/package.py

@@ -19,6 +19,8 @@ class Adlbx(AutotoolsPackage):
     version("0.9.2", sha256="524902d648001b689a98492402d754a607b8c1d0734699154063c1a4f3410d4a")
     version("0.9.1", sha256="8913493fe0c097ff13c721ab057514e5bdb55f6318d4e3512692ab739c3190b3")
 
+    depends_on("c", type="build")  # generated
+
     depends_on("exmcutils@master", when="@master")
     depends_on("exmcutils@:0.5.7", when="@:0.9.2")
     depends_on("exmcutils", when="@0.9.1:")

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

@@ -23,6 +23,8 @@ class Admixtools(MakefilePackage):
     version("1.0.1", sha256="ef3afff161e6a24c0857678373138edb1251c24d7b5308a07f10bdb0dedd44d0")
     version("1.0", sha256="cf0d6950285e801e8a99c2a0b3dbbbc941a78e867af1767b1d002ec3f5803c4b")
 
+    depends_on("c", type="build")  # generated
+
     depends_on("lapack")
     depends_on("gsl")
 

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

@@ -23,6 +23,8 @@ class Adms(AutotoolsPackage):
     version("master", branch="master")
     version("2.3.7", sha256="3a78e1283ecdc3f356410474b3ff44c4dcc82cb89772087fd3bbde8a1038ce08")
 
+    depends_on("c", type="build")  # generated
+
     depends_on("bison@2.5:", type="build")
     depends_on("flex", type="build")
     depends_on("perl-xml-libxml", type="build")

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

@@ -30,6 +30,9 @@ class AdolC(AutotoolsPackage):
     version("2.5.1", sha256="dedb93c3bb291366d799014b04b6d1ec63ca4e7216edf16167776c07961e3b4a")
     version("2.5.0", sha256="9d51c426d831884aac8f418be410c001eb62f3a11cb8f30c66af0b842edffb96")
 
+    depends_on("c", type="build")  # generated
+    depends_on("cxx", type="build")  # generated
+
     variant(
         "advanced_branching",
         default=False,
@@ -84,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(
@@ -104,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
@@ -127,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
@@ -145,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/advancecomp/package.py

@@ -22,6 +22,9 @@ class Advancecomp(AutotoolsPackage):
     version("1.23", sha256="fe89d6ab382efc6b6be536b8d58113f36b83d82783d5215c261c14374cba800a")
     version("1.22", sha256="b8c482027a5f78d9a7f871cbba19cc896ed61653d1d93034c9dbe55484952605")
 
+    depends_on("c", type="build")  # generated
+    depends_on("cxx", type="build")  # generated
+
     depends_on("autoconf", type="build")
     depends_on("automake", type="build")
     depends_on("libtool", type="build")

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

@@ -20,6 +20,8 @@ class Aegean(MakefilePackage):
     version("0.16.0", sha256="c6303ec58289f6c7bc4dd0edcd0e6c0bce4d95b21e25386f314f2b5e2f835812")
     version("0.15.2", sha256="734c9dd23ab3415c3966083bfde5fb72c81e6ace84e08ee3fe0d4c338331d975")
 
+    depends_on("c", type="build")  # generated
+
     depends_on("genometools")
 
     def edit(self, spec, prefix):

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

@@ -15,6 +15,8 @@ class Aeskeyfind(MakefilePackage):
 
     version("master", branch="master")
 
+    depends_on("c", type="build")  # generated
+
     def install(self, spec, prefix):
         mkdirp(prefix.bin)
         install("aeskeyfind", prefix.bin)

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

@@ -22,3 +22,5 @@ class Aespipe(AutotoolsPackage):
     version("2.4b", sha256="4f08611966998f66266f03d40d0597f94096164393c8f303b2dfd565e9d9b59d")
     version("2.3e", sha256="4e63a5709fdd0bffdb555582f9fd7a0bd1842e429420159accaf7f60c5d3c70f")
     version("2.3d", sha256="70330cd0710446c9ddf8148a7713fd73f1dc5e0b13fc4d3c75590305b2e3f008")
+
+    depends_on("c", type="build")  # generated

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

@@ -21,6 +21,10 @@ class Agile(AutotoolsPackage):
 
     version("1.5.1", sha256="e38536300060e4b845ccaaed824c7495944f9117a0d7e4ee74a18bf278e2012f")
 
+    depends_on("c", type="build")  # generated
+    depends_on("cxx", type="build")  # generated
+    depends_on("fortran", type="build")  # generated
+
     depends_on("hepmc")
     depends_on("boost")
 

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

@@ -20,6 +20,8 @@ class Agrep(MakefilePackage):
 
     version("3.41", sha256="0508eafaf9725fc67cc955eb6d32ba4f50138443a4fea4275508d2c3f67a234e")
 
+    depends_on("c", type="build")  # generated
+
     def install(self, spec, prefix):
         mkdirp(prefix.bin)
         install("agrep", prefix.bin)

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

@@ -26,6 +26,9 @@ class Akantu(CMakePackage):
     version("master", branch="master")
     version("3.0.0", sha256="7e8f64e25956eba44def1b2d891f6db8ba824e4a82ff0d51d6b585b60ab465db")
 
+    depends_on("c", type="build")  # generated
+    depends_on("cxx", type="build")  # generated
+
     variant(
         "external_solvers",
         values=any_combination_of("mumps", "petsc"),

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

@@ -21,6 +21,8 @@ class Albany(CMakePackage):
 
     version("develop", branch="master")
 
+    depends_on("cxx", type="build")  # generated
+
     variant("lcm", default=True, description="Enable LCM")
     variant("aeras", default=False, description="Enable AERAS")
     variant("qcad", default=False, description="Enable QCAD")

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

@@ -16,6 +16,8 @@ class Albert(MakefilePackage):
     version("4.0a_opt4", sha256="80b9ee774789c9cd123072523cfb693c443c3624708a58a5af177a51f36b2c79")
     version("4.0a", sha256="caf49e24fb9bf2a09053d9bf022c4737ffe61d62ce9c6bc32aa03dded2a14913")
 
+    depends_on("cxx", type="build")  # generated
+
     depends_on("readline")
 
     def install(self, spec, prefix):

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

@@ -21,6 +21,8 @@ class Alembic(CMakePackage):
     version("1.8.5", sha256="180a12f08d391cd89f021f279dbe3b5423b1db751a9898540c8059a45825c2e9")
     version("1.7.16", sha256="2529586c89459af34d27a36ab114ad1d43dafd44061e65cfcfc73b7457379e7c")
 
+    depends_on("cxx", type="build")  # generated
+
     variant("python", default=False, description="Python support")
     variant("hdf5", default=False, description="HDF5 support")
 

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

@@ -21,6 +21,8 @@ class Alglib(MakefilePackage):
     version("3.20.0", sha256="e7357f0f894313ff1b640ec9cb5e8b63f06d2d3411c2143a374aa0e9740da8a9")
     version("3.11.0", sha256="34e391594aac89fb354bdaf58c42849489cd1199197398ba98bb69961f42bdb0")
 
+    depends_on("cxx", type="build")  # generated
+
     build_directory = "src"
 
     def edit(self, spec, prefix):

var/spack/repos/builtin/packages/allpaths-lg/package.py

@@ -15,6 +15,8 @@ class AllpathsLg(AutotoolsPackage):
 
     version("52488", sha256="035b49cb21b871a6b111976757d7aee9c2513dd51af04678f33375e620998542")
 
+    depends_on("cxx", type="build")  # generated
+
     # compiles with gcc 4.7.0 to 4.9.4)
     conflicts("%gcc@:4.6.4,5.1.0:")
     conflicts("%cce")

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

@@ -25,6 +25,8 @@ class Alpaka(CMakePackage, CudaPackage):
     version("0.5.0", sha256="0ba08ea19961dd986160219ba00d6162fe7758980d88a606eff6494d7b3a6cd1")
     version("0.4.0", sha256="ad7905b13c22abcee4344ba225a65078e3f452ad45a9eda907e7d27c08315e46")
 
+    depends_on("cxx", type="build")  # generated
+
     variant(
         "backend",
         multi=True,
@@ -77,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/alquimia/package.py

@@ -24,6 +24,10 @@ class Alquimia(CMakePackage):
     version("xsdk-0.6.0", commit="9a0aedd3a927d4d5e837f8fd18b74ad5a78c3821")
     version("xsdk-0.5.0", commit="8397c3b00a09534c5473ff3ab21f0e32bb159380")
 
+    depends_on("c", type="build")  # generated
+    depends_on("cxx", type="build")  # generated
+    depends_on("fortran", type="build")  # generated
+
     variant("shared", default=True, description="Enables the build of shared libraries")
 
     depends_on("mpi")

var/spack/repos/builtin/packages/alsa-lib/package.py

@@ -20,6 +20,8 @@ class AlsaLib(AutotoolsPackage):
     version("1.2.2", sha256="d8e853d8805574777bbe40937812ad1419c9ea7210e176f0def3e6ed255ab3ec")
     version("1.1.4.1", sha256="91bb870c14d1c7c269213285eeed874fa3d28112077db061a3af8010d0885b76")
 
+    depends_on("c", type="build")  # generated
+
     variant("python", default=False, description="enable python")
 
     patch("python.patch", when="@1.1.4:1.1.5 +python")

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

@@ -33,6 +33,8 @@ class Aluminum(CachedCMakePackage, CudaPackage, ROCmPackage):
     version("1.3.0", sha256="d0442efbebfdfb89eec793ae65eceb8f1ba65afa9f2e48df009f81985a4c27e3")
     version("1.2.3", sha256="9b214bdf30f9b7e8e017f83e6615db6be2631f5be3dd186205dbe3aa62f4018a")
 
+    depends_on("cxx", type="build")  # generated
+
     # Library capabilities
     variant(
         "cuda_rma",

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

@@ -51,6 +51,10 @@ class Amdblis(BlisBase):
     version("3.0", sha256="ac848c040cd6c3550fe49148dbdf109216cad72d3235763ee7ee8134e1528517")
     version("2.2", sha256="e1feb60ac919cf6d233c43c424f6a8a11eab2c62c2c6e3f2652c15ee9063c0c9")
 
+    depends_on("c", type="build")  # generated
+    depends_on("cxx", type="build")  # generated
+    depends_on("fortran", type="build")  # generated
+
     variant("ilp64", default=False, when="@3.0.1:", description="ILP64 support")
     variant("aocl_gemm", default=False, when="@4.1:", description="aocl_gemm support")
     variant("suphandling", default=True, description="Small Unpacked Kernel handling")

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

@@ -54,6 +54,9 @@ class Amdfftw(FftwBase):
     version("3.0", sha256="a69deaf45478a59a69f77c4f7e9872967f1cfe996592dd12beb6318f18ea0bcd")
     version("2.2", sha256="de9d777236fb290c335860b458131678f75aa0799c641490c644c843f0e246f8")
 
+    depends_on("c", type="build")  # generated
+    depends_on("fortran", type="build")  # generated
+
     variant("shared", default=True, description="Builds a shared version of the library")
     variant("openmp", default=True, description="Enable OpenMP support")
     variant("threads", default=False, description="Enable SMP threads support")
@@ -162,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)))
@@ -183,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:
@@ -220,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/amdlibflame/package.py

@@ -62,6 +62,10 @@ class Amdlibflame(CMakePackage, LibflameBase):
     version("3.0", sha256="d94e08b688539748571e6d4c1ec1ce42732eac18bd75de989234983c33f01ced")
     version("2.2", sha256="12b9c1f92d2c2fa637305aaa15cf706652406f210eaa5cbc17aaea9fcfa576dc")
 
+    depends_on("c", type="build")  # generated
+    depends_on("cxx", type="build")  # generated
+    depends_on("fortran", type="build")  # generated
+
     variant("ilp64", default=False, when="@3.0.1: ", description="Build with ILP64 support")
     variant(
         "enable-aocl-blas",

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

@@ -46,6 +46,9 @@ class Amdlibm(SConsPackage):
     version("3.0", sha256="eb26b5e174f43ce083928d0d8748a6d6d74853333bba37d50057aac2bef7c7aa")
     version("2.2", commit="4033e022da428125747e118ccd6fdd9cee21c470")
 
+    depends_on("c", type="build")  # generated
+    depends_on("cxx", type="build")  # generated
+
     variant("verbose", default=False, description="Building with verbosity", when="@:4.1")
 
     # Mandatory dependencies

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

@@ -45,6 +45,9 @@ class Amdscalapack(ScalapackBase):
     version("3.0", sha256="6e6f3578f44a8e64518d276e7580530599ecfa8729f568303ed2590688e7096f")
     version("2.2", sha256="2d64926864fc6d12157b86e3f88eb1a5205e7fc157bf67e7577d0f18b9a7484c")
 
+    depends_on("c", type="build")  # generated
+    depends_on("fortran", type="build")  # generated
+
     variant("ilp64", default=False, description="Build with ILP64 support")
 
     conflicts("+ilp64", when="@:3.0", msg="ILP64 is supported from 3.1 onwards")

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

@@ -30,6 +30,8 @@ class Amdsmi(CMakePackage):
     version("5.5.1", sha256="b794c7fd562fd92f2c9f2bbdc2d5dded7486101fcd4598f2e8c3484c9a939281")
     version("5.5.0", sha256="dcfbd96e93afcf86b1261464e008e9ef7e521670871a1885e6eaffc7cdc8f555")
 
+    depends_on("cxx", type="build")  # generated
+
     depends_on("cmake@3.11:")
     depends_on("python@3.6:")
     depends_on("py-virtualenv")

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

@@ -24,6 +24,8 @@ class Amg2013(MakefilePackage):
     version("1.1", tag="1.1", commit="09fe8a78baf6ba5eaef7d2804f7b653885d60fee")
     version("1.0", tag="1.0", commit="f5b864708ca3ef48a86e1e46fcb812cbbfa80c51")
 
+    depends_on("c", type="build")  # generated
+
     variant("openmp", default=True, description="Build with OpenMP support")
     variant("optflags", default=False, description="Additional optimizations")
     variant("int64", default=False, description="Use 64-bit integers for global variables")
@@ -37,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/amg2023/package.py

@@ -21,6 +21,8 @@ class Amg2023(CMakePackage, CudaPackage, ROCmPackage):
 
     version("develop", branch="main")
 
+    depends_on("c", type="build")  # generated
+
     variant("mpi", default=True, description="Enable MPI support")
     variant("openmp", default=False, description="Enable OpenMP support")
     variant("caliper", default=False, description="Enable Caliper monitoring")

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

@@ -29,6 +29,9 @@ class Amgx(CMakePackage, CudaPackage):
     version("2.0.1", sha256="6f9991f1836fbf4ba2114ce9f49febd0edc069a24f533bd94fd9aa9be72435a7")
     version("2.0.0", sha256="8ec7ea8412be3de216fcf7243c4e2a8bcf76878e6865468e4238630a082a431b")
 
+    depends_on("c", type="build")  # generated
+    depends_on("cxx", type="build")  # generated
+
     variant("cuda", default=True, description="Build with CUDA")
     variant("mpi", default=True, description="Enable MPI support")
     variant("mkl", default=False, description="Enable MKL support")
@@ -42,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":
@@ -50,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/aml/package.py

@@ -41,6 +41,8 @@ class Aml(AutotoolsPackage):
         deprecated=True,
     )
 
+    depends_on("c", type="build")  # generated
+
     # Generate possible variants.
     #############################
 

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))