ccache: set base_dir

.github/workflows/import-check.yaml

@@ -39,7 +39,7 @@ jobs:
       uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
       with:
         repository: haampie/circular-import-fighter
-        ref: 4cdb0bf15f04ab6b49041d5ef1bfd9644cce7f33
+        ref: e38bcd0aa46368e30648b61b7f0d8c1ca68aadff
         path: circular-import-fighter
     - name: Install dependencies
       working-directory: circular-import-fighter

etc/spack/defaults/concretizer.yaml

@@ -63,7 +63,3 @@ concretizer:
   # Setting this to false yields unreproducible results, so we advise to use that value only
   # for debugging purposes (e.g. check which constraints can help Spack concretize faster).
   error_on_timeout: true
-
-  # Static analysis may reduce the concretization time by generating smaller ASP problems, in
-  # cases where there are requirements that prevent part of the search space to be explored.
-  static_analysis: false

etc/spack/defaults/windows/config.yaml

@@ -1,5 +1,5 @@
 config:
   locks: false
   build_stage::
-    - '$user_cache_path/stage'
+    - '$spack/.staging'
   stage_name: '{name}-{version}-{hash:7}'

lib/spack/env/cc

@@ -960,9 +960,6 @@ if [ -n "$SPACK_CCACHE_BINARY" ]; then
     case "$lang_flags" in
         C|CXX)  # ccache only supports C languages
             prepend full_command_list "${SPACK_CCACHE_BINARY}"
-            # workaround for stage being a temp folder
-            # see #3761#issuecomment-294352232
-            export CCACHE_NOHASHDIR=yes
             ;;
     esac
 fi

lib/spack/llnl/util/tty/log.py

@@ -344,6 +344,26 @@ def close(self):
             self.file.close()
 
 
+@contextmanager
+def replace_environment(env):
+    """Replace the current environment (`os.environ`) with `env`.
+
+    If `env` is empty (or None), this unsets all current environment
+    variables.
+    """
+    env = env or {}
+    old_env = os.environ.copy()
+    try:
+        os.environ.clear()
+        for name, val in env.items():
+            os.environ[name] = val
+        yield
+    finally:
+        os.environ.clear()
+        for name, val in old_env.items():
+            os.environ[name] = val
+
+
 def log_output(*args, **kwargs):
     """Context manager that logs its output to a file.
 
@@ -427,6 +447,7 @@ def __init__(
         self.echo = echo
         self.debug = debug
         self.buffer = buffer
+        self.env = env  # the environment to use for _writer_daemon
         self.filter_fn = filter_fn
 
         self._active = False  # used to prevent re-entry
@@ -498,20 +519,21 @@ def __enter__(self):
                 # just don't forward input if this fails
                 pass
 
-            self.process = multiprocessing.Process(
-                target=_writer_daemon,
-                args=(
-                    input_fd,
-                    read_fd,
-                    self.write_fd,
-                    self.echo,
-                    self.log_file,
-                    child_pipe,
-                    self.filter_fn,
-                ),
-            )
-            self.process.daemon = True  # must set before start()
-            self.process.start()
+            with replace_environment(self.env):
+                self.process = multiprocessing.Process(
+                    target=_writer_daemon,
+                    args=(
+                        input_fd,
+                        read_fd,
+                        self.write_fd,
+                        self.echo,
+                        self.log_file,
+                        child_pipe,
+                        self.filter_fn,
+                    ),
+                )
+                self.process.daemon = True  # must set before start()
+                self.process.start()
 
         finally:
             if input_fd:
@@ -707,7 +729,10 @@ class winlog:
     Does not support the use of 'v' toggling as nixlog does.
     """
 
-    def __init__(self, file_like=None, echo=False, debug=0, buffer=False, filter_fn=None):
+    def __init__(
+        self, file_like=None, echo=False, debug=0, buffer=False, env=None, filter_fn=None
+    ):
+        self.env = env
         self.debug = debug
         self.echo = echo
         self.logfile = file_like
@@ -764,10 +789,11 @@ def background_reader(reader, echo_writer, _kill):
                     reader.close()
 
             self._active = True
-            self._thread = Thread(
-                target=background_reader, args=(self.reader, self.echo_writer, self._kill)
-            )
-            self._thread.start()
+            with replace_environment(self.env):
+                self._thread = Thread(
+                    target=background_reader, args=(self.reader, self.echo_writer, self._kill)
+                )
+                self._thread.start()
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):

lib/spack/spack/audit.py

@@ -1010,7 +1010,7 @@ def _issues_in_depends_on_directive(pkgs, error_cls):
             for dep_name, dep in deps_by_name.items():
 
                 def check_virtual_with_variants(spec, msg):
