chore: support removal of builtin providers (bazel-contrib#2274)

The builtin providers PyInfo, PyRuntimeInfo, and PyCcLinkParamsProvider
are being removed,
which means Bazel throws an error while compiling bzl files if there is
a reference to a
top-level symbol that doesn't exist anymore. For backwards
compatibility, rules_python
consumes/produces these providers, so the symbols are used in various
places.

To fix, use `native.legacy_globals` and Bazel version detection to
conditionally emit
the symbols into `@rules_python_internal`. If they aren't present, they
are reported
as None.

This mimics equivalent functionality in bazel_features; bazel_features
isn't used because
it would require users to update their WORKSPACE to initialize some
dependencies before
rules_python can perform its initialization.

Removal of the builtin symbols is controlled by
`--incompatible_autoload_externally`
(which is in Bazel 8 and has been cherry-picked into earlier version).
If the flag is
enabled with "@rules_python" or "-@rules_python" the providers are
removed from Bazel.

---------

Co-authored-by: Richard Levasseur <[email protected]>

Author: comius

python/config_settings/transition.bzl

@@ -101,12 +101,12 @@ def _transition_py_impl(ctx):
     ]
     if PyInfo in target:
         providers.append(target[PyInfo])
-    if BuiltinPyInfo in target and PyInfo != BuiltinPyInfo:
+    if BuiltinPyInfo != None and BuiltinPyInfo in target and PyInfo != BuiltinPyInfo:
         providers.append(target[BuiltinPyInfo])
 
     if PyRuntimeInfo in target:
         providers.append(target[PyRuntimeInfo])
-    if BuiltinPyRuntimeInfo in target and PyRuntimeInfo != BuiltinPyRuntimeInfo:
+    if BuiltinPyRuntimeInfo != None and BuiltinPyRuntimeInfo in target and PyRuntimeInfo != BuiltinPyRuntimeInfo:
         providers.append(target[BuiltinPyRuntimeInfo])
     return providers
 

python/private/BUILD.bazel

