New graph resolution detects build_requires transitive conflicts

conans/client/graph/graph.py

@@ -1,5 +1,3 @@
-from collections import OrderedDict
-
 from conans.model.ref import PackageReference
 
 RECIPE_DOWNLOADED = "Downloaded"
@@ -25,7 +23,7 @@
 class Node(object):
     def __init__(self, ref, conanfile, recipe=None):
         self.ref = ref
-        self.package_id = None
+        self._package_id = None
         self.prev = None
         self.conanfile = conanfile
         self.dependencies = []  # Ordered Edges
@@ -36,12 +34,31 @@ def __init__(self, ref, conanfile, recipe=None):
         self.binary_remote = None
         self.build_require = False
         self.revision_pinned = False  # The revision has been specified by the user
+        # all the public deps to which this node belongs
+        self.public_deps = None  # {ref.name: Node}
+        # all the public deps only in the closure of this node
+        self.public_closure = None  # {ref.name: Node}
+        self.ancestors = None  # set{ref.name}
+
+    @property
+    def package_id(self):
+        return self._package_id
+
+    @package_id.setter
+    def package_id(self, pkg_id):
+        assert self._package_id is None, "Trying to override an existing package_id"
+        self._package_id = pkg_id
+
+    @property
+    def name(self):
+        return self.ref.name if self.ref else None
 
     @property
     def pref(self):
         return PackageReference(self.ref, self.package_id, self.prev)
 
     def partial_copy(self):
+        # Used for collapse_graph
         result = Node(self.ref, self.conanfile)
         result.dependants = set()
         result.dependencies = []
@@ -62,12 +79,8 @@ def add_edge(self, edge):
     def neighbors(self):
         return [edge.dst for edge in self.dependencies]
 
-    def public_neighbors(self):
-        return [edge.dst for edge in self.dependencies
-                if not edge.private and not edge.build_require]
-
     def private_neighbors(self):
-        return [edge.dst for edge in self.dependencies if edge.private or edge.build_require]
+        return [edge.dst for edge in self.dependencies if edge.private]
 
     def inverse_neighbors(self):
         return [edge.src for edge in self.dependants]
@@ -146,18 +159,9 @@ class DepsGraph(object):
     def __init__(self):
         self.nodes = set()
         self.root = None
-
-    def add_graph(self, node, graph, build_require=False):
-        for n in graph.nodes:
-            if n != graph.root:
-                n.build_require = build_require
-                self.add_node(n)
-
-        for e in graph.root.dependencies:
-            e.src = node
-            e.build_require = build_require
-
-        node.dependencies = graph.root.dependencies + node.dependencies
+        self.aliased = {}
+        # These are the nodes with pref (not including PREV) that have been evaluated
+        self.evaluated = {}  # {pref: [nodes]}
 
     def add_node(self, node):
         if not self.nodes:
@@ -176,37 +180,6 @@ def ordered_iterate(self):
             for node in level:
                 yield node
 
-    def full_closure(self, node, private=False):
-        # Needed to propagate correctly the cpp_info even with privates
-        closure = OrderedDict()
-        current = node.neighbors()
-        while current:
-            new_current = []
-            for n in current:
-                closure[n] = n
-            for n in current:
-                neighbors = n.public_neighbors() if not private else n.neighbors()
-                for neigh in neighbors:
-                    if neigh not in new_current and neigh not in closure:
-                        new_current.append(neigh)
-            current = new_current
-        return closure
-
-    def closure(self, node):
-        closure = OrderedDict()
-        current = node.neighbors()
-        while current:
-            new_current = []
-            for n in current:
-                closure[n.ref.name] = n
-            for n in current:
-                neighs = n.public_neighbors()
-                for neigh in neighs:
-                    if neigh not in new_current and neigh.ref.name not in closure:
-                        new_current.append(neigh)
-            current = new_current
-        return closure
-
     def _inverse_closure(self, references):
         closure = set()
         current = [n for n in self.nodes if str(n.ref) in references or "ALL" in references]

conans/client/graph/graph_binaries.py

@@ -38,22 +38,27 @@ def _evaluate_node(self, node, build_mode, update, evaluated_nodes, remote_name)
         pref = PackageReference(ref, node.package_id)
 
         # Check that this same reference hasn't already been checked
-        previous_node = evaluated_nodes.get(pref)
-        if previous_node:
+        previous_nodes = evaluated_nodes.get(pref)
+        if previous_nodes:
+            previous_nodes.append(node)
+            previous_node = previous_nodes[0]
             node.binary = previous_node.binary
             node.binary_remote = previous_node.binary_remote
