22740642519

Committed 05 Mar 2026 11:00PM UTC coverage: 52.677% (-40.3%) from 92.931%

Build # 22740642519

Build Type

Pull #23157

github

Committed by

web-flow

Commit Message

Merge 2aa18e6d4 into f0030f5e7

Pull Request Pull Request #23157: [pants ng] Partition source files by config.

Run Details

31678 of 60136 relevant lines covered (52.68%)

0.53 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

61.82

/src/python/pants/backend/go/util_rules/binary.py

# Copyright 2022 Pants project contributors (see CONTRIBUTORS.md).
# Licensed under the Apache License, Version 2.0 (see LICENSE).
from __future__ import annotations

from dataclasses import dataclass

from pants.backend.go.target_types import (
    GoBinaryDependenciesField,
    GoBinaryMainPackageField,
    GoImportPathField,
    GoPackageSourcesField,
)
from pants.base.specs import DirGlobSpec, RawSpecs
from pants.build_graph.address import Address, AddressInput, ResolveError
from pants.engine.engine_aware import EngineAwareParameter
from pants.engine.internals.build_files import resolve_address
from pants.engine.internals.graph import resolve_target, resolve_targets
from pants.engine.rules import collect_rules, implicitly, rule
from pants.engine.target import (
    FieldSet,
    InferDependenciesRequest,
    InferredDependencies,
    InvalidFieldException,
    WrappedTargetRequest,
)
from pants.engine.unions import UnionRule
from pants.util.logging import LogLevel


@dataclass(frozen=True)
class GoBinaryMainPackage:
    address: Address

    is_third_party: bool
    import_path: str | None = None


@dataclass(frozen=True)
class GoBinaryMainPackageRequest(EngineAwareParameter):
    field: GoBinaryMainPackageField

    def debug_hint(self) -> str:
        return self.field.address.spec


@rule(desc="Determine first-party package used by `go_binary` target", level=LogLevel.DEBUG)
async def determine_main_pkg_for_go_binary(
    request: GoBinaryMainPackageRequest,
) -> GoBinaryMainPackage:
    addr = request.field.address
    if request.field.value:
        description_of_origin = (
            f"the `{request.field.alias}` field from the target {request.field.address}"
        )
        address_input = AddressInput.parse(
            request.field.value,
            relative_to=addr.spec_path,
            description_of_origin=description_of_origin,
        )
        specified_address = await resolve_address(**implicitly({address_input: AddressInput}))
        wrapped_specified_tgt = await resolve_target(
            WrappedTargetRequest(specified_address, description_of_origin=description_of_origin),
            **implicitly(),
        )
        if not wrapped_specified_tgt.target.has_field(
            GoPackageSourcesField
        ) and not wrapped_specified_tgt.target.has_field(GoImportPathField):
            raise InvalidFieldException(
                f"The {repr(GoBinaryMainPackageField.alias)} field in target {addr} must point to "
                "a `go_package` or `go_third_party_package` target, but was the address for a "
                f"`{wrapped_specified_tgt.target.alias}` target.\n\n"
                "Hint: unless the package is a `go_third_party_package` target, you should normally "
                "not specify this field for local packages so that Pants will find the `go_package` "
                "target for you."
            )

        if not wrapped_specified_tgt.target.has_field(GoPackageSourcesField):
            return GoBinaryMainPackage(
                wrapped_specified_tgt.target.address,
                is_third_party=True,
                import_path=wrapped_specified_tgt.target.get(GoImportPathField).value,
            )
        return GoBinaryMainPackage(wrapped_specified_tgt.target.address, is_third_party=False)

    candidate_targets = await resolve_targets(
        **implicitly(
            RawSpecs(
                dir_globs=(DirGlobSpec(addr.spec_path),),
                description_of_origin="the `go_binary` dependency inference rule",
            )
        )
    )
    relevant_pkg_targets = [
        tgt
        for tgt in candidate_targets
        if tgt.has_field(GoPackageSourcesField) and tgt.residence_dir == addr.spec_path
    ]
    if len(relevant_pkg_targets) == 1:
        return GoBinaryMainPackage(relevant_pkg_targets[0].address, is_third_party=False)

    if not relevant_pkg_targets:
        raise ResolveError(
            f"The target {addr} requires that there is a `go_package` "
            f"target defined in its directory {addr.spec_path}, but none were found.\n\n"
            "To fix, add a target like `go_package()` or `go_package(name='pkg')` to the BUILD "
            f"file in {addr.spec_path}."
        )
    raise ResolveError(
        f"There are multiple `go_package` targets for the same directory of the "
        f"target {addr}: {addr.spec_path}. It is ambiguous what to use as the `main` "
        "package.\n\n"
        f"To fix, please either set the `main` field for `{addr} or remove these "
        "`go_package` targets so that only one remains: "
        f"{sorted(tgt.address.spec for tgt in relevant_pkg_targets)}"
    )


