Rename atom: "facts" -> "pkg_fact"

lib/spack/spack/solver/asp.py

@@ -968,7 +968,7 @@ def key_fn(version):
 
         for weight, declared_version in enumerate(most_to_least_preferred):
             self.gen.fact(
-                fn.facts(
+                fn.pkg_fact(
                     pkg.name,
                     fn.version_declared(
                         declared_version.version, weight, str(declared_version.origin)
@@ -979,7 +979,7 @@ def key_fn(version):
         # Declare deprecated versions for this package, if any
         deprecated = self.deprecated_versions[pkg.name]
         for v in sorted(deprecated):
-            self.gen.fact(fn.facts(pkg.name, fn.deprecated_version(v)))
+            self.gen.fact(fn.pkg_fact(pkg.name, fn.deprecated_version(v)))
 
     def spec_versions(self, spec):
         """Return list of clauses expressing spec's version constraints."""
@@ -1023,7 +1023,7 @@ def conflict_rules(self, pkg):
                 constraint_msg = "conflict constraint %s" % str(constraint)
                 constraint_id = self.condition(constraint, name=pkg.name, msg=constraint_msg)
                 self.gen.fact(
-                    fn.facts(pkg.name, fn.conflict(trigger_id, constraint_id, conflict_msg))
+                    fn.pkg_fact(pkg.name, fn.conflict(trigger_id, constraint_id, conflict_msg))
                 )
                 self.gen.newline()
 
@@ -1077,7 +1077,7 @@ def package_compiler_defaults(self, pkg):
 
         for i, compiler in enumerate(reversed(matches)):
             self.gen.fact(
-                fn.facts(
+                fn.pkg_fact(
                     pkg.name,
                     fn.node_compiler_preference(
                         compiler.spec.name, compiler.spec.version, -i * 100
@@ -1188,7 +1188,7 @@ def pkg_rules(self, pkg, tests):
         # virtual preferences
         self.virtual_preferences(
             pkg.name,
-            lambda v, p, i: self.gen.fact(fn.facts(pkg.name, fn.provider_preference(v, p, i))),
+            lambda v, p, i: self.gen.fact(fn.pkg_fact(pkg.name, fn.provider_preference(v, p, i))),
         )
 
         self.package_requirement_rules(pkg)
@@ -1201,8 +1201,8 @@ def trigger_rules(self, name):
         self.gen.h2("Trigger conditions")
         cache = self._trigger_cache[name]
         for spec_str, (trigger_id, requirements) in cache.items():
-            self.gen.fact(fn.facts(name, fn.trigger_id(trigger_id)))
+            self.gen.fact(fn.pkg_fact(name, fn.trigger_id(trigger_id)))
-            self.gen.fact(fn.facts(name, fn.trigger_msg(spec_str)))
+            self.gen.fact(fn.pkg_fact(name, fn.trigger_msg(spec_str)))
             for predicate in requirements:
                 self.gen.fact(fn.condition_requirement(trigger_id, *predicate.args))
             self.gen.newline()
@@ -1212,8 +1212,8 @@ def effect_rules(self, name):
         self.gen.h2("Imposed requirements")
         cache = self._effect_cache[name]
         for spec_str, (effect_id, requirements) in cache.items():
-            self.gen.fact(fn.facts(name, fn.effect_id(effect_id)))
+            self.gen.fact(fn.pkg_fact(name, fn.effect_id(effect_id)))
-            self.gen.fact(fn.facts(name, fn.effect_msg(spec_str)))
+            self.gen.fact(fn.pkg_fact(name, fn.effect_msg(spec_str)))
             for predicate in requirements:
                 self.gen.fact(fn.imposed_constraint(effect_id, *predicate.args))
             self.gen.newline()
@@ -1225,7 +1225,7 @@ def variant_rules(self, pkg):
 
             if spack.spec.Spec() in when:
                 # unconditional variant
-                self.gen.fact(fn.facts(pkg.name, fn.variant(name)))
+                self.gen.fact(fn.pkg_fact(pkg.name, fn.variant(name)))
             else:
                 # conditional variant
                 for w in when:
@@ -1234,13 +1234,13 @@ def variant_rules(self, pkg):
                         msg += " when %s" % w
 
                     cond_id = self.condition(w, name=pkg.name, msg=msg)
-                    self.gen.fact(fn.facts(pkg.name, fn.conditional_variant(cond_id, name)))
+                    self.gen.fact(fn.pkg_fact(pkg.name, fn.conditional_variant(cond_id, name)))
 
             single_value = not variant.multi
             if single_value:
-                self.gen.fact(fn.facts(pkg.name, fn.variant_single_value(name)))
+                self.gen.fact(fn.pkg_fact(pkg.name, fn.variant_single_value(name)))
                 self.gen.fact(
-                    fn.facts(
+                    fn.pkg_fact(
                         pkg.name, fn.variant_default_value_from_package_py(name, variant.default)
                     )
                 )
@@ -1249,7 +1249,7 @@ def variant_rules(self, pkg):
                 defaults = spec_variant.value
                 for val in sorted(defaults):
                     self.gen.fact(
-                        fn.facts(pkg.name, fn.variant_default_value_from_package_py(name, val))
+                        fn.pkg_fact(pkg.name, fn.variant_default_value_from_package_py(name, val))
                     )
 
             values = variant.values
@@ -1261,7 +1261,7 @@ def variant_rules(self, pkg):
                 for sid, s in enumerate(values.sets):
                     for value in s:
                         self.gen.fact(
-                            fn.facts(
+                            fn.pkg_fact(
                                 pkg.name, fn.variant_value_from_disjoint_sets(name, value, sid)
                             )
                         )
@@ -1291,7 +1291,7 @@ def variant_rules(self, pkg):
                         )
                         msg = "variant {0}={1} is conditionally disabled".format(name, value)
                         self.gen.fact(
-                            fn.facts(pkg.name, fn.conflict(trigger_id, constraint_id, msg))
+                            fn.pkg_fact(pkg.name, fn.conflict(trigger_id, constraint_id, msg))
                         )
                     else:
                         imposed = spack.spec.Spec(value.when)
@@ -1303,10 +1303,10 @@ def variant_rules(self, pkg):
                             name=pkg.name,
                             msg="%s variant %s value %s when %s" % (pkg.name, name, value, when),
                         )
-                self.gen.fact(fn.facts(pkg.name, fn.variant_possible_value(name, value)))
+                self.gen.fact(fn.pkg_fact(pkg.name, fn.variant_possible_value(name, value)))
 
             if variant.sticky:
-                self.gen.fact(fn.facts(pkg.name, fn.variant_sticky(name)))
+                self.gen.fact(fn.pkg_fact(pkg.name, fn.variant_sticky(name)))
 
             self.gen.newline()
 
@@ -1334,7 +1334,7 @@ def condition(self, required_spec, imposed_spec=None, name=None, msg=None, node=
         # we won't emit partial facts.
 
         condition_id = next(self._condition_id_counter)
-        self.gen.fact(fn.facts(named_cond.name, fn.condition(condition_id)))
+        self.gen.fact(fn.pkg_fact(named_cond.name, fn.condition(condition_id)))
         self.gen.fact(fn.condition_reason(condition_id, msg))
 
         cache = self._trigger_cache[named_cond.name]
@@ -1343,7 +1343,7 @@ def condition(self, required_spec, imposed_spec=None, name=None, msg=None, node=
             requirements = self.spec_clauses(named_cond, body=True, required_from=name)
             cache[named_cond] = (trigger_id, requirements)
         trigger_id, requirements = cache[named_cond]
-        self.gen.fact(fn.facts(named_cond.name, fn.condition_trigger(condition_id, trigger_id)))
+        self.gen.fact(fn.pkg_fact(named_cond.name, fn.condition_trigger(condition_id, trigger_id)))
 
         if not imposed_spec:
             return condition_id
@@ -1358,7 +1358,7 @@ def condition(self, required_spec, imposed_spec=None, name=None, msg=None, node=
                 )
             cache[imposed_spec] = (effect_id, requirements)
         effect_id, requirements = cache[imposed_spec]
-        self.gen.fact(fn.facts(named_cond.name, fn.condition_effect(condition_id, effect_id)))
+        self.gen.fact(fn.pkg_fact(named_cond.name, fn.condition_effect(condition_id, effect_id)))
         return condition_id
 
     def impose(self, condition_id, imposed_spec, node=True, name=None, body=False):
@@ -1373,7 +1373,7 @@ def package_provider_rules(self, pkg):
         for provider_name in sorted(set(s.name for s in pkg.provided.keys())):
             if provider_name not in self.possible_virtuals:
                 continue
-            self.gen.fact(fn.facts(pkg.name, fn.possible_provider(provider_name)))
+            self.gen.fact(fn.pkg_fact(pkg.name, fn.possible_provider(provider_name)))
 
         for provided, whens in pkg.provided.items():
             if provided.name not in self.possible_virtuals:
@@ -1382,7 +1382,7 @@ def package_provider_rules(self, pkg):
                 msg = "%s provides %s when %s" % (pkg.name, provided, when)
                 condition_id = self.condition(when, provided, pkg.name, msg)
                 self.gen.fact(
-                    fn.facts(when.name, fn.provider_condition(condition_id, provided.name))
+                    fn.pkg_fact(when.name, fn.provider_condition(condition_id, provided.name))
                 )
             self.gen.newline()
 
@@ -1412,7 +1412,7 @@ def package_dependencies_rules(self, pkg):
 
                 condition_id = self.condition(cond, dep.spec, pkg.name, msg)
                 self.gen.fact(
-                    fn.facts(pkg.name, fn.dependency_condition(condition_id, dep.spec.name))
+                    fn.pkg_fact(pkg.name, fn.dependency_condition(condition_id, dep.spec.name))
                 )
 
                 for t in sorted(deptypes):
@@ -1573,7 +1573,7 @@ def external_packages(self):
             for local_idx, spec in enumerate(external_specs):
                 msg = "%s available as external when satisfying %s" % (spec.name, spec)
                 condition_id = self.condition(spec, msg=msg)
-                self.gen.fact(fn.facts(pkg_name, fn.possible_external(condition_id, local_idx)))
+                self.gen.fact(fn.pkg_fact(pkg_name, fn.possible_external(condition_id, local_idx)))
                 self.possible_versions[spec.name].add(spec.version)
                 self.gen.newline()
 
@@ -1621,7 +1621,7 @@ def target_preferences(self, pkg_name):
             if str(preferred.architecture.target) == best_default and i != 0:
                 offset = 100
             self.gen.fact(
-                fn.facts(
+                fn.pkg_fact(
                     pkg_name, fn.target_weight(str(preferred.architecture.target), i + offset)
                 )
             )
@@ -2169,7 +2169,7 @@ def define_version_constraints(self):
             # generate facts for each package constraint and the version
             # that satisfies it
             for v in sorted(v for v in self.possible_versions[pkg_name] if v.satisfies(versions)):
-                self.gen.fact(fn.facts(pkg_name, fn.version_satisfies(versions, v)))
+                self.gen.fact(fn.pkg_fact(pkg_name, fn.version_satisfies(versions, v)))
 
             self.gen.newline()
 
@@ -2259,7 +2259,7 @@ def define_variant_values(self):
         # spec_clauses(). We might want to order these facts by pkg and name
         # if we are debugging.
         for pkg, variant, value in self.variant_values_from_specs:
-            self.gen.fact(fn.facts(pkg, fn.variant_possible_value(variant, value)))
+            self.gen.fact(fn.pkg_fact(pkg, fn.variant_possible_value(variant, value)))
 
     def _facts_from_concrete_spec(self, spec, possible):
         # tell the solver about any installed packages that could

lib/spack/spack/solver/concretize.lp

@@ -145,23 +145,23 @@ error(100, multiple_values_error, Attribute, PackageNode)
 
 % Versions are declared with a weight and an origin, which indicates where the
 % version was declared (e.g. "package_py" or "external").
-facts(Package, version_declared(Version, Weight)) :- facts(Package, version_declared(Version, Weight, _)).
+pkg_fact(Package, version_declared(Version, Weight)) :- pkg_fact(Package, version_declared(Version, Weight, _)).
 
 % We can't emit the same version **with the same weight** from two different sources
-:- facts(Package, version_declared(Version, Weight, Origin1)),
+:- pkg_fact(Package, version_declared(Version, Weight, Origin1)),
-   facts(Package, version_declared(Version, Weight, Origin2)),
+   pkg_fact(Package, version_declared(Version, Weight, Origin2)),
    Origin1 < Origin2,
    internal_error("Two versions with identical weights").
 
 % We cannot use a version declared for an installed package if we end up building it
-:- facts(Package, version_declared(Version, Weight, "installed")),
+:- pkg_fact(Package, version_declared(Version, Weight, "installed")),
    attr("version", node(ID, Package), Version),
    version_weight(node(ID, Package), Weight),
    not attr("hash", node(ID, Package), _),
    internal_error("Reuse version weight used for built package").
 
 % versions are declared w/priority -- declared with priority implies declared
-facts(Package, version_declared(Version)) :- facts(Package, version_declared(Version, _)).
+pkg_fact(Package, version_declared(Version)) :- pkg_fact(Package, version_declared(Version, _)).
 
 % If something is a package, it has only one version and that must be a
 % declared version.
@@ -169,7 +169,7 @@ facts(Package, version_declared(Version)) :- facts(Package, version_declared(Ver
 % is not precisely one version chosen. Error facts are heavily optimized
 % against to ensure they cannot be inferred when a non-error solution is
 % possible
-{ attr("version", node(ID, Package), Version) : facts(Package, version_declared(Version)) }
+{ attr("version", node(ID, Package), Version) : pkg_fact(Package, version_declared(Version)) }
  :- attr("node", node(ID, Package)).
 
 % A virtual package may or may not have a version, but never has more than one
@@ -180,17 +180,17 @@ error(100, "Cannot select a single version for virtual '{0}'", Virtual)
 % If we select a deprecated version, mark the package as deprecated
 attr("deprecated", node(ID, Package), Version) :-
      attr("version", node(ID, Package), Version),
-     facts(Package, deprecated_version(Version)).
+     pkg_fact(Package, deprecated_version(Version)).
 
 possible_version_weight(node(ID, Package), Weight)
  :- attr("version", node(ID, Package), Version),
-    facts(Package, version_declared(Version, Weight)).
+    pkg_fact(Package, version_declared(Version, Weight)).
 
 % we can't use the weight for an external version if we don't use the
 % corresponding external spec.
 :- attr("version", node(ID, Package), Version),
    version_weight(node(ID, Package), Weight),
-   facts(Package, version_declared(Version, Weight, "external")),
+   pkg_fact(Package, version_declared(Version, Weight, "external")),
    not external(node(ID, Package)),
    internal_error("External weight used for built package").
 
@@ -198,17 +198,17 @@ possible_version_weight(node(ID, Package), Weight)
 % and vice-versa
 :- attr("version", node(ID, Package), Version),
    version_weight(node(ID, Package), Weight),
-   facts(Package, version_declared(Version, Weight, "installed")),
+   pkg_fact(Package, version_declared(Version, Weight, "installed")),
    build(node(ID, Package)),
    internal_error("Reuse version weight used for build package").
 
 :- attr("version", node(ID, Package), Version),
    version_weight(node(ID, Package), Weight),
-   not facts(Package, version_declared(Version, Weight, "installed")),
+   not pkg_fact(Package, version_declared(Version, Weight, "installed")),
    not build(node(ID, Package)),
    internal_error("Build version weight used for reused package").
 
-1 { version_weight(node(ID, Package), Weight) : facts(Package, version_declared(Version, Weight)) } 1
+1 { version_weight(node(ID, Package), Weight) : pkg_fact(Package, version_declared(Version, Weight)) } 1
   :- attr("version", node(ID, Package), Version),
      attr("node", node(ID, Package)).
 
@@ -217,25 +217,25 @@ possible_version_weight(node(ID, Package), Weight)
 % While this choice rule appears redundant with the initial choice rule for
 % versions, virtual nodes with version constraints require this rule to be
 % able to choose versions
-{ attr("version", node(ID, Package), Version) : facts(Package, version_satisfies(Constraint, Version)) }
+{ attr("version", node(ID, Package), Version) : pkg_fact(Package, version_satisfies(Constraint, Version)) }
   :- attr("node_version_satisfies", node(ID, Package), Constraint).
 
 % If there is at least a version that satisfy the constraint, impose a lower
 % bound on the choice rule to avoid false positives with the error below
-1 { attr("version", node(ID, Package), Version) : facts(Package, version_satisfies(Constraint, Version)) }
+1 { attr("version", node(ID, Package), Version) : pkg_fact(Package, version_satisfies(Constraint, Version)) }
   :- attr("node_version_satisfies", node(ID, Package), Constraint),
-     facts(Package, version_satisfies(Constraint, _)).
+     pkg_fact(Package, version_satisfies(Constraint, _)).
 
 % More specific error message if the version cannot satisfy some constraint
 % Otherwise covered by `no_version_error` and `versions_conflict_error`.
 error(10, "Cannot satisfy '{0}@{1}'", Package, Constraint)
   :- attr("node_version_satisfies", node(ID, Package), Constraint),
      attr("version", node(ID, Package), Version),
-     not facts(Package, version_satisfies(Constraint, Version)).
+     not pkg_fact(Package, version_satisfies(Constraint, Version)).
 
 attr("node_version_satisfies", node(ID, Package), Constraint)
   :- attr("version", node(ID, Package), Version),
-     facts(Package, version_satisfies(Constraint, Version)).
+     pkg_fact(Package, version_satisfies(Constraint, Version)).
 
 #defined version_satisfies/3.
 #defined deprecated_version/2.
@@ -285,8 +285,8 @@ condition_packages(ID, A1) :- condition_requirement(ID, _, A1, _).
 condition_packages(ID, A1) :- condition_requirement(ID, _, A1, _, _).
 condition_packages(ID, A1) :- condition_requirement(ID, _, A1, _, _, _).
 
-trigger_node(ID, node(PackageID, Package), node(PackageID, Package)) :- facts(Package, trigger_id(ID)), attr("node", node(PackageID, Package)).
+trigger_node(ID, node(PackageID, Package), node(PackageID, Package)) :- pkg_fact(Package, trigger_id(ID)), attr("node", node(PackageID, Package)).
-trigger_node(ID, node(PackageID, Package), node(VirtualID, Virtual)) :- facts(Virtual, trigger_id(ID)), provider(node(PackageID, Package), node(VirtualID, Virtual)).
+trigger_node(ID, node(PackageID, Package), node(VirtualID, Virtual)) :- pkg_fact(Virtual, trigger_id(ID)), provider(node(PackageID, Package), node(VirtualID, Virtual)).
 
 condition_nodes(TriggerID, PackageNode, node(X, A1))
   :- condition_packages(TriggerID, A1),
@@ -309,12 +309,12 @@ trigger_condition_holds(ID, RequestorNode) :-
   not cannot_hold(ID, PackageNode).
 
 condition_holds(ConditionID, node(X, Package))
-  :- facts(Package, condition_trigger(ConditionID, TriggerID)),
+  :- pkg_fact(Package, condition_trigger(ConditionID, TriggerID)),
      trigger_condition_holds(TriggerID, node(X, Package)).
 
 trigger_and_effect(Package, TriggerID, EffectID)
-  :- facts(Package, condition_trigger(ID, TriggerID)),
+  :- pkg_fact(Package, condition_trigger(ID, TriggerID)),
-     facts(Package, condition_effect(ID, EffectID)).
+     pkg_fact(Package, condition_effect(ID, EffectID)).
 
 % condition_holds(ID, node(ID, Package)) implies all imposed_constraints, unless do_not_impose(ID, node(ID, Package))
 % is derived. This allows imposed constraints to be canceled in special cases.
@@ -331,8 +331,8 @@ imposed_packages(ID, A1) :- imposed_constraint(ID, _, A1, _, _, _).
 imposed_packages(ID, A1) :- imposed_constraint(ID, "depends_on", _, A1, _).
 
 imposed_nodes(EffectID, node(NodeID, Package), node(X, A1))
-  :- facts(Package, condition_trigger(ID, TriggerID)),
+  :- pkg_fact(Package, condition_trigger(ID, TriggerID)),
-     facts(Package, condition_effect(ID, EffectID)),
+     pkg_fact(Package, condition_effect(ID, EffectID)),
      imposed_packages(EffectID, A1),
      condition_set(node(NodeID, Package), node(X, A1)),
      trigger_node(TriggerID, _, node(NodeID, Package)).
@@ -406,7 +406,7 @@ depends_on(PackageNode, DependencyNode) :- attr("depends_on", PackageNode, Depen
 % concrete specs don't need to be resolved -- they arise from the concrete
 % specs themselves.
 dependency_holds(node(NodeID, Package), Dependency, Type) :-
-  facts(Package, dependency_condition(ID, Dependency)),
+  pkg_fact(Package, dependency_condition(ID, Dependency)),
   dependency_type(ID, Type),
   build(node(NodeID, Package)),
   not external(node(NodeID, Package)),
@@ -417,8 +417,8 @@ dependency_holds(node(NodeID, Package), Dependency, Type) :-
 do_not_impose(EffectID, node(NodeID, Package)) :-
   not dependency_holds(node(NodeID, Package), Dependency, _),
   attr("node", node(NodeID, Package)),
-  facts(Package, dependency_condition(ID, Dependency)),
+  pkg_fact(Package, dependency_condition(ID, Dependency)),
-  facts(Package, condition_effect(ID, EffectID)).
+  pkg_fact(Package, condition_effect(ID, EffectID)).
 
 % If a dependency holds on a package node, there must be one and only one dependency node satisfying it
 1 { attr("depends_on", PackageNode, node(0..Y-1, Dependency), Type) : max_nodes(Dependency, Y) } 1
@@ -441,7 +441,7 @@ error(10, "'{0}' is not a valid dependency for any package in the DAG", Package)
 %-----------------------------------------------------------------------------
 error(1, Msg)
   :- attr("node", node(ID, Package)),
-     facts(Package, conflict(TriggerID, ConstraintID, Msg)),
+     pkg_fact(Package, conflict(TriggerID, ConstraintID, Msg)),
      condition_holds(TriggerID, node(ID, Package)),
      condition_holds(ConstraintID, node(ID, Package)),
      not external(node(ID, Package)),  % ignore conflicts for externals
@@ -499,7 +499,7 @@ attr("root", PackageNode) :- attr("virtual_root", VirtualNode), provider(Package
 % The provider provides the virtual if some provider condition holds.
 virtual_condition_holds(node(ProviderID, Provider), Virtual) :- virtual_condition_holds(ID, node(ProviderID, Provider), Virtual).
 virtual_condition_holds(ID, node(ProviderID, Provider), Virtual) :-
-   facts(Provider, provider_condition(ID, Virtual)),
+   pkg_fact(Provider, provider_condition(ID, Virtual)),
    condition_holds(ID, node(ProviderID, Provider)),
    virtual(Virtual).
 
@@ -530,7 +530,7 @@ possible_provider_weight(DependencyNode, VirtualNode, 0, "external")
 possible_provider_weight(node(DependencyID, Dependency), node(VirtualID, Virtual), Weight, "packages_yaml")
   :- provider(node(DependencyID, Dependency), node(VirtualID, Virtual)),
      depends_on(node(ID, Package), node(DependencyID, Dependency)),
-     facts(Package, provider_preference(Virtual, Dependency, Weight)).
+     pkg_fact(Package, provider_preference(Virtual, Dependency, Weight)).
 
 % A provider mentioned in the default configuration can use a weight
 % according to its priority in the list of providers
@@ -554,7 +554,7 @@ possible_provider_weight(node(DependencyID, Dependency), VirtualNode, 100, "fall
 
 % if a package is external its version must be one of the external versions
 { external_version(node(ID, Package), Version, Weight):
-    facts(Package, version_declared(Version, Weight, "external")) }
+    pkg_fact(Package, version_declared(Version, Weight, "external")) }
     :- external(node(ID, Package)).
 
 error(100, "Attempted to use external for '{0}' which does not satisfy any configured external spec", Package)
@@ -584,7 +584,7 @@ external(PackageNode) :- attr("external_spec_selected", PackageNode, _).
 % corresponding external spec.
 :- attr("version",  node(ID, Package), Version),
    version_weight(node(ID, Package), Weight),
-   facts(Package, version_declared(Version, Weight, "external")),
+   pkg_fact(Package, version_declared(Version, Weight, "external")),
    not external(node(ID, Package)),
    internal_error("External weight used for internal spec").
 
@@ -595,7 +595,7 @@ attr("external_spec_selected", node(ID, Package), LocalIndex) :-
     not attr("hash", node(ID, Package), _).
 
 external_conditions_hold(node(PackageID, Package), LocalIndex) :-
-    facts(Package, possible_external(ID, LocalIndex)), condition_holds(ID, node(PackageID, Package)).
+    pkg_fact(Package, possible_external(ID, LocalIndex)), condition_holds(ID, node(PackageID, Package)).
 
 % it cannot happen that a spec is external, but none of the external specs
 % conditions hold.
@@ -692,11 +692,11 @@ error(10, Message) :-
 % a variant is a variant of a package if it is a variant under some condition
 % and that condition holds
 node_has_variant(node(NodeID, Package), Variant) :-
-  facts(Package, conditional_variant(ID, Variant)),
+  pkg_fact(Package, conditional_variant(ID, Variant)),
   condition_holds(ID, node(NodeID, Package)).
 
 node_has_variant(node(ID, Package), Variant) :-
-  facts(Package, variant(Variant)),
+  pkg_fact(Package, variant(Variant)),
   attr("node", node(ID, Package)).
 
 attr("variant_propagate", PackageNode, Variant, Value, Source) :-
@@ -709,7 +709,7 @@ attr("variant_value", node(ID, Package), Variant, Value) :-
   attr("node", node(ID, Package)),
   node_has_variant(node(ID, Package), Variant),
   attr("variant_propagate", node(ID, Package), Variant, Value, _),
-  facts(Package, variant_possible_value(Variant, Value)).
+  pkg_fact(Package, variant_possible_value(Variant, Value)).
 
 error(100, "{0} and {1} cannot both propagate variant '{2}' to package {3} with values '{4}' and '{5}'", Source1, Source2, Variant, PackageNode, Value1, Value2) :-
   attr("variant_propagate", PackageNode, Variant, Value1, Source1),
@@ -733,14 +733,14 @@ error(100, "Cannot set variant '{0}' for package '{1}' because the variant condi
 attr("variant_value", node(ID, Package), Variant, Value) :-
   node_has_variant(node(ID, Package), Variant),
   not attr("variant_set", node(ID, Package), Variant),
-  facts(Package, variant_sticky(Variant)),
+  pkg_fact(Package, variant_sticky(Variant)),
   variant_default_value(Package, Variant, Value),
   build(node(ID, Package)).
 
 % at most one variant value for single-valued variants.
 {
   attr("variant_value", node(ID, Package), Variant, Value)
-  : facts(Package, variant_possible_value(Variant, Value))
+  : pkg_fact(Package, variant_possible_value(Variant, Value))
 }
  :- attr("node", node(ID, Package)),
     node_has_variant(node(ID, Package), Variant),
@@ -750,7 +750,7 @@ attr("variant_value", node(ID, Package), Variant, Value) :-
 error(100, "'{0}' required multiple values for single-valued variant '{1}'", Package, Variant)
   :- attr("node", node(ID, Package)),
      node_has_variant(node(ID, Package), Variant),
-     facts(Package, variant_single_value(Variant)),
+     pkg_fact(Package, variant_single_value(Variant)),
      build(node(ID, Package)),
      2 { attr("variant_value", node(ID, Package), Variant, Value) }.
 
@@ -768,7 +768,7 @@ attr("variant_set", PackageNode, Variant) :- attr("variant_set", PackageNode, Va
 % have been built w/different variants from older/different package versions.
 error(10, "'Spec({1}={2})' is not a valid value for '{0}' variant '{1}'", Package, Variant, Value)
  :- attr("variant_value", node(ID, Package), Variant, Value),
-    not facts(Package, variant_possible_value(Variant, Value)),
+    not pkg_fact(Package, variant_possible_value(Variant, Value)),
     build(node(ID, Package)).
 
 % Some multi valued variants accept multiple values from disjoint sets.
@@ -777,8 +777,8 @@ error(10, "'Spec({1}={2})' is not a valid value for '{0}' variant '{1}'", Packag
 error(100, "{0} variant '{1}' cannot have values '{2}' and '{3}' as they come from disjoint value sets", Package, Variant, Value1, Value2)
   :- attr("variant_value", node(ID, Package), Variant, Value1),
      attr("variant_value", node(ID, Package), Variant, Value2),
-     facts(Package, variant_value_from_disjoint_sets(Variant, Value1, Set1)),
+     pkg_fact(Package, variant_value_from_disjoint_sets(Variant, Value1, Set1)),
-     facts(Package, variant_value_from_disjoint_sets(Variant, Value2, Set2)),
+     pkg_fact(Package, variant_value_from_disjoint_sets(Variant, Value2, Set2)),
      Set1 < Set2, % see[1]
      build(node(ID, Package)).
 
@@ -817,7 +817,7 @@ variant_default_not_used(node(ID, Package), Variant, Value)
 external_with_variant_set(node(NodeID, Package), Variant, Value)
  :- attr("variant_value", node(NodeID, Package), Variant, Value),
     condition_requirement(ID, "variant_value", Package, Variant, Value),
-    facts(Package, possible_external(ID, _)),
+    pkg_fact(Package, possible_external(ID, _)),
     external(node(NodeID, Package)),
     attr("node", node(NodeID, Package)).
 
@@ -829,7 +829,7 @@ external_with_variant_set(node(NodeID, Package), Variant, Value)
 %    packages.yaml and the command line)
 %
 variant_default_value(Package, Variant, Value)
- :- facts(Package, variant_default_value_from_package_py(Variant, Value)),
+ :- pkg_fact(Package, variant_default_value_from_package_py(Variant, Value)),
     not variant_default_value_from_packages_yaml(Package, Variant, _),
     not attr("variant_default_value_from_cli", node(root_node_id, Package), Variant, _).
 
@@ -857,7 +857,7 @@ auto_variant("patches").
 node_has_variant(PackageNode, Variant)
   :- attr("variant_set", PackageNode, Variant, _), auto_variant(Variant).
 
-facts(Package, variant_single_value("dev_path"))
+pkg_fact(Package, variant_single_value("dev_path"))
   :- attr("variant_set", node(ID, Package), "dev_path", _).
 
 % suppress warnings about this atom being unset.  It's only set if some
@@ -992,7 +992,7 @@ attr("node_target", PackageNode, Target)
 node_target_weight(node(ID, Package), Weight)
  :- attr("node", node(ID, Package)),
     attr("node_target", node(ID, Package), Target),
-    facts(Package, target_weight(Target, Weight)).
+    pkg_fact(Package, target_weight(Target, Weight)).
 
 % compatibility rules for targets among nodes
 node_target_match(ParentNode, DependencyNode)
@@ -1118,18 +1118,18 @@ compiler_weight(node(ID, Package), Weight)
  :- node_compiler(node(ID, Package), CompilerID),
     compiler_name(CompilerID, Compiler),
     compiler_version(CompilerID, V),
-    facts(Package, node_compiler_preference(Compiler, V, Weight)).
+    pkg_fact(Package, node_compiler_preference(Compiler, V, Weight)).
 compiler_weight(node(ID, Package), Weight)
  :- node_compiler(node(ID, Package), CompilerID),
     compiler_name(CompilerID, Compiler),
     compiler_version(CompilerID, V),
-    not facts(Package, node_compiler_preference(Compiler, V, _)),
+    not pkg_fact(Package, node_compiler_preference(Compiler, V, _)),
     default_compiler_preference(CompilerID, Weight).
 compiler_weight(node(ID, Package), 100)
  :- node_compiler(node(ID, Package), CompilerID),
     compiler_name(CompilerID, Compiler),
     compiler_version(CompilerID, V),
-    not facts(Package, node_compiler_preference(Compiler, V, _)),
+    not pkg_fact(Package, node_compiler_preference(Compiler, V, _)),
     not default_compiler_preference(CompilerID, _).
 
 % For the time being, be strict and reuse only if the compiler match one we have on the system
@@ -1267,7 +1267,7 @@ build_priority(PackageNode, 0)   :- not build(PackageNode), attr("node", Package
 % build deps in the solve, consider using them as a preference to resolve this.
 :- attr("version", node(ID, Package), Version),
    version_weight(node(ID, Package), Weight),
-   facts(Package, version_declared(Version, Weight, "installed")),
+   pkg_fact(Package, version_declared(Version, Weight, "installed")),
    not optimize_for_reuse().
 
 #defined installed_hash/2.

lib/spack/spack/solver/heuristic.lp

@@ -12,10 +12,10 @@
 #heuristic attr("node", node(0, Package)) : literal(_, "node", Package). [45, true]
 
 % Root node
-#heuristic attr("version", node(0, Package), Version) : facts(Package, version_declared(Version, 0)), attr("root", node(0, Package)). [35, true]
+#heuristic attr("version", node(0, Package), Version) : pkg_fact(Package, version_declared(Version, 0)), attr("root", node(0, Package)). [35, true]
-#heuristic version_weight(node(0, Package), 0) : facts(Package, version_declared(Version, 0)), attr("root", node(0, Package)). [35, true]
+#heuristic version_weight(node(0, Package), 0) : pkg_fact(Package, version_declared(Version, 0)), attr("root", node(0, Package)). [35, true]
 #heuristic attr("variant_value", node(0, Package), Variant, Value) : variant_default_value(Package, Variant, Value), attr("root", node(0, Package)). [35, true]
-#heuristic attr("node_target", node(0, Package), Target) : facts(Package, target_weight(Target, 0)), attr("root", node(0, Package)). [35, true]
+#heuristic attr("node_target", node(0, Package), Target) : pkg_fact(Package, target_weight(Target, 0)), attr("root", node(0, Package)). [35, true]
 #heuristic node_target_weight(node(0, Package), 0) : attr("root", node(0, Package)). [35, true]
 #heuristic node_compiler(node(0, Package), CompilerID) : default_compiler_preference(ID, 0), compiler_id(ID), attr("root", node(0, Package)). [35, true]
 
@@ -25,17 +25,17 @@
 %#heuristic provider_weight(node(0, Package), node(0, Virtual), 0) : default_provider_preference(Virtual, Package, 0), possible_in_link_run(Package). [30, true]
 
 % node(ID, _)
-#heuristic attr("version", node(ID, Package), Version) : facts(Package, version_declared(Version, ID)), attr("node", node(ID, Package)). [25-5*ID, true]
+#heuristic attr("version", node(ID, Package), Version) : pkg_fact(Package, version_declared(Version, ID)), attr("node", node(ID, Package)). [25-5*ID, true]
-#heuristic version_weight(node(ID, Package), ID) : facts(Package, version_declared(Version, ID)), attr("node", node(ID, Package)). [25-5*ID, true]
+#heuristic version_weight(node(ID, Package), ID) : pkg_fact(Package, version_declared(Version, ID)), attr("node", node(ID, Package)). [25-5*ID, true]
 #heuristic attr("variant_value", node(ID, Package), Variant, Value) : variant_default_value(Package, Variant, Value), attr("node", node(ID, Package)). [25-5*ID, true]
-#heuristic attr("node_target", node(ID, Package), Target) : facts(Package, target_weight(Target, ID)), attr("node", node(ID, Package)). [25-5*ID, true]
+#heuristic attr("node_target", node(ID, Package), Target) : pkg_fact(Package, target_weight(Target, ID)), attr("node", node(ID, Package)). [25-5*ID, true]
 #heuristic node_target_weight(node(ID, Package), ID) : attr("node", node(ID, Package)). [25-5*ID, true]
 #heuristic node_compiler(node(ID, Package), CompilerID) : default_compiler_preference(ID, ID), compiler_id(ID), attr("node", node(ID, Package)). [25-5*ID, true]
 
 % node(ID, _), split build dependencies
-#heuristic attr("version", node(ID, Package), Version) : facts(Package, version_declared(Version, ID)), attr("node", node(ID, Package)), multiple_unification_sets(Package). [25, true]
+#heuristic attr("version", node(ID, Package), Version) : pkg_fact(Package, version_declared(Version, ID)), attr("node", node(ID, Package)), multiple_unification_sets(Package). [25, true]
-#heuristic version_weight(node(ID, Package), ID) : facts(Package, version_declared(Version, ID)), attr("node", node(ID, Package)), multiple_unification_sets(Package). [25, true]
+#heuristic version_weight(node(ID, Package), ID) : pkg_fact(Package, version_declared(Version, ID)), attr("node", node(ID, Package)), multiple_unification_sets(Package). [25, true]
 #heuristic attr("variant_value", node(ID, Package), Variant, Value) : variant_default_value(Package, Variant, Value), attr("node", node(ID, Package)), multiple_unification_sets(Package). [25, true]
-#heuristic attr("node_target", node(ID, Package), Target) : facts(Package, target_weight(Target, ID)), attr("node", node(ID, Package)), multiple_unification_sets(Package). [25, true]
+#heuristic attr("node_target", node(ID, Package), Target) : pkg_fact(Package, target_weight(Target, ID)), attr("node", node(ID, Package)), multiple_unification_sets(Package). [25, true]
 #heuristic node_target_weight(node(ID, Package), ID) : attr("node", node(ID, Package)), multiple_unification_sets(Package). [25, true]
 #heuristic node_compiler(node(ID, Package), CompilerID) : default_compiler_preference(ID, ID), compiler_id(ID), attr("node", node(ID, Package)), multiple_unification_sets(Package). [25, true]