setup-env.sh: if exe contains qemu, use /proc/$$/comm instead

lib/spack/docs/build_systems.rst

@@ -66,7 +66,7 @@ on these ideas for each distinct build system that Spack supports:
    build_systems/rocmpackage
    build_systems/sourceforgepackage
 
-For reference, the :py:mod:`Build System API docs <spack_repo.builtin.build_systems>`
+For reference, the :py:mod:`Build System API docs <spack.build_systems>`
 provide a list of build systems and methods/attributes that can be
 overridden. If you are curious about the implementation of a particular
 build system, you can view the source code by running:
@@ -90,7 +90,7 @@ packages. You can quickly find examples by running:
 You can then view these packages with ``spack edit``.
 
 This guide is intended to supplement the
-:py:mod:`Build System API docs <spack_repo.builtin.build_systems>` with examples of
+:py:mod:`Build System API docs <spack.build_systems>` with examples of
 how to override commonly used methods. It also provides rules of thumb
 and suggestions for package developers who are unfamiliar with a
 particular build system.

lib/spack/docs/build_systems/cmakepackage.rst

@@ -129,8 +129,8 @@ Adding flags to cmake
 To add additional flags to the ``cmake`` call, simply override the
 ``cmake_args`` function. The following example defines values for the flags
 ``WHATEVER``, ``ENABLE_BROKEN_FEATURE``, ``DETECT_HDF5``, and ``THREADS`` with
-and without the :meth:`~spack_repo.builtin.build_systems.cmake.CMakeBuilder.define` and
+and without the :meth:`~spack.build_systems.cmake.CMakeBuilder.define` and
-:meth:`~spack_repo.builtin.build_systems.cmake.CMakeBuilder.define_from_variant` helper functions:
+:meth:`~spack.build_systems.cmake.CMakeBuilder.define_from_variant` helper functions:
 
 .. code-block:: python
 

lib/spack/docs/conf.py

@@ -36,7 +36,6 @@
     os.symlink(os.path.abspath("../../.."), link_name, target_is_directory=True)
 sys.path.insert(0, os.path.abspath("_spack_root/lib/spack/external"))
 sys.path.append(os.path.abspath("_spack_root/lib/spack/"))
-sys.path.append(os.path.abspath("_spack_root/var/spack/repos/"))
 
 # Add the Spack bin directory to the path so that we can use its output in docs.
 os.environ["SPACK_ROOT"] = os.path.abspath("_spack_root")
@@ -76,20 +75,11 @@
     apidoc_args
     + [
         "_spack_root/lib/spack/spack",
-        "_spack_root/lib/spack/spack/package.py",  # sphinx struggles with os.chdir re-export.
         "_spack_root/lib/spack/spack/test/*.py",
         "_spack_root/lib/spack/spack/test/cmd/*.py",
     ]
 )
 sphinx_apidoc(apidoc_args + ["_spack_root/lib/spack/llnl"])
-sphinx_apidoc(
-    apidoc_args
-    + [
-        "--implicit-namespaces",
-        "_spack_root/var/spack/repos/spack_repo",
-        "_spack_root/var/spack/repos/spack_repo/builtin/packages",
-    ]
-)
 
 # Enable todo items
 todo_include_todos = True
@@ -218,7 +208,7 @@ def setup(sphinx):
     # Spack classes that are private and we don't want to expose
     ("py:class", "spack.provider_index._IndexBase"),
     ("py:class", "spack.repo._PrependFileLoader"),
-    ("py:class", "spack_repo.builtin.build_systems._checks.BuilderWithDefaults"),
+    ("py:class", "spack.build_systems._checks.BuilderWithDefaults"),
     # Spack classes that intersphinx is unable to resolve
     ("py:class", "spack.version.StandardVersion"),
     ("py:class", "spack.spec.DependencySpec"),

lib/spack/docs/index.rst

@@ -103,7 +103,6 @@ or refer to the full manual below.
    :caption: API Docs
 
    Spack API Docs <spack>
-   Spack Builtin Repo <spack_repo>
    LLNL API Docs <llnl>
 
 ==================

lib/spack/docs/packaging_guide.rst

@@ -69,7 +69,7 @@ An example for ``CMake`` is, for instance:
 
 The predefined steps for each build system are called "phases".
 In general, the name and order in which the phases will be executed can be
-obtained by either reading the API docs at :py:mod:`~.spack_repo.builtin.build_systems`, or
+obtained by either reading the API docs at :py:mod:`~.spack.build_systems`, or
 using the ``spack info`` command:
 
 .. code-block:: console
@@ -158,7 +158,7 @@ builder class explicitly. Using the same example as above, this reads:
            url_fmt = "https://github.com/uclouvain/openjpeg/archive/version.{0}.tar.gz"
            return url_fmt.format(version)
 
-   class CMakeBuilder(spack_repo.builtin.build_systems.cmake.CMakeBuilder):
+   class CMakeBuilder(spack.build_systems.cmake.CMakeBuilder):
        def cmake_args(self):
            args = [
                self.define_from_variant("BUILD_CODEC", "codec"),
@@ -256,7 +256,7 @@ for details):
    #
    # See the Spack documentation for more information on packaging.
    # ----------------------------------------------------------------------------
-   import spack_repo.builtin.build_systems.autotools
+   import spack.build_systems.autotools
    from spack.package import *
 
 
@@ -3697,57 +3697,60 @@ the build system. The build systems currently supported by Spack are:
 +----------------------------------------------------------+----------------------------------+
 |     **API docs**                                         |           **Description**        |
 +==========================================================+==================================+
-| :class:`~spack_repo.builtin.build_systems.generic`       | Generic build system without any |
+| :class:`~spack.build_systems.generic`                    | Generic build system without any |
 |                                                          | base implementation              |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack_repo.builtin.build_systems.makefile`      | Specialized build system for     |
+| :class:`~spack.build_systems.makefile`                   | Specialized build system for     |
 |                                                          | software built invoking          |
 |                                                          | hand-written Makefiles           |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack_repo.builtin.build_systems.autotools`     | Specialized build system for     |
+| :class:`~spack.build_systems.autotools`                  | Specialized build system for     |
 |                                                          | software built using             |
 |                                                          | GNU Autotools                    |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack_repo.builtin.build_systems.cmake`         | Specialized build system for     |
+| :class:`~spack.build_systems.cmake`                      | Specialized build system for     |
 |                                                          | software built using CMake       |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack_repo.builtin.build_systems.maven`         | Specialized build system for     |
+| :class:`~spack.build_systems.maven`                      | Specialized build system for     |
 |                                                          | software built using Maven       |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack_repo.builtin.build_systems.meson`         | Specialized build system for     |
+| :class:`~spack.build_systems.meson`                      | Specialized build system for     |
 |                                                          | software built using Meson       |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack_repo.builtin.build_systems.nmake`         | Specialized build system for     |
+| :class:`~spack.build_systems.nmake`                      | Specialized build system for     |
 |                                                          | software built using NMake       |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack_repo.builtin.build_systems.qmake`         | Specialized build system for     |
+| :class:`~spack.build_systems.qmake`                      | Specialized build system for     |
 |                                                          | software built using QMake       |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack_repo.builtin.build_systems.scons`         | Specialized build system for     |
+| :class:`~spack.build_systems.scons`                      | Specialized build system for     |
 |                                                          | software built using SCons       |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack_repo.builtin.build_systems.waf`           | Specialized build system for     |
+| :class:`~spack.build_systems.waf`                        | Specialized build system for     |
 |                                                          | software built using Waf         |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack_repo.builtin.build_systems.r`             | Specialized build system for     |
+| :class:`~spack.build_systems.r`                          | Specialized build system for     |
 |                                                          | R extensions                     |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack_repo.builtin.build_systems.octave`        | Specialized build system for     |
+| :class:`~spack.build_systems.octave`                     | Specialized build system for     |
 |                                                          | Octave packages                  |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack_repo.builtin.build_systems.python`        | Specialized build system for     |
+| :class:`~spack.build_systems.python`                     | Specialized build system for     |
 |                                                          | Python extensions                |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack_repo.builtin.build_systems.perl`          | Specialized build system for     |
+| :class:`~spack.build_systems.perl`                       | Specialized build system for     |
 |                                                          | Perl extensions                  |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack_repo.builtin.build_systems.ruby`          | Specialized build system for     |