@@ -344,7 +344,10 @@ bzl_library(
     visibility = [
         "//:__subpackages__",
     ],
-    deps = [":bazel_tools_bzl"],
+    deps = [
+        ":bazel_tools_bzl",
+        "@rules_python_internal//:rules_python_config_bzl",
+    ],
 )
 
 bzl_library(

python/private/common/attributes.bzl

@@ -253,15 +253,16 @@ COMMON_ATTRS = union_attrs(
     allow_none = True,
 )
 
+_MaybeBuiltinPyInfo = [[BuiltinPyInfo]] if BuiltinPyInfo != None else []
+
 # Attributes common to rules accepting Python sources and deps.
 PY_SRCS_ATTRS = union_attrs(
     {
         "deps": attr.label_list(
             providers = [
                 [PyInfo],
                 [CcInfo],
-                [BuiltinPyInfo],
-            ],
+            ] + _MaybeBuiltinPyInfo,
             # TODO(b/228692666): Google-specific; remove these allowances once
             # the depot is cleaned up.
             allow_rules = DEPS_ATTR_ALLOW_RULES,

python/private/common/common.bzl

@@ -280,7 +280,7 @@ def collect_imports(ctx, semantics):
         dep[BuiltinPyInfo].imports
         for dep in ctx.attr.deps
         if BuiltinPyInfo in dep
-    ])
+    ] if BuiltinPyInfo != None else [])
 
 def collect_runfiles(ctx, files = depset()):
     """Collects the necessary files from the rule's context.
@@ -374,7 +374,7 @@ def create_py_info(ctx, *, direct_sources, direct_pyc_files, imports):
 
     for target in ctx.attr.deps:
         # PyInfo may not be present e.g. cc_library rules.
-        if PyInfo in target or BuiltinPyInfo in target:
+        if PyInfo in target or (BuiltinPyInfo != None and BuiltinPyInfo in target):
             py_info.merge(_get_py_info(target))
         else:
             # TODO(b/228692666): Remove this once non-PyInfo targets are no
@@ -395,7 +395,7 @@ def create_py_info(ctx, *, direct_sources, direct_pyc_files, imports):
         for target in ctx.attr.data:
             # TODO(b/234730058): Remove checking for PyInfo in data once depot
             # cleaned up.
-            if PyInfo in target or BuiltinPyInfo in target:
+            if PyInfo in target or (BuiltinPyInfo != None and BuiltinPyInfo in target):
                 info = _get_py_info(target)
                 py_info.merge_uses_shared_libraries(info.uses_shared_libraries)
             else:
@@ -410,7 +410,7 @@ def create_py_info(ctx, *, direct_sources, direct_pyc_files, imports):
     return py_info.build(), deps_transitive_sources, py_info.build_builtin_py_info()
 
 def _get_py_info(target):
-    return target[PyInfo] if PyInfo in target else target[BuiltinPyInfo]
+    return target[PyInfo] if PyInfo in target or BuiltinPyInfo == None else target[BuiltinPyInfo]
 
 def create_instrumented_files_info(ctx):
     return _coverage_common.instrumented_files_info(

python/private/common/py_executable.bzl

@@ -855,7 +855,7 @@ def _create_providers(
         # builtin py_runtime rule or defined their own. We can't directly detect
         # the type of the provider object, but the rules_python PyRuntimeInfo
         # object has an extra attribute that the builtin one doesn't.
-        if hasattr(py_runtime_info, "interpreter_version_info"):
+        if hasattr(py_runtime_info, "interpreter_version_info") and BuiltinPyRuntimeInfo != None:
             providers.append(BuiltinPyRuntimeInfo(
                 interpreter_path = py_runtime_info.interpreter_path,
                 interpreter = py_runtime_info.interpreter,
@@ -890,7 +890,8 @@ def _create_providers(
         )
 
     providers.append(py_info)
-    providers.append(builtin_py_info)
+    if builtin_py_info:
+        providers.append(builtin_py_info)
     providers.append(create_output_group_info(py_info.transitive_sources, output_groups))
 
     extra_providers = semantics.get_extra_providers(

python/private/common/py_library.bzl

@@ -98,14 +98,16 @@ def py_library_impl(ctx, *, semantics):
             dependency_transitive_python_sources = deps_transitive_sources,
         )
 
-    return [
+    providers = [
         DefaultInfo(files = default_outputs, runfiles = runfiles),
         py_info,
-        builtins_py_info,
         create_instrumented_files_info(ctx),
         PyCcLinkParamsProvider(cc_info = cc_info),
         create_output_group_info(py_info.transitive_sources, extra_groups = {}),
     ]
+    if builtins_py_info:
+        providers.append(builtins_py_info)
+    return providers
 
 _DEFAULT_PY_LIBRARY_DOC = """
 A library of Python code that can be depended upon.

python/private/common/py_runtime_rule.bzl

@@ -125,18 +125,20 @@ def _py_runtime_impl(ctx):
     if not IS_BAZEL_7_OR_HIGHER:
         builtin_py_runtime_info_kwargs.pop("bootstrap_template")
 
-    return [
+    providers = [
         PyRuntimeInfo(**py_runtime_info_kwargs),
-        # Return the builtin provider for better compatibility.
-        # 1. There is a legacy code path in py_binary that
-        #    checks for the provider when toolchains aren't used
-        # 2. It makes it easier to transition from builtins to rules_python
-        BuiltinPyRuntimeInfo(**builtin_py_runtime_info_kwargs),
         DefaultInfo(
             files = runtime_files,
             runfiles = runfiles,
         ),
     ]
+    if BuiltinPyRuntimeInfo != None and BuiltinPyRuntimeInfo != PyRuntimeInfo:
+        # Return the builtin provider for better compatibility.
+        # 1. There is a legacy code path in py_binary that
+        #    checks for the provider when toolchains aren't used
+        # 2. It makes it easier to transition from builtins to rules_python
+        providers.append(BuiltinPyRuntimeInfo(**builtin_py_runtime_info_kwargs))
+    return providers
 
 # Bind to the name "py_runtime" to preserve the kind/rule_class it shows up
 # as elsewhere.

python/private/internal_config_repo.bzl

@@ -24,6 +24,9 @@ _ENABLE_PYSTAR_DEFAULT = "1"
 _CONFIG_TEMPLATE = """\
 config = struct(
   enable_pystar = {enable_pystar},
+  BuiltinPyInfo = getattr(getattr(native, "legacy_globals", None), "PyInfo", {builtin_py_info_symbol}),
+  BuiltinPyRuntimeInfo = getattr(getattr(native, "legacy_globals", None), "PyRuntimeInfo", {builtin_py_runtime_info_symbol}),
+  BuiltinPyCcLinkParamsProvider = getattr(getattr(native, "legacy_globals", None), "PyCcLinkParamsProvider", {builtin_py_cc_link_params_provider}),
 )
 """
 
@@ -65,8 +68,20 @@ def _internal_config_repo_impl(rctx):
     else:
         enable_pystar = False
 
+    if native.bazel_version.startswith("8."):
+        builtin_py_info_symbol = "None"
+        builtin_py_runtime_info_symbol = "None"
+        builtin_py_cc_link_params_provider = "None"
+    else:
+        builtin_py_info_symbol = "PyInfo"
+        builtin_py_runtime_info_symbol = "PyRuntimeInfo"
+        builtin_py_cc_link_params_provider = "PyCcLinkParamsProvider"
+
     rctx.file("rules_python_config.bzl", _CONFIG_TEMPLATE.format(
         enable_pystar = enable_pystar,
+        builtin_py_info_symbol = builtin_py_info_symbol,
+        builtin_py_runtime_info_symbol = builtin_py_runtime_info_symbol,
+        builtin_py_cc_link_params_provider = builtin_py_cc_link_params_provider,
     ))
 
     if enable_pystar:

python/private/py_info.bzl

@@ -118,7 +118,7 @@ This field is currently unused in Bazel and may go away in the future.
 )
 
 # The "effective" PyInfo is what the canonical //python:py_info.bzl%PyInfo symbol refers to
