Variant satisfaction for indirect dependencies

Fixes #4898

Constraints that were supposed to be conditionally activated for
specified values of a single-valued variant were being activated
unconditionally in the case that the variant was associated with
an implicit dependency. For example if X->Y->Z and Y places a
conditional constraint on Z for a given single-valued variant on
Y, then it would have been applied unconditionally when
concretizing X.

lib/spack/spack/spec.py

@@ -1879,6 +1879,7 @@ def _evaluate_dependency_conditions(self, name):
         pkg = spack.repo.get(self.fullname)
         conditions = pkg.dependencies[name]
 
+        substitute_abstract_variants(self)
         # evaluate when specs to figure out constraints on the dependency.
         dep = None
         for when_spec, dep_spec in conditions.items():

lib/spack/spack/test/cmd/dependents.py

@@ -42,7 +42,8 @@ def test_transitive_dependents(builtin_mock):
     out, err = dependents('--transitive', 'libelf')
     actual = set(re.split(r'\s+', out.strip()))
     assert actual == set(
-        ['callpath', 'dyninst', 'libdwarf', 'mpileaks', 'multivalue_variant'])
+        ['callpath', 'dyninst', 'libdwarf', 'mpileaks', 'multivalue_variant',
+         'singlevalue-variant-dependent'])
 
 
 def test_immediate_installed_dependents(builtin_mock, database):

lib/spack/spack/test/spec_semantics.py

@@ -307,6 +307,20 @@ def test_satisfies_single_valued_variant(self):
         # Check that conditional dependencies are treated correctly
         assert '^b' in a
 
+    def test_unsatisfied_single_valued_variant(self):
+        a = Spec('a foobar=baz')
+        a.concretize()
+        assert '^b' not in a
+
+        mv = Spec('multivalue_variant')
+        mv.concretize()
+        assert 'a@1.0' not in mv
+
+    def test_indirect_unsatisfied_single_valued_variant(self):
+        spec = Spec('singlevalue-variant-dependent')
+        spec.concretize()
+        assert 'a@1.0' not in spec
+
     def test_unsatisfiable_multi_value_variant(self):
 
         # Semantics for a multi-valued variant is different