+| :class:`~spack.build_systems.ruby`                       | Specialized build system for     |
 |                                                          | Ruby extensions                  |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack_repo.builtin.build_systems.oneapi`        | Specialized build system for     |
+| :class:`~spack.build_systems.intel`                      | Specialized build system for     |
+|                                                          | licensed Intel software          |
++----------------------------------------------------------+----------------------------------+
+| :class:`~spack.build_systems.oneapi`                     | Specialized build system for     |
 |                                                          | Intel oneAPI software            |
 +----------------------------------------------------------+----------------------------------+
-| :class:`~spack_repo.builtin.build_systems.aspell_dict`   | Specialized build system for     |
+| :class:`~spack.build_systems.aspell_dict`                | Specialized build system for     |
 |                                                          | Aspell dictionaries              |
 +----------------------------------------------------------+----------------------------------+
 
@@ -3759,7 +3762,7 @@ the build system. The build systems currently supported by Spack are:
         rare cases where manual intervention is needed we need to stress that a
         package base class depends on the *build system* being used, not the language of the package.
         For example, a Python extension installed with CMake would ``extends("python")`` and
-        subclass from :class:`~spack_repo.builtin.build_systems.cmake.CMakePackage`.
+        subclass from :class:`~spack.build_systems.cmake.CMakePackage`.
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 Overriding builder methods
@@ -3767,7 +3770,7 @@ Overriding builder methods
 
 Build-system "phases" have default implementations that fit most of the common cases:
 
-.. literalinclude:: _spack_root/var/spack/repos/spack_repo/builtin/build_systems/autotools.py
+.. literalinclude:: _spack_root/lib/spack/spack/build_systems/autotools.py
     :pyobject: AutotoolsBuilder.configure
     :linenos:
 
@@ -3781,7 +3784,7 @@ configure arguments:
 
 Each specific build system has a list of attributes and methods that can be overridden to
 fine-tune the installation of a package without overriding an entire phase. To
-have more information on them the place to go is the API docs of the :py:mod:`~.spack_repo.builtin.build_systems`
+have more information on them the place to go is the API docs of the :py:mod:`~.spack.build_systems`
 module.
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -3823,7 +3826,7 @@ If the ``package.py`` has build instructions in a separate
 
 .. code-block:: python
 
-   class CMakeBuilder(spack_repo.builtin.build_systems.cmake.CMakeBuilder):
+   class CMakeBuilder(spack.build_systems.cmake.CMakeBuilder):
        def install(self, pkg, spec, prefix):
            ...
 
@@ -3836,32 +3839,31 @@ Mixin base classes
 Besides build systems, there are other cases where common metadata and behavior can be extracted
 and reused by many packages. For instance, packages that depend on ``Cuda`` or ``Rocm``, share
 common dependencies and constraints. To factor these attributes into a single place, Spack provides
-a few mixin classes in the ``spack_repo.builtin.build_systems`` module:
+a few mixin classes in the ``spack.build_systems`` module:
 
-+----------------------------------------------------------------------------+----------------------------------+
++---------------------------------------------------------------+----------------------------------+
-|     **API docs**                                                           |           **Description**        |
+|     **API docs**                                              |           **Description**        |
-+============================================================================+==================================+
++===============================================================+==================================+
-| :class:`~spack_repo.builtin.build_systems.cuda.CudaPackage`                | A helper class for packages that |
+| :class:`~spack.build_systems.cuda.CudaPackage`                | A helper class for packages that |
-|                                                                            | use CUDA                         |
+|                                                               | use CUDA                         |
-+----------------------------------------------------------------------------+----------------------------------+
++---------------------------------------------------------------+----------------------------------+
-| :class:`~spack_repo.builtin.build_systems.rocm.ROCmPackage`                | A helper class for packages that |
+| :class:`~spack.build_systems.rocm.ROCmPackage`                | A helper class for packages that |
-|                                                                            | use ROCm                         |
+|                                                               | use ROCm                         |
-+----------------------------------------------------------------------------+----------------------------------+
++---------------------------------------------------------------+----------------------------------+
-| :class:`~spack_repo.builtin.build_systems.gnu.GNUMirrorPackage`            | A helper class for GNU packages  |
+| :class:`~spack.build_systems.gnu.GNUMirrorPackage`            | A helper class for GNU packages  |
-|                                                                            |                                  |
++---------------------------------------------------------------+----------------------------------+
-+----------------------------------------------------------------------------+----------------------------------+
+| :class:`~spack.build_systems.python.PythonExtension`          | A helper class for Python        |
-| :class:`~spack_repo.builtin.build_systems.python.PythonExtension`          | A helper class for Python        |
+|                                                               | extensions                       |
-|                                                                            | extensions                       |
++---------------------------------------------------------------+----------------------------------+
-+----------------------------------------------------------------------------+----------------------------------+
+| :class:`~spack.build_systems.sourceforge.SourceforgePackage`  | A helper class for packages      |
-| :class:`~spack_repo.builtin.build_systems.sourceforge.SourceforgePackage`  | A helper class for packages      |
+|                                                               | from sourceforge.org             |
-|                                                                            | from sourceforge.org             |
++---------------------------------------------------------------+----------------------------------+
-+----------------------------------------------------------------------------+----------------------------------+
+| :class:`~spack.build_systems.sourceware.SourcewarePackage`    | A helper class for packages      |
-| :class:`~spack_repo.builtin.build_systems.sourceware.SourcewarePackage`    | A helper class for packages      |
+|                                                               | from sourceware.org              |
-|                                                                            | from sourceware.org              |
++---------------------------------------------------------------+----------------------------------+
-+----------------------------------------------------------------------------+----------------------------------+
+| :class:`~spack.build_systems.xorg.XorgPackage`                | A helper class for x.org         |
-| :class:`~spack_repo.builtin.build_systems.xorg.XorgPackage`                | A helper class for x.org         |
+|                                                               | packages                         |
-|                                                                            | packages                         |
++---------------------------------------------------------------+----------------------------------+
-+----------------------------------------------------------------------------+----------------------------------+
 
 These classes should be used by adding them to the inheritance tree of the package that needs them,
 for instance:
@@ -3905,13 +3907,13 @@ Additional build instructions are split into separate builder classes:
 
 .. code-block:: python
 
-   class CMakeBuilder(spack_repo.builtin.build_systems.cmake.CMakeBuilder):
+   class CMakeBuilder(spack.build_systems.cmake.CMakeBuilder):
        def cmake_args(self):
            return [
                self.define_from_variant("MY_FEATURE", "my_feature")
            ]
 
-   class AutotoolsBuilder(spack_repo.builtin.build_systems.autotools.AutotoolsBuilder):
+   class AutotoolsBuilder(spack.build_systems.autotools.AutotoolsBuilder):
        def configure_args(self):
            return self.with_or_without("my-feature", variant="my_feature")
 

lib/spack/spack/build_systems/README-intel.rst

@@ -0,0 +1,660 @@
+====================================
+Development Notes on Intel Packages
+====================================
+
+These are notes for concepts and development of
+lib/spack/spack/build_systems/intel.py .
+
+For documentation on how to *use* ``IntelPackage``, see
+lib/spack/docs/build_systems/intelpackage.rst .
+
+-------------------------------------------------------------------------------
+Installation and path handling as implemented in ./intel.py
+-------------------------------------------------------------------------------
+
+
+***************************************************************************
+Prefix differences between Spack-external and Spack-internal installations
+***************************************************************************
+
+
+Problem summary
+~~~~~~~~~~~~~~~~
+
+For Intel packages that were installed external to Spack, ``self.prefix`` will
+be a *component-specific* path (e.g. to an MKL-specific dir hierarchy), whereas
+for a package installed by Spack itself, ``self.prefix`` will be a
+*vendor-level* path that holds one or more components (or parts thereof), and
+must be further qualified down to a particular desired component.
+
+It is possible that a similar conceptual difference is inherent to other
+package families that use a common vendor-style installer.
+
+
+Description
+~~~~~~~~~~~~
+
+Spack makes packages available through two routes, let's call them A and B:
+
+A. Packages pre-installed external to Spack and configured *for* Spack
+B. Packages built and installed *by* Spack.
+
+For a user who is interested in building end-user applications, it should not
+matter through which route any of its dependent packages has been installed.
+Most packages natively support a ``prefix`` concept which unifies the two
+routes just fine.
+
+Intel packages, however, are more complicated because they consist of a number
+of components that are released as a suite of varying extent, like "Intel
+Parallel Studio *Foo* Edition", or subsetted into products like "MKL" or "MPI",
+each of which also contain libraries from other components like the compiler
+runtime and multithreading libraries. For this reason, an Intel package is
+"anchored" during installation at a directory level higher than just the
+user-facing directory that has the conventional hierarchy of ``bin``, ``lib``,
+and others relevant for the end-product.
+
+As a result, internal to Spack, there is a conceptual difference in what
+``self.prefix`` represents for the two routes.
+
+For route A, consider MKL installed outside of Spack. It will likely be one
+product component among other products, at one particular release among others
+that are installed in sibling or cousin directories on the local system.
+Therefore, the path given to Spack in ``packages.yaml`` should be a
+*product-specific and fully version-specific* directory.  E.g., for an
+``intel-mkl`` package, ``self.prefix`` should look like::
+
+  /opt/intel/compilers_and_libraries_2018.1.163/linux/mkl
+
+In this route, the interaction point with the user is encapsulated in an
+environment variable which will be (in pseudo-code)::
+
+    MKLROOT := {self.prefix}
+
+For route B, a Spack-based installation of MKL will be placed in the directory
+given to the ``./install.sh`` script of Intel's package distribution.  This
+directory is taken to be the *vendor*-specific anchor directory, playing the
+same role as the default ``/opt/intel``. In this case, ``self.prefix`` will
+be::
+
+  $SPACK_ROOT/opt/spack/linux-centos6-x86_64/gcc-4.9.3/intel-mkl-2018.1.163-<HASH>
+
+However, now the environment variable will have to be constructed as *several
+directory levels down*::
+
+    MKLROOT := {self.prefix}/compilers_and_libraries_2018.1.163/linux/mkl
+
+A recent post on the Spack mailing list illustrates the confusion when route A
+was taken while route B was the only one that was coded in Spack:
+https://groups.google.com/d/msg/spack/x28qlmqPAys/Ewx6220uAgAJ
+
+
+Solution
+~~~~~~~~~
+
+Introduce a series of functions which will return the appropriate
+directories, regardless of whether the Intel package has been installed
+external or internal to Spack:
+
+==========================  ==================================================
+Function                    Example return values
+--------------------------  --------------------------------------------------
+normalize_suite_dir()       Spack-external installation:
+                                /opt/intel/compilers_and_libraries_2018.1.163
+                            Spack-internal installation:
+                                $SPACK_ROOT/...<HASH>/compilers_and_libraries_2018.1.163
+--------------------------  --------------------------------------------------
+normalize_path('mkl')       <suite_dir>/linux/mkl
+component_bin_dir()         <suite_dir>/linux/mkl/bin
+component_lib_dir()         <suite_dir>/linux/mkl/lib/intel64
+--------------------------  --------------------------------------------------
+normalize_path('mpi')       <suite_dir>/linux/mpi
+component_bin_dir('mpi')    <suite_dir>/linux/mpi/intel64/bin
+component_lib_dir('mpi')    <suite_dir>/linux/mpi/intel64/lib
+==========================  ==================================================
+
+
+*********************************
+Analysis of directory layouts
+*********************************
+
+Let's look at some sample directory layouts, using ``ls -lF``,
+but focusing on names and symlinks only.
+
+Spack-born installation of ``intel-mkl@2018.1.163``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+::
+
+  $ ls -l <prefix>
+
+  bin/
+      - compilervars.*sh (symlinked) ONLY
+
+  compilers_and_libraries -> compilers_and_libraries_2018
+      - generically-named entry point, stable across versions (one hopes)
+
+  compilers_and_libraries_2018/
+      - vaguely-versioned dirname, holding a stub hierarchy --ignorable
+
+      $ ls -l compilers_and_libraries_2018/linux/
+      bin         - actual compilervars.*sh (reg. files) ONLY
+      documentation -> ../../documentation_2018/
+      lib -> ../../compilers_and_libraries_2018.1.163/linux/compiler/lib/
+      mkl -> ../../compilers_and_libraries_2018.1.163/linux/mkl/
+      pkg_bin -> ../../compilers_and_libraries_2018.1.163/linux/bin/
+      samples -> ../../samples_2018/
+      tbb -> ../../compilers_and_libraries_2018.1.163/linux/tbb/
+
+  compilers_and_libraries_2018.1.163/
+      - Main "product" + a minimal set of libs from related products
+
+      $ ls -l compilers_and_libraries_2018.1.163/linux/
+      bin/        - compilervars.*sh, link_install*sh  ONLY
+      mkl/        - Main Product ==> to be assigned to MKLROOT
+      compiler/   - lib/intel64_lin/libiomp5*  ONLY
+      tbb/        - tbb/lib/intel64_lin/gcc4.[147]/libtbb*.so* ONLY
+
+  parallel_studio_xe_2018 -> parallel_studio_xe_2018.1.038/
+  parallel_studio_xe_2018.1.038/
+      - Alternate product packaging - ignorable
+
+      $ ls -l parallel_studio_xe_2018.1.038/
+      bin/               - actual psxevars.*sh (reg. files)
+      compilers_and_libraries_2018 -> <full_path>/comp...aries_2018.1.163
+      documentation_2018 -> <full_path_prefix>/documentation_2018
+      samples_2018 -> <full_path_prefix>/samples_2018
+      ...
+
+  documentation_2018/
+  samples_2018/
+  lib -> compilers_and_libraries/linux/lib/
+  mkl -> compilers_and_libraries/linux/mkl/
+  tbb -> compilers_and_libraries/linux/tbb/
+                  - auxiliaries and convenience links
+
+Spack-external installation of Intel-MPI 2018
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+For MPI, the layout is slightly different than MKL. The prefix will have to
+include an architecture directory (typically ``intel64``), which then contains
+bin/, lib/, ..., all without further architecture branching.  The environment
+variable ``I_MPI_ROOT`` from the API documentation, however, must be the
+package's top directory, not including the architecture.
+
+FIXME: For MANPATH, need the parent dir.
+
+::
+
+  $ ls -lF /opt/intel/compilers_and_libraries_2018.1.163/linux/mpi/
+  bin64 -> intel64/bin/
+  etc64 -> intel64/etc/
+  include64 -> intel64/include/
+  lib64 -> intel64/lib/
+
+  benchmarks/
+  binding/
+  intel64/
+  man/
+  test/
+
+The package contains an MPI-2019 preview; Curiously, its release notes contain
+the tag: "File structure clean-up." I could not find further documentation on
+this, however, so it is unclear what, if any, changes will make it to release.
+
+https://software.intel.com/en-us/articles/restoring-legacy-path-structure-on-intel-mpi-library-2019
+
+::
+
+  $ ls -lF /opt/intel/compilers_and_libraries_2018.1.163/linux/mpi_2019/
+  binding/
+  doc/
+  imb/
+  intel64/
+  man/
+  test/
+
+Spack-external installation of Intel Parallel Studio 2018
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+This is the main product bundle that I actually downloaded and installed on my
+system.  Its nominal installation directory mostly holds merely symlinks
+to components installed in sibling dirs::
+
+  $ ls -lF /opt/intel/parallel_studio_xe_2018.1.038/
+  advisor_2018		 -> /opt/intel/advisor_2018/
+  clck_2018		 -> /opt/intel/clck/2018.1/
+  compilers_and_libraries_2018 -> /opt/intel/comp....aries_2018.1.163/
+  documentation_2018	 -> /opt/intel/documentation_2018/
+  ide_support_2018	 -> /opt/intel/ide_support_2018/
+  inspector_2018		 -> /opt/intel/inspector_2018/
+  itac_2018		 -> /opt/intel/itac/2018.1.017/
+  man		         -> /opt/intel/man/
+  samples_2018		 -> /opt/intel/samples_2018/
+  vtune_amplifier_2018	 -> /opt/intel/vtune_amplifier_2018/
+
+  psxevars.csh		 -> ./bin/psxevars.csh*
+  psxevars.sh		 -> ./bin/psxevars.sh*
+  bin/            - *vars.*sh scripts + sshconnectivity.exp ONLY
+
+  licensing/
+  uninstall*
+
+The only relevant regular files are ``*vars.*sh``, but those also just churn
+through the subordinate vars files of the components.
+
+Installation model
+~~~~~~~~~~~~~~~~~~~~
+
+Intel packages come with an ``install.sh`` script that is normally run
+interactively (in either text or GUI mode) but can run unattended with a
+``--silent <file>`` option, which is of course what Spack uses.
+
+Format of configuration file
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The configuration file is conventionally called ``silent.cfg`` and has a simple
+``token=value`` syntax.  Before using the configuration file, the installer
+calls ``<staging_dir>/pset/check.awk`` to validate it. Example paths to the
+validator are::
+
+      .../l_mkl_2018.1.163/pset/check.awk .
+      .../parallel_studio_xe_2018_update1_cluster_edition/pset/check.awk
+
+The tokens that are accepted in the configuration file vary between packages.
+Tokens not supported for a given package **will cause the installer to stop
+and fail.** This is particularly relevant for license-related tokens, which are
+accepted only for packages that actually require a license.
+
+Reference: [Intel's documentation](https://software.intel.com/en-us/articles/configuration-file-format)
+
+See also:  https://software.intel.com/en-us/articles/silent-installation-guide-for-intel-parallel-studio-xe-composer-edition-for-os-x
+
+The following is from ``.../parallel_studio_xe_2018_update1_cluster_edition/pset/check.awk``:
+
+* Tokens valid for all packages encountered::
+
+    ACCEPT_EULA                                  {accept, decline}
+    CONTINUE_WITH_OPTIONAL_ERROR                 {yes, no}
+    PSET_INSTALL_DIR                             {/opt/intel, , filepat}
+    CONTINUE_WITH_INSTALLDIR_OVERWRITE           {yes, no}
+    COMPONENTS                                   {ALL, DEFAULTS, , anythingpat}
+    PSET_MODE                                    {install, repair, uninstall}
+    NONRPM_DB_DIR                                {, filepat}
+
+    SIGNING_ENABLED                              {yes, no}
+    ARCH_SELECTED                                {IA32, INTEL64, ALL}
+
+* Mentioned but unexplained in ``check.awk``::
+
+    NO_VALIDATE   (?!)
+
+* Only for licensed packages::
+
+    ACTIVATION_SERIAL_NUMBER                     {, snpat}
+    ACTIVATION_LICENSE_FILE                      {, lspat, filepat}
+    ACTIVATION_TYPE                              {exist_lic, license_server,
+                                                 license_file, trial_lic,
+
+    PHONEHOME_SEND_USAGE_DATA                    {yes, no}
+                                                 serial_number}
+
+* Only for Amplifier (obviously)::
+
+    AMPLIFIER_SAMPLING_DRIVER_INSTALL_TYPE       {build, kit}
+    AMPLIFIER_DRIVER_ACCESS_GROUP                {, anythingpat, vtune}
+    AMPLIFIER_DRIVER_PERMISSIONS                 {, anythingpat, 666}
+    AMPLIFIER_LOAD_DRIVER                        {yes, no}
+    AMPLIFIER_C_COMPILER                         {, filepat, auto, none}
+    AMPLIFIER_KERNEL_SRC_DIR                     {, filepat, auto, none}
+    AMPLIFIER_MAKE_COMMAND                       {, filepat, auto, none}
+    AMPLIFIER_INSTALL_BOOT_SCRIPT                {yes, no}
+    AMPLIFIER_DRIVER_PER_USER_MODE               {yes, no}
+
+* Only for MKL and Studio::
+
+    CLUSTER_INSTALL_REMOTE                       {yes, no}
+    CLUSTER_INSTALL_TEMP                         {, filepat}
+    CLUSTER_INSTALL_MACHINES_FILE                {, filepat}
+
+* "backward compatibility" (?)::
+
+    INSTALL_MODE                                 {RPM, NONRPM}
+    download_only                                {yes}
+    download_dir                                 {, filepat}
+
+
+Details for licensing tokens
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Quoted from
+https://software.intel.com/en-us/articles/configuration-file-format,
+for reference:
+
+[ed. note: As of 2018-05, the page incorrectly references ``ACTIVATION``, which
+was used only until about 2012; this is corrected to ``ACTIVATION_TYPE`` here.]
+
+    ...
+
+    ``ACTIVATION_TYPE=exist_lic``
+       This directive tells the install program to look for an existing
+       license during the install process.  This is the preferred method for
+       silent installs.  Take the time to register your serial number and get
+       a license file (see below).  Having a license file on the system
+       simplifies the process.  In addition, as an administrator it is good
+       practice to know WHERE your licenses are saved on your system.
+       License files are plain text files with a .lic extension.  By default
+       these are saved in /opt/intel/licenses which is searched by default.
+       If you save your license elsewhere, perhaps under an NFS folder, set
+       environment variable **INTEL_LICENSE_FILE** to the full path to your
+       license file prior to starting the installation or use the
+       configuration file directive ``ACTIVATION_LICENSE_FILE`` to specify the
+       full pathname to the license file.
+    
+       Options for ``ACTIVATION_TYPE`` are ``{ exist_lic, license_file, server_lic,
+       serial_number, trial_lic }``
+    
+    ``exist_lic``
+       directs the installer to search for a valid license on the server.
+       Searches will utilize the environment variable **INTEL_LICENSE_FILE**,
+       search the default license directory /opt/intel/licenses, or use the
+       ``ACTIVATION_LICENSE_FILE`` directive to find a valid license file.
+    
+    ``license_file``
+       is similar to exist_lic but directs the installer to use
+       ``ACTIVATION_LICENSE_FILE`` to find the license file.
+    
+    ``server_lic``
+       is similar to exist_lic and exist_lic but directs the installer that
+       this is a client installation and a floating license server will be
+       contacted to active the product.  This option will contact your
+       floating license server on your network to retrieve the license
+       information.  BEFORE using this option make sure your client is
+       correctly set up for your network including all networking, routing,
+       name service, and firewall configuration.  Insure that your client has
+       direct access to your floating license server and that firewalls are
+       set up to allow TCP/IP access for the 2 license server ports.
+       server_lic will use **INTEL_LICENSE_FILE** containing a port@host format
+       OR a client license file.  The formats for these are described here
+       https://software.intel.com/en-us/articles/licensing-setting-up-the-client-floating-license
+    
+    ``serial_number``
+       directs the installer to use directive ``ACTIVATION_SERIAL_NUMBER`` for
+       activation.  This method will require the installer to contact an
+       external Intel activation server over the Internet to confirm your
+       serial number.  Due to user and company firewalls, this method is more
+       complex and hence error prone of the available activation methods.  We
+       highly recommend using a license file or license server for activation
+       instead.
+    
+    ``trial_lic``
+       is used only if you do not have an existing license and intend to
+       temporarily evaluate the compiler.  This method creates a temporary
+       trial license in Trusted Storage on your system.
+    
+    ...
+
+*******************
+vars files
+*******************
+
+Intel's product packages contain a number of shell initialization files let's call them vars files.
+
+There are three kinds:
+
+#. Component-specific vars files, such as `mklvars` or `tbbvars`.
+#. Toplevel vars files such as "psxevars". They will scan for all
+   component-specific vars files associated with the product, and source them
+   if found.
+#. Symbolic links to either of them. Links may appear under a different name
+   for backward compatibility.
+
+At present, IntelPackage class is only concerned with the toplevel vars files,
+generally found in the product's toplevel bin/ directory.
+
+For reference, here is an overview of the names and locations of the vars files
+in the 2018 product releases, as seen for Spack-native installation. NB: May be
+incomplete as some components may have been omitted during installation.
+
+Names of vars files seen::
+
+    $ cd opt/spack/linux-centos6-x86_64
+    $ find intel* -name \*vars.sh -printf '%f\n' | sort -u | nl
+     1	advixe-vars.sh
+     2	amplxe-vars.sh
+     3	apsvars.sh
+     4	compilervars.sh
+     5	daalvars.sh
+     6	debuggervars.sh
+     7	iccvars.sh
+     8	ifortvars.sh
+     9	inspxe-vars.sh
+    10	ippvars.sh
+    11	mklvars.sh
+    12	mpivars.sh
+    13	pstlvars.sh
+    14	psxevars.sh
+    15	sep_vars.sh
+    16	tbbvars.sh
+
+Names and locations of vars files, sorted by Spack package name::
+
+    $ cd opt/spack/linux-centos6-x86_64
+    $ find intel* -name \*vars.sh -printf '%y\t%-15f\t%h\n' \
+        | cut -d/ -f1,4- \
+        | sed '/iccvars\|ifortvars/d; s,/,\t\t,; s,\.sh,,; s,  */\(intel[/-]\),\1,' \
+        | sort -k3,3 -k2,2 \
+        | nl \
+        | awk '{printf "%6i %-2s %-16s %-24s %s\n", $1, $2, $3, $4, $5}'
+
+    --------------------------------------------------------------------------------------------------------
+    item no.
+       file or link
+          name of vars file
+                           Spack package name
+                                                    dir relative to Spack install dir
+    --------------------------------------------------------------------------------------------------------
+
+     1 f  mpivars          intel                    compilers_and_libraries_2018.1.163/linux/mpi/intel64/bin
+     2 f  mpivars          intel                    compilers_and_libraries_2018.1.163/linux/mpirt/bin/ia32_lin
+     3 f  tbbvars          intel                    compilers_and_libraries_2018.1.163/linux/tbb/bin
+     4 f  pstlvars         intel                    compilers_and_libraries_2018.1.163/linux/pstl/bin
+     5 f  compilervars     intel                    compilers_and_libraries_2018.1.163/linux/bin
+     6 f  compilervars     intel                    compilers_and_libraries_2018/linux/bin
+     7 l  compilervars     intel                    bin
+     8 f  daalvars         intel-daal               compilers_and_libraries_2018.2.199/linux/daal/bin
+     9 f  psxevars         intel-daal               parallel_studio_xe_2018.2.046/bin
+    10 l  psxevars         intel-daal               parallel_studio_xe_2018.2.046
+    11 f  compilervars     intel-daal               compilers_and_libraries_2018.2.199/linux/bin
+    12 f  compilervars     intel-daal               compilers_and_libraries_2018/linux/bin
+    13 l  compilervars     intel-daal               bin
+    14 f  ippvars          intel-ipp                compilers_and_libraries_2018.2.199/linux/ipp/bin
+    15 f  psxevars         intel-ipp                parallel_studio_xe_2018.2.046/bin
+    16 l  psxevars         intel-ipp                parallel_studio_xe_2018.2.046
+    17 f  compilervars     intel-ipp                compilers_and_libraries_2018.2.199/linux/bin
+    18 f  compilervars     intel-ipp                compilers_and_libraries_2018/linux/bin
+    19 l  compilervars     intel-ipp                bin
+    20 f  mklvars          intel-mkl                compilers_and_libraries_2018.2.199/linux/mkl/bin
+    21 f  psxevars         intel-mkl                parallel_studio_xe_2018.2.046/bin
+    22 l  psxevars         intel-mkl                parallel_studio_xe_2018.2.046
+    23 f  compilervars     intel-mkl                compilers_and_libraries_2018.2.199/linux/bin
+    24 f  compilervars     intel-mkl                compilers_and_libraries_2018/linux/bin
+    25 l  compilervars     intel-mkl                bin
+    26 f  mpivars          intel-mpi                compilers_and_libraries_2018.2.199/linux/mpi_2019/intel64/bin
+    27 f  mpivars          intel-mpi                compilers_and_libraries_2018.2.199/linux/mpi/intel64/bin
+    28 f  psxevars         intel-mpi                parallel_studio_xe_2018.2.046/bin
+    29 l  psxevars         intel-mpi                parallel_studio_xe_2018.2.046
+    30 f  compilervars     intel-mpi                compilers_and_libraries_2018.2.199/linux/bin
+    31 f  compilervars     intel-mpi                compilers_and_libraries_2018/linux/bin
+    32 l  compilervars     intel-mpi                bin
+    33 f  apsvars          intel-parallel-studio    vtune_amplifier_2018.1.0.535340
+    34 l  apsvars          intel-parallel-studio    performance_snapshots_2018.1.0.535340
+    35 f  ippvars          intel-parallel-studio    compilers_and_libraries_2018.1.163/linux/ipp/bin
+    36 f  ippvars          intel-parallel-studio    composer_xe_2015.6.233/ipp/bin
+    37 f  mklvars          intel-parallel-studio    compilers_and_libraries_2018.1.163/linux/mkl/bin
+    38 f  mklvars          intel-parallel-studio    composer_xe_2015.6.233/mkl/bin
+    39 f  mpivars          intel-parallel-studio    compilers_and_libraries_2018.1.163/linux/mpi/intel64/bin
+    40 f  mpivars          intel-parallel-studio    compilers_and_libraries_2018.1.163/linux/mpirt/bin/ia32_lin
+    41 f  tbbvars          intel-parallel-studio    compilers_and_libraries_2018.1.163/linux/tbb/bin
+    42 f  tbbvars          intel-parallel-studio    composer_xe_2015.6.233/tbb/bin
+    43 f  daalvars         intel-parallel-studio    compilers_and_libraries_2018.1.163/linux/daal/bin
+    44 f  pstlvars         intel-parallel-studio    compilers_and_libraries_2018.1.163/linux/pstl/bin
+    45 f  psxevars         intel-parallel-studio    parallel_studio_xe_2018.1.038/bin
+    46 l  psxevars         intel-parallel-studio    parallel_studio_xe_2018.1.038
+    47 f  sep_vars         intel-parallel-studio    vtune_amplifier_2018.1.0.535340
+    48 f  sep_vars         intel-parallel-studio    vtune_amplifier_2018.1.0.535340/target/android_v4.1_x86_64
+    49 f  advixe-vars      intel-parallel-studio    advisor_2018.1.1.535164
+    50 f  amplxe-vars      intel-parallel-studio    vtune_amplifier_2018.1.0.535340
+    51 f  inspxe-vars      intel-parallel-studio    inspector_2018.1.1.535159
+    52 f  compilervars     intel-parallel-studio    compilers_and_libraries_2018.1.163/linux/bin
+    53 f  compilervars     intel-parallel-studio    compilers_and_libraries_2018/linux/bin
+    54 l  compilervars     intel-parallel-studio    bin
+    55 f  debuggervars     intel-parallel-studio    debugger_2018/bin
+
+
+********************
+MPI linkage
+********************
+
+
+Library selection
+~~~~~~~~~~~~~~~~~~~~~
+
+In the Spack code so far, the library selections for MPI are:
+
+::
+
+        libnames = ['libmpifort', 'libmpi']
+        if 'cxx' in self.spec.last_query.extra_parameters:
+            libnames = ['libmpicxx'] + libnames
+        return find_libraries(libnames,
+                              root=self.component_lib_dir('mpi'),
+                              shared=True, recursive=False)
+
+The problem is that there are multiple library versions under ``component_lib_dir``::
+
+    $ cd $I_MPI_ROOT 
+    $ find . -name libmpi.so | sort
+    ./intel64/lib/debug/libmpi.so
+    ./intel64/lib/debug_mt/libmpi.so
+    ./intel64/lib/libmpi.so
+    ./intel64/lib/release/libmpi.so
+    ./intel64/lib/release_mt/libmpi.so
+
+"mt" refers to multi-threading, not in the explicit sense but in the sense of being thread-safe::
+
+    $ mpiifort -help | grep mt
+       -mt_mpi         link the thread safe version of the Intel(R) MPI Library
+
+Well, why should we not inspect what the canonical script does?  The wrapper
+has its own hardcoded "prefix=..." and can thus tell us what it will do, from a
+*wiped environment* no less!::
+
+    $ env - intel64/bin/mpiicc -show hello.c | ld-unwrap-args 
+    icc 'hello.c' \
+        -I/opt/intel/compilers_and_libraries_2018.1.163/linux/mpi/intel64/include \
+        -L/opt/intel/compilers_and_libraries_2018.1.163/linux/mpi/intel64/lib/release_mt \
+        -L/opt/intel/compilers_and_libraries_2018.1.163/linux/mpi/intel64/lib \
+        -Xlinker --enable-new-dtags \
+        -Xlinker -rpath=/opt/intel/compilers_and_libraries_2018.1.163/linux/mpi/intel64/lib/release_mt \
+        -Xlinker -rpath=/opt/intel/compilers_and_libraries_2018.1.163/linux/mpi/intel64/lib \
+        -Xlinker -rpath=/opt/intel/mpi-rt/2017.0.0/intel64/lib/release_mt \
+        -Xlinker -rpath=/opt/intel/mpi-rt/2017.0.0/intel64/lib \
+        -lmpifort \
+        -lmpi \
+        -lmpigi \
+        -ldl \
+        -lrt \
+        -lpthread
+
+
+MPI Wrapper options
+~~~~~~~~~~~~~~~~~~~~~
+
+For reference, here's the wrapper's builtin help output::
+
+    $ mpiifort -help
+    Simple script to compile and/or link MPI programs.
+    Usage: mpiifort [options] <files>
+    ----------------------------------------------------------------------------
+    The following options are supported:
+       -fc=<name> | -f90=<name>
+                       specify a FORTRAN compiler name: i.e. -fc=ifort
+       -echo           print the scripts during their execution
+       -show           show command lines without real calling
+       -config=<name>  specify a configuration file: i.e. -config=ifort for mpif90-ifort.conf file
+       -v              print version info of mpiifort and its native compiler
+       -profile=<name> specify a profile configuration file (an MPI profiling
+                       library): i.e. -profile=myprofile for the myprofile.cfg file.
+                       As a special case, lib<name>.so or lib<name>.a may be used
+                       if the library is found
+       -check_mpi      link against the Intel(R) Trace Collector (-profile=vtmc).
+       -static_mpi     link the Intel(R) MPI Library statically
+       -mt_mpi         link the thread safe version of the Intel(R) MPI Library
+       -ilp64          link the ILP64 support of the Intel(R) MPI Library
+       -no_ilp64       disable ILP64 support explicitly
+       -fast           the same as -static_mpi + pass -fast option to a compiler.
+       -t or -trace
+                       link against the Intel(R) Trace Collector
+       -trace-imbalance
+                       link against the Intel(R) Trace Collector imbalance library
+                       (-profile=vtim)
+       -dynamic_log    link against the Intel(R) Trace Collector dynamically
+       -static         use static linkage method
+       -nostrip        turn off the debug information stripping during static linking
+       -O              enable optimization
+       -link_mpi=<name>
+                       link against the specified version of the Intel(R) MPI Library
+    All other options will be passed to the compiler without changing.
+    ----------------------------------------------------------------------------
+    The following environment variables are used:
+       I_MPI_ROOT      the Intel(R) MPI Library installation directory path
+       I_MPI_F90 or MPICH_F90
+                       the path/name of the underlying compiler to be used
+       I_MPI_FC_PROFILE or I_MPI_F90_PROFILE or MPIF90_PROFILE
+                       the name of profile file (without extension)
+       I_MPI_COMPILER_CONFIG_DIR
+                       the folder which contains configuration files *.conf
+       I_MPI_TRACE_PROFILE
+                       specify a default profile for the -trace option
+       I_MPI_CHECK_PROFILE
+                       specify a default profile for the -check_mpi option
+       I_MPI_CHECK_COMPILER
+                       enable compiler setup checks
+       I_MPI_LINK      specify the version of the Intel(R) MPI Library
+       I_MPI_DEBUG_INFO_STRIP
+                       turn on/off the debug information stripping during static linking
+       I_MPI_FCFLAGS
+                       special flags needed for compilation
+       I_MPI_LDFLAGS 
+                       special flags needed for linking
+    ----------------------------------------------------------------------------
+
+
+Side Note: MPI version divergence in 2015 release
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The package `intel-parallel-studio@cluster.2015.6` contains both a full MPI
+development version in `$prefix/impi` and an MPI Runtime under the
+`composer_xe*` suite directory. Curiously, these have *different versions*,
+with a release date nearly 1 year apart::
+
+    $ $SPACK_ROOT/...uaxaw7/impi/5.0.3.049/intel64/bin/mpiexec --version
+    Intel(R) MPI Library for Linux* OS, Version 5.0 Update 3 Build 20150804 (build id: 12452)
+    Copyright (C) 2003-2015, Intel Corporation. All rights reserved.
+
+    $ $SPACK_ROOT/...uaxaw7/composer_xe_2015.6.233/mpirt/bin/intel64/mpiexec --version
+    Intel(R) MPI Library for Linux* OS, Version 5.0 Update 1 Build 20140709
+    Copyright (C) 2003-2014, Intel Corporation. All rights reserved.
+
+I'm not sure what to make of it.
+
+
+**************
+macOS support
+**************
+
+- On macOS, the Spack methods here only include support to integrate an
+  externally installed MKL.
+
+- URLs in child packages will be Linux-specific; macOS download packages
+  are located in differently numbered dirs and are named m_*.dmg.

lib/spack/spack/build_systems/_package_api_v1.py

@@ -23,6 +23,7 @@
 from .generic import Package
 from .gnu import GNUMirrorPackage
 from .go import GoPackage
+from .intel import IntelPackage
 from .lua import LuaPackage
 from .makefile import MakefilePackage
 from .maven import MavenPackage
@@ -68,6 +69,7 @@
     "Package",
     "GNUMirrorPackage",
     "GoPackage",
+    "IntelPackage",
     "IntelOneApiLibraryPackageWithSdk",
     "IntelOneApiLibraryPackage",
     "IntelOneApiStaticLibraryList",

lib/spack/spack/build_systems/aspell_dict.py

@@ -3,7 +3,12 @@
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 import os
 
-from spack.package import Executable, Prefix, Spec, extends, filter_file
+import llnl.util.filesystem as fs
+
+import spack.directives
+import spack.spec
+import spack.util.executable
+import spack.util.prefix
 
 from .autotools import AutotoolsBuilder, AutotoolsPackage
 
@@ -15,13 +20,16 @@ class AspellBuilder(AutotoolsBuilder):
     """
 
     def configure(
-        self, pkg: "AspellDictPackage", spec: Spec, prefix: Prefix  # type: ignore[override]
+        self,
+        pkg: "AspellDictPackage",  # type: ignore[override]
+        spec: spack.spec.Spec,
+        prefix: spack.util.prefix.Prefix,
     ):
         aspell = spec["aspell"].prefix.bin.aspell
         prezip = spec["aspell"].prefix.bin.prezip
         destdir = prefix
 
-        sh = Executable("/bin/sh")
+        sh = spack.util.executable.Executable("/bin/sh")
         sh("./configure", "--vars", f"ASPELL={aspell}", f"PREZIP={prezip}", f"DESTDIR={destdir}")
 
 
@@ -34,7 +42,7 @@ def configure(
 class AspellDictPackage(AutotoolsPackage):
     """Specialized class for building aspell dictionairies."""
 
-    extends("aspell", when="build_system=autotools")
+    spack.directives.extends("aspell", when="build_system=autotools")
 
     #: Override the default autotools builder
     AutotoolsBuilder = AspellBuilder
@@ -46,5 +54,5 @@ def patch(self):
         datadir = aspell("dump", "config", "data-dir", output=str).strip()
         dictdir = os.path.relpath(dictdir, aspell_spec.prefix)
         datadir = os.path.relpath(datadir, aspell_spec.prefix)
-        filter_file(r"^dictdir=.*$", f"dictdir=/{dictdir}", "configure")
+        fs.filter_file(r"^dictdir=.*$", f"dictdir=/{dictdir}", "configure")
-        filter_file(r"^datadir=.*$", f"datadir=/{datadir}", "configure")
+        fs.filter_file(r"^datadir=.*$", f"datadir=/{datadir}", "configure")

lib/spack/spack/build_systems/autotools.py

@@ -78,7 +78,7 @@ def with_or_without(self, *args, **kwargs):
         return spack.builder.create(self).with_or_without(*args, **kwargs)
 
 
-@spack.builder.register_builder("autotools")
+@spack.builder.builder("autotools")
 class AutotoolsBuilder(BuilderWithDefaults):
     """The autotools builder encodes the default way of installing software built
     with autotools. It has four phases that can be overridden, if need be:

lib/spack/spack/build_systems/bundle.py

@@ -22,7 +22,7 @@ class BundlePackage(spack.package_base.PackageBase):
     spack.directives.build_system("bundle")
 
 
-@spack.builder.register_builder("bundle")
+@spack.builder.builder("bundle")
 class BundleBuilder(spack.builder.Builder):
     phases = ("install",)
 

lib/spack/spack/build_systems/cached_cmake.py

@@ -7,7 +7,14 @@
 import re
 from typing import Optional, Tuple
 
-from spack.package import Prefix, Spec, depends_on, install, mkdirp, run_after, tty, which_string
+import llnl.util.filesystem as fs
+import llnl.util.tty as tty
+
+import spack.phase_callbacks
+import spack.spec
+import spack.util.prefix
+from spack.directives import depends_on
+from spack.util.executable import which_string
 
 from .cmake import CMakeBuilder, CMakePackage
 
@@ -368,7 +375,9 @@ def initconfig_package_entries(self):
         """This method is to be overwritten by the package"""
         return []
 
-    def initconfig(self, pkg: "CachedCMakePackage", spec: Spec, prefix: Prefix) -> None:
+    def initconfig(
+        self, pkg: "CachedCMakePackage", spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         cache_entries = (
             self.std_initconfig_entries()
             + self.initconfig_compiler_entries()
@@ -388,10 +397,10 @@ def std_cmake_args(self):
         args.extend(["-C", self.cache_path])
         return args
 
-    @run_after("install")
+    @spack.phase_callbacks.run_after("install")
     def install_cmake_cache(self):
-        mkdirp(self.pkg.spec.prefix.share.cmake)
+        fs.mkdirp(self.pkg.spec.prefix.share.cmake)
-        install(self.cache_path, self.pkg.spec.prefix.share.cmake)
+        fs.install(self.cache_path, self.pkg.spec.prefix.share.cmake)
 
 
 class CachedCMakePackage(CMakePackage):

lib/spack/spack/build_systems/cargo.py

@@ -2,24 +2,21 @@
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
-from spack.package import (
+import llnl.util.filesystem as fs
-    EnvironmentModifications,
+
-    PackageBase,
+import spack.builder
-    Prefix,
+import spack.package_base
-    Spec,
+import spack.phase_callbacks
-    build_system,
+import spack.spec
-    depends_on,
+import spack.util.environment
-    install_tree,
+import spack.util.prefix
-    register_builder,
+from spack.directives import build_system, depends_on
-    run_after,
+from spack.multimethod import when
-    when,
-    working_dir,
-)
 
 from ._checks import BuilderWithDefaults, execute_install_time_tests
 
 
-class CargoPackage(PackageBase):
+class CargoPackage(spack.package_base.PackageBase):
     """Specialized class for packages built using cargo."""
 
     #: This attribute is used in UI queries that need to know the build
@@ -32,7 +29,7 @@ class CargoPackage(PackageBase):
         depends_on("rust", type="build")
 
 
-@register_builder("cargo")
+@spack.builder.builder("cargo")
 class CargoBuilder(BuilderWithDefaults):
     """The Cargo builder encodes the most common way of building software with
     a rust Cargo.toml file. It has two phases that can be overridden, if need be:
@@ -90,24 +87,30 @@ def check_args(self):
         """Argument for ``cargo test`` during check phase"""
         return []
 
-    def setup_build_environment(self, env: EnvironmentModifications) -> None:
+    def setup_build_environment(
+        self, env: spack.util.environment.EnvironmentModifications
+    ) -> None:
         env.set("CARGO_HOME", self.stage.path)
 
-    def build(self, pkg: CargoPackage, spec: Spec, prefix: Prefix) -> None:
+    def build(
+        self, pkg: CargoPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Runs ``cargo install`` in the source directory"""
-        with working_dir(self.build_directory):
+        with fs.working_dir(self.build_directory):
             pkg.module.cargo(
                 "install", "--root", "out", "--path", ".", *self.std_build_args, *self.build_args
             )
 
-    def install(self, pkg: CargoPackage, spec: Spec, prefix: Prefix) -> None:
+    def install(
+        self, pkg: CargoPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Copy build files into package prefix."""
-        with working_dir(self.build_directory):
+        with fs.working_dir(self.build_directory):
-            install_tree("out", prefix)
+            fs.install_tree("out", prefix)
 
-    run_after("install")(execute_install_time_tests)
+    spack.phase_callbacks.run_after("install")(execute_install_time_tests)
 
     def check(self):
         """Run "cargo test"."""
-        with working_dir(self.build_directory):
+        with fs.working_dir(self.build_directory):
             self.pkg.module.cargo("test", *self.check_args)

lib/spack/spack/build_systems/cmake.py

@@ -283,7 +283,7 @@ def define_from_variant(self, cmake_var: str, variant: Optional[str] = None) ->
         return define_from_variant(self, cmake_var, variant)
 
 
-@spack.builder.register_builder("cmake")
+@spack.builder.builder("cmake")
 class CMakeBuilder(BuilderWithDefaults):
     """The cmake builder encodes the default way of building software with CMake. IT
     has three phases that can be overridden:

lib/spack/spack/build_systems/cuda.py

@@ -5,7 +5,10 @@
 import re
 from typing import Iterable, List
 
-from spack.package import PackageBase, any_combination_of, conflicts, depends_on, variant, when
+import spack.variant
+from spack.directives import conflicts, depends_on, variant
+from spack.multimethod import when
+from spack.package_base import PackageBase
 
 
 class CudaPackage(PackageBase):
@@ -68,7 +71,7 @@ class CudaPackage(PackageBase):
     variant(
         "cuda_arch",
         description="CUDA architecture",
-        values=any_combination_of(*cuda_arch_values),
+        values=spack.variant.any_combination_of(*cuda_arch_values),
         sticky=True,
         when="+cuda",
     )

lib/spack/spack/build_systems/generic.py

@@ -27,7 +27,7 @@ class Package(spack.package_base.PackageBase):
     spack.directives.build_system("generic")
 
 
-@spack.builder.register_builder("generic")
+@spack.builder.builder("generic")
 class GenericBuilder(BuilderWithDefaults):
     """A builder for a generic build system, that require packagers
     to implement an "install" phase.

lib/spack/spack/build_systems/go.py

@@ -2,26 +2,21 @@
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
-from spack.package import (
+import llnl.util.filesystem as fs
-    EnvironmentModifications,
+
-    PackageBase,
+import spack.builder
-    Prefix,
+import spack.package_base
-    Spec,
+import spack.phase_callbacks
-    build_system,
+import spack.spec
-    depends_on,
+import spack.util.environment
-    install,
+import spack.util.prefix
-    join_path,
+from spack.directives import build_system, depends_on
-    mkdirp,
+from spack.multimethod import when
-    register_builder,
-    run_after,
-    when,
-    working_dir,
-)
 
 from ._checks import BuilderWithDefaults, execute_install_time_tests
 
 
-class GoPackage(PackageBase):
+class GoPackage(spack.package_base.PackageBase):
     """Specialized class for packages built using the Go toolchain."""
 
     #: This attribute is used in UI queries that need to know the build
@@ -37,7 +32,7 @@ class GoPackage(PackageBase):
         depends_on("go", type="build")
 
 
-@register_builder("go")
+@spack.builder.builder("go")
 class GoBuilder(BuilderWithDefaults):
     """The Go builder encodes the most common way of building software with
     a golang go.mod file. It has two phases that can be overridden, if need be:
@@ -74,10 +69,12 @@ class GoBuilder(BuilderWithDefaults):
     #: Callback names for install-time test
     install_time_test_callbacks = ["check"]
 
-    def setup_build_environment(self, env: EnvironmentModifications) -> None:
+    def setup_build_environment(
+        self, env: spack.util.environment.EnvironmentModifications
+    ) -> None:
         env.set("GO111MODULE", "on")
         env.set("GOTOOLCHAIN", "local")
-        env.set("GOPATH", join_path(self.pkg.stage.path, "go"))
+        env.set("GOPATH", fs.join_path(self.pkg.stage.path, "go"))
 
     @property
     def build_directory(self):
@@ -103,20 +100,24 @@ def check_args(self):
         """Argument for ``go test`` during check phase"""
         return []
 
-    def build(self, pkg: GoPackage, spec: Spec, prefix: Prefix) -> None:
+    def build(
+        self, pkg: GoPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Runs ``go build`` in the source directory"""
-        with working_dir(self.build_directory):
+        with fs.working_dir(self.build_directory):
             pkg.module.go("build", *self.build_args)
 
-    def install(self, pkg: GoPackage, spec: Spec, prefix: Prefix) -> None:
+    def install(
+        self, pkg: GoPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Install built binaries into prefix bin."""
-        with working_dir(self.build_directory):
+        with fs.working_dir(self.build_directory):
-            mkdirp(prefix.bin)
+            fs.mkdirp(prefix.bin)
-            install(pkg.name, prefix.bin)
+            fs.install(pkg.name, prefix.bin)
 
-    run_after("install")(execute_install_time_tests)
+    spack.phase_callbacks.run_after("install")(execute_install_time_tests)
 
     def check(self):
         """Run ``go test .`` in the source directory"""
-        with working_dir(self.build_directory):
+        with fs.working_dir(self.build_directory):
             self.pkg.module.go("test", *self.check_args)

lib/spack/spack/build_systems/lua.py

@@ -3,23 +3,19 @@
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 import os
 
-from spack.package import (
+from llnl.util.filesystem import find
-    Builder,
+
-    EnvironmentModifications,
+import spack.builder
-    Executable,
+import spack.package_base
-    PackageBase,
+import spack.spec
-    Prefix,
+import spack.util.environment
-    Spec,
+import spack.util.executable
-    build_system,
+import spack.util.prefix
-    depends_on,
+from spack.directives import build_system, depends_on, extends
-    extends,
+from spack.multimethod import when
-    find,
-    register_builder,
-    when,
-)
 
 
-class LuaPackage(PackageBase):
+class LuaPackage(spack.package_base.PackageBase):
     """Specialized class for lua packages"""
 
     #: This attribute is used in UI queries that need to know the build
@@ -44,16 +40,16 @@ class LuaPackage(PackageBase):
 
     @property
     def lua(self):
-        return Executable(self.spec["lua-lang"].prefix.bin.lua)
+        return spack.util.executable.Executable(self.spec["lua-lang"].prefix.bin.lua)
 
     @property
     def luarocks(self):
-        lr = Executable(self.spec["lua-lang"].prefix.bin.luarocks)
+        lr = spack.util.executable.Executable(self.spec["lua-lang"].prefix.bin.luarocks)
         return lr
 
 
-@register_builder("lua")
+@spack.builder.builder("lua")
-class LuaBuilder(Builder):
+class LuaBuilder(spack.builder.Builder):
     phases = ("unpack", "generate_luarocks_config", "preprocess", "install")
 
     #: Names associated with package methods in the old build-system format
@@ -62,7 +58,9 @@ class LuaBuilder(Builder):
     #: Names associated with package attributes in the old build-system format
     legacy_attributes = ()
 
-    def unpack(self, pkg: LuaPackage, spec: Spec, prefix: Prefix) -> None:
+    def unpack(
+        self, pkg: LuaPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         if os.path.splitext(pkg.stage.archive_file)[1] == ".rock":
             directory = pkg.luarocks("unpack", pkg.stage.archive_file, output=str)
             dirlines = directory.split("\n")
@@ -73,7 +71,9 @@ def unpack(self, pkg: LuaPackage, spec: Spec, prefix: Prefix) -> None:
     def _generate_tree_line(name, prefix):
         return """{{ name = "{name}", root = "{prefix}" }};""".format(name=name, prefix=prefix)
 
-    def generate_luarocks_config(self, pkg: LuaPackage, spec: Spec, prefix: Prefix) -> None:
+    def generate_luarocks_config(
+        self, pkg: LuaPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         spec = self.pkg.spec
         table_entries = []
         for d in spec.traverse(deptype=("build", "run")):
@@ -92,14 +92,18 @@ def generate_luarocks_config(self, pkg: LuaPackage, spec: Spec, prefix: Prefix)
                 )
             )
 
-    def preprocess(self, pkg: LuaPackage, spec: Spec, prefix: Prefix) -> None:
+    def preprocess(
+        self, pkg: LuaPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Override this to preprocess source before building with luarocks"""
         pass
 
     def luarocks_args(self):
         return []
 
-    def install(self, pkg: LuaPackage, spec: Spec, prefix: Prefix) -> None:
+    def install(
+        self, pkg: LuaPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         rock = "."
         specs = find(".", "*.rockspec", recursive=False)
         if specs:
@@ -111,5 +115,7 @@ def install(self, pkg: LuaPackage, spec: Spec, prefix: Prefix) -> None:
     def _luarocks_config_path(self):
         return os.path.join(self.pkg.stage.source_path, "spack_luarocks.lua")
 
-    def setup_build_environment(self, env: EnvironmentModifications) -> None:
+    def setup_build_environment(
+        self, env: spack.util.environment.EnvironmentModifications
+    ) -> None:
         env.set("LUAROCKS_CONFIG", self._luarocks_config_path())

lib/spack/spack/build_systems/makefile.py

@@ -37,7 +37,7 @@ class MakefilePackage(spack.package_base.PackageBase):
         depends_on("gmake", type="build")
 
 
-@spack.builder.register_builder("makefile")
+@spack.builder.builder("makefile")
 class MakefileBuilder(BuilderWithDefaults):
     """The Makefile builder encodes the most common way of building software with
     Makefiles. It has three phases that can be overridden, if need be:

lib/spack/spack/build_systems/maven.py

@@ -1,23 +1,20 @@
 # Copyright Spack Project Developers. See COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
-from spack.package import (
+import llnl.util.filesystem as fs
-    PackageBase,
+
-    Prefix,
+import spack.builder
-    Spec,
+import spack.package_base
-    build_system,
+import spack.spec
-    depends_on,
+import spack.util.prefix
-    install_tree,
+from spack.directives import build_system, depends_on
-    register_builder,
+from spack.multimethod import when
-    when,
+from spack.util.executable import which
-    which,
-    working_dir,
-)
 
 from ._checks import BuilderWithDefaults
 
 
-class MavenPackage(PackageBase):
+class MavenPackage(spack.package_base.PackageBase):
     """Specialized class for packages that are built using the
     Maven build system. See https://maven.apache.org/index.html
     for more information.
@@ -37,7 +34,7 @@ class MavenPackage(PackageBase):
         depends_on("maven", type="build")
 
 
-@register_builder("maven")
+@spack.builder.builder("maven")
 class MavenBuilder(BuilderWithDefaults):
     """The Maven builder encodes the default way to build software with Maven.
     It has two phases that can be overridden, if need be:
@@ -63,16 +60,20 @@ def build_args(self):
         """List of args to pass to build phase."""
         return []
 
-    def build(self, pkg: MavenPackage, spec: Spec, prefix: Prefix) -> None:
+    def build(
+        self, pkg: MavenPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Compile code and package into a JAR file."""
-        with working_dir(self.build_directory):
+        with fs.working_dir(self.build_directory):
             mvn = which("mvn", required=True)
             if self.pkg.run_tests:
                 mvn("verify", *self.build_args())
             else:
                 mvn("package", "-DskipTests", *self.build_args())
 
-    def install(self, pkg: MavenPackage, spec: Spec, prefix: Prefix) -> None:
+    def install(
+        self, pkg: MavenPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Copy to installation prefix."""
-        with working_dir(self.build_directory):
+        with fs.working_dir(self.build_directory):
-            install_tree(".", prefix)
+            fs.install_tree(".", prefix)

lib/spack/spack/build_systems/meson.py

@@ -4,24 +4,20 @@
 import os
 from typing import List
 
-from spack.package import (
+import llnl.util.filesystem as fs
-    PackageBase,
+
-    Prefix,
+import spack.builder
-    Spec,
+import spack.package_base
-    build_system,
+import spack.phase_callbacks
-    conflicts,
+import spack.spec
-    depends_on,
+import spack.util.prefix
-    register_builder,
+from spack.directives import build_system, conflicts, depends_on, variant
-    run_after,
+from spack.multimethod import when
-    variant,
-    when,
-    working_dir,
-)
 
 from ._checks import BuilderWithDefaults, execute_build_time_tests
 
 
-class MesonPackage(PackageBase):
+class MesonPackage(spack.package_base.PackageBase):
     """Specialized class for packages built using Meson. For more information
     on the Meson build system, see https://mesonbuild.com/
     """
@@ -70,7 +66,7 @@ def flags_to_build_system_args(self, flags):
         setattr(self, "meson_flag_args", [])
 
 
-@register_builder("meson")
+@spack.builder.builder("meson")
 class MesonBuilder(BuilderWithDefaults):
     """The Meson builder encodes the default way to build software with Meson.
     The builder has three phases that can be overridden, if need be:
@@ -194,7 +190,9 @@ def meson_args(self) -> List[str]:
         """
         return []
 
-    def meson(self, pkg: MesonPackage, spec: Spec, prefix: Prefix) -> None:
+    def meson(
+        self, pkg: MesonPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Run ``meson`` in the build directory"""
         options = []
         if self.spec["meson"].satisfies("@0.64:"):
@@ -202,25 +200,29 @@ def meson(self, pkg: MesonPackage, spec: Spec, prefix: Prefix) -> None:
         options.append(os.path.abspath(self.root_mesonlists_dir))
         options += self.std_meson_args
         options += self.meson_args()
-        with working_dir(self.build_directory, create=True):
+        with fs.working_dir(self.build_directory, create=True):
             pkg.module.meson(*options)
 
-    def build(self, pkg: MesonPackage, spec: Spec, prefix: Prefix) -> None:
+    def build(
+        self, pkg: MesonPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Make the build targets"""
         options = ["-v"]
         options += self.build_targets
-        with working_dir(self.build_directory):
+        with fs.working_dir(self.build_directory):
             pkg.module.ninja(*options)
 
-    def install(self, pkg: MesonPackage, spec: Spec, prefix: Prefix) -> None:
+    def install(
+        self, pkg: MesonPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Make the install targets"""
-        with working_dir(self.build_directory):
+        with fs.working_dir(self.build_directory):
             pkg.module.ninja(*self.install_targets)
 
-    run_after("build")(execute_build_time_tests)
+    spack.phase_callbacks.run_after("build")(execute_build_time_tests)
 
     def check(self) -> None:
         """Search Meson-generated files for the target ``test`` and run it if found."""
-        with working_dir(self.build_directory):
+        with fs.working_dir(self.build_directory):
             self.pkg._if_ninja_target_execute("test")
             self.pkg._if_ninja_target_execute("check")

lib/spack/spack/build_systems/msbuild.py

@@ -5,20 +5,16 @@
 
 import llnl.util.filesystem as fs
 
-from spack.package import (
+import spack.builder
-    PackageBase,
+import spack.package_base
-    Prefix,
+import spack.spec
-    Spec,
+import spack.util.prefix
-    build_system,
+from spack.directives import build_system, conflicts
-    conflicts,
-    register_builder,
-    working_dir,
-)
 
 from ._checks import BuilderWithDefaults
 
 
-class MSBuildPackage(PackageBase):
+class MSBuildPackage(spack.package_base.PackageBase):
     """Specialized class for packages built using Visual Studio project files or solutions."""
 
     #: This attribute is used in UI queries that need to know the build
@@ -34,7 +30,7 @@ def define(self, msbuild_arg, value):
         return define(msbuild_arg, value)
 
 
-@register_builder("msbuild")
+@spack.builder.builder("msbuild")
 class MSBuildBuilder(BuilderWithDefaults):
     """The MSBuild builder encodes the most common way of building software with
     Mircosoft's MSBuild tool. It has two phases that can be overridden, if need be:
@@ -109,19 +105,23 @@ def msbuild_install_args(self):
         as `msbuild_args` by default."""
         return self.msbuild_args()
 
-    def build(self, pkg: MSBuildPackage, spec: Spec, prefix: Prefix) -> None:
+    def build(
+        self, pkg: MSBuildPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Run "msbuild" on the build targets specified by the builder."""
-        with working_dir(self.build_directory):
+        with fs.working_dir(self.build_directory):
             pkg.module.msbuild(
                 *self.std_msbuild_args,
                 *self.msbuild_args(),
                 self.define_targets(*self.build_targets),
             )
 
-    def install(self, pkg: MSBuildPackage, spec: Spec, prefix: Prefix) -> None:
+    def install(
+        self, pkg: MSBuildPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Run "msbuild" on the install targets specified by the builder.
         This is INSTALL by default"""
-        with working_dir(self.build_directory):
+        with fs.working_dir(self.build_directory):
             pkg.module.msbuild(
                 *self.msbuild_install_args(), self.define_targets(*self.install_targets)
             )

lib/spack/spack/build_systems/nmake.py

@@ -5,20 +5,16 @@
 
 import llnl.util.filesystem as fs
 
-from spack.package import (
+import spack.builder
-    PackageBase,
+import spack.package_base
-    Prefix,
+import spack.spec
-    Spec,
+import spack.util.prefix
-    build_system,
+from spack.directives import build_system, conflicts
-    conflicts,
-    register_builder,
-    working_dir,
-)
 
 from ._checks import BuilderWithDefaults
 
 
-class NMakePackage(PackageBase):
+class NMakePackage(spack.package_base.PackageBase):
     """Specialized class for packages built using a Makefiles."""
 
     #: This attribute is used in UI queries that need to know the build
@@ -30,7 +26,7 @@ class NMakePackage(PackageBase):
     conflicts("platform=darwin", when="build_system=nmake")
 
 
-@register_builder("nmake")
+@spack.builder.builder("nmake")
 class NMakeBuilder(BuilderWithDefaults):
     """The NMake builder encodes the most common way of building software with
     Mircosoft's NMake tool. It has two phases that can be overridden, if need be:
@@ -129,16 +125,20 @@ def nmake_install_args(self):
         Individual packages should override to specify NMake args to command line"""
         return []
 
-    def build(self, pkg: NMakePackage, spec: Spec, prefix: Prefix) -> None:
+    def build(
+        self, pkg: NMakePackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Run "nmake" on the build targets specified by the builder."""
         opts = self.std_nmake_args
         opts += self.nmake_args()
         if self.makefile_name:
             opts.append("/F{}".format(self.makefile_name))
-        with working_dir(self.build_directory):
+        with fs.working_dir(self.build_directory):
             pkg.module.nmake(*opts, *self.build_targets, ignore_quotes=self.ignore_quotes)
 
-    def install(self, pkg: NMakePackage, spec: Spec, prefix: Prefix) -> None:
+    def install(
+        self, pkg: NMakePackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Run "nmake" on the install targets specified by the builder.
         This is INSTALL by default"""
         opts = self.std_nmake_args
@@ -147,5 +147,5 @@ def install(self, pkg: NMakePackage, spec: Spec, prefix: Prefix) -> None:
         if self.makefile_name:
             opts.append("/F{}".format(self.makefile_name))
         opts.append(self.define("PREFIX", fs.windows_sfn(prefix)))
-        with working_dir(self.build_directory):
+        with fs.working_dir(self.build_directory):
             pkg.module.nmake(*opts, *self.install_targets, ignore_quotes=self.ignore_quotes)

lib/spack/spack/build_systems/octave.py

@@ -1,21 +1,18 @@
 # Copyright Spack Project Developers. See COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
-from spack.package import (
+import spack.builder
-    EnvironmentModifications,
+import spack.package_base
-    PackageBase,
+import spack.spec
-    Prefix,
+import spack.util.environment
-    Spec,
+import spack.util.prefix
-    build_system,
+from spack.directives import build_system, extends
-    extends,
+from spack.multimethod import when
-    register_builder,
-    when,
-)
 
 from ._checks import BuilderWithDefaults
 
 
-class OctavePackage(PackageBase):
+class OctavePackage(spack.package_base.PackageBase):
     """Specialized class for Octave packages. See
     https://www.gnu.org/software/octave/doc/v4.2.0/Installing-and-Removing-Packages.html
     for more information.
@@ -33,7 +30,7 @@ class OctavePackage(PackageBase):
         extends("octave")
 
 
-@register_builder("octave")
+@spack.builder.builder("octave")
 class OctaveBuilder(BuilderWithDefaults):
     """The octave builder provides the following phases that can be overridden:
 
@@ -48,7 +45,9 @@ class OctaveBuilder(BuilderWithDefaults):
     #: Names associated with package attributes in the old build-system format
     legacy_attributes = ()
 
-    def install(self, pkg: OctavePackage, spec: Spec, prefix: Prefix) -> None:
+    def install(
+        self, pkg: OctavePackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Install the package from the archive file"""
         pkg.module.octave(
             "--quiet",
@@ -59,7 +58,9 @@ def install(self, pkg: OctavePackage, spec: Spec, prefix: Prefix) -> None:
             "pkg prefix %s; pkg install %s" % (prefix, self.pkg.stage.archive_file),
         )
 
-    def setup_build_environment(self, env: EnvironmentModifications) -> None:
+    def setup_build_environment(
+        self, env: spack.util.environment.EnvironmentModifications
+    ) -> None:
         # octave does not like those environment variables to be set:
         env.unset("CC")
         env.unset("CXX")

lib/spack/spack/build_systems/oneapi.py

@@ -7,25 +7,16 @@
 import shutil
 from os.path import basename, isdir
 
+from llnl.util import tty
+from llnl.util.filesystem import HeaderList, LibraryList, find_libraries, join_path, mkdirp
 from llnl.util.link_tree import LinkTree
 
 import spack.util.path
 from spack.build_environment import dso_suffix
-from spack.package import (
+from spack.directives import conflicts, license, redistribute, variant
-    EnvironmentModifications,
+from spack.error import InstallError
-    Executable,
+from spack.util.environment import EnvironmentModifications
-    HeaderList,
+from spack.util.executable import Executable
-    InstallError,
-    LibraryList,
-    conflicts,
-    find_libraries,
-    join_path,
-    license,
-    mkdirp,
-    redistribute,
-    tty,
-    variant,
-)
 
 from .generic import Package
 

lib/spack/spack/build_systems/perl.py

@@ -88,7 +88,7 @@ def test_use(self):
                 assert "OK" in out
 
 
-@spack.builder.register_builder("perl")
+@spack.builder.builder("perl")
 class PerlBuilder(BuilderWithDefaults):
     """The perl builder provides four phases that can be overridden, if required:
 

lib/spack/spack/build_systems/python.py

@@ -427,7 +427,7 @@ def libs(self) -> LibraryList:
         raise NoLibrariesError(msg.format(self.spec.name, platlib, purelib))
 
 
-@spack.builder.register_builder("python_pip")
+@spack.builder.builder("python_pip")
 class PythonPipBuilder(BuilderWithDefaults):
     phases = ("install",)
 

lib/spack/spack/build_systems/qmake.py

@@ -1,21 +1,19 @@
 # Copyright Spack Project Developers. See COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
-from spack.package import (
+from llnl.util.filesystem import working_dir
-    PackageBase,
+
-    Prefix,
+import spack.builder
-    Spec,
+import spack.package_base
-    build_system,
+import spack.phase_callbacks
-    depends_on,
+import spack.spec
-    register_builder,
+import spack.util.prefix
-    run_after,
+from spack.directives import build_system, depends_on
-    working_dir,
-)
 
 from ._checks import BuilderWithDefaults, execute_build_time_tests
 
 
-class QMakePackage(PackageBase):
+class QMakePackage(spack.package_base.PackageBase):
     """Specialized class for packages built using qmake.
 
     For more information on the qmake build system, see:
@@ -34,7 +32,7 @@ class QMakePackage(PackageBase):
     depends_on("gmake", type="build")
 
 
-@register_builder("qmake")
+@spack.builder.builder("qmake")
 class QMakeBuilder(BuilderWithDefaults):
     """The qmake builder provides three phases that can be overridden:
 
@@ -66,17 +64,23 @@ def qmake_args(self):
         """List of arguments passed to qmake."""
         return []
 
-    def qmake(self, pkg: QMakePackage, spec: Spec, prefix: Prefix) -> None:
+    def qmake(
+        self, pkg: QMakePackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Run ``qmake`` to configure the project and generate a Makefile."""
         with working_dir(self.build_directory):
             pkg.module.qmake(*self.qmake_args())
 
-    def build(self, pkg: QMakePackage, spec: Spec, prefix: Prefix) -> None:
+    def build(
+        self, pkg: QMakePackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Make the build targets"""
         with working_dir(self.build_directory):
             pkg.module.make()
 
-    def install(self, pkg: QMakePackage, spec: Spec, prefix: Prefix) -> None:
+    def install(
+        self, pkg: QMakePackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Make the install targets"""
         with working_dir(self.build_directory):
             pkg.module.make("install")
@@ -86,4 +90,4 @@ def check(self):
         with working_dir(self.build_directory):
             self.pkg._if_make_target_execute("check")
 
-    run_after("build")(execute_build_time_tests)
+    spack.phase_callbacks.run_after("build")(execute_build_time_tests)

lib/spack/spack/build_systems/r.py

@@ -3,9 +3,10 @@
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 from typing import Optional, Tuple
 
+from llnl.util.filesystem import mkdirp
 from llnl.util.lang import ClassProperty, classproperty
 
-from spack.package import extends, mkdirp
+from spack.directives import extends
 
 from .generic import GenericBuilder, Package
 

lib/spack/spack/build_systems/racket.py

@@ -4,25 +4,19 @@
 import os
 from typing import Optional, Tuple
 
+import llnl.util.filesystem as fs
+import llnl.util.tty as tty
 from llnl.util.lang import ClassProperty, classproperty
 
+import spack.builder
+import spack.spec
+import spack.util.prefix
 from spack.build_environment import SPACK_NO_PARALLEL_MAKE
-from spack.package import (
+from spack.config import determine_number_of_jobs
-    Builder,
+from spack.directives import build_system, extends, maintainers
-    Executable,
+from spack.package_base import PackageBase
-    PackageBase,
-    Prefix,
-    ProcessError,
-    Spec,
-    build_system,
-    determine_number_of_jobs,
-    extends,
-    maintainers,
-    register_builder,
-    tty,
-    working_dir,
-)
 from spack.util.environment import env_flag
+from spack.util.executable import Executable, ProcessError
 
 
 def _homepage(cls: "RacketPackage") -> Optional[str]:
@@ -52,8 +46,8 @@ class RacketPackage(PackageBase):
     homepage: ClassProperty[Optional[str]] = classproperty(_homepage)
 
 
-@register_builder("racket")
+@spack.builder.builder("racket")
-class RacketBuilder(Builder):
+class RacketBuilder(spack.builder.Builder):
     """The Racket builder provides an ``install`` phase that can be overridden."""
 
     phases = ("install",)
@@ -82,10 +76,12 @@ def build_directory(self):
             ret = os.path.join(ret, self.subdirectory)
         return ret
 
-    def install(self, pkg: RacketPackage, spec: Spec, prefix: Prefix) -> None:
+    def install(
+        self, pkg: RacketPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Install everything from build directory."""
         raco = Executable("raco")
-        with working_dir(self.build_directory):
+        with fs.working_dir(self.build_directory):
             parallel = pkg.parallel and (not env_flag(SPACK_NO_PARALLEL_MAKE))
             name = pkg.racket_name
             assert name is not None, "Racket package name is not set"

lib/spack/spack/build_systems/rocm.py

@@ -76,14 +76,10 @@
 
 import os
 
-from spack.package import (
+import spack.variant
-    EnvironmentModifications,
+from spack.directives import conflicts, depends_on, variant
-    PackageBase,
+from spack.package_base import PackageBase
-    any_combination_of,
+from spack.util.environment import EnvironmentModifications
-    conflicts,
-    depends_on,
-    variant,
-)
 
 
 class ROCmPackage(PackageBase):
@@ -139,7 +135,7 @@ class ROCmPackage(PackageBase):
     variant(
         "amdgpu_target",
         description="AMD GPU architecture",
-        values=any_combination_of(*amdgpu_targets),
+        values=spack.variant.any_combination_of(*amdgpu_targets),
         sticky=True,
         when="+rocm",
     )

lib/spack/spack/build_systems/ruby.py

@@ -3,20 +3,16 @@
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 import glob
 
-from spack.package import (
+import spack.builder
-    PackageBase,
+import spack.package_base
-    Prefix,
+import spack.spec
-    Spec,
+import spack.util.prefix
-    build_system,
+from spack.directives import build_system, extends, maintainers
-    extends,
-    maintainers,
-    register_builder,
-)
 
 from ._checks import BuilderWithDefaults
 
 
-class RubyPackage(PackageBase):
+class RubyPackage(spack.package_base.PackageBase):
     """Specialized class for building Ruby gems."""
 
     maintainers("Kerilk")
@@ -32,7 +28,7 @@ class RubyPackage(PackageBase):
     extends("ruby", when="build_system=ruby")
 
 
-@register_builder("ruby")
+@spack.builder.builder("ruby")
 class RubyBuilder(BuilderWithDefaults):
     """The Ruby builder provides two phases that can be overridden if required:
 
@@ -48,7 +44,9 @@ class RubyBuilder(BuilderWithDefaults):
     #: Names associated with package attributes in the old build-system format
     legacy_attributes = ()
 
-    def build(self, pkg: RubyPackage, spec: Spec, prefix: Prefix) -> None:
+    def build(
+        self, pkg: RubyPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Build a Ruby gem."""
 
         # ruby-rake provides both rake.gemspec and Rakefile, but only
@@ -64,7 +62,9 @@ def build(self, pkg: RubyPackage, spec: Spec, prefix: Prefix) -> None:
             # Some Ruby packages only ship `*.gem` files, so nothing to build
             pass
 
-    def install(self, pkg: RubyPackage, spec: Spec, prefix: Prefix) -> None:
+    def install(
+        self, pkg: RubyPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Install a Ruby gem.
 
         The ruby package sets ``GEM_HOME`` to tell gem where to install to."""

lib/spack/spack/build_systems/scons.py

@@ -1,20 +1,17 @@
 # Copyright Spack Project Developers. See COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
-from spack.package import (
+import spack.builder
-    PackageBase,
+import spack.package_base
-    Prefix,
+import spack.phase_callbacks
-    Spec,
+import spack.spec
-    build_system,
+import spack.util.prefix
-    depends_on,
+from spack.directives import build_system, depends_on
-    register_builder,
-    run_after,
-)
 
 from ._checks import BuilderWithDefaults, execute_build_time_tests
 
 
-class SConsPackage(PackageBase):
+class SConsPackage(spack.package_base.PackageBase):
     """Specialized class for packages built using SCons.
 
     See http://scons.org/documentation.html for more information.
@@ -32,7 +29,7 @@ class SConsPackage(PackageBase):
     depends_on("scons", type="build", when="build_system=scons")
 
 
-@register_builder("scons")
+@spack.builder.builder("scons")
 class SConsBuilder(BuilderWithDefaults):
     """The Scons builder provides the following phases that can be overridden:
 
@@ -64,7 +61,9 @@ def build_args(self, spec, prefix):
         """Arguments to pass to build."""
         return []
 
-    def build(self, pkg: SConsPackage, spec: Spec, prefix: Prefix) -> None:
+    def build(
+        self, pkg: SConsPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Build the package."""
         pkg.module.scons(*self.build_args(spec, prefix))
 
@@ -72,7 +71,9 @@ def install_args(self, spec, prefix):
         """Arguments to pass to install."""
         return []
 
-    def install(self, pkg: SConsPackage, spec: Spec, prefix: Prefix) -> None:
+    def install(
+        self, pkg: SConsPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Install the package."""
         pkg.module.scons("install", *self.install_args(spec, prefix))
 
@@ -84,4 +85,4 @@ def build_test(self):
         """
         pass
 
-    run_after("build")(execute_build_time_tests)
+    spack.phase_callbacks.run_after("build")(execute_build_time_tests)

lib/spack/spack/build_systems/sip.py

@@ -4,27 +4,23 @@
 import os
 import re
 
-from spack.package import (
+import llnl.util.tty as tty
-    Executable,
+from llnl.util.filesystem import find, working_dir
-    PackageBase,
+
-    Prefix,
+import spack.builder
-    Spec,
+import spack.install_test
-    build_system,
+import spack.package_base
-    depends_on,
+import spack.phase_callbacks
-    extends,
+import spack.spec
-    find,
+import spack.util.prefix
-    register_builder,
+from spack.directives import build_system, depends_on, extends
-    run_after,
+from spack.multimethod import when
-    test_part,
+from spack.util.executable import Executable
-    tty,
-    when,
-    working_dir,
-)
 
 from ._checks import BuilderWithDefaults, execute_install_time_tests
 
 
-class SIPPackage(PackageBase):
+class SIPPackage(spack.package_base.PackageBase):
     """Specialized class for packages that are built using the
     SIP build system. See https://www.riverbankcomputing.com/software/sip/intro
     for more information.
@@ -100,7 +96,7 @@ def test_imports(self):
         # Make sure we are importing the installed modules,
         # not the ones in the source directory
         for module in self.import_modules:
-            with test_part(
+            with spack.install_test.test_part(
                 self,
                 "test_imports_{0}".format(module),
                 purpose="checking import of {0}".format(module),
@@ -109,7 +105,7 @@ def test_imports(self):
                 self.python("-c", "import {0}".format(module))
 
 
-@register_builder("sip")
+@spack.builder.builder("sip")
 class SIPBuilder(BuilderWithDefaults):
     """The SIP builder provides the following phases that can be overridden:
 
@@ -137,7 +133,9 @@ class SIPBuilder(BuilderWithDefaults):
 
     build_directory = "build"
 
-    def configure(self, pkg: SIPPackage, spec: Spec, prefix: Prefix) -> None:
+    def configure(
+        self, pkg: SIPPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Configure the package."""
 
         # https://www.riverbankcomputing.com/static/Docs/sip/command_line_tools.html
@@ -155,7 +153,9 @@ def configure_args(self):
         """Arguments to pass to configure."""
         return []
 
-    def build(self, pkg: SIPPackage, spec: Spec, prefix: Prefix) -> None:
+    def build(
+        self, pkg: SIPPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Build the package."""
         args = self.build_args()
 
@@ -166,7 +166,9 @@ def build_args(self):
         """Arguments to pass to build."""
         return []
 
-    def install(self, pkg: SIPPackage, spec: Spec, prefix: Prefix) -> None:
+    def install(
+        self, pkg: SIPPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Install the package."""
         args = self.install_args()
 
@@ -177,4 +179,4 @@ def install_args(self):
         """Arguments to pass to install."""
         return []
 
-    run_after("install")(execute_install_time_tests)
+    spack.phase_callbacks.run_after("install")(execute_install_time_tests)

lib/spack/spack/build_systems/waf.py

@@ -1,21 +1,19 @@
 # Copyright Spack Project Developers. See COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
-from spack.package import (
+from llnl.util.filesystem import working_dir
-    PackageBase,
+
-    Prefix,
+import spack.builder
-    Spec,
+import spack.package_base
-    build_system,
+import spack.phase_callbacks
-    depends_on,
+import spack.spec
-    register_builder,
+import spack.util.prefix
-    run_after,
+from spack.directives import build_system, depends_on
-    working_dir,
-)
 
 from ._checks import BuilderWithDefaults, execute_build_time_tests, execute_install_time_tests
 
 
-class WafPackage(PackageBase):
+class WafPackage(spack.package_base.PackageBase):
     """Specialized class for packages that are built using the
     Waf build system. See https://waf.io/book/ for more information.
     """
@@ -33,7 +31,7 @@ class WafPackage(PackageBase):
     depends_on("python@2.5:", type="build", when="build_system=waf")
 
 
-@register_builder("waf")
+@spack.builder.builder("waf")
 class WafBuilder(BuilderWithDefaults):
     """The WAF builder provides the following phases that can be overridden:
 
@@ -101,7 +99,9 @@ def waf(self, *args, **kwargs):
         with working_dir(self.build_directory):
             self.python("waf", "-j{0}".format(jobs), *args, **kwargs)
 
-    def configure(self, pkg: WafPackage, spec: Spec, prefix: Prefix) -> None:
+    def configure(
+        self, pkg: WafPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Configures the project."""
         args = ["--prefix={0}".format(self.pkg.prefix)]
         args += self.configure_args()
@@ -112,7 +112,9 @@ def configure_args(self):
         """Arguments to pass to configure."""
         return []
 
-    def build(self, pkg: WafPackage, spec: Spec, prefix: Prefix) -> None:
+    def build(
+        self, pkg: WafPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Executes the build."""
         args = self.build_args()
 
@@ -122,7 +124,9 @@ def build_args(self):
         """Arguments to pass to build."""
         return []
 
-    def install(self, pkg: WafPackage, spec: Spec, prefix: Prefix) -> None:
+    def install(
+        self, pkg: WafPackage, spec: spack.spec.Spec, prefix: spack.util.prefix.Prefix
+    ) -> None:
         """Installs the targets on the system."""
         args = self.install_args()
 
@@ -140,7 +144,7 @@ def build_test(self):
         """
         pass
 
-    run_after("build")(execute_build_time_tests)
+    spack.phase_callbacks.run_after("build")(execute_build_time_tests)
 
     def install_test(self):
         """Run unit tests after install.
@@ -150,4 +154,4 @@ def install_test(self):
         """
         pass
 
-    run_after("install")(execute_install_time_tests)
+    spack.phase_callbacks.run_after("install")(execute_install_time_tests)

lib/spack/spack/builder.py

@@ -23,7 +23,7 @@
 _BUILDERS: Dict[int, "Builder"] = {}
 
 
-def register_builder(build_system_name: str):
+def builder(build_system_name: str):
     """Class decorator used to register the default builder
     for a given build-system.
 

lib/spack/spack/cmd/create.py

@@ -52,7 +52,6 @@
 # See the Spack documentation for more information on packaging.
 # ----------------------------------------------------------------------------
 
-{package_class_import}
 from spack.package import *
 
 
@@ -86,7 +85,6 @@ class BundlePackageTemplate:
     """
 
     base_class_name = "BundlePackage"
-    package_class_import = "from spack_repo.builtin.build_systems.bundle import BundlePackage"
 
     dependencies = """\
     # FIXME: Add dependencies if required.
@@ -116,7 +114,6 @@ def write(self, pkg_path):
                     name=self.name,
                     class_name=self.class_name,
                     base_class_name=self.base_class_name,
-                    package_class_import=self.package_class_import,
                     url_def=self.url_def,
                     versions=self.versions,
                     dependencies="\n".join(all_deps),
@@ -129,7 +126,6 @@ class PackageTemplate(BundlePackageTemplate):
     """Provides the default values to be used for the package file template"""
 
     base_class_name = "Package"
-    package_class_import = "from spack_repo.builtin.build_systems.generic import Package"
 
     body_def = """\
     def install(self, spec, prefix):
@@ -150,9 +146,6 @@ class AutotoolsPackageTemplate(PackageTemplate):
     that *do* come with a ``configure`` script"""
 
     base_class_name = "AutotoolsPackage"
-    package_class_import = (
-        "from spack_repo.builtin.build_systems.autotools import AutotoolsPackage"
-    )
 
     body_def = """\
     def configure_args(self):
@@ -167,9 +160,6 @@ class AutoreconfPackageTemplate(PackageTemplate):
     that *do not* come with a ``configure`` script"""
 
     base_class_name = "AutotoolsPackage"
-    package_class_import = (
-        "from spack_repo.builtin.build_systems.autotools import AutotoolsPackage"
-    )
 
     dependencies = """\
     depends_on("autoconf", type="build")
@@ -196,7 +186,6 @@ class CargoPackageTemplate(PackageTemplate):
     """Provides appropriate overrides for cargo-based packages"""
 
     base_class_name = "CargoPackage"
-    package_class_import = "from spack_repo.builtin.build_systems.cargo import CargoPackage"
 
     body_def = ""
 
@@ -205,7 +194,6 @@ class CMakePackageTemplate(PackageTemplate):
     """Provides appropriate overrides for CMake-based packages"""
 
     base_class_name = "CMakePackage"
-    package_class_import = "from spack_repo.builtin.build_systems.cmake import CMakePackage"
 
     body_def = """\
     def cmake_args(self):
@@ -220,7 +208,6 @@ class GoPackageTemplate(PackageTemplate):
     """Provides appropriate overrides for Go-module-based packages"""
 
     base_class_name = "GoPackage"
-    package_class_import = "from spack_repo.builtin.build_systems.go import GoPackage"
 
     body_def = ""
 
@@ -229,7 +216,6 @@ class LuaPackageTemplate(PackageTemplate):
     """Provides appropriate overrides for LuaRocks-based packages"""
 
     base_class_name = "LuaPackage"
-    package_class_import = "from spack_repo.builtin.build_systems.lua import LuaPackage"
 
     body_def = """\
     def luarocks_args(self):
@@ -251,7 +237,6 @@ class MesonPackageTemplate(PackageTemplate):
     """Provides appropriate overrides for meson-based packages"""
 
     base_class_name = "MesonPackage"
-    package_class_import = "from spack_repo.builtin.build_systems.meson import MesonPackage"
 
     body_def = """\
     def meson_args(self):
@@ -264,7 +249,6 @@ class QMakePackageTemplate(PackageTemplate):
     """Provides appropriate overrides for QMake-based packages"""
 
     base_class_name = "QMakePackage"
-    package_class_import = "from spack_repo.builtin.build_systems.qmake import QMakePackage"
 
     body_def = """\
     def qmake_args(self):
@@ -277,7 +261,6 @@ class MavenPackageTemplate(PackageTemplate):
     """Provides appropriate overrides for Maven-based packages"""
 
     base_class_name = "MavenPackage"
-    package_class_import = "from spack_repo.builtin.build_systems.maven import MavenPackage"
 
     body_def = """\
     def build(self, spec, prefix):
@@ -289,7 +272,6 @@ class SconsPackageTemplate(PackageTemplate):
     """Provides appropriate overrides for SCons-based packages"""
 
     base_class_name = "SConsPackage"
-    package_class_import = "from spack_repo.builtin.build_systems.scons import SConsPackage"
 
     body_def = """\
     def build_args(self, spec, prefix):
@@ -303,7 +285,6 @@ class WafPackageTemplate(PackageTemplate):
     """Provides appropriate override for Waf-based packages"""
 
     base_class_name = "WafPackage"
-    package_class_import = "from spack_repo.builtin.build_systems.waf import WafPackage"
 
     body_def = """\
     # FIXME: Override configure_args(), build_args(),
@@ -327,7 +308,6 @@ class RacketPackageTemplate(PackageTemplate):
     """Provides approriate overrides for Racket extensions"""
 
     base_class_name = "RacketPackage"
-    package_class_import = "from spack_repo.builtin.build_systems.racket import RacketPackage"
 
     url_line = """\
     # FIXME: set the proper location from which to fetch your package
@@ -365,7 +345,6 @@ class PythonPackageTemplate(PackageTemplate):
     """Provides appropriate overrides for python extensions"""
 
     base_class_name = "PythonPackage"
-    package_class_import = "from spack_repo.builtin.build_systems.python import PythonPackage"
 
     dependencies = """\
     # FIXME: Only add the python/pip/wheel dependencies if you need specific versions
@@ -453,7 +432,6 @@ class RPackageTemplate(PackageTemplate):
     """Provides appropriate overrides for R extensions"""
 
     base_class_name = "RPackage"
-    package_class_import = "from spack_repo.builtin.build_systems.r import RPackage"
 
     dependencies = """\
     # FIXME: Add dependencies if required.
@@ -494,7 +472,6 @@ class PerlmakePackageTemplate(PackageTemplate):
     that come with a Makefile.PL"""
 
     base_class_name = "PerlPackage"
-    package_class_import = "from spack_repo.builtin.build_systems.perl import PerlPackage"
 
     dependencies = """\
     # FIXME: Add dependencies if required:
@@ -532,7 +509,6 @@ class OctavePackageTemplate(PackageTemplate):
     """Provides appropriate overrides for octave packages"""
 
     base_class_name = "OctavePackage"
-    package_class_import = "from spack_repo.builtin.build_systems.octave import OctavePackage"
 
     dependencies = """\
     extends("octave")
@@ -555,7 +531,6 @@ class RubyPackageTemplate(PackageTemplate):
     """Provides appropriate overrides for Ruby packages"""
 
     base_class_name = "RubyPackage"
-    package_class_import = "from spack_repo.builtin.build_systems.ruby import RubyPackage"
 
     dependencies = """\
     # FIXME: Add dependencies if required. Only add the ruby dependency
@@ -584,7 +559,6 @@ class MakefilePackageTemplate(PackageTemplate):
     """Provides appropriate overrides for Makefile packages"""
 
     base_class_name = "MakefilePackage"
-    package_class_import = "from spack_repo.builtin.build_systems.makefile import MakefilePackage"
 
     body_def = """\
     def edit(self, spec, prefix):
@@ -599,7 +573,6 @@ class IntelPackageTemplate(PackageTemplate):
     """Provides appropriate overrides for licensed Intel software"""
 
     base_class_name = "IntelOneApiPackage"
-    package_class_import = "from spack_repo.builtin.build_systems.oneapi import IntelOneApiPackage"
 
     body_def = """\
     # FIXME: Override `setup_environment` if necessary."""
@@ -609,7 +582,6 @@ class SIPPackageTemplate(PackageTemplate):
     """Provides appropriate overrides for SIP packages."""
 
     base_class_name = "SIPPackage"
-    package_class_import = "from spack_repo.builtin.build_systems.sip import SIPPackage"
 
     body_def = """\
     def configure_args(self, spec, prefix):

lib/spack/spack/cmd/edit.py

@@ -28,7 +28,7 @@ def setup_parser(subparser):
         "--build-system",
         dest="path",
         action="store_const",
-        const=os.path.join(spack.repo.PATH.repos[0].root, "build_systems"),
+        const=spack.paths.build_systems_path,
         help="edit the build system with the supplied name",
     )
     excl_args.add_argument(

lib/spack/spack/cmd/pkg.py

@@ -183,7 +183,7 @@ def pkg_grep(args, unknown_args):
         grep.add_default_arg("--color=auto")
 
     # determines number of files to grep at a time
-    grouper = lambda e: e[0] // 100
+    grouper = lambda e: e[0] // 500
 
     # set up iterator and save the first group to ensure we don't end up with a group of size 1
     groups = itertools.groupby(enumerate(spack.repo.PATH.all_package_paths()), grouper)

lib/spack/spack/cmd/style.py

@@ -332,8 +332,18 @@ def process_files(file_list, is_args):
 
             rewrite_and_print_output(output, args, pat, replacement)
 
+    packages_isort_args = (
+        "--rm",
+        "spack.pkgkit",
+        "--rm",
+        "spack.package_defs",
+        "-a",
+        "from spack.package import *",
+    )
+    packages_isort_args = packages_isort_args + isort_args
+
     # packages
-    process_files(filter(is_package, file_list), isort_args)
+    process_files(filter(is_package, file_list), packages_isort_args)
     # non-packages
     process_files(filter(lambda f: not is_package(f), file_list), isort_args)
 

lib/spack/spack/environment/environment.py

@@ -5,7 +5,6 @@
 import collections.abc
 import contextlib
 import errno
-import glob
 import os
 import pathlib
 import re
@@ -2425,11 +2424,19 @@ def display_specs(specs):
 
 def make_repo_path(root):
     """Make a RepoPath from the repo subdirectories in an environment."""
-    repos = [
+    path = spack.repo.RepoPath(cache=spack.caches.MISC_CACHE)
-        spack.repo.from_path(os.path.dirname(p))
+
-        for p in glob.glob(os.path.join(root, "**", "repo.yaml"), recursive=True)
+    if os.path.isdir(root):
-    ]
+        for repo_root in os.listdir(root):
-    return spack.repo.RepoPath(*repos, cache=spack.caches.MISC_CACHE)
+            repo_root = os.path.join(root, repo_root)
+
+            if not os.path.isdir(repo_root):
+                continue
+
+            repo = spack.repo.from_path(repo_root)
+            path.put_last(repo)
+
+    return path
 
 
 def manifest_file(env_name_or_dir):

lib/spack/spack/package.py

@@ -2,6 +2,7 @@
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
+# flake8: noqa: F401, E402
 """spack.package defines the public API for Spack packages, by re-exporting useful symbols from
 other modules. Packages should import this module, instead of importing from spack.* directly
 to ensure forward compatibility with future versions of Spack."""
@@ -12,6 +13,17 @@
 # import most common types used in packages
 from typing import Dict, List, Optional
 
+
+class tty:
+    import llnl.util.tty as _tty
+
+    debug = _tty.debug
+    error = _tty.error
+    info = _tty.info
+    msg = _tty.msg
+    warn = _tty.warn
+
+
 from llnl.util.filesystem import (
     FileFilter,
     FileList,
@@ -49,7 +61,52 @@
 from llnl.util.symlink import symlink
 
 from spack.build_environment import MakeExecutable
-from spack.builder import BaseBuilder, Builder, register_builder
+from spack.build_systems.aspell_dict import AspellDictPackage
+from spack.build_systems.autotools import AutotoolsPackage
+from spack.build_systems.bundle import BundlePackage
+from spack.build_systems.cached_cmake import (
+    CachedCMakePackage,
+    cmake_cache_filepath,
+    cmake_cache_option,
+    cmake_cache_path,
+    cmake_cache_string,
+)
+from spack.build_systems.cargo import CargoPackage
+from spack.build_systems.cmake import CMakePackage, generator
+from spack.build_systems.compiler import CompilerPackage
+from spack.build_systems.cuda import CudaPackage
+from spack.build_systems.generic import Package
+from spack.build_systems.gnu import GNUMirrorPackage
+from spack.build_systems.go import GoPackage
+from spack.build_systems.intel import IntelPackage
+from spack.build_systems.lua import LuaPackage
+from spack.build_systems.makefile import MakefilePackage
+from spack.build_systems.maven import MavenPackage
+from spack.build_systems.meson import MesonPackage
+from spack.build_systems.msbuild import MSBuildPackage
+from spack.build_systems.nmake import NMakePackage
+from spack.build_systems.octave import OctavePackage
+from spack.build_systems.oneapi import (
+    INTEL_MATH_LIBRARIES,
+    IntelOneApiLibraryPackage,
+    IntelOneApiLibraryPackageWithSdk,
+    IntelOneApiPackage,
+    IntelOneApiStaticLibraryList,
+)
+from spack.build_systems.perl import PerlPackage
+from spack.build_systems.python import PythonExtension, PythonPackage
+from spack.build_systems.qmake import QMakePackage
+from spack.build_systems.r import RPackage
+from spack.build_systems.racket import RacketPackage
+from spack.build_systems.rocm import ROCmPackage
+from spack.build_systems.ruby import RubyPackage
+from spack.build_systems.scons import SConsPackage
+from spack.build_systems.sip import SIPPackage
+from spack.build_systems.sourceforge import SourceforgePackage
+from spack.build_systems.sourceware import SourcewarePackage
+from spack.build_systems.waf import WafPackage
+from spack.build_systems.xorg import XorgPackage
+from spack.builder import BaseBuilder
 from spack.config import determine_number_of_jobs
 from spack.deptypes import ALL_TYPES as all_deptypes
 from spack.directives import (
@@ -81,13 +138,7 @@
 )
 from spack.mixins import filter_compiler_wrappers
 from spack.multimethod import default_args, when
-from spack.package_base import (
+from spack.package_base import build_system_flags, env_flags, inject_flags, on_package_attributes
-    PackageBase,
-    build_system_flags,
-    env_flags,
-    inject_flags,
-    on_package_attributes,
-)
 from spack.package_completions import (
     bash_completion_path,
     fish_completion_path,
@@ -107,126 +158,6 @@
 cd = chdir
 pwd = getcwd
 
-
-class tty:
-    import llnl.util.tty as _tty
-
-    debug = _tty.debug
-    error = _tty.error
-    info = _tty.info
-    msg = _tty.msg
-    warn = _tty.warn
-
-
-__all__ = [
-    "chdir",
-    "environ",
-    "getcwd",
-    "makedirs",
-    "mkdir",
-    "remove",
-    "removedirs",
-    "move",
-    "rmtree",
-    "Dict",
-    "List",
-    "Optional",
-    "FileFilter",
-    "FileList",
-    "HeaderList",
-    "LibraryList",
-    "ancestor",
-    "can_access",
-    "change_sed_delimiter",
-    "copy",
-    "copy_tree",
-    "filter_file",
-    "find",
-    "find_all_headers",
-    "find_first",
-    "find_headers",
-    "find_libraries",
-    "find_system_libraries",
-    "force_remove",
-    "force_symlink",
-    "install",
-    "install_tree",
-    "is_exe",
-    "join_path",
-    "keep_modification_time",
-    "library_extensions",
-    "mkdirp",
-    "remove_directory_contents",
-    "remove_linked_tree",
-    "rename",
-    "set_executable",
-    "set_install_permissions",
-    "touch",
-    "working_dir",
-    "symlink",
-    "MakeExecutable",
-    "BaseBuilder",
-    "determine_number_of_jobs",
-    "all_deptypes",
-    "build_system",
-    "can_splice",
-    "conditional",
-    "conflicts",
-    "depends_on",
-    "extends",
-    "license",
-    "maintainers",
-    "patch",
-    "provides",
-    "redistribute",
-    "requires",
-    "resource",
-    "variant",
-    "version",
-    "InstallError",
-    "NoHeadersError",
-    "NoLibrariesError",
-    "SkipTest",
-    "cache_extra_test_sources",
-    "check_outputs",
-    "find_required_file",
-    "get_escaped_text_output",
-    "install_test_root",
-    "test_part",
-    "filter_compiler_wrappers",
-    "default_args",
-    "when",
-    "build_system_flags",
-    "env_flags",
-    "inject_flags",
-    "on_package_attributes",
-    "bash_completion_path",
-    "fish_completion_path",
-    "zsh_completion_path",
-    "run_after",
-    "run_before",
-    "Spec",
-    "EnvironmentModifications",
-    "Executable",
-    "ProcessError",
-    "which",
-    "which_string",
-    "fix_darwin_install_name",
-    "Prefix",
-    "any_combination_of",
-    "auto_or_any_combination_of",
-    "disjoint_sets",
-    "Version",
-    "ver",
-    "env",
-    "cd",
-    "pwd",
-    "tty",
-    "Builder",
-    "PackageBase",
-    "register_builder",
-]
-
 # These are just here for editor support; they may be set when the build env is set up.
 configure: Executable
 make_jobs: int

lib/spack/spack/package_base.py

@@ -583,7 +583,7 @@ class PackageBase(WindowsRPath, PackageViewMixin, metaclass=PackageMeta):
     like ``homepage`` and, for a code-based package, ``url``, or functions
     such as ``install()``.
     There are many custom ``Package`` subclasses in the
-    ``spack_repo.builtin.build_systems`` package that make things even easier for
+    ``spack.build_systems`` package that make things even easier for
     specific build systems.
 
     """

lib/spack/spack/paths.py

@@ -58,7 +58,7 @@
 repos_path = os.path.join(var_path, "repos")
 test_repos_path = os.path.join(var_path, "test_repos")
 packages_path = os.path.join(repos_path, "spack_repo", "builtin")
-mock_packages_path = os.path.join(test_repos_path, "spack_repo", "builtin_mock")
+mock_packages_path = os.path.join(test_repos_path, "builtin.mock")
 
 #
 # Writable things in $spack/var/spack

lib/spack/spack/repo.py

@@ -85,7 +85,7 @@ def __init__(self, fullname: str, repo: "Repo", package_name: str) -> None:
         self.package_name = package_name
         path = repo.filename_for_package_name(package_name)
         self.fullname = fullname
-        self.prepend = b"from spack_repo.builtin.build_systems._package_api_v1 import *\n"
+        self.prepend = b"from spack.build_systems._package_api_v1 import *\n"
         super().__init__(self.fullname, path)
 
     def path_stats(self, path):
@@ -173,7 +173,7 @@ def compute_loader(self, fullname: str):
 def builtin_repo() -> "Repo":
     """Get the test repo if it is active, otherwise the builtin repo."""
     try:
-        return PATH.get_repo("builtin_mock")
+        return PATH.get_repo("builtin.mock")
     except UnknownNamespaceError:
         return PATH.get_repo("builtin")
 

lib/spack/spack/repo_migrate.py

@@ -3,7 +3,6 @@
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 import ast
-import difflib
 import os
 import re
 import shutil
@@ -83,8 +82,7 @@ def migrate_v1_to_v2(
 
     errors = False
 
-    stack: List[Tuple[str, int]] = [(repo.packages_path, 0)]
+    stack: List[Tuple[str, int]] = [(repo.root, 0)]
-
     while stack:
         path, depth = stack.pop()
 
@@ -102,11 +100,7 @@ def migrate_v1_to_v2(
             ino_to_relpath[entry.inode()] = entry.path[prefix_len:]
 
             if entry.is_symlink():
-                try:
+                symlink_to_ino[rel_path] = entry.stat(follow_symlinks=True).st_ino
-                    symlink_to_ino[rel_path] = entry.stat(follow_symlinks=True).st_ino
-                except OSError:
-                    symlink_to_ino[rel_path] = -1  # dangling or no access
-
                 continue
 
             elif entry.is_dir(follow_symlinks=False):
@@ -114,7 +108,11 @@ def migrate_v1_to_v2(
                     continue
 
                 # check if this is a package
-                if depth == 0 and os.path.exists(os.path.join(entry.path, "package.py")):
+                if (
+                    depth == 1
+                    and rel_path.startswith(f"{subdirectory}{os.sep}")
+                    and os.path.exists(os.path.join(entry.path, "package.py"))
+                ):
                     if "_" in entry.name:
                         print(
                             f"Invalid package name '{entry.name}': underscores are not allowed in "
@@ -142,16 +140,12 @@ def migrate_v1_to_v2(
     rename_regex = re.compile("^(" + "|".join(re.escape(k) for k in rename.keys()) + ")")
 
     if fix:
-        os.makedirs(os.path.join(new_root, repo.subdirectory), exist_ok=True)
+        os.makedirs(new_root, exist_ok=True)
 
     def _relocate(rel_path: str) -> Tuple[str, str]:
-        old = os.path.join(repo.root, rel_path)
+        return os.path.join(repo.root, rel_path), os.path.join(
-        if rename:
+            new_root, rename_regex.sub(lambda m: rename[m.group(0)], rel_path)
-            new_rel = rename_regex.sub(lambda m: rename[m.group(0)], rel_path)
+        )
-        else:
-            new_rel = rel_path
-        new = os.path.join(new_root, new_rel)
-        return old, new
 
     if not fix:
         print("The following directories, files and symlinks will be created:\n", file=out)
@@ -221,16 +215,6 @@ def _relocate(rel_path: str) -> Tuple[str, str]:
     return result, (updated_repo if fix else None)
 
 
-def _spack_pkg_to_spack_repo(modulename: str) -> str:
-    # rewrite spack.pkg.builtin.foo -> spack_repo.builtin.packages.foo.package
-    parts = modulename.split(".")
-    assert parts[:2] == ["spack", "pkg"]
-    parts[0:2] = ["spack_repo"]
-    parts.insert(2, "packages")
-    parts.append("package")
-    return ".".join(parts)
-
-
 def migrate_v2_imports(
     packages_dir: str, root: str, fix: bool, out: IO[str] = sys.stdout, err: IO[str] = sys.stderr
 ) -> bool:
@@ -255,6 +239,7 @@ def migrate_v2_imports(
         "Package": "spack_repo.builtin.build_systems.generic",
         "GNUMirrorPackage": "spack_repo.builtin.build_systems.gnu",
         "GoPackage": "spack_repo.builtin.build_systems.go",
+        "IntelPackage": "spack_repo.builtin.build_systems.intel",
         "LuaPackage": "spack_repo.builtin.build_systems.lua",
         "MakefilePackage": "spack_repo.builtin.build_systems.makefile",
         "MavenPackage": "spack_repo.builtin.build_systems.maven",
@@ -307,41 +292,12 @@ def migrate_v2_imports(
         #: Set of symbols of interest that are already defined through imports, assignments, or
         #: function definitions.
         defined_symbols: Set[str] = set()
+
         best_line: Optional[int] = None
+
         seen_import = False
-        module_replacements: Dict[str, str] = {}
-        parent: Dict[int, ast.AST] = {}
-
-        #: List of (line, col start, old, new) tuples of strings to be replaced inline.
-        inline_updates: List[Tuple[int, int, str, str]] = []
-
-        #: List of (line from, line to, new lines) tuples of line replacements
-        multiline_updates: List[Tuple[int, int, List[str]]] = []
-
-        with open(pkg_path, "r", encoding="utf-8", newline="") as file:
-            original_lines = file.readlines()
-
-        if len(original_lines) < 2:  # assume packagepy files have at least 2 lines...
-            continue
-
-        if original_lines[0].endswith("\r\n"):
-            newline = "\r\n"
-        elif original_lines[0].endswith("\n"):
-            newline = "\n"
-        elif original_lines[0].endswith("\r"):
-            newline = "\r"
-        else:
-            success = False
-            print(f"{pkg_path}: unknown line ending, cannot fix", file=err)
-            continue
-
-        updated_lines = original_lines.copy()
 
         for node in ast.walk(tree):
-            for child in ast.iter_child_nodes(node):
-                if isinstance(child, ast.Attribute):
-                    parent[id(child)] = node
-
             # Get the last import statement from the first block of top-level imports
             if isinstance(node, ast.Module):
                 for child in ast.iter_child_nodes(node):
@@ -361,7 +317,7 @@ def migrate_v2_imports(
 
                     if is_import:
                         if isinstance(child, (ast.stmt, ast.expr)):
-                            best_line = (getattr(child, "end_lineno", None) or child.lineno) + 1
+                            best_line = (child.end_lineno or child.lineno) + 1
 
                     if not seen_import and is_import:
                         seen_import = True
@@ -390,89 +346,12 @@ def migrate_v2_imports(
             elif isinstance(node, ast.Name) and node.id in symbol_to_module:
                 referenced_symbols.add(node.id)
 
-            # Find lines where spack.pkg is used.
+            # Register imported symbols to make this operation idempotent
-            elif (
-                isinstance(node, ast.Attribute)
-                and isinstance(node.value, ast.Name)
-                and node.value.id == "spack"
-                and node.attr == "pkg"
-            ):
-                # go as many attrs up until we reach a known module name to be replaced
-                known_module = "spack.pkg"
-                ancestor = node
-                while True:
-                    next_parent = parent.get(id(ancestor))
-                    if next_parent is None or not isinstance(next_parent, ast.Attribute):
-                        break
-                    ancestor = next_parent
-                    known_module = f"{known_module}.{ancestor.attr}"
-                    if known_module in module_replacements:
-                        break
-
-                inline_updates.append(
-                    (
-                        ancestor.lineno,
-                        ancestor.col_offset,
-                        known_module,
-                        module_replacements[known_module],
-                    )
-                )
-
             elif isinstance(node, ast.ImportFrom):
-                # Keep track of old style spack.pkg imports, to be replaced.
-                if node.module and node.module.startswith("spack.pkg.") and node.level == 0:
-
-                    depth = node.module.count(".")
-
-                    # simple case of find and replace
-                    # from spack.pkg.builtin.my_pkg import MyPkg
-                    # -> from spack_repo.builtin.packages.my_pkg.package import MyPkg
-                    if depth == 3:
-                        module_replacements[node.module] = _spack_pkg_to_spack_repo(node.module)
-                        inline_updates.append(
-                            (
-                                node.lineno,
-                                node.col_offset,
-                                node.module,
-                                module_replacements[node.module],
-                            )
-                        )
-
-                    # non-trivial possible multiline case
-                    # from spack.pkg.builtin import (boost, cmake as foo)
-                    # -> import spack_repo.builtin.packages.boost.package as boost
-                    # -> import spack_repo.builtin.packages.cmake.package as foo
-                    elif depth == 2 and node.end_lineno is not None:
-                        _, _, namespace = node.module.rpartition(".")
-                        indent = original_lines[node.lineno - 1][: node.col_offset]
-                        multiline_updates.append(
-                            (
-                                node.lineno,
-                                node.end_lineno + 1,
-                                [
-                                    f"{indent}import spack_repo.{namespace}.packages."
-                                    f"{alias.name}.package as {alias.asname or alias.name}"
-                                    f"{newline}"
-                                    for alias in node.names
-                                ],
-                            )
-                        )
-
-                    else:
-                        success = False
-                        print(
-                            f"{pkg_path}:{node.lineno}: don't know how to rewrite `{node.module}`",
-                            file=err,
-                        )
-
-                # Subtract the symbols that are imported so we don't repeatedly add imports.
                 for alias in node.names:
                     if alias.name in symbol_to_module:
-                        if alias.asname is None:
+                        defined_symbols.add(alias.name)
-                            defined_symbols.add(alias.name)
+                        if node.module == "spack.package":
-
-                        # error when symbols are explicitly imported that are no longer available
-                        if node.module == "spack.package" and node.level == 0:
                             success = False
                             print(
                                 f"{pkg_path}:{node.lineno}: `{alias.name}` is imported from "
@@ -483,84 +362,59 @@ def migrate_v2_imports(
                     if alias.asname and alias.asname in symbol_to_module:
                         defined_symbols.add(alias.asname)
 
-            elif isinstance(node, ast.Import):
-                # normal imports are easy find and replace since they are single lines.
-                for alias in node.names:
-                    if alias.asname and alias.asname in symbol_to_module:
-                        defined_symbols.add(alias.name)
-                    elif alias.asname is None and alias.name.startswith("spack.pkg."):
-                        module_replacements[alias.name] = _spack_pkg_to_spack_repo(alias.name)
-                        inline_updates.append(
-                            (
-                                alias.lineno,
-                                alias.col_offset,
-                                alias.name,
-                                module_replacements[alias.name],
-                            )
-                        )
-
         # Remove imported symbols from the referenced symbols
         referenced_symbols.difference_update(defined_symbols)
 
-        # Sort from last to first so we can modify without messing up the line / col offsets
+        if not referenced_symbols:
-        inline_updates.sort(reverse=True)
-
-        # Nothing to change here.
-        if not inline_updates and not referenced_symbols:
             continue
 
-        # First do module replacements of spack.pkg imports
+        if best_line is None:
-        for line, col, old, new in inline_updates:
+            print(f"{pkg_path}: failed to update imports", file=err)
-            updated_lines[line - 1] = updated_lines[line - 1][:col] + updated_lines[line - 1][
+            success = False
-                col:
+            continue
-            ].replace(old, new, 1)
 
-        # Then insert new imports for symbols referenced in the package
+        # Add the missing imports right after the last import statement
-        if referenced_symbols:
+        with open(pkg_path, "r", encoding="utf-8", newline="") as file:
-            if best_line is None:
+            lines = file.readlines()
-                print(f"{pkg_path}: failed to update imports", file=err)
-                success = False
-                continue
 
-            # Group missing symbols by their module
+        # Group missing symbols by their module
-            missing_imports_by_module: Dict[str, list] = {}
+        missing_imports_by_module: Dict[str, list] = {}
-            for symbol in referenced_symbols:
+        for symbol in referenced_symbols:
-                module = symbol_to_module[symbol]
+            module = symbol_to_module[symbol]
-                if module not in missing_imports_by_module:
+            if module not in missing_imports_by_module:
-                    missing_imports_by_module[module] = []
+                missing_imports_by_module[module] = []
-                missing_imports_by_module[module].append(symbol)
+            missing_imports_by_module[module].append(symbol)
 
-            new_lines = [
+        new_lines = [
-                f"from {module} import {', '.join(sorted(symbols))}{newline}"
+            f"from {module} import {', '.join(sorted(symbols))}\n"
-                for module, symbols in sorted(missing_imports_by_module.items())
+            for module, symbols in sorted(missing_imports_by_module.items())
-            ]
+        ]
 
-            if not seen_import:
+        if not seen_import:
-                new_lines.extend((newline, newline))
+            new_lines.extend(("\n", "\n"))
 
-            multiline_updates.append((best_line, best_line, new_lines))
+        if not fix:  # only print the diff
-
+            success = False  # packages need to be fixed, but we didn't do it
-        multiline_updates.sort(reverse=True)
+            diff_start, diff_end = max(1, best_line - 3), min(best_line + 2, len(lines))
-        for start, end, new_lines in multiline_updates:
+            num_changed = diff_end - diff_start + 1
-            updated_lines[start - 1 : end - 1] = new_lines
+            num_added = num_changed + len(new_lines)
-
-        if not fix:
             rel_pkg_path = os.path.relpath(pkg_path, start=root)
-            diff = difflib.unified_diff(
+            out.write(f"--- a/{rel_pkg_path}\n+++ b/{rel_pkg_path}\n")
-                original_lines,
+            out.write(f"@@ -{diff_start},{num_changed} +{diff_start},{num_added} @@\n")
-                updated_lines,
+            for line in lines[diff_start - 1 : best_line - 1]:
-                n=3,
+                out.write(f" {line}")
-                fromfile=f"a/{rel_pkg_path}",
+            for line in new_lines:
-                tofile=f"b/{rel_pkg_path}",
+                out.write(f"+{line}")
-            )
+            for line in lines[best_line - 1 : diff_end]:
-            out.write("".join(diff))
+                out.write(f" {line}")
             continue
 
+        lines[best_line - 1 : best_line - 1] = new_lines
+
         tmp_file = pkg_path + ".tmp"
 
-        # binary mode to avoid newline conversion issues; utf-8 was already required upon read.
+        with open(tmp_file, "w", encoding="utf-8", newline="") as file:
-        with open(tmp_file, "wb") as file:
+            file.writelines(lines)
-            file.write("".join(updated_lines).encode("utf-8"))
 
         os.replace(tmp_file, pkg_path)
 

lib/spack/spack/test/build_systems.py

@@ -12,7 +12,8 @@
 
 import llnl.util.filesystem as fs
 
-import spack
+import spack.build_systems.autotools
+import spack.build_systems.cmake
 import spack.builder
 import spack.concretize
 import spack.environment
@@ -27,8 +28,6 @@
 
 DATA_PATH = os.path.join(spack.paths.test_path, "data")
 
-pytestmark = pytest.mark.skip(reason="build_systems module is moved out of spack")
-
 
 @pytest.fixture()
 def concretize_and_setup(default_mock_concretization, monkeypatch):

lib/spack/spack/test/builder.py

@@ -15,7 +15,7 @@
 
 @pytest.fixture()
 def builder_test_repository(config):
-    builder_test_path = os.path.join(spack.paths.test_repos_path, "spack_repo", "builder_test")
+    builder_test_path = os.path.join(spack.paths.test_repos_path, "builder.test")
     with spack.repo.use_repositories(builder_test_path) as mock_repo:
         yield mock_repo
 

lib/spack/spack/test/cmd/buildcache.py

@@ -549,10 +549,11 @@ def test_url_buildcache_entry_v2_exists(
 ):
     """Test existence check for v2 buildcache entries"""
     test_mirror_path = v2_buildcache_layout("unsigned")
-    mirror_url = pathlib.Path(test_mirror_path).as_uri()
+    mirror_url = f"file://{test_mirror_path}"
     mirror("add", "v2mirror", mirror_url)
 
-    output = buildcache("list", "-a", "-l")
+    with capsys.disabled():
+        output = buildcache("list", "-a", "-l")
 
     assert "Fetching an index from a v2 binary mirror layout" in output
     assert "is deprecated" in output

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

@@ -2,39 +2,134 @@
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
-import os
-
 import pytest
 
 import spack.cmd.diff
 import spack.concretize
 import spack.main
-import spack.paths
 import spack.repo
 import spack.util.spack_json as sjson
+from spack.test.conftest import create_test_repo
 
 install_cmd = spack.main.SpackCommand("install")
 diff_cmd = spack.main.SpackCommand("diff")
 find_cmd = spack.main.SpackCommand("find")
 
+
+_p1 = (
+    "p1",
+    """\
+from spack.package import *
+
+class P1(Package):
+    version("1.0")
+
+    variant("p1var", default=True)
+    variant("usev1", default=True)
+
+    depends_on("p2")
+    depends_on("v1", when="+usev1")
+""",
+)
+
+
+_p2 = (
+    "p2",
+    """\
+from spack.package import *
+
+class P2(Package):
+    version("1.0")
+
+    variant("p2var", default=True)
+
+    depends_on("p3")
+""",
+)
+
+
+_p3 = (
+    "p3",
+    """\
+from spack.package import *
+
+class P3(Package):
+    version("1.0")
+
+    variant("p3var", default=True)
+""",
+)
+
+_i1 = (
+    "i1",
+    """\
+from spack.package import *
+
+class I1(Package):
+    version("1.0")
+
+    provides("v1")
+
+    variant("i1var", default=True)
+
+    depends_on("p3")
+    depends_on("p4")
+""",
+)
+
+_i2 = (
+    "i2",
+    """\
+from spack.package import *
+
+class I2(Package):
+    version("1.0")
+
+    provides("v1")
+
+    variant("i2var", default=True)
+
+    depends_on("p3")
+    depends_on("p4")
+""",
+)
+
+
+_p4 = (
+    "p4",
+    """\
+from spack.package import *
+
+class P4(Package):
+    version("1.0")
+
+    variant("p4var", default=True)
+""",
+)
+
+
 # Note that the hash of p1 will differ depending on the variant chosen
 # we probably always want to omit that from diffs
-# p1____
+@pytest.fixture
-# |     \
+def _create_test_repo(tmpdir, mutable_config):
-# p2     v1
+    """
-# | ____/ |
+    p1____
-# p3      p4
+    |     \
+    p2     v1
+    | ____/ |
+    p3      p4
 
-# i1 and i2 provide v1 (and both have the same dependencies)
+    i1 and i2 provide v1 (and both have the same dependencies)
 
-# All packages have an associated variant
+    All packages have an associated variant
+    """
+    yield create_test_repo(tmpdir, [_p1, _p2, _p3, _i1, _i2, _p4])
 
 
 @pytest.fixture
-def test_repo(config):
+def test_repo(_create_test_repo, monkeypatch, mock_stage):
-    builder_test_path = os.path.join(spack.paths.test_repos_path, "spack_repo", "diff")
+    with spack.repo.use_repositories(_create_test_repo) as mock_repo_path:
-    with spack.repo.use_repositories(builder_test_path) as mock_repo:
+        yield mock_repo_path
-        yield mock_repo
 
 
 def test_diff_ignore(test_repo):

lib/spack/spack/test/cmd/edit.py

@@ -6,6 +6,7 @@
 
 import spack.repo
 import spack.util.editor
+from spack.build_systems import autotools, cmake
 from spack.main import SpackCommand
 
 edit = SpackCommand("edit")
@@ -28,15 +29,13 @@ def editor(*args: str, **kwargs):
     assert called
 
 
-def test_edit_files(monkeypatch, mock_packages):
+def test_edit_files(monkeypatch):
     """Test spack edit --build-system autotools cmake"""
     called = False
 
     def editor(*args: str, **kwargs):
         nonlocal called
         called = True
-        from spack_repo.builtin_mock.build_systems import autotools, cmake  # type: ignore
-
         assert os.path.samefile(args[0], autotools.__file__)
         assert os.path.samefile(args[1], cmake.__file__)
 

lib/spack/spack/test/cmd/env.py

@@ -886,12 +886,12 @@ def test_env_activate_broken_view(
     with spack.repo.use_repositories(mock_custom_repository):
         wrong_repo = env("activate", "--sh", "test")
         assert "Warning: could not load runtime environment" in wrong_repo
-        assert "Unknown namespace: builtin_mock" in wrong_repo
+        assert "Unknown namespace: builtin.mock" in wrong_repo
 
     # test replacing repo fixes it
     normal_repo = env("activate", "--sh", "test")
     assert "Warning: could not load runtime environment" not in normal_repo
-    assert "Unknown namespace: builtin_mock" not in normal_repo
+    assert "Unknown namespace: builtin.mock" not in normal_repo
 
 
 def test_to_lockfile_dict():
@@ -916,7 +916,7 @@ def test_env_repo():
 
     pkg_cls = e.repo.get_pkg_class("mpileaks")
     assert pkg_cls.name == "mpileaks"
-    assert pkg_cls.namespace == "builtin_mock"
+    assert pkg_cls.namespace == "builtin.mock"
 
 
 def test_user_removed_spec(environment_from_manifest):

lib/spack/spack/test/cmd/external.py

@@ -102,25 +102,25 @@ def _determine_version(cls, exe):
             ["detectable"],
             [],
             [
-                "builtin_mock.cmake",
+                "builtin.mock.cmake",
-                "builtin_mock.find-externals1",
+                "builtin.mock.find-externals1",
-                "builtin_mock.gcc",
+                "builtin.mock.gcc",
-                "builtin_mock.intel-oneapi-compilers",
+                "builtin.mock.intel-oneapi-compilers",
-                "builtin_mock.llvm",
+                "builtin.mock.llvm",
-                "builtin_mock.mpich",
+                "builtin.mock.mpich",
             ],
         ),
         # find --all --exclude find-externals1
         (
             None,
             ["detectable"],
-            ["builtin_mock.find-externals1"],
+            ["builtin.mock.find-externals1"],
             [
-                "builtin_mock.cmake",
+                "builtin.mock.cmake",
-                "builtin_mock.gcc",
+                "builtin.mock.gcc",
-                "builtin_mock.intel-oneapi-compilers",
+                "builtin.mock.intel-oneapi-compilers",
-                "builtin_mock.llvm",
+                "builtin.mock.llvm",
-                "builtin_mock.mpich",
+                "builtin.mock.mpich",
             ],
         ),
         (
@@ -128,11 +128,11 @@ def _determine_version(cls, exe):
             ["detectable"],
             ["find-externals1"],
             [
-                "builtin_mock.cmake",
+                "builtin.mock.cmake",
-                "builtin_mock.gcc",
+                "builtin.mock.gcc",
-                "builtin_mock.intel-oneapi-compilers",
+                "builtin.mock.intel-oneapi-compilers",
-                "builtin_mock.llvm",
+                "builtin.mock.llvm",
-                "builtin_mock.mpich",
+                "builtin.mock.mpich",
             ],
         ),
         # find hwloc (and mock hwloc is not detectable)

lib/spack/spack/test/cmd/find.py

@@ -14,12 +14,12 @@
 import spack.cmd.find
 import spack.concretize
 import spack.environment as ev
-import spack.paths
 import spack.repo
 import spack.store
 import spack.user_environment as uenv
 from spack.enums import InstallRecordStatus
 from spack.main import SpackCommand
+from spack.test.conftest import create_test_repo
 from spack.test.utilities import SpackCommandArgs
 from spack.util.pattern import Bunch
 
@@ -129,7 +129,7 @@ def test_tag2_tag3(parser, specs):
 @pytest.mark.db
 def test_namespaces_shown_correctly(args, with_namespace, database):
     """Test that --namespace(s) works. Old syntax is --namespace"""
-    assert ("builtin_mock.zmpi" in find(*args)) == with_namespace
+    assert ("builtin.mock.zmpi" in find(*args)) == with_namespace
 
 
 @pytest.mark.db
@@ -462,16 +462,89 @@ def test_environment_with_version_range_in_compiler_doesnt_fail(tmp_path, mock_p
     assert "zlib" in output
 
 
-#   a0  d0
+_pkga = (
-#  / \ / \
+    "a0",
-# b0  c0  e0
+    """\
+from spack.package import *
+
+class A0(Package):
+    version("1.2")
+    version("1.1")
+
+    depends_on("b0")
+    depends_on("c0")
+""",
+)
+
+
+_pkgb = (
+    "b0",
+    """\
+from spack.package import *
+
+class B0(Package):
+    version("1.2")
+    version("1.1")
+""",
+)
+
+
+_pkgc = (
+    "c0",
+    """\
+from spack.package import *
+
+class C0(Package):
+    version("1.2")
+    version("1.1")
+
+    tags = ["tag0", "tag1"]
+""",
+)
+
+
+_pkgd = (
+    "d0",
+    """\
+from spack.package import *
+
+class D0(Package):
+    version("1.2")
+    version("1.1")
+
+    depends_on("c0")
+    depends_on("e0")
+""",
+)
+
+
+_pkge = (
+    "e0",
+    """\
+from spack.package import *
+
+class E0(Package):
+    tags = ["tag1", "tag2"]
+
+    version("1.2")
+    version("1.1")
+""",
+)
 
 
 @pytest.fixture
-def test_repo(mock_stage):
+def _create_test_repo(tmpdir, mutable_config):
-    with spack.repo.use_repositories(
+    r"""
-        os.path.join(spack.paths.test_repos_path, "spack_repo", "find")
+      a0  d0
-    ) as mock_repo_path:
+     / \ / \
+    b0  c0  e0
+    """
+    yield create_test_repo(tmpdir, [_pkga, _pkgb, _pkgc, _pkgd, _pkge])
+
+
+@pytest.fixture
+def test_repo(_create_test_repo, monkeypatch, mock_stage):
+    with spack.repo.use_repositories(_create_test_repo) as mock_repo_path:
         yield mock_repo_path
 
 

lib/spack/spack/test/cmd/list.py

@@ -143,13 +143,13 @@ def test_list_count():
 
 def test_list_repos():
     with spack.repo.use_repositories(
-        os.path.join(spack.paths.test_repos_path, "spack_repo", "builtin_mock"),
+        os.path.join(spack.paths.test_repos_path, "builtin.mock"),
-        os.path.join(spack.paths.test_repos_path, "spack_repo", "builder_test"),
+        os.path.join(spack.paths.test_repos_path, "builder.test"),
     ):
         total_pkgs = len(list().strip().split())
-        mock_pkgs = len(list("-r", "builtin_mock").strip().split())
+        mock_pkgs = len(list("-r", "builtin.mock").strip().split())
-        builder_pkgs = len(list("-r", "builder_test").strip().split())
+        builder_pkgs = len(list("-r", "builder.test").strip().split())
-        both_repos = len(list("-r", "builtin_mock", "-r", "builder_test").strip().split())
+        both_repos = len(list("-r", "builtin.mock", "-r", "builder.test").strip().split())
 
         assert total_pkgs > mock_pkgs > builder_pkgs
         assert both_repos == total_pkgs

lib/spack/spack/test/cmd/pkg.py

@@ -39,9 +39,7 @@ def install(self, spec, prefix):
 def mock_pkg_git_repo(git, tmp_path_factory):
     """Copy the builtin.mock repo and make a mutable git repo inside it."""
     root_dir = tmp_path_factory.mktemp("mock_pkg_git_repo")
-    # create spack_repo subdir
+    repo_dir = root_dir / "builtin.mock"
-    (root_dir / "spack_repo").mkdir()
-    repo_dir = root_dir / "spack_repo" / "builtin_mock"
     shutil.copytree(spack.paths.mock_packages_path, str(repo_dir))
 
     repo_cache = spack.util.file_cache.FileCache(root_dir / "cache")
@@ -59,25 +57,25 @@ def mock_pkg_git_repo(git, tmp_path_factory):
         git("-c", "commit.gpgsign=false", "commit", "-m", "initial mock repo commit")
 
         # add commit with mockpkg-a, mockpkg-b, mockpkg-c packages
-        mkdirp("mockpkg_a", "mockpkg_b", "mockpkg_c")
+        mkdirp("mockpkg-a", "mockpkg-b", "mockpkg-c")
-        with open("mockpkg_a/package.py", "w", encoding="utf-8") as f:
+        with open("mockpkg-a/package.py", "w", encoding="utf-8") as f:
             f.write(pkg_template.format(name="PkgA"))
-        with open("mockpkg_b/package.py", "w", encoding="utf-8") as f:
+        with open("mockpkg-b/package.py", "w", encoding="utf-8") as f:
             f.write(pkg_template.format(name="PkgB"))
-        with open("mockpkg_c/package.py", "w", encoding="utf-8") as f:
+        with open("mockpkg-c/package.py", "w", encoding="utf-8") as f:
             f.write(pkg_template.format(name="PkgC"))
-        git("add", "mockpkg_a", "mockpkg_b", "mockpkg_c")
+        git("add", "mockpkg-a", "mockpkg-b", "mockpkg-c")
         git("-c", "commit.gpgsign=false", "commit", "-m", "add mockpkg-a, mockpkg-b, mockpkg-c")
 
         # remove mockpkg-c, add mockpkg-d
-        with open("mockpkg_b/package.py", "a", encoding="utf-8") as f:
+        with open("mockpkg-b/package.py", "a", encoding="utf-8") as f:
             f.write("\n# change mockpkg-b")
-        git("add", "mockpkg_b")
+        git("add", "mockpkg-b")
-        mkdirp("mockpkg_d")
+        mkdirp("mockpkg-d")
-        with open("mockpkg_d/package.py", "w", encoding="utf-8") as f:
+        with open("mockpkg-d/package.py", "w", encoding="utf-8") as f:
             f.write(pkg_template.format(name="PkgD"))
-        git("add", "mockpkg_d")
+        git("add", "mockpkg-d")
-        git("rm", "-rf", "mockpkg_c")
+        git("rm", "-rf", "mockpkg-c")
         git(
             "-c",
             "commit.gpgsign=false",
@@ -92,7 +90,7 @@ def mock_pkg_git_repo(git, tmp_path_factory):
 
 @pytest.fixture(scope="module")
 def mock_pkg_names():
-    repo = spack.repo.PATH.get_repo("builtin_mock")
+    repo = spack.repo.PATH.get_repo("builtin.mock")
 
     # Be sure to include virtual packages since packages with stand-alone
     # tests may inherit additional tests from the virtuals they provide,
@@ -119,22 +117,22 @@ def test_builtin_repo():
 
 
 def test_mock_builtin_repo(mock_packages):
-    assert spack.repo.builtin_repo() is spack.repo.PATH.get_repo("builtin_mock")
+    assert spack.repo.builtin_repo() is spack.repo.PATH.get_repo("builtin.mock")
 
 
 def test_pkg_add(git, mock_pkg_git_repo):
     with working_dir(mock_pkg_git_repo):
-        mkdirp("mockpkg_e")
+        mkdirp("mockpkg-e")
-        with open("mockpkg_e/package.py", "w", encoding="utf-8") as f:
+        with open("mockpkg-e/package.py", "w", encoding="utf-8") as f:
             f.write(pkg_template.format(name="PkgE"))
 
     pkg("add", "mockpkg-e")
 
     with working_dir(mock_pkg_git_repo):
         try:
-            assert "A  mockpkg_e/package.py" in git("status", "--short", output=str)
+            assert "A  mockpkg-e/package.py" in git("status", "--short", output=str)
         finally:
-            shutil.rmtree("mockpkg_e")
+            shutil.rmtree("mockpkg-e")
             # Removing a package mid-run disrupts Spack's caching
             if spack.repo.PATH.repos[0]._fast_package_checker:
                 spack.repo.PATH.repos[0]._fast_package_checker.invalidate()

lib/spack/spack/test/cmd/repo.py

@@ -95,47 +95,24 @@ class _7zip(Package):
     pass
 """
 
-# this is written like this to be explicit about line endings and indentation
+OLD_NUMPY = b"""\
-OLD_NUMPY = (
+# some comment
-    b"# some comment\r\n"
-    b"\r\n"
-    b"import spack.pkg.builtin.foo, spack.pkg.builtin.bar\r\n"
-    b"from spack.package import *\r\n"
-    b"from something.unrelated import AutotoolsPackage\r\n"
-    b"\r\n"
-    b"if True:\r\n"
-    b"\tfrom spack.pkg.builtin import (\r\n"
-    b"\t\tfoo,\r\n"
-    b"\t\tbar as baz,\r\n"
-    b"\t)\r\n"
-    b"\r\n"
-    b"class PyNumpy(CMakePackage, AutotoolsPackage):\r\n"
-    b"\tgenerator('ninja')\r\n"
-    b"\r\n"
-    b"\tdef example(self):\r\n"
-    b"\t\t# unchanged comment: spack.pkg.builtin.foo.something\r\n"
-    b"\t\treturn spack.pkg.builtin.foo.example(), foo, baz\r\n"
-)
 
-NEW_NUMPY = (
+from spack.package import *
-    b"# some comment\r\n"
+
-    b"\r\n"
+class PyNumpy(CMakePackage):
-    b"import spack_repo.builtin.packages.foo.package, spack_repo.builtin.packages.bar.package\r\n"
+    generator("ninja")
-    b"from spack_repo.builtin.build_systems.cmake import CMakePackage, generator\r\n"
+"""
-    b"from spack.package import *\r\n"
+
-    b"from something.unrelated import AutotoolsPackage\r\n"
+NEW_NUMPY = b"""\
-    b"\r\n"
+# some comment
-    b"if True:\r\n"
+
-    b"\timport spack_repo.builtin.packages.foo.package as foo\r\n"
+from spack_repo.builtin.build_systems.cmake import CMakePackage, generator
-    b"\timport spack_repo.builtin.packages.bar.package as baz\r\n"
+from spack.package import *
-    b"\r\n"
+
-    b"class PyNumpy(CMakePackage, AutotoolsPackage):\r\n"
+class PyNumpy(CMakePackage):
-    b"\tgenerator('ninja')\r\n"
+    generator("ninja")
-    b"\r\n"
+"""
-    b"\tdef example(self):\r\n"
-    b"\t\t# unchanged comment: spack.pkg.builtin.foo.something\r\n"
-    b"\t\treturn spack_repo.builtin.packages.foo.package.example(), foo, baz\r\n"
-)
 
 
 def test_repo_migrate(tmp_path: pathlib.Path, config):
@@ -165,6 +142,7 @@ def test_repo_migrate(tmp_path: pathlib.Path, config):
     assert pkg_py_numpy_new.read_bytes() == NEW_NUMPY
 
 
+@pytest.mark.not_on_windows("Known failure on windows")
 def test_migrate_diff(git: Executable, tmp_path: pathlib.Path):
     root, _ = spack.repo.create_repo(str(tmp_path), "foo", package_api=(2, 0))
     r = pathlib.Path(root)

lib/spack/spack/test/cmd/resource.py

@@ -48,13 +48,11 @@ def test_resource_list(mock_packages, capfd):
     assert "path:" in out
 
     assert (
-        os.path.join(
+        os.path.join("repos", "builtin.mock", "packages", "patch-a-dependency", "libelf.patch")
-            "spack_repo", "builtin_mock", "packages", "patch_a_dependency", "libelf.patch"
-        )
         in out
     )
-    assert "applies to: builtin_mock.libelf" in out
+    assert "applies to: builtin.mock.libelf" in out
-    assert "patched by: builtin_mock.patch-a-dependency" in out
+    assert "patched by: builtin.mock.patch-a-dependency" in out
 
 
 def test_resource_list_only_hashes(mock_packages, capfd):
@@ -76,12 +74,10 @@ def test_resource_show(mock_packages, capfd):
 
     assert out.startswith(test_hash)
     assert (
-        os.path.join(
+        os.path.join("repos", "builtin.mock", "packages", "patch-a-dependency", "libelf.patch")
-            "spack_repo", "builtin_mock", "packages", "patch_a_dependency", "libelf.patch"
-        )
         in out
     )
-    assert "applies to: builtin_mock.libelf" in out
+    assert "applies to: builtin.mock.libelf" in out
-    assert "patched by: builtin_mock.patch-a-dependency" in out
+    assert "patched by: builtin.mock.patch-a-dependency" in out
 
     assert len(out.strip().split("\n")) == 4

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

@@ -241,14 +241,14 @@ def test_external_root(external_style_root, capfd):
     assert "%s Imports are incorrectly sorted" % str(py_file) in output
 
     # mypy error
-    assert 'lib/spack/spack/dummy.py:47: error: Name "version" is not defined' in output
+    assert 'lib/spack/spack/dummy.py:9: error: Name "Package" is not defined' in output
 
     # black error
     assert "--- lib/spack/spack/dummy.py" in output
     assert "+++ lib/spack/spack/dummy.py" in output
 
     # flake8 error
-    assert "lib/spack/spack/dummy.py:8: [F401] 'os' imported but unused" in output
+    assert "lib/spack/spack/dummy.py:6: [F401] 'os' imported but unused" in output
 
 
 @pytest.mark.skipif(not FLAKE8, reason="flake8 is not installed.")
@@ -311,10 +311,8 @@ def test_run_import_check(tmp_path: pathlib.Path):
 import spack.repo
 import spack.repo_utils
 
-from spack_repo.builtin_mock.build_systems import autotools
-
 # this comment about spack.error should not be removed
-class Example(autotools.AutotoolsPackage):
+class Example(spack.build_systems.autotools.AutotoolsPackage):
     """this is a docstring referencing unused spack.error.SpackError, which is fine"""
     pass
 
@@ -341,6 +339,7 @@ def foo(config: "spack.error.SpackError"):
     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
     assert "issues.py: missing import: spack.util.executable" in output
     assert "issues.py: missing import: spack.error" not in output  # not directly used
     assert exit_code == 1
@@ -360,6 +359,7 @@ def foo(config: "spack.error.SpackError"):
     assert exit_code == 1
     assert "issues.py: redundant import: spack.cmd" in output
     assert "issues.py: missing import: spack" in output
+    assert "issues.py: missing import: spack.build_systems.autotools" in output
     assert "issues.py: missing import: spack.util.executable" in output
 
     # after fix a second fix is idempotent
@@ -380,6 +380,7 @@ def foo(config: "spack.error.SpackError"):
     new_contents = file.read_text()
     assert "import spack.cmd" not in new_contents
     assert "import spack\n" in new_contents
+    assert "import spack.build_systems.autotools\n" in new_contents
     assert "import spack.util.executable\n" in new_contents
 
 

lib/spack/spack/test/cmd/versions.py

@@ -36,7 +36,7 @@ def test_remote_versions_only():
 @pytest.mark.usefixtures("mock_packages")
 def test_new_versions_only(monkeypatch):
     """Test a package for which new versions should be available."""
-    from spack_repo.builtin_mock.packages.brillig.package import Brillig  # type: ignore[import]
+    from spack.pkg.builtin.mock.brillig import Brillig  # type: ignore[import]
 
     def mock_fetch_remote_versions(*args, **kwargs):
         mock_remote_versions = {

lib/spack/spack/test/concretization/compiler_runtimes.py

@@ -29,7 +29,7 @@ def _concretize_with_reuse(*, root_str, reused_str):
 
 @pytest.fixture
 def runtime_repo(mutable_config):
-    repo = os.path.join(spack.paths.test_repos_path, "spack_repo", "compiler_runtime_test")
+    repo = os.path.join(spack.paths.test_repos_path, "compiler_runtime.test")
     with spack.repo.use_repositories(repo) as mock_repo:
         yield mock_repo
 

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

@@ -2,7 +2,6 @@
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 import os
-import pathlib
 import platform
 import sys
 
@@ -80,7 +79,7 @@ def binary_compatibility(monkeypatch, request):
         return
 
     if "mock_packages" not in request.fixturenames:
-        # Only builtin_mock has a mock glibc package
+        # Only builtin.mock has a mock glibc package
         return
 
     if "database" in request.fixturenames or "mutable_database" in request.fixturenames:
@@ -171,12 +170,18 @@ def reverser(pkg_name):
 
 @pytest.fixture()
 def repo_with_changing_recipe(tmp_path_factory, mutable_mock_repo):
-    repos_dir: pathlib.Path = tmp_path_factory.mktemp("repos_dir")
+    repo_namespace = "changing"
-    root, _ = spack.repo.create_repo(str(repos_dir), "changing")
+    repo_dir = tmp_path_factory.mktemp(repo_namespace)
-    packages_dir = pathlib.Path(root, "packages")
 
+    (repo_dir / "repo.yaml").write_text(
+        """
+repo:
+  namespace: changing
+"""
+    )
+
+    packages_dir = repo_dir / "packages"
     root_pkg_str = """
-from spack_repo.builtin_mock.build_systems.generic import Package
 from spack.package import *
 
 class Root(Package):
@@ -194,7 +199,6 @@ class Root(Package):
     package_py.write_text(root_pkg_str)
 
     middle_pkg_str = """
-from spack_repo.builtin_mock.build_systems.generic import Package
 from spack.package import *
 
 class Middle(Package):
@@ -209,7 +213,6 @@ class Middle(Package):
     package_py.write_text(middle_pkg_str)
 
     changing_template = """
-from spack_repo.builtin_mock.build_systems.generic import Package
 from spack.package import *
 
 class Changing(Package):
@@ -232,7 +235,7 @@ class Changing(Package):
 {% endif %}
 """
 
-    with spack.repo.use_repositories(root, override=False) as repos:
+    with spack.repo.use_repositories(str(repo_dir), override=False) as repository:
 
         class _ChangingPackage:
             default_context = [
@@ -241,22 +244,27 @@ class _ChangingPackage:
                 ("add_variant", False),
             ]
 
-            def __init__(self):
+            def __init__(self, repo_directory):
+                self.repo_dir = repo_directory
                 cache_dir = tmp_path_factory.mktemp("cache")
                 self.repo_cache = spack.util.file_cache.FileCache(str(cache_dir))
-                self.repo = spack.repo.Repo(root, cache=self.repo_cache)
+                self.repo = spack.repo.Repo(str(repo_directory), cache=self.repo_cache)
 
             def change(self, changes=None):
                 changes = changes or {}
                 context = dict(self.default_context)
                 context.update(changes)
                 # Remove the repo object and delete Python modules
-                repos.remove(self.repo)
+                repository.remove(self.repo)
                 # TODO: this mocks a change in the recipe that should happen in a
                 # TODO: different process space. Leaving this comment as a hint
                 # TODO: in case tests using this fixture start failing.
-                for module in [x for x in sys.modules if x.startswith("spack_repo.changing")]:
+                if sys.modules.get("spack.pkg.changing.changing"):
-                    del sys.modules[module]
+                    del sys.modules["spack.pkg.changing.changing"]
+                if sys.modules.get("spack.pkg.changing.root"):
+                    del sys.modules["spack.pkg.changing.root"]
+                if sys.modules.get("spack.pkg.changing"):
+                    del sys.modules["spack.pkg.changing"]
 
                 # Change the recipe
                 t = _vendoring.jinja2.Template(changing_template)
@@ -266,10 +274,10 @@ def change(self, changes=None):
                 package_py.write_text(changing_pkg_str)
 
                 # Re-add the repository
-                self.repo = spack.repo.Repo(root, cache=self.repo_cache)
+                self.repo = spack.repo.Repo(str(self.repo_dir), cache=self.repo_cache)
-                repos.put_first(self.repo)
+                repository.put_first(self.repo)
 
-        _changing_pkg = _ChangingPackage()
+        _changing_pkg = _ChangingPackage(repo_dir)
         _changing_pkg.change(
             {"delete_version": False, "delete_variant": False, "add_variant": False}
         )
@@ -366,11 +374,11 @@ def test_provides_handles_multiple_providers_of_same_version(self):
         # Note that providers are repo-specific, so we don't misinterpret
         # providers, but vdeps are not namespace-specific, so we can
         # associate vdeps across repos.
-        assert Spec("builtin_mock.multi-provider-mpi@1.10.3") in providers
+        assert Spec("builtin.mock.multi-provider-mpi@1.10.3") in providers
-        assert Spec("builtin_mock.multi-provider-mpi@1.10.2") in providers
+        assert Spec("builtin.mock.multi-provider-mpi@1.10.2") in providers
-        assert Spec("builtin_mock.multi-provider-mpi@1.10.1") in providers
+        assert Spec("builtin.mock.multi-provider-mpi@1.10.1") in providers
-        assert Spec("builtin_mock.multi-provider-mpi@1.10.0") in providers
+        assert Spec("builtin.mock.multi-provider-mpi@1.10.0") in providers
-        assert Spec("builtin_mock.multi-provider-mpi@1.8.8") in providers
+        assert Spec("builtin.mock.multi-provider-mpi@1.8.8") in providers
 
     def test_different_compilers_get_different_flags(
         self, mutable_config, clang12_with_flags, gcc11_with_flags
@@ -1708,12 +1716,12 @@ def test_reuse_with_unknown_namespace_dont_raise(
     ):
         with spack.repo.use_repositories(mock_custom_repository, override=False):
             s = spack.concretize.concretize_one("pkg-c")
-            assert s.namespace != "builtin_mock"
+            assert s.namespace != "builtin.mock"
             PackageInstaller([s.package], fake=True, explicit=True).install()
 
         with spack.config.override("concretizer:reuse", True):
             s = spack.concretize.concretize_one("pkg-c")
-        assert s.namespace == "builtin_mock"
+        assert s.namespace == "builtin.mock"
 
     @pytest.mark.regression("45538")
     def test_reuse_from_other_namespace_no_raise(self, tmpdir, temporary_store, monkeypatch):
@@ -1744,7 +1752,7 @@ def test_reuse_with_unknown_package_dont_raise(self, tmpdir, temporary_store, mo
             repos.repos[0]._pkg_checker.invalidate()
             with spack.config.override("concretizer:reuse", True):
                 s = spack.concretize.concretize_one("pkg-c")
-            assert s.namespace == "builtin_mock"
+            assert s.namespace == "builtin.mock"
 
     @pytest.mark.parametrize(
         "specs,checks",
@@ -2321,10 +2329,10 @@ def test_reuse_python_from_cli_and_extension_from_db(self, mutable_database):
         "spec_str,expected_namespaces",
         [
             # Single node with fully qualified namespace
-            ("builtin_mock.gmake", {"gmake": "builtin_mock"}),
+            ("builtin.mock.gmake", {"gmake": "builtin.mock"}),
             # Dependency with fully qualified namespace
-            ("hdf5 ^builtin_mock.gmake", {"gmake": "builtin_mock", "hdf5": "duplicates_test"}),
+            ("hdf5 ^builtin.mock.gmake", {"gmake": "builtin.mock", "hdf5": "duplicates.test"}),
-            ("hdf5 ^gmake", {"gmake": "duplicates_test", "hdf5": "duplicates_test"}),
+            ("hdf5 ^gmake", {"gmake": "duplicates.test", "hdf5": "duplicates.test"}),
         ],
     )
     def test_select_lower_priority_package_from_repository_stack(
@@ -2333,10 +2341,8 @@ def test_select_lower_priority_package_from_repository_stack(
         """Tests that a user can explicitly select a lower priority, fully qualified dependency
         from cli.
         """
-        # 'builtin_mock" and "duplicates_test" share a 'gmake' package
+        # 'builtin.mock" and "duplicates.test" share a 'gmake' package
-        additional_repo = os.path.join(
+        additional_repo = os.path.join(spack.paths.test_repos_path, "duplicates.test")
-            spack.paths.test_repos_path, "spack_repo", "duplicates_test"
-        )
         with spack.repo.use_repositories(additional_repo, override=False):
             s = spack.concretize.concretize_one(spec_str)
 
@@ -2580,7 +2586,7 @@ def test_correct_external_is_selected_from_packages_yaml(self, mutable_config):
 
 @pytest.fixture()
 def duplicates_test_repository():
-    repository_path = os.path.join(spack.paths.test_repos_path, "spack_repo", "duplicates_test")
+    repository_path = os.path.join(spack.paths.test_repos_path, "duplicates.test")
     with spack.repo.use_repositories(repository_path) as mock_repo:
         yield mock_repo
 
@@ -2815,7 +2821,7 @@ def test_adding_specs(self, input_specs, default_mock_concretization):
 
 @pytest.fixture()
 def edges_test_repository():
-    repository_path = os.path.join(spack.paths.test_repos_path, "spack_repo", "edges_test")
+    repository_path = os.path.join(spack.paths.test_repos_path, "edges.test")
     with spack.repo.use_repositories(repository_path) as mock_repo:
         yield mock_repo
 

lib/spack/spack/test/concretization/flag_mixing.py

@@ -46,7 +46,7 @@
 
 @pytest.fixture
 def test_repo(mutable_config, monkeypatch, mock_stage):
-    repo_dir = pathlib.Path(spack.paths.test_repos_path) / "spack_repo" / "flags_test"
+    repo_dir = pathlib.Path(spack.paths.test_repos_path) / "flags.test"
     with spack.repo.use_repositories(str(repo_dir)) as mock_repo_path:
         yield mock_repo_path
 

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

@@ -28,7 +28,7 @@ def update_packages_config(conf_str):
 
 @pytest.fixture
 def test_repo(mutable_config, monkeypatch, mock_stage):
-    repo_dir = pathlib.Path(spack.paths.test_repos_path) / "spack_repo" / "requirements_test"
+    repo_dir = pathlib.Path(spack.paths.test_repos_path) / "requirements.test"
     with spack.repo.use_repositories(str(repo_dir)) as mock_repo_path:
         yield mock_repo_path
 
@@ -766,21 +766,21 @@ def test_skip_requirement_when_default_requirement_condition_cannot_be_met(
 
 def test_requires_directive(mock_packages, config):
     # This package requires either clang or gcc
-    s = spack.concretize.concretize_one("requires-clang-or-gcc")
+    s = spack.concretize.concretize_one("requires_clang_or_gcc")
     assert s.satisfies("%gcc")
-    s = spack.concretize.concretize_one("requires-clang-or-gcc %gcc")
+    s = spack.concretize.concretize_one("requires_clang_or_gcc %gcc")
     assert s.satisfies("%gcc")
-    s = spack.concretize.concretize_one("requires-clang-or-gcc %clang")
+    s = spack.concretize.concretize_one("requires_clang_or_gcc %clang")
     # Test both the real package (llvm) and its alias (clang)
     assert s.satisfies("%llvm") and s.satisfies("%clang")
 
     # This package can only be compiled with clang
-    s = spack.concretize.concretize_one("requires-clang")
+    s = spack.concretize.concretize_one("requires_clang")
     assert s.satisfies("%llvm")
-    s = spack.concretize.concretize_one("requires-clang %clang")
+    s = spack.concretize.concretize_one("requires_clang %clang")
     assert s.satisfies("%llvm")
     with pytest.raises(spack.error.SpackError, match="can only be compiled with Clang"):
-        spack.concretize.concretize_one("requires-clang %gcc")
+        spack.concretize.concretize_one("requires_clang %gcc")
 
 
 @pytest.mark.parametrize(

lib/spack/spack/test/conftest.py

@@ -654,7 +654,7 @@ def mock_pkg_install(monkeypatch):
 
 @pytest.fixture(scope="function")
 def mock_packages(mock_repo_path, mock_pkg_install, request):
-    """Use the 'builtin_mock' repository instead of 'builtin'"""
+    """Use the 'builtin.mock' repository instead of 'builtin'"""
     ensure_configuration_fixture_run_before(request)
     with spack.repo.use_repositories(mock_repo_path) as mock_repo:
         yield mock_repo
@@ -1434,7 +1434,7 @@ def mock_git_repository(git, tmpdir_factory):
     of these refers to a repository with a single commit.
 
     c0, c1, and c2 include information to define explicit versions in the
-    associated builtin_mock package 'git-test'. c3 is a commit in the
+    associated builtin.mock package 'git-test'. c3 is a commit in the
     repository but does not have an associated explicit package version.
     """
     suburls = []
@@ -2100,6 +2100,35 @@ def mock_modules_root(tmp_path, monkeypatch):
     monkeypatch.setattr(spack.modules.common, "root_path", fn)
 
 
+_repo_name_id = 0
+
+
+def create_test_repo(tmpdir, pkg_name_content_tuples):
+    global _repo_name_id
+
+    repo_path = str(tmpdir)
+    repo_yaml = tmpdir.join("repo.yaml")
+    with open(str(repo_yaml), "w", encoding="utf-8") as f:
+        f.write(
+            f"""\
+repo:
+  namespace: testrepo{str(_repo_name_id)}
+"""
+        )
+
+    _repo_name_id += 1
+
+    packages_dir = tmpdir.join("packages")
+    for pkg_name, pkg_str in pkg_name_content_tuples:
+        pkg_dir = packages_dir.ensure(pkg_name, dir=True)
+        pkg_file = pkg_dir.join("package.py")
+        with open(str(pkg_file), "w", encoding="utf-8") as f:
+            f.write(pkg_str)
+
+    repo_cache = spack.util.file_cache.FileCache(str(tmpdir.join("cache")))
+    return spack.repo.Repo(repo_path, cache=repo_cache)
+
+
 @pytest.fixture()
 def compiler_factory():
     """Factory for a compiler dict, taking a spec and an OS as arguments."""

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

@@ -2,11 +2,10 @@
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
-from spack.package_base import PackageBase
 from spack.package import *
 
 
-class DiffTest(PackageBase):
+class DiffTest(AutotoolsPackage):
     """zlib replacement with optimizations for next generation systems."""
 
     homepage = "https://github.com/zlib-ng/zlib-ng"

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

@@ -2,11 +2,10 @@
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
-from spack.package_base import PackageBase
 from spack.package import *
 
 
-class DiffTest(PackageBase):
+class DiffTest(AutotoolsPackage):
     """zlib replacement with optimizations for next generation systems."""
 
     homepage = "https://github.com/zlib-ng/zlib-ng"

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

@@ -2,11 +2,10 @@
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
-from spack.package_base import PackageBase
 from spack.package import *
 
 
-class DiffTest(PackageBase):
+class DiffTest(AutotoolsPackage):
     """zlib replacement with optimizations for next generation systems."""
 
     homepage = "https://github.com/zlib-ng/zlib-ng"

lib/spack/spack/test/data/legacy_env/v1.lock

@@ -26,7 +26,7 @@
      "name": "clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],
@@ -70,7 +70,7 @@
      "name": "clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],
@@ -114,7 +114,7 @@
      "name": "clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],
@@ -137,7 +137,7 @@
      "name": "clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],
@@ -160,7 +160,7 @@
      "name": "clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],
@@ -183,7 +183,7 @@
      "name": "clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],
@@ -215,7 +215,7 @@
      "name": "clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],
@@ -253,7 +253,7 @@
      "name": "clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],
@@ -276,7 +276,7 @@
      "name": "clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],
@@ -314,7 +314,7 @@
      "name": "clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],
@@ -337,7 +337,7 @@
      "name": "clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],
@@ -368,7 +368,7 @@
      "name": "clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],

lib/spack/spack/test/data/legacy_env/v2.lock

@@ -57,7 +57,7 @@
      "name": "apple-clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],
@@ -133,7 +133,7 @@
      "name": "apple-clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],
@@ -209,7 +209,7 @@
      "name": "apple-clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],
@@ -264,7 +264,7 @@
      "name": "apple-clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],
@@ -319,7 +319,7 @@
      "name": "apple-clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],
@@ -374,7 +374,7 @@
      "name": "apple-clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],
@@ -438,7 +438,7 @@
      "name": "apple-clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],
@@ -508,7 +508,7 @@
      "name": "apple-clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],
@@ -563,7 +563,7 @@
      "name": "apple-clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],
@@ -633,7 +633,7 @@
      "name": "apple-clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],
@@ -688,7 +688,7 @@
      "name": "apple-clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],
@@ -751,7 +751,7 @@
      "name": "apple-clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],
@@ -806,7 +806,7 @@
      "name": "apple-clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],
@@ -882,7 +882,7 @@
      "name": "apple-clang",
      "version": "13.0.0"
     },
-    "namespace": "builtin_mock",
+    "namespace": "builtin.mock",
     "parameters": {
      "cflags": [],
      "cppflags": [],

lib/spack/spack/test/data/legacy_env/v3.lock

@@ -58,7 +58,7 @@
         "name": "apple-clang",
         "version": "13.0.0"
       },
-      "namespace": "builtin_mock",
+      "namespace": "builtin.mock",
       "parameters": {
         "cflags": [],
         "cppflags": [],
@@ -136,7 +136,7 @@
         "name": "apple-clang",
         "version": "13.0.0"
       },
-      "namespace": "builtin_mock",
+      "namespace": "builtin.mock",
       "parameters": {
         "cflags": [],
         "cppflags": [],
@@ -214,7 +214,7 @@
         "name": "apple-clang",
         "version": "13.0.0"
       },
-      "namespace": "builtin_mock",
+      "namespace": "builtin.mock",
       "parameters": {
         "cflags": [],
         "cppflags": [],
@@ -268,7 +268,7 @@
         "name": "apple-clang",
         "version": "13.0.0"
       },
-      "namespace": "builtin_mock",
+      "namespace": "builtin.mock",
       "parameters": {
         "cflags": [],
         "cppflags": [],
@@ -322,7 +322,7 @@
         "name": "apple-clang",
         "version": "13.0.0"
       },
-      "namespace": "builtin_mock",
+      "namespace": "builtin.mock",
       "parameters": {
         "cflags": [],
         "cppflags": [],
@@ -376,7 +376,7 @@
         "name": "apple-clang",
         "version": "13.0.0"
       },
-      "namespace": "builtin_mock",
+      "namespace": "builtin.mock",
       "parameters": {
         "cflags": [],
         "cppflags": [],
@@ -440,7 +440,7 @@
         "name": "apple-clang",
         "version": "13.0.0"
       },
-      "namespace": "builtin_mock",
+      "namespace": "builtin.mock",
       "parameters": {
         "cflags": [],
         "cppflags": [],
@@ -511,7 +511,7 @@
         "name": "apple-clang",
         "version": "13.0.0"
       },
-      "namespace": "builtin_mock",
+      "namespace": "builtin.mock",
       "parameters": {
         "cflags": [],
         "cppflags": [],
@@ -565,7 +565,7 @@
         "name": "apple-clang",
         "version": "13.0.0"
       },
-      "namespace": "builtin_mock",
+      "namespace": "builtin.mock",
       "parameters": {
         "cflags": [],
         "cppflags": [],
@@ -636,7 +636,7 @@
         "name": "apple-clang",
         "version": "13.0.0"
       },
-      "namespace": "builtin_mock",
+      "namespace": "builtin.mock",
       "parameters": {
         "cflags": [],
         "cppflags": [],
@@ -690,7 +690,7 @@
         "name": "apple-clang",
         "version": "13.0.0"
       },
-      "namespace": "builtin_mock",
+      "namespace": "builtin.mock",
       "parameters": {
         "cflags": [],
         "cppflags": [],
@@ -753,7 +753,7 @@
         "name": "apple-clang",
         "version": "13.0.0"
       },
-      "namespace": "builtin_mock",
+      "namespace": "builtin.mock",
       "parameters": {
         "cflags": [],
         "cppflags": [],
@@ -807,7 +807,7 @@
         "name": "apple-clang",
         "version": "13.0.0"
       },
-      "namespace": "builtin_mock",
+      "namespace": "builtin.mock",
       "parameters": {
         "cflags": [],
         "cppflags": [],
@@ -885,7 +885,7 @@
         "name": "apple-clang",
         "version": "13.0.0"
       },
-      "namespace": "builtin_mock",
+      "namespace": "builtin.mock",
       "parameters": {
         "cflags": [],
         "cppflags": [],

lib/spack/spack/test/data/mirrors/legacy_yaml/build_cache/test-debian6-core2-gcc-4.5.0-zlib-1.2.11-t5mczux3tfqpxwmg7egp7axy2jvyulqk.spec.yaml

@@ -18,7 +18,7 @@ spec:
     compiler:
       name: gcc
       version: 4.5.0
-    namespace: builtin_mock
+    namespace: builtin.mock
     parameters:
       optimize: true
       pic: true

lib/spack/spack/test/data/mirrors/v2_layout/signed/build_cache/_pgp/A98A04B882E19D85FD36EE069565D80B055C92FF.pub

@@ -0,0 +1,29 @@
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+
+mQINBGf23+EBEAC6UqaiE43cF9jFuVjA8xJ5j31BMhufpnk0cwoE5Iks/GgR/Hki
+LMYbzy36V7TZGObel+5DtFKipX+WCwWj2XsjbeqHeuCkxZhzHFwfi1UJl9FO2T28
+iNn6OsBiGeU6ULNmehSia2hx0uhj1re/FUwJExOAvuYv8nc7M+nozqi7Pp/WjP8v
+UTiqP2onzZJbidlSBvmZ2nheWk7G78e617gcV/ye+UyXZvciiF2UQBg9YV6D8JuD
+YhBbNAVOzJOiyOdTBmZmOkmYsGx58sEbFVqGeOMB0xoxZrqKjMm9NhvjqjJF/sWs
+hN/PD5ylW1UR05/fGxlG2GLKKfBInbdqnC101OFWXP5HenYHmKaBJoCKCAUfsoJ0
+r/t/GVh3z3w/99p0TRDONnTecKm5S9z3/5QjjE5RsWcd4ll7mRikUiVpe1WhKRwT
+4T76pQLq3XwNJqiOmuMQuSHoBE9OMufvRFiTYC0QHyLoCV2H5PCWtS2xSsIDN4PB
+0RNd0hnHKanVV7d2TkIrGOagoAo0wXqyW/Op6KUG1NdaFYYziDFEHeZxfGoPKytO
+iS5PEwZG2FqambAZhJU5OXwzgnCRIoE5DCZad4YS6U5YD/2zg+RrQ/5GUxl5Cc+W
+Zwesn9FV5jywx/oFePYbTSNQVPQ6jbUDvhmHvZ8c/OfGOVXQr0VpvfIwdwARAQAB
+tD1UZXN0IFNpZ25pbmcgS2V5IChHUEcgY3JlYXRlZCBmb3IgU3BhY2spIDxub2Jv
+ZHlAbm93aGVyZS5jb20+iQJRBBMBCAA7FiEEqYoEuILhnYX9Nu4GlWXYCwVckv8F
+Amf23+ECGwMFCwkIBwICIgIGFQoJCAsCBBYCAwECHgcCF4AACgkQlWXYCwVckv9i
+pg//eGjBR9ph9hUYRsekzKWM1xB5zFOFfNoqlpCut/W7LAfy0XXkFy/y6EvPdcgn
+lLWRWPsOFfsKGwZd7LgSovhEMQ2MRsAUUB/KNZx7s6vO/P773PmJspF3odQ/lcrM
+1fum2lShChWqimdBdNLrXxG+8duO9uWaMBIp28diBCyB25M/MqpHtKYu00FB/QJ6
+ZwQH4OsgXVQHRjyrtIGx/2FQoWt0ah3eJMJCEw46GgkgiojtoTfXQQc4fIJP324b
+O1sxz5lx3xVBG/EZYzyV3xnSoG9aZNJ1cJq8EKO7ZoNKc/8jwkVu5gewGaXYI0LK
+/WkOeiXcSHPMSdu7TpnitvLYFCjc9YAEKQnjooXdt7+BElwC3+5hZJNXEnoGPMzn
+3UL60sQE/ViCsGcW+l9rtzXPNTmLMjEg4rGRqOhX+UmwyhvGD2QYbZtXlayu5xn+
+5m/PfmdqgL1xsdvNsLo/BOo+6kizMdBk48Xfp0YM8AC4BzUEENypGzC4T0WYF0k1
+Jfc6/eSwiytIcIkJ42GlaVfEFE8UxfYc1/2zqTBN9EdzWJqy0Bh+mVOgOaeb0Dzi
+xWpUpChi1fBB3PXWJ5iAS/w0HSVn4G5/JAIEFAs7r6ju2YtKBfuk+u/K5Q28mo7W
+6LrZQywN44nBMTvSQUhhXpSNYG+juyotXJUJ3F2u9Cf/jVU=
+=TkbL
+-----END PGP PUBLIC KEY BLOCK-----

lib/spack/spack/test/data/mirrors/v2_layout/signed/build_cache/_pgp/CBAB2C1032C6FF5078049EC0FA61D50C12CAD37E.pub

@@ -1,29 +0,0 @@
------BEGIN PGP PUBLIC KEY BLOCK-----
-
-mQINBGgnhhYBEAC5LOSkJlxL4rRDBLDatswpzAw7NQnONW37hwOauEf6rlw/wk6J
-2D1l/jjmGwyo1iHOEu1/26fMuXMmG0vAxOQJFrkoKAgxDUD9nL0GqTJyg0+yTCN6
-xsWsrIZi+8oNDXYzLiejICZorc+ri11kcZdA+WE2hWPRStmJH75afpSd7XfNijqb
-MPfDZBcr+pLeARSH11BTfb8Dtm9qN//+X+pNIUqeHL9hLu/W9hb3GCfXqnsCQJA1
-WMFTrbCcPYm0R7EevMnscFvS8xbhocBPDwZ12f4W5CugrL29X4Vx9SaUlIyy/+SC
-2Gwi8Yq78Y4dTN7N5aA8L169/uqy4Tx7/966wMkUYXk7UxmH9E0ol5EZYnY9SCj6
-xLtMNKA+NLwESj0azaWEzxfztyNdTYfG8Eaa/QGFs1YVGhYdmcEp8KDbQg5FBeCA
-I6MUcH0XWOTJaZI/oEtukMYHzBt9jyyq6Gp45TiQvOou0wE+w/zJcd9Td23R81KW
-GfMh5r80NET/bx88vee4NNHkWCphhqs53rIrhWV3y3WKaWp7DfP3WMiTBJ+Yc+PI
-0vMIHKYNy+OqwTjmwgKdN1w1xZhLG7hx0sAdcZGP7q0A6381HtucgS/fucDogMnW
-H3anE8UGx4HBRjyXsuOaOAgNw2K4IwancUSf67WSzji3AiP46sUun5ERNQARAQAB
-tBlTcGFjayA8c3BhY2tAc3BhY2suc3BhY2s+iQJXBBMBCgBBFiEEy6ssEDLG/1B4
-BJ7A+mHVDBLK034FAmgnhhYCGwMFCQWjmoAFCwkIBwICIgIGFQoJCAsCBBYCAwEC
-HgcCF4AACgkQ+mHVDBLK034zWhAAtjm802qaTSCvB9WvY1RM65/B1GUK3ZEv3fw/
-Dvt3xd3mh+rzWBTJ8t7+/cPaOq7qOGnfUateHgou+0T6lgCLkrwr4lFa6yZSUATb
-xcnopcA0Dal218UcIRb20PjPtoKu3Tt9JFceXJGCTYoGz5HbkOemwkR8B+4qMRPW
-sn1IhV32eig2HUzrUXVOv6WomMtk2qUpND0WnTlZo3EoInJeTzdlXkOR3lRLADM9
-yPM6Rp8AV/ykM9DztL4SinzyZjqEM7o1H7EFITZSlkjcBPvqDlvowZGN8TVbG9TQ
-8Nfz8BYF3SVaPduwXwhbE9D8jqtNt652IZ1+1KbMii1l4deu0UYx8BSfJjNANTTU
-jFDiyNaGnn5OsZXNllsyAHWky6ApyBD9qFxxNr0kiWbVrrN6s2u4ghm5Hgtdx40v
-hA9+kvB2mtV/HklUkwDTJ6Ytgp5veh8GKvBD9eAWIitl6w153Rba5LkZbk2ijK6k
-oyN9Ge/YloSMwXpIEnE7/SRE1o5vye294BZjyqnr+U+wzbEYbC7eXJ0peDCbpbZc
-0kxMDDbrhmHeEaHeWF30hm6WBaUT4SUcPj5BiV3mt3BhtRgAwA3SvuSenk2yRzR8
-tBES4b/RBmOczfs4w4m5rAmfVNkNwykry4M2jPCJhVA2qG8q1gLxf+AvaPcAvQ8D
-kmDeNLI=
-=CYuA
------END PGP PUBLIC KEY BLOCK-----

lib/spack/spack/test/data/mirrors/v2_layout/signed/build_cache/_pgp/E89D4971F0097B1E7A3EB57371B484802E78D7CD.pub

@@ -0,0 +1,29 @@
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+
+mQINBGfHlp4BEAC5wkZSHqF9z6GcymuHpk1m9aNXCJdt4ZWvE8ck8GcuVu1nbzlZ
+h959jqtwk7nFMki5YaNMz6jcQf0eeS75viL4CoPAqFiVyhyCCh5am75h9F7vTBq6
+190017lhu9IgkAkiklnjfDbyXH+BwqJ78nXp6e6R4ShFMHNGGvYLem1wmPKzqPlZ
+zN0yjc0+d5pw4hu+IEFrM63yqGp2BVX1X132IKUEcROCQt1QOma5oORhYEtSCieX
+PuhuHJOA7q6nJuFccPCs5OcDS4IbQgGAbWL4L1+LAGVLVGpK4IVtqEZ831Srclh8
+0ruyFFeV/hqOONThwwile0Jwh5Jz/2sYxT5c+nlumXWK+CXTm4OCfGt1UuGy6c6u
+Rz84PHfanbKnATp6RUjz4DMREkmA6qBnUFqGLLGaBKBsm42b7kbo7m5aeItuOwLE
+U7AcnBEqqHLfI7O1zrHKjQCxhEWP/iok0kgEdiJ4tlPhfDjQRG6thlmZnVdt/08V
++bvVkbYZyWPzjbG3QHyFew1+uzPHb2UopgpByVKYEWhCgNfcFtE56lEI9c40Ba5o
+LaZl0VlgfSLP4c+LoFB6gZp1gcVQuPo1JKd1v5WP60f1iHhazL5LEeMYcW6kvujK
+58Q683gSH5DsVAnxaj1uU4nvtKDh8IF1CNKKXk8RVsltdpv9bGhV8b4qVQARAQAB
+tD1UZXN0IFNpZ25pbmcgS2V5IChHUEcgY3JlYXRlZCBmb3IgU3BhY2spIDxub2Jv
+ZHlAbm93aGVyZS5jb20+iQJOBBMBCgA4FiEE6J1JcfAJex56PrVzcbSEgC54180F
+AmfHlp4CGwMFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQcbSEgC54180aDg//
+f7GqIW5LzYqIqkey+IjdkSSfeD47tlWc2ukKYStHu0gTlHhrUp4rHNJ/s8XQ1o6o
+jwzWfNMYh68wt9sjuM2BEkkh3RUFEjVqqW+k562gS5ibfKTDtJb2Yj0n/CQKWvoi
+vUUzO88xW0AnZFieP+vD5iI5Zw4H2dY8cH4X1XlWAJufFdH4WBaZjujNwNOcCsnd
+w2nE050wKTR2wroWq0HKn1Ni3QNtKWPpLoHGAlhW6ACLa+EFqxHU6D3KhW6IV4Jc
+sdt36nHNiRiy6nT99asqtN6Z0Yw+EnQSuIDosIbmSgZoieINh0gU6AKwgydxLUxL
+Cu1w2fZHGuFR/ym0c/tTpM893DxHMc/EZ/SpU8fXkC9lYnQO3or/Y0mLHd0kSEv7
+XoonvcOu1tOQzmvrvUQUtTn4+6OKpGViyZG5C8Lbk8/yKWFv5b+Gpss/EiGTHSsk
+bPTHf5jMsWElv0GgFq2TpybtIcY52yJoZ1fBMEA9Nk76Y/MNFlN0d7HyS6tWGr6E
+8FWJB7RYG5XHMEDIKSheq+Q5cORwz92JPFI+sovZukp+20G7f7/gwos441KamJPc
+y1+M4uO21aKX2fA07bcgFtm25gNLoHyvjQLcmyDis6xogvciCV3iQ/mtunewgYp/
+lUX1dv0R5o8TteaAIkbJicbdLtur/iuAWN404E/QShc=
+=8P00
+-----END PGP PUBLIC KEY BLOCK-----

lib/spack/spack/test/data/mirrors/v2_layout/signed/build_cache/_pgp/index.json

@@ -1 +1 @@
-{"keys":{"CBAB2C1032C6FF5078049EC0FA61D50C12CAD37E":{}}}
+{"keys":{"A98A04B882E19D85FD36EE069565D80B055C92FF":{},"E89D4971F0097B1E7A3EB57371B484802E78D7CD":{}}}

lib/spack/spack/test/data/mirrors/v2_layout/signed/build_cache/index.json.hash

@@ -1 +1 @@
-81a5add9d75b27fc4d16a4f72685b54903973366531b98c65e8cf5376758a817
+7f94d6038bb4e5e7fff817151da5b22d7dd6d1e2d9ad51bd55504676786c17bd

lib/spack/spack/test/data/mirrors/v2_layout/signed/build_cache/test-debian6-core2-gcc-10.2.1-libdwarf-20130729-sk2gqqz4n5njmvktycnd25wq25jxiqkr.spec.json.sig

@@ -33,7 +33,7 @@ Hash: SHA512
 "name":"gcc",
 "version":"10.2.1"
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "cflags":[],
@@ -85,7 +85,7 @@ Hash: SHA512
 "name":"gcc",
 "version":"10.2.1"
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "cflags":[],
@@ -108,17 +108,17 @@ Hash: SHA512
 }
 -----BEGIN PGP SIGNATURE-----
 
-iQIzBAEBCgAdFiEEy6ssEDLG/1B4BJ7A+mHVDBLK034FAmgnhqIACgkQ+mHVDBLK
+iQIzBAEBCgAdFiEE6J1JcfAJex56PrVzcbSEgC54180FAmfHlp8ACgkQcbSEgC54
-0373kg/+Iy7pfWoAa465XtWUyf87KcjmJ1hE4OmfMc9sA7kdKNYPfmttxfp8jCU5
+180hlxAAisLofFhr/PQvLcQ79T3t3V0tqGgz9x6QnPKfbPCgvb66tTNlny+ML0fY
-gRc8RnQ5K+h4GWGl9nd6bFOT3oZSBH9WnH33gcnStHubwvHzhY05ZmlKjXKKTJmG
+y1H9xXQO53QOxfN9cdXcf2EVbRQ2eT6ltmwekI3ZZuCaTguflNu/i11UV6UnDy3x
-rcQ8+vVv/e8KfMatydPuXQmAzbJ0pr2bGnicT8fs/W35hgcyygDZvDqJo3m+q4H7
+dXOYQhky5QjtPbhJ0NxG5XDKoRFoUPR/rgXsiNG5O0sk3M5H9ldpsj8af5W/6LCL
-uu4C3LnaixAf7kCZefdxReYvFBNz9Qovws3+LqVFPxWgqo4zYt1PcI24UhCpL2YJ
+gCTNM8fF0TVbd4MF9TiIECFBng2CrxhHwpl2gPHHxab1zxLRCF6t1lZvL6To0hmC
-6XJySW7e0rR64bwCZR/owy504aUC64wr8kM19MMJAoB0R4zciJ0YyY8xLfRMI3Tr
+e/Tqre+42PhRSCtXuwhK22r0rvreVUaiglYn8udjOJHwNVKdzLnTZ1OBAFeIq00U
-JTPetuTN7ncKJ2kZJ5L+KbeYnr4+CA5ZYmjyAM5NSJ3fTXuEu477H+1XovcJtP1s
+9uuroyaF841pq9+8PitwUORurv0lsnHUbfbi/+ou0HzMiaXzz+MPdOXt8nUuyScs
-IZS10UWX452QEBXE5nWAludmiw4BenyR2Lccg2QfER8jbiZf3U3do43aGoI5U8rg
+oKOi8ExvpWJ7vn6klkvQtMK/Gakzd4YOxO/nk9K8BJgVN3qrODwHYSORk8RrdITS
-qf1kQ/dMcIX6oSrbxMKymdsuf6e8UCSys3KNwb44UdSBiihgYFtiMfGtQ6Ixsvky
+tkjiEJiIoklddiwCf3NUzlxiIYWbiqKqNbY+Pxh4B+OpVDnvRmpkJHgoSuVoCS8b
-TB+EwweUY6LtBuep1fh+M1tHgo9qCxUH79duor0JRDgQ/VLeO6e1RCptc7EHnQZQ
+coaOTIgqDpnIClHIj7ogxO+ureRjIIkGNNh6wVhlHDlgm1GzxNUOklMrzDkYMD01
-mZK7YjVtHYWzyOZ4KsWuLYBSAMvKDhrTxI8cxp816NNGUfj1jmBQR/5vn6d7nMwX
+eTYxrbicw7ZVwqhFtR8olODKT9QAqXUJOkGHS9IA6FJctatkUkIOG1DSI52AZV1r
-PmWrQV9O2e899Mv30VVR9XDf6tJoT+BPvS4Kc5hw/LxjaBbAxXo=
+PYzgdKtTxS60EkN8Igl6VMTkaC05anLygCTyOvGaV7sqVKmzHY8=
-=Zprh
+=8OR5
 -----END PGP SIGNATURE-----

lib/spack/spack/test/data/mirrors/v2_layout/signed/build_cache/test-debian6-core2-gcc-10.2.1-libelf-0.8.13-rqh2vuf6fqwkmipzgi2wjx352mq7y7ez.spec.json.sig

@@ -33,7 +33,7 @@ Hash: SHA512
 "name":"gcc",
 "version":"10.2.1"
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "cflags":[],
@@ -56,17 +56,17 @@ Hash: SHA512
 }
 -----BEGIN PGP SIGNATURE-----
 
-iQIzBAEBCgAdFiEEy6ssEDLG/1B4BJ7A+mHVDBLK034FAmgnhqIACgkQ+mHVDBLK
+iQIzBAEBCgAdFiEE6J1JcfAJex56PrVzcbSEgC54180FAmfHlp8ACgkQcbSEgC54
-036q+Q//XkOoRoZ5g3uyQTXTV3w6YCUezkvGv+WRV4oZfj0CElKf4KoW5bhdtWEM
+182ezg/7Bkil1mY6d4recJMkFhpBzzDs8aMD+WQOBPoy/bWHIGsPb1DyOOW7lTLa
-EBRC4UuFturk7m1KrgztKsEFq7vx0TxvbWjj5R64swrwczKkD7i5xjMhWZn0nrpk
+QC9jh9Rq02oMeX0LWvNg7k6iMTayWcrPzJwk1rgh3pg/ySgCTZ576/aP/UOZwA8h
-kzeKJw8zCr+o+qAHUoqTZAAf1GaMOwCKN8rZ5zrulbkrugPY783UKJtfyJc8+BPT
+HT/3RzsDFlq7Wkh4yYaDgSEDVc5PgUevb1p2f126Z9HMFjG8siEWmuZQOcy4I9JG
-dixOerTC5cvzFNHENIKXMTh7Pbww2jdnFCn2eGA1kmyJGkRFhKKQ9kerlUcfOdQB
+osQFtwWTLmx96sBMzweZTu2i3iGTPNz4Ae1hu+v5clmSFg43eW7EWChEVoob+3hb
-w51jMfgZRoG/hvSnrlrYHJQx1hpUiBV5eyEcLHnlbiJj7cNTvqcrt2nHpy/1Co1H
+hLRxajZEPsIho4yR5yynoxduXeXrLLP7GH6XGnYt7Z2GJR0UamIrPfxYuWBK76V1
-5uiQou5I8ETTvTQrtWNgCtUBg1ZqaKZw8tanSY4cHXoeP5s4uQl1yTEGCEDDFB9y
+03Ie2rRXwOKfsjDWw9Z8ziTVu25G0aZ274DX6eQyaWKfvzz69cBXO0fgw1lU8B9S
-E/yO9xTfak3Avv1h6FZ2Lw+ipVLnlurtpo/jGmr4UgoKV4MZ1hFSseIEWQVyXJ+4
+K0j9k/xtnDCrIkPSh4QGQpFRlbzxkj20E+EnwgDCGIlK1rBzo2V5na4YNj+SbC91
-kP2gZ/LZF84eYqRKANYGWbKp/fKJQgnn/nhKgySfx4dKHJFRpVNgiGzNYyYwOtOC
+0BmWrj6dRkQZUMJHeb95kBMfFpKG5B6u7HQxZtIwHFAfF0nypbiB7xmdy/gAmUao
-BWrLIqgvETl+MZZPMPwt8T7ZCYIR5fzQ1itGM3ffmsh9DIvRyu32DRWBcqgiDE7o
+ej3Cu34DvWtLVeSh7lRimeEc44WyBDk2YSPqYleAwYMZBn4WSozUS/KVLU2T/AhZ
-866L+C6Kk2RyCS8dB3Ep4LW7kO42k0Rq6cvkO8wV+CjbTF/i8OQEclDMxr+ruoN0
+VlLaEBaFrVngmsw5PCdck0XRSNSAN9HUgPItpOzYig20NeT1/69wIlUZVNpLEYGT
-IKEp2thRZA39iDHGAIPyCsryrZhpEJ+uOfMykWKc0j957CpXLck=
+yvZsmqHFnkunAs6av3XmGl0i8rSA6DujunpNXML6hUciFEK5wg4=
-=Qmpp
+=Aq8h
 -----END PGP SIGNATURE-----

lib/spack/spack/test/data/mirrors/v2_layout/signed/build_cache/test-debian6-m1-gcc-10.2.1-libdwarf-20130729-u5uz3dcch5if4eve4sef67o2rf2lbfgh.spec.json.sig

@@ -1,5 +1,5 @@
 -----BEGIN PGP SIGNED MESSAGE-----
-Hash: SHA512
+Hash: SHA256
 
 {
 "spec":{
@@ -57,7 +57,7 @@ Hash: SHA512
 "cpupart":"0x022"
 }
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "cflags":[],
@@ -169,7 +169,7 @@ Hash: SHA512
 "cpupart":"0x022"
 }
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "cflags":[],
@@ -193,7 +193,7 @@ Hash: SHA512
 "platform_os":"debian6",
 "target":"aarch64"
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "languages":[
@@ -275,7 +275,7 @@ Hash: SHA512
 "cpupart":"0x022"
 }
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "cflags":[],
@@ -353,7 +353,7 @@ Hash: SHA512
 "cpupart":"0x022"
 }
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "cflags":[],
@@ -413,17 +413,17 @@ Hash: SHA512
 }
 -----BEGIN PGP SIGNATURE-----
 
-iQIzBAEBCgAdFiEEy6ssEDLG/1B4BJ7A+mHVDBLK034FAmgnhqIACgkQ+mHVDBLK
+iQIzBAEBCAAdFiEEqYoEuILhnYX9Nu4GlWXYCwVckv8FAmf23+QACgkQlWXYCwVc
-035oXBAAj12qztxIYhTbNRq0jpk7/ZfCLRDz/XyqzKx2JbS+p3DfZruVZV/OMZ9I
+kv9Xlg//d7uWhVbHjujSXRpoN3hzH5sUvvTSZ9xzvXGAXCoAu2oEGg4hxZPIFQJ3
-Hlj9GYxQEwLGVsEMXoZDWtUytcte3m6sCG6H8fZGKw6IWQ6eiDR5i7TJWSuPvWGU
+pZzKysZMfeFg+UKwDzex5TlKZ3JtKgCTKYl64zZfUl2EQgo/d/Fjz5mSFHW/6sa1
-NMH57kvSJlICLP9x6NWjQeyLAI4I3kASk+Ei/WHAGqIiP9CR1O5IXheMusPDAEjd
+1uTe3+sVt+HlijN72t2412Qbp+/uGvU+KBvXPA7kgkp88Kd/PL9xe3jlT9ytH5Nw
-2IR7khPvJTwpD6rzMHPou9BWk0Jqefb9qHhaJnc0Ga1D5HCS2VdGltViQ0XCX7/7
+3LIghe++JiepjFAKXTfIA04EjLb8c50AAxsK5Xx37HOOVHHQ8L9anFnOVYM+DxAz
-nkWV9ad9NOvbO9oQYIW1jRY8D9Iw9vp2d77Dv5eUzI8or5c5x0VFAHpQL0FUxIR9
+gn4dBYUQ9Uu5k5uEu5CwtxsED2/Yar7YWIepEnyp6z4zQVbwjO4/w0vZ3wSJ9c4P
-LpHWUohDiAp3M4kmZqLBPl1Qf2jAXFXiSmcrLhKD5eWhdiwn3Bkhs2JiSiJpHt6K
+UhZs8V2akuqIWyzlQuBOjywnEQc/nw9v0py+Dr/Qr3U4XWh/LARWABMxa4IqXMOK
-Sa970evIFcGw6sUBGznsuFxmXFfp84LYvzIVjacuzkm9WDvbEE/5pa2b5Pxr7BmH
+aVmd6weVjV4U929gaOT/FCtZPfaFNRbk97YP8yAxuLhSdiGS0Mp16Ygz21fVWB7C
-d2xDmAYmZVOso6INf3ZEXOyMBPWyGyq9Hy/8Nyg/+7w2d4ICEG/z/N13VsTqRoXc
+UjkGGsKK1cdiJQ0m1CffmydU/nbDjSuw4WZIoIgDzvN7SFm7YBtE+xY+RUPsHU22
-rb8I0xDE9iCXCelQJYlJcJ2UMZk9E76zd3Bd2WcgCTrrnHsg0fBjmNeyPJcBN8hA
+QMAXojF5abwn48HJeP47MYdfR7+nUJq6XJiJ7/80a7Ciy8SAVxinQWqvigf/hmTf
-am5Lq/Cxqm2Jo2qnjoVmCt8/TBkvT2w8PTpR5uTEbLDl2ghyzxyBkX7a8ldKx55f
+kAiQaqOVSlRBJ2yry5fYBKHSIRvghCqS4t4es8o13R7n2wz68VqKu0JkNlT3Ijjc
-aL8/OxN+u0pyISTDs5AoZ1YbhgDMiBiZV8ZDIB8PzU8pE78De3Q=
+QjJYtI+844PCDNetPVV8iNWF6upnTJnPHcFmKAEO1663hOc3Dh8=
-=YbRr
+=3fA5
 -----END PGP SIGNATURE-----

lib/spack/spack/test/data/mirrors/v2_layout/signed/build_cache/test-debian6-m1-gcc-10.2.1-libelf-0.8.13-jr3yipyxyjulcdvckwwwjrrumis7glpa.spec.json.sig

@@ -1,5 +1,5 @@
 -----BEGIN PGP SIGNED MESSAGE-----
-Hash: SHA512
+Hash: SHA256
 
 {
 "spec":{
@@ -57,7 +57,7 @@ Hash: SHA512
 "cpupart":"0x022"
 }
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "cflags":[],
@@ -157,7 +157,7 @@ Hash: SHA512
 "cpupart":"0x022"
 }
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "cflags":[],
@@ -181,7 +181,7 @@ Hash: SHA512
 "platform_os":"debian6",
 "target":"aarch64"
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "languages":[
@@ -263,7 +263,7 @@ Hash: SHA512
 "cpupart":"0x022"
 }
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "cflags":[],
@@ -301,17 +301,17 @@ Hash: SHA512
 }
 -----BEGIN PGP SIGNATURE-----
 
-iQIzBAEBCgAdFiEEy6ssEDLG/1B4BJ7A+mHVDBLK034FAmgnhqIACgkQ+mHVDBLK
+iQIzBAEBCAAdFiEEqYoEuILhnYX9Nu4GlWXYCwVckv8FAmf23+QACgkQlWXYCwVc
-0356nQ//aVMUZU8Ly8/b1H4nvKM8Vyd275aFK64rvO89mERDNiYIOKk1pmYSMldU
+kv/zSg/+NrS4JjT9TFSFR/q2vaN9aL7fSTunxp+M8eAzTmg0sgHc/D6ov2PMpUF7
-+ltx2iIfVTUCEWYYJb/4UXWmw6SLAXIZ5mtrkALDAeDSih4wqIdevM3yii7pn8Oh
+1E2mnZ2gL5a5dHtsSCf30ILFzQoD+m+I9yOwcJopcbEjr8pcnXBFe6TT8lkxlXtI
-/OEyDX8N5k05pnxFLYqR/2gA6vvdxHFd9/h4/zy2Z5w6m1hXb5jtS2ECyYN72nYN
+EHNsYGMUHFbFvc+hFdWatQJicdDaIbdyEMGAC7Kobs/4KpdBF5VWV+sIrzD5+XzO
-8QnnkXWZYturOhb4GawWY1l/rHIBqAseCQXSGR6UyrHTEGLUgT0+VQZwgxLNM4uG
+ACiKRjBmcaJpa950nuEaFzBITgq1aDtZ0EEZdXYvjRnzj9Bm6gbqmWzlllW1wf4r
-xj4xCDTgKiOesa5+3WE8Ug2wDIm48Prvg4qFmNrofguRNiIsNrl5k7wRiJWdfkjc
+5hSMTpAsRED4TxL433nuf0nKIvTD5Mywzs88kiLCtEABfDy1qccyBAnjyNypFF6B
-gzs9URYddoCTRR2wpN0CaAQ268UlwZUCjPSrxgCNeqRi4Ob9Q4n37TKXNcVw46Ud
+fPqSDnr33s+JQ35t7RcHKfrgowk69UablE25YOUrQP6LtH4QzLBLj4/Z0zuz33hO
-MXRezAf+wyPGkq4vudh7cu11mHUcTeev82GM5bYQa6dSna3WvPpie/rx0TZYRkKE
+v+YYe51DgixsMQ2WCKWEO6sNcrcrLBJMFVwUP2FyTTdW3jCYRlFiTYLSfoDhTRJ/
-hesDW/41ZtFDANfXa7r011ngS5zZwak3zUaoqOdLNhN/xL4TFsZ19uSUdSZHAgSk
+4o7f2eEp3sVoOe12jKI6dw/P+c70dl8K4+1ICcnZkwsb0pd0vt2z4J2kPs2+1/0g
-9Sr3xodwV2D5H6gDuOtAo1vRod1Fx+yoi3BubX0sI5QuFgvtJrHVZmVj2bnGMBKI
+vpywJO1HL5Zy7/ZRlmeeSMHYEDX2eKhm7QRFbxw1IEbg3stQCA7a425JWztyJ05K
-gR17q1ZHOmp3yPhVE9ZsiLKn9r3yIsfVhoTB6mXOnvq2q1fBxyrEpIGzIUmWfuTm
+sfhFQgPt7F/xanJVFYk/hdza+3+5pFr1K/ARcLFBdLBKGxAXTMMR+NkMp3J5NiOo
-vLn4nXt7PD78msiG/GZt6fShYBAwVfuvG+M1AQrsyGGoW2Bty7M=
+SMZJ3jG6xA2ntvSkyx/GFawD0FpnlgEByU3E+R/WiQA4VojLpvo=
-=hLvB
+=kfWI
 -----END PGP SIGNATURE-----

lib/spack/spack/test/data/mirrors/v2_layout/signed/build_cache/test-debian6-m1-none-none-compiler-wrapper-1.0-qeehcxyvluwnihsc2qxstmpomtxo3lrc.spec.json.sig

@@ -1,5 +1,5 @@
 -----BEGIN PGP SIGNED MESSAGE-----
-Hash: SHA512
+Hash: SHA256
 
 {
 "spec":{
@@ -57,7 +57,7 @@ Hash: SHA512
 "cpupart":"0x022"
 }
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "cflags":[],
@@ -83,17 +83,17 @@ Hash: SHA512
 }
 -----BEGIN PGP SIGNATURE-----
 
-iQIzBAEBCgAdFiEEy6ssEDLG/1B4BJ7A+mHVDBLK034FAmgnhqIACgkQ+mHVDBLK
+iQIzBAEBCAAdFiEEqYoEuILhnYX9Nu4GlWXYCwVckv8FAmf23+QACgkQlWXYCwVc
-037BIQ//U30gx1qTt5cQs+I6fwqQSase8DT7Hi8VdYxMuBTVbEpnPScNpcH03ITC
+kv/T8BAAhK/v7CP6lMIKILj35nEi+Gftjs7B7f6qvb4QNtqcGHum6z9t3JxkOOrd
-KWVbXvEAPBdoWEfAHpuOJr2pm013dYXaWp1k0G6pLSvnR17LEDTJs0ixAurH4vDr
++q+Wd329kLYAFs/y9eaGe5X7wY1U7/f863i3XrxHbtmrnMci61D8qMjA1xnBGC+5
-4VXPerPR57sMi0WYomi1+dJhvA3S85+m6KBPLhXgi9Y28leDrFpjBwxVoIN7yUP2
+yd746aVeV/VRbJxTeB9kGcKPMcIQYcearlDMgj5fKfpCKM8a+VyJfw7qHNUyrTnu
-tenMI9jAoGh/hts1pIPbALmKbeGUKC2MPu9MF0CtkbbE1VOkeJ6jkZLGki7AAYZ0
+d6LSGsEey6tGkJecgnJZTNSwryO3BZbg/4EviivMXm38AKGZrSib06qjkoHrPRvB
-TSWAeWDk6EG90TZ6ls2anUPI1mNc7JdPqq8L0+jWAwLJi3i/JiDAGUM99hpu9cCF
+8ftGSGlK4YmFs5/YjKFL7QzuNJeqPNJt4mD64tsk21urOfbQJe5AmdMLPGY0PbW/
-NvZn+eQFOKrE0WG1KsF4vQilOAuE3P+QLomcfZdf2UNi73XPWIF5j46r50oPmXZE
+w++06c8lsd/6FmzUwlnTBUa39lKJjhkhoK7KFGVqZROcXZfhwAyqPZt7ReA5FDMV
-+mVUyw7CUbHMZlXvWml0pdugEER1Kyc2nLZdLZYAT92AsPbAcDBQKsm1xf66lOB+
+l5X7sytjQuSFaQPGi5g1xXQGEI394T2I55p5T5/RuQ2PXcFxxSOmIcEcD8o6Z7+x
-FPPLc97oybcFFldrjmUJAASJBeAihZG1aDm6dYBxtynMzzRGdq2+R1chHMOQ5Wej
+XWLq44KUWQyQP/StjaVhIz9YPogeBBJllA9hN+GzVrr2i+Esu1QO5uDgVuJP7pTA
-8ZvyRv+TOPUTtRkAxrUpq6wA+BUoq+OBDltOs9mXUIcV3rpOq5nTjKZ5FLMtGaDw
+9wwCLV/t0hf2TZcpU2fwEu+DMniaHm6haVwqiu6QGkbkMBx49zkV9b5i9L441GoC
-No0E5gwceDDLeshT9nAHaqcmSY1LK+/5+aDxOFRm4yRTI+GLJzg8FZCJbJRLstrD
+Q86R2Gs9O0+QzHuN6egbQ0xKm/lfU8dmJSzV0snXawAeQ/vgCpdinx40EMc7Nz03
-Ts4zKdcb0kukKdE9raqWw7xuhbjz2ORiEicZzckzvB1Lx38bG2s=
+rgZ3j88c/ADvCb1DVKmu1Phf6U7WqG6/AvB9tYl4Zl30VX7ETaw=
-=T5l5
+=ifvQ
 -----END PGP SIGNATURE-----

lib/spack/spack/test/data/mirrors/v2_layout/signed/build_cache/test-debian6-m1-none-none-gcc-runtime-10.2.1-izgzpzeljwairalfjm3k6fntbb64nt6n.spec.json.sig

@@ -1,5 +1,5 @@
 -----BEGIN PGP SIGNED MESSAGE-----
-Hash: SHA512
+Hash: SHA256
 
 {
 "spec":{
@@ -57,7 +57,7 @@ Hash: SHA512
 "cpupart":"0x022"
 }
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "cflags":[],
@@ -93,7 +93,7 @@ Hash: SHA512
 "platform_os":"debian6",
 "target":"aarch64"
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "languages":[
@@ -135,17 +135,17 @@ Hash: SHA512
 }
 -----BEGIN PGP SIGNATURE-----
 
-iQIzBAEBCgAdFiEEy6ssEDLG/1B4BJ7A+mHVDBLK034FAmgnhqIACgkQ+mHVDBLK
+iQIzBAEBCAAdFiEEqYoEuILhnYX9Nu4GlWXYCwVckv8FAmf23+QACgkQlWXYCwVc
-037zHBAAsqy4wItctMqauuna+JjxT1HM7YJElXzqjOWmxyuAzUzjXlhR2DBd/2TI
+kv+MsRAAsaQjZbB9iW/Lq9b87H/E5Zmv6RrClvpjSnwvhLR4nhPL3p0G70k6tI/b
-ZEN2q3Z3XY9sCjhZ/4c9wDfMNYLUBLMHuenyV3fOqsfIVL8NprrkGc5mOiJ8HbRk
+NEdXctDyvBOJOEoLaEBrCODl/3GjV8B9Gj7OhT/BIKQjlOfJqVdwIrnHgav5ri+Q
-u00qXWogsYSEmbGrlfDKf4HmZtgPNs82+Li1MD5udDUzyApuVbObJumSRh6/1QHm
+UUXLtejhJiUNoxeILI/xZx2CoKT9q/3EpQ5ysqdybJmYJCf/hv+lXEhnwUIv8vV/
-BcQZgMlSCd8xsTxJudXKAnfpemqE41LF0znuU0x5Hj/hU1A3CELynQrLEYnJpzpR
+xdRYY//rfeMowCNIZtFPjSejMywXJfFKjl7h5dN5kwM63D6z/sh4zW7tqHq4kk+A
-ja2l341cBQKNy86kX1/eHQtBJverjFoD3Nx4per8/qUc+xTH0ejMuseyd9P3RLnd
+2m0WcorVg93wAm+YoJaQJVx8bYeMGfV/TjmY/cSouCt8PM4Vi93vwieZCkzEpXbM
-WShY8Uk72f1OLGzq5RvayP1M/dBWedajKz5gYOD19pCuFEdQm1LkZhxRWJ35PYMV
+BkVN4X3PTMZSOf0WTkEbnQD5v090/DoQPZyBrcDoJ/HmWDiz5Is2wUI0mLVkbg2L
-CqzY/uJgs33zyYkNJKO8CKG5j7Y8zOuZ3YFN8DKmoWa+lC4gFIsXm42BttqiQ5+x
++rKNC3ZajJhsWElMGNNtZRLmGeTIe8hT+LNAejo221vrOJbnUmpIjKxVjStDbXmW
-Q65YkX/DdPYO6dcUety1j3NuNr70W6PsLyqKBny1WOzKCx25nmzftS0OA76F6UZA
+nulgyEPSTfsJaXgbXmeJ8LOk0tWpBAGC16VzgXrPxoGD2XKxoiPCGLNrF/l1wyl+
-hDneqltGrYEQTowU5I7V14f3SMeO8xje3BcqhOAn956/JJObd5VbwqcHwcslwEJA
+n+nw3TchNFrofpPrqJzT/vS71B6KDb0PVSTQZfM9+FahrQ+YbsIkzDAuxVZb5t3q
-tL3361qbpkc7xURnhciV1eL3RYR9Q4xDnvI1i/k8J8E8W373TviK3r2MG/oKZ6N9
+HUME95RgoIBbccUGxAPwkaNme2OLaLzsJZ/Xhl5I8T1fraLYapsKNjQ5+CSKO8+t
-n+ehBZhSIT+QUgqylATekoMQfohNVbDQEsQhj96Ky1CC2Iqo1/c=
+MlJYgSHuazWSetRbZ2H7g7QJWqeHUAWi9i1szpNDYxTFSs8wgDY=
-=UIyv
+=edPy
 -----END PGP SIGNATURE-----

lib/spack/spack/test/data/mirrors/v2_layout/unsigned/build_cache/index.json.hash

@@ -1 +1 @@
-fc129b8fab649ab4c5623c874c73bd998a76fd30d2218b9d99340d045c1ec759
+57cad2589fae55cda3c35cadf4286d2e7702f90a708da80d70a76213fc45a688

lib/spack/spack/test/data/mirrors/v2_layout/unsigned/build_cache/test-debian6-core2-gcc-10.2.1-libdwarf-20130729-sk2gqqz4n5njmvktycnd25wq25jxiqkr.spec.json

@@ -30,7 +30,7 @@
 "name":"gcc",
 "version":"10.2.1"
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "cflags":[],
@@ -82,7 +82,7 @@
 "name":"gcc",
 "version":"10.2.1"
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "cflags":[],

lib/spack/spack/test/data/mirrors/v2_layout/unsigned/build_cache/test-debian6-core2-gcc-10.2.1-libelf-0.8.13-rqh2vuf6fqwkmipzgi2wjx352mq7y7ez.spec.json

@@ -30,7 +30,7 @@
 "name":"gcc",
 "version":"10.2.1"
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "cflags":[],

lib/spack/spack/test/data/mirrors/v2_layout/unsigned/build_cache/test-debian6-m1-gcc-10.2.1-libdwarf-20130729-u5uz3dcch5if4eve4sef67o2rf2lbfgh.spec.json

@@ -54,7 +54,7 @@
 "cpupart":"0x022"
 }
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "cflags":[],
@@ -166,7 +166,7 @@
 "cpupart":"0x022"
 }
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "cflags":[],
@@ -190,7 +190,7 @@
 "platform_os":"debian6",
 "target":"aarch64"
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "languages":[
@@ -272,7 +272,7 @@
 "cpupart":"0x022"
 }
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "cflags":[],
@@ -350,7 +350,7 @@
 "cpupart":"0x022"
 }
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "cflags":[],

lib/spack/spack/test/data/mirrors/v2_layout/unsigned/build_cache/test-debian6-m1-gcc-10.2.1-libelf-0.8.13-jr3yipyxyjulcdvckwwwjrrumis7glpa.spec.json

@@ -54,7 +54,7 @@
 "cpupart":"0x022"
 }
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "cflags":[],
@@ -154,7 +154,7 @@
 "cpupart":"0x022"
 }
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "cflags":[],
@@ -178,7 +178,7 @@
 "platform_os":"debian6",
 "target":"aarch64"
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "languages":[
@@ -260,7 +260,7 @@
 "cpupart":"0x022"
 }
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "cflags":[],

lib/spack/spack/test/data/mirrors/v2_layout/unsigned/build_cache/test-debian6-m1-none-none-compiler-wrapper-1.0-qeehcxyvluwnihsc2qxstmpomtxo3lrc.spec.json

@@ -54,7 +54,7 @@
 "cpupart":"0x022"
 }
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "cflags":[],

lib/spack/spack/test/data/mirrors/v2_layout/unsigned/build_cache/test-debian6-m1-none-none-gcc-runtime-10.2.1-izgzpzeljwairalfjm3k6fntbb64nt6n.spec.json

@@ -54,7 +54,7 @@
 "cpupart":"0x022"
 }
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "cflags":[],
@@ -90,7 +90,7 @@
 "platform_os":"debian6",
 "target":"aarch64"
 },
-"namespace":"builtin_mock",
+"namespace":"builtin.mock",
 "parameters":{
 "build_system":"generic",
 "languages":[

lib/spack/spack/test/data/test/test_stage/gavrxt67t7yaiwfek7dds7lgokmoaiin/test_suite.lock

@@ -31,7 +31,7 @@
               "name": "gcc",
               "version": "4.5.0"
             },
-            "namespace": "builtin_mock",
+            "namespace": "builtin.mock",
             "parameters": {
               "cflags": [],
               "cppflags": [],