-                    if not spack.repo.PATH.is_virtual(spec.name) or not spec.variants:
+                    if not spec.virtual or not spec.variants:
                         return
                     error = error_cls(
                         f"{pkg_name}: {msg}",

lib/spack/spack/binary_distribution.py

@@ -2529,10 +2529,10 @@ def install_root_node(
         allow_missing: when true, allows installing a node with missing dependencies
     """
     # Early termination
-    if spec.external or not spec.concrete:
-        warnings.warn("Skipping external or abstract spec {0}".format(spec.format()))
+    if spec.external or spec.virtual:
+        warnings.warn("Skipping external or virtual package {0}".format(spec.format()))
         return
-    elif spec.installed and not force:
+    elif spec.concrete and spec.installed and not force:
         warnings.warn("Package for spec {0} already installed.".format(spec.format()))
         return
 

lib/spack/spack/build_environment.py

@@ -610,9 +610,11 @@ def set_wrapper_variables(pkg, env):
     if spack.config.get("config:ccache"):
         # Enable ccache in the compiler wrapper
         env.set(SPACK_CCACHE_BINARY, spack.util.executable.which_string("ccache", required=True))
+        env.set("CCACHE_NOHASHDIR", "")
+        env.set("CCACHE_BASEDIR", os.path.realpath(spack.stage.get_stage_root()))
     else:
         # Avoid cache pollution if a build system forces `ccache <compiler wrapper invocation>`.
-        env.set("CCACHE_DISABLE", "1")
+        env.set("CCACHE_DISABLE", "")
 
     # Gather information about various types of dependencies
     rpath_hashes = set(s.dag_hash() for s in get_rpath_deps(pkg))

lib/spack/spack/build_systems/cmake.py

@@ -11,7 +11,6 @@
 from typing import Any, List, Optional, Tuple
 
 import llnl.util.filesystem as fs
-from llnl.util import tty
 from llnl.util.lang import stable_partition
 
 import spack.builder
@@ -470,11 +469,6 @@ def cmake(
                 configure_artifact = "ninja.build"
 
             if os.path.isfile(os.path.join(self.build_directory, configure_artifact)):
-                tty.msg(
-                    "Incremental build criteria satisfied."
-                    "Skipping CMake configure step. To force configuration run"
-                    f" `spack clean {pkg.name}`"
-                )
                 return
 
         options = self.std_cmake_args

lib/spack/spack/ci/__init__.py

@@ -16,7 +16,6 @@
 from typing import Callable, Dict, List, Set
 from urllib.request import Request
 
-import llnl.path
 import llnl.util.filesystem as fs
 import llnl.util.tty as tty
 from llnl.util.tty.color import cescape, colorize
@@ -84,9 +83,6 @@ def get_stack_changed(env_path, rev1="HEAD^", rev2="HEAD"):
     whether or not the stack was changed.  Returns True if the environment
     manifest changed between the provided revisions (or additionally if the
     `.gitlab-ci.yml` file itself changed).  Returns False otherwise."""
-    # git returns posix paths always, normalize input to be comptaible
-    # with that
-    env_path = llnl.path.convert_to_posix_path(env_path)
     git = spack.util.git.git()
     if git:
         with fs.working_dir(spack.paths.prefix):

lib/spack/spack/cmd/dependencies.py

@@ -9,9 +9,9 @@
 
 import spack.cmd
 import spack.environment as ev
+import spack.package_base
 import spack.store
 from spack.cmd.common import arguments
-from spack.solver.input_analysis import create_graph_analyzer
 
 description = "show dependencies of a package"
 section = "basic"
@@ -68,17 +68,15 @@ def dependencies(parser, args):
 
     else:
         spec = specs[0]
-        dependencies, virtuals, _ = create_graph_analyzer().possible_dependencies(
+        dependencies = spack.package_base.possible_dependencies(
             spec,
             transitive=args.transitive,
             expand_virtuals=args.expand_virtuals,
-            allowed_deps=args.deptype,
+            depflag=args.deptype,
         )
-        if not args.expand_virtuals:
-            dependencies.update(virtuals)
 
         if spec.name in dependencies:
-            dependencies.remove(spec.name)
+            del dependencies[spec.name]
 
         if dependencies:
             colify(sorted(dependencies))

lib/spack/spack/cmd/develop.py

@@ -125,7 +125,7 @@ def develop(parser, args):
     version = spec.versions.concrete_range_as_version
     if not version:
         # look up the maximum version so infintiy versions are preferred for develop
-        version = max(spack.repo.PATH.get_pkg_class(spec.fullname).versions.keys())
+        version = max(spec.package_class.versions.keys())
         tty.msg(f"Defaulting to highest version: {spec.name}@{version}")
     spec.versions = spack.version.VersionList([version])
 

lib/spack/spack/cmd/mirror.py

@@ -545,7 +545,7 @@ def _not_license_excluded(self, x):
         package does not explicitly forbid redistributing source."""
         if self.private:
             return True
-        elif spack.repo.PATH.get_pkg_class(x.fullname).redistribute_source(x):
+        elif x.package_class.redistribute_source(x):
             return True
         else:
             tty.debug(

lib/spack/spack/cmd/providers.py

@@ -41,11 +41,7 @@ def providers(parser, args):
     specs = spack.cmd.parse_specs(args.virtual_package)
 
     # Check prerequisites
-    non_virtual = [
-        str(s)
-        for s in specs
-        if not spack.repo.PATH.is_virtual(s.name) or s.name not in valid_virtuals
-    ]
+    non_virtual = [str(s) for s in specs if not s.virtual or s.name not in valid_virtuals]
     if non_virtual:
         msg = "non-virtual specs cannot be part of the query "
         msg += "[{0}]\n".format(", ".join(non_virtual))

lib/spack/spack/cmd/style.py

@@ -6,7 +6,7 @@
 import os
 import re
 import sys
-from itertools import islice, zip_longest
+from itertools import zip_longest
 from typing import Dict, List, Optional
 
 import llnl.util.tty as tty
@@ -423,8 +423,7 @@ def _run_import_check(
             continue
 
         for m in is_abs_import.finditer(contents):
-            # Find at most two occurences: the first is the import itself, the second is its usage.
-            if len(list(islice(re.finditer(rf"{re.escape(m.group(1))}(?!\w)", contents), 2))) == 1:
+            if contents.count(m.group(1)) == 1:
                 to_remove.append(m.group(0))
                 exit_code = 1
                 print(f"{pretty_path}: redundant import: {m.group(1)}", file=out)
@@ -439,7 +438,7 @@ def _run_import_check(
             module = _module_part(root, m.group(0))
             if not module or module in to_add:
                 continue
-            if re.search(rf"import {re.escape(module)}(?!\w|\.)", contents):
+            if re.search(rf"import {re.escape(module)}\b(?!\.)", contents):
                 continue
             to_add.add(module)
             exit_code = 1

lib/spack/spack/cmd/test.py

@@ -252,9 +252,7 @@ def has_test_and_tags(pkg_class):
     hashes = env.all_hashes() if env else None
 
     specs = spack.store.STORE.db.query(hashes=hashes)
-    specs = list(
-        filter(lambda s: has_test_and_tags(spack.repo.PATH.get_pkg_class(s.fullname)), specs)
-    )
+    specs = list(filter(lambda s: has_test_and_tags(s.package_class), specs))
 
     spack.cmd.display_specs(specs, long=True)
 

lib/spack/spack/concretize.py

@@ -220,7 +220,7 @@ def concretize_one(spec: Union[str, Spec], tests: TestsType = False) -> Spec:
     opt, i, answer = min(result.answers)
     name = spec.name
     # TODO: Consolidate this code with similar code in solve.py
-    if spack.repo.PATH.is_virtual(spec.name):
+    if spec.virtual:
         providers = [s.name for s in answer.values() if s.package.provides(name)]
         name = providers[0]
 

lib/spack/spack/database.py

@@ -41,8 +41,6 @@
     Union,
 )
 
-import spack.repo
-
 try:
     import uuid
 
@@ -1558,12 +1556,7 @@ def _query(
         # If we did fine something, the query spec can't be virtual b/c we matched an actual
         # package installation, so skip the virtual check entirely. If we *didn't* find anything,
         # check all the deferred specs *if* the query is virtual.
-        if (
-            not results
-            and query_spec is not None
-            and deferred
-            and spack.repo.PATH.is_virtual(query_spec.name)
-        ):
+        if not results and query_spec is not None and deferred and query_spec.virtual:
             results = [spec for spec in deferred if spec.satisfies(query_spec)]
 
         return results

lib/spack/spack/detection/path.py

@@ -259,8 +259,6 @@ def detect_specs(
             )
             return []
 
-        from spack.repo import PATH as repo_path
-
         result = []
         for candidate_path, items_in_prefix in _group_by_prefix(
             llnl.util.lang.dedupe(paths)
@@ -307,10 +305,7 @@ def detect_specs(
 
                 resolved_specs[spec] = candidate_path
                 try:
-                    # Validate the spec calling a package specific method
-                    pkg_cls = repo_path.get_pkg_class(spec.name)
-                    validate_fn = getattr(pkg_cls, "validate_detected_spec", lambda x, y: None)
-                    validate_fn(spec, spec.extra_attributes)
+                    spec.validate_detection()
                 except Exception as e:
                     msg = (
                         f'"{spec}" has been detected on the system but will '

lib/spack/spack/graph.py

@@ -42,10 +42,10 @@
 import llnl.util.tty.color
 
 import spack.deptypes as dt
+import spack.repo
 import spack.spec
 import spack.tengine
 import spack.traverse
-from spack.solver.input_analysis import create_graph_analyzer
 
 
 def find(seq, predicate):
@@ -537,11 +537,10 @@ def edge_entry(self, edge):
 
 def _static_edges(specs, depflag):
     for spec in specs:
-        *_, edges = create_graph_analyzer().possible_dependencies(
-            spec.name, expand_virtuals=True, allowed_deps=depflag
-        )
+        pkg_cls = spack.repo.PATH.get_pkg_class(spec.name)
+        possible = pkg_cls.possible_dependencies(expand_virtuals=True, depflag=depflag)
 
-        for parent_name, dependencies in edges.items():
+        for parent_name, dependencies in possible.items():
             for dependency_name in dependencies:
                 yield spack.spec.DependencySpec(
                     spack.spec.Spec(parent_name),

lib/spack/spack/install_test.py

@@ -566,7 +566,7 @@ def copy_test_files(pkg: Pb, test_spec: spack.spec.Spec):
 
     # copy test data into test stage data dir
     try:
-        pkg_cls = spack.repo.PATH.get_pkg_class(test_spec.fullname)
+        pkg_cls = test_spec.package_class
     except spack.repo.UnknownPackageError:
         tty.debug(f"{test_spec.name}: skipping test data copy since no package class found")
         return
@@ -623,7 +623,7 @@ def test_functions(
         vpkgs = virtuals(pkg)
         for vname in vpkgs:
             try:
-                classes.append(spack.repo.PATH.get_pkg_class(vname))
+                classes.append((Spec(vname)).package_class)
             except spack.repo.UnknownPackageError:
                 tty.debug(f"{vname}: virtual does not appear to have a package file")
 
@@ -668,7 +668,7 @@ def process_test_parts(pkg: Pb, test_specs: List[spack.spec.Spec], verbose: bool
 
             # grab test functions associated with the spec, which may be virtual
             try:
-                tests = test_functions(spack.repo.PATH.get_pkg_class(spec.fullname))
+                tests = test_functions(spec.package_class)
             except spack.repo.UnknownPackageError:
                 # Some virtuals don't have a package so we don't want to report
                 # them as not having tests when that isn't appropriate.

lib/spack/spack/installer.py

@@ -2436,7 +2436,11 @@ def _real_install(self) -> None:
                     # DEBUGGING TIP - to debug this section, insert an IPython
                     # embed here, and run the sections below without log capture
                     log_contextmanager = log_output(
-                        log_file, self.echo, True, filter_fn=self.filter_fn
+                        log_file,
+                        self.echo,
+                        True,
+                        env=self.unmodified_env,
+                        filter_fn=self.filter_fn,
                     )
 
                     with log_contextmanager as logger:

lib/spack/spack/modules/lmod.py

@@ -209,7 +209,7 @@ def provides(self):
         # All the other tokens in the hierarchy must be virtual dependencies
         for x in self.hierarchy_tokens:
             if self.spec.package.provides(x):
-                provides[x] = self.spec
+                provides[x] = self.spec[x]
         return provides
 
     @property

lib/spack/spack/package_base.py

@@ -22,6 +22,7 @@
 import textwrap
 import time
 import traceback
+import typing
 from typing import Any, Callable, Dict, Iterable, List, Optional, Set, Tuple, Type, TypeVar, Union
 
 from typing_extensions import Literal
@@ -709,6 +710,19 @@ class PackageBase(WindowsRPath, PackageViewMixin, metaclass=PackageMeta):
     #: Do not include @ here in order not to unnecessarily ping the users.
     maintainers: List[str] = []
 
+    #: List of attributes to be excluded from a package's hash.
+    metadata_attrs = [
+        "homepage",
+        "url",
+        "urls",
+        "list_url",
+        "extendable",
+        "parallel",
+        "make_jobs",
+        "maintainers",
+        "tags",
+    ]
+
     #: Set to ``True`` to indicate the stand-alone test requires a compiler.
     #: It is used to ensure a compiler and build dependencies like 'cmake'
     #: are available to build a custom test code.
@@ -808,6 +822,104 @@ def get_variant(self, name: str) -> spack.variant.Variant:
         except StopIteration:
             raise ValueError(f"No variant '{name}' on spec: {self.spec}")
 
+    @classmethod
+    def possible_dependencies(
+        cls,
+        transitive: bool = True,
+        expand_virtuals: bool = True,
+        depflag: dt.DepFlag = dt.ALL,
+        visited: Optional[dict] = None,
+        missing: Optional[dict] = None,
+        virtuals: Optional[set] = None,
+    ) -> Dict[str, Set[str]]:
+        """Return dict of possible dependencies of this package.
+
+        Args:
+            transitive (bool or None): return all transitive dependencies if
+                True, only direct dependencies if False (default True)..
+            expand_virtuals (bool or None): expand virtual dependencies into
+                all possible implementations (default True)
+            depflag: dependency types to consider
+            visited (dict or None): dict of names of dependencies visited so
+                far, mapped to their immediate dependencies' names.
+            missing (dict or None): dict to populate with packages and their
+                *missing* dependencies.
+            virtuals (set): if provided, populate with virtuals seen so far.
+
+        Returns:
+            (dict): dictionary mapping dependency names to *their*
+                immediate dependencies
+
+        Each item in the returned dictionary maps a (potentially
+        transitive) dependency of this package to its possible
+        *immediate* dependencies. If ``expand_virtuals`` is ``False``,
+        virtual package names wil be inserted as keys mapped to empty
+        sets of dependencies.  Virtuals, if not expanded, are treated as
+        though they have no immediate dependencies.
+
+        Missing dependencies by default are ignored, but if a
+        missing dict is provided, it will be populated with package names
+        mapped to any dependencies they have that are in no
+        repositories. This is only populated if transitive is True.
+
+        Note: the returned dict *includes* the package itself.
+
+        """
+        visited = {} if visited is None else visited
+        missing = {} if missing is None else missing
+
+        visited.setdefault(cls.name, set())
+
+        for name, conditions in cls.dependencies_by_name(when=True).items():
+            # check whether this dependency could be of the type asked for
+            depflag_union = 0
+            for deplist in conditions.values():
+                for dep in deplist:
+                    depflag_union |= dep.depflag
+            if not (depflag & depflag_union):
+                continue
+
+            # expand virtuals if enabled, otherwise just stop at virtuals
+            if spack.repo.PATH.is_virtual(name):
+                if virtuals is not None:
+                    virtuals.add(name)
+                if expand_virtuals:
+                    providers = spack.repo.PATH.providers_for(name)
+                    dep_names = [spec.name for spec in providers]
+                else:
+                    visited.setdefault(cls.name, set()).add(name)
+                    visited.setdefault(name, set())
+                    continue
+            else:
+                dep_names = [name]
+
+            # add the dependency names to the visited dict
+            visited.setdefault(cls.name, set()).update(set(dep_names))
+
+            # recursively traverse dependencies
+            for dep_name in dep_names:
+                if dep_name in visited:
+                    continue
+
+                visited.setdefault(dep_name, set())
+
+                # skip the rest if not transitive
+                if not transitive:
+                    continue
+
+                try:
+                    dep_cls = spack.repo.PATH.get_pkg_class(dep_name)
+                except spack.repo.UnknownPackageError:
+                    # log unknown packages
+                    missing.setdefault(cls.name, set()).add(dep_name)
+                    continue
+
+                dep_cls.possible_dependencies(
+                    transitive, expand_virtuals, depflag, visited, missing, virtuals
+                )
+
+        return visited
+
     @classproperty
     def package_dir(cls):
         """Directory where the package.py file lives."""
@@ -2172,6 +2284,55 @@ def rpath_args(self):
 build_system_flags = PackageBase.build_system_flags
 
 
+def use_cray_compiler_names():
+    """Compiler names for builds that rely on cray compiler names."""
+    os.environ["CC"] = "cc"
+    os.environ["CXX"] = "CC"
+    os.environ["FC"] = "ftn"
+    os.environ["F77"] = "ftn"
+
+
+def possible_dependencies(
+    *pkg_or_spec: Union[str, spack.spec.Spec, typing.Type[PackageBase]],
+    transitive: bool = True,
+    expand_virtuals: bool = True,
+    depflag: dt.DepFlag = dt.ALL,
+    missing: Optional[dict] = None,
+    virtuals: Optional[set] = None,
+) -> Dict[str, Set[str]]:
+    """Get the possible dependencies of a number of packages.
+
+    See ``PackageBase.possible_dependencies`` for details.
+    """
+    packages = []
+    for pos in pkg_or_spec:
+        if isinstance(pos, PackageMeta) and issubclass(pos, PackageBase):
+            packages.append(pos)
+            continue
+
+        if not isinstance(pos, spack.spec.Spec):
+            pos = spack.spec.Spec(pos)
+
+        if spack.repo.PATH.is_virtual(pos.name):
+            packages.extend(p.package_class for p in spack.repo.PATH.providers_for(pos.name))
+            continue
+        else:
+            packages.append(pos.package_class)
+
+    visited: Dict[str, Set[str]] = {}
+    for pkg in packages:
+        pkg.possible_dependencies(
+            visited=visited,
+            transitive=transitive,
+            expand_virtuals=expand_virtuals,
+            depflag=depflag,
+            missing=missing,
+            virtuals=virtuals,
+        )
+
+    return visited
+
+
 def deprecated_version(pkg: PackageBase, version: Union[str, StandardVersion]) -> bool:
     """Return True iff the version is deprecated.
 

lib/spack/spack/relocate.py

@@ -236,15 +236,22 @@ def relocate_elf_binaries(binaries: Iterable[str], prefix_to_prefix: Dict[str, s
             _set_elf_rpaths_and_interpreter(path, rpaths=rpaths, interpreter=interpreter)
 
 
+def _warn_if_link_cant_be_relocated(link: str, target: str):
+    if not os.path.isabs(target):
+        return
+    tty.warn(f'Symbolic link at "{link}" to "{target}" cannot be relocated')
+
+
 def relocate_links(links: Iterable[str], prefix_to_prefix: Dict[str, str]) -> None:
     """Relocate links to a new install prefix."""
     regex = re.compile("|".join(re.escape(p) for p in prefix_to_prefix.keys()))
     for link in links:
         old_target = readlink(link)
-        if not os.path.isabs(old_target):
-            continue
         match = regex.match(old_target)
+
+        # No match.
         if match is None:
+            _warn_if_link_cant_be_relocated(link, old_target)
             continue
 
         new_target = prefix_to_prefix[match.group()] + old_target[match.end() :]
@@ -406,8 +413,8 @@ def fixup_macos_rpaths(spec):
     entries which makes it harder to adjust with ``install_name_tool
     -delete_rpath``.
     """
-    if spec.external or not spec.concrete:
-        tty.warn("external/abstract spec cannot be fixed up: {0!s}".format(spec))
+    if spec.external or spec.virtual:
+        tty.warn("external or virtual package cannot be fixed up: {0!s}".format(spec))
         return False
 
     if "platform=darwin" not in spec:

lib/spack/spack/schema/concretizer.py

@@ -87,7 +87,6 @@
                     "strategy": {"type": "string", "enum": ["none", "minimal", "full"]}
                 },
             },
-            "static_analysis": {"type": "boolean"},
             "timeout": {"type": "integer", "minimum": 0},
             "error_on_timeout": {"type": "boolean"},
             "os_compatible": {"type": "object", "additionalProperties": {"type": "array"}},

lib/spack/spack/solver/asp.py

@@ -6,7 +6,6 @@
 import copy
 import enum
 import functools
-import io
 import itertools
 import os
 import pathlib
@@ -63,7 +62,7 @@
     parse_files,
     parse_term,
 )
-from .input_analysis import create_counter, create_graph_analyzer
+from .counter import FullDuplicatesCounter, MinimalDuplicatesCounter, NoDuplicatesCounter
 from .requirements import RequirementKind, RequirementParser, RequirementRule
 from .version_order import concretization_version_order
 
@@ -74,19 +73,17 @@
 #: Enable the addition of a runtime node
 WITH_RUNTIME = sys.platform != "win32"
 
-
-class OutputConfiguration(NamedTuple):
-    """Data class that contains configuration on what a clingo solve should output."""
-
-    #: Print out coarse timers for different solve phases
-    timers: bool
-    #: Whether to output Clingo's internal solver statistics
-    stats: bool
-    #: Optional output stream for the generated ASP program
-    out: Optional[io.IOBase]
-    #: If True, stop after setup and don't solve
-    setup_only: bool
-
+#: Data class that contain configuration on what a
+#: clingo solve should output.
+#:
+#: Args:
+#:     timers (bool):  Print out coarse timers for different solve phases.
+#:     stats (bool): Whether to output Clingo's internal solver statistics.
+#:     out: Optional output stream for the generated ASP program.
+#:     setup_only (bool): if True, stop after setup and don't solve (default False).
+OutputConfiguration = collections.namedtuple(
+    "OutputConfiguration", ["timers", "stats", "out", "setup_only"]
+)
 
 #: Default output configuration for a solve
 DEFAULT_OUTPUT_CONFIGURATION = OutputConfiguration(
@@ -274,6 +271,15 @@ def remove_node(spec: spack.spec.Spec, facts: List[AspFunction]) -> List[AspFunc
     return list(filter(lambda x: x.args[0] not in ("node", "virtual_node"), facts))
 
 
+def _create_counter(specs: List[spack.spec.Spec], tests: bool):
+    strategy = spack.config.CONFIG.get("concretizer:duplicates:strategy", "none")
+    if strategy == "full":
+        return FullDuplicatesCounter(specs, tests=tests)
+    if strategy == "minimal":
+        return MinimalDuplicatesCounter(specs, tests=tests)
+    return NoDuplicatesCounter(specs, tests=tests)
+
+
 def all_libcs() -> Set[spack.spec.Spec]:
     """Return a set of all libc specs targeted by any configured compiler. If none, fall back to
     libc determined from the current Python process if dynamically linked."""
@@ -501,7 +507,7 @@ def _compute_specs_from_answer_set(self):
             # The specs must be unified to get here, so it is safe to associate any satisfying spec
             # with the input. Multiple inputs may be matched to the same concrete spec
             node = SpecBuilder.make_node(pkg=input_spec.name)
-            if spack.repo.PATH.is_virtual(input_spec.name):
+            if input_spec.virtual:
                 providers = [
                     spec.name for spec in answer.values() if spec.package.provides(input_spec.name)
                 ]
@@ -1115,8 +1121,6 @@ class SpackSolverSetup:
     """Class to set up and run a Spack concretization solve."""
 
     def __init__(self, tests: bool = False):
-        self.possible_graph = create_graph_analyzer()
-
         # these are all initialized in setup()
         self.gen: "ProblemInstanceBuilder" = ProblemInstanceBuilder()
         self.requirement_parser = RequirementParser(spack.config.CONFIG)
@@ -2083,11 +2087,7 @@ def _spec_clauses(
         f: Union[Type[_Head], Type[_Body]] = _Body if body else _Head
 
         if spec.name:
-            clauses.append(
-                f.node(spec.name)
-                if not spack.repo.PATH.is_virtual(spec.name)
-                else f.virtual_node(spec.name)
-            )
+            clauses.append(f.node(spec.name) if not spec.virtual else f.virtual_node(spec.name))
         if spec.namespace:
             clauses.append(f.namespace(spec.name, spec.namespace))
 
@@ -2114,7 +2114,7 @@ def _spec_clauses(
 
             for value in variant.value_as_tuple:
                 # ensure that the value *can* be valid for the spec
-                if spec.name and not spec.concrete and not spack.repo.PATH.is_virtual(spec.name):
+                if spec.name and not spec.concrete and not spec.virtual:
                     variant_defs = vt.prevalidate_variant_value(
                         self.pkg_class(spec.name), variant, spec
                     )
@@ -2397,20 +2397,38 @@ def keyfun(os):
 
     def target_defaults(self, specs):
         """Add facts about targets and target compatibility."""
+        self.gen.h2("Default target")
+
+        platform = spack.platforms.host()
+        uarch = archspec.cpu.TARGETS.get(platform.default)
+
         self.gen.h2("Target compatibility")
 
-        # Add targets explicitly requested from specs
-        candidate_targets = []
-        for x in self.possible_graph.candidate_targets():
-            if all(
-                self.possible_graph.unreachable(pkg_name=pkg_name, when_spec=f"target={x}")
-                for pkg_name in self.pkgs
-            ):
-                tty.debug(f"[{__name__}] excluding target={x}, cause no package can use it")
-                continue
-            candidate_targets.append(x)
+        # Construct the list of targets which are compatible with the host
+        candidate_targets = [uarch] + uarch.ancestors
 
-        host_compatible = spack.config.CONFIG.get("concretizer:targets:host_compatible")
+        # Get configuration options
+        granularity = spack.config.get("concretizer:targets:granularity")
+        host_compatible = spack.config.get("concretizer:targets:host_compatible")
+
+        # Add targets which are not compatible with the current host
+        if not host_compatible:
+            additional_targets_in_family = sorted(
+                [
+                    t
+                    for t in archspec.cpu.TARGETS.values()
+                    if (t.family.name == uarch.family.name and t not in candidate_targets)
+                ],
+                key=lambda x: len(x.ancestors),
+                reverse=True,
+            )
+            candidate_targets += additional_targets_in_family
+
+        # Check if we want only generic architecture
+        if granularity == "generic":
+            candidate_targets = [t for t in candidate_targets if t.vendor == "generic"]
+
+        # Add targets explicitly requested from specs
         for spec in specs:
             if not spec.architecture or not spec.architecture.target:
                 continue
@@ -2426,8 +2444,6 @@ def target_defaults(self, specs):
                     if ancestor not in candidate_targets:
                         candidate_targets.append(ancestor)
 
-        platform = spack.platforms.host()
-        uarch = archspec.cpu.TARGETS.get(platform.default)
         best_targets = {uarch.family.name}
         for compiler_id, known_compiler in enumerate(self.possible_compilers):
             if not known_compiler.available:
@@ -2485,6 +2501,7 @@ def target_defaults(self, specs):
             self.gen.newline()
 
         self.default_targets = list(sorted(set(self.default_targets)))
+
         self.target_preferences()
 
     def virtual_providers(self):
@@ -2588,14 +2605,7 @@ def define_variant_values(self):
         # Tell the concretizer about possible values from specs seen in spec_clauses().
         # We might want to order these facts by pkg and name if we are debugging.
         for pkg_name, variant_def_id, value in self.variant_values_from_specs:
-            try:
-                vid = self.variant_ids_by_def_id[variant_def_id]
-            except KeyError:
-                tty.debug(
-                    f"[{__name__}] cannot retrieve id of the {value} variant from {pkg_name}"
-                )
-                continue
-
+            vid = self.variant_ids_by_def_id[variant_def_id]
             self.gen.fact(fn.pkg_fact(pkg_name, fn.variant_possible_value(vid, value)))
 
     def register_concrete_spec(self, spec, possible):
@@ -2666,7 +2676,7 @@ def setup(
         """
         check_packages_exist(specs)
 
-        node_counter = create_counter(specs, tests=self.tests, possible_graph=self.possible_graph)
+        node_counter = _create_counter(specs, tests=self.tests)
         self.possible_virtuals = node_counter.possible_virtuals()
         self.pkgs = node_counter.possible_dependencies()
         self.libcs = sorted(all_libcs())  # type: ignore[type-var]
@@ -2674,9 +2684,7 @@ def setup(
         # Fail if we already know an unreachable node is requested
         for spec in specs:
             missing_deps = [
-                str(d)
-                for d in spec.traverse()
-                if d.name not in self.pkgs and not spack.repo.PATH.is_virtual(d.name)
+                str(d) for d in spec.traverse() if d.name not in self.pkgs and not d.virtual
             ]
             if missing_deps:
                 raise spack.spec.InvalidDependencyError(spec.name, missing_deps)
@@ -2893,11 +2901,7 @@ def literal_specs(self, specs):
                     pkg_name = clause.args[1]
                     self.gen.fact(fn.mentioned_in_literal(trigger_id, root_name, pkg_name))
 
-            requirements.append(
-                fn.attr(
-                    "virtual_root" if spack.repo.PATH.is_virtual(spec.name) else "root", spec.name
-                )
-            )
+            requirements.append(fn.attr("virtual_root" if spec.virtual else "root", spec.name))
             cache[imposed_spec_key] = (effect_id, requirements)
             self.gen.fact(fn.pkg_fact(spec.name, fn.condition_effect(condition_id, effect_id)))
 
@@ -3485,7 +3489,7 @@ def external_spec_selected(self, node, idx):
         self._specs[node].extra_attributes = spec_info.get("extra_attributes", {})
 
         # If this is an extension, update the dependencies to include the extendee
-        package = spack.repo.PATH.get_pkg_class(self._specs[node].fullname)(self._specs[node])
+        package = self._specs[node].package_class(self._specs[node])
         extendee_spec = package.extendee_spec
 
         if extendee_spec:
@@ -4098,10 +4102,10 @@ def _check_input_and_extract_concrete_specs(specs):
         reusable = []
         for root in specs:
             for s in root.traverse():
+                if s.virtual:
+                    continue
                 if s.concrete:
                     reusable.append(s)
-                elif spack.repo.PATH.is_virtual(s.name):
-                    continue
                 spack.spec.Spec.ensure_valid_variants(s)
         return reusable
 

lib/spack/spack/solver/concretize.lp

@@ -265,7 +265,6 @@ error(100, "Cannot select a single version for virtual '{0}'", Virtual)
 % If we select a deprecated version, mark the package as deprecated
 attr("deprecated", node(ID, Package), Version) :-
      attr("version", node(ID, Package), Version),
-     not external(node(ID, Package)),
      pkg_fact(Package, deprecated_version(Version)).
 
 error(100, "Package '{0}' needs the deprecated version '{1}', and this is not allowed", Package, Version)

lib/spack/spack/solver/counter.py

@@ -0,0 +1,179 @@
+# Copyright Spack Project Developers. See COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+import collections
+from typing import List, Set
+
+from llnl.util import lang
+
+import spack.deptypes as dt
+import spack.package_base
+import spack.repo
+import spack.spec
+
+PossibleDependencies = Set[str]
+
+
+class Counter:
+    """Computes the possible packages and the maximum number of duplicates
+    allowed for each of them.
+
+    Args:
+        specs: abstract specs to concretize
+        tests: if True, add test dependencies to the list of possible packages
+    """
+
+    def __init__(self, specs: List["spack.spec.Spec"], tests: bool) -> None:
+        runtime_pkgs = spack.repo.PATH.packages_with_tags("runtime")
+        runtime_virtuals = set()
+        for x in runtime_pkgs:
+            pkg_class = spack.repo.PATH.get_pkg_class(x)
+            runtime_virtuals.update(pkg_class.provided_virtual_names())
+
+        self.specs = specs + [spack.spec.Spec(x) for x in runtime_pkgs]
+
+        self.link_run_types: dt.DepFlag = dt.LINK | dt.RUN | dt.TEST
+        self.all_types: dt.DepFlag = dt.ALL
+        if not tests:
+            self.link_run_types = dt.LINK | dt.RUN
+            self.all_types = dt.LINK | dt.RUN | dt.BUILD
+
+        self._possible_dependencies: PossibleDependencies = set()
+        self._possible_virtuals: Set[str] = (
+            set(x.name for x in specs if x.virtual) | runtime_virtuals
+        )
+
+    def possible_dependencies(self) -> PossibleDependencies:
+        """Returns the list of possible dependencies"""
+        self.ensure_cache_values()
+        return self._possible_dependencies
+
+    def possible_virtuals(self) -> Set[str]:
+        """Returns the list of possible virtuals"""
+        self.ensure_cache_values()
+        return self._possible_virtuals
+
+    def ensure_cache_values(self) -> None:
+        """Ensure the cache values have been computed"""
+        if self._possible_dependencies:
+            return
+        self._compute_cache_values()
+
+    def possible_packages_facts(self, gen: "spack.solver.asp.PyclingoDriver", fn) -> None:
+        """Emit facts associated with the possible packages"""
+        raise NotImplementedError("must be implemented by derived classes")
+
+    def _compute_cache_values(self):
+        raise NotImplementedError("must be implemented by derived classes")
+
+
+class NoDuplicatesCounter(Counter):
+    def _compute_cache_values(self):
+        result = spack.package_base.possible_dependencies(
+            *self.specs, virtuals=self._possible_virtuals, depflag=self.all_types
+        )
+        self._possible_dependencies = set(result)
+
+    def possible_packages_facts(self, gen, fn):
+        gen.h2("Maximum number of nodes (packages)")
+        for package_name in sorted(self.possible_dependencies()):
+            gen.fact(fn.max_dupes(package_name, 1))
+        gen.newline()
+        gen.h2("Maximum number of nodes (virtual packages)")
+        for package_name in sorted(self.possible_virtuals()):
+            gen.fact(fn.max_dupes(package_name, 1))
+        gen.newline()
+        gen.h2("Possible package in link-run subDAG")
+        for name in sorted(self.possible_dependencies()):
+            gen.fact(fn.possible_in_link_run(name))
+        gen.newline()
+
+
+class MinimalDuplicatesCounter(NoDuplicatesCounter):
+    def __init__(self, specs, tests):
+        super().__init__(specs, tests)
+        self._link_run: PossibleDependencies = set()
+        self._direct_build: PossibleDependencies = set()
+        self._total_build: PossibleDependencies = set()
+        self._link_run_virtuals: Set[str] = set()
+
+    def _compute_cache_values(self):
+        self._link_run = set(
+            spack.package_base.possible_dependencies(
+                *self.specs, virtuals=self._possible_virtuals, depflag=self.link_run_types
+            )
+        )
+        self._link_run_virtuals.update(self._possible_virtuals)
+        for x in self._link_run:
+            build_dependencies = spack.repo.PATH.get_pkg_class(x).dependencies_of_type(dt.BUILD)
+            virtuals, reals = lang.stable_partition(
+                build_dependencies, spack.repo.PATH.is_virtual_safe
+            )
+
+            self._possible_virtuals.update(virtuals)
+            for virtual_dep in virtuals:
+                providers = spack.repo.PATH.providers_for(virtual_dep)
+                self._direct_build.update(str(x) for x in providers)
+
+            self._direct_build.update(reals)
+
+        self._total_build = set(
+            spack.package_base.possible_dependencies(
+                *self._direct_build, virtuals=self._possible_virtuals, depflag=self.all_types
+            )
+        )
+        self._possible_dependencies = set(self._link_run) | set(self._total_build)
+
+    def possible_packages_facts(self, gen, fn):
+        build_tools = spack.repo.PATH.packages_with_tags("build-tools")
+        gen.h2("Packages with at most a single node")
+        for package_name in sorted(self.possible_dependencies() - build_tools):
+            gen.fact(fn.max_dupes(package_name, 1))
+        gen.newline()
+
+        gen.h2("Packages with at multiple possible nodes (build-tools)")
+        for package_name in sorted(self.possible_dependencies() & build_tools):
+            gen.fact(fn.max_dupes(package_name, 2))
+            gen.fact(fn.multiple_unification_sets(package_name))
+        gen.newline()
+
+        gen.h2("Maximum number of nodes (virtual packages)")
+        for package_name in sorted(self.possible_virtuals()):
+            gen.fact(fn.max_dupes(package_name, 1))
+        gen.newline()
+
+        gen.h2("Possible package in link-run subDAG")
+        for name in sorted(self._link_run):
+            gen.fact(fn.possible_in_link_run(name))
+        gen.newline()
+
+
+class FullDuplicatesCounter(MinimalDuplicatesCounter):
+    def possible_packages_facts(self, gen, fn):
+        build_tools = spack.repo.PATH.packages_with_tags("build-tools")
+        counter = collections.Counter(
+            list(self._link_run) + list(self._total_build) + list(self._direct_build)
+        )
+        gen.h2("Maximum number of nodes")
+        for pkg, count in sorted(counter.items(), key=lambda x: (x[1], x[0])):
+            count = min(count, 2)
+            gen.fact(fn.max_dupes(pkg, count))
+        gen.newline()
+
+        gen.h2("Build unification sets ")
+        for name in sorted(self.possible_dependencies() & build_tools):
+            gen.fact(fn.multiple_unification_sets(name))
+        gen.newline()
+
+        gen.h2("Possible package in link-run subDAG")
+        for name in sorted(self._link_run):
+            gen.fact(fn.possible_in_link_run(name))
+        gen.newline()
+
+        counter = collections.Counter(
+            list(self._link_run_virtuals) + list(self._possible_virtuals)
+        )
+        gen.h2("Maximum number of virtual nodes")
+        for pkg, count in sorted(counter.items(), key=lambda x: (x[1], x[0])):
+            gen.fact(fn.max_dupes(pkg, count))
+        gen.newline()

lib/spack/spack/solver/input_analysis.py

@@ -1,526 +0,0 @@
-# Copyright Spack Project Developers. See COPYRIGHT file for details.
-#
-# SPDX-License-Identifier: (Apache-2.0 OR MIT)
-"""Classes to analyze the input of a solve, and provide information to set up the ASP problem"""
-import collections
-from typing import Dict, List, NamedTuple, Set, Tuple, Union
-
-import archspec.cpu
-
-from llnl.util import lang, tty
-
-import spack.binary_distribution
-import spack.config
-import spack.deptypes as dt
-import spack.platforms
-import spack.repo
-import spack.spec
-import spack.store
-from spack.error import SpackError
-
-RUNTIME_TAG = "runtime"
-
-
-class PossibleGraph(NamedTuple):
-    real_pkgs: Set[str]
-    virtuals: Set[str]
-    edges: Dict[str, Set[str]]
-
-
-class PossibleDependencyGraph:
-    """Returns information needed to set up an ASP problem"""
-
-    def unreachable(self, *, pkg_name: str, when_spec: spack.spec.Spec) -> bool:
-        """Returns true if the context can determine that the condition cannot ever
-        be met on pkg_name.
-        """
-        raise NotImplementedError
-
-    def candidate_targets(self) -> List[archspec.cpu.Microarchitecture]:
-        """Returns a list of targets that are candidate for concretization"""
-        raise NotImplementedError
-
-    def possible_dependencies(
-        self,
-        *specs: Union[spack.spec.Spec, str],
-        allowed_deps: dt.DepFlag,
-        transitive: bool = True,
-        strict_depflag: bool = False,
-        expand_virtuals: bool = True,
-    ) -> PossibleGraph:
-        """Returns the set of possible dependencies, and the set of possible virtuals.
-
-        Both sets always include runtime packages, which may be injected by compilers.
-
-        Args:
-            transitive: return transitive dependencies if True, only direct dependencies if False
-            allowed_deps: dependency types to consider
-            strict_depflag: if True, only the specific dep type is considered, if False any
-                deptype that intersects with allowed deptype is considered
-            expand_virtuals: expand virtual dependencies into all possible implementations
-        """
-        raise NotImplementedError
-
-
-class NoStaticAnalysis(PossibleDependencyGraph):
-    """Implementation that tries to minimize the setup time (i.e. defaults to give fast
-    answers), rather than trying to reduce the ASP problem size with more complex analysis.
-    """
-
-    def __init__(self, *, configuration: spack.config.Configuration, repo: spack.repo.RepoPath):
-        self.configuration = configuration
-        self.repo = repo
-        self.runtime_pkgs = set(self.repo.packages_with_tags(RUNTIME_TAG))
-        self.runtime_virtuals = set()
-        self._platform_condition = spack.spec.Spec(
-            f"platform={spack.platforms.host()} target={archspec.cpu.host().family}:"
-        )
-        for x in self.runtime_pkgs:
-            pkg_class = self.repo.get_pkg_class(x)
-            self.runtime_virtuals.update(pkg_class.provided_virtual_names())
-
-        try:
-            self.libc_pkgs = [x.name for x in self.providers_for("libc")]
-        except spack.repo.UnknownPackageError:
-            self.libc_pkgs = []
-
-    def is_virtual(self, name: str) -> bool:
-        return self.repo.is_virtual(name)
-
-    @lang.memoized
-    def is_allowed_on_this_platform(self, *, pkg_name: str) -> bool:
-        """Returns true if a package is allowed on the current host"""
-        pkg_cls = self.repo.get_pkg_class(pkg_name)
-        for when_spec, conditions in pkg_cls.requirements.items():
-            if not when_spec.intersects(self._platform_condition):
-                continue
-            for requirements, _, _ in conditions:
-                if not any(x.intersects(self._platform_condition) for x in requirements):
-                    tty.debug(f"[{__name__}] {pkg_name} is not for this platform")
-                    return False
-        return True
-
-    def providers_for(self, virtual_str: str) -> List[spack.spec.Spec]:
-        """Returns a list of possible providers for the virtual string in input."""
-        return self.repo.providers_for(virtual_str)
-
-    def can_be_installed(self, *, pkg_name) -> bool:
-        """Returns True if a package can be installed, False otherwise."""
-        return True
-
-    def unreachable(self, *, pkg_name: str, when_spec: spack.spec.Spec) -> bool:
-        """Returns true if the context can determine that the condition cannot ever
-        be met on pkg_name.
-        """
-        return False
-
-    def candidate_targets(self) -> List[archspec.cpu.Microarchitecture]:
-        """Returns a list of targets that are candidate for concretization"""
-        platform = spack.platforms.host()
-        default_target = archspec.cpu.TARGETS[platform.default]
-
-        # Construct the list of targets which are compatible with the host
-        candidate_targets = [default_target] + default_target.ancestors
-        granularity = self.configuration.get("concretizer:targets:granularity")
-        host_compatible = self.configuration.get("concretizer:targets:host_compatible")
-
-        # Add targets which are not compatible with the current host
-        if not host_compatible:
-            additional_targets_in_family = sorted(
-                [
-                    t
-                    for t in archspec.cpu.TARGETS.values()
-                    if (t.family.name == default_target.family.name and t not in candidate_targets)
-                ],
-                key=lambda x: len(x.ancestors),
-                reverse=True,
-            )
-            candidate_targets += additional_targets_in_family
-
-        # Check if we want only generic architecture
-        if granularity == "generic":
-            candidate_targets = [t for t in candidate_targets if t.vendor == "generic"]
-
-        return candidate_targets
-
-    def possible_dependencies(
-        self,
-        *specs: Union[spack.spec.Spec, str],
-        allowed_deps: dt.DepFlag,
-        transitive: bool = True,
-        strict_depflag: bool = False,
-        expand_virtuals: bool = True,
-    ) -> PossibleGraph:
-        stack = [x for x in self._package_list(specs)]
-        virtuals: Set[str] = set()
-        edges: Dict[str, Set[str]] = {}
-
-        while stack:
-            pkg_name = stack.pop()
-
-            if pkg_name in edges:
-                continue
-
-            edges[pkg_name] = set()
-
-            # Since libc is not buildable, there is no need to extend the
-            # search space with libc dependencies.
-            if pkg_name in self.libc_pkgs:
-                continue
-
-            pkg_cls = self.repo.get_pkg_class(pkg_name=pkg_name)
-            for name, conditions in pkg_cls.dependencies_by_name(when=True).items():
-                if all(self.unreachable(pkg_name=pkg_name, when_spec=x) for x in conditions):
-                    tty.debug(
-                        f"[{__name__}] Not adding {name} as a dep of {pkg_name}, because "
-                        f"conditions cannot be met"
-                    )
-                    continue
-
-                if not self._has_deptypes(
-                    conditions, allowed_deps=allowed_deps, strict=strict_depflag
-                ):
-                    continue
-
-                if name in virtuals:
-                    continue
-
-                dep_names = set()
-                if self.is_virtual(name):
-                    virtuals.add(name)
-                    if expand_virtuals:
-                        providers = self.providers_for(name)
-                        dep_names = {spec.name for spec in providers}
-                else:
-                    dep_names = {name}
-
-                edges[pkg_name].update(dep_names)
-
-                if not transitive:
-                    continue
-
-                for dep_name in dep_names:
-                    if dep_name in edges:
-                        continue
-
-                    if not self._is_possible(pkg_name=dep_name):
-                        continue
-
-                    stack.append(dep_name)
-
-        real_packages = set(edges)
-        if not transitive:
-            # We exit early, so add children from the edges information
-            for root, children in edges.items():
-                real_packages.update(x for x in children if self._is_possible(pkg_name=x))
-
-        virtuals.update(self.runtime_virtuals)
-        real_packages = real_packages | self.runtime_pkgs
-        return PossibleGraph(real_pkgs=real_packages, virtuals=virtuals, edges=edges)
-
-    def _package_list(self, specs: Tuple[Union[spack.spec.Spec, str], ...]) -> List[str]:
-        stack = []
-        for current_spec in specs:
-            if isinstance(current_spec, str):
-                current_spec = spack.spec.Spec(current_spec)
-
-            if self.repo.is_virtual(current_spec.name):
-                stack.extend([p.name for p in self.providers_for(current_spec.name)])
-                continue
-
-            stack.append(current_spec.name)
-        return sorted(set(stack))
-
-    def _has_deptypes(self, dependencies, *, allowed_deps: dt.DepFlag, strict: bool) -> bool:
-        if strict is True:
-            return any(
-                dep.depflag == allowed_deps for deplist in dependencies.values() for dep in deplist
-            )
-        return any(
-            dep.depflag & allowed_deps for deplist in dependencies.values() for dep in deplist
-        )
-
-    def _is_possible(self, *, pkg_name):
-        try:
-            return self.is_allowed_on_this_platform(pkg_name=pkg_name) and self.can_be_installed(
-                pkg_name=pkg_name
-            )
-        except spack.repo.UnknownPackageError:
-            return False
-
-
-class StaticAnalysis(NoStaticAnalysis):
-    """Performs some static analysis of the configuration, store, etc. to provide more precise
-    answers on whether some packages can be installed, or used as a provider.
-
-    It increases the setup time, but might decrease the grounding and solve time considerably,
-    especially when requirements restrict the possible choices for providers.
-    """
-
-    def __init__(
-        self,
-        *,
-        configuration: spack.config.Configuration,
-        repo: spack.repo.RepoPath,
-        store: spack.store.Store,
-        binary_index: spack.binary_distribution.BinaryCacheIndex,
-    ):
-        super().__init__(configuration=configuration, repo=repo)
-        self.store = store
-        self.binary_index = binary_index
-
-    @lang.memoized
-    def providers_for(self, virtual_str: str) -> List[spack.spec.Spec]:
-        candidates = super().providers_for(virtual_str)
-        result = []
-        for spec in candidates:
-            if not self._is_provider_candidate(pkg_name=spec.name, virtual=virtual_str):
-                continue
-            result.append(spec)
-        return result
-
-    @lang.memoized
-    def buildcache_specs(self) -> List[spack.spec.Spec]:
-        self.binary_index.update()
-        return self.binary_index.get_all_built_specs()
-
-    @lang.memoized
-    def can_be_installed(self, *, pkg_name) -> bool:
-        if self.configuration.get(f"packages:{pkg_name}:buildable", True):
-            return True
-
-        if self.configuration.get(f"packages:{pkg_name}:externals", []):
-            return True
-
-        reuse = self.configuration.get("concretizer:reuse")
-        if reuse is not False and self.store.db.query(pkg_name):
-            return True
-
-        if reuse is not False and any(x.name == pkg_name for x in self.buildcache_specs()):
-            return True
-
-        tty.debug(f"[{__name__}] {pkg_name} cannot be installed")
-        return False
-
-    @lang.memoized
-    def _is_provider_candidate(self, *, pkg_name: str, virtual: str) -> bool:
-        if not self.is_allowed_on_this_platform(pkg_name=pkg_name):
-            return False
-
-        if not self.can_be_installed(pkg_name=pkg_name):
-            return False
-
-        virtual_spec = spack.spec.Spec(virtual)
-        if self.unreachable(pkg_name=virtual_spec.name, when_spec=pkg_name):
-            tty.debug(f"[{__name__}] {pkg_name} cannot be a provider for {virtual}")
-            return False
-
-        return True
-
-    @lang.memoized
-    def unreachable(self, *, pkg_name: str, when_spec: spack.spec.Spec) -> bool:
-        """Returns true if the context can determine that the condition cannot ever
-        be met on pkg_name.
-        """
-        candidates = self.configuration.get(f"packages:{pkg_name}:require", [])
-        if not candidates and pkg_name != "all":
-            return self.unreachable(pkg_name="all", when_spec=when_spec)
-
-        if not candidates:
-            return False
-
-        if isinstance(candidates, str):
-            candidates = [candidates]
-
-        union_requirement = spack.spec.Spec()
-        for c in candidates:
-            if not isinstance(c, str):
-                continue
-            try:
-                union_requirement.constrain(c)
-            except SpackError:
-                # Less optimized, but shouldn't fail
-                pass
-
-        if not union_requirement.intersects(when_spec):
-            return True
-
-        return False
-
-
-def create_graph_analyzer() -> PossibleDependencyGraph:
-    static_analysis = spack.config.CONFIG.get("concretizer:static_analysis", False)
-    if static_analysis:
-        return StaticAnalysis(
-            configuration=spack.config.CONFIG,
-            repo=spack.repo.PATH,
-            store=spack.store.STORE,
-            binary_index=spack.binary_distribution.BINARY_INDEX,
-        )
-    return NoStaticAnalysis(configuration=spack.config.CONFIG, repo=spack.repo.PATH)
-
-
-class Counter:
-    """Computes the possible packages and the maximum number of duplicates
-    allowed for each of them.
-
-    Args:
-        specs: abstract specs to concretize
-        tests: if True, add test dependencies to the list of possible packages
-    """
-
-    def __init__(
-        self, specs: List["spack.spec.Spec"], tests: bool, possible_graph: PossibleDependencyGraph
-    ) -> None:
-        self.possible_graph = possible_graph
-        self.specs = specs
-        self.link_run_types: dt.DepFlag = dt.LINK | dt.RUN | dt.TEST
-        self.all_types: dt.DepFlag = dt.ALL
-        if not tests:
-            self.link_run_types = dt.LINK | dt.RUN
-            self.all_types = dt.LINK | dt.RUN | dt.BUILD
-
-        self._possible_dependencies: Set[str] = set()
-        self._possible_virtuals: Set[str] = {
-            x.name for x in specs if spack.repo.PATH.is_virtual(x.name)
-        }
-
-    def possible_dependencies(self) -> Set[str]:
-        """Returns the list of possible dependencies"""
-        self.ensure_cache_values()
-        return self._possible_dependencies
-
-    def possible_virtuals(self) -> Set[str]:
-        """Returns the list of possible virtuals"""
-        self.ensure_cache_values()
-        return self._possible_virtuals
-
-    def ensure_cache_values(self) -> None:
-        """Ensure the cache values have been computed"""
-        if self._possible_dependencies:
-            return
-        self._compute_cache_values()
-
-    def possible_packages_facts(self, gen: "spack.solver.asp.ProblemInstanceBuilder", fn) -> None:
-        """Emit facts associated with the possible packages"""
-        raise NotImplementedError("must be implemented by derived classes")
-
-    def _compute_cache_values(self) -> None:
-        raise NotImplementedError("must be implemented by derived classes")
-
-
-class NoDuplicatesCounter(Counter):
-    def _compute_cache_values(self) -> None:
-        self._possible_dependencies, virtuals, _ = self.possible_graph.possible_dependencies(
-            *self.specs, allowed_deps=self.all_types
-        )
-        self._possible_virtuals.update(virtuals)
-
-    def possible_packages_facts(self, gen: "spack.solver.asp.ProblemInstanceBuilder", fn) -> None:
-        gen.h2("Maximum number of nodes (packages)")
-        for package_name in sorted(self.possible_dependencies()):
-            gen.fact(fn.max_dupes(package_name, 1))
-        gen.newline()
-        gen.h2("Maximum number of nodes (virtual packages)")
-        for package_name in sorted(self.possible_virtuals()):
-            gen.fact(fn.max_dupes(package_name, 1))
-        gen.newline()
-        gen.h2("Possible package in link-run subDAG")
-        for name in sorted(self.possible_dependencies()):
-            gen.fact(fn.possible_in_link_run(name))
-        gen.newline()
-
-
-class MinimalDuplicatesCounter(NoDuplicatesCounter):
-    def __init__(
-        self, specs: List["spack.spec.Spec"], tests: bool, possible_graph: PossibleDependencyGraph
-    ) -> None:
-        super().__init__(specs, tests, possible_graph)
-        self._link_run: Set[str] = set()
-        self._direct_build: Set[str] = set()
-        self._total_build: Set[str] = set()
-        self._link_run_virtuals: Set[str] = set()
-
-    def _compute_cache_values(self) -> None:
-        self._link_run, virtuals, _ = self.possible_graph.possible_dependencies(
-            *self.specs, allowed_deps=self.link_run_types
-        )
-        self._possible_virtuals.update(virtuals)
-        self._link_run_virtuals.update(virtuals)
-        for x in self._link_run:
-            reals, virtuals, _ = self.possible_graph.possible_dependencies(
-                x, allowed_deps=dt.BUILD, transitive=False, strict_depflag=True
-            )
-            self._possible_virtuals.update(virtuals)
-            self._direct_build.update(reals)
-
-        self._total_build, virtuals, _ = self.possible_graph.possible_dependencies(
-            *self._direct_build, allowed_deps=self.all_types
-        )
-        self._possible_virtuals.update(virtuals)
-        self._possible_dependencies = set(self._link_run) | set(self._total_build)
-
-    def possible_packages_facts(self, gen, fn):
-        build_tools = spack.repo.PATH.packages_with_tags("build-tools")
-        gen.h2("Packages with at most a single node")
-        for package_name in sorted(self.possible_dependencies() - build_tools):
-            gen.fact(fn.max_dupes(package_name, 1))
-        gen.newline()
-
-        gen.h2("Packages with at multiple possible nodes (build-tools)")
-        for package_name in sorted(self.possible_dependencies() & build_tools):
-            gen.fact(fn.max_dupes(package_name, 2))
-            gen.fact(fn.multiple_unification_sets(package_name))
-        gen.newline()
-
-        gen.h2("Maximum number of nodes (virtual packages)")
-        for package_name in sorted(self.possible_virtuals()):
-            gen.fact(fn.max_dupes(package_name, 1))
-        gen.newline()
-
-        gen.h2("Possible package in link-run subDAG")
-        for name in sorted(self._link_run):
-            gen.fact(fn.possible_in_link_run(name))
-        gen.newline()
-
-
-class FullDuplicatesCounter(MinimalDuplicatesCounter):
-    def possible_packages_facts(self, gen, fn):
-        build_tools = spack.repo.PATH.packages_with_tags("build-tools")
-        counter = collections.Counter(
-            list(self._link_run) + list(self._total_build) + list(self._direct_build)
-        )
-        gen.h2("Maximum number of nodes")
-        for pkg, count in sorted(counter.items(), key=lambda x: (x[1], x[0])):
-            count = min(count, 2)
-            gen.fact(fn.max_dupes(pkg, count))
-        gen.newline()
-
-        gen.h2("Build unification sets ")
-        for name in sorted(self.possible_dependencies() & build_tools):
-            gen.fact(fn.multiple_unification_sets(name))
-        gen.newline()
-
-        gen.h2("Possible package in link-run subDAG")
-        for name in sorted(self._link_run):
-            gen.fact(fn.possible_in_link_run(name))
-        gen.newline()
-
-        counter = collections.Counter(
-            list(self._link_run_virtuals) + list(self._possible_virtuals)
-        )
-        gen.h2("Maximum number of virtual nodes")
-        for pkg, count in sorted(counter.items(), key=lambda x: (x[1], x[0])):
-            gen.fact(fn.max_dupes(pkg, count))
-        gen.newline()
-
-
-def create_counter(
-    specs: List[spack.spec.Spec], tests: bool, possible_graph: PossibleDependencyGraph
-) -> Counter:
-    strategy = spack.config.CONFIG.get("concretizer:duplicates:strategy", "none")
-    if strategy == "full":
-        return FullDuplicatesCounter(specs, tests=tests, possible_graph=possible_graph)
-    if strategy == "minimal":
-        return MinimalDuplicatesCounter(specs, tests=tests, possible_graph=possible_graph)
-    return NoDuplicatesCounter(specs, tests=tests, possible_graph=possible_graph)

lib/spack/spack/spec.py

@@ -1337,20 +1337,14 @@ class SpecBuildInterface(lang.ObjectWrapper):
         "command", default_handler=_command_default_handler, _indirect=True
     )
 
-    def __init__(
-        self,
-        spec: "Spec",
-        name: str,
-        query_parameters: List[str],
-        _parent: "Spec",
-        is_virtual: bool,
-    ):
+    def __init__(self, spec: "Spec", name: str, query_parameters: List[str], _parent: "Spec"):
         super().__init__(spec)
         # Adding new attributes goes after super() call since the ObjectWrapper
         # resets __dict__ to behave like the passed object
         original_spec = getattr(spec, "wrapped_obj", spec)
         self.wrapped_obj = original_spec
-        self.token = original_spec, name, query_parameters, _parent, is_virtual
+        self.token = original_spec, name, query_parameters, _parent
+        is_virtual = spack.repo.PATH.is_virtual(name)
         self.last_query = QueryState(
             name=name, extra_parameters=query_parameters, isvirtual=is_virtual
         )
@@ -1533,8 +1527,9 @@ def __init__(self, spec_like=None, *, external_path=None, external_modules=None)
         self._external_path = external_path
         self.external_modules = Spec._format_module_list(external_modules)
 
-        # This attribute is used to store custom information for external specs.
-        self.extra_attributes: dict = {}
+        # This attribute is used to store custom information for
+        # external specs. None signal that it was not set yet.
+        self.extra_attributes = None
 
         # This attribute holds the original build copy of the spec if it is
         # deployed differently than it was built. None signals that the spec
@@ -1911,22 +1906,10 @@ def package_class(self):
         """Internal package call gets only the class object for a package.
         Use this to just get package metadata.
         """
-        warnings.warn(
-            "`Spec.package_class` is deprecated and will be removed in version 1.0.0. Use "
-            "`spack.repo.PATH.get_pkg_class(spec.fullname) instead.",
-            category=spack.error.SpackAPIWarning,
-            stacklevel=2,
-        )
         return spack.repo.PATH.get_pkg_class(self.fullname)
 
     @property
     def virtual(self):
-        warnings.warn(
-            "`Spec.virtual` is deprecated and will be removed in version 1.0.0. Use "
-            "`spack.repo.PATH.is_virtual(spec.name)` instead.",
-            category=spack.error.SpackAPIWarning,
-            stacklevel=2,
-        )
         return spack.repo.PATH.is_virtual(self.name)
 
     @property
@@ -2368,10 +2351,15 @@ def to_node_dict(self, hash=ht.dag_hash):
             )
 
         if self.external:
+            if self.extra_attributes:
+                extra_attributes = syaml.sorted_dict(self.extra_attributes)
+            else:
+                extra_attributes = None
+
             d["external"] = {
                 "path": self.external_path,
-                "module": self.external_modules or None,
-                "extra_attributes": syaml.sorted_dict(self.extra_attributes),
+                "module": self.external_modules,
+                "extra_attributes": extra_attributes,
             }
 
         if not self._concrete:
@@ -2826,6 +2814,24 @@ def from_detection(
         s.extra_attributes = extra_attributes
         return s
 
+    def validate_detection(self):
+        """Validate the detection of an external spec.
+
+        This method is used as part of Spack's detection protocol, and is
+        not meant for client code use.
+        """
+        # Assert that _extra_attributes is a Mapping and not None,
+        # which likely means the spec was created with Spec.from_detection
+        msg = 'cannot validate "{0}" since it was not created ' "using Spec.from_detection".format(
+            self
+        )
+        assert isinstance(self.extra_attributes, collections.abc.Mapping), msg
+
+        # Validate the spec calling a package specific method
+        pkg_cls = spack.repo.PATH.get_pkg_class(self.name)
+        validate_fn = getattr(pkg_cls, "validate_detected_spec", lambda x, y: None)
+        validate_fn(self, self.extra_attributes)
+
     def _patches_assigned(self):
         """Whether patches have been assigned to this spec by the concretizer."""
         # FIXME: _patches_in_order_of_appearance is attached after concretization
@@ -2864,7 +2870,7 @@ def inject_patches_variant(root):
 
             # Add any patches from the package to the spec.
             patches = set()
-            for cond, patch_list in spack.repo.PATH.get_pkg_class(s.fullname).patches.items():
+            for cond, patch_list in s.package_class.patches.items():
                 if s.satisfies(cond):
                     for patch in patch_list:
                         patches.add(patch)
@@ -2877,7 +2883,7 @@ def inject_patches_variant(root):
             if dspec.spec.concrete:
                 continue
 
-            pkg_deps = spack.repo.PATH.get_pkg_class(dspec.parent.fullname).dependencies
+            pkg_deps = dspec.parent.package_class.dependencies
 
             patches = []
             for cond, deps_by_name in pkg_deps.items():
@@ -3084,7 +3090,7 @@ def validate_or_raise(self):
         # FIXME: raise just the first one encountered
         for spec in self.traverse():
             # raise an UnknownPackageError if the spec's package isn't real.
-            if spec.name and not spack.repo.PATH.is_virtual(spec.name):
+            if (not spec.virtual) and spec.name:
                 spack.repo.PATH.get_pkg_class(spec.fullname)
 
             # validate compiler in addition to the package name.
@@ -3093,7 +3099,7 @@ def validate_or_raise(self):
                     raise UnsupportedCompilerError(spec.compiler.name)
 
             # Ensure correctness of variants (if the spec is not virtual)
-            if not spack.repo.PATH.is_virtual(spec.name):
+            if not spec.virtual:
                 Spec.ensure_valid_variants(spec)
                 substitute_abstract_variants(spec)
 
@@ -3111,7 +3117,7 @@ def ensure_valid_variants(spec):
         if spec.concrete:
             return
 
-        pkg_cls = spack.repo.PATH.get_pkg_class(spec.fullname)
+        pkg_cls = spec.package_class
         pkg_variants = pkg_cls.variant_names()
         # reserved names are variants that may be set on any package
         # but are not necessarily recorded by the package's class
@@ -3328,9 +3334,7 @@ def intersects(self, other: Union[str, "Spec"], deps: bool = True) -> bool:
 
         # If the names are different, we need to consider virtuals
         if self.name != other.name and self.name and other.name:
-            self_virtual = spack.repo.PATH.is_virtual(self.name)
-            other_virtual = spack.repo.PATH.is_virtual(other.name)
-            if self_virtual and other_virtual:
+            if self.virtual and other.virtual:
                 # Two virtual specs intersect only if there are providers for both
                 lhs = spack.repo.PATH.providers_for(str(self))
                 rhs = spack.repo.PATH.providers_for(str(other))
@@ -3338,8 +3342,8 @@ def intersects(self, other: Union[str, "Spec"], deps: bool = True) -> bool:
                 return bool(intersection)
 
             # A provider can satisfy a virtual dependency.
-            elif self_virtual or other_virtual:
-                virtual_spec, non_virtual_spec = (self, other) if self_virtual else (other, self)
+            elif self.virtual or other.virtual:
+                virtual_spec, non_virtual_spec = (self, other) if self.virtual else (other, self)
                 try:
                     # Here we might get an abstract spec
                     pkg_cls = spack.repo.PATH.get_pkg_class(non_virtual_spec.fullname)
@@ -3444,9 +3448,7 @@ def satisfies(self, other: Union[str, "Spec"], deps: bool = True) -> bool:
         # If the names are different, we need to consider virtuals
         if self.name != other.name and self.name and other.name:
             # A concrete provider can satisfy a virtual dependency.
-            if not spack.repo.PATH.is_virtual(self.name) and spack.repo.PATH.is_virtual(
-                other.name
-            ):
+            if not self.virtual and other.virtual:
                 try:
                     # Here we might get an abstract spec
                     pkg_cls = spack.repo.PATH.get_pkg_class(self.fullname)
@@ -3514,7 +3516,7 @@ def satisfies(self, other: Union[str, "Spec"], deps: bool = True) -> bool:
         lhs_edges: Dict[str, Set[DependencySpec]] = collections.defaultdict(set)
         for rhs_edge in other.traverse_edges(root=False, cover="edges"):
             # If we are checking for ^mpi we need to verify if there is any edge
-            if spack.repo.PATH.is_virtual(rhs_edge.spec.name):
+            if rhs_edge.spec.virtual:
                 rhs_edge.update_virtuals(virtuals=(rhs_edge.spec.name,))
 
             if not rhs_edge.virtuals:
@@ -3560,7 +3562,7 @@ def satisfies(self, other: Union[str, "Spec"], deps: bool = True) -> bool:
 
     def virtual_dependencies(self):
         """Return list of any virtual deps in this spec."""
-        return [spec for spec in self.traverse() if spack.repo.PATH.is_virtual(spec.name)]
+        return [spec for spec in self.traverse() if spec.virtual]
 
     @property  # type: ignore[misc] # decorated prop not supported in mypy
     def patches(self):
@@ -3760,16 +3762,21 @@ def __getitem__(self, name: str):
         # Consider runtime dependencies and direct build/test deps before transitive dependencies,
         # and prefer matches closest to the root.
         try:
-            edge = next((e for e in order() if e.spec.name == name or name in e.virtuals))
+            child: Spec = next(
+                e.spec
+                for e in itertools.chain(
+                    (e for e in order() if e.spec.name == name or name in e.virtuals),
+                    # for historical reasons
+                    (e for e in order() if e.spec.concrete and e.spec.package.provides(name)),
+                )
+            )
         except StopIteration:
             raise KeyError(f"No spec with name {name} in {self}")
 
         if self._concrete:
-            return SpecBuildInterface(
-                edge.spec, name, query_parameters, _parent=self, is_virtual=name in edge.virtuals
-            )
+            return SpecBuildInterface(child, name, query_parameters, _parent=self)
 
-        return edge.spec
+        return child
 
     def __contains__(self, spec):
         """True if this spec or some dependency satisfies the spec.
@@ -3854,13 +3861,6 @@ def _cmp_iter(self):
         for item in self._cmp_node():
             yield item
 
-        # If there is ever a breaking change to hash computation, whether accidental or purposeful,
-        # two specs can be identical modulo DAG hash, depending on what time they were concretized
-        # From the perspective of many operation in Spack (database, build cache, etc) a different
-        # DAG hash means a different spec. Here we ensure that two otherwise identical specs, one
-        # serialized before the hash change and one after, are considered different.
-        yield self.dag_hash() if self.concrete else None
-
         # This needs to be in _cmp_iter so that no specs with different process hashes
         # are considered the same by `__hash__` or `__eq__`.
         #
@@ -4704,7 +4704,7 @@ def concrete(self):
             bool: True or False
         """
         return self.spec._concrete or all(
-            v in self for v in spack.repo.PATH.get_pkg_class(self.spec.fullname).variant_names()
+            v in self for v in self.spec.package_class.variant_names()
         )
 
     def copy(self) -> "VariantMap":
@@ -4764,14 +4764,14 @@ def substitute_abstract_variants(spec: Spec):
         elif name in vt.reserved_names:
             continue
 
-        variant_defs = spack.repo.PATH.get_pkg_class(spec.fullname).variant_definitions(name)
+        variant_defs = spec.package_class.variant_definitions(name)
         valid_defs = []
         for when, vdef in variant_defs:
             if when.intersects(spec):
                 valid_defs.append(vdef)
 
         if not valid_defs:
-            if name not in spack.repo.PATH.get_pkg_class(spec.fullname).variant_names():
+            if name not in spec.package_class.variant_names():
                 unknown.append(name)
             else:
                 whens = [str(when) for when, _ in variant_defs]
@@ -4843,9 +4843,7 @@ def reconstruct_virtuals_on_edges(spec):
     possible_virtuals = set()
     for node in spec.traverse():
         try:
-            possible_virtuals.update(
-                {x for x in node.package.dependencies if spack.repo.PATH.is_virtual(x)}
-            )
+            possible_virtuals.update({x for x in node.package.dependencies if Spec(x).virtual})
         except Exception as e:
             warnings.warn(f"cannot reconstruct virtual dependencies on package {node.name}: {e}")
             continue
@@ -4910,7 +4908,7 @@ def from_node_dict(cls, node):
                 spec.external_modules = node["external"]["module"]
                 if spec.external_modules is False:
                     spec.external_modules = None
-                spec.extra_attributes = node["external"].get("extra_attributes") or {}
+                spec.extra_attributes = node["external"].get("extra_attributes", {})
 
         # specs read in are concrete unless marked abstract
         if node.get("concrete", True):

lib/spack/spack/test/cmd/dependencies.py

@@ -24,24 +24,32 @@
 mpi_deps = ["fake"]
 
 
-@pytest.mark.parametrize(
-    "cli_args,expected",
-    [
-        (["mpileaks"], set(["callpath"] + mpis)),
-        (
-            ["--transitive", "mpileaks"],
-            set(["callpath", "dyninst", "libdwarf", "libelf"] + mpis + mpi_deps),
-        ),
-        (["--transitive", "--deptype=link,run", "dtbuild1"], {"dtlink2", "dtrun2"}),
-        (["--transitive", "--deptype=build", "dtbuild1"], {"dtbuild2", "dtlink2"}),
-        (["--transitive", "--deptype=link", "dtbuild1"], {"dtlink2"}),
-    ],
-)
-def test_direct_dependencies(cli_args, expected, mock_runtimes):
-    out = dependencies(*cli_args)
-    result = set(re.split(r"\s+", out.strip()))
-    expected.update(mock_runtimes)
-    assert expected == result
+def test_direct_dependencies(mock_packages):
+    out = dependencies("mpileaks")
+    actual = set(re.split(r"\s+", out.strip()))
+    expected = set(["callpath"] + mpis)
+    assert expected == actual
+
+
+def test_transitive_dependencies(mock_packages):
+    out = dependencies("--transitive", "mpileaks")
+    actual = set(re.split(r"\s+", out.strip()))
+    expected = set(["callpath", "dyninst", "libdwarf", "libelf"] + mpis + mpi_deps)
+    assert expected == actual
+
+
+def test_transitive_dependencies_with_deptypes(mock_packages):
+    out = dependencies("--transitive", "--deptype=link,run", "dtbuild1")
+    deps = set(re.split(r"\s+", out.strip()))
+    assert set(["dtlink2", "dtrun2"]) == deps
+
+    out = dependencies("--transitive", "--deptype=build", "dtbuild1")
+    deps = set(re.split(r"\s+", out.strip()))
+    assert set(["dtbuild2", "dtlink2"]) == deps
+
+    out = dependencies("--transitive", "--deptype=link", "dtbuild1")
+    deps = set(re.split(r"\s+", out.strip()))
+    assert set(["dtlink2"]) == deps
 
 
 @pytest.mark.db

lib/spack/spack/test/cmd/style.py

@@ -304,8 +304,6 @@ def test_run_import_check(tmp_path: pathlib.Path):
     contents = '''
 import spack.cmd
 import spack.config  # do not drop this import because of this comment
-import spack.repo
-import spack.repo_utils
 
 # this comment about spack.error should not be removed
 class Example(spack.build_systems.autotools.AutotoolsPackage):
@@ -316,7 +314,6 @@ def foo(config: "spack.error.SpackError"):
     # the type hint is quoted, so it should not be removed
     spack.util.executable.Executable("example")
     print(spack.__version__)
-    print(spack.repo_utils.__file__)
 '''
     file.write_text(contents)
     root = str(tmp_path)
@@ -332,7 +329,6 @@ def foo(config: "spack.error.SpackError"):
     output = output_buf.getvalue()
 
     assert "issues.py: redundant import: spack.cmd" in output
-    assert "issues.py: redundant import: spack.repo" in output
     assert "issues.py: redundant import: spack.config" not in output  # comment prevents removal
     assert "issues.py: missing import: spack" in output  # used by spack.__version__
     assert "issues.py: missing import: spack.build_systems.autotools" in output

lib/spack/spack/test/concretization/core.py

@@ -1243,7 +1243,7 @@ def test_transitive_conditional_virtual_dependency(self, mutable_config):
     def test_conditional_provides_or_depends_on(self):
         # Check that we can concretize correctly a spec that can either
         # provide a virtual or depend on it based on the value of a variant
-        s = spack.concretize.concretize_one("v1-consumer ^conditional-provider +disable-v1")
+        s = spack.concretize.concretize_one("conditional-provider +disable-v1")
         assert "v1-provider" in s
         assert s["v1"].name == "v1-provider"
         assert s["v2"].name == "conditional-provider"

lib/spack/spack/test/concretization/preferences.py

@@ -259,7 +259,7 @@ def test_develop(self):
     def test_external_mpi(self):
         # make sure this doesn't give us an external first.
         spec = spack.concretize.concretize_one("mpi")
-        assert not spec.external and spec.package.provides("mpi")
+        assert not spec["mpi"].external
 
         # load config
         conf = syaml.load_config(
@@ -293,7 +293,7 @@ def mock_module(cmd, module):
         monkeypatch.setattr(spack.util.module_cmd, "module", mock_module)
 
         spec = spack.concretize.concretize_one("mpi")
-        assert not spec.external and spec.package.provides("mpi")
+        assert not spec["mpi"].external
 
         # load config
         conf = syaml.load_config(

lib/spack/spack/test/concretization/requirements.py

@@ -1,6 +1,7 @@
 # Copyright Spack Project Developers. See COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
+import os
 import pathlib
 
 import pytest
@@ -199,11 +200,11 @@ def test_requirement_adds_version_satisfies(
 
 @pytest.mark.parametrize("require_checksum", (True, False))
 def test_requirement_adds_git_hash_version(
-    require_checksum, concretize_scope, test_repo, mock_git_version_info, monkeypatch
+    require_checksum, concretize_scope, test_repo, mock_git_version_info, monkeypatch, working_env
 ):
     # A full commit sha is a checksummed version, so this test should pass in both cases
     if require_checksum:
-        monkeypatch.setenv("SPACK_CONCRETIZER_REQUIRE_CHECKSUM", "yes")
+        os.environ["SPACK_CONCRETIZER_REQUIRE_CHECKSUM"] = "yes"
 
     repo_path, filename, commits = mock_git_version_info
     monkeypatch.setattr(

lib/spack/spack/test/conftest.py

@@ -2171,8 +2171,3 @@ def getcode(self):
 
     def info(self):
         return self.headers
-
-
-@pytest.fixture()
-def mock_runtimes(config, mock_packages):
-    return mock_packages.packages_with_tags("runtime")

lib/spack/spack/test/directives.py

@@ -206,7 +206,7 @@ def test_repo(_create_test_repo, monkeypatch, mock_stage):
 )
 def test_redistribute_directive(test_repo, spec_str, distribute_src, distribute_bin):
     spec = spack.spec.Spec(spec_str)
-    assert spack.repo.PATH.get_pkg_class(spec.fullname).redistribute_source(spec) == distribute_src
+    assert spec.package_class.redistribute_source(spec) == distribute_src
     concretized_spec = spack.concretize.concretize_one(spec)
     assert concretized_spec.package.redistribute_binary == distribute_bin
 

lib/spack/spack/test/package_class.py

@@ -1,6 +1,7 @@
 # Copyright Spack Project Developers. See COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
 """Test class methods on Package objects.
 
 This doesn't include methods on package *instances* (like do_patch(),
@@ -15,7 +16,6 @@
 
 import llnl.util.filesystem as fs
 
-import spack.binary_distribution
 import spack.compilers
 import spack.concretize
 import spack.deptypes as dt
@@ -23,11 +23,15 @@
 import spack.install_test
 import spack.package
 import spack.package_base
+import spack.repo
 import spack.spec
-import spack.store
 from spack.build_systems.generic import Package
 from spack.error import InstallError
-from spack.solver.input_analysis import NoStaticAnalysis, StaticAnalysis
+
+
+@pytest.fixture(scope="module")
+def mpi_names(mock_repo_path):
+    return [spec.name for spec in mock_repo_path.providers_for("mpi")]
 
 
 @pytest.fixture()
@@ -49,94 +53,78 @@ def mpileaks_possible_deps(mock_packages, mpi_names):
     return possible
 
 
-@pytest.fixture(params=[NoStaticAnalysis, StaticAnalysis])
-def mock_inspector(config, mock_packages, request):
-    inspector_cls = request.param
-    if inspector_cls is NoStaticAnalysis:
-        return inspector_cls(configuration=config, repo=mock_packages)
-    return inspector_cls(
-        configuration=config,
-        repo=mock_packages,
-        store=spack.store.STORE,
-        binary_index=spack.binary_distribution.BINARY_INDEX,
+def test_possible_dependencies(mock_packages, mpileaks_possible_deps):
+    pkg_cls = spack.repo.PATH.get_pkg_class("mpileaks")
+    expanded_possible_deps = pkg_cls.possible_dependencies(expand_virtuals=True)
+    assert mpileaks_possible_deps == expanded_possible_deps
+    assert {
+        "callpath": {"dyninst", "mpi"},
+        "dyninst": {"libdwarf", "libelf"},
+        "libdwarf": {"libelf"},
+        "libelf": set(),
+        "mpi": set(),
+        "mpileaks": {"callpath", "mpi"},
+    } == pkg_cls.possible_dependencies(expand_virtuals=False)
+
+
+def test_possible_direct_dependencies(mock_packages, mpileaks_possible_deps):
+    pkg_cls = spack.repo.PATH.get_pkg_class("mpileaks")
+    deps = pkg_cls.possible_dependencies(transitive=False, expand_virtuals=False)
+    assert {"callpath": set(), "mpi": set(), "mpileaks": {"callpath", "mpi"}} == deps
+
+
+def test_possible_dependencies_virtual(mock_packages, mpi_names):
+    expected = dict(
+        (name, set(dep for dep in spack.repo.PATH.get_pkg_class(name).dependencies_by_name()))
+        for name in mpi_names
+    )
+
+    # only one mock MPI has a dependency
+    expected["fake"] = set()
+
+    assert expected == spack.package_base.possible_dependencies("mpi", transitive=False)
+
+
+def test_possible_dependencies_missing(mock_packages):
+    pkg_cls = spack.repo.PATH.get_pkg_class("missing-dependency")
+    missing = {}
+    pkg_cls.possible_dependencies(transitive=True, missing=missing)
+    assert {"this-is-a-missing-dependency"} == missing["missing-dependency"]
+
+
+def test_possible_dependencies_with_deptypes(mock_packages):
+    dtbuild1 = spack.repo.PATH.get_pkg_class("dtbuild1")
+
+    assert {
+        "dtbuild1": {"dtrun2", "dtlink2"},
+        "dtlink2": set(),
+        "dtrun2": set(),
+    } == dtbuild1.possible_dependencies(depflag=dt.LINK | dt.RUN)
+
+    assert {
+        "dtbuild1": {"dtbuild2", "dtlink2"},
+        "dtbuild2": set(),
+        "dtlink2": set(),
+    } == dtbuild1.possible_dependencies(depflag=dt.BUILD)
+
+    assert {"dtbuild1": {"dtlink2"}, "dtlink2": set()} == dtbuild1.possible_dependencies(
+        depflag=dt.LINK
     )
 
 
-@pytest.fixture
-def mpi_names(mock_inspector):
-    return [spec.name for spec in mock_inspector.providers_for("mpi")]
-
-
-@pytest.mark.parametrize(
-    "pkg_name,fn_kwargs,expected",
-    [
-        (
-            "mpileaks",
-            {"expand_virtuals": True, "allowed_deps": dt.ALL},
-            {
-                "fake",
-                "mpileaks",
-                "multi-provider-mpi",
-                "callpath",
-                "dyninst",
-                "mpich2",
-                "libdwarf",
-                "zmpi",
-                "low-priority-provider",
-                "intel-parallel-studio",
-                "mpich",
-                "libelf",
-            },
-        ),
-        (
-            "mpileaks",
-            {"expand_virtuals": False, "allowed_deps": dt.ALL},
-            {"callpath", "dyninst", "libdwarf", "libelf", "mpileaks"},
-        ),
-        (
-            "mpileaks",
-            {"expand_virtuals": False, "allowed_deps": dt.ALL, "transitive": False},
-            {"callpath", "mpileaks"},
-        ),
-        ("dtbuild1", {"allowed_deps": dt.LINK | dt.RUN}, {"dtbuild1", "dtrun2", "dtlink2"}),
-        ("dtbuild1", {"allowed_deps": dt.BUILD}, {"dtbuild1", "dtbuild2", "dtlink2"}),
-        ("dtbuild1", {"allowed_deps": dt.LINK}, {"dtbuild1", "dtlink2"}),
-    ],
-)
-def test_possible_dependencies(pkg_name, fn_kwargs, expected, mock_runtimes, mock_inspector):
-    """Tests possible nodes of mpileaks, under different scenarios."""
-    expected.update(mock_runtimes)
-    result, *_ = mock_inspector.possible_dependencies(pkg_name, **fn_kwargs)
-    assert expected == result
-
-
-def test_possible_dependencies_virtual(mock_inspector, mock_packages, mock_runtimes, mpi_names):
-    expected = set(mpi_names)
-    for name in mpi_names:
-        expected.update(dep for dep in mock_packages.get_pkg_class(name).dependencies_by_name())
-    expected.update(mock_runtimes)
-
-    real_pkgs, *_ = mock_inspector.possible_dependencies(
-        "mpi", transitive=False, allowed_deps=dt.ALL
-    )
-    assert expected == real_pkgs
-
-
-def test_possible_dependencies_missing(mock_inspector):
-    result, *_ = mock_inspector.possible_dependencies("missing-dependency", allowed_deps=dt.ALL)
-    assert "this-is-a-missing-dependency" not in result
-
-
-def test_possible_dependencies_with_multiple_classes(
-    mock_inspector, mock_packages, mpileaks_possible_deps
-):
+def test_possible_dependencies_with_multiple_classes(mock_packages, mpileaks_possible_deps):
     pkgs = ["dt-diamond", "mpileaks"]
-    expected = set(mpileaks_possible_deps)
-    expected.update({"dt-diamond", "dt-diamond-left", "dt-diamond-right", "dt-diamond-bottom"})
-    expected.update(mock_packages.packages_with_tags("runtime"))
+    expected = mpileaks_possible_deps.copy()
+    expected.update(
+        {
+            "dt-diamond": set(["dt-diamond-left", "dt-diamond-right"]),
+            "dt-diamond-left": set(["dt-diamond-bottom"]),
+            "dt-diamond-right": set(["dt-diamond-bottom"]),
+            "dt-diamond-bottom": set(),
+        }
+    )
 
-    real_pkgs, *_ = mock_inspector.possible_dependencies(*pkgs, allowed_deps=dt.ALL)
-    assert set(expected) == real_pkgs
+    assert expected == spack.package_base.possible_dependencies(*pkgs)
 
 
 def setup_install_test(source_paths, test_root):

lib/spack/spack/test/spec_semantics.py

@@ -1989,26 +1989,3 @@ def test_equality_discriminate_on_propagation(lhs, rhs):
 
 def test_comparison_multivalued_variants():
     assert Spec("x=a") < Spec("x=a,b") < Spec("x==a,b") < Spec("x==a,b,c")
-
-
-def test_comparison_after_breaking_hash_change():
-    # We simulate a breaking change in DAG hash computation in Spack. We have two specs that are
-    # entirely equal modulo DAG hash. When deserializing these specs, we don't want them to compare
-    # as equal, because DAG hash is used throughout in Spack to distinguish between specs
-    # (e.g. database, build caches, install dir).
-    s = Spec("example@=1.0")
-    s._mark_concrete(True)
-
-    # compute the dag hash and a change to it
-    dag_hash = s.dag_hash()
-    new_dag_hash = f"{'b' if dag_hash[0] == 'a' else 'a'}{dag_hash[1:]}"
-
-    before_breakage = s.to_dict()
-    after_breakage = s.to_dict()
-    after_breakage["spec"]["nodes"][0]["hash"] = new_dag_hash
-    assert before_breakage != after_breakage
-
-    x = Spec.from_dict(before_breakage)
-    y = Spec.from_dict(after_breakage)
-    assert x != y
-    assert len({x, y}) == 2

lib/spack/spack/test/util/elf.py

@@ -201,15 +201,3 @@ def test_drop_redundant_rpath(tmpdir, binary_with_rpaths):
     new_rpaths = elf.get_rpaths(binary)
     assert set(existing_dirs).issubset(new_rpaths)
     assert set(non_existing_dirs).isdisjoint(new_rpaths)
-
-
-def test_elf_invalid_e_shnum(tmp_path):
-    # from llvm/test/Object/Inputs/invalid-e_shnum.elf
-    path = tmp_path / "invalid-e_shnum.elf"
-    with open(path, "wb") as file:
-        file.write(
-            b"\x7fELF\x02\x010000000000\x03\x00>\x0000000000000000000000"
-            b"\x00\x00\x00\x00\x00\x00\x00\x000000000000@\x000000"
-        )
-    with open(path, "rb") as file, pytest.raises(elf.ElfParsingError):
-        elf.parse_elf(file)

lib/spack/spack/util/elf.py

@@ -195,10 +195,7 @@ def parse_program_headers(f: BinaryIO, elf: ElfFile) -> None:
         elf: ELF file parser data
     """
     # Forward to the program header
-    try:
-        f.seek(elf.elf_hdr.e_phoff)
-    except OSError:
-        raise ElfParsingError("Could not seek to program header")
+    f.seek(elf.elf_hdr.e_phoff)
 
     # Here we have to make a mapping from virtual address to offset in the file.
     ph_fmt = elf.byte_order + ("LLQQQQQQ" if elf.is_64_bit else "LLLLLLLL")
@@ -248,10 +245,7 @@ def parse_pt_interp(f: BinaryIO, elf: ElfFile) -> None:
         f: file handle
         elf: ELF file parser data
     """
-    try:
-        f.seek(elf.pt_interp_p_offset)
-    except OSError:
-        raise ElfParsingError("Could not seek to PT_INTERP entry")
+    f.seek(elf.pt_interp_p_offset)
     data = read_exactly(f, elf.pt_interp_p_filesz, "Malformed PT_INTERP entry")
     elf.pt_interp_str = parse_c_string(data)
 
@@ -270,10 +264,7 @@ def find_strtab_size_at_offset(f: BinaryIO, elf: ElfFile, offset: int) -> int:
     """
     section_hdr_fmt = elf.byte_order + ("LLQQQQLLQQ" if elf.is_64_bit else "LLLLLLLLLL")
     section_hdr_size = calcsize(section_hdr_fmt)
-    try:
-        f.seek(elf.elf_hdr.e_shoff)
-    except OSError:
-        raise ElfParsingError("Could not seek to section header table")
+    f.seek(elf.elf_hdr.e_shoff)
     for _ in range(elf.elf_hdr.e_shnum):
         data = read_exactly(f, section_hdr_size, "Malformed section header")
         sh = SectionHeader(*unpack(section_hdr_fmt, data))
@@ -295,10 +286,7 @@ def retrieve_strtab(f: BinaryIO, elf: ElfFile, offset: int) -> bytes:
     Returns: file offset
     """
     size = find_strtab_size_at_offset(f, elf, offset)
-    try:
-        f.seek(offset)
-    except OSError:
-        raise ElfParsingError("Could not seek to string table")
+    f.seek(offset)
     return read_exactly(f, size, "Could not read string table")
 
 
@@ -331,10 +319,7 @@ def parse_pt_dynamic(f: BinaryIO, elf: ElfFile) -> None:
     count_runpath = 0
     count_strtab = 0
 
-    try:
-        f.seek(elf.pt_dynamic_p_offset)
-    except OSError:
-        raise ElfParsingError("Could not seek to PT_DYNAMIC entry")
+    f.seek(elf.pt_dynamic_p_offset)
 
     # In case of broken ELF files, don't read beyond the advertized size.
     for _ in range(elf.pt_dynamic_p_filesz // dynamic_array_size):
@@ -493,10 +478,7 @@ def get_interpreter(path: str) -> Optional[str]:
 def _delete_dynamic_array_entry(
     f: BinaryIO, elf: ElfFile, should_delete: Callable[[int, int], bool]
 ) -> None:
-    try:
-        f.seek(elf.pt_dynamic_p_offset)
-    except OSError:
-        raise ElfParsingError("Could not seek to PT_DYNAMIC entry")
+    f.seek(elf.pt_dynamic_p_offset)
     dynamic_array_fmt = elf.byte_order + ("qQ" if elf.is_64_bit else "lL")
     dynamic_array_size = calcsize(dynamic_array_fmt)
     new_offset = elf.pt_dynamic_p_offset  # points to the new dynamic array

lib/spack/spack/util/package_hash.py

@@ -8,6 +8,7 @@
 import spack.directives_meta
 import spack.error
 import spack.fetch_strategy
+import spack.package_base
 import spack.repo
 import spack.spec
 import spack.util.hash
@@ -60,18 +61,10 @@ class RemoveDirectives(ast.NodeTransformer):
     """
 
     def __init__(self, spec):
-        #: List of attributes to be excluded from a package's hash.
-        self.metadata_attrs = [s.url_attr for s in spack.fetch_strategy.all_strategies] + [
-            "homepage",
-            "url",
-            "urls",
-            "list_url",
-            "extendable",
-            "parallel",
-            "make_jobs",
-            "maintainers",
-            "tags",
-        ]
+        # list of URL attributes and metadata attributes
+        # these will be removed from packages.
+        self.metadata_attrs = [s.url_attr for s in spack.fetch_strategy.all_strategies]
+        self.metadata_attrs += spack.package_base.PackageBase.metadata_attrs
 
         self.spec = spec
         self.in_classdef = False  # used to avoid nested classdefs

share/spack/gitlab/cloud_pipelines/stacks/developer-tools-x86_64_v3-linux-gnu/spack.yaml

@@ -2,16 +2,10 @@ spack:
   view: false
   packages:
     all:
-      require:
-      - target=x86_64_v3
-      - ~cuda
-      - ~rocm
-
+      require: target=x86_64_v3
   concretizer:
     unify: true
     reuse: false
-    static_analysis: true
-
   definitions:
   - default_specs:
       # editors

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

@@ -4,32 +4,16 @@ spack:
   concretizer:
     reuse: false
     unify: false
-    static_analysis: true
 
   packages:
     all:
-      require:
-      - '%gcc target=x86_64_v3'
+      require: '%gcc target=x86_64_v3'
+      providers:
+        blas: [openblas]
+        mpi: [mpich]
       variants: +mpi
-    mpi:
-      require:
-      - mpich
-    blas:
-      require:
-      - openblas
-    lapack:
-      require:
-      - openblas
     binutils:
       variants: +ld +gold +headers +libiberty ~nls
-    cmake:
-      require:
-      - "~qtgui"
-      - '%gcc target=x86_64_v3'
-    gmake:
-      require:
-      - "~guile"
-      - '%gcc target=x86_64_v3'
     hdf5:
       variants: +fortran +hl +shared
     libfabric:
@@ -43,25 +27,19 @@ spack:
         +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
+    mpi:
+      require: mpich
     mpich:
-      require:
-      - '~wrapperrpath ~hwloc'
-      - '%gcc target=x86_64_v3'
+      require: '~wrapperrpath ~hwloc target=x86_64_v3'
     tbb:
-      require:
-      - intel-tbb
+      require: intel-tbb
     vtk-m:
-      require:
-      - "+examples"
-      - '%gcc target=x86_64_v3'
+      require: "+examples target=x86_64_v3"
     visit:
-      require:
-      - "~gui target=x86_64_v3"
+      require: "~gui target=x86_64_v3"
     paraview:
       # Don't build GUI support or GLX rendering for HPC/container deployments
-      require:
-      - "+examples ~qt ^[virtuals=gl] osmesa target=x86_64_v3"
-      - '%gcc target=x86_64_v3'
+      require: "+examples ~qt ^[virtuals=gl] osmesa target=x86_64_v3"
 
   specs:
   # CPU

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

@@ -13,43 +13,29 @@ spack:
         mpi: [mpich]
         tbb: [intel-tbb]
       variants: +mpi
-    acts:
-      require: +analysis +dd4hep +edm4hep +examples +fatras +geant4 +hepmc3 +podio +pythia8 +python ~svg +tgeo cxxstd=20
-    celeritas:
-      require: +geant4 +hepmc3 +root +shared cxxstd=20
-    hip:
-      require: '@5.7.1 +rocm'
-    rivet:
-      require: hepmc=3
-    root:
-      require: +davix +dcache +examples +fftw +fits +fortran +gdml +graphviz +gsl +http +math +minuit +mlp +mysql +opengl +postgres +pythia8 +python +r +roofit +root7 +rpath ~shadow +spectrum +sqlite +ssl +tbb +threads +tmva +tmva-cpu +unuran +vc +vdt +veccore +webgui +x +xml +xrootd # cxxstd=20
-      # note: root cxxstd=20 not concretizable within sherpa
-    vecgeom:
-      require: +gdml +geant4 +root +shared cxxstd=20
 
     # Mark geant4 data as external to prevent wasting bandwidth on GB-scale files
     geant4-data:
-      buildable: false
       externals:
-      - spec: geant4-data@11.3.0
-        prefix: /usr
-      - spec: geant4-data@11.2.2
-        prefix: /usr
-      - spec: geant4-data@11.2.0
-        prefix: /usr
-      - spec: geant4-data@11.1.0
-        prefix: /usr
-      - spec: geant4-data@11.0.0
-        prefix: /usr
+        - spec: geant4-data@11.3.0
+          prefix: /usr
+        - spec: geant4-data@11.2.2
+          prefix: /usr
+        - spec: geant4-data@11.2.0
+          prefix: /usr
+        - spec: geant4-data@11.1.0
+          prefix: /usr
+        - spec: geant4-data@11.0.0
+          prefix: /usr
 
   specs:
   # CPU
-  - acts ~cuda
+  - acts +analysis +dd4hep +edm4hep +examples +fatras +geant4 +hepmc3 +podio +pythia8 +python +tgeo cxxstd=20
   #- agile  # fails on c++>11 compiler
   - alpgen
   - ampt
   - apfel +lhapdf +python
-  - celeritas ~cuda +openmp ~rocm +vecgeom
+  - celeritas +geant4 +hepmc3 +openmp +root +shared +vecgeom cxxstd=20
   - cepgen
   - cernlib +shared
   - collier
@@ -95,29 +81,20 @@ spack:
   - py-uproot +lz4 +xrootd +zstd
   - py-vector
   - pythia8 +evtgen +fastjet +hdf5 +hepmc +hepmc3 +lhapdf ~madgraph5amc +python +rivet ~root # pythia8 and root circularly depend
-  - rivet
-  - root ~cuda
+  - rivet hepmc=3
+  - root +davix +dcache +examples +fftw +fits +fortran +gdml +graphviz +gsl +http +math +minuit +mlp +mysql +opengl +postgres +pythia8 +python +r +roofit +root7 +rpath ~shadow +spectrum +sqlite +ssl +tbb +threads +tmva +unuran +vc +vdt +veccore +webgui +x +xml +xrootd
   - sherpa +analysis ~blackhat +gzip +hepmc3 +hepmc3root +lhapdf +lhole +openloops +pythia ~python ~recola ~rivet +root +ufo cxxstd=20
   - tauola +hepmc3 +lhapdf cxxstd=20
   - thepeg hepmc=3 ~rivet
-  - vecgeom ~cuda
+  - vecgeom +gdml +geant4 +root
   - whizard +fastjet +gosam hepmc=3 +lcio +lhapdf +openloops +openmp +pythia8
   - xrootd +davix +http +krb5 +python +readline +scitokens-cpp
   - yoda +root
 
-  # CUDA
-  #- acts +cuda +traccc cuda_arch=80
-  #- celeritas +cuda ~openmp +vecgeom cuda_arch=80
-  - root +cuda +cudnn +tmva-gpu
-  - vecgeom +cuda cuda_arch=80
-
-  # ROCm
-  - celeritas +rocm amdgpu_target=gfx90a ~openmp ~vecgeom  # only available with ORANGE
-
   ci:
     pipeline-gen:
     - build-job:
-        image: ghcr.io/spack/spack/ubuntu22.04-runner-amd64-gcc-11.4:2024.03.01
+        image: "ghcr.io/spack/spack/ubuntu22.04-runner-amd64-gcc-11.4:2024.03.01"
 
   cdash:
     build-group: HEP

share/spack/gitlab/cloud_pipelines/stacks/ml-linux-aarch64-cuda/spack.yaml

@@ -12,13 +12,6 @@ spack:
       require: ~cuda
     mpi:
       require: openmpi
-    py-torch:
-      require:
-      - target=aarch64
-      - ~rocm
-      - +cuda
-      - cuda_arch=80
-      - ~flash_attention
 
   specs:
     # Horovod

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

@@ -12,13 +12,6 @@ spack:
       require: ~cuda
     mpi:
       require: openmpi
-    py-torch:
-      require:
-      - target=x86_64_v3
-      - ~rocm
-      - +cuda
-      - cuda_arch=80
-      - ~flash_attention
 
   specs:
     # Horovod

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

@@ -11,13 +11,6 @@ spack:
       require: "osmesa"
     mpi:
       require: openmpi
-    py-torch:
-      require:
-      - target=x86_64_v3
-      - ~cuda
-      - +rocm
-      - amdgpu_target=gfx90a
-      - ~flash_attention
 
   specs:
     # Horovod

share/spack/qa/run-unit-tests

@@ -36,7 +36,7 @@ bin/spack -h
 bin/spack help -a
 
 # Profile and print top 20 lines for a simple call to spack spec
-spack -p --lines 20 spec mpileaks%gcc
+spack -p --lines 20 spec mpileaks%gcc ^dyninst@10.0.0 ^elfutils@0.170
 $coverage_run $(which spack) bootstrap status --dev --optional
 
 # Check that we can import Spack packages directly as a first import

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

@@ -40,7 +40,6 @@ class Acts(CMakePackage, CudaPackage):
     # Supported Acts versions
     version("main", branch="main")
     version("master", branch="main", deprecated=True)  # For compatibility
-    version("39.0.0", commit="b055202e2fbdd509bc186eb4782714bc46f38f3f", submodules=True)
     version("38.2.0", commit="9cb8f4494656553fd9b85955938b79b2fac4c9b0", submodules=True)
     version("38.1.0", commit="8a20c88808f10bf4fcdfd7c6e077f23614c3ab90", submodules=True)
     version("38.0.0", commit="0a6b5155e29e3b755bf351b8a76067fff9b4214b", submodules=True)
@@ -194,8 +193,7 @@ class Acts(CMakePackage, CudaPackage):
     version("0.08.1", commit="289bdcc320f0b3ff1d792e29e462ec2d3ea15df6")
     version("0.08.0", commit="99eedb38f305e3a1cd99d9b4473241b7cd641fa9")
 
-    depends_on("c", type="build", when="+dd4hep")  # DD4hep requires C
-    depends_on("cxx", type="build")
+    depends_on("cxx", type="build")  # generated
 
     # Variants that affect the core Acts library
     variant(

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

@@ -4,6 +4,7 @@
 
 import os
 
+from spack.build_environment import optimization_flags
 from spack.package import *
 from spack.pkg.builtin.fftw import FftwBase
 
@@ -94,14 +95,14 @@ class Amdfftw(FftwBase):
     )
     variant(
         "amd-dynamic-dispatcher",
-        default=False,
+        default=True,
         when="@4.1: %aocc@4.1.0:",
         description="Single portable optimized library"
         " to execute on different x86 CPU architectures",
     )
     variant(
         "amd-dynamic-dispatcher",
-        default=False,
+        default=True,
         when="@3.2: %gcc",
         description="Single portable optimized library"
         " to execute on different x86 CPU architectures",
@@ -202,10 +203,11 @@ def configure(self, spec, prefix):
         if not self.compiler.f77 or not self.compiler.fc:
             options.append("--disable-fortran")
 
-        if "avx512" in spec.target:
-            options.append("CFLAGS=-mprefer-vector-width=512")
-        else:
-            options.append("CFLAGS=-mprefer-vector-width=256")
+        # Cross compilation is supported in amd-fftw by making use of target
+        # variable to set AMD_ARCH configure option.
+        # Spack user can not directly use AMD_ARCH for this purpose but should
+        # use target variable to set appropriate -march option in AMD_ARCH.
+        options.append(f"AMD_ARCH={optimization_flags(self.compiler, spec.target)}")
 
         # Specific SIMD support.
         # float and double precisions are supported

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

@@ -19,7 +19,6 @@ class Amdsmi(CMakePackage):
     libraries = ["libamd_smi"]
 
     license("MIT")
-    version("6.3.2", sha256="1ed452eedfe51ac6e615d7bfe0bd7a0614f21113874ae3cbea7df72343cc2d13")
     version("6.3.1", sha256="a3a5a711052e813b9be9304d5e818351d3797f668ec2a455e61253a73429c355")
     version("6.3.0", sha256="7234c46648938239385cd5db57516ed53985b8c09d2f0828ae8f446386d8bd1e")
     version("6.2.4", sha256="5ebe8d0f176bf4a73b0e7000d9c47cb7f65ecca47011d3f9b08b93047dcf7ac5")

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

@@ -27,7 +27,6 @@ class Apfel(AutotoolsPackage, CMakePackage):
     version("3.0.6", sha256="7063c9eee457e030b97926ac166cdaedd84625b31397e1dfd01ae47371fb9f61")
     version("3.0.4", sha256="c7bfae7fe2dc0185981850f2fe6ae4842749339d064c25bf525b4ef412bbb224")
 
-    depends_on("c", type="build")
     depends_on("cxx", type="build")
     depends_on("fortran", type="build")
 

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

@@ -36,7 +36,7 @@ class Apptainer(SingularityBase):
         checked_by="tgamblin",
     )
 
-    version("main", branch="main", get_full_repo=True)  # apptainer version uses git describe
+    version("main", branch="main")
     version("1.3.6", sha256="b5343369e7fdf67572f887d81f8d2b938f099fb39c876d96430d747935960d51")
     version("1.3.5", sha256="fe1c977da952edf1056915b2df67ae2203ef06065d4e4901a237c902329306b2")
     version("1.3.4", sha256="c6ccfdd7c967e5c36dde8711f369c4ac669a16632b79fa0dcaf7e772b7a47397")

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

@@ -8,20 +8,6 @@
 from spack.package import *
 
 _versions = {
-    "6.3.2": {
-        "apt": (
-            "bef302bf344c9297f9fb64a4a93f360721a467185bc4fefbeecb307dd956c504",
-            "https://repo.radeon.com/rocm/apt/6.3.2/pool/main/h/hsa-amd-aqlprofile/hsa-amd-aqlprofile_1.0.0.60302-66~20.04_amd64.deb",
-        ),
-        "yum": (
-            "1e01de060073cb72a97fcddf0f3b637b48cf89a08b34f2447d010031abc0e099",
-            "https://repo.radeon.com/rocm/rhel8/6.3.2/main/hsa-amd-aqlprofile-1.0.0.60302-66.el8.x86_64.rpm",
-        ),
-        "zyp": (
-            "408fb29e09ba59a9e83e8f7d703ba53e1ef3b3acbae1103b2a82d4f87f321752",
-            "https://repo.radeon.com/rocm/zyp/6.3.2/main/hsa-amd-aqlprofile-1.0.0.60302-sles155.66.x86_64.rpm",
-        ),
-    },
     "6.3.1": {
         "apt": (
             "76b129345a1a7caa04859fd738e0ba5bfa6f7bc1ad11171f1a7b2d46e0c0b158",
@@ -289,7 +275,6 @@ class Aqlprofile(Package):
         "6.2.4",
         "6.3.0",
         "6.3.1",
-        "6.3.2",
     ]:
         depends_on(f"hsa-rocr-dev@{ver}", when=f"@{ver}")
 

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

@@ -110,15 +110,22 @@ class Arborx(CMakePackage, CudaPackage, ROCmPackage):
     conflicts("~serial", when="+trilinos")
 
     def cmake_args(self):
-        kokkos_pkg = self["trilinos"] if self.spec.satisfies("+trilinos") else self["kokkos"]
+        spec = self.spec
+
+        if "+trilinos" in spec:
+            kokkos_spec = spec["trilinos"]
+        else:
+            kokkos_spec = spec["kokkos"]
+
         options = [
-            self.define("Kokkos_ROOT", kokkos_pkg.prefix),
+            f"-DKokkos_ROOT={kokkos_spec.prefix}",
             self.define_from_variant("ARBORX_ENABLE_MPI", "mpi"),
         ]
-        if self.spec.satisfies("+cuda"):
-            options.append(self.define("CMAKE_CXX_COMPILER", kokkos_pkg.kokkos_cxx))
-        if self.spec.satisfies("+rocm"):
-            options.append(self.define("CMAKE_CXX_COMPILER", self.spec["hip"].hipcc))
+
+        if spec.satisfies("+cuda"):
+            options.append(f"-DCMAKE_CXX_COMPILER={kokkos_spec.kokkos_cxx}")
+        if spec.satisfies("+rocm"):
+            options.append("-DCMAKE_CXX_COMPILER=%s" % spec["hip"].hipcc)
 
         return options
 

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

@@ -148,14 +148,6 @@ class Ascent(CMakePackage, CudaPackage):
     # https://github.com/Alpine-DAV/ascent/pull/1123
     patch("ascent-find-raja-pr1123.patch", when="@0.9.0")
 
-    # patch for fix typo in coord_type
-    # https://github.com/Alpine-DAV/ascent/pull/1408
-    patch(
-        "https://github.com/Alpine-DAV/ascent/pull/1408.patch?full_index=1",
-        when="@0.9.3 %oneapi@2025:",
-        sha256="7de7f51e57f3d743c39ad80d8783a4eb482be1def51eb2d3f9259246c661f164",
-    )
-
     ##########################################################################
     # package dependencies
     ###########################################################################
@@ -476,9 +468,6 @@ def hostconfig(self):
         if cflags:
             cfg.write(cmake_cache_entry("CMAKE_C_FLAGS", cflags))
         cxxflags = cppflags + " ".join(spec.compiler_flags["cxxflags"])
-        if spec.satisfies("%oneapi@2025:"):
-            cxxflags += "-Wno-error=missing-template-arg-list-after-template-kw "
-            cxxflags += "-Wno-missing-template-arg-list-after-template-kw"
         if cxxflags:
             cfg.write(cmake_cache_entry("CMAKE_CXX_FLAGS", cxxflags))
         fflags = " ".join(spec.compiler_flags["fflags"])

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

@@ -23,10 +23,6 @@ class Bash(AutotoolsPackage, GNUMirrorPackage):
 
     depends_on("c", type="build")  # generated
 
-    depends_on("autoconf", type="build")
-    depends_on("automake", type="build")
-    depends_on("libtool", type="build")
-
     depends_on("ncurses")
     depends_on("readline@8.2:", when="@5.2:")
     depends_on("readline@5.0:")

var/spack/repos/builtin/packages/cbtf-krell/package.py

@@ -4,6 +4,7 @@
 
 import spack.store
 from spack.package import *
+from spack.pkg.builtin.boost import Boost
 
 
 class CbtfKrell(CMakePackage):
@@ -50,17 +51,9 @@ class CbtfKrell(CMakePackage):
         description="build only the FE tool using the runtime_dir to point to target build.",
     )
 
-    # Fix build errors with gcc >= 10
-    patch(
-        "https://github.com/OpenSpeedShop/cbtf-krell/commit/7d47761c6cd9110883bff9ca1e694af1475676f5.patch?full_index=1",
-        sha256="64ed80d18163ca04a67be4a13ac2d2553243fc24c6274d26981472e6e2050b8a",
-    )
-
     # Dependencies for cbtf-krell
     depends_on("cmake@3.0.2:", type="build")
 
-    depends_on("gotcha")
-
     # For rpcgen
     depends_on("rpcsvc-proto", type="build")
 
@@ -71,11 +64,16 @@ class CbtfKrell(CMakePackage):
     depends_on("binutils@2.32")
 
     # For boost
-    depends_on("boost@1.70.0:+filesystem+graph+program_options+python+test+thread")
+    depends_on("boost@1.70.0:")
+
+    # TODO: replace this with an explicit list of components of Boost,
+    # for instance depends_on('boost +filesystem')
+    # See https://github.com/spack/spack/pull/22303 for reference
+    depends_on(Boost.with_default_variants)
 
     # For Dyninst
-    depends_on("dyninst@10.1.0:", when="@develop")
-    depends_on("dyninst@10.1.0:", when="@1.9.3:9999")
+    depends_on("dyninst@10.1.0", when="@develop")
+    depends_on("dyninst@10.1.0", when="@1.9.3:9999")
 
     # For MRNet
     depends_on("mrnet@5.0.1-3:+lwthreads", when="@develop", type=("build", "link", "run"))

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

@@ -2,7 +2,6 @@
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
-from spack.build_systems.cmake import CMakeBuilder
 from spack.package import *
 
 
@@ -72,7 +71,6 @@ class Celeritas(CMakePackage, CudaPackage, ROCmPackage):
     depends_on("nlohmann-json")
     depends_on("geant4@10.5:", when="@0.4.2: +geant4")
     depends_on("geant4@10.5:11.1", when="@0.3.1:0.4.1 +geant4")
-    depends_on("geant4@:11.2", when="@:0.5.0 +geant4")
     depends_on("hepmc3", when="+hepmc3")
     depends_on("root", when="+root")
     depends_on("swig@4.1:", when="+swig")
@@ -83,22 +81,13 @@ class Celeritas(CMakePackage, CudaPackage, ROCmPackage):
     depends_on("py-breathe", type="build", when="+doc")
     depends_on("py-sphinx", type="build", when="+doc")
 
-    with when("+cuda"):
-        depends_on("thrust")
-    with when("+rocm"):
-        depends_on("hiprand")
-        depends_on("rocprim")
-        depends_on("rocrand")
-        depends_on("rocthrust")
-
     for _std in _cxxstd_values:
         depends_on("geant4 cxxstd=" + _std, when="+geant4 cxxstd=" + _std)
         depends_on("root cxxstd=" + _std, when="+root cxxstd=" + _std)
         depends_on("vecgeom cxxstd=" + _std, when="+vecgeom cxxstd=" + _std)
 
-    depends_on("vecgeom +cuda cuda_arch=none", when="+vecgeom +cuda cuda_arch=none")
     for _arch in CudaPackage.cuda_arch_values:
-        depends_on(f"vecgeom +cuda cuda_arch={_arch}", when=f"+vecgeom +cuda cuda_arch={_arch}")
+        depends_on("vecgeom+cuda cuda_arch=" + _arch, when="+vecgeom +cuda cuda_arch=" + _arch)
 
     conflicts("+rocm", when="+cuda", msg="AMD and NVIDIA accelerators are incompatible")
     conflicts("+rocm", when="+vecgeom", msg="HIP support is only available with ORANGE")
@@ -122,7 +111,7 @@ def cmake_args(self):
             from_variant("CELERITAS_BUILD_DOCS", "doc"),
             define("CELERITAS_BUILD_DEMOS", False),
             define("CELERITAS_BUILD_TESTS", False),
-            from_variant("CELERITAS_USE_HIP", "rocm"),
+            from_variant("Celeritas_USE_HIP", "rocm"),
             define("CELERITAS_USE_MPI", False),
             define("CELERITAS_USE_Python", True),
         ]
@@ -130,22 +119,6 @@ def cmake_args(self):
         for pkg in ["CUDA", "Geant4", "HepMC3", "OpenMP", "ROOT", "SWIG", "VecGeom"]:
             args.append(from_variant("CELERITAS_USE_" + pkg, pkg.lower()))
 
-        if self.spec.satisfies("+cuda"):
-            args.append(CMakeBuilder.define_cuda_architectures(self))
-        if self.spec.satisfies("+rocm"):
-            args.append(CMakeBuilder.define_hip_architectures(self))
-            args.append(
-                define(
-                    "CMAKE_HIP_FLAGS",
-                    " ".join(
-                        [
-                            f"-I{self.spec[p].prefix.include}"
-                            for p in ["hiprand", "rocprim", "rocrand", "rocthrust"]
-                        ]
-                    ),
-                )
-            )
-
         if self.version < Version("0.5"):
             # JSON is required for 0.5 and later
             args.append(define("CELERITAS_USE_JSON", True))

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

@@ -21,9 +21,8 @@ class Cepgen(CMakePackage):
         "1.0.2patch1", sha256="333bba0cb1965a98dec127e00c150eab1a515cd348a90f7b1d66d5cd8d206d21"
     )
 
-    depends_on("c", type="build")
-    depends_on("cxx", type="build")
-    depends_on("fortran", type="build")
+    depends_on("cxx", type="build")  # generated
+    depends_on("fortran", type="build")  # generated
 
     generator("ninja")
 

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

@@ -52,8 +52,7 @@ class Clhep(CMakePackage):
     version("2.2.0.4", sha256="9bf7fcd9892313c8d1436bc4a4a285a016c4f8e81e1fc65bdf6783207ae57550")
     version("2.1.2.3", sha256="4353231be09c134507092161cd3ced27a065ca0ebb31ee0256e60a8163c47c3b")
 
-    depends_on("c", type="build")
-    depends_on("cxx", type="build")
+    depends_on("cxx", type="build")  # generated
 
     variant(
         "cxxstd",

var/spack/repos/builtin/packages/clingo-bootstrap/package.py

@@ -92,9 +92,9 @@ def pgo_train(self):
 
         # Set PGO training flags.
         generate_mods = EnvironmentModifications()
-        generate_mods.append_flags("CFLAGS", f"-fprofile-generate={reports}")
-        generate_mods.append_flags("CXXFLAGS", f"-fprofile-generate={reports}")
-        generate_mods.append_flags("LDFLAGS", f"-fprofile-generate={reports}")
+        generate_mods.append_flags("CFLAGS", "-fprofile-generate={}".format(reports))
+        generate_mods.append_flags("CXXFLAGS", "-fprofile-generate={}".format(reports))
+        generate_mods.append_flags("LDFLAGS", "-fprofile-generate={} --verbose".format(reports))
 
         with working_dir(self.build_directory, create=True):
             cmake(*cmake_options, sources, extra_env=generate_mods)
@@ -118,14 +118,14 @@ def pgo_train(self):
         # Clean the build dir.
         rmtree(self.build_directory, ignore_errors=True)
 
-        if self.spec.satisfies("%clang") or self.spec.satisfies("%apple-clang"):
+        if self.spec.satisfies("%clang") or self.spec.satisfies("apple-clang"):
             # merge reports
             use_report = join_path(reports, "merged.prof")
             raw_files = glob.glob(join_path(reports, "*.profraw"))
-            llvm_profdata("merge", f"--output={use_report}", *raw_files)
-            use_flag = f"-fprofile-instr-use={use_report}"
+            llvm_profdata("merge", "--output={}".format(use_report), *raw_files)
+            use_flag = "-fprofile-instr-use={}".format(use_report)
         else:
-            use_flag = f"-fprofile-use={reports}"
+            use_flag = "-fprofile-use={}".format(reports)
 
         # Set PGO use flags for next cmake phase.
         use_mods = EnvironmentModifications()

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

@@ -125,9 +125,9 @@ class Cmake(Package):
     patch("mr-9623.patch", when="@3.22.0:3.30")
 
     depends_on("ninja", when="platform=windows")
-    depends_on("gmake", type=("build", "run"), when="platform=linux")
-    depends_on("gmake", type=("build", "run"), when="platform=darwin")
-    depends_on("gmake", type=("build", "run"), when="platform=freebsd")
+    depends_on("gmake", when="platform=linux")
+    depends_on("gmake", when="platform=darwin")
+    depends_on("gmake", when="platform=freebsd")
 
     depends_on("qt", when="+qtgui")
     # Qt depends on libmng, which is a CMake package;

var/spack/repos/builtin/packages/code-server/package.py

@@ -12,11 +12,58 @@ class CodeServer(Package):
     homepage = "https://coder.com/docs/code-server/latest"
     url = "https://github.com/coder/code-server/releases/download/v4.4.0/code-server-4.4.0-linux-amd64.tar.gz"
 
-    version("4.96.4", sha256="b3f9025d00f2cdf61caf83945ef7225d4a3eb576c4c007e45868f45713e39c8e")
+    version("4.12.0", sha256="d50ee947c4144a6ff2656e664ecbb3f70b75168b8a6e8c3eef47787f3c240c26")
+    version("4.11.0", sha256="4eb233054941ec298caec6fc84dfba0a72c1bc5fadc0fe4896b10f3f4a291d51")
+    version("4.10.1", sha256="f34ce611a9c058982a5e9d200fdf009788e3a564e970b053f4145574bce21b09")
+    version("4.4.0", sha256="e3dd265acb18c2230c72d19bbce619ac5c1bd800ebb26e5e169c4d613069500d")
+    version("4.3.0", sha256="42c71e98de85270b164b023ef8eb0692cf7700c03081ba5a44eaca014a92eb57")
+    version("4.2.0", sha256="98be5bc43ac604c49ae11da259e318b581757a59a25edeee5cf55317ca589ec6")
+    version("4.1.0", sha256="f720b20d1f615b78f3a1be9b1614f3d99ed722b8da3047a4143dbe5835e52ce3")
+    version("4.0.2", sha256="68c11afa3288707a6880920013d8bac7404cd590eb4f63cac92979d0b0bf4fd1")
+    version("4.0.1", sha256="5fe6d26e9d19e685946f0f392d9c822e5303a800cac3ac54a6a2c26104d239fd")
+    version("3.12.0", sha256="d3ca41a55e36d73d80300702af2687e25d440cff6b613bb58a2c88d9b8a0a38f")
+    version("3.11.1", sha256="d34b0b79582196d59d44ac971aabb7f15cb05d837318b94f62470dc8475665e9")
+    version("3.11.0", sha256="dddb97f044ed615a4b8a526328fca6ad703b9c671a28a6090d84668a18755589")
+    version("3.10.2", sha256="47154a6b9e61a0313ba499dd5d948613a17841c2f580612f9721c31964622bf5")
+    version("3.10.1", sha256="18175624df78976488dbcc2a26f2582a71cef5ca0a419e691b1b70da0b27c7ef")
+    version("3.10.0", sha256="5dfce848747f3dd5074cba435cca6730ac99d6d3aa3f50e0a9bf222ad12d3e97")
+    version("3.9.3", sha256="eba42eaf868c2144795b1ac54929e3b252ae35403bf8553b3412a5ac4f365a41")
+    version("3.9.2", sha256="5dbda5ac598223006f72bcb700b133a752aabe4468ed8105806d1d69b5364408")
+    version("3.9.1", sha256="f2648a4387c5a5be8666fb82a7b8a58274c45b91942251ab337e202e078ae8a5")
+    version("3.9.0", sha256="229b0fb95d78a7f7ff0dd55bc151a7521fcd699af50151faf67f6c7ce51110f4")
+    version("3.8.1", sha256="130cf94e3921d0e2adfa33e875bf1aa81fd28548aac94fd31fbc589baa68d45f")
+    version("3.8.0", sha256="70b069f26b30c38cca5fa07b5f25db4d15976de80af3a644b9105d1b5e23e7d5")
+    version("3.7.4", sha256="01ca0e48df44df70cdf702644b013102024a5b30edf6c1fbb2e10b0310056382")
+    version("3.7.3", sha256="7a90f3171c9bc6f65266066e35cc34d48a032910c136ea21116d28f3d7214547")
+    version("3.7.2", sha256="c3054f214392b1b2eb4c77c57cb950ac5d733d349a426975e8bf32028e65a226")
+    version("3.7.1", sha256="bebd9e0c46e0fd4b4f295fd91fc2db135a694614db972095e9842bf7969f4cee")
+    version("3.7.0", sha256="5f8df8ed3924e8e594674d73fb50b00a06efa529f96a0495a5ee8c39c68f3ce1")
+    version("3.6.2", sha256="fd4ac7d61f3e1b2a5034f1706e409c77fad299adef0ede204828d8ecfe317e45")
+    version("3.6.1", sha256="bbe4ef9585e093b3521deb34a0820d2136172271862d6396df21c2e9a26c6374")
+    version("3.6.0", sha256="d1ae4f7263741e0551358d3ed77dad587b33b352d827623d4df25e98f9e21019")
+    version("3.5.0", sha256="90c19c84611becac4af1fb0bd5324ab30f9200769fa7914cd10ccb6b88c657bb")
+    version("3.4.1", sha256="afdb89f4dc7201c03cb35d4f8dc1ccb6060bd0da324a6789089de264d3406817")
+    version("3.4.0", sha256="918c28696b73b96dc9361977f93e788d5c8884b5d4a088d206f05d5b8bccb738")
+    version("3.3.1", sha256="57b9855b20f511e22776ee8a53d1ff30f864498814c4c0b0af3510f71d7a2969")
+    version("3.3.0", sha256="6ca5148a447b41753d5151c5a49a8af24122c7b0808609782aec454e66be4f2c")
+    version("3.2.0", sha256="a8157e8766d6a0e255c72db25e8677a57adb8d889d653e78750b4d26a6ff7400")
+    version("3.1.1", sha256="5dd922d28b2e351c146081849d987fb1e439ee7d53b941434b2eecb2a194da71")
+    version("3.1.0", sha256="5ef85c8f280ce781a176a8b77386b333efe892755a5c325a1782e4eac6016e59")
+    version("3.0.2", sha256="04367cfeb23991f3dc3f1ef8e3dfe5e9d683bb50c9e1fa69e3c21757facfd7ee")
 
     depends_on("c", type="build")  # generated
     depends_on("cxx", type="build")  # generated
 
+    def url_for_version(self, version):
+        if version <= Version("3.2.0"):
+            return "https://github.com/coder/code-server/releases/download/{0}/code-server-{0}-linux-x86_64.tar.gz".format(
+                version
+            )
+        else:
+            return "https://github.com/coder/code-server/releases/download/v{0}/code-server-{0}-linux-amd64.tar.gz".format(
+                version
+            )
+
     def install(self, spec, prefix):
         install_tree(".", prefix)
 

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

@@ -31,9 +31,7 @@ class Collier(CMakePackage):
     version("1.1", sha256="80fd54e2c30029d3d7d646738ae9469ad3a6f5ea7aa1179b951030df048e36bc")
     version("1.0", sha256="54f40c1ed07a6829230af400abfe48791e74e56eac2709c0947cec3410a4473d")
 
-    depends_on("c", type="build")
-    depends_on("cxx", type="build")
-    depends_on("fortran", type="build")
+    depends_on("fortran", type="build")  # generated
 
     @property
     def parallel(self):

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

@@ -29,7 +29,6 @@ def url_for_version(self, version):
     license("NCSA")
 
     version("master", branch="amd-stg-open")
-    version("6.3.2", sha256="1f52e45660ea508d3fe717a9903fe27020cee96de95a3541434838e0193a4827")
     version("6.3.1", sha256="e9c2481cccacdea72c1f8d3970956c447cec47e18dfb9712cbbba76a2820552c")
     version("6.3.0", sha256="79580508b039ca6c50dfdfd7c4f6fbcf489fe1931037ca51324818851eea0c1c")
     version("6.2.4", sha256="7af782bf5835fcd0928047dbf558f5000e7f0207ca39cf04570969343e789528")
@@ -89,7 +88,6 @@ def url_for_version(self, version):
         "6.2.4",
         "6.3.0",
         "6.3.1",
-        "6.3.2",
         "master",
     ]:
         # llvm libs are linked statically, so this *could* be a build dep
@@ -117,7 +115,6 @@ def url_for_version(self, version):
         "6.2.4",
         "6.3.0",
         "6.3.1",
-        "6.3.2",
     ]:
         depends_on(f"rocm-core@{ver}", when=f"@{ver}")
 

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

@@ -66,7 +66,7 @@ def cmake_args(self):
             [
                 "-DKokkosCore_PREFIX={0}".format(kokkos.prefix),
                 "-DKokkosKernels_PREFIX={0}".format(kokkos_kernels.prefix),
-                "-DCMAKE_CXX_COMPILER:STRING={0}".format(self["kokkos"].kokkos_cxx),
+                "-DCMAKE_CXX_COMPILER:STRING={0}".format(spec["kokkos"].kokkos_cxx),
                 # Compadre_USE_PYTHON is OFF by default
                 "-DCompadre_USE_PYTHON=OFF",
             ]

var/spack/repos/builtin/packages/composable-kernel/package.py

@@ -18,7 +18,6 @@ class ComposableKernel(CMakePackage):
     license("MIT")
 
     version("master", branch="develop")
-    version("6.3.2", sha256="875237fe493ff040f8f63b827cddf2ff30a8d3aa18864f87d0e35323c7d62a2d")
     version("6.3.1", sha256="3e8c8c832ca3f9ceb99ab90f654b93b7db876f08d90eda87a70bc629c854052a")
     version("6.3.0", sha256="274f87fc27ec2584c76b5bc7ebdbe172923166b6b93e66a24f98475b44be272d")
     version("6.2.4", sha256="5598aea4bce57dc95b60f2029831edfdade80b30a56e635412cc02b2a6729aa6")
@@ -61,7 +60,6 @@ class ComposableKernel(CMakePackage):
 
     for ver in [
         "master",
-        "6.3.2",
         "6.3.1",
         "6.3.0",
         "6.2.4",

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

@@ -18,8 +18,7 @@ class Cpuinfo(CMakePackage):
     license("BSD-2-Clause")
 
     version("main", branch="main")
-    version("2024-09-26", commit="1e83a2fdd3102f65c6f1fb602c1b320486218a99")  # py-torch@2.6:
-    version("2024-09-06", commit="094fc30b9256f54dad5ad23bcbfb5de74781422f")  # py-torch@2.5.1
+    version("2024-09-06", commit="094fc30b9256f54dad5ad23bcbfb5de74781422f")  # py-torch@2.5.1:
     version("2024-08-30", commit="fa1c679da8d19e1d87f20175ae1ec10995cd3dd3")  # py-torch@2.5.0
     version("2023-11-04", commit="d6860c477c99f1fce9e28eb206891af3c0e1a1d7")  # py-torch@2.3:2.4
     version("2023-01-13", commit="6481e8bef08f606ddd627e4d3be89f64d62e1b8a")  # py-torch@2.1:2.2

var/spack/repos/builtin/packages/cray-mpich/package.py

@@ -4,24 +4,20 @@
 
 import os
 
-import llnl.util.tty as tty
-
 from spack.package import *
 from spack.pkg.builtin.mpich import MpichEnvironmentModifications
 from spack.util.module_cmd import get_path_args_from_module_line, module
 
 
-class CrayMpich(MpichEnvironmentModifications, Package, CudaPackage, ROCmPackage):
+class CrayMpich(MpichEnvironmentModifications, Package):
     """Cray's MPICH is a high performance and widely portable implementation of
     the Message Passing Interface (MPI) standard."""
 
     homepage = "https://docs.nersc.gov/development/compilers/wrappers/"
     has_code = False  # Skip attempts to fetch source that is not available
 
-    maintainers("etiennemlb", "haampie")
+    maintainers("haampie")
 
-    version("8.1.30")
-    version("8.1.28")
     version("8.1.25")
     version("8.1.24")
     version("8.1.21")
@@ -127,86 +123,3 @@ def libs(self):
         libs += find_libraries(libraries, root=self.prefix.lib64, recursive=True)
 
         return libs
-
-    @property
-    def gtl_lib(self):
-        # GPU transport Layer (GTL) handling background:
-        # - The cray-mpich module defines an environment variable per supported
-        # GPU (say, PE_MPICH_GTL_LIBS_amd_gfx942). So we should read the
-        # appropriate variable.
-        # In practice loading a module and checking its content is a PITA. We
-        # simplify by assuming that the GTL for a given vendor (say, AMD), is
-        # one and the same for all the targets of this vendor (one GTL for all
-        # Nvidia or one GTL for all AMD devices).
-        # - Second, except if you have a very weird mpich layout, the GTL are
-        # located in /opt/cray/pe/mpich/<cray_mpich_version>/gtl/lib when the
-        # MPI libraries are in
-        # /opt/cray/pe/mpich/<cray_mpich_version>/ofi/<vendor>/<vendor_version>.
-        # Example:
-        #   /opt/cray/pe/mpich/8.1.28/gtl/lib
-        #   /opt/cray/pe/mpich/8.1.28/ofi/<vendor>/<vendor_version>
-        #   /opt/cray/pe/mpich/8.1.28/ofi/<vendor>/<vendor_version>/../../../gtl/lib
-
-        gtl_kinds = {
-            "cuda": {
-                "lib": "libmpi_gtl_cuda",
-                "variant": "cuda_arch",
-                "values": {"70", "80", "90"},
-            },
-            "rocm": {
-                "lib": "libmpi_gtl_hsa",
-                "variant": "amdgpu_target",
-                "values": {"gfx906", "gfx908", "gfx90a", "gfx940", "gfx942"},
-            },
-        }
-
-        for variant, gtl_kind in gtl_kinds.items():
-            arch_variant = gtl_kind["variant"]
-            arch_values = gtl_kind["values"]
-            gtl_lib = gtl_kind["lib"]
-
-            if self.spec.satisfies(f"+{variant} {arch_variant}=*"):
-                accelerator_architecture_set = set(self.spec.variants[arch_variant].value)
-
-                if len(
-                    accelerator_architecture_set
-                ) >= 1 and not accelerator_architecture_set.issubset(arch_values):
-                    raise InstallError(
-                        f"cray-mpich variant '+{variant} {arch_variant}'"
-                        " was specified but no GTL support could be found for it."
-                    )
-
-                mpi_root = os.path.abspath(
-                    os.path.join(self.prefix, os.pardir, os.pardir, os.pardir)
-                )
-
-                gtl_root = os.path.join(mpi_root, "gtl", "lib")
-
-                gtl_shared_libraries = find_libraries(
-                    [gtl_lib], root=gtl_root, shared=True, recursive=False
-                )
-
-                if len(gtl_shared_libraries) != 1:
-                    raise InstallError(
-                        f"cray-mpich variant '+{variant} {arch_variant}'"
-                        " was specified and GTL support was found for it but"
-                        f" the '{gtl_lib}' could not be correctly found on disk."
-                    )
-
-                gtl_library_fullpath = list(gtl_shared_libraries)[0]
-                tty.debug(f"Selected GTL: {gtl_library_fullpath}")
-
-                gtl_library_directory = os.path.dirname(gtl_library_fullpath)
-                gtl_library_name = os.path.splitext(
-                    os.path.basename(gtl_library_fullpath).split("lib")[1]
-                )[0]
-
-                # Early break. Only one GTL can be active at a given time.
-                return {
-                    "ldflags": [
-                        f"-L{gtl_library_directory}",
-                        f"-Wl,-rpath,{gtl_library_directory}",
-                    ],
-                    "ldlibs": [f"-l{gtl_library_name}"],
-                }
-        return {}

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

@@ -57,9 +57,6 @@ class Davix(CMakePackage):
         description="Use the specified C++ standard when building.",
     )
 
-    depends_on("c", type="build")
-    depends_on("cxx", type="build")
-
     depends_on("pkgconfig", type="build")
     depends_on("libxml2")
     depends_on("uuid")
@@ -71,10 +68,14 @@ class Davix(CMakePackage):
     depends_on("gsoap", when="+thirdparty")
 
     def cmake_args(self):
-        return [
+        cmake_args = [
             self.define_from_variant("CMAKE_CXX_STANDARD", variant="cxxstd"),
             self.define_from_variant("ENABLE_THIRD_PARTY_COPY", variant="thirdparty"),
-            # Disable the use of embedded packages; use Spack to fetch them instead
-            self.define("EMBEDDED_LIBCURL", False),
-            self.define("CMAKE_MACOSX_RPATH", self.spec.satisfies("platform=darwin")),
         ]
+
+        # Disable the use of embedded packages; use Spack to fetch them instead.
+        cmake_args.append("-DEMBEDDED_LIBCURL=OFF")
+
+        if "darwin" in self.spec.architecture:
+            cmake_args.append("-DCMAKE_MACOSX_RPATH=ON")
+        return cmake_args

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

@@ -25,7 +25,6 @@ class Dcap(AutotoolsPackage):
     depends_on("m4", type="build")
 
     depends_on("openssl")
-    depends_on("libxcrypt")
     depends_on("zlib-api")
 
     variant("plugins", default=True, description="Build plugins")

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

@@ -47,8 +47,7 @@ class Dd4hep(CMakePackage):
     version("1.17", sha256="036a9908aaf1e13eaf5f2f43b6f5f4a8bdda8183ddc5befa77a4448dbb485826")
     version("1.16.1", sha256="c8b1312aa88283986f89cc008d317b3476027fd146fdb586f9f1fbbb47763f1a")
 
-    depends_on("c", type="build")
-    depends_on("cxx", type="build")
+    depends_on("cxx", type="build")  # generated
 
     generator("ninja")
 

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

@@ -552,7 +552,7 @@ def cmake_args(self):
                 )
             # Make sure we use the same compiler that Trilinos uses
             if spec.satisfies("+trilinos"):
-                options.extend([self.define("CMAKE_CXX_COMPILER", self["trilinos"].kokkos_cxx)])
+                options.extend([self.define("CMAKE_CXX_COMPILER", spec["trilinos"].kokkos_cxx)])
 
         # Complex support
         options.append(self.define_from_variant("DEAL_II_WITH_COMPLEX_VALUES", "complex"))

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

@@ -19,7 +19,6 @@ class Detray(CMakePackage):
 
     license("MPL-2.0", checked_by="stephenswat")
 
-    version("0.88.0", sha256="bda15501c9c96af961e24ce243982f62051c535b9fe458fb28336a19b54eb47d")
     version("0.87.0", sha256="2d4a76432dd6ddbfc00b88b5d482072e471fefc264b60748bb1f9a123963576e")
     version("0.86.0", sha256="98350c94e8a2395b8712b7102fd449536857e8158b38a96cc913c79b70301170")
     version("0.85.0", sha256="a0121a27fd08243d4a6aab060e8ab379ad5129e96775b45f6a683835767fa8e7")

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

@@ -20,7 +20,6 @@ class DlaFutureFortran(CMakePackage):
     license("BSD-3-Clause")
 
     version("main", branch="main")
-    version("0.3.0", sha256="404ce0d2d3df9317764450158901fd6cb2198b37f5687e9616519100ad6e9ece")
     version("0.2.0", sha256="7fd3e1779c111b35f0d2701a024398b4f6e8dea4af523b6c8617d28c0b7ae61a")
     version("0.1.0", sha256="9fd8a105cbb2f3e1daf8a49910f98fce68ca0b954773dba98a91464cf2e7c1da")
 
@@ -37,7 +36,6 @@ class DlaFutureFortran(CMakePackage):
 
     depends_on("dla-future@0.4.1:0.5 +scalapack", when="@0.1.0")
     depends_on("dla-future@0.6.0: +scalapack", when="@0.2.0:")
-    depends_on("dla-future@0.7.3: +scalapack", when="@0.3:")
     depends_on("dla-future +shared", when="+shared")
 
     depends_on("mpi", when="+test")

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

@@ -17,7 +17,6 @@ class Duckdb(MakefilePackage):
     maintainers("glentner", "teaguesterling")
 
     version("master", branch="master")
-    version("1.2.0", sha256="f22c97e18c071fa8e43b5e150c03c6ab4bcc510cca6e6b50cbe13af8535fa701")
     version("1.1.3", sha256="2aea0af898ad753fee82b776fea1bf78ccbc9648986e7f7a87372df5e74cdb98")
     version("1.1.2", sha256="a3319a64c390ed0454c869b2e4fc0af2413cd49f55cd0f1400aaed9069cdbc4c")
     version("1.1.1", sha256="a764cef80287ccfd8555884d8facbe962154e7c747043c0842cd07873b4d6752")
@@ -93,6 +92,7 @@ class Duckdb(MakefilePackage):
     # Extensions
     variant("autocomplete", default=True, description="Include autocomplete for CLI in build")
     variant("excel", default=True, description="Include Excel formatting extension in build")
+    variant("fts", default=True, description="Include FTS (full text search) support in build")
     variant("httpfs", default=True, description="Include HTTPFS (& S3) support in build")
     variant("inet", default=True, description="Include INET (ip address) support in build")
     variant("json", default=True, description="Include JSON support in build")
@@ -100,14 +100,6 @@ class Duckdb(MakefilePackage):
     variant("tpce", default=False, description="Include TPCE in build")
     variant("tpch", default=False, description="Include TPCH in build")
 
-    # FTS was moved to an out-of-tree extension after v1.1.3
-    variant(
-        "fts",
-        default=True,
-        description="Include FTS (full text search) support in build",
-        when="@:1.1",
-    )
-
     # APIs
     variant("python", default=True, description="Build with Python driver")
     extends("python", when="+python")

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

@@ -33,30 +33,60 @@ class Dyninst(CMakePackage):
     version("10.2.1", sha256="8077c6c7a12577d2ffdcd07521c1eb1b7367da94d9a7ef10bf14053aeaae7ba1")
     version("10.2.0", sha256="4212b93bef4563c7de7dce4258e899bcde52315a571087e87fde9f8040123b43")
     version("10.1.0", sha256="4a121d70c1bb020408a7a697d74602e18250c3c85800f230566fcccd593c0129")
+    version("10.0.0", sha256="542fccf5c57c4fe784b1a9a9e3db01d40b16ad04e7174dc6f7eb23440485ba06")
+    version(
+        "9.3.2", tag="v9.3.2", commit="5d2ddacb273682daa014ae22f17f3575e05b411e", deprecated=True
+    )
+    version(
+        "9.3.0", tag="v9.3.0", commit="9b8e9c1f16d4616b827d2d36955604a8e3fb915c", deprecated=True
+    )
+    version(
+        "9.2.0", tag="v9.2.0", commit="3a6ad66df7294417cf61618acdcfcc0fecccb045", deprecated=True
+    )
+    version(
+        "9.1.0", tag="v9.1.0", commit="df6d090061bae7ff2ba5a6bd57bb2ecbf538ef7a", deprecated=True
+    )
+    version(
+        "8.2.1", tag="v8.2.1", commit="939afcbad1a8273636a3686a31b51dae4f1f0c11", deprecated=True
+    )
 
-    depends_on("c", type="build")
-    depends_on("cxx", type="build")
+    depends_on("c", type="build")  # generated
+    depends_on("cxx", type="build")  # generated
 
-    variant("openmp", default=True, description="Enable OpenMP support for ParseAPI ")
+    variant(
+        "openmp",
+        default=True,
+        description="Enable OpenMP support for ParseAPI " "(version 10.0.0 or later)",
+    )
 
     variant("static", default=False, description="Build static libraries")
 
     variant("stat_dysect", default=False, description="Patch for STAT's DySectAPI")
 
-    depends_on(
-        "boost+atomic+chrono+date_time+filesystem+system+thread+timer+container+random+exception"
+    boost_libs = (
+        "+atomic+chrono+date_time+filesystem+system+thread+timer+container+random+exception"
     )
-    depends_on("boost@1.61.0:", when="@10.1.0:")
-    depends_on("boost@1.67.0:", when="@11.0.0:")
-    depends_on("boost@1.70.0:", when="@12:12.3.0")
-    depends_on("boost@1.71.0:", when="@13:")
+
+    depends_on("boost@1.61.0:" + boost_libs, when="@10.1.0:")
+    depends_on("boost@1.61.0:1.69" + boost_libs, when="@:10.0")
+    depends_on("boost@1.67.0:" + boost_libs, when="@11.0.0:")
+    depends_on("boost@1.70.0:" + boost_libs, when="@12:12.3.0")
+    depends_on("boost@1.71.0:" + boost_libs, when="@13:")
 
     depends_on("libiberty+pic")
 
-    # Parallel DWARF parsing requires a thread-safe libdw
-    depends_on("elfutils", type="link")
+    # Dyninst uses elfutils starting with 9.3.0, and used libelf
+    # before that.
+    # NB: Parallel DWARF parsing in Dyninst 10.2.0 requires a thread-
+    #     safe libdw
     depends_on("elfutils@0.186:", type="link", when="@12.0.1:")
     depends_on("elfutils@0.178:", type="link", when="@10.2.0:")
+    depends_on("elfutils", type="link", when="@9.3.0:10.1")
+    depends_on("libelf", type="link", when="@:9.2")
+
+    # Dyninst uses libdw from elfutils starting with 10.0, and used
+    # libdwarf before that.
+    depends_on("libdwarf", when="@:9")
 
     with when("@:12.3.0"):
         # findtbb.cmake in the dynist repo does not work with recent tbb
@@ -65,16 +95,21 @@ class Dyninst(CMakePackage):
         conflicts("^intel-oneapi-tbb@2021.1:")
         conflicts("^intel-parallel-studio")
 
-    depends_on("tbb")
-    requires("^[virtuals=tbb] intel-tbb@2019.9:", when="@13.0.0:")
+    depends_on("intel-tbb@2019.9:", when="@13.0.0:")
+    depends_on("tbb@2018.6.0:", when="@10.0.0:12.3.0")
 
     with when("@13.0.0:"):
         depends_on("cmake@3.14.0:", type="build")
         conflicts("cmake@3.19.0")
 
     depends_on("cmake@3.4.0:", type="build", when="@10.1.0:")
+    depends_on("cmake@3.0.0:", type="build", when="@10.0.0:10.0")
+    depends_on("cmake@2.8:", type="build", when="@:9")
 
     patch("stat_dysect.patch", when="+stat_dysect")
+    patch("stackanalysis_h.patch", when="@9.2.0")
+    patch("v9.3.2-auto.patch", when="@9.3.2 %gcc@:4.7")
+    patch("tribool.patch", when="@9.3.0:10.0.0 ^boost@1.69:")
     patch(
         "missing_include_deque.patch",
         when="@10.0.0:12.2.0",
@@ -89,21 +124,92 @@ class Dyninst(CMakePackage):
     # Version 11.0 requires a C++11-compliant ABI
     conflicts("%gcc@:5", when="@11.0.0:")
 
+    # Versions 9.3.x used cotire, but have no knob to turn it off.
+    # Cotire has no real use for one-time builds and can break
+    # parallel builds with both static and shared libs.
+    @when("@9.3.0:9.3")
+    def patch(self):
+        filter_file("USE_COTIRE true", "USE_COTIRE false", "cmake/shared.cmake")
+
+    # New style cmake args, starting with 10.1.
+    @when("@10.1.0:")
     def cmake_args(self):
         spec = self.spec
+
         args = [
-            self.define("Boost_ROOT_DIR", spec["boost"].prefix),
-            self.define("ElfUtils_ROOT_DIR", spec["elfutils"].prefix),
-            self.define("LibIberty_ROOT_DIR", spec["libiberty"].prefix),
-            self.define("TBB_ROOT_DIR", spec["tbb"].prefix),
+            "-DBoost_ROOT_DIR=%s" % spec["boost"].prefix,
+            "-DElfUtils_ROOT_DIR=%s" % spec["elf"].prefix,
+            "-DLibIberty_ROOT_DIR=%s" % spec["libiberty"].prefix,
+            "-DTBB_ROOT_DIR=%s" % spec["tbb"].prefix,
             self.define("LibIberty_LIBRARIES", spec["libiberty"].libs),
-            self.define_from_variant("USE_OpenMP", "openmp"),
-            self.define_from_variant("ENABLE_STATIC_LIBS", "static"),
         ]
 
-        # Make sure Dyninst doesn't try to build its own dependencies outside of Spack
+        if spec.satisfies("+openmp"):
+            args.append("-DUSE_OpenMP=ON")
+        else:
+            args.append("-DUSE_OpenMP=OFF")
+
+        if spec.satisfies("+static"):
+            args.append("-DENABLE_STATIC_LIBS=YES")
+        else:
+            args.append("-DENABLE_STATIC_LIBS=NO")
+
+        # Make sure Dyninst doesn't try to build its own dependencies
+        # outside of Spack
         if spec.satisfies("@10.2.0:12.3.0"):
-            args.append(self.define("STERILE_BUILD", True))
+            args.append("-DSTERILE_BUILD=ON")
+
+        return args
+
+    # Old style cmake args, up through 10.0.
+    @when("@:10.0")
+    def cmake_args(self):
+        spec = self.spec
+
+        # Elf -- the directory containing libelf.h.
+        elf = spec["elf"].prefix
+        elf_include = os.path.dirname(find_headers("libelf", elf.include, recursive=True)[0])
+
+        # Dwarf -- the directory containing elfutils/libdw.h or
+        # libdwarf.h, and the path to libdw.so or libdwarf.so.
+        if spec.satisfies("@10.0.0:"):
+            dwarf_include = elf.include
+            dwarf_lib = find_libraries("libdw", elf, recursive=True)
+        else:
+            dwarf_include = spec["libdwarf"].prefix.include
+            dwarf_lib = spec["libdwarf"].libs
+
+        args = [
+            "-DPATH_BOOST=%s" % spec["boost"].prefix,
+            "-DIBERTY_LIBRARIES=%s" % spec["libiberty"].libs,
+            "-DLIBELF_INCLUDE_DIR=%s" % elf_include,
+            "-DLIBELF_LIBRARIES=%s" % spec["elf"].libs,
+            "-DLIBDWARF_INCLUDE_DIR=%s" % dwarf_include,
+            "-DLIBDWARF_LIBRARIES=%s" % dwarf_lib,
+        ]
+
+        # TBB include and lib directories, version 10.x or later.
+        if spec.satisfies("@10.0.0:"):
+            args.extend(
+                [
+                    "-DTBB_INCLUDE_DIRS=%s" % spec["tbb"].prefix.include,
+                    "-DTBB_LIBRARY=%s" % spec["tbb"].prefix.lib,
+                ]
+            )
+
+        # Openmp applies to version 10.x or later.
+        if spec.satisfies("@10.0.0:"):
+            if spec.satisfies("+openmp"):
+                args.append("-DUSE_OpenMP=ON")
+            else:
+                args.append("-DUSE_OpenMP=OFF")
+
+        # Static libs started with version 9.1.0.
+        if spec.satisfies("@9.1.0:"):
+            if spec.satisfies("+static"):
+                args.append("-DENABLE_STATIC_LIBS=1")
+            else:
+                args.append("-DENABLE_STATIC_LIBS=NO")
 
         return args
 

var/spack/repos/builtin/packages/dyninst/stackanalysis_h.patch

@@ -0,0 +1,11 @@
+--- a/dataflowAPI/h/stackanalysis.h	2016-06-29 14:54:14.000000000 -0700
++++ b/dataflowAPI/h/stackanalysis.h	2016-08-02 09:50:13.619079000 -0700
+@@ -331,7 +331,7 @@
+ 
+    // To build intervals, we must replay the effect of each instruction.
+    // To avoid sucking enormous time, we keep those transfer functions around...
+-   typedef std::map<ParseAPI::Block *, std::map<Offset, TransferFuncs>>
++   typedef std::map<ParseAPI::Block *, std::map<Offset, TransferFuncs> >
+       InstructionEffects;
+ 
+    DATAFLOW_EXPORT StackAnalysis();

var/spack/repos/builtin/packages/dyninst/tribool.patch

@@ -0,0 +1,34 @@
+Add explicit casts from boost::tribool to bool.  Starting with 1.69,
+tribool added 'explicit' to the conversion operator to bool, and this
+was breaking the build when using boost >= 1.69.
+
+Patch is from:  https://github.com/dyninst/dyninst/commit/54a2debd9
+
+
+diff --git a/dataflowAPI/rose/util/Message.C b/dataflowAPI/rose/util/Message.C
+index a8a66ad4c..5e276f97d 100644
+--- a/dataflowAPI/rose/util/Message.C
++++ b/dataflowAPI/rose/util/Message.C
+@@ -1123,7 +1123,7 @@ StreamBuf::bake() {
+         destination_->bakeDestinations(message_.properties(), baked_/*out*/);
+         anyUnbuffered_ = false;
+         for (BakedDestinations::const_iterator bi=baked_.begin(); bi!=baked_.end() && !anyUnbuffered_; ++bi)
+-            anyUnbuffered_ = !bi->second.isBuffered;
++            anyUnbuffered_ = static_cast<bool>(!bi->second.isBuffered);
+         isBaked_ = true;
+     }
+ }
+diff --git a/dataflowAPI/rose/util/Message.h b/dataflowAPI/rose/util/Message.h
+index 816f68d2e..03592cb97 100644
+--- a/dataflowAPI/rose/util/Message.h
++++ b/dataflowAPI/rose/util/Message.h
+@@ -386,7 +386,8 @@ struct SAWYER_EXPORT ColorSpec {
+     ColorSpec(AnsiColor fg, AnsiColor bg, bool bold): foreground(fg), background(bg), bold(bold) {}
+ 
+     /** Returns true if this object is in its default-constructed state. */
+-    bool isDefault() const { return COLOR_DEFAULT==foreground && COLOR_DEFAULT==background && !bold; }
++    bool isDefault() const { return COLOR_DEFAULT==foreground && COLOR_DEFAULT==background
++                                    && static_cast<bool>(!bold); }
+ };
+ 
+ /** Colors to use for each message importance.

var/spack/repos/builtin/packages/dyninst/v9.3.2-auto.patch

@@ -0,0 +1,73 @@
+Change some 'for (const auto& t: type)' usage to the older but
+equivalent 'for (auto t = type.begin(); ...)'.  This patch allows
+dyninst 9.3.2 to build with gcc 4.4 which doesn't support the newer
+syntax.
+
+
+diff --git a/dyninstAPI/src/BPatch.C b/dyninstAPI/src/BPatch.C
+index ebf7db0c4..49fe69f9a 100644
+--- a/dyninstAPI/src/BPatch.C
++++ b/dyninstAPI/src/BPatch.C
+@@ -166,16 +166,16 @@ BPatch::BPatch()
+     stdTypes = BPatch_typeCollection::getGlobalTypeCollection();
+     vector<Type *> *sTypes = Symtab::getAllstdTypes();
+     BPatch_type* type = NULL;
+-    for(const auto& t: *sTypes) {
+-        stdTypes->addType(type = new BPatch_type(t));
++    for(auto t = sTypes->begin(); t != sTypes->end(); ++t) {
++        stdTypes->addType(type = new BPatch_type(*t));
+         type->decrRefCount();
+     }
+     delete sTypes;
+ 
+     builtInTypes = new BPatch_builtInTypeCollection;
+     sTypes = Symtab::getAllbuiltInTypes();
+-    for(const auto& t: *sTypes) {
+-        builtInTypes->addBuiltInType(type = new BPatch_type(t));
++    for(auto t = sTypes->begin(); t != sTypes->end(); ++t) {
++        builtInTypes->addBuiltInType(type = new BPatch_type(*t));
+         type->decrRefCount();
+     }
+     delete sTypes;
+diff --git a/dyninstAPI/src/BPatch_collections.C b/dyninstAPI/src/BPatch_collections.C
+index f4e2986a3..129f8b74a 100644
+--- a/dyninstAPI/src/BPatch_collections.C
++++ b/dyninstAPI/src/BPatch_collections.C
+@@ -172,12 +172,12 @@ BPatch_typeCollection::~BPatch_typeCollection()
+     assert(refcount == 0 ||
+            refcount == 1);
+ 
+-    for(const auto& t: typesByName) {
+-        t.second->decrRefCount();
++    for(auto t = typesByName.begin(); t != typesByName.end(); ++t) {
++        t->second->decrRefCount();
+     }
+ 
+-    for(const auto& t: typesByID) {
+-        t.second->decrRefCount();
++    for(auto t = typesByID.begin(); t != typesByID.end(); ++t) {
++        t->second->decrRefCount();
+     }
+ }
+ 
+diff --git a/symtabAPI/src/Collections.C b/symtabAPI/src/Collections.C
+index 7431dd6bf..43c339f45 100644
+--- a/symtabAPI/src/Collections.C
++++ b/symtabAPI/src/Collections.C
+@@ -318,12 +318,12 @@ typeCollection::typeCollection() :
+ typeCollection::~typeCollection()
+ {
+     // delete all of the types
+-    for(const auto& t: typesByName) {
+-        t.second->decrRefCount();
++    for(auto t = typesByName.begin(); t != typesByName.end(); ++t) {
++        t->second->decrRefCount();
+     }
+ 
+-    for(const auto& t: typesByID) {
+-        t.second->decrRefCount();
++    for(auto t = typesByID.begin(); t != typesByID.end(); ++t) {
++        t->second->decrRefCount();
+     }
+ }
+ 

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

@@ -14,7 +14,7 @@ class Enzyme(CMakePackage):
     """
 
     homepage = "https://enzyme.mit.edu"
-    url = "https://github.com/wsmoses/Enzyme/archive/v0.0.172.tar.gz"
+    url = "https://github.com/wsmoses/Enzyme/archive/v0.0.15.tar.gz"
     list_url = "https://github.com/wsmoses/Enzyme/releases"
     git = "https://github.com/wsmoses/Enzyme"
 
@@ -23,7 +23,6 @@ class Enzyme(CMakePackage):
     root_cmakelists_dir = "enzyme"
 
     version("main", branch="main")
-    version("0.0.172", sha256="688200164787d543641cb446cff20f6a8e8b5c92bb7032ebe7f867efa67ceafb")
     version("0.0.135", sha256="49c798534faec7ba524a3ed053dd4352d690a44d3cad5a14915c9398dc9b175b")
     version("0.0.100", sha256="fbc53ec02adc0303ff200d7699afface2d9fbc7350664e6c6d4c527ef11c2e82")
     version("0.0.81", sha256="4c17d0c28f0572a3ab97a60f1e56bbc045ed5dd64c2daac53ae34371ca5e8b34")
@@ -43,8 +42,7 @@ class Enzyme(CMakePackage):
     depends_on("llvm@7:14", when="@0.0.48:0.0.68")
     depends_on("llvm@9:16", when="@0.0.69:0.0.79")
     depends_on("llvm@11:16", when="@0.0.80:0.0.99")
-    depends_on("llvm@11:19", when="@0.0.100:0.0.148")
-    depends_on("llvm@15:19", when="@0.0.149:")
+    depends_on("llvm@11:19", when="@0.0.100:")
     depends_on("cmake@3.13:", type="build")
 
     def cmake_args(self):

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

@@ -22,8 +22,7 @@ class Evtgen(CMakePackage):
     version("02.02.00", sha256="0c626e51cb17e799ad0ffd0beea5cb94d7ac8a5f8777b746aa1944dd26071ecf")
     version("02.00.00", sha256="02372308e1261b8369d10538a3aa65fe60728ab343fcb64b224dac7313deb719")
 
-    depends_on("c", type="build")
-    depends_on("cxx", type="build")
+    depends_on("cxx", type="build")  # generated
 
     variant("pythia8", default=True, description="Build with pythia8")
     variant("tauola", default=False, description="Build with tauola")

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

@@ -121,9 +121,9 @@ def setup_build_environment(self, env):
             # Manually turn off device self.defines to solve Kokkos issues in Nalu-Wind headers
             env.append_flags("CXXFLAGS", "-U__HIP_DEVICE_COMPILE__ -DDESUL_HIP_RDC")
         if self.spec.satisfies("+cuda"):
-            env.set("OMPI_CXX", self["kokkos-nvcc-wrapper"].kokkos_cxx)
-            env.set("MPICH_CXX", self["kokkos-nvcc-wrapper"].kokkos_cxx)
-            env.set("MPICXX_CXX", self["kokkos-nvcc-wrapper"].kokkos_cxx)
+            env.set("OMPI_CXX", self.spec["kokkos-nvcc-wrapper"].kokkos_cxx)
+            env.set("MPICH_CXX", self.spec["kokkos-nvcc-wrapper"].kokkos_cxx)
+            env.set("MPICXX_CXX", self.spec["kokkos-nvcc-wrapper"].kokkos_cxx)
         if self.spec.satisfies("+rocm"):
             env.set("OMPI_CXX", self.spec["hip"].hipcc)
             env.set("MPICH_CXX", self.spec["hip"].hipcc)

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

@@ -73,6 +73,10 @@ class Extrae(AutotoolsPackage):
     depends_on("mpi")
     depends_on("libunwind")
 
+    # TODO: replace this with an explicit list of components of Boost,
+    # for instance depends_on('boost +filesystem')
+    # See https://github.com/spack/spack/pull/22303 for reference
+    depends_on(Boost.with_default_variants)
     depends_on("libdwarf")
     depends_on("elf", type="link")
     depends_on("libxml2")
@@ -88,10 +92,6 @@ class Extrae(AutotoolsPackage):
     variant("dyninst", default=False, description="Use dyninst for dynamic code installation")
     with when("+dyninst"):
         depends_on("dyninst@10.1.0:")
-        # TODO: replace this with an explicit list of components of Boost,
-        # for instance depends_on('boost +filesystem')
-        # See https://github.com/spack/spack/pull/22303 for reference
-        depends_on(Boost.with_default_variants)
         depends_on("elfutils", when="@4.1.2:")
         depends_on("intel-oneapi-tbb", when="@4.1.2:")
 
@@ -127,6 +127,7 @@ def configure_args(self):
         args = [
             "--with-mpi=%s" % mpiroot,
             "--with-unwind=%s" % spec["libunwind"].prefix,
+            "--with-boost=%s" % spec["boost"].prefix,
             "--with-dwarf=%s" % spec["libdwarf"].prefix,
             "--with-elf=%s" % spec["elf"].prefix,
             "--with-xml-prefix=%s" % spec["libxml2"].prefix,
@@ -140,10 +141,7 @@ def configure_args(self):
         )
 
         if spec.satisfies("+dyninst"):
-            args += [
-                f"--with-dyninst={spec['dyninst'].prefix}",
-                f"--with-boost={spec['boost'].prefix}",
-            ]
+            args += ["--with-dyninst={spec['dyninst'].prefix}"]
 
             if spec.satisfies("@4.1.2:"):
                 args += [

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

@@ -19,7 +19,6 @@ class Fargparse(CMakePackage):
     version("develop", branch="develop")
     version("main", branch="main")
 
-    version("1.9.0", sha256="c83c13fa90b6b45adf8d84fe00571174acfa118d2a0d1e8c467f74bbd7dec49d")
     version("1.8.0", sha256="37108bd3c65d892d8c24611ce4d8e5451767e4afe81445fde67eab652178dd01")
     version("1.7.0", sha256="9889e7eca9c020b742787fba2be0ba16edcc3fcf52929261ccb7d09996a35f89")
     version("1.6.0", sha256="055a0af44f50c302f8f20a8bcf3d26c5bbeacf5222cdbaa5b19da4cff56eb9c0")

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

@@ -59,7 +59,6 @@ class Fastjet(AutotoolsPackage):
     version("2.3.0", sha256="e452fe4a9716627bcdb726cfb0917f46a7ac31f6006330a6ccc1abc43d9c2d53")
     # older version use .tar instead of .tar.gz extension, to be added
 
-    depends_on("c", type="build")
     depends_on("cxx", type="build")
     depends_on("fortran", type="build", when="plugins=all")
     depends_on("fortran", type="build", when="plugins=pxcone")

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

@@ -20,16 +20,12 @@ class Flecsi(CMakePackage, CudaPackage, ROCmPackage):
 
     tags = ["e4s"]
 
-    version("2.3.1", tag="v2.3.1", commit="6c04b9b21790533e457764bd7f8f26757db1552f")
+    version("develop", branch="develop", deprecated=True)
     version("2.3.0", tag="v2.3.0", commit="90bc8267fceb02060e54646f73b45d4252aef491")
     version("2.2.1", tag="v2.2.1", commit="84b5b232aebab40610f57387778db80f6c8c84c5")
     version("2.2.0", tag="v2.2.0", commit="dd531ac16c5df124d76e385c6ebe9b9589c2d3ad")
-    version(
-        "2.1.0", tag="v2.1.0", commit="533df139c267e2a93c268dfe68f9aec55de11cf0", deprecated=True
-    )
-    version(
-        "2.0.0", tag="v2.0.0", commit="5ceebadf75d1c98999ea9e9446926722d061ec22", deprecated=True
-    )
+    version("2.1.0", tag="v2.1.0", commit="533df139c267e2a93c268dfe68f9aec55de11cf0")
+    version("2.0.0", tag="v2.0.0", commit="5ceebadf75d1c98999ea9e9446926722d061ec22")
 
     variant(
         "backend",
@@ -50,8 +46,8 @@ class Flecsi(CMakePackage, CudaPackage, ROCmPackage):
         description="Set Caliper Profiling Detail",
         multi=False,
     )
-    variant("kokkos", default=False, description="Enable Kokkos Support", when="@:2.3.1")
-    variant("openmp", default=False, description="Enable OpenMP Support", when="@:2.3.1")
+    variant("kokkos", default=False, description="Enable Kokkos Support")
+    variant("openmp", default=False, description="Enable OpenMP Support")
 
     depends_on("c", type="build")
     depends_on("cxx", type="build")
@@ -73,22 +69,18 @@ class Flecsi(CMakePackage, CudaPackage, ROCmPackage):
     depends_on("boost@1.79.0:", when="@2.2:")
     depends_on("kokkos@3.2.00:", when="+kokkos")
     depends_on("kokkos@3.7:", when="+kokkos @2.3:")
-    depends_on("kokkos@3.7:", when="@2.4:")
-    depends_on("kokkos +cuda", when="+kokkos +cuda")
-    requires("^kokkos +cuda_constexpr +cuda_lambda", when="^kokkos +cuda")
+    depends_on("kokkos +cuda +cuda_constexpr +cuda_lambda", when="+kokkos +cuda")
     depends_on("kokkos +rocm", when="+kokkos +rocm")
     depends_on("kokkos +openmp", when="+kokkos +openmp")
-    requires("+openmp", when="@:2.3.1 ^kokkos +openmp")
-    depends_on("legion@cr-20210122", when="backend=legion @2.0:2.1.0")
+    depends_on("legion@cr-20210122", when="backend=legion @2.0:2.2.1")
     depends_on("legion@cr-20230307", when="backend=legion @2.2.0:2.2.1")
     depends_on("legion@24.03.0:", when="backend=legion @2.2.2:")
-    depends_on("legion@24.09.0:", when="backend=legion @2.3.1:")
     depends_on("legion+shared", when="backend=legion +shared")
     depends_on("legion+hdf5", when="backend=legion +hdf5")
-    depends_on("legion+kokkos", when="backend=legion ^kokkos")
-    depends_on("legion+openmp", when="backend=legion ^kokkos+openmp")
-    depends_on("legion+cuda", when="backend=legion ^kokkos+cuda")
-    depends_on("legion+rocm", when="backend=legion ^kokkos+rocm")
+    depends_on("legion+kokkos", when="backend=legion +kokkos")
+    depends_on("legion+openmp", when="backend=legion +openmp")
+    depends_on("legion+cuda", when="backend=legion +cuda")
+    depends_on("legion+rocm", when="backend=legion +rocm")
     depends_on("hdf5@1.10.7:", when="backend=legion +hdf5")
     depends_on("hpx@1.10.0: cxxstd=17 malloc=system", when="backend=hpx")
     depends_on("mpi")
@@ -105,13 +97,11 @@ class Flecsi(CMakePackage, CudaPackage, ROCmPackage):
 
     # Propagate cuda_arch requirement to dependencies
     for _flag in CudaPackage.cuda_arch_values:
-        requires(f"+cuda cuda_arch={_flag}", when=f"^kokkos +cuda cuda_arch={_flag}")
         depends_on(f"kokkos cuda_arch={_flag}", when=f"+cuda+kokkos cuda_arch={_flag}")
         depends_on(f"legion cuda_arch={_flag}", when=f"backend=legion +cuda cuda_arch={_flag}")
 
     # Propagate amdgpu_target requirement to dependencies
     for _flag in ROCmPackage.amdgpu_targets:
-        requires(f"+rocm amdgpu_target={_flag}", when=f"^kokkos +rocm amdgpu_target={_flag}")
         depends_on(f"kokkos amdgpu_target={_flag}", when=f"+kokkos +rocm amdgpu_target={_flag}")
         depends_on(
             f"legion amdgpu_target={_flag}", when=f"backend=legion +rocm amdgpu_target={_flag}"
@@ -140,14 +130,14 @@ def cmake_args(self):
                 self.define_from_variant("ENABLE_DOCUMENTATION", "doc"),
             ]
 
-            if self.spec.satisfies("^kokkos +rocm"):
+            if self.spec.satisfies("+rocm"):
                 options.append(self.define("CMAKE_CXX_COMPILER", self.spec["hip"].hipcc))
                 options.append(self.define("CMAKE_C_COMPILER", self.spec["hip"].hipcc))
                 if self.spec.satisfies("backend=legion"):
                     # CMake pulled in via find_package(Legion) won't work without this
                     options.append(self.define("HIP_PATH", "{0}/hip".format(spec["hip"].prefix)))
-            elif self.spec.satisfies("^kokkos"):
-                options.append(self.define("CMAKE_CXX_COMPILER", self["kokkos"].kokkos_cxx))
+            elif self.spec.satisfies("+kokkos"):
+                options.append(self.define("CMAKE_CXX_COMPILER", self.spec["kokkos"].kokkos_cxx))
         else:
             # kept for supporing version prior to 2.2
             options = [

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

@@ -22,7 +22,6 @@ class FluxSched(CMakePackage, AutotoolsPackage):
     license("LGPL-3.0-only")
 
     version("master", branch="master")
-    version("0.42.1", sha256="ab56b257e4918ad7e26ef6a375d0ea500a4929bf6633937f0c11c06e21db56b9")
     version("0.41.0", sha256="c89baf72867031847748c157aa99f3b36755f2801df917aae66010d2112e10fe")
     version("0.40.0", sha256="1484befcf8628b0af7833bf550d0bb3864db32b70f2c1bb363c35e30ada1ecc5")
     version("0.39.0", sha256="7e87029f8ad17b9286096e4e2d44982b5d6634908aefde3282497bdd3f44f2f8")

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

@@ -18,8 +18,6 @@ class Fms(CMakePackage):
     license("LGPL-3.0-or-later")
 
     maintainers("AlexanderRichert-NOAA", "Hang-Lei-NOAA", "edwardhartnett", "rem1776", "climbfuji")
-    version("2025.01", sha256="19997ef5468a06c60c1e7af3a56ab7f8a33da814a30827293ca34df5bd888d6f")
-    version("2024.03", sha256="4c1e6bdfafcfec19a4a1c08770c313ab3135d47ec8319f6b07f24d2589caf44d")
     version("2024.02", sha256="47e5740bb066f5eb032e1de163eb762c7258880a2932f4cc4e34e769e0cc2b0e")
     version(
         "2024.01.01", sha256="41c8686bad2b1aed76275e35cbe1af855f7dfce9b6d8907744ea2e8174758f6a"
@@ -66,13 +64,6 @@ class Fms(CMakePackage):
         when="@2023.03",
     )
 
-    variant(
-        "portable_kinds",
-        description="Use iso_c_binding variable kinds",
-        when="@2025.01:",
-        default=False,
-    )
-
     variant("shared", description="Build shared libraries", when="@2024.02:", default=False)
     # What the following patch is providing is available in version 2024.03
     # and newer so it is only needed to 2024.02
@@ -140,7 +131,6 @@ def cmake_args(self):
             self.define_from_variant("OPENMP"),
             self.define_from_variant("ENABLE_QUAD_PRECISION", "quad_precision"),
             self.define_from_variant("SHARED_LIBS", "shared"),
-            self.define_from_variant("PORTABLE_KINDS", "portable_kinds"),
             self.define_from_variant("WITH_YAML", "yaml"),
             self.define_from_variant("CONSTANTS"),
             self.define_from_variant("LARGEFILE", "large_file"),

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

@@ -9,15 +9,12 @@ class G4vg(CMakePackage):
     """Generate VecGeom geometry representations from in-memory Geant4 geometry."""
 
     homepage = "https://github.com/celeritas-project/g4vg"
-    git = "https://github.com/celeritas-project/g4vg.git"
     url = "https://github.com/celeritas-project/g4vg/releases/download/v1.0.1/g4vg-1.0.1.tar.gz"
 
     maintainers("sethrj", "drbenmorgan")
 
     license("Apache-2.0", checked_by="sethrj")
 
-    version("develop", branch="main", get_full_repo=True)
-
     version("1.0.1", sha256="add7ce4bc37889cac2101323a997cea8574b18da6cbeffdab44a2b714d134e99")
 
     variant("debug", default=False, description="Enable runtime debug assertions")

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

@@ -11,7 +11,6 @@
 
 import spack.compiler
 import spack.platforms
-import spack.repo
 import spack.util.libc
 from spack.operating_systems.mac_os import macos_sdk_path, macos_version
 from spack.package import *
@@ -1218,7 +1217,7 @@ def _post_buildcache_install_hook(self):
         )
         if header_dir and all(
             os.path.exists(os.path.join(header_dir, h))
-            for h in spack.repo.PATH.get_pkg_class(libc.fullname).representative_headers
+            for h in libc.package_class.representative_headers
         ):
             relocation_args.append(f"-idirafter {header_dir}")
         else:

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

@@ -49,7 +49,6 @@ class Geant4(CMakePackage):
     version("10.3.3", sha256="bcd36a453da44de9368d1d61b0144031a58e4b43a6d2d875e19085f2700a89d8")
     version("10.0.4", sha256="97f3744366b00143d1eed52f8786823034bbe523f45998106f798af61d83f863")
 
-    depends_on("c", type="build")
     depends_on("cxx", type="build")
 
     _cxxstd_values = (

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

@@ -17,7 +17,6 @@ class Geomodel(CMakePackage):
 
     license("Apache-2.0", checked_by="wdconinc")
 
-    version("6.9.0", sha256="ea34dad8a0cd392e06794b8a1b7407dd6ad617fefd19fb4cccdf36b154749793")
     version("6.8.0", sha256="4dfd5a932955ee2618a880bb210aed9ce7087cfadd31f23f92e5ff009c8384eb")
     version("6.7.0", sha256="bfa69062ba191d0844d7099b28c0d6c3c0f87e726dacfaa21dba7a6f593d34bf")
     version("6.6.0", sha256="3cefeaa409177d45d3fa63e069b6496ca062991b0d7d71275b1748487659e91b")

var/spack/repos/builtin/packages/gftl-shared/package.py

@@ -24,7 +24,6 @@ class GftlShared(CMakePackage):
 
     version("main", branch="main")
 
-    version("1.10.0", sha256="42158fe75fa6bee336516c7531b4c6c4e7252dee2fed541eec740209a07ceafe")
     version("1.9.0", sha256="a3291ce61b512fe88628cc074b02363c2ba3081e7b453371089121988482dd6f")
     version("1.8.0", sha256="3450161508c573ea053b2a23cdbf2a1d6fd6fdb78c162d31fc0019da0f8dd03c")
     version("1.7.0", sha256="8ba567133fcee6b93bc71f61b3bb2053b4b07c6d78f6ad98a04dfc40aa478de7")

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

@@ -38,7 +38,6 @@ class Gftl(CMakePackage):
     version("develop", branch="develop")
     version("main", branch="main")
 
-    version("1.15.1", sha256="13b9e17b7ec5e9ba19d0ee3ad1957bfa2015055b654891c6bb0bbe68b7a040d7")
     version("1.14.0", sha256="bf8e3ba3f708ea327c7eb1a5bd1afdce41358c6df1a323aba0f73575c25d5fc8")
     version("1.13.0", sha256="d8ef4bca5fb67e63dcd69e5377a0cef8336b00178a97450e79010552000d0a52")
     version("1.12.0", sha256="b50e17cb2109372819b3ee676e6e61fd3a517dc4c1ea293937c8a83f03b0cbd6")

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

@@ -99,11 +99,3 @@ def setup_dependent_package(self, module, dspec):
             self.spec.prefix.bin.make,
             jobs=determine_number_of_jobs(parallel=dspec.package.parallel),
         )
-
-    @property
-    def libs(self):
-        return LibraryList([])
-
-    @property
-    def headers(self):
-        return HeaderList([])

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

@@ -38,8 +38,6 @@ class Go(Package):
 
     license("BSD-3-Clause")
 
-    version("1.23.6", sha256="039c5b04e65279daceee8a6f71e70bd05cf5b801782b6f77c6e19e2ed0511222")
-    version("1.23.5", sha256="a6f3f4bbd3e6bdd626f79b668f212fbb5649daf75084fb79b678a0ae4d97423b")
     version("1.23.4", sha256="ad345ac421e90814293a9699cca19dd5238251c3f687980bbcae28495b263531")
     version("1.23.3", sha256="8d6a77332487557c6afa2421131b50f83db4ae3c579c3bc72e670ee1f6968599")
     version("1.23.2", sha256="36930162a93df417d90bd22c6e14daff4705baac2b02418edda671cdfa9cd07f")