+            node.prev = previous_node.prev
             return
-        evaluated_nodes[pref] = node
+        evaluated_nodes[pref] = [node]
 
         output = conanfile.output
 
         if node.recipe == RECIPE_EDITABLE:
             node.binary = BINARY_EDITABLE
+            # TODO: PREV?
             return
 
         if build_mode.forced(conanfile, ref):
             output.warn('Forced build from source')
             node.binary = BINARY_BUILD
+            node.prev = None
             return
 
         package_folder = self._cache.package(pref, short_paths=conanfile.short_paths)
@@ -105,6 +110,8 @@ def _evaluate_node(self, node, build_mode, update, evaluated_nodes, remote_name)
                     output.warn("Can't update, no remote defined")
             if not node.binary:
                 node.binary = BINARY_CACHE
+                metadata = self._cache.package_layout(pref.ref).load_metadata()
+                node.prev = metadata.packages[pref.id].revision
                 package_hash = ConanInfo.load_from_package(package_folder).recipe_hash
 
         else:  # Binary does NOT exist locally
@@ -138,13 +145,15 @@ def _evaluate_node(self, node, build_mode, update, evaluated_nodes, remote_name)
                     node.binary = BINARY_BUILD
                 else:
                     node.binary = BINARY_MISSING
+                node.prev = None
 
         if build_mode.outdated:
             if node.binary in (BINARY_CACHE, BINARY_DOWNLOAD, BINARY_UPDATE):
                 local_recipe_hash = self._cache.package_layout(ref).recipe_manifest().summary_hash
                 if local_recipe_hash != package_hash:
                     output.info("Outdated package!")
                     node.binary = BINARY_BUILD
+                    node.prev = None
                 else:
                     output.info("Package is up to date")
 
@@ -158,8 +167,7 @@ def _compute_package_id(node):
         indirect_reqs = set()   # of PackageReference, avoid duplicates
         for neighbor in neighbors:
             ref, nconan = neighbor.ref, neighbor.conanfile
-            pref = PackageReference(ref, neighbor.package_id)
-            direct_reqs.append(pref)
+            direct_reqs.append(neighbor.pref)
             indirect_reqs.update(nconan.info.requires.refs())
             conanfile.options.propagate_downstream(ref, nconan.info.full_options)
             # Might be never used, but update original requirement, just in case
@@ -171,6 +179,7 @@ def _compute_package_id(node):
         # for build-requires
         conanfile.build_requires_options = conanfile.options.values
         conanfile.options.clear_unused(indirect_reqs.union(direct_reqs))
+        conanfile.options.freeze()
 
         conanfile.info = ConanInfo.create(conanfile.settings.values,
                                           conanfile.options.values,
@@ -181,24 +190,23 @@ def _compute_package_id(node):
         with conanfile_exception_formatter(str(conanfile), "package_id"):
             conanfile.package_id()
 
-        info = node.conanfile.info
+        info = conanfile.info
         node.package_id = info.package_id()
 
-    def _handle_private(self, node, deps_graph):
-        private_neighbours = node.private_neighbors()
-        if private_neighbours:
-            if node.binary in (BINARY_CACHE, BINARY_DOWNLOAD, BINARY_UPDATE):
-                for neigh in private_neighbours:
-                    neigh.binary = BINARY_SKIP
-                    closure = deps_graph.full_closure(neigh, private=True)
-                    for n in closure:
-                        n.binary = BINARY_SKIP
+    def _handle_private(self, node):
+        if node.binary in (BINARY_CACHE, BINARY_DOWNLOAD, BINARY_UPDATE, BINARY_SKIP):
+            private_neighbours = node.private_neighbors()
+            for neigh in private_neighbours:
+                # Current closure contains own node to be skipped
+                for n in neigh.public_closure.values():
+                    n.binary = BINARY_SKIP
+                    self._handle_private(n)
 
     def evaluate_graph(self, deps_graph, build_mode, update, remote_name):
-        evaluated_nodes = {}
+        evaluated = deps_graph.evaluated
         for node in deps_graph.ordered_iterate():
             self._compute_package_id(node)
             if node.recipe in (RECIPE_CONSUMER, RECIPE_VIRTUAL):
                 continue
-            self._evaluate_node(node, build_mode, update, evaluated_nodes, remote_name)
-            self._handle_private(node, deps_graph)
+            self._evaluate_node(node, build_mode, update, evaluated, remote_name)
+            self._handle_private(node)