refactor: merge PyVirtualInfo into PyInfo

Author: jbedard

py/private/BUILD.bazel

@@ -49,6 +49,7 @@ bzl_library(
     deps = [
         ":py_info",
         "@bazel_lib//lib:transitions",
+        "@rules_python//python:defs_bzl",
         "@tar.bzl//tar:mtree",
         "@tar.bzl//tar:tar",
     ],
@@ -60,6 +61,7 @@ bzl_library(
     deps = [
         ":py_info",
         "@bazel_skylib//lib:paths",
+        "@rules_python//python:defs_bzl",
     ],
 )
 
@@ -124,13 +126,13 @@ bzl_library(
     ],
 )
 
+# keep
 bzl_library(
     name = "py_info",
     srcs = ["py_info.bzl"],
     # PyInfo is re-exported as public API from //py:defs.bzl, so its bzl_library
     # is public too, allowing sibling trees (e.g. //uv) to depend on it.
     visibility = ["//visibility:public"],
-    deps = ["@rules_python//python:defs_bzl"],
 )
 
 bzl_library(

py/private/providers.bzl

@@ -144,11 +144,3 @@ def make_wheel_record(
         metadata_top_levels = tuple(metadata_top_levels),
         cs_claims = tuple(cs_claims),
     )
-
-PyVirtualInfo = provider(
-    doc = "FIXME",
-    fields = {
-        "dependencies": "Depset of required virtual dependencies, independent of their resolution status",
-        "resolutions": "FIXME",
-    },
-)

py/private/pth.bzl

@@ -1,6 +1,9 @@
 """Helper functions for building imports depsets."""
 
 load("@bazel_skylib//lib:paths.bzl", "paths")
+
+# API edge: deps may expose rules_py's PyInfo or native `@rules_python`'s.
+load("@rules_python//python:defs.bzl", RulesPythonPyInfo = "PyInfo")
 load("//py/private:py_info.bzl", "PyInfo")
 
 def _make_import_path(label, workspace, imp):
@@ -72,11 +75,16 @@ def make_imports_depset(deps, imports, workspace_name, label = None, extra_impor
     if label and label.workspace_name:
         import_paths.append(label.workspace_name)
 
+    # `deps` come from py_library/py_binary/py_test, whose deps attribute accepts
+    # both rules_py (PyInfo) and native @rules_python (RulesPythonPyInfo) targets;
+    # both expose `imports`.
+    transitive = [
+        (target[PyInfo] if PyInfo in target else target[RulesPythonPyInfo]).imports
+        for target in deps
+        if PyInfo in target or RulesPythonPyInfo in target
+    ]
+
     return depset(
         direct = import_paths,
-        transitive = [
-            target[PyInfo].imports
-            for target in deps
-            if PyInfo in target
-        ] + extra_imports_depsets,
+        transitive = transitive + extra_imports_depsets,
     )

py/private/py_image_layer.bzl

@@ -32,6 +32,7 @@ Sharing model:
   - Ungrouped pip packages: squashed by the rule into one per-rule tar.
 """
 
+load("@rules_python//python:defs.bzl", RulesPythonPyInfo = "PyInfo")
 load("//py/private:providers.bzl", "PyWheelsInfo")
 load("//py/private:py_info.bzl", "PyInfo")
 load("//py/private/toolchain:types.bzl", "PY_TOOLCHAIN")
@@ -373,6 +374,10 @@ def _layer_aspect_impl(target, ctx):
     interpreter_layer = None
     interpreter_files = None
     kind = ctx.rule.kind
+
+    # The binary being layered must be a rules_py py_binary (it carries rules_py's
+    # PyInfo); rules_python's py_binary is not supported. rules_python *library*
+    # deps within the graph are still handled by the membership checks below.
     is_binary = (
         PyInfo in target and
         target[DefaultInfo].files_to_run.executable != None
@@ -394,14 +399,14 @@ def _layer_aspect_impl(target, ctx):
 
     # Skip PyInfo deps (including wheel-leaf targets, which also emit PyInfo) —
     # they self-capture via the aspect.
-    if kind not in _PY_VENV_KINDS and PyInfo in target and not is_binary:
+    if kind not in _PY_VENV_KINDS and (PyInfo in target or RulesPythonPyInfo in target) and not is_binary:
         own_parts = [target[DefaultInfo].files]
         for attr_name in ("data", "deps"):
             attr_val = getattr(ctx.rule.attr, attr_name, None)
             if not attr_val:
                 continue
             for dep in attr_val:
-                if PyInfo in dep:
+                if PyInfo in dep or RulesPythonPyInfo in dep:
                     continue
                 if DefaultInfo in dep:
                     own_parts.append(dep[DefaultInfo].files)

py/private/py_info.bzl

@@ -1,17 +1,26 @@
 """The `PyInfo` provider produced and consumed by rules_py targets.
 
-`PyInfo` carries the two pieces of information rules_py needs to assemble a
-target's dependency closure: the transitive set of first-party Python sources,
-and the import roots to place on `sys.path`. Targets in a dependency graph
-aggregate these fields from their deps to build the eventual venv or wheel.
+`PyInfo` carries the information rules_py needs to assemble a target's dependency
+closure: the transitive set of first-party Python sources, the import roots to
+place on `sys.path`, and the virtual-dependency declarations and their
+resolutions. Targets in a dependency graph aggregate these fields from their
+deps to build the eventual venv or wheel.
 
 Defined here in one module and re-exported from `//py:defs.bzl` as public API.
+
+rules_py can *consume* deps built by `@rules_python` (e.g. a `py_proto_library`),
+which expose `@rules_python`'s `PyInfo` rather than this one. Rules that ingest
+`deps` handle that at the API edge by also reading `@rules_python`'s `PyInfo`.
+(The reverse — a `@rules_python` rule consuming a rules_py target — is not
+supported: rules_py does not emit `@rules_python`'s `PyInfo`.)
 """
 
 PyInfo = provider(
-    doc = "Python source and import-path information for a target's dependency closure.",
+    doc = "Python source, import-path, and virtual-dependency information for a target's dependency closure.",
     fields = {
         "transitive_sources": "depset[File] — postorder depset of first-party `.py` sources in the transitive closure.",
         "imports": "depset[str] — import roots to place on `sys.path` (rlocation-root-relative).",
+        "virtual_dependencies": "depset[str] — names of required virtual dependencies, independent of their resolution status.",
+        "virtual_resolutions": "depset[struct(virtual, target)] — virtual-dependency-name to concrete-target resolutions.",
     },
 )

py/private/py_library.bzl

@@ -7,11 +7,12 @@ without binding them to a particular version of that package.
 load("@bazel_skylib//lib:new_sets.bzl", "sets")
 load("@rules_cc//cc/common:cc_info.bzl", "CcInfo")
 
-# rules_python's PyInfo, referenced ONLY in the `deps` provider constraint so
-# native `@rules_python` targets are still accepted as deps. rules_py emits and
-# reads its own PyInfo (py_info.bzl).
+# rules_python's PyInfo, referenced in the `deps` provider constraint so native
+# `@rules_python` targets (e.g. py_proto_library) are accepted as deps. rules_py
+# emits its own PyInfo; it reads a dep's sources/imports from either provider via
+# the accessors below.
 load("@rules_python//python:defs.bzl", RulesPythonPyInfo = "PyInfo")
-load("//py/private:providers.bzl", "PyVirtualInfo", "PyWheelsInfo")
+load("//py/private:providers.bzl", "PyWheelsInfo")
 load("//py/private:pth.bzl", "make_imports_depset")
 load("//py/private:py_info.bzl", "PyInfo")
 
@@ -24,13 +25,15 @@ def _make_instrumented_files_info(ctx):
     )
 
 def _make_srcs_depset(ctx):
+    # `deps` accepts rules_py targets (PyInfo) and native @rules_python targets
+    # (RulesPythonPyInfo); both expose `transitive_sources`.
     return depset(
         order = "postorder",
         direct = ctx.files.srcs,
         transitive = [
-            target[PyInfo].transitive_sources
+            (target[PyInfo] if PyInfo in target else target[RulesPythonPyInfo]).transitive_sources
             for target in ctx.attr.deps
-            if PyInfo in target
+            if PyInfo in target or RulesPythonPyInfo in target
         ],
     )
 
@@ -39,16 +42,17 @@ def _make_virtual_depset(ctx):
         order = "postorder",
         direct = getattr(ctx.attr, "virtual_deps", []),
         transitive = [
-            target[PyVirtualInfo].dependencies
+            target[PyInfo].virtual_dependencies
             for target in ctx.attr.deps
-            if PyVirtualInfo in target
+            if PyInfo in target
         ],
     )
 
 def _make_resolved_virtual_depset(target):
     transitive = [target[DefaultInfo].files]
-    if PyInfo in target:
-        transitive.append(target[PyInfo].transitive_sources)
+    if PyInfo in target or RulesPythonPyInfo in target:
+        info = target[PyInfo] if PyInfo in target else target[RulesPythonPyInfo]
+        transitive.append(info.transitive_sources)
 
     return depset(
         order = "postorder",
@@ -63,9 +67,9 @@ def _make_virtual_resolutions_depset(ctx):
             for k, v in ctx.attr.resolutions.items()
         ],
         transitive = [
-            target[PyVirtualInfo].resolutions
+            target[PyInfo].virtual_resolutions
             for target in ctx.attr.deps
-            if PyVirtualInfo in target
+            if PyInfo in target
         ],
     )
 
@@ -89,8 +93,9 @@ def _resolve_virtuals(ctx):
         v_srcs.append(_make_resolved_virtual_depset(resolution.target))
         v_runfiles.append(resolution.target[DefaultInfo].default_runfiles.files)
 
-        if PyInfo in resolution.target:
-            v_imports.append(resolution.target[PyInfo].imports)
+        if PyInfo in resolution.target or RulesPythonPyInfo in resolution.target:
+            info = resolution.target[PyInfo] if PyInfo in resolution.target else resolution.target[RulesPythonPyInfo]
+            v_imports.append(info.imports)
 
     missing = sets.to_list(sets.difference(sets.make(virtual), sets.make(seen.keys())))
     if len(missing) > 0:
@@ -166,10 +171,8 @@ def _py_library_impl(ctx):
         PyInfo(
             imports = imports,
             transitive_sources = transitive_srcs,
-        ),
-        PyVirtualInfo(
-            dependencies = virtuals,
-            resolutions = resolutions,
+            virtual_dependencies = virtuals,
+            virtual_resolutions = resolutions,
         ),
         PyWheelsInfo(
             wheels = wheels,
@@ -184,7 +187,12 @@ _attrs = dict({
     ),
     "deps": attr.label_list(
         doc = "Targets that produce Python code, commonly `py_library` rules.",
-        providers = [[PyInfo], [RulesPythonPyInfo], [PyVirtualInfo], [CcInfo]],
+        # This attribute — shared by py_library, py_binary and py_test — is the
+        # public surface that supports rules_python interop: a dep may carry
+        # rules_py's PyInfo, or native @rules_python's PyInfo (e.g. a
+        # py_proto_library). RulesPythonPyInfo appears here and at the reads in
+        # this file for exactly that reason; rules_py never emits it.
+        providers = [[PyInfo], [RulesPythonPyInfo], [CcInfo]],
     ),
     "data": attr.label_list(
         doc = """Runtime dependencies of the program.

py/private/py_unpacked_wheel.bzl

@@ -73,6 +73,8 @@ def _py_unpacked_wheel_impl(ctx):
         PyInfo(
             imports = imports,
             transitive_sources = depset([unpack_directory]),
+            virtual_dependencies = depset(),
+            virtual_resolutions = depset(),
         ),
     ]
 

py/private/py_venv/py_venv_exec.bzl

@@ -135,6 +135,8 @@ def _py_venv_exec_impl(ctx):
             # sibling venv, not on this rule.
             imports = vinfo.imports,
             transitive_sources = vinfo.transitive_sources,
+            virtual_dependencies = depset(),
+            virtual_resolutions = depset(),
         ),
         instrumented_files_info,
         RunEnvironmentInfo(

py/tests/py_venv_conflict/collision_order_test.bzl

@@ -67,6 +67,8 @@ printf 'VALUE = "namespace"\n' > "$site/mixed_top/from_namespace.py"
         PyInfo(
             imports = depset([site_packages]),
             transitive_sources = depset([install_tree]),
+            virtual_dependencies = depset(),
+            virtual_resolutions = depset(),
         ),
         PyWheelsInfo(wheels = depset([wheel])),
     ]
@@ -191,6 +193,8 @@ printf 'native' > "$site/collision_order/native_extension.so"
         PyInfo(
             imports = depset([site_packages]),
             transitive_sources = depset([install_tree]),
+            virtual_dependencies = depset(),
+            virtual_resolutions = depset(),
         ),
         PyWheelsInfo(wheels = depset([wheel])),
     ]

py/tests/py_venv_conflict/site_merge_order_test.bzl

@@ -122,6 +122,8 @@ printf 'VALUE = %s\n' "$4" > "$site/other/from_final.py"
         PyInfo(
             imports = depset(site_packages_paths),
             transitive_sources = depset(install_trees),
+            virtual_dependencies = depset(),
+            virtual_resolutions = depset(),
         ),
         PyWheelsInfo(wheels = depset(direct = wheels, order = "postorder")),
     ]
@@ -229,9 +231,8 @@ printf 'VALUE = %s\n' "$4" > "$site/mixed/sibling.py"
         PyInfo(
             imports = depset(site_packages_paths),
             transitive_sources = depset(install_trees),
-            has_py2_only_sources = False,
-            has_py3_only_sources = True,
-            uses_shared_libraries = False,
+            virtual_dependencies = depset(),
+            virtual_resolutions = depset(),
         ),
         PyWheelsInfo(wheels = depset(direct = wheels, order = "postorder")),
     ]