diff --git a/lib/spack/spack/solver/asp.py b/lib/spack/spack/solver/asp.py
index aa489944ba..f26954ec16 100644
--- a/lib/spack/spack/solver/asp.py
+++ b/lib/spack/spack/solver/asp.py
@@ -133,6 +133,10 @@ def named_spec(
         yield spec
         return
 
+    # Clone empty spec when we need to assign a name
+    if spec is spack.spec.EMPTY_SPEC:
+        spec = spack.spec.Spec()
+
     old_name = spec.name
     spec.name = name
     try:
@@ -1842,7 +1846,9 @@ def _condition_clauses(
             if not imposed_name:
                 raise ValueError(f"Must provide a name for imposed constraint: '{imposed_spec}'")
 
-        with named_spec(required_spec, required_name), named_spec(imposed_spec, imposed_name):
+        with named_spec(required_spec, required_name) as required_spec_with_name, named_spec(
+            imposed_spec, imposed_name
+        ) as imposed_spec_with_name:
             # Check if we can emit the requirements before updating the condition ID counter.
             # In this way, if a condition can't be emitted but the exception is handled in the
             # caller, we won't emit partial facts.
@@ -1850,22 +1856,32 @@ def _condition_clauses(
             condition_id = next(self._id_counter)
             requirement_context = context.requirement_context()
             trigger_id = self._get_condition_id(
-                required_spec, cache=self._trigger_cache, body=True, context=requirement_context
+                required_spec_with_name,
+                cache=self._trigger_cache,
+                body=True,
+                context=requirement_context,
             )
-            clauses.append(fn.pkg_fact(required_spec.name, fn.condition(condition_id)))
+            clauses.append(fn.pkg_fact(required_spec_with_name.name, fn.condition(condition_id)))
             clauses.append(fn.condition_reason(condition_id, msg))
             clauses.append(
-                fn.pkg_fact(required_spec.name, fn.condition_trigger(condition_id, trigger_id))
+                fn.pkg_fact(
+                    required_spec_with_name.name, fn.condition_trigger(condition_id, trigger_id)
+                )
             )
-            if not imposed_spec:
+            if not imposed_spec_with_name:
                 return clauses, condition_id
 
             impose_context = context.impose_context()
             effect_id = self._get_condition_id(
-                imposed_spec, cache=self._effect_cache, body=False, context=impose_context
+                imposed_spec_with_name,
+                cache=self._effect_cache,
+                body=False,
+                context=impose_context,
             )
             clauses.append(
-                fn.pkg_fact(required_spec.name, fn.condition_effect(condition_id, effect_id))
+                fn.pkg_fact(
+                    required_spec_with_name.name, fn.condition_effect(condition_id, effect_id)
+                )
             )
 
             return clauses, condition_id
@@ -2028,14 +2044,14 @@ def package_splice_rules(self, pkg):
         for i, (cond, (spec_to_splice, match_variants)) in enumerate(
             sorted(pkg.splice_specs.items())
         ):
-            with named_spec(cond, pkg.name):
-                self.version_constraints.add((cond.name, cond.versions))
+            with named_spec(cond, pkg.name) as cond_with_name:
+                self.version_constraints.add((cond_with_name.name, cond_with_name.versions))
                 self.version_constraints.add((spec_to_splice.name, spec_to_splice.versions))
                 hash_var = AspVar("Hash")
-                splice_node = fn.node(AspVar("NID"), cond.name)
+                splice_node = fn.node(AspVar("NID"), cond_with_name.name)
                 when_spec_attrs = [
                     fn.attr(c.args[0], splice_node, *(c.args[2:]))
-                    for c in self.spec_clauses(cond, body=True, required_from=None)
+                    for c in self.spec_clauses(cond_with_name, body=True, required_from=None)
                     if c.args[0] != "node"
                 ]
                 splice_spec_hash_attrs = [
@@ -2052,17 +2068,23 @@ def package_splice_rules(self, pkg):
                             filt_match_variants.add(k)
                     filt_match_variants = sorted(filt_match_variants)
                     variant_constraints = self._gen_match_variant_splice_constraints(
-                        pkg, cond, spec_to_splice, hash_var, splice_node, filt_match_variants
+                        pkg,
+                        cond_with_name,
+                        spec_to_splice,
+                        hash_var,
+                        splice_node,
+                        filt_match_variants,
                     )
                 else:
                     if any(
-                        v in cond.variants or v in spec_to_splice.variants for v in match_variants
+                        v in cond_with_name.variants or v in spec_to_splice.variants
+                        for v in match_variants
                     ):
                         raise spack.error.PackageError(
                             "Overlap between match_variants and explicitly set variants"
                         )
                     variant_constraints = self._gen_match_variant_splice_constraints(
-                        pkg, cond, spec_to_splice, hash_var, splice_node, match_variants
+                        pkg, cond_with_name, spec_to_splice, hash_var, splice_node, match_variants
                     )
 
                 rule_head = fn.abi_splice_conditions_hold(