18252174847

Committed 05 Oct 2025 01:36AM UTC coverage: 43.382% (-36.9%) from 80.261%

Build # 18252174847

Build Type

push

github

Committed by

web-flow

Commit Message

run tests on mac arm (#22717)

Just doing the minimal to pull forward the x86_64 pattern.

ref #20993

Run Details

25776 of 59416 relevant lines covered (43.38%)

1.3 hits per line

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

0.0

/src/python/pants/backend/go/goals/package_binary.py

# Copyright 2021 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 pathlib import PurePath

from pants.backend.go.target_types import (
    GoBinaryMainPackageField,
    GoBinaryTarget,
    GoPackageTarget,
    GoThirdPartyPackageTarget,
)
from pants.backend.go.util_rules.binary import (
    GoBinaryMainPackageRequest,
    determine_main_pkg_for_go_binary,
)
from pants.backend.go.util_rules.build_opts import (
    GoBuildOptionsFromTargetRequest,
    go_extract_build_options_from_target,
)
from pants.backend.go.util_rules.build_pkg import required_built_go_package
from pants.backend.go.util_rules.build_pkg_target import BuildGoPackageTargetRequest
from pants.backend.go.util_rules.first_party_pkg import (
    FirstPartyPkgAnalysisRequest,
    analyze_first_party_package,
)
from pants.backend.go.util_rules.go_mod import GoModInfoRequest, determine_go_mod_info
from pants.backend.go.util_rules.link import LinkGoBinaryRequest, link_go_binary
from pants.backend.go.util_rules.third_party_pkg import (
    ThirdPartyPkgAnalysisRequest,
    extract_package_info,
)
from pants.core.environments.target_types import EnvironmentField
from pants.core.goals.package import (
    BuiltPackage,
    BuiltPackageArtifact,
    OutputPathField,
    PackageFieldSet,
)
from pants.core.goals.run import RunFieldSet, RunInSandboxBehavior
from pants.engine.fs import AddPrefix
from pants.engine.internals.selectors import concurrently
from pants.engine.intrinsics import add_prefix
from pants.engine.rules import collect_rules, implicitly, rule
from pants.engine.unions import UnionRule
from pants.util.frozendict import FrozenDict
from pants.util.logging import LogLevel


@dataclass(frozen=True)
class GoBinaryFieldSet(PackageFieldSet, RunFieldSet):
    required_fields = (GoBinaryMainPackageField,)
    run_in_sandbox_behavior = RunInSandboxBehavior.RUN_REQUEST_HERMETIC

    main: GoBinaryMainPackageField
    output_path: OutputPathField
    environment: EnvironmentField


@rule(desc="Package Go binary", level=LogLevel.DEBUG)
async def package_go_binary(field_set: GoBinaryFieldSet) -> BuiltPackage:
    main_pkg, build_opts = await concurrently(
        determine_main_pkg_for_go_binary(GoBinaryMainPackageRequest(field_set.main)),
        go_extract_build_options_from_target(
            GoBuildOptionsFromTargetRequest(field_set.address), **implicitly()
        ),
    )

    if main_pkg.is_third_party:
        assert isinstance(main_pkg.import_path, str)

        go_mod_address = main_pkg.address.maybe_convert_to_target_generator()
        go_mod_info = await determine_go_mod_info(GoModInfoRequest(go_mod_address))

        analysis = await extract_package_info(
            ThirdPartyPkgAnalysisRequest(
                main_pkg.import_path,
                go_mod_address,
                go_mod_info.digest,
                go_mod_info.mod_path,
                build_opts=build_opts,
            )
        )

        package_name = analysis.name
    else:
        main_pkg_analysis = await analyze_first_party_package(
            FirstPartyPkgAnalysisRequest(main_pkg.address, build_opts=build_opts), **implicitly()
        )
        if not main_pkg_analysis.analysis:
            raise ValueError(
                f"Unable to analyze main package `{main_pkg.address}` for go_binary target {field_set.address}: {main_pkg_analysis.stderr}"
            )

        package_name = main_pkg_analysis.analysis.name

    if package_name != "main":
        raise ValueError(
            f"{GoThirdPartyPackageTarget.alias if main_pkg.is_third_party else GoPackageTarget.alias} "
            f"target `{main_pkg.address}` is used as the main package for {GoBinaryTarget.alias} target "
            f"`{field_set.address}` but uses package name `{package_name}` instead of `main`. Go "
            "requires that main packages actually use `main` as the package name."
        )

    built_package = await required_built_go_package(
        **implicitly(
            BuildGoPackageTargetRequest(main_pkg.address, is_main=True, build_opts=build_opts)
        ),
    )

    main_pkg_a_file_path = built_package.import_paths_to_pkg_a_files["main"]

    output_filename = PurePath(field_set.output_path.value_or_default(file_ending=None))
    binary = await link_go_binary(
        LinkGoBinaryRequest(
            input_digest=built_package.digest,
            archives=(main_pkg_a_file_path,),
            build_opts=build_opts,
            import_paths_to_pkg_a_files=FrozenDict(built_package.import_paths_to_pkg_a_files),
            output_filename=f"./{output_filename.name}",
            description=f"Link Go binary for {field_set.address}",
        ),
        **implicitly(),
    )

    renamed_output_digest = await add_prefix(AddPrefix(binary.digest, str(output_filename.parent)))

    artifact = BuiltPackageArtifact(relpath=str(output_filename))
    return BuiltPackage(renamed_output_digest, (artifact,))


def rules():
    return [*collect_rules(), UnionRule(PackageFieldSet, GoBinaryFieldSet)]

1	# Copyright 2021 Pants project contributors (see CONTRIBUTORS.md).
2	# Licensed under the Apache License, Version 2.0 (see LICENSE).
3
4	from __future__ import annotations	×
5
6	from dataclasses import dataclass	×
7	from pathlib import PurePath	×
8
9	from pants.backend.go.target_types import (	×
10	GoBinaryMainPackageField,
11	GoBinaryTarget,
12	GoPackageTarget,
13	GoThirdPartyPackageTarget,
14	)
15	from pants.backend.go.util_rules.binary import (	×
16	GoBinaryMainPackageRequest,
17	determine_main_pkg_for_go_binary,
18	)
19	from pants.backend.go.util_rules.build_opts import (	×
20	GoBuildOptionsFromTargetRequest,
21	go_extract_build_options_from_target,
22	)
23	from pants.backend.go.util_rules.build_pkg import required_built_go_package	×
24	from pants.backend.go.util_rules.build_pkg_target import BuildGoPackageTargetRequest	×
25	from pants.backend.go.util_rules.first_party_pkg import (	×
26	FirstPartyPkgAnalysisRequest,
27	analyze_first_party_package,
28	)
29	from pants.backend.go.util_rules.go_mod import GoModInfoRequest, determine_go_mod_info	×
30	from pants.backend.go.util_rules.link import LinkGoBinaryRequest, link_go_binary	×
31	from pants.backend.go.util_rules.third_party_pkg import (	×
32	ThirdPartyPkgAnalysisRequest,
33	extract_package_info,
34	)
35	from pants.core.environments.target_types import EnvironmentField	×
36	from pants.core.goals.package import (	×
37	BuiltPackage,
38	BuiltPackageArtifact,
39	OutputPathField,
40	PackageFieldSet,
41	)
42	from pants.core.goals.run import RunFieldSet, RunInSandboxBehavior	×
43	from pants.engine.fs import AddPrefix	×
44	from pants.engine.internals.selectors import concurrently	×
45	from pants.engine.intrinsics import add_prefix	×
46	from pants.engine.rules import collect_rules, implicitly, rule	×
47	from pants.engine.unions import UnionRule	×
48	from pants.util.frozendict import FrozenDict	×
49	from pants.util.logging import LogLevel	×
50
51
52	@dataclass(frozen=True)	×
53	class GoBinaryFieldSet(PackageFieldSet, RunFieldSet):	×
54	required_fields = (GoBinaryMainPackageField,)	×
55	run_in_sandbox_behavior = RunInSandboxBehavior.RUN_REQUEST_HERMETIC	×
56
57	main: GoBinaryMainPackageField	×
58	output_path: OutputPathField	×
59	environment: EnvironmentField	×
60
61
62	@rule(desc="Package Go binary", level=LogLevel.DEBUG)	×
63	async def package_go_binary(field_set: GoBinaryFieldSet) -> BuiltPackage:	×
64	main_pkg, build_opts = await concurrently(	×
65	determine_main_pkg_for_go_binary(GoBinaryMainPackageRequest(field_set.main)),
66	go_extract_build_options_from_target(
67	GoBuildOptionsFromTargetRequest(field_set.address), **implicitly()
68	),
69	)
70
71	if main_pkg.is_third_party:	×
72	assert isinstance(main_pkg.import_path, str)	×
73
74	go_mod_address = main_pkg.address.maybe_convert_to_target_generator()	×
75	go_mod_info = await determine_go_mod_info(GoModInfoRequest(go_mod_address))	×
76
77	analysis = await extract_package_info(	×
78	ThirdPartyPkgAnalysisRequest(
79	main_pkg.import_path,
80	go_mod_address,
81	go_mod_info.digest,
82	go_mod_info.mod_path,
83	build_opts=build_opts,
84	)
85	)
86
87	package_name = analysis.name	×
88	else:
89	main_pkg_analysis = await analyze_first_party_package(	×
90	FirstPartyPkgAnalysisRequest(main_pkg.address, build_opts=build_opts), **implicitly()
91	)
92	if not main_pkg_analysis.analysis:	×
93	raise ValueError(	×
94	f"Unable to analyze main package `{main_pkg.address}` for go_binary target {field_set.address}: {main_pkg_analysis.stderr}"
95	)
96
97	package_name = main_pkg_analysis.analysis.name	×
98
99	if package_name != "main":	×
100	raise ValueError(	×
101	f"{GoThirdPartyPackageTarget.alias if main_pkg.is_third_party else GoPackageTarget.alias} "
102	f"target `{main_pkg.address}` is used as the main package for {GoBinaryTarget.alias} target "
103	f"`{field_set.address}` but uses package name `{package_name}` instead of `main`. Go "
104	"requires that main packages actually use `main` as the package name."
105	)
106
107	built_package = await required_built_go_package(	×
108	**implicitly(
109	BuildGoPackageTargetRequest(main_pkg.address, is_main=True, build_opts=build_opts)
110	),
111	)
112
113	main_pkg_a_file_path = built_package.import_paths_to_pkg_a_files["main"]	×
114
115	output_filename = PurePath(field_set.output_path.value_or_default(file_ending=None))	×
116	binary = await link_go_binary(	×
117	LinkGoBinaryRequest(
118	input_digest=built_package.digest,
119	archives=(main_pkg_a_file_path,),
120	build_opts=build_opts,
121	import_paths_to_pkg_a_files=FrozenDict(built_package.import_paths_to_pkg_a_files),
122	output_filename=f"./{output_filename.name}",
123	description=f"Link Go binary for {field_set.address}",
124	),
125	**implicitly(),
126	)
127
128	renamed_output_digest = await add_prefix(AddPrefix(binary.digest, str(output_filename.parent)))	×
129
130	artifact = BuiltPackageArtifact(relpath=str(output_filename))	×
131	return BuiltPackage(renamed_output_digest, (artifact,))	×
132
133
134	def rules():	×
135	return [*collect_rules(), UnionRule(PackageFieldSet, GoBinaryFieldSet)]	×

pantsbuild / pants / 18252174847

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