-_EffectivePyInfo = PyInfo if config.enable_pystar else BuiltinPyInfo
+_EffectivePyInfo = PyInfo if (config.enable_pystar or BuiltinPyInfo == None) else BuiltinPyInfo
 
 def PyInfoBuilder():
     # buildifier: disable=uninitialized
@@ -206,7 +206,7 @@ def _PyInfoBuilder_merge_all(self, transitive, *, direct = []):
 def _PyInfoBuilder_merge_target(self, target):
     if PyInfo in target:
         self.merge(target[PyInfo])
-    elif BuiltinPyInfo in target:
+    elif BuiltinPyInfo != None and BuiltinPyInfo in target:
         self.merge(target[BuiltinPyInfo])
     return self
 
@@ -234,6 +234,9 @@ def _PyInfoBuilder_build(self):
     )
 
 def _PyInfoBuilder_build_builtin_py_info(self):
+    if BuiltinPyInfo == None:
+        return None
+
     return BuiltinPyInfo(
         has_py2_only_sources = self._has_py2_only_sources[0],
         has_py3_only_sources = self._has_py3_only_sources[0],

python/private/py_runtime_pair_rule.bzl

@@ -56,7 +56,7 @@ def _get_py_runtime_info(target):
     # py_binary (implemented in Java) performs a type check on the provider
     # value to verify it is an instance of the Java-implemented PyRuntimeInfo
     # class.
-    if IS_BAZEL_7_OR_HIGHER and PyRuntimeInfo in target:
+    if (IS_BAZEL_7_OR_HIGHER and PyRuntimeInfo in target) or BuiltinPyRuntimeInfo == None:
         return target[PyRuntimeInfo]
     else:
         return target[BuiltinPyRuntimeInfo]
@@ -70,21 +70,23 @@ def _is_py2_disabled(ctx):
         return False
     return ctx.fragments.py.disable_py2
 
+_MaybeBuiltinPyRuntimeInfo = [[BuiltinPyRuntimeInfo]] if BuiltinPyRuntimeInfo != None else []
+
 py_runtime_pair = rule(
     implementation = _py_runtime_pair_impl,
     attrs = {
         # The two runtimes are used by the py_binary at runtime, and so need to
         # be built for the target platform.
         "py2_runtime": attr.label(
-            providers = [[PyRuntimeInfo], [BuiltinPyRuntimeInfo]],
+            providers = [[PyRuntimeInfo]] + _MaybeBuiltinPyRuntimeInfo,
             cfg = "target",
             doc = """\
 The runtime to use for Python 2 targets. Must have `python_version` set to
 `PY2`.
 """,
         ),
         "py3_runtime": attr.label(
-            providers = [[PyRuntimeInfo], [BuiltinPyRuntimeInfo]],
+            providers = [[PyRuntimeInfo]] + _MaybeBuiltinPyRuntimeInfo,
             cfg = "target",
             doc = """\
 The runtime to use for Python 3 targets. Must have `python_version` set to