@dataclass(frozen=True)
class GoBinaryMainDependencyInferenceFieldSet(FieldSet):
    required_fields = (GoBinaryDependenciesField, GoBinaryMainPackageField)

    dependencies: GoBinaryDependenciesField
    main_package: GoBinaryMainPackageField


class InferGoBinaryMainDependencyRequest(InferDependenciesRequest):
    infer_from = GoBinaryMainDependencyInferenceFieldSet


@rule
async def infer_go_binary_main_dependency(
    request: InferGoBinaryMainDependencyRequest,
) -> InferredDependencies:
    main_pkg = await determine_main_pkg_for_go_binary(
        GoBinaryMainPackageRequest(request.field_set.main_package)
    )
    return InferredDependencies([main_pkg.address])


def rules():
    return (
        *collect_rules(),
        UnionRule(InferDependenciesRequest, InferGoBinaryMainDependencyRequest),
    )

1	# Copyright 2022 Pants project contributors (see CONTRIBUTORS.md).
2	# Licensed under the Apache License, Version 2.0 (see LICENSE).
3	from __future__ import annotations	1✔
4
5	from dataclasses import dataclass	1✔
6
7	from pants.backend.go.target_types import (	1✔
8	GoBinaryDependenciesField,
9	GoBinaryMainPackageField,
10	GoImportPathField,
11	GoPackageSourcesField,
12	)
13	from pants.base.specs import DirGlobSpec, RawSpecs	1✔
14	from pants.build_graph.address import Address, AddressInput, ResolveError	1✔
15	from pants.engine.engine_aware import EngineAwareParameter	1✔
16	from pants.engine.internals.build_files import resolve_address	1✔
17	from pants.engine.internals.graph import resolve_target, resolve_targets	1✔
18	from pants.engine.rules import collect_rules, implicitly, rule	1✔
19	from pants.engine.target import (	1✔
20	FieldSet,
21	InferDependenciesRequest,
22	InferredDependencies,
23	InvalidFieldException,
24	WrappedTargetRequest,
25	)
26	from pants.engine.unions import UnionRule	1✔
27	from pants.util.logging import LogLevel	1✔
28
29
30	@dataclass(frozen=True)	1✔
31	class GoBinaryMainPackage:	1✔
32	address: Address	1✔
33
34	is_third_party: bool	1✔
35	import_path: str \| None = None	1✔
36
37
38	@dataclass(frozen=True)	1✔
39	class GoBinaryMainPackageRequest(EngineAwareParameter):	1✔
40	field: GoBinaryMainPackageField	1✔
41
42	def debug_hint(self) -> str:	1✔
43	return self.field.address.spec	×
44
45
46	@rule(desc="Determine first-party package used by `go_binary` target", level=LogLevel.DEBUG)	1✔
47	async def determine_main_pkg_for_go_binary(	1✔
48	request: GoBinaryMainPackageRequest,
49	) -> GoBinaryMainPackage:
50	addr = request.field.address	×
51	if request.field.value:	×
52	description_of_origin = (	×
53	f"the `{request.field.alias}` field from the target {request.field.address}"
54	)
55	address_input = AddressInput.parse(	×
56	request.field.value,
57	relative_to=addr.spec_path,
58	description_of_origin=description_of_origin,
59	)
60	specified_address = await resolve_address(**implicitly({address_input: AddressInput}))	×
61	wrapped_specified_tgt = await resolve_target(	×
62	WrappedTargetRequest(specified_address, description_of_origin=description_of_origin),
63	**implicitly(),
64	)
65	if not wrapped_specified_tgt.target.has_field(	×
66	GoPackageSourcesField
67	) and not wrapped_specified_tgt.target.has_field(GoImportPathField):
68	raise InvalidFieldException(	×
69	f"The {repr(GoBinaryMainPackageField.alias)} field in target {addr} must point to "
70	"a `go_package` or `go_third_party_package` target, but was the address for a "
71	f"`{wrapped_specified_tgt.target.alias}` target.\n\n"
72	"Hint: unless the package is a `go_third_party_package` target, you should normally "
73	"not specify this field for local packages so that Pants will find the `go_package` "
74	"target for you."
75	)
76
77	if not wrapped_specified_tgt.target.has_field(GoPackageSourcesField):	×
78	return GoBinaryMainPackage(	×
79	wrapped_specified_tgt.target.address,
80	is_third_party=True,
81	import_path=wrapped_specified_tgt.target.get(GoImportPathField).value,
82	)
83	return GoBinaryMainPackage(wrapped_specified_tgt.target.address, is_third_party=False)	×
84
85	candidate_targets = await resolve_targets(	×
86	**implicitly(
87	RawSpecs(
88	dir_globs=(DirGlobSpec(addr.spec_path),),
89	description_of_origin="the `go_binary` dependency inference rule",
90	)
91	)
92	)
93	relevant_pkg_targets = [	×
94	tgt
95	for tgt in candidate_targets
96	if tgt.has_field(GoPackageSourcesField) and tgt.residence_dir == addr.spec_path
97	]
98	if len(relevant_pkg_targets) == 1:	×
99	return GoBinaryMainPackage(relevant_pkg_targets[0].address, is_third_party=False)	×
100
101	if not relevant_pkg_targets:	×
102	raise ResolveError(	×
103	f"The target {addr} requires that there is a `go_package` "
104	f"target defined in its directory {addr.spec_path}, but none were found.\n\n"
105	"To fix, add a target like `go_package()` or `go_package(name='pkg')` to the BUILD "
106	f"file in {addr.spec_path}."
107	)
108	raise ResolveError(	×
109	f"There are multiple `go_package` targets for the same directory of the "
110	f"target {addr}: {addr.spec_path}. It is ambiguous what to use as the `main` "
111	"package.\n\n"
112	f"To fix, please either set the `main` field for `{addr} or remove these "
113	"`go_package` targets so that only one remains: "
114	f"{sorted(tgt.address.spec for tgt in relevant_pkg_targets)}"
115	)
116
117
118	@dataclass(frozen=True)	1✔
119	class GoBinaryMainDependencyInferenceFieldSet(FieldSet):	1✔
120	required_fields = (GoBinaryDependenciesField, GoBinaryMainPackageField)	1✔
121
122	dependencies: GoBinaryDependenciesField	1✔
123	main_package: GoBinaryMainPackageField	1✔
124
125
126	class InferGoBinaryMainDependencyRequest(InferDependenciesRequest):	1✔
127	infer_from = GoBinaryMainDependencyInferenceFieldSet	1✔
128
129
130	@rule	1✔
131	async def infer_go_binary_main_dependency(	1✔
132	request: InferGoBinaryMainDependencyRequest,
133	) -> InferredDependencies:
134	main_pkg = await determine_main_pkg_for_go_binary(	×
135	GoBinaryMainPackageRequest(request.field_set.main_package)
136	)
137	return InferredDependencies([main_pkg.address])	×
138
139
140	def rules():	1✔
141	return (	1✔
142	*collect_rules(),
143	UnionRule(InferDependenciesRequest, InferGoBinaryMainDependencyRequest),
144	)

pantsbuild / pants / 22740